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  * SPDX-License-Identifier:     GPL-2.0+
   9  */
  10
  11 #include <common.h>
  12 #include <asm/errno.h>
  13 #include <linux/netdevice.h>
  14 #include <linux/usb/ch9.h>
  15 #include <linux/usb/cdc.h>
  16 #include <linux/usb/gadget.h>
  17 #include <net.h>
  18 #include <malloc.h>
  19 #include <linux/ctype.h>
  20
  21 #include "gadget_chips.h"
  22 #include "rndis.h"
  23
  24 #define USB_NET_NAME "usb_ether"
  25
  26 #define atomic_read
  27 extern struct platform_data brd;
  28
  29
  30 unsigned packet_received, packet_sent;
  31
  32 /*
  33  * Ethernet gadget driver -- with CDC and non-CDC options
  34  * Builds on hardware support for a full duplex link.
  35  *
  36  * CDC Ethernet is the standard USB solution for sending Ethernet frames
  37  * using USB.  Real hardware tends to use the same framing protocol but look
  38  * different for control features.  This driver strongly prefers to use
  39  * this USB-IF standard as its open-systems interoperability solution;
  40  * most host side USB stacks (except from Microsoft) support it.
  41  *
  42  * This is sometimes called "CDC ECM" (Ethernet Control Model) to support
  43  * TLA-soup.  "CDC ACM" (Abstract Control Model) is for modems, and a new
  44  * "CDC EEM" (Ethernet Emulation Model) is starting to spread.
  45  *
  46  * There's some hardware that can't talk CDC ECM.  We make that hardware
  47  * implement a "minimalist" vendor-agnostic CDC core:  same framing, but
  48  * link-level setup only requires activating the configuration.  Only the
  49  * endpoint descriptors, and product/vendor IDs, are relevant; no control
  50  * operations are available.  Linux supports it, but other host operating
  51  * systems may not.  (This is a subset of CDC Ethernet.)
  52  *
  53  * It turns out that if you add a few descriptors to that "CDC Subset",
  54  * (Windows) host side drivers from MCCI can treat it as one submode of
  55  * a proprietary scheme called "SAFE" ... without needing to know about
  56  * specific product/vendor IDs.  So we do that, making it easier to use
  57  * those MS-Windows drivers.  Those added descriptors make it resemble a
  58  * CDC MDLM device, but they don't change device behavior at all.  (See
  59  * MCCI Engineering report 950198 "SAFE Networking Functions".)
  60  *
  61  * A third option is also in use.  Rather than CDC Ethernet, or something
  62  * simpler, Microsoft pushes their own approach: RNDIS.  The published
  63  * RNDIS specs are ambiguous and appear to be incomplete, and are also
  64  * needlessly complex.  They borrow more from CDC ACM than CDC ECM.
  65  */
  66 #define ETH_ALEN        6               /* Octets in one ethernet addr   */
  67 #define ETH_HLEN        14              /* Total octets in header.       */
  68 #define ETH_ZLEN        60              /* Min. octets in frame sans FCS */
  69 #define ETH_DATA_LEN    1500            /* Max. octets in payload        */
  70 #define ETH_FRAME_LEN   PKTSIZE_ALIGN   /* Max. octets in frame sans FCS */
  71
  72 #define DRIVER_DESC             "Ethernet Gadget"
  73 /* Based on linux 2.6.27 version */
  74 #define DRIVER_VERSION          "May Day 2005"
  75
  76 static const char shortname[] = "ether";
  77 static const char driver_desc[] = DRIVER_DESC;
  78
  79 #define RX_EXTRA        20              /* guard against rx overflows */
  80
  81 #ifndef CONFIG_USB_ETH_RNDIS
  82 #define rndis_uninit(x)         do {} while (0)
  83 #define rndis_deregister(c)     do {} while (0)
  84 #define rndis_exit()            do {} while (0)
  85 #endif
  86
  87 /* CDC and RNDIS support the same host-chosen outgoing packet filters. */
  88 #define DEFAULT_FILTER  (USB_CDC_PACKET_TYPE_BROADCAST \
  89                         |USB_CDC_PACKET_TYPE_ALL_MULTICAST \
  90                         |USB_CDC_PACKET_TYPE_PROMISCUOUS \
  91                         |USB_CDC_PACKET_TYPE_DIRECTED)
  92
  93 #define USB_CONNECT_TIMEOUT (3 * CONFIG_SYS_HZ)
  94
  95 /*-------------------------------------------------------------------------*/
  96
  97 struct eth_dev {
  98         struct usb_gadget       *gadget;
  99         struct usb_request      *req;           /* for control responses */
 100         struct usb_request      *stat_req;      /* for cdc & rndis status */
 101
 102         u8                      config;
 103         struct usb_ep           *in_ep, *out_ep, *status_ep;
 104         const struct usb_endpoint_descriptor
 105                                 *in, *out, *status;
 106
 107         struct usb_request      *tx_req, *rx_req;
 108
 109         struct eth_device       *net;
 110         struct net_device_stats stats;
 111         unsigned int            tx_qlen;
 112
 113         unsigned                zlp:1;
 114         unsigned                cdc:1;
 115         unsigned                rndis:1;
 116         unsigned                suspended:1;
 117         unsigned                network_started:1;
 118         u16                     cdc_filter;
 119         unsigned long           todo;
 120         int                     mtu;
 121 #define WORK_RX_MEMORY          0
 122         int                     rndis_config;
 123         u8                      host_mac[ETH_ALEN];
 124 };
 125
 126 /*
 127  * This version autoconfigures as much as possible at run-time.
 128  *
 129  * It also ASSUMES a self-powered device, without remote wakeup,
 130  * although remote wakeup support would make sense.
 131  */
 132
 133 /*-------------------------------------------------------------------------*/
 134 static struct eth_dev l_ethdev;
 135 static struct eth_device l_netdev;
 136 static struct usb_gadget_driver eth_driver;
 137
 138 /*-------------------------------------------------------------------------*/
 139
 140 /* "main" config is either CDC, or its simple subset */
 141 static inline int is_cdc(struct eth_dev *dev)
 142 {
 143 #if     !defined(CONFIG_USB_ETH_SUBSET)
 144         return 1;               /* only cdc possible */
 145 #elif   !defined(CONFIG_USB_ETH_CDC)
 146         return 0;               /* only subset possible */
 147 #else
 148         return dev->cdc;        /* depends on what hardware we found */
 149 #endif
 150 }
 151
 152 /* "secondary" RNDIS config may sometimes be activated */
 153 static inline int rndis_active(struct eth_dev *dev)
 154 {
 155 #ifdef  CONFIG_USB_ETH_RNDIS
 156         return dev->rndis;
 157 #else
 158         return 0;
 159 #endif
 160 }
 161
 162 #define subset_active(dev)      (!is_cdc(dev) && !rndis_active(dev))
 163 #define cdc_active(dev)         (is_cdc(dev) && !rndis_active(dev))
 164
 165 #define DEFAULT_QLEN    2       /* double buffering by default */
 166
 167 /* peak bulk transfer bits-per-second */
 168 #define HS_BPS          (13 * 512 * 8 * 1000 * 8)
 169 #define FS_BPS          (19 *  64 * 1 * 1000 * 8)
 170
 171 #ifdef CONFIG_USB_GADGET_DUALSPEED
 172 #define DEVSPEED        USB_SPEED_HIGH
 173
 174 #ifdef CONFIG_USB_ETH_QMULT
 175 #define qmult CONFIG_USB_ETH_QMULT
 176 #else
 177 #define qmult 5
 178 #endif
 179
 180 /* for dual-speed hardware, use deeper queues at highspeed */
 181 #define qlen(gadget) \
 182         (DEFAULT_QLEN*((gadget->speed == USB_SPEED_HIGH) ? qmult : 1))
 183
 184 static inline int BITRATE(struct usb_gadget *g)
 185 {
 186         return (g->speed == USB_SPEED_HIGH) ? HS_BPS : FS_BPS;
 187 }
 188
 189 #else   /* full speed (low speed doesn't do bulk) */
 190
 191 #define qmult           1
 192
 193 #define DEVSPEED        USB_SPEED_FULL
 194
 195 #define qlen(gadget) DEFAULT_QLEN
 196
 197 static inline int BITRATE(struct usb_gadget *g)
 198 {
 199         return FS_BPS;
 200 }
 201 #endif
 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 /*
 211  * Thanks to NetChip Technologies for donating this product ID.
 212  * It's for devices with only CDC Ethernet configurations.
 213  */
 214 #define CDC_VENDOR_NUM          0x0525  /* NetChip */
 215 #define CDC_PRODUCT_NUM         0xa4a1  /* Linux-USB Ethernet Gadget */
 216
 217 /*
 218  * For hardware that can't talk CDC, we use the same vendor ID that
 219  * ARM Linux has used for ethernet-over-usb, both with sa1100 and
 220  * with pxa250.  We're protocol-compatible, if the host-side drivers
 221  * use the endpoint descriptors.  bcdDevice (version) is nonzero, so
 222  * drivers that need to hard-wire endpoint numbers have a hook.
 223  *
 224  * The protocol is a minimal subset of CDC Ether, which works on any bulk
 225  * hardware that's not deeply broken ... even on hardware that can't talk
 226  * RNDIS (like SA-1100, with no interrupt endpoint, or anything that
 227  * doesn't handle control-OUT).
 228  */
 229 #define SIMPLE_VENDOR_NUM       0x049f  /* Compaq Computer Corp. */
 230 #define SIMPLE_PRODUCT_NUM      0x505a  /* Linux-USB "CDC Subset" Device */
 231
 232 /*
 233  * For hardware that can talk RNDIS and either of the above protocols,
 234  * use this ID ... the windows INF files will know it.  Unless it's
 235  * used with CDC Ethernet, Linux 2.4 hosts will need updates to choose
 236  * the non-RNDIS configuration.
 237  */
 238 #define RNDIS_VENDOR_NUM        0x0525  /* NetChip */
 239 #define RNDIS_PRODUCT_NUM       0xa4a2  /* Ethernet/RNDIS Gadget */
 240
 241 /*
 242  * Some systems will want different product identifers published in the
 243  * device descriptor, either numbers or strings or both.  These string
 244  * parameters are in UTF-8 (superset of ASCII's 7 bit characters).
 245  */
 246
 247 /*
 248  * Emulating them in eth_bind:
 249  * static ushort idVendor;
 250  * static ushort idProduct;
 251  */
 252
 253 #if defined(CONFIG_USBNET_MANUFACTURER)
 254 static char *iManufacturer = CONFIG_USBNET_MANUFACTURER;
 255 #else
 256 static char *iManufacturer = "U-boot";
 257 #endif
 258
 259 /* These probably need to be configurable. */
 260 static ushort bcdDevice;
 261 static char *iProduct;
 262 static char *iSerialNumber;
 263
 264 static char dev_addr[18];
 265
 266 static char host_addr[18];
 267
 268
 269 /*-------------------------------------------------------------------------*/
 270
 271 /*
 272  * USB DRIVER HOOKUP (to the hardware driver, below us), mostly
 273  * ep0 implementation:  descriptors, config management, setup().
 274  * also optional class-specific notification interrupt transfer.
 275  */
 276
 277 /*
 278  * DESCRIPTORS ... most are static, but strings and (full) configuration
 279  * descriptors are built on demand.  For now we do either full CDC, or
 280  * our simple subset, with RNDIS as an optional second configuration.
 281  *
 282  * RNDIS includes some CDC ACM descriptors ... like CDC Ethernet.  But
 283  * the class descriptors match a modem (they're ignored; it's really just
 284  * Ethernet functionality), they don't need the NOP altsetting, and the
 285  * status transfer endpoint isn't optional.
 286  */
 287
 288 #define STRING_MANUFACTURER             1
 289 #define STRING_PRODUCT                  2
 290 #define STRING_ETHADDR                  3
 291 #define STRING_DATA                     4
 292 #define STRING_CONTROL                  5
 293 #define STRING_RNDIS_CONTROL            6
 294 #define STRING_CDC                      7
 295 #define STRING_SUBSET                   8
 296 #define STRING_RNDIS                    9
 297 #define STRING_SERIALNUMBER             10
 298
 299 /* holds our biggest descriptor (or RNDIS response) */
 300 #define USB_BUFSIZ      256
 301
 302 /*
 303  * This device advertises one configuration, eth_config, unless RNDIS
 304  * is enabled (rndis_config) on hardware supporting at least two configs.
 305  *
 306  * NOTE:  Controllers like superh_udc should probably be able to use
 307  * an RNDIS-only configuration.
 308  *
 309  * FIXME define some higher-powered configurations to make it easier
 310  * to recharge batteries ...
 311  */
 312
 313 #define DEV_CONFIG_VALUE        1       /* cdc or subset */
 314 #define DEV_RNDIS_CONFIG_VALUE  2       /* rndis; optional */
 315
 316 static struct usb_device_descriptor
 317 device_desc = {
 318         .bLength =              sizeof device_desc,
 319         .bDescriptorType =      USB_DT_DEVICE,
 320
 321         .bcdUSB =               __constant_cpu_to_le16(0x0200),
 322
 323         .bDeviceClass =         USB_CLASS_COMM,
 324         .bDeviceSubClass =      0,
 325         .bDeviceProtocol =      0,
 326
 327         .idVendor =             __constant_cpu_to_le16(CDC_VENDOR_NUM),
 328         .idProduct =            __constant_cpu_to_le16(CDC_PRODUCT_NUM),
 329         .iManufacturer =        STRING_MANUFACTURER,
 330         .iProduct =             STRING_PRODUCT,
 331         .bNumConfigurations =   1,
 332 };
 333
 334 static struct usb_otg_descriptor
 335 otg_descriptor = {
 336         .bLength =              sizeof otg_descriptor,
 337         .bDescriptorType =      USB_DT_OTG,
 338
 339         .bmAttributes =         USB_OTG_SRP,
 340 };
 341
 342 static struct usb_config_descriptor
 343 eth_config = {
 344         .bLength =              sizeof eth_config,
 345         .bDescriptorType =      USB_DT_CONFIG,
 346
 347         /* compute wTotalLength on the fly */
 348         .bNumInterfaces =       2,
 349         .bConfigurationValue =  DEV_CONFIG_VALUE,
 350         .iConfiguration =       STRING_CDC,
 351         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 352         .bMaxPower =            1,
 353 };
 354
 355 #ifdef  CONFIG_USB_ETH_RNDIS
 356 static struct usb_config_descriptor
 357 rndis_config = {
 358         .bLength =              sizeof rndis_config,
 359         .bDescriptorType =      USB_DT_CONFIG,
 360
 361         /* compute wTotalLength on the fly */
 362         .bNumInterfaces =       2,
 363         .bConfigurationValue =  DEV_RNDIS_CONFIG_VALUE,
 364         .iConfiguration =       STRING_RNDIS,
 365         .bmAttributes =         USB_CONFIG_ATT_ONE | USB_CONFIG_ATT_SELFPOWER,
 366         .bMaxPower =            1,
 367 };
 368 #endif
 369
 370 /*
 371  * Compared to the simple CDC subset, the full CDC Ethernet model adds
 372  * three class descriptors, two interface descriptors, optional status
 373  * endpoint.  Both have a "data" interface and two bulk endpoints.
 374  * There are also differences in how control requests are handled.
 375  *
 376  * RNDIS shares a lot with CDC-Ethernet, since it's a variant of the
 377  * CDC-ACM (modem) spec.  Unfortunately MSFT's RNDIS driver is buggy; it
 378  * may hang or oops.  Since bugfixes (or accurate specs, letting Linux
 379  * work around those bugs) are unlikely to ever come from MSFT, you may
 380  * wish to avoid using RNDIS.
 381  *
 382  * MCCI offers an alternative to RNDIS if you need to connect to Windows
 383  * but have hardware that can't support CDC Ethernet.   We add descriptors
 384  * to present the CDC Subset as a (nonconformant) CDC MDLM variant called
 385  * "SAFE".  That borrows from both CDC Ethernet and CDC MDLM.  You can
 386  * get those drivers from MCCI, or bundled with various products.
 387  */
 388
 389 #ifdef  CONFIG_USB_ETH_CDC
 390 static struct usb_interface_descriptor
 391 control_intf = {
 392         .bLength =              sizeof control_intf,
 393         .bDescriptorType =      USB_DT_INTERFACE,
 394
 395         .bInterfaceNumber =     0,
 396         /* status endpoint is optional; this may be patched later */
 397         .bNumEndpoints =        1,
 398         .bInterfaceClass =      USB_CLASS_COMM,
 399         .bInterfaceSubClass =   USB_CDC_SUBCLASS_ETHERNET,
 400         .bInterfaceProtocol =   USB_CDC_PROTO_NONE,
 401         .iInterface =           STRING_CONTROL,
 402 };
 403 #endif
 404
 405 #ifdef  CONFIG_USB_ETH_RNDIS
 406 static const struct usb_interface_descriptor
 407 rndis_control_intf = {
 408         .bLength =              sizeof rndis_control_intf,
 409         .bDescriptorType =      USB_DT_INTERFACE,
 410
 411         .bInterfaceNumber =     0,
 412         .bNumEndpoints =        1,
 413         .bInterfaceClass =      USB_CLASS_COMM,
 414         .bInterfaceSubClass =   USB_CDC_SUBCLASS_ACM,
 415         .bInterfaceProtocol =   USB_CDC_ACM_PROTO_VENDOR,
 416         .iInterface =           STRING_RNDIS_CONTROL,
 417 };
 418 #endif
 419
 420 static const struct usb_cdc_header_desc header_desc = {
 421         .bLength =              sizeof header_desc,
 422         .bDescriptorType =      USB_DT_CS_INTERFACE,
 423         .bDescriptorSubType =   USB_CDC_HEADER_TYPE,
 424
 425         .bcdCDC =               __constant_cpu_to_le16(0x0110),
 426 };
 427
 428 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
 429
 430 static const struct usb_cdc_union_desc union_desc = {
 431         .bLength =              sizeof union_desc,
 432         .bDescriptorType =      USB_DT_CS_INTERFACE,
 433         .bDescriptorSubType =   USB_CDC_UNION_TYPE,
 434
 435         .bMasterInterface0 =    0,      /* index of control interface */
 436         .bSlaveInterface0 =     1,      /* index of DATA interface */
 437 };
 438
 439 #endif  /* CDC || RNDIS */
 440
 441 #ifdef  CONFIG_USB_ETH_RNDIS
 442
 443 static const struct usb_cdc_call_mgmt_descriptor call_mgmt_descriptor = {
 444         .bLength =              sizeof call_mgmt_descriptor,
 445         .bDescriptorType =      USB_DT_CS_INTERFACE,
 446         .bDescriptorSubType =   USB_CDC_CALL_MANAGEMENT_TYPE,
 447
 448         .bmCapabilities =       0x00,
 449         .bDataInterface =       0x01,
 450 };
 451
 452 static const struct usb_cdc_acm_descriptor acm_descriptor = {
 453         .bLength =              sizeof acm_descriptor,
 454         .bDescriptorType =      USB_DT_CS_INTERFACE,
 455         .bDescriptorSubType =   USB_CDC_ACM_TYPE,
 456
 457         .bmCapabilities =       0x00,
 458 };
 459
 460 #endif
 461
 462 #ifndef CONFIG_USB_ETH_CDC
 463
 464 /*
 465  * "SAFE" loosely follows CDC WMC MDLM, violating the spec in various
 466  * ways:  data endpoints live in the control interface, there's no data
 467  * interface, and it's not used to talk to a cell phone radio.
 468  */
 469
 470 static const struct usb_cdc_mdlm_desc mdlm_desc = {
 471         .bLength =              sizeof mdlm_desc,
 472         .bDescriptorType =      USB_DT_CS_INTERFACE,
 473         .bDescriptorSubType =   USB_CDC_MDLM_TYPE,
 474
 475         .bcdVersion =           __constant_cpu_to_le16(0x0100),
 476         .bGUID = {
 477                 0x5d, 0x34, 0xcf, 0x66, 0x11, 0x18, 0x11, 0xd6,
 478                 0xa2, 0x1a, 0x00, 0x01, 0x02, 0xca, 0x9a, 0x7f,
 479         },
 480 };
 481
 482 /*
 483  * since "usb_cdc_mdlm_detail_desc" is a variable length structure, we
 484  * can't really use its struct.  All we do here is say that we're using
 485  * the submode of "SAFE" which directly matches the CDC Subset.
 486  */
 487 static const u8 mdlm_detail_desc[] = {
 488         6,
 489         USB_DT_CS_INTERFACE,
 490         USB_CDC_MDLM_DETAIL_TYPE,
 491
 492         0,      /* "SAFE" */
 493         0,      /* network control capabilities (none) */
 494         0,      /* network data capabilities ("raw" encapsulation) */
 495 };
 496
 497 #endif
 498
 499 static const struct usb_cdc_ether_desc ether_desc = {
 500         .bLength =              sizeof(ether_desc),
 501         .bDescriptorType =      USB_DT_CS_INTERFACE,
 502         .bDescriptorSubType =   USB_CDC_ETHERNET_TYPE,
 503
 504         /* this descriptor actually adds value, surprise! */
 505         .iMACAddress =          STRING_ETHADDR,
 506         .bmEthernetStatistics = __constant_cpu_to_le32(0), /* no statistics */
 507         .wMaxSegmentSize =      __constant_cpu_to_le16(ETH_FRAME_LEN),
 508         .wNumberMCFilters =     __constant_cpu_to_le16(0),
 509         .bNumberPowerFilters =  0,
 510 };
 511
 512 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
 513
 514 /*
 515  * include the status endpoint if we can, even where it's optional.
 516  * use wMaxPacketSize big enough to fit CDC_NOTIFY_SPEED_CHANGE in one
 517  * packet, to simplify cancellation; and a big transfer interval, to
 518  * waste less bandwidth.
 519  *
 520  * some drivers (like Linux 2.4 cdc-ether!) "need" it to exist even
 521  * if they ignore the connect/disconnect notifications that real aether
 522  * can provide.  more advanced cdc configurations might want to support
 523  * encapsulated commands (vendor-specific, using control-OUT).
 524  *
 525  * RNDIS requires the status endpoint, since it uses that encapsulation
 526  * mechanism for its funky RPC scheme.
 527  */
 528
 529 #define LOG2_STATUS_INTERVAL_MSEC       5       /* 1 << 5 == 32 msec */
 530 #define STATUS_BYTECOUNT                16      /* 8 byte header + data */
 531
 532 static struct usb_endpoint_descriptor
 533 fs_status_desc = {
 534         .bLength =              USB_DT_ENDPOINT_SIZE,
 535         .bDescriptorType =      USB_DT_ENDPOINT,
 536
 537         .bEndpointAddress =     USB_DIR_IN,
 538         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 539         .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
 540         .bInterval =            1 << LOG2_STATUS_INTERVAL_MSEC,
 541 };
 542 #endif
 543
 544 #ifdef  CONFIG_USB_ETH_CDC
 545
 546 /* the default data interface has no endpoints ... */
 547
 548 static const struct usb_interface_descriptor
 549 data_nop_intf = {
 550         .bLength =              sizeof data_nop_intf,
 551         .bDescriptorType =      USB_DT_INTERFACE,
 552
 553         .bInterfaceNumber =     1,
 554         .bAlternateSetting =    0,
 555         .bNumEndpoints =        0,
 556         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 557         .bInterfaceSubClass =   0,
 558         .bInterfaceProtocol =   0,
 559 };
 560
 561 /* ... but the "real" data interface has two bulk endpoints */
 562
 563 static const struct usb_interface_descriptor
 564 data_intf = {
 565         .bLength =              sizeof data_intf,
 566         .bDescriptorType =      USB_DT_INTERFACE,
 567
 568         .bInterfaceNumber =     1,
 569         .bAlternateSetting =    1,
 570         .bNumEndpoints =        2,
 571         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 572         .bInterfaceSubClass =   0,
 573         .bInterfaceProtocol =   0,
 574         .iInterface =           STRING_DATA,
 575 };
 576
 577 #endif
 578
 579 #ifdef  CONFIG_USB_ETH_RNDIS
 580
 581 /* RNDIS doesn't activate by changing to the "real" altsetting */
 582
 583 static const struct usb_interface_descriptor
 584 rndis_data_intf = {
 585         .bLength =              sizeof rndis_data_intf,
 586         .bDescriptorType =      USB_DT_INTERFACE,
 587
 588         .bInterfaceNumber =     1,
 589         .bAlternateSetting =    0,
 590         .bNumEndpoints =        2,
 591         .bInterfaceClass =      USB_CLASS_CDC_DATA,
 592         .bInterfaceSubClass =   0,
 593         .bInterfaceProtocol =   0,
 594         .iInterface =           STRING_DATA,
 595 };
 596
 597 #endif
 598
 599 #ifdef CONFIG_USB_ETH_SUBSET
 600
 601 /*
 602  * "Simple" CDC-subset option is a simple vendor-neutral model that most
 603  * full speed controllers can handle:  one interface, two bulk endpoints.
 604  *
 605  * To assist host side drivers, we fancy it up a bit, and add descriptors
 606  * so some host side drivers will understand it as a "SAFE" variant.
 607  */
 608
 609 static const struct usb_interface_descriptor
 610 subset_data_intf = {
 611         .bLength =              sizeof subset_data_intf,
 612         .bDescriptorType =      USB_DT_INTERFACE,
 613
 614         .bInterfaceNumber =     0,
 615         .bAlternateSetting =    0,
 616         .bNumEndpoints =        2,
 617         .bInterfaceClass =      USB_CLASS_COMM,
 618         .bInterfaceSubClass =   USB_CDC_SUBCLASS_MDLM,
 619         .bInterfaceProtocol =   0,
 620         .iInterface =           STRING_DATA,
 621 };
 622
 623 #endif  /* SUBSET */
 624
 625 static struct usb_endpoint_descriptor
 626 fs_source_desc = {
 627         .bLength =              USB_DT_ENDPOINT_SIZE,
 628         .bDescriptorType =      USB_DT_ENDPOINT,
 629
 630         .bEndpointAddress =     USB_DIR_IN,
 631         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 632         .wMaxPacketSize =       __constant_cpu_to_le16(64),
 633 };
 634
 635 static struct usb_endpoint_descriptor
 636 fs_sink_desc = {
 637         .bLength =              USB_DT_ENDPOINT_SIZE,
 638         .bDescriptorType =      USB_DT_ENDPOINT,
 639
 640         .bEndpointAddress =     USB_DIR_OUT,
 641         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 642         .wMaxPacketSize =       __constant_cpu_to_le16(64),
 643 };
 644
 645 static const struct usb_descriptor_header *fs_eth_function[11] = {
 646         (struct usb_descriptor_header *) &otg_descriptor,
 647 #ifdef CONFIG_USB_ETH_CDC
 648         /* "cdc" mode descriptors */
 649         (struct usb_descriptor_header *) &control_intf,
 650         (struct usb_descriptor_header *) &header_desc,
 651         (struct usb_descriptor_header *) &union_desc,
 652         (struct usb_descriptor_header *) &ether_desc,
 653         /* NOTE: status endpoint may need to be removed */
 654         (struct usb_descriptor_header *) &fs_status_desc,
 655         /* data interface, with altsetting */
 656         (struct usb_descriptor_header *) &data_nop_intf,
 657         (struct usb_descriptor_header *) &data_intf,
 658         (struct usb_descriptor_header *) &fs_source_desc,
 659         (struct usb_descriptor_header *) &fs_sink_desc,
 660         NULL,
 661 #endif /* CONFIG_USB_ETH_CDC */
 662 };
 663
 664 static inline void fs_subset_descriptors(void)
 665 {
 666 #ifdef CONFIG_USB_ETH_SUBSET
 667         /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
 668         fs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
 669         fs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
 670         fs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
 671         fs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
 672         fs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
 673         fs_eth_function[6] = (struct usb_descriptor_header *) &fs_source_desc;
 674         fs_eth_function[7] = (struct usb_descriptor_header *) &fs_sink_desc;
 675         fs_eth_function[8] = NULL;
 676 #else
 677         fs_eth_function[1] = NULL;
 678 #endif
 679 }
 680
 681 #ifdef  CONFIG_USB_ETH_RNDIS
 682 static const struct usb_descriptor_header *fs_rndis_function[] = {
 683         (struct usb_descriptor_header *) &otg_descriptor,
 684         /* control interface matches ACM, not Ethernet */
 685         (struct usb_descriptor_header *) &rndis_control_intf,
 686         (struct usb_descriptor_header *) &header_desc,
 687         (struct usb_descriptor_header *) &call_mgmt_descriptor,
 688         (struct usb_descriptor_header *) &acm_descriptor,
 689         (struct usb_descriptor_header *) &union_desc,
 690         (struct usb_descriptor_header *) &fs_status_desc,
 691         /* data interface has no altsetting */
 692         (struct usb_descriptor_header *) &rndis_data_intf,
 693         (struct usb_descriptor_header *) &fs_source_desc,
 694         (struct usb_descriptor_header *) &fs_sink_desc,
 695         NULL,
 696 };
 697 #endif
 698
 699 /*
 700  * usb 2.0 devices need to expose both high speed and full speed
 701  * descriptors, unless they only run at full speed.
 702  */
 703
 704 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
 705 static struct usb_endpoint_descriptor
 706 hs_status_desc = {
 707         .bLength =              USB_DT_ENDPOINT_SIZE,
 708         .bDescriptorType =      USB_DT_ENDPOINT,
 709
 710         .bmAttributes =         USB_ENDPOINT_XFER_INT,
 711         .wMaxPacketSize =       __constant_cpu_to_le16(STATUS_BYTECOUNT),
 712         .bInterval =            LOG2_STATUS_INTERVAL_MSEC + 4,
 713 };
 714 #endif /* CONFIG_USB_ETH_CDC */
 715
 716 static struct usb_endpoint_descriptor
 717 hs_source_desc = {
 718         .bLength =              USB_DT_ENDPOINT_SIZE,
 719         .bDescriptorType =      USB_DT_ENDPOINT,
 720
 721         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 722         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 723 };
 724
 725 static struct usb_endpoint_descriptor
 726 hs_sink_desc = {
 727         .bLength =              USB_DT_ENDPOINT_SIZE,
 728         .bDescriptorType =      USB_DT_ENDPOINT,
 729
 730         .bmAttributes =         USB_ENDPOINT_XFER_BULK,
 731         .wMaxPacketSize =       __constant_cpu_to_le16(512),
 732 };
 733
 734 static struct usb_qualifier_descriptor
 735 dev_qualifier = {
 736         .bLength =              sizeof dev_qualifier,
 737         .bDescriptorType =      USB_DT_DEVICE_QUALIFIER,
 738
 739         .bcdUSB =               __constant_cpu_to_le16(0x0200),
 740         .bDeviceClass =         USB_CLASS_COMM,
 741
 742         .bNumConfigurations =   1,
 743 };
 744
 745 static const struct usb_descriptor_header *hs_eth_function[11] = {
 746         (struct usb_descriptor_header *) &otg_descriptor,
 747 #ifdef CONFIG_USB_ETH_CDC
 748         /* "cdc" mode descriptors */
 749         (struct usb_descriptor_header *) &control_intf,
 750         (struct usb_descriptor_header *) &header_desc,
 751         (struct usb_descriptor_header *) &union_desc,
 752         (struct usb_descriptor_header *) &ether_desc,
 753         /* NOTE: status endpoint may need to be removed */
 754         (struct usb_descriptor_header *) &hs_status_desc,
 755         /* data interface, with altsetting */
 756         (struct usb_descriptor_header *) &data_nop_intf,
 757         (struct usb_descriptor_header *) &data_intf,
 758         (struct usb_descriptor_header *) &hs_source_desc,
 759         (struct usb_descriptor_header *) &hs_sink_desc,
 760         NULL,
 761 #endif /* CONFIG_USB_ETH_CDC */
 762 };
 763
 764 static inline void hs_subset_descriptors(void)
 765 {
 766 #ifdef CONFIG_USB_ETH_SUBSET
 767         /* behavior is "CDC Subset"; extra descriptors say "SAFE" */
 768         hs_eth_function[1] = (struct usb_descriptor_header *) &subset_data_intf;
 769         hs_eth_function[2] = (struct usb_descriptor_header *) &header_desc;
 770         hs_eth_function[3] = (struct usb_descriptor_header *) &mdlm_desc;
 771         hs_eth_function[4] = (struct usb_descriptor_header *) &mdlm_detail_desc;
 772         hs_eth_function[5] = (struct usb_descriptor_header *) &ether_desc;
 773         hs_eth_function[6] = (struct usb_descriptor_header *) &hs_source_desc;
 774         hs_eth_function[7] = (struct usb_descriptor_header *) &hs_sink_desc;
 775         hs_eth_function[8] = NULL;
 776 #else
 777         hs_eth_function[1] = NULL;
 778 #endif
 779 }
 780
 781 #ifdef  CONFIG_USB_ETH_RNDIS
 782 static const struct usb_descriptor_header *hs_rndis_function[] = {
 783         (struct usb_descriptor_header *) &otg_descriptor,
 784         /* control interface matches ACM, not Ethernet */
 785         (struct usb_descriptor_header *) &rndis_control_intf,
 786         (struct usb_descriptor_header *) &header_desc,
 787         (struct usb_descriptor_header *) &call_mgmt_descriptor,
 788         (struct usb_descriptor_header *) &acm_descriptor,
 789         (struct usb_descriptor_header *) &union_desc,
 790         (struct usb_descriptor_header *) &hs_status_desc,
 791         /* data interface has no altsetting */
 792         (struct usb_descriptor_header *) &rndis_data_intf,
 793         (struct usb_descriptor_header *) &hs_source_desc,
 794         (struct usb_descriptor_header *) &hs_sink_desc,
 795         NULL,
 796 };
 797 #endif
 798
 799
 800 /* maxpacket and other transfer characteristics vary by speed. */
 801 static inline struct usb_endpoint_descriptor *
 802 ep_desc(struct usb_gadget *g, struct usb_endpoint_descriptor *hs,
 803                 struct usb_endpoint_descriptor *fs)
 804 {
 805         if (gadget_is_dualspeed(g) && g->speed == USB_SPEED_HIGH)
 806                 return hs;
 807         return fs;
 808 }
 809
 810 /*-------------------------------------------------------------------------*/
 811
 812 /* descriptors that are built on-demand */
 813
 814 static char manufacturer[50];
 815 static char product_desc[40] = DRIVER_DESC;
 816 static char serial_number[20];
 817
 818 /* address that the host will use ... usually assigned at random */
 819 static char ethaddr[2 * ETH_ALEN + 1];
 820
 821 /* static strings, in UTF-8 */
 822 static struct usb_string                strings[] = {
 823         { STRING_MANUFACTURER,  manufacturer, },
 824         { STRING_PRODUCT,       product_desc, },
 825         { STRING_SERIALNUMBER,  serial_number, },
 826         { STRING_DATA,          "Ethernet Data", },
 827         { STRING_ETHADDR,       ethaddr, },
 828 #ifdef  CONFIG_USB_ETH_CDC
 829         { STRING_CDC,           "CDC Ethernet", },
 830         { STRING_CONTROL,       "CDC Communications Control", },
 831 #endif
 832 #ifdef  CONFIG_USB_ETH_SUBSET
 833         { STRING_SUBSET,        "CDC Ethernet Subset", },
 834 #endif
 835 #ifdef  CONFIG_USB_ETH_RNDIS
 836         { STRING_RNDIS,         "RNDIS", },
 837         { STRING_RNDIS_CONTROL, "RNDIS Communications Control", },
 838 #endif
 839         {  }            /* end of list */
 840 };
 841
 842 static struct usb_gadget_strings        stringtab = {
 843         .language       = 0x0409,       /* en-us */
 844         .strings        = strings,
 845 };
 846
 847 /*============================================================================*/
 848 DEFINE_CACHE_ALIGN_BUFFER(u8, control_req, USB_BUFSIZ);
 849
 850 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
 851 DEFINE_CACHE_ALIGN_BUFFER(u8, status_req, STATUS_BYTECOUNT);
 852 #endif
 853
 854 /*============================================================================*/
 855
 856 /*
 857  * one config, two interfaces:  control, data.
 858  * complications: class descriptors, and an altsetting.
 859  */
 860 static int
 861 config_buf(struct usb_gadget *g, u8 *buf, u8 type, unsigned index, int is_otg)
 862 {
 863         int                                     len;
 864         const struct usb_config_descriptor      *config;
 865         const struct usb_descriptor_header      **function;
 866         int                                     hs = 0;
 867
 868         if (gadget_is_dualspeed(g)) {
 869                 hs = (g->speed == USB_SPEED_HIGH);
 870                 if (type == USB_DT_OTHER_SPEED_CONFIG)
 871                         hs = !hs;
 872         }
 873 #define which_fn(t)     (hs ? hs_ ## t ## _function : fs_ ## t ## _function)
 874
 875         if (index >= device_desc.bNumConfigurations)
 876                 return -EINVAL;
 877
 878 #ifdef  CONFIG_USB_ETH_RNDIS
 879         /*
 880          * list the RNDIS config first, to make Microsoft's drivers
 881          * happy. DOCSIS 1.0 needs this too.
 882          */
 883         if (device_desc.bNumConfigurations == 2 && index == 0) {
 884                 config = &rndis_config;
 885                 function = which_fn(rndis);
 886         } else
 887 #endif
 888         {
 889                 config = &eth_config;
 890                 function = which_fn(eth);
 891         }
 892
 893         /* for now, don't advertise srp-only devices */
 894         if (!is_otg)
 895                 function++;
 896
 897         len = usb_gadget_config_buf(config, buf, USB_BUFSIZ, function);
 898         if (len < 0)
 899                 return len;
 900         ((struct usb_config_descriptor *) buf)->bDescriptorType = type;
 901         return len;
 902 }
 903
 904 /*-------------------------------------------------------------------------*/
 905
 906 static void eth_start(struct eth_dev *dev, gfp_t gfp_flags);
 907 static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags);
 908
 909 static int
 910 set_ether_config(struct eth_dev *dev, gfp_t gfp_flags)
 911 {
 912         int                                     result = 0;
 913         struct usb_gadget                       *gadget = dev->gadget;
 914
 915 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
 916         /* status endpoint used for RNDIS and (optionally) CDC */
 917         if (!subset_active(dev) && dev->status_ep) {
 918                 dev->status = ep_desc(gadget, &hs_status_desc,
 919                                                 &fs_status_desc);
 920                 dev->status_ep->driver_data = dev;
 921
 922                 result = usb_ep_enable(dev->status_ep, dev->status);
 923                 if (result != 0) {
 924                         debug("enable %s --> %d\n",
 925                                 dev->status_ep->name, result);
 926                         goto done;
 927                 }
 928         }
 929 #endif
 930
 931         dev->in = ep_desc(gadget, &hs_source_desc, &fs_source_desc);
 932         dev->in_ep->driver_data = dev;
 933
 934         dev->out = ep_desc(gadget, &hs_sink_desc, &fs_sink_desc);
 935         dev->out_ep->driver_data = dev;
 936
 937         /*
 938          * With CDC,  the host isn't allowed to use these two data
 939          * endpoints in the default altsetting for the interface.
 940          * so we don't activate them yet.  Reset from SET_INTERFACE.
 941          *
 942          * Strictly speaking RNDIS should work the same: activation is
 943          * a side effect of setting a packet filter.  Deactivation is
 944          * from REMOTE_NDIS_HALT_MSG, reset from REMOTE_NDIS_RESET_MSG.
 945          */
 946         if (!cdc_active(dev)) {
 947                 result = usb_ep_enable(dev->in_ep, dev->in);
 948                 if (result != 0) {
 949                         debug("enable %s --> %d\n",
 950                                 dev->in_ep->name, result);
 951                         goto done;
 952                 }
 953
 954                 result = usb_ep_enable(dev->out_ep, dev->out);
 955                 if (result != 0) {
 956                         debug("enable %s --> %d\n",
 957                                 dev->out_ep->name, result);
 958                         goto done;
 959                 }
 960         }
 961
 962 done:
 963         if (result == 0)
 964                 result = alloc_requests(dev, qlen(gadget), gfp_flags);
 965
 966         /* on error, disable any endpoints  */
 967         if (result < 0) {
 968                 if (!subset_active(dev) && dev->status_ep)
 969                         (void) usb_ep_disable(dev->status_ep);
 970                 dev->status = NULL;
 971                 (void) usb_ep_disable(dev->in_ep);
 972                 (void) usb_ep_disable(dev->out_ep);
 973                 dev->in = NULL;
 974                 dev->out = NULL;
 975         } else if (!cdc_active(dev)) {
 976                 /*
 977                  * activate non-CDC configs right away
 978                  * this isn't strictly according to the RNDIS spec
 979                  */
 980                 eth_start(dev, GFP_ATOMIC);
 981         }
 982
 983         /* caller is responsible for cleanup on error */
 984         return result;
 985 }
 986
 987 static void eth_reset_config(struct eth_dev *dev)
 988 {
 989         if (dev->config == 0)
 990                 return;
 991
 992         debug("%s\n", __func__);
 993
 994         rndis_uninit(dev->rndis_config);
 995
 996         /*
 997          * disable endpoints, forcing (synchronous) completion of
 998          * pending i/o.  then free the requests.
 999          */
1000
1001         if (dev->in) {
1002                 usb_ep_disable(dev->in_ep);
1003                 if (dev->tx_req) {
1004                         usb_ep_free_request(dev->in_ep, dev->tx_req);
1005                         dev->tx_req = NULL;
1006                 }
1007         }
1008         if (dev->out) {
1009                 usb_ep_disable(dev->out_ep);
1010                 if (dev->rx_req) {
1011                         usb_ep_free_request(dev->out_ep, dev->rx_req);
1012                         dev->rx_req = NULL;
1013                 }
1014         }
1015         if (dev->status)
1016                 usb_ep_disable(dev->status_ep);
1017
1018         dev->rndis = 0;
1019         dev->cdc_filter = 0;
1020         dev->config = 0;
1021 }
1022
1023 /*
1024  * change our operational config.  must agree with the code
1025  * that returns config descriptors, and altsetting code.
1026  */
1027 static int eth_set_config(struct eth_dev *dev, unsigned number,
1028                                 gfp_t gfp_flags)
1029 {
1030         int                     result = 0;
1031         struct usb_gadget       *gadget = dev->gadget;
1032
1033         if (gadget_is_sa1100(gadget)
1034                         && dev->config
1035                         && dev->tx_qlen != 0) {
1036                 /* tx fifo is full, but we can't clear it...*/
1037                 error("can't change configurations");
1038                 return -ESPIPE;
1039         }
1040         eth_reset_config(dev);
1041
1042         switch (number) {
1043         case DEV_CONFIG_VALUE:
1044                 result = set_ether_config(dev, gfp_flags);
1045                 break;
1046 #ifdef  CONFIG_USB_ETH_RNDIS
1047         case DEV_RNDIS_CONFIG_VALUE:
1048                 dev->rndis = 1;
1049                 result = set_ether_config(dev, gfp_flags);
1050                 break;
1051 #endif
1052         default:
1053                 result = -EINVAL;
1054                 /* FALL THROUGH */
1055         case 0:
1056                 break;
1057         }
1058
1059         if (result) {
1060                 if (number)
1061                         eth_reset_config(dev);
1062                 usb_gadget_vbus_draw(dev->gadget,
1063                                 gadget_is_otg(dev->gadget) ? 8 : 100);
1064         } else {
1065                 char *speed;
1066                 unsigned power;
1067
1068                 power = 2 * eth_config.bMaxPower;
1069                 usb_gadget_vbus_draw(dev->gadget, power);
1070
1071                 switch (gadget->speed) {
1072                 case USB_SPEED_FULL:
1073                         speed = "full"; break;
1074 #ifdef CONFIG_USB_GADGET_DUALSPEED
1075                 case USB_SPEED_HIGH:
1076                         speed = "high"; break;
1077 #endif
1078                 default:
1079                         speed = "?"; break;
1080                 }
1081
1082                 dev->config = number;
1083                 printf("%s speed config #%d: %d mA, %s, using %s\n",
1084                                 speed, number, power, driver_desc,
1085                                 rndis_active(dev)
1086                                         ? "RNDIS"
1087                                         : (cdc_active(dev)
1088                                                 ? "CDC Ethernet"
1089                                                 : "CDC Ethernet Subset"));
1090         }
1091         return result;
1092 }
1093
1094 /*-------------------------------------------------------------------------*/
1095
1096 #ifdef  CONFIG_USB_ETH_CDC
1097
1098 /*
1099  * The interrupt endpoint is used in CDC networking models (Ethernet, ATM)
1100  * only to notify the host about link status changes (which we support) or
1101  * report completion of some encapsulated command (as used in RNDIS).  Since
1102  * we want this CDC Ethernet code to be vendor-neutral, we don't use that
1103  * command mechanism; and only one status request is ever queued.
1104  */
1105 static void eth_status_complete(struct usb_ep *ep, struct usb_request *req)
1106 {
1107         struct usb_cdc_notification     *event = req->buf;
1108         int                             value = req->status;
1109         struct eth_dev                  *dev = ep->driver_data;
1110
1111         /* issue the second notification if host reads the first */
1112         if (event->bNotificationType == USB_CDC_NOTIFY_NETWORK_CONNECTION
1113                         && value == 0) {
1114                 __le32  *data = req->buf + sizeof *event;
1115
1116                 event->bmRequestType = 0xA1;
1117                 event->bNotificationType = USB_CDC_NOTIFY_SPEED_CHANGE;
1118                 event->wValue = __constant_cpu_to_le16(0);
1119                 event->wIndex = __constant_cpu_to_le16(1);
1120                 event->wLength = __constant_cpu_to_le16(8);
1121
1122                 /* SPEED_CHANGE data is up/down speeds in bits/sec */
1123                 data[0] = data[1] = cpu_to_le32(BITRATE(dev->gadget));
1124
1125                 req->length = STATUS_BYTECOUNT;
1126                 value = usb_ep_queue(ep, req, GFP_ATOMIC);
1127                 debug("send SPEED_CHANGE --> %d\n", value);
1128                 if (value == 0)
1129                         return;
1130         } else if (value != -ECONNRESET) {
1131                 debug("event %02x --> %d\n",
1132                         event->bNotificationType, value);
1133                 if (event->bNotificationType ==
1134                                 USB_CDC_NOTIFY_SPEED_CHANGE) {
1135                         l_ethdev.network_started = 1;
1136                         printf("USB network up!\n");
1137                 }
1138         }
1139         req->context = NULL;
1140 }
1141
1142 static void issue_start_status(struct eth_dev *dev)
1143 {
1144         struct usb_request              *req = dev->stat_req;
1145         struct usb_cdc_notification     *event;
1146         int                             value;
1147
1148         /*
1149          * flush old status
1150          *
1151          * FIXME ugly idiom, maybe we'd be better with just
1152          * a "cancel the whole queue" primitive since any
1153          * unlink-one primitive has way too many error modes.
1154          * here, we "know" toggle is already clear...
1155          *
1156          * FIXME iff req->context != null just dequeue it
1157          */
1158         usb_ep_disable(dev->status_ep);
1159         usb_ep_enable(dev->status_ep, dev->status);
1160
1161         /*
1162          * 3.8.1 says to issue first NETWORK_CONNECTION, then
1163          * a SPEED_CHANGE.  could be useful in some configs.
1164          */
1165         event = req->buf;
1166         event->bmRequestType = 0xA1;
1167         event->bNotificationType = USB_CDC_NOTIFY_NETWORK_CONNECTION;
1168         event->wValue = __constant_cpu_to_le16(1);      /* connected */
1169         event->wIndex = __constant_cpu_to_le16(1);
1170         event->wLength = 0;
1171
1172         req->length = sizeof *event;
1173         req->complete = eth_status_complete;
1174         req->context = dev;
1175
1176         value = usb_ep_queue(dev->status_ep, req, GFP_ATOMIC);
1177         if (value < 0)
1178                 debug("status buf queue --> %d\n", value);
1179 }
1180
1181 #endif
1182
1183 /*-------------------------------------------------------------------------*/
1184
1185 static void eth_setup_complete(struct usb_ep *ep, struct usb_request *req)
1186 {
1187         if (req->status || req->actual != req->length)
1188                 debug("setup complete --> %d, %d/%d\n",
1189                                 req->status, req->actual, req->length);
1190 }
1191
1192 #ifdef CONFIG_USB_ETH_RNDIS
1193
1194 static void rndis_response_complete(struct usb_ep *ep, struct usb_request *req)
1195 {
1196         if (req->status || req->actual != req->length)
1197                 debug("rndis response complete --> %d, %d/%d\n",
1198                         req->status, req->actual, req->length);
1199
1200         /* done sending after USB_CDC_GET_ENCAPSULATED_RESPONSE */
1201 }
1202
1203 static void rndis_command_complete(struct usb_ep *ep, struct usb_request *req)
1204 {
1205         struct eth_dev          *dev = ep->driver_data;
1206         int                     status;
1207
1208         /* received RNDIS command from USB_CDC_SEND_ENCAPSULATED_COMMAND */
1209         status = rndis_msg_parser(dev->rndis_config, (u8 *) req->buf);
1210         if (status < 0)
1211                 error("%s: rndis parse error %d", __func__, status);
1212 }
1213
1214 #endif  /* RNDIS */
1215
1216 /*
1217  * The setup() callback implements all the ep0 functionality that's not
1218  * handled lower down.  CDC has a number of less-common features:
1219  *
1220  *  - two interfaces:  control, and ethernet data
1221  *  - Ethernet data interface has two altsettings:  default, and active
1222  *  - class-specific descriptors for the control interface
1223  *  - class-specific control requests
1224  */
1225 static int
1226 eth_setup(struct usb_gadget *gadget, const struct usb_ctrlrequest *ctrl)
1227 {
1228         struct eth_dev          *dev = get_gadget_data(gadget);
1229         struct usb_request      *req = dev->req;
1230         int                     value = -EOPNOTSUPP;
1231         u16                     wIndex = le16_to_cpu(ctrl->wIndex);
1232         u16                     wValue = le16_to_cpu(ctrl->wValue);
1233         u16                     wLength = le16_to_cpu(ctrl->wLength);
1234
1235         /*
1236          * descriptors just go into the pre-allocated ep0 buffer,
1237          * while config change events may enable network traffic.
1238          */
1239
1240         debug("%s\n", __func__);
1241
1242         req->complete = eth_setup_complete;
1243         switch (ctrl->bRequest) {
1244
1245         case USB_REQ_GET_DESCRIPTOR:
1246                 if (ctrl->bRequestType != USB_DIR_IN)
1247                         break;
1248                 switch (wValue >> 8) {
1249
1250                 case USB_DT_DEVICE:
1251                         value = min(wLength, (u16) sizeof device_desc);
1252                         memcpy(req->buf, &device_desc, value);
1253                         break;
1254                 case USB_DT_DEVICE_QUALIFIER:
1255                         if (!gadget_is_dualspeed(gadget))
1256                                 break;
1257                         value = min(wLength, (u16) sizeof dev_qualifier);
1258                         memcpy(req->buf, &dev_qualifier, value);
1259                         break;
1260
1261                 case USB_DT_OTHER_SPEED_CONFIG:
1262                         if (!gadget_is_dualspeed(gadget))
1263                                 break;
1264                         /* FALLTHROUGH */
1265                 case USB_DT_CONFIG:
1266                         value = config_buf(gadget, req->buf,
1267                                         wValue >> 8,
1268                                         wValue & 0xff,
1269                                         gadget_is_otg(gadget));
1270                         if (value >= 0)
1271                                 value = min(wLength, (u16) value);
1272                         break;
1273
1274                 case USB_DT_STRING:
1275                         value = usb_gadget_get_string(&stringtab,
1276                                         wValue & 0xff, req->buf);
1277
1278                         if (value >= 0)
1279                                 value = min(wLength, (u16) value);
1280
1281                         break;
1282                 }
1283                 break;
1284
1285         case USB_REQ_SET_CONFIGURATION:
1286                 if (ctrl->bRequestType != 0)
1287                         break;
1288                 if (gadget->a_hnp_support)
1289                         debug("HNP available\n");
1290                 else if (gadget->a_alt_hnp_support)
1291                         debug("HNP needs a different root port\n");
1292                 value = eth_set_config(dev, wValue, GFP_ATOMIC);
1293                 break;
1294         case USB_REQ_GET_CONFIGURATION:
1295                 if (ctrl->bRequestType != USB_DIR_IN)
1296                         break;
1297                 *(u8 *)req->buf = dev->config;
1298                 value = min(wLength, (u16) 1);
1299                 break;
1300
1301         case USB_REQ_SET_INTERFACE:
1302                 if (ctrl->bRequestType != USB_RECIP_INTERFACE
1303                                 || !dev->config
1304                                 || wIndex > 1)
1305                         break;
1306                 if (!cdc_active(dev) && wIndex != 0)
1307                         break;
1308
1309                 /*
1310                  * PXA hardware partially handles SET_INTERFACE;
1311                  * we need to kluge around that interference.
1312                  */
1313                 if (gadget_is_pxa(gadget)) {
1314                         value = eth_set_config(dev, DEV_CONFIG_VALUE,
1315                                                 GFP_ATOMIC);
1316                         /*
1317                          * PXA25x driver use non-CDC ethernet gadget.
1318                          * But only _CDC and _RNDIS code can signalize
1319                          * that network is working. So we signalize it
1320                          * here.
1321                          */
1322                         l_ethdev.network_started = 1;
1323                         debug("USB network up!\n");
1324                         goto done_set_intf;
1325                 }
1326
1327 #ifdef CONFIG_USB_ETH_CDC
1328                 switch (wIndex) {
1329                 case 0:         /* control/master intf */
1330                         if (wValue != 0)
1331                                 break;
1332                         if (dev->status) {
1333                                 usb_ep_disable(dev->status_ep);
1334                                 usb_ep_enable(dev->status_ep, dev->status);
1335                         }
1336
1337                         value = 0;
1338                         break;
1339                 case 1:         /* data intf */
1340                         if (wValue > 1)
1341                                 break;
1342                         usb_ep_disable(dev->in_ep);
1343                         usb_ep_disable(dev->out_ep);
1344
1345                         /*
1346                          * CDC requires the data transfers not be done from
1347                          * the default interface setting ... also, setting
1348                          * the non-default interface resets filters etc.
1349                          */
1350                         if (wValue == 1) {
1351                                 if (!cdc_active(dev))
1352                                         break;
1353                                 usb_ep_enable(dev->in_ep, dev->in);
1354                                 usb_ep_enable(dev->out_ep, dev->out);
1355                                 dev->cdc_filter = DEFAULT_FILTER;
1356                                 if (dev->status)
1357                                         issue_start_status(dev);
1358                                 eth_start(dev, GFP_ATOMIC);
1359                         }
1360                         value = 0;
1361                         break;
1362                 }
1363 #else
1364                 /*
1365                  * FIXME this is wrong, as is the assumption that
1366                  * all non-PXA hardware talks real CDC ...
1367                  */
1368                 debug("set_interface ignored!\n");
1369 #endif /* CONFIG_USB_ETH_CDC */
1370
1371 done_set_intf:
1372                 break;
1373         case USB_REQ_GET_INTERFACE:
1374                 if (ctrl->bRequestType != (USB_DIR_IN|USB_RECIP_INTERFACE)
1375                                 || !dev->config
1376                                 || wIndex > 1)
1377                         break;
1378                 if (!(cdc_active(dev) || rndis_active(dev)) && wIndex != 0)
1379                         break;
1380
1381                 /* for CDC, iff carrier is on, data interface is active. */
1382                 if (rndis_active(dev) || wIndex != 1)
1383                         *(u8 *)req->buf = 0;
1384                 else {
1385                         /* *(u8 *)req->buf = netif_carrier_ok (dev->net) ? 1 : 0; */
1386                         /* carrier always ok ...*/
1387                         *(u8 *)req->buf = 1 ;
1388                 }
1389                 value = min(wLength, (u16) 1);
1390                 break;
1391
1392 #ifdef CONFIG_USB_ETH_CDC
1393         case USB_CDC_SET_ETHERNET_PACKET_FILTER:
1394                 /*
1395                  * see 6.2.30: no data, wIndex = interface,
1396                  * wValue = packet filter bitmap
1397                  */
1398                 if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1399                                 || !cdc_active(dev)
1400                                 || wLength != 0
1401                                 || wIndex > 1)
1402                         break;
1403                 debug("packet filter %02x\n", wValue);
1404                 dev->cdc_filter = wValue;
1405                 value = 0;
1406                 break;
1407
1408         /*
1409          * and potentially:
1410          * case USB_CDC_SET_ETHERNET_MULTICAST_FILTERS:
1411          * case USB_CDC_SET_ETHERNET_PM_PATTERN_FILTER:
1412          * case USB_CDC_GET_ETHERNET_PM_PATTERN_FILTER:
1413          * case USB_CDC_GET_ETHERNET_STATISTIC:
1414          */
1415
1416 #endif /* CONFIG_USB_ETH_CDC */
1417
1418 #ifdef CONFIG_USB_ETH_RNDIS
1419         /*
1420          * RNDIS uses the CDC command encapsulation mechanism to implement
1421          * an RPC scheme, with much getting/setting of attributes by OID.
1422          */
1423         case USB_CDC_SEND_ENCAPSULATED_COMMAND:
1424                 if (ctrl->bRequestType != (USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1425                                 || !rndis_active(dev)
1426                                 || wLength > USB_BUFSIZ
1427                                 || wValue
1428                                 || rndis_control_intf.bInterfaceNumber
1429                                         != wIndex)
1430                         break;
1431                 /* read the request, then process it */
1432                 value = wLength;
1433                 req->complete = rndis_command_complete;
1434                 /* later, rndis_control_ack () sends a notification */
1435                 break;
1436
1437         case USB_CDC_GET_ENCAPSULATED_RESPONSE:
1438                 if ((USB_DIR_IN|USB_TYPE_CLASS|USB_RECIP_INTERFACE)
1439                                         == ctrl->bRequestType
1440                                 && rndis_active(dev)
1441                                 /* && wLength >= 0x0400 */
1442                                 && !wValue
1443                                 && rndis_control_intf.bInterfaceNumber
1444                                         == wIndex) {
1445                         u8 *buf;
1446                         u32 n;
1447
1448                         /* return the result */
1449                         buf = rndis_get_next_response(dev->rndis_config, &n);
1450                         if (buf) {
1451                                 memcpy(req->buf, buf, n);
1452                                 req->complete = rndis_response_complete;
1453                                 rndis_free_response(dev->rndis_config, buf);
1454                                 value = n;
1455                         }
1456                         /* else stalls ... spec says to avoid that */
1457                 }
1458                 break;
1459 #endif  /* RNDIS */
1460
1461         default:
1462                 debug("unknown control req%02x.%02x v%04x i%04x l%d\n",
1463                         ctrl->bRequestType, ctrl->bRequest,
1464                         wValue, wIndex, wLength);
1465         }
1466
1467         /* respond with data transfer before status phase? */
1468         if (value >= 0) {
1469                 debug("respond with data transfer before status phase\n");
1470                 req->length = value;
1471                 req->zero = value < wLength
1472                                 && (value % gadget->ep0->maxpacket) == 0;
1473                 value = usb_ep_queue(gadget->ep0, req, GFP_ATOMIC);
1474                 if (value < 0) {
1475                         debug("ep_queue --> %d\n", value);
1476                         req->status = 0;
1477                         eth_setup_complete(gadget->ep0, req);
1478                 }
1479         }
1480
1481         /* host either stalls (value < 0) or reports success */
1482         return value;
1483 }
1484
1485 /*-------------------------------------------------------------------------*/
1486
1487 static void rx_complete(struct usb_ep *ep, struct usb_request *req);
1488
1489 static int rx_submit(struct eth_dev *dev, struct usb_request *req,
1490                                 gfp_t gfp_flags)
1491 {
1492         int                     retval = -ENOMEM;
1493         size_t                  size;
1494
1495         /*
1496          * Padding up to RX_EXTRA handles minor disagreements with host.
1497          * Normally we use the USB "terminate on short read" convention;
1498          * so allow up to (N*maxpacket), since that memory is normally
1499          * already allocated.  Some hardware doesn't deal well with short
1500          * reads (e.g. DMA must be N*maxpacket), so for now don't trim a
1501          * byte off the end (to force hardware errors on overflow).
1502          *
1503          * RNDIS uses internal framing, and explicitly allows senders to
1504          * pad to end-of-packet.  That's potentially nice for speed,
1505          * but means receivers can't recover synch on their own.
1506          */
1507
1508         debug("%s\n", __func__);
1509         if (!req)
1510                 return -EINVAL;
1511
1512         size = (ETHER_HDR_SIZE + dev->mtu + RX_EXTRA);
1513         size += dev->out_ep->maxpacket - 1;
1514         if (rndis_active(dev))
1515                 size += sizeof(struct rndis_packet_msg_type);
1516         size -= size % dev->out_ep->maxpacket;
1517
1518         /*
1519          * Some platforms perform better when IP packets are aligned,
1520          * but on at least one, checksumming fails otherwise.  Note:
1521          * RNDIS headers involve variable numbers of LE32 values.
1522          */
1523
1524         req->buf = (u8 *) NetRxPackets[0];
1525         req->length = size;
1526         req->complete = rx_complete;
1527
1528         retval = usb_ep_queue(dev->out_ep, req, gfp_flags);
1529
1530         if (retval)
1531                 error("rx submit --> %d", retval);
1532
1533         return retval;
1534 }
1535
1536 static void rx_complete(struct usb_ep *ep, struct usb_request *req)
1537 {
1538         struct eth_dev  *dev = ep->driver_data;
1539
1540         debug("%s: status %d\n", __func__, req->status);
1541         switch (req->status) {
1542         /* normal completion */
1543         case 0:
1544                 if (rndis_active(dev)) {
1545                         /* we know MaxPacketsPerTransfer == 1 here */
1546                         int length = rndis_rm_hdr(req->buf, req->actual);
1547                         if (length < 0)
1548                                 goto length_err;
1549                         req->length -= length;
1550                         req->actual -= length;
1551                 }
1552                 if (req->actual < ETH_HLEN || ETH_FRAME_LEN < req->actual) {
1553 length_err:
1554                         dev->stats.rx_errors++;
1555                         dev->stats.rx_length_errors++;
1556                         debug("rx length %d\n", req->length);
1557                         break;
1558                 }
1559
1560                 dev->stats.rx_packets++;
1561                 dev->stats.rx_bytes += req->length;
1562                 break;
1563
1564         /* software-driven interface shutdown */
1565         case -ECONNRESET:               /* unlink */
1566         case -ESHUTDOWN:                /* disconnect etc */
1567         /* for hardware automagic (such as pxa) */
1568         case -ECONNABORTED:             /* endpoint reset */
1569                 break;
1570
1571         /* data overrun */
1572         case -EOVERFLOW:
1573                 dev->stats.rx_over_errors++;
1574                 /* FALLTHROUGH */
1575         default:
1576                 dev->stats.rx_errors++;
1577                 break;
1578         }
1579
1580         packet_received = 1;
1581 }
1582
1583 static int alloc_requests(struct eth_dev *dev, unsigned n, gfp_t gfp_flags)
1584 {
1585
1586         dev->tx_req = usb_ep_alloc_request(dev->in_ep, 0);
1587
1588         if (!dev->tx_req)
1589                 goto fail1;
1590
1591         dev->rx_req = usb_ep_alloc_request(dev->out_ep, 0);
1592
1593         if (!dev->rx_req)
1594                 goto fail2;
1595
1596         return 0;
1597
1598 fail2:
1599         usb_ep_free_request(dev->in_ep, dev->tx_req);
1600 fail1:
1601         error("can't alloc requests");
1602         return -1;
1603 }
1604
1605 static void tx_complete(struct usb_ep *ep, struct usb_request *req)
1606 {
1607         struct eth_dev  *dev = ep->driver_data;
1608
1609         debug("%s: status %s\n", __func__, (req->status) ? "failed" : "ok");
1610         switch (req->status) {
1611         default:
1612                 dev->stats.tx_errors++;
1613                 debug("tx err %d\n", req->status);
1614                 /* FALLTHROUGH */
1615         case -ECONNRESET:               /* unlink */
1616         case -ESHUTDOWN:                /* disconnect etc */
1617                 break;
1618         case 0:
1619                 dev->stats.tx_bytes += req->length;
1620         }
1621         dev->stats.tx_packets++;
1622
1623         packet_sent = 1;
1624 }
1625
1626 static inline int eth_is_promisc(struct eth_dev *dev)
1627 {
1628         /* no filters for the CDC subset; always promisc */
1629         if (subset_active(dev))
1630                 return 1;
1631         return dev->cdc_filter & USB_CDC_PACKET_TYPE_PROMISCUOUS;
1632 }
1633
1634 #if 0
1635 static int eth_start_xmit (struct sk_buff *skb, struct net_device *net)
1636 {
1637         struct eth_dev          *dev = netdev_priv(net);
1638         int                     length = skb->len;
1639         int                     retval;
1640         struct usb_request      *req = NULL;
1641         unsigned long           flags;
1642
1643         /* apply outgoing CDC or RNDIS filters */
1644         if (!eth_is_promisc (dev)) {
1645                 u8              *dest = skb->data;
1646
1647                 if (is_multicast_ether_addr(dest)) {
1648                         u16     type;
1649
1650                         /* ignores USB_CDC_PACKET_TYPE_MULTICAST and host
1651                          * SET_ETHERNET_MULTICAST_FILTERS requests
1652                          */
1653                         if (is_broadcast_ether_addr(dest))
1654                                 type = USB_CDC_PACKET_TYPE_BROADCAST;
1655                         else
1656                                 type = USB_CDC_PACKET_TYPE_ALL_MULTICAST;
1657                         if (!(dev->cdc_filter & type)) {
1658                                 dev_kfree_skb_any (skb);
1659                                 return 0;
1660                         }
1661                 }
1662                 /* ignores USB_CDC_PACKET_TYPE_DIRECTED */
1663         }
1664
1665         spin_lock_irqsave(&dev->req_lock, flags);
1666         /*
1667          * this freelist can be empty if an interrupt triggered disconnect()
1668          * and reconfigured the gadget (shutting down this queue) after the
1669          * network stack decided to xmit but before we got the spinlock.
1670          */
1671         if (list_empty(&dev->tx_reqs)) {
1672                 spin_unlock_irqrestore(&dev->req_lock, flags);
1673                 return 1;
1674         }
1675
1676         req = container_of (dev->tx_reqs.next, struct usb_request, list);
1677         list_del (&req->list);
1678
1679         /* temporarily stop TX queue when the freelist empties */
1680         if (list_empty (&dev->tx_reqs))
1681                 netif_stop_queue (net);
1682         spin_unlock_irqrestore(&dev->req_lock, flags);
1683
1684         /* no buffer copies needed, unless the network stack did it
1685          * or the hardware can't use skb buffers.
1686          * or there's not enough space for any RNDIS headers we need
1687          */
1688         if (rndis_active(dev)) {
1689                 struct sk_buff  *skb_rndis;
1690
1691                 skb_rndis = skb_realloc_headroom (skb,
1692                                 sizeof (struct rndis_packet_msg_type));
1693                 if (!skb_rndis)
1694                         goto drop;
1695
1696                 dev_kfree_skb_any (skb);
1697                 skb = skb_rndis;
1698                 rndis_add_hdr (skb);
1699                 length = skb->len;
1700         }
1701         req->buf = skb->data;
1702         req->context = skb;
1703         req->complete = tx_complete;
1704
1705         /* use zlp framing on tx for strict CDC-Ether conformance,
1706          * though any robust network rx path ignores extra padding.
1707          * and some hardware doesn't like to write zlps.
1708          */
1709         req->zero = 1;
1710         if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
1711                 length++;
1712
1713         req->length = length;
1714
1715         /* throttle highspeed IRQ rate back slightly */
1716         if (gadget_is_dualspeed(dev->gadget))
1717                 req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
1718                         ? ((atomic_read(&dev->tx_qlen) % qmult) != 0)
1719                         : 0;
1720
1721         retval = usb_ep_queue (dev->in_ep, req, GFP_ATOMIC);
1722         switch (retval) {
1723         default:
1724                 DEBUG (dev, "tx queue err %d\n", retval);
1725                 break;
1726         case 0:
1727                 net->trans_start = jiffies;
1728                 atomic_inc (&dev->tx_qlen);
1729         }
1730
1731         if (retval) {
1732 drop:
1733                 dev->stats.tx_dropped++;
1734                 dev_kfree_skb_any (skb);
1735                 spin_lock_irqsave(&dev->req_lock, flags);
1736                 if (list_empty (&dev->tx_reqs))
1737                         netif_start_queue (net);
1738                 list_add (&req->list, &dev->tx_reqs);
1739                 spin_unlock_irqrestore(&dev->req_lock, flags);
1740         }
1741         return 0;
1742 }
1743
1744 /*-------------------------------------------------------------------------*/
1745 #endif
1746
1747 static void eth_unbind(struct usb_gadget *gadget)
1748 {
1749         struct eth_dev          *dev = get_gadget_data(gadget);
1750
1751         debug("%s...\n", __func__);
1752         rndis_deregister(dev->rndis_config);
1753         rndis_exit();
1754
1755         /* we've already been disconnected ... no i/o is active */
1756         if (dev->req) {
1757                 usb_ep_free_request(gadget->ep0, dev->req);
1758                 dev->req = NULL;
1759         }
1760         if (dev->stat_req) {
1761                 usb_ep_free_request(dev->status_ep, dev->stat_req);
1762                 dev->stat_req = NULL;
1763         }
1764
1765         if (dev->tx_req) {
1766                 usb_ep_free_request(dev->in_ep, dev->tx_req);
1767                 dev->tx_req = NULL;
1768         }
1769
1770         if (dev->rx_req) {
1771                 usb_ep_free_request(dev->out_ep, dev->rx_req);
1772                 dev->rx_req = NULL;
1773         }
1774
1775 /*      unregister_netdev (dev->net);*/
1776 /*      free_netdev(dev->net);*/
1777
1778         dev->gadget = NULL;
1779         set_gadget_data(gadget, NULL);
1780 }
1781
1782 static void eth_disconnect(struct usb_gadget *gadget)
1783 {
1784         eth_reset_config(get_gadget_data(gadget));
1785         /* FIXME RNDIS should enter RNDIS_UNINITIALIZED */
1786 }
1787
1788 static void eth_suspend(struct usb_gadget *gadget)
1789 {
1790         /* Not used */
1791 }
1792
1793 static void eth_resume(struct usb_gadget *gadget)
1794 {
1795         /* Not used */
1796 }
1797
1798 /*-------------------------------------------------------------------------*/
1799
1800 #ifdef CONFIG_USB_ETH_RNDIS
1801
1802 /*
1803  * The interrupt endpoint is used in RNDIS to notify the host when messages
1804  * other than data packets are available ... notably the REMOTE_NDIS_*_CMPLT
1805  * messages, but also REMOTE_NDIS_INDICATE_STATUS_MSG and potentially even
1806  * REMOTE_NDIS_KEEPALIVE_MSG.
1807  *
1808  * The RNDIS control queue is processed by GET_ENCAPSULATED_RESPONSE, and
1809  * normally just one notification will be queued.
1810  */
1811
1812 static void rndis_control_ack_complete(struct usb_ep *ep,
1813                                         struct usb_request *req)
1814 {
1815         struct eth_dev          *dev = ep->driver_data;
1816
1817         debug("%s...\n", __func__);
1818         if (req->status || req->actual != req->length)
1819                 debug("rndis control ack complete --> %d, %d/%d\n",
1820                         req->status, req->actual, req->length);
1821
1822         if (!l_ethdev.network_started) {
1823                 if (rndis_get_state(dev->rndis_config)
1824                                 == RNDIS_DATA_INITIALIZED) {
1825                         l_ethdev.network_started = 1;
1826                         printf("USB RNDIS network up!\n");
1827                 }
1828         }
1829
1830         req->context = NULL;
1831
1832         if (req != dev->stat_req)
1833                 usb_ep_free_request(ep, req);
1834 }
1835
1836 static char rndis_resp_buf[8] __attribute__((aligned(sizeof(__le32))));
1837
1838 static int rndis_control_ack(struct eth_device *net)
1839 {
1840         struct eth_dev          *dev = &l_ethdev;
1841         int                     length;
1842         struct usb_request      *resp = dev->stat_req;
1843
1844         /* in case RNDIS calls this after disconnect */
1845         if (!dev->status) {
1846                 debug("status ENODEV\n");
1847                 return -ENODEV;
1848         }
1849
1850         /* in case queue length > 1 */
1851         if (resp->context) {
1852                 resp = usb_ep_alloc_request(dev->status_ep, GFP_ATOMIC);
1853                 if (!resp)
1854                         return -ENOMEM;
1855                 resp->buf = rndis_resp_buf;
1856         }
1857
1858         /*
1859          * Send RNDIS RESPONSE_AVAILABLE notification;
1860          * USB_CDC_NOTIFY_RESPONSE_AVAILABLE should work too
1861          */
1862         resp->length = 8;
1863         resp->complete = rndis_control_ack_complete;
1864         resp->context = dev;
1865
1866         *((__le32 *) resp->buf) = __constant_cpu_to_le32(1);
1867         *((__le32 *) (resp->buf + 4)) = __constant_cpu_to_le32(0);
1868
1869         length = usb_ep_queue(dev->status_ep, resp, GFP_ATOMIC);
1870         if (length < 0) {
1871                 resp->status = 0;
1872                 rndis_control_ack_complete(dev->status_ep, resp);
1873         }
1874
1875         return 0;
1876 }
1877
1878 #else
1879
1880 #define rndis_control_ack       NULL
1881
1882 #endif  /* RNDIS */
1883
1884 static void eth_start(struct eth_dev *dev, gfp_t gfp_flags)
1885 {
1886         if (rndis_active(dev)) {
1887                 rndis_set_param_medium(dev->rndis_config,
1888                                         NDIS_MEDIUM_802_3,
1889                                         BITRATE(dev->gadget)/100);
1890                 rndis_signal_connect(dev->rndis_config);
1891         }
1892 }
1893
1894 static int eth_stop(struct eth_dev *dev)
1895 {
1896 #ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT
1897         unsigned long ts;
1898         unsigned long timeout = CONFIG_SYS_HZ; /* 1 sec to stop RNDIS */
1899 #endif
1900
1901         if (rndis_active(dev)) {
1902                 rndis_set_param_medium(dev->rndis_config, NDIS_MEDIUM_802_3, 0);
1903                 rndis_signal_disconnect(dev->rndis_config);
1904
1905 #ifdef RNDIS_COMPLETE_SIGNAL_DISCONNECT
1906                 /* Wait until host receives OID_GEN_MEDIA_CONNECT_STATUS */
1907                 ts = get_timer(0);
1908                 while (get_timer(ts) < timeout)
1909                         usb_gadget_handle_interrupts();
1910 #endif
1911
1912                 rndis_uninit(dev->rndis_config);
1913                 dev->rndis = 0;
1914         }
1915
1916         return 0;
1917 }
1918
1919 /*-------------------------------------------------------------------------*/
1920
1921 static int is_eth_addr_valid(char *str)
1922 {
1923         if (strlen(str) == 17) {
1924                 int i;
1925                 char *p, *q;
1926                 uchar ea[6];
1927
1928                 /* see if it looks like an ethernet address */
1929
1930                 p = str;
1931
1932                 for (i = 0; i < 6; i++) {
1933                         char term = (i == 5 ? '\0' : ':');
1934
1935                         ea[i] = simple_strtol(p, &q, 16);
1936
1937                         if ((q - p) != 2 || *q++ != term)
1938                                 break;
1939
1940                         p = q;
1941                 }
1942
1943                 /* Now check the contents. */
1944                 return is_valid_ether_addr(ea);
1945         }
1946         return 0;
1947 }
1948
1949 static u8 nibble(unsigned char c)
1950 {
1951         if (likely(isdigit(c)))
1952                 return c - '0';
1953         c = toupper(c);
1954         if (likely(isxdigit(c)))
1955                 return 10 + c - 'A';
1956         return 0;
1957 }
1958
1959 static int get_ether_addr(const char *str, u8 *dev_addr)
1960 {
1961         if (str) {
1962                 unsigned        i;
1963
1964                 for (i = 0; i < 6; i++) {
1965                         unsigned char num;
1966
1967                         if ((*str == '.') || (*str == ':'))
1968                                 str++;
1969                         num = nibble(*str++) << 4;
1970                         num |= (nibble(*str++));
1971                         dev_addr[i] = num;
1972                 }
1973                 if (is_valid_ether_addr(dev_addr))
1974                         return 0;
1975         }
1976         return 1;
1977 }
1978
1979 static int eth_bind(struct usb_gadget *gadget)
1980 {
1981         struct eth_dev          *dev = &l_ethdev;
1982         u8                      cdc = 1, zlp = 1, rndis = 1;
1983         struct usb_ep           *in_ep, *out_ep, *status_ep = NULL;
1984         int                     status = -ENOMEM;
1985         int                     gcnum;
1986         u8                      tmp[7];
1987
1988         /* these flags are only ever cleared; compiler take note */
1989 #ifndef CONFIG_USB_ETH_CDC
1990         cdc = 0;
1991 #endif
1992 #ifndef CONFIG_USB_ETH_RNDIS
1993         rndis = 0;
1994 #endif
1995         /*
1996          * Because most host side USB stacks handle CDC Ethernet, that
1997          * standard protocol is _strongly_ preferred for interop purposes.
1998          * (By everyone except Microsoft.)
1999          */
2000         if (gadget_is_pxa(gadget)) {
2001                 /* pxa doesn't support altsettings */
2002                 cdc = 0;
2003         } else if (gadget_is_musbhdrc(gadget)) {
2004                 /* reduce tx dma overhead by avoiding special cases */
2005                 zlp = 0;
2006         } else if (gadget_is_sh(gadget)) {
2007                 /* sh doesn't support multiple interfaces or configs */
2008                 cdc = 0;
2009                 rndis = 0;
2010         } else if (gadget_is_sa1100(gadget)) {
2011                 /* hardware can't write zlps */
2012                 zlp = 0;
2013                 /*
2014                  * sa1100 CAN do CDC, without status endpoint ... we use
2015                  * non-CDC to be compatible with ARM Linux-2.4 "usb-eth".
2016                  */
2017                 cdc = 0;
2018         }
2019
2020         gcnum = usb_gadget_controller_number(gadget);
2021         if (gcnum >= 0)
2022                 device_desc.bcdDevice = cpu_to_le16(0x0300 + gcnum);
2023         else {
2024                 /*
2025                  * can't assume CDC works.  don't want to default to
2026                  * anything less functional on CDC-capable hardware,
2027                  * so we fail in this case.
2028                  */
2029                 error("controller '%s' not recognized",
2030                         gadget->name);
2031                 return -ENODEV;
2032         }
2033
2034         /*
2035          * If there's an RNDIS configuration, that's what Windows wants to
2036          * be using ... so use these product IDs here and in the "linux.inf"
2037          * needed to install MSFT drivers.  Current Linux kernels will use
2038          * the second configuration if it's CDC Ethernet, and need some help
2039          * to choose the right configuration otherwise.
2040          */
2041         if (rndis) {
2042 #if defined(CONFIG_USB_RNDIS_VENDOR_ID) && defined(CONFIG_USB_RNDIS_PRODUCT_ID)
2043                 device_desc.idVendor =
2044                         __constant_cpu_to_le16(CONFIG_USB_RNDIS_VENDOR_ID);
2045                 device_desc.idProduct =
2046                         __constant_cpu_to_le16(CONFIG_USB_RNDIS_PRODUCT_ID);
2047 #else
2048                 device_desc.idVendor =
2049                         __constant_cpu_to_le16(RNDIS_VENDOR_NUM);
2050                 device_desc.idProduct =
2051                         __constant_cpu_to_le16(RNDIS_PRODUCT_NUM);
2052 #endif
2053                 sprintf(product_desc, "RNDIS/%s", driver_desc);
2054
2055         /*
2056          * CDC subset ... recognized by Linux since 2.4.10, but Windows
2057          * drivers aren't widely available.  (That may be improved by
2058          * supporting one submode of the "SAFE" variant of MDLM.)
2059          */
2060         } else {
2061 #if defined(CONFIG_USB_CDC_VENDOR_ID) && defined(CONFIG_USB_CDC_PRODUCT_ID)
2062                 device_desc.idVendor = cpu_to_le16(CONFIG_USB_CDC_VENDOR_ID);
2063                 device_desc.idProduct = cpu_to_le16(CONFIG_USB_CDC_PRODUCT_ID);
2064 #else
2065                 if (!cdc) {
2066                         device_desc.idVendor =
2067                                 __constant_cpu_to_le16(SIMPLE_VENDOR_NUM);
2068                         device_desc.idProduct =
2069                                 __constant_cpu_to_le16(SIMPLE_PRODUCT_NUM);
2070                 }
2071 #endif
2072         }
2073         /* support optional vendor/distro customization */
2074         if (bcdDevice)
2075                 device_desc.bcdDevice = cpu_to_le16(bcdDevice);
2076         if (iManufacturer)
2077                 strlcpy(manufacturer, iManufacturer, sizeof manufacturer);
2078         if (iProduct)
2079                 strlcpy(product_desc, iProduct, sizeof product_desc);
2080         if (iSerialNumber) {
2081                 device_desc.iSerialNumber = STRING_SERIALNUMBER,
2082                 strlcpy(serial_number, iSerialNumber, sizeof serial_number);
2083         }
2084
2085         /* all we really need is bulk IN/OUT */
2086         usb_ep_autoconfig_reset(gadget);
2087         in_ep = usb_ep_autoconfig(gadget, &fs_source_desc);
2088         if (!in_ep) {
2089 autoconf_fail:
2090                 error("can't autoconfigure on %s\n",
2091                         gadget->name);
2092                 return -ENODEV;
2093         }
2094         in_ep->driver_data = in_ep;     /* claim */
2095
2096         out_ep = usb_ep_autoconfig(gadget, &fs_sink_desc);
2097         if (!out_ep)
2098                 goto autoconf_fail;
2099         out_ep->driver_data = out_ep;   /* claim */
2100
2101 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
2102         /*
2103          * CDC Ethernet control interface doesn't require a status endpoint.
2104          * Since some hosts expect one, try to allocate one anyway.
2105          */
2106         if (cdc || rndis) {
2107                 status_ep = usb_ep_autoconfig(gadget, &fs_status_desc);
2108                 if (status_ep) {
2109                         status_ep->driver_data = status_ep;     /* claim */
2110                 } else if (rndis) {
2111                         error("can't run RNDIS on %s", gadget->name);
2112                         return -ENODEV;
2113 #ifdef CONFIG_USB_ETH_CDC
2114                 } else if (cdc) {
2115                         control_intf.bNumEndpoints = 0;
2116                         /* FIXME remove endpoint from descriptor list */
2117 #endif
2118                 }
2119         }
2120 #endif
2121
2122         /* one config:  cdc, else minimal subset */
2123         if (!cdc) {
2124                 eth_config.bNumInterfaces = 1;
2125                 eth_config.iConfiguration = STRING_SUBSET;
2126
2127                 /*
2128                  * use functions to set these up, in case we're built to work
2129                  * with multiple controllers and must override CDC Ethernet.
2130                  */
2131                 fs_subset_descriptors();
2132                 hs_subset_descriptors();
2133         }
2134
2135         device_desc.bMaxPacketSize0 = gadget->ep0->maxpacket;
2136         usb_gadget_set_selfpowered(gadget);
2137
2138         /* For now RNDIS is always a second config */
2139         if (rndis)
2140                 device_desc.bNumConfigurations = 2;
2141
2142         if (gadget_is_dualspeed(gadget)) {
2143                 if (rndis)
2144                         dev_qualifier.bNumConfigurations = 2;
2145                 else if (!cdc)
2146                         dev_qualifier.bDeviceClass = USB_CLASS_VENDOR_SPEC;
2147
2148                 /* assumes ep0 uses the same value for both speeds ... */
2149                 dev_qualifier.bMaxPacketSize0 = device_desc.bMaxPacketSize0;
2150
2151                 /* and that all endpoints are dual-speed */
2152                 hs_source_desc.bEndpointAddress =
2153                                 fs_source_desc.bEndpointAddress;
2154                 hs_sink_desc.bEndpointAddress =
2155                                 fs_sink_desc.bEndpointAddress;
2156 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
2157                 if (status_ep)
2158                         hs_status_desc.bEndpointAddress =
2159                                         fs_status_desc.bEndpointAddress;
2160 #endif
2161         }
2162
2163         if (gadget_is_otg(gadget)) {
2164                 otg_descriptor.bmAttributes |= USB_OTG_HNP,
2165                 eth_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
2166                 eth_config.bMaxPower = 4;
2167 #ifdef  CONFIG_USB_ETH_RNDIS
2168                 rndis_config.bmAttributes |= USB_CONFIG_ATT_WAKEUP;
2169                 rndis_config.bMaxPower = 4;
2170 #endif
2171         }
2172
2173
2174         /* network device setup */
2175         dev->net = &l_netdev;
2176
2177         dev->cdc = cdc;
2178         dev->zlp = zlp;
2179
2180         dev->in_ep = in_ep;
2181         dev->out_ep = out_ep;
2182         dev->status_ep = status_ep;
2183
2184         /*
2185          * Module params for these addresses should come from ID proms.
2186          * The host side address is used with CDC and RNDIS, and commonly
2187          * ends up in a persistent config database.  It's not clear if
2188          * host side code for the SAFE thing cares -- its original BLAN
2189          * thing didn't, Sharp never assigned those addresses on Zaurii.
2190          */
2191         get_ether_addr(dev_addr, dev->net->enetaddr);
2192
2193         memset(tmp, 0, sizeof(tmp));
2194         memcpy(tmp, dev->net->enetaddr, sizeof(dev->net->enetaddr));
2195
2196         get_ether_addr(host_addr, dev->host_mac);
2197
2198         sprintf(ethaddr, "%02X%02X%02X%02X%02X%02X",
2199                 dev->host_mac[0], dev->host_mac[1],
2200                         dev->host_mac[2], dev->host_mac[3],
2201                         dev->host_mac[4], dev->host_mac[5]);
2202
2203         if (rndis) {
2204                 status = rndis_init();
2205                 if (status < 0) {
2206                         error("can't init RNDIS, %d", status);
2207                         goto fail;
2208                 }
2209         }
2210
2211         /*
2212          * use PKTSIZE (or aligned... from u-boot) and set
2213          * wMaxSegmentSize accordingly
2214          */
2215         dev->mtu = PKTSIZE_ALIGN; /* RNDIS does not like this, only 1514, TODO*/
2216
2217         /* preallocate control message data and buffer */
2218         dev->req = usb_ep_alloc_request(gadget->ep0, GFP_KERNEL);
2219         if (!dev->req)
2220                 goto fail;
2221         dev->req->buf = control_req;
2222         dev->req->complete = eth_setup_complete;
2223
2224         /* ... and maybe likewise for status transfer */
2225 #if defined(CONFIG_USB_ETH_CDC) || defined(CONFIG_USB_ETH_RNDIS)
2226         if (dev->status_ep) {
2227                 dev->stat_req = usb_ep_alloc_request(dev->status_ep,
2228                                                         GFP_KERNEL);
2229                 if (!dev->stat_req) {
2230                         usb_ep_free_request(dev->status_ep, dev->req);
2231
2232                         goto fail;
2233                 }
2234                 dev->stat_req->buf = status_req;
2235                 dev->stat_req->context = NULL;
2236         }
2237 #endif
2238
2239         /* finish hookup to lower layer ... */
2240         dev->gadget = gadget;
2241         set_gadget_data(gadget, dev);
2242         gadget->ep0->driver_data = dev;
2243
2244         /*
2245          * two kinds of host-initiated state changes:
2246          *  - iff DATA transfer is active, carrier is "on"
2247          *  - tx queueing enabled if open *and* carrier is "on"
2248          */
2249
2250         printf("using %s, OUT %s IN %s%s%s\n", gadget->name,
2251                 out_ep->name, in_ep->name,
2252                 status_ep ? " STATUS " : "",
2253                 status_ep ? status_ep->name : ""
2254                 );
2255         printf("MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
2256                 dev->net->enetaddr[0], dev->net->enetaddr[1],
2257                 dev->net->enetaddr[2], dev->net->enetaddr[3],
2258                 dev->net->enetaddr[4], dev->net->enetaddr[5]);
2259
2260         if (cdc || rndis)
2261                 printf("HOST MAC %02x:%02x:%02x:%02x:%02x:%02x\n",
2262                         dev->host_mac[0], dev->host_mac[1],
2263                         dev->host_mac[2], dev->host_mac[3],
2264                         dev->host_mac[4], dev->host_mac[5]);
2265
2266         if (rndis) {
2267                 u32     vendorID = 0;
2268
2269                 /* FIXME RNDIS vendor id == "vendor NIC code" == ? */
2270
2271                 dev->rndis_config = rndis_register(rndis_control_ack);
2272                 if (dev->rndis_config < 0) {
2273 fail0:
2274                         eth_unbind(gadget);
2275                         debug("RNDIS setup failed\n");
2276                         status = -ENODEV;
2277                         goto fail;
2278                 }
2279
2280                 /* these set up a lot of the OIDs that RNDIS needs */
2281                 rndis_set_host_mac(dev->rndis_config, dev->host_mac);
2282                 if (rndis_set_param_dev(dev->rndis_config, dev->net, dev->mtu,
2283                                         &dev->stats, &dev->cdc_filter))
2284                         goto fail0;
2285                 if (rndis_set_param_vendor(dev->rndis_config, vendorID,
2286                                         manufacturer))
2287                         goto fail0;
2288                 if (rndis_set_param_medium(dev->rndis_config,
2289                                         NDIS_MEDIUM_802_3, 0))
2290                         goto fail0;
2291                 printf("RNDIS ready\n");
2292         }
2293         return 0;
2294
2295 fail:
2296         error("%s failed, status = %d", __func__, status);
2297         eth_unbind(gadget);
2298         return status;
2299 }
2300
2301 /*-------------------------------------------------------------------------*/
2302
2303 static int usb_eth_init(struct eth_device *netdev, bd_t *bd)
2304 {
2305         struct eth_dev *dev = &l_ethdev;
2306         struct usb_gadget *gadget;
2307         unsigned long ts;
2308         unsigned long timeout = USB_CONNECT_TIMEOUT;
2309
2310         if (!netdev) {
2311                 error("received NULL ptr");
2312                 goto fail;
2313         }
2314
2315         /* Configure default mac-addresses for the USB ethernet device */
2316 #ifdef CONFIG_USBNET_DEV_ADDR
2317         strlcpy(dev_addr, CONFIG_USBNET_DEV_ADDR, sizeof(dev_addr));
2318 #endif
2319 #ifdef CONFIG_USBNET_HOST_ADDR
2320         strlcpy(host_addr, CONFIG_USBNET_HOST_ADDR, sizeof(host_addr));
2321 #endif
2322         /* Check if the user overruled the MAC addresses */
2323         if (getenv("usbnet_devaddr"))
2324                 strlcpy(dev_addr, getenv("usbnet_devaddr"),
2325                         sizeof(dev_addr));
2326
2327         if (getenv("usbnet_hostaddr"))
2328                 strlcpy(host_addr, getenv("usbnet_hostaddr"),
2329                         sizeof(host_addr));
2330
2331         if (!is_eth_addr_valid(dev_addr)) {
2332                 error("Need valid 'usbnet_devaddr' to be set");
2333                 goto fail;
2334         }
2335         if (!is_eth_addr_valid(host_addr)) {
2336                 error("Need valid 'usbnet_hostaddr' to be set");
2337                 goto fail;
2338         }
2339
2340         if (usb_gadget_register_driver(&eth_driver) < 0)
2341                 goto fail;
2342
2343         dev->network_started = 0;
2344
2345         packet_received = 0;
2346         packet_sent = 0;
2347
2348         gadget = dev->gadget;
2349         usb_gadget_connect(gadget);
2350
2351         if (getenv("cdc_connect_timeout"))
2352                 timeout = simple_strtoul(getenv("cdc_connect_timeout"),
2353                                                 NULL, 10) * CONFIG_SYS_HZ;
2354         ts = get_timer(0);
2355         while (!l_ethdev.network_started) {
2356                 /* Handle control-c and timeouts */
2357                 if (ctrlc() || (get_timer(ts) > timeout)) {
2358                         error("The remote end did not respond in time.");
2359                         goto fail;
2360                 }
2361                 usb_gadget_handle_interrupts();
2362         }
2363
2364         packet_received = 0;
2365         rx_submit(dev, dev->rx_req, 0);
2366         return 0;
2367 fail:
2368         return -1;
2369 }
2370
2371 static int usb_eth_send(struct eth_device *netdev, void *packet, int length)
2372 {
2373         int                     retval;
2374         void                    *rndis_pkt = NULL;
2375         struct eth_dev          *dev = &l_ethdev;
2376         struct usb_request      *req = dev->tx_req;
2377         unsigned long ts;
2378         unsigned long timeout = USB_CONNECT_TIMEOUT;
2379
2380         debug("%s:...\n", __func__);
2381
2382         /* new buffer is needed to include RNDIS header */
2383         if (rndis_active(dev)) {
2384                 rndis_pkt = malloc(length +
2385                                         sizeof(struct rndis_packet_msg_type));
2386                 if (!rndis_pkt) {
2387                         error("No memory to alloc RNDIS packet");
2388                         goto drop;
2389                 }
2390                 rndis_add_hdr(rndis_pkt, length);
2391                 memcpy(rndis_pkt + sizeof(struct rndis_packet_msg_type),
2392                                 packet, length);
2393                 packet = rndis_pkt;
2394                 length += sizeof(struct rndis_packet_msg_type);
2395         }
2396         req->buf = packet;
2397         req->context = NULL;
2398         req->complete = tx_complete;
2399
2400         /*
2401          * use zlp framing on tx for strict CDC-Ether conformance,
2402          * though any robust network rx path ignores extra padding.
2403          * and some hardware doesn't like to write zlps.
2404          */
2405         req->zero = 1;
2406         if (!dev->zlp && (length % dev->in_ep->maxpacket) == 0)
2407                 length++;
2408
2409         req->length = length;
2410 #if 0
2411         /* throttle highspeed IRQ rate back slightly */
2412         if (gadget_is_dualspeed(dev->gadget))
2413                 req->no_interrupt = (dev->gadget->speed == USB_SPEED_HIGH)
2414                         ? ((dev->tx_qlen % qmult) != 0) : 0;
2415 #endif
2416         dev->tx_qlen = 1;
2417         ts = get_timer(0);
2418         packet_sent = 0;
2419
2420         retval = usb_ep_queue(dev->in_ep, req, GFP_ATOMIC);
2421
2422         if (!retval)
2423                 debug("%s: packet queued\n", __func__);
2424         while (!packet_sent) {
2425                 if (get_timer(ts) > timeout) {
2426                         printf("timeout sending packets to usb ethernet\n");
2427                         return -1;
2428                 }
2429                 usb_gadget_handle_interrupts();
2430         }
2431         if (rndis_pkt)
2432                 free(rndis_pkt);
2433
2434         return 0;
2435 drop:
2436         dev->stats.tx_dropped++;
2437         return -ENOMEM;
2438 }
2439
2440 static int usb_eth_recv(struct eth_device *netdev)
2441 {
2442         struct eth_dev *dev = &l_ethdev;
2443
2444         usb_gadget_handle_interrupts();
2445
2446         if (packet_received) {
2447                 debug("%s: packet received\n", __func__);
2448                 if (dev->rx_req) {
2449                         NetReceive(NetRxPackets[0], dev->rx_req->length);
2450                         packet_received = 0;
2451
2452                         rx_submit(dev, dev->rx_req, 0);
2453                 } else
2454                         error("dev->rx_req invalid");
2455         }
2456         return 0;
2457 }
2458
2459 void usb_eth_halt(struct eth_device *netdev)
2460 {
2461         struct eth_dev *dev = &l_ethdev;
2462
2463         if (!netdev) {
2464                 error("received NULL ptr");
2465                 return;
2466         }
2467
2468         /* If the gadget not registered, simple return */
2469         if (!dev->gadget)
2470                 return;
2471
2472         /*
2473          * Some USB controllers may need additional deinitialization here
2474          * before dropping pull-up (also due to hardware issues).
2475          * For example: unhandled interrupt with status stage started may
2476          * bring the controller to fully broken state (until board reset).
2477          * There are some variants to debug and fix such cases:
2478          * 1) In the case of RNDIS connection eth_stop can perform additional
2479          * interrupt handling. See RNDIS_COMPLETE_SIGNAL_DISCONNECT definition.
2480          * 2) 'pullup' callback in your UDC driver can be improved to perform
2481          * this deinitialization.
2482          */
2483         eth_stop(dev);
2484
2485         usb_gadget_disconnect(dev->gadget);
2486
2487         /* Clear pending interrupt */
2488         if (dev->network_started) {
2489                 usb_gadget_handle_interrupts();
2490                 dev->network_started = 0;
2491         }
2492
2493         usb_gadget_unregister_driver(&eth_driver);
2494 }
2495
2496 static struct usb_gadget_driver eth_driver = {
2497         .speed          = DEVSPEED,
2498
2499         .bind           = eth_bind,
2500         .unbind         = eth_unbind,
2501
2502         .setup          = eth_setup,
2503         .disconnect     = eth_disconnect,
2504
2505         .suspend        = eth_suspend,
2506         .resume         = eth_resume,
2507 };
2508
2509 int usb_eth_initialize(bd_t *bi)
2510 {
2511         struct eth_device *netdev = &l_netdev;
2512
2513         strlcpy(netdev->name, USB_NET_NAME, sizeof(netdev->name));
2514
2515         netdev->init = usb_eth_init;
2516         netdev->send = usb_eth_send;
2517         netdev->recv = usb_eth_recv;
2518         netdev->halt = usb_eth_halt;
2519
2520 #ifdef CONFIG_MCAST_TFTP
2521   #error not supported
2522 #endif
2523         eth_register(netdev);
2524         return 0;
2525 }