Commit | Line | Data |
---|---|---|
bc774b8c WNH |
1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* | |
3 | * HID driver for Google Hammer device. | |
4 | * | |
5 | * Copyright (c) 2017 Google Inc. | |
6 | * Author: Wei-Ning Huang <wnhuang@google.com> | |
7 | */ | |
8 | ||
9 | /* | |
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) | |
13 | * any later version. | |
14 | */ | |
15 | ||
eb1aac4c | 16 | #include <linux/acpi.h> |
bc774b8c WNH |
17 | #include <linux/hid.h> |
18 | #include <linux/leds.h> | |
eb1aac4c DT |
19 | #include <linux/mfd/cros_ec.h> |
20 | #include <linux/mfd/cros_ec_commands.h> | |
bc774b8c | 21 | #include <linux/module.h> |
eb1aac4c DT |
22 | #include <linux/platform_device.h> |
23 | #include <linux/pm_wakeup.h> | |
24 | #include <asm/unaligned.h> | |
bc774b8c WNH |
25 | |
26 | #include "hid-ids.h" | |
27 | ||
eb1aac4c DT |
28 | /* |
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. | |
33 | */ | |
34 | struct cbas_ec { | |
35 | struct device *dev; /* The platform device (EC) */ | |
36 | struct input_dev *input; | |
37 | bool base_present; | |
38 | struct notifier_block notifier; | |
39 | }; | |
bc774b8c | 40 | |
eb1aac4c DT |
41 | static struct cbas_ec cbas_ec; |
42 | static DEFINE_SPINLOCK(cbas_ec_lock); | |
43 | static DEFINE_MUTEX(cbas_ec_reglock); | |
44 | ||
45 | static bool cbas_parse_base_state(const void *data) | |
46 | { | |
47 | u32 switches = get_unaligned_le32(data); | |
48 | ||
49 | return !!(switches & BIT(EC_MKBP_BASE_ATTACHED)); | |
50 | } | |
51 | ||
52 | static int cbas_ec_query_base(struct cros_ec_device *ec_dev, bool get_state, | |
53 | bool *state) | |
54 | { | |
55 | struct ec_params_mkbp_info *params; | |
56 | struct cros_ec_command *msg; | |
57 | int ret; | |
58 | ||
59 | msg = kzalloc(sizeof(*msg) + max(sizeof(u32), sizeof(*params)), | |
60 | GFP_KERNEL); | |
61 | if (!msg) | |
62 | return -ENOMEM; | |
63 | ||
64 | msg->command = EC_CMD_MKBP_INFO; | |
65 | msg->version = 1; | |
66 | msg->outsize = sizeof(*params); | |
67 | msg->insize = sizeof(u32); | |
68 | params = (struct ec_params_mkbp_info *)msg->data; | |
69 | params->info_type = get_state ? | |
70 | EC_MKBP_INFO_CURRENT : EC_MKBP_INFO_SUPPORTED; | |
71 | params->event_type = EC_MKBP_EVENT_SWITCH; | |
72 | ||
73 | ret = cros_ec_cmd_xfer_status(ec_dev, msg); | |
74 | if (ret >= 0) { | |
75 | if (ret != sizeof(u32)) { | |
76 | dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n", | |
77 | ret, sizeof(u32)); | |
78 | ret = -EPROTO; | |
79 | } else { | |
80 | *state = cbas_parse_base_state(msg->data); | |
81 | ret = 0; | |
82 | } | |
83 | } | |
84 | ||
85 | kfree(msg); | |
86 | ||
87 | return ret; | |
88 | } | |
89 | ||
90 | static int cbas_ec_notify(struct notifier_block *nb, | |
91 | unsigned long queued_during_suspend, | |
92 | void *_notify) | |
93 | { | |
94 | struct cros_ec_device *ec = _notify; | |
95 | unsigned long flags; | |
96 | bool base_present; | |
97 | ||
98 | if (ec->event_data.event_type == EC_MKBP_EVENT_SWITCH) { | |
99 | base_present = cbas_parse_base_state( | |
100 | &ec->event_data.data.switches); | |
101 | dev_dbg(cbas_ec.dev, | |
102 | "%s: base: %d\n", __func__, base_present); | |
103 | ||
104 | if (device_may_wakeup(cbas_ec.dev) || | |
105 | !queued_during_suspend) { | |
106 | ||
107 | pm_wakeup_event(cbas_ec.dev, 0); | |
108 | ||
109 | spin_lock_irqsave(&cbas_ec_lock, flags); | |
110 | ||
111 | /* | |
112 | * While input layer dedupes the events, we do not want | |
113 | * to disrupt the state reported by the base by | |
114 | * overriding it with state reported by the LID. Only | |
115 | * report changes, as we assume that on attach the base | |
116 | * is not folded. | |
117 | */ | |
118 | if (base_present != cbas_ec.base_present) { | |
119 | input_report_switch(cbas_ec.input, | |
120 | SW_TABLET_MODE, | |
121 | !base_present); | |
122 | input_sync(cbas_ec.input); | |
123 | cbas_ec.base_present = base_present; | |
124 | } | |
125 | ||
126 | spin_unlock_irqrestore(&cbas_ec_lock, flags); | |
127 | } | |
128 | } | |
129 | ||
130 | return NOTIFY_OK; | |
131 | } | |
132 | ||
133 | static __maybe_unused int cbas_ec_resume(struct device *dev) | |
134 | { | |
135 | struct cros_ec_device *ec = dev_get_drvdata(dev->parent); | |
136 | bool base_present; | |
137 | int error; | |
138 | ||
139 | error = cbas_ec_query_base(ec, true, &base_present); | |
140 | if (error) { | |
141 | dev_warn(dev, "failed to fetch base state on resume: %d\n", | |
142 | error); | |
143 | } else { | |
144 | spin_lock_irq(&cbas_ec_lock); | |
145 | ||
146 | cbas_ec.base_present = base_present; | |
147 | ||
148 | /* | |
149 | * Only report if base is disconnected. If base is connected, | |
150 | * it will resend its state on resume, and we'll update it | |
151 | * in hammer_event(). | |
152 | */ | |
153 | if (!cbas_ec.base_present) { | |
154 | input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1); | |
155 | input_sync(cbas_ec.input); | |
156 | } | |
157 | ||
158 | spin_unlock_irq(&cbas_ec_lock); | |
159 | } | |
160 | ||
161 | return 0; | |
162 | } | |
163 | ||
8f35260e | 164 | static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume); |
eb1aac4c DT |
165 | |
166 | static void cbas_ec_set_input(struct input_dev *input) | |
167 | { | |
168 | /* Take the lock so hammer_event() does not race with us here */ | |
169 | spin_lock_irq(&cbas_ec_lock); | |
170 | cbas_ec.input = input; | |
171 | spin_unlock_irq(&cbas_ec_lock); | |
172 | } | |
173 | ||
174 | static int __cbas_ec_probe(struct platform_device *pdev) | |
175 | { | |
176 | struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); | |
177 | struct input_dev *input; | |
178 | bool base_supported; | |
179 | int error; | |
180 | ||
181 | error = cbas_ec_query_base(ec, false, &base_supported); | |
182 | if (error) | |
183 | return error; | |
184 | ||
185 | if (!base_supported) | |
186 | return -ENXIO; | |
187 | ||
188 | input = devm_input_allocate_device(&pdev->dev); | |
189 | if (!input) | |
190 | return -ENOMEM; | |
191 | ||
192 | input->name = "Whiskers Tablet Mode Switch"; | |
193 | input->id.bustype = BUS_HOST; | |
194 | ||
195 | input_set_capability(input, EV_SW, SW_TABLET_MODE); | |
196 | ||
197 | error = input_register_device(input); | |
198 | if (error) { | |
199 | dev_err(&pdev->dev, "cannot register input device: %d\n", | |
200 | error); | |
201 | return error; | |
202 | } | |
203 | ||
204 | /* Seed the state */ | |
205 | error = cbas_ec_query_base(ec, true, &cbas_ec.base_present); | |
206 | if (error) { | |
207 | dev_err(&pdev->dev, "cannot query base state: %d\n", error); | |
208 | return error; | |
209 | } | |
210 | ||
211 | input_report_switch(input, SW_TABLET_MODE, !cbas_ec.base_present); | |
212 | ||
213 | cbas_ec_set_input(input); | |
214 | ||
215 | cbas_ec.dev = &pdev->dev; | |
216 | cbas_ec.notifier.notifier_call = cbas_ec_notify; | |
217 | error = blocking_notifier_chain_register(&ec->event_notifier, | |
218 | &cbas_ec.notifier); | |
219 | if (error) { | |
220 | dev_err(&pdev->dev, "cannot register notifier: %d\n", error); | |
221 | cbas_ec_set_input(NULL); | |
222 | return error; | |
223 | } | |
224 | ||
225 | device_init_wakeup(&pdev->dev, true); | |
226 | return 0; | |
227 | } | |
228 | ||
229 | static int cbas_ec_probe(struct platform_device *pdev) | |
230 | { | |
231 | int retval; | |
232 | ||
233 | mutex_lock(&cbas_ec_reglock); | |
234 | ||
235 | if (cbas_ec.input) { | |
236 | retval = -EBUSY; | |
237 | goto out; | |
238 | } | |
239 | ||
240 | retval = __cbas_ec_probe(pdev); | |
241 | ||
242 | out: | |
243 | mutex_unlock(&cbas_ec_reglock); | |
244 | return retval; | |
245 | } | |
246 | ||
247 | static int cbas_ec_remove(struct platform_device *pdev) | |
248 | { | |
249 | struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); | |
250 | ||
251 | mutex_lock(&cbas_ec_reglock); | |
252 | ||
253 | blocking_notifier_chain_unregister(&ec->event_notifier, | |
254 | &cbas_ec.notifier); | |
255 | cbas_ec_set_input(NULL); | |
256 | ||
257 | mutex_unlock(&cbas_ec_reglock); | |
258 | return 0; | |
259 | } | |
260 | ||
261 | static const struct acpi_device_id cbas_ec_acpi_ids[] = { | |
262 | { "GOOG000B", 0 }, | |
263 | { } | |
264 | }; | |
265 | MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids); | |
266 | ||
267 | static struct platform_driver cbas_ec_driver = { | |
268 | .probe = cbas_ec_probe, | |
269 | .remove = cbas_ec_remove, | |
270 | .driver = { | |
271 | .name = "cbas_ec", | |
272 | .acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids), | |
273 | .pm = &cbas_ec_pm_ops, | |
274 | }, | |
275 | }; | |
276 | ||
277 | #define MAX_BRIGHTNESS 100 | |
bc774b8c WNH |
278 | |
279 | struct hammer_kbd_leds { | |
280 | struct led_classdev cdev; | |
281 | struct hid_device *hdev; | |
282 | u8 buf[2] ____cacheline_aligned; | |
283 | }; | |
284 | ||
285 | static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev, | |
286 | enum led_brightness br) | |
287 | { | |
288 | struct hammer_kbd_leds *led = container_of(cdev, | |
289 | struct hammer_kbd_leds, | |
290 | cdev); | |
291 | int ret; | |
292 | ||
293 | led->buf[0] = 0; | |
294 | led->buf[1] = br; | |
295 | ||
7d3d8840 HK |
296 | /* |
297 | * Request USB HID device to be in Full On mode, so that sending | |
298 | * hardware output report and hardware raw request won't fail. | |
299 | */ | |
300 | ret = hid_hw_power(led->hdev, PM_HINT_FULLON); | |
301 | if (ret < 0) { | |
302 | hid_err(led->hdev, "failed: device not resumed %d\n", ret); | |
303 | return ret; | |
304 | } | |
305 | ||
bc774b8c WNH |
306 | ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf)); |
307 | if (ret == -ENOSYS) | |
308 | ret = hid_hw_raw_request(led->hdev, 0, led->buf, | |
309 | sizeof(led->buf), | |
310 | HID_OUTPUT_REPORT, | |
311 | HID_REQ_SET_REPORT); | |
312 | if (ret < 0) | |
313 | hid_err(led->hdev, "failed to set keyboard backlight: %d\n", | |
314 | ret); | |
7d3d8840 HK |
315 | |
316 | /* Request USB HID device back to Normal Mode. */ | |
317 | hid_hw_power(led->hdev, PM_HINT_NORMAL); | |
318 | ||
bc774b8c WNH |
319 | return ret; |
320 | } | |
321 | ||
322 | static int hammer_register_leds(struct hid_device *hdev) | |
323 | { | |
324 | struct hammer_kbd_leds *kbd_backlight; | |
325 | ||
326 | kbd_backlight = devm_kzalloc(&hdev->dev, | |
327 | sizeof(*kbd_backlight), | |
328 | GFP_KERNEL); | |
329 | if (!kbd_backlight) | |
330 | return -ENOMEM; | |
331 | ||
332 | kbd_backlight->hdev = hdev; | |
333 | kbd_backlight->cdev.name = "hammer::kbd_backlight"; | |
334 | kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS; | |
335 | kbd_backlight->cdev.brightness_set_blocking = | |
336 | hammer_kbd_brightness_set_blocking; | |
337 | kbd_backlight->cdev.flags = LED_HW_PLUGGABLE; | |
338 | ||
339 | /* Set backlight to 0% initially. */ | |
340 | hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0); | |
341 | ||
342 | return devm_led_classdev_register(&hdev->dev, &kbd_backlight->cdev); | |
343 | } | |
344 | ||
eb1aac4c DT |
345 | #define HID_UP_GOOGLEVENDOR 0xffd10000 |
346 | #define HID_VD_KBD_FOLDED 0x00000019 | |
347 | #define WHISKERS_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED) | |
348 | ||
349 | /* HID usage for keyboard backlight (Alphanumeric display brightness) */ | |
350 | #define HID_AD_BRIGHTNESS 0x00140046 | |
351 | ||
352 | static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi, | |
353 | struct hid_field *field, | |
354 | struct hid_usage *usage, | |
355 | unsigned long **bit, int *max) | |
bc774b8c | 356 | { |
eb1aac4c DT |
357 | if (hdev->product == USB_DEVICE_ID_GOOGLE_WHISKERS && |
358 | usage->hid == WHISKERS_KBD_FOLDED) { | |
359 | /* | |
360 | * We do not want to have this usage mapped as it will get | |
361 | * mixed in with "base attached" signal and delivered over | |
362 | * separate input device for tablet switch mode. | |
363 | */ | |
364 | return -1; | |
365 | } | |
366 | ||
367 | return 0; | |
368 | } | |
369 | ||
370 | static int hammer_event(struct hid_device *hid, struct hid_field *field, | |
371 | struct hid_usage *usage, __s32 value) | |
372 | { | |
373 | unsigned long flags; | |
374 | ||
375 | if (hid->product == USB_DEVICE_ID_GOOGLE_WHISKERS && | |
376 | usage->hid == WHISKERS_KBD_FOLDED) { | |
377 | spin_lock_irqsave(&cbas_ec_lock, flags); | |
378 | ||
379 | hid_dbg(hid, "%s: base: %d, folded: %d\n", __func__, | |
380 | cbas_ec.base_present, value); | |
381 | ||
382 | /* | |
383 | * We should not get event if base is detached, but in case | |
384 | * we happen to service HID and EC notifications out of order | |
385 | * let's still check the "base present" flag. | |
386 | */ | |
387 | if (cbas_ec.input && cbas_ec.base_present) { | |
388 | input_report_switch(cbas_ec.input, | |
389 | SW_TABLET_MODE, value); | |
390 | input_sync(cbas_ec.input); | |
391 | } | |
392 | ||
393 | spin_unlock_irqrestore(&cbas_ec_lock, flags); | |
394 | return 1; /* We handled this event */ | |
395 | } | |
396 | ||
397 | return 0; | |
398 | } | |
399 | ||
400 | static bool hammer_is_keyboard_interface(struct hid_device *hdev) | |
401 | { | |
402 | struct hid_report_enum *re = &hdev->report_enum[HID_INPUT_REPORT]; | |
bc774b8c WNH |
403 | struct hid_report *report; |
404 | ||
eb1aac4c DT |
405 | list_for_each_entry(report, &re->report_list, list) |
406 | if (report->application == HID_GD_KEYBOARD) | |
407 | return true; | |
bc774b8c | 408 | |
eb1aac4c DT |
409 | return false; |
410 | } | |
411 | ||
412 | static bool hammer_has_backlight_control(struct hid_device *hdev) | |
413 | { | |
414 | struct hid_report_enum *re = &hdev->report_enum[HID_OUTPUT_REPORT]; | |
415 | struct hid_report *report; | |
416 | int i, j; | |
bc774b8c | 417 | |
eb1aac4c DT |
418 | list_for_each_entry(report, &re->report_list, list) { |
419 | if (report->application != HID_GD_KEYBOARD) | |
420 | continue; | |
bc774b8c | 421 | |
eb1aac4c DT |
422 | for (i = 0; i < report->maxfield; i++) { |
423 | struct hid_field *field = report->field[i]; | |
424 | ||
425 | for (j = 0; j < field->maxusage; j++) | |
426 | if (field->usage[j].hid == HID_AD_BRIGHTNESS) | |
427 | return true; | |
428 | } | |
429 | } | |
430 | ||
431 | return false; | |
432 | } | |
433 | ||
434 | static int hammer_probe(struct hid_device *hdev, | |
435 | const struct hid_device_id *id) | |
436 | { | |
437 | int error; | |
438 | ||
439 | /* | |
440 | * We always want to poll for, and handle tablet mode events from | |
441 | * Whiskers, even when nobody has opened the input device. This also | |
442 | * prevents the hid core from dropping early tablet mode events from | |
443 | * the device. | |
444 | */ | |
445 | if (hdev->product == USB_DEVICE_ID_GOOGLE_WHISKERS && | |
446 | hammer_is_keyboard_interface(hdev)) | |
447 | hdev->quirks |= HID_QUIRK_ALWAYS_POLL; | |
448 | ||
449 | error = hid_parse(hdev); | |
450 | if (error) | |
451 | return error; | |
452 | ||
453 | error = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
454 | if (error) | |
455 | return error; | |
456 | ||
457 | if (hammer_has_backlight_control(hdev)) { | |
458 | error = hammer_register_leds(hdev); | |
459 | if (error) | |
bc774b8c WNH |
460 | hid_warn(hdev, |
461 | "Failed to register keyboard backlight: %d\n", | |
eb1aac4c | 462 | error); |
bc774b8c WNH |
463 | } |
464 | ||
465 | return 0; | |
466 | } | |
467 | ||
eb1aac4c | 468 | |
bc774b8c WNH |
469 | static const struct hid_device_id hammer_devices[] = { |
470 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, | |
471 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) }, | |
472 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, | |
473 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) }, | |
474 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, | |
475 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) }, | |
3e84c765 NB |
476 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
477 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) }, | |
bc774b8c WNH |
478 | { } |
479 | }; | |
480 | MODULE_DEVICE_TABLE(hid, hammer_devices); | |
481 | ||
482 | static struct hid_driver hammer_driver = { | |
483 | .name = "hammer", | |
484 | .id_table = hammer_devices, | |
eb1aac4c DT |
485 | .probe = hammer_probe, |
486 | .input_mapping = hammer_input_mapping, | |
487 | .event = hammer_event, | |
bc774b8c | 488 | }; |
eb1aac4c DT |
489 | |
490 | static int __init hammer_init(void) | |
491 | { | |
492 | int error; | |
493 | ||
494 | error = platform_driver_register(&cbas_ec_driver); | |
495 | if (error) | |
496 | return error; | |
497 | ||
498 | error = hid_register_driver(&hammer_driver); | |
499 | if (error) { | |
500 | platform_driver_unregister(&cbas_ec_driver); | |
501 | return error; | |
502 | } | |
503 | ||
504 | return 0; | |
505 | } | |
506 | module_init(hammer_init); | |
507 | ||
508 | static void __exit hammer_exit(void) | |
509 | { | |
510 | hid_unregister_driver(&hammer_driver); | |
511 | platform_driver_unregister(&cbas_ec_driver); | |
512 | } | |
513 | module_exit(hammer_exit); | |
bc774b8c WNH |
514 | |
515 | MODULE_LICENSE("GPL"); |