开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
usbnet.c
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：57k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

usbnet.c：源码内容
  1. /*
  2.  * USB Host-to-Host Links
  3.  * Copyright (C) 2000-2002 by David Brownell <dbrownell@users.sourceforge.net>
  4.  */
  6. /*
  7.  * This is used for "USB networking", connecting USB hosts as peers.
  8.  *
  9.  * It can be used with USB "network cables", for IP-over-USB communications;
  10.  * Ethernet speeds without the Ethernet.  USB devices (including some PDAs)
  11.  * can support such links directly, replacing device-specific protocols
  12.  * with Internet standard ones.
  13.  *
  14.  * The links can be bridged using the Ethernet bridging (net/bridge)
  15.  * support as appropriate.  Devices currently supported include:
  16.  *
  17.  * - AnchorChip 2720
  18.  * - Belkin, eTEK (interops with Win32 drivers)
  19.  * - EPSON USB clients
  20.  * - GeneSys GL620USB-A
  21.  * - "Linux Devices" (like iPaq and similar SA-1100 based PDAs)
  22.  * - NetChip 1080 (interoperates with NetChip Win32 drivers)
  23.  * - Prolific PL-2301/2302 (replaces "plusb" driver)
  24.  *
  25.  * USB devices can implement their side of this protocol at the cost
  26.  * of two bulk endpoints; it's not restricted to "cable" applications.
  27.  * See the LINUXDEV or EPSON device/client support.
  28.  *
  29.  * 
  30.  * Status:
  31.  *
  32.  * - AN2720 ... not widely available, but reportedly works well
  33.  *
  34.  * - Belkin/eTEK ... no known issues
  35.  *
  36.  * - Both GeneSys and PL-230x use interrupt transfers for driver-to-driver
  37.  *   handshaking; it'd be worth implementing those as "carrier detect".
  38.  *   Prefer generic hooks, not minidriver-specific hacks.
  39.  *
  40.  * - Linux devices ... the www.handhelds.org SA-1100 support works nicely,
  41.  *   but the Sharp Zaurus uses an incompatible protocol (extra checksums).
  42.  *   No reason not to merge the Zaurus protocol here too (got patch? :)
  43.  *
  44.  * - For Netchip, should use keventd to poll via control requests to detect
  45.  *   hardware level "carrier detect". 
  46.  *
  47.  * - PL-230x ... the initialization protocol doesn't seem to match chip data
  48.  *   sheets, sometimes it's not needed and sometimes it hangs.  Prolific has
  49.  *   not responded to repeated support/information requests.
  50.  *
  51.  * Interop with more Win32 drivers may be a good thing.
  52.  *
  53.  * Seems like reporting "peer connected" (carrier present) events may end
  54.  * up going through the netlink event system, not hotplug ... that may be
  55.  * awkward in terms of automatic configuration though.
  56.  *
  57.  * There are reports that bridging gives lower-than-usual throughput.
  58.  *
  59.  * Need smarter hotplug policy scripts ... ones that know how to arrange
  60.  * bridging with "brctl", and can handle static and dynamic ("pump") setups.
  61.  * Use those eventual "peer connected" events, and zeroconf.
  62.  *
  63.  *
  64.  * CHANGELOG:
  65.  *
  66.  * 13-sep-2000 experimental, new
  67.  * 10-oct-2000 usb_device_id table created. 
  68.  * 28-oct-2000 misc fixes; mostly, discard more TTL-mangled rx packets.
  69.  * 01-nov-2000 usb_device_id table and probing api update by
  70.  * Adam J. Richter <adam@yggdrasil.com>.
  71.  * 18-dec-2000 (db) tx watchdog, "net1080" renaming to "usbnet", device_info
  72.  * and prolific support, isolate net1080-specific bits, cleanup.
  73.  * fix unlink_urbs oops in D3 PM resume code path.
  74.  *
  75.  * 02-feb-2001 (db) fix tx skb sharing, packet length, match_flags, ...
  76.  * 08-feb-2001 stubbed in "linuxdev", maybe the SA-1100 folk can use it;
  77.  * AnchorChips 2720 support (from spec) for testing;
  78.  * fix bit-ordering problem with ethernet multicast addr
  79.  * 19-feb-2001  Support for clearing halt conditions. SA1100 UDC support
  80.  * updates. Oleg Drokin (green@iXcelerator.com)
  81.  * 25-mar-2001 More SA-1100 updates, including workaround for ip problem
  82.  * expecting cleared skb->cb and framing change to match latest
  83.  * handhelds.org version (Oleg).  Enable device IDs from the
  84.  * Win32 Belkin driver; other cleanups (db).
  85.  * 16-jul-2001 Bugfixes for uhci oops-on-unplug, Belkin support, various
  86.  * cleanups for problems not yet seen in the field. (db)
  87.  * 17-oct-2001 Handle "Advance USBNET" product, like Belkin/eTEK devices,
  88.  * from Ioannis Mavroukakis <i.mavroukakis@btinternet.com>;
  89.  * rx unlinks somehow weren't async; minor cleanup.
  90.  * 03-nov-2001 Merged GeneSys driver; original code from Jiun-Jie Huang
  91.  * <huangjj@genesyslogic.com.tw>, updated by Stanislav Brabec
  92.  * <utx@penguin.cz>.  Made framing options (NetChip/GeneSys)
  93.  * tie mostly to (sub)driver info.  Workaround some PL-2302
  94.  * chips that seem to reject SET_INTERFACE requests.
  95.  *
  96.  * 06-apr-2002 Added ethtool support, based on a patch from Brad Hards.
  97.  * Level of diagnostics is more configurable; they use device
  98.  * location (usb_device->devpath) instead of address (2.5).
  99.  * For tx_fixup, memflags can't be NOIO.
  100.  * 07-may-2002 Generalize/cleanup keventd support, handling rx stalls (mostly
  101.  * for USB 2.0 TTs) and memory shortages (potential) too. (db)
  102.  * Use "locally assigned" IEEE802 address space. (Brad Hards)
  103.  *
  104.  *-------------------------------------------------------------------------*/
  106. #include <linux/config.h>
  107. #include <linux/module.h>
  108. #include <linux/kmod.h>
  109. #include <linux/sched.h>
  110. #include <linux/init.h>
  111. #include <linux/netdevice.h>
  112. #include <linux/etherdevice.h>
  113. #include <linux/random.h>
  114. #include <linux/ethtool.h>
  115. #include <linux/tqueue.h>
  116. #include <asm/uaccess.h>
  117. #include <asm/unaligned.h>
  119. // #define DEBUG // error path messages, extra info
  120. // #define VERBOSE // more; success messages
  121. // #define REALLY_QUEUE
  123. #if !defined (DEBUG) && defined (CONFIG_USB_DEBUG)
  124. #   define DEBUG
  125. #endif
  126. #include <linux/usb.h>
  128. /* in 2.5 these standard usb ops take mem_flags */
  129. #define ALLOC_URB(n,flags) usb_alloc_urb(n)
  130. #define SUBMIT_URB(u,flags) usb_submit_urb(u)
  132. /* and these got renamed (may move to usb.h) */
  133. #define usb_get_dev usb_inc_dev_use
  134. #define usb_put_dev usb_dec_dev_use
  137. /* minidrivers _could_ be individually configured */
  138. #define CONFIG_USB_AN2720
  139. #define CONFIG_USB_BELKIN
  140. #define CONFIG_USB_EPSON2888
  141. #define CONFIG_USB_GENESYS
  142. #define CONFIG_USB_LINUXDEV
  143. #define CONFIG_USB_NET1080
  144. #define CONFIG_USB_PL2301
  147. #define DRIVER_VERSION "17-Jul-2002"
  149. /*-------------------------------------------------------------------------*/
  151. /*
  152.  * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
  153.  * Several dozen bytes of IPv4 data can fit in two such transactions.
  154.  * One maximum size Ethernet packet takes twenty four of them.
  155.  */
  156. #ifdef REALLY_QUEUE
  157. #define RX_QLEN 4
  158. #define TX_QLEN 4
  159. #else
  160. #define RX_QLEN 1
  161. #define TX_QLEN 1
  162. #endif
  164. // packets are always ethernet inside
  165. // ... except they can be bigger (limit of 64K with NetChip framing)
  166. #define MIN_PACKET sizeof(struct ethhdr)
  167. #define MAX_PACKET 32768
  169. // reawaken network queue this soon after stopping; else watchdog barks
  170. #define TX_TIMEOUT_JIFFIES (5*HZ)
  172. // for vendor-specific control operations
  173. #define CONTROL_TIMEOUT_MS (500) /* msec */
  174. #define CONTROL_TIMEOUT_JIFFIES ((CONTROL_TIMEOUT_MS * HZ)/1000)
  176. // between wakeups
  177. #define UNLINK_TIMEOUT_JIFFIES ((3  /*ms*/ * HZ)/1000)
  179. /*-------------------------------------------------------------------------*/
  181. // list of all devices we manage
  182. static DECLARE_MUTEX (usbnet_mutex);
  183. static LIST_HEAD (usbnet_list);
  185. // randomly generated ethernet address
  186. static u8 node_id [ETH_ALEN];
  188. // state we keep for each device we handle
  189. struct usbnet {
  190. // housekeeping
  191. struct usb_device *udev;
  192. struct driver_info *driver_info;
  193. struct semaphore mutex;
  194. struct list_head dev_list;
  195. wait_queue_head_t *wait;
  197. // protocol/interface state
  198. struct net_device net;
  199. struct net_device_stats stats;
  200. int msg_level;
  202. #ifdef CONFIG_USB_NET1080
  203. u16 packet_id;
  204. #endif
  206. // various kinds of pending driver work
  207. struct sk_buff_head rxq;
  208. struct sk_buff_head txq;
  209. struct sk_buff_head done;
  210. struct tasklet_struct bh;
  212. struct tq_struct kevent;
  213. unsigned long flags;
  214. # define EVENT_TX_HALT 0
  215. # define EVENT_RX_HALT 1
  216. # define EVENT_RX_MEMORY 2
  217. };
  219. // device-specific info used by the driver
  220. struct driver_info {
  221. char *description;
  223. int flags;
  224. #define FLAG_FRAMING_NC 0x0001 /* guard against device dropouts */ 
  225. #define FLAG_FRAMING_GL 0x0002 /* genelink batches packets */
  226. #define FLAG_NO_SETINT 0x0010 /* device can't set_interface() */
  228. /* reset device ... can sleep */
  229. int (*reset)(struct usbnet *);
  231. /* see if peer is connected ... can sleep */
  232. int (*check_connect)(struct usbnet *);
  234. /* fixup rx packet (strip framing) */
  235. int (*rx_fixup)(struct usbnet *dev, struct sk_buff *skb);
  237. /* fixup tx packet (add framing) */
  238. struct sk_buff *(*tx_fixup)(struct usbnet *dev,
  239. struct sk_buff *skb, int flags);
  241. // FIXME -- also an interrupt mechanism
  242. // useful for at least PL2301/2302 and GL620USB-A
  244. /* framework currently "knows" bulk EPs talk packets */
  245. int in; /* rx endpoint */
  246. int out; /* tx endpoint */
  247. int epsize;
  248. };
  250. #define EP_SIZE(usbnet) ((usbnet)->driver_info->epsize)
  252. // we record the state for each of our queued skbs
  253. enum skb_state {
  254. illegal = 0,
  255. tx_start, tx_done,
  256. rx_start, rx_done, rx_cleanup
  257. };
  259. struct skb_data { // skb->cb is one of these
  260. struct urb *urb;
  261. struct usbnet *dev;
  262. enum skb_state state;
  263. size_t length;
  264. };
  266. static const char driver_name [] = "usbnet";
  268. /* use ethtool to change the level for any given device */
  269. static int msg_level = 1;
  270. MODULE_PARM (msg_level, "i");
  271. MODULE_PARM_DESC (msg_level, "Initial message level (default = 1)");
  274. #define mutex_lock(x) down(x)
  275. #define mutex_unlock(x) up(x)
  277. #define RUN_CONTEXT (in_irq () ? "in_irq" 
  278. : (in_interrupt () ? "in_interrupt" : "can sleep"))
  280. /*-------------------------------------------------------------------------*/
  282. #ifdef DEBUG
  283. #define devdbg(usbnet, fmt, arg...) 
  284. printk(KERN_DEBUG "%s: " fmt "n" , (usbnet)->net.name, ## arg)
  285. #else
  286. #define devdbg(usbnet, fmt, arg...) do {} while(0)
  287. #endif
  289. #define devinfo(usbnet, fmt, arg...) 
  290. do { if ((usbnet)->msg_level >= 1) 
  291. printk(KERN_INFO "%s: " fmt "n" , (usbnet)->net.name, ## arg); 
  292. } while (0)
  295. #ifdef CONFIG_USB_AN2720
  297. /*-------------------------------------------------------------------------
  298.  *
  299.  * AnchorChips 2720 driver ... http://www.cypress.com
  300.  *
  301.  * This doesn't seem to have a way to detect whether the peer is
  302.  * connected, or need any reset handshaking.  It's got pretty big
  303.  * internal buffers (handles most of a frame's worth of data).
  304.  * Chip data sheets don't describe any vendor control messages.
  305.  *
  306.  *-------------------------------------------------------------------------*/
  308. static const struct driver_info an2720_info = {
  309. .description = "AnchorChips/Cypress 2720",
  310. // no reset available!
  311. // no check_connect available!
  313. .in = 2, .out = 2, // direction distinguishes these
  314. .epsize =64,
  315. };
  317. #endif /* CONFIG_USB_AN2720 */
  321. #ifdef CONFIG_USB_BELKIN
  323. /*-------------------------------------------------------------------------
  324.  *
  325.  * Belkin F5U104 ... two NetChip 2280 devices + Atmel microcontroller
  326.  *
  327.  * ... also two eTEK designs, including one sold as "Advance USBNET"
  328.  *
  329.  *-------------------------------------------------------------------------*/
  331. static const struct driver_info belkin_info = {
  332. .description = "Belkin, eTEK, or compatible",
  334. .in = 1, .out = 1, // direction distinguishes these
  335. .epsize =64,
  336. };
  338. #endif /* CONFIG_USB_BELKIN */
  342. #ifdef CONFIG_USB_EPSON2888
  344. /*-------------------------------------------------------------------------
  345.  *
  346.  * EPSON USB clients
  347.  *
  348.  * This is the same idea as "linuxdev" (below) except the firmware in the
  349.  * device might not be Tux-powered.  Epson provides reference firmware that
  350.  * implements this interface.  Product developers can reuse or modify that
  351.  * code, such as by using their own product and vendor codes.
  352.  *
  353.  *-------------------------------------------------------------------------*/
  355. static const struct driver_info epson2888_info = {
  356. .description = "Epson USB Device",
  358. .in = 4, .out = 3,
  359. .epsize = 64,
  360. };
  362. #endif /* CONFIG_USB_EPSON2888 */
  365. #ifdef CONFIG_USB_GENESYS
  367. /*-------------------------------------------------------------------------
  368.  *
  369.  * GeneSys GL620USB-A (www.genesyslogic.com.tw)
  370.  *
  371.  * ... should partially interop with the Win32 driver for this hardware
  372.  * The GeneSys docs imply there's some NDIS issue motivating this framing.
  373.  *
  374.  * Some info from GeneSys:
  375.  *  - GL620USB-A is full duplex; GL620USB is only half duplex for bulk.
  376.  *    (Some cables, like the BAFO-100c, use the half duplex version.)
  377.  *  - For the full duplex model, the low bit of the version code says
  378.  *    which side is which ("left/right").
  379.  *  - For the half duplex type, a control/interrupt handshake settles
  380.  *    the transfer direction.  (That's disabled here, partially coded.)
  381.  *    A control URB would block until other side writes an interrupt.
  382.  *
  383.  *-------------------------------------------------------------------------*/
  385. // control msg write command
  386. #define GENELINK_CONNECT_WRITE 0xF0
  387. // interrupt pipe index
  388. #define GENELINK_INTERRUPT_PIPE 0x03
  389. // interrupt read buffer size
  390. #define INTERRUPT_BUFSIZE 0x08
  391. // interrupt pipe interval value
  392. #define GENELINK_INTERRUPT_INTERVAL 0x10
  393. // max transmit packet number per transmit
  394. #define GL_MAX_TRANSMIT_PACKETS 32
  395. // max packet length
  396. #define GL_MAX_PACKET_LEN 1514
  397. // max receive buffer size 
  398. #define GL_RCV_BUF_SIZE
  399. (((GL_MAX_PACKET_LEN + 4) * GL_MAX_TRANSMIT_PACKETS) + 4)
  401. struct gl_packet {
  402. u32 packet_length;
  403. char packet_data [1];
  404. };
  406. struct gl_header {
  407. u32 packet_count;
  408. struct gl_packet packets;
  409. };
  411. #ifdef GENLINK_ACK
  413. // FIXME:  this code is incomplete, not debugged; it doesn't
  414. // handle interrupts correctly.  interrupts should be generic
  415. // code like all other device I/O, anyway.
  417. struct gl_priv { 
  418. struct urb *irq_urb;
  419. char irq_buf [INTERRUPT_BUFSIZE];
  420. };
  422. static inline int gl_control_write (struct usbnet *dev, u8 request, u16 value)
  423. {
  424. int retval;
  426. retval = usb_control_msg (dev->udev,
  427.       usb_sndctrlpipe (dev->udev, 0),
  428.       request,
  429.       USB_DIR_OUT | USB_TYPE_CLASS | USB_RECIP_INTERFACE,
  430.       value, 
  431.       0, // index
  432.       0, // data buffer
  433.       0, // size
  434.       CONTROL_TIMEOUT_JIFFIES);
  435. return retval;
  436. }
  438. static void gl_interrupt_complete (struct urb *urb)
  439. {
  440. int status = urb->status;
  442. if (status)
  443. dbg ("gl_interrupt_complete fail - %X", status);
  444. else
  445. dbg ("gl_interrupt_complete success...");
  446. }
  448. static int gl_interrupt_read (struct usbnet *dev)
  449. {
  450. struct gl_priv *priv = dev->priv_data;
  451. int retval;
  453. // issue usb interrupt read
  454. if (priv && priv->irq_urb) {
  455. // submit urb
  456. if ((retval = SUBMIT_URB (priv->irq_urb, GFP_KERNEL)) != 0)
  457. dbg ("gl_interrupt_read: submit fail - %X...", retval);
  458. else
  459. dbg ("gl_interrupt_read: submit success...");
  460. }
  462. return 0;
  463. }
  465. // check whether another side is connected
  466. static int genelink_check_connect (struct usbnet *dev)
  467. {
  468. int retval;
  470. dbg ("genelink_check_connect...");
  472. // detect whether another side is connected
  473. if ((retval = gl_control_write (dev, GENELINK_CONNECT_WRITE, 0)) != 0) {
  474. dbg ("%s: genelink_check_connect write fail - %X",
  475. dev->net.name, retval);
  476. return retval;
  477. }
  479. // usb interrupt read to ack another side 
  480. if ((retval = gl_interrupt_read (dev)) != 0) {
  481. dbg ("%s: genelink_check_connect read fail - %X",
  482. dev->net.name, retval);
  483. return retval;
  484. }
  486. dbg ("%s: genelink_check_connect read success", dev->net.name);
  487. return 0;
  488. }
  490. // allocate and initialize the private data for genelink
  491. static int genelink_init (struct usbnet *dev)
  492. {
  493. struct gl_priv *priv;
  495. // allocate the private data structure
  496. if ((priv = kmalloc (sizeof *priv, GFP_KERNEL)) == 0) {
  497. dbg ("%s: cannot allocate private data per device",
  498. dev->net.name);
  499. return -ENOMEM;
  500. }
  502. // allocate irq urb
  503. if ((priv->irq_urb = ALLOC_URB (0, GFP_KERNEL)) == 0) {
  504. dbg ("%s: cannot allocate private irq urb per device",
  505. dev->net.name);
  506. kfree (priv);
  507. return -ENOMEM;
  508. }
  510. // fill irq urb
  511. FILL_INT_URB (priv->irq_urb, dev->udev,
  512. usb_rcvintpipe (dev->udev, GENELINK_INTERRUPT_PIPE),
  513. priv->irq_buf, INTERRUPT_BUFSIZE,
  514. gl_interrupt_complete, 0,
  515. GENELINK_INTERRUPT_INTERVAL);
  517. // set private data pointer
  518. dev->priv_data = priv;
  520. return 0;
  521. }
  523. // release the private data
  524. static int genelink_free (struct usbnet *dev)
  525. {
  526. struct gl_priv *priv = dev->priv_data;
  528. if (!priv) 
  529. return 0;
  531. // FIXME:  can't cancel here; it's synchronous, and
  532. // should have happened earlier in any case (interrupt
  533. // handling needs to be generic)
  535. // cancel irq urb first
  536. usb_unlink_urb (priv->irq_urb);
  538. // free irq urb
  539. usb_free_urb (priv->irq_urb);
  541. // free the private data structure
  542. kfree (priv);
  544. return 0;
  545. }
  547. #endif
  549. static int genelink_rx_fixup (struct usbnet *dev, struct sk_buff *skb)
  550. {
  551. struct gl_header *header;
  552. struct gl_packet *packet;
  553. struct sk_buff *gl_skb;
  554. int status;
  555. u32 size;
  557. header = (struct gl_header *) skb->data;
  559. // get the packet count of the received skb
  560. le32_to_cpus (&header->packet_count);
  561. if ((header->packet_count > GL_MAX_TRANSMIT_PACKETS)
  562. || (header->packet_count < 0)) {
  563. dbg ("genelink: illegal received packet count %d",
  564. header->packet_count);
  565. return 0;
  566. }
  568. // set the current packet pointer to the first packet
  569. packet = &header->packets;
  571. // decrement the length for the packet count size 4 bytes
  572. skb_pull (skb, 4);
  574. while (header->packet_count > 1) {
  575. // get the packet length
  576. size = packet->packet_length;
  578. // this may be a broken packet
  579. if (size > GL_MAX_PACKET_LEN) {
  580. dbg ("genelink: illegal rx length %d", size);
  581. return 0;
  582. }
  584. // allocate the skb for the individual packet
  585. gl_skb = alloc_skb (size, GFP_ATOMIC);
  586. if (gl_skb) {
  588. // copy the packet data to the new skb
  589. memcpy (gl_skb->data, packet->packet_data, size);
  591. // set skb data size
  592. gl_skb->len = size;
  593. gl_skb->dev = &dev->net;
  595. // determine the packet's protocol ID
  596. gl_skb->protocol = eth_type_trans (gl_skb, &dev->net);
  598. // update the status
  599. dev->stats.rx_packets++;
  600. dev->stats.rx_bytes += size;
  602. // notify os of the received packet
  603. status = netif_rx (gl_skb);
  604. }
  606. // advance to the next packet
  607. packet = (struct gl_packet *)
  608. &packet->packet_data [size];
  609. header->packet_count--;
  611. // shift the data pointer to the next gl_packet
  612. skb_pull (skb, size + 4);
  613. }
  615. // skip the packet length field 4 bytes
  616. skb_pull (skb, 4);
  618. if (skb->len > GL_MAX_PACKET_LEN) {
  619. dbg ("genelink: illegal rx length %d", skb->len);
  620. return 0;
  621. }
  622. return 1;
  623. }
  625. static struct sk_buff *
  626. genelink_tx_fixup (struct usbnet *dev, struct sk_buff *skb, int flags)
  627. {
  628. int  padlen;
  629. int length = skb->len;
  630. int headroom = skb_headroom (skb);
  631. int tailroom = skb_tailroom (skb);
  632. u32 *packet_count;
  633. u32 *packet_len;
  635. // FIXME:  magic numbers, bleech
  636. padlen = ((skb->len + (4 + 4*1)) % 64) ? 0 : 1;
  638. if ((!skb_cloned (skb))
  639. && ((headroom + tailroom) >= (padlen + (4 + 4*1)))) {
  640. if ((headroom < (4 + 4*1)) || (tailroom < padlen)) {
  641. skb->data = memmove (skb->head + (4 + 4*1),
  642.      skb->data, skb->len);
  643. skb->tail = skb->data + skb->len;
  644. }
  645. } else {
  646. struct sk_buff *skb2;
  647. skb2 = skb_copy_expand (skb, (4 + 4*1) , padlen, flags);
  648. dev_kfree_skb_any (skb);
  649. skb = skb2;
  650. }
  652. // attach the packet count to the header
  653. packet_count = (u32 *) skb_push (skb, (4 + 4*1));
  654. packet_len = packet_count + 1;
  656. // FIXME little endian?
  657. *packet_count = 1;
  658. *packet_len = length;
  660. // add padding byte
  661. if ((skb->len % EP_SIZE (dev)) == 0)
  662. skb_put (skb, 1);
  664. return skb;
  665. }
  667. static const struct driver_info genelink_info = {
  668. .description = "Genesys GeneLink",
  669. .flags = FLAG_FRAMING_GL | FLAG_NO_SETINT,
  670. .rx_fixup = genelink_rx_fixup,
  671. .tx_fixup = genelink_tx_fixup,
  673. .in = 1, .out = 2,
  674. .epsize =64,
  676. #ifdef GENELINK_ACK
  677. .check_connect =genelink_check_connect,
  678. #endif
  679. };
  681. #endif /* CONFIG_USB_GENESYS */
  685. #ifdef CONFIG_USB_LINUXDEV
  687. /*-------------------------------------------------------------------------
  688.  *
  689.  * This could talk to a device that uses Linux, such as a PDA or
  690.  * an embedded system, or in fact to any "smart" device using this
  691.  * particular mapping of USB and Ethernet.
  692.  *
  693.  * Such a Linux host would need a "USB Device Controller" hardware
  694.  * (not "USB Host Controller"), and a network driver talking to that
  695.  * hardware.
  696.  *
  697.  * One example is Intel's SA-1100 chip, which integrates basic USB
  698.  * support (arch/arm/sa1100/usb-eth.c); it's used in the iPaq PDA.
  699.  * And others too, like the Yopy.
  700.  *
  701.  *-------------------------------------------------------------------------*/
  703. static const struct driver_info linuxdev_info = {
  704. .description = "Linux Device",
  706. .in = 2, .out = 1,
  707. .epsize = 64,
  708. };
  710. #endif /* CONFIG_USB_LINUXDEV */
  713. #ifdef CONFIG_USB_NET1080
  715. /*-------------------------------------------------------------------------
  716.  *
  717.  * Netchip 1080 driver ... http://www.netchip.com
  718.  * Used in LapLink cables
  719.  *
  720.  *-------------------------------------------------------------------------*/
  722. /*
  723.  * NetChip framing of ethernet packets, supporting additional error
  724.  * checks for links that may drop bulk packets from inside messages.
  725.  * Odd USB length == always short read for last usb packet.
  726.  * - nc_header
  727.  * - Ethernet header (14 bytes)
  728.  * - payload
  729.  * - (optional padding byte, if needed so length becomes odd)
  730.  * - nc_trailer
  731.  *
  732.  * This framing is to be avoided for non-NetChip devices.
  733.  */
  735. struct nc_header { // packed:
  736. u16 hdr_len; // sizeof nc_header (LE, all)
  737. u16 packet_len; // payload size (including ethhdr)
  738. u16 packet_id; // detects dropped packets
  739. #define MIN_HEADER 6
  741. // all else is optional, and must start with:
  742. // u16 vendorId; // from usb-if
  743. // u16 productId;
  744. } __attribute__((__packed__));
  746. #define PAD_BYTE ((unsigned char)0xAC)
  748. struct nc_trailer {
  749. u16 packet_id;
  750. } __attribute__((__packed__));
  752. // packets may use FLAG_FRAMING_NC and optional pad
  753. #define FRAMED_SIZE(mtu) (sizeof (struct nc_header) 
  754. + sizeof (struct ethhdr) 
  755. + (mtu) 
  756. + 1 
  757. + sizeof (struct nc_trailer))
  759. #define MIN_FRAMED FRAMED_SIZE(0)
  762. /*
  763.  * Zero means no timeout; else, how long a 64 byte bulk packet may be queued
  764.  * before the hardware drops it.  If that's done, the driver will need to
  765.  * frame network packets to guard against the dropped USB packets.  The win32
  766.  * driver sets this for both sides of the link.
  767.  */
  768. #define NC_READ_TTL_MS ((u8)255) // ms
  770. /*
  771.  * We ignore most registers and EEPROM contents.
  772.  */
  773. #define REG_USBCTL ((u8)0x04)
  774. #define REG_TTL ((u8)0x10)
  775. #define REG_STATUS ((u8)0x11)
  777. /*
  778.  * Vendor specific requests to read/write data
  779.  */
  780. #define REQUEST_REGISTER ((u8)0x10)
  781. #define REQUEST_EEPROM ((u8)0x11)
  783. static int
  784. nc_vendor_read (struct usbnet *dev, u8 req, u8 regnum, u16 *retval_ptr)
  785. {
  786. int status = usb_control_msg (dev->udev,
  787. usb_rcvctrlpipe (dev->udev, 0),
  788. req,
  789. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  790. 0, regnum,
  791. retval_ptr, sizeof *retval_ptr,
  792. CONTROL_TIMEOUT_JIFFIES);
  793. if (status > 0)
  794. status = 0;
  795. if (!status)
  796. le16_to_cpus (retval_ptr);
  797. return status;
  798. }
  800. static inline int
  801. nc_register_read (struct usbnet *dev, u8 regnum, u16 *retval_ptr)
  802. {
  803. return nc_vendor_read (dev, REQUEST_REGISTER, regnum, retval_ptr);
  804. }
  806. // no retval ... can become async, usable in_interrupt()
  807. static void
  808. nc_vendor_write (struct usbnet *dev, u8 req, u8 regnum, u16 value)
  809. {
  810. usb_control_msg (dev->udev,
  811. usb_sndctrlpipe (dev->udev, 0),
  812. req,
  813. USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  814. value, regnum,
  815. 0, 0, // data is in setup packet
  816. CONTROL_TIMEOUT_JIFFIES);
  817. }
  819. static inline void
  820. nc_register_write (struct usbnet *dev, u8 regnum, u16 value)
  821. {
  822. nc_vendor_write (dev, REQUEST_REGISTER, regnum, value);
  823. }
  826. #if 0
  827. static void nc_dump_registers (struct usbnet *dev)
  828. {
  829. u8 reg;
  830. u16 *vp = kmalloc (sizeof (u16));
  832. if (!vp) {
  833. dbg ("no memory?");
  834. return;
  835. }
  837. dbg ("%s registers:", dev->net.name);
  838. for (reg = 0; reg < 0x20; reg++) {
  839. int retval;
  841. // reading some registers is trouble
  842. if (reg >= 0x08 && reg <= 0xf)
  843. continue;
  844. if (reg >= 0x12 && reg <= 0x1e)
  845. continue;
  847. retval = nc_register_read (dev, reg, vp);
  848. if (retval < 0)
  849. dbg ("%s reg [0x%x] ==> error %d",
  850. dev->net.name, reg, retval);
  851. else
  852. dbg ("%s reg [0x%x] = 0x%x",
  853. dev->net.name, reg, *vp);
  854. }
  855. kfree (vp);
  856. }
  857. #endif
  860. /*-------------------------------------------------------------------------*/
  862. /*
  863.  * Control register
  864.  */
  866. #define USBCTL_WRITABLE_MASK 0x1f0f
  867. // bits 15-13 reserved, r/o
  868. #define USBCTL_ENABLE_LANG (1 << 12)
  869. #define USBCTL_ENABLE_MFGR (1 << 11)
  870. #define USBCTL_ENABLE_PROD (1 << 10)
  871. #define USBCTL_ENABLE_SERIAL (1 << 9)
  872. #define USBCTL_ENABLE_DEFAULTS (1 << 8)
  873. // bits 7-4 reserved, r/o
  874. #define USBCTL_FLUSH_OTHER (1 << 3)
  875. #define USBCTL_FLUSH_THIS (1 << 2)
  876. #define USBCTL_DISCONN_OTHER (1 << 1)
  877. #define USBCTL_DISCONN_THIS (1 << 0)
  879. static inline void nc_dump_usbctl (struct usbnet *dev, u16 usbctl)
  880. {
  881. #ifdef DEBUG
  882. devdbg (dev, "net1080 %s-%s usbctl 0x%x:%s%s%s%s%s;"
  883. " this%s%s;"
  884. " other%s%s; r/o 0x%x",
  885. dev->udev->bus->bus_name, dev->udev->devpath,
  886. usbctl,
  887. (usbctl & USBCTL_ENABLE_LANG) ? " lang" : "",
  888. (usbctl & USBCTL_ENABLE_MFGR) ? " mfgr" : "",
  889. (usbctl & USBCTL_ENABLE_PROD) ? " prod" : "",
  890. (usbctl & USBCTL_ENABLE_SERIAL) ? " serial" : "",
  891. (usbctl & USBCTL_ENABLE_DEFAULTS) ? " defaults" : "",
  893. (usbctl & USBCTL_FLUSH_OTHER) ? " FLUSH" : "",
  894. (usbctl & USBCTL_DISCONN_OTHER) ? " DIS" : "",
  895. (usbctl & USBCTL_FLUSH_THIS) ? " FLUSH" : "",
  896. (usbctl & USBCTL_DISCONN_THIS) ? " DIS" : "",
  897. usbctl & ~USBCTL_WRITABLE_MASK
  898. );
  899. #endif
  900. }
  902. /*-------------------------------------------------------------------------*/
  904. /*
  905.  * Status register
  906.  */
  908. #define STATUS_PORT_A (1 << 15)
  910. #define STATUS_CONN_OTHER (1 << 14)
  911. #define STATUS_SUSPEND_OTHER (1 << 13)
  912. #define STATUS_MAILBOX_OTHER (1 << 12)
  913. #define STATUS_PACKETS_OTHER(n) (((n) >> 8) && 0x03)
  915. #define STATUS_CONN_THIS (1 << 6)
  916. #define STATUS_SUSPEND_THIS (1 << 5)
  917. #define STATUS_MAILBOX_THIS (1 << 4)
  918. #define STATUS_PACKETS_THIS(n) (((n) >> 0) && 0x03)
  920. #define STATUS_UNSPEC_MASK 0x0c8c
  921. #define STATUS_NOISE_MASK  ((u16)~(0x0303|STATUS_UNSPEC_MASK))
  924. static inline void nc_dump_status (struct usbnet *dev, u16 status)
  925. {
  926. #ifdef DEBUG
  927. devdbg (dev, "net1080 %s-%s status 0x%x:"
  928. " this (%c) PKT=%d%s%s%s;"
  929. " other PKT=%d%s%s%s; unspec 0x%x",
  930. dev->udev->bus->bus_name, dev->udev->devpath,
  931. status,
  933. // XXX the packet counts don't seem right
  934. // (1 at reset, not 0); maybe UNSPEC too
  936. (status & STATUS_PORT_A) ? 'A' : 'B',
  937. STATUS_PACKETS_THIS (status),
  938. (status & STATUS_CONN_THIS) ? " CON" : "",
  939. (status & STATUS_SUSPEND_THIS) ? " SUS" : "",
  940. (status & STATUS_MAILBOX_THIS) ? " MBOX" : "",
  942. STATUS_PACKETS_OTHER (status),
  943. (status & STATUS_CONN_OTHER) ? " CON" : "",
  944. (status & STATUS_SUSPEND_OTHER) ? " SUS" : "",
  945. (status & STATUS_MAILBOX_OTHER) ? " MBOX" : "",
  947. status & STATUS_UNSPEC_MASK
  948. );
  949. #endif
  950. }
  952. /*-------------------------------------------------------------------------*/
  954. /*
  955.  * TTL register
  956.  */
  958. #define TTL_THIS(ttl) (0x00ff & ttl)
  959. #define TTL_OTHER(ttl) (0x00ff & (ttl >> 8))
  960. #define MK_TTL(this,other) ((u16)(((other)<<8)|(0x00ff&(this))))
  962. static inline void nc_dump_ttl (struct usbnet *dev, u16 ttl)
  963. {
  964. #ifdef DEBUG
  965. devdbg (dev, "net1080 %s-%s ttl 0x%x this = %d, other = %d",
  966. dev->udev->bus->bus_name, dev->udev->devpath,
  967. ttl,
  969. TTL_THIS (ttl),
  970. TTL_OTHER (ttl)
  971. );
  972. #endif
  973. }
  975. /*-------------------------------------------------------------------------*/
  977. static int net1080_reset (struct usbnet *dev)
  978. {
  979. u16 usbctl, status, ttl;
  980. u16 *vp = kmalloc (sizeof (u16), GFP_KERNEL);
  981. int retval;
  983. if (!vp)
  984. return -ENOMEM;
  986. // nc_dump_registers (dev);
  988. if ((retval = nc_register_read (dev, REG_STATUS, vp)) < 0) {
  989. dbg ("can't read %s-%s status: %d",
  990. dev->udev->bus->bus_name, dev->udev->devpath, retval);
  991. goto done;
  992. }
  993. status = *vp;
  994. // nc_dump_status (dev, status);
  996. if ((retval = nc_register_read (dev, REG_USBCTL, vp)) < 0) {
  997. dbg ("can't read USBCTL, %d", retval);
  998. goto done;
  999. }
  1000. usbctl = *vp;
  1001. // nc_dump_usbctl (dev, usbctl);
  1003. nc_register_write (dev, REG_USBCTL,
  1004. USBCTL_FLUSH_THIS | USBCTL_FLUSH_OTHER);
  1006. if ((retval = nc_register_read (dev, REG_TTL, vp)) < 0) {
  1007. dbg ("can't read TTL, %d", retval);
  1008. goto done;
  1009. }
  1010. ttl = *vp;
  1011. // nc_dump_ttl (dev, ttl);
  1013. nc_register_write (dev, REG_TTL,
  1014. MK_TTL (NC_READ_TTL_MS, TTL_OTHER (ttl)) );
  1015. dbg ("%s: assigned TTL, %d ms", dev->net.name, NC_READ_TTL_MS);
  1017. if (dev->msg_level >= 2)
  1018. devinfo (dev, "port %c, peer %sconnected",
  1019. (status & STATUS_PORT_A) ? 'A' : 'B',
  1020. (status & STATUS_CONN_OTHER) ? "" : "dis"
  1021. );
  1022. retval = 0;
  1024. done:
  1025. kfree (vp);
  1026. return retval;
  1027. }
  1029. static int net1080_check_connect (struct usbnet *dev)
  1030. {
  1031. int retval;
  1032. u16 status;
  1033. u16 *vp = kmalloc (sizeof (u16), GFP_KERNEL);
  1035. if (!vp)
  1036. return -ENOMEM;
  1037. retval = nc_register_read (dev, REG_STATUS, vp);
  1038. status = *vp;
  1039. kfree (vp);
  1040. if (retval != 0) {
  1041. dbg ("%s net1080_check_conn read - %d", dev->net.name, retval);
  1042. return retval;
  1043. }
  1044. if ((status & STATUS_CONN_OTHER) != STATUS_CONN_OTHER)
  1045. return -ENOLINK;
  1046. return 0;
  1047. }
  1049. static int net1080_rx_fixup (struct usbnet *dev, struct sk_buff *skb)
  1050. {
  1051. struct nc_header *header;
  1052. struct nc_trailer *trailer;
  1054. if (!(skb->len & 0x01)
  1055. || MIN_FRAMED > skb->len
  1056. || skb->len > FRAMED_SIZE (dev->net.mtu)) {
  1057. dev->stats.rx_frame_errors++;
  1058. dbg ("rx framesize %d range %d..%d mtu %d", skb->len,
  1059. (int)MIN_FRAMED, (int)FRAMED_SIZE (dev->net.mtu),
  1060. dev->net.mtu);
  1061. return 0;
  1062. }
  1064. header = (struct nc_header *) skb->data;
  1065. le16_to_cpus (&header->hdr_len);
  1066. le16_to_cpus (&header->packet_len);
  1067. if (FRAMED_SIZE (header->packet_len) > MAX_PACKET) {
  1068. dev->stats.rx_frame_errors++;
  1069. dbg ("packet too big, %d", header->packet_len);
  1070. return 0;
  1071. } else if (header->hdr_len < MIN_HEADER) {
  1072. dev->stats.rx_frame_errors++;
  1073. dbg ("header too short, %d", header->hdr_len);
  1074. return 0;
  1075. } else if (header->hdr_len > MIN_HEADER) {
  1076. // out of band data for us?
  1077. dbg ("header OOB, %d bytes",
  1078. header->hdr_len - MIN_HEADER);
  1079. // switch (vendor/product ids) { ... }
  1080. }
  1081. skb_pull (skb, header->hdr_len);
  1083. trailer = (struct nc_trailer *)
  1084. (skb->data + skb->len - sizeof *trailer);
  1085. skb_trim (skb, skb->len - sizeof *trailer);
  1087. if ((header->packet_len & 0x01) == 0) {
  1088. if (skb->data [header->packet_len] != PAD_BYTE) {
  1089. dev->stats.rx_frame_errors++;
  1090. dbg ("bad pad");
  1091. return 0;
  1092. }
  1093. skb_trim (skb, skb->len - 1);
  1094. }
  1095. if (skb->len != header->packet_len) {
  1096. dev->stats.rx_frame_errors++;
  1097. dbg ("bad packet len %d (expected %d)",
  1098. skb->len, header->packet_len);
  1099. return 0;
  1100. }
  1101. if (header->packet_id != get_unaligned (&trailer->packet_id)) {
  1102. dev->stats.rx_fifo_errors++;
  1103. dbg ("(2+ dropped) rx packet_id mismatch 0x%x 0x%x",
  1104. header->packet_id, trailer->packet_id);
  1105. return 0;
  1106. }
  1107. #if 0
  1108. devdbg (dev, "frame <rx h %d p %d id %d", header->hdr_len,
  1109. header->packet_len, header->packet_id);
  1110. #endif
  1111. return 1;
  1112. }
  1114. static struct sk_buff *
  1115. net1080_tx_fixup (struct usbnet *dev, struct sk_buff *skb, int flags)
  1116. {
  1117. int padlen;
  1118. struct sk_buff *skb2;
  1120. padlen = ((skb->len + sizeof (struct nc_header)
  1121. + sizeof (struct nc_trailer)) & 0x01) ? 0 : 1;
  1122. if (!skb_cloned (skb)) {
  1123. int headroom = skb_headroom (skb);
  1124. int tailroom = skb_tailroom (skb);
  1126. if ((padlen + sizeof (struct nc_trailer)) <= tailroom
  1127.     && sizeof (struct nc_header) <= headroom)
  1128. return skb;
  1130. if ((sizeof (struct nc_header) + padlen
  1131. + sizeof (struct nc_trailer)) <
  1132. (headroom + tailroom)) {
  1133. skb->data = memmove (skb->head
  1134. + sizeof (struct nc_header),
  1135.     skb->data, skb->len);
  1136. skb->tail = skb->data + skb->len;
  1137. return skb;
  1138. }
  1139. }
  1140. skb2 = skb_copy_expand (skb,
  1141. sizeof (struct nc_header),
  1142. sizeof (struct nc_trailer) + padlen,
  1143. flags);
  1144. dev_kfree_skb_any (skb);
  1145. return skb2;
  1146. }
  1148. static const struct driver_info net1080_info = {
  1149. .description = "NetChip TurboCONNECT",
  1150. .flags = FLAG_FRAMING_NC,
  1151. .reset = net1080_reset,
  1152. .check_connect =net1080_check_connect,
  1153. .rx_fixup = net1080_rx_fixup,
  1154. .tx_fixup = net1080_tx_fixup,
  1156. .in = 1, .out = 1, // direction distinguishes these
  1157. .epsize =64,
  1158. };
  1160. #endif /* CONFIG_USB_NET1080 */
  1164. #ifdef CONFIG_USB_PL2301
  1166. /*-------------------------------------------------------------------------
  1167.  *
  1168.  * Prolific PL-2301/PL-2302 driver ... http://www.prolifictech.com
  1169.  *
  1170.  *-------------------------------------------------------------------------*/
  1172. /*
  1173.  * Bits 0-4 can be used for software handshaking; they're set from
  1174.  * one end, cleared from the other, "read" with the interrupt byte.
  1175.  */
  1176. #define PL_S_EN (1<<7) /* (feature only) suspend enable */
  1177. /* reserved bit -- rx ready (6) ? */
  1178. #define PL_TX_READY (1<<5) /* (interrupt only) transmit ready */
  1179. #define PL_RESET_OUT (1<<4) /* reset output pipe */
  1180. #define PL_RESET_IN (1<<3) /* reset input pipe */
  1181. #define PL_TX_C (1<<2) /* transmission complete */
  1182. #define PL_TX_REQ (1<<1) /* transmission received */
  1183. #define PL_PEER_E (1<<0) /* peer exists */
  1185. static inline int
  1186. pl_vendor_req (struct usbnet *dev, u8 req, u8 val, u8 index)
  1187. {
  1188. return usb_control_msg (dev->udev,
  1189. usb_rcvctrlpipe (dev->udev, 0),
  1190. req,
  1191. USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
  1192. val, index,
  1193. 0, 0,
  1194. CONTROL_TIMEOUT_JIFFIES);
  1195. }
  1197. static inline int
  1198. pl_clear_QuickLink_features (struct usbnet *dev, int val)
  1199. {
  1200. return pl_vendor_req (dev, 1, (u8) val, 0);
  1201. }
  1203. static inline int
  1204. pl_set_QuickLink_features (struct usbnet *dev, int val)
  1205. {
  1206. return pl_vendor_req (dev, 3, (u8) val, 0);
  1207. }
  1209. /*-------------------------------------------------------------------------*/
  1211. static int pl_reset (struct usbnet *dev)
  1212. {
  1213. return pl_set_QuickLink_features (dev,
  1214. PL_S_EN|PL_RESET_OUT|PL_RESET_IN|PL_PEER_E);
  1215. }
  1217. static const struct driver_info prolific_info = {
  1218. .description = "Prolific PL-2301/PL-2302",
  1219. .flags = FLAG_NO_SETINT,
  1220. /* some PL-2302 versions seem to fail usb_set_interface() */
  1221. .reset = pl_reset,
  1223. .in = 3, .out = 2,
  1224. .epsize =64,
  1225. };
  1227. #endif /* CONFIG_USB_PL2301 */
  1231. /*-------------------------------------------------------------------------
  1232.  *
  1233.  * Network Device Driver (peer link to "Host Device", from USB host)
  1234.  *
  1235.  *-------------------------------------------------------------------------*/
  1237. static int usbnet_change_mtu (struct net_device *net, int new_mtu)
  1238. {
  1239. struct usbnet *dev = (struct usbnet *) net->priv;
  1241. if (new_mtu <= MIN_PACKET || new_mtu > MAX_PACKET)
  1242. return -EINVAL;
  1243. #ifdef CONFIG_USB_NET1080
  1244. if (((dev->driver_info->flags) & FLAG_FRAMING_NC)) {
  1245. if (FRAMED_SIZE (new_mtu) > MAX_PACKET)
  1246. return -EINVAL;
  1247. }
  1248. #endif
  1249. #ifdef CONFIG_USB_GENESYS
  1250. if (((dev->driver_info->flags) & FLAG_FRAMING_GL)
  1251. && new_mtu > GL_MAX_PACKET_LEN)
  1252. return -EINVAL;
  1253. #endif
  1254. // no second zero-length packet read wanted after mtu-sized packets
  1255. if (((new_mtu + sizeof (struct ethhdr)) % EP_SIZE (dev)) == 0)
  1256. return -EDOM;
  1257. net->mtu = new_mtu;
  1258. return 0;
  1259. }
  1261. /*-------------------------------------------------------------------------*/
  1263. static struct net_device_stats *usbnet_get_stats (struct net_device *net)
  1264. {
  1265. return &((struct usbnet *) net->priv)->stats;
  1266. }
  1268. /*-------------------------------------------------------------------------*/
  1270. /* urb completions are currently in_irq; avoid doing real work then. */
  1272. static void defer_bh (struct usbnet *dev, struct sk_buff *skb)
  1273. {
  1274. struct sk_buff_head *list = skb->list;
  1275. unsigned long flags;
  1277. spin_lock_irqsave (&list->lock, flags);
  1278. __skb_unlink (skb, list);
  1279. spin_unlock (&list->lock);
  1280. spin_lock (&dev->done.lock);
  1281. __skb_queue_tail (&dev->done, skb);
  1282. if (dev->done.qlen == 1)
  1283. tasklet_schedule (&dev->bh);
  1284. spin_unlock_irqrestore (&dev->done.lock, flags);
  1285. }
  1287. /* some work can't be done in tasklets, so we use keventd
  1288.  *
  1289.  * NOTE:  annoying asymmetry:  if it's active, schedule_task() fails,
  1290.  * but tasklet_schedule() doesn't.  hope the failure is rare.
  1291.  */
  1292. static void defer_kevent (struct usbnet *dev, int work)
  1293. {
  1294. set_bit (work, &dev->flags);
  1295. if (!schedule_task (&dev->kevent))
  1296. err ("%s: kevent %d may have been dropped",
  1297. dev->net.name, work);
  1298. else
  1299. dbg ("%s: kevent %d scheduled", dev->net.name, work);
  1300. }
  1302. /*-------------------------------------------------------------------------*/
  1304. static void rx_complete (struct urb *urb);
  1306. static void rx_submit (struct usbnet *dev, struct urb *urb, int flags)
  1307. {
  1308. struct sk_buff *skb;
  1309. struct skb_data *entry;
  1310. int retval = 0;
  1311. unsigned long lockflags;
  1312. size_t size;
  1314. #ifdef CONFIG_USB_NET1080
  1315. if (dev->driver_info->flags & FLAG_FRAMING_NC)
  1316. size = FRAMED_SIZE (dev->net.mtu);
  1317. else
  1318. #endif
  1319. #ifdef CONFIG_USB_GENESYS
  1320. if (dev->driver_info->flags & FLAG_FRAMING_GL)
  1321. size = GL_RCV_BUF_SIZE;
  1322. else
  1323. #endif
  1324. size = (sizeof (struct ethhdr) + dev->net.mtu);
  1326. if ((skb = alloc_skb (size, flags)) == 0) {
  1327. dbg ("no rx skb");
  1328. defer_kevent (dev, EVENT_RX_MEMORY);
  1329. usb_free_urb (urb);
  1330. return;
  1331. }
  1333. entry = (struct skb_data *) skb->cb;
  1334. entry->urb = urb;
  1335. entry->dev = dev;
  1336. entry->state = rx_start;
  1337. entry->length = 0;
  1339. FILL_BULK_URB (urb, dev->udev,
  1340. usb_rcvbulkpipe (dev->udev, dev->driver_info->in),
  1341. skb->data, size, rx_complete, skb);
  1342. urb->transfer_flags |= USB_ASYNC_UNLINK;
  1343. #if 0
  1344. // Idle-but-posted reads with UHCI really chew up
  1345. // PCI bandwidth unless FSBR is disabled
  1346. urb->transfer_flags |= USB_NO_FSBR;
  1347. #endif
  1349. spin_lock_irqsave (&dev->rxq.lock, lockflags);
  1351. if (netif_running (&dev->net)
  1352. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  1353. switch (retval = SUBMIT_URB (urb, GFP_ATOMIC)){ 
  1354. case -EPIPE:
  1355. defer_kevent (dev, EVENT_RX_HALT);
  1356. break;
  1357. case -ENOMEM:
  1358. defer_kevent (dev, EVENT_RX_MEMORY);
  1359. break;
  1360. default:
  1361. dbg ("%s rx submit, %d", dev->net.name, retval);
  1362. tasklet_schedule (&dev->bh);
  1363. break;
  1364. case 0:
  1365. __skb_queue_tail (&dev->rxq, skb);
  1366. }
  1367. } else {
  1368. dbg ("rx: stopped");
  1369. retval = -ENOLINK;
  1370. }
  1371. spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
  1372. if (retval) {
  1373. dev_kfree_skb_any (skb);
  1374. usb_free_urb (urb);
  1375. }
  1376. }
  1379. /*-------------------------------------------------------------------------*/
  1381. static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
  1382. {
  1383. if (dev->driver_info->rx_fixup
  1384. && !dev->driver_info->rx_fixup (dev, skb))
  1385. goto error;
  1386. // else network stack removes extra byte if we forced a short packet
  1388. if (skb->len) {
  1389. int status;
  1391. // FIXME: eth_copy_and_csum "small" packets to new SKB (small < ~200 bytes) ?
  1393. skb->dev = &dev->net;
  1394. skb->protocol = eth_type_trans (skb, &dev->net);
  1395. dev->stats.rx_packets++;
  1396. dev->stats.rx_bytes += skb->len;
  1398. #ifdef VERBOSE
  1399. devdbg (dev, "< rx, len %d, type 0x%x",
  1400. skb->len + sizeof (struct ethhdr), skb->protocol);
  1401. #endif
  1402. memset (skb->cb, 0, sizeof (struct skb_data));
  1403. status = netif_rx (skb);
  1404. if (status != NET_RX_SUCCESS)
  1405. devdbg (dev, "netif_rx status %d", status);
  1406. } else {
  1407. dbg ("drop");
  1408. error:
  1409. dev->stats.rx_errors++;
  1410. skb_queue_tail (&dev->done, skb);
  1411. }
  1412. }
  1414. /*-------------------------------------------------------------------------*/
  1416. static void rx_complete (struct urb *urb)
  1417. {
  1418. struct sk_buff *skb = (struct sk_buff *) urb->context;
  1419. struct skb_data *entry = (struct skb_data *) skb->cb;
  1420. struct usbnet *dev = entry->dev;
  1421. int urb_status = urb->status;
  1423. skb_put (skb, urb->actual_length);
  1424. entry->state = rx_done;
  1425. entry->urb = 0;
  1427. switch (urb_status) {
  1428.     // success
  1429.     case 0:
  1430. if (MIN_PACKET > skb->len || skb->len > MAX_PACKET) {
  1431. entry->state = rx_cleanup;
  1432. dev->stats.rx_errors++;
  1433. dev->stats.rx_length_errors++;
  1434. dbg ("rx length %d", skb->len);
  1435. }
  1436. break;
  1438.     // stalls need manual reset. this is rare ... except that
  1439.     // when going through USB 2.0 TTs, unplug appears this way.
  1440.     // we avoid the highspeed version of the ETIMEOUT/EILSEQ
  1441.     // storm, recovering as needed.
  1442.     case -EPIPE:
  1443. defer_kevent (dev, EVENT_RX_HALT);
  1444. // FALLTHROUGH
  1446.     // software-driven interface shutdown
  1447.     case -ECONNRESET: // according to API spec
  1448.     case -ECONNABORTED: // some (now fixed?) UHCI bugs
  1449. dbg ("%s rx shutdown, code %d", dev->net.name, urb_status);
  1450. entry->state = rx_cleanup;
  1451. // do urb frees only in the tasklet (UHCI has oopsed ...)
  1452. entry->urb = urb;
  1453. urb = 0;
  1454. break;
  1456.     // data overrun ... flush fifo?
  1457.     case -EOVERFLOW:
  1458. dev->stats.rx_over_errors++;
  1459. // FALLTHROUGH
  1460.     
  1461.     default:
  1462. // on unplug we get ETIMEDOUT (ohci) or EILSEQ (uhci)
  1463. // until khubd sees its interrupt and disconnects us.
  1464. // that can easily be hundreds of passes through here.
  1465. entry->state = rx_cleanup;
  1466. dev->stats.rx_errors++;
  1467. dbg ("%s rx: status %d", dev->net.name, urb_status);
  1468. break;
  1469. }
  1471. defer_bh (dev, skb);
  1473. if (urb) {
  1474. if (netif_running (&dev->net)
  1475. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  1476. rx_submit (dev, urb, GFP_ATOMIC);
  1477. return;
  1478. }
  1479. usb_free_urb (urb);
  1480. }
  1481. #ifdef VERBOSE
  1482. dbg ("no read resubmitted");
  1483. #endif /* VERBOSE */
  1484. }
  1486. /*-------------------------------------------------------------------------*/
  1488. // unlink pending rx/tx; completion handlers do all other cleanup
  1490. static int unlink_urbs (struct sk_buff_head *q)
  1491. {
  1492. unsigned long flags;
  1493. struct sk_buff *skb, *skbnext;
  1494. int count = 0;
  1496. spin_lock_irqsave (&q->lock, flags);
  1497. for (skb = q->next; skb != (struct sk_buff *) q; skb = skbnext) {
  1498. struct skb_data *entry;
  1499. struct urb *urb;
  1500. int retval;
  1502. entry = (struct skb_data *) skb->cb;
  1503. urb = entry->urb;
  1504. skbnext = skb->next;
  1506. // during some PM-driven resume scenarios,
  1507. // these (async) unlinks complete immediately
  1508. retval = usb_unlink_urb (urb);
  1509. if (retval != -EINPROGRESS && retval != 0)
  1510. dbg ("unlink urb err, %d", retval);
  1511. else
  1512. count++;
  1513. }
  1514. spin_unlock_irqrestore (&q->lock, flags);
  1515. return count;
  1516. }
  1519. /*-------------------------------------------------------------------------*/
  1521. // precondition: never called in_interrupt
  1523. static int usbnet_stop (struct net_device *net)
  1524. {
  1525. struct usbnet *dev = (struct usbnet *) net->priv;
  1526. int temp;
  1527. DECLARE_WAIT_QUEUE_HEAD (unlink_wakeup); 
  1528. DECLARE_WAITQUEUE (wait, current);
  1530. mutex_lock (&dev->mutex);
  1531. netif_stop_queue (net);
  1533. if (dev->msg_level >= 2)
  1534. devinfo (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",
  1535. dev->stats.rx_packets, dev->stats.tx_packets, 
  1536. dev->stats.rx_errors, dev->stats.tx_errors
  1537. );
  1539. // ensure there are no more active urbs
  1540. add_wait_queue (&unlink_wakeup, &wait);
  1541. dev->wait = &unlink_wakeup;
  1542. temp = unlink_urbs (&dev->txq) + unlink_urbs (&dev->rxq);
  1544. // maybe wait for deletions to finish.
  1545. while (skb_queue_len (&dev->rxq)
  1546. && skb_queue_len (&dev->txq)
  1547. && skb_queue_len (&dev->done)) {
  1548. set_current_state (TASK_UNINTERRUPTIBLE);
  1549. schedule_timeout (UNLINK_TIMEOUT_JIFFIES);
  1550. dbg ("waited for %d urb completions", temp);
  1551. }
  1552. dev->wait = 0;
  1553. remove_wait_queue (&unlink_wakeup, &wait); 
  1555. mutex_unlock (&dev->mutex);
  1556. return 0;
  1557. }
  1559. /*-------------------------------------------------------------------------*/
  1561. // posts reads, and enables write queing
  1563. // precondition: never called in_interrupt
  1565. static int usbnet_open (struct net_device *net)
  1566. {
  1567. struct usbnet *dev = (struct usbnet *) net->priv;
  1568. int retval = 0;
  1569. struct driver_info *info = dev->driver_info;
  1571. mutex_lock (&dev->mutex);
  1573. // put into "known safe" state
  1574. if (info->reset && (retval = info->reset (dev)) < 0) {
  1575. devinfo (dev, "open reset fail (%d) usbnet usb-%s-%s, %s",
  1576. retval,
  1577. dev->udev->bus->bus_name, dev->udev->devpath,
  1578. info->description);
  1579. goto done;
  1580. }
  1582. // insist peer be connected
  1583. if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
  1584. devdbg (dev, "can't open; %d", retval);
  1585. goto done;
  1586. }
  1588. netif_start_queue (net);
  1589. if (dev->msg_level >= 2)
  1590. devinfo (dev, "open: enable queueing "
  1591. "(rx %d, tx %d) mtu %d %s framing",
  1592. RX_QLEN, TX_QLEN, dev->net.mtu,
  1593. (info->flags & (FLAG_FRAMING_NC | FLAG_FRAMING_GL))
  1594.     ? ((info->flags & FLAG_FRAMING_NC)
  1595. ? "NetChip"
  1596. : "GeneSys")
  1597.     : "raw"
  1598. );
  1600. // delay posting reads until we're fully open
  1601. tasklet_schedule (&dev->bh);
  1602. done:
  1603. mutex_unlock (&dev->mutex);
  1604. return retval;
  1605. }
  1607. /*-------------------------------------------------------------------------*/
  1609. static int usbnet_ethtool_ioctl (struct net_device *net, void *useraddr)
  1610. {
  1611. struct usbnet *dev = (struct usbnet *) net->priv;
  1612. u32 cmd;
  1614. if (get_user (cmd, (u32 *)useraddr))
  1615. return -EFAULT;
  1616. switch (cmd) {
  1618. case ETHTOOL_GDRVINFO: { /* get driver info */
  1619. struct ethtool_drvinfo info;
  1621. memset (&info, 0, sizeof info);
  1622. info.cmd = ETHTOOL_GDRVINFO;
  1623. strncpy (info.driver, driver_name, sizeof info.driver);
  1624. strncpy (info.version, DRIVER_VERSION, sizeof info.version);
  1625. strncpy (info.fw_version, dev->driver_info->description,
  1626. sizeof info.fw_version);
  1627. usb_make_path (dev->udev, info.bus_info, sizeof info.bus_info);
  1628. if (copy_to_user (useraddr, &info, sizeof (info)))
  1629. return -EFAULT;
  1630. return 0;
  1631. }
  1633. case ETHTOOL_GLINK:  /* get link status */
  1634. if (dev->driver_info->check_connect) {
  1635. struct ethtool_value edata = { ETHTOOL_GLINK };
  1637. edata.data = dev->driver_info->check_connect (dev) == 0;
  1638. if (copy_to_user (useraddr, &edata, sizeof (edata)))
  1639. return -EFAULT;
  1640. return 0;
  1641. }
  1642. break;
  1644. case ETHTOOL_GMSGLVL: { /* get message-level */
  1645. struct ethtool_value edata = {ETHTOOL_GMSGLVL};
  1647. edata.data = dev->msg_level;
  1648. if (copy_to_user (useraddr, &edata, sizeof (edata)))
  1649. return -EFAULT;
  1650. return 0;
  1651. }
  1653. case ETHTOOL_SMSGLVL: { /* set message-level */
  1654. struct ethtool_value edata;
  1656. if (copy_from_user (&edata, useraddr, sizeof (edata)))
  1657. return -EFAULT;
  1658. dev->msg_level = edata.data;
  1659. return 0;
  1660. }
  1662. /* could also map RINGPARAM to RX/TX QLEN */
  1664. }
  1665.         /* Note that the ethtool user space code requires EOPNOTSUPP */
  1666. return -EOPNOTSUPP;
  1667. }
  1669. static int usbnet_ioctl (struct net_device *net, struct ifreq *rq, int cmd)
  1670. {
  1671. switch (cmd) {
  1672. case SIOCETHTOOL:
  1673. return usbnet_ethtool_ioctl (net, (void *)rq->ifr_data);
  1674. default:
  1675. return -EOPNOTSUPP;
  1676. }
  1677. }
  1679. /*-------------------------------------------------------------------------*/
  1681. /* work that cannot be done in interrupt context uses keventd.
  1682.  *
  1683.  * NOTE:  "uhci" and "usb-uhci" may have trouble with this since they don't
  1684.  * queue control transfers to individual devices, and other threads could
  1685.  * trigger control requests concurrently.  hope that's rare.
  1686.  */
  1687. static void
  1688. kevent (void *data)
  1689. {
  1690. struct usbnet *dev = data;
  1691. int status;
  1693. /* usb_clear_halt() needs a thread context */
  1694. if (test_bit (EVENT_TX_HALT, &dev->flags)) {
  1695. unlink_urbs (&dev->txq);
  1696. status = usb_clear_halt (dev->udev,
  1697. usb_sndbulkpipe (dev->udev, dev->driver_info->out));
  1698. if (status < 0)
  1699. err ("%s: can't clear tx halt, status %d",
  1700. dev->net.name, status);
  1701. else {
  1702. clear_bit (EVENT_TX_HALT, &dev->flags);
  1703. netif_wake_queue (&dev->net);
  1704. }
  1705. }
  1706. if (test_bit (EVENT_RX_HALT, &dev->flags)) {
  1707. unlink_urbs (&dev->rxq);
  1708. status = usb_clear_halt (dev->udev,
  1709. usb_rcvbulkpipe (dev->udev, dev->driver_info->in));
  1710. if (status < 0)
  1711. err ("%s: can't clear rx halt, status %d",
  1712. dev->net.name, status);
  1713. else {
  1714. clear_bit (EVENT_RX_HALT, &dev->flags);
  1715. tasklet_schedule (&dev->bh);
  1716. }
  1717. }
  1719. /* tasklet could resubmit itself forever if memory is tight */
  1720. if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
  1721. struct urb *urb = 0;
  1723. if (netif_running (&dev->net))
  1724. urb = ALLOC_URB (0, GFP_KERNEL);
  1725. else
  1726. clear_bit (EVENT_RX_MEMORY, &dev->flags);
  1727. if (urb != 0) {
  1728. clear_bit (EVENT_RX_MEMORY, &dev->flags);
  1729. rx_submit (dev, urb, GFP_KERNEL);
  1730. tasklet_schedule (&dev->bh);
  1731. }
  1732. }
  1734. if (dev->flags)
  1735. dbg ("%s: kevent done, flags = 0x%lx",
  1736. dev->net.name, dev->flags);
  1737. }
  1739. /*-------------------------------------------------------------------------*/
  1741. static void tx_complete (struct urb *urb)
  1742. {
  1743. struct sk_buff *skb = (struct sk_buff *) urb->context;
  1744. struct skb_data *entry = (struct skb_data *) skb->cb;
  1745. struct usbnet *dev = entry->dev;
  1747. if (urb->status == -EPIPE)
  1748. defer_kevent (dev, EVENT_TX_HALT);
  1749. urb->dev = 0;
  1750. entry->state = tx_done;
  1751. defer_bh (dev, skb);
  1752. }
  1754. /*-------------------------------------------------------------------------*/
  1756. static void usbnet_tx_timeout (struct net_device *net)
  1757. {
  1758. struct usbnet *dev = (struct usbnet *) net->priv;
  1760. unlink_urbs (&dev->txq);
  1761. tasklet_schedule (&dev->bh);
  1763. // FIXME: device recovery -- reset?
  1764. }
  1766. /*-------------------------------------------------------------------------*/
  1768. static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
  1769. {
  1770. struct usbnet *dev = (struct usbnet *) net->priv;
  1771. int length = skb->len;
  1772. int retval = NET_XMIT_SUCCESS;
  1773. struct urb *urb = 0;
  1774. struct skb_data *entry;
  1775. struct driver_info *info = dev->driver_info;
  1776. unsigned long flags;
  1777. #ifdef CONFIG_USB_NET1080
  1778. struct nc_header *header = 0;
  1779. struct nc_trailer *trailer = 0;
  1780. #endif /* CONFIG_USB_NET1080 */
  1782. // some devices want funky USB-level framing, for
  1783. // win32 driver (usually) and/or hardware quirks
  1784. if (info->tx_fixup) {
  1785. skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
  1786. if (!skb) {
  1787. dbg ("can't tx_fixup skb");
  1788. goto drop;
  1789. }
  1790. }
  1792. if (!(urb = ALLOC_URB (0, GFP_ATOMIC))) {
  1793. dbg ("no urb");
  1794. goto drop;
  1795. }
  1797. entry = (struct skb_data *) skb->cb;
  1798. entry->urb = urb;
  1799. entry->dev = dev;
  1800. entry->state = tx_start;
  1801. entry->length = length;
  1803. // FIXME: reorganize a bit, so that fixup() fills out NetChip
  1804. // framing too. (Packet ID update needs the spinlock...)
  1806. #ifdef CONFIG_USB_NET1080
  1807. if (info->flags & FLAG_FRAMING_NC) {
  1808. header = (struct nc_header *) skb_push (skb, sizeof *header);
  1809. header->hdr_len = cpu_to_le16 (sizeof (*header));
  1810. header->packet_len = cpu_to_le16 (length);
  1811. if (!((skb->len + sizeof *trailer) & 0x01))
  1812. *skb_put (skb, 1) = PAD_BYTE;
  1813. trailer = (struct nc_trailer *) skb_put (skb, sizeof *trailer);
  1814. } else
  1815. #endif /* CONFIG_USB_NET1080 */
  1817. /* don't assume the hardware handles USB_ZERO_PACKET */
  1818. if ((length % EP_SIZE (dev)) == 0)
  1819. skb->len++;
  1821. FILL_BULK_URB (urb, dev->udev,
  1822. usb_sndbulkpipe (dev->udev, info->out),
  1823. skb->data, skb->len, tx_complete, skb);
  1824. urb->transfer_flags |= USB_ASYNC_UNLINK;
  1825. // FIXME urb->timeout = ... jiffies ... ;
  1827. spin_lock_irqsave (&dev->txq.lock, flags);
  1829. #ifdef CONFIG_USB_NET1080
  1830. if (info->flags & FLAG_FRAMING_NC) {
  1831. header->packet_id = cpu_to_le16 (dev->packet_id++);
  1832. put_unaligned (header->packet_id, &trailer->packet_id);
  1833. #if 0
  1834. devdbg (dev, "frame >tx h %d p %d id %d",
  1835. header->hdr_len, header->packet_len,
  1836. header->packet_id);
  1837. #endif
  1838. }
  1839. #endif /* CONFIG_USB_NET1080 */
  1841. switch ((retval = SUBMIT_URB (urb, GFP_ATOMIC))) {
  1842. case -EPIPE:
  1843. netif_stop_queue (net);
  1844. defer_kevent (dev, EVENT_TX_HALT);
  1845. break;
  1846. default:
  1847. dbg ("%s tx: submit urb err %d", net->name, retval);
  1848. break;
  1849. case 0:
  1850. net->trans_start = jiffies;
  1851. __skb_queue_tail (&dev->txq, skb);
  1852. if (dev->txq.qlen >= TX_QLEN)
  1853. netif_stop_queue (net);
  1854. }
  1855. spin_unlock_irqrestore (&dev->txq.lock, flags);
  1857. if (retval) {
  1858. devdbg (dev, "drop, code %d", retval);
  1859. drop:
  1860. retval = NET_XMIT_DROP;
  1861. dev->stats.tx_dropped++;
  1862. if (skb)
  1863. dev_kfree_skb_any (skb);
  1864. usb_free_urb (urb);
  1865. #ifdef VERBOSE
  1866. } else {
  1867. devdbg (dev, "> tx, len %d, type 0x%x",
  1868. length, skb->protocol);
  1869. #endif
  1870. }
  1871. return retval;
  1872. }
  1875. /*-------------------------------------------------------------------------*/
  1877. // tasklet ... work that avoided running in_irq()
  1879. static void usbnet_bh (unsigned long param)
  1880. {
  1881. struct usbnet *dev = (struct usbnet *) param;
  1882. struct sk_buff *skb;
  1883. struct skb_data *entry;
  1885. while ((skb = skb_dequeue (&dev->done))) {
  1886. entry = (struct skb_data *) skb->cb;
  1887. switch (entry->state) {
  1888.     case rx_done:
  1889. entry->state = rx_cleanup;
  1890. rx_process (dev, skb);
  1891. continue;
  1892.     case tx_done:
  1893. if (entry->urb->status) {
  1894. // can this statistic become more specific?
  1895. dev->stats.tx_errors++;
  1896. dbg ("%s tx: err %d", dev->net.name,
  1897. entry->urb->status);
  1898. } else {
  1899. dev->stats.tx_packets++;
  1900. dev->stats.tx_bytes += entry->length;
  1901. }
  1902. // FALLTHROUGH:
  1903.     case rx_cleanup:
  1904. usb_free_urb (entry->urb);
  1905. dev_kfree_skb (skb);
  1906. continue;
  1907.     default:
  1908. dbg ("%s: bogus skb state %d",
  1909. dev->net.name, entry->state);
  1910. }
  1911. }
  1913. // waiting for all pending urbs to complete?
  1914. if (dev->wait) {
  1915. if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) {
  1916. wake_up (dev->wait);
  1917. }
  1919. // or are we maybe short a few urbs?
  1920. } else if (netif_running (&dev->net)
  1921. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  1922. int temp = dev->rxq.qlen;
  1924. if (temp < RX_QLEN) {
  1925. struct urb *urb;
  1926. int i;
  1927. for (i = 0; i < 3 && dev->rxq.qlen < RX_QLEN; i++) {
  1928. if ((urb = ALLOC_URB (0, GFP_ATOMIC)) != 0)
  1929. rx_submit (dev, urb, GFP_ATOMIC);
  1930. }
  1931. if (temp != dev->rxq.qlen)
  1932. devdbg (dev, "rxqlen %d --> %d",
  1933. temp, dev->rxq.qlen);
  1934. if (dev->rxq.qlen < RX_QLEN)
  1935. tasklet_schedule (&dev->bh);
  1936. }
  1937. if (dev->txq.qlen < TX_QLEN)
  1938. netif_wake_queue (&dev->net);
  1939. }
  1940. }
  1944. /*-------------------------------------------------------------------------
  1945.  *
  1946.  * USB Device Driver support
  1947.  *
  1948.  *-------------------------------------------------------------------------*/
  1949.  
  1950. // precondition: never called in_interrupt
  1952. static void usbnet_disconnect (struct usb_device *udev, void *ptr)
  1953. {
  1954. struct usbnet *dev = (struct usbnet *) ptr;
  1956. devinfo (dev, "unregister usbnet usb-%s-%s, %s",
  1957. udev->bus->bus_name, udev->devpath,
  1958. dev->driver_info->description);
  1960. unregister_netdev (&dev->net);
  1962. mutex_lock (&usbnet_mutex);
  1963. mutex_lock (&dev->mutex);
  1964. list_del (&dev->dev_list);
  1965. mutex_unlock (&usbnet_mutex);
  1967. // assuming we used keventd, it must quiesce too
  1968. flush_scheduled_tasks ();
  1970. kfree (dev);
  1971. usb_put_dev (udev);
  1972. }
  1975. /*-------------------------------------------------------------------------*/
  1977. // precondition: never called in_interrupt
  1979. static void *
  1980. usbnet_probe (struct usb_device *udev, unsigned ifnum,
  1981. const struct usb_device_id *prod)
  1982. {
  1983. struct usbnet *dev;
  1984. struct net_device  *net;
  1985. struct usb_interface_descriptor *interface;
  1986. struct driver_info *info;
  1987. int altnum = 0;
  1989. info = (struct driver_info *) prod->driver_info;
  1991. // sanity check; expect dedicated interface/devices for now.
  1992. interface = &udev->actconfig->interface [ifnum].altsetting [altnum];
  1993. if (udev->descriptor.bNumConfigurations != 1
  1994. || udev->config[0].bNumInterfaces != 1
  1995. // || interface->bInterfaceClass != USB_CLASS_VENDOR_SPEC
  1996. ) {
  1997. dbg ("Bogus config info");
  1998. return 0;
  1999. }
  2001. // more sanity (unless the device is broken)
  2002. if (!(info->flags & FLAG_NO_SETINT)) {
  2003. if (usb_set_interface (udev, ifnum, altnum) < 0) {
  2004. err ("set_interface failed");
  2005. return 0;
  2006. }
  2007. }
  2009. // set up our own records
  2010. if (!(dev = kmalloc (sizeof *dev, GFP_KERNEL))) {
  2011. dbg ("can't kmalloc dev");
  2012. return 0;
  2013. }
  2014. memset (dev, 0, sizeof *dev);
  2016. init_MUTEX_LOCKED (&dev->mutex);
  2017. usb_get_dev (udev);
  2018. dev->udev = udev;
  2019. dev->driver_info = info;
  2020. dev->msg_level = msg_level;
  2021. INIT_LIST_HEAD (&dev->dev_list);
  2022. skb_queue_head_init (&dev->rxq);
  2023. skb_queue_head_init (&dev->txq);
  2024. skb_queue_head_init (&dev->done);
  2025. dev->bh.func = usbnet_bh;
  2026. dev->bh.data = (unsigned long) dev;
  2027. INIT_TQUEUE (&dev->kevent, kevent, dev);
  2029. // set up network interface records
  2030. net = &dev->net;
  2031. SET_MODULE_OWNER (net);
  2032. net->priv = dev;
  2033. strcpy (net->name, "usb%d");
  2034. memcpy (net->dev_addr, node_id, sizeof node_id);
  2036. // point-to-point link ... we always use Ethernet headers 
  2037. // supports win32 interop and the bridge driver.
  2038. ether_setup (net);
  2040. net->change_mtu = usbnet_change_mtu;
  2041. net->get_stats = usbnet_get_stats;
  2042. net->hard_start_xmit = usbnet_start_xmit;
  2043. net->open = usbnet_open;
  2044. net->stop = usbnet_stop;
  2045. net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
  2046. net->tx_timeout = usbnet_tx_timeout;
  2047. net->do_ioctl = usbnet_ioctl;
  2049. register_netdev (&dev->net);
  2050. devinfo (dev, "register usbnet usb-%s-%s, %s",
  2051. udev->bus->bus_name, udev->devpath,
  2052. dev->driver_info->description);
  2054. // ok, it's ready to go.
  2055. mutex_lock (&usbnet_mutex);
  2056. list_add (&dev->dev_list, &usbnet_list);
  2057. mutex_unlock (&dev->mutex);
  2059. // start as if the link is up
  2060. netif_device_attach (&dev->net);
  2062. mutex_unlock (&usbnet_mutex);
  2063. return dev;
  2064. }
  2067. /*-------------------------------------------------------------------------*/
  2069. /*
  2070.  * chip vendor names won't normally be on the cables, and
  2071.  * may not be on the device.
  2072.  */
  2074. static const struct usb_device_id products [] = {
  2076. #ifdef CONFIG_USB_AN2720
  2077. {
  2078. USB_DEVICE (0x0547, 0x2720), // AnchorChips defaults
  2079. .driver_info = (unsigned long) &an2720_info,
  2080. }, {
  2081. USB_DEVICE (0x0547, 0x2727), // Xircom PGUNET
  2082. .driver_info = (unsigned long) &an2720_info,
  2083. },
  2084. #endif
  2086. #ifdef CONFIG_USB_BELKIN
  2087. {
  2088. USB_DEVICE (0x050d, 0x0004), // Belkin
  2089. .driver_info = (unsigned long) &belkin_info,
  2090. }, {
  2091. USB_DEVICE (0x056c, 0x8100), // eTEK
  2092. .driver_info = (unsigned long) &belkin_info,
  2093. }, {
  2094. USB_DEVICE (0x0525, 0x9901), // Advance USBNET (eTEK)
  2095. .driver_info = (unsigned long) &belkin_info,
  2096. },
  2097. #endif
  2099. #ifdef CONFIG_USB_EPSON2888
  2100. {
  2101. USB_DEVICE (0x0525, 0x2888), // EPSON USB client
  2102. driver_info: (unsigned long) &epson2888_info,
  2103. },
  2104. #endif
  2106. #ifdef CONFIG_USB_GENESYS
  2107. {
  2108. USB_DEVICE (0x05e3, 0x0502), // GL620USB-A
  2109. .driver_info = (unsigned long) &genelink_info,
  2110. },
  2111. /* NOT: USB_DEVICE (0x05e3, 0x0501), // GL620USB
  2112.  * that's half duplex, not currently supported
  2113.  */
  2114. #endif
  2116. #ifdef CONFIG_USB_LINUXDEV
  2117. /*
  2118.  * for example, this can be a host side talk-to-PDA driver.
  2119.  * this driver is NOT what runs _inside_ a Linux device !!
  2120.  */
  2121. {
  2122. // 1183 = 0x049F, both used as hex values?
  2123. USB_DEVICE (0x049F, 0x505A), // Compaq "Itsy"
  2124. .driver_info = (unsigned long) &linuxdev_info,
  2125. }, {
  2126. USB_DEVICE (0x0E7E, 0x1001), // G.Mate "Yopy"
  2127. .driver_info = (unsigned long) &linuxdev_info,
  2128. },
  2129. // NOTE:  the Sharp Zaurus uses a modified version of
  2130. // this driver, which is not interoperable with this.
  2131. #endif
  2133. #ifdef CONFIG_USB_NET1080
  2134. {
  2135. USB_DEVICE (0x0525, 0x1080), // NetChip ref design
  2136. .driver_info = (unsigned long) &net1080_info,
  2137. }, {
  2138. USB_DEVICE (0x06D0, 0x0622), // Laplink Gold
  2139. .driver_info = (unsigned long) &net1080_info,
  2140. },
  2141. #endif
  2143. #ifdef CONFIG_USB_PL2301
  2144. {
  2145. USB_DEVICE (0x067b, 0x0000), // PL-2301
  2146. .driver_info = (unsigned long) &prolific_info,
  2147. }, {
  2148. USB_DEVICE (0x067b, 0x0001), // PL-2302
  2149. .driver_info = (unsigned long) &prolific_info,
  2150. },
  2151. #endif
  2153. /* KC2190 from www.sepoong.co.kr "InstaNET" */
  2155. { }, // END
  2156. };
  2157. MODULE_DEVICE_TABLE (usb, products);
  2159. static struct usb_driver usbnet_driver = {
  2160. .name = driver_name,
  2161. .id_table = products,
  2162. .probe = usbnet_probe,
  2163. .disconnect = usbnet_disconnect,
  2164. };
  2166. /*-------------------------------------------------------------------------*/
  2168. static int __init usbnet_init (void)
  2169. {
  2170. // compiler should optimize this out
  2171. if (sizeof (((struct sk_buff *)0)->cb) < sizeof (struct skb_data))
  2172. BUG ();
  2174. get_random_bytes (node_id, sizeof node_id);
  2175. node_id [0] &= 0xfe; // clear multicast bit
  2176. node_id [0] |= 0x02;    // set local assignment bit (IEEE802)
  2178.   if (usb_register (&usbnet_driver) < 0)
  2179.   return -1;
  2181. return 0;
  2182. }
  2183. module_init (usbnet_init);
  2185. static void __exit usbnet_exit (void)
  2186. {
  2187.   usb_deregister (&usbnet_driver);
  2188. }
  2189. module_exit (usbnet_exit);
  2191. EXPORT_NO_SYMBOLS;
  2192. MODULE_AUTHOR ("David Brownell <dbrownell@users.sourceforge.net>");
  2193. MODULE_DESCRIPTION ("USB Host-to-Host Link Drivers (numerous vendors)");
  2194. MODULE_LICENSE ("GPL");