]>
Commit | Line | Data |
---|---|---|
27fff221 EBS |
1 | // SPDX-License-Identifier: GPL-2.0 |
2 | // ChromeOS EC keyboard driver | |
3 | // | |
4 | // Copyright (C) 2012 Google, Inc. | |
5 | // | |
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 | |
12 | // expensive. | |
6af6dc2d SG |
13 | |
14 | #include <linux/module.h> | |
017f14e8 | 15 | #include <linux/bitops.h> |
6af6dc2d SG |
16 | #include <linux/i2c.h> |
17 | #include <linux/input.h> | |
d1fd345e | 18 | #include <linux/interrupt.h> |
6af6dc2d | 19 | #include <linux/kernel.h> |
44051a68 | 20 | #include <linux/notifier.h> |
6af6dc2d SG |
21 | #include <linux/platform_device.h> |
22 | #include <linux/slab.h> | |
e6eba3fa | 23 | #include <linux/sysrq.h> |
6af6dc2d | 24 | #include <linux/input/matrix_keypad.h> |
840d9f13 EBS |
25 | #include <linux/platform_data/cros_ec_commands.h> |
26 | #include <linux/platform_data/cros_ec_proto.h> | |
6af6dc2d | 27 | |
cdd7950e DA |
28 | #include <asm/unaligned.h> |
29 | ||
6af6dc2d SG |
30 | /* |
31 | * @rows: Number of rows in the keypad | |
32 | * @cols: Number of columns in the keypad | |
33 | * @row_shift: log2 or number of rows, rounded up | |
34 | * @keymap_data: Matrix keymap data used to convert to keyscan values | |
35 | * @ghost_filter: true to enable the matrix key-ghosting filter | |
017f14e8 | 36 | * @valid_keys: bitmap of existing keys for each matrix column |
64757eba | 37 | * @old_kb_state: bitmap of keys pressed last scan |
6af6dc2d | 38 | * @dev: Device pointer |
6af6dc2d | 39 | * @ec: Top level ChromeOS device to use to talk to EC |
cdd7950e DA |
40 | * @idev: The input device for the matrix keys. |
41 | * @bs_idev: The input device for non-matrix buttons and switches (or NULL). | |
44051a68 | 42 | * @notifier: interrupt event notifier for transport devices |
6af6dc2d SG |
43 | */ |
44 | struct cros_ec_keyb { | |
45 | unsigned int rows; | |
46 | unsigned int cols; | |
47 | int row_shift; | |
48 | const struct matrix_keymap_data *keymap_data; | |
49 | bool ghost_filter; | |
017f14e8 | 50 | uint8_t *valid_keys; |
64757eba | 51 | uint8_t *old_kb_state; |
6af6dc2d SG |
52 | |
53 | struct device *dev; | |
6af6dc2d | 54 | struct cros_ec_device *ec; |
cdd7950e DA |
55 | |
56 | struct input_dev *idev; | |
57 | struct input_dev *bs_idev; | |
44051a68 | 58 | struct notifier_block notifier; |
6af6dc2d SG |
59 | }; |
60 | ||
61 | ||
cdd7950e DA |
62 | /** |
63 | * cros_ec_bs_map - Struct mapping Linux keycodes to EC button/switch bitmap | |
64 | * #defines | |
65 | * | |
66 | * @ev_type: The type of the input event to generate (e.g., EV_KEY). | |
67 | * @code: A linux keycode | |
68 | * @bit: A #define like EC_MKBP_POWER_BUTTON or EC_MKBP_LID_OPEN | |
69 | * @inverted: If the #define and EV_SW have opposite meanings, this is true. | |
70 | * Only applicable to switches. | |
71 | */ | |
72 | struct cros_ec_bs_map { | |
73 | unsigned int ev_type; | |
74 | unsigned int code; | |
75 | u8 bit; | |
76 | bool inverted; | |
77 | }; | |
78 | ||
79 | /* cros_ec_keyb_bs - Map EC button/switch #defines into kernel ones */ | |
80 | static const struct cros_ec_bs_map cros_ec_keyb_bs[] = { | |
81 | /* Buttons */ | |
82 | { | |
83 | .ev_type = EV_KEY, | |
84 | .code = KEY_POWER, | |
85 | .bit = EC_MKBP_POWER_BUTTON, | |
86 | }, | |
87 | { | |
88 | .ev_type = EV_KEY, | |
89 | .code = KEY_VOLUMEUP, | |
90 | .bit = EC_MKBP_VOL_UP, | |
91 | }, | |
92 | { | |
93 | .ev_type = EV_KEY, | |
94 | .code = KEY_VOLUMEDOWN, | |
95 | .bit = EC_MKBP_VOL_DOWN, | |
96 | }, | |
97 | ||
98 | /* Switches */ | |
99 | { | |
100 | .ev_type = EV_SW, | |
101 | .code = SW_LID, | |
102 | .bit = EC_MKBP_LID_OPEN, | |
103 | .inverted = true, | |
104 | }, | |
6ccc3a33 GG |
105 | { |
106 | .ev_type = EV_SW, | |
107 | .code = SW_TABLET_MODE, | |
108 | .bit = EC_MKBP_TABLET_MODE, | |
109 | }, | |
cdd7950e DA |
110 | }; |
111 | ||
6af6dc2d SG |
112 | /* |
113 | * Returns true when there is at least one combination of pressed keys that | |
114 | * results in ghosting. | |
115 | */ | |
116 | static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb *ckdev, uint8_t *buf) | |
117 | { | |
017f14e8 TB |
118 | int col1, col2, buf1, buf2; |
119 | struct device *dev = ckdev->dev; | |
120 | uint8_t *valid_keys = ckdev->valid_keys; | |
6af6dc2d SG |
121 | |
122 | /* | |
123 | * Ghosting happens if for any pressed key X there are other keys | |
124 | * pressed both in the same row and column of X as, for instance, | |
125 | * in the following diagram: | |
126 | * | |
127 | * . . Y . g . | |
128 | * . . . . . . | |
129 | * . . . . . . | |
130 | * . . X . Z . | |
131 | * | |
132 | * In this case only X, Y, and Z are pressed, but g appears to be | |
133 | * pressed too (see Wikipedia). | |
6af6dc2d | 134 | */ |
017f14e8 TB |
135 | for (col1 = 0; col1 < ckdev->cols; col1++) { |
136 | buf1 = buf[col1] & valid_keys[col1]; | |
137 | for (col2 = col1 + 1; col2 < ckdev->cols; col2++) { | |
138 | buf2 = buf[col2] & valid_keys[col2]; | |
139 | if (hweight8(buf1 & buf2) > 1) { | |
140 | dev_dbg(dev, "ghost found at: B[%02d]:0x%02x & B[%02d]:0x%02x", | |
141 | col1, buf1, col2, buf2); | |
142 | return true; | |
143 | } | |
144 | } | |
145 | } | |
6af6dc2d SG |
146 | |
147 | return false; | |
148 | } | |
149 | ||
017f14e8 | 150 | |
6af6dc2d SG |
151 | /* |
152 | * Compares the new keyboard state to the old one and produces key | |
153 | * press/release events accordingly. The keyboard state is 13 bytes (one byte | |
154 | * per column) | |
155 | */ | |
156 | static void cros_ec_keyb_process(struct cros_ec_keyb *ckdev, | |
157 | uint8_t *kb_state, int len) | |
158 | { | |
159 | struct input_dev *idev = ckdev->idev; | |
160 | int col, row; | |
161 | int new_state; | |
64757eba | 162 | int old_state; |
6af6dc2d SG |
163 | |
164 | if (ckdev->ghost_filter && cros_ec_keyb_has_ghosting(ckdev, kb_state)) { | |
165 | /* | |
166 | * Simple-minded solution: ignore this state. The obvious | |
167 | * improvement is to only ignore changes to keys involved in | |
168 | * the ghosting, but process the other changes. | |
169 | */ | |
170 | dev_dbg(ckdev->dev, "ghosting found\n"); | |
171 | return; | |
172 | } | |
173 | ||
174 | for (col = 0; col < ckdev->cols; col++) { | |
175 | for (row = 0; row < ckdev->rows; row++) { | |
176 | int pos = MATRIX_SCAN_CODE(row, col, ckdev->row_shift); | |
177 | const unsigned short *keycodes = idev->keycode; | |
6af6dc2d | 178 | |
6af6dc2d | 179 | new_state = kb_state[col] & (1 << row); |
64757eba DA |
180 | old_state = ckdev->old_kb_state[col] & (1 << row); |
181 | if (new_state != old_state) { | |
6af6dc2d SG |
182 | dev_dbg(ckdev->dev, |
183 | "changed: [r%d c%d]: byte %02x\n", | |
184 | row, col, new_state); | |
185 | ||
64757eba DA |
186 | input_report_key(idev, keycodes[pos], |
187 | new_state); | |
6af6dc2d SG |
188 | } |
189 | } | |
64757eba | 190 | ckdev->old_kb_state[col] = kb_state[col]; |
6af6dc2d SG |
191 | } |
192 | input_sync(ckdev->idev); | |
193 | } | |
194 | ||
cdd7950e DA |
195 | /** |
196 | * cros_ec_keyb_report_bs - Report non-matrixed buttons or switches | |
197 | * | |
198 | * This takes a bitmap of buttons or switches from the EC and reports events, | |
199 | * syncing at the end. | |
200 | * | |
201 | * @ckdev: The keyboard device. | |
202 | * @ev_type: The input event type (e.g., EV_KEY). | |
203 | * @mask: A bitmap of buttons from the EC. | |
204 | */ | |
205 | static void cros_ec_keyb_report_bs(struct cros_ec_keyb *ckdev, | |
206 | unsigned int ev_type, u32 mask) | |
207 | ||
6af6dc2d | 208 | { |
cdd7950e DA |
209 | struct input_dev *idev = ckdev->bs_idev; |
210 | int i; | |
6af6dc2d | 211 | |
cdd7950e DA |
212 | for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) { |
213 | const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i]; | |
d1fd345e | 214 | |
cdd7950e DA |
215 | if (map->ev_type != ev_type) |
216 | continue; | |
d1fd345e | 217 | |
cdd7950e DA |
218 | input_event(idev, ev_type, map->code, |
219 | !!(mask & BIT(map->bit)) ^ map->inverted); | |
220 | } | |
221 | input_sync(idev); | |
d1fd345e AB |
222 | } |
223 | ||
44051a68 VY |
224 | static int cros_ec_keyb_work(struct notifier_block *nb, |
225 | unsigned long queued_during_suspend, void *_notify) | |
d1fd345e | 226 | { |
44051a68 VY |
227 | struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb, |
228 | notifier); | |
cdd7950e DA |
229 | u32 val; |
230 | unsigned int ev_type; | |
d1fd345e | 231 | |
925ffff2 RCS |
232 | /* |
233 | * If not wake enabled, discard key state changes during | |
234 | * suspend. Switches will be re-checked in | |
235 | * cros_ec_keyb_resume() to be sure nothing is lost. | |
236 | */ | |
237 | if (queued_during_suspend && !device_may_wakeup(ckdev->dev)) | |
238 | return NOTIFY_OK; | |
239 | ||
99cdb247 | 240 | switch (ckdev->ec->event_data.event_type) { |
cdd7950e | 241 | case EC_MKBP_EVENT_KEY_MATRIX: |
925ffff2 | 242 | pm_wakeup_event(ckdev->dev, 0); |
cdd7950e DA |
243 | |
244 | if (ckdev->ec->event_size != ckdev->cols) { | |
245 | dev_err(ckdev->dev, | |
246 | "Discarded incomplete key matrix event.\n"); | |
247 | return NOTIFY_OK; | |
248 | } | |
38ba34a4 | 249 | |
cdd7950e DA |
250 | cros_ec_keyb_process(ckdev, |
251 | ckdev->ec->event_data.data.key_matrix, | |
252 | ckdev->ec->event_size); | |
253 | break; | |
254 | ||
e6eba3fa | 255 | case EC_MKBP_EVENT_SYSRQ: |
925ffff2 | 256 | pm_wakeup_event(ckdev->dev, 0); |
38ba34a4 | 257 | |
e6eba3fa RJ |
258 | val = get_unaligned_le32(&ckdev->ec->event_data.data.sysrq); |
259 | dev_dbg(ckdev->dev, "sysrq code from EC: %#x\n", val); | |
260 | handle_sysrq(val); | |
261 | break; | |
262 | ||
cdd7950e DA |
263 | case EC_MKBP_EVENT_BUTTON: |
264 | case EC_MKBP_EVENT_SWITCH: | |
925ffff2 | 265 | pm_wakeup_event(ckdev->dev, 0); |
cdd7950e | 266 | |
3bcce2e8 | 267 | if (ckdev->ec->event_data.event_type == EC_MKBP_EVENT_BUTTON) { |
cdd7950e DA |
268 | val = get_unaligned_le32( |
269 | &ckdev->ec->event_data.data.buttons); | |
270 | ev_type = EV_KEY; | |
271 | } else { | |
272 | val = get_unaligned_le32( | |
273 | &ckdev->ec->event_data.data.switches); | |
274 | ev_type = EV_SW; | |
275 | } | |
276 | cros_ec_keyb_report_bs(ckdev, ev_type, val); | |
277 | break; | |
d1fd345e | 278 | |
cdd7950e | 279 | default: |
44051a68 | 280 | return NOTIFY_DONE; |
44051a68 | 281 | } |
cdd7950e | 282 | |
44051a68 | 283 | return NOTIFY_OK; |
6af6dc2d SG |
284 | } |
285 | ||
017f14e8 TB |
286 | /* |
287 | * Walks keycodes flipping bit in buffer COLUMNS deep where bit is ROW. Used by | |
288 | * ghosting logic to ignore NULL or virtual keys. | |
289 | */ | |
290 | static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb *ckdev) | |
291 | { | |
292 | int row, col; | |
293 | int row_shift = ckdev->row_shift; | |
294 | unsigned short *keymap = ckdev->idev->keycode; | |
295 | unsigned short code; | |
296 | ||
297 | BUG_ON(ckdev->idev->keycodesize != sizeof(*keymap)); | |
298 | ||
299 | for (col = 0; col < ckdev->cols; col++) { | |
300 | for (row = 0; row < ckdev->rows; row++) { | |
301 | code = keymap[MATRIX_SCAN_CODE(row, col, row_shift)]; | |
302 | if (code && (code != KEY_BATTERY)) | |
303 | ckdev->valid_keys[col] |= 1 << row; | |
304 | } | |
305 | dev_dbg(ckdev->dev, "valid_keys[%02d] = 0x%02x\n", | |
306 | col, ckdev->valid_keys[col]); | |
307 | } | |
308 | } | |
309 | ||
cdd7950e DA |
310 | /** |
311 | * cros_ec_keyb_info - Wrap the EC command EC_CMD_MKBP_INFO | |
312 | * | |
313 | * This wraps the EC_CMD_MKBP_INFO, abstracting out all of the marshalling and | |
314 | * unmarshalling and different version nonsense into something simple. | |
315 | * | |
316 | * @ec_dev: The EC device | |
317 | * @info_type: Either EC_MKBP_INFO_SUPPORTED or EC_MKBP_INFO_CURRENT. | |
318 | * @event_type: Either EC_MKBP_EVENT_BUTTON or EC_MKBP_EVENT_SWITCH. Actually | |
319 | * in some cases this could be EC_MKBP_EVENT_KEY_MATRIX or | |
320 | * EC_MKBP_EVENT_HOST_EVENT too but we don't use in this driver. | |
321 | * @result: Where we'll store the result; a union | |
322 | * @result_size: The size of the result. Expected to be the size of one of | |
323 | * the elements in the union. | |
324 | * | |
325 | * Returns 0 if no error or -error upon error. | |
326 | */ | |
327 | static int cros_ec_keyb_info(struct cros_ec_device *ec_dev, | |
328 | enum ec_mkbp_info_type info_type, | |
329 | enum ec_mkbp_event event_type, | |
330 | union ec_response_get_next_data *result, | |
331 | size_t result_size) | |
6af6dc2d | 332 | { |
cdd7950e DA |
333 | struct ec_params_mkbp_info *params; |
334 | struct cros_ec_command *msg; | |
335 | int ret; | |
336 | ||
337 | msg = kzalloc(sizeof(*msg) + max_t(size_t, result_size, | |
338 | sizeof(*params)), GFP_KERNEL); | |
339 | if (!msg) | |
340 | return -ENOMEM; | |
341 | ||
342 | msg->command = EC_CMD_MKBP_INFO; | |
343 | msg->version = 1; | |
344 | msg->outsize = sizeof(*params); | |
345 | msg->insize = result_size; | |
346 | params = (struct ec_params_mkbp_info *)msg->data; | |
347 | params->info_type = info_type; | |
348 | params->event_type = event_type; | |
349 | ||
0bcee119 EBS |
350 | ret = cros_ec_cmd_xfer_status(ec_dev, msg); |
351 | if (ret == -ENOTSUPP) { | |
cdd7950e DA |
352 | /* With older ECs we just return 0 for everything */ |
353 | memset(result, 0, result_size); | |
354 | ret = 0; | |
0bcee119 EBS |
355 | } else if (ret < 0) { |
356 | dev_warn(ec_dev->dev, "Transfer error %d/%d: %d\n", | |
357 | (int)info_type, (int)event_type, ret); | |
cdd7950e DA |
358 | } else if (ret != result_size) { |
359 | dev_warn(ec_dev->dev, "Wrong size %d/%d: %d != %zu\n", | |
360 | (int)info_type, (int)event_type, | |
361 | ret, result_size); | |
362 | ret = -EPROTO; | |
363 | } else { | |
364 | memcpy(result, msg->data, result_size); | |
365 | ret = 0; | |
366 | } | |
367 | ||
368 | kfree(msg); | |
369 | ||
370 | return ret; | |
371 | } | |
372 | ||
373 | /** | |
374 | * cros_ec_keyb_query_switches - Query the state of switches and report | |
375 | * | |
376 | * This will ask the EC about the current state of switches and report to the | |
377 | * kernel. Note that we don't query for buttons because they are more | |
378 | * transitory and we'll get an update on the next release / press. | |
379 | * | |
380 | * @ckdev: The keyboard device | |
381 | * | |
382 | * Returns 0 if no error or -error upon error. | |
383 | */ | |
384 | static int cros_ec_keyb_query_switches(struct cros_ec_keyb *ckdev) | |
385 | { | |
386 | struct cros_ec_device *ec_dev = ckdev->ec; | |
387 | union ec_response_get_next_data event_data = {}; | |
388 | int ret; | |
389 | ||
390 | ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_CURRENT, | |
391 | EC_MKBP_EVENT_SWITCH, &event_data, | |
392 | sizeof(event_data.switches)); | |
393 | if (ret) | |
394 | return ret; | |
395 | ||
396 | cros_ec_keyb_report_bs(ckdev, EV_SW, | |
397 | get_unaligned_le32(&event_data.switches)); | |
398 | ||
399 | return 0; | |
400 | } | |
401 | ||
402 | /** | |
403 | * cros_ec_keyb_resume - Resume the keyboard | |
404 | * | |
405 | * We use the resume notification as a chance to query the EC for switches. | |
406 | * | |
407 | * @dev: The keyboard device | |
408 | * | |
409 | * Returns 0 if no error or -error upon error. | |
410 | */ | |
411 | static __maybe_unused int cros_ec_keyb_resume(struct device *dev) | |
412 | { | |
413 | struct cros_ec_keyb *ckdev = dev_get_drvdata(dev); | |
414 | ||
415 | if (ckdev->bs_idev) | |
416 | return cros_ec_keyb_query_switches(ckdev); | |
417 | ||
418 | return 0; | |
419 | } | |
420 | ||
421 | /** | |
422 | * cros_ec_keyb_register_bs - Register non-matrix buttons/switches | |
423 | * | |
424 | * Handles all the bits of the keyboard driver related to non-matrix buttons | |
425 | * and switches, including asking the EC about which are present and telling | |
426 | * the kernel to expect them. | |
427 | * | |
428 | * If this device has no support for buttons and switches we'll return no error | |
429 | * but the ckdev->bs_idev will remain NULL when this function exits. | |
430 | * | |
431 | * @ckdev: The keyboard device | |
432 | * | |
433 | * Returns 0 if no error or -error upon error. | |
434 | */ | |
435 | static int cros_ec_keyb_register_bs(struct cros_ec_keyb *ckdev) | |
436 | { | |
437 | struct cros_ec_device *ec_dev = ckdev->ec; | |
438 | struct device *dev = ckdev->dev; | |
6af6dc2d | 439 | struct input_dev *idev; |
cdd7950e DA |
440 | union ec_response_get_next_data event_data = {}; |
441 | const char *phys; | |
442 | u32 buttons; | |
443 | u32 switches; | |
444 | int ret; | |
445 | int i; | |
446 | ||
447 | ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED, | |
448 | EC_MKBP_EVENT_BUTTON, &event_data, | |
449 | sizeof(event_data.buttons)); | |
450 | if (ret) | |
451 | return ret; | |
452 | buttons = get_unaligned_le32(&event_data.buttons); | |
453 | ||
454 | ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED, | |
455 | EC_MKBP_EVENT_SWITCH, &event_data, | |
456 | sizeof(event_data.switches)); | |
457 | if (ret) | |
458 | return ret; | |
459 | switches = get_unaligned_le32(&event_data.switches); | |
460 | ||
461 | if (!buttons && !switches) | |
462 | return 0; | |
6af6dc2d | 463 | |
cdd7950e DA |
464 | /* |
465 | * We call the non-matrix buttons/switches 'input1', if present. | |
466 | * Allocate phys before input dev, to ensure correct tear-down | |
467 | * ordering. | |
468 | */ | |
469 | phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input1", ec_dev->phys_name); | |
470 | if (!phys) | |
471 | return -ENOMEM; | |
6af6dc2d | 472 | |
cdd7950e DA |
473 | idev = devm_input_allocate_device(dev); |
474 | if (!idev) | |
6af6dc2d | 475 | return -ENOMEM; |
aef01aad | 476 | |
cdd7950e DA |
477 | idev->name = "cros_ec_buttons"; |
478 | idev->phys = phys; | |
479 | __set_bit(EV_REP, idev->evbit); | |
480 | ||
481 | idev->id.bustype = BUS_VIRTUAL; | |
482 | idev->id.version = 1; | |
483 | idev->id.product = 0; | |
484 | idev->dev.parent = dev; | |
485 | ||
486 | input_set_drvdata(idev, ckdev); | |
487 | ckdev->bs_idev = idev; | |
488 | ||
489 | for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) { | |
490 | const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i]; | |
491 | ||
ac5722c1 BN |
492 | if ((map->ev_type == EV_KEY && (buttons & BIT(map->bit))) || |
493 | (map->ev_type == EV_SW && (switches & BIT(map->bit)))) | |
cdd7950e DA |
494 | input_set_capability(idev, map->ev_type, map->code); |
495 | } | |
496 | ||
497 | ret = cros_ec_keyb_query_switches(ckdev); | |
498 | if (ret) { | |
499 | dev_err(dev, "cannot query switches\n"); | |
500 | return ret; | |
501 | } | |
502 | ||
503 | ret = input_register_device(ckdev->bs_idev); | |
504 | if (ret) { | |
505 | dev_err(dev, "cannot register input device\n"); | |
506 | return ret; | |
507 | } | |
508 | ||
509 | return 0; | |
510 | } | |
511 | ||
512 | /** | |
513 | * cros_ec_keyb_register_bs - Register matrix keys | |
514 | * | |
515 | * Handles all the bits of the keyboard driver related to matrix keys. | |
516 | * | |
517 | * @ckdev: The keyboard device | |
518 | * | |
519 | * Returns 0 if no error or -error upon error. | |
520 | */ | |
521 | static int cros_ec_keyb_register_matrix(struct cros_ec_keyb *ckdev) | |
522 | { | |
523 | struct cros_ec_device *ec_dev = ckdev->ec; | |
524 | struct device *dev = ckdev->dev; | |
525 | struct input_dev *idev; | |
526 | const char *phys; | |
527 | int err; | |
528 | ||
aef01aad | 529 | err = matrix_keypad_parse_properties(dev, &ckdev->rows, &ckdev->cols); |
6af6dc2d SG |
530 | if (err) |
531 | return err; | |
017f14e8 | 532 | |
8f97f8e5 | 533 | ckdev->valid_keys = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL); |
017f14e8 TB |
534 | if (!ckdev->valid_keys) |
535 | return -ENOMEM; | |
536 | ||
8f97f8e5 | 537 | ckdev->old_kb_state = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL); |
64757eba DA |
538 | if (!ckdev->old_kb_state) |
539 | return -ENOMEM; | |
6af6dc2d | 540 | |
cdd7950e DA |
541 | /* |
542 | * We call the keyboard matrix 'input0'. Allocate phys before input | |
543 | * dev, to ensure correct tear-down ordering. | |
544 | */ | |
545 | phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", ec_dev->phys_name); | |
546 | if (!phys) | |
547 | return -ENOMEM; | |
548 | ||
8f97f8e5 | 549 | idev = devm_input_allocate_device(dev); |
6af6dc2d SG |
550 | if (!idev) |
551 | return -ENOMEM; | |
552 | ||
57b33ff0 | 553 | idev->name = CROS_EC_DEV_NAME; |
cdd7950e | 554 | idev->phys = phys; |
6af6dc2d SG |
555 | __set_bit(EV_REP, idev->evbit); |
556 | ||
557 | idev->id.bustype = BUS_VIRTUAL; | |
558 | idev->id.version = 1; | |
559 | idev->id.product = 0; | |
8f97f8e5 | 560 | idev->dev.parent = dev; |
6af6dc2d | 561 | |
cdd7950e | 562 | ckdev->ghost_filter = of_property_read_bool(dev->of_node, |
6af6dc2d SG |
563 | "google,needs-ghost-filter"); |
564 | ||
565 | err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols, | |
566 | NULL, idev); | |
567 | if (err) { | |
568 | dev_err(dev, "cannot build key matrix\n"); | |
569 | return err; | |
570 | } | |
571 | ||
572 | ckdev->row_shift = get_count_order(ckdev->cols); | |
573 | ||
574 | input_set_capability(idev, EV_MSC, MSC_SCAN); | |
575 | input_set_drvdata(idev, ckdev); | |
576 | ckdev->idev = idev; | |
017f14e8 TB |
577 | cros_ec_keyb_compute_valid_keys(ckdev); |
578 | ||
6af6dc2d SG |
579 | err = input_register_device(ckdev->idev); |
580 | if (err) { | |
581 | dev_err(dev, "cannot register input device\n"); | |
582 | return err; | |
583 | } | |
584 | ||
585 | return 0; | |
586 | } | |
587 | ||
cdd7950e DA |
588 | static int cros_ec_keyb_probe(struct platform_device *pdev) |
589 | { | |
590 | struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); | |
591 | struct device *dev = &pdev->dev; | |
592 | struct cros_ec_keyb *ckdev; | |
593 | int err; | |
594 | ||
595 | if (!dev->of_node) | |
596 | return -ENODEV; | |
597 | ||
598 | ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL); | |
599 | if (!ckdev) | |
600 | return -ENOMEM; | |
601 | ||
602 | ckdev->ec = ec; | |
603 | ckdev->dev = dev; | |
604 | dev_set_drvdata(dev, ckdev); | |
605 | ||
606 | err = cros_ec_keyb_register_matrix(ckdev); | |
607 | if (err) { | |
608 | dev_err(dev, "cannot register matrix inputs: %d\n", err); | |
609 | return err; | |
610 | } | |
611 | ||
612 | err = cros_ec_keyb_register_bs(ckdev); | |
613 | if (err) { | |
614 | dev_err(dev, "cannot register non-matrix inputs: %d\n", err); | |
615 | return err; | |
616 | } | |
617 | ||
618 | ckdev->notifier.notifier_call = cros_ec_keyb_work; | |
619 | err = blocking_notifier_chain_register(&ckdev->ec->event_notifier, | |
620 | &ckdev->notifier); | |
621 | if (err) { | |
622 | dev_err(dev, "cannot register notifier: %d\n", err); | |
623 | return err; | |
624 | } | |
625 | ||
38ba34a4 | 626 | device_init_wakeup(ckdev->dev, true); |
cdd7950e DA |
627 | return 0; |
628 | } | |
629 | ||
630 | static int cros_ec_keyb_remove(struct platform_device *pdev) | |
631 | { | |
632 | struct cros_ec_keyb *ckdev = dev_get_drvdata(&pdev->dev); | |
633 | ||
634 | blocking_notifier_chain_unregister(&ckdev->ec->event_notifier, | |
635 | &ckdev->notifier); | |
636 | ||
637 | return 0; | |
638 | } | |
639 | ||
3f1fe73b SS |
640 | #ifdef CONFIG_OF |
641 | static const struct of_device_id cros_ec_keyb_of_match[] = { | |
642 | { .compatible = "google,cros-ec-keyb" }, | |
643 | {}, | |
644 | }; | |
645 | MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match); | |
646 | #endif | |
647 | ||
3af92561 | 648 | static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume); |
cdd7950e | 649 | |
6af6dc2d SG |
650 | static struct platform_driver cros_ec_keyb_driver = { |
651 | .probe = cros_ec_keyb_probe, | |
cdd7950e | 652 | .remove = cros_ec_keyb_remove, |
6af6dc2d SG |
653 | .driver = { |
654 | .name = "cros-ec-keyb", | |
3f1fe73b | 655 | .of_match_table = of_match_ptr(cros_ec_keyb_of_match), |
cdd7950e | 656 | .pm = &cros_ec_keyb_pm_ops, |
6af6dc2d SG |
657 | }, |
658 | }; | |
659 | ||
660 | module_platform_driver(cros_ec_keyb_driver); | |
661 | ||
e7a35f12 | 662 | MODULE_LICENSE("GPL v2"); |
6af6dc2d SG |
663 | MODULE_DESCRIPTION("ChromeOS EC keyboard driver"); |
664 | MODULE_ALIAS("platform:cros-ec-keyb"); |