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/acpi.h>
25 #include <linux/dmi.h>
26 #include <linux/delay.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>
35 #define DRV_NAME "cros_ec_lpcs"
36 #define ACPI_DRV_NAME "GOOG0004"
38 static int ec_response_timed_out(void)
40 unsigned long one_second
= jiffies
+ HZ
;
43 usleep_range(200, 300);
45 if (!(cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_CMD
, 1, &data
) &
46 EC_LPC_STATUS_BUSY_MASK
))
48 usleep_range(100, 200);
49 } while (time_before(jiffies
, one_second
));
54 static int cros_ec_pkt_xfer_lpc(struct cros_ec_device
*ec
,
55 struct cros_ec_command
*msg
)
57 struct ec_host_request
*request
;
58 struct ec_host_response response
;
63 ret
= cros_ec_prepare_tx(ec
, msg
);
66 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_PACKET
, ret
, ec
->dout
);
68 request
= (struct ec_host_request
*)ec
->dout
;
71 sum
= EC_COMMAND_PROTOCOL_3
;
72 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_CMD
, 1, &sum
);
74 if (ec_response_timed_out()) {
75 dev_warn(ec
->dev
, "EC responsed timed out\n");
81 msg
->result
= cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_DATA
, 1, &sum
);
82 ret
= cros_ec_check_result(ec
, msg
);
86 /* Read back response */
87 dout
= (u8
*)&response
;
88 sum
= cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PACKET
, sizeof(response
),
91 msg
->result
= response
.result
;
93 if (response
.data_len
> msg
->insize
) {
95 "packet too long (%d bytes, expected %d)",
96 response
.data_len
, msg
->insize
);
101 /* Read response and process checksum */
102 sum
+= cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PACKET
+
103 sizeof(response
), response
.data_len
,
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
;
127 if (msg
->outsize
> EC_PROTO2_MAX_PARAM_SIZE
||
128 msg
->insize
> EC_PROTO2_MAX_PARAM_SIZE
) {
130 "invalid buffer sizes (out %d, in %d)\n",
131 msg
->outsize
, msg
->insize
);
135 /* Now actually send the command to the EC and get the result */
136 args
.flags
= EC_HOST_ARGS_FLAG_FROM_HOST
;
137 args
.command_version
= msg
->version
;
138 args
.data_size
= msg
->outsize
;
140 /* Initialize checksum */
141 sum
= msg
->command
+ args
.flags
+ args
.command_version
+ args
.data_size
;
143 /* Copy data and update checksum */
144 sum
+= cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_PARAM
, msg
->outsize
,
147 /* Finalize checksum and write args */
149 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_ARGS
, sizeof(args
),
154 cros_ec_lpc_write_bytes(EC_LPC_ADDR_HOST_CMD
, 1, &sum
);
156 if (ec_response_timed_out()) {
157 dev_warn(ec
->dev
, "EC responsed timed out\n");
163 msg
->result
= cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_DATA
, 1, &sum
);
164 ret
= cros_ec_check_result(ec
, msg
);
169 cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_ARGS
, sizeof(args
),
172 if (args
.data_size
> msg
->insize
) {
174 "packet too long (%d bytes, expected %d)",
175 args
.data_size
, msg
->insize
);
180 /* Start calculating response checksum */
181 sum
= msg
->command
+ args
.flags
+ args
.command_version
+ args
.data_size
;
183 /* Read response and update checksum */
184 sum
+= cros_ec_lpc_read_bytes(EC_LPC_ADDR_HOST_PARAM
, args
.data_size
,
187 /* Verify checksum */
188 if (args
.checksum
!= sum
) {
190 "bad packet checksum, expected %02x, got %02x\n",
196 /* Return actual amount of data received */
197 ret
= args
.data_size
;
202 /* Returns num bytes read, or negative on error. Doesn't need locking. */
203 static int cros_ec_lpc_readmem(struct cros_ec_device
*ec
, unsigned int offset
,
204 unsigned int bytes
, void *dest
)
210 if (offset
>= EC_MEMMAP_SIZE
- bytes
)
215 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP
+ offset
, bytes
, s
);
220 for (; i
< EC_MEMMAP_SIZE
; i
++, s
++) {
221 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP
+ i
, 1, s
);
230 static void cros_ec_lpc_acpi_notify(acpi_handle device
, u32 value
, void *data
)
232 struct cros_ec_device
*ec_dev
= data
;
234 if (ec_dev
->mkbp_event_supported
&&
235 cros_ec_get_next_event(ec_dev
, NULL
) > 0)
236 blocking_notifier_call_chain(&ec_dev
->event_notifier
, 0,
240 static int cros_ec_lpc_probe(struct platform_device
*pdev
)
242 struct device
*dev
= &pdev
->dev
;
243 struct acpi_device
*adev
;
245 struct cros_ec_device
*ec_dev
;
249 if (!devm_request_region(dev
, EC_LPC_ADDR_MEMMAP
, EC_MEMMAP_SIZE
,
251 dev_err(dev
, "couldn't reserve memmap region\n");
255 cros_ec_lpc_read_bytes(EC_LPC_ADDR_MEMMAP
+ EC_MEMMAP_ID
, 2, buf
);
256 if (buf
[0] != 'E' || buf
[1] != 'C') {
257 dev_err(dev
, "EC ID not detected\n");
261 if (!devm_request_region(dev
, EC_HOST_CMD_REGION0
,
262 EC_HOST_CMD_REGION_SIZE
, dev_name(dev
))) {
263 dev_err(dev
, "couldn't reserve region0\n");
266 if (!devm_request_region(dev
, EC_HOST_CMD_REGION1
,
267 EC_HOST_CMD_REGION_SIZE
, dev_name(dev
))) {
268 dev_err(dev
, "couldn't reserve region1\n");
272 ec_dev
= devm_kzalloc(dev
, sizeof(*ec_dev
), GFP_KERNEL
);
276 platform_set_drvdata(pdev
, ec_dev
);
278 ec_dev
->phys_name
= dev_name(dev
);
279 ec_dev
->cmd_xfer
= cros_ec_cmd_xfer_lpc
;
280 ec_dev
->pkt_xfer
= cros_ec_pkt_xfer_lpc
;
281 ec_dev
->cmd_readmem
= cros_ec_lpc_readmem
;
282 ec_dev
->din_size
= sizeof(struct ec_host_response
) +
283 sizeof(struct ec_response_get_protocol_info
);
284 ec_dev
->dout_size
= sizeof(struct ec_host_request
);
286 ret
= cros_ec_register(ec_dev
);
288 dev_err(dev
, "couldn't register ec_dev (%d)\n", ret
);
293 * Connect a notify handler to process MKBP messages if we have a
294 * companion ACPI device.
296 adev
= ACPI_COMPANION(dev
);
298 status
= acpi_install_notify_handler(adev
->handle
,
300 cros_ec_lpc_acpi_notify
,
302 if (ACPI_FAILURE(status
))
303 dev_warn(dev
, "Failed to register notifier %08x\n",
310 static int cros_ec_lpc_remove(struct platform_device
*pdev
)
312 struct cros_ec_device
*ec_dev
;
313 struct acpi_device
*adev
;
315 adev
= ACPI_COMPANION(&pdev
->dev
);
317 acpi_remove_notify_handler(adev
->handle
, ACPI_ALL_NOTIFY
,
318 cros_ec_lpc_acpi_notify
);
320 ec_dev
= platform_get_drvdata(pdev
);
321 cros_ec_remove(ec_dev
);
326 static const struct acpi_device_id cros_ec_lpc_acpi_device_ids
[] = {
327 { ACPI_DRV_NAME
, 0 },
330 MODULE_DEVICE_TABLE(acpi
, cros_ec_lpc_acpi_device_ids
);
332 static struct dmi_system_id cros_ec_lpc_dmi_table
[] __initdata
= {
335 * Today all Chromebooks/boxes ship with Google_* as version and
336 * coreboot as bios vendor. No other systems with this
337 * combination are known to date.
340 DMI_MATCH(DMI_BIOS_VENDOR
, "coreboot"),
341 DMI_MATCH(DMI_BIOS_VERSION
, "Google_"),
345 /* x86-link, the Chromebook Pixel. */
347 DMI_MATCH(DMI_SYS_VENDOR
, "GOOGLE"),
348 DMI_MATCH(DMI_PRODUCT_NAME
, "Link"),
352 /* x86-samus, the Chromebook Pixel 2. */
354 DMI_MATCH(DMI_SYS_VENDOR
, "GOOGLE"),
355 DMI_MATCH(DMI_PRODUCT_NAME
, "Samus"),
359 /* x86-peppy, the Acer C720 Chromebook. */
361 DMI_MATCH(DMI_SYS_VENDOR
, "Acer"),
362 DMI_MATCH(DMI_PRODUCT_NAME
, "Peppy"),
367 MODULE_DEVICE_TABLE(dmi
, cros_ec_lpc_dmi_table
);
369 #ifdef CONFIG_PM_SLEEP
370 static int cros_ec_lpc_suspend(struct device
*dev
)
372 struct cros_ec_device
*ec_dev
= dev_get_drvdata(dev
);
374 return cros_ec_suspend(ec_dev
);
377 static int cros_ec_lpc_resume(struct device
*dev
)
379 struct cros_ec_device
*ec_dev
= dev_get_drvdata(dev
);
381 return cros_ec_resume(ec_dev
);
385 const struct dev_pm_ops cros_ec_lpc_pm_ops
= {
386 SET_LATE_SYSTEM_SLEEP_PM_OPS(cros_ec_lpc_suspend
, cros_ec_lpc_resume
)
389 static struct platform_driver cros_ec_lpc_driver
= {
392 .acpi_match_table
= cros_ec_lpc_acpi_device_ids
,
393 .pm
= &cros_ec_lpc_pm_ops
,
395 .probe
= cros_ec_lpc_probe
,
396 .remove
= cros_ec_lpc_remove
,
399 static int __init
cros_ec_lpc_init(void)
403 if (!dmi_check_system(cros_ec_lpc_dmi_table
)) {
404 pr_err(DRV_NAME
": unsupported system.\n");
408 cros_ec_lpc_reg_init();
410 /* Register the driver */
411 ret
= platform_driver_register(&cros_ec_lpc_driver
);
413 pr_err(DRV_NAME
": can't register driver: %d\n", ret
);
414 cros_ec_lpc_reg_destroy();
421 static void __exit
cros_ec_lpc_exit(void)
423 platform_driver_unregister(&cros_ec_lpc_driver
);
424 cros_ec_lpc_reg_destroy();
427 module_init(cros_ec_lpc_init
);
428 module_exit(cros_ec_lpc_exit
);
430 MODULE_LICENSE("GPL");
431 MODULE_DESCRIPTION("ChromeOS EC LPC driver");