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