1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/module.h>
15#include <linux/bitops.h>
16#include <linux/i2c.h>
17#include <linux/input.h>
18#include <linux/interrupt.h>
19#include <linux/kernel.h>
20#include <linux/notifier.h>
21#include <linux/platform_device.h>
22#include <linux/slab.h>
23#include <linux/sysrq.h>
24#include <linux/input/matrix_keypad.h>
25#include <linux/platform_data/cros_ec_commands.h>
26#include <linux/platform_data/cros_ec_proto.h>
27
28#include <asm/unaligned.h>
29
30#define MAX_NUM_TOP_ROW_KEYS 15
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51struct cros_ec_keyb {
52 unsigned int rows;
53 unsigned int cols;
54 int row_shift;
55 const struct matrix_keymap_data *keymap_data;
56 bool ghost_filter;
57 uint8_t *valid_keys;
58 uint8_t *old_kb_state;
59
60 struct device *dev;
61 struct cros_ec_device *ec;
62
63 struct input_dev *idev;
64 struct input_dev *bs_idev;
65 struct notifier_block notifier;
66
67 u16 function_row_physmap[MAX_NUM_TOP_ROW_KEYS];
68 size_t num_function_row_keys;
69};
70
71
72
73
74
75
76
77
78
79
80
81struct cros_ec_bs_map {
82 unsigned int ev_type;
83 unsigned int code;
84 u8 bit;
85 bool inverted;
86};
87
88
89static const struct cros_ec_bs_map cros_ec_keyb_bs[] = {
90
91 {
92 .ev_type = EV_KEY,
93 .code = KEY_POWER,
94 .bit = EC_MKBP_POWER_BUTTON,
95 },
96 {
97 .ev_type = EV_KEY,
98 .code = KEY_VOLUMEUP,
99 .bit = EC_MKBP_VOL_UP,
100 },
101 {
102 .ev_type = EV_KEY,
103 .code = KEY_VOLUMEDOWN,
104 .bit = EC_MKBP_VOL_DOWN,
105 },
106
107
108 {
109 .ev_type = EV_SW,
110 .code = SW_LID,
111 .bit = EC_MKBP_LID_OPEN,
112 .inverted = true,
113 },
114 {
115 .ev_type = EV_SW,
116 .code = SW_TABLET_MODE,
117 .bit = EC_MKBP_TABLET_MODE,
118 },
119};
120
121
122
123
124
125static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb *ckdev, uint8_t *buf)
126{
127 int col1, col2, buf1, buf2;
128 struct device *dev = ckdev->dev;
129 uint8_t *valid_keys = ckdev->valid_keys;
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144 for (col1 = 0; col1 < ckdev->cols; col1++) {
145 buf1 = buf[col1] & valid_keys[col1];
146 for (col2 = col1 + 1; col2 < ckdev->cols; col2++) {
147 buf2 = buf[col2] & valid_keys[col2];
148 if (hweight8(buf1 & buf2) > 1) {
149 dev_dbg(dev, "ghost found at: B[%02d]:0x%02x & B[%02d]:0x%02x",
150 col1, buf1, col2, buf2);
151 return true;
152 }
153 }
154 }
155
156 return false;
157}
158
159
160
161
162
163
164
165static void cros_ec_keyb_process(struct cros_ec_keyb *ckdev,
166 uint8_t *kb_state, int len)
167{
168 struct input_dev *idev = ckdev->idev;
169 int col, row;
170 int new_state;
171 int old_state;
172
173 if (ckdev->ghost_filter && cros_ec_keyb_has_ghosting(ckdev, kb_state)) {
174
175
176
177
178
179 dev_dbg(ckdev->dev, "ghosting found\n");
180 return;
181 }
182
183 for (col = 0; col < ckdev->cols; col++) {
184 for (row = 0; row < ckdev->rows; row++) {
185 int pos = MATRIX_SCAN_CODE(row, col, ckdev->row_shift);
186 const unsigned short *keycodes = idev->keycode;
187
188 new_state = kb_state[col] & (1 << row);
189 old_state = ckdev->old_kb_state[col] & (1 << row);
190 if (new_state != old_state) {
191 dev_dbg(ckdev->dev,
192 "changed: [r%d c%d]: byte %02x\n",
193 row, col, new_state);
194
195 input_event(idev, EV_MSC, MSC_SCAN, pos);
196 input_report_key(idev, keycodes[pos],
197 new_state);
198 }
199 }
200 ckdev->old_kb_state[col] = kb_state[col];
201 }
202 input_sync(ckdev->idev);
203}
204
205
206
207
208
209
210
211
212
213
214
215static void cros_ec_keyb_report_bs(struct cros_ec_keyb *ckdev,
216 unsigned int ev_type, u32 mask)
217
218{
219 struct input_dev *idev = ckdev->bs_idev;
220 int i;
221
222 for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {
223 const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];
224
225 if (map->ev_type != ev_type)
226 continue;
227
228 input_event(idev, ev_type, map->code,
229 !!(mask & BIT(map->bit)) ^ map->inverted);
230 }
231 input_sync(idev);
232}
233
234static int cros_ec_keyb_work(struct notifier_block *nb,
235 unsigned long queued_during_suspend, void *_notify)
236{
237 struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb,
238 notifier);
239 u32 val;
240 unsigned int ev_type;
241
242
243
244
245
246
247 if (queued_during_suspend && !device_may_wakeup(ckdev->dev))
248 return NOTIFY_OK;
249
250 switch (ckdev->ec->event_data.event_type) {
251 case EC_MKBP_EVENT_KEY_MATRIX:
252 pm_wakeup_event(ckdev->dev, 0);
253
254 if (ckdev->ec->event_size != ckdev->cols) {
255 dev_err(ckdev->dev,
256 "Discarded incomplete key matrix event.\n");
257 return NOTIFY_OK;
258 }
259
260 cros_ec_keyb_process(ckdev,
261 ckdev->ec->event_data.data.key_matrix,
262 ckdev->ec->event_size);
263 break;
264
265 case EC_MKBP_EVENT_SYSRQ:
266 pm_wakeup_event(ckdev->dev, 0);
267
268 val = get_unaligned_le32(&ckdev->ec->event_data.data.sysrq);
269 dev_dbg(ckdev->dev, "sysrq code from EC: %#x\n", val);
270 handle_sysrq(val);
271 break;
272
273 case EC_MKBP_EVENT_BUTTON:
274 case EC_MKBP_EVENT_SWITCH:
275 pm_wakeup_event(ckdev->dev, 0);
276
277 if (ckdev->ec->event_data.event_type == EC_MKBP_EVENT_BUTTON) {
278 val = get_unaligned_le32(
279 &ckdev->ec->event_data.data.buttons);
280 ev_type = EV_KEY;
281 } else {
282 val = get_unaligned_le32(
283 &ckdev->ec->event_data.data.switches);
284 ev_type = EV_SW;
285 }
286 cros_ec_keyb_report_bs(ckdev, ev_type, val);
287 break;
288
289 default:
290 return NOTIFY_DONE;
291 }
292
293 return NOTIFY_OK;
294}
295
296
297
298
299
300static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb *ckdev)
301{
302 int row, col;
303 int row_shift = ckdev->row_shift;
304 unsigned short *keymap = ckdev->idev->keycode;
305 unsigned short code;
306
307 BUG_ON(ckdev->idev->keycodesize != sizeof(*keymap));
308
309 for (col = 0; col < ckdev->cols; col++) {
310 for (row = 0; row < ckdev->rows; row++) {
311 code = keymap[MATRIX_SCAN_CODE(row, col, row_shift)];
312 if (code && (code != KEY_BATTERY))
313 ckdev->valid_keys[col] |= 1 << row;
314 }
315 dev_dbg(ckdev->dev, "valid_keys[%02d] = 0x%02x\n",
316 col, ckdev->valid_keys[col]);
317 }
318}
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337static int cros_ec_keyb_info(struct cros_ec_device *ec_dev,
338 enum ec_mkbp_info_type info_type,
339 enum ec_mkbp_event event_type,
340 union ec_response_get_next_data *result,
341 size_t result_size)
342{
343 struct ec_params_mkbp_info *params;
344 struct cros_ec_command *msg;
345 int ret;
346
347 msg = kzalloc(sizeof(*msg) + max_t(size_t, result_size,
348 sizeof(*params)), GFP_KERNEL);
349 if (!msg)
350 return -ENOMEM;
351
352 msg->command = EC_CMD_MKBP_INFO;
353 msg->version = 1;
354 msg->outsize = sizeof(*params);
355 msg->insize = result_size;
356 params = (struct ec_params_mkbp_info *)msg->data;
357 params->info_type = info_type;
358 params->event_type = event_type;
359
360 ret = cros_ec_cmd_xfer_status(ec_dev, msg);
361 if (ret == -ENOPROTOOPT) {
362
363 memset(result, 0, result_size);
364 ret = 0;
365 } else if (ret < 0) {
366 dev_warn(ec_dev->dev, "Transfer error %d/%d: %d\n",
367 (int)info_type, (int)event_type, ret);
368 } else if (ret != result_size) {
369 dev_warn(ec_dev->dev, "Wrong size %d/%d: %d != %zu\n",
370 (int)info_type, (int)event_type,
371 ret, result_size);
372 ret = -EPROTO;
373 } else {
374 memcpy(result, msg->data, result_size);
375 ret = 0;
376 }
377
378 kfree(msg);
379
380 return ret;
381}
382
383
384
385
386
387
388
389
390
391
392
393
394static int cros_ec_keyb_query_switches(struct cros_ec_keyb *ckdev)
395{
396 struct cros_ec_device *ec_dev = ckdev->ec;
397 union ec_response_get_next_data event_data = {};
398 int ret;
399
400 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_CURRENT,
401 EC_MKBP_EVENT_SWITCH, &event_data,
402 sizeof(event_data.switches));
403 if (ret)
404 return ret;
405
406 cros_ec_keyb_report_bs(ckdev, EV_SW,
407 get_unaligned_le32(&event_data.switches));
408
409 return 0;
410}
411
412
413
414
415
416
417
418
419
420
421static __maybe_unused int cros_ec_keyb_resume(struct device *dev)
422{
423 struct cros_ec_keyb *ckdev = dev_get_drvdata(dev);
424
425 if (ckdev->bs_idev)
426 return cros_ec_keyb_query_switches(ckdev);
427
428 return 0;
429}
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445static int cros_ec_keyb_register_bs(struct cros_ec_keyb *ckdev)
446{
447 struct cros_ec_device *ec_dev = ckdev->ec;
448 struct device *dev = ckdev->dev;
449 struct input_dev *idev;
450 union ec_response_get_next_data event_data = {};
451 const char *phys;
452 u32 buttons;
453 u32 switches;
454 int ret;
455 int i;
456
457 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,
458 EC_MKBP_EVENT_BUTTON, &event_data,
459 sizeof(event_data.buttons));
460 if (ret)
461 return ret;
462 buttons = get_unaligned_le32(&event_data.buttons);
463
464 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED,
465 EC_MKBP_EVENT_SWITCH, &event_data,
466 sizeof(event_data.switches));
467 if (ret)
468 return ret;
469 switches = get_unaligned_le32(&event_data.switches);
470
471 if (!buttons && !switches)
472 return 0;
473
474
475
476
477
478
479 phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input1", ec_dev->phys_name);
480 if (!phys)
481 return -ENOMEM;
482
483 idev = devm_input_allocate_device(dev);
484 if (!idev)
485 return -ENOMEM;
486
487 idev->name = "cros_ec_buttons";
488 idev->phys = phys;
489 __set_bit(EV_REP, idev->evbit);
490
491 idev->id.bustype = BUS_VIRTUAL;
492 idev->id.version = 1;
493 idev->id.product = 0;
494 idev->dev.parent = dev;
495
496 input_set_drvdata(idev, ckdev);
497 ckdev->bs_idev = idev;
498
499 for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) {
500 const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i];
501
502 if ((map->ev_type == EV_KEY && (buttons & BIT(map->bit))) ||
503 (map->ev_type == EV_SW && (switches & BIT(map->bit))))
504 input_set_capability(idev, map->ev_type, map->code);
505 }
506
507 ret = cros_ec_keyb_query_switches(ckdev);
508 if (ret) {
509 dev_err(dev, "cannot query switches\n");
510 return ret;
511 }
512
513 ret = input_register_device(ckdev->bs_idev);
514 if (ret) {
515 dev_err(dev, "cannot register input device\n");
516 return ret;
517 }
518
519 return 0;
520}
521
522
523
524
525
526
527
528
529
530
531static int cros_ec_keyb_register_matrix(struct cros_ec_keyb *ckdev)
532{
533 struct cros_ec_device *ec_dev = ckdev->ec;
534 struct device *dev = ckdev->dev;
535 struct input_dev *idev;
536 const char *phys;
537 int err;
538 struct property *prop;
539 const __be32 *p;
540 u16 *physmap;
541 u32 key_pos;
542 int row, col;
543
544 err = matrix_keypad_parse_properties(dev, &ckdev->rows, &ckdev->cols);
545 if (err)
546 return err;
547
548 ckdev->valid_keys = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL);
549 if (!ckdev->valid_keys)
550 return -ENOMEM;
551
552 ckdev->old_kb_state = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL);
553 if (!ckdev->old_kb_state)
554 return -ENOMEM;
555
556
557
558
559
560 phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", ec_dev->phys_name);
561 if (!phys)
562 return -ENOMEM;
563
564 idev = devm_input_allocate_device(dev);
565 if (!idev)
566 return -ENOMEM;
567
568 idev->name = CROS_EC_DEV_NAME;
569 idev->phys = phys;
570 __set_bit(EV_REP, idev->evbit);
571
572 idev->id.bustype = BUS_VIRTUAL;
573 idev->id.version = 1;
574 idev->id.product = 0;
575 idev->dev.parent = dev;
576
577 ckdev->ghost_filter = of_property_read_bool(dev->of_node,
578 "google,needs-ghost-filter");
579
580 err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols,
581 NULL, idev);
582 if (err) {
583 dev_err(dev, "cannot build key matrix\n");
584 return err;
585 }
586
587 ckdev->row_shift = get_count_order(ckdev->cols);
588
589 input_set_capability(idev, EV_MSC, MSC_SCAN);
590 input_set_drvdata(idev, ckdev);
591 ckdev->idev = idev;
592 cros_ec_keyb_compute_valid_keys(ckdev);
593
594 physmap = ckdev->function_row_physmap;
595 of_property_for_each_u32(dev->of_node, "function-row-physmap",
596 prop, p, key_pos) {
597 if (ckdev->num_function_row_keys == MAX_NUM_TOP_ROW_KEYS) {
598 dev_warn(dev, "Only support up to %d top row keys\n",
599 MAX_NUM_TOP_ROW_KEYS);
600 break;
601 }
602 row = KEY_ROW(key_pos);
603 col = KEY_COL(key_pos);
604 *physmap = MATRIX_SCAN_CODE(row, col, ckdev->row_shift);
605 physmap++;
606 ckdev->num_function_row_keys++;
607 }
608
609 err = input_register_device(ckdev->idev);
610 if (err) {
611 dev_err(dev, "cannot register input device\n");
612 return err;
613 }
614
615 return 0;
616}
617
618static ssize_t function_row_physmap_show(struct device *dev,
619 struct device_attribute *attr,
620 char *buf)
621{
622 ssize_t size = 0;
623 int i;
624 struct cros_ec_keyb *ckdev = dev_get_drvdata(dev);
625 u16 *physmap = ckdev->function_row_physmap;
626
627 for (i = 0; i < ckdev->num_function_row_keys; i++)
628 size += scnprintf(buf + size, PAGE_SIZE - size,
629 "%s%02X", size ? " " : "", physmap[i]);
630 if (size)
631 size += scnprintf(buf + size, PAGE_SIZE - size, "\n");
632
633 return size;
634}
635
636static DEVICE_ATTR_RO(function_row_physmap);
637
638static struct attribute *cros_ec_keyb_attrs[] = {
639 &dev_attr_function_row_physmap.attr,
640 NULL,
641};
642
643static umode_t cros_ec_keyb_attr_is_visible(struct kobject *kobj,
644 struct attribute *attr,
645 int n)
646{
647 struct device *dev = kobj_to_dev(kobj);
648 struct cros_ec_keyb *ckdev = dev_get_drvdata(dev);
649
650 if (attr == &dev_attr_function_row_physmap.attr &&
651 !ckdev->num_function_row_keys)
652 return 0;
653
654 return attr->mode;
655}
656
657static const struct attribute_group cros_ec_keyb_attr_group = {
658 .is_visible = cros_ec_keyb_attr_is_visible,
659 .attrs = cros_ec_keyb_attrs,
660};
661
662
663static int cros_ec_keyb_probe(struct platform_device *pdev)
664{
665 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent);
666 struct device *dev = &pdev->dev;
667 struct cros_ec_keyb *ckdev;
668 int err;
669
670 if (!dev->of_node)
671 return -ENODEV;
672
673 ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL);
674 if (!ckdev)
675 return -ENOMEM;
676
677 ckdev->ec = ec;
678 ckdev->dev = dev;
679 dev_set_drvdata(dev, ckdev);
680
681 err = cros_ec_keyb_register_matrix(ckdev);
682 if (err) {
683 dev_err(dev, "cannot register matrix inputs: %d\n", err);
684 return err;
685 }
686
687 err = cros_ec_keyb_register_bs(ckdev);
688 if (err) {
689 dev_err(dev, "cannot register non-matrix inputs: %d\n", err);
690 return err;
691 }
692
693 err = devm_device_add_group(dev, &cros_ec_keyb_attr_group);
694 if (err) {
695 dev_err(dev, "failed to create attributes. err=%d\n", err);
696 return err;
697 }
698
699 ckdev->notifier.notifier_call = cros_ec_keyb_work;
700 err = blocking_notifier_chain_register(&ckdev->ec->event_notifier,
701 &ckdev->notifier);
702 if (err) {
703 dev_err(dev, "cannot register notifier: %d\n", err);
704 return err;
705 }
706
707 device_init_wakeup(ckdev->dev, true);
708 return 0;
709}
710
711static int cros_ec_keyb_remove(struct platform_device *pdev)
712{
713 struct cros_ec_keyb *ckdev = dev_get_drvdata(&pdev->dev);
714
715 blocking_notifier_chain_unregister(&ckdev->ec->event_notifier,
716 &ckdev->notifier);
717
718 return 0;
719}
720
721#ifdef CONFIG_OF
722static const struct of_device_id cros_ec_keyb_of_match[] = {
723 { .compatible = "google,cros-ec-keyb" },
724 {},
725};
726MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match);
727#endif
728
729static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume);
730
731static struct platform_driver cros_ec_keyb_driver = {
732 .probe = cros_ec_keyb_probe,
733 .remove = cros_ec_keyb_remove,
734 .driver = {
735 .name = "cros-ec-keyb",
736 .of_match_table = of_match_ptr(cros_ec_keyb_of_match),
737 .pm = &cros_ec_keyb_pm_ops,
738 },
739};
740
741module_platform_driver(cros_ec_keyb_driver);
742
743MODULE_LICENSE("GPL v2");
744MODULE_DESCRIPTION("ChromeOS EC keyboard driver");
745MODULE_ALIAS("platform:cros-ec-keyb");
746