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> | |
19 | #include <linux/module.h> | |
8dcaa046 | 20 | #include <linux/of.h> |
840d9f13 EBS |
21 | #include <linux/platform_data/cros_ec_commands.h> |
22 | #include <linux/platform_data/cros_ec_proto.h> | |
eb1aac4c DT |
23 | #include <linux/platform_device.h> |
24 | #include <linux/pm_wakeup.h> | |
25 | #include <asm/unaligned.h> | |
bc774b8c WNH |
26 | |
27 | #include "hid-ids.h" | |
28 | ||
eb1aac4c DT |
29 | /* |
30 | * C(hrome)B(ase)A(ttached)S(witch) - switch exported by Chrome EC and reporting | |
31 | * state of the "Whiskers" base - attached or detached. Whiskers USB device also | |
32 | * reports position of the keyboard - folded or not. Combining base state and | |
33 | * position allows us to generate proper "Tablet mode" events. | |
34 | */ | |
35 | struct cbas_ec { | |
36 | struct device *dev; /* The platform device (EC) */ | |
37 | struct input_dev *input; | |
38 | bool base_present; | |
38e57f06 | 39 | bool base_folded; |
eb1aac4c DT |
40 | struct notifier_block notifier; |
41 | }; | |
bc774b8c | 42 | |
eb1aac4c DT |
43 | static struct cbas_ec cbas_ec; |
44 | static DEFINE_SPINLOCK(cbas_ec_lock); | |
45 | static DEFINE_MUTEX(cbas_ec_reglock); | |
46 | ||
47 | static bool cbas_parse_base_state(const void *data) | |
48 | { | |
49 | u32 switches = get_unaligned_le32(data); | |
50 | ||
51 | return !!(switches & BIT(EC_MKBP_BASE_ATTACHED)); | |
52 | } | |
53 | ||
54 | static int cbas_ec_query_base(struct cros_ec_device *ec_dev, bool get_state, | |
55 | bool *state) | |
56 | { | |
57 | struct ec_params_mkbp_info *params; | |
58 | struct cros_ec_command *msg; | |
59 | int ret; | |
60 | ||
61 | msg = kzalloc(sizeof(*msg) + max(sizeof(u32), sizeof(*params)), | |
62 | GFP_KERNEL); | |
63 | if (!msg) | |
64 | return -ENOMEM; | |
65 | ||
66 | msg->command = EC_CMD_MKBP_INFO; | |
67 | msg->version = 1; | |
68 | msg->outsize = sizeof(*params); | |
69 | msg->insize = sizeof(u32); | |
70 | params = (struct ec_params_mkbp_info *)msg->data; | |
71 | params->info_type = get_state ? | |
72 | EC_MKBP_INFO_CURRENT : EC_MKBP_INFO_SUPPORTED; | |
73 | params->event_type = EC_MKBP_EVENT_SWITCH; | |
74 | ||
75 | ret = cros_ec_cmd_xfer_status(ec_dev, msg); | |
76 | if (ret >= 0) { | |
77 | if (ret != sizeof(u32)) { | |
78 | dev_warn(ec_dev->dev, "wrong result size: %d != %zu\n", | |
79 | ret, sizeof(u32)); | |
80 | ret = -EPROTO; | |
81 | } else { | |
82 | *state = cbas_parse_base_state(msg->data); | |
83 | ret = 0; | |
84 | } | |
85 | } | |
86 | ||
87 | kfree(msg); | |
88 | ||
89 | return ret; | |
90 | } | |
91 | ||
92 | static int cbas_ec_notify(struct notifier_block *nb, | |
93 | unsigned long queued_during_suspend, | |
94 | void *_notify) | |
95 | { | |
96 | struct cros_ec_device *ec = _notify; | |
97 | unsigned long flags; | |
98 | bool base_present; | |
99 | ||
100 | if (ec->event_data.event_type == EC_MKBP_EVENT_SWITCH) { | |
101 | base_present = cbas_parse_base_state( | |
102 | &ec->event_data.data.switches); | |
103 | dev_dbg(cbas_ec.dev, | |
104 | "%s: base: %d\n", __func__, base_present); | |
105 | ||
106 | if (device_may_wakeup(cbas_ec.dev) || | |
107 | !queued_during_suspend) { | |
108 | ||
109 | pm_wakeup_event(cbas_ec.dev, 0); | |
110 | ||
111 | spin_lock_irqsave(&cbas_ec_lock, flags); | |
112 | ||
113 | /* | |
114 | * While input layer dedupes the events, we do not want | |
115 | * to disrupt the state reported by the base by | |
116 | * overriding it with state reported by the LID. Only | |
117 | * report changes, as we assume that on attach the base | |
118 | * is not folded. | |
119 | */ | |
120 | if (base_present != cbas_ec.base_present) { | |
121 | input_report_switch(cbas_ec.input, | |
122 | SW_TABLET_MODE, | |
123 | !base_present); | |
124 | input_sync(cbas_ec.input); | |
125 | cbas_ec.base_present = base_present; | |
126 | } | |
127 | ||
128 | spin_unlock_irqrestore(&cbas_ec_lock, flags); | |
129 | } | |
130 | } | |
131 | ||
132 | return NOTIFY_OK; | |
133 | } | |
134 | ||
135 | static __maybe_unused int cbas_ec_resume(struct device *dev) | |
136 | { | |
137 | struct cros_ec_device *ec = dev_get_drvdata(dev->parent); | |
138 | bool base_present; | |
139 | int error; | |
140 | ||
141 | error = cbas_ec_query_base(ec, true, &base_present); | |
142 | if (error) { | |
143 | dev_warn(dev, "failed to fetch base state on resume: %d\n", | |
144 | error); | |
145 | } else { | |
146 | spin_lock_irq(&cbas_ec_lock); | |
147 | ||
148 | cbas_ec.base_present = base_present; | |
149 | ||
150 | /* | |
151 | * Only report if base is disconnected. If base is connected, | |
152 | * it will resend its state on resume, and we'll update it | |
153 | * in hammer_event(). | |
154 | */ | |
155 | if (!cbas_ec.base_present) { | |
156 | input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1); | |
157 | input_sync(cbas_ec.input); | |
158 | } | |
159 | ||
160 | spin_unlock_irq(&cbas_ec_lock); | |
161 | } | |
162 | ||
163 | return 0; | |
164 | } | |
165 | ||
8f35260e | 166 | static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume); |
eb1aac4c DT |
167 | |
168 | static void cbas_ec_set_input(struct input_dev *input) | |
169 | { | |
170 | /* Take the lock so hammer_event() does not race with us here */ | |
171 | spin_lock_irq(&cbas_ec_lock); | |
172 | cbas_ec.input = input; | |
173 | spin_unlock_irq(&cbas_ec_lock); | |
174 | } | |
175 | ||
176 | static int __cbas_ec_probe(struct platform_device *pdev) | |
177 | { | |
178 | struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); | |
179 | struct input_dev *input; | |
180 | bool base_supported; | |
181 | int error; | |
182 | ||
183 | error = cbas_ec_query_base(ec, false, &base_supported); | |
184 | if (error) | |
185 | return error; | |
186 | ||
187 | if (!base_supported) | |
188 | return -ENXIO; | |
189 | ||
190 | input = devm_input_allocate_device(&pdev->dev); | |
191 | if (!input) | |
192 | return -ENOMEM; | |
193 | ||
194 | input->name = "Whiskers Tablet Mode Switch"; | |
195 | input->id.bustype = BUS_HOST; | |
196 | ||
197 | input_set_capability(input, EV_SW, SW_TABLET_MODE); | |
198 | ||
199 | error = input_register_device(input); | |
200 | if (error) { | |
201 | dev_err(&pdev->dev, "cannot register input device: %d\n", | |
202 | error); | |
203 | return error; | |
204 | } | |
205 | ||
206 | /* Seed the state */ | |
207 | error = cbas_ec_query_base(ec, true, &cbas_ec.base_present); | |
208 | if (error) { | |
209 | dev_err(&pdev->dev, "cannot query base state: %d\n", error); | |
210 | return error; | |
211 | } | |
212 | ||
38e57f06 DT |
213 | if (!cbas_ec.base_present) |
214 | cbas_ec.base_folded = false; | |
215 | ||
216 | dev_dbg(&pdev->dev, "%s: base: %d, folded: %d\n", __func__, | |
217 | cbas_ec.base_present, cbas_ec.base_folded); | |
218 | ||
219 | input_report_switch(input, SW_TABLET_MODE, | |
220 | !cbas_ec.base_present || cbas_ec.base_folded); | |
eb1aac4c DT |
221 | |
222 | cbas_ec_set_input(input); | |
223 | ||
224 | cbas_ec.dev = &pdev->dev; | |
225 | cbas_ec.notifier.notifier_call = cbas_ec_notify; | |
226 | error = blocking_notifier_chain_register(&ec->event_notifier, | |
227 | &cbas_ec.notifier); | |
228 | if (error) { | |
229 | dev_err(&pdev->dev, "cannot register notifier: %d\n", error); | |
230 | cbas_ec_set_input(NULL); | |
231 | return error; | |
232 | } | |
233 | ||
234 | device_init_wakeup(&pdev->dev, true); | |
235 | return 0; | |
236 | } | |
237 | ||
238 | static int cbas_ec_probe(struct platform_device *pdev) | |
239 | { | |
240 | int retval; | |
241 | ||
242 | mutex_lock(&cbas_ec_reglock); | |
243 | ||
244 | if (cbas_ec.input) { | |
245 | retval = -EBUSY; | |
246 | goto out; | |
247 | } | |
248 | ||
249 | retval = __cbas_ec_probe(pdev); | |
250 | ||
251 | out: | |
252 | mutex_unlock(&cbas_ec_reglock); | |
253 | return retval; | |
254 | } | |
255 | ||
256 | static int cbas_ec_remove(struct platform_device *pdev) | |
257 | { | |
258 | struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); | |
259 | ||
260 | mutex_lock(&cbas_ec_reglock); | |
261 | ||
262 | blocking_notifier_chain_unregister(&ec->event_notifier, | |
263 | &cbas_ec.notifier); | |
264 | cbas_ec_set_input(NULL); | |
265 | ||
266 | mutex_unlock(&cbas_ec_reglock); | |
267 | return 0; | |
268 | } | |
269 | ||
270 | static const struct acpi_device_id cbas_ec_acpi_ids[] = { | |
271 | { "GOOG000B", 0 }, | |
272 | { } | |
273 | }; | |
274 | MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids); | |
275 | ||
8dcaa046 IJ |
276 | #ifdef CONFIG_OF |
277 | static const struct of_device_id cbas_ec_of_match[] = { | |
278 | { .compatible = "google,cros-cbas" }, | |
279 | { }, | |
280 | }; | |
281 | MODULE_DEVICE_TABLE(of, cbas_ec_of_match); | |
282 | #endif | |
283 | ||
eb1aac4c DT |
284 | static struct platform_driver cbas_ec_driver = { |
285 | .probe = cbas_ec_probe, | |
286 | .remove = cbas_ec_remove, | |
287 | .driver = { | |
288 | .name = "cbas_ec", | |
289 | .acpi_match_table = ACPI_PTR(cbas_ec_acpi_ids), | |
8dcaa046 | 290 | .of_match_table = of_match_ptr(cbas_ec_of_match), |
eb1aac4c DT |
291 | .pm = &cbas_ec_pm_ops, |
292 | }, | |
293 | }; | |
294 | ||
295 | #define MAX_BRIGHTNESS 100 | |
bc774b8c WNH |
296 | |
297 | struct hammer_kbd_leds { | |
298 | struct led_classdev cdev; | |
299 | struct hid_device *hdev; | |
300 | u8 buf[2] ____cacheline_aligned; | |
301 | }; | |
302 | ||
303 | static int hammer_kbd_brightness_set_blocking(struct led_classdev *cdev, | |
304 | enum led_brightness br) | |
305 | { | |
306 | struct hammer_kbd_leds *led = container_of(cdev, | |
307 | struct hammer_kbd_leds, | |
308 | cdev); | |
309 | int ret; | |
310 | ||
311 | led->buf[0] = 0; | |
312 | led->buf[1] = br; | |
313 | ||
7d3d8840 HK |
314 | /* |
315 | * Request USB HID device to be in Full On mode, so that sending | |
316 | * hardware output report and hardware raw request won't fail. | |
317 | */ | |
318 | ret = hid_hw_power(led->hdev, PM_HINT_FULLON); | |
319 | if (ret < 0) { | |
320 | hid_err(led->hdev, "failed: device not resumed %d\n", ret); | |
321 | return ret; | |
322 | } | |
323 | ||
bc774b8c WNH |
324 | ret = hid_hw_output_report(led->hdev, led->buf, sizeof(led->buf)); |
325 | if (ret == -ENOSYS) | |
326 | ret = hid_hw_raw_request(led->hdev, 0, led->buf, | |
327 | sizeof(led->buf), | |
328 | HID_OUTPUT_REPORT, | |
329 | HID_REQ_SET_REPORT); | |
330 | if (ret < 0) | |
331 | hid_err(led->hdev, "failed to set keyboard backlight: %d\n", | |
332 | ret); | |
7d3d8840 HK |
333 | |
334 | /* Request USB HID device back to Normal Mode. */ | |
335 | hid_hw_power(led->hdev, PM_HINT_NORMAL); | |
336 | ||
bc774b8c WNH |
337 | return ret; |
338 | } | |
339 | ||
340 | static int hammer_register_leds(struct hid_device *hdev) | |
341 | { | |
342 | struct hammer_kbd_leds *kbd_backlight; | |
38e57f06 | 343 | int error; |
bc774b8c | 344 | |
38e57f06 | 345 | kbd_backlight = kzalloc(sizeof(*kbd_backlight), GFP_KERNEL); |
bc774b8c WNH |
346 | if (!kbd_backlight) |
347 | return -ENOMEM; | |
348 | ||
349 | kbd_backlight->hdev = hdev; | |
350 | kbd_backlight->cdev.name = "hammer::kbd_backlight"; | |
351 | kbd_backlight->cdev.max_brightness = MAX_BRIGHTNESS; | |
352 | kbd_backlight->cdev.brightness_set_blocking = | |
353 | hammer_kbd_brightness_set_blocking; | |
354 | kbd_backlight->cdev.flags = LED_HW_PLUGGABLE; | |
355 | ||
356 | /* Set backlight to 0% initially. */ | |
357 | hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0); | |
358 | ||
38e57f06 DT |
359 | error = led_classdev_register(&hdev->dev, &kbd_backlight->cdev); |
360 | if (error) | |
361 | goto err_free_mem; | |
362 | ||
363 | hid_set_drvdata(hdev, kbd_backlight); | |
364 | return 0; | |
365 | ||
366 | err_free_mem: | |
367 | kfree(kbd_backlight); | |
368 | return error; | |
369 | } | |
370 | ||
371 | static void hammer_unregister_leds(struct hid_device *hdev) | |
372 | { | |
373 | struct hammer_kbd_leds *kbd_backlight = hid_get_drvdata(hdev); | |
374 | ||
375 | if (kbd_backlight) { | |
376 | led_classdev_unregister(&kbd_backlight->cdev); | |
377 | kfree(kbd_backlight); | |
378 | } | |
bc774b8c WNH |
379 | } |
380 | ||
eb1aac4c DT |
381 | #define HID_UP_GOOGLEVENDOR 0xffd10000 |
382 | #define HID_VD_KBD_FOLDED 0x00000019 | |
20c55f25 | 383 | #define HID_USAGE_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED) |
eb1aac4c DT |
384 | |
385 | /* HID usage for keyboard backlight (Alphanumeric display brightness) */ | |
386 | #define HID_AD_BRIGHTNESS 0x00140046 | |
387 | ||
388 | static int hammer_input_mapping(struct hid_device *hdev, struct hid_input *hi, | |
389 | struct hid_field *field, | |
390 | struct hid_usage *usage, | |
391 | unsigned long **bit, int *max) | |
bc774b8c | 392 | { |
20c55f25 | 393 | if (usage->hid == HID_USAGE_KBD_FOLDED) { |
eb1aac4c DT |
394 | /* |
395 | * We do not want to have this usage mapped as it will get | |
396 | * mixed in with "base attached" signal and delivered over | |
397 | * separate input device for tablet switch mode. | |
398 | */ | |
399 | return -1; | |
400 | } | |
401 | ||
402 | return 0; | |
403 | } | |
404 | ||
df7b6229 | 405 | static void hammer_folded_event(struct hid_device *hdev, bool folded) |
eb1aac4c DT |
406 | { |
407 | unsigned long flags; | |
408 | ||
df7b6229 | 409 | spin_lock_irqsave(&cbas_ec_lock, flags); |
eb1aac4c | 410 | |
df7b6229 NB |
411 | /* |
412 | * If we are getting events from Whiskers that means that it | |
413 | * is attached to the lid. | |
414 | */ | |
415 | cbas_ec.base_present = true; | |
416 | cbas_ec.base_folded = folded; | |
417 | hid_dbg(hdev, "%s: base: %d, folded: %d\n", __func__, | |
418 | cbas_ec.base_present, cbas_ec.base_folded); | |
eb1aac4c | 419 | |
df7b6229 NB |
420 | if (cbas_ec.input) { |
421 | input_report_switch(cbas_ec.input, SW_TABLET_MODE, folded); | |
422 | input_sync(cbas_ec.input); | |
423 | } | |
424 | ||
425 | spin_unlock_irqrestore(&cbas_ec_lock, flags); | |
426 | } | |
427 | ||
428 | static int hammer_event(struct hid_device *hid, struct hid_field *field, | |
429 | struct hid_usage *usage, __s32 value) | |
430 | { | |
431 | if (usage->hid == HID_USAGE_KBD_FOLDED) { | |
432 | hammer_folded_event(hid, value); | |
eb1aac4c DT |
433 | return 1; /* We handled this event */ |
434 | } | |
435 | ||
436 | return 0; | |
437 | } | |
438 | ||
20c55f25 NB |
439 | static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type, |
440 | unsigned application, unsigned usage) | |
eb1aac4c | 441 | { |
20c55f25 | 442 | struct hid_report_enum *re = &hdev->report_enum[report_type]; |
eb1aac4c DT |
443 | struct hid_report *report; |
444 | int i, j; | |
bc774b8c | 445 | |
eb1aac4c | 446 | list_for_each_entry(report, &re->report_list, list) { |
20c55f25 | 447 | if (report->application != application) |
eb1aac4c | 448 | continue; |
bc774b8c | 449 | |
eb1aac4c DT |
450 | for (i = 0; i < report->maxfield; i++) { |
451 | struct hid_field *field = report->field[i]; | |
452 | ||
453 | for (j = 0; j < field->maxusage; j++) | |
20c55f25 | 454 | if (field->usage[j].hid == usage) |
eb1aac4c DT |
455 | return true; |
456 | } | |
457 | } | |
458 | ||
459 | return false; | |
460 | } | |
461 | ||
20c55f25 NB |
462 | static bool hammer_has_folded_event(struct hid_device *hdev) |
463 | { | |
464 | return hammer_has_usage(hdev, HID_INPUT_REPORT, | |
465 | HID_GD_KEYBOARD, HID_USAGE_KBD_FOLDED); | |
466 | } | |
467 | ||
468 | static bool hammer_has_backlight_control(struct hid_device *hdev) | |
469 | { | |
470 | return hammer_has_usage(hdev, HID_OUTPUT_REPORT, | |
471 | HID_GD_KEYBOARD, HID_AD_BRIGHTNESS); | |
472 | } | |
473 | ||
df7b6229 NB |
474 | static void hammer_get_folded_state(struct hid_device *hdev) |
475 | { | |
476 | struct hid_report *report; | |
477 | char *buf; | |
478 | int len, rlen; | |
479 | int a; | |
480 | ||
481 | report = hdev->report_enum[HID_INPUT_REPORT].report_id_hash[0x0]; | |
482 | ||
483 | if (!report || report->maxfield < 1) | |
484 | return; | |
485 | ||
486 | len = hid_report_len(report) + 1; | |
487 | ||
488 | buf = kmalloc(len, GFP_KERNEL); | |
489 | if (!buf) | |
490 | return; | |
491 | ||
492 | rlen = hid_hw_raw_request(hdev, report->id, buf, len, report->type, HID_REQ_GET_REPORT); | |
493 | ||
494 | if (rlen != len) { | |
495 | hid_warn(hdev, "Unable to read base folded state: %d (expected %d)\n", rlen, len); | |
496 | goto out; | |
497 | } | |
498 | ||
499 | for (a = 0; a < report->maxfield; a++) { | |
500 | struct hid_field *field = report->field[a]; | |
501 | ||
502 | if (field->usage->hid == HID_USAGE_KBD_FOLDED) { | |
503 | u32 value = hid_field_extract(hdev, buf+1, | |
504 | field->report_offset, field->report_size); | |
505 | ||
506 | hammer_folded_event(hdev, value); | |
507 | break; | |
508 | } | |
509 | } | |
510 | ||
511 | out: | |
512 | kfree(buf); | |
513 | } | |
514 | ||
eb1aac4c DT |
515 | static int hammer_probe(struct hid_device *hdev, |
516 | const struct hid_device_id *id) | |
517 | { | |
518 | int error; | |
519 | ||
eb1aac4c DT |
520 | error = hid_parse(hdev); |
521 | if (error) | |
522 | return error; | |
523 | ||
524 | error = hid_hw_start(hdev, HID_CONNECT_DEFAULT); | |
525 | if (error) | |
526 | return error; | |
527 | ||
eb1aac4c DT |
528 | /* |
529 | * We always want to poll for, and handle tablet mode events from | |
20c55f25 NB |
530 | * devices that have folded usage, even when nobody has opened the input |
531 | * device. This also prevents the hid core from dropping early tablet | |
532 | * mode events from the device. | |
eb1aac4c | 533 | */ |
20c55f25 | 534 | if (hammer_has_folded_event(hdev)) { |
eb1aac4c | 535 | hdev->quirks |= HID_QUIRK_ALWAYS_POLL; |
38e57f06 DT |
536 | error = hid_hw_open(hdev); |
537 | if (error) | |
538 | return error; | |
df7b6229 NB |
539 | |
540 | hammer_get_folded_state(hdev); | |
38e57f06 | 541 | } |
eb1aac4c DT |
542 | |
543 | if (hammer_has_backlight_control(hdev)) { | |
544 | error = hammer_register_leds(hdev); | |
545 | if (error) | |
bc774b8c WNH |
546 | hid_warn(hdev, |
547 | "Failed to register keyboard backlight: %d\n", | |
eb1aac4c | 548 | error); |
bc774b8c WNH |
549 | } |
550 | ||
551 | return 0; | |
552 | } | |
553 | ||
38e57f06 DT |
554 | static void hammer_remove(struct hid_device *hdev) |
555 | { | |
79085c7d DT |
556 | unsigned long flags; |
557 | ||
20c55f25 | 558 | if (hammer_has_folded_event(hdev)) { |
38e57f06 DT |
559 | hid_hw_close(hdev); |
560 | ||
79085c7d DT |
561 | /* |
562 | * If we are disconnecting then most likely Whiskers is | |
563 | * being removed. Even if it is not removed, without proper | |
564 | * keyboard we should not stay in clamshell mode. | |
565 | * | |
566 | * The reason for doing it here and not waiting for signal | |
567 | * from EC, is that on some devices there are high leakage | |
568 | * on Whiskers pins and we do not detect disconnect reliably, | |
569 | * resulting in devices being stuck in clamshell mode. | |
570 | */ | |
571 | spin_lock_irqsave(&cbas_ec_lock, flags); | |
572 | if (cbas_ec.input && cbas_ec.base_present) { | |
573 | input_report_switch(cbas_ec.input, SW_TABLET_MODE, 1); | |
574 | input_sync(cbas_ec.input); | |
575 | } | |
576 | cbas_ec.base_present = false; | |
577 | spin_unlock_irqrestore(&cbas_ec_lock, flags); | |
578 | } | |
579 | ||
38e57f06 | 580 | hammer_unregister_leds(hdev); |
79085c7d | 581 | |
38e57f06 DT |
582 | hid_hw_stop(hdev); |
583 | } | |
eb1aac4c | 584 | |
bc774b8c | 585 | static const struct hid_device_id hammer_devices[] = { |
36b87cf3 SCH |
586 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
587 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) }, | |
bc774b8c WNH |
588 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
589 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) }, | |
9e4dbc46 NB |
590 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
591 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MAGNEMITE) }, | |
592 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, | |
593 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MASTERBALL) }, | |
58322a15 CTH |
594 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
595 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) }, | |
bc774b8c WNH |
596 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
597 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_STAFF) }, | |
598 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, | |
599 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WAND) }, | |
3e84c765 NB |
600 | { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, |
601 | USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) }, | |
bc774b8c WNH |
602 | { } |
603 | }; | |
604 | MODULE_DEVICE_TABLE(hid, hammer_devices); | |
605 | ||
606 | static struct hid_driver hammer_driver = { | |
607 | .name = "hammer", | |
608 | .id_table = hammer_devices, | |
eb1aac4c | 609 | .probe = hammer_probe, |
38e57f06 | 610 | .remove = hammer_remove, |
eb1aac4c DT |
611 | .input_mapping = hammer_input_mapping, |
612 | .event = hammer_event, | |
bc774b8c | 613 | }; |
eb1aac4c DT |
614 | |
615 | static int __init hammer_init(void) | |
616 | { | |
617 | int error; | |
618 | ||
619 | error = platform_driver_register(&cbas_ec_driver); | |
620 | if (error) | |
621 | return error; | |
622 | ||
623 | error = hid_register_driver(&hammer_driver); | |
624 | if (error) { | |
625 | platform_driver_unregister(&cbas_ec_driver); | |
626 | return error; | |
627 | } | |
628 | ||
629 | return 0; | |
630 | } | |
631 | module_init(hammer_init); | |
632 | ||
633 | static void __exit hammer_exit(void) | |
634 | { | |
635 | hid_unregister_driver(&hammer_driver); | |
636 | platform_driver_unregister(&cbas_ec_driver); | |
637 | } | |
638 | module_exit(hammer_exit); | |
bc774b8c WNH |
639 | |
640 | MODULE_LICENSE("GPL"); |