GNU Linux-libre 5.19-rc6-gnu
[releases.git] / drivers / rpmsg / rpmsg_char.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2022, STMicroelectronics
4  * Copyright (c) 2016, Linaro Ltd.
5  * Copyright (c) 2012, Michal Simek <monstr@monstr.eu>
6  * Copyright (c) 2012, PetaLogix
7  * Copyright (c) 2011, Texas Instruments, Inc.
8  * Copyright (c) 2011, Google, Inc.
9  *
10  * Based on rpmsg performance statistics driver by Michal Simek, which in turn
11  * was based on TI & Google OMX rpmsg driver.
12  */
13
14 #define pr_fmt(fmt)     KBUILD_MODNAME ": " fmt
15
16 #include <linux/cdev.h>
17 #include <linux/device.h>
18 #include <linux/fs.h>
19 #include <linux/idr.h>
20 #include <linux/kernel.h>
21 #include <linux/module.h>
22 #include <linux/poll.h>
23 #include <linux/rpmsg.h>
24 #include <linux/skbuff.h>
25 #include <linux/slab.h>
26 #include <linux/uaccess.h>
27 #include <uapi/linux/rpmsg.h>
28
29 #include "rpmsg_char.h"
30 #include "rpmsg_internal.h"
31
32 #define RPMSG_DEV_MAX   (MINORMASK + 1)
33
34 static dev_t rpmsg_major;
35
36 static DEFINE_IDA(rpmsg_ept_ida);
37 static DEFINE_IDA(rpmsg_minor_ida);
38
39 #define dev_to_eptdev(dev) container_of(dev, struct rpmsg_eptdev, dev)
40 #define cdev_to_eptdev(i_cdev) container_of(i_cdev, struct rpmsg_eptdev, cdev)
41
42 /**
43  * struct rpmsg_eptdev - endpoint device context
44  * @dev:        endpoint device
45  * @cdev:       cdev for the endpoint device
46  * @rpdev:      underlaying rpmsg device
47  * @chinfo:     info used to open the endpoint
48  * @ept_lock:   synchronization of @ept modifications
49  * @ept:        rpmsg endpoint reference, when open
50  * @queue_lock: synchronization of @queue operations
51  * @queue:      incoming message queue
52  * @readq:      wait object for incoming queue
53  * @default_ept: set to channel default endpoint if the default endpoint should be re-used
54  *              on device open to prevent endpoint address update.
55  */
56 struct rpmsg_eptdev {
57         struct device dev;
58         struct cdev cdev;
59
60         struct rpmsg_device *rpdev;
61         struct rpmsg_channel_info chinfo;
62
63         struct mutex ept_lock;
64         struct rpmsg_endpoint *ept;
65         struct rpmsg_endpoint *default_ept;
66
67         spinlock_t queue_lock;
68         struct sk_buff_head queue;
69         wait_queue_head_t readq;
70
71 };
72
73 int rpmsg_chrdev_eptdev_destroy(struct device *dev, void *data)
74 {
75         struct rpmsg_eptdev *eptdev = dev_to_eptdev(dev);
76
77         mutex_lock(&eptdev->ept_lock);
78         if (eptdev->ept) {
79                 rpmsg_destroy_ept(eptdev->ept);
80                 eptdev->ept = NULL;
81         }
82         mutex_unlock(&eptdev->ept_lock);
83
84         /* wake up any blocked readers */
85         wake_up_interruptible(&eptdev->readq);
86
87         cdev_device_del(&eptdev->cdev, &eptdev->dev);
88         put_device(&eptdev->dev);
89
90         return 0;
91 }
92 EXPORT_SYMBOL(rpmsg_chrdev_eptdev_destroy);
93
94 static int rpmsg_ept_cb(struct rpmsg_device *rpdev, void *buf, int len,
95                         void *priv, u32 addr)
96 {
97         struct rpmsg_eptdev *eptdev = priv;
98         struct sk_buff *skb;
99
100         skb = alloc_skb(len, GFP_ATOMIC);
101         if (!skb)
102                 return -ENOMEM;
103
104         skb_put_data(skb, buf, len);
105
106         spin_lock(&eptdev->queue_lock);
107         skb_queue_tail(&eptdev->queue, skb);
108         spin_unlock(&eptdev->queue_lock);
109
110         /* wake up any blocking processes, waiting for new data */
111         wake_up_interruptible(&eptdev->readq);
112
113         return 0;
114 }
115
116 static int rpmsg_eptdev_open(struct inode *inode, struct file *filp)
117 {
118         struct rpmsg_eptdev *eptdev = cdev_to_eptdev(inode->i_cdev);
119         struct rpmsg_endpoint *ept;
120         struct rpmsg_device *rpdev = eptdev->rpdev;
121         struct device *dev = &eptdev->dev;
122
123         if (eptdev->ept)
124                 return -EBUSY;
125
126         get_device(dev);
127
128         /*
129          * If the default_ept is set, the rpmsg device default endpoint is used.
130          * Else a new endpoint is created on open that will be destroyed on release.
131          */
132         if (eptdev->default_ept)
133                 ept = eptdev->default_ept;
134         else
135                 ept = rpmsg_create_ept(rpdev, rpmsg_ept_cb, eptdev, eptdev->chinfo);
136
137         if (!ept) {
138                 dev_err(dev, "failed to open %s\n", eptdev->chinfo.name);
139                 put_device(dev);
140                 return -EINVAL;
141         }
142
143         eptdev->ept = ept;
144         filp->private_data = eptdev;
145
146         return 0;
147 }
148
149 static int rpmsg_eptdev_release(struct inode *inode, struct file *filp)
150 {
151         struct rpmsg_eptdev *eptdev = cdev_to_eptdev(inode->i_cdev);
152         struct device *dev = &eptdev->dev;
153
154         /* Close the endpoint, if it's not already destroyed by the parent */
155         mutex_lock(&eptdev->ept_lock);
156         if (eptdev->ept) {
157                 if (!eptdev->default_ept)
158                         rpmsg_destroy_ept(eptdev->ept);
159                 eptdev->ept = NULL;
160         }
161         mutex_unlock(&eptdev->ept_lock);
162
163         /* Discard all SKBs */
164         skb_queue_purge(&eptdev->queue);
165
166         put_device(dev);
167
168         return 0;
169 }
170
171 static ssize_t rpmsg_eptdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
172 {
173         struct file *filp = iocb->ki_filp;
174         struct rpmsg_eptdev *eptdev = filp->private_data;
175         unsigned long flags;
176         struct sk_buff *skb;
177         int use;
178
179         if (!eptdev->ept)
180                 return -EPIPE;
181
182         spin_lock_irqsave(&eptdev->queue_lock, flags);
183
184         /* Wait for data in the queue */
185         if (skb_queue_empty(&eptdev->queue)) {
186                 spin_unlock_irqrestore(&eptdev->queue_lock, flags);
187
188                 if (filp->f_flags & O_NONBLOCK)
189                         return -EAGAIN;
190
191                 /* Wait until we get data or the endpoint goes away */
192                 if (wait_event_interruptible(eptdev->readq,
193                                              !skb_queue_empty(&eptdev->queue) ||
194                                              !eptdev->ept))
195                         return -ERESTARTSYS;
196
197                 /* We lost the endpoint while waiting */
198                 if (!eptdev->ept)
199                         return -EPIPE;
200
201                 spin_lock_irqsave(&eptdev->queue_lock, flags);
202         }
203
204         skb = skb_dequeue(&eptdev->queue);
205         spin_unlock_irqrestore(&eptdev->queue_lock, flags);
206         if (!skb)
207                 return -EFAULT;
208
209         use = min_t(size_t, iov_iter_count(to), skb->len);
210         if (copy_to_iter(skb->data, use, to) != use)
211                 use = -EFAULT;
212
213         kfree_skb(skb);
214
215         return use;
216 }
217
218 static ssize_t rpmsg_eptdev_write_iter(struct kiocb *iocb,
219                                        struct iov_iter *from)
220 {
221         struct file *filp = iocb->ki_filp;
222         struct rpmsg_eptdev *eptdev = filp->private_data;
223         size_t len = iov_iter_count(from);
224         void *kbuf;
225         int ret;
226
227         kbuf = kzalloc(len, GFP_KERNEL);
228         if (!kbuf)
229                 return -ENOMEM;
230
231         if (!copy_from_iter_full(kbuf, len, from)) {
232                 ret = -EFAULT;
233                 goto free_kbuf;
234         }
235
236         if (mutex_lock_interruptible(&eptdev->ept_lock)) {
237                 ret = -ERESTARTSYS;
238                 goto free_kbuf;
239         }
240
241         if (!eptdev->ept) {
242                 ret = -EPIPE;
243                 goto unlock_eptdev;
244         }
245
246         if (filp->f_flags & O_NONBLOCK) {
247                 ret = rpmsg_trysendto(eptdev->ept, kbuf, len, eptdev->chinfo.dst);
248                 if (ret == -ENOMEM)
249                         ret = -EAGAIN;
250         } else {
251                 ret = rpmsg_sendto(eptdev->ept, kbuf, len, eptdev->chinfo.dst);
252         }
253
254 unlock_eptdev:
255         mutex_unlock(&eptdev->ept_lock);
256
257 free_kbuf:
258         kfree(kbuf);
259         return ret < 0 ? ret : len;
260 }
261
262 static __poll_t rpmsg_eptdev_poll(struct file *filp, poll_table *wait)
263 {
264         struct rpmsg_eptdev *eptdev = filp->private_data;
265         __poll_t mask = 0;
266
267         if (!eptdev->ept)
268                 return EPOLLERR;
269
270         poll_wait(filp, &eptdev->readq, wait);
271
272         if (!skb_queue_empty(&eptdev->queue))
273                 mask |= EPOLLIN | EPOLLRDNORM;
274
275         mask |= rpmsg_poll(eptdev->ept, filp, wait);
276
277         return mask;
278 }
279
280 static long rpmsg_eptdev_ioctl(struct file *fp, unsigned int cmd,
281                                unsigned long arg)
282 {
283         struct rpmsg_eptdev *eptdev = fp->private_data;
284
285         if (cmd != RPMSG_DESTROY_EPT_IOCTL)
286                 return -EINVAL;
287
288         /* Don't allow to destroy a default endpoint. */
289         if (eptdev->default_ept)
290                 return -EINVAL;
291
292         return rpmsg_chrdev_eptdev_destroy(&eptdev->dev, NULL);
293 }
294
295 static const struct file_operations rpmsg_eptdev_fops = {
296         .owner = THIS_MODULE,
297         .open = rpmsg_eptdev_open,
298         .release = rpmsg_eptdev_release,
299         .read_iter = rpmsg_eptdev_read_iter,
300         .write_iter = rpmsg_eptdev_write_iter,
301         .poll = rpmsg_eptdev_poll,
302         .unlocked_ioctl = rpmsg_eptdev_ioctl,
303         .compat_ioctl = compat_ptr_ioctl,
304 };
305
306 static ssize_t name_show(struct device *dev, struct device_attribute *attr,
307                          char *buf)
308 {
309         struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
310
311         return sprintf(buf, "%s\n", eptdev->chinfo.name);
312 }
313 static DEVICE_ATTR_RO(name);
314
315 static ssize_t src_show(struct device *dev, struct device_attribute *attr,
316                          char *buf)
317 {
318         struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
319
320         return sprintf(buf, "%d\n", eptdev->chinfo.src);
321 }
322 static DEVICE_ATTR_RO(src);
323
324 static ssize_t dst_show(struct device *dev, struct device_attribute *attr,
325                          char *buf)
326 {
327         struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
328
329         return sprintf(buf, "%d\n", eptdev->chinfo.dst);
330 }
331 static DEVICE_ATTR_RO(dst);
332
333 static struct attribute *rpmsg_eptdev_attrs[] = {
334         &dev_attr_name.attr,
335         &dev_attr_src.attr,
336         &dev_attr_dst.attr,
337         NULL
338 };
339 ATTRIBUTE_GROUPS(rpmsg_eptdev);
340
341 static void rpmsg_eptdev_release_device(struct device *dev)
342 {
343         struct rpmsg_eptdev *eptdev = dev_to_eptdev(dev);
344
345         ida_simple_remove(&rpmsg_ept_ida, dev->id);
346         ida_simple_remove(&rpmsg_minor_ida, MINOR(eptdev->dev.devt));
347         kfree(eptdev);
348 }
349
350 static struct rpmsg_eptdev *rpmsg_chrdev_eptdev_alloc(struct rpmsg_device *rpdev,
351                                                       struct device *parent)
352 {
353         struct rpmsg_eptdev *eptdev;
354         struct device *dev;
355
356         eptdev = kzalloc(sizeof(*eptdev), GFP_KERNEL);
357         if (!eptdev)
358                 return ERR_PTR(-ENOMEM);
359
360         dev = &eptdev->dev;
361         eptdev->rpdev = rpdev;
362
363         mutex_init(&eptdev->ept_lock);
364         spin_lock_init(&eptdev->queue_lock);
365         skb_queue_head_init(&eptdev->queue);
366         init_waitqueue_head(&eptdev->readq);
367
368         device_initialize(dev);
369         dev->class = rpmsg_class;
370         dev->parent = parent;
371         dev->groups = rpmsg_eptdev_groups;
372         dev_set_drvdata(dev, eptdev);
373
374         cdev_init(&eptdev->cdev, &rpmsg_eptdev_fops);
375         eptdev->cdev.owner = THIS_MODULE;
376
377         return eptdev;
378 }
379
380 static int rpmsg_chrdev_eptdev_add(struct rpmsg_eptdev *eptdev, struct rpmsg_channel_info chinfo)
381 {
382         struct device *dev = &eptdev->dev;
383         int ret;
384
385         eptdev->chinfo = chinfo;
386
387         ret = ida_simple_get(&rpmsg_minor_ida, 0, RPMSG_DEV_MAX, GFP_KERNEL);
388         if (ret < 0)
389                 goto free_eptdev;
390         dev->devt = MKDEV(MAJOR(rpmsg_major), ret);
391
392         ret = ida_simple_get(&rpmsg_ept_ida, 0, 0, GFP_KERNEL);
393         if (ret < 0)
394                 goto free_minor_ida;
395         dev->id = ret;
396         dev_set_name(dev, "rpmsg%d", ret);
397
398         ret = cdev_device_add(&eptdev->cdev, &eptdev->dev);
399         if (ret)
400                 goto free_ept_ida;
401
402         /* We can now rely on the release function for cleanup */
403         dev->release = rpmsg_eptdev_release_device;
404
405         return ret;
406
407 free_ept_ida:
408         ida_simple_remove(&rpmsg_ept_ida, dev->id);
409 free_minor_ida:
410         ida_simple_remove(&rpmsg_minor_ida, MINOR(dev->devt));
411 free_eptdev:
412         put_device(dev);
413         kfree(eptdev);
414
415         return ret;
416 }
417
418 int rpmsg_chrdev_eptdev_create(struct rpmsg_device *rpdev, struct device *parent,
419                                struct rpmsg_channel_info chinfo)
420 {
421         struct rpmsg_eptdev *eptdev;
422         int ret;
423
424         eptdev = rpmsg_chrdev_eptdev_alloc(rpdev, parent);
425         if (IS_ERR(eptdev))
426                 return PTR_ERR(eptdev);
427
428         ret = rpmsg_chrdev_eptdev_add(eptdev, chinfo);
429
430         return ret;
431 }
432 EXPORT_SYMBOL(rpmsg_chrdev_eptdev_create);
433
434 static int rpmsg_chrdev_probe(struct rpmsg_device *rpdev)
435 {
436         struct rpmsg_channel_info chinfo;
437         struct rpmsg_eptdev *eptdev;
438         struct device *dev = &rpdev->dev;
439
440         memcpy(chinfo.name, rpdev->id.name, RPMSG_NAME_SIZE);
441         chinfo.src = rpdev->src;
442         chinfo.dst = rpdev->dst;
443
444         eptdev = rpmsg_chrdev_eptdev_alloc(rpdev, dev);
445         if (IS_ERR(eptdev))
446                 return PTR_ERR(eptdev);
447
448         /* Set the default_ept to the rpmsg device endpoint */
449         eptdev->default_ept = rpdev->ept;
450
451         /*
452          * The rpmsg_ept_cb uses *priv parameter to get its rpmsg_eptdev context.
453          * Storedit in default_ept *priv field.
454          */
455         eptdev->default_ept->priv = eptdev;
456
457         return rpmsg_chrdev_eptdev_add(eptdev, chinfo);
458 }
459
460 static void rpmsg_chrdev_remove(struct rpmsg_device *rpdev)
461 {
462         int ret;
463
464         ret = device_for_each_child(&rpdev->dev, NULL, rpmsg_chrdev_eptdev_destroy);
465         if (ret)
466                 dev_warn(&rpdev->dev, "failed to destroy endpoints: %d\n", ret);
467 }
468
469 static struct rpmsg_device_id rpmsg_chrdev_id_table[] = {
470         { .name = "rpmsg-raw" },
471         { },
472 };
473
474 static struct rpmsg_driver rpmsg_chrdev_driver = {
475         .probe = rpmsg_chrdev_probe,
476         .remove = rpmsg_chrdev_remove,
477         .callback = rpmsg_ept_cb,
478         .id_table = rpmsg_chrdev_id_table,
479         .drv.name = "rpmsg_chrdev",
480 };
481
482 static int rpmsg_chrdev_init(void)
483 {
484         int ret;
485
486         ret = alloc_chrdev_region(&rpmsg_major, 0, RPMSG_DEV_MAX, "rpmsg_char");
487         if (ret < 0) {
488                 pr_err("failed to allocate char dev region\n");
489                 return ret;
490         }
491
492         ret = register_rpmsg_driver(&rpmsg_chrdev_driver);
493         if (ret < 0) {
494                 pr_err("rpmsg: failed to register rpmsg raw driver\n");
495                 goto free_region;
496         }
497
498         return 0;
499
500 free_region:
501         unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);
502
503         return ret;
504 }
505 postcore_initcall(rpmsg_chrdev_init);
506
507 static void rpmsg_chrdev_exit(void)
508 {
509         unregister_rpmsg_driver(&rpmsg_chrdev_driver);
510         unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);
511 }
512 module_exit(rpmsg_chrdev_exit);
513
514 MODULE_ALIAS("rpmsg:rpmsg_chrdev");
515 MODULE_LICENSE("GPL v2");