1 // SPDX-License-Identifier: GPL-2.0 2 // LPC interface for ChromeOS Embedded Controller 3 // 4 // Copyright (C) 2012-2015 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/acpi.h> 15 #include <linux/dmi.h> 16 #include <linux/delay.h> 17 #include <linux/io.h> 18 #include <linux/interrupt.h> 19 #include <linux/module.h> 20 #include <linux/platform_data/cros_ec_commands.h> 21 #include <linux/platform_data/cros_ec_proto.h> 22 #include <linux/platform_device.h> 23 #include <linux/printk.h> 24 #include <linux/suspend.h> 25 26 #include "cros_ec.h" 27 #include "cros_ec_lpc_mec.h" 28 29 #define DRV_NAME "cros_ec_lpcs" 30 #define ACPI_DRV_NAME "GOOG0004" 31 32 /* True if ACPI device is present */ 33 static bool cros_ec_lpc_acpi_device_found; 34 35 /** 36 * struct lpc_driver_ops - LPC driver operations 37 * @read: Copy length bytes from EC address offset into buffer dest. Returns 38 * the 8-bit checksum of all bytes read. 39 * @write: Copy length bytes from buffer msg into EC address offset. Returns 40 * the 8-bit checksum of all bytes written. 41 */ 42 struct lpc_driver_ops { 43 u8 (*read)(unsigned int offset, unsigned int length, u8 *dest); 44 u8 (*write)(unsigned int offset, unsigned int length, const u8 *msg); 45 }; 46 47 static struct lpc_driver_ops cros_ec_lpc_ops = { }; 48 49 /* 50 * A generic instance of the read function of struct lpc_driver_ops, used for 51 * the LPC EC. 52 */ 53 static u8 cros_ec_lpc_read_bytes(unsigned int offset, unsigned int length, 54 u8 *dest) 55 { 56 int sum = 0; 57 int i; 58 59 for (i = 0; i < length; ++i) { 60 dest[i] = inb(offset + i); 61 sum += dest[i]; 62 } 63 64 /* Return checksum of all bytes read */ 65 return sum; 66 } 67 68 /* 69 * A generic instance of the write function of struct lpc_driver_ops, used for 70 * the LPC EC. 71 */ 72 static u8 cros_ec_lpc_write_bytes(unsigned int offset, unsigned int length, 73 const u8 *msg) 74 { 75 int sum = 0; 76 int i; 77 78 for (i = 0; i < length; ++i) { 79 outb(msg[i], offset + i); 80 sum += msg[i]; 81 } 82 83 /* Return checksum of all bytes written */ 84 return sum; 85 } 86 87 /* 88 * An instance of the read function of struct lpc_driver_ops, used for the 89 * MEC variant of LPC EC. 90 */ 91 static u8 cros_ec_lpc_mec_read_bytes(unsigned int offset, unsigned int length, 92 u8 *dest) 93 { 94 int in_range = cros_ec_lpc_mec_in_range(offset, length); 95 96 if (in_range < 0) 97 return 0; 98 99 return in_range ? 100 cros_ec_lpc_io_bytes_mec(MEC_IO_READ, 101 offset - EC_HOST_CMD_REGION0, 102 length, dest) : 103 cros_ec_lpc_read_bytes(offset, length, dest); 104 } 105 106 /* 107 * An instance of the write function of struct lpc_driver_ops, used for the 108 * MEC variant of LPC EC. 109 */ 110 static u8 cros_ec_lpc_mec_write_bytes(unsigned int offset, unsigned int length, 111 const u8 *msg) 112 { 113 int in_range = cros_ec_lpc_mec_in_range(offset, length); 114 115 if (in_range < 0) 116 return 0; 117 118 return in_range ? 119 cros_ec_lpc_io_bytes_mec(MEC_IO_WRITE, 120 offset - EC_HOST_CMD_REGION0, 121 length, (u8 *)msg) : 122 cros_ec_lpc_write_bytes(offset, length, msg); 123 } 124 125 static int ec_response_timed_out(void) 126 { 127 unsigned long one_second = jiffies + HZ; 128 u8 data; 129 130 usleep_range(200, 300); 131 do { 132 if (!(cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_CMD, 1, &data) & 133 EC_LPC_STATUS_BUSY_MASK)) 134 return 0; 135 usleep_range(100, 200); 136 } while (time_before(jiffies, one_second)); 137 138 return 1; 139 } 140 141 static int cros_ec_pkt_xfer_lpc(struct cros_ec_device *ec, 142 struct cros_ec_command *msg) 143 { 144 struct ec_host_response response; 145 u8 sum; 146 int ret = 0; 147 u8 *dout; 148 149 ret = cros_ec_prepare_tx(ec, msg); 150 151 /* Write buffer */ 152 cros_ec_lpc_ops.write(EC_LPC_ADDR_HOST_PACKET, ret, ec->dout); 153 154 /* Here we go */ 155 sum = EC_COMMAND_PROTOCOL_3; 156 cros_ec_lpc_ops.write(EC_LPC_ADDR_HOST_CMD, 1, &sum); 157 158 if (ec_response_timed_out()) { 159 dev_warn(ec->dev, "EC response timed out\n"); 160 ret = -EIO; 161 goto done; 162 } 163 164 /* Check result */ 165 msg->result = cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_DATA, 1, &sum); 166 ret = cros_ec_check_result(ec, msg); 167 if (ret) 168 goto done; 169 170 /* Read back response */ 171 dout = (u8 *)&response; 172 sum = cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_PACKET, sizeof(response), 173 dout); 174 175 msg->result = response.result; 176 177 if (response.data_len > msg->insize) { 178 dev_err(ec->dev, 179 "packet too long (%d bytes, expected %d)", 180 response.data_len, msg->insize); 181 ret = -EMSGSIZE; 182 goto done; 183 } 184 185 /* Read response and process checksum */ 186 sum += cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_PACKET + 187 sizeof(response), response.data_len, 188 msg->data); 189 190 if (sum) { 191 dev_err(ec->dev, 192 "bad packet checksum %02x\n", 193 response.checksum); 194 ret = -EBADMSG; 195 goto done; 196 } 197 198 /* Return actual amount of data received */ 199 ret = response.data_len; 200 done: 201 return ret; 202 } 203 204 static int cros_ec_cmd_xfer_lpc(struct cros_ec_device *ec, 205 struct cros_ec_command *msg) 206 { 207 struct ec_lpc_host_args args; 208 u8 sum; 209 int ret = 0; 210 211 if (msg->outsize > EC_PROTO2_MAX_PARAM_SIZE || 212 msg->insize > EC_PROTO2_MAX_PARAM_SIZE) { 213 dev_err(ec->dev, 214 "invalid buffer sizes (out %d, in %d)\n", 215 msg->outsize, msg->insize); 216 return -EINVAL; 217 } 218 219 /* Now actually send the command to the EC and get the result */ 220 args.flags = EC_HOST_ARGS_FLAG_FROM_HOST; 221 args.command_version = msg->version; 222 args.data_size = msg->outsize; 223 224 /* Initialize checksum */ 225 sum = msg->command + args.flags + args.command_version + args.data_size; 226 227 /* Copy data and update checksum */ 228 sum += cros_ec_lpc_ops.write(EC_LPC_ADDR_HOST_PARAM, msg->outsize, 229 msg->data); 230 231 /* Finalize checksum and write args */ 232 args.checksum = sum; 233 cros_ec_lpc_ops.write(EC_LPC_ADDR_HOST_ARGS, sizeof(args), 234 (u8 *)&args); 235 236 /* Here we go */ 237 sum = msg->command; 238 cros_ec_lpc_ops.write(EC_LPC_ADDR_HOST_CMD, 1, &sum); 239 240 if (ec_response_timed_out()) { 241 dev_warn(ec->dev, "EC response timed out\n"); 242 ret = -EIO; 243 goto done; 244 } 245 246 /* Check result */ 247 msg->result = cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_DATA, 1, &sum); 248 ret = cros_ec_check_result(ec, msg); 249 if (ret) 250 goto done; 251 252 /* Read back args */ 253 cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_ARGS, sizeof(args), (u8 *)&args); 254 255 if (args.data_size > msg->insize) { 256 dev_err(ec->dev, 257 "packet too long (%d bytes, expected %d)", 258 args.data_size, msg->insize); 259 ret = -ENOSPC; 260 goto done; 261 } 262 263 /* Start calculating response checksum */ 264 sum = msg->command + args.flags + args.command_version + args.data_size; 265 266 /* Read response and update checksum */ 267 sum += cros_ec_lpc_ops.read(EC_LPC_ADDR_HOST_PARAM, args.data_size, 268 msg->data); 269 270 /* Verify checksum */ 271 if (args.checksum != sum) { 272 dev_err(ec->dev, 273 "bad packet checksum, expected %02x, got %02x\n", 274 args.checksum, sum); 275 ret = -EBADMSG; 276 goto done; 277 } 278 279 /* Return actual amount of data received */ 280 ret = args.data_size; 281 done: 282 return ret; 283 } 284 285 /* Returns num bytes read, or negative on error. Doesn't need locking. */ 286 static int cros_ec_lpc_readmem(struct cros_ec_device *ec, unsigned int offset, 287 unsigned int bytes, void *dest) 288 { 289 int i = offset; 290 char *s = dest; 291 int cnt = 0; 292 293 if (offset >= EC_MEMMAP_SIZE - bytes) 294 return -EINVAL; 295 296 /* fixed length */ 297 if (bytes) { 298 cros_ec_lpc_ops.read(EC_LPC_ADDR_MEMMAP + offset, bytes, s); 299 return bytes; 300 } 301 302 /* string */ 303 for (; i < EC_MEMMAP_SIZE; i++, s++) { 304 cros_ec_lpc_ops.read(EC_LPC_ADDR_MEMMAP + i, 1, s); 305 cnt++; 306 if (!*s) 307 break; 308 } 309 310 return cnt; 311 } 312 313 static void cros_ec_lpc_acpi_notify(acpi_handle device, u32 value, void *data) 314 { 315 struct cros_ec_device *ec_dev = data; 316 bool ec_has_more_events; 317 int ret; 318 319 ec_dev->last_event_time = cros_ec_get_time_ns(); 320 321 if (ec_dev->mkbp_event_supported) 322 do { 323 ret = cros_ec_get_next_event(ec_dev, NULL, 324 &ec_has_more_events); 325 if (ret > 0) 326 blocking_notifier_call_chain( 327 &ec_dev->event_notifier, 0, 328 ec_dev); 329 } while (ec_has_more_events); 330 331 if (value == ACPI_NOTIFY_DEVICE_WAKE) 332 pm_system_wakeup(); 333 } 334 335 static int cros_ec_lpc_probe(struct platform_device *pdev) 336 { 337 struct device *dev = &pdev->dev; 338 struct acpi_device *adev; 339 acpi_status status; 340 struct cros_ec_device *ec_dev; 341 u8 buf[2]; 342 int irq, ret; 343 344 /* 345 * The Framework Laptop (and possibly other non-ChromeOS devices) 346 * only exposes the eight I/O ports that are required for the Microchip EC. 347 * Requesting a larger reservation will fail. 348 */ 349 if (!devm_request_region(dev, EC_HOST_CMD_REGION0, 350 EC_HOST_CMD_MEC_REGION_SIZE, dev_name(dev))) { 351 dev_err(dev, "couldn't reserve MEC region\n"); 352 return -EBUSY; 353 } 354 355 /* 356 * Read the mapped ID twice, the first one is assuming the 357 * EC is a Microchip Embedded Controller (MEC) variant, if the 358 * protocol fails, fallback to the non MEC variant and try to 359 * read again the ID. 360 */ 361 cros_ec_lpc_ops.read = cros_ec_lpc_mec_read_bytes; 362 cros_ec_lpc_ops.write = cros_ec_lpc_mec_write_bytes; 363 cros_ec_lpc_ops.read(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID, 2, buf); 364 if (buf[0] != 'E' || buf[1] != 'C') { 365 if (!devm_request_region(dev, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE, 366 dev_name(dev))) { 367 dev_err(dev, "couldn't reserve memmap region\n"); 368 return -EBUSY; 369 } 370 371 /* Re-assign read/write operations for the non MEC variant */ 372 cros_ec_lpc_ops.read = cros_ec_lpc_read_bytes; 373 cros_ec_lpc_ops.write = cros_ec_lpc_write_bytes; 374 cros_ec_lpc_ops.read(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID, 2, 375 buf); 376 if (buf[0] != 'E' || buf[1] != 'C') { 377 dev_err(dev, "EC ID not detected\n"); 378 return -ENODEV; 379 } 380 381 /* Reserve the remaining I/O ports required by the non-MEC protocol. */ 382 if (!devm_request_region(dev, EC_HOST_CMD_REGION0 + EC_HOST_CMD_MEC_REGION_SIZE, 383 EC_HOST_CMD_REGION_SIZE - EC_HOST_CMD_MEC_REGION_SIZE, 384 dev_name(dev))) { 385 dev_err(dev, "couldn't reserve remainder of region0\n"); 386 return -EBUSY; 387 } 388 if (!devm_request_region(dev, EC_HOST_CMD_REGION1, 389 EC_HOST_CMD_REGION_SIZE, dev_name(dev))) { 390 dev_err(dev, "couldn't reserve region1\n"); 391 return -EBUSY; 392 } 393 } 394 395 ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL); 396 if (!ec_dev) 397 return -ENOMEM; 398 399 platform_set_drvdata(pdev, ec_dev); 400 ec_dev->dev = dev; 401 ec_dev->phys_name = dev_name(dev); 402 ec_dev->cmd_xfer = cros_ec_cmd_xfer_lpc; 403 ec_dev->pkt_xfer = cros_ec_pkt_xfer_lpc; 404 ec_dev->cmd_readmem = cros_ec_lpc_readmem; 405 ec_dev->din_size = sizeof(struct ec_host_response) + 406 sizeof(struct ec_response_get_protocol_info); 407 ec_dev->dout_size = sizeof(struct ec_host_request); 408 409 /* 410 * Some boards do not have an IRQ allotted for cros_ec_lpc, 411 * which makes ENXIO an expected (and safe) scenario. 412 */ 413 irq = platform_get_irq_optional(pdev, 0); 414 if (irq > 0) 415 ec_dev->irq = irq; 416 else if (irq != -ENXIO) { 417 dev_err(dev, "couldn't retrieve IRQ number (%d)\n", irq); 418 return irq; 419 } 420 421 ret = cros_ec_register(ec_dev); 422 if (ret) { 423 dev_err(dev, "couldn't register ec_dev (%d)\n", ret); 424 return ret; 425 } 426 427 /* 428 * Connect a notify handler to process MKBP messages if we have a 429 * companion ACPI device. 430 */ 431 adev = ACPI_COMPANION(dev); 432 if (adev) { 433 status = acpi_install_notify_handler(adev->handle, 434 ACPI_ALL_NOTIFY, 435 cros_ec_lpc_acpi_notify, 436 ec_dev); 437 if (ACPI_FAILURE(status)) 438 dev_warn(dev, "Failed to register notifier %08x\n", 439 status); 440 } 441 442 return 0; 443 } 444 445 static int cros_ec_lpc_remove(struct platform_device *pdev) 446 { 447 struct cros_ec_device *ec_dev = platform_get_drvdata(pdev); 448 struct acpi_device *adev; 449 450 adev = ACPI_COMPANION(&pdev->dev); 451 if (adev) 452 acpi_remove_notify_handler(adev->handle, ACPI_ALL_NOTIFY, 453 cros_ec_lpc_acpi_notify); 454 455 cros_ec_unregister(ec_dev); 456 457 return 0; 458 } 459 460 static const struct acpi_device_id cros_ec_lpc_acpi_device_ids[] = { 461 { ACPI_DRV_NAME, 0 }, 462 { } 463 }; 464 MODULE_DEVICE_TABLE(acpi, cros_ec_lpc_acpi_device_ids); 465 466 static const struct dmi_system_id cros_ec_lpc_dmi_table[] __initconst = { 467 { 468 /* 469 * Today all Chromebooks/boxes ship with Google_* as version and 470 * coreboot as bios vendor. No other systems with this 471 * combination are known to date. 472 */ 473 .matches = { 474 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 475 DMI_MATCH(DMI_BIOS_VERSION, "Google_"), 476 }, 477 }, 478 { 479 /* 480 * If the box is running custom coreboot firmware then the 481 * DMI BIOS version string will not be matched by "Google_", 482 * but the system vendor string will still be matched by 483 * "GOOGLE". 484 */ 485 .matches = { 486 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 487 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 488 }, 489 }, 490 { 491 /* x86-link, the Chromebook Pixel. */ 492 .matches = { 493 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 494 DMI_MATCH(DMI_PRODUCT_NAME, "Link"), 495 }, 496 }, 497 { 498 /* x86-samus, the Chromebook Pixel 2. */ 499 .matches = { 500 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 501 DMI_MATCH(DMI_PRODUCT_NAME, "Samus"), 502 }, 503 }, 504 { 505 /* x86-peppy, the Acer C720 Chromebook. */ 506 .matches = { 507 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 508 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"), 509 }, 510 }, 511 { 512 /* x86-glimmer, the Lenovo Thinkpad Yoga 11e. */ 513 .matches = { 514 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 515 DMI_MATCH(DMI_PRODUCT_NAME, "Glimmer"), 516 }, 517 }, 518 /* A small number of non-Chromebook/box machines also use the ChromeOS EC */ 519 { 520 /* the Framework Laptop */ 521 .matches = { 522 DMI_MATCH(DMI_SYS_VENDOR, "Framework"), 523 DMI_MATCH(DMI_PRODUCT_NAME, "Laptop"), 524 }, 525 }, 526 { /* sentinel */ } 527 }; 528 MODULE_DEVICE_TABLE(dmi, cros_ec_lpc_dmi_table); 529 530 #ifdef CONFIG_PM_SLEEP 531 static int cros_ec_lpc_suspend(struct device *dev) 532 { 533 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 534 535 return cros_ec_suspend(ec_dev); 536 } 537 538 static int cros_ec_lpc_resume(struct device *dev) 539 { 540 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 541 542 return cros_ec_resume(ec_dev); 543 } 544 #endif 545 546 static const struct dev_pm_ops cros_ec_lpc_pm_ops = { 547 SET_LATE_SYSTEM_SLEEP_PM_OPS(cros_ec_lpc_suspend, cros_ec_lpc_resume) 548 }; 549 550 static struct platform_driver cros_ec_lpc_driver = { 551 .driver = { 552 .name = DRV_NAME, 553 .acpi_match_table = cros_ec_lpc_acpi_device_ids, 554 .pm = &cros_ec_lpc_pm_ops, 555 }, 556 .probe = cros_ec_lpc_probe, 557 .remove = cros_ec_lpc_remove, 558 }; 559 560 static struct platform_device cros_ec_lpc_device = { 561 .name = DRV_NAME 562 }; 563 564 static acpi_status cros_ec_lpc_parse_device(acpi_handle handle, u32 level, 565 void *context, void **retval) 566 { 567 *(bool *)context = true; 568 return AE_CTRL_TERMINATE; 569 } 570 571 static int __init cros_ec_lpc_init(void) 572 { 573 int ret; 574 acpi_status status; 575 576 status = acpi_get_devices(ACPI_DRV_NAME, cros_ec_lpc_parse_device, 577 &cros_ec_lpc_acpi_device_found, NULL); 578 if (ACPI_FAILURE(status)) 579 pr_warn(DRV_NAME ": Looking for %s failed\n", ACPI_DRV_NAME); 580 581 if (!cros_ec_lpc_acpi_device_found && 582 !dmi_check_system(cros_ec_lpc_dmi_table)) { 583 pr_err(DRV_NAME ": unsupported system.\n"); 584 return -ENODEV; 585 } 586 587 cros_ec_lpc_mec_init(EC_HOST_CMD_REGION0, 588 EC_LPC_ADDR_MEMMAP + EC_MEMMAP_SIZE); 589 590 /* Register the driver */ 591 ret = platform_driver_register(&cros_ec_lpc_driver); 592 if (ret) { 593 pr_err(DRV_NAME ": can't register driver: %d\n", ret); 594 cros_ec_lpc_mec_destroy(); 595 return ret; 596 } 597 598 if (!cros_ec_lpc_acpi_device_found) { 599 /* Register the device, and it'll get hooked up automatically */ 600 ret = platform_device_register(&cros_ec_lpc_device); 601 if (ret) { 602 pr_err(DRV_NAME ": can't register device: %d\n", ret); 603 platform_driver_unregister(&cros_ec_lpc_driver); 604 cros_ec_lpc_mec_destroy(); 605 } 606 } 607 608 return ret; 609 } 610 611 static void __exit cros_ec_lpc_exit(void) 612 { 613 if (!cros_ec_lpc_acpi_device_found) 614 platform_device_unregister(&cros_ec_lpc_device); 615 platform_driver_unregister(&cros_ec_lpc_driver); 616 cros_ec_lpc_mec_destroy(); 617 } 618 619 module_init(cros_ec_lpc_init); 620 module_exit(cros_ec_lpc_exit); 621 622 MODULE_LICENSE("GPL"); 623 MODULE_DESCRIPTION("ChromeOS EC LPC driver"); 624