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/platform_device.h>
31 #include <linux/slab.h>
32 #include <linux/input/matrix_keypad.h>
33 #include <linux/mfd/cros_ec.h>
34 #include <linux/mfd/cros_ec_commands.h>
37 * @rows: Number of rows in the keypad
38 * @cols: Number of columns in the keypad
39 * @row_shift: log2 or number of rows, rounded up
40 * @keymap_data: Matrix keymap data used to convert to keyscan values
41 * @ghost_filter: true to enable the matrix key-ghosting filter
42 * @valid_keys: bitmap of existing keys for each matrix column
43 * @old_kb_state: bitmap of keys pressed last scan
44 * @dev: Device pointer
46 * @ec: Top level ChromeOS device to use to talk to EC
52 const struct matrix_keymap_data
*keymap_data
;
55 uint8_t *old_kb_state
;
58 struct input_dev
*idev
;
59 struct cros_ec_device
*ec
;
64 * Returns true when there is at least one combination of pressed keys that
65 * results in ghosting.
67 static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb
*ckdev
, uint8_t *buf
)
69 int col1
, col2
, buf1
, buf2
;
70 struct device
*dev
= ckdev
->dev
;
71 uint8_t *valid_keys
= ckdev
->valid_keys
;
74 * Ghosting happens if for any pressed key X there are other keys
75 * pressed both in the same row and column of X as, for instance,
76 * in the following diagram:
83 * In this case only X, Y, and Z are pressed, but g appears to be
84 * pressed too (see Wikipedia).
86 for (col1
= 0; col1
< ckdev
->cols
; col1
++) {
87 buf1
= buf
[col1
] & valid_keys
[col1
];
88 for (col2
= col1
+ 1; col2
< ckdev
->cols
; col2
++) {
89 buf2
= buf
[col2
] & valid_keys
[col2
];
90 if (hweight8(buf1
& buf2
) > 1) {
91 dev_dbg(dev
, "ghost found at: B[%02d]:0x%02x & B[%02d]:0x%02x",
92 col1
, buf1
, col2
, buf2
);
103 * Compares the new keyboard state to the old one and produces key
104 * press/release events accordingly. The keyboard state is 13 bytes (one byte
107 static void cros_ec_keyb_process(struct cros_ec_keyb
*ckdev
,
108 uint8_t *kb_state
, int len
)
110 struct input_dev
*idev
= ckdev
->idev
;
118 if (ckdev
->ghost_filter
&& cros_ec_keyb_has_ghosting(ckdev
, kb_state
)) {
120 * Simple-minded solution: ignore this state. The obvious
121 * improvement is to only ignore changes to keys involved in
122 * the ghosting, but process the other changes.
124 dev_dbg(ckdev
->dev
, "ghosting found\n");
128 for (col
= 0; col
< ckdev
->cols
; col
++) {
129 for (row
= 0; row
< ckdev
->rows
; row
++) {
130 int pos
= MATRIX_SCAN_CODE(row
, col
, ckdev
->row_shift
);
131 const unsigned short *keycodes
= idev
->keycode
;
133 new_state
= kb_state
[col
] & (1 << row
);
134 old_state
= ckdev
->old_kb_state
[col
] & (1 << row
);
135 if (new_state
!= old_state
) {
137 "changed: [r%d c%d]: byte %02x\n",
138 row
, col
, new_state
);
140 input_report_key(idev
, keycodes
[pos
],
144 ckdev
->old_kb_state
[col
] = kb_state
[col
];
146 input_sync(ckdev
->idev
);
149 static int cros_ec_keyb_get_state(struct cros_ec_keyb
*ckdev
, uint8_t *kb_state
)
151 struct cros_ec_command msg
= {
153 .command
= EC_CMD_MKBP_STATE
,
157 .insize
= ckdev
->cols
,
160 return ckdev
->ec
->cmd_xfer(ckdev
->ec
, &msg
);
163 static irqreturn_t
cros_ec_keyb_irq(int irq
, void *data
)
165 struct cros_ec_keyb
*ckdev
= data
;
166 struct cros_ec_device
*ec
= ckdev
->ec
;
168 uint8_t kb_state
[ckdev
->cols
];
170 if (device_may_wakeup(ec
->dev
))
171 pm_wakeup_event(ec
->dev
, 0);
173 ret
= cros_ec_keyb_get_state(ckdev
, kb_state
);
175 cros_ec_keyb_process(ckdev
, kb_state
, ret
);
177 dev_err(ec
->dev
, "failed to get keyboard state: %d\n", ret
);
182 static int cros_ec_keyb_open(struct input_dev
*dev
)
184 struct cros_ec_keyb
*ckdev
= input_get_drvdata(dev
);
185 struct cros_ec_device
*ec
= ckdev
->ec
;
187 return request_threaded_irq(ec
->irq
, NULL
, cros_ec_keyb_irq
,
188 IRQF_TRIGGER_LOW
| IRQF_ONESHOT
,
189 "cros_ec_keyb", ckdev
);
192 static void cros_ec_keyb_close(struct input_dev
*dev
)
194 struct cros_ec_keyb
*ckdev
= input_get_drvdata(dev
);
195 struct cros_ec_device
*ec
= ckdev
->ec
;
197 free_irq(ec
->irq
, ckdev
);
201 * Walks keycodes flipping bit in buffer COLUMNS deep where bit is ROW. Used by
202 * ghosting logic to ignore NULL or virtual keys.
204 static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb
*ckdev
)
207 int row_shift
= ckdev
->row_shift
;
208 unsigned short *keymap
= ckdev
->idev
->keycode
;
211 BUG_ON(ckdev
->idev
->keycodesize
!= sizeof(*keymap
));
213 for (col
= 0; col
< ckdev
->cols
; col
++) {
214 for (row
= 0; row
< ckdev
->rows
; row
++) {
215 code
= keymap
[MATRIX_SCAN_CODE(row
, col
, row_shift
)];
216 if (code
&& (code
!= KEY_BATTERY
))
217 ckdev
->valid_keys
[col
] |= 1 << row
;
219 dev_dbg(ckdev
->dev
, "valid_keys[%02d] = 0x%02x\n",
220 col
, ckdev
->valid_keys
[col
]);
224 static int cros_ec_keyb_probe(struct platform_device
*pdev
)
226 struct cros_ec_device
*ec
= dev_get_drvdata(pdev
->dev
.parent
);
227 struct device
*dev
= ec
->dev
;
228 struct cros_ec_keyb
*ckdev
;
229 struct input_dev
*idev
;
230 struct device_node
*np
;
233 np
= pdev
->dev
.of_node
;
237 ckdev
= devm_kzalloc(&pdev
->dev
, sizeof(*ckdev
), GFP_KERNEL
);
240 err
= matrix_keypad_parse_of_params(&pdev
->dev
, &ckdev
->rows
,
245 ckdev
->valid_keys
= devm_kzalloc(&pdev
->dev
, ckdev
->cols
, GFP_KERNEL
);
246 if (!ckdev
->valid_keys
)
249 ckdev
->old_kb_state
= devm_kzalloc(&pdev
->dev
, ckdev
->cols
, GFP_KERNEL
);
250 if (!ckdev
->old_kb_state
)
253 idev
= devm_input_allocate_device(&pdev
->dev
);
258 dev_err(dev
, "no EC IRQ specified\n");
264 dev_set_drvdata(&pdev
->dev
, ckdev
);
266 idev
->name
= ec
->ec_name
;
267 idev
->phys
= ec
->phys_name
;
268 __set_bit(EV_REP
, idev
->evbit
);
270 idev
->id
.bustype
= BUS_VIRTUAL
;
271 idev
->id
.version
= 1;
272 idev
->id
.product
= 0;
273 idev
->dev
.parent
= &pdev
->dev
;
274 idev
->open
= cros_ec_keyb_open
;
275 idev
->close
= cros_ec_keyb_close
;
277 ckdev
->ghost_filter
= of_property_read_bool(np
,
278 "google,needs-ghost-filter");
280 err
= matrix_keypad_build_keymap(NULL
, NULL
, ckdev
->rows
, ckdev
->cols
,
283 dev_err(dev
, "cannot build key matrix\n");
287 ckdev
->row_shift
= get_count_order(ckdev
->cols
);
289 input_set_capability(idev
, EV_MSC
, MSC_SCAN
);
290 input_set_drvdata(idev
, ckdev
);
292 cros_ec_keyb_compute_valid_keys(ckdev
);
294 err
= input_register_device(ckdev
->idev
);
296 dev_err(dev
, "cannot register input device\n");
303 #ifdef CONFIG_PM_SLEEP
304 /* Clear any keys in the buffer */
305 static void cros_ec_keyb_clear_keyboard(struct cros_ec_keyb
*ckdev
)
307 uint8_t old_state
[ckdev
->cols
];
308 uint8_t new_state
[ckdev
->cols
];
309 unsigned long duration
;
313 * Keep reading until we see that the scan state does not change.
314 * That indicates that we are done.
316 * Assume that the EC keyscan buffer is at most 32 deep.
319 ret
= cros_ec_keyb_get_state(ckdev
, new_state
);
320 for (i
= 1; !ret
&& i
< 32; i
++) {
321 memcpy(old_state
, new_state
, sizeof(old_state
));
322 ret
= cros_ec_keyb_get_state(ckdev
, new_state
);
323 if (0 == memcmp(old_state
, new_state
, sizeof(old_state
)))
326 duration
= jiffies
- duration
;
327 dev_info(ckdev
->dev
, "Discarded %d keyscan(s) in %dus\n", i
,
328 jiffies_to_usecs(duration
));
331 static int cros_ec_keyb_resume(struct device
*dev
)
333 struct cros_ec_keyb
*ckdev
= dev_get_drvdata(dev
);
336 * When the EC is not a wake source, then it could not have caused the
337 * resume, so we clear the EC's key scan buffer. If the EC was a
338 * wake source (e.g. the lid is open and the user might press a key to
339 * wake) then the key scan buffer should be preserved.
341 if (ckdev
->ec
->was_wake_device
)
342 cros_ec_keyb_clear_keyboard(ckdev
);
349 static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops
, NULL
, cros_ec_keyb_resume
);
351 static struct platform_driver cros_ec_keyb_driver
= {
352 .probe
= cros_ec_keyb_probe
,
354 .name
= "cros-ec-keyb",
355 .pm
= &cros_ec_keyb_pm_ops
,
359 module_platform_driver(cros_ec_keyb_driver
);
361 MODULE_LICENSE("GPL");
362 MODULE_DESCRIPTION("ChromeOS EC keyboard driver");
363 MODULE_ALIAS("platform:cros-ec-keyb");