1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * Intel HID event & 5 button array driver 4 * 5 * Copyright (C) 2015 Alex Hung <alex.hung@canonical.com> 6 * Copyright (C) 2015 Andrew Lutomirski <luto@kernel.org> 7 */ 8 9 #include <linux/acpi.h> 10 #include <linux/dmi.h> 11 #include <linux/input.h> 12 #include <linux/input/sparse-keymap.h> 13 #include <linux/kernel.h> 14 #include <linux/module.h> 15 #include <linux/platform_device.h> 16 #include <linux/suspend.h> 17 #include "../dual_accel_detect.h" 18 19 /* When NOT in tablet mode, VGBS returns with the flag 0x40 */ 20 #define TABLET_MODE_FLAG BIT(6) 21 22 MODULE_LICENSE("GPL"); 23 MODULE_AUTHOR("Alex Hung"); 24 25 static const struct acpi_device_id intel_hid_ids[] = { 26 {"INT33D5", 0}, 27 {"INTC1051", 0}, 28 {"INTC1054", 0}, 29 {"INTC1070", 0}, 30 {"", 0}, 31 }; 32 MODULE_DEVICE_TABLE(acpi, intel_hid_ids); 33 34 /* In theory, these are HID usages. */ 35 static const struct key_entry intel_hid_keymap[] = { 36 /* 1: LSuper (Page 0x07, usage 0xE3) -- unclear what to do */ 37 /* 2: Toggle SW_ROTATE_LOCK -- easy to implement if seen in wild */ 38 { KE_KEY, 3, { KEY_NUMLOCK } }, 39 { KE_KEY, 4, { KEY_HOME } }, 40 { KE_KEY, 5, { KEY_END } }, 41 { KE_KEY, 6, { KEY_PAGEUP } }, 42 { KE_KEY, 7, { KEY_PAGEDOWN } }, 43 { KE_KEY, 8, { KEY_RFKILL } }, 44 { KE_KEY, 9, { KEY_POWER } }, 45 { KE_KEY, 11, { KEY_SLEEP } }, 46 /* 13 has two different meanings in the spec -- ignore it. */ 47 { KE_KEY, 14, { KEY_STOPCD } }, 48 { KE_KEY, 15, { KEY_PLAYPAUSE } }, 49 { KE_KEY, 16, { KEY_MUTE } }, 50 { KE_KEY, 17, { KEY_VOLUMEUP } }, 51 { KE_KEY, 18, { KEY_VOLUMEDOWN } }, 52 { KE_KEY, 19, { KEY_BRIGHTNESSUP } }, 53 { KE_KEY, 20, { KEY_BRIGHTNESSDOWN } }, 54 /* 27: wake -- needs special handling */ 55 { KE_END }, 56 }; 57 58 /* 5 button array notification value. */ 59 static const struct key_entry intel_array_keymap[] = { 60 { KE_KEY, 0xC2, { KEY_LEFTMETA } }, /* Press */ 61 { KE_IGNORE, 0xC3, { KEY_LEFTMETA } }, /* Release */ 62 { KE_KEY, 0xC4, { KEY_VOLUMEUP } }, /* Press */ 63 { KE_IGNORE, 0xC5, { KEY_VOLUMEUP } }, /* Release */ 64 { KE_KEY, 0xC6, { KEY_VOLUMEDOWN } }, /* Press */ 65 { KE_IGNORE, 0xC7, { KEY_VOLUMEDOWN } }, /* Release */ 66 { KE_KEY, 0xC8, { KEY_ROTATE_LOCK_TOGGLE } }, /* Press */ 67 { KE_IGNORE, 0xC9, { KEY_ROTATE_LOCK_TOGGLE } }, /* Release */ 68 { KE_KEY, 0xCE, { KEY_POWER } }, /* Press */ 69 { KE_IGNORE, 0xCF, { KEY_POWER } }, /* Release */ 70 { KE_END }, 71 }; 72 73 static const struct dmi_system_id button_array_table[] = { 74 { 75 .ident = "Wacom MobileStudio Pro 13", 76 .matches = { 77 DMI_MATCH(DMI_SYS_VENDOR, "Wacom Co.,Ltd"), 78 DMI_MATCH(DMI_PRODUCT_NAME, "Wacom MobileStudio Pro 13"), 79 }, 80 }, 81 { 82 .ident = "Wacom MobileStudio Pro 16", 83 .matches = { 84 DMI_MATCH(DMI_SYS_VENDOR, "Wacom Co.,Ltd"), 85 DMI_MATCH(DMI_PRODUCT_NAME, "Wacom MobileStudio Pro 16"), 86 }, 87 }, 88 { 89 .ident = "HP Spectre x2 (2015)", 90 .matches = { 91 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 92 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x2 Detachable"), 93 }, 94 }, 95 { 96 .ident = "Lenovo ThinkPad X1 Tablet Gen 2", 97 .matches = { 98 DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"), 99 DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"), 100 }, 101 }, 102 { } 103 }; 104 105 /* 106 * Some convertible use the intel-hid ACPI interface to report SW_TABLET_MODE, 107 * these need to be compared via a DMI based authorization list because some 108 * models have unreliable VGBS return which could cause incorrect 109 * SW_TABLET_MODE report. 110 */ 111 static const struct dmi_system_id dmi_vgbs_allow_list[] = { 112 { 113 .matches = { 114 DMI_MATCH(DMI_SYS_VENDOR, "HP"), 115 DMI_MATCH(DMI_PRODUCT_NAME, "HP Spectre x360 Convertible 15-df0xxx"), 116 }, 117 }, 118 { } 119 }; 120 121 struct intel_hid_priv { 122 struct input_dev *input_dev; 123 struct input_dev *array; 124 struct input_dev *switches; 125 bool wakeup_mode; 126 bool dual_accel; 127 }; 128 129 #define HID_EVENT_FILTER_UUID "eeec56b3-4442-408f-a792-4edd4d758054" 130 131 enum intel_hid_dsm_fn_codes { 132 INTEL_HID_DSM_FN_INVALID, 133 INTEL_HID_DSM_BTNL_FN, 134 INTEL_HID_DSM_HDMM_FN, 135 INTEL_HID_DSM_HDSM_FN, 136 INTEL_HID_DSM_HDEM_FN, 137 INTEL_HID_DSM_BTNS_FN, 138 INTEL_HID_DSM_BTNE_FN, 139 INTEL_HID_DSM_HEBC_V1_FN, 140 INTEL_HID_DSM_VGBS_FN, 141 INTEL_HID_DSM_HEBC_V2_FN, 142 INTEL_HID_DSM_FN_MAX 143 }; 144 145 static const char *intel_hid_dsm_fn_to_method[INTEL_HID_DSM_FN_MAX] = { 146 NULL, 147 "BTNL", 148 "HDMM", 149 "HDSM", 150 "HDEM", 151 "BTNS", 152 "BTNE", 153 "HEBC", 154 "VGBS", 155 "HEBC" 156 }; 157 158 static unsigned long long intel_hid_dsm_fn_mask; 159 static guid_t intel_dsm_guid; 160 161 static bool intel_hid_execute_method(acpi_handle handle, 162 enum intel_hid_dsm_fn_codes fn_index, 163 unsigned long long arg) 164 { 165 union acpi_object *obj, argv4, req; 166 acpi_status status; 167 char *method_name; 168 169 if (fn_index <= INTEL_HID_DSM_FN_INVALID || 170 fn_index >= INTEL_HID_DSM_FN_MAX) 171 return false; 172 173 method_name = (char *)intel_hid_dsm_fn_to_method[fn_index]; 174 175 if (!(intel_hid_dsm_fn_mask & BIT(fn_index))) 176 goto skip_dsm_exec; 177 178 /* All methods expects a package with one integer element */ 179 req.type = ACPI_TYPE_INTEGER; 180 req.integer.value = arg; 181 182 argv4.type = ACPI_TYPE_PACKAGE; 183 argv4.package.count = 1; 184 argv4.package.elements = &req; 185 186 obj = acpi_evaluate_dsm(handle, &intel_dsm_guid, 1, fn_index, &argv4); 187 if (obj) { 188 acpi_handle_debug(handle, "Exec DSM Fn code: %d[%s] success\n", 189 fn_index, method_name); 190 ACPI_FREE(obj); 191 return true; 192 } 193 194 skip_dsm_exec: 195 status = acpi_execute_simple_method(handle, method_name, arg); 196 if (ACPI_SUCCESS(status)) 197 return true; 198 199 return false; 200 } 201 202 static bool intel_hid_evaluate_method(acpi_handle handle, 203 enum intel_hid_dsm_fn_codes fn_index, 204 unsigned long long *result) 205 { 206 union acpi_object *obj; 207 acpi_status status; 208 char *method_name; 209 210 if (fn_index <= INTEL_HID_DSM_FN_INVALID || 211 fn_index >= INTEL_HID_DSM_FN_MAX) 212 return false; 213 214 method_name = (char *)intel_hid_dsm_fn_to_method[fn_index]; 215 216 if (!(intel_hid_dsm_fn_mask & fn_index)) 217 goto skip_dsm_eval; 218 219 obj = acpi_evaluate_dsm_typed(handle, &intel_dsm_guid, 220 1, fn_index, 221 NULL, ACPI_TYPE_INTEGER); 222 if (obj) { 223 *result = obj->integer.value; 224 acpi_handle_debug(handle, 225 "Eval DSM Fn code: %d[%s] results: 0x%llx\n", 226 fn_index, method_name, *result); 227 ACPI_FREE(obj); 228 return true; 229 } 230 231 skip_dsm_eval: 232 status = acpi_evaluate_integer(handle, method_name, NULL, result); 233 if (ACPI_SUCCESS(status)) 234 return true; 235 236 return false; 237 } 238 239 static void intel_hid_init_dsm(acpi_handle handle) 240 { 241 union acpi_object *obj; 242 243 guid_parse(HID_EVENT_FILTER_UUID, &intel_dsm_guid); 244 245 obj = acpi_evaluate_dsm_typed(handle, &intel_dsm_guid, 1, 0, NULL, 246 ACPI_TYPE_BUFFER); 247 if (obj) { 248 switch (obj->buffer.length) { 249 default: 250 case 2: 251 intel_hid_dsm_fn_mask = *(u16 *)obj->buffer.pointer; 252 break; 253 case 1: 254 intel_hid_dsm_fn_mask = *obj->buffer.pointer; 255 break; 256 case 0: 257 acpi_handle_warn(handle, "intel_hid_dsm_fn_mask length is zero\n"); 258 intel_hid_dsm_fn_mask = 0; 259 break; 260 } 261 ACPI_FREE(obj); 262 } 263 264 acpi_handle_debug(handle, "intel_hid_dsm_fn_mask = %llx\n", 265 intel_hid_dsm_fn_mask); 266 } 267 268 static int intel_hid_set_enable(struct device *device, bool enable) 269 { 270 acpi_handle handle = ACPI_HANDLE(device); 271 272 /* Enable|disable features - power button is always enabled */ 273 if (!intel_hid_execute_method(handle, INTEL_HID_DSM_HDSM_FN, 274 enable)) { 275 dev_warn(device, "failed to %sable hotkeys\n", 276 enable ? "en" : "dis"); 277 return -EIO; 278 } 279 280 return 0; 281 } 282 283 static void intel_button_array_enable(struct device *device, bool enable) 284 { 285 struct intel_hid_priv *priv = dev_get_drvdata(device); 286 acpi_handle handle = ACPI_HANDLE(device); 287 unsigned long long button_cap; 288 acpi_status status; 289 290 if (!priv->array) 291 return; 292 293 /* Query supported platform features */ 294 status = acpi_evaluate_integer(handle, "BTNC", NULL, &button_cap); 295 if (ACPI_FAILURE(status)) { 296 dev_warn(device, "failed to get button capability\n"); 297 return; 298 } 299 300 /* Enable|disable features - power button is always enabled */ 301 if (!intel_hid_execute_method(handle, INTEL_HID_DSM_BTNE_FN, 302 enable ? button_cap : 1)) 303 dev_warn(device, "failed to set button capability\n"); 304 } 305 306 static int intel_hid_pm_prepare(struct device *device) 307 { 308 if (device_may_wakeup(device)) { 309 struct intel_hid_priv *priv = dev_get_drvdata(device); 310 311 priv->wakeup_mode = true; 312 } 313 return 0; 314 } 315 316 static void intel_hid_pm_complete(struct device *device) 317 { 318 struct intel_hid_priv *priv = dev_get_drvdata(device); 319 320 priv->wakeup_mode = false; 321 } 322 323 static int intel_hid_pl_suspend_handler(struct device *device) 324 { 325 intel_button_array_enable(device, false); 326 327 if (!pm_suspend_no_platform()) 328 intel_hid_set_enable(device, false); 329 330 return 0; 331 } 332 333 static int intel_hid_pl_resume_handler(struct device *device) 334 { 335 intel_hid_pm_complete(device); 336 337 if (!pm_suspend_no_platform()) 338 intel_hid_set_enable(device, true); 339 340 intel_button_array_enable(device, true); 341 return 0; 342 } 343 344 static const struct dev_pm_ops intel_hid_pl_pm_ops = { 345 .prepare = intel_hid_pm_prepare, 346 .complete = intel_hid_pm_complete, 347 .freeze = intel_hid_pl_suspend_handler, 348 .thaw = intel_hid_pl_resume_handler, 349 .restore = intel_hid_pl_resume_handler, 350 .suspend = intel_hid_pl_suspend_handler, 351 .resume = intel_hid_pl_resume_handler, 352 }; 353 354 static int intel_hid_input_setup(struct platform_device *device) 355 { 356 struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); 357 int ret; 358 359 priv->input_dev = devm_input_allocate_device(&device->dev); 360 if (!priv->input_dev) 361 return -ENOMEM; 362 363 ret = sparse_keymap_setup(priv->input_dev, intel_hid_keymap, NULL); 364 if (ret) 365 return ret; 366 367 priv->input_dev->name = "Intel HID events"; 368 priv->input_dev->id.bustype = BUS_HOST; 369 370 return input_register_device(priv->input_dev); 371 } 372 373 static int intel_button_array_input_setup(struct platform_device *device) 374 { 375 struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); 376 int ret; 377 378 /* Setup input device for 5 button array */ 379 priv->array = devm_input_allocate_device(&device->dev); 380 if (!priv->array) 381 return -ENOMEM; 382 383 ret = sparse_keymap_setup(priv->array, intel_array_keymap, NULL); 384 if (ret) 385 return ret; 386 387 priv->array->name = "Intel HID 5 button array"; 388 priv->array->id.bustype = BUS_HOST; 389 390 return input_register_device(priv->array); 391 } 392 393 static int intel_hid_switches_setup(struct platform_device *device) 394 { 395 struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); 396 397 /* Setup input device for switches */ 398 priv->switches = devm_input_allocate_device(&device->dev); 399 if (!priv->switches) 400 return -ENOMEM; 401 402 __set_bit(EV_SW, priv->switches->evbit); 403 __set_bit(SW_TABLET_MODE, priv->switches->swbit); 404 405 priv->switches->name = "Intel HID switches"; 406 priv->switches->id.bustype = BUS_HOST; 407 return input_register_device(priv->switches); 408 } 409 410 static void report_tablet_mode_state(struct platform_device *device) 411 { 412 struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); 413 acpi_handle handle = ACPI_HANDLE(&device->dev); 414 unsigned long long vgbs; 415 int m; 416 417 if (!intel_hid_evaluate_method(handle, INTEL_HID_DSM_VGBS_FN, &vgbs)) 418 return; 419 420 m = !(vgbs & TABLET_MODE_FLAG); 421 input_report_switch(priv->switches, SW_TABLET_MODE, m); 422 input_sync(priv->switches); 423 } 424 425 static bool report_tablet_mode_event(struct input_dev *input_dev, u32 event) 426 { 427 if (!input_dev) 428 return false; 429 430 switch (event) { 431 case 0xcc: 432 input_report_switch(input_dev, SW_TABLET_MODE, 1); 433 input_sync(input_dev); 434 return true; 435 case 0xcd: 436 input_report_switch(input_dev, SW_TABLET_MODE, 0); 437 input_sync(input_dev); 438 return true; 439 default: 440 return false; 441 } 442 } 443 444 static void notify_handler(acpi_handle handle, u32 event, void *context) 445 { 446 struct platform_device *device = context; 447 struct intel_hid_priv *priv = dev_get_drvdata(&device->dev); 448 unsigned long long ev_index; 449 int err; 450 451 /* 452 * Some convertible have unreliable VGBS return which could cause incorrect 453 * SW_TABLET_MODE report, in these cases we enable support when receiving 454 * the first event instead of during driver setup. 455 * 456 * See dual_accel_detect.h for more info on the dual_accel check. 457 */ 458 if (!priv->switches && !priv->dual_accel && (event == 0xcc || event == 0xcd)) { 459 dev_info(&device->dev, "switch event received, enable switches supports\n"); 460 err = intel_hid_switches_setup(device); 461 if (err) 462 pr_err("Failed to setup Intel HID switches\n"); 463 } 464 465 if (priv->wakeup_mode) { 466 /* 467 * Needed for wakeup from suspend-to-idle to work on some 468 * platforms that don't expose the 5-button array, but still 469 * send notifies with the power button event code to this 470 * device object on power button actions while suspended. 471 */ 472 if (event == 0xce) 473 goto wakeup; 474 475 /* 476 * Some devices send (duplicate) tablet-mode events when moved 477 * around even though the mode has not changed; and they do this 478 * even when suspended. 479 * Update the switch state in case it changed and then return 480 * without waking up to avoid spurious wakeups. 481 */ 482 if (event == 0xcc || event == 0xcd) { 483 report_tablet_mode_event(priv->switches, event); 484 return; 485 } 486 487 /* Wake up on 5-button array events only. */ 488 if (event == 0xc0 || !priv->array) 489 return; 490 491 if (!sparse_keymap_entry_from_scancode(priv->array, event)) { 492 dev_info(&device->dev, "unknown event 0x%x\n", event); 493 return; 494 } 495 496 wakeup: 497 pm_wakeup_hard_event(&device->dev); 498 499 return; 500 } 501 502 /* 503 * Needed for suspend to work on some platforms that don't expose 504 * the 5-button array, but still send notifies with power button 505 * event code to this device object on power button actions. 506 * 507 * Report the power button press and release. 508 */ 509 if (!priv->array) { 510 if (event == 0xce) { 511 input_report_key(priv->input_dev, KEY_POWER, 1); 512 input_sync(priv->input_dev); 513 return; 514 } 515 516 if (event == 0xcf) { 517 input_report_key(priv->input_dev, KEY_POWER, 0); 518 input_sync(priv->input_dev); 519 return; 520 } 521 } 522 523 if (report_tablet_mode_event(priv->switches, event)) 524 return; 525 526 /* 0xC0 is for HID events, other values are for 5 button array */ 527 if (event != 0xc0) { 528 if (!priv->array || 529 !sparse_keymap_report_event(priv->array, event, 1, true)) 530 dev_dbg(&device->dev, "unknown event 0x%x\n", event); 531 return; 532 } 533 534 if (!intel_hid_evaluate_method(handle, INTEL_HID_DSM_HDEM_FN, 535 &ev_index)) { 536 dev_warn(&device->dev, "failed to get event index\n"); 537 return; 538 } 539 540 if (!sparse_keymap_report_event(priv->input_dev, ev_index, 1, true)) 541 dev_dbg(&device->dev, "unknown event index 0x%llx\n", 542 ev_index); 543 } 544 545 static bool button_array_present(struct platform_device *device) 546 { 547 acpi_handle handle = ACPI_HANDLE(&device->dev); 548 unsigned long long event_cap; 549 550 if (intel_hid_evaluate_method(handle, INTEL_HID_DSM_HEBC_V2_FN, 551 &event_cap)) { 552 /* Check presence of 5 button array or v2 power button */ 553 if (event_cap & 0x60000) 554 return true; 555 } 556 557 if (intel_hid_evaluate_method(handle, INTEL_HID_DSM_HEBC_V1_FN, 558 &event_cap)) { 559 if (event_cap & 0x20000) 560 return true; 561 } 562 563 if (dmi_check_system(button_array_table)) 564 return true; 565 566 return false; 567 } 568 569 static int intel_hid_probe(struct platform_device *device) 570 { 571 acpi_handle handle = ACPI_HANDLE(&device->dev); 572 unsigned long long mode; 573 struct intel_hid_priv *priv; 574 acpi_status status; 575 int err; 576 577 intel_hid_init_dsm(handle); 578 579 if (!intel_hid_evaluate_method(handle, INTEL_HID_DSM_HDMM_FN, &mode)) { 580 dev_warn(&device->dev, "failed to read mode\n"); 581 return -ENODEV; 582 } 583 584 if (mode != 0) { 585 /* 586 * This driver only implements "simple" mode. There appear 587 * to be no other modes, but we should be paranoid and check 588 * for compatibility. 589 */ 590 dev_info(&device->dev, "platform is not in simple mode\n"); 591 return -ENODEV; 592 } 593 594 priv = devm_kzalloc(&device->dev, sizeof(*priv), GFP_KERNEL); 595 if (!priv) 596 return -ENOMEM; 597 dev_set_drvdata(&device->dev, priv); 598 599 priv->dual_accel = dual_accel_detect(); 600 601 err = intel_hid_input_setup(device); 602 if (err) { 603 pr_err("Failed to setup Intel HID hotkeys\n"); 604 return err; 605 } 606 607 /* Setup 5 button array */ 608 if (button_array_present(device)) { 609 dev_info(&device->dev, "platform supports 5 button array\n"); 610 err = intel_button_array_input_setup(device); 611 if (err) 612 pr_err("Failed to setup Intel 5 button array hotkeys\n"); 613 } 614 615 /* Setup switches for devices that we know VGBS return correctly */ 616 if (dmi_check_system(dmi_vgbs_allow_list)) { 617 dev_info(&device->dev, "platform supports switches\n"); 618 err = intel_hid_switches_setup(device); 619 if (err) 620 pr_err("Failed to setup Intel HID switches\n"); 621 else 622 report_tablet_mode_state(device); 623 } 624 625 status = acpi_install_notify_handler(handle, 626 ACPI_DEVICE_NOTIFY, 627 notify_handler, 628 device); 629 if (ACPI_FAILURE(status)) 630 return -EBUSY; 631 632 err = intel_hid_set_enable(&device->dev, true); 633 if (err) 634 goto err_remove_notify; 635 636 if (priv->array) { 637 unsigned long long dummy; 638 639 intel_button_array_enable(&device->dev, true); 640 641 /* Call button load method to enable HID power button */ 642 if (!intel_hid_evaluate_method(handle, INTEL_HID_DSM_BTNL_FN, 643 &dummy)) { 644 dev_warn(&device->dev, 645 "failed to enable HID power button\n"); 646 } 647 } 648 649 device_init_wakeup(&device->dev, true); 650 /* 651 * In order for system wakeup to work, the EC GPE has to be marked as 652 * a wakeup one, so do that here (this setting will persist, but it has 653 * no effect until the wakeup mask is set for the EC GPE). 654 */ 655 acpi_ec_mark_gpe_for_wake(); 656 return 0; 657 658 err_remove_notify: 659 acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler); 660 661 return err; 662 } 663 664 static int intel_hid_remove(struct platform_device *device) 665 { 666 acpi_handle handle = ACPI_HANDLE(&device->dev); 667 668 device_init_wakeup(&device->dev, false); 669 acpi_remove_notify_handler(handle, ACPI_DEVICE_NOTIFY, notify_handler); 670 intel_hid_set_enable(&device->dev, false); 671 intel_button_array_enable(&device->dev, false); 672 673 /* 674 * Even if we failed to shut off the event stream, we can still 675 * safely detach from the device. 676 */ 677 return 0; 678 } 679 680 static struct platform_driver intel_hid_pl_driver = { 681 .driver = { 682 .name = "intel-hid", 683 .acpi_match_table = intel_hid_ids, 684 .pm = &intel_hid_pl_pm_ops, 685 }, 686 .probe = intel_hid_probe, 687 .remove = intel_hid_remove, 688 }; 689 690 /* 691 * Unfortunately, some laptops provide a _HID="INT33D5" device with 692 * _CID="PNP0C02". This causes the pnpacpi scan driver to claim the 693 * ACPI node, so no platform device will be created. The pnpacpi 694 * driver rejects this device in subsequent processing, so no physical 695 * node is created at all. 696 * 697 * As a workaround until the ACPI core figures out how to handle 698 * this corner case, manually ask the ACPI platform device code to 699 * claim the ACPI node. 700 */ 701 static acpi_status __init 702 check_acpi_dev(acpi_handle handle, u32 lvl, void *context, void **rv) 703 { 704 const struct acpi_device_id *ids = context; 705 struct acpi_device *dev; 706 707 if (acpi_bus_get_device(handle, &dev) != 0) 708 return AE_OK; 709 710 if (acpi_match_device_ids(dev, ids) == 0) 711 if (!IS_ERR_OR_NULL(acpi_create_platform_device(dev, NULL))) 712 dev_info(&dev->dev, 713 "intel-hid: created platform device\n"); 714 715 return AE_OK; 716 } 717 718 static int __init intel_hid_init(void) 719 { 720 acpi_walk_namespace(ACPI_TYPE_DEVICE, ACPI_ROOT_OBJECT, 721 ACPI_UINT32_MAX, check_acpi_dev, NULL, 722 (void *)intel_hid_ids, NULL); 723 724 return platform_driver_register(&intel_hid_pl_driver); 725 } 726 module_init(intel_hid_init); 727 728 static void __exit intel_hid_exit(void) 729 { 730 platform_driver_unregister(&intel_hid_pl_driver); 731 } 732 module_exit(intel_hid_exit); 733