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