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"); 516