xref: /openbmc/linux/drivers/net/wwan/wwan_core.c (revision 2243acd5)
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("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