1 // SPDX-License-Identifier: GPL-2.0
2 // ChromeOS EC keyboard driver
4 // Copyright (C) 2012 Google, Inc.
6 // This driver uses the ChromeOS EC byte-level message-based protocol for
7 // communicating the keyboard state (which keys are pressed) from a keyboard EC
8 // to the AP over some bus (such as i2c, lpc, spi). The EC does debouncing,
9 // but everything else (including deghosting) is done here. The main
10 // motivation for this is to keep the EC firmware as simple as possible, since
11 // it cannot be easily upgraded and EC flash/IRAM space is relatively
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>
28 #include <asm/unaligned.h>
30 #define MAX_NUM_TOP_ROW_KEYS 15
33 * struct cros_ec_keyb - Structure representing EC keyboard device
35 * @rows: Number of rows in the keypad
36 * @cols: Number of columns in the keypad
37 * @row_shift: log2 or number of rows, rounded up
38 * @keymap_data: Matrix keymap data used to convert to keyscan values
39 * @ghost_filter: true to enable the matrix key-ghosting filter
40 * @valid_keys: bitmap of existing keys for each matrix column
41 * @old_kb_state: bitmap of keys pressed last scan
42 * @dev: Device pointer
43 * @ec: Top level ChromeOS device to use to talk to EC
44 * @idev: The input device for the matrix keys.
45 * @bs_idev: The input device for non-matrix buttons and switches (or NULL).
46 * @notifier: interrupt event notifier for transport devices
47 * @function_row_physmap: An array of the encoded rows/columns for the top
48 * row function keys, in an order from left to right
49 * @num_function_row_keys: The number of top row keys in a custom keyboard
55 const struct matrix_keymap_data
*keymap_data
;
58 uint8_t *old_kb_state
;
61 struct cros_ec_device
*ec
;
63 struct input_dev
*idev
;
64 struct input_dev
*bs_idev
;
65 struct notifier_block notifier
;
67 u16 function_row_physmap
[MAX_NUM_TOP_ROW_KEYS
];
68 size_t num_function_row_keys
;
72 * struct cros_ec_bs_map - Mapping between Linux keycodes and EC button/switch
75 * @ev_type: The type of the input event to generate (e.g., EV_KEY).
76 * @code: A linux keycode
77 * @bit: A #define like EC_MKBP_POWER_BUTTON or EC_MKBP_LID_OPEN
78 * @inverted: If the #define and EV_SW have opposite meanings, this is true.
79 * Only applicable to switches.
81 struct cros_ec_bs_map
{
88 /* cros_ec_keyb_bs - Map EC button/switch #defines into kernel ones */
89 static const struct cros_ec_bs_map cros_ec_keyb_bs
[] = {
94 .bit
= EC_MKBP_POWER_BUTTON
,
99 .bit
= EC_MKBP_VOL_UP
,
103 .code
= KEY_VOLUMEDOWN
,
104 .bit
= EC_MKBP_VOL_DOWN
,
111 .bit
= EC_MKBP_LID_OPEN
,
116 .code
= SW_TABLET_MODE
,
117 .bit
= EC_MKBP_TABLET_MODE
,
122 * Returns true when there is at least one combination of pressed keys that
123 * results in ghosting.
125 static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb
*ckdev
, uint8_t *buf
)
127 int col1
, col2
, buf1
, buf2
;
128 struct device
*dev
= ckdev
->dev
;
129 uint8_t *valid_keys
= ckdev
->valid_keys
;
132 * Ghosting happens if for any pressed key X there are other keys
133 * pressed both in the same row and column of X as, for instance,
134 * in the following diagram:
141 * In this case only X, Y, and Z are pressed, but g appears to be
142 * pressed too (see Wikipedia).
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
);
161 * Compares the new keyboard state to the old one and produces key
162 * press/release events accordingly. The keyboard state is 13 bytes (one byte
165 static void cros_ec_keyb_process(struct cros_ec_keyb
*ckdev
,
166 uint8_t *kb_state
, int len
)
168 struct input_dev
*idev
= ckdev
->idev
;
173 if (ckdev
->ghost_filter
&& cros_ec_keyb_has_ghosting(ckdev
, kb_state
)) {
175 * Simple-minded solution: ignore this state. The obvious
176 * improvement is to only ignore changes to keys involved in
177 * the ghosting, but process the other changes.
179 dev_dbg(ckdev
->dev
, "ghosting found\n");
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
;
188 new_state
= kb_state
[col
] & (1 << row
);
189 old_state
= ckdev
->old_kb_state
[col
] & (1 << row
);
190 if (new_state
!= old_state
) {
192 "changed: [r%d c%d]: byte %02x\n",
193 row
, col
, new_state
);
195 input_event(idev
, EV_MSC
, MSC_SCAN
, pos
);
196 input_report_key(idev
, keycodes
[pos
],
200 ckdev
->old_kb_state
[col
] = kb_state
[col
];
202 input_sync(ckdev
->idev
);
206 * cros_ec_keyb_report_bs - Report non-matrixed buttons or switches
208 * This takes a bitmap of buttons or switches from the EC and reports events,
209 * syncing at the end.
211 * @ckdev: The keyboard device.
212 * @ev_type: The input event type (e.g., EV_KEY).
213 * @mask: A bitmap of buttons from the EC.
215 static void cros_ec_keyb_report_bs(struct cros_ec_keyb
*ckdev
,
216 unsigned int ev_type
, u32 mask
)
219 struct input_dev
*idev
= ckdev
->bs_idev
;
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
];
225 if (map
->ev_type
!= ev_type
)
228 input_event(idev
, ev_type
, map
->code
,
229 !!(mask
& BIT(map
->bit
)) ^ map
->inverted
);
234 static int cros_ec_keyb_work(struct notifier_block
*nb
,
235 unsigned long queued_during_suspend
, void *_notify
)
237 struct cros_ec_keyb
*ckdev
= container_of(nb
, struct cros_ec_keyb
,
240 unsigned int ev_type
;
243 * If not wake enabled, discard key state changes during
244 * suspend. Switches will be re-checked in
245 * cros_ec_keyb_resume() to be sure nothing is lost.
247 if (queued_during_suspend
&& !device_may_wakeup(ckdev
->dev
))
250 switch (ckdev
->ec
->event_data
.event_type
) {
251 case EC_MKBP_EVENT_KEY_MATRIX
:
252 pm_wakeup_event(ckdev
->dev
, 0);
254 if (ckdev
->ec
->event_size
!= ckdev
->cols
) {
256 "Discarded incomplete key matrix event.\n");
260 cros_ec_keyb_process(ckdev
,
261 ckdev
->ec
->event_data
.data
.key_matrix
,
262 ckdev
->ec
->event_size
);
265 case EC_MKBP_EVENT_SYSRQ
:
266 pm_wakeup_event(ckdev
->dev
, 0);
268 val
= get_unaligned_le32(&ckdev
->ec
->event_data
.data
.sysrq
);
269 dev_dbg(ckdev
->dev
, "sysrq code from EC: %#x\n", val
);
273 case EC_MKBP_EVENT_BUTTON
:
274 case EC_MKBP_EVENT_SWITCH
:
275 pm_wakeup_event(ckdev
->dev
, 0);
277 if (ckdev
->ec
->event_data
.event_type
== EC_MKBP_EVENT_BUTTON
) {
278 val
= get_unaligned_le32(
279 &ckdev
->ec
->event_data
.data
.buttons
);
282 val
= get_unaligned_le32(
283 &ckdev
->ec
->event_data
.data
.switches
);
286 cros_ec_keyb_report_bs(ckdev
, ev_type
, val
);
297 * Walks keycodes flipping bit in buffer COLUMNS deep where bit is ROW. Used by
298 * ghosting logic to ignore NULL or virtual keys.
300 static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb
*ckdev
)
303 int row_shift
= ckdev
->row_shift
;
304 unsigned short *keymap
= ckdev
->idev
->keycode
;
307 BUG_ON(ckdev
->idev
->keycodesize
!= sizeof(*keymap
));
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
;
315 dev_dbg(ckdev
->dev
, "valid_keys[%02d] = 0x%02x\n",
316 col
, ckdev
->valid_keys
[col
]);
321 * cros_ec_keyb_info - Wrap the EC command EC_CMD_MKBP_INFO
323 * This wraps the EC_CMD_MKBP_INFO, abstracting out all of the marshalling and
324 * unmarshalling and different version nonsense into something simple.
326 * @ec_dev: The EC device
327 * @info_type: Either EC_MKBP_INFO_SUPPORTED or EC_MKBP_INFO_CURRENT.
328 * @event_type: Either EC_MKBP_EVENT_BUTTON or EC_MKBP_EVENT_SWITCH. Actually
329 * in some cases this could be EC_MKBP_EVENT_KEY_MATRIX or
330 * EC_MKBP_EVENT_HOST_EVENT too but we don't use in this driver.
331 * @result: Where we'll store the result; a union
332 * @result_size: The size of the result. Expected to be the size of one of
333 * the elements in the union.
335 * Returns 0 if no error or -error upon error.
337 static 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
,
343 struct ec_params_mkbp_info
*params
;
344 struct cros_ec_command
*msg
;
347 msg
= kzalloc(sizeof(*msg
) + max_t(size_t, result_size
,
348 sizeof(*params
)), GFP_KERNEL
);
352 msg
->command
= EC_CMD_MKBP_INFO
;
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
;
360 ret
= cros_ec_cmd_xfer_status(ec_dev
, msg
);
361 if (ret
== -ENOPROTOOPT
) {
362 /* With older ECs we just return 0 for everything */
363 memset(result
, 0, result_size
);
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
,
374 memcpy(result
, msg
->data
, result_size
);
384 * cros_ec_keyb_query_switches - Query the state of switches and report
386 * This will ask the EC about the current state of switches and report to the
387 * kernel. Note that we don't query for buttons because they are more
388 * transitory and we'll get an update on the next release / press.
390 * @ckdev: The keyboard device
392 * Returns 0 if no error or -error upon error.
394 static int cros_ec_keyb_query_switches(struct cros_ec_keyb
*ckdev
)
396 struct cros_ec_device
*ec_dev
= ckdev
->ec
;
397 union ec_response_get_next_data event_data
= {};
400 ret
= cros_ec_keyb_info(ec_dev
, EC_MKBP_INFO_CURRENT
,
401 EC_MKBP_EVENT_SWITCH
, &event_data
,
402 sizeof(event_data
.switches
));
406 cros_ec_keyb_report_bs(ckdev
, EV_SW
,
407 get_unaligned_le32(&event_data
.switches
));
413 * cros_ec_keyb_resume - Resume the keyboard
415 * We use the resume notification as a chance to query the EC for switches.
417 * @dev: The keyboard device
419 * Returns 0 if no error or -error upon error.
421 static __maybe_unused
int cros_ec_keyb_resume(struct device
*dev
)
423 struct cros_ec_keyb
*ckdev
= dev_get_drvdata(dev
);
426 return cros_ec_keyb_query_switches(ckdev
);
432 * cros_ec_keyb_register_bs - Register non-matrix buttons/switches
434 * Handles all the bits of the keyboard driver related to non-matrix buttons
435 * and switches, including asking the EC about which are present and telling
436 * the kernel to expect them.
438 * If this device has no support for buttons and switches we'll return no error
439 * but the ckdev->bs_idev will remain NULL when this function exits.
441 * @ckdev: The keyboard device
443 * Returns 0 if no error or -error upon error.
445 static int cros_ec_keyb_register_bs(struct cros_ec_keyb
*ckdev
)
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
= {};
457 ret
= cros_ec_keyb_info(ec_dev
, EC_MKBP_INFO_SUPPORTED
,
458 EC_MKBP_EVENT_BUTTON
, &event_data
,
459 sizeof(event_data
.buttons
));
462 buttons
= get_unaligned_le32(&event_data
.buttons
);
464 ret
= cros_ec_keyb_info(ec_dev
, EC_MKBP_INFO_SUPPORTED
,
465 EC_MKBP_EVENT_SWITCH
, &event_data
,
466 sizeof(event_data
.switches
));
469 switches
= get_unaligned_le32(&event_data
.switches
);
471 if (!buttons
&& !switches
)
475 * We call the non-matrix buttons/switches 'input1', if present.
476 * Allocate phys before input dev, to ensure correct tear-down
479 phys
= devm_kasprintf(dev
, GFP_KERNEL
, "%s/input1", ec_dev
->phys_name
);
483 idev
= devm_input_allocate_device(dev
);
487 idev
->name
= "cros_ec_buttons";
489 __set_bit(EV_REP
, idev
->evbit
);
491 idev
->id
.bustype
= BUS_VIRTUAL
;
492 idev
->id
.version
= 1;
493 idev
->id
.product
= 0;
494 idev
->dev
.parent
= dev
;
496 input_set_drvdata(idev
, ckdev
);
497 ckdev
->bs_idev
= idev
;
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
];
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
);
507 ret
= cros_ec_keyb_query_switches(ckdev
);
509 dev_err(dev
, "cannot query switches\n");
513 ret
= input_register_device(ckdev
->bs_idev
);
515 dev_err(dev
, "cannot register input device\n");
523 * cros_ec_keyb_register_bs - Register matrix keys
525 * Handles all the bits of the keyboard driver related to matrix keys.
527 * @ckdev: The keyboard device
529 * Returns 0 if no error or -error upon error.
531 static int cros_ec_keyb_register_matrix(struct cros_ec_keyb
*ckdev
)
533 struct cros_ec_device
*ec_dev
= ckdev
->ec
;
534 struct device
*dev
= ckdev
->dev
;
535 struct input_dev
*idev
;
538 struct property
*prop
;
544 err
= matrix_keypad_parse_properties(dev
, &ckdev
->rows
, &ckdev
->cols
);
548 ckdev
->valid_keys
= devm_kzalloc(dev
, ckdev
->cols
, GFP_KERNEL
);
549 if (!ckdev
->valid_keys
)
552 ckdev
->old_kb_state
= devm_kzalloc(dev
, ckdev
->cols
, GFP_KERNEL
);
553 if (!ckdev
->old_kb_state
)
557 * We call the keyboard matrix 'input0'. Allocate phys before input
558 * dev, to ensure correct tear-down ordering.
560 phys
= devm_kasprintf(dev
, GFP_KERNEL
, "%s/input0", ec_dev
->phys_name
);
564 idev
= devm_input_allocate_device(dev
);
568 idev
->name
= CROS_EC_DEV_NAME
;
570 __set_bit(EV_REP
, idev
->evbit
);
572 idev
->id
.bustype
= BUS_VIRTUAL
;
573 idev
->id
.version
= 1;
574 idev
->id
.product
= 0;
575 idev
->dev
.parent
= dev
;
577 ckdev
->ghost_filter
= of_property_read_bool(dev
->of_node
,
578 "google,needs-ghost-filter");
580 err
= matrix_keypad_build_keymap(NULL
, NULL
, ckdev
->rows
, ckdev
->cols
,
583 dev_err(dev
, "cannot build key matrix\n");
587 ckdev
->row_shift
= get_count_order(ckdev
->cols
);
589 input_set_capability(idev
, EV_MSC
, MSC_SCAN
);
590 input_set_drvdata(idev
, ckdev
);
592 cros_ec_keyb_compute_valid_keys(ckdev
);
594 physmap
= ckdev
->function_row_physmap
;
595 of_property_for_each_u32(dev
->of_node
, "function-row-physmap",
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
);
602 row
= KEY_ROW(key_pos
);
603 col
= KEY_COL(key_pos
);
604 *physmap
= MATRIX_SCAN_CODE(row
, col
, ckdev
->row_shift
);
606 ckdev
->num_function_row_keys
++;
609 err
= input_register_device(ckdev
->idev
);
611 dev_err(dev
, "cannot register input device\n");
618 static ssize_t
function_row_physmap_show(struct device
*dev
,
619 struct device_attribute
*attr
,
624 struct cros_ec_keyb
*ckdev
= dev_get_drvdata(dev
);
625 u16
*physmap
= ckdev
->function_row_physmap
;
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
]);
631 size
+= scnprintf(buf
+ size
, PAGE_SIZE
- size
, "\n");
636 static DEVICE_ATTR_RO(function_row_physmap
);
638 static struct attribute
*cros_ec_keyb_attrs
[] = {
639 &dev_attr_function_row_physmap
.attr
,
643 static umode_t
cros_ec_keyb_attr_is_visible(struct kobject
*kobj
,
644 struct attribute
*attr
,
647 struct device
*dev
= kobj_to_dev(kobj
);
648 struct cros_ec_keyb
*ckdev
= dev_get_drvdata(dev
);
650 if (attr
== &dev_attr_function_row_physmap
.attr
&&
651 !ckdev
->num_function_row_keys
)
657 static const struct attribute_group cros_ec_keyb_attr_group
= {
658 .is_visible
= cros_ec_keyb_attr_is_visible
,
659 .attrs
= cros_ec_keyb_attrs
,
663 static int cros_ec_keyb_probe(struct platform_device
*pdev
)
665 struct cros_ec_device
*ec
= dev_get_drvdata(pdev
->dev
.parent
);
666 struct device
*dev
= &pdev
->dev
;
667 struct cros_ec_keyb
*ckdev
;
673 ckdev
= devm_kzalloc(dev
, sizeof(*ckdev
), GFP_KERNEL
);
679 dev_set_drvdata(dev
, ckdev
);
681 err
= cros_ec_keyb_register_matrix(ckdev
);
683 dev_err(dev
, "cannot register matrix inputs: %d\n", err
);
687 err
= cros_ec_keyb_register_bs(ckdev
);
689 dev_err(dev
, "cannot register non-matrix inputs: %d\n", err
);
693 err
= devm_device_add_group(dev
, &cros_ec_keyb_attr_group
);
695 dev_err(dev
, "failed to create attributes. err=%d\n", err
);
699 ckdev
->notifier
.notifier_call
= cros_ec_keyb_work
;
700 err
= blocking_notifier_chain_register(&ckdev
->ec
->event_notifier
,
703 dev_err(dev
, "cannot register notifier: %d\n", err
);
707 device_init_wakeup(ckdev
->dev
, true);
711 static int cros_ec_keyb_remove(struct platform_device
*pdev
)
713 struct cros_ec_keyb
*ckdev
= dev_get_drvdata(&pdev
->dev
);
715 blocking_notifier_chain_unregister(&ckdev
->ec
->event_notifier
,
722 static const struct of_device_id cros_ec_keyb_of_match
[] = {
723 { .compatible
= "google,cros-ec-keyb" },
726 MODULE_DEVICE_TABLE(of
, cros_ec_keyb_of_match
);
729 static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops
, NULL
, cros_ec_keyb_resume
);
731 static struct platform_driver cros_ec_keyb_driver
= {
732 .probe
= cros_ec_keyb_probe
,
733 .remove
= cros_ec_keyb_remove
,
735 .name
= "cros-ec-keyb",
736 .of_match_table
= of_match_ptr(cros_ec_keyb_of_match
),
737 .pm
= &cros_ec_keyb_pm_ops
,
741 module_platform_driver(cros_ec_keyb_driver
);
743 MODULE_LICENSE("GPL v2");
744 MODULE_DESCRIPTION("ChromeOS EC keyboard driver");
745 MODULE_ALIAS("platform:cros-ec-keyb");