1 /* 2 * cros_ec_lpc - LPC access to the Chrome OS Embedded Controller 3 * 4 * Copyright (C) 2012-2015 Google, Inc 5 * 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. 9 * 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. 14 * 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 21 * expensive. 22 */ 23 24 #include <linux/acpi.h> 25 #include <linux/dmi.h> 26 #include <linux/delay.h> 27 #include <linux/io.h> 28 #include <linux/interrupt.h> 29 #include <linux/mfd/cros_ec.h> 30 #include <linux/mfd/cros_ec_commands.h> 31 #include <linux/module.h> 32 #include <linux/platform_device.h> 33 #include <linux/printk.h> 34 #include <linux/suspend.h> 35 36 #include "cros_ec_lpc_reg.h" 37 38 #define DRV_NAME "cros_ec_lpcs" 39 #define ACPI_DRV_NAME "GOOG0004" 40 41 /* True if ACPI device is present */ 42 static bool cros_ec_lpc_acpi_device_found; 43 44 static int ec_response_timed_out(void) 45 { 46 unsigned long one_second = jiffies + HZ; 47 u8 data; 48 49 usleep_range(200, 300); 50 do { 51 if (!(cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_CMD, 1, &data) & 52 EC_LPC_STATUS_BUSY_MASK)) 53 return 0; 54 usleep_range(100, 200); 55 } while (time_before(jiffies, one_second)); 56 57 return 1; 58 } 59 60 static int cros_ec_pkt_xfer_lpc(struct cros_ec_device *ec, 61 struct cros_ec_command *msg) 62 { 63 struct ec_host_response response; 64 u8 sum; 65 int ret = 0; 66 u8 *dout; 67 68 ret = cros_ec_prepare_tx(ec, msg); 69 70 /* Write buffer */ 71 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_PACKET, ret, ec->dout); 72 73 /* Here we go */ 74 sum = EC_COMMAND_PROTOCOL_3; 75 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_CMD, 1, &sum); 76 77 if (ec_response_timed_out()) { 78 dev_warn(ec->dev, "EC responsed timed out\n"); 79 ret = -EIO; 80 goto done; 81 } 82 83 /* Check result */ 84 msg->result = cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_DATA, 1, &sum); 85 ret = cros_ec_check_result(ec, msg); 86 if (ret) 87 goto done; 88 89 /* Read back response */ 90 dout = (u8 *)&response; 91 sum = cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PACKET, sizeof(response), 92 dout); 93 94 msg->result = response.result; 95 96 if (response.data_len > msg->insize) { 97 dev_err(ec->dev, 98 "packet too long (%d bytes, expected %d)", 99 response.data_len, msg->insize); 100 ret = -EMSGSIZE; 101 goto done; 102 } 103 104 /* Read response and process checksum */ 105 sum += cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PACKET + 106 sizeof(response), response.data_len, 107 msg->data); 108 109 if (sum) { 110 dev_err(ec->dev, 111 "bad packet checksum %02x\n", 112 response.checksum); 113 ret = -EBADMSG; 114 goto done; 115 } 116 117 /* Return actual amount of data received */ 118 ret = response.data_len; 119 done: 120 return ret; 121 } 122 123 static int cros_ec_cmd_xfer_lpc(struct cros_ec_device *ec, 124 struct cros_ec_command *msg) 125 { 126 struct ec_lpc_host_args args; 127 u8 sum; 128 int ret = 0; 129 130 if (msg->outsize > EC_PROTO2_MAX_PARAM_SIZE || 131 msg->insize > EC_PROTO2_MAX_PARAM_SIZE) { 132 dev_err(ec->dev, 133 "invalid buffer sizes (out %d, in %d)\n", 134 msg->outsize, msg->insize); 135 return -EINVAL; 136 } 137 138 /* Now actually send the command to the EC and get the result */ 139 args.flags = EC_HOST_ARGS_FLAG_FROM_HOST; 140 args.command_version = msg->version; 141 args.data_size = msg->outsize; 142 143 /* Initialize checksum */ 144 sum = msg->command + args.flags + args.command_version + args.data_size; 145 146 /* Copy data and update checksum */ 147 sum += cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_PARAM, msg->outsize, 148 msg->data); 149 150 /* Finalize checksum and write args */ 151 args.checksum = sum; 152 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), 153 (u8 *)&args); 154 155 /* Here we go */ 156 sum = msg->command; 157 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_CMD, 1, &sum); 158 159 if (ec_response_timed_out()) { 160 dev_warn(ec->dev, "EC responsed timed out\n"); 161 ret = -EIO; 162 goto done; 163 } 164 165 /* Check result */ 166 msg->result = cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_DATA, 1, &sum); 167 ret = cros_ec_check_result(ec, msg); 168 if (ret) 169 goto done; 170 171 /* Read back args */ 172 cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_ARGS, sizeof(args), 173 (u8 *)&args); 174 175 if (args.data_size > msg->insize) { 176 dev_err(ec->dev, 177 "packet too long (%d bytes, expected %d)", 178 args.data_size, msg->insize); 179 ret = -ENOSPC; 180 goto done; 181 } 182 183 /* Start calculating response checksum */ 184 sum = msg->command + args.flags + args.command_version + args.data_size; 185 186 /* Read response and update checksum */ 187 sum += cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PARAM, args.data_size, 188 msg->data); 189 190 /* Verify checksum */ 191 if (args.checksum != sum) { 192 dev_err(ec->dev, 193 "bad packet checksum, expected %02x, got %02x\n", 194 args.checksum, sum); 195 ret = -EBADMSG; 196 goto done; 197 } 198 199 /* Return actual amount of data received */ 200 ret = args.data_size; 201 done: 202 return ret; 203 } 204 205 /* Returns num bytes read, or negative on error. Doesn't need locking. */ 206 static int cros_ec_lpc_readmem(struct cros_ec_device *ec, unsigned int offset, 207 unsigned int bytes, void *dest) 208 { 209 int i = offset; 210 char *s = dest; 211 int cnt = 0; 212 213 if (offset >= EC_MEMMAP_SIZE - bytes) 214 return -EINVAL; 215 216 /* fixed length */ 217 if (bytes) { 218 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP + offset, bytes, s); 219 return bytes; 220 } 221 222 /* string */ 223 for (; i < EC_MEMMAP_SIZE; i++, s++) { 224 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP + i, 1, s); 225 cnt++; 226 if (!*s) 227 break; 228 } 229 230 return cnt; 231 } 232 233 static void cros_ec_lpc_acpi_notify(acpi_handle device, u32 value, void *data) 234 { 235 struct cros_ec_device *ec_dev = data; 236 237 if (ec_dev->mkbp_event_supported && 238 cros_ec_get_next_event(ec_dev, NULL) > 0) 239 blocking_notifier_call_chain(&ec_dev->event_notifier, 0, 240 ec_dev); 241 242 if (value == ACPI_NOTIFY_DEVICE_WAKE) 243 pm_system_wakeup(); 244 } 245 246 static int cros_ec_lpc_probe(struct platform_device *pdev) 247 { 248 struct device *dev = &pdev->dev; 249 struct acpi_device *adev; 250 acpi_status status; 251 struct cros_ec_device *ec_dev; 252 u8 buf[2]; 253 int irq, ret; 254 255 if (!devm_request_region(dev, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE, 256 dev_name(dev))) { 257 dev_err(dev, "couldn't reserve memmap region\n"); 258 return -EBUSY; 259 } 260 261 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID, 2, buf); 262 if (buf[0] != 'E' || buf[1] != 'C') { 263 dev_err(dev, "EC ID not detected\n"); 264 return -ENODEV; 265 } 266 267 if (!devm_request_region(dev, EC_HOST_CMD_REGION0, 268 EC_HOST_CMD_REGION_SIZE, dev_name(dev))) { 269 dev_err(dev, "couldn't reserve region0\n"); 270 return -EBUSY; 271 } 272 if (!devm_request_region(dev, EC_HOST_CMD_REGION1, 273 EC_HOST_CMD_REGION_SIZE, dev_name(dev))) { 274 dev_err(dev, "couldn't reserve region1\n"); 275 return -EBUSY; 276 } 277 278 ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL); 279 if (!ec_dev) 280 return -ENOMEM; 281 282 platform_set_drvdata(pdev, ec_dev); 283 ec_dev->dev = dev; 284 ec_dev->phys_name = dev_name(dev); 285 ec_dev->cmd_xfer = cros_ec_cmd_xfer_lpc; 286 ec_dev->pkt_xfer = cros_ec_pkt_xfer_lpc; 287 ec_dev->cmd_readmem = cros_ec_lpc_readmem; 288 ec_dev->din_size = sizeof(struct ec_host_response) + 289 sizeof(struct ec_response_get_protocol_info); 290 ec_dev->dout_size = sizeof(struct ec_host_request); 291 292 /* 293 * Some boards do not have an IRQ allotted for cros_ec_lpc, 294 * which makes ENXIO an expected (and safe) scenario. 295 */ 296 irq = platform_get_irq(pdev, 0); 297 if (irq > 0) 298 ec_dev->irq = irq; 299 else if (irq != -ENXIO) { 300 dev_err(dev, "couldn't retrieve IRQ number (%d)\n", irq); 301 return irq; 302 } 303 304 ret = cros_ec_register(ec_dev); 305 if (ret) { 306 dev_err(dev, "couldn't register ec_dev (%d)\n", ret); 307 return ret; 308 } 309 310 /* 311 * Connect a notify handler to process MKBP messages if we have a 312 * companion ACPI device. 313 */ 314 adev = ACPI_COMPANION(dev); 315 if (adev) { 316 status = acpi_install_notify_handler(adev->handle, 317 ACPI_ALL_NOTIFY, 318 cros_ec_lpc_acpi_notify, 319 ec_dev); 320 if (ACPI_FAILURE(status)) 321 dev_warn(dev, "Failed to register notifier %08x\n", 322 status); 323 } 324 325 return 0; 326 } 327 328 static int cros_ec_lpc_remove(struct platform_device *pdev) 329 { 330 struct cros_ec_device *ec_dev; 331 struct acpi_device *adev; 332 333 adev = ACPI_COMPANION(&pdev->dev); 334 if (adev) 335 acpi_remove_notify_handler(adev->handle, ACPI_ALL_NOTIFY, 336 cros_ec_lpc_acpi_notify); 337 338 ec_dev = platform_get_drvdata(pdev); 339 cros_ec_remove(ec_dev); 340 341 return 0; 342 } 343 344 static const struct acpi_device_id cros_ec_lpc_acpi_device_ids[] = { 345 { ACPI_DRV_NAME, 0 }, 346 { } 347 }; 348 MODULE_DEVICE_TABLE(acpi, cros_ec_lpc_acpi_device_ids); 349 350 static const struct dmi_system_id cros_ec_lpc_dmi_table[] __initconst = { 351 { 352 /* 353 * Today all Chromebooks/boxes ship with Google_* as version and 354 * coreboot as bios vendor. No other systems with this 355 * combination are known to date. 356 */ 357 .matches = { 358 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 359 DMI_MATCH(DMI_BIOS_VERSION, "Google_"), 360 }, 361 }, 362 { 363 /* 364 * If the box is running custom coreboot firmware then the 365 * DMI BIOS version string will not be matched by "Google_", 366 * but the system vendor string will still be matched by 367 * "GOOGLE". 368 */ 369 .matches = { 370 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"), 371 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 372 }, 373 }, 374 { 375 /* x86-link, the Chromebook Pixel. */ 376 .matches = { 377 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 378 DMI_MATCH(DMI_PRODUCT_NAME, "Link"), 379 }, 380 }, 381 { 382 /* x86-samus, the Chromebook Pixel 2. */ 383 .matches = { 384 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 385 DMI_MATCH(DMI_PRODUCT_NAME, "Samus"), 386 }, 387 }, 388 { 389 /* x86-peppy, the Acer C720 Chromebook. */ 390 .matches = { 391 DMI_MATCH(DMI_SYS_VENDOR, "Acer"), 392 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"), 393 }, 394 }, 395 { 396 /* x86-glimmer, the Lenovo Thinkpad Yoga 11e. */ 397 .matches = { 398 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"), 399 DMI_MATCH(DMI_PRODUCT_NAME, "Glimmer"), 400 }, 401 }, 402 { /* sentinel */ } 403 }; 404 MODULE_DEVICE_TABLE(dmi, cros_ec_lpc_dmi_table); 405 406 #ifdef CONFIG_PM_SLEEP 407 static int cros_ec_lpc_suspend(struct device *dev) 408 { 409 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 410 411 return cros_ec_suspend(ec_dev); 412 } 413 414 static int cros_ec_lpc_resume(struct device *dev) 415 { 416 struct cros_ec_device *ec_dev = dev_get_drvdata(dev); 417 418 return cros_ec_resume(ec_dev); 419 } 420 #endif 421 422 const struct dev_pm_ops cros_ec_lpc_pm_ops = { 423 SET_LATE_SYSTEM_SLEEP_PM_OPS(cros_ec_lpc_suspend, cros_ec_lpc_resume) 424 }; 425 426 static struct platform_driver cros_ec_lpc_driver = { 427 .driver = { 428 .name = DRV_NAME, 429 .acpi_match_table = cros_ec_lpc_acpi_device_ids, 430 .pm = &cros_ec_lpc_pm_ops, 431 }, 432 .probe = cros_ec_lpc_probe, 433 .remove = cros_ec_lpc_remove, 434 }; 435 436 static struct platform_device cros_ec_lpc_device = { 437 .name = DRV_NAME 438 }; 439 440 static acpi_status cros_ec_lpc_parse_device(acpi_handle handle, u32 level, 441 void *context, void **retval) 442 { 443 *(bool *)context = true; 444 return AE_CTRL_TERMINATE; 445 } 446 447 static int __init cros_ec_lpc_init(void) 448 { 449 int ret; 450 acpi_status status; 451 452 status = acpi_get_devices(ACPI_DRV_NAME, cros_ec_lpc_parse_device, 453 &cros_ec_lpc_acpi_device_found, NULL); 454 if (ACPI_FAILURE(status)) 455 pr_warn(DRV_NAME ": Looking for %s failed\n", ACPI_DRV_NAME); 456 457 if (!cros_ec_lpc_acpi_device_found && 458 !dmi_check_system(cros_ec_lpc_dmi_table)) { 459 pr_err(DRV_NAME ": unsupported system.\n"); 460 return -ENODEV; 461 } 462 463 cros_ec_lpc_reg_init(); 464 465 /* Register the driver */ 466 ret = platform_driver_register(&cros_ec_lpc_driver); 467 if (ret) { 468 pr_err(DRV_NAME ": can't register driver: %d\n", ret); 469 cros_ec_lpc_reg_destroy(); 470 return ret; 471 } 472 473 if (!cros_ec_lpc_acpi_device_found) { 474 /* Register the device, and it'll get hooked up automatically */ 475 ret = platform_device_register(&cros_ec_lpc_device); 476 if (ret) { 477 pr_err(DRV_NAME ": can't register device: %d\n", ret); 478 platform_driver_unregister(&cros_ec_lpc_driver); 479 cros_ec_lpc_reg_destroy(); 480 } 481 } 482 483 return ret; 484 } 485 486 static void __exit cros_ec_lpc_exit(void) 487 { 488 if (!cros_ec_lpc_acpi_device_found) 489 platform_device_unregister(&cros_ec_lpc_device); 490 platform_driver_unregister(&cros_ec_lpc_driver); 491 cros_ec_lpc_reg_destroy(); 492 } 493 494 module_init(cros_ec_lpc_init); 495 module_exit(cros_ec_lpc_exit); 496 497 MODULE_LICENSE("GPL"); 498 MODULE_DESCRIPTION("ChromeOS EC LPC driver"); 499