1 // SPDX-License-Identifier: GPL-2.0+
3 * Intel HID event & 5 button array driver
5 * Copyright (C) 2015 Alex Hung <alex.hung@canonical.com>
6 * Copyright (C) 2015 Andrew Lutomirski <luto@kernel.org>
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>
18 MODULE_LICENSE("GPL");
19 MODULE_AUTHOR("Alex Hung");
21 static const struct acpi_device_id intel_hid_ids
[] = {
26 /* In theory, these are HID usages. */
27 static const struct key_entry intel_hid_keymap
[] = {
28 /* 1: LSuper (Page 0x07, usage 0xE3) -- unclear what to do */
29 /* 2: Toggle SW_ROTATE_LOCK -- easy to implement if seen in wild */
30 { KE_KEY
, 3, { KEY_NUMLOCK
} },
31 { KE_KEY
, 4, { KEY_HOME
} },
32 { KE_KEY
, 5, { KEY_END
} },
33 { KE_KEY
, 6, { KEY_PAGEUP
} },
34 { KE_KEY
, 7, { KEY_PAGEDOWN
} },
35 { KE_KEY
, 8, { KEY_RFKILL
} },
36 { KE_KEY
, 9, { KEY_POWER
} },
37 { KE_KEY
, 11, { KEY_SLEEP
} },
38 /* 13 has two different meanings in the spec -- ignore it. */
39 { KE_KEY
, 14, { KEY_STOPCD
} },
40 { KE_KEY
, 15, { KEY_PLAYPAUSE
} },
41 { KE_KEY
, 16, { KEY_MUTE
} },
42 { KE_KEY
, 17, { KEY_VOLUMEUP
} },
43 { KE_KEY
, 18, { KEY_VOLUMEDOWN
} },
44 { KE_KEY
, 19, { KEY_BRIGHTNESSUP
} },
45 { KE_KEY
, 20, { KEY_BRIGHTNESSDOWN
} },
46 /* 27: wake -- needs special handling */
50 /* 5 button array notification value. */
51 static const struct key_entry intel_array_keymap
[] = {
52 { KE_KEY
, 0xC2, { KEY_LEFTMETA
} }, /* Press */
53 { KE_IGNORE
, 0xC3, { KEY_LEFTMETA
} }, /* Release */
54 { KE_KEY
, 0xC4, { KEY_VOLUMEUP
} }, /* Press */
55 { KE_IGNORE
, 0xC5, { KEY_VOLUMEUP
} }, /* Release */
56 { KE_KEY
, 0xC6, { KEY_VOLUMEDOWN
} }, /* Press */
57 { KE_IGNORE
, 0xC7, { KEY_VOLUMEDOWN
} }, /* Release */
58 { KE_KEY
, 0xC8, { KEY_ROTATE_LOCK_TOGGLE
} }, /* Press */
59 { KE_IGNORE
, 0xC9, { KEY_ROTATE_LOCK_TOGGLE
} }, /* Release */
60 { KE_KEY
, 0xCE, { KEY_POWER
} }, /* Press */
61 { KE_IGNORE
, 0xCF, { KEY_POWER
} }, /* Release */
65 static const struct dmi_system_id button_array_table
[] = {
67 .ident
= "Wacom MobileStudio Pro 13",
69 DMI_MATCH(DMI_SYS_VENDOR
, "Wacom Co.,Ltd"),
70 DMI_MATCH(DMI_PRODUCT_NAME
, "Wacom MobileStudio Pro 13"),
74 .ident
= "Wacom MobileStudio Pro 16",
76 DMI_MATCH(DMI_SYS_VENDOR
, "Wacom Co.,Ltd"),
77 DMI_MATCH(DMI_PRODUCT_NAME
, "Wacom MobileStudio Pro 16"),
83 struct intel_hid_priv
{
84 struct input_dev
*input_dev
;
85 struct input_dev
*array
;
89 #define HID_EVENT_FILTER_UUID "eeec56b3-4442-408f-a792-4edd4d758054"
91 enum intel_hid_dsm_fn_codes
{
92 INTEL_HID_DSM_FN_INVALID
,
93 INTEL_HID_DSM_BTNL_FN
,
94 INTEL_HID_DSM_HDMM_FN
,
95 INTEL_HID_DSM_HDSM_FN
,
96 INTEL_HID_DSM_HDEM_FN
,
97 INTEL_HID_DSM_BTNS_FN
,
98 INTEL_HID_DSM_BTNE_FN
,
99 INTEL_HID_DSM_HEBC_V1_FN
,
100 INTEL_HID_DSM_VGBS_FN
,
101 INTEL_HID_DSM_HEBC_V2_FN
,
105 static const char *intel_hid_dsm_fn_to_method
[INTEL_HID_DSM_FN_MAX
] = {
118 static unsigned long long intel_hid_dsm_fn_mask
;
119 static guid_t intel_dsm_guid
;
121 static bool intel_hid_execute_method(acpi_handle handle
,
122 enum intel_hid_dsm_fn_codes fn_index
,
123 unsigned long long arg
)
125 union acpi_object
*obj
, argv4
, req
;
129 if (fn_index
<= INTEL_HID_DSM_FN_INVALID
||
130 fn_index
>= INTEL_HID_DSM_FN_MAX
)
133 method_name
= (char *)intel_hid_dsm_fn_to_method
[fn_index
];
135 if (!(intel_hid_dsm_fn_mask
& fn_index
))
138 /* All methods expects a package with one integer element */
139 req
.type
= ACPI_TYPE_INTEGER
;
140 req
.integer
.value
= arg
;
142 argv4
.type
= ACPI_TYPE_PACKAGE
;
143 argv4
.package
.count
= 1;
144 argv4
.package
.elements
= &req
;
146 obj
= acpi_evaluate_dsm(handle
, &intel_dsm_guid
, 1, fn_index
, &argv4
);
148 acpi_handle_debug(handle
, "Exec DSM Fn code: %d[%s] success\n",
149 fn_index
, method_name
);
155 status
= acpi_execute_simple_method(handle
, method_name
, arg
);
156 if (ACPI_SUCCESS(status
))
162 static bool intel_hid_evaluate_method(acpi_handle handle
,
163 enum intel_hid_dsm_fn_codes fn_index
,
164 unsigned long long *result
)
166 union acpi_object
*obj
;
170 if (fn_index
<= INTEL_HID_DSM_FN_INVALID
||
171 fn_index
>= INTEL_HID_DSM_FN_MAX
)
174 method_name
= (char *)intel_hid_dsm_fn_to_method
[fn_index
];
176 if (!(intel_hid_dsm_fn_mask
& fn_index
))
179 obj
= acpi_evaluate_dsm_typed(handle
, &intel_dsm_guid
,
181 NULL
, ACPI_TYPE_INTEGER
);
183 *result
= obj
->integer
.value
;
184 acpi_handle_debug(handle
,
185 "Eval DSM Fn code: %d[%s] results: 0x%llx\n",
186 fn_index
, method_name
, *result
);
192 status
= acpi_evaluate_integer(handle
, method_name
, NULL
, result
);
193 if (ACPI_SUCCESS(status
))
199 static void intel_hid_init_dsm(acpi_handle handle
)
201 union acpi_object
*obj
;
203 guid_parse(HID_EVENT_FILTER_UUID
, &intel_dsm_guid
);
205 obj
= acpi_evaluate_dsm_typed(handle
, &intel_dsm_guid
, 1, 0, NULL
,
208 intel_hid_dsm_fn_mask
= *obj
->buffer
.pointer
;
212 acpi_handle_debug(handle
, "intel_hid_dsm_fn_mask = %llx\n",
213 intel_hid_dsm_fn_mask
);
216 static int intel_hid_set_enable(struct device
*device
, bool enable
)
218 acpi_handle handle
= ACPI_HANDLE(device
);
220 /* Enable|disable features - power button is always enabled */
221 if (!intel_hid_execute_method(handle
, INTEL_HID_DSM_HDSM_FN
,
223 dev_warn(device
, "failed to %sable hotkeys\n",
224 enable
? "en" : "dis");
231 static void intel_button_array_enable(struct device
*device
, bool enable
)
233 struct intel_hid_priv
*priv
= dev_get_drvdata(device
);
234 acpi_handle handle
= ACPI_HANDLE(device
);
235 unsigned long long button_cap
;
241 /* Query supported platform features */
242 status
= acpi_evaluate_integer(handle
, "BTNC", NULL
, &button_cap
);
243 if (ACPI_FAILURE(status
)) {
244 dev_warn(device
, "failed to get button capability\n");
248 /* Enable|disable features - power button is always enabled */
249 if (!intel_hid_execute_method(handle
, INTEL_HID_DSM_BTNE_FN
,
250 enable
? button_cap
: 1))
251 dev_warn(device
, "failed to set button capability\n");
254 static int intel_hid_pm_prepare(struct device
*device
)
256 if (device_may_wakeup(device
)) {
257 struct intel_hid_priv
*priv
= dev_get_drvdata(device
);
259 priv
->wakeup_mode
= true;
264 static void intel_hid_pm_complete(struct device
*device
)
266 struct intel_hid_priv
*priv
= dev_get_drvdata(device
);
268 priv
->wakeup_mode
= false;
271 static int intel_hid_pl_suspend_handler(struct device
*device
)
273 intel_button_array_enable(device
, false);
275 if (!pm_suspend_no_platform())
276 intel_hid_set_enable(device
, false);
281 static int intel_hid_pl_resume_handler(struct device
*device
)
283 intel_hid_pm_complete(device
);
285 if (!pm_suspend_no_platform())
286 intel_hid_set_enable(device
, true);
288 intel_button_array_enable(device
, true);
292 static const struct dev_pm_ops intel_hid_pl_pm_ops
= {
293 .prepare
= intel_hid_pm_prepare
,
294 .complete
= intel_hid_pm_complete
,
295 .freeze
= intel_hid_pl_suspend_handler
,
296 .thaw
= intel_hid_pl_resume_handler
,
297 .restore
= intel_hid_pl_resume_handler
,
298 .suspend
= intel_hid_pl_suspend_handler
,
299 .resume
= intel_hid_pl_resume_handler
,
302 static int intel_hid_input_setup(struct platform_device
*device
)
304 struct intel_hid_priv
*priv
= dev_get_drvdata(&device
->dev
);
307 priv
->input_dev
= devm_input_allocate_device(&device
->dev
);
308 if (!priv
->input_dev
)
311 ret
= sparse_keymap_setup(priv
->input_dev
, intel_hid_keymap
, NULL
);
315 priv
->input_dev
->name
= "Intel HID events";
316 priv
->input_dev
->id
.bustype
= BUS_HOST
;
318 return input_register_device(priv
->input_dev
);
321 static int intel_button_array_input_setup(struct platform_device
*device
)
323 struct intel_hid_priv
*priv
= dev_get_drvdata(&device
->dev
);
326 /* Setup input device for 5 button array */
327 priv
->array
= devm_input_allocate_device(&device
->dev
);
331 ret
= sparse_keymap_setup(priv
->array
, intel_array_keymap
, NULL
);
335 priv
->array
->name
= "Intel HID 5 button array";
336 priv
->array
->id
.bustype
= BUS_HOST
;
338 return input_register_device(priv
->array
);
341 static void notify_handler(acpi_handle handle
, u32 event
, void *context
)
343 struct platform_device
*device
= context
;
344 struct intel_hid_priv
*priv
= dev_get_drvdata(&device
->dev
);
345 unsigned long long ev_index
;
347 if (priv
->wakeup_mode
) {
349 * Needed for wakeup from suspend-to-idle to work on some
350 * platforms that don't expose the 5-button array, but still
351 * send notifies with the power button event code to this
352 * device object on power button actions while suspended.
357 /* Wake up on 5-button array events only. */
358 if (event
== 0xc0 || !priv
->array
)
361 if (!sparse_keymap_entry_from_scancode(priv
->array
, event
)) {
362 dev_info(&device
->dev
, "unknown event 0x%x\n", event
);
367 pm_wakeup_hard_event(&device
->dev
);
372 * Needed for suspend to work on some platforms that don't expose
373 * the 5-button array, but still send notifies with power button
374 * event code to this device object on power button actions.
376 * Report the power button press and release.
380 input_report_key(priv
->input_dev
, KEY_POWER
, 1);
381 input_sync(priv
->input_dev
);
386 input_report_key(priv
->input_dev
, KEY_POWER
, 0);
387 input_sync(priv
->input_dev
);
392 /* 0xC0 is for HID events, other values are for 5 button array */
395 !sparse_keymap_report_event(priv
->array
, event
, 1, true))
396 dev_dbg(&device
->dev
, "unknown event 0x%x\n", event
);
400 if (!intel_hid_evaluate_method(handle
, INTEL_HID_DSM_HDEM_FN
,
402 dev_warn(&device
->dev
, "failed to get event index\n");
406 if (!sparse_keymap_report_event(priv
->input_dev
, ev_index
, 1, true))
407 dev_dbg(&device
->dev
, "unknown event index 0x%llx\n",
411 static bool button_array_present(struct platform_device
*device
)
413 acpi_handle handle
= ACPI_HANDLE(&device
->dev
);
414 unsigned long long event_cap
;
416 if (intel_hid_evaluate_method(handle
, INTEL_HID_DSM_HEBC_V2_FN
,
418 /* Check presence of 5 button array or v2 power button */
419 if (event_cap
& 0x60000)
423 if (intel_hid_evaluate_method(handle
, INTEL_HID_DSM_HEBC_V1_FN
,
425 if (event_cap
& 0x20000)
429 if (dmi_check_system(button_array_table
))
435 static int intel_hid_probe(struct platform_device
*device
)
437 acpi_handle handle
= ACPI_HANDLE(&device
->dev
);
438 unsigned long long mode
;
439 struct intel_hid_priv
*priv
;
443 intel_hid_init_dsm(handle
);
445 if (!intel_hid_evaluate_method(handle
, INTEL_HID_DSM_HDMM_FN
, &mode
)) {
446 dev_warn(&device
->dev
, "failed to read mode\n");
452 * This driver only implements "simple" mode. There appear
453 * to be no other modes, but we should be paranoid and check
456 dev_info(&device
->dev
, "platform is not in simple mode\n");
460 priv
= devm_kzalloc(&device
->dev
, sizeof(*priv
), GFP_KERNEL
);
463 dev_set_drvdata(&device
->dev
, priv
);
465 err
= intel_hid_input_setup(device
);
467 pr_err("Failed to setup Intel HID hotkeys\n");
471 /* Setup 5 button array */
472 if (button_array_present(device
)) {
473 dev_info(&device
->dev
, "platform supports 5 button array\n");
474 err
= intel_button_array_input_setup(device
);
476 pr_err("Failed to setup Intel 5 button array hotkeys\n");
479 status
= acpi_install_notify_handler(handle
,
483 if (ACPI_FAILURE(status
))
486 err
= intel_hid_set_enable(&device
->dev
, true);
488 goto err_remove_notify
;
491 unsigned long long dummy
;
493 intel_button_array_enable(&device
->dev
, true);
495 /* Call button load method to enable HID power button */
496 if (!intel_hid_evaluate_method(handle
, INTEL_HID_DSM_BTNL_FN
,
498 dev_warn(&device
->dev
,
499 "failed to enable HID power button\n");
503 device_init_wakeup(&device
->dev
, true);
505 * In order for system wakeup to work, the EC GPE has to be marked as
506 * a wakeup one, so do that here (this setting will persist, but it has
507 * no effect until the wakeup mask is set for the EC GPE).
509 acpi_ec_mark_gpe_for_wake();
513 acpi_remove_notify_handler(handle
, ACPI_DEVICE_NOTIFY
, notify_handler
);
518 static int intel_hid_remove(struct platform_device
*device
)
520 acpi_handle handle
= ACPI_HANDLE(&device
->dev
);
522 device_init_wakeup(&device
->dev
, false);
523 acpi_remove_notify_handler(handle
, ACPI_DEVICE_NOTIFY
, notify_handler
);
524 intel_hid_set_enable(&device
->dev
, false);
525 intel_button_array_enable(&device
->dev
, false);
528 * Even if we failed to shut off the event stream, we can still
529 * safely detach from the device.
534 static struct platform_driver intel_hid_pl_driver
= {
537 .acpi_match_table
= intel_hid_ids
,
538 .pm
= &intel_hid_pl_pm_ops
,
540 .probe
= intel_hid_probe
,
541 .remove
= intel_hid_remove
,
543 MODULE_DEVICE_TABLE(acpi
, intel_hid_ids
);
546 * Unfortunately, some laptops provide a _HID="INT33D5" device with
547 * _CID="PNP0C02". This causes the pnpacpi scan driver to claim the
548 * ACPI node, so no platform device will be created. The pnpacpi
549 * driver rejects this device in subsequent processing, so no physical
550 * node is created at all.
552 * As a workaround until the ACPI core figures out how to handle
553 * this corner case, manually ask the ACPI platform device code to
554 * claim the ACPI node.
556 static acpi_status __init
557 check_acpi_dev(acpi_handle handle
, u32 lvl
, void *context
, void **rv
)
559 const struct acpi_device_id
*ids
= context
;
560 struct acpi_device
*dev
;
562 if (acpi_bus_get_device(handle
, &dev
) != 0)
565 if (acpi_match_device_ids(dev
, ids
) == 0)
566 if (acpi_create_platform_device(dev
, NULL
))
568 "intel-hid: created platform device\n");
573 static int __init
intel_hid_init(void)
575 acpi_walk_namespace(ACPI_TYPE_DEVICE
, ACPI_ROOT_OBJECT
,
576 ACPI_UINT32_MAX
, check_acpi_dev
, NULL
,
577 (void *)intel_hid_ids
, NULL
);
579 return platform_driver_register(&intel_hid_pl_driver
);
581 module_init(intel_hid_init
);
583 static void __exit
intel_hid_exit(void)
585 platform_driver_unregister(&intel_hid_pl_driver
);
587 module_exit(intel_hid_exit
);