1 // SPDX-License-Identifier: GPL-2.0-only 2 /* Copyright (c) 2021, Linaro Ltd <loic.poulain@linaro.org> */ 3 4 #include <linux/err.h> 5 #include <linux/errno.h> 6 #include <linux/debugfs.h> 7 #include <linux/fs.h> 8 #include <linux/init.h> 9 #include <linux/idr.h> 10 #include <linux/kernel.h> 11 #include <linux/module.h> 12 #include <linux/poll.h> 13 #include <linux/skbuff.h> 14 #include <linux/slab.h> 15 #include <linux/types.h> 16 #include <linux/uaccess.h> 17 #include <linux/termios.h> 18 #include <linux/wwan.h> 19 #include <net/rtnetlink.h> 20 #include <uapi/linux/wwan.h> 21 22 /* Maximum number of minors in use */ 23 #define WWAN_MAX_MINORS (1 << MINORBITS) 24 25 static DEFINE_MUTEX(wwan_register_lock); /* WWAN device create|remove lock */ 26 static DEFINE_IDA(minors); /* minors for WWAN port chardevs */ 27 static DEFINE_IDA(wwan_dev_ids); /* for unique WWAN device IDs */ 28 static struct class *wwan_class; 29 static int wwan_major; 30 static struct dentry *wwan_debugfs_dir; 31 32 #define to_wwan_dev(d) container_of(d, struct wwan_device, dev) 33 #define to_wwan_port(d) container_of(d, struct wwan_port, dev) 34 35 /* WWAN port flags */ 36 #define WWAN_PORT_TX_OFF 0 37 38 /** 39 * struct wwan_device - The structure that defines a WWAN device 40 * 41 * @id: WWAN device unique ID. 42 * @dev: Underlying device. 43 * @port_id: Current available port ID to pick. 44 * @ops: wwan device ops 45 * @ops_ctxt: context to pass to ops 46 * @debugfs_dir: WWAN device debugfs dir 47 */ 48 struct wwan_device { 49 unsigned int id; 50 struct device dev; 51 atomic_t port_id; 52 const struct wwan_ops *ops; 53 void *ops_ctxt; 54 #ifdef CONFIG_WWAN_DEBUGFS 55 struct dentry *debugfs_dir; 56 #endif 57 }; 58 59 /** 60 * struct wwan_port - The structure that defines a WWAN port 61 * @type: Port type 62 * @start_count: Port start counter 63 * @flags: Store port state and capabilities 64 * @ops: Pointer to WWAN port operations 65 * @ops_lock: Protect port ops 66 * @dev: Underlying device 67 * @rxq: Buffer inbound queue 68 * @waitqueue: The waitqueue for port fops (read/write/poll) 69 * @data_lock: Port specific data access serialization 70 * @at_data: AT port specific data 71 */ 72 struct wwan_port { 73 enum wwan_port_type type; 74 unsigned int start_count; 75 unsigned long flags; 76 const struct wwan_port_ops *ops; 77 struct mutex ops_lock; /* Serialize ops + protect against removal */ 78 struct device dev; 79 struct sk_buff_head rxq; 80 wait_queue_head_t waitqueue; 81 struct mutex data_lock; /* Port specific data access serialization */ 82 union { 83 struct { 84 struct ktermios termios; 85 int mdmbits; 86 } at_data; 87 }; 88 }; 89 90 static ssize_t index_show(struct device *dev, struct device_attribute *attr, char *buf) 91 { 92 struct wwan_device *wwan = to_wwan_dev(dev); 93 94 return sprintf(buf, "%d\n", wwan->id); 95 } 96 static DEVICE_ATTR_RO(index); 97 98 static struct attribute *wwan_dev_attrs[] = { 99 &dev_attr_index.attr, 100 NULL, 101 }; 102 ATTRIBUTE_GROUPS(wwan_dev); 103 104 static void wwan_dev_destroy(struct device *dev) 105 { 106 struct wwan_device *wwandev = to_wwan_dev(dev); 107 108 ida_free(&wwan_dev_ids, wwandev->id); 109 kfree(wwandev); 110 } 111 112 static const struct device_type wwan_dev_type = { 113 .name = "wwan_dev", 114 .release = wwan_dev_destroy, 115 .groups = wwan_dev_groups, 116 }; 117 118 static int wwan_dev_parent_match(struct device *dev, const void *parent) 119 { 120 return (dev->type == &wwan_dev_type && 121 (dev->parent == parent || dev == parent)); 122 } 123 124 static struct wwan_device *wwan_dev_get_by_parent(struct device *parent) 125 { 126 struct device *dev; 127 128 dev = class_find_device(wwan_class, NULL, parent, wwan_dev_parent_match); 129 if (!dev) 130 return ERR_PTR(-ENODEV); 131 132 return to_wwan_dev(dev); 133 } 134 135 static int wwan_dev_name_match(struct device *dev, const void *name) 136 { 137 return dev->type == &wwan_dev_type && 138 strcmp(dev_name(dev), name) == 0; 139 } 140 141 static struct wwan_device *wwan_dev_get_by_name(const char *name) 142 { 143 struct device *dev; 144 145 dev = class_find_device(wwan_class, NULL, name, wwan_dev_name_match); 146 if (!dev) 147 return ERR_PTR(-ENODEV); 148 149 return to_wwan_dev(dev); 150 } 151 152 #ifdef CONFIG_WWAN_DEBUGFS 153 struct dentry *wwan_get_debugfs_dir(struct device *parent) 154 { 155 struct wwan_device *wwandev; 156 157 wwandev = wwan_dev_get_by_parent(parent); 158 if (IS_ERR(wwandev)) 159 return ERR_CAST(wwandev); 160 161 return wwandev->debugfs_dir; 162 } 163 EXPORT_SYMBOL_GPL(wwan_get_debugfs_dir); 164 165 static int wwan_dev_debugfs_match(struct device *dev, const void *dir) 166 { 167 struct wwan_device *wwandev; 168 169 if (dev->type != &wwan_dev_type) 170 return 0; 171 172 wwandev = to_wwan_dev(dev); 173 174 return wwandev->debugfs_dir == dir; 175 } 176 177 static struct wwan_device *wwan_dev_get_by_debugfs(struct dentry *dir) 178 { 179 struct device *dev; 180 181 dev = class_find_device(wwan_class, NULL, dir, wwan_dev_debugfs_match); 182 if (!dev) 183 return ERR_PTR(-ENODEV); 184 185 return to_wwan_dev(dev); 186 } 187 188 void wwan_put_debugfs_dir(struct dentry *dir) 189 { 190 struct wwan_device *wwandev = wwan_dev_get_by_debugfs(dir); 191 192 if (WARN_ON(IS_ERR(wwandev))) 193 return; 194 195 /* wwan_dev_get_by_debugfs() also got a reference */ 196 put_device(&wwandev->dev); 197 put_device(&wwandev->dev); 198 } 199 EXPORT_SYMBOL_GPL(wwan_put_debugfs_dir); 200 #endif 201 202 /* This function allocates and registers a new WWAN device OR if a WWAN device 203 * already exist for the given parent, it gets a reference and return it. 204 * This function is not exported (for now), it is called indirectly via 205 * wwan_create_port(). 206 */ 207 static struct wwan_device *wwan_create_dev(struct device *parent) 208 { 209 struct wwan_device *wwandev; 210 int err, id; 211 212 /* The 'find-alloc-register' operation must be protected against 213 * concurrent execution, a WWAN device is possibly shared between 214 * multiple callers or concurrently unregistered from wwan_remove_dev(). 215 */ 216 mutex_lock(&wwan_register_lock); 217 218 /* If wwandev already exists, return it */ 219 wwandev = wwan_dev_get_by_parent(parent); 220 if (!IS_ERR(wwandev)) 221 goto done_unlock; 222 223 id = ida_alloc(&wwan_dev_ids, GFP_KERNEL); 224 if (id < 0) { 225 wwandev = ERR_PTR(id); 226 goto done_unlock; 227 } 228 229 wwandev = kzalloc(sizeof(*wwandev), GFP_KERNEL); 230 if (!wwandev) { 231 wwandev = ERR_PTR(-ENOMEM); 232 ida_free(&wwan_dev_ids, id); 233 goto done_unlock; 234 } 235 236 wwandev->dev.parent = parent; 237 wwandev->dev.class = wwan_class; 238 wwandev->dev.type = &wwan_dev_type; 239 wwandev->id = id; 240 dev_set_name(&wwandev->dev, "wwan%d", wwandev->id); 241 242 err = device_register(&wwandev->dev); 243 if (err) { 244 put_device(&wwandev->dev); 245 wwandev = ERR_PTR(err); 246 goto done_unlock; 247 } 248 249 #ifdef CONFIG_WWAN_DEBUGFS 250 wwandev->debugfs_dir = 251 debugfs_create_dir(kobject_name(&wwandev->dev.kobj), 252 wwan_debugfs_dir); 253 #endif 254 255 done_unlock: 256 mutex_unlock(&wwan_register_lock); 257 258 return wwandev; 259 } 260 261 static int is_wwan_child(struct device *dev, void *data) 262 { 263 return dev->class == wwan_class; 264 } 265 266 static void wwan_remove_dev(struct wwan_device *wwandev) 267 { 268 int ret; 269 270 /* Prevent concurrent picking from wwan_create_dev */ 271 mutex_lock(&wwan_register_lock); 272 273 /* WWAN device is created and registered (get+add) along with its first 274 * child port, and subsequent port registrations only grab a reference 275 * (get). The WWAN device must then be unregistered (del+put) along with 276 * its last port, and reference simply dropped (put) otherwise. In the 277 * same fashion, we must not unregister it when the ops are still there. 278 */ 279 if (wwandev->ops) 280 ret = 1; 281 else 282 ret = device_for_each_child(&wwandev->dev, NULL, is_wwan_child); 283 284 if (!ret) { 285 #ifdef CONFIG_WWAN_DEBUGFS 286 debugfs_remove_recursive(wwandev->debugfs_dir); 287 #endif 288 device_unregister(&wwandev->dev); 289 } else { 290 put_device(&wwandev->dev); 291 } 292 293 mutex_unlock(&wwan_register_lock); 294 } 295 296 /* ------- WWAN port management ------- */ 297 298 static const struct { 299 const char * const name; /* Port type name */ 300 const char * const devsuf; /* Port devce name suffix */ 301 } wwan_port_types[WWAN_PORT_MAX + 1] = { 302 [WWAN_PORT_AT] = { 303 .name = "AT", 304 .devsuf = "at", 305 }, 306 [WWAN_PORT_MBIM] = { 307 .name = "MBIM", 308 .devsuf = "mbim", 309 }, 310 [WWAN_PORT_QMI] = { 311 .name = "QMI", 312 .devsuf = "qmi", 313 }, 314 [WWAN_PORT_QCDM] = { 315 .name = "QCDM", 316 .devsuf = "qcdm", 317 }, 318 [WWAN_PORT_FIREHOSE] = { 319 .name = "FIREHOSE", 320 .devsuf = "firehose", 321 }, 322 [WWAN_PORT_XMMRPC] = { 323 .name = "XMMRPC", 324 .devsuf = "xmmrpc", 325 }, 326 }; 327 328 static ssize_t type_show(struct device *dev, struct device_attribute *attr, 329 char *buf) 330 { 331 struct wwan_port *port = to_wwan_port(dev); 332 333 return sprintf(buf, "%s\n", wwan_port_types[port->type].name); 334 } 335 static DEVICE_ATTR_RO(type); 336 337 static struct attribute *wwan_port_attrs[] = { 338 &dev_attr_type.attr, 339 NULL, 340 }; 341 ATTRIBUTE_GROUPS(wwan_port); 342 343 static void wwan_port_destroy(struct device *dev) 344 { 345 struct wwan_port *port = to_wwan_port(dev); 346 347 ida_free(&minors, MINOR(port->dev.devt)); 348 mutex_destroy(&port->data_lock); 349 mutex_destroy(&port->ops_lock); 350 kfree(port); 351 } 352 353 static const struct device_type wwan_port_dev_type = { 354 .name = "wwan_port", 355 .release = wwan_port_destroy, 356 .groups = wwan_port_groups, 357 }; 358 359 static int wwan_port_minor_match(struct device *dev, const void *minor) 360 { 361 return (dev->type == &wwan_port_dev_type && 362 MINOR(dev->devt) == *(unsigned int *)minor); 363 } 364 365 static struct wwan_port *wwan_port_get_by_minor(unsigned int minor) 366 { 367 struct device *dev; 368 369 dev = class_find_device(wwan_class, NULL, &minor, wwan_port_minor_match); 370 if (!dev) 371 return ERR_PTR(-ENODEV); 372 373 return to_wwan_port(dev); 374 } 375 376 /* Allocate and set unique name based on passed format 377 * 378 * Name allocation approach is highly inspired by the __dev_alloc_name() 379 * function. 380 * 381 * To avoid names collision, the caller must prevent the new port device 382 * registration as well as concurrent invocation of this function. 383 */ 384 static int __wwan_port_dev_assign_name(struct wwan_port *port, const char *fmt) 385 { 386 struct wwan_device *wwandev = to_wwan_dev(port->dev.parent); 387 const unsigned int max_ports = PAGE_SIZE * 8; 388 struct class_dev_iter iter; 389 unsigned long *idmap; 390 struct device *dev; 391 char buf[0x20]; 392 int id; 393 394 idmap = (unsigned long *)get_zeroed_page(GFP_KERNEL); 395 if (!idmap) 396 return -ENOMEM; 397 398 /* Collect ids of same name format ports */ 399 class_dev_iter_init(&iter, wwan_class, NULL, &wwan_port_dev_type); 400 while ((dev = class_dev_iter_next(&iter))) { 401 if (dev->parent != &wwandev->dev) 402 continue; 403 if (sscanf(dev_name(dev), fmt, &id) != 1) 404 continue; 405 if (id < 0 || id >= max_ports) 406 continue; 407 set_bit(id, idmap); 408 } 409 class_dev_iter_exit(&iter); 410 411 /* Allocate unique id */ 412 id = find_first_zero_bit(idmap, max_ports); 413 free_page((unsigned long)idmap); 414 415 snprintf(buf, sizeof(buf), fmt, id); /* Name generation */ 416 417 dev = device_find_child_by_name(&wwandev->dev, buf); 418 if (dev) { 419 put_device(dev); 420 return -ENFILE; 421 } 422 423 return dev_set_name(&port->dev, buf); 424 } 425 426 struct wwan_port *wwan_create_port(struct device *parent, 427 enum wwan_port_type type, 428 const struct wwan_port_ops *ops, 429 void *drvdata) 430 { 431 struct wwan_device *wwandev; 432 struct wwan_port *port; 433 char namefmt[0x20]; 434 int minor, err; 435 436 if (type > WWAN_PORT_MAX || !ops) 437 return ERR_PTR(-EINVAL); 438 439 /* A port is always a child of a WWAN device, retrieve (allocate or 440 * pick) the WWAN device based on the provided parent device. 441 */ 442 wwandev = wwan_create_dev(parent); 443 if (IS_ERR(wwandev)) 444 return ERR_CAST(wwandev); 445 446 /* A port is exposed as character device, get a minor */ 447 minor = ida_alloc_range(&minors, 0, WWAN_MAX_MINORS - 1, GFP_KERNEL); 448 if (minor < 0) { 449 err = minor; 450 goto error_wwandev_remove; 451 } 452 453 port = kzalloc(sizeof(*port), GFP_KERNEL); 454 if (!port) { 455 err = -ENOMEM; 456 ida_free(&minors, minor); 457 goto error_wwandev_remove; 458 } 459 460 port->type = type; 461 port->ops = ops; 462 mutex_init(&port->ops_lock); 463 skb_queue_head_init(&port->rxq); 464 init_waitqueue_head(&port->waitqueue); 465 mutex_init(&port->data_lock); 466 467 port->dev.parent = &wwandev->dev; 468 port->dev.class = wwan_class; 469 port->dev.type = &wwan_port_dev_type; 470 port->dev.devt = MKDEV(wwan_major, minor); 471 dev_set_drvdata(&port->dev, drvdata); 472 473 /* allocate unique name based on wwan device id, port type and number */ 474 snprintf(namefmt, sizeof(namefmt), "wwan%u%s%%d", wwandev->id, 475 wwan_port_types[port->type].devsuf); 476 477 /* Serialize ports registration */ 478 mutex_lock(&wwan_register_lock); 479 480 __wwan_port_dev_assign_name(port, namefmt); 481 err = device_register(&port->dev); 482 483 mutex_unlock(&wwan_register_lock); 484 485 if (err) 486 goto error_put_device; 487 488 return port; 489 490 error_put_device: 491 put_device(&port->dev); 492 error_wwandev_remove: 493 wwan_remove_dev(wwandev); 494 495 return ERR_PTR(err); 496 } 497 EXPORT_SYMBOL_GPL(wwan_create_port); 498 499 void wwan_remove_port(struct wwan_port *port) 500 { 501 struct wwan_device *wwandev = to_wwan_dev(port->dev.parent); 502 503 mutex_lock(&port->ops_lock); 504 if (port->start_count) 505 port->ops->stop(port); 506 port->ops = NULL; /* Prevent any new port operations (e.g. from fops) */ 507 mutex_unlock(&port->ops_lock); 508 509 wake_up_interruptible(&port->waitqueue); 510 511 skb_queue_purge(&port->rxq); 512 dev_set_drvdata(&port->dev, NULL); 513 device_unregister(&port->dev); 514 515 /* Release related wwan device */ 516 wwan_remove_dev(wwandev); 517 } 518 EXPORT_SYMBOL_GPL(wwan_remove_port); 519 520 void wwan_port_rx(struct wwan_port *port, struct sk_buff *skb) 521 { 522 skb_queue_tail(&port->rxq, skb); 523 wake_up_interruptible(&port->waitqueue); 524 } 525 EXPORT_SYMBOL_GPL(wwan_port_rx); 526 527 void wwan_port_txon(struct wwan_port *port) 528 { 529 clear_bit(WWAN_PORT_TX_OFF, &port->flags); 530 wake_up_interruptible(&port->waitqueue); 531 } 532 EXPORT_SYMBOL_GPL(wwan_port_txon); 533 534 void wwan_port_txoff(struct wwan_port *port) 535 { 536 set_bit(WWAN_PORT_TX_OFF, &port->flags); 537 } 538 EXPORT_SYMBOL_GPL(wwan_port_txoff); 539 540 void *wwan_port_get_drvdata(struct wwan_port *port) 541 { 542 return dev_get_drvdata(&port->dev); 543 } 544 EXPORT_SYMBOL_GPL(wwan_port_get_drvdata); 545 546 static int wwan_port_op_start(struct wwan_port *port) 547 { 548 int ret = 0; 549 550 mutex_lock(&port->ops_lock); 551 if (!port->ops) { /* Port got unplugged */ 552 ret = -ENODEV; 553 goto out_unlock; 554 } 555 556 /* If port is already started, don't start again */ 557 if (!port->start_count) 558 ret = port->ops->start(port); 559 560 if (!ret) 561 port->start_count++; 562 563 out_unlock: 564 mutex_unlock(&port->ops_lock); 565 566 return ret; 567 } 568 569 static void wwan_port_op_stop(struct wwan_port *port) 570 { 571 mutex_lock(&port->ops_lock); 572 port->start_count--; 573 if (!port->start_count) { 574 if (port->ops) 575 port->ops->stop(port); 576 skb_queue_purge(&port->rxq); 577 } 578 mutex_unlock(&port->ops_lock); 579 } 580 581 static int wwan_port_op_tx(struct wwan_port *port, struct sk_buff *skb, 582 bool nonblock) 583 { 584 int ret; 585 586 mutex_lock(&port->ops_lock); 587 if (!port->ops) { /* Port got unplugged */ 588 ret = -ENODEV; 589 goto out_unlock; 590 } 591 592 if (nonblock || !port->ops->tx_blocking) 593 ret = port->ops->tx(port, skb); 594 else 595 ret = port->ops->tx_blocking(port, skb); 596 597 out_unlock: 598 mutex_unlock(&port->ops_lock); 599 600 return ret; 601 } 602 603 static bool is_read_blocked(struct wwan_port *port) 604 { 605 return skb_queue_empty(&port->rxq) && port->ops; 606 } 607 608 static bool is_write_blocked(struct wwan_port *port) 609 { 610 return test_bit(WWAN_PORT_TX_OFF, &port->flags) && port->ops; 611 } 612 613 static int wwan_wait_rx(struct wwan_port *port, bool nonblock) 614 { 615 if (!is_read_blocked(port)) 616 return 0; 617 618 if (nonblock) 619 return -EAGAIN; 620 621 if (wait_event_interruptible(port->waitqueue, !is_read_blocked(port))) 622 return -ERESTARTSYS; 623 624 return 0; 625 } 626 627 static int wwan_wait_tx(struct wwan_port *port, bool nonblock) 628 { 629 if (!is_write_blocked(port)) 630 return 0; 631 632 if (nonblock) 633 return -EAGAIN; 634 635 if (wait_event_interruptible(port->waitqueue, !is_write_blocked(port))) 636 return -ERESTARTSYS; 637 638 return 0; 639 } 640 641 static int wwan_port_fops_open(struct inode *inode, struct file *file) 642 { 643 struct wwan_port *port; 644 int err = 0; 645 646 port = wwan_port_get_by_minor(iminor(inode)); 647 if (IS_ERR(port)) 648 return PTR_ERR(port); 649 650 file->private_data = port; 651 stream_open(inode, file); 652 653 err = wwan_port_op_start(port); 654 if (err) 655 put_device(&port->dev); 656 657 return err; 658 } 659 660 static int wwan_port_fops_release(struct inode *inode, struct file *filp) 661 { 662 struct wwan_port *port = filp->private_data; 663 664 wwan_port_op_stop(port); 665 put_device(&port->dev); 666 667 return 0; 668 } 669 670 static ssize_t wwan_port_fops_read(struct file *filp, char __user *buf, 671 size_t count, loff_t *ppos) 672 { 673 struct wwan_port *port = filp->private_data; 674 struct sk_buff *skb; 675 size_t copied; 676 int ret; 677 678 ret = wwan_wait_rx(port, !!(filp->f_flags & O_NONBLOCK)); 679 if (ret) 680 return ret; 681 682 skb = skb_dequeue(&port->rxq); 683 if (!skb) 684 return -EIO; 685 686 copied = min_t(size_t, count, skb->len); 687 if (copy_to_user(buf, skb->data, copied)) { 688 kfree_skb(skb); 689 return -EFAULT; 690 } 691 skb_pull(skb, copied); 692 693 /* skb is not fully consumed, keep it in the queue */ 694 if (skb->len) 695 skb_queue_head(&port->rxq, skb); 696 else 697 consume_skb(skb); 698 699 return copied; 700 } 701 702 static ssize_t wwan_port_fops_write(struct file *filp, const char __user *buf, 703 size_t count, loff_t *offp) 704 { 705 struct wwan_port *port = filp->private_data; 706 struct sk_buff *skb; 707 int ret; 708 709 ret = wwan_wait_tx(port, !!(filp->f_flags & O_NONBLOCK)); 710 if (ret) 711 return ret; 712 713 skb = alloc_skb(count, GFP_KERNEL); 714 if (!skb) 715 return -ENOMEM; 716 717 if (copy_from_user(skb_put(skb, count), buf, count)) { 718 kfree_skb(skb); 719 return -EFAULT; 720 } 721 722 ret = wwan_port_op_tx(port, skb, !!(filp->f_flags & O_NONBLOCK)); 723 if (ret) { 724 kfree_skb(skb); 725 return ret; 726 } 727 728 return count; 729 } 730 731 static __poll_t wwan_port_fops_poll(struct file *filp, poll_table *wait) 732 { 733 struct wwan_port *port = filp->private_data; 734 __poll_t mask = 0; 735 736 poll_wait(filp, &port->waitqueue, wait); 737 738 mutex_lock(&port->ops_lock); 739 if (port->ops && port->ops->tx_poll) 740 mask |= port->ops->tx_poll(port, filp, wait); 741 else if (!is_write_blocked(port)) 742 mask |= EPOLLOUT | EPOLLWRNORM; 743 if (!is_read_blocked(port)) 744 mask |= EPOLLIN | EPOLLRDNORM; 745 if (!port->ops) 746 mask |= EPOLLHUP | EPOLLERR; 747 mutex_unlock(&port->ops_lock); 748 749 return mask; 750 } 751 752 /* Implements minimalistic stub terminal IOCTLs support */ 753 static long wwan_port_fops_at_ioctl(struct wwan_port *port, unsigned int cmd, 754 unsigned long arg) 755 { 756 int ret = 0; 757 758 mutex_lock(&port->data_lock); 759 760 switch (cmd) { 761 case TCFLSH: 762 break; 763 764 case TCGETS: 765 if (copy_to_user((void __user *)arg, &port->at_data.termios, 766 sizeof(struct termios))) 767 ret = -EFAULT; 768 break; 769 770 case TCSETS: 771 case TCSETSW: 772 case TCSETSF: 773 if (copy_from_user(&port->at_data.termios, (void __user *)arg, 774 sizeof(struct termios))) 775 ret = -EFAULT; 776 break; 777 778 #ifdef TCGETS2 779 case TCGETS2: 780 if (copy_to_user((void __user *)arg, &port->at_data.termios, 781 sizeof(struct termios2))) 782 ret = -EFAULT; 783 break; 784 785 case TCSETS2: 786 case TCSETSW2: 787 case TCSETSF2: 788 if (copy_from_user(&port->at_data.termios, (void __user *)arg, 789 sizeof(struct termios2))) 790 ret = -EFAULT; 791 break; 792 #endif 793 794 case TIOCMGET: 795 ret = put_user(port->at_data.mdmbits, (int __user *)arg); 796 break; 797 798 case TIOCMSET: 799 case TIOCMBIC: 800 case TIOCMBIS: { 801 int mdmbits; 802 803 if (copy_from_user(&mdmbits, (int __user *)arg, sizeof(int))) { 804 ret = -EFAULT; 805 break; 806 } 807 if (cmd == TIOCMBIC) 808 port->at_data.mdmbits &= ~mdmbits; 809 else if (cmd == TIOCMBIS) 810 port->at_data.mdmbits |= mdmbits; 811 else 812 port->at_data.mdmbits = mdmbits; 813 break; 814 } 815 816 default: 817 ret = -ENOIOCTLCMD; 818 } 819 820 mutex_unlock(&port->data_lock); 821 822 return ret; 823 } 824 825 static long wwan_port_fops_ioctl(struct file *filp, unsigned int cmd, 826 unsigned long arg) 827 { 828 struct wwan_port *port = filp->private_data; 829 int res; 830 831 if (port->type == WWAN_PORT_AT) { /* AT port specific IOCTLs */ 832 res = wwan_port_fops_at_ioctl(port, cmd, arg); 833 if (res != -ENOIOCTLCMD) 834 return res; 835 } 836 837 switch (cmd) { 838 case TIOCINQ: { /* aka SIOCINQ aka FIONREAD */ 839 unsigned long flags; 840 struct sk_buff *skb; 841 int amount = 0; 842 843 spin_lock_irqsave(&port->rxq.lock, flags); 844 skb_queue_walk(&port->rxq, skb) 845 amount += skb->len; 846 spin_unlock_irqrestore(&port->rxq.lock, flags); 847 848 return put_user(amount, (int __user *)arg); 849 } 850 851 default: 852 return -ENOIOCTLCMD; 853 } 854 } 855 856 static const struct file_operations wwan_port_fops = { 857 .owner = THIS_MODULE, 858 .open = wwan_port_fops_open, 859 .release = wwan_port_fops_release, 860 .read = wwan_port_fops_read, 861 .write = wwan_port_fops_write, 862 .poll = wwan_port_fops_poll, 863 .unlocked_ioctl = wwan_port_fops_ioctl, 864 #ifdef CONFIG_COMPAT 865 .compat_ioctl = compat_ptr_ioctl, 866 #endif 867 .llseek = noop_llseek, 868 }; 869 870 static int wwan_rtnl_validate(struct nlattr *tb[], struct nlattr *data[], 871 struct netlink_ext_ack *extack) 872 { 873 if (!data) 874 return -EINVAL; 875 876 if (!tb[IFLA_PARENT_DEV_NAME]) 877 return -EINVAL; 878 879 if (!data[IFLA_WWAN_LINK_ID]) 880 return -EINVAL; 881 882 return 0; 883 } 884 885 static struct device_type wwan_type = { .name = "wwan" }; 886 887 static struct net_device *wwan_rtnl_alloc(struct nlattr *tb[], 888 const char *ifname, 889 unsigned char name_assign_type, 890 unsigned int num_tx_queues, 891 unsigned int num_rx_queues) 892 { 893 const char *devname = nla_data(tb[IFLA_PARENT_DEV_NAME]); 894 struct wwan_device *wwandev = wwan_dev_get_by_name(devname); 895 struct net_device *dev; 896 unsigned int priv_size; 897 898 if (IS_ERR(wwandev)) 899 return ERR_CAST(wwandev); 900 901 /* only supported if ops were registered (not just ports) */ 902 if (!wwandev->ops) { 903 dev = ERR_PTR(-EOPNOTSUPP); 904 goto out; 905 } 906 907 priv_size = sizeof(struct wwan_netdev_priv) + wwandev->ops->priv_size; 908 dev = alloc_netdev_mqs(priv_size, ifname, name_assign_type, 909 wwandev->ops->setup, num_tx_queues, num_rx_queues); 910 911 if (dev) { 912 SET_NETDEV_DEV(dev, &wwandev->dev); 913 SET_NETDEV_DEVTYPE(dev, &wwan_type); 914 } 915 916 out: 917 /* release the reference */ 918 put_device(&wwandev->dev); 919 return dev; 920 } 921 922 static int wwan_rtnl_newlink(struct net *src_net, struct net_device *dev, 923 struct nlattr *tb[], struct nlattr *data[], 924 struct netlink_ext_ack *extack) 925 { 926 struct wwan_device *wwandev = wwan_dev_get_by_parent(dev->dev.parent); 927 u32 link_id = nla_get_u32(data[IFLA_WWAN_LINK_ID]); 928 struct wwan_netdev_priv *priv = netdev_priv(dev); 929 int ret; 930 931 if (IS_ERR(wwandev)) 932 return PTR_ERR(wwandev); 933 934 /* shouldn't have a netdev (left) with us as parent so WARN */ 935 if (WARN_ON(!wwandev->ops)) { 936 ret = -EOPNOTSUPP; 937 goto out; 938 } 939 940 priv->link_id = link_id; 941 if (wwandev->ops->newlink) 942 ret = wwandev->ops->newlink(wwandev->ops_ctxt, dev, 943 link_id, extack); 944 else 945 ret = register_netdevice(dev); 946 947 out: 948 /* release the reference */ 949 put_device(&wwandev->dev); 950 return ret; 951 } 952 953 static void wwan_rtnl_dellink(struct net_device *dev, struct list_head *head) 954 { 955 struct wwan_device *wwandev = wwan_dev_get_by_parent(dev->dev.parent); 956 957 if (IS_ERR(wwandev)) 958 return; 959 960 /* shouldn't have a netdev (left) with us as parent so WARN */ 961 if (WARN_ON(!wwandev->ops)) 962 goto out; 963 964 if (wwandev->ops->dellink) 965 wwandev->ops->dellink(wwandev->ops_ctxt, dev, head); 966 else 967 unregister_netdevice_queue(dev, head); 968 969 out: 970 /* release the reference */ 971 put_device(&wwandev->dev); 972 } 973 974 static size_t wwan_rtnl_get_size(const struct net_device *dev) 975 { 976 return 977 nla_total_size(4) + /* IFLA_WWAN_LINK_ID */ 978 0; 979 } 980 981 static int wwan_rtnl_fill_info(struct sk_buff *skb, 982 const struct net_device *dev) 983 { 984 struct wwan_netdev_priv *priv = netdev_priv(dev); 985 986 if (nla_put_u32(skb, IFLA_WWAN_LINK_ID, priv->link_id)) 987 goto nla_put_failure; 988 989 return 0; 990 991 nla_put_failure: 992 return -EMSGSIZE; 993 } 994 995 static const struct nla_policy wwan_rtnl_policy[IFLA_WWAN_MAX + 1] = { 996 [IFLA_WWAN_LINK_ID] = { .type = NLA_U32 }, 997 }; 998 999 static struct rtnl_link_ops wwan_rtnl_link_ops __read_mostly = { 1000 .kind = "wwan", 1001 .maxtype = __IFLA_WWAN_MAX, 1002 .alloc = wwan_rtnl_alloc, 1003 .validate = wwan_rtnl_validate, 1004 .newlink = wwan_rtnl_newlink, 1005 .dellink = wwan_rtnl_dellink, 1006 .get_size = wwan_rtnl_get_size, 1007 .fill_info = wwan_rtnl_fill_info, 1008 .policy = wwan_rtnl_policy, 1009 }; 1010 1011 static void wwan_create_default_link(struct wwan_device *wwandev, 1012 u32 def_link_id) 1013 { 1014 struct nlattr *tb[IFLA_MAX + 1], *linkinfo[IFLA_INFO_MAX + 1]; 1015 struct nlattr *data[IFLA_WWAN_MAX + 1]; 1016 struct net_device *dev; 1017 struct nlmsghdr *nlh; 1018 struct sk_buff *msg; 1019 1020 /* Forge attributes required to create a WWAN netdev. We first 1021 * build a netlink message and then parse it. This looks 1022 * odd, but such approach is less error prone. 1023 */ 1024 msg = nlmsg_new(NLMSG_DEFAULT_SIZE, GFP_KERNEL); 1025 if (WARN_ON(!msg)) 1026 return; 1027 nlh = nlmsg_put(msg, 0, 0, RTM_NEWLINK, 0, 0); 1028 if (WARN_ON(!nlh)) 1029 goto free_attrs; 1030 1031 if (nla_put_string(msg, IFLA_PARENT_DEV_NAME, dev_name(&wwandev->dev))) 1032 goto free_attrs; 1033 tb[IFLA_LINKINFO] = nla_nest_start(msg, IFLA_LINKINFO); 1034 if (!tb[IFLA_LINKINFO]) 1035 goto free_attrs; 1036 linkinfo[IFLA_INFO_DATA] = nla_nest_start(msg, IFLA_INFO_DATA); 1037 if (!linkinfo[IFLA_INFO_DATA]) 1038 goto free_attrs; 1039 if (nla_put_u32(msg, IFLA_WWAN_LINK_ID, def_link_id)) 1040 goto free_attrs; 1041 nla_nest_end(msg, linkinfo[IFLA_INFO_DATA]); 1042 nla_nest_end(msg, tb[IFLA_LINKINFO]); 1043 1044 nlmsg_end(msg, nlh); 1045 1046 /* The next three parsing calls can not fail */ 1047 nlmsg_parse_deprecated(nlh, 0, tb, IFLA_MAX, NULL, NULL); 1048 nla_parse_nested_deprecated(linkinfo, IFLA_INFO_MAX, tb[IFLA_LINKINFO], 1049 NULL, NULL); 1050 nla_parse_nested_deprecated(data, IFLA_WWAN_MAX, 1051 linkinfo[IFLA_INFO_DATA], NULL, NULL); 1052 1053 rtnl_lock(); 1054 1055 dev = rtnl_create_link(&init_net, "wwan%d", NET_NAME_ENUM, 1056 &wwan_rtnl_link_ops, tb, NULL); 1057 if (WARN_ON(IS_ERR(dev))) 1058 goto unlock; 1059 1060 if (WARN_ON(wwan_rtnl_newlink(&init_net, dev, tb, data, NULL))) { 1061 free_netdev(dev); 1062 goto unlock; 1063 } 1064 1065 rtnl_configure_link(dev, NULL, 0, NULL); /* Link initialized, notify new link */ 1066 1067 unlock: 1068 rtnl_unlock(); 1069 1070 free_attrs: 1071 nlmsg_free(msg); 1072 } 1073 1074 /** 1075 * wwan_register_ops - register WWAN device ops 1076 * @parent: Device to use as parent and shared by all WWAN ports and 1077 * created netdevs 1078 * @ops: operations to register 1079 * @ctxt: context to pass to operations 1080 * @def_link_id: id of the default link that will be automatically created by 1081 * the WWAN core for the WWAN device. The default link will not be created 1082 * if the passed value is WWAN_NO_DEFAULT_LINK. 1083 * 1084 * Returns: 0 on success, a negative error code on failure 1085 */ 1086 int wwan_register_ops(struct device *parent, const struct wwan_ops *ops, 1087 void *ctxt, u32 def_link_id) 1088 { 1089 struct wwan_device *wwandev; 1090 1091 if (WARN_ON(!parent || !ops || !ops->setup)) 1092 return -EINVAL; 1093 1094 wwandev = wwan_create_dev(parent); 1095 if (IS_ERR(wwandev)) 1096 return PTR_ERR(wwandev); 1097 1098 if (WARN_ON(wwandev->ops)) { 1099 wwan_remove_dev(wwandev); 1100 return -EBUSY; 1101 } 1102 1103 wwandev->ops = ops; 1104 wwandev->ops_ctxt = ctxt; 1105 1106 /* NB: we do not abort ops registration in case of default link 1107 * creation failure. Link ops is the management interface, while the 1108 * default link creation is a service option. And we should not prevent 1109 * a user from manually creating a link latter if service option failed 1110 * now. 1111 */ 1112 if (def_link_id != WWAN_NO_DEFAULT_LINK) 1113 wwan_create_default_link(wwandev, def_link_id); 1114 1115 return 0; 1116 } 1117 EXPORT_SYMBOL_GPL(wwan_register_ops); 1118 1119 /* Enqueue child netdev deletion */ 1120 static int wwan_child_dellink(struct device *dev, void *data) 1121 { 1122 struct list_head *kill_list = data; 1123 1124 if (dev->type == &wwan_type) 1125 wwan_rtnl_dellink(to_net_dev(dev), kill_list); 1126 1127 return 0; 1128 } 1129 1130 /** 1131 * wwan_unregister_ops - remove WWAN device ops 1132 * @parent: Device to use as parent and shared by all WWAN ports and 1133 * created netdevs 1134 */ 1135 void wwan_unregister_ops(struct device *parent) 1136 { 1137 struct wwan_device *wwandev = wwan_dev_get_by_parent(parent); 1138 LIST_HEAD(kill_list); 1139 1140 if (WARN_ON(IS_ERR(wwandev))) 1141 return; 1142 if (WARN_ON(!wwandev->ops)) { 1143 put_device(&wwandev->dev); 1144 return; 1145 } 1146 1147 /* put the reference obtained by wwan_dev_get_by_parent(), 1148 * we should still have one (that the owner is giving back 1149 * now) due to the ops being assigned. 1150 */ 1151 put_device(&wwandev->dev); 1152 1153 rtnl_lock(); /* Prevent concurent netdev(s) creation/destroying */ 1154 1155 /* Remove all child netdev(s), using batch removing */ 1156 device_for_each_child(&wwandev->dev, &kill_list, 1157 wwan_child_dellink); 1158 unregister_netdevice_many(&kill_list); 1159 1160 wwandev->ops = NULL; /* Finally remove ops */ 1161 1162 rtnl_unlock(); 1163 1164 wwandev->ops_ctxt = NULL; 1165 wwan_remove_dev(wwandev); 1166 } 1167 EXPORT_SYMBOL_GPL(wwan_unregister_ops); 1168 1169 static int __init wwan_init(void) 1170 { 1171 int err; 1172 1173 err = rtnl_link_register(&wwan_rtnl_link_ops); 1174 if (err) 1175 return err; 1176 1177 wwan_class = class_create(THIS_MODULE, "wwan"); 1178 if (IS_ERR(wwan_class)) { 1179 err = PTR_ERR(wwan_class); 1180 goto unregister; 1181 } 1182 1183 /* chrdev used for wwan ports */ 1184 wwan_major = __register_chrdev(0, 0, WWAN_MAX_MINORS, "wwan_port", 1185 &wwan_port_fops); 1186 if (wwan_major < 0) { 1187 err = wwan_major; 1188 goto destroy; 1189 } 1190 1191 #ifdef CONFIG_WWAN_DEBUGFS 1192 wwan_debugfs_dir = debugfs_create_dir("wwan", NULL); 1193 #endif 1194 1195 return 0; 1196 1197 destroy: 1198 class_destroy(wwan_class); 1199 unregister: 1200 rtnl_link_unregister(&wwan_rtnl_link_ops); 1201 return err; 1202 } 1203 1204 static void __exit wwan_exit(void) 1205 { 1206 debugfs_remove_recursive(wwan_debugfs_dir); 1207 __unregister_chrdev(wwan_major, 0, WWAN_MAX_MINORS, "wwan_port"); 1208 rtnl_link_unregister(&wwan_rtnl_link_ops); 1209 class_destroy(wwan_class); 1210 } 1211 1212 module_init(wwan_init); 1213 module_exit(wwan_exit); 1214 1215 MODULE_AUTHOR("Loic Poulain <loic.poulain@linaro.org>"); 1216 MODULE_DESCRIPTION("WWAN core"); 1217 MODULE_LICENSE("GPL v2"); 1218