xref: /linux/drivers/net/wwan/wwan_core.c (revision f7f52738637f4361c108cad36e23ee98959a9006)
1 // SPDX-License-Identifier: GPL-2.0-only
2 /* Copyright (c) 2021, Linaro Ltd <loic.poulain@linaro.org> */
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 <loic.poulain@linaro.org>");
1262 MODULE_DESCRIPTION("WWAN core");
1263 MODULE_LICENSE("GPL v2");
1264