source: src/linux/universal/linux-3.18/drivers/usb/gadget/function/u_ether.c @ 31869

Last change on this file since 31869 was 31869, checked in by brainslayer, 3 months ago

update

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