1
2
3
4
5
6
7
8
9
10
11
12#include <linux/cdev.h>
13#include <linux/device.h>
14#include <linux/fs.h>
15#include <linux/idr.h>
16#include <linux/kernel.h>
17#include <linux/module.h>
18#include <linux/poll.h>
19#include <linux/rpmsg.h>
20#include <linux/skbuff.h>
21#include <linux/slab.h>
22#include <linux/uaccess.h>
23#include <uapi/linux/rpmsg.h>
24
25#include "rpmsg_internal.h"
26
27#define RPMSG_DEV_MAX (MINORMASK + 1)
28
29static dev_t rpmsg_major;
30static struct class *rpmsg_class;
31
32static DEFINE_IDA(rpmsg_ctrl_ida);
33static DEFINE_IDA(rpmsg_ept_ida);
34static DEFINE_IDA(rpmsg_minor_ida);
35
36#define dev_to_eptdev(dev) container_of(dev, struct rpmsg_eptdev, dev)
37#define cdev_to_eptdev(i_cdev) container_of(i_cdev, struct rpmsg_eptdev, cdev)
38
39#define dev_to_ctrldev(dev) container_of(dev, struct rpmsg_ctrldev, dev)
40#define cdev_to_ctrldev(i_cdev) container_of(i_cdev, struct rpmsg_ctrldev, cdev)
41
42
43
44
45
46
47
48struct rpmsg_ctrldev {
49 struct rpmsg_device *rpdev;
50 struct cdev cdev;
51 struct device dev;
52};
53
54
55
56
57
58
59
60
61
62
63
64
65
66struct rpmsg_eptdev {
67 struct device dev;
68 struct cdev cdev;
69
70 struct rpmsg_device *rpdev;
71 struct rpmsg_channel_info chinfo;
72
73 struct mutex ept_lock;
74 struct rpmsg_endpoint *ept;
75
76 spinlock_t queue_lock;
77 struct sk_buff_head queue;
78 wait_queue_head_t readq;
79};
80
81static int rpmsg_eptdev_destroy(struct device *dev, void *data)
82{
83 struct rpmsg_eptdev *eptdev = dev_to_eptdev(dev);
84
85 mutex_lock(&eptdev->ept_lock);
86 if (eptdev->ept) {
87 rpmsg_destroy_ept(eptdev->ept);
88 eptdev->ept = NULL;
89 }
90 mutex_unlock(&eptdev->ept_lock);
91
92
93 wake_up_interruptible(&eptdev->readq);
94
95 device_del(&eptdev->dev);
96 put_device(&eptdev->dev);
97
98 return 0;
99}
100
101static int rpmsg_ept_cb(struct rpmsg_device *rpdev, void *buf, int len,
102 void *priv, u32 addr)
103{
104 struct rpmsg_eptdev *eptdev = priv;
105 struct sk_buff *skb;
106
107 skb = alloc_skb(len, GFP_ATOMIC);
108 if (!skb)
109 return -ENOMEM;
110
111 skb_put_data(skb, buf, len);
112
113 spin_lock(&eptdev->queue_lock);
114 skb_queue_tail(&eptdev->queue, skb);
115 spin_unlock(&eptdev->queue_lock);
116
117
118 wake_up_interruptible(&eptdev->readq);
119
120 return 0;
121}
122
123static int rpmsg_eptdev_open(struct inode *inode, struct file *filp)
124{
125 struct rpmsg_eptdev *eptdev = cdev_to_eptdev(inode->i_cdev);
126 struct rpmsg_endpoint *ept;
127 struct rpmsg_device *rpdev = eptdev->rpdev;
128 struct device *dev = &eptdev->dev;
129
130 get_device(dev);
131
132 ept = rpmsg_create_ept(rpdev, rpmsg_ept_cb, eptdev, eptdev->chinfo);
133 if (!ept) {
134 dev_err(dev, "failed to open %s\n", eptdev->chinfo.name);
135 put_device(dev);
136 return -EINVAL;
137 }
138
139 eptdev->ept = ept;
140 filp->private_data = eptdev;
141
142 return 0;
143}
144
145static int rpmsg_eptdev_release(struct inode *inode, struct file *filp)
146{
147 struct rpmsg_eptdev *eptdev = cdev_to_eptdev(inode->i_cdev);
148 struct device *dev = &eptdev->dev;
149
150
151 mutex_lock(&eptdev->ept_lock);
152 if (eptdev->ept) {
153 rpmsg_destroy_ept(eptdev->ept);
154 eptdev->ept = NULL;
155 }
156 mutex_unlock(&eptdev->ept_lock);
157
158
159 skb_queue_purge(&eptdev->queue);
160
161 put_device(dev);
162
163 return 0;
164}
165
166static ssize_t rpmsg_eptdev_read_iter(struct kiocb *iocb, struct iov_iter *to)
167{
168 struct file *filp = iocb->ki_filp;
169 struct rpmsg_eptdev *eptdev = filp->private_data;
170 unsigned long flags;
171 struct sk_buff *skb;
172 int use;
173
174 if (!eptdev->ept)
175 return -EPIPE;
176
177 spin_lock_irqsave(&eptdev->queue_lock, flags);
178
179
180 if (skb_queue_empty(&eptdev->queue)) {
181 spin_unlock_irqrestore(&eptdev->queue_lock, flags);
182
183 if (filp->f_flags & O_NONBLOCK)
184 return -EAGAIN;
185
186
187 if (wait_event_interruptible(eptdev->readq,
188 !skb_queue_empty(&eptdev->queue) ||
189 !eptdev->ept))
190 return -ERESTARTSYS;
191
192
193 if (!eptdev->ept)
194 return -EPIPE;
195
196 spin_lock_irqsave(&eptdev->queue_lock, flags);
197 }
198
199 skb = skb_dequeue(&eptdev->queue);
200 spin_unlock_irqrestore(&eptdev->queue_lock, flags);
201 if (!skb)
202 return -EFAULT;
203
204 use = min_t(size_t, iov_iter_count(to), skb->len);
205 if (copy_to_iter(skb->data, use, to) != use)
206 use = -EFAULT;
207
208 kfree_skb(skb);
209
210 return use;
211}
212
213static ssize_t rpmsg_eptdev_write_iter(struct kiocb *iocb,
214 struct iov_iter *from)
215{
216 struct file *filp = iocb->ki_filp;
217 struct rpmsg_eptdev *eptdev = filp->private_data;
218 size_t len = iov_iter_count(from);
219 void *kbuf;
220 int ret;
221
222 kbuf = kzalloc(len, GFP_KERNEL);
223 if (!kbuf)
224 return -ENOMEM;
225
226 if (!copy_from_iter_full(kbuf, len, from)) {
227 ret = -EFAULT;
228 goto free_kbuf;
229 }
230
231 if (mutex_lock_interruptible(&eptdev->ept_lock)) {
232 ret = -ERESTARTSYS;
233 goto free_kbuf;
234 }
235
236 if (!eptdev->ept) {
237 ret = -EPIPE;
238 goto unlock_eptdev;
239 }
240
241 if (filp->f_flags & O_NONBLOCK)
242 ret = rpmsg_trysend(eptdev->ept, kbuf, len);
243 else
244 ret = rpmsg_send(eptdev->ept, kbuf, len);
245
246unlock_eptdev:
247 mutex_unlock(&eptdev->ept_lock);
248
249free_kbuf:
250 kfree(kbuf);
251 return ret < 0 ? ret : len;
252}
253
254static __poll_t rpmsg_eptdev_poll(struct file *filp, poll_table *wait)
255{
256 struct rpmsg_eptdev *eptdev = filp->private_data;
257 __poll_t mask = 0;
258
259 if (!eptdev->ept)
260 return EPOLLERR;
261
262 poll_wait(filp, &eptdev->readq, wait);
263
264 if (!skb_queue_empty(&eptdev->queue))
265 mask |= EPOLLIN | EPOLLRDNORM;
266
267 mask |= rpmsg_poll(eptdev->ept, filp, wait);
268
269 return mask;
270}
271
272static long rpmsg_eptdev_ioctl(struct file *fp, unsigned int cmd,
273 unsigned long arg)
274{
275 struct rpmsg_eptdev *eptdev = fp->private_data;
276
277 if (cmd != RPMSG_DESTROY_EPT_IOCTL)
278 return -EINVAL;
279
280 return rpmsg_eptdev_destroy(&eptdev->dev, NULL);
281}
282
283static const struct file_operations rpmsg_eptdev_fops = {
284 .owner = THIS_MODULE,
285 .open = rpmsg_eptdev_open,
286 .release = rpmsg_eptdev_release,
287 .read_iter = rpmsg_eptdev_read_iter,
288 .write_iter = rpmsg_eptdev_write_iter,
289 .poll = rpmsg_eptdev_poll,
290 .unlocked_ioctl = rpmsg_eptdev_ioctl,
291 .compat_ioctl = compat_ptr_ioctl,
292};
293
294static ssize_t name_show(struct device *dev, struct device_attribute *attr,
295 char *buf)
296{
297 struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
298
299 return sprintf(buf, "%s\n", eptdev->chinfo.name);
300}
301static DEVICE_ATTR_RO(name);
302
303static ssize_t src_show(struct device *dev, struct device_attribute *attr,
304 char *buf)
305{
306 struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
307
308 return sprintf(buf, "%d\n", eptdev->chinfo.src);
309}
310static DEVICE_ATTR_RO(src);
311
312static ssize_t dst_show(struct device *dev, struct device_attribute *attr,
313 char *buf)
314{
315 struct rpmsg_eptdev *eptdev = dev_get_drvdata(dev);
316
317 return sprintf(buf, "%d\n", eptdev->chinfo.dst);
318}
319static DEVICE_ATTR_RO(dst);
320
321static struct attribute *rpmsg_eptdev_attrs[] = {
322 &dev_attr_name.attr,
323 &dev_attr_src.attr,
324 &dev_attr_dst.attr,
325 NULL
326};
327ATTRIBUTE_GROUPS(rpmsg_eptdev);
328
329static void rpmsg_eptdev_release_device(struct device *dev)
330{
331 struct rpmsg_eptdev *eptdev = dev_to_eptdev(dev);
332
333 ida_simple_remove(&rpmsg_ept_ida, dev->id);
334 ida_simple_remove(&rpmsg_minor_ida, MINOR(eptdev->dev.devt));
335 cdev_del(&eptdev->cdev);
336 kfree(eptdev);
337}
338
339static int rpmsg_eptdev_create(struct rpmsg_ctrldev *ctrldev,
340 struct rpmsg_channel_info chinfo)
341{
342 struct rpmsg_device *rpdev = ctrldev->rpdev;
343 struct rpmsg_eptdev *eptdev;
344 struct device *dev;
345 int ret;
346
347 eptdev = kzalloc(sizeof(*eptdev), GFP_KERNEL);
348 if (!eptdev)
349 return -ENOMEM;
350
351 dev = &eptdev->dev;
352 eptdev->rpdev = rpdev;
353 eptdev->chinfo = chinfo;
354
355 mutex_init(&eptdev->ept_lock);
356 spin_lock_init(&eptdev->queue_lock);
357 skb_queue_head_init(&eptdev->queue);
358 init_waitqueue_head(&eptdev->readq);
359
360 device_initialize(dev);
361 dev->class = rpmsg_class;
362 dev->parent = &ctrldev->dev;
363 dev->groups = rpmsg_eptdev_groups;
364 dev_set_drvdata(dev, eptdev);
365
366 cdev_init(&eptdev->cdev, &rpmsg_eptdev_fops);
367 eptdev->cdev.owner = THIS_MODULE;
368
369 ret = ida_simple_get(&rpmsg_minor_ida, 0, RPMSG_DEV_MAX, GFP_KERNEL);
370 if (ret < 0)
371 goto free_eptdev;
372 dev->devt = MKDEV(MAJOR(rpmsg_major), ret);
373
374 ret = ida_simple_get(&rpmsg_ept_ida, 0, 0, GFP_KERNEL);
375 if (ret < 0)
376 goto free_minor_ida;
377 dev->id = ret;
378 dev_set_name(dev, "rpmsg%d", ret);
379
380 ret = cdev_add(&eptdev->cdev, dev->devt, 1);
381 if (ret)
382 goto free_ept_ida;
383
384
385 dev->release = rpmsg_eptdev_release_device;
386
387 ret = device_add(dev);
388 if (ret) {
389 dev_err(dev, "device_add failed: %d\n", ret);
390 put_device(dev);
391 }
392
393 return ret;
394
395free_ept_ida:
396 ida_simple_remove(&rpmsg_ept_ida, dev->id);
397free_minor_ida:
398 ida_simple_remove(&rpmsg_minor_ida, MINOR(dev->devt));
399free_eptdev:
400 put_device(dev);
401 kfree(eptdev);
402
403 return ret;
404}
405
406static int rpmsg_ctrldev_open(struct inode *inode, struct file *filp)
407{
408 struct rpmsg_ctrldev *ctrldev = cdev_to_ctrldev(inode->i_cdev);
409
410 get_device(&ctrldev->dev);
411 filp->private_data = ctrldev;
412
413 return 0;
414}
415
416static int rpmsg_ctrldev_release(struct inode *inode, struct file *filp)
417{
418 struct rpmsg_ctrldev *ctrldev = cdev_to_ctrldev(inode->i_cdev);
419
420 put_device(&ctrldev->dev);
421
422 return 0;
423}
424
425static long rpmsg_ctrldev_ioctl(struct file *fp, unsigned int cmd,
426 unsigned long arg)
427{
428 struct rpmsg_ctrldev *ctrldev = fp->private_data;
429 void __user *argp = (void __user *)arg;
430 struct rpmsg_endpoint_info eptinfo;
431 struct rpmsg_channel_info chinfo;
432
433 if (cmd != RPMSG_CREATE_EPT_IOCTL)
434 return -EINVAL;
435
436 if (copy_from_user(&eptinfo, argp, sizeof(eptinfo)))
437 return -EFAULT;
438
439 memcpy(chinfo.name, eptinfo.name, RPMSG_NAME_SIZE);
440 chinfo.name[RPMSG_NAME_SIZE-1] = '\0';
441 chinfo.src = eptinfo.src;
442 chinfo.dst = eptinfo.dst;
443
444 return rpmsg_eptdev_create(ctrldev, chinfo);
445};
446
447static const struct file_operations rpmsg_ctrldev_fops = {
448 .owner = THIS_MODULE,
449 .open = rpmsg_ctrldev_open,
450 .release = rpmsg_ctrldev_release,
451 .unlocked_ioctl = rpmsg_ctrldev_ioctl,
452 .compat_ioctl = compat_ptr_ioctl,
453};
454
455static void rpmsg_ctrldev_release_device(struct device *dev)
456{
457 struct rpmsg_ctrldev *ctrldev = dev_to_ctrldev(dev);
458
459 ida_simple_remove(&rpmsg_ctrl_ida, dev->id);
460 ida_simple_remove(&rpmsg_minor_ida, MINOR(dev->devt));
461 cdev_del(&ctrldev->cdev);
462 kfree(ctrldev);
463}
464
465static int rpmsg_chrdev_probe(struct rpmsg_device *rpdev)
466{
467 struct rpmsg_ctrldev *ctrldev;
468 struct device *dev;
469 int ret;
470
471 ctrldev = kzalloc(sizeof(*ctrldev), GFP_KERNEL);
472 if (!ctrldev)
473 return -ENOMEM;
474
475 ctrldev->rpdev = rpdev;
476
477 dev = &ctrldev->dev;
478 device_initialize(dev);
479 dev->parent = &rpdev->dev;
480 dev->class = rpmsg_class;
481
482 cdev_init(&ctrldev->cdev, &rpmsg_ctrldev_fops);
483 ctrldev->cdev.owner = THIS_MODULE;
484
485 ret = ida_simple_get(&rpmsg_minor_ida, 0, RPMSG_DEV_MAX, GFP_KERNEL);
486 if (ret < 0)
487 goto free_ctrldev;
488 dev->devt = MKDEV(MAJOR(rpmsg_major), ret);
489
490 ret = ida_simple_get(&rpmsg_ctrl_ida, 0, 0, GFP_KERNEL);
491 if (ret < 0)
492 goto free_minor_ida;
493 dev->id = ret;
494 dev_set_name(&ctrldev->dev, "rpmsg_ctrl%d", ret);
495
496 ret = cdev_add(&ctrldev->cdev, dev->devt, 1);
497 if (ret)
498 goto free_ctrl_ida;
499
500
501 dev->release = rpmsg_ctrldev_release_device;
502
503 ret = device_add(dev);
504 if (ret) {
505 dev_err(&rpdev->dev, "device_add failed: %d\n", ret);
506 put_device(dev);
507 }
508
509 dev_set_drvdata(&rpdev->dev, ctrldev);
510
511 return ret;
512
513free_ctrl_ida:
514 ida_simple_remove(&rpmsg_ctrl_ida, dev->id);
515free_minor_ida:
516 ida_simple_remove(&rpmsg_minor_ida, MINOR(dev->devt));
517free_ctrldev:
518 put_device(dev);
519 kfree(ctrldev);
520
521 return ret;
522}
523
524static void rpmsg_chrdev_remove(struct rpmsg_device *rpdev)
525{
526 struct rpmsg_ctrldev *ctrldev = dev_get_drvdata(&rpdev->dev);
527 int ret;
528
529
530 ret = device_for_each_child(&ctrldev->dev, NULL, rpmsg_eptdev_destroy);
531 if (ret)
532 dev_warn(&rpdev->dev, "failed to nuke endpoints: %d\n", ret);
533
534 device_del(&ctrldev->dev);
535 put_device(&ctrldev->dev);
536}
537
538static struct rpmsg_driver rpmsg_chrdev_driver = {
539 .probe = rpmsg_chrdev_probe,
540 .remove = rpmsg_chrdev_remove,
541 .drv = {
542 .name = "rpmsg_chrdev",
543 },
544};
545
546static int rpmsg_char_init(void)
547{
548 int ret;
549
550 ret = alloc_chrdev_region(&rpmsg_major, 0, RPMSG_DEV_MAX, "rpmsg");
551 if (ret < 0) {
552 pr_err("rpmsg: failed to allocate char dev region\n");
553 return ret;
554 }
555
556 rpmsg_class = class_create(THIS_MODULE, "rpmsg");
557 if (IS_ERR(rpmsg_class)) {
558 pr_err("failed to create rpmsg class\n");
559 unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);
560 return PTR_ERR(rpmsg_class);
561 }
562
563 ret = register_rpmsg_driver(&rpmsg_chrdev_driver);
564 if (ret < 0) {
565 pr_err("rpmsgchr: failed to register rpmsg driver\n");
566 class_destroy(rpmsg_class);
567 unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);
568 }
569
570 return ret;
571}
572postcore_initcall(rpmsg_char_init);
573
574static void rpmsg_chrdev_exit(void)
575{
576 unregister_rpmsg_driver(&rpmsg_chrdev_driver);
577 class_destroy(rpmsg_class);
578 unregister_chrdev_region(rpmsg_major, RPMSG_DEV_MAX);
579}
580module_exit(rpmsg_chrdev_exit);
581
582MODULE_ALIAS("rpmsg:rpmsg_chrdev");
583MODULE_LICENSE("GPL v2");
584
