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