1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Miscellaneous character driver for ChromeOS Embedded Controller
4 *
5 * Copyright 2014 Google, Inc.
6 * Copyright 2019 Google LLC
7 *
8 * This file is a rework and part of the code is ported from
9 * drivers/mfd/cros_ec_dev.c that was originally written by
10 * Bill Richardson.
11 */
12
13#include <linux/init.h>
14#include <linux/device.h>
15#include <linux/fs.h>
16#include <linux/miscdevice.h>
17#include <linux/mod_devicetable.h>
18#include <linux/module.h>
19#include <linux/notifier.h>
20#include <linux/platform_data/cros_ec_chardev.h>
21#include <linux/platform_data/cros_ec_commands.h>
22#include <linux/platform_data/cros_ec_proto.h>
23#include <linux/platform_device.h>
24#include <linux/poll.h>
25#include <linux/slab.h>
26#include <linux/types.h>
27#include <linux/uaccess.h>
28
29#define DRV_NAME "cros-ec-chardev"
30
31/* Arbitrary bounded size for the event queue */
32#define CROS_MAX_EVENT_LEN PAGE_SIZE
33
34struct chardev_priv {
35 struct cros_ec_device *ec_dev;
36 struct notifier_block notifier;
37 wait_queue_head_t wait_event;
38 unsigned long event_mask;
39 struct list_head events;
40 size_t event_len;
41 u16 cmd_offset;
42};
43
44struct ec_event {
45 struct list_head node;
46 size_t size;
47 u8 event_type;
48 u8 data[];
49};
50
51static int ec_get_version(struct chardev_priv *priv, char *str, int maxlen)
52{
53 static const char * const current_image_name[] = {
54 "unknown", "read-only", "read-write", "invalid",
55 };
56 struct ec_response_get_version *resp;
57 struct cros_ec_command *msg;
58 int ret;
59
60 msg = kzalloc(sizeof(*msg) + sizeof(*resp), GFP_KERNEL);
61 if (!msg)
62 return -ENOMEM;
63
64 msg->command = EC_CMD_GET_VERSION + priv->cmd_offset;
65 msg->insize = sizeof(*resp);
66
67 ret = cros_ec_cmd_xfer_status(ec_dev: priv->ec_dev, msg);
68 if (ret < 0) {
69 snprintf(buf: str, size: maxlen,
70 fmt: "Unknown EC version, returned error: %d\n",
71 msg->result);
72 goto exit;
73 }
74
75 resp = (struct ec_response_get_version *)msg->data;
76 if (resp->current_image >= ARRAY_SIZE(current_image_name))
77 resp->current_image = 3; /* invalid */
78
79 snprintf(buf: str, size: maxlen, fmt: "%s\n%s\n%s\n%s\n", CROS_EC_DEV_VERSION,
80 resp->version_string_ro, resp->version_string_rw,
81 current_image_name[resp->current_image]);
82
83 ret = 0;
84exit:
85 kfree(objp: msg);
86 return ret;
87}
88
89static int cros_ec_chardev_mkbp_event(struct notifier_block *nb,
90 unsigned long queued_during_suspend,
91 void *_notify)
92{
93 struct chardev_priv *priv = container_of(nb, struct chardev_priv,
94 notifier);
95 struct cros_ec_device *ec_dev = priv->ec_dev;
96 struct ec_event *event;
97 unsigned long event_bit = 1 << ec_dev->event_data.event_type;
98 int total_size = sizeof(*event) + ec_dev->event_size;
99
100 if (!(event_bit & priv->event_mask) ||
101 (priv->event_len + total_size) > CROS_MAX_EVENT_LEN)
102 return NOTIFY_DONE;
103
104 event = kzalloc(total_size, GFP_KERNEL);
105 if (!event)
106 return NOTIFY_DONE;
107
108 event->size = ec_dev->event_size;
109 event->event_type = ec_dev->event_data.event_type;
110 memcpy(event->data, &ec_dev->event_data.data, ec_dev->event_size);
111
112 spin_lock(lock: &priv->wait_event.lock);
113 list_add_tail(new: &event->node, head: &priv->events);
114 priv->event_len += total_size;
115 wake_up_locked(&priv->wait_event);
116 spin_unlock(lock: &priv->wait_event.lock);
117
118 return NOTIFY_OK;
119}
120
121static struct ec_event *cros_ec_chardev_fetch_event(struct chardev_priv *priv,
122 bool fetch, bool block)
123{
124 struct ec_event *event;
125 int err;
126
127 spin_lock(lock: &priv->wait_event.lock);
128 if (!block && list_empty(head: &priv->events)) {
129 event = ERR_PTR(error: -EWOULDBLOCK);
130 goto out;
131 }
132
133 if (!fetch) {
134 event = NULL;
135 goto out;
136 }
137
138 err = wait_event_interruptible_locked(priv->wait_event,
139 !list_empty(&priv->events));
140 if (err) {
141 event = ERR_PTR(error: err);
142 goto out;
143 }
144
145 event = list_first_entry(&priv->events, struct ec_event, node);
146 list_del(entry: &event->node);
147 priv->event_len -= sizeof(*event) + event->size;
148
149out:
150 spin_unlock(lock: &priv->wait_event.lock);
151 return event;
152}
153
154/*
155 * Device file ops
156 */
157static int cros_ec_chardev_open(struct inode *inode, struct file *filp)
158{
159 struct miscdevice *mdev = filp->private_data;
160 struct cros_ec_dev *ec = dev_get_drvdata(dev: mdev->parent);
161 struct cros_ec_device *ec_dev = ec->ec_dev;
162 struct chardev_priv *priv;
163 int ret;
164
165 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
166 if (!priv)
167 return -ENOMEM;
168
169 priv->ec_dev = ec_dev;
170 priv->cmd_offset = ec->cmd_offset;
171 filp->private_data = priv;
172 INIT_LIST_HEAD(list: &priv->events);
173 init_waitqueue_head(&priv->wait_event);
174 nonseekable_open(inode, filp);
175
176 priv->notifier.notifier_call = cros_ec_chardev_mkbp_event;
177 ret = blocking_notifier_chain_register(nh: &ec_dev->event_notifier,
178 nb: &priv->notifier);
179 if (ret) {
180 dev_err(ec_dev->dev, "failed to register event notifier\n");
181 kfree(objp: priv);
182 }
183
184 return ret;
185}
186
187static __poll_t cros_ec_chardev_poll(struct file *filp, poll_table *wait)
188{
189 struct chardev_priv *priv = filp->private_data;
190
191 poll_wait(filp, wait_address: &priv->wait_event, p: wait);
192
193 if (list_empty(head: &priv->events))
194 return 0;
195
196 return EPOLLIN | EPOLLRDNORM;
197}
198
199static ssize_t cros_ec_chardev_read(struct file *filp, char __user *buffer,
200 size_t length, loff_t *offset)
201{
202 char msg[sizeof(struct ec_response_get_version) +
203 sizeof(CROS_EC_DEV_VERSION)];
204 struct chardev_priv *priv = filp->private_data;
205 size_t count;
206 int ret;
207
208 if (priv->event_mask) { /* queued MKBP event */
209 struct ec_event *event;
210
211 event = cros_ec_chardev_fetch_event(priv, fetch: length != 0,
212 block: !(filp->f_flags & O_NONBLOCK));
213 if (IS_ERR(ptr: event))
214 return PTR_ERR(ptr: event);
215 /*
216 * length == 0 is special - no IO is done but we check
217 * for error conditions.
218 */
219 if (length == 0)
220 return 0;
221
222 /* The event is 1 byte of type plus the payload */
223 count = min(length, event->size + 1);
224 ret = copy_to_user(to: buffer, from: &event->event_type, n: count);
225 kfree(objp: event);
226 if (ret) /* the copy failed */
227 return -EFAULT;
228 *offset = count;
229 return count;
230 }
231
232 /*
233 * Legacy behavior if no event mask is defined
234 */
235 if (*offset != 0)
236 return 0;
237
238 ret = ec_get_version(priv, str: msg, maxlen: sizeof(msg));
239 if (ret)
240 return ret;
241
242 count = min(length, strlen(msg));
243
244 if (copy_to_user(to: buffer, from: msg, n: count))
245 return -EFAULT;
246
247 *offset = count;
248 return count;
249}
250
251static int cros_ec_chardev_release(struct inode *inode, struct file *filp)
252{
253 struct chardev_priv *priv = filp->private_data;
254 struct cros_ec_device *ec_dev = priv->ec_dev;
255 struct ec_event *event, *e;
256
257 blocking_notifier_chain_unregister(nh: &ec_dev->event_notifier,
258 nb: &priv->notifier);
259
260 list_for_each_entry_safe(event, e, &priv->events, node) {
261 list_del(entry: &event->node);
262 kfree(objp: event);
263 }
264 kfree(objp: priv);
265
266 return 0;
267}
268
269/*
270 * Ioctls
271 */
272static long cros_ec_chardev_ioctl_xcmd(struct chardev_priv *priv, void __user *arg)
273{
274 struct cros_ec_command *s_cmd;
275 struct cros_ec_command u_cmd;
276 long ret;
277
278 if (copy_from_user(to: &u_cmd, from: arg, n: sizeof(u_cmd)))
279 return -EFAULT;
280
281 if (u_cmd.outsize > EC_MAX_MSG_BYTES ||
282 u_cmd.insize > EC_MAX_MSG_BYTES)
283 return -EINVAL;
284
285 s_cmd = kzalloc(sizeof(*s_cmd) + max(u_cmd.outsize, u_cmd.insize),
286 GFP_KERNEL);
287 if (!s_cmd)
288 return -ENOMEM;
289
290 if (copy_from_user(to: s_cmd, from: arg, n: sizeof(*s_cmd) + u_cmd.outsize)) {
291 ret = -EFAULT;
292 goto exit;
293 }
294
295 if (u_cmd.outsize != s_cmd->outsize ||
296 u_cmd.insize != s_cmd->insize) {
297 ret = -EINVAL;
298 goto exit;
299 }
300
301 s_cmd->command += priv->cmd_offset;
302 ret = cros_ec_cmd_xfer(ec_dev: priv->ec_dev, msg: s_cmd);
303 /* Only copy data to userland if data was received. */
304 if (ret < 0)
305 goto exit;
306
307 if (copy_to_user(to: arg, from: s_cmd, n: sizeof(*s_cmd) + s_cmd->insize))
308 ret = -EFAULT;
309exit:
310 kfree(objp: s_cmd);
311 return ret;
312}
313
314static long cros_ec_chardev_ioctl_readmem(struct chardev_priv *priv, void __user *arg)
315{
316 struct cros_ec_device *ec_dev = priv->ec_dev;
317 struct cros_ec_readmem s_mem = { };
318 long num;
319
320 /* Not every platform supports direct reads */
321 if (!ec_dev->cmd_readmem)
322 return -ENOTTY;
323
324 if (copy_from_user(to: &s_mem, from: arg, n: sizeof(s_mem)))
325 return -EFAULT;
326
327 if (s_mem.bytes > sizeof(s_mem.buffer))
328 return -EINVAL;
329
330 num = ec_dev->cmd_readmem(ec_dev, s_mem.offset, s_mem.bytes,
331 s_mem.buffer);
332 if (num <= 0)
333 return num;
334
335 if (copy_to_user(to: (void __user *)arg, from: &s_mem, n: sizeof(s_mem)))
336 return -EFAULT;
337
338 return num;
339}
340
341static long cros_ec_chardev_ioctl(struct file *filp, unsigned int cmd,
342 unsigned long arg)
343{
344 struct chardev_priv *priv = filp->private_data;
345
346 if (_IOC_TYPE(cmd) != CROS_EC_DEV_IOC)
347 return -ENOTTY;
348
349 switch (cmd) {
350 case CROS_EC_DEV_IOCXCMD:
351 return cros_ec_chardev_ioctl_xcmd(priv, arg: (void __user *)arg);
352 case CROS_EC_DEV_IOCRDMEM:
353 return cros_ec_chardev_ioctl_readmem(priv, arg: (void __user *)arg);
354 case CROS_EC_DEV_IOCEVENTMASK:
355 priv->event_mask = arg;
356 return 0;
357 }
358
359 return -ENOTTY;
360}
361
362static const struct file_operations chardev_fops = {
363 .open = cros_ec_chardev_open,
364 .poll = cros_ec_chardev_poll,
365 .read = cros_ec_chardev_read,
366 .release = cros_ec_chardev_release,
367 .unlocked_ioctl = cros_ec_chardev_ioctl,
368#ifdef CONFIG_COMPAT
369 .compat_ioctl = cros_ec_chardev_ioctl,
370#endif
371};
372
373static int cros_ec_chardev_probe(struct platform_device *pdev)
374{
375 struct cros_ec_dev *ec = dev_get_drvdata(dev: pdev->dev.parent);
376 struct cros_ec_platform *ec_platform = dev_get_platdata(dev: ec->dev);
377 struct miscdevice *misc;
378
379 /* Create a char device: we want to create it anew */
380 misc = devm_kzalloc(dev: &pdev->dev, size: sizeof(*misc), GFP_KERNEL);
381 if (!misc)
382 return -ENOMEM;
383
384 misc->minor = MISC_DYNAMIC_MINOR;
385 misc->fops = &chardev_fops;
386 misc->name = ec_platform->ec_name;
387 misc->parent = pdev->dev.parent;
388
389 dev_set_drvdata(dev: &pdev->dev, data: misc);
390
391 return misc_register(misc);
392}
393
394static void cros_ec_chardev_remove(struct platform_device *pdev)
395{
396 struct miscdevice *misc = dev_get_drvdata(dev: &pdev->dev);
397
398 misc_deregister(misc);
399}
400
401static const struct platform_device_id cros_ec_chardev_id[] = {
402 { DRV_NAME, 0 },
403 {}
404};
405MODULE_DEVICE_TABLE(platform, cros_ec_chardev_id);
406
407static struct platform_driver cros_ec_chardev_driver = {
408 .driver = {
409 .name = DRV_NAME,
410 },
411 .probe = cros_ec_chardev_probe,
412 .remove = cros_ec_chardev_remove,
413 .id_table = cros_ec_chardev_id,
414};
415
416module_platform_driver(cros_ec_chardev_driver);
417
418MODULE_AUTHOR("Enric Balletbo i Serra <enric.balletbo@collabora.com>");
419MODULE_DESCRIPTION("ChromeOS EC Miscellaneous Character Driver");
420MODULE_LICENSE("GPL");
421

source code of linux/drivers/platform/chrome/cros_ec_chardev.c