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