1 // SPDX-License-Identifier: GPL-2.0+
3 * HID driver for Google Hammer device.
5 * Copyright (c) 2017 Google Inc.
6 * Author: Wei-Ning Huang <wnhuang@google.com>
10 * This program is free software; you can redistribute it and/or modify it
11 * under the terms of the GNU General Public License as published by the Free
12 * Software Foundation; either version 2 of the License, or (at your option)
16 #include <linux/acpi.h>
17 #include <linux/hid.h>
18 #include <linux/leds.h>
19 #include <linux/module.h>
20 #include <linux/platform_data/cros_ec_commands.h>
21 #include <linux/platform_data/cros_ec_proto.h>
22 #include <linux/platform_device.h>
23 #include <linux/pm_wakeup.h>
24 #include <asm/unaligned.h>
29 * C(hrome)B(ase)A(ttached)S(witch) - switch exported by Chrome EC and reporting
30 * state of the "Whiskers" base - attached or detached. Whiskers USB device also
31 * reports position of the keyboard - folded or not. Combining base state and
32 * position allows us to generate proper "Tablet mode" events.
35 struct device *dev; /* The platform device (EC) */
36 struct input_dev *input;
39 struct notifier_block notifier;
42 static struct cbas_ec cbas_ec;
43 static DEFINE_SPINLOCK(cbas_ec_lock);
44 static DEFINE_MUTEX(cbas_ec_reglock);
46 static bool cbas_parse_base_state(const void *data)
48 u32 switches = get_unaligned_le32(data);
50 return !!(switches & BIT(EC_MKBP_BASE_ATTACHED));
53 static int cbas_ec_query_base(struct cros_ec_device *ec_dev, bool get_state,
56 struct ec_params_mkbp_info *params;
57 struct cros_ec_command *msg;
60 msg = kzalloc(sizeof(*msg) + max(sizeof(u32), sizeof(*params)),
65 msg->command = EC_CMD_MKBP_INFO;
67 msg->outsize = sizeof(*params);
68 msg->insize = sizeof(u32);
69 params = (struct ec_params_mkbp_info *)msg->data;
70 params->info_type = get_state ?
71 EC_MKBP_INFO_CURRENT : EC_MKBP_INFO_SUPPORTED;
72 params->event_type = EC_MKBP_EVENT_SWITCH;
74 ret = cros_ec_cmd_xfer_status(ec_dev, msg);
76 if (ret != sizeof(u32)) {
77 dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n",
81 *state = cbas_parse_base_state(msg->data);
91 static int cbas_ec_notify(struct notifier_block *nb,
92 unsigned long queued_during_suspend,
95 struct cros_ec_device *ec = _notify;
99 if (ec->event_data.event_type == EC_MKBP_EVENT_SWITCH) {
100 base_present = cbas_parse_base_state(
101 &ec->event_data.data.switches);
103 "%s: base: %d\n", __func__, base_present);
105 if (device_may_wakeup(cbas_ec.dev) ||
106 !queued_during_suspend) {
108 pm_wakeup_event(cbas_ec.dev, 0);
110 spin_lock_irqsave(&cbas_ec_lock, flags);
113 * While input layer dedupes the events, we do not want
114 * to disrupt the state reported by the base by
115 * overriding it with state reported by the LID. Only
116 * report changes, as we assume that on attach the base
119 if (base_present != cbas_ec.base_present) {
120 input_report_switch(cbas_ec.input,
123 input_sync(cbas_ec.input);
124 cbas_ec.base_present = base_present;
127 spin_unlock_irqrestore(&cbas_ec_lock, flags);
134 static __maybe_unused int cbas_ec_resume(struct device *dev)
136 struct cros_ec_device *ec = dev_get_drvdata(dev->parent);
140 error = cbas_ec_query_base(ec, true, &base_present);
142 dev_warn(dev, "failed to fetch base state on resume: %d\n",
145 spin_lock_irq(&cbas_ec_lock);
147 cbas_ec.base_present = base_present;
150 * Only report if base is disconnected. If base is connected,
151 * it will resend its state on resume, and we'll update it
154 if (!cbas_ec.base_present) {
155 input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
156 input_sync(cbas_ec.input);
159 spin_unlock_irq(&cbas_ec_lock);
165 static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume);
167 static void cbas_ec_set_input(struct input_dev *input)
169 /* Take the lock so hammer_event() does not race with us here */
170 spin_lock_irq(&cbas_ec_lock);
171 cbas_ec.input = input;
172 spin_unlock_irq(&cbas_ec_lock);
175 static int __cbas_ec_probe(struct platform_device *pdev)
177 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
178 struct input_dev *input;
182 error = cbas_ec_query_base(ec, false, &base_supported);
189 input = devm_input_allocate_device(&pdev->dev);
193 input->name = "Whiskers Tablet Mode Switch";
194 input->id.bustype = BUS_HOST;
196 input_set_capability(input, EV_SW, SW_TABLET_MODE);
198 error = input_register_device(input);
200 dev_err(&pdev->dev, "cannot register input device: %d\n",
206 error = cbas_ec_query_base(ec, true, &cbas_ec.base_present);
208 dev_err(&pdev->dev, "cannot query base state: %d\n", error);
212 if (!cbas_ec.base_present)
213 cbas_ec.base_folded = false;
215 dev_dbg(&pdev->dev, "%s: base: %d, folded: %d\n", __func__,
216 cbas_ec.base_present, cbas_ec.base_folded);
218 input_report_switch(input, SW_TABLET_MODE,
219 !cbas_ec.base_present || cbas_ec.base_folded);
221 cbas_ec_set_input(input);
223 cbas_ec.dev = &pdev->dev;
224 cbas_ec.notifier.notifier_call = cbas_ec_notify;
225 error = blocking_notifier_chain_register(&ec->event_notifier,
228 dev_err(&pdev->dev, "cannot register notifier: %d\n", error);
229 cbas_ec_set_input(NULL);
233 device_init_wakeup(&pdev->dev, true);
237 static int cbas_ec_probe(struct platform_device *pdev)
241 mutex_lock(&cbas_ec_reglock);
248 retval = __cbas_ec_probe(pdev);
251 mutex_unlock(&cbas_ec_reglock);
255 static int cbas_ec_remove(struct platform_device *pdev)
257 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
259 mutex_lock(&cbas_ec_reglock);
261 blocking_notifier_chain_unregister(&ec->event_notifier,
263 cbas_ec_set_input(NULL);
265 mutex_unlock(&cbas_ec_reglock);
269 static const struct acpi_device_id cbas_ec_acpi_ids[] = {
273 MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids);
275 static struct platform_driver cbas_ec_driver = {
276 .probe = cbas_ec_probe,
277 .remove = cbas_ec_remove,
280 .acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids),
281 .pm = &cbas_ec_pm_ops,
285 #define MAX_BRIGHTNESS 100
287 struct hammer_kbd_leds {
288 struct led_classdev cdev;
289 struct hid_device *hdev;
290 u8 buf[2] ____cacheline_aligned;
293 static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev,
294 enum led_brightness br)
296 struct hammer_kbd_leds *led = container_of(cdev,
297 struct hammer_kbd_leds,
305 * Request USB HID device to be in Full On mode, so that sending
306 * hardware output report and hardware raw request won't fail.
308 ret = hid_hw_power(led->hdev, PM_HINT_FULLON);
310 hid_err(led->hdev, "failed: device not resumed %d\n", ret);
314 ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf));
316 ret = hid_hw_raw_request(led->hdev, 0, led->buf,
321 hid_err(led->hdev, "failed to set keyboard backlight: %d\n",
324 /* Request USB HID device back to Normal Mode. */
325 hid_hw_power(led->hdev, PM_HINT_NORMAL);
330 static int hammer_register_leds(struct hid_device *hdev)
332 struct hammer_kbd_leds *kbd_backlight;
335 kbd_backlight = kzalloc(sizeof(*kbd_backlight), GFP_KERNEL);
339 kbd_backlight->hdev = hdev;
340 kbd_backlight->cdev.name = "hammer::kbd_backlight";
341 kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS;
342 kbd_backlight->cdev.brightness_set_blocking =
343 hammer_kbd_brightness_set_blocking;
344 kbd_backlight->cdev.flags = LED_HW_PLUGGABLE;
346 /* Set backlight to 0% initially. */
347 hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0);
349 error = led_classdev_register(&hdev->dev, &kbd_backlight->cdev);
353 hid_set_drvdata(hdev, kbd_backlight);
357 kfree(kbd_backlight);
361 static void hammer_unregister_leds(struct hid_device *hdev)
363 struct hammer_kbd_leds *kbd_backlight = hid_get_drvdata(hdev);
366 led_classdev_unregister(&kbd_backlight->cdev);
367 kfree(kbd_backlight);
371 #define HID_UP_GOOGLEVENDOR 0xffd10000
372 #define HID_VD_KBD_FOLDED 0x00000019
373 #define HID_USAGE_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED)
375 /* HID usage for keyboard backlight (Alphanumeric display brightness) */
376 #define HID_AD_BRIGHTNESS 0x00140046
378 static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi,
379 struct hid_field *field,
380 struct hid_usage *usage,
381 unsigned long **bit, int *max)
383 if (usage->hid == HID_USAGE_KBD_FOLDED) {
385 * We do not want to have this usage mapped as it will get
386 * mixed in with "base attached" signal and delivered over
387 * separate input device for tablet switch mode.
395 static void hammer_folded_event(struct hid_device *hdev, bool folded)
399 spin_lock_irqsave(&cbas_ec_lock, flags);
402 * If we are getting events from Whiskers that means that it
403 * is attached to the lid.
405 cbas_ec.base_present = true;
406 cbas_ec.base_folded = folded;
407 hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__,
408 cbas_ec.base_present, cbas_ec.base_folded);
411 input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded);
412 input_sync(cbas_ec.input);
415 spin_unlock_irqrestore(&cbas_ec_lock, flags);
418 static int hammer_event(struct hid_device *hid, struct hid_field *field,
419 struct hid_usage *usage, __s32 value)
421 if (usage->hid == HID_USAGE_KBD_FOLDED) {
422 hammer_folded_event(hid, value);
423 return 1; /* We handled this event */
429 static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type,
430 unsigned application, unsigned usage)
432 struct hid_report_enum *re = &hdev->report_enum[report_type];
433 struct hid_report *report;
436 list_for_each_entry(report, &re->report_list, list) {
437 if (report->application != application)
440 for (i = 0; i < report->maxfield; i++) {
441 struct hid_field *field = report->field[i];
443 for (j = 0; j < field->maxusage; j++)
444 if (field->usage[j].hid == usage)
452 static bool hammer_has_folded_event(struct hid_device *hdev)
454 return hammer_has_usage(hdev, HID_INPUT_REPORT,
455 HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED);
458 static bool hammer_has_backlight_control(struct hid_device *hdev)
460 return hammer_has_usage(hdev, HID_OUTPUT_REPORT,
461 HID_GD_KEYBOARD, HID_AD_BRIGHTNESS);
464 static void hammer_get_folded_state(struct hid_device *hdev)
466 struct hid_report *report;
471 report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0];
473 if (!report || report->maxfield < 1)
476 len = hid_report_len(report) + 1;
478 buf = kmalloc(len, GFP_KERNEL);
482 rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT);
485 hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len);
489 for (a = 0; a < report->maxfield; a++) {
490 struct hid_field *field = report->field[a];
492 if (field->usage->hid == HID_USAGE_KBD_FOLDED) {
493 u32 value = hid_field_extract(hdev, buf+1,
494 field->report_offset, field->report_size);
496 hammer_folded_event(hdev, value);
505 static int hammer_probe(struct hid_device *hdev,
506 const struct hid_device_id *id)
510 error = hid_parse(hdev);
514 error = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
519 * We always want to poll for, and handle tablet mode events from
520 * devices that have folded usage, even when nobody has opened the input
521 * device. This also prevents the hid core from dropping early tablet
522 * mode events from the device.
524 if (hammer_has_folded_event(hdev)) {
525 hdev->quirks |= HID_QUIRK_ALWAYS_POLL;
526 error = hid_hw_open(hdev);
530 hammer_get_folded_state(hdev);
533 if (hammer_has_backlight_control(hdev)) {
534 error = hammer_register_leds(hdev);
537 "Failed to register keyboard backlight: %d\n",
544 static void hammer_remove(struct hid_device *hdev)
548 if (hammer_has_folded_event(hdev)) {
552 * If we are disconnecting then most likely Whiskers is
553 * being removed. Even if it is not removed, without proper
554 * keyboard we should not stay in clamshell mode.
556 * The reason for doing it here and not waiting for signal
557 * from EC, is that on some devices there are high leakage
558 * on Whiskers pins and we do not detect disconnect reliably,
559 * resulting in devices being stuck in clamshell mode.
561 spin_lock_irqsave(&cbas_ec_lock, flags);
562 if (cbas_ec.input && cbas_ec.base_present) {
563 input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1);
564 input_sync(cbas_ec.input);
566 cbas_ec.base_present = false;
567 spin_unlock_irqrestore(&cbas_ec_lock, flags);
570 hammer_unregister_leds(hdev);
575 static const struct hid_device_id hammer_devices[] = {
576 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
577 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },
578 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
579 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
580 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
581 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) },
582 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
583 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) },
584 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
585 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
586 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
587 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) },
588 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
589 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) },
590 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
591 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },
594 MODULE_DEVICE_TABLE(hid, hammer_devices);
596 static struct hid_driver hammer_driver = {
598 .id_table = hammer_devices,
599 .probe = hammer_probe,
600 .remove = hammer_remove,
601 .input_mapping = hammer_input_mapping,
602 .event = hammer_event,
605 static int __init hammer_init(void)
609 error = platform_driver_register(&cbas_ec_driver);
613 error = hid_register_driver(&hammer_driver);
615 platform_driver_unregister(&cbas_ec_driver);
621 module_init(hammer_init);
623 static void __exit hammer_exit(void)
625 hid_unregister_driver(&hammer_driver);
626 platform_driver_unregister(&cbas_ec_driver);
628 module_exit(hammer_exit);
630 MODULE_LICENSE("GPL");