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