1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * u_ether.c -- Ethernet-over-USB link layer utilities for Gadget stack
4 *
5 * Copyright (C) 2003-2005,2008 David Brownell
6 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
7 * Copyright (C) 2008 Nokia Corporation
8 */
9
10/* #define VERBOSE_DEBUG */
11
12#include <linux/kernel.h>
13#include <linux/module.h>
14#include <linux/gfp.h>
15#include <linux/device.h>
16#include <linux/ctype.h>
17#include <linux/etherdevice.h>
18#include <linux/ethtool.h>
19#include <linux/if_vlan.h>
20#include <linux/string_helpers.h>
21
22#include "u_ether.h"
23
24
25/*
26 * This component encapsulates the Ethernet link glue needed to provide
27 * one (!) network link through the USB gadget stack, normally "usb0".
28 *
29 * The control and data models are handled by the function driver which
30 * connects to this code; such as CDC Ethernet (ECM or EEM),
31 * "CDC Subset", or RNDIS.  That includes all descriptor and endpoint
32 * management.
33 *
34 * Link level addressing is handled by this component using module
35 * parameters; if no such parameters are provided, random link level
36 * addresses are used.  Each end of the link uses one address.  The
37 * host end address is exported in various ways, and is often recorded
38 * in configuration databases.
39 *
40 * The driver which assembles each configuration using such a link is
41 * responsible for ensuring that each configuration includes at most one
42 * instance of is network link.  (The network layer provides ways for
43 * this single "physical" link to be used by multiple virtual links.)
44 */
45
46#define UETH__VERSION	"29-May-2008"
47
48/* Experiments show that both Linux and Windows hosts allow up to 16k
49 * frame sizes. Set the max MTU size to 15k+52 to prevent allocating 32k
50 * blocks and still have efficient handling. */
51#define GETHER_MAX_MTU_SIZE 15412
52#define GETHER_MAX_ETH_FRAME_LEN (GETHER_MAX_MTU_SIZE + ETH_HLEN)
53
54struct eth_dev {
55	/* lock is held while accessing port_usb
56	 */
57	spinlock_t		lock;
58	struct gether		*port_usb;
59
60	struct net_device	*net;
61	struct usb_gadget	*gadget;
62
63	spinlock_t		req_lock;	/* guard {rx,tx}_reqs */
64	struct list_head	tx_reqs, rx_reqs;
65	atomic_t		tx_qlen;
66
67	struct sk_buff_head	rx_frames;
68
69	unsigned		qmult;
70
71	unsigned		header_len;
72	struct sk_buff		*(*wrap)(struct gether *, struct sk_buff *skb);
73	int			(*unwrap)(struct gether *,
74						struct sk_buff *skb,
75						struct sk_buff_head *list);
76
77	struct work_struct	work;
78
79	unsigned long		todo;
80#define	WORK_RX_MEMORY		0
81
82	bool			zlp;
83	bool			no_skb_reserve;
84	u8			host_mac[ETH_ALEN];
85	u8			dev_mac[ETH_ALEN];
86};
87
88/*-------------------------------------------------------------------------*/
89
90#define RX_EXTRA	20	/* bytes guarding against rx overflows */
91
92#define DEFAULT_QLEN	2	/* double buffering by default */
93
94/* for dual-speed hardware, use deeper queues at high/super speed */
95static inline int qlen(struct usb_gadget *gadget, unsigned qmult)
96{
97	if (gadget_is_dualspeed(gadget) && (gadget->speed == USB_SPEED_HIGH ||
98					    gadget->speed >= USB_SPEED_SUPER))
99		return qmult * DEFAULT_QLEN;
100	else
101		return DEFAULT_QLEN;
102}
103
104/*-------------------------------------------------------------------------*/
105
106/* REVISIT there must be a better way than having two sets
107 * of debug calls ...
108 */
109
110#undef DBG
111#undef VDBG
112#undef ERROR
113#undef INFO
114
115#define xprintk(d, level, fmt, args...) \
116	printk(level "%s: " fmt , (d)->net->name , ## args)
117
118#ifdef DEBUG
119#undef DEBUG
120#define DBG(dev, fmt, args...) \
121	xprintk(dev , KERN_DEBUG , fmt , ## args)
122#else
123#define DBG(dev, fmt, args...) \
124	do { } while (0)
125#endif /* DEBUG */
126
127#ifdef VERBOSE_DEBUG
128#define VDBG	DBG
129#else
130#define VDBG(dev, fmt, args...) \
131	do { } while (0)
132#endif /* DEBUG */
133
134#define ERROR(dev, fmt, args...) \
135	xprintk(dev , KERN_ERR , fmt , ## args)
136#define INFO(dev, fmt, args...) \
137	xprintk(dev , KERN_INFO , fmt , ## args)
138
139/*-------------------------------------------------------------------------*/
140
141/* NETWORK DRIVER HOOKUP (to the layer above this driver) */
142
143static void eth_get_drvinfo(struct net_device *net, struct ethtool_drvinfo *p)
144{
145	struct eth_dev *dev = netdev_priv(net);
146
147	strlcpy(p->driver, "g_ether", sizeof(p->driver));
148	strlcpy(p->version, UETH__VERSION, sizeof(p->version));
149	strlcpy(p->fw_version, dev->gadget->name, sizeof(p->fw_version));
150	strlcpy(p->bus_info, dev_name(&dev->gadget->dev), sizeof(p->bus_info));
151}
152
153/* REVISIT can also support:
154 *   - WOL (by tracking suspends and issuing remote wakeup)
155 *   - msglevel (implies updated messaging)
156 *   - ... probably more ethtool ops
157 */
158
159static const struct ethtool_ops ops = {
160	.get_drvinfo = eth_get_drvinfo,
161	.get_link = ethtool_op_get_link,
162};
163
164static void defer_kevent(struct eth_dev *dev, int flag)
165{
166	if (test_and_set_bit(flag, &dev->todo))
167		return;
168	if (!schedule_work(&dev->work))
169		ERROR(dev, "kevent %d may have been dropped\n", flag);
170	else
171		DBG(dev, "kevent %d scheduled\n", flag);
172}
173
174static void rx_complete(struct usb_ep *ep, struct usb_request *req);
175
176static int
177rx_submit(struct eth_dev *dev, struct usb_request *req, gfp_t gfp_flags)
178{
179	struct usb_gadget *g = dev->gadget;
180	struct sk_buff	*skb;
181	int		retval = -ENOMEM;
182	size_t		size = 0;
183	struct usb_ep	*out;
184	unsigned long	flags;
185
186	spin_lock_irqsave(&dev->lock, flags);
187	if (dev->port_usb)
188		out = dev->port_usb->out_ep;
189	else
190		out = NULL;
191
192	if (!out)
193	{
194		spin_unlock_irqrestore(&dev->lock, flags);
195		return -ENOTCONN;
196	}
197
198	/* Padding up to RX_EXTRA handles minor disagreements with host.
199	 * Normally we use the USB "terminate on short read" convention;
200	 * so allow up to (N*maxpacket), since that memory is normally
201	 * already allocated.  Some hardware doesn't deal well with short
202	 * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
203	 * byte off the end (to force hardware errors on overflow).
204	 *
205	 * RNDIS uses internal framing, and explicitly allows senders to
206	 * pad to end-of-packet.  That's potentially nice for speed, but
207	 * means receivers can't recover lost synch on their own (because
208	 * new packets don't only start after a short RX).
209	 */
210	size += sizeof(struct ethhdr) + dev->net->mtu + RX_EXTRA;
211	size += dev->port_usb->header_len;
212
213	if (g->quirk_ep_out_aligned_size) {
214		size += out->maxpacket - 1;
215		size -= size % out->maxpacket;
216	}
217
218	if (dev->port_usb->is_fixed)
219		size = max_t(size_t, size, dev->port_usb->fixed_out_len);
220	spin_unlock_irqrestore(&dev->lock, flags);
221
222	skb = __netdev_alloc_skb(dev->net, size + NET_IP_ALIGN, gfp_flags);
223	if (skb == NULL) {
224		DBG(dev, "no rx skb\n");
225		goto enomem;
226	}
227
228	/* Some platforms perform better when IP packets are aligned,
229	 * but on at least one, checksumming fails otherwise.  Note:
230	 * RNDIS headers involve variable numbers of LE32 values.
231	 */
232	if (likely(!dev->no_skb_reserve))
233		skb_reserve(skb, NET_IP_ALIGN);
234
235	req->buf = skb->data;
236	req->length = size;
237	req->complete = rx_complete;
238	req->context = skb;
239
240	retval = usb_ep_queue(out, req, gfp_flags);
241	if (retval == -ENOMEM)
242enomem:
243		defer_kevent(dev, WORK_RX_MEMORY);
244	if (retval) {
245		DBG(dev, "rx submit --> %d\n", retval);
246		if (skb)
247			dev_kfree_skb_any(skb);
248		spin_lock_irqsave(&dev->req_lock, flags);
249		list_add(&req->list, &dev->rx_reqs);
250		spin_unlock_irqrestore(&dev->req_lock, flags);
251	}
252	return retval;
253}
254
255static void rx_complete(struct usb_ep *ep, struct usb_request *req)
256{
257	struct sk_buff	*skb = req->context, *skb2;
258	struct eth_dev	*dev = ep->driver_data;
259	int		status = req->status;
260
261	switch (status) {
262
263	/* normal completion */
264	case 0:
265		skb_put(skb, req->actual);
266
267		if (dev->unwrap) {
268			unsigned long	flags;
269
270			spin_lock_irqsave(&dev->lock, flags);
271			if (dev->port_usb) {
272				status = dev->unwrap(dev->port_usb,
273							skb,
274							&dev->rx_frames);
275			} else {
276				dev_kfree_skb_any(skb);
277				status = -ENOTCONN;
278			}
279			spin_unlock_irqrestore(&dev->lock, flags);
280		} else {
281			skb_queue_tail(&dev->rx_frames, skb);
282		}
283		skb = NULL;
284
285		skb2 = skb_dequeue(&dev->rx_frames);
286		while (skb2) {
287			if (status < 0
288					|| ETH_HLEN > skb2->len
289					|| skb2->len > GETHER_MAX_ETH_FRAME_LEN) {
290				dev->net->stats.rx_errors++;
291				dev->net->stats.rx_length_errors++;
292				DBG(dev, "rx length %d\n", skb2->len);
293				dev_kfree_skb_any(skb2);
294				goto next_frame;
295			}
296			skb2->protocol = eth_type_trans(skb2, dev->net);
297			dev->net->stats.rx_packets++;
298			dev->net->stats.rx_bytes += skb2->len;
299
300			/* no buffer copies needed, unless hardware can't
301			 * use skb buffers.
302			 */
303			status = netif_rx(skb2);
304next_frame:
305			skb2 = skb_dequeue(&dev->rx_frames);
306		}
307		break;
308
309	/* software-driven interface shutdown */
310	case -ECONNRESET:		/* unlink */
311	case -ESHUTDOWN:		/* disconnect etc */
312		VDBG(dev, "rx shutdown, code %d\n", status);
313		goto quiesce;
314
315	/* for hardware automagic (such as pxa) */
316	case -ECONNABORTED:		/* endpoint reset */
317		DBG(dev, "rx %s reset\n", ep->name);
318		defer_kevent(dev, WORK_RX_MEMORY);
319quiesce:
320		dev_kfree_skb_any(skb);
321		goto clean;
322
323	/* data overrun */
324	case -EOVERFLOW:
325		dev->net->stats.rx_over_errors++;
326		fallthrough;
327
328	default:
329		dev->net->stats.rx_errors++;
330		DBG(dev, "rx status %d\n", status);
331		break;
332	}
333
334	if (skb)
335		dev_kfree_skb_any(skb);
336	if (!netif_running(dev->net)) {
337clean:
338		spin_lock(&dev->req_lock);
339		list_add(&req->list, &dev->rx_reqs);
340		spin_unlock(&dev->req_lock);
341		req = NULL;
342	}
343	if (req)
344		rx_submit(dev, req, GFP_ATOMIC);
345}
346
347static int prealloc(struct list_head *list, struct usb_ep *ep, unsigned n)
348{
349	unsigned		i;
350	struct usb_request	*req;
351
352	if (!n)
353		return -ENOMEM;
354
355	/* queue/recycle up to N requests */
356	i = n;
357	list_for_each_entry(req, list, list) {
358		if (i-- == 0)
359			goto extra;
360	}
361	while (i--) {
362		req = usb_ep_alloc_request(ep, GFP_ATOMIC);
363		if (!req)
364			return list_empty(list) ? -ENOMEM : 0;
365		list_add(&req->list, list);
366	}
367	return 0;
368
369extra:
370	/* free extras */
371	for (;;) {
372		struct list_head	*next;
373
374		next = req->list.next;
375		list_del(&req->list);
376		usb_ep_free_request(ep, req);
377
378		if (next == list)
379			break;
380
381		req = container_of(next, struct usb_request, list);
382	}
383	return 0;
384}
385
386static int alloc_requests(struct eth_dev *dev, struct gether *link, unsigned n)
387{
388	int	status;
389
390	spin_lock(&dev->req_lock);
391	status = prealloc(&dev->tx_reqs, link->in_ep, n);
392	if (status < 0)
393		goto fail;
394	status = prealloc(&dev->rx_reqs, link->out_ep, n);
395	if (status < 0)
396		goto fail;
397	goto done;
398fail:
399	DBG(dev, "can't alloc requests\n");
400done:
401	spin_unlock(&dev->req_lock);
402	return status;
403}
404
405static void rx_fill(struct eth_dev *dev, gfp_t gfp_flags)
406{
407	struct usb_request	*req;
408	unsigned long		flags;
409
410	/* fill unused rxq slots with some skb */
411	spin_lock_irqsave(&dev->req_lock, flags);
412	while (!list_empty(&dev->rx_reqs)) {
413		req = list_first_entry(&dev->rx_reqs, struct usb_request, list);
414		list_del_init(&req->list);
415		spin_unlock_irqrestore(&dev->req_lock, flags);
416
417		if (rx_submit(dev, req, gfp_flags) < 0) {
418			defer_kevent(dev, WORK_RX_MEMORY);
419			return;
420		}
421
422		spin_lock_irqsave(&dev->req_lock, flags);
423	}
424	spin_unlock_irqrestore(&dev->req_lock, flags);
425}
426
427static void eth_work(struct work_struct *work)
428{
429	struct eth_dev	*dev = container_of(work, struct eth_dev, work);
430
431	if (test_and_clear_bit(WORK_RX_MEMORY, &dev->todo)) {
432		if (netif_running(dev->net))
433			rx_fill(dev, GFP_KERNEL);
434	}
435
436	if (dev->todo)
437		DBG(dev, "work done, flags = 0x%lx\n", dev->todo);
438}
439
440static void tx_complete(struct usb_ep *ep, struct usb_request *req)
441{
442	struct sk_buff	*skb = req->context;
443	struct eth_dev	*dev = ep->driver_data;
444
445	switch (req->status) {
446	default:
447		dev->net->stats.tx_errors++;
448		VDBG(dev, "tx err %d\n", req->status);
449		fallthrough;
450	case -ECONNRESET:		/* unlink */
451	case -ESHUTDOWN:		/* disconnect etc */
452		dev_kfree_skb_any(skb);
453		break;
454	case 0:
455		dev->net->stats.tx_bytes += skb->len;
456		dev_consume_skb_any(skb);
457	}
458	dev->net->stats.tx_packets++;
459
460	spin_lock(&dev->req_lock);
461	list_add(&req->list, &dev->tx_reqs);
462	spin_unlock(&dev->req_lock);
463
464	atomic_dec(&dev->tx_qlen);
465	if (netif_carrier_ok(dev->net))
466		netif_wake_queue(dev->net);
467}
468
469static inline int is_promisc(u16 cdc_filter)
470{
471	return cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
472}
473
474static netdev_tx_t eth_start_xmit(struct sk_buff *skb,
475					struct net_device *net)
476{
477	struct eth_dev		*dev = netdev_priv(net);
478	int			length = 0;
479	int			retval;
480	struct usb_request	*req = NULL;
481	unsigned long		flags;
482	struct usb_ep		*in;
483	u16			cdc_filter;
484
485	spin_lock_irqsave(&dev->lock, flags);
486	if (dev->port_usb) {
487		in = dev->port_usb->in_ep;
488		cdc_filter = dev->port_usb->cdc_filter;
489	} else {
490		in = NULL;
491		cdc_filter = 0;
492	}
493	spin_unlock_irqrestore(&dev->lock, flags);
494
495	if (!in) {
496		if (skb)
497			dev_kfree_skb_any(skb);
498		return NETDEV_TX_OK;
499	}
500
501	/* apply outgoing CDC or RNDIS filters */
502	if (skb && !is_promisc(cdc_filter)) {
503		u8		*dest = skb->data;
504
505		if (is_multicast_ether_addr(dest)) {
506			u16	type;
507
508			/* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
509			 * SET_ETHERNET_MULTICAST_FILTERS requests
510			 */
511			if (is_broadcast_ether_addr(dest))
512				type = USB_CDC_PACKET_TYPE_BROADCAST;
513			else
514				type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
515			if (!(cdc_filter & type)) {
516				dev_kfree_skb_any(skb);
517				return NETDEV_TX_OK;
518			}
519		}
520		/* ignores USB_CDC_PACKET_TYPE_DIRECTED */
521	}
522
523	spin_lock_irqsave(&dev->req_lock, flags);
524	/*
525	 * this freelist can be empty if an interrupt triggered disconnect()
526	 * and reconfigured the gadget (shutting down this queue) after the
527	 * network stack decided to xmit but before we got the spinlock.
528	 */
529	if (list_empty(&dev->tx_reqs)) {
530		spin_unlock_irqrestore(&dev->req_lock, flags);
531		return NETDEV_TX_BUSY;
532	}
533
534	req = list_first_entry(&dev->tx_reqs, struct usb_request, list);
535	list_del(&req->list);
536
537	/* temporarily stop TX queue when the freelist empties */
538	if (list_empty(&dev->tx_reqs))
539		netif_stop_queue(net);
540	spin_unlock_irqrestore(&dev->req_lock, flags);
541
542	/* no buffer copies needed, unless the network stack did it
543	 * or the hardware can't use skb buffers.
544	 * or there's not enough space for extra headers we need
545	 */
546	if (dev->wrap) {
547		unsigned long	flags;
548
549		spin_lock_irqsave(&dev->lock, flags);
550		if (dev->port_usb)
551			skb = dev->wrap(dev->port_usb, skb);
552		spin_unlock_irqrestore(&dev->lock, flags);
553		if (!skb) {
554			/* Multi frame CDC protocols may store the frame for
555			 * later which is not a dropped frame.
556			 */
557			if (dev->port_usb &&
558					dev->port_usb->supports_multi_frame)
559				goto multiframe;
560			goto drop;
561		}
562	}
563
564	length = skb->len;
565	req->buf = skb->data;
566	req->context = skb;
567	req->complete = tx_complete;
568
569	/* NCM requires no zlp if transfer is dwNtbInMaxSize */
570	if (dev->port_usb &&
571	    dev->port_usb->is_fixed &&
572	    length == dev->port_usb->fixed_in_len &&
573	    (length % in->maxpacket) == 0)
574		req->zero = 0;
575	else
576		req->zero = 1;
577
578	/* use zlp framing on tx for strict CDC-Ether conformance,
579	 * though any robust network rx path ignores extra padding.
580	 * and some hardware doesn't like to write zlps.
581	 */
582	if (req->zero && !dev->zlp && (length % in->maxpacket) == 0)
583		length++;
584
585	req->length = length;
586
587	retval = usb_ep_queue(in, req, GFP_ATOMIC);
588	switch (retval) {
589	default:
590		DBG(dev, "tx queue err %d\n", retval);
591		break;
592	case 0:
593		netif_trans_update(net);
594		atomic_inc(&dev->tx_qlen);
595	}
596
597	if (retval) {
598		dev_kfree_skb_any(skb);
599drop:
600		dev->net->stats.tx_dropped++;
601multiframe:
602		spin_lock_irqsave(&dev->req_lock, flags);
603		if (list_empty(&dev->tx_reqs))
604			netif_start_queue(net);
605		list_add(&req->list, &dev->tx_reqs);
606		spin_unlock_irqrestore(&dev->req_lock, flags);
607	}
608	return NETDEV_TX_OK;
609}
610
611/*-------------------------------------------------------------------------*/
612
613static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
614{
615	DBG(dev, "%s\n", __func__);
616
617	/* fill the rx queue */
618	rx_fill(dev, gfp_flags);
619
620	/* and open the tx floodgates */
621	atomic_set(&dev->tx_qlen, 0);
622	netif_wake_queue(dev->net);
623}
624
625static int eth_open(struct net_device *net)
626{
627	struct eth_dev	*dev = netdev_priv(net);
628	struct gether	*link;
629
630	DBG(dev, "%s\n", __func__);
631	if (netif_carrier_ok(dev->net))
632		eth_start(dev, GFP_KERNEL);
633
634	spin_lock_irq(&dev->lock);
635	link = dev->port_usb;
636	if (link && link->open)
637		link->open(link);
638	spin_unlock_irq(&dev->lock);
639
640	return 0;
641}
642
643static int eth_stop(struct net_device *net)
644{
645	struct eth_dev	*dev = netdev_priv(net);
646	unsigned long	flags;
647
648	VDBG(dev, "%s\n", __func__);
649	netif_stop_queue(net);
650
651	DBG(dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
652		dev->net->stats.rx_packets, dev->net->stats.tx_packets,
653		dev->net->stats.rx_errors, dev->net->stats.tx_errors
654		);
655
656	/* ensure there are no more active requests */
657	spin_lock_irqsave(&dev->lock, flags);
658	if (dev->port_usb) {
659		struct gether	*link = dev->port_usb;
660		const struct usb_endpoint_descriptor *in;
661		const struct usb_endpoint_descriptor *out;
662
663		if (link->close)
664			link->close(link);
665
666		/* NOTE:  we have no abort-queue primitive we could use
667		 * to cancel all pending I/O.  Instead, we disable then
668		 * reenable the endpoints ... this idiom may leave toggle
669		 * wrong, but that's a self-correcting error.
670		 *
671		 * REVISIT:  we *COULD* just let the transfers complete at
672		 * their own pace; the network stack can handle old packets.
673		 * For the moment we leave this here, since it works.
674		 */
675		in = link->in_ep->desc;
676		out = link->out_ep->desc;
677		usb_ep_disable(link->in_ep);
678		usb_ep_disable(link->out_ep);
679		if (netif_carrier_ok(net)) {
680			DBG(dev, "host still using in/out endpoints\n");
681			link->in_ep->desc = in;
682			link->out_ep->desc = out;
683			usb_ep_enable(link->in_ep);
684			usb_ep_enable(link->out_ep);
685		}
686	}
687	spin_unlock_irqrestore(&dev->lock, flags);
688
689	return 0;
690}
691
692/*-------------------------------------------------------------------------*/
693
694static int get_ether_addr(const char *str, u8 *dev_addr)
695{
696	if (str) {
697		unsigned	i;
698
699		for (i = 0; i < 6; i++) {
700			unsigned char num;
701
702			if ((*str == '.') || (*str == ':'))
703				str++;
704			num = hex_to_bin(*str++) << 4;
705			num |= hex_to_bin(*str++);
706			dev_addr [i] = num;
707		}
708		if (is_valid_ether_addr(dev_addr))
709			return 0;
710	}
711	eth_random_addr(dev_addr);
712	return 1;
713}
714
715static int get_ether_addr_str(u8 dev_addr[ETH_ALEN], char *str, int len)
716{
717	if (len < 18)
718		return -EINVAL;
719
720	snprintf(str, len, "%pM", dev_addr);
721	return 18;
722}
723
724static const struct net_device_ops eth_netdev_ops = {
725	.ndo_open		= eth_open,
726	.ndo_stop		= eth_stop,
727	.ndo_start_xmit		= eth_start_xmit,
728	.ndo_set_mac_address 	= eth_mac_addr,
729	.ndo_validate_addr	= eth_validate_addr,
730};
731
732static struct device_type gadget_type = {
733	.name	= "gadget",
734};
735
736/*
737 * gether_setup_name - initialize one ethernet-over-usb link
738 * @g: gadget to associated with these links
739 * @ethaddr: NULL, or a buffer in which the ethernet address of the
740 *	host side of the link is recorded
741 * @netname: name for network device (for example, "usb")
742 * Context: may sleep
743 *
744 * This sets up the single network link that may be exported by a
745 * gadget driver using this framework.  The link layer addresses are
746 * set up using module parameters.
747 *
748 * Returns an eth_dev pointer on success, or an ERR_PTR on failure.
749 */
750struct eth_dev *gether_setup_name(struct usb_gadget *g,
751		const char *dev_addr, const char *host_addr,
752		u8 ethaddr[ETH_ALEN], unsigned qmult, const char *netname)
753{
754	struct eth_dev		*dev;
755	struct net_device	*net;
756	int			status;
757
758	net = alloc_etherdev(sizeof *dev);
759	if (!net)
760		return ERR_PTR(-ENOMEM);
761
762	dev = netdev_priv(net);
763	spin_lock_init(&dev->lock);
764	spin_lock_init(&dev->req_lock);
765	INIT_WORK(&dev->work, eth_work);
766	INIT_LIST_HEAD(&dev->tx_reqs);
767	INIT_LIST_HEAD(&dev->rx_reqs);
768
769	skb_queue_head_init(&dev->rx_frames);
770
771	/* network device setup */
772	dev->net = net;
773	dev->qmult = qmult;
774	snprintf(net->name, sizeof(net->name), "%s%%d", netname);
775
776	if (get_ether_addr(dev_addr, net->dev_addr)) {
777		net->addr_assign_type = NET_ADDR_RANDOM;
778		dev_warn(&g->dev,
779			"using random %s ethernet address\n", "self");
780	} else {
781		net->addr_assign_type = NET_ADDR_SET;
782	}
783	if (get_ether_addr(host_addr, dev->host_mac))
784		dev_warn(&g->dev,
785			"using random %s ethernet address\n", "host");
786
787	if (ethaddr)
788		memcpy(ethaddr, dev->host_mac, ETH_ALEN);
789
790	net->netdev_ops = &eth_netdev_ops;
791
792	net->ethtool_ops = &ops;
793
794	/* MTU range: 14 - 15412 */
795	net->min_mtu = ETH_HLEN;
796	net->max_mtu = GETHER_MAX_MTU_SIZE;
797
798	dev->gadget = g;
799	SET_NETDEV_DEV(net, &g->dev);
800	SET_NETDEV_DEVTYPE(net, &gadget_type);
801
802	status = register_netdev(net);
803	if (status < 0) {
804		dev_dbg(&g->dev, "register_netdev failed, %d\n", status);
805		free_netdev(net);
806		dev = ERR_PTR(status);
807	} else {
808		INFO(dev, "MAC %pM\n", net->dev_addr);
809		INFO(dev, "HOST MAC %pM\n", dev->host_mac);
810
811		/*
812		 * two kinds of host-initiated state changes:
813		 *  - iff DATA transfer is active, carrier is "on"
814		 *  - tx queueing enabled if open *and* carrier is "on"
815		 */
816		netif_carrier_off(net);
817	}
818
819	return dev;
820}
821EXPORT_SYMBOL_GPL(gether_setup_name);
822
823struct net_device *gether_setup_name_default(const char *netname)
824{
825	struct net_device	*net;
826	struct eth_dev		*dev;
827
828	net = alloc_etherdev(sizeof(*dev));
829	if (!net)
830		return ERR_PTR(-ENOMEM);
831
832	dev = netdev_priv(net);
833	spin_lock_init(&dev->lock);
834	spin_lock_init(&dev->req_lock);
835	INIT_WORK(&dev->work, eth_work);
836	INIT_LIST_HEAD(&dev->tx_reqs);
837	INIT_LIST_HEAD(&dev->rx_reqs);
838
839	/* by default we always have a random MAC address */
840	net->addr_assign_type = NET_ADDR_RANDOM;
841
842	skb_queue_head_init(&dev->rx_frames);
843
844	/* network device setup */
845	dev->net = net;
846	dev->qmult = QMULT_DEFAULT;
847	snprintf(net->name, sizeof(net->name), "%s%%d", netname);
848
849	eth_random_addr(dev->dev_mac);
850	pr_warn("using random %s ethernet address\n", "self");
851	eth_random_addr(dev->host_mac);
852	pr_warn("using random %s ethernet address\n", "host");
853
854	net->netdev_ops = &eth_netdev_ops;
855
856	net->ethtool_ops = &ops;
857	SET_NETDEV_DEVTYPE(net, &gadget_type);
858
859	/* MTU range: 14 - 15412 */
860	net->min_mtu = ETH_HLEN;
861	net->max_mtu = GETHER_MAX_MTU_SIZE;
862
863	return net;
864}
865EXPORT_SYMBOL_GPL(gether_setup_name_default);
866
867int gether_register_netdev(struct net_device *net)
868{
869	struct eth_dev *dev;
870	struct usb_gadget *g;
871	int status;
872
873	if (!net->dev.parent)
874		return -EINVAL;
875	dev = netdev_priv(net);
876	g = dev->gadget;
877
878	memcpy(net->dev_addr, dev->dev_mac, ETH_ALEN);
879
880	status = register_netdev(net);
881	if (status < 0) {
882		dev_dbg(&g->dev, "register_netdev failed, %d\n", status);
883		return status;
884	} else {
885		INFO(dev, "HOST MAC %pM\n", dev->host_mac);
886		INFO(dev, "MAC %pM\n", dev->dev_mac);
887
888		/* two kinds of host-initiated state changes:
889		 *  - iff DATA transfer is active, carrier is "on"
890		 *  - tx queueing enabled if open *and* carrier is "on"
891		 */
892		netif_carrier_off(net);
893	}
894
895	return status;
896}
897EXPORT_SYMBOL_GPL(gether_register_netdev);
898
899void gether_set_gadget(struct net_device *net, struct usb_gadget *g)
900{
901	struct eth_dev *dev;
902
903	dev = netdev_priv(net);
904	dev->gadget = g;
905	SET_NETDEV_DEV(net, &g->dev);
906}
907EXPORT_SYMBOL_GPL(gether_set_gadget);
908
909int gether_set_dev_addr(struct net_device *net, const char *dev_addr)
910{
911	struct eth_dev *dev;
912	u8 new_addr[ETH_ALEN];
913
914	dev = netdev_priv(net);
915	if (get_ether_addr(dev_addr, new_addr))
916		return -EINVAL;
917	memcpy(dev->dev_mac, new_addr, ETH_ALEN);
918	net->addr_assign_type = NET_ADDR_SET;
919	return 0;
920}
921EXPORT_SYMBOL_GPL(gether_set_dev_addr);
922
923int gether_get_dev_addr(struct net_device *net, char *dev_addr, int len)
924{
925	struct eth_dev *dev;
926	int ret;
927
928	dev = netdev_priv(net);
929	ret = get_ether_addr_str(dev->dev_mac, dev_addr, len);
930	if (ret + 1 < len) {
931		dev_addr[ret++] = '\n';
932		dev_addr[ret] = '\0';
933	}
934
935	return ret;
936}
937EXPORT_SYMBOL_GPL(gether_get_dev_addr);
938
939int gether_set_host_addr(struct net_device *net, const char *host_addr)
940{
941	struct eth_dev *dev;
942	u8 new_addr[ETH_ALEN];
943
944	dev = netdev_priv(net);
945	if (get_ether_addr(host_addr, new_addr))
946		return -EINVAL;
947	memcpy(dev->host_mac, new_addr, ETH_ALEN);
948	return 0;
949}
950EXPORT_SYMBOL_GPL(gether_set_host_addr);
951
952int gether_get_host_addr(struct net_device *net, char *host_addr, int len)
953{
954	struct eth_dev *dev;
955	int ret;
956
957	dev = netdev_priv(net);
958	ret = get_ether_addr_str(dev->host_mac, host_addr, len);
959	if (ret + 1 < len) {
960		host_addr[ret++] = '\n';
961		host_addr[ret] = '\0';
962	}
963
964	return ret;
965}
966EXPORT_SYMBOL_GPL(gether_get_host_addr);
967
968int gether_get_host_addr_cdc(struct net_device *net, char *host_addr, int len)
969{
970	struct eth_dev *dev;
971
972	if (len < 13)
973		return -EINVAL;
974
975	dev = netdev_priv(net);
976	snprintf(host_addr, len, "%pm", dev->host_mac);
977
978	string_upper(host_addr, host_addr);
979
980	return strlen(host_addr);
981}
982EXPORT_SYMBOL_GPL(gether_get_host_addr_cdc);
983
984void gether_get_host_addr_u8(struct net_device *net, u8 host_mac[ETH_ALEN])
985{
986	struct eth_dev *dev;
987
988	dev = netdev_priv(net);
989	memcpy(host_mac, dev->host_mac, ETH_ALEN);
990}
991EXPORT_SYMBOL_GPL(gether_get_host_addr_u8);
992
993void gether_set_qmult(struct net_device *net, unsigned qmult)
994{
995	struct eth_dev *dev;
996
997	dev = netdev_priv(net);
998	dev->qmult = qmult;
999}
1000EXPORT_SYMBOL_GPL(gether_set_qmult);
1001
1002unsigned gether_get_qmult(struct net_device *net)
1003{
1004	struct eth_dev *dev;
1005
1006	dev = netdev_priv(net);
1007	return dev->qmult;
1008}
1009EXPORT_SYMBOL_GPL(gether_get_qmult);
1010
1011int gether_get_ifname(struct net_device *net, char *name, int len)
1012{
1013	int ret;
1014
1015	rtnl_lock();
1016	ret = scnprintf(name, len, "%s\n", netdev_name(net));
1017	rtnl_unlock();
1018	return ret;
1019}
1020EXPORT_SYMBOL_GPL(gether_get_ifname);
1021
1022/*
1023 * gether_cleanup - remove Ethernet-over-USB device
1024 * Context: may sleep
1025 *
1026 * This is called to free all resources allocated by @gether_setup().
1027 */
1028void gether_cleanup(struct eth_dev *dev)
1029{
1030	if (!dev)
1031		return;
1032
1033	unregister_netdev(dev->net);
1034	flush_work(&dev->work);
1035	free_netdev(dev->net);
1036}
1037EXPORT_SYMBOL_GPL(gether_cleanup);
1038
1039/**
1040 * gether_connect - notify network layer that USB link is active
1041 * @link: the USB link, set up with endpoints, descriptors matching
1042 *	current device speed, and any framing wrapper(s) set up.
1043 * Context: irqs blocked
1044 *
1045 * This is called to activate endpoints and let the network layer know
1046 * the connection is active ("carrier detect").  It may cause the I/O
1047 * queues to open and start letting network packets flow, but will in
1048 * any case activate the endpoints so that they respond properly to the
1049 * USB host.
1050 *
1051 * Verify net_device pointer returned using IS_ERR().  If it doesn't
1052 * indicate some error code (negative errno), ep->driver_data values
1053 * have been overwritten.
1054 */
1055struct net_device *gether_connect(struct gether *link)
1056{
1057	struct eth_dev		*dev = link->ioport;
1058	int			result = 0;
1059
1060	if (!dev)
1061		return ERR_PTR(-EINVAL);
1062
1063	link->in_ep->driver_data = dev;
1064	result = usb_ep_enable(link->in_ep);
1065	if (result != 0) {
1066		DBG(dev, "enable %s --> %d\n",
1067			link->in_ep->name, result);
1068		goto fail0;
1069	}
1070
1071	link->out_ep->driver_data = dev;
1072	result = usb_ep_enable(link->out_ep);
1073	if (result != 0) {
1074		DBG(dev, "enable %s --> %d\n",
1075			link->out_ep->name, result);
1076		goto fail1;
1077	}
1078
1079	if (result == 0)
1080		result = alloc_requests(dev, link, qlen(dev->gadget,
1081					dev->qmult));
1082
1083	if (result == 0) {
1084		dev->zlp = link->is_zlp_ok;
1085		dev->no_skb_reserve = gadget_avoids_skb_reserve(dev->gadget);
1086		DBG(dev, "qlen %d\n", qlen(dev->gadget, dev->qmult));
1087
1088		dev->header_len = link->header_len;
1089		dev->unwrap = link->unwrap;
1090		dev->wrap = link->wrap;
1091
1092		spin_lock(&dev->lock);
1093		dev->port_usb = link;
1094		if (netif_running(dev->net)) {
1095			if (link->open)
1096				link->open(link);
1097		} else {
1098			if (link->close)
1099				link->close(link);
1100		}
1101		spin_unlock(&dev->lock);
1102
1103		netif_carrier_on(dev->net);
1104		if (netif_running(dev->net))
1105			eth_start(dev, GFP_ATOMIC);
1106
1107	/* on error, disable any endpoints  */
1108	} else {
1109		(void) usb_ep_disable(link->out_ep);
1110fail1:
1111		(void) usb_ep_disable(link->in_ep);
1112	}
1113fail0:
1114	/* caller is responsible for cleanup on error */
1115	if (result < 0)
1116		return ERR_PTR(result);
1117	return dev->net;
1118}
1119EXPORT_SYMBOL_GPL(gether_connect);
1120
1121/**
1122 * gether_disconnect - notify network layer that USB link is inactive
1123 * @link: the USB link, on which gether_connect() was called
1124 * Context: irqs blocked
1125 *
1126 * This is called to deactivate endpoints and let the network layer know
1127 * the connection went inactive ("no carrier").
1128 *
1129 * On return, the state is as if gether_connect() had never been called.
1130 * The endpoints are inactive, and accordingly without active USB I/O.
1131 * Pointers to endpoint descriptors and endpoint private data are nulled.
1132 */
1133void gether_disconnect(struct gether *link)
1134{
1135	struct eth_dev		*dev = link->ioport;
1136	struct usb_request	*req;
1137
1138	WARN_ON(!dev);
1139	if (!dev)
1140		return;
1141
1142	DBG(dev, "%s\n", __func__);
1143
1144	netif_stop_queue(dev->net);
1145	netif_carrier_off(dev->net);
1146
1147	/* disable endpoints, forcing (synchronous) completion
1148	 * of all pending i/o.  then free the request objects
1149	 * and forget about the endpoints.
1150	 */
1151	usb_ep_disable(link->in_ep);
1152	spin_lock(&dev->req_lock);
1153	while (!list_empty(&dev->tx_reqs)) {
1154		req = list_first_entry(&dev->tx_reqs, struct usb_request, list);
1155		list_del(&req->list);
1156
1157		spin_unlock(&dev->req_lock);
1158		usb_ep_free_request(link->in_ep, req);
1159		spin_lock(&dev->req_lock);
1160	}
1161	spin_unlock(&dev->req_lock);
1162	link->in_ep->desc = NULL;
1163
1164	usb_ep_disable(link->out_ep);
1165	spin_lock(&dev->req_lock);
1166	while (!list_empty(&dev->rx_reqs)) {
1167		req = list_first_entry(&dev->rx_reqs, struct usb_request, list);
1168		list_del(&req->list);
1169
1170		spin_unlock(&dev->req_lock);
1171		usb_ep_free_request(link->out_ep, req);
1172		spin_lock(&dev->req_lock);
1173	}
1174	spin_unlock(&dev->req_lock);
1175	link->out_ep->desc = NULL;
1176
1177	/* finish forgetting about this USB link episode */
1178	dev->header_len = 0;
1179	dev->unwrap = NULL;
1180	dev->wrap = NULL;
1181
1182	spin_lock(&dev->lock);
1183	dev->port_usb = NULL;
1184	spin_unlock(&dev->lock);
1185}
1186EXPORT_SYMBOL_GPL(gether_disconnect);
1187
1188MODULE_LICENSE("GPL");
1189MODULE_AUTHOR("David Brownell");
1190