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