2 * ChromeOS EC keyboard driver
4 * Copyright (C) 2012 Google, Inc
6 * This software is licensed under the terms of the GNU General Public
7 * License version 2, as published by the Free Software Foundation, and
8 * may be copied, distributed, and modified under those terms.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * This driver uses the Chrome OS EC byte-level message-based protocol for
16 * communicating the keyboard state (which keys are pressed) from a keyboard EC
17 * to the AP over some bus (such as i2c, lpc, spi). The EC does debouncing,
18 * but everything else (including deghosting) is done here. The main
19 * motivation for this is to keep the EC firmware as simple as possible, since
20 * it cannot be easily upgraded and EC flash/IRAM space is relatively
24 #include <linux/module.h>
25 #include <linux/bitops.h>
26 #include <linux/i2c.h>
27 #include <linux/input.h>
28 #include <linux/interrupt.h>
29 #include <linux/kernel.h>
30 #include <linux/notifier.h>
31 #include <linux/platform_device.h>
32 #include <linux/slab.h>
33 #include <linux/input/matrix_keypad.h>
34 #include <linux/mfd/cros_ec.h>
35 #include <linux/mfd/cros_ec_commands.h>
38 * @rows: Number of rows in the keypad
39 * @cols: Number of columns in the keypad
40 * @row_shift: log2 or number of rows, rounded up
41 * @keymap_data: Matrix keymap data used to convert to keyscan values
42 * @ghost_filter: true to enable the matrix key-ghosting filter
43 * @valid_keys: bitmap of existing keys for each matrix column
44 * @old_kb_state: bitmap of keys pressed last scan
45 * @dev: Device pointer
47 * @ec: Top level ChromeOS device to use to talk to EC
48 * @notifier: interrupt event notifier for transport devices
54 const struct matrix_keymap_data
*keymap_data
;
57 uint8_t *old_kb_state
;
60 struct input_dev
*idev
;
61 struct cros_ec_device
*ec
;
62 struct notifier_block notifier
;
67 * Returns true when there is at least one combination of pressed keys that
68 * results in ghosting.
70 static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb
*ckdev
, uint8_t *buf
)
72 int col1
, col2
, buf1
, buf2
;
73 struct device
*dev
= ckdev
->dev
;
74 uint8_t *valid_keys
= ckdev
->valid_keys
;
77 * Ghosting happens if for any pressed key X there are other keys
78 * pressed both in the same row and column of X as, for instance,
79 * in the following diagram:
86 * In this case only X, Y, and Z are pressed, but g appears to be
87 * pressed too (see Wikipedia).
89 for (col1
= 0; col1
< ckdev
->cols
; col1
++) {
90 buf1
= buf
[col1
] & valid_keys
[col1
];
91 for (col2
= col1
+ 1; col2
< ckdev
->cols
; col2
++) {
92 buf2
= buf
[col2
] & valid_keys
[col2
];
93 if (hweight8(buf1
& buf2
) > 1) {
94 dev_dbg(dev
, "ghost found at: B[%02d]:0x%02x & B[%02d]:0x%02x",
95 col1
, buf1
, col2
, buf2
);
106 * Compares the new keyboard state to the old one and produces key
107 * press/release events accordingly. The keyboard state is 13 bytes (one byte
110 static void cros_ec_keyb_process(struct cros_ec_keyb
*ckdev
,
111 uint8_t *kb_state
, int len
)
113 struct input_dev
*idev
= ckdev
->idev
;
121 if (ckdev
->ghost_filter
&& cros_ec_keyb_has_ghosting(ckdev
, kb_state
)) {
123 * Simple-minded solution: ignore this state. The obvious
124 * improvement is to only ignore changes to keys involved in
125 * the ghosting, but process the other changes.
127 dev_dbg(ckdev
->dev
, "ghosting found\n");
131 for (col
= 0; col
< ckdev
->cols
; col
++) {
132 for (row
= 0; row
< ckdev
->rows
; row
++) {
133 int pos
= MATRIX_SCAN_CODE(row
, col
, ckdev
->row_shift
);
134 const unsigned short *keycodes
= idev
->keycode
;
136 new_state
= kb_state
[col
] & (1 << row
);
137 old_state
= ckdev
->old_kb_state
[col
] & (1 << row
);
138 if (new_state
!= old_state
) {
140 "changed: [r%d c%d]: byte %02x\n",
141 row
, col
, new_state
);
143 input_report_key(idev
, keycodes
[pos
],
147 ckdev
->old_kb_state
[col
] = kb_state
[col
];
149 input_sync(ckdev
->idev
);
152 static int cros_ec_keyb_open(struct input_dev
*dev
)
154 struct cros_ec_keyb
*ckdev
= input_get_drvdata(dev
);
156 return blocking_notifier_chain_register(&ckdev
->ec
->event_notifier
,
160 static void cros_ec_keyb_close(struct input_dev
*dev
)
162 struct cros_ec_keyb
*ckdev
= input_get_drvdata(dev
);
164 blocking_notifier_chain_unregister(&ckdev
->ec
->event_notifier
,
168 static int cros_ec_keyb_work(struct notifier_block
*nb
,
169 unsigned long queued_during_suspend
, void *_notify
)
171 struct cros_ec_keyb
*ckdev
= container_of(nb
, struct cros_ec_keyb
,
174 if (ckdev
->ec
->event_data
.event_type
!= EC_MKBP_EVENT_KEY_MATRIX
)
177 * If EC is not the wake source, discard key state changes during
180 if (queued_during_suspend
)
182 if (ckdev
->ec
->event_size
!= ckdev
->cols
) {
184 "Discarded incomplete key matrix event.\n");
187 cros_ec_keyb_process(ckdev
, ckdev
->ec
->event_data
.data
.key_matrix
,
188 ckdev
->ec
->event_size
);
193 * Walks keycodes flipping bit in buffer COLUMNS deep where bit is ROW. Used by
194 * ghosting logic to ignore NULL or virtual keys.
196 static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb
*ckdev
)
199 int row_shift
= ckdev
->row_shift
;
200 unsigned short *keymap
= ckdev
->idev
->keycode
;
203 BUG_ON(ckdev
->idev
->keycodesize
!= sizeof(*keymap
));
205 for (col
= 0; col
< ckdev
->cols
; col
++) {
206 for (row
= 0; row
< ckdev
->rows
; row
++) {
207 code
= keymap
[MATRIX_SCAN_CODE(row
, col
, row_shift
)];
208 if (code
&& (code
!= KEY_BATTERY
))
209 ckdev
->valid_keys
[col
] |= 1 << row
;
211 dev_dbg(ckdev
->dev
, "valid_keys[%02d] = 0x%02x\n",
212 col
, ckdev
->valid_keys
[col
]);
216 static int cros_ec_keyb_probe(struct platform_device
*pdev
)
218 struct cros_ec_device
*ec
= dev_get_drvdata(pdev
->dev
.parent
);
219 struct device
*dev
= &pdev
->dev
;
220 struct cros_ec_keyb
*ckdev
;
221 struct input_dev
*idev
;
222 struct device_node
*np
;
225 np
= pdev
->dev
.of_node
;
229 ckdev
= devm_kzalloc(dev
, sizeof(*ckdev
), GFP_KERNEL
);
232 err
= matrix_keypad_parse_of_params(dev
, &ckdev
->rows
, &ckdev
->cols
);
236 ckdev
->valid_keys
= devm_kzalloc(dev
, ckdev
->cols
, GFP_KERNEL
);
237 if (!ckdev
->valid_keys
)
240 ckdev
->old_kb_state
= devm_kzalloc(dev
, ckdev
->cols
, GFP_KERNEL
);
241 if (!ckdev
->old_kb_state
)
244 idev
= devm_input_allocate_device(dev
);
249 ckdev
->notifier
.notifier_call
= cros_ec_keyb_work
;
251 dev_set_drvdata(dev
, ckdev
);
253 idev
->name
= CROS_EC_DEV_NAME
;
254 idev
->phys
= ec
->phys_name
;
255 __set_bit(EV_REP
, idev
->evbit
);
257 idev
->id
.bustype
= BUS_VIRTUAL
;
258 idev
->id
.version
= 1;
259 idev
->id
.product
= 0;
260 idev
->dev
.parent
= dev
;
261 idev
->open
= cros_ec_keyb_open
;
262 idev
->close
= cros_ec_keyb_close
;
264 ckdev
->ghost_filter
= of_property_read_bool(np
,
265 "google,needs-ghost-filter");
267 err
= matrix_keypad_build_keymap(NULL
, NULL
, ckdev
->rows
, ckdev
->cols
,
270 dev_err(dev
, "cannot build key matrix\n");
274 ckdev
->row_shift
= get_count_order(ckdev
->cols
);
276 input_set_capability(idev
, EV_MSC
, MSC_SCAN
);
277 input_set_drvdata(idev
, ckdev
);
279 cros_ec_keyb_compute_valid_keys(ckdev
);
281 err
= input_register_device(ckdev
->idev
);
283 dev_err(dev
, "cannot register input device\n");
291 static const struct of_device_id cros_ec_keyb_of_match
[] = {
292 { .compatible
= "google,cros-ec-keyb" },
295 MODULE_DEVICE_TABLE(of
, cros_ec_keyb_of_match
);
298 static struct platform_driver cros_ec_keyb_driver
= {
299 .probe
= cros_ec_keyb_probe
,
301 .name
= "cros-ec-keyb",
302 .of_match_table
= of_match_ptr(cros_ec_keyb_of_match
),
306 module_platform_driver(cros_ec_keyb_driver
);
308 MODULE_LICENSE("GPL");
309 MODULE_DESCRIPTION("ChromeOS EC keyboard driver");
310 MODULE_ALIAS("platform:cros-ec-keyb");