2 * u_ether.c -- Ethernet-over-USB link layer utilities for Gadget stack
4 * Copyright (C) 2003-2005,2008 David Brownell
5 * Copyright (C) 2003-2004 Robert Schwebel, Benedikt Spranger
6 * Copyright (C) 2008 Nokia Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
14 /* #define VERBOSE_DEBUG */
16 #include <linux/kernel.h>
17 #include <linux/gfp.h>
18 #include <linux/device.h>
19 #include <linux/ctype.h>
20 #include <linux/etherdevice.h>
21 #include <linux/ethtool.h>
27 * This component encapsulates the Ethernet link glue needed to provide
28 * one (!) network link through the USB gadget stack, normally "usb0".
30 * The control and data models are handled by the function driver which
31 * connects to this code; such as CDC Ethernet (ECM or EEM),
32 * "CDC Subset", or RNDIS. That includes all descriptor and endpoint
35 * Link level addressing is handled by this component using module
36 * parameters; if no such parameters are provided, random link level
37 * addresses are used. Each end of the link uses one address. The
38 * host end address is exported in various ways, and is often recorded
39 * in configuration databases.
41 * The driver which assembles each configuration using such a link is
42 * responsible for ensuring that each configuration includes at most one
43 * instance of is network link. (The network layer provides ways for
44 * this single "physical" link to be used by multiple virtual links.)
47 #define UETH__VERSION "29-May-2008"
50 /* lock is held while accessing port_usb
51 * or updating its backlink port_usb->ioport
54 struct gether
*port_usb
;
56 struct net_device
*net
;
57 struct usb_gadget
*gadget
;
59 spinlock_t req_lock
; /* guard {rx,tx}_reqs */
60 struct list_head tx_reqs
, rx_reqs
;
63 struct sk_buff_head rx_frames
;
66 struct sk_buff
*(*wrap
)(struct gether
*, struct sk_buff
*skb
);
67 int (*unwrap
)(struct gether
*,
69 struct sk_buff_head
*list
);
71 struct work_struct work
;
74 #define WORK_RX_MEMORY 0
77 u8 host_mac
[ETH_ALEN
];
80 /*-------------------------------------------------------------------------*/
82 #define RX_EXTRA 20 /* bytes guarding against rx overflows */
84 #define DEFAULT_QLEN 2 /* double buffering by default */
86 static unsigned qmult
= 5;
87 module_param(qmult
, uint
, S_IRUGO
|S_IWUSR
);
88 MODULE_PARM_DESC(qmult
, "queue length multiplier at high/super speed");
90 /* for dual-speed hardware, use deeper queues at high/super speed */
91 static inline int qlen(struct usb_gadget
*gadget
)
93 if (gadget_is_dualspeed(gadget
) && (gadget
->speed
== USB_SPEED_HIGH
||
94 gadget
->speed
== USB_SPEED_SUPER
))
95 return qmult
* DEFAULT_QLEN
;
100 /*-------------------------------------------------------------------------*/
102 /* REVISIT there must be a better way than having two sets
111 #define xprintk(d, level, fmt, args...) \
112 printk(level "%s: " fmt , (d)->net->name , ## args)
116 #define DBG(dev, fmt, args...) \
117 xprintk(dev , KERN_DEBUG , fmt , ## args)
119 #define DBG(dev, fmt, args...) \
126 #define VDBG(dev, fmt, args...) \
130 #define ERROR(dev, fmt, args...) \
131 xprintk(dev , KERN_ERR , fmt , ## args)
132 #define INFO(dev, fmt, args...) \
133 xprintk(dev , KERN_INFO , fmt , ## args)
135 /*-------------------------------------------------------------------------*/
137 /* NETWORK DRIVER HOOKUP (to the layer above this driver) */
139 static int ueth_change_mtu(struct net_device
*net
, int new_mtu
)
141 struct eth_dev
*dev
= netdev_priv(net
);
145 /* don't change MTU on "live" link (peer won't know) */
146 spin_lock_irqsave(&dev
->lock
, flags
);
149 else if (new_mtu
<= ETH_HLEN
|| new_mtu
> ETH_FRAME_LEN
)
153 spin_unlock_irqrestore(&dev
->lock
, flags
);
158 static void eth_get_drvinfo(struct net_device
*net
, struct ethtool_drvinfo
*p
)
160 struct eth_dev
*dev
= netdev_priv(net
);
162 strlcpy(p
->driver
, "g_ether", sizeof p
->driver
);
163 strlcpy(p
->version
, UETH__VERSION
, sizeof p
->version
);
164 strlcpy(p
->fw_version
, dev
->gadget
->name
, sizeof p
->fw_version
);
165 strlcpy(p
->bus_info
, dev_name(&dev
->gadget
->dev
), sizeof p
->bus_info
);
168 /* REVISIT can also support:
169 * - WOL (by tracking suspends and issuing remote wakeup)
170 * - msglevel (implies updated messaging)
171 * - ... probably more ethtool ops
174 static const struct ethtool_ops ops
= {
175 .get_drvinfo
= eth_get_drvinfo
,
176 .get_link
= ethtool_op_get_link
,
179 static void defer_kevent(struct eth_dev
*dev
, int flag
)
181 if (test_and_set_bit(flag
, &dev
->todo
))
183 if (!schedule_work(&dev
->work
))
184 ERROR(dev
, "kevent %d may have been dropped\n", flag
);
186 DBG(dev
, "kevent %d scheduled\n", flag
);
189 static void rx_complete(struct usb_ep
*ep
, struct usb_request
*req
);
192 rx_submit(struct eth_dev
*dev
, struct usb_request
*req
, gfp_t gfp_flags
)
195 int retval
= -ENOMEM
;
200 spin_lock_irqsave(&dev
->lock
, flags
);
202 out
= dev
->port_usb
->out_ep
;
205 spin_unlock_irqrestore(&dev
->lock
, flags
);
211 /* Padding up to RX_EXTRA handles minor disagreements with host.
212 * Normally we use the USB "terminate on short read" convention;
213 * so allow up to (N*maxpacket), since that memory is normally
214 * already allocated. Some hardware doesn't deal well with short
215 * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
216 * byte off the end (to force hardware errors on overflow).
218 * RNDIS uses internal framing, and explicitly allows senders to
219 * pad to end-of-packet. That's potentially nice for speed, but
220 * means receivers can't recover lost synch on their own (because
221 * new packets don't only start after a short RX).
223 size
+= sizeof(struct ethhdr
) + dev
->net
->mtu
+ RX_EXTRA
;
224 size
+= dev
->port_usb
->header_len
;
225 size
+= out
->maxpacket
- 1;
226 size
-= size
% out
->maxpacket
;
228 if (dev
->port_usb
->is_fixed
)
229 size
= max_t(size_t, size
, dev
->port_usb
->fixed_out_len
);
231 skb
= alloc_skb(size
+ NET_IP_ALIGN
, gfp_flags
);
233 DBG(dev
, "no rx skb\n");
237 /* Some platforms perform better when IP packets are aligned,
238 * but on at least one, checksumming fails otherwise. Note:
239 * RNDIS headers involve variable numbers of LE32 values.
241 skb_reserve(skb
, NET_IP_ALIGN
);
243 req
->buf
= skb
->data
;
245 req
->complete
= rx_complete
;
248 retval
= usb_ep_queue(out
, req
, gfp_flags
);
249 if (retval
== -ENOMEM
)
251 defer_kevent(dev
, WORK_RX_MEMORY
);
253 DBG(dev
, "rx submit --> %d\n", retval
);
255 dev_kfree_skb_any(skb
);
256 spin_lock_irqsave(&dev
->req_lock
, flags
);
257 list_add(&req
->list
, &dev
->rx_reqs
);
258 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
263 static void rx_complete(struct usb_ep
*ep
, struct usb_request
*req
)
265 struct sk_buff
*skb
= req
->context
, *skb2
;
266 struct eth_dev
*dev
= ep
->driver_data
;
267 int status
= req
->status
;
271 /* normal completion */
273 skb_put(skb
, req
->actual
);
278 spin_lock_irqsave(&dev
->lock
, flags
);
280 status
= dev
->unwrap(dev
->port_usb
,
284 dev_kfree_skb_any(skb
);
287 spin_unlock_irqrestore(&dev
->lock
, flags
);
289 skb_queue_tail(&dev
->rx_frames
, skb
);
293 skb2
= skb_dequeue(&dev
->rx_frames
);
296 || ETH_HLEN
> skb2
->len
297 || skb2
->len
> ETH_FRAME_LEN
) {
298 dev
->net
->stats
.rx_errors
++;
299 dev
->net
->stats
.rx_length_errors
++;
300 DBG(dev
, "rx length %d\n", skb2
->len
);
301 dev_kfree_skb_any(skb2
);
304 skb2
->protocol
= eth_type_trans(skb2
, dev
->net
);
305 dev
->net
->stats
.rx_packets
++;
306 dev
->net
->stats
.rx_bytes
+= skb2
->len
;
308 /* no buffer copies needed, unless hardware can't
311 status
= netif_rx(skb2
);
313 skb2
= skb_dequeue(&dev
->rx_frames
);
317 /* software-driven interface shutdown */
318 case -ECONNRESET
: /* unlink */
319 case -ESHUTDOWN
: /* disconnect etc */
320 VDBG(dev
, "rx shutdown, code %d\n", status
);
323 /* for hardware automagic (such as pxa) */
324 case -ECONNABORTED
: /* endpoint reset */
325 DBG(dev
, "rx %s reset\n", ep
->name
);
326 defer_kevent(dev
, WORK_RX_MEMORY
);
328 dev_kfree_skb_any(skb
);
333 dev
->net
->stats
.rx_over_errors
++;
337 dev
->net
->stats
.rx_errors
++;
338 DBG(dev
, "rx status %d\n", status
);
343 dev_kfree_skb_any(skb
);
344 if (!netif_running(dev
->net
)) {
346 spin_lock(&dev
->req_lock
);
347 list_add(&req
->list
, &dev
->rx_reqs
);
348 spin_unlock(&dev
->req_lock
);
352 rx_submit(dev
, req
, GFP_ATOMIC
);
355 static int prealloc(struct list_head
*list
, struct usb_ep
*ep
, unsigned n
)
358 struct usb_request
*req
;
363 /* queue/recycle up to N requests */
365 list_for_each_entry(req
, list
, list
) {
370 req
= usb_ep_alloc_request(ep
, GFP_ATOMIC
);
372 return list_empty(list
) ? -ENOMEM
: 0;
373 list_add(&req
->list
, list
);
380 struct list_head
*next
;
382 next
= req
->list
.next
;
383 list_del(&req
->list
);
384 usb_ep_free_request(ep
, req
);
389 req
= container_of(next
, struct usb_request
, list
);
394 static int alloc_requests(struct eth_dev
*dev
, struct gether
*link
, unsigned n
)
398 spin_lock(&dev
->req_lock
);
399 status
= prealloc(&dev
->tx_reqs
, link
->in_ep
, n
);
402 status
= prealloc(&dev
->rx_reqs
, link
->out_ep
, n
);
407 DBG(dev
, "can't alloc requests\n");
409 spin_unlock(&dev
->req_lock
);
413 static void rx_fill(struct eth_dev
*dev
, gfp_t gfp_flags
)
415 struct usb_request
*req
;
418 /* fill unused rxq slots with some skb */
419 spin_lock_irqsave(&dev
->req_lock
, flags
);
420 while (!list_empty(&dev
->rx_reqs
)) {
421 req
= container_of(dev
->rx_reqs
.next
,
422 struct usb_request
, list
);
423 list_del_init(&req
->list
);
424 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
426 if (rx_submit(dev
, req
, gfp_flags
) < 0) {
427 defer_kevent(dev
, WORK_RX_MEMORY
);
431 spin_lock_irqsave(&dev
->req_lock
, flags
);
433 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
436 static void eth_work(struct work_struct
*work
)
438 struct eth_dev
*dev
= container_of(work
, struct eth_dev
, work
);
440 if (test_and_clear_bit(WORK_RX_MEMORY
, &dev
->todo
)) {
441 if (netif_running(dev
->net
))
442 rx_fill(dev
, GFP_KERNEL
);
446 DBG(dev
, "work done, flags = 0x%lx\n", dev
->todo
);
449 static void tx_complete(struct usb_ep
*ep
, struct usb_request
*req
)
451 struct sk_buff
*skb
= req
->context
;
452 struct eth_dev
*dev
= ep
->driver_data
;
454 switch (req
->status
) {
456 dev
->net
->stats
.tx_errors
++;
457 VDBG(dev
, "tx err %d\n", req
->status
);
459 case -ECONNRESET
: /* unlink */
460 case -ESHUTDOWN
: /* disconnect etc */
463 dev
->net
->stats
.tx_bytes
+= skb
->len
;
465 dev
->net
->stats
.tx_packets
++;
467 spin_lock(&dev
->req_lock
);
468 list_add(&req
->list
, &dev
->tx_reqs
);
469 spin_unlock(&dev
->req_lock
);
470 dev_kfree_skb_any(skb
);
472 atomic_dec(&dev
->tx_qlen
);
473 if (netif_carrier_ok(dev
->net
))
474 netif_wake_queue(dev
->net
);
477 static inline int is_promisc(u16 cdc_filter
)
479 return cdc_filter
& USB_CDC_PACKET_TYPE_PROMISCUOUS
;
482 static netdev_tx_t
eth_start_xmit(struct sk_buff
*skb
,
483 struct net_device
*net
)
485 struct eth_dev
*dev
= netdev_priv(net
);
486 int length
= skb
->len
;
488 struct usb_request
*req
= NULL
;
493 spin_lock_irqsave(&dev
->lock
, flags
);
495 in
= dev
->port_usb
->in_ep
;
496 cdc_filter
= dev
->port_usb
->cdc_filter
;
501 spin_unlock_irqrestore(&dev
->lock
, flags
);
504 dev_kfree_skb_any(skb
);
508 /* apply outgoing CDC or RNDIS filters */
509 if (!is_promisc(cdc_filter
)) {
510 u8
*dest
= skb
->data
;
512 if (is_multicast_ether_addr(dest
)) {
515 /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
516 * SET_ETHERNET_MULTICAST_FILTERS requests
518 if (is_broadcast_ether_addr(dest
))
519 type
= USB_CDC_PACKET_TYPE_BROADCAST
;
521 type
= USB_CDC_PACKET_TYPE_ALL_MULTICAST
;
522 if (!(cdc_filter
& type
)) {
523 dev_kfree_skb_any(skb
);
527 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
530 spin_lock_irqsave(&dev
->req_lock
, flags
);
532 * this freelist can be empty if an interrupt triggered disconnect()
533 * and reconfigured the gadget (shutting down this queue) after the
534 * network stack decided to xmit but before we got the spinlock.
536 if (list_empty(&dev
->tx_reqs
)) {
537 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
538 return NETDEV_TX_BUSY
;
541 req
= container_of(dev
->tx_reqs
.next
, struct usb_request
, list
);
542 list_del(&req
->list
);
544 /* temporarily stop TX queue when the freelist empties */
545 if (list_empty(&dev
->tx_reqs
))
546 netif_stop_queue(net
);
547 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
549 /* no buffer copies needed, unless the network stack did it
550 * or the hardware can't use skb buffers.
551 * or there's not enough space for extra headers we need
556 spin_lock_irqsave(&dev
->lock
, flags
);
558 skb
= dev
->wrap(dev
->port_usb
, skb
);
559 spin_unlock_irqrestore(&dev
->lock
, flags
);
565 req
->buf
= skb
->data
;
567 req
->complete
= tx_complete
;
569 /* NCM requires no zlp if transfer is dwNtbInMaxSize */
570 if (dev
->port_usb
->is_fixed
&&
571 length
== dev
->port_usb
->fixed_in_len
&&
572 (length
% in
->maxpacket
) == 0)
577 /* use zlp framing on tx for strict CDC-Ether conformance,
578 * though any robust network rx path ignores extra padding.
579 * and some hardware doesn't like to write zlps.
581 if (req
->zero
&& !dev
->zlp
&& (length
% in
->maxpacket
) == 0)
584 req
->length
= length
;
586 /* throttle high/super speed IRQ rate back slightly */
587 if (gadget_is_dualspeed(dev
->gadget
))
588 req
->no_interrupt
= (dev
->gadget
->speed
== USB_SPEED_HIGH
||
589 dev
->gadget
->speed
== USB_SPEED_SUPER
)
590 ? ((atomic_read(&dev
->tx_qlen
) % qmult
) != 0)
593 retval
= usb_ep_queue(in
, req
, GFP_ATOMIC
);
596 DBG(dev
, "tx queue err %d\n", retval
);
599 net
->trans_start
= jiffies
;
600 atomic_inc(&dev
->tx_qlen
);
604 dev_kfree_skb_any(skb
);
606 dev
->net
->stats
.tx_dropped
++;
607 spin_lock_irqsave(&dev
->req_lock
, flags
);
608 if (list_empty(&dev
->tx_reqs
))
609 netif_start_queue(net
);
610 list_add(&req
->list
, &dev
->tx_reqs
);
611 spin_unlock_irqrestore(&dev
->req_lock
, flags
);
616 /*-------------------------------------------------------------------------*/
618 static void eth_start(struct eth_dev
*dev
, gfp_t gfp_flags
)
620 DBG(dev
, "%s\n", __func__
);
622 /* fill the rx queue */
623 rx_fill(dev
, gfp_flags
);
625 /* and open the tx floodgates */
626 atomic_set(&dev
->tx_qlen
, 0);
627 netif_wake_queue(dev
->net
);
630 static int eth_open(struct net_device
*net
)
632 struct eth_dev
*dev
= netdev_priv(net
);
635 DBG(dev
, "%s\n", __func__
);
636 if (netif_carrier_ok(dev
->net
))
637 eth_start(dev
, GFP_KERNEL
);
639 spin_lock_irq(&dev
->lock
);
640 link
= dev
->port_usb
;
641 if (link
&& link
->open
)
643 spin_unlock_irq(&dev
->lock
);
648 static int eth_stop(struct net_device
*net
)
650 struct eth_dev
*dev
= netdev_priv(net
);
653 VDBG(dev
, "%s\n", __func__
);
654 netif_stop_queue(net
);
656 DBG(dev
, "stop stats: rx/tx %ld/%ld, errs %ld/%ld\n",
657 dev
->net
->stats
.rx_packets
, dev
->net
->stats
.tx_packets
,
658 dev
->net
->stats
.rx_errors
, dev
->net
->stats
.tx_errors
661 /* ensure there are no more active requests */
662 spin_lock_irqsave(&dev
->lock
, flags
);
664 struct gether
*link
= dev
->port_usb
;
669 /* NOTE: we have no abort-queue primitive we could use
670 * to cancel all pending I/O. Instead, we disable then
671 * reenable the endpoints ... this idiom may leave toggle
672 * wrong, but that's a self-correcting error.
674 * REVISIT: we *COULD* just let the transfers complete at
675 * their own pace; the network stack can handle old packets.
676 * For the moment we leave this here, since it works.
678 usb_ep_disable(link
->in_ep
);
679 usb_ep_disable(link
->out_ep
);
680 if (netif_carrier_ok(net
)) {
681 DBG(dev
, "host still using in/out endpoints\n");
682 usb_ep_enable(link
->in_ep
);
683 usb_ep_enable(link
->out_ep
);
686 spin_unlock_irqrestore(&dev
->lock
, flags
);
691 /*-------------------------------------------------------------------------*/
693 /* initial value, changed by "ifconfig usb0 hw ether xx:xx:xx:xx:xx:xx" */
694 static char *dev_addr
;
695 module_param(dev_addr
, charp
, S_IRUGO
);
696 MODULE_PARM_DESC(dev_addr
, "Device Ethernet Address");
698 /* this address is invisible to ifconfig */
699 static char *host_addr
;
700 module_param(host_addr
, charp
, S_IRUGO
);
701 MODULE_PARM_DESC(host_addr
, "Host Ethernet Address");
703 static int get_ether_addr(const char *str
, u8
*dev_addr
)
708 for (i
= 0; i
< 6; i
++) {
711 if ((*str
== '.') || (*str
== ':'))
713 num
= hex_to_bin(*str
++) << 4;
714 num
|= hex_to_bin(*str
++);
717 if (is_valid_ether_addr(dev_addr
))
720 eth_random_addr(dev_addr
);
724 static struct eth_dev
*the_dev
;
726 static const struct net_device_ops eth_netdev_ops
= {
727 .ndo_open
= eth_open
,
728 .ndo_stop
= eth_stop
,
729 .ndo_start_xmit
= eth_start_xmit
,
730 .ndo_change_mtu
= ueth_change_mtu
,
731 .ndo_set_mac_address
= eth_mac_addr
,
732 .ndo_validate_addr
= eth_validate_addr
,
735 static struct device_type gadget_type
= {
740 * gether_setup_name - initialize one ethernet-over-usb link
741 * @g: gadget to associated with these links
742 * @ethaddr: NULL, or a buffer in which the ethernet address of the
743 * host side of the link is recorded
744 * @netname: name for network device (for example, "usb")
747 * This sets up the single network link that may be exported by a
748 * gadget driver using this framework. The link layer addresses are
749 * set up using module parameters.
751 * Returns negative errno, or zero on success
753 int gether_setup_name(struct usb_gadget
*g
, u8 ethaddr
[ETH_ALEN
],
757 struct net_device
*net
;
763 net
= alloc_etherdev(sizeof *dev
);
767 dev
= netdev_priv(net
);
768 spin_lock_init(&dev
->lock
);
769 spin_lock_init(&dev
->req_lock
);
770 INIT_WORK(&dev
->work
, eth_work
);
771 INIT_LIST_HEAD(&dev
->tx_reqs
);
772 INIT_LIST_HEAD(&dev
->rx_reqs
);
774 skb_queue_head_init(&dev
->rx_frames
);
776 /* network device setup */
778 snprintf(net
->name
, sizeof(net
->name
), "%s%%d", netname
);
780 if (get_ether_addr(dev_addr
, net
->dev_addr
))
782 "using random %s ethernet address\n", "self");
783 if (get_ether_addr(host_addr
, dev
->host_mac
))
785 "using random %s ethernet address\n", "host");
788 memcpy(ethaddr
, dev
->host_mac
, ETH_ALEN
);
790 net
->netdev_ops
= ð_netdev_ops
;
792 SET_ETHTOOL_OPS(net
, &ops
);
795 SET_NETDEV_DEV(net
, &g
->dev
);
796 SET_NETDEV_DEVTYPE(net
, &gadget_type
);
798 status
= register_netdev(net
);
800 dev_dbg(&g
->dev
, "register_netdev failed, %d\n", status
);
803 INFO(dev
, "MAC %pM\n", net
->dev_addr
);
804 INFO(dev
, "HOST MAC %pM\n", dev
->host_mac
);
808 /* two kinds of host-initiated state changes:
809 * - iff DATA transfer is active, carrier is "on"
810 * - tx queueing enabled if open *and* carrier is "on"
812 netif_carrier_off(net
);
819 * gether_cleanup - remove Ethernet-over-USB device
822 * This is called to free all resources allocated by @gether_setup().
824 void gether_cleanup(void)
829 unregister_netdev(the_dev
->net
);
830 flush_work(&the_dev
->work
);
831 free_netdev(the_dev
->net
);
838 * gether_connect - notify network layer that USB link is active
839 * @link: the USB link, set up with endpoints, descriptors matching
840 * current device speed, and any framing wrapper(s) set up.
841 * Context: irqs blocked
843 * This is called to activate endpoints and let the network layer know
844 * the connection is active ("carrier detect"). It may cause the I/O
845 * queues to open and start letting network packets flow, but will in
846 * any case activate the endpoints so that they respond properly to the
849 * Verify net_device pointer returned using IS_ERR(). If it doesn't
850 * indicate some error code (negative errno), ep->driver_data values
851 * have been overwritten.
853 struct net_device
*gether_connect(struct gether
*link
)
855 struct eth_dev
*dev
= the_dev
;
859 return ERR_PTR(-EINVAL
);
861 link
->in_ep
->driver_data
= dev
;
862 result
= usb_ep_enable(link
->in_ep
);
864 DBG(dev
, "enable %s --> %d\n",
865 link
->in_ep
->name
, result
);
869 link
->out_ep
->driver_data
= dev
;
870 result
= usb_ep_enable(link
->out_ep
);
872 DBG(dev
, "enable %s --> %d\n",
873 link
->out_ep
->name
, result
);
878 result
= alloc_requests(dev
, link
, qlen(dev
->gadget
));
881 dev
->zlp
= link
->is_zlp_ok
;
882 DBG(dev
, "qlen %d\n", qlen(dev
->gadget
));
884 dev
->header_len
= link
->header_len
;
885 dev
->unwrap
= link
->unwrap
;
886 dev
->wrap
= link
->wrap
;
888 spin_lock(&dev
->lock
);
889 dev
->port_usb
= link
;
891 if (netif_running(dev
->net
)) {
898 spin_unlock(&dev
->lock
);
900 netif_carrier_on(dev
->net
);
901 if (netif_running(dev
->net
))
902 eth_start(dev
, GFP_ATOMIC
);
904 /* on error, disable any endpoints */
906 (void) usb_ep_disable(link
->out_ep
);
908 (void) usb_ep_disable(link
->in_ep
);
911 /* caller is responsible for cleanup on error */
913 return ERR_PTR(result
);
918 * gether_disconnect - notify network layer that USB link is inactive
919 * @link: the USB link, on which gether_connect() was called
920 * Context: irqs blocked
922 * This is called to deactivate endpoints and let the network layer know
923 * the connection went inactive ("no carrier").
925 * On return, the state is as if gether_connect() had never been called.
926 * The endpoints are inactive, and accordingly without active USB I/O.
927 * Pointers to endpoint descriptors and endpoint private data are nulled.
929 void gether_disconnect(struct gether
*link
)
931 struct eth_dev
*dev
= link
->ioport
;
932 struct usb_request
*req
;
938 DBG(dev
, "%s\n", __func__
);
940 netif_stop_queue(dev
->net
);
941 netif_carrier_off(dev
->net
);
943 /* disable endpoints, forcing (synchronous) completion
944 * of all pending i/o. then free the request objects
945 * and forget about the endpoints.
947 usb_ep_disable(link
->in_ep
);
948 spin_lock(&dev
->req_lock
);
949 while (!list_empty(&dev
->tx_reqs
)) {
950 req
= container_of(dev
->tx_reqs
.next
,
951 struct usb_request
, list
);
952 list_del(&req
->list
);
954 spin_unlock(&dev
->req_lock
);
955 usb_ep_free_request(link
->in_ep
, req
);
956 spin_lock(&dev
->req_lock
);
958 spin_unlock(&dev
->req_lock
);
959 link
->in_ep
->driver_data
= NULL
;
960 link
->in_ep
->desc
= NULL
;
962 usb_ep_disable(link
->out_ep
);
963 spin_lock(&dev
->req_lock
);
964 while (!list_empty(&dev
->rx_reqs
)) {
965 req
= container_of(dev
->rx_reqs
.next
,
966 struct usb_request
, list
);
967 list_del(&req
->list
);
969 spin_unlock(&dev
->req_lock
);
970 usb_ep_free_request(link
->out_ep
, req
);
971 spin_lock(&dev
->req_lock
);
973 spin_unlock(&dev
->req_lock
);
974 link
->out_ep
->driver_data
= NULL
;
975 link
->out_ep
->desc
= NULL
;
977 /* finish forgetting about this USB link episode */
982 spin_lock(&dev
->lock
);
983 dev
->port_usb
= NULL
;
985 spin_unlock(&dev
->lock
);