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