drivers/net/wwan/wwan_core.c

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