drivers/usb/gadget/ether.c

   1 /*
   2  * ether.c -- Ethernet gadget driver, with CDC and non-CDC options
   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  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 #include <common.h>
  24 #include <asm/errno.h>
  25 #include <linux/usb/ch9.h>
  26 #include <linux/usb/cdc.h>
  27 #include <linux/usb/gadget.h>
  28 #include <net.h>
  29 #include <linux/ctype.h>
  30
  31 #include "gadget_chips.h"
  32
  33 #define USB_NET_NAME "usb0"
  34
  35 #define atomic_read
  36 extern struct platform_data brd;
  37 #define spin_lock(x)
  38 #define spin_unlock(x)
  39
  40
  41 unsigned packet_received, packet_sent;
  42
  43 #define DEV_CONFIG_CDC  1
  44 #define GFP_ATOMIC ((gfp_t) 0)
  45 #define GFP_KERNEL ((gfp_t) 0)
  46
  47 /*
  48  * Ethernet gadget driver -- with CDC and non-CDC options
  49  * Builds on hardware support for a full duplex link.
  50  *
  51  * CDC Ethernet is the standard USB solution for sending Ethernet frames
  52  * using USB.  Real hardware tends to use the same framing protocol but look
  53  * different for control features.  This driver strongly prefers to use
  54  * this USB-IF standard as its open-systems interoperability solution;
  55  * most host side USB stacks (except from Microsoft) support it.
  56  *
  57  * This is sometimes called "CDC ECM" (Ethernet Control Model) to support
  58  * TLA-soup.  "CDC ACM" (Abstract Control Model) is for modems, and a new
  59  * "CDC EEM" (Ethernet Emulation Model) is starting to spread.
  60  *
  61  * There's some hardware that can't talk CDC ECM.  We make that hardware
  62  * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
  63  * link-level setup only requires activating the configuration.  Only the
  64  * endpoint descriptors, and product/vendor IDs, are relevant; no control
  65  * operations are available.  Linux supports it, but other host operating
  66  * systems may not.  (This is a subset of CDC Ethernet.)
  67  *
  68  * It turns out that if you add a few descriptors to that "CDC Subset",
  69  * (Windows) host side drivers from MCCI can treat it as one submode of
  70  * a proprietary scheme called "SAFE" ... without needing to know about
  71  * specific product/vendor IDs.  So we do that, making it easier to use
  72  * those MS-Windows drivers.  Those added descriptors make it resemble a
  73  * CDC MDLM device, but they don't change device behavior at all.  (See
  74  * MCCI Engineering report 950198 "SAFE Networking Functions".)
  75  *
  76  * A third option is also in use.  Rather than CDC Ethernet, or something
  77  * simpler, Microsoft pushes their own approach: RNDIS.  The published
  78  * RNDIS specs are ambiguous and appear to be incomplete, and are also
  79  * needlessly complex.  They borrow more from CDC ACM than CDC ECM.
  80  */
  81 #define ETH_ALEN        6               /* Octets in one ethernet addr   */
  82 #define ETH_HLEN        14              /* Total octets in header.       */
  83 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
  84 #define ETH_DATA_LEN    1500            /* Max. octets in payload        */
  85 #define ETH_FRAME_LEN   PKTSIZE_ALIGN   /* Max. octets in frame sans FCS */
  86 #define ETH_FCS_LEN     4               /* Octets in the FCS             */
  87
  88 #define DRIVER_DESC             "Ethernet Gadget"
  89 /* Based on linux 2.6.27 version */
  90 #define DRIVER_VERSION          "May Day 2005"
  91
  92 static const char shortname[] = "ether";
  93 static const char driver_desc[] = DRIVER_DESC;
  94
  95 #define RX_EXTRA        20              /* guard against rx overflows */
  96
  97 /* CDC support the same host-chosen outgoing packet filters. */
  98 #define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
  99                         |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
 100                         |USB_CDC_PACKET_TYPE_PROMISCUOUS \
 101                         |USB_CDC_PACKET_TYPE_DIRECTED)
 102
 103 #define USB_CONNECT_TIMEOUT (3 * CONFIG_SYS_HZ)
 104
 105 /*-------------------------------------------------------------------------*/
 106 static struct eth_dev l_ethdev;
 107 static struct eth_device l_netdev;
 108 static struct usb_gadget_driver eth_driver;
 109
 110 /*-------------------------------------------------------------------------*/
 111
 112 /* "main" config is either CDC, or its simple subset */
 113 static inline int is_cdc(struct eth_dev *dev)
 114 {
 115 #if     !defined(DEV_CONFIG_SUBSET)
 116         return 1;               /* only cdc possible */
 117 #elif   !defined(DEV_CONFIG_CDC)
 118         return 0;               /* only subset possible */
 119 #else
 120         return dev->cdc;        /* depends on what hardware we found */
 121 #endif
 122 }
 123
 124 #define subset_active(dev)      (!is_cdc(dev))
 125 #define cdc_active(dev)         (is_cdc(dev))
 126
 127 #define DEFAULT_QLEN    2       /* double buffering by default */
 128
 129 /* peak bulk transfer bits-per-second */
 130 #define HS_BPS          (13 * 512 * 8 * 1000 * 8)
 131 #define FS_BPS          (19 *  64 * 1 * 1000 * 8)
 132
 133 #ifdef CONFIG_USB_GADGET_DUALSPEED
 134 #define DEVSPEED        USB_SPEED_HIGH
 135
 136 #ifdef CONFIG_USB_ETH_QMULT
 137 #define qmult CONFIG_USB_ETH_QMULT
 138 #else
 139 #define qmult 5
 140 #endif
 141
 142 /* for dual-speed hardware, use deeper queues at highspeed */
 143 #define qlen(gadget) \
 144         (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
 145
 146 static inline int BITRATE(struct usb_gadget *g)
 147 {
 148         return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;
 149 }
 150
 151 #else   /* full speed (low speed doesn't do bulk) */
 152
 153 #define qmult           1
 154
 155 #define DEVSPEED        USB_SPEED_FULL
 156
 157 #define qlen(gadget) DEFAULT_QLEN
 158
 159 static inline int BITRATE(struct usb_gadget *g)
 160 {
 161         return FS_BPS;
 162 }
 163 #endif
 164
 165 struct eth_dev {
 166         struct usb_gadget       *gadget;
 167         struct usb_request      *req;           /* for control responses */
 168         struct usb_request      *stat_req;      /* for cdc status */
 169
 170         u8                      config;
 171         struct usb_ep           *in_ep, *out_ep, *status_ep;
 172         const struct usb_endpoint_descriptor
 173                                 *in, *out, *status;
 174
 175         struct usb_request      *tx_req, *rx_req;
 176
 177         struct eth_device       *net;
 178         unsigned int            tx_qlen;
 179
 180         unsigned                zlp:1;
 181         unsigned                cdc:1;
 182         unsigned                suspended:1;
 183         unsigned                network_started:1;
 184         u16                     cdc_filter;
 185         unsigned long           todo;
 186         int                     mtu;
 187 #define WORK_RX_MEMORY          0
 188         u8                      host_mac[ETH_ALEN];
 189 };
 190
 191 /*
 192  * This version autoconfigures as much as possible at run-time.
 193  *
 194  * It also ASSUMES a self-powered device, without remote wakeup,
 195  * although remote wakeup support would make sense.
 196  */
 197
 198 /*-------------------------------------------------------------------------*/
 199
 200 /*
 201  * DO NOT REUSE THESE IDs with a protocol-incompatible driver!!  Ever!!
 202  * Instead:  allocate your own, using normal USB-IF procedures.
 203  */
 204
 205 /*
 206  * Thanks to NetChip Technologies for donating this product ID.
 207  * It's for devices with only CDC Ethernet configurations.
 208  */
 209 #define CDC_VENDOR_NUM          0x0525  /* NetChip */
 210 #define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
 211
 212 /*
 213  * For hardware that can't talk CDC, we use the same vendor ID that
 214  * ARM Linux has used for ethernet-over-usb, both with sa1100 and
 215  * with pxa250.  We're protocol-compatible, if the host-side drivers
 216  * use the endpoint descriptors.  bcdDevice (version) is nonzero, so
 217  * drivers that need to hard-wire endpoint numbers have a hook.
 218  *
 219  * The protocol is a minimal subset of CDC Ether, which works on any bulk
 220  * hardware that's not deeply broken ... even on hardware that can't talk
 221  * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
 222  * doesn't handle control-OUT).
 223  */
 224 #define SIMPLE_VENDOR_NUM       0x049f
 225 #define SIMPLE_PRODUCT_NUM      0x505a
 226
 227 /*
 228  * Some systems will want different product identifers published in the
 229  * device descriptor, either numbers or strings or both.  These string
 230  * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
 231  */
 232
 233 static ushort bcdDevice;
 234 #if defined(CONFIG_USBNET_MANUFACTURER)
 235 static char *iManufacturer = CONFIG_USBNET_MANUFACTURER;
 236 #else
 237 static char *iManufacturer = "U-boot";
 238 #endif
 239 static char *iProduct;
 240 static char *iSerialNumber;
 241 static char dev_addr[18];
 242 static char host_addr[18];
 243
 244 /*-------------------------------------------------------------------------*/
 245
 246 /*
 247  * USB DRIVER HOOKUP (to the hardware driver, below us), mostly
 248  * ep0 implementation:  descriptors, config management, setup().
 249  * also optional class-specific notification interrupt transfer.
 250  */
 251
 252 /*
 253  * DESCRIPTORS ... most are static, but strings and (full) configuration
 254  * descriptors are built on demand.  For now we do either full CDC, or
 255  * our simple subset.
 256  */
 257
 258 #define STRING_MANUFACTURER             1
 259 #define STRING_PRODUCT                  2
 260 #define STRING_ETHADDR                  3
 261 #define STRING_DATA                     4
 262 #define STRING_CONTROL                  5
 263 #define STRING_CDC                      7
 264 #define STRING_SUBSET                   8
 265 #define STRING_SERIALNUMBER             10
 266
 267 /* holds our biggest descriptor */
 268 #define USB_BUFSIZ      256
 269
 270 /*
 271  * This device advertises one configuration, eth_config,
 272  * on hardware supporting at least two configs.
 273  *
 274  * FIXME define some higher-powered configurations to make it easier
 275  * to recharge batteries ...
 276  */
 277
 278 #define DEV_CONFIG_VALUE        1       /* cdc or subset */
 279
 280 static struct usb_device_descriptor
 281 device_desc = {
 282         .bLength =              sizeof device_desc,
 283         .bDescriptorType =      USB_DT_DEVICE,
 284
 285         .bcdUSB =               __constant_cpu_to_le16(0x0200),
 286
 287         .bDeviceClass =         USB_CLASS_COMM,
 288         .bDeviceSubClass =      0,
 289         .bDeviceProtocol =      0,
 290
 291         .idVendor =             __constant_cpu_to_le16(CDC_VENDOR_NUM),
 292         .idProduct =            __constant_cpu_to_le16(CDC_PRODUCT_NUM),
 293         .iManufacturer =        STRING_MANUFACTURER,
 294         .iProduct =             STRING_PRODUCT,
 295         .bNumConfigurations =   1,
 296 };
 297
 298 static struct usb_otg_descriptor
 299 otg_descriptor = {
 300         .bLength =              sizeof otg_descriptor,
 301         .bDescriptorType =      USB_DT_OTG,
 302
 303         .bmAttributes =         USB_OTG_SRP,
 304 };
 305
 306 static struct usb_config_descriptor
 307 eth_config = {
 308         .bLength =              sizeof eth_config,
 309         .bDescriptorType =      USB_DT_CONFIG,
 310
 311         /* compute wTotalLength on the fly */
 312         .bNumInterfaces =       2,
 313         .bConfigurationValue =  DEV_CONFIG_VALUE,
 314         .iConfiguration =       STRING_CDC,
 315         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 316         .bMaxPower =            1,
 317 };
 318
 319 /*
 320  * Compared to the simple CDC subset, the full CDC Ethernet model adds
 321  * three class descriptors, two interface descriptors, optional status
 322  * endpoint.  Both have a "data" interface and two bulk endpoints.
 323  * There are also differences in how control requests are handled.
 324  */
 325
 326 #ifdef  DEV_CONFIG_CDC
 327 static struct usb_interface_descriptor
 328 control_intf = {
 329         .bLength =              sizeof control_intf,
 330         .bDescriptorType =      USB_DT_INTERFACE,
 331
 332         .bInterfaceNumber =     0,
 333         /* status endpoint is optional; this may be patched later */
 334         .bNumEndpoints =        1,
 335         .bInterfaceClass =      USB_CLASS_COMM,
 336         .bInterfaceSubClass =   USB_CDC_SUBCLASS_ETHERNET,
 337         .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
 338         .iInterface =           STRING_CONTROL,
 339 };
 340 #endif
 341
 342 static const struct usb_cdc_header_desc header_desc = {
 343         .bLength =              sizeof header_desc,
 344         .bDescriptorType =      USB_DT_CS_INTERFACE,
 345         .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
 346
 347         .bcdCDC =               __constant_cpu_to_le16(0x0110),
 348 };
 349
 350 #if defined(DEV_CONFIG_CDC)
 351
 352 static const struct usb_cdc_union_desc union_desc = {
 353         .bLength =              sizeof union_desc,
 354         .bDescriptorType =      USB_DT_CS_INTERFACE,
 355         .bDescriptorSubType =   USB_CDC_UNION_TYPE,
 356
 357         .bMasterInterface0 =    0,      /* index of control interface */
 358         .bSlaveInterface0 =     1,      /* index of DATA interface */
 359 };
 360
 361 #endif  /* CDC */
 362
 363 #ifndef DEV_CONFIG_CDC
 364
 365 /*
 366  * "SAFE" loosely follows CDC WMC MDLM, violating the spec in various
 367  * ways:  data endpoints live in the control interface, there's no data
 368  * interface, and it's not used to talk to a cell phone radio.
 369  */
 370
 371 static const struct usb_cdc_mdlm_desc mdlm_desc = {
 372         .bLength =              sizeof mdlm_desc,
 373         .bDescriptorType =      USB_DT_CS_INTERFACE,
 374         .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
 375
 376         .bcdVersion =           __constant_cpu_to_le16(0x0100),
 377         .bGUID = {
 378                 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
 379                 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
 380         },
 381 };
 382
 383 /*
 384  * since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
 385  * can't really use its struct.  All we do here is say that we're using
 386  * the submode of "SAFE" which directly matches the CDC Subset.
 387  */
 388 static const u8 mdlm_detail_desc[] = {
 389         6,
 390         USB_DT_CS_INTERFACE,
 391         USB_CDC_MDLM_DETAIL_TYPE,
 392
 393         0,      /* "SAFE" */
 394         0,      /* network control capabilities (none) */
 395         0,      /* network data capabilities ("raw" encapsulation) */
 396 };
 397
 398 #endif
 399
 400 static const struct usb_cdc_ether_desc ether_desc = {
 401         .bLength =              sizeof(ether_desc),
 402         .bDescriptorType =      USB_DT_CS_INTERFACE,
 403         .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
 404
 405         /* this descriptor actually adds value, surprise! */
 406         .iMACAddress =          STRING_ETHADDR,
 407         .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
 408         .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
 409         .wNumberMCFilters =     __constant_cpu_to_le16(0),
 410         .bNumberPowerFilters =  0,
 411 };
 412
 413 #if defined(DEV_CONFIG_CDC)
 414
 415 /*
 416  * include the status endpoint if we can, even where it's optional.
 417  * use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
 418  * packet, to simplify cancellation; and a big transfer interval, to
 419  * waste less bandwidth.
 420  *
 421  * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
 422  * if they ignore the connect/disconnect notifications that real aether
 423  * can provide.  more advanced cdc configurations might want to support
 424  * encapsulated commands (vendor-specific, using control-OUT).
 425  */
 426
 427 #define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
 428 #define STATUS_BYTECOUNT                16      /* 8 byte header + data */
 429
 430 static struct usb_endpoint_descriptor
 431 fs_status_desc = {
 432         .bLength =              USB_DT_ENDPOINT_SIZE,
 433         .bDescriptorType =      USB_DT_ENDPOINT,
 434
 435         .bEndpointAddress =     USB_DIR_IN,
 436         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 437         .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
 438         .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
 439 };
 440 #endif
 441
 442 #ifdef  DEV_CONFIG_CDC
 443
 444 /* the default data interface has no endpoints ... */
 445
 446 static const struct usb_interface_descriptor
 447 data_nop_intf = {
 448         .bLength =              sizeof data_nop_intf,
 449         .bDescriptorType =      USB_DT_INTERFACE,
 450
 451         .bInterfaceNumber =     1,
 452         .bAlternateSetting =    0,
 453         .bNumEndpoints =        0,
 454         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 455         .bInterfaceSubClass =   0,
 456         .bInterfaceProtocol =   0,
 457 };
 458
 459 /* ... but the "real" data interface has two bulk endpoints */
 460
 461 static const struct usb_interface_descriptor
 462 data_intf = {
 463         .bLength =              sizeof data_intf,
 464         .bDescriptorType =      USB_DT_INTERFACE,
 465
 466         .bInterfaceNumber =     1,
 467         .bAlternateSetting =    1,
 468         .bNumEndpoints =        2,
 469         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 470         .bInterfaceSubClass =   0,
 471         .bInterfaceProtocol =   0,
 472         .iInterface =           STRING_DATA,
 473 };
 474
 475 #endif
 476
 477 #ifdef DEV_CONFIG_SUBSET
 478
 479 /*
 480  * "Simple" CDC-subset option is a simple vendor-neutral model that most
 481  * full speed controllers can handle:  one interface, two bulk endpoints.
 482  *
 483  * To assist host side drivers, we fancy it up a bit, and add descriptors
 484  * so some host side drivers will understand it as a "SAFE" variant.
 485  */
 486
 487 static const struct usb_interface_descriptor
 488 subset_data_intf = {
 489         .bLength =              sizeof subset_data_intf,
 490         .bDescriptorType =      USB_DT_INTERFACE,
 491
 492         .bInterfaceNumber =     0,
 493         .bAlternateSetting =    0,
 494         .bNumEndpoints =        2,
 495         .bInterfaceClass =      USB_CLASS_COMM,
 496         .bInterfaceSubClass =   USB_CDC_SUBCLASS_MDLM,
 497         .bInterfaceProtocol =   0,
 498         .iInterface =           STRING_DATA,
 499 };
 500
 501 #endif  /* SUBSET */
 502
 503 static struct usb_endpoint_descriptor
 504 fs_source_desc = {
 505         .bLength =              USB_DT_ENDPOINT_SIZE,
 506         .bDescriptorType =      USB_DT_ENDPOINT,
 507
 508         .bEndpointAddress =     USB_DIR_IN,
 509         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 510 };
 511
 512 static struct usb_endpoint_descriptor
 513 fs_sink_desc = {
 514         .bLength =              USB_DT_ENDPOINT_SIZE,
 515         .bDescriptorType =      USB_DT_ENDPOINT,
 516
 517         .bEndpointAddress =     USB_DIR_OUT,
 518         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 519 };
 520
 521 static const struct usb_descriptor_header *fs_eth_function[11] = {
 522         (struct usb_descriptor_header *) &otg_descriptor,
 523 #ifdef DEV_CONFIG_CDC
 524         /* "cdc" mode descriptors */
 525         (struct usb_descriptor_header *) &control_intf,
 526         (struct usb_descriptor_header *) &header_desc,
 527         (struct usb_descriptor_header *) &union_desc,
 528         (struct usb_descriptor_header *) &ether_desc,
 529         /* NOTE: status endpoint may need to be removed */
 530         (struct usb_descriptor_header *) &fs_status_desc,
 531         /* data interface, with altsetting */
 532         (struct usb_descriptor_header *) &data_nop_intf,
 533         (struct usb_descriptor_header *) &data_intf,
 534         (struct usb_descriptor_header *) &fs_source_desc,
 535         (struct usb_descriptor_header *) &fs_sink_desc,
 536         NULL,
 537 #endif /* DEV_CONFIG_CDC */
 538 };
 539
 540 static inline void fs_subset_descriptors(void)
 541 {
 542 #ifdef DEV_CONFIG_SUBSET
 543         /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
 544         fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
 545         fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
 546         fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
 547         fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
 548         fs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
 549         fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;
 550         fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;
 551         fs_eth_function[8] = NULL;
 552 #else
 553         fs_eth_function[1] = NULL;
 554 #endif
 555 }
 556
 557 /*
 558  * usb 2.0 devices need to expose both high speed and full speed
 559  * descriptors, unless they only run at full speed.
 560  */
 561
 562 #if defined(DEV_CONFIG_CDC)
 563 static struct usb_endpoint_descriptor
 564 hs_status_desc = {
 565         .bLength =              USB_DT_ENDPOINT_SIZE,
 566         .bDescriptorType =      USB_DT_ENDPOINT,
 567
 568         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 569         .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
 570         .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
 571 };
 572 #endif /* DEV_CONFIG_CDC */
 573
 574 static struct usb_endpoint_descriptor
 575 hs_source_desc = {
 576         .bLength =              USB_DT_ENDPOINT_SIZE,
 577         .bDescriptorType =      USB_DT_ENDPOINT,
 578
 579         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 580         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 581 };
 582
 583 static struct usb_endpoint_descriptor
 584 hs_sink_desc = {
 585         .bLength =              USB_DT_ENDPOINT_SIZE,
 586         .bDescriptorType =      USB_DT_ENDPOINT,
 587
 588         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 589         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 590 };
 591
 592 static struct usb_qualifier_descriptor
 593 dev_qualifier = {
 594         .bLength =              sizeof dev_qualifier,
 595         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 596
 597         .bcdUSB =               __constant_cpu_to_le16(0x0200),
 598         .bDeviceClass =         USB_CLASS_COMM,
 599
 600         .bNumConfigurations =   1,
 601 };
 602
 603 static const struct usb_descriptor_header *hs_eth_function[11] = {
 604         (struct usb_descriptor_header *) &otg_descriptor,
 605 #ifdef DEV_CONFIG_CDC
 606         /* "cdc" mode descriptors */
 607         (struct usb_descriptor_header *) &control_intf,
 608         (struct usb_descriptor_header *) &header_desc,
 609         (struct usb_descriptor_header *) &union_desc,
 610         (struct usb_descriptor_header *) &ether_desc,
 611         /* NOTE: status endpoint may need to be removed */
 612         (struct usb_descriptor_header *) &hs_status_desc,
 613         /* data interface, with altsetting */
 614         (struct usb_descriptor_header *) &data_nop_intf,
 615         (struct usb_descriptor_header *) &data_intf,
 616         (struct usb_descriptor_header *) &hs_source_desc,
 617         (struct usb_descriptor_header *) &hs_sink_desc,
 618         NULL,
 619 #endif /* DEV_CONFIG_CDC */
 620 };
 621
 622 static inline void hs_subset_descriptors(void)
 623 {
 624 #ifdef DEV_CONFIG_SUBSET
 625         /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
 626         hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
 627         hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
 628         hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
 629         hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
 630         hs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
 631         hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;
 632         hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;
 633         hs_eth_function[8] = NULL;
 634 #else
 635         hs_eth_function[1] = NULL;
 636 #endif
 637 }
 638
 639 /* maxpacket and other transfer characteristics vary by speed. */
 640 static inline struct usb_endpoint_descriptor *
 641 ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
 642                 struct usb_endpoint_descriptor *fs)
 643 {
 644         if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
 645                 return hs;
 646         return fs;
 647 }
 648
 649 /*-------------------------------------------------------------------------*/
 650
 651 /* descriptors that are built on-demand */
 652
 653 static char manufacturer[50];
 654 static char product_desc[40] = DRIVER_DESC;
 655 static char serial_number[20];
 656
 657 /* address that the host will use ... usually assigned at random */
 658 static char ethaddr[2 * ETH_ALEN + 1];
 659
 660 /* static strings, in UTF-8 */
 661 static struct usb_string                strings[] = {
 662         { STRING_MANUFACTURER,  manufacturer, },
 663         { STRING_PRODUCT,       product_desc, },
 664         { STRING_SERIALNUMBER,  serial_number, },
 665         { STRING_DATA,          "Ethernet Data", },
 666         { STRING_ETHADDR,       ethaddr, },
 667 #ifdef  DEV_CONFIG_CDC
 668         { STRING_CDC,           "CDC Ethernet", },
 669         { STRING_CONTROL,       "CDC Communications Control", },
 670 #endif
 671 #ifdef  DEV_CONFIG_SUBSET
 672         { STRING_SUBSET,        "CDC Ethernet Subset", },
 673 #endif
 674         {  }            /* end of list */
 675 };
 676
 677 static struct usb_gadget_strings        stringtab = {
 678         .language       = 0x0409,       /* en-us */
 679         .strings        = strings,
 680 };
 681
 682 /*============================================================================*/
 683 static u8 control_req[USB_BUFSIZ];
 684 static u8 status_req[STATUS_BYTECOUNT] __attribute__ ((aligned(4)));
 685
 686
 687 /**
 688  * strlcpy - Copy a %NUL terminated string into a sized buffer
 689  * @dest: Where to copy the string to
 690  * @src: Where to copy the string from
 691  * @size: size of destination buffer
 692  *
 693  * Compatible with *BSD: the result is always a valid
 694  * NUL-terminated string that fits in the buffer (unless,
 695  * of course, the buffer size is zero). It does not pad
 696  * out the result like strncpy() does.
 697  */
 698 size_t strlcpy(char *dest, const char *src, size_t size)
 699 {
 700         size_t ret = strlen(src);
 701
 702         if (size) {
 703                 size_t len = (ret >= size) ? size - 1 : ret;
 704                 memcpy(dest, src, len);
 705                 dest[len] = '\0';
 706         }
 707         return ret;
 708 }
 709
 710 /*============================================================================*/
 711
 712 /*
 713  * one config, two interfaces:  control, data.
 714  * complications: class descriptors, and an altsetting.
 715  */
 716 static int
 717 config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
 718 {
 719         int                                     len;
 720         const struct usb_config_descriptor      *config;
 721         const struct usb_descriptor_header      **function;
 722         int                                     hs = 0;
 723
 724         if (gadget_is_dualspeed(g)) {
 725                 hs = (g->speed == USB_SPEED_HIGH);
 726                 if (type == USB_DT_OTHER_SPEED_CONFIG)
 727                         hs = !hs;
 728         }
 729 #define which_fn(t)     (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
 730
 731         if (index >= device_desc.bNumConfigurations)
 732                 return -EINVAL;
 733
 734         config = &eth_config;
 735         function = which_fn(eth);
 736
 737         /* for now, don't advertise srp-only devices */
 738         if (!is_otg)
 739                 function++;
 740
 741         len = usb_gadget_config_buf(config, buf, USB_BUFSIZ, function);
 742         if (len < 0)
 743                 return len;
 744         ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
 745         return len;
 746 }
 747
 748 /*-------------------------------------------------------------------------*/
 749
 750 static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
 751
 752 static int
 753 set_ether_config(struct eth_dev *dev, gfp_t gfp_flags)
 754 {
 755         int                                     result = 0;
 756         struct usb_gadget                       *gadget = dev->gadget;
 757
 758 #if defined(DEV_CONFIG_CDC)
 759         /* status endpoint used for (optionally) CDC */
 760         if (!subset_active(dev) && dev->status_ep) {
 761                 dev->status = ep_desc(gadget, &hs_status_desc,
 762                                                 &fs_status_desc);
 763                 dev->status_ep->driver_data = dev;
 764
 765                 result = usb_ep_enable(dev->status_ep, dev->status);
 766                 if (result != 0) {
 767                         debug("enable %s --> %d\n",
 768                                 dev->status_ep->name, result);
 769                         goto done;
 770                 }
 771         }
 772 #endif
 773
 774         dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
 775         dev->in_ep->driver_data = dev;
 776
 777         dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
 778         dev->out_ep->driver_data = dev;
 779
 780         /*
 781          * With CDC,  the host isn't allowed to use these two data
 782          * endpoints in the default altsetting for the interface.
 783          * so we don't activate them yet.  Reset from SET_INTERFACE.
 784          */
 785         if (!cdc_active(dev)) {
 786                 result = usb_ep_enable(dev->in_ep, dev->in);
 787                 if (result != 0) {
 788                         debug("enable %s --> %d\n",
 789                                 dev->in_ep->name, result);
 790                         goto done;
 791                 }
 792
 793                 result = usb_ep_enable(dev->out_ep, dev->out);
 794                 if (result != 0) {
 795                         debug("enable %s --> %d\n",
 796                                 dev->out_ep->name, result);
 797                         goto done;
 798                 }
 799         }
 800
 801 done:
 802         if (result == 0)
 803                 result = alloc_requests(dev, qlen(gadget), gfp_flags);
 804
 805         /* on error, disable any endpoints  */
 806         if (result < 0) {
 807                 if (!subset_active(dev) && dev->status_ep)
 808                         (void) usb_ep_disable(dev->status_ep);
 809                 dev->status = NULL;
 810                 (void) usb_ep_disable(dev->in_ep);
 811                 (void) usb_ep_disable(dev->out_ep);
 812                 dev->in = NULL;
 813                 dev->out = NULL;
 814         }
 815
 816         /* caller is responsible for cleanup on error */
 817         return result;
 818 }
 819
 820 static void eth_reset_config(struct eth_dev *dev)
 821 {
 822         if (dev->config == 0)
 823                 return;
 824
 825         debug("%s\n", __func__);
 826
 827         /*
 828          * disable endpoints, forcing (synchronous) completion of
 829          * pending i/o.  then free the requests.
 830          */
 831
 832         if (dev->in) {
 833                 usb_ep_disable(dev->in_ep);
 834                 if (dev->tx_req) {
 835                         usb_ep_free_request(dev->in_ep, dev->tx_req);
 836                         dev->tx_req = NULL;
 837                 }
 838         }
 839         if (dev->out) {
 840                 usb_ep_disable(dev->out_ep);
 841                 if (dev->rx_req) {
 842                         usb_ep_free_request(dev->out_ep, dev->rx_req);
 843                         dev->rx_req = NULL;
 844                 }
 845         }
 846         if (dev->status)
 847                 usb_ep_disable(dev->status_ep);
 848
 849         dev->cdc_filter = 0;
 850         dev->config = 0;
 851 }
 852
 853 /*
 854  * change our operational config.  must agree with the code
 855  * that returns config descriptors, and altsetting code.
 856  */
 857 static int eth_set_config(struct eth_dev *dev, unsigned number,
 858                                 gfp_t gfp_flags)
 859 {
 860         int                     result = 0;
 861         struct usb_gadget       *gadget = dev->gadget;
 862
 863         if (gadget_is_sa1100(gadget)
 864                         && dev->config
 865                         && dev->tx_qlen != 0) {
 866                 /* tx fifo is full, but we can't clear it...*/
 867                 error("can't change configurations");
 868                 return -ESPIPE;
 869         }
 870         eth_reset_config(dev);
 871
 872         switch (number) {
 873         case DEV_CONFIG_VALUE:
 874                 result = set_ether_config(dev, gfp_flags);
 875                 break;
 876         default:
 877                 result = -EINVAL;
 878                 /* FALL THROUGH */
 879         case 0:
 880                 break;
 881         }
 882
 883         if (result) {
 884                 if (number)
 885                         eth_reset_config(dev);
 886                 usb_gadget_vbus_draw(dev->gadget,
 887                                 gadget_is_otg(dev->gadget) ? 8 : 100);
 888         } else {
 889                 char *speed;
 890                 unsigned power;
 891
 892                 power = 2 * eth_config.bMaxPower;
 893                 usb_gadget_vbus_draw(dev->gadget, power);
 894
 895                 switch (gadget->speed) {
 896                 case USB_SPEED_FULL:
 897                         speed = "full"; break;
 898 #ifdef CONFIG_USB_GADGET_DUALSPEED
 899                 case USB_SPEED_HIGH:
 900                         speed = "high"; break;
 901 #endif
 902                 default:
 903                         speed = "?"; break;
 904                 }
 905
 906                 dev->config = number;
 907                 printf("%s speed config #%d: %d mA, %s, using %s\n",
 908                                 speed, number, power, driver_desc,
 909                                 (cdc_active(dev) ? "CDC Ethernet"
 910                                                 : "CDC Ethernet Subset"));
 911         }
 912         return result;
 913 }
 914
 915 /*-------------------------------------------------------------------------*/
 916
 917 #ifdef  DEV_CONFIG_CDC
 918
 919 /*
 920  * The interrupt endpoint is used in CDC networking models (Ethernet, ATM)
 921  * only to notify the host about link status changes (which we support) or
 922  * report completion of some encapsulated command.  Since
 923  * we want this CDC Ethernet code to be vendor-neutral, we don't use that
 924  * command mechanism; and only one status request is ever queued.
 925  */
 926 static void eth_status_complete(struct usb_ep *ep, struct usb_request *req)
 927 {
 928         struct usb_cdc_notification     *event = req->buf;
 929         int                             value = req->status;
 930         struct eth_dev                  *dev = ep->driver_data;
 931
 932         /* issue the second notification if host reads the first */
 933         if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION
 934                         && value == 0) {
 935                 __le32  *data = req->buf + sizeof *event;
 936
 937                 event->bmRequestType = 0xA1;
 938                 event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
 939                 event->wValue = __constant_cpu_to_le16(0);
 940                 event->wIndex = __constant_cpu_to_le16(1);
 941                 event->wLength = __constant_cpu_to_le16(8);
 942
 943                 /* SPEED_CHANGE data is up/down speeds in bits/sec */
 944                 data[0] = data[1] = cpu_to_le32(BITRATE(dev->gadget));
 945
 946                 req->length = STATUS_BYTECOUNT;
 947                 value = usb_ep_queue(ep, req, GFP_ATOMIC);
 948                 debug("send SPEED_CHANGE --> %d\n", value);
 949                 if (value == 0)
 950                         return;
 951         } else if (value != -ECONNRESET) {
 952                 debug("event %02x --> %d\n",
 953                         event->bNotificationType, value);
 954                 if (event->bNotificationType ==
 955                                 USB_CDC_NOTIFY_SPEED_CHANGE) {
 956                         l_ethdev.network_started = 1;
 957                         printf("USB network up!\n");
 958                 }
 959         }
 960         req->context = NULL;
 961 }
 962
 963 static void issue_start_status(struct eth_dev *dev)
 964 {
 965         struct usb_request              *req = dev->stat_req;
 966         struct usb_cdc_notification     *event;
 967         int                             value;
 968
 969         /*
 970          * flush old status
 971          *
 972          * FIXME ugly idiom, maybe we'd be better with just
 973          * a "cancel the whole queue" primitive since any
 974          * unlink-one primitive has way too many error modes.
 975          * here, we "know" toggle is already clear...
 976          *
 977          * FIXME iff req->context != null just dequeue it
 978          */
 979         usb_ep_disable(dev->status_ep);
 980         usb_ep_enable(dev->status_ep, dev->status);
 981
 982         /*
 983          * 3.8.1 says to issue first NETWORK_CONNECTION, then
 984          * a SPEED_CHANGE.  could be useful in some configs.
 985          */
 986         event = req->buf;
 987         event->bmRequestType = 0xA1;
 988         event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
 989         event->wValue = __constant_cpu_to_le16(1);      /* connected */
 990         event->wIndex = __constant_cpu_to_le16(1);
 991         event->wLength = 0;
 992
 993         req->length = sizeof *event;
 994         req->complete = eth_status_complete;
 995         req->context = dev;
 996
 997         value = usb_ep_queue(dev->status_ep, req, GFP_ATOMIC);
 998         if (value < 0)
 999                 debug("status buf queue --> %d\n", value);
1000 }
1001
1002 #endif
1003
1004 /*-------------------------------------------------------------------------*/
1005
1006 static void eth_setup_complete(struct usb_ep *ep, struct usb_request *req)
1007 {
1008         if (req->status || req->actual != req->length)
1009                 debug("setup complete --> %d, %d/%d\n",
1010                                 req->status, req->actual, req->length);
1011 }
1012
1013 /*
1014  * The setup() callback implements all the ep0 functionality that's not
1015  * handled lower down.  CDC has a number of less-common features:
1016  *
1017  *  - two interfaces:  control, and ethernet data
1018  *  - Ethernet data interface has two altsettings:  default, and active
1019  *  - class-specific descriptors for the control interface
1020  *  - class-specific control requests
1021  */
1022 static int
1023 eth_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1024 {
1025         struct eth_dev          *dev = get_gadget_data(gadget);
1026         struct usb_request      *req = dev->req;
1027         int                     value = -EOPNOTSUPP;
1028         u16                     wIndex = le16_to_cpu(ctrl->wIndex);
1029         u16                     wValue = le16_to_cpu(ctrl->wValue);
1030         u16                     wLength = le16_to_cpu(ctrl->wLength);
1031
1032         /*
1033          * descriptors just go into the pre-allocated ep0 buffer,
1034          * while config change events may enable network traffic.
1035          */
1036
1037         debug("%s\n", __func__);
1038
1039         req->complete = eth_setup_complete;
1040         switch (ctrl->bRequest) {
1041
1042         case USB_REQ_GET_DESCRIPTOR:
1043                 if (ctrl->bRequestType != USB_DIR_IN)
1044                         break;
1045                 switch (wValue >> 8) {
1046
1047                 case USB_DT_DEVICE:
1048                         value = min(wLength, (u16) sizeof device_desc);
1049                         memcpy(req->buf, &device_desc, value);
1050                         break;
1051                 case USB_DT_DEVICE_QUALIFIER:
1052                         if (!gadget_is_dualspeed(gadget))
1053                                 break;
1054                         value = min(wLength, (u16) sizeof dev_qualifier);
1055                         memcpy(req->buf, &dev_qualifier, value);
1056                         break;
1057
1058                 case USB_DT_OTHER_SPEED_CONFIG:
1059                         if (!gadget_is_dualspeed(gadget))
1060                                 break;
1061                         /* FALLTHROUGH */
1062                 case USB_DT_CONFIG:
1063                         value = config_buf(gadget, req->buf,
1064                                         wValue >> 8,
1065                                         wValue & 0xff,
1066                                         gadget_is_otg(gadget));
1067                         if (value >= 0)
1068                                 value = min(wLength, (u16) value);
1069                         break;
1070
1071                 case USB_DT_STRING:
1072                         value = usb_gadget_get_string(&stringtab,
1073                                         wValue & 0xff, req->buf);
1074
1075                         if (value >= 0)
1076                                 value = min(wLength, (u16) value);
1077
1078                         break;
1079                 }
1080                 break;
1081
1082         case USB_REQ_SET_CONFIGURATION:
1083                 if (ctrl->bRequestType != 0)
1084                         break;
1085                 if (gadget->a_hnp_support)
1086                         debug("HNP available\n");
1087                 else if (gadget->a_alt_hnp_support)
1088                         debug("HNP needs a different root port\n");
1089                 value = eth_set_config(dev, wValue, GFP_ATOMIC);
1090                 break;
1091         case USB_REQ_GET_CONFIGURATION:
1092                 if (ctrl->bRequestType != USB_DIR_IN)
1093                         break;
1094                 *(u8 *)req->buf = dev->config;
1095                 value = min(wLength, (u16) 1);
1096                 break;
1097
1098         case USB_REQ_SET_INTERFACE:
1099                 if (ctrl->bRequestType != USB_RECIP_INTERFACE
1100                                 || !dev->config
1101                                 || wIndex > 1)
1102                         break;
1103                 if (!cdc_active(dev) && wIndex != 0)
1104                         break;
1105
1106                 /*
1107                  * PXA hardware partially handles SET_INTERFACE;
1108                  * we need to kluge around that interference.
1109                  */
1110                 if (gadget_is_pxa(gadget)) {
1111                         value = eth_set_config(dev, DEV_CONFIG_VALUE,
1112                                                 GFP_ATOMIC);
1113                         goto done_set_intf;
1114                 }
1115
1116 #ifdef DEV_CONFIG_CDC
1117                 switch (wIndex) {
1118                 case 0:         /* control/master intf */
1119                         if (wValue != 0)
1120                                 break;
1121                         if (dev->status) {
1122                                 usb_ep_disable(dev->status_ep);
1123                                 usb_ep_enable(dev->status_ep, dev->status);
1124                         }
1125                         value = 0;
1126                         break;
1127                 case 1:         /* data intf */
1128                         if (wValue > 1)
1129                                 break;
1130                         usb_ep_disable(dev->in_ep);
1131                         usb_ep_disable(dev->out_ep);
1132
1133                         /*
1134                          * CDC requires the data transfers not be done from
1135                          * the default interface setting ... also, setting
1136                          * the non-default interface resets filters etc.
1137                          */
1138                         if (wValue == 1) {
1139                                 if (!cdc_active(dev))
1140                                         break;
1141                                 usb_ep_enable(dev->in_ep, dev->in);
1142                                 usb_ep_enable(dev->out_ep, dev->out);
1143                                 dev->cdc_filter = DEFAULT_FILTER;
1144                                 if (dev->status)
1145                                         issue_start_status(dev);
1146                         }
1147
1148                         value = 0;
1149                         break;
1150                 }
1151 #else
1152                 /*
1153                  * FIXME this is wrong, as is the assumption that
1154                  * all non-PXA hardware talks real CDC ...
1155                  */
1156                 debug("set_interface ignored!\n");
1157 #endif /* DEV_CONFIG_CDC */
1158
1159 done_set_intf:
1160                 break;
1161         case USB_REQ_GET_INTERFACE:
1162                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
1163                                 || !dev->config
1164                                 || wIndex > 1)
1165                         break;
1166                 if (!(cdc_active(dev)) && wIndex != 0)
1167                         break;
1168
1169                 /* for CDC, iff carrier is on, data interface is active. */
1170                 if (wIndex != 1)
1171                         *(u8 *)req->buf = 0;
1172                 else {
1173                         /* *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0; */
1174                         /* carrier always ok ...*/
1175                         *(u8 *)req->buf = 1 ;
1176                 }
1177                 value = min(wLength, (u16) 1);
1178                 break;
1179
1180 #ifdef DEV_CONFIG_CDC
1181         case USB_CDC_SET_ETHERNET_PACKET_FILTER:
1182                 /*
1183                  * see 6.2.30: no data, wIndex = interface,
1184                  * wValue = packet filter bitmap
1185                  */
1186                 if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1187                                 || !cdc_active(dev)
1188                                 || wLength != 0
1189                                 || wIndex > 1)
1190                         break;
1191                 debug("packet filter %02x\n", wValue);
1192                 dev->cdc_filter = wValue;
1193                 value = 0;
1194                 break;
1195
1196         /*
1197          * and potentially:
1198          * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
1199          * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
1200          * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
1201          * case USB_CDC_GET_ETHERNET_STATISTIC:
1202          */
1203
1204 #endif /* DEV_CONFIG_CDC */
1205
1206         default:
1207                 debug("unknown control req%02x.%02x v%04x i%04x l%d\n",
1208                         ctrl->bRequestType, ctrl->bRequest,
1209                         wValue, wIndex, wLength);
1210         }
1211
1212         /* respond with data transfer before status phase? */
1213         if (value >= 0) {
1214                 debug("respond with data transfer before status phase\n");
1215                 req->length = value;
1216                 req->zero = value < wLength
1217                                 && (value % gadget->ep0->maxpacket) == 0;
1218                 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1219                 if (value < 0) {
1220                         debug("ep_queue --> %d\n", value);
1221                         req->status = 0;
1222                         eth_setup_complete(gadget->ep0, req);
1223                 }
1224         }
1225
1226         /* host either stalls (value < 0) or reports success */
1227         return value;
1228 }
1229
1230 /*-------------------------------------------------------------------------*/
1231
1232 static void rx_complete(struct usb_ep *ep, struct usb_request *req);
1233
1234 static int rx_submit(struct eth_dev *dev, struct usb_request *req,
1235                                 gfp_t gfp_flags)
1236 {
1237         int                     retval = -ENOMEM;
1238         size_t                  size;
1239
1240         /*
1241          * Padding up to RX_EXTRA handles minor disagreements with host.
1242          * Normally we use the USB "terminate on short read" convention;
1243          * so allow up to (N*maxpacket), since that memory is normally
1244          * already allocated.  Some hardware doesn't deal well with short
1245          * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
1246          * byte off the end (to force hardware errors on overflow).
1247          */
1248
1249         debug("%s\n", __func__);
1250
1251         size = (ETHER_HDR_SIZE + dev->mtu + RX_EXTRA);
1252         size += dev->out_ep->maxpacket - 1;
1253         size -= size % dev->out_ep->maxpacket;
1254
1255         /*
1256          * Some platforms perform better when IP packets are aligned,
1257          * but on at least one, checksumming fails otherwise.
1258          */
1259
1260         req->buf = (u8 *) NetRxPackets[0];
1261         req->length = size;
1262         req->complete = rx_complete;
1263
1264         retval = usb_ep_queue(dev->out_ep, req, gfp_flags);
1265
1266         if (retval)
1267                 error("rx submit --> %d", retval);
1268
1269         return retval;
1270 }
1271
1272 static void rx_complete(struct usb_ep *ep, struct usb_request *req)
1273 {
1274         struct eth_dev  *dev = ep->driver_data;
1275
1276         debug("%s: status %d\n", __func__, req->status);
1277
1278         packet_received = 1;
1279 }
1280
1281 static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
1282 {
1283
1284         dev->tx_req = usb_ep_alloc_request(dev->in_ep, 0);
1285
1286         if (!dev->tx_req)
1287                 goto fail1;
1288
1289         dev->rx_req = usb_ep_alloc_request(dev->out_ep, 0);
1290
1291         if (!dev->rx_req)
1292                 goto fail2;
1293
1294         return 0;
1295
1296 fail2:
1297         usb_ep_free_request(dev->in_ep, dev->tx_req);
1298 fail1:
1299         error("can't alloc requests");
1300         return -1;
1301 }
1302
1303 static void tx_complete(struct usb_ep *ep, struct usb_request *req)
1304 {
1305         debug("%s: status %s\n", __func__, (req->status) ? "failed" : "ok");
1306         packet_sent = 1;
1307 }
1308
1309 static inline int eth_is_promisc(struct eth_dev *dev)
1310 {
1311         /* no filters for the CDC subset; always promisc */
1312         if (subset_active(dev))
1313                 return 1;
1314         return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
1315 }
1316
1317 #if 0
1318 static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
1319 {
1320         struct eth_dev          *dev = netdev_priv(net);
1321         int                     length = skb->len;
1322         int                     retval;
1323         struct usb_request      *req = NULL;
1324         unsigned long           flags;
1325
1326         /* apply outgoing CDC or RNDIS filters */
1327         if (!eth_is_promisc (dev)) {
1328                 u8              *dest = skb->data;
1329
1330                 if (is_multicast_ether_addr(dest)) {
1331                         u16     type;
1332
1333                         /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
1334                          * SET_ETHERNET_MULTICAST_FILTERS requests
1335                          */
1336                         if (is_broadcast_ether_addr(dest))
1337                                 type = USB_CDC_PACKET_TYPE_BROADCAST;
1338                         else
1339                                 type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
1340                         if (!(dev->cdc_filter & type)) {
1341                                 dev_kfree_skb_any (skb);
1342                                 return 0;
1343                         }
1344                 }
1345                 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
1346         }
1347
1348         spin_lock_irqsave(&dev->req_lock, flags);
1349         /*
1350          * this freelist can be empty if an interrupt triggered disconnect()
1351          * and reconfigured the gadget (shutting down this queue) after the
1352          * network stack decided to xmit but before we got the spinlock.
1353          */
1354         if (list_empty(&dev->tx_reqs)) {
1355                 spin_unlock_irqrestore(&dev->req_lock, flags);
1356                 return 1;
1357         }
1358
1359         req = container_of (dev->tx_reqs.next, struct usb_request, list);
1360         list_del (&req->list);
1361
1362         /* temporarily stop TX queue when the freelist empties */
1363         if (list_empty (&dev->tx_reqs))
1364                 netif_stop_queue (net);
1365         spin_unlock_irqrestore(&dev->req_lock, flags);
1366
1367         /* no buffer copies needed, unless the network stack did it
1368          * or the hardware can't use skb buffers.
1369          * or there's not enough space for any RNDIS headers we need
1370          */
1371         if (rndis_active(dev)) {
1372                 struct sk_buff  *skb_rndis;
1373
1374                 skb_rndis = skb_realloc_headroom (skb,
1375                                 sizeof (struct rndis_packet_msg_type));
1376                 if (!skb_rndis)
1377                         goto drop;
1378
1379                 dev_kfree_skb_any (skb);
1380                 skb = skb_rndis;
1381                 rndis_add_hdr (skb);
1382                 length = skb->len;
1383         }
1384         req->buf = skb->data;
1385         req->context = skb;
1386         req->complete = tx_complete;
1387
1388         /* use zlp framing on tx for strict CDC-Ether conformance,
1389          * though any robust network rx path ignores extra padding.
1390          * and some hardware doesn't like to write zlps.
1391          */
1392         req->zero = 1;
1393         if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
1394                 length++;
1395
1396         req->length = length;
1397
1398         /* throttle highspeed IRQ rate back slightly */
1399         if (gadget_is_dualspeed(dev->gadget))
1400                 req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
1401                         ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
1402                         : 0;
1403
1404         retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
1405         switch (retval) {
1406         default:
1407                 DEBUG (dev, "tx queue err %d\n", retval);
1408                 break;
1409         case 0:
1410                 net->trans_start = jiffies;
1411                 atomic_inc (&dev->tx_qlen);
1412         }
1413
1414         if (retval) {
1415 drop:
1416                 dev->stats.tx_dropped++;
1417                 dev_kfree_skb_any (skb);
1418                 spin_lock_irqsave(&dev->req_lock, flags);
1419                 if (list_empty (&dev->tx_reqs))
1420                         netif_start_queue (net);
1421                 list_add (&req->list, &dev->tx_reqs);
1422                 spin_unlock_irqrestore(&dev->req_lock, flags);
1423         }
1424         return 0;
1425 }
1426
1427 /*-------------------------------------------------------------------------*/
1428 #endif
1429
1430 static void eth_unbind(struct usb_gadget *gadget)
1431 {
1432         struct eth_dev *dev = get_gadget_data(gadget);
1433
1434         debug("%s...\n", __func__);
1435
1436         /* we've already been disconnected ... no i/o is active */
1437         if (dev->req) {
1438                 usb_ep_free_request(gadget->ep0, dev->req);
1439                 dev->req = NULL;
1440         }
1441         if (dev->stat_req) {
1442                 usb_ep_free_request(dev->status_ep, dev->stat_req);
1443                 dev->stat_req = NULL;
1444         }
1445
1446         if (dev->tx_req) {
1447                 usb_ep_free_request(dev->in_ep, dev->tx_req);
1448                 dev->tx_req = NULL;
1449         }
1450
1451         if (dev->rx_req) {
1452                 usb_ep_free_request(dev->out_ep, dev->rx_req);
1453                 dev->rx_req = NULL;
1454         }
1455
1456 /*      unregister_netdev (dev->net);*/
1457 /*      free_netdev(dev->net);*/
1458
1459         set_gadget_data(gadget, NULL);
1460 }
1461
1462 static void eth_disconnect(struct usb_gadget *gadget)
1463 {
1464         eth_reset_config(get_gadget_data(gadget));
1465 }
1466
1467 static void eth_suspend(struct usb_gadget *gadget)
1468 {
1469         /* Not used */
1470 }
1471
1472 static void eth_resume(struct usb_gadget *gadget)
1473 {
1474         /* Not used */
1475 }
1476
1477 /*-------------------------------------------------------------------------*/
1478
1479 static int is_eth_addr_valid(char *str)
1480 {
1481         if (strlen(str) == 17) {
1482                 int i;
1483                 char *p, *q;
1484                 uchar ea[6];
1485
1486                 /* see if it looks like an ethernet address */
1487
1488                 p = str;
1489
1490                 for (i = 0; i < 6; i++) {
1491                         char term = (i == 5 ? '\0' : ':');
1492
1493                         ea[i] = simple_strtol(p, &q, 16);
1494
1495                         if ((q - p) != 2 || *q++ != term)
1496                                 break;
1497
1498                         p = q;
1499                 }
1500
1501                 if (i == 6) /* it looks ok */
1502                         return 1;
1503         }
1504         return 0;
1505 }
1506
1507 static u8 nibble(unsigned char c)
1508 {
1509         if (likely(isdigit(c)))
1510                 return c - '0';
1511         c = toupper(c);
1512         if (likely(isxdigit(c)))
1513                 return 10 + c - 'A';
1514         return 0;
1515 }
1516
1517 static int get_ether_addr(const char *str, u8 *dev_addr)
1518 {
1519         if (str) {
1520                 unsigned        i;
1521
1522                 for (i = 0; i < 6; i++) {
1523                         unsigned char num;
1524
1525                         if ((*str == '.') || (*str == ':'))
1526                                 str++;
1527                         num = nibble(*str++) << 4;
1528                         num |= (nibble(*str++));
1529                         dev_addr[i] = num;
1530                 }
1531                 if (is_valid_ether_addr(dev_addr))
1532                         return 0;
1533         }
1534         return 1;
1535 }
1536
1537 static int eth_bind(struct usb_gadget *gadget)
1538 {
1539         struct eth_dev          *dev = &l_ethdev;
1540         u8                      cdc = 1, zlp = 1;
1541         struct usb_ep           *in_ep, *out_ep, *status_ep = NULL;
1542         int                     gcnum;
1543         u8                      tmp[7];
1544
1545         /* these flags are only ever cleared; compiler take note */
1546 #ifndef DEV_CONFIG_CDC
1547         cdc = 0;
1548 #endif
1549         /*
1550          * Because most host side USB stacks handle CDC Ethernet, that
1551          * standard protocol is _strongly_ preferred for interop purposes.
1552          * (By everyone except Microsoft.)
1553          */
1554         if (gadget_is_pxa(gadget)) {
1555                 /* pxa doesn't support altsettings */
1556                 cdc = 0;
1557         } else if (gadget_is_musbhdrc(gadget)) {
1558                 /* reduce tx dma overhead by avoiding special cases */
1559                 zlp = 0;
1560         } else if (gadget_is_sh(gadget)) {
1561                 /* sh doesn't support multiple interfaces or configs */
1562                 cdc = 0;
1563         } else if (gadget_is_sa1100(gadget)) {
1564                 /* hardware can't write zlps */
1565                 zlp = 0;
1566                 /*
1567                  * sa1100 CAN do CDC, without status endpoint ... we use
1568                  * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
1569                  */
1570                 cdc = 0;
1571         }
1572
1573         gcnum = usb_gadget_controller_number(gadget);
1574         if (gcnum >= 0)
1575                 device_desc.bcdDevice = cpu_to_le16(0x0300 + gcnum);
1576         else {
1577                 /*
1578                  * can't assume CDC works.  don't want to default to
1579                  * anything less functional on CDC-capable hardware,
1580                  * so we fail in this case.
1581                  */
1582                 error("controller '%s' not recognized",
1583                         gadget->name);
1584                 return -ENODEV;
1585         }
1586
1587         /*
1588          * CDC subset ... recognized by Linux since 2.4.10, but Windows
1589          * drivers aren't widely available.  (That may be improved by
1590          * supporting one submode of the "SAFE" variant of MDLM.)
1591          */
1592         if (!cdc) {
1593                 device_desc.idVendor =
1594                         __constant_cpu_to_le16(SIMPLE_VENDOR_NUM);
1595                 device_desc.idProduct =
1596                         __constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);
1597         }
1598
1599         /* support optional vendor/distro customization */
1600 #if defined(CONFIG_USB_CDC_VENDOR_ID) && defined(CONFIG_USB_CDC_PRODUCT_ID)
1601         device_desc.idVendor = cpu_to_le16(CONFIG_USB_CDC_VENDOR_ID);
1602         device_desc.idProduct = cpu_to_le16(CONFIG_USB_CDC_PRODUCT_ID);
1603 #endif
1604         if (bcdDevice)
1605                 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
1606         if (iManufacturer)
1607                 strlcpy(manufacturer, iManufacturer, sizeof manufacturer);
1608         if (iProduct)
1609                 strlcpy(product_desc, iProduct, sizeof product_desc);
1610         if (iSerialNumber) {
1611                 device_desc.iSerialNumber = STRING_SERIALNUMBER,
1612                 strlcpy(serial_number, iSerialNumber, sizeof serial_number);
1613         }
1614
1615         /* all we really need is bulk IN/OUT */
1616         usb_ep_autoconfig_reset(gadget);
1617         in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);
1618         if (!in_ep) {
1619 autoconf_fail:
1620                 error("can't autoconfigure on %s\n",
1621                         gadget->name);
1622                 return -ENODEV;
1623         }
1624         in_ep->driver_data = in_ep;     /* claim */
1625
1626         out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
1627         if (!out_ep)
1628                 goto autoconf_fail;
1629         out_ep->driver_data = out_ep;   /* claim */
1630
1631 #if defined(DEV_CONFIG_CDC)
1632         /*
1633          * CDC Ethernet control interface doesn't require a status endpoint.
1634          * Since some hosts expect one, try to allocate one anyway.
1635          */
1636         if (cdc) {
1637                 status_ep = usb_ep_autoconfig(gadget, &fs_status_desc);
1638                 if (status_ep) {
1639                         status_ep->driver_data = status_ep;     /* claim */
1640                 } else if (cdc) {
1641                         control_intf.bNumEndpoints = 0;
1642                         /* FIXME remove endpoint from descriptor list */
1643                 }
1644         }
1645 #endif
1646
1647         /* one config:  cdc, else minimal subset */
1648         if (!cdc) {
1649                 eth_config.bNumInterfaces = 1;
1650                 eth_config.iConfiguration = STRING_SUBSET;
1651
1652                 /*
1653                  * use functions to set these up, in case we're built to work
1654                  * with multiple controllers and must override CDC Ethernet.
1655                  */
1656                 fs_subset_descriptors();
1657                 hs_subset_descriptors();
1658         }
1659
1660         device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
1661         usb_gadget_set_selfpowered(gadget);
1662
1663         if (gadget_is_dualspeed(gadget)) {
1664                 if (!cdc)
1665                         dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
1666
1667                 /* assumes ep0 uses the same value for both speeds ... */
1668                 dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
1669
1670                 /* and that all endpoints are dual-speed */
1671                 hs_source_desc.bEndpointAddress =
1672                                 fs_source_desc.bEndpointAddress;
1673                 hs_sink_desc.bEndpointAddress =
1674                                 fs_sink_desc.bEndpointAddress;
1675 #if defined(DEV_CONFIG_CDC)
1676                 if (status_ep)
1677                         hs_status_desc.bEndpointAddress =
1678                                         fs_status_desc.bEndpointAddress;
1679 #endif
1680         }
1681
1682         if (gadget_is_otg(gadget)) {
1683                 otg_descriptor.bmAttributes |= USB_OTG_HNP,
1684                 eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
1685                 eth_config.bMaxPower = 4;
1686         }
1687
1688         dev->net = &l_netdev;
1689         strcpy(dev->net->name, USB_NET_NAME);
1690
1691         dev->cdc = cdc;
1692         dev->zlp = zlp;
1693
1694         dev->in_ep = in_ep;
1695         dev->out_ep = out_ep;
1696         dev->status_ep = status_ep;
1697
1698         /*
1699          * Module params for these addresses should come from ID proms.
1700          * The host side address is used with CDC, and commonly
1701          * ends up in a persistent config database.  It's not clear if
1702          * host side code for the SAFE thing cares -- its original BLAN
1703          * thing didn't, Sharp never assigned those addresses on Zaurii.
1704          */
1705         get_ether_addr(dev_addr, dev->net->enetaddr);
1706
1707         memset(tmp, 0, sizeof(tmp));
1708         memcpy(tmp, dev->net->enetaddr, sizeof(dev->net->enetaddr));
1709
1710         get_ether_addr(host_addr, dev->host_mac);
1711
1712         sprintf(ethaddr, "%02X%02X%02X%02X%02X%02X",
1713                 dev->host_mac[0], dev->host_mac[1],
1714                         dev->host_mac[2], dev->host_mac[3],
1715                         dev->host_mac[4], dev->host_mac[5]);
1716
1717         printf("using %s, OUT %s IN %s%s%s\n", gadget->name,
1718                 out_ep->name, in_ep->name,
1719                 status_ep ? " STATUS " : "",
1720                 status_ep ? status_ep->name : ""
1721                 );
1722         printf("MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
1723                 dev->net->enetaddr[0], dev->net->enetaddr[1],
1724                 dev->net->enetaddr[2], dev->net->enetaddr[3],
1725                 dev->net->enetaddr[4], dev->net->enetaddr[5]);
1726
1727         if (cdc) {
1728                 printf("HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
1729                         dev->host_mac[0], dev->host_mac[1],
1730                         dev->host_mac[2], dev->host_mac[3],
1731                         dev->host_mac[4], dev->host_mac[5]);
1732         }
1733
1734         /*
1735          * use PKTSIZE (or aligned... from u-boot) and set
1736          * wMaxSegmentSize accordingly
1737          */
1738         dev->mtu = PKTSIZE_ALIGN; /* RNDIS does not like this, only 1514, TODO*/
1739
1740         /* preallocate control message data and buffer */
1741         dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
1742         if (!dev->req)
1743                 goto fail;
1744         dev->req->buf = control_req;
1745         dev->req->complete = eth_setup_complete;
1746
1747         /* ... and maybe likewise for status transfer */
1748 #if defined(DEV_CONFIG_CDC)
1749         if (dev->status_ep) {
1750                 dev->stat_req = usb_ep_alloc_request(dev->status_ep,
1751                                                         GFP_KERNEL);
1752                 if (!dev->stat_req) {
1753                         usb_ep_free_request(dev->status_ep, dev->req);
1754
1755                         goto fail;
1756                 }
1757                 dev->stat_req->buf = status_req;
1758                 dev->stat_req->context = NULL;
1759         }
1760 #endif
1761
1762         /* finish hookup to lower layer ... */
1763         dev->gadget = gadget;
1764         set_gadget_data(gadget, dev);
1765         gadget->ep0->driver_data = dev;
1766
1767         /*
1768          * two kinds of host-initiated state changes:
1769          *  - iff DATA transfer is active, carrier is "on"
1770          *  - tx queueing enabled if open *and* carrier is "on"
1771          */
1772         return 0;
1773
1774 fail:
1775         error("%s failed", __func__);
1776         eth_unbind(gadget);
1777         return -ENOMEM;
1778 }
1779
1780 static int usb_eth_init(struct eth_device *netdev, bd_t *bd)
1781 {
1782         struct eth_dev *dev = &l_ethdev;
1783         struct usb_gadget *gadget;
1784         unsigned long ts;
1785         unsigned long timeout = USB_CONNECT_TIMEOUT;
1786
1787         if (!netdev) {
1788                 error("received NULL ptr");
1789                 goto fail;
1790         }
1791
1792         dev->network_started = 0;
1793
1794         packet_received = 0;
1795         packet_sent = 0;
1796
1797         gadget = dev->gadget;
1798         usb_gadget_connect(gadget);
1799
1800         if (getenv("cdc_connect_timeout"))
1801                 timeout = simple_strtoul(getenv("cdc_connect_timeout"),
1802                                                 NULL, 10) * CONFIG_SYS_HZ;
1803         ts = get_timer(0);
1804         while (!l_ethdev.network_started) {
1805                 /* Handle control-c and timeouts */
1806                 if (ctrlc() || (get_timer(ts) > timeout)) {
1807                         error("The remote end did not respond in time.");
1808                         goto fail;
1809                 }
1810                 usb_gadget_handle_interrupts();
1811         }
1812
1813         packet_received = 0;
1814         rx_submit(dev, dev->rx_req, 0);
1815         return 0;
1816 fail:
1817         return -1;
1818 }
1819
1820 static int usb_eth_send(struct eth_device *netdev,
1821                         volatile void *packet, int length)
1822 {
1823         int                     retval;
1824         struct eth_dev          *dev = &l_ethdev;
1825         struct usb_request      *req = dev->tx_req;
1826         unsigned long ts;
1827         unsigned long timeout = USB_CONNECT_TIMEOUT;
1828
1829         debug("%s:...\n", __func__);
1830
1831         req->buf = (void *)packet;
1832         req->context = NULL;
1833         req->complete = tx_complete;
1834
1835         /*
1836          * use zlp framing on tx for strict CDC-Ether conformance,
1837          * though any robust network rx path ignores extra padding.
1838          * and some hardware doesn't like to write zlps.
1839          */
1840         req->zero = 1;
1841         if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
1842                 length++;
1843
1844         req->length = length;
1845 #if 0
1846         /* throttle highspeed IRQ rate back slightly */
1847         if (gadget_is_dualspeed(dev->gadget))
1848                 req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
1849                         ? ((dev->tx_qlen % qmult) != 0) : 0;
1850 #endif
1851         dev->tx_qlen = 1;
1852         ts = get_timer(0);
1853         packet_sent = 0;
1854
1855         retval = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
1856
1857         if (!retval)
1858                 debug("%s: packet queued\n", __func__);
1859         while (!packet_sent) {
1860                 if (get_timer(ts) > timeout) {
1861                         printf("timeout sending packets to usb ethernet\n");
1862                         return -1;
1863                 }
1864                 usb_gadget_handle_interrupts();
1865         }
1866
1867         return 0;
1868 }
1869
1870 static int usb_eth_recv(struct eth_device *netdev)
1871 {
1872         struct eth_dev *dev = &l_ethdev;
1873
1874         usb_gadget_handle_interrupts();
1875
1876         if (packet_received) {
1877                 debug("%s: packet received\n", __func__);
1878                 if (dev->rx_req) {
1879                         NetReceive(NetRxPackets[0], dev->rx_req->length);
1880                         packet_received = 0;
1881
1882                         rx_submit(dev, dev->rx_req, 0);
1883                 } else
1884                         error("dev->rx_req invalid");
1885         }
1886         return 0;
1887 }
1888
1889 void usb_eth_halt(struct eth_device *netdev)
1890 {
1891         struct eth_dev *dev = &l_ethdev;
1892
1893         if (!netdev) {
1894                 error("received NULL ptr");
1895                 return;
1896         }
1897
1898         usb_gadget_disconnect(dev->gadget);
1899 }
1900
1901 static struct usb_gadget_driver eth_driver = {
1902         .speed          = DEVSPEED,
1903
1904         .bind           = eth_bind,
1905         .unbind         = eth_unbind,
1906
1907         .setup          = eth_setup,
1908         .disconnect     = eth_disconnect,
1909
1910         .suspend        = eth_suspend,
1911         .resume         = eth_resume,
1912 };
1913
1914 int usb_eth_initialize(bd_t *bi)
1915 {
1916         int status = 0;
1917         struct eth_device *netdev = &l_netdev;
1918
1919         sprintf(netdev->name, "usb_ether");
1920
1921         netdev->init = usb_eth_init;
1922         netdev->send = usb_eth_send;
1923         netdev->recv = usb_eth_recv;
1924         netdev->halt = usb_eth_halt;
1925
1926 #ifdef CONFIG_MCAST_TFTP
1927   #error not supported
1928 #endif
1929         /* Configure default mac-addresses for the USB ethernet device */
1930 #ifdef CONFIG_USBNET_DEV_ADDR
1931         strncpy(dev_addr, CONFIG_USBNET_DEV_ADDR, sizeof(dev_addr));
1932 #endif
1933 #ifdef CONFIG_USBNET_HOST_ADDR
1934         strncpy(host_addr, CONFIG_USBNET_HOST_ADDR, sizeof(host_addr));
1935 #endif
1936         /* Check if the user overruled the MAC addresses */
1937         if (getenv("usbnet_devaddr"))
1938                 strncpy(dev_addr, getenv("usbnet_devaddr"),
1939                         sizeof(dev_addr));
1940
1941         if (getenv("usbnet_hostaddr"))
1942                 strncpy(host_addr, getenv("usbnet_hostaddr"),
1943                         sizeof(host_addr));
1944
1945         /* Make sure both strings are terminated */
1946         dev_addr[sizeof(dev_addr)-1] = '\0';
1947         host_addr[sizeof(host_addr)-1] = '\0';
1948
1949         if (!is_eth_addr_valid(dev_addr)) {
1950                 error("Need valid 'usbnet_devaddr' to be set");
1951                 status = -1;
1952         }
1953         if (!is_eth_addr_valid(host_addr)) {
1954                 error("Need valid 'usbnet_hostaddr' to be set");
1955                 status = -1;
1956         }
1957         if (status)
1958                 goto fail;
1959
1960         status = usb_gadget_register_driver(&eth_driver);
1961         if (status < 0)
1962                 goto fail;
1963
1964         eth_register(netdev);
1965         return 0;
1966
1967 fail:
1968         error("%s failed. error = %d", __func__, status);
1969         return status;
1970 }