1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16#include <linux/acpi.h>
17#include <linux/hid.h>
18#include <linux/leds.h>
19#include <linux/module.h>
20#include <linux/of.h>
21#include <linux/platform_data/cros_ec_commands.h>
22#include <linux/platform_data/cros_ec_proto.h>
23#include <linux/platform_device.h>
24#include <linux/pm_wakeup.h>
25#include <asm/unaligned.h>
26
27#include "hid-ids.h"
28
29
30
31
32
33
34
35struct cbas_ec {
36 struct device *dev;
37 struct input_dev *input;
38 bool base_present;
39 bool base_folded;
40 struct notifier_block notifier;
41};
42
43static struct cbas_ec cbas_ec;
44static DEFINE_SPINLOCK(cbas_ec_lock);
45static DEFINE_MUTEX(cbas_ec_reglock);
46
47static 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
54static 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
92static 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
115
116
117
118
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
135static __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
152
153
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
166static SIMPLE_DEV_PM_OPS(cbas_ec_pm_ops, NULL, cbas_ec_resume);
167
168static void cbas_ec_set_input(struct input_dev *input)
169{
170
171 spin_lock_irq(&cbas_ec_lock);
172 cbas_ec.input = input;
173 spin_unlock_irq(&cbas_ec_lock);
174}
175
176static 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
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
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);
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
238static 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
251out:
252 mutex_unlock(&cbas_ec_reglock);
253 return retval;
254}
255
256static 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
270static const struct acpi_device_id cbas_ec_acpi_ids[] = {
271 { "GOOG000B", 0 },
272 { }
273};
274MODULE_DEVICE_TABLE(acpi, cbas_ec_acpi_ids);
275
276#ifdef CONFIG_OF
277static const struct of_device_id cbas_ec_of_match[] = {
278 { .compatible = "google,cros-cbas" },
279 { },
280};
281MODULE_DEVICE_TABLE(of, cbas_ec_of_match);
282#endif
283
284static 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),
290 .of_match_table = of_match_ptr(cbas_ec_of_match),
291 .pm = &cbas_ec_pm_ops,
292 },
293};
294
295#define MAX_BRIGHTNESS 100
296
297struct hammer_kbd_leds {
298 struct led_classdev cdev;
299 struct hid_device *hdev;
300 u8 buf[2] ____cacheline_aligned;
301};
302
303static 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
314
315
316
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
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);
333
334
335 hid_hw_power(led->hdev, PM_HINT_NORMAL);
336
337 return ret;
338}
339
340static int hammer_register_leds(struct hid_device *hdev)
341{
342 struct hammer_kbd_leds *kbd_backlight;
343 int error;
344
345 kbd_backlight = kzalloc(sizeof(*kbd_backlight), GFP_KERNEL);
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
357 hammer_kbd_brightness_set_blocking(&kbd_backlight->cdev, 0);
358
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
366err_free_mem:
367 kfree(kbd_backlight);
368 return error;
369}
370
371static 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 }
379}
380
381#define HID_UP_GOOGLEVENDOR 0xffd10000
382#define HID_VD_KBD_FOLDED 0x00000019
383#define HID_USAGE_KBD_FOLDED (HID_UP_GOOGLEVENDOR | HID_VD_KBD_FOLDED)
384
385
386#define HID_AD_BRIGHTNESS 0x00140046
387
388static 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)
392{
393 if (usage->hid == HID_USAGE_KBD_FOLDED) {
394
395
396
397
398
399 return -1;
400 }
401
402 return 0;
403}
404
405static void hammer_folded_event(struct hid_device *hdev, bool folded)
406{
407 unsigned long flags;
408
409 spin_lock_irqsave(&cbas_ec_lock, flags);
410
411
412
413
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);
419
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
428static 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);
433 return 1;
434 }
435
436 return 0;
437}
438
439static bool hammer_has_usage(struct hid_device *hdev, unsigned int report_type,
440 unsigned application, unsigned usage)
441{
442 struct hid_report_enum *re = &hdev->report_enum[report_type];
443 struct hid_report *report;
444 int i, j;
445
446 list_for_each_entry(report, &re->report_list, list) {
447 if (report->application != application)
448 continue;
449
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++)
454 if (field->usage[j].hid == usage)
455 return true;
456 }
457 }
458
459 return false;
460}
461
462static 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
468static 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
474static 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
511out:
512 kfree(buf);
513}
514
515static int hammer_probe(struct hid_device *hdev,
516 const struct hid_device_id *id)
517{
518 int error;
519
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
528
529
530
531
532
533
534 if (hammer_has_folded_event(hdev)) {
535 hdev->quirks |= HID_QUIRK_ALWAYS_POLL;
536 error = hid_hw_open(hdev);
537 if (error)
538 return error;
539
540 hammer_get_folded_state(hdev);
541 }
542
543 if (hammer_has_backlight_control(hdev)) {
544 error = hammer_register_leds(hdev);
545 if (error)
546 hid_warn(hdev,
547 "Failed to register keyboard backlight: %d\n",
548 error);
549 }
550
551 return 0;
552}
553
554static void hammer_remove(struct hid_device *hdev)
555{
556 unsigned long flags;
557
558 if (hammer_has_folded_event(hdev)) {
559 hid_hw_close(hdev);
560
561
562
563
564
565
566
567
568
569
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
580 hammer_unregister_leds(hdev);
581
582 hid_hw_stop(hdev);
583}
584
585static const struct hid_device_id hammer_devices[] = {
586 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
587 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },
588 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
589 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
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) },
594 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
595 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_MOONBALL) },
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) },
600 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
601 USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_WHISKERS) },
602 { }
603};
604MODULE_DEVICE_TABLE(hid, hammer_devices);
605
606static struct hid_driver hammer_driver = {
607 .name = "hammer",
608 .id_table = hammer_devices,
609 .probe = hammer_probe,
610 .remove = hammer_remove,
611 .input_mapping = hammer_input_mapping,
612 .event = hammer_event,
613};
614
615static 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}
631module_init(hammer_init);
632
633static void __exit hammer_exit(void)
634{
635 hid_unregister_driver(&hammer_driver);
636 platform_driver_unregister(&cbas_ec_driver);
637}
638module_exit(hammer_exit);
639
640MODULE_LICENSE("GPL");
641