GNU Linux-libre 4.9.328-gnu1
[releases.git] / 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/dmi.h>
25 #include <linux/delay.h>
26 #include <linux/io.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>
32
33 #define DRV_NAME "cros_ec_lpc"
34
35 static int ec_response_timed_out(void)
36 {
37         unsigned long one_second = jiffies + HZ;
38
39         usleep_range(200, 300);
40         do {
41                 if (!(inb(EC_LPC_ADDR_HOST_CMD) & EC_LPC_STATUS_BUSY_MASK))
42                         return 0;
43                 usleep_range(100, 200);
44         } while (time_before(jiffies, one_second));
45
46         return 1;
47 }
48
49 static int cros_ec_pkt_xfer_lpc(struct cros_ec_device *ec,
50                                 struct cros_ec_command *msg)
51 {
52         struct ec_host_response response;
53         u8 sum = 0;
54         int i;
55         int ret = 0;
56         u8 *dout;
57
58         ret = cros_ec_prepare_tx(ec, msg);
59
60         /* Write buffer */
61         for (i = 0; i < ret; i++)
62                 outb(ec->dout[i], EC_LPC_ADDR_HOST_PACKET + i);
63
64         /* Here we go */
65         outb(EC_COMMAND_PROTOCOL_3, EC_LPC_ADDR_HOST_CMD);
66
67         if (ec_response_timed_out()) {
68                 dev_warn(ec->dev, "EC responsed timed out\n");
69                 ret = -EIO;
70                 goto done;
71         }
72
73         /* Check result */
74         msg->result = inb(EC_LPC_ADDR_HOST_DATA);
75         ret = cros_ec_check_result(ec, msg);
76         if (ret)
77                 goto done;
78
79         /* Read back response */
80         dout = (u8 *)&response;
81         for (i = 0; i < sizeof(response); i++) {
82                 dout[i] = inb(EC_LPC_ADDR_HOST_PACKET + i);
83                 sum += dout[i];
84         }
85
86         msg->result = response.result;
87
88         if (response.data_len > msg->insize) {
89                 dev_err(ec->dev,
90                         "packet too long (%d bytes, expected %d)",
91                         response.data_len, msg->insize);
92                 ret = -EMSGSIZE;
93                 goto done;
94         }
95
96         /* Read response and process checksum */
97         for (i = 0; i < response.data_len; i++) {
98                 msg->data[i] =
99                         inb(EC_LPC_ADDR_HOST_PACKET + sizeof(response) + i);
100                 sum += msg->data[i];
101         }
102
103         if (sum) {
104                 dev_err(ec->dev,
105                         "bad packet checksum %02x\n",
106                         response.checksum);
107                 ret = -EBADMSG;
108                 goto done;
109         }
110
111         /* Return actual amount of data received */
112         ret = response.data_len;
113 done:
114         return ret;
115 }
116
117 static int cros_ec_cmd_xfer_lpc(struct cros_ec_device *ec,
118                                 struct cros_ec_command *msg)
119 {
120         struct ec_lpc_host_args args;
121         int csum;
122         int i;
123         int ret = 0;
124
125         if (msg->outsize > EC_PROTO2_MAX_PARAM_SIZE ||
126             msg->insize > EC_PROTO2_MAX_PARAM_SIZE) {
127                 dev_err(ec->dev,
128                         "invalid buffer sizes (out %d, in %d)\n",
129                         msg->outsize, msg->insize);
130                 return -EINVAL;
131         }
132
133         /* Now actually send the command to the EC and get the result */
134         args.flags = EC_HOST_ARGS_FLAG_FROM_HOST;
135         args.command_version = msg->version;
136         args.data_size = msg->outsize;
137
138         /* Initialize checksum */
139         csum = msg->command + args.flags +
140                 args.command_version + args.data_size;
141
142         /* Copy data and update checksum */
143         for (i = 0; i < msg->outsize; i++) {
144                 outb(msg->data[i], EC_LPC_ADDR_HOST_PARAM + i);
145                 csum += msg->data[i];
146         }
147
148         /* Finalize checksum and write args */
149         args.checksum = csum & 0xFF;
150         outb(args.flags, EC_LPC_ADDR_HOST_ARGS);
151         outb(args.command_version, EC_LPC_ADDR_HOST_ARGS + 1);
152         outb(args.data_size, EC_LPC_ADDR_HOST_ARGS + 2);
153         outb(args.checksum, EC_LPC_ADDR_HOST_ARGS + 3);
154
155         /* Here we go */
156         outb(msg->command, EC_LPC_ADDR_HOST_CMD);
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 = inb(EC_LPC_ADDR_HOST_DATA);
166         ret = cros_ec_check_result(ec, msg);
167         if (ret)
168                 goto done;
169
170         /* Read back args */
171         args.flags = inb(EC_LPC_ADDR_HOST_ARGS);
172         args.command_version = inb(EC_LPC_ADDR_HOST_ARGS + 1);
173         args.data_size = inb(EC_LPC_ADDR_HOST_ARGS + 2);
174         args.checksum = inb(EC_LPC_ADDR_HOST_ARGS + 3);
175
176         if (args.data_size > msg->insize) {
177                 dev_err(ec->dev,
178                         "packet too long (%d bytes, expected %d)",
179                         args.data_size, msg->insize);
180                 ret = -ENOSPC;
181                 goto done;
182         }
183
184         /* Start calculating response checksum */
185         csum = msg->command + args.flags +
186                 args.command_version + args.data_size;
187
188         /* Read response and update checksum */
189         for (i = 0; i < args.data_size; i++) {
190                 msg->data[i] = inb(EC_LPC_ADDR_HOST_PARAM + i);
191                 csum += msg->data[i];
192         }
193
194         /* Verify checksum */
195         if (args.checksum != (csum & 0xFF)) {
196                 dev_err(ec->dev,
197                         "bad packet checksum, expected %02x, got %02x\n",
198                         args.checksum, csum & 0xFF);
199                 ret = -EBADMSG;
200                 goto done;
201         }
202
203         /* Return actual amount of data received */
204         ret = args.data_size;
205 done:
206         return ret;
207 }
208
209 /* Returns num bytes read, or negative on error. Doesn't need locking. */
210 static int cros_ec_lpc_readmem(struct cros_ec_device *ec, unsigned int offset,
211                                unsigned int bytes, void *dest)
212 {
213         int i = offset;
214         char *s = dest;
215         int cnt = 0;
216
217         if (offset >= EC_MEMMAP_SIZE - bytes)
218                 return -EINVAL;
219
220         /* fixed length */
221         if (bytes) {
222                 for (; cnt < bytes; i++, s++, cnt++)
223                         *s = inb(EC_LPC_ADDR_MEMMAP + i);
224                 return cnt;
225         }
226
227         /* string */
228         for (; i < EC_MEMMAP_SIZE; i++, s++) {
229                 *s = inb(EC_LPC_ADDR_MEMMAP + i);
230                 cnt++;
231                 if (!*s)
232                         break;
233         }
234
235         return cnt;
236 }
237
238 static int cros_ec_lpc_probe(struct platform_device *pdev)
239 {
240         struct device *dev = &pdev->dev;
241         struct cros_ec_device *ec_dev;
242         int ret;
243
244         if (!devm_request_region(dev, EC_LPC_ADDR_MEMMAP, EC_MEMMAP_SIZE,
245                                  dev_name(dev))) {
246                 dev_err(dev, "couldn't reserve memmap region\n");
247                 return -EBUSY;
248         }
249
250         if ((inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID) != 'E') ||
251             (inb(EC_LPC_ADDR_MEMMAP + EC_MEMMAP_ID + 1) != 'C')) {
252                 dev_err(dev, "EC ID not detected\n");
253                 return -ENODEV;
254         }
255
256         if (!devm_request_region(dev, EC_HOST_CMD_REGION0,
257                                  EC_HOST_CMD_REGION_SIZE, dev_name(dev))) {
258                 dev_err(dev, "couldn't reserve region0\n");
259                 return -EBUSY;
260         }
261         if (!devm_request_region(dev, EC_HOST_CMD_REGION1,
262                                  EC_HOST_CMD_REGION_SIZE, dev_name(dev))) {
263                 dev_err(dev, "couldn't reserve region1\n");
264                 return -EBUSY;
265         }
266
267         ec_dev = devm_kzalloc(dev, sizeof(*ec_dev), GFP_KERNEL);
268         if (!ec_dev)
269                 return -ENOMEM;
270
271         platform_set_drvdata(pdev, ec_dev);
272         ec_dev->dev = dev;
273         ec_dev->phys_name = dev_name(dev);
274         ec_dev->cmd_xfer = cros_ec_cmd_xfer_lpc;
275         ec_dev->pkt_xfer = cros_ec_pkt_xfer_lpc;
276         ec_dev->cmd_readmem = cros_ec_lpc_readmem;
277         ec_dev->din_size = sizeof(struct ec_host_response) +
278                            sizeof(struct ec_response_get_protocol_info);
279         ec_dev->dout_size = sizeof(struct ec_host_request);
280
281         ret = cros_ec_register(ec_dev);
282         if (ret) {
283                 dev_err(dev, "couldn't register ec_dev (%d)\n", ret);
284                 return ret;
285         }
286
287         return 0;
288 }
289
290 static int cros_ec_lpc_remove(struct platform_device *pdev)
291 {
292         struct cros_ec_device *ec_dev;
293
294         ec_dev = platform_get_drvdata(pdev);
295         cros_ec_remove(ec_dev);
296
297         return 0;
298 }
299
300 static struct dmi_system_id cros_ec_lpc_dmi_table[] __initdata = {
301         {
302                 /*
303                  * Today all Chromebooks/boxes ship with Google_* as version and
304                  * coreboot as bios vendor. No other systems with this
305                  * combination are known to date.
306                  */
307                 .matches = {
308                         DMI_MATCH(DMI_BIOS_VENDOR, "coreboot"),
309                         DMI_MATCH(DMI_BIOS_VERSION, "Google_"),
310                 },
311         },
312         {
313                 /* x86-link, the Chromebook Pixel. */
314                 .matches = {
315                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
316                         DMI_MATCH(DMI_PRODUCT_NAME, "Link"),
317                 },
318         },
319         {
320                 /* x86-samus, the Chromebook Pixel 2. */
321                 .matches = {
322                         DMI_MATCH(DMI_SYS_VENDOR, "GOOGLE"),
323                         DMI_MATCH(DMI_PRODUCT_NAME, "Samus"),
324                 },
325         },
326         {
327                 /* x86-peppy, the Acer C720 Chromebook. */
328                 .matches = {
329                         DMI_MATCH(DMI_SYS_VENDOR, "Acer"),
330                         DMI_MATCH(DMI_PRODUCT_NAME, "Peppy"),
331                 },
332         },
333         { /* sentinel */ }
334 };
335 MODULE_DEVICE_TABLE(dmi, cros_ec_lpc_dmi_table);
336
337 static struct platform_driver cros_ec_lpc_driver = {
338         .driver = {
339                 .name = DRV_NAME,
340         },
341         .probe = cros_ec_lpc_probe,
342         .remove = cros_ec_lpc_remove,
343 };
344
345 static struct platform_device cros_ec_lpc_device = {
346         .name = DRV_NAME
347 };
348
349 static int __init cros_ec_lpc_init(void)
350 {
351         int ret;
352
353         if (!dmi_check_system(cros_ec_lpc_dmi_table)) {
354                 pr_err(DRV_NAME ": unsupported system.\n");
355                 return -ENODEV;
356         }
357
358         /* Register the driver */
359         ret = platform_driver_register(&cros_ec_lpc_driver);
360         if (ret) {
361                 pr_err(DRV_NAME ": can't register driver: %d\n", ret);
362                 return ret;
363         }
364
365         /* Register the device, and it'll get hooked up automatically */
366         ret = platform_device_register(&cros_ec_lpc_device);
367         if (ret) {
368                 pr_err(DRV_NAME ": can't register device: %d\n", ret);
369                 platform_driver_unregister(&cros_ec_lpc_driver);
370                 return ret;
371         }
372
373         return 0;
374 }
375
376 static void __exit cros_ec_lpc_exit(void)
377 {
378         platform_device_unregister(&cros_ec_lpc_device);
379         platform_driver_unregister(&cros_ec_lpc_driver);
380 }
381
382 module_init(cros_ec_lpc_init);
383 module_exit(cros_ec_lpc_exit);
384
385 MODULE_LICENSE("GPL");
386 MODULE_DESCRIPTION("ChromeOS EC LPC driver");