xref: /openbmc/linux/drivers/net/wwan/wwan_hwsim.c (revision fa0dadde) 
1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * WWAN device simulator for WWAN framework testing.
4  *
5  * Copyright (c) 2021, Sergey Ryazanov <ryazanov.s.a@gmail.com>
6  */
7 
8 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
9 
10 #include <linux/kernel.h>
11 #include <linux/module.h>
12 #include <linux/slab.h>
13 #include <linux/device.h>
14 #include <linux/spinlock.h>
15 #include <linux/list.h>
16 #include <linux/skbuff.h>
17 #include <linux/netdevice.h>
18 #include <linux/wwan.h>
19 #include <linux/debugfs.h>
20 #include <linux/workqueue.h>
21 
22 #include <net/arp.h>
23 
24 static int wwan_hwsim_devsnum = 2;
25 module_param_named(devices, wwan_hwsim_devsnum, int, 0444);
26 MODULE_PARM_DESC(devices, "Number of simulated devices");
27 
28 static struct class *wwan_hwsim_class;
29 
30 static struct dentry *wwan_hwsim_debugfs_topdir;
31 static struct dentry *wwan_hwsim_debugfs_devcreate;
32 
33 static DEFINE_SPINLOCK(wwan_hwsim_devs_lock);
34 static LIST_HEAD(wwan_hwsim_devs);
35 static unsigned int wwan_hwsim_dev_idx;
36 static struct workqueue_struct *wwan_wq;
37 
38 struct wwan_hwsim_dev {
39 	struct list_head list;
40 	unsigned int id;
41 	struct device dev;
42 	struct work_struct del_work;
43 	struct dentry *debugfs_topdir;
44 	struct dentry *debugfs_portcreate;
45 	spinlock_t ports_lock;	/* Serialize ports creation/deletion */
46 	unsigned int port_idx;
47 	struct list_head ports;
48 };
49 
50 struct wwan_hwsim_port {
51 	struct list_head list;
52 	unsigned int id;
53 	struct wwan_hwsim_dev *dev;
54 	struct wwan_port *wwan;
55 	struct work_struct del_work;
56 	struct dentry *debugfs_topdir;
57 	enum {			/* AT command parser state */
58 		AT_PARSER_WAIT_A,
59 		AT_PARSER_WAIT_T,
60 		AT_PARSER_WAIT_TERM,
61 		AT_PARSER_SKIP_LINE,
62 	} pstate;
63 };
64 
65 static const struct file_operations wwan_hwsim_debugfs_portdestroy_fops;
66 static const struct file_operations wwan_hwsim_debugfs_portcreate_fops;
67 static const struct file_operations wwan_hwsim_debugfs_devdestroy_fops;
68 static void wwan_hwsim_port_del_work(struct work_struct *work);
69 static void wwan_hwsim_dev_del_work(struct work_struct *work);
70 
71 static netdev_tx_t wwan_hwsim_netdev_xmit(struct sk_buff *skb,
72 					  struct net_device *ndev)
73 {
74 	ndev->stats.tx_packets++;
75 	ndev->stats.tx_bytes += skb->len;
76 	consume_skb(skb);
77 	return NETDEV_TX_OK;
78 }
79 
80 static const struct net_device_ops wwan_hwsim_netdev_ops = {
81 	.ndo_start_xmit = wwan_hwsim_netdev_xmit,
82 };
83 
84 static void wwan_hwsim_netdev_setup(struct net_device *ndev)
85 {
86 	ndev->netdev_ops = &wwan_hwsim_netdev_ops;
87 	ndev->needs_free_netdev = true;
88 
89 	ndev->mtu = ETH_DATA_LEN;
90 	ndev->min_mtu = ETH_MIN_MTU;
91 	ndev->max_mtu = ETH_MAX_MTU;
92 
93 	ndev->type = ARPHRD_NONE;
94 	ndev->flags = IFF_POINTOPOINT | IFF_NOARP;
95 }
96 
97 static const struct wwan_ops wwan_hwsim_wwan_rtnl_ops = {
98 	.priv_size = 0,			/* No private data */
99 	.setup = wwan_hwsim_netdev_setup,
100 };
101 
102 static int wwan_hwsim_port_start(struct wwan_port *wport)
103 {
104 	struct wwan_hwsim_port *port = wwan_port_get_drvdata(wport);
105 
106 	port->pstate = AT_PARSER_WAIT_A;
107 
108 	return 0;
109 }
110 
111 static void wwan_hwsim_port_stop(struct wwan_port *wport)
112 {
113 }
114 
115 /* Implements a minimalistic AT commands parser that echo input back and
116  * reply with 'OK' to each input command. See AT command protocol details in the
117  * ITU-T V.250 recomendations document.
118  *
119  * Be aware that this processor is not fully V.250 compliant.
120  */
121 static int wwan_hwsim_port_tx(struct wwan_port *wport, struct sk_buff *in)
122 {
123 	struct wwan_hwsim_port *port = wwan_port_get_drvdata(wport);
124 	struct sk_buff *out;
125 	int i, n, s;
126 
127 	/* Estimate a max possible number of commands by counting the number of
128 	 * termination chars (S3 param, CR by default). And then allocate the
129 	 * output buffer that will be enough to fit the echo and result codes of
130 	 * all commands.
131 	 */
132 	for (i = 0, n = 0; i < in->len; ++i)
133 		if (in->data[i] == '\r')
134 			n++;
135 	n = in->len + n * (2 + 2 + 2);	/* Output buffer size */
136 	out = alloc_skb(n, GFP_KERNEL);
137 	if (!out)
138 		return -ENOMEM;
139 
140 	for (i = 0, s = 0; i < in->len; ++i) {
141 		char c = in->data[i];
142 
143 		if (port->pstate == AT_PARSER_WAIT_A) {
144 			if (c == 'A' || c == 'a')
145 				port->pstate = AT_PARSER_WAIT_T;
146 			else if (c != '\n')	/* Ignore formating char */
147 				port->pstate = AT_PARSER_SKIP_LINE;
148 		} else if (port->pstate == AT_PARSER_WAIT_T) {
149 			if (c == 'T' || c == 't')
150 				port->pstate = AT_PARSER_WAIT_TERM;
151 			else
152 				port->pstate = AT_PARSER_SKIP_LINE;
153 		} else if (port->pstate == AT_PARSER_WAIT_TERM) {
154 			if (c != '\r')
155 				continue;
156 			/* Consume the trailing formatting char as well */
157 			if ((i + 1) < in->len && in->data[i + 1] == '\n')
158 				i++;
159 			n = i - s + 1;
160 			skb_put_data(out, &in->data[s], n);/* Echo */
161 			skb_put_data(out, "\r\nOK\r\n", 6);
162 			s = i + 1;
163 			port->pstate = AT_PARSER_WAIT_A;
164 		} else if (port->pstate == AT_PARSER_SKIP_LINE) {
165 			if (c != '\r')
166 				continue;
167 			port->pstate = AT_PARSER_WAIT_A;
168 		}
169 	}
170 
171 	if (i > s) {
172 		/* Echo the processed portion of a not yet completed command */
173 		n = i - s;
174 		skb_put_data(out, &in->data[s], n);
175 	}
176 
177 	consume_skb(in);
178 
179 	wwan_port_rx(wport, out);
180 
181 	return 0;
182 }
183 
184 static const struct wwan_port_ops wwan_hwsim_port_ops = {
185 	.start = wwan_hwsim_port_start,
186 	.stop = wwan_hwsim_port_stop,
187 	.tx = wwan_hwsim_port_tx,
188 };
189 
190 static struct wwan_hwsim_port *wwan_hwsim_port_new(struct wwan_hwsim_dev *dev)
191 {
192 	struct wwan_hwsim_port *port;
193 	char name[0x10];
194 	int err;
195 
196 	port = kzalloc(sizeof(*port), GFP_KERNEL);
197 	if (!port)
198 		return ERR_PTR(-ENOMEM);
199 
200 	port->dev = dev;
201 
202 	spin_lock(&dev->ports_lock);
203 	port->id = dev->port_idx++;
204 	spin_unlock(&dev->ports_lock);
205 
206 	port->wwan = wwan_create_port(&dev->dev, WWAN_PORT_AT,
207 				      &wwan_hwsim_port_ops,
208 				      NULL, port);
209 	if (IS_ERR(port->wwan)) {
210 		err = PTR_ERR(port->wwan);
211 		goto err_free_port;
212 	}
213 
214 	INIT_WORK(&port->del_work, wwan_hwsim_port_del_work);
215 
216 	snprintf(name, sizeof(name), "port%u", port->id);
217 	port->debugfs_topdir = debugfs_create_dir(name, dev->debugfs_topdir);
218 	debugfs_create_file("destroy", 0200, port->debugfs_topdir, port,
219 			    &wwan_hwsim_debugfs_portdestroy_fops);
220 
221 	return port;
222 
223 err_free_port:
224 	kfree(port);
225 
226 	return ERR_PTR(err);
227 }
228 
229 static void wwan_hwsim_port_del(struct wwan_hwsim_port *port)
230 {
231 	debugfs_remove(port->debugfs_topdir);
232 
233 	/* Make sure that there is no pending deletion work */
234 	if (current_work() != &port->del_work)
235 		cancel_work_sync(&port->del_work);
236 
237 	wwan_remove_port(port->wwan);
238 	kfree(port);
239 }
240 
241 static void wwan_hwsim_port_del_work(struct work_struct *work)
242 {
243 	struct wwan_hwsim_port *port =
244 				container_of(work, typeof(*port), del_work);
245 	struct wwan_hwsim_dev *dev = port->dev;
246 
247 	spin_lock(&dev->ports_lock);
248 	if (list_empty(&port->list)) {
249 		/* Someone else deleting port at the moment */
250 		spin_unlock(&dev->ports_lock);
251 		return;
252 	}
253 	list_del_init(&port->list);
254 	spin_unlock(&dev->ports_lock);
255 
256 	wwan_hwsim_port_del(port);
257 }
258 
259 static void wwan_hwsim_dev_release(struct device *sysdev)
260 {
261 	struct wwan_hwsim_dev *dev = container_of(sysdev, typeof(*dev), dev);
262 
263 	kfree(dev);
264 }
265 
266 static struct wwan_hwsim_dev *wwan_hwsim_dev_new(void)
267 {
268 	struct wwan_hwsim_dev *dev;
269 	int err;
270 
271 	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
272 	if (!dev)
273 		return ERR_PTR(-ENOMEM);
274 
275 	spin_lock(&wwan_hwsim_devs_lock);
276 	dev->id = wwan_hwsim_dev_idx++;
277 	spin_unlock(&wwan_hwsim_devs_lock);
278 
279 	dev->dev.release = wwan_hwsim_dev_release;
280 	dev->dev.class = wwan_hwsim_class;
281 	dev_set_name(&dev->dev, "hwsim%u", dev->id);
282 
283 	spin_lock_init(&dev->ports_lock);
284 	INIT_LIST_HEAD(&dev->ports);
285 
286 	err = device_register(&dev->dev);
287 	if (err)
288 		goto err_free_dev;
289 
290 	INIT_WORK(&dev->del_work, wwan_hwsim_dev_del_work);
291 
292 	err = wwan_register_ops(&dev->dev, &wwan_hwsim_wwan_rtnl_ops, dev, 1);
293 	if (err)
294 		goto err_unreg_dev;
295 
296 	dev->debugfs_topdir = debugfs_create_dir(dev_name(&dev->dev),
297 						 wwan_hwsim_debugfs_topdir);
298 	debugfs_create_file("destroy", 0200, dev->debugfs_topdir, dev,
299 			    &wwan_hwsim_debugfs_devdestroy_fops);
300 	dev->debugfs_portcreate =
301 		debugfs_create_file("portcreate", 0200,
302 				    dev->debugfs_topdir, dev,
303 				    &wwan_hwsim_debugfs_portcreate_fops);
304 
305 	return dev;
306 
307 err_unreg_dev:
308 	device_unregister(&dev->dev);
309 	/* Memory will be freed in the device release callback */
310 
311 	return ERR_PTR(err);
312 
313 err_free_dev:
314 	put_device(&dev->dev);
315 
316 	return ERR_PTR(err);
317 }
318 
319 static void wwan_hwsim_dev_del(struct wwan_hwsim_dev *dev)
320 {
321 	debugfs_remove(dev->debugfs_portcreate);	/* Avoid new ports */
322 
323 	spin_lock(&dev->ports_lock);
324 	while (!list_empty(&dev->ports)) {
325 		struct wwan_hwsim_port *port;
326 
327 		port = list_first_entry(&dev->ports, struct wwan_hwsim_port,
328 					list);
329 		list_del_init(&port->list);
330 		spin_unlock(&dev->ports_lock);
331 		wwan_hwsim_port_del(port);
332 		spin_lock(&dev->ports_lock);
333 	}
334 	spin_unlock(&dev->ports_lock);
335 
336 	debugfs_remove(dev->debugfs_topdir);
337 
338 	/* This will remove all child netdev(s) */
339 	wwan_unregister_ops(&dev->dev);
340 
341 	/* Make sure that there is no pending deletion work */
342 	if (current_work() != &dev->del_work)
343 		cancel_work_sync(&dev->del_work);
344 
345 	device_unregister(&dev->dev);
346 	/* Memory will be freed in the device release callback */
347 }
348 
349 static void wwan_hwsim_dev_del_work(struct work_struct *work)
350 {
351 	struct wwan_hwsim_dev *dev = container_of(work, typeof(*dev), del_work);
352 
353 	spin_lock(&wwan_hwsim_devs_lock);
354 	if (list_empty(&dev->list)) {
355 		/* Someone else deleting device at the moment */
356 		spin_unlock(&wwan_hwsim_devs_lock);
357 		return;
358 	}
359 	list_del_init(&dev->list);
360 	spin_unlock(&wwan_hwsim_devs_lock);
361 
362 	wwan_hwsim_dev_del(dev);
363 }
364 
365 static ssize_t wwan_hwsim_debugfs_portdestroy_write(struct file *file,
366 						    const char __user *usrbuf,
367 						    size_t count, loff_t *ppos)
368 {
369 	struct wwan_hwsim_port *port = file->private_data;
370 
371 	/* We can not delete port here since it will cause a deadlock due to
372 	 * waiting this callback to finish in the debugfs_remove() call. So,
373 	 * use workqueue.
374 	 */
375 	queue_work(wwan_wq, &port->del_work);
376 
377 	return count;
378 }
379 
380 static const struct file_operations wwan_hwsim_debugfs_portdestroy_fops = {
381 	.write = wwan_hwsim_debugfs_portdestroy_write,
382 	.open = simple_open,
383 	.llseek = noop_llseek,
384 };
385 
386 static ssize_t wwan_hwsim_debugfs_portcreate_write(struct file *file,
387 						   const char __user *usrbuf,
388 						   size_t count, loff_t *ppos)
389 {
390 	struct wwan_hwsim_dev *dev = file->private_data;
391 	struct wwan_hwsim_port *port;
392 
393 	port = wwan_hwsim_port_new(dev);
394 	if (IS_ERR(port))
395 		return PTR_ERR(port);
396 
397 	spin_lock(&dev->ports_lock);
398 	list_add_tail(&port->list, &dev->ports);
399 	spin_unlock(&dev->ports_lock);
400 
401 	return count;
402 }
403 
404 static const struct file_operations wwan_hwsim_debugfs_portcreate_fops = {
405 	.write = wwan_hwsim_debugfs_portcreate_write,
406 	.open = simple_open,
407 	.llseek = noop_llseek,
408 };
409 
410 static ssize_t wwan_hwsim_debugfs_devdestroy_write(struct file *file,
411 						   const char __user *usrbuf,
412 						   size_t count, loff_t *ppos)
413 {
414 	struct wwan_hwsim_dev *dev = file->private_data;
415 
416 	/* We can not delete device here since it will cause a deadlock due to
417 	 * waiting this callback to finish in the debugfs_remove() call. So,
418 	 * use workqueue.
419 	 */
420 	queue_work(wwan_wq, &dev->del_work);
421 
422 	return count;
423 }
424 
425 static const struct file_operations wwan_hwsim_debugfs_devdestroy_fops = {
426 	.write = wwan_hwsim_debugfs_devdestroy_write,
427 	.open = simple_open,
428 	.llseek = noop_llseek,
429 };
430 
431 static ssize_t wwan_hwsim_debugfs_devcreate_write(struct file *file,
432 						  const char __user *usrbuf,
433 						  size_t count, loff_t *ppos)
434 {
435 	struct wwan_hwsim_dev *dev;
436 
437 	dev = wwan_hwsim_dev_new();
438 	if (IS_ERR(dev))
439 		return PTR_ERR(dev);
440 
441 	spin_lock(&wwan_hwsim_devs_lock);
442 	list_add_tail(&dev->list, &wwan_hwsim_devs);
443 	spin_unlock(&wwan_hwsim_devs_lock);
444 
445 	return count;
446 }
447 
448 static const struct file_operations wwan_hwsim_debugfs_devcreate_fops = {
449 	.write = wwan_hwsim_debugfs_devcreate_write,
450 	.open = simple_open,
451 	.llseek = noop_llseek,
452 };
453 
454 static int __init wwan_hwsim_init_devs(void)
455 {
456 	struct wwan_hwsim_dev *dev;
457 	int i, j;
458 
459 	for (i = 0; i < wwan_hwsim_devsnum; ++i) {
460 		dev = wwan_hwsim_dev_new();
461 		if (IS_ERR(dev))
462 			return PTR_ERR(dev);
463 
464 		spin_lock(&wwan_hwsim_devs_lock);
465 		list_add_tail(&dev->list, &wwan_hwsim_devs);
466 		spin_unlock(&wwan_hwsim_devs_lock);
467 
468 		/* Create a couple of ports per each device to accelerate
469 		 * the simulator readiness time.
470 		 */
471 		for (j = 0; j < 2; ++j) {
472 			struct wwan_hwsim_port *port;
473 
474 			port = wwan_hwsim_port_new(dev);
475 			if (IS_ERR(port))
476 				return PTR_ERR(port);
477 
478 			spin_lock(&dev->ports_lock);
479 			list_add_tail(&port->list, &dev->ports);
480 			spin_unlock(&dev->ports_lock);
481 		}
482 	}
483 
484 	return 0;
485 }
486 
487 static void wwan_hwsim_free_devs(void)
488 {
489 	struct wwan_hwsim_dev *dev;
490 
491 	spin_lock(&wwan_hwsim_devs_lock);
492 	while (!list_empty(&wwan_hwsim_devs)) {
493 		dev = list_first_entry(&wwan_hwsim_devs, struct wwan_hwsim_dev,
494 				       list);
495 		list_del_init(&dev->list);
496 		spin_unlock(&wwan_hwsim_devs_lock);
497 		wwan_hwsim_dev_del(dev);
498 		spin_lock(&wwan_hwsim_devs_lock);
499 	}
500 	spin_unlock(&wwan_hwsim_devs_lock);
501 }
502 
503 static int __init wwan_hwsim_init(void)
504 {
505 	int err;
506 
507 	if (wwan_hwsim_devsnum < 0 || wwan_hwsim_devsnum > 128)
508 		return -EINVAL;
509 
510 	wwan_wq = alloc_workqueue("wwan_wq", 0, 0);
511 	if (!wwan_wq)
512 		return -ENOMEM;
513 
514 	wwan_hwsim_class = class_create("wwan_hwsim");
515 	if (IS_ERR(wwan_hwsim_class)) {
516 		err = PTR_ERR(wwan_hwsim_class);
517 		goto err_wq_destroy;
518 	}
519 
520 	wwan_hwsim_debugfs_topdir = debugfs_create_dir("wwan_hwsim", NULL);
521 	wwan_hwsim_debugfs_devcreate =
522 			debugfs_create_file("devcreate", 0200,
523 					    wwan_hwsim_debugfs_topdir, NULL,
524 					    &wwan_hwsim_debugfs_devcreate_fops);
525 
526 	err = wwan_hwsim_init_devs();
527 	if (err)
528 		goto err_clean_devs;
529 
530 	return 0;
531 
532 err_clean_devs:
533 	debugfs_remove(wwan_hwsim_debugfs_devcreate);	/* Avoid new devs */
534 	wwan_hwsim_free_devs();
535 	flush_workqueue(wwan_wq);	/* Wait deletion works completion */
536 	debugfs_remove(wwan_hwsim_debugfs_topdir);
537 	class_destroy(wwan_hwsim_class);
538 err_wq_destroy:
539 	destroy_workqueue(wwan_wq);
540 
541 	return err;
542 }
543 
544 static void __exit wwan_hwsim_exit(void)
545 {
546 	debugfs_remove(wwan_hwsim_debugfs_devcreate);	/* Avoid new devs */
547 	wwan_hwsim_free_devs();
548 	flush_workqueue(wwan_wq);	/* Wait deletion works completion */
549 	debugfs_remove(wwan_hwsim_debugfs_topdir);
550 	class_destroy(wwan_hwsim_class);
551 	destroy_workqueue(wwan_wq);
552 }
553 
554 module_init(wwan_hwsim_init);
555 module_exit(wwan_hwsim_exit);
556 
557 MODULE_AUTHOR("Sergey Ryazanov");
558 MODULE_DESCRIPTION("Device simulator for WWAN framework");
559 MODULE_LICENSE("GPL");
560