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. 13 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> 27 28#include <asm/unaligned.h> 29 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 36 * @valid_keys: bitmap of existing keys for each matrix column 37 * @old_kb_state: bitmap of keys pressed last scan 38 * @dev: Device pointer 39 * @ec: Top level ChromeOS device to use to talk to EC 40 * @idev: The input device for the matrix keys. 41 * @bs_idev: The input device for non-matrix buttons and switches (or NULL). 42 * @notifier: interrupt event notifier for transport devices 43 */ 44struct 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; 50 uint8_t *valid_keys; 51 uint8_t *old_kb_state; 52 53 struct device *dev; 54 struct cros_ec_device *ec; 55 56 struct input_dev *idev; 57 struct input_dev *bs_idev; 58 struct notifier_block notifier; 59}; 60 61 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 */ 72struct 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 */ 80static 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 }, 105 { 106 .ev_type = EV_SW, 107 .code = SW_TABLET_MODE, 108 .bit = EC_MKBP_TABLET_MODE, 109 }, 110}; 111 112/* 113 * Returns true when there is at least one combination of pressed keys that 114 * results in ghosting. 115 */ 116static bool cros_ec_keyb_has_ghosting(struct cros_ec_keyb *ckdev, uint8_t *buf) 117{ 118 int col1, col2, buf1, buf2; 119 struct device *dev = ckdev->dev; 120 uint8_t *valid_keys = ckdev->valid_keys; 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). 134 */ 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 } 146 147 return false; 148} 149 150 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 */ 156static 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; 162 int old_state; 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; 178 179 new_state = kb_state[col] & (1 << row); 180 old_state = ckdev->old_kb_state[col] & (1 << row); 181 if (new_state != old_state) { 182 dev_dbg(ckdev->dev, 183 "changed: [r%d c%d]: byte %02x\n", 184 row, col, new_state); 185 186 input_event(idev, EV_MSC, MSC_SCAN, pos); 187 input_report_key(idev, keycodes[pos], 188 new_state); 189 } 190 } 191 ckdev->old_kb_state[col] = kb_state[col]; 192 } 193 input_sync(ckdev->idev); 194} 195 196/** 197 * cros_ec_keyb_report_bs - Report non-matrixed buttons or switches 198 * 199 * This takes a bitmap of buttons or switches from the EC and reports events, 200 * syncing at the end. 201 * 202 * @ckdev: The keyboard device. 203 * @ev_type: The input event type (e.g., EV_KEY). 204 * @mask: A bitmap of buttons from the EC. 205 */ 206static void cros_ec_keyb_report_bs(struct cros_ec_keyb *ckdev, 207 unsigned int ev_type, u32 mask) 208 209{ 210 struct input_dev *idev = ckdev->bs_idev; 211 int i; 212 213 for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) { 214 const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i]; 215 216 if (map->ev_type != ev_type) 217 continue; 218 219 input_event(idev, ev_type, map->code, 220 !!(mask & BIT(map->bit)) ^ map->inverted); 221 } 222 input_sync(idev); 223} 224 225static int cros_ec_keyb_work(struct notifier_block *nb, 226 unsigned long queued_during_suspend, void *_notify) 227{ 228 struct cros_ec_keyb *ckdev = container_of(nb, struct cros_ec_keyb, 229 notifier); 230 u32 val; 231 unsigned int ev_type; 232 233 /* 234 * If not wake enabled, discard key state changes during 235 * suspend. Switches will be re-checked in 236 * cros_ec_keyb_resume() to be sure nothing is lost. 237 */ 238 if (queued_during_suspend && !device_may_wakeup(ckdev->dev)) 239 return NOTIFY_OK; 240 241 switch (ckdev->ec->event_data.event_type) { 242 case EC_MKBP_EVENT_KEY_MATRIX: 243 pm_wakeup_event(ckdev->dev, 0); 244 245 if (ckdev->ec->event_size != ckdev->cols) { 246 dev_err(ckdev->dev, 247 "Discarded incomplete key matrix event.\n"); 248 return NOTIFY_OK; 249 } 250 251 cros_ec_keyb_process(ckdev, 252 ckdev->ec->event_data.data.key_matrix, 253 ckdev->ec->event_size); 254 break; 255 256 case EC_MKBP_EVENT_SYSRQ: 257 pm_wakeup_event(ckdev->dev, 0); 258 259 val = get_unaligned_le32(&ckdev->ec->event_data.data.sysrq); 260 dev_dbg(ckdev->dev, "sysrq code from EC: %#x\n", val); 261 handle_sysrq(val); 262 break; 263 264 case EC_MKBP_EVENT_BUTTON: 265 case EC_MKBP_EVENT_SWITCH: 266 pm_wakeup_event(ckdev->dev, 0); 267 268 if (ckdev->ec->event_data.event_type == EC_MKBP_EVENT_BUTTON) { 269 val = get_unaligned_le32( 270 &ckdev->ec->event_data.data.buttons); 271 ev_type = EV_KEY; 272 } else { 273 val = get_unaligned_le32( 274 &ckdev->ec->event_data.data.switches); 275 ev_type = EV_SW; 276 } 277 cros_ec_keyb_report_bs(ckdev, ev_type, val); 278 break; 279 280 default: 281 return NOTIFY_DONE; 282 } 283 284 return NOTIFY_OK; 285} 286 287/* 288 * Walks keycodes flipping bit in buffer COLUMNS deep where bit is ROW. Used by 289 * ghosting logic to ignore NULL or virtual keys. 290 */ 291static void cros_ec_keyb_compute_valid_keys(struct cros_ec_keyb *ckdev) 292{ 293 int row, col; 294 int row_shift = ckdev->row_shift; 295 unsigned short *keymap = ckdev->idev->keycode; 296 unsigned short code; 297 298 BUG_ON(ckdev->idev->keycodesize != sizeof(*keymap)); 299 300 for (col = 0; col < ckdev->cols; col++) { 301 for (row = 0; row < ckdev->rows; row++) { 302 code = keymap[MATRIX_SCAN_CODE(row, col, row_shift)]; 303 if (code && (code != KEY_BATTERY)) 304 ckdev->valid_keys[col] |= 1 << row; 305 } 306 dev_dbg(ckdev->dev, "valid_keys[%02d] = 0x%02x\n", 307 col, ckdev->valid_keys[col]); 308 } 309} 310 311/** 312 * cros_ec_keyb_info - Wrap the EC command EC_CMD_MKBP_INFO 313 * 314 * This wraps the EC_CMD_MKBP_INFO, abstracting out all of the marshalling and 315 * unmarshalling and different version nonsense into something simple. 316 * 317 * @ec_dev: The EC device 318 * @info_type: Either EC_MKBP_INFO_SUPPORTED or EC_MKBP_INFO_CURRENT. 319 * @event_type: Either EC_MKBP_EVENT_BUTTON or EC_MKBP_EVENT_SWITCH. Actually 320 * in some cases this could be EC_MKBP_EVENT_KEY_MATRIX or 321 * EC_MKBP_EVENT_HOST_EVENT too but we don't use in this driver. 322 * @result: Where we'll store the result; a union 323 * @result_size: The size of the result. Expected to be the size of one of 324 * the elements in the union. 325 * 326 * Returns 0 if no error or -error upon error. 327 */ 328static int cros_ec_keyb_info(struct cros_ec_device *ec_dev, 329 enum ec_mkbp_info_type info_type, 330 enum ec_mkbp_event event_type, 331 union ec_response_get_next_data *result, 332 size_t result_size) 333{ 334 struct ec_params_mkbp_info *params; 335 struct cros_ec_command *msg; 336 int ret; 337 338 msg = kzalloc(sizeof(*msg) + max_t(size_t, result_size, 339 sizeof(*params)), GFP_KERNEL); 340 if (!msg) 341 return -ENOMEM; 342 343 msg->command = EC_CMD_MKBP_INFO; 344 msg->version = 1; 345 msg->outsize = sizeof(*params); 346 msg->insize = result_size; 347 params = (struct ec_params_mkbp_info *)msg->data; 348 params->info_type = info_type; 349 params->event_type = event_type; 350 351 ret = cros_ec_cmd_xfer_status(ec_dev, msg); 352 if (ret == -ENOPROTOOPT) { 353 /* With older ECs we just return 0 for everything */ 354 memset(result, 0, result_size); 355 ret = 0; 356 } else if (ret < 0) { 357 dev_warn(ec_dev->dev, "Transfer error %d/%d: %d\n", 358 (int)info_type, (int)event_type, ret); 359 } else if (ret != result_size) { 360 dev_warn(ec_dev->dev, "Wrong size %d/%d: %d != %zu\n", 361 (int)info_type, (int)event_type, 362 ret, result_size); 363 ret = -EPROTO; 364 } else { 365 memcpy(result, msg->data, result_size); 366 ret = 0; 367 } 368 369 kfree(msg); 370 371 return ret; 372} 373 374/** 375 * cros_ec_keyb_query_switches - Query the state of switches and report 376 * 377 * This will ask the EC about the current state of switches and report to the 378 * kernel. Note that we don't query for buttons because they are more 379 * transitory and we'll get an update on the next release / press. 380 * 381 * @ckdev: The keyboard device 382 * 383 * Returns 0 if no error or -error upon error. 384 */ 385static int cros_ec_keyb_query_switches(struct cros_ec_keyb *ckdev) 386{ 387 struct cros_ec_device *ec_dev = ckdev->ec; 388 union ec_response_get_next_data event_data = {}; 389 int ret; 390 391 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_CURRENT, 392 EC_MKBP_EVENT_SWITCH, &event_data, 393 sizeof(event_data.switches)); 394 if (ret) 395 return ret; 396 397 cros_ec_keyb_report_bs(ckdev, EV_SW, 398 get_unaligned_le32(&event_data.switches)); 399 400 return 0; 401} 402 403/** 404 * cros_ec_keyb_resume - Resume the keyboard 405 * 406 * We use the resume notification as a chance to query the EC for switches. 407 * 408 * @dev: The keyboard device 409 * 410 * Returns 0 if no error or -error upon error. 411 */ 412static __maybe_unused int cros_ec_keyb_resume(struct device *dev) 413{ 414 struct cros_ec_keyb *ckdev = dev_get_drvdata(dev); 415 416 if (ckdev->bs_idev) 417 return cros_ec_keyb_query_switches(ckdev); 418 419 return 0; 420} 421 422/** 423 * cros_ec_keyb_register_bs - Register non-matrix buttons/switches 424 * 425 * Handles all the bits of the keyboard driver related to non-matrix buttons 426 * and switches, including asking the EC about which are present and telling 427 * the kernel to expect them. 428 * 429 * If this device has no support for buttons and switches we'll return no error 430 * but the ckdev->bs_idev will remain NULL when this function exits. 431 * 432 * @ckdev: The keyboard device 433 * 434 * Returns 0 if no error or -error upon error. 435 */ 436static int cros_ec_keyb_register_bs(struct cros_ec_keyb *ckdev) 437{ 438 struct cros_ec_device *ec_dev = ckdev->ec; 439 struct device *dev = ckdev->dev; 440 struct input_dev *idev; 441 union ec_response_get_next_data event_data = {}; 442 const char *phys; 443 u32 buttons; 444 u32 switches; 445 int ret; 446 int i; 447 448 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED, 449 EC_MKBP_EVENT_BUTTON, &event_data, 450 sizeof(event_data.buttons)); 451 if (ret) 452 return ret; 453 buttons = get_unaligned_le32(&event_data.buttons); 454 455 ret = cros_ec_keyb_info(ec_dev, EC_MKBP_INFO_SUPPORTED, 456 EC_MKBP_EVENT_SWITCH, &event_data, 457 sizeof(event_data.switches)); 458 if (ret) 459 return ret; 460 switches = get_unaligned_le32(&event_data.switches); 461 462 if (!buttons && !switches) 463 return 0; 464 465 /* 466 * We call the non-matrix buttons/switches 'input1', if present. 467 * Allocate phys before input dev, to ensure correct tear-down 468 * ordering. 469 */ 470 phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input1", ec_dev->phys_name); 471 if (!phys) 472 return -ENOMEM; 473 474 idev = devm_input_allocate_device(dev); 475 if (!idev) 476 return -ENOMEM; 477 478 idev->name = "cros_ec_buttons"; 479 idev->phys = phys; 480 __set_bit(EV_REP, idev->evbit); 481 482 idev->id.bustype = BUS_VIRTUAL; 483 idev->id.version = 1; 484 idev->id.product = 0; 485 idev->dev.parent = dev; 486 487 input_set_drvdata(idev, ckdev); 488 ckdev->bs_idev = idev; 489 490 for (i = 0; i < ARRAY_SIZE(cros_ec_keyb_bs); i++) { 491 const struct cros_ec_bs_map *map = &cros_ec_keyb_bs[i]; 492 493 if ((map->ev_type == EV_KEY && (buttons & BIT(map->bit))) || 494 (map->ev_type == EV_SW && (switches & BIT(map->bit)))) 495 input_set_capability(idev, map->ev_type, map->code); 496 } 497 498 ret = cros_ec_keyb_query_switches(ckdev); 499 if (ret) { 500 dev_err(dev, "cannot query switches\n"); 501 return ret; 502 } 503 504 ret = input_register_device(ckdev->bs_idev); 505 if (ret) { 506 dev_err(dev, "cannot register input device\n"); 507 return ret; 508 } 509 510 return 0; 511} 512 513/** 514 * cros_ec_keyb_register_bs - Register matrix keys 515 * 516 * Handles all the bits of the keyboard driver related to matrix keys. 517 * 518 * @ckdev: The keyboard device 519 * 520 * Returns 0 if no error or -error upon error. 521 */ 522static int cros_ec_keyb_register_matrix(struct cros_ec_keyb *ckdev) 523{ 524 struct cros_ec_device *ec_dev = ckdev->ec; 525 struct device *dev = ckdev->dev; 526 struct input_dev *idev; 527 const char *phys; 528 int err; 529 530 err = matrix_keypad_parse_properties(dev, &ckdev->rows, &ckdev->cols); 531 if (err) 532 return err; 533 534 ckdev->valid_keys = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL); 535 if (!ckdev->valid_keys) 536 return -ENOMEM; 537 538 ckdev->old_kb_state = devm_kzalloc(dev, ckdev->cols, GFP_KERNEL); 539 if (!ckdev->old_kb_state) 540 return -ENOMEM; 541 542 /* 543 * We call the keyboard matrix 'input0'. Allocate phys before input 544 * dev, to ensure correct tear-down ordering. 545 */ 546 phys = devm_kasprintf(dev, GFP_KERNEL, "%s/input0", ec_dev->phys_name); 547 if (!phys) 548 return -ENOMEM; 549 550 idev = devm_input_allocate_device(dev); 551 if (!idev) 552 return -ENOMEM; 553 554 idev->name = CROS_EC_DEV_NAME; 555 idev->phys = phys; 556 __set_bit(EV_REP, idev->evbit); 557 558 idev->id.bustype = BUS_VIRTUAL; 559 idev->id.version = 1; 560 idev->id.product = 0; 561 idev->dev.parent = dev; 562 563 ckdev->ghost_filter = of_property_read_bool(dev->of_node, 564 "google,needs-ghost-filter"); 565 566 err = matrix_keypad_build_keymap(NULL, NULL, ckdev->rows, ckdev->cols, 567 NULL, idev); 568 if (err) { 569 dev_err(dev, "cannot build key matrix\n"); 570 return err; 571 } 572 573 ckdev->row_shift = get_count_order(ckdev->cols); 574 575 input_set_capability(idev, EV_MSC, MSC_SCAN); 576 input_set_drvdata(idev, ckdev); 577 ckdev->idev = idev; 578 cros_ec_keyb_compute_valid_keys(ckdev); 579 580 err = input_register_device(ckdev->idev); 581 if (err) { 582 dev_err(dev, "cannot register input device\n"); 583 return err; 584 } 585 586 return 0; 587} 588 589static int cros_ec_keyb_probe(struct platform_device *pdev) 590{ 591 struct cros_ec_device *ec = dev_get_drvdata(pdev->dev.parent); 592 struct device *dev = &pdev->dev; 593 struct cros_ec_keyb *ckdev; 594 int err; 595 596 if (!dev->of_node) 597 return -ENODEV; 598 599 ckdev = devm_kzalloc(dev, sizeof(*ckdev), GFP_KERNEL); 600 if (!ckdev) 601 return -ENOMEM; 602 603 ckdev->ec = ec; 604 ckdev->dev = dev; 605 dev_set_drvdata(dev, ckdev); 606 607 err = cros_ec_keyb_register_matrix(ckdev); 608 if (err) { 609 dev_err(dev, "cannot register matrix inputs: %d\n", err); 610 return err; 611 } 612 613 err = cros_ec_keyb_register_bs(ckdev); 614 if (err) { 615 dev_err(dev, "cannot register non-matrix inputs: %d\n", err); 616 return err; 617 } 618 619 ckdev->notifier.notifier_call = cros_ec_keyb_work; 620 err = blocking_notifier_chain_register(&ckdev->ec->event_notifier, 621 &ckdev->notifier); 622 if (err) { 623 dev_err(dev, "cannot register notifier: %d\n", err); 624 return err; 625 } 626 627 device_init_wakeup(ckdev->dev, true); 628 return 0; 629} 630 631static int cros_ec_keyb_remove(struct platform_device *pdev) 632{ 633 struct cros_ec_keyb *ckdev = dev_get_drvdata(&pdev->dev); 634 635 blocking_notifier_chain_unregister(&ckdev->ec->event_notifier, 636 &ckdev->notifier); 637 638 return 0; 639} 640 641#ifdef CONFIG_OF 642static const struct of_device_id cros_ec_keyb_of_match[] = { 643 { .compatible = "google,cros-ec-keyb" }, 644 {}, 645}; 646MODULE_DEVICE_TABLE(of, cros_ec_keyb_of_match); 647#endif 648 649static SIMPLE_DEV_PM_OPS(cros_ec_keyb_pm_ops, NULL, cros_ec_keyb_resume); 650 651static struct platform_driver cros_ec_keyb_driver = { 652 .probe = cros_ec_keyb_probe, 653 .remove = cros_ec_keyb_remove, 654 .driver = { 655 .name = "cros-ec-keyb", 656 .of_match_table = of_match_ptr(cros_ec_keyb_of_match), 657 .pm = &cros_ec_keyb_pm_ops, 658 }, 659}; 660 661module_platform_driver(cros_ec_keyb_driver); 662 663MODULE_LICENSE("GPL v2"); 664MODULE_DESCRIPTION("ChromeOS EC keyboard driver"); 665MODULE_ALIAS("platform:cros-ec-keyb"); 666