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