drivers/platform/chrome/cros_ec_lpc.c

   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");