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