2 * cros_ec_lpc - LPC access to the Chrome OS Embedded Controller
4 * Copyright (C) 2012-2015 Google, Inc
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.
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.
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
24 #include <linux/dmi.h>
25 #include <linux/delay.h>
27 #include <linux/mfd/cros_ec.h>
28 #include <linux/mfd/cros_ec_commands.h>
29 #include <linux/module.h>
30 #include <linux/platform_device.h>
31 #include <linux/printk.h>
33 #define DRV_NAME "cros_ec_lpc"
35 static int ec_response_timed_out(void)
37 unsigned long one_second = jiffies + HZ;
39 usleep_range(200, 300);
41 if (!(inb(EC_LPC_ADDR_HOST_CMD) & EC_LPC_STATUS_BUSY_MASK))
43 usleep_range(100, 200);
44 } while (time_before(jiffies, one_second));
49 static int cros_ec_pkt_xfer_lpc(struct cros_ec_device *ec,
50 struct cros_ec_command *msg)
52 struct ec_host_request *request;
53 struct ec_host_response response;
59 ret = cros_ec_prepare_tx(ec, msg);
62 for (i = 0; i < ret; i++)
63 outb(ec->dout[i], EC_LPC_ADDR_HOST_PACKET + i);
65 request = (struct ec_host_request *)ec->dout;
68 outb(EC_COMMAND_PROTOCOL_3, EC_LPC_ADDR_HOST_CMD);
70 if (ec_response_timed_out()) {
71 dev_warn(ec->dev, "EC responsed timed out\n");
77 msg->result = inb(EC_LPC_ADDR_HOST_DATA);
78 ret = cros_ec_check_result(ec, msg);
82 /* Read back response */
83 dout = (u8 *)&response;
84 for (i = 0; i < sizeof(response); i++) {
85 dout[i] = inb(EC_LPC_ADDR_HOST_PACKET + i);
89 msg->result = response.result;
91 if (response.data_len > msg->insize) {
93 "packet too long (%d bytes, expected %d)",
94 response.data_len, msg->insize);
99 /* Read response and process checksum */
100 for (i = 0; i < response.data_len; i++) {
102 inb(EC_LPC_ADDR_HOST_PACKET + sizeof(response) + i);
108 "bad packet checksum %02x\n",
114 /* Return actual amount of data received */
115 ret = response.data_len;
120 static int cros_ec_cmd_xfer_lpc(struct cros_ec_device *ec,
121 struct cros_ec_command *msg)
123 struct ec_lpc_host_args args;
128 if (msg->outsize > EC_PROTO2_MAX_PARAM_SIZE ||
129 msg->insize > EC_PROTO2_MAX_PARAM_SIZE) {
131 "invalid buffer sizes (out %d, in %d)\n",
132 msg->outsize, msg->insize);
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;
141 /* Initialize checksum */
142 csum = msg->command + args.flags +
143 args.command_version + args.data_size;
145 /* Copy data and update checksum */
146 for (i = 0; i < msg->outsize; i++) {
147 outb(msg->data[i], EC_LPC_ADDR_HOST_PARAM + i);
148 csum += msg->data[i];
151 /* Finalize checksum and write args */
152 args.checksum = csum & 0xFF;
153 outb(args.flags, EC_LPC_ADDR_HOST_ARGS);
154 outb(args.command_version, EC_LPC_ADDR_HOST_ARGS + 1);
155 outb(args.data_size, EC_LPC_ADDR_HOST_ARGS + 2);
156 outb(args.checksum, EC_LPC_ADDR_HOST_ARGS + 3);
159 outb(msg->command, EC_LPC_ADDR_HOST_CMD);
161 if (ec_response_timed_out()) {
162 dev_warn(ec->dev, "EC responsed timed out\n");
168 msg->result = inb(EC_LPC_ADDR_HOST_DATA);
170 switch (msg->result) {
173 case EC_RES_IN_PROGRESS:
175 dev_dbg(ec->dev, "command 0x%02x in progress\n",
179 dev_dbg(ec->dev, "command 0x%02x returned %d\n",
180 msg->command, msg->result);
184 args.flags = inb(EC_LPC_ADDR_HOST_ARGS);
185 args.command_version = inb(EC_LPC_ADDR_HOST_ARGS + 1);
186 args.data_size = inb(EC_LPC_ADDR_HOST_ARGS + 2);
187 args.checksum = inb(EC_LPC_ADDR_HOST_ARGS + 3);
189 if (args.data_size > msg->insize) {
191 "packet too long (%d bytes, expected %d)",
192 args.data_size, msg->insize);
197 /* Start calculating response checksum */
198 csum = msg->command + args.flags +
199 args.command_version + args.data_size;
201 /* Read response and update checksum */
202 for (i = 0; i < args.data_size; i++) {
203 msg->data[i] = inb(EC_LPC_ADDR_HOST_PARAM + i);
204 csum += msg->data[i];
207 /* Verify checksum */
208 if (args.checksum != (csum & 0xFF)) {
210 "bad packet checksum, expected %02x, got %02x\n",
211 args.checksum, csum & 0xFF);
216 /* Return actual amount of data received */
217 ret = args.data_size;
222 /* Returns num bytes read, or negative on error. Doesn't need locking. */
223 static int cros_ec_lpc_readmem(struct cros_ec_device *ec, unsigned int offset,
224 unsigned int bytes, void *dest)
230 if (offset >= EC_MEMMAP_SIZE - bytes)
235 for (; cnt < bytes; i++, s++, cnt++)
236 *s = inb(EC_LPC_ADDR_MEMMAP + i);
241 for (; i < EC_MEMMAP_SIZE; i++, s++) {
242 *s = inb(EC_LPC_ADDR_MEMMAP + i);
251 static int cros_ec_lpc_probe(struct platform_device *pdev)
253 struct device *dev = &pdev->dev;
254 struct cros_ec_device *ec_dev;
257 if (!devm_request_region(dev, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE,
259 dev_err(dev, "couldn't reserve memmap region\n");
263 if ((inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) != 'E') ||
264 (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1) != 'C')) {
265 dev_err(dev, "EC ID not detected\n");
269 if (!devm_request_region(dev, EC_HOST_CMD_REGION0,
270 EC_HOST_CMD_REGION_SIZE, dev_name(dev))) {
271 dev_err(dev, "couldn't reserve region0\n");
274 if (!devm_request_region(dev, EC_HOST_CMD_REGION1,
275 EC_HOST_CMD_REGION_SIZE, dev_name(dev))) {
276 dev_err(dev, "couldn't reserve region1\n");
280 ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
284 platform_set_drvdata(pdev, ec_dev);
286 ec_dev->phys_name = dev_name(dev);
287 ec_dev->cmd_xfer = cros_ec_cmd_xfer_lpc;
288 ec_dev->pkt_xfer = cros_ec_pkt_xfer_lpc;
289 ec_dev->cmd_readmem = cros_ec_lpc_readmem;
290 ec_dev->din_size = sizeof(struct ec_host_response) +
291 sizeof(struct ec_response_get_protocol_info);
292 ec_dev->dout_size = sizeof(struct ec_host_request);
294 ret = cros_ec_register(ec_dev);
296 dev_err(dev, "couldn't register ec_dev (%d)\n", ret);
303 static int cros_ec_lpc_remove(struct platform_device *pdev)
305 struct cros_ec_device *ec_dev;
307 ec_dev = platform_get_drvdata(pdev);
308 cros_ec_remove(ec_dev);
313 static struct dmi_system_id cros_ec_lpc_dmi_table[] __initdata = {
316 * Today all Chromebooks/boxes ship with Google_* as version and
317 * coreboot as bios vendor. No other systems with this
318 * combination are known to date.
321 DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
322 DMI_MATCH(DMI_BIOS_VERSION, "Google_"),
326 /* x86-link, the Chromebook Pixel. */
328 DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
329 DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
333 /* x86-peppy, the Acer C720 Chromebook. */
335 DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
336 DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
341 MODULE_DEVICE_TABLE(dmi, cros_ec_lpc_dmi_table);
343 static struct platform_driver cros_ec_lpc_driver = {
347 .probe = cros_ec_lpc_probe,
348 .remove = cros_ec_lpc_remove,
351 static struct platform_device cros_ec_lpc_device = {
355 static int __init cros_ec_lpc_init(void)
359 if (!dmi_check_system(cros_ec_lpc_dmi_table)) {
360 pr_err(DRV_NAME ": unsupported system.\n");
364 /* Register the driver */
365 ret = platform_driver_register(&cros_ec_lpc_driver);
367 pr_err(DRV_NAME ": can't register driver: %d\n", ret);
371 /* Register the device, and it'll get hooked up automatically */
372 ret = platform_device_register(&cros_ec_lpc_device);
374 pr_err(DRV_NAME ": can't register device: %d\n", ret);
375 platform_driver_unregister(&cros_ec_lpc_driver);
382 static void __exit cros_ec_lpc_exit(void)
384 platform_device_unregister(&cros_ec_lpc_device);
385 platform_driver_unregister(&cros_ec_lpc_driver);
388 module_init(cros_ec_lpc_init);
389 module_exit(cros_ec_lpc_exit);
391 MODULE_LICENSE("GPL");
392 MODULE_DESCRIPTION("ChromeOS EC LPC driver");