usbnet.c 34 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326
  1. /*
  2. * USB Network driver infrastructure
  3. * Copyright (C) 2000-2005 by David Brownell
  4. * Copyright (C) 2003-2005 David Hollis <dhollis@davehollis.com>
  5. *
  6. * This program is free software; you can redistribute it and/or modify
  7. * it under the terms of the GNU General Public License as published by
  8. * the Free Software Foundation; either version 2 of the License, or
  9. * (at your option) any later version.
  10. *
  11. * This program is distributed in the hope that it will be useful,
  12. * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  14. * GNU General Public License for more details.
  15. *
  16. * You should have received a copy of the GNU General Public License
  17. * along with this program; if not, write to the Free Software
  18. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  19. */
  20. /*
  21. * This is a generic "USB networking" framework that works with several
  22. * kinds of full and high speed networking devices: host-to-host cables,
  23. * smart usb peripherals, and actual Ethernet adapters.
  24. *
  25. * These devices usually differ in terms of control protocols (if they
  26. * even have one!) and sometimes they define new framing to wrap or batch
  27. * Ethernet packets. Otherwise, they talk to USB pretty much the same,
  28. * so interface (un)binding, endpoint I/O queues, fault handling, and other
  29. * issues can usefully be addressed by this framework.
  30. */
  31. // #define DEBUG // error path messages, extra info
  32. // #define VERBOSE // more; success messages
  33. #include <linux/module.h>
  34. #include <linux/init.h>
  35. #include <linux/netdevice.h>
  36. #include <linux/etherdevice.h>
  37. #include <linux/ethtool.h>
  38. #include <linux/workqueue.h>
  39. #include <linux/mii.h>
  40. #include <linux/usb.h>
  41. #include <linux/usb/usbnet.h>
  42. #define DRIVER_VERSION "22-Aug-2005"
  43. /*-------------------------------------------------------------------------*/
  44. /*
  45. * Nineteen USB 1.1 max size bulk transactions per frame (ms), max.
  46. * Several dozen bytes of IPv4 data can fit in two such transactions.
  47. * One maximum size Ethernet packet takes twenty four of them.
  48. * For high speed, each frame comfortably fits almost 36 max size
  49. * Ethernet packets (so queues should be bigger).
  50. *
  51. * REVISIT qlens should be members of 'struct usbnet'; the goal is to
  52. * let the USB host controller be busy for 5msec or more before an irq
  53. * is required, under load. Jumbograms change the equation.
  54. */
  55. #define RX_MAX_QUEUE_MEMORY (60 * 1518)
  56. #define RX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
  57. (RX_MAX_QUEUE_MEMORY/(dev)->rx_urb_size) : 4)
  58. #define TX_QLEN(dev) (((dev)->udev->speed == USB_SPEED_HIGH) ? \
  59. (RX_MAX_QUEUE_MEMORY/(dev)->hard_mtu) : 4)
  60. // reawaken network queue this soon after stopping; else watchdog barks
  61. #define TX_TIMEOUT_JIFFIES (5*HZ)
  62. // throttle rx/tx briefly after some faults, so khubd might disconnect()
  63. // us (it polls at HZ/4 usually) before we report too many false errors.
  64. #define THROTTLE_JIFFIES (HZ/8)
  65. // between wakeups
  66. #define UNLINK_TIMEOUT_MS 3
  67. /*-------------------------------------------------------------------------*/
  68. // randomly generated ethernet address
  69. static u8 node_id [ETH_ALEN];
  70. static const char driver_name [] = "usbnet";
  71. /* use ethtool to change the level for any given device */
  72. static int msg_level = -1;
  73. module_param (msg_level, int, 0);
  74. MODULE_PARM_DESC (msg_level, "Override default message level");
  75. /*-------------------------------------------------------------------------*/
  76. /* handles CDC Ethernet and many other network "bulk data" interfaces */
  77. int usbnet_get_endpoints(struct usbnet *dev, struct usb_interface *intf)
  78. {
  79. int tmp;
  80. struct usb_host_interface *alt = NULL;
  81. struct usb_host_endpoint *in = NULL, *out = NULL;
  82. struct usb_host_endpoint *status = NULL;
  83. for (tmp = 0; tmp < intf->num_altsetting; tmp++) {
  84. unsigned ep;
  85. in = out = status = NULL;
  86. alt = intf->altsetting + tmp;
  87. /* take the first altsetting with in-bulk + out-bulk;
  88. * remember any status endpoint, just in case;
  89. * ignore other endpoints and altsetttings.
  90. */
  91. for (ep = 0; ep < alt->desc.bNumEndpoints; ep++) {
  92. struct usb_host_endpoint *e;
  93. int intr = 0;
  94. e = alt->endpoint + ep;
  95. switch (e->desc.bmAttributes) {
  96. case USB_ENDPOINT_XFER_INT:
  97. if (!usb_endpoint_dir_in(&e->desc))
  98. continue;
  99. intr = 1;
  100. /* FALLTHROUGH */
  101. case USB_ENDPOINT_XFER_BULK:
  102. break;
  103. default:
  104. continue;
  105. }
  106. if (usb_endpoint_dir_in(&e->desc)) {
  107. if (!intr && !in)
  108. in = e;
  109. else if (intr && !status)
  110. status = e;
  111. } else {
  112. if (!out)
  113. out = e;
  114. }
  115. }
  116. if (in && out)
  117. break;
  118. }
  119. if (!alt || !in || !out)
  120. return -EINVAL;
  121. if (alt->desc.bAlternateSetting != 0
  122. || !(dev->driver_info->flags & FLAG_NO_SETINT)) {
  123. tmp = usb_set_interface (dev->udev, alt->desc.bInterfaceNumber,
  124. alt->desc.bAlternateSetting);
  125. if (tmp < 0)
  126. return tmp;
  127. }
  128. dev->in = usb_rcvbulkpipe (dev->udev,
  129. in->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
  130. dev->out = usb_sndbulkpipe (dev->udev,
  131. out->desc.bEndpointAddress & USB_ENDPOINT_NUMBER_MASK);
  132. dev->status = status;
  133. return 0;
  134. }
  135. EXPORT_SYMBOL_GPL(usbnet_get_endpoints);
  136. static void intr_complete (struct urb *urb);
  137. static int init_status (struct usbnet *dev, struct usb_interface *intf)
  138. {
  139. char *buf = NULL;
  140. unsigned pipe = 0;
  141. unsigned maxp;
  142. unsigned period;
  143. if (!dev->driver_info->status)
  144. return 0;
  145. pipe = usb_rcvintpipe (dev->udev,
  146. dev->status->desc.bEndpointAddress
  147. & USB_ENDPOINT_NUMBER_MASK);
  148. maxp = usb_maxpacket (dev->udev, pipe, 0);
  149. /* avoid 1 msec chatter: min 8 msec poll rate */
  150. period = max ((int) dev->status->desc.bInterval,
  151. (dev->udev->speed == USB_SPEED_HIGH) ? 7 : 3);
  152. buf = kmalloc (maxp, GFP_KERNEL);
  153. if (buf) {
  154. dev->interrupt = usb_alloc_urb (0, GFP_KERNEL);
  155. if (!dev->interrupt) {
  156. kfree (buf);
  157. return -ENOMEM;
  158. } else {
  159. usb_fill_int_urb(dev->interrupt, dev->udev, pipe,
  160. buf, maxp, intr_complete, dev, period);
  161. dev_dbg(&intf->dev,
  162. "status ep%din, %d bytes period %d\n",
  163. usb_pipeendpoint(pipe), maxp, period);
  164. }
  165. }
  166. return 0;
  167. }
  168. /* Passes this packet up the stack, updating its accounting.
  169. * Some link protocols batch packets, so their rx_fixup paths
  170. * can return clones as well as just modify the original skb.
  171. */
  172. void usbnet_skb_return (struct usbnet *dev, struct sk_buff *skb)
  173. {
  174. int status;
  175. skb->protocol = eth_type_trans (skb, dev->net);
  176. dev->stats.rx_packets++;
  177. dev->stats.rx_bytes += skb->len;
  178. if (netif_msg_rx_status (dev))
  179. devdbg (dev, "< rx, len %zu, type 0x%x",
  180. skb->len + sizeof (struct ethhdr), skb->protocol);
  181. memset (skb->cb, 0, sizeof (struct skb_data));
  182. status = netif_rx (skb);
  183. if (status != NET_RX_SUCCESS && netif_msg_rx_err (dev))
  184. devdbg (dev, "netif_rx status %d", status);
  185. }
  186. EXPORT_SYMBOL_GPL(usbnet_skb_return);
  187. /*-------------------------------------------------------------------------
  188. *
  189. * Network Device Driver (peer link to "Host Device", from USB host)
  190. *
  191. *-------------------------------------------------------------------------*/
  192. static int usbnet_change_mtu (struct net_device *net, int new_mtu)
  193. {
  194. struct usbnet *dev = netdev_priv(net);
  195. int ll_mtu = new_mtu + net->hard_header_len;
  196. int old_hard_mtu = dev->hard_mtu;
  197. int old_rx_urb_size = dev->rx_urb_size;
  198. if (new_mtu <= 0)
  199. return -EINVAL;
  200. // no second zero-length packet read wanted after mtu-sized packets
  201. if ((ll_mtu % dev->maxpacket) == 0)
  202. return -EDOM;
  203. net->mtu = new_mtu;
  204. dev->hard_mtu = net->mtu + net->hard_header_len;
  205. if (dev->rx_urb_size == old_hard_mtu) {
  206. dev->rx_urb_size = dev->hard_mtu;
  207. if (dev->rx_urb_size > old_rx_urb_size)
  208. usbnet_unlink_rx_urbs(dev);
  209. }
  210. return 0;
  211. }
  212. /*-------------------------------------------------------------------------*/
  213. static struct net_device_stats *usbnet_get_stats (struct net_device *net)
  214. {
  215. struct usbnet *dev = netdev_priv(net);
  216. return &dev->stats;
  217. }
  218. /*-------------------------------------------------------------------------*/
  219. /* some LK 2.4 HCDs oopsed if we freed or resubmitted urbs from
  220. * completion callbacks. 2.5 should have fixed those bugs...
  221. */
  222. static void defer_bh(struct usbnet *dev, struct sk_buff *skb, struct sk_buff_head *list)
  223. {
  224. unsigned long flags;
  225. spin_lock_irqsave(&list->lock, flags);
  226. __skb_unlink(skb, list);
  227. spin_unlock(&list->lock);
  228. spin_lock(&dev->done.lock);
  229. __skb_queue_tail(&dev->done, skb);
  230. if (dev->done.qlen == 1)
  231. tasklet_schedule(&dev->bh);
  232. spin_unlock_irqrestore(&dev->done.lock, flags);
  233. }
  234. /* some work can't be done in tasklets, so we use keventd
  235. *
  236. * NOTE: annoying asymmetry: if it's active, schedule_work() fails,
  237. * but tasklet_schedule() doesn't. hope the failure is rare.
  238. */
  239. void usbnet_defer_kevent (struct usbnet *dev, int work)
  240. {
  241. set_bit (work, &dev->flags);
  242. if (!schedule_work (&dev->kevent))
  243. deverr (dev, "kevent %d may have been dropped", work);
  244. else
  245. devdbg (dev, "kevent %d scheduled", work);
  246. }
  247. EXPORT_SYMBOL_GPL(usbnet_defer_kevent);
  248. /*-------------------------------------------------------------------------*/
  249. static void rx_complete (struct urb *urb);
  250. static void rx_submit (struct usbnet *dev, struct urb *urb, gfp_t flags)
  251. {
  252. struct sk_buff *skb;
  253. struct skb_data *entry;
  254. int retval = 0;
  255. unsigned long lockflags;
  256. size_t size = dev->rx_urb_size;
  257. if ((skb = alloc_skb (size + NET_IP_ALIGN, flags)) == NULL) {
  258. if (netif_msg_rx_err (dev))
  259. devdbg (dev, "no rx skb");
  260. usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
  261. usb_free_urb (urb);
  262. return;
  263. }
  264. skb_reserve (skb, NET_IP_ALIGN);
  265. entry = (struct skb_data *) skb->cb;
  266. entry->urb = urb;
  267. entry->dev = dev;
  268. entry->state = rx_start;
  269. entry->length = 0;
  270. usb_fill_bulk_urb (urb, dev->udev, dev->in,
  271. skb->data, size, rx_complete, skb);
  272. spin_lock_irqsave (&dev->rxq.lock, lockflags);
  273. if (netif_running (dev->net)
  274. && netif_device_present (dev->net)
  275. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  276. switch (retval = usb_submit_urb (urb, GFP_ATOMIC)) {
  277. case -EPIPE:
  278. usbnet_defer_kevent (dev, EVENT_RX_HALT);
  279. break;
  280. case -ENOMEM:
  281. usbnet_defer_kevent (dev, EVENT_RX_MEMORY);
  282. break;
  283. case -ENODEV:
  284. if (netif_msg_ifdown (dev))
  285. devdbg (dev, "device gone");
  286. netif_device_detach (dev->net);
  287. break;
  288. default:
  289. if (netif_msg_rx_err (dev))
  290. devdbg (dev, "rx submit, %d", retval);
  291. tasklet_schedule (&dev->bh);
  292. break;
  293. case 0:
  294. __skb_queue_tail (&dev->rxq, skb);
  295. }
  296. } else {
  297. if (netif_msg_ifdown (dev))
  298. devdbg (dev, "rx: stopped");
  299. retval = -ENOLINK;
  300. }
  301. spin_unlock_irqrestore (&dev->rxq.lock, lockflags);
  302. if (retval) {
  303. dev_kfree_skb_any (skb);
  304. usb_free_urb (urb);
  305. }
  306. }
  307. /*-------------------------------------------------------------------------*/
  308. static inline void rx_process (struct usbnet *dev, struct sk_buff *skb)
  309. {
  310. if (dev->driver_info->rx_fixup
  311. && !dev->driver_info->rx_fixup (dev, skb))
  312. goto error;
  313. // else network stack removes extra byte if we forced a short packet
  314. if (skb->len)
  315. usbnet_skb_return (dev, skb);
  316. else {
  317. if (netif_msg_rx_err (dev))
  318. devdbg (dev, "drop");
  319. error:
  320. dev->stats.rx_errors++;
  321. skb_queue_tail (&dev->done, skb);
  322. }
  323. }
  324. /*-------------------------------------------------------------------------*/
  325. static void rx_complete (struct urb *urb)
  326. {
  327. struct sk_buff *skb = (struct sk_buff *) urb->context;
  328. struct skb_data *entry = (struct skb_data *) skb->cb;
  329. struct usbnet *dev = entry->dev;
  330. int urb_status = urb->status;
  331. skb_put (skb, urb->actual_length);
  332. entry->state = rx_done;
  333. entry->urb = NULL;
  334. switch (urb_status) {
  335. /* success */
  336. case 0:
  337. if (skb->len < dev->net->hard_header_len) {
  338. entry->state = rx_cleanup;
  339. dev->stats.rx_errors++;
  340. dev->stats.rx_length_errors++;
  341. if (netif_msg_rx_err (dev))
  342. devdbg (dev, "rx length %d", skb->len);
  343. }
  344. break;
  345. /* stalls need manual reset. this is rare ... except that
  346. * when going through USB 2.0 TTs, unplug appears this way.
  347. * we avoid the highspeed version of the ETIMEOUT/EILSEQ
  348. * storm, recovering as needed.
  349. */
  350. case -EPIPE:
  351. dev->stats.rx_errors++;
  352. usbnet_defer_kevent (dev, EVENT_RX_HALT);
  353. // FALLTHROUGH
  354. /* software-driven interface shutdown */
  355. case -ECONNRESET: /* async unlink */
  356. case -ESHUTDOWN: /* hardware gone */
  357. if (netif_msg_ifdown (dev))
  358. devdbg (dev, "rx shutdown, code %d", urb_status);
  359. goto block;
  360. /* we get controller i/o faults during khubd disconnect() delays.
  361. * throttle down resubmits, to avoid log floods; just temporarily,
  362. * so we still recover when the fault isn't a khubd delay.
  363. */
  364. case -EPROTO:
  365. case -ETIME:
  366. case -EILSEQ:
  367. dev->stats.rx_errors++;
  368. if (!timer_pending (&dev->delay)) {
  369. mod_timer (&dev->delay, jiffies + THROTTLE_JIFFIES);
  370. if (netif_msg_link (dev))
  371. devdbg (dev, "rx throttle %d", urb_status);
  372. }
  373. block:
  374. entry->state = rx_cleanup;
  375. entry->urb = urb;
  376. urb = NULL;
  377. break;
  378. /* data overrun ... flush fifo? */
  379. case -EOVERFLOW:
  380. dev->stats.rx_over_errors++;
  381. // FALLTHROUGH
  382. default:
  383. entry->state = rx_cleanup;
  384. dev->stats.rx_errors++;
  385. if (netif_msg_rx_err (dev))
  386. devdbg (dev, "rx status %d", urb_status);
  387. break;
  388. }
  389. defer_bh(dev, skb, &dev->rxq);
  390. if (urb) {
  391. if (netif_running (dev->net)
  392. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  393. rx_submit (dev, urb, GFP_ATOMIC);
  394. return;
  395. }
  396. usb_free_urb (urb);
  397. }
  398. if (netif_msg_rx_err (dev))
  399. devdbg (dev, "no read resubmitted");
  400. }
  401. static void intr_complete (struct urb *urb)
  402. {
  403. struct usbnet *dev = urb->context;
  404. int status = urb->status;
  405. switch (status) {
  406. /* success */
  407. case 0:
  408. dev->driver_info->status(dev, urb);
  409. break;
  410. /* software-driven interface shutdown */
  411. case -ENOENT: /* urb killed */
  412. case -ESHUTDOWN: /* hardware gone */
  413. if (netif_msg_ifdown (dev))
  414. devdbg (dev, "intr shutdown, code %d", status);
  415. return;
  416. /* NOTE: not throttling like RX/TX, since this endpoint
  417. * already polls infrequently
  418. */
  419. default:
  420. devdbg (dev, "intr status %d", status);
  421. break;
  422. }
  423. if (!netif_running (dev->net))
  424. return;
  425. memset(urb->transfer_buffer, 0, urb->transfer_buffer_length);
  426. status = usb_submit_urb (urb, GFP_ATOMIC);
  427. if (status != 0 && netif_msg_timer (dev))
  428. deverr(dev, "intr resubmit --> %d", status);
  429. }
  430. /*-------------------------------------------------------------------------*/
  431. // unlink pending rx/tx; completion handlers do all other cleanup
  432. static int unlink_urbs (struct usbnet *dev, struct sk_buff_head *q)
  433. {
  434. unsigned long flags;
  435. struct sk_buff *skb, *skbnext;
  436. int count = 0;
  437. spin_lock_irqsave (&q->lock, flags);
  438. for (skb = q->next; skb != (struct sk_buff *) q; skb = skbnext) {
  439. struct skb_data *entry;
  440. struct urb *urb;
  441. int retval;
  442. entry = (struct skb_data *) skb->cb;
  443. urb = entry->urb;
  444. skbnext = skb->next;
  445. // during some PM-driven resume scenarios,
  446. // these (async) unlinks complete immediately
  447. retval = usb_unlink_urb (urb);
  448. if (retval != -EINPROGRESS && retval != 0)
  449. devdbg (dev, "unlink urb err, %d", retval);
  450. else
  451. count++;
  452. }
  453. spin_unlock_irqrestore (&q->lock, flags);
  454. return count;
  455. }
  456. // Flush all pending rx urbs
  457. // minidrivers may need to do this when the MTU changes
  458. void usbnet_unlink_rx_urbs(struct usbnet *dev)
  459. {
  460. if (netif_running(dev->net)) {
  461. (void) unlink_urbs (dev, &dev->rxq);
  462. tasklet_schedule(&dev->bh);
  463. }
  464. }
  465. EXPORT_SYMBOL_GPL(usbnet_unlink_rx_urbs);
  466. /*-------------------------------------------------------------------------*/
  467. // precondition: never called in_interrupt
  468. static int usbnet_stop (struct net_device *net)
  469. {
  470. struct usbnet *dev = netdev_priv(net);
  471. int temp;
  472. DECLARE_WAIT_QUEUE_HEAD_ONSTACK (unlink_wakeup);
  473. DECLARE_WAITQUEUE (wait, current);
  474. netif_stop_queue (net);
  475. if (netif_msg_ifdown (dev))
  476. devinfo (dev, "stop stats: rx/tx %ld/%ld, errs %ld/%ld",
  477. dev->stats.rx_packets, dev->stats.tx_packets,
  478. dev->stats.rx_errors, dev->stats.tx_errors
  479. );
  480. // ensure there are no more active urbs
  481. add_wait_queue (&unlink_wakeup, &wait);
  482. dev->wait = &unlink_wakeup;
  483. temp = unlink_urbs (dev, &dev->txq) + unlink_urbs (dev, &dev->rxq);
  484. // maybe wait for deletions to finish.
  485. while (!skb_queue_empty(&dev->rxq)
  486. && !skb_queue_empty(&dev->txq)
  487. && !skb_queue_empty(&dev->done)) {
  488. msleep(UNLINK_TIMEOUT_MS);
  489. if (netif_msg_ifdown (dev))
  490. devdbg (dev, "waited for %d urb completions", temp);
  491. }
  492. dev->wait = NULL;
  493. remove_wait_queue (&unlink_wakeup, &wait);
  494. usb_kill_urb(dev->interrupt);
  495. /* deferred work (task, timer, softirq) must also stop.
  496. * can't flush_scheduled_work() until we drop rtnl (later),
  497. * else workers could deadlock; so make workers a NOP.
  498. */
  499. dev->flags = 0;
  500. del_timer_sync (&dev->delay);
  501. tasklet_kill (&dev->bh);
  502. usb_autopm_put_interface(dev->intf);
  503. return 0;
  504. }
  505. /*-------------------------------------------------------------------------*/
  506. // posts reads, and enables write queuing
  507. // precondition: never called in_interrupt
  508. static int usbnet_open (struct net_device *net)
  509. {
  510. struct usbnet *dev = netdev_priv(net);
  511. int retval;
  512. struct driver_info *info = dev->driver_info;
  513. if ((retval = usb_autopm_get_interface(dev->intf)) < 0) {
  514. if (netif_msg_ifup (dev))
  515. devinfo (dev,
  516. "resumption fail (%d) usbnet usb-%s-%s, %s",
  517. retval,
  518. dev->udev->bus->bus_name, dev->udev->devpath,
  519. info->description);
  520. goto done_nopm;
  521. }
  522. // put into "known safe" state
  523. if (info->reset && (retval = info->reset (dev)) < 0) {
  524. if (netif_msg_ifup (dev))
  525. devinfo (dev,
  526. "open reset fail (%d) usbnet usb-%s-%s, %s",
  527. retval,
  528. dev->udev->bus->bus_name, dev->udev->devpath,
  529. info->description);
  530. goto done;
  531. }
  532. // insist peer be connected
  533. if (info->check_connect && (retval = info->check_connect (dev)) < 0) {
  534. if (netif_msg_ifup (dev))
  535. devdbg (dev, "can't open; %d", retval);
  536. goto done;
  537. }
  538. /* start any status interrupt transfer */
  539. if (dev->interrupt) {
  540. retval = usb_submit_urb (dev->interrupt, GFP_KERNEL);
  541. if (retval < 0) {
  542. if (netif_msg_ifup (dev))
  543. deverr (dev, "intr submit %d", retval);
  544. goto done;
  545. }
  546. }
  547. netif_start_queue (net);
  548. if (netif_msg_ifup (dev)) {
  549. char *framing;
  550. if (dev->driver_info->flags & FLAG_FRAMING_NC)
  551. framing = "NetChip";
  552. else if (dev->driver_info->flags & FLAG_FRAMING_GL)
  553. framing = "GeneSys";
  554. else if (dev->driver_info->flags & FLAG_FRAMING_Z)
  555. framing = "Zaurus";
  556. else if (dev->driver_info->flags & FLAG_FRAMING_RN)
  557. framing = "RNDIS";
  558. else if (dev->driver_info->flags & FLAG_FRAMING_AX)
  559. framing = "ASIX";
  560. else
  561. framing = "simple";
  562. devinfo (dev, "open: enable queueing "
  563. "(rx %d, tx %d) mtu %d %s framing",
  564. (int)RX_QLEN (dev), (int)TX_QLEN (dev), dev->net->mtu,
  565. framing);
  566. }
  567. // delay posting reads until we're fully open
  568. tasklet_schedule (&dev->bh);
  569. return retval;
  570. done:
  571. usb_autopm_put_interface(dev->intf);
  572. done_nopm:
  573. return retval;
  574. }
  575. /*-------------------------------------------------------------------------*/
  576. /* ethtool methods; minidrivers may need to add some more, but
  577. * they'll probably want to use this base set.
  578. */
  579. int usbnet_get_settings (struct net_device *net, struct ethtool_cmd *cmd)
  580. {
  581. struct usbnet *dev = netdev_priv(net);
  582. if (!dev->mii.mdio_read)
  583. return -EOPNOTSUPP;
  584. return mii_ethtool_gset(&dev->mii, cmd);
  585. }
  586. EXPORT_SYMBOL_GPL(usbnet_get_settings);
  587. int usbnet_set_settings (struct net_device *net, struct ethtool_cmd *cmd)
  588. {
  589. struct usbnet *dev = netdev_priv(net);
  590. int retval;
  591. if (!dev->mii.mdio_write)
  592. return -EOPNOTSUPP;
  593. retval = mii_ethtool_sset(&dev->mii, cmd);
  594. /* link speed/duplex might have changed */
  595. if (dev->driver_info->link_reset)
  596. dev->driver_info->link_reset(dev);
  597. return retval;
  598. }
  599. EXPORT_SYMBOL_GPL(usbnet_set_settings);
  600. u32 usbnet_get_link (struct net_device *net)
  601. {
  602. struct usbnet *dev = netdev_priv(net);
  603. /* If a check_connect is defined, return its result */
  604. if (dev->driver_info->check_connect)
  605. return dev->driver_info->check_connect (dev) == 0;
  606. /* if the device has mii operations, use those */
  607. if (dev->mii.mdio_read)
  608. return mii_link_ok(&dev->mii);
  609. /* Otherwise, say we're up (to avoid breaking scripts) */
  610. return 1;
  611. }
  612. EXPORT_SYMBOL_GPL(usbnet_get_link);
  613. int usbnet_nway_reset(struct net_device *net)
  614. {
  615. struct usbnet *dev = netdev_priv(net);
  616. if (!dev->mii.mdio_write)
  617. return -EOPNOTSUPP;
  618. return mii_nway_restart(&dev->mii);
  619. }
  620. EXPORT_SYMBOL_GPL(usbnet_nway_reset);
  621. void usbnet_get_drvinfo (struct net_device *net, struct ethtool_drvinfo *info)
  622. {
  623. struct usbnet *dev = netdev_priv(net);
  624. strncpy (info->driver, dev->driver_name, sizeof info->driver);
  625. strncpy (info->version, DRIVER_VERSION, sizeof info->version);
  626. strncpy (info->fw_version, dev->driver_info->description,
  627. sizeof info->fw_version);
  628. usb_make_path (dev->udev, info->bus_info, sizeof info->bus_info);
  629. }
  630. EXPORT_SYMBOL_GPL(usbnet_get_drvinfo);
  631. u32 usbnet_get_msglevel (struct net_device *net)
  632. {
  633. struct usbnet *dev = netdev_priv(net);
  634. return dev->msg_enable;
  635. }
  636. EXPORT_SYMBOL_GPL(usbnet_get_msglevel);
  637. void usbnet_set_msglevel (struct net_device *net, u32 level)
  638. {
  639. struct usbnet *dev = netdev_priv(net);
  640. dev->msg_enable = level;
  641. }
  642. EXPORT_SYMBOL_GPL(usbnet_set_msglevel);
  643. /* drivers may override default ethtool_ops in their bind() routine */
  644. static struct ethtool_ops usbnet_ethtool_ops = {
  645. .get_settings = usbnet_get_settings,
  646. .set_settings = usbnet_set_settings,
  647. .get_link = usbnet_get_link,
  648. .nway_reset = usbnet_nway_reset,
  649. .get_drvinfo = usbnet_get_drvinfo,
  650. .get_msglevel = usbnet_get_msglevel,
  651. .set_msglevel = usbnet_set_msglevel,
  652. };
  653. /*-------------------------------------------------------------------------*/
  654. /* work that cannot be done in interrupt context uses keventd.
  655. *
  656. * NOTE: with 2.5 we could do more of this using completion callbacks,
  657. * especially now that control transfers can be queued.
  658. */
  659. static void
  660. kevent (struct work_struct *work)
  661. {
  662. struct usbnet *dev =
  663. container_of(work, struct usbnet, kevent);
  664. int status;
  665. /* usb_clear_halt() needs a thread context */
  666. if (test_bit (EVENT_TX_HALT, &dev->flags)) {
  667. unlink_urbs (dev, &dev->txq);
  668. status = usb_clear_halt (dev->udev, dev->out);
  669. if (status < 0
  670. && status != -EPIPE
  671. && status != -ESHUTDOWN) {
  672. if (netif_msg_tx_err (dev))
  673. deverr (dev, "can't clear tx halt, status %d",
  674. status);
  675. } else {
  676. clear_bit (EVENT_TX_HALT, &dev->flags);
  677. if (status != -ESHUTDOWN)
  678. netif_wake_queue (dev->net);
  679. }
  680. }
  681. if (test_bit (EVENT_RX_HALT, &dev->flags)) {
  682. unlink_urbs (dev, &dev->rxq);
  683. status = usb_clear_halt (dev->udev, dev->in);
  684. if (status < 0
  685. && status != -EPIPE
  686. && status != -ESHUTDOWN) {
  687. if (netif_msg_rx_err (dev))
  688. deverr (dev, "can't clear rx halt, status %d",
  689. status);
  690. } else {
  691. clear_bit (EVENT_RX_HALT, &dev->flags);
  692. tasklet_schedule (&dev->bh);
  693. }
  694. }
  695. /* tasklet could resubmit itself forever if memory is tight */
  696. if (test_bit (EVENT_RX_MEMORY, &dev->flags)) {
  697. struct urb *urb = NULL;
  698. if (netif_running (dev->net))
  699. urb = usb_alloc_urb (0, GFP_KERNEL);
  700. else
  701. clear_bit (EVENT_RX_MEMORY, &dev->flags);
  702. if (urb != NULL) {
  703. clear_bit (EVENT_RX_MEMORY, &dev->flags);
  704. rx_submit (dev, urb, GFP_KERNEL);
  705. tasklet_schedule (&dev->bh);
  706. }
  707. }
  708. if (test_bit (EVENT_LINK_RESET, &dev->flags)) {
  709. struct driver_info *info = dev->driver_info;
  710. int retval = 0;
  711. clear_bit (EVENT_LINK_RESET, &dev->flags);
  712. if(info->link_reset && (retval = info->link_reset(dev)) < 0) {
  713. devinfo(dev, "link reset failed (%d) usbnet usb-%s-%s, %s",
  714. retval,
  715. dev->udev->bus->bus_name, dev->udev->devpath,
  716. info->description);
  717. }
  718. }
  719. if (dev->flags)
  720. devdbg (dev, "kevent done, flags = 0x%lx",
  721. dev->flags);
  722. }
  723. /*-------------------------------------------------------------------------*/
  724. static void tx_complete (struct urb *urb)
  725. {
  726. struct sk_buff *skb = (struct sk_buff *) urb->context;
  727. struct skb_data *entry = (struct skb_data *) skb->cb;
  728. struct usbnet *dev = entry->dev;
  729. if (urb->status == 0) {
  730. dev->stats.tx_packets++;
  731. dev->stats.tx_bytes += entry->length;
  732. } else {
  733. dev->stats.tx_errors++;
  734. switch (urb->status) {
  735. case -EPIPE:
  736. usbnet_defer_kevent (dev, EVENT_TX_HALT);
  737. break;
  738. /* software-driven interface shutdown */
  739. case -ECONNRESET: // async unlink
  740. case -ESHUTDOWN: // hardware gone
  741. break;
  742. // like rx, tx gets controller i/o faults during khubd delays
  743. // and so it uses the same throttling mechanism.
  744. case -EPROTO:
  745. case -ETIME:
  746. case -EILSEQ:
  747. if (!timer_pending (&dev->delay)) {
  748. mod_timer (&dev->delay,
  749. jiffies + THROTTLE_JIFFIES);
  750. if (netif_msg_link (dev))
  751. devdbg (dev, "tx throttle %d",
  752. urb->status);
  753. }
  754. netif_stop_queue (dev->net);
  755. break;
  756. default:
  757. if (netif_msg_tx_err (dev))
  758. devdbg (dev, "tx err %d", entry->urb->status);
  759. break;
  760. }
  761. }
  762. urb->dev = NULL;
  763. entry->state = tx_done;
  764. defer_bh(dev, skb, &dev->txq);
  765. }
  766. /*-------------------------------------------------------------------------*/
  767. static void usbnet_tx_timeout (struct net_device *net)
  768. {
  769. struct usbnet *dev = netdev_priv(net);
  770. unlink_urbs (dev, &dev->txq);
  771. tasklet_schedule (&dev->bh);
  772. // FIXME: device recovery -- reset?
  773. }
  774. /*-------------------------------------------------------------------------*/
  775. static int usbnet_start_xmit (struct sk_buff *skb, struct net_device *net)
  776. {
  777. struct usbnet *dev = netdev_priv(net);
  778. int length;
  779. int retval = NET_XMIT_SUCCESS;
  780. struct urb *urb = NULL;
  781. struct skb_data *entry;
  782. struct driver_info *info = dev->driver_info;
  783. unsigned long flags;
  784. // some devices want funky USB-level framing, for
  785. // win32 driver (usually) and/or hardware quirks
  786. if (info->tx_fixup) {
  787. skb = info->tx_fixup (dev, skb, GFP_ATOMIC);
  788. if (!skb) {
  789. if (netif_msg_tx_err (dev))
  790. devdbg (dev, "can't tx_fixup skb");
  791. goto drop;
  792. }
  793. }
  794. length = skb->len;
  795. if (!(urb = usb_alloc_urb (0, GFP_ATOMIC))) {
  796. if (netif_msg_tx_err (dev))
  797. devdbg (dev, "no urb");
  798. goto drop;
  799. }
  800. entry = (struct skb_data *) skb->cb;
  801. entry->urb = urb;
  802. entry->dev = dev;
  803. entry->state = tx_start;
  804. entry->length = length;
  805. usb_fill_bulk_urb (urb, dev->udev, dev->out,
  806. skb->data, skb->len, tx_complete, skb);
  807. /* don't assume the hardware handles USB_ZERO_PACKET
  808. * NOTE: strictly conforming cdc-ether devices should expect
  809. * the ZLP here, but ignore the one-byte packet.
  810. */
  811. if ((length % dev->maxpacket) == 0) {
  812. urb->transfer_buffer_length++;
  813. if (skb_tailroom(skb)) {
  814. skb->data[skb->len] = 0;
  815. __skb_put(skb, 1);
  816. }
  817. }
  818. spin_lock_irqsave (&dev->txq.lock, flags);
  819. switch ((retval = usb_submit_urb (urb, GFP_ATOMIC))) {
  820. case -EPIPE:
  821. netif_stop_queue (net);
  822. usbnet_defer_kevent (dev, EVENT_TX_HALT);
  823. break;
  824. default:
  825. if (netif_msg_tx_err (dev))
  826. devdbg (dev, "tx: submit urb err %d", retval);
  827. break;
  828. case 0:
  829. net->trans_start = jiffies;
  830. __skb_queue_tail (&dev->txq, skb);
  831. if (dev->txq.qlen >= TX_QLEN (dev))
  832. netif_stop_queue (net);
  833. }
  834. spin_unlock_irqrestore (&dev->txq.lock, flags);
  835. if (retval) {
  836. if (netif_msg_tx_err (dev))
  837. devdbg (dev, "drop, code %d", retval);
  838. drop:
  839. retval = NET_XMIT_SUCCESS;
  840. dev->stats.tx_dropped++;
  841. if (skb)
  842. dev_kfree_skb_any (skb);
  843. usb_free_urb (urb);
  844. } else if (netif_msg_tx_queued (dev)) {
  845. devdbg (dev, "> tx, len %d, type 0x%x",
  846. length, skb->protocol);
  847. }
  848. return retval;
  849. }
  850. /*-------------------------------------------------------------------------*/
  851. // tasklet (work deferred from completions, in_irq) or timer
  852. static void usbnet_bh (unsigned long param)
  853. {
  854. struct usbnet *dev = (struct usbnet *) param;
  855. struct sk_buff *skb;
  856. struct skb_data *entry;
  857. while ((skb = skb_dequeue (&dev->done))) {
  858. entry = (struct skb_data *) skb->cb;
  859. switch (entry->state) {
  860. case rx_done:
  861. entry->state = rx_cleanup;
  862. rx_process (dev, skb);
  863. continue;
  864. case tx_done:
  865. case rx_cleanup:
  866. usb_free_urb (entry->urb);
  867. dev_kfree_skb (skb);
  868. continue;
  869. default:
  870. devdbg (dev, "bogus skb state %d", entry->state);
  871. }
  872. }
  873. // waiting for all pending urbs to complete?
  874. if (dev->wait) {
  875. if ((dev->txq.qlen + dev->rxq.qlen + dev->done.qlen) == 0) {
  876. wake_up (dev->wait);
  877. }
  878. // or are we maybe short a few urbs?
  879. } else if (netif_running (dev->net)
  880. && netif_device_present (dev->net)
  881. && !timer_pending (&dev->delay)
  882. && !test_bit (EVENT_RX_HALT, &dev->flags)) {
  883. int temp = dev->rxq.qlen;
  884. int qlen = RX_QLEN (dev);
  885. if (temp < qlen) {
  886. struct urb *urb;
  887. int i;
  888. // don't refill the queue all at once
  889. for (i = 0; i < 10 && dev->rxq.qlen < qlen; i++) {
  890. urb = usb_alloc_urb (0, GFP_ATOMIC);
  891. if (urb != NULL)
  892. rx_submit (dev, urb, GFP_ATOMIC);
  893. }
  894. if (temp != dev->rxq.qlen && netif_msg_link (dev))
  895. devdbg (dev, "rxqlen %d --> %d",
  896. temp, dev->rxq.qlen);
  897. if (dev->rxq.qlen < qlen)
  898. tasklet_schedule (&dev->bh);
  899. }
  900. if (dev->txq.qlen < TX_QLEN (dev))
  901. netif_wake_queue (dev->net);
  902. }
  903. }
  904. /*-------------------------------------------------------------------------
  905. *
  906. * USB Device Driver support
  907. *
  908. *-------------------------------------------------------------------------*/
  909. // precondition: never called in_interrupt
  910. void usbnet_disconnect (struct usb_interface *intf)
  911. {
  912. struct usbnet *dev;
  913. struct usb_device *xdev;
  914. struct net_device *net;
  915. dev = usb_get_intfdata(intf);
  916. usb_set_intfdata(intf, NULL);
  917. if (!dev)
  918. return;
  919. xdev = interface_to_usbdev (intf);
  920. if (netif_msg_probe (dev))
  921. devinfo (dev, "unregister '%s' usb-%s-%s, %s",
  922. intf->dev.driver->name,
  923. xdev->bus->bus_name, xdev->devpath,
  924. dev->driver_info->description);
  925. net = dev->net;
  926. unregister_netdev (net);
  927. /* we don't hold rtnl here ... */
  928. flush_scheduled_work ();
  929. if (dev->driver_info->unbind)
  930. dev->driver_info->unbind (dev, intf);
  931. free_netdev(net);
  932. usb_put_dev (xdev);
  933. }
  934. EXPORT_SYMBOL_GPL(usbnet_disconnect);
  935. /*-------------------------------------------------------------------------*/
  936. // precondition: never called in_interrupt
  937. int
  938. usbnet_probe (struct usb_interface *udev, const struct usb_device_id *prod)
  939. {
  940. struct usbnet *dev;
  941. struct net_device *net;
  942. struct usb_host_interface *interface;
  943. struct driver_info *info;
  944. struct usb_device *xdev;
  945. int status;
  946. const char *name;
  947. DECLARE_MAC_BUF(mac);
  948. name = udev->dev.driver->name;
  949. info = (struct driver_info *) prod->driver_info;
  950. if (!info) {
  951. dev_dbg (&udev->dev, "blacklisted by %s\n", name);
  952. return -ENODEV;
  953. }
  954. xdev = interface_to_usbdev (udev);
  955. interface = udev->cur_altsetting;
  956. usb_get_dev (xdev);
  957. status = -ENOMEM;
  958. // set up our own records
  959. net = alloc_etherdev(sizeof(*dev));
  960. if (!net) {
  961. dbg ("can't kmalloc dev");
  962. goto out;
  963. }
  964. dev = netdev_priv(net);
  965. dev->udev = xdev;
  966. dev->intf = udev;
  967. dev->driver_info = info;
  968. dev->driver_name = name;
  969. dev->msg_enable = netif_msg_init (msg_level, NETIF_MSG_DRV
  970. | NETIF_MSG_PROBE | NETIF_MSG_LINK);
  971. skb_queue_head_init (&dev->rxq);
  972. skb_queue_head_init (&dev->txq);
  973. skb_queue_head_init (&dev->done);
  974. dev->bh.func = usbnet_bh;
  975. dev->bh.data = (unsigned long) dev;
  976. INIT_WORK (&dev->kevent, kevent);
  977. dev->delay.function = usbnet_bh;
  978. dev->delay.data = (unsigned long) dev;
  979. init_timer (&dev->delay);
  980. mutex_init (&dev->phy_mutex);
  981. dev->net = net;
  982. strcpy (net->name, "usb%d");
  983. memcpy (net->dev_addr, node_id, sizeof node_id);
  984. /* rx and tx sides can use different message sizes;
  985. * bind() should set rx_urb_size in that case.
  986. */
  987. dev->hard_mtu = net->mtu + net->hard_header_len;
  988. #if 0
  989. // dma_supported() is deeply broken on almost all architectures
  990. // possible with some EHCI controllers
  991. if (dma_supported (&udev->dev, DMA_64BIT_MASK))
  992. net->features |= NETIF_F_HIGHDMA;
  993. #endif
  994. net->change_mtu = usbnet_change_mtu;
  995. net->get_stats = usbnet_get_stats;
  996. net->hard_start_xmit = usbnet_start_xmit;
  997. net->open = usbnet_open;
  998. net->stop = usbnet_stop;
  999. net->watchdog_timeo = TX_TIMEOUT_JIFFIES;
  1000. net->tx_timeout = usbnet_tx_timeout;
  1001. net->ethtool_ops = &usbnet_ethtool_ops;
  1002. // allow device-specific bind/init procedures
  1003. // NOTE net->name still not usable ...
  1004. if (info->bind) {
  1005. status = info->bind (dev, udev);
  1006. if (status < 0)
  1007. goto out1;
  1008. // heuristic: "usb%d" for links we know are two-host,
  1009. // else "eth%d" when there's reasonable doubt. userspace
  1010. // can rename the link if it knows better.
  1011. if ((dev->driver_info->flags & FLAG_ETHER) != 0
  1012. && (net->dev_addr [0] & 0x02) == 0)
  1013. strcpy (net->name, "eth%d");
  1014. /* WLAN devices should always be named "wlan%d" */
  1015. if ((dev->driver_info->flags & FLAG_WLAN) != 0)
  1016. strcpy(net->name, "wlan%d");
  1017. /* maybe the remote can't receive an Ethernet MTU */
  1018. if (net->mtu > (dev->hard_mtu - net->hard_header_len))
  1019. net->mtu = dev->hard_mtu - net->hard_header_len;
  1020. } else if (!info->in || !info->out)
  1021. status = usbnet_get_endpoints (dev, udev);
  1022. else {
  1023. dev->in = usb_rcvbulkpipe (xdev, info->in);
  1024. dev->out = usb_sndbulkpipe (xdev, info->out);
  1025. if (!(info->flags & FLAG_NO_SETINT))
  1026. status = usb_set_interface (xdev,
  1027. interface->desc.bInterfaceNumber,
  1028. interface->desc.bAlternateSetting);
  1029. else
  1030. status = 0;
  1031. }
  1032. if (status >= 0 && dev->status)
  1033. status = init_status (dev, udev);
  1034. if (status < 0)
  1035. goto out3;
  1036. if (!dev->rx_urb_size)
  1037. dev->rx_urb_size = dev->hard_mtu;
  1038. dev->maxpacket = usb_maxpacket (dev->udev, dev->out, 1);
  1039. SET_NETDEV_DEV(net, &udev->dev);
  1040. status = register_netdev (net);
  1041. if (status)
  1042. goto out3;
  1043. if (netif_msg_probe (dev))
  1044. devinfo (dev, "register '%s' at usb-%s-%s, %s, %s",
  1045. udev->dev.driver->name,
  1046. xdev->bus->bus_name, xdev->devpath,
  1047. dev->driver_info->description,
  1048. print_mac(mac, net->dev_addr));
  1049. // ok, it's ready to go.
  1050. usb_set_intfdata (udev, dev);
  1051. // start as if the link is up
  1052. netif_device_attach (net);
  1053. return 0;
  1054. out3:
  1055. if (info->unbind)
  1056. info->unbind (dev, udev);
  1057. out1:
  1058. free_netdev(net);
  1059. out:
  1060. usb_put_dev(xdev);
  1061. return status;
  1062. }
  1063. EXPORT_SYMBOL_GPL(usbnet_probe);
  1064. /*-------------------------------------------------------------------------*/
  1065. /*
  1066. * suspend the whole driver as soon as the first interface is suspended
  1067. * resume only when the last interface is resumed
  1068. */
  1069. int usbnet_suspend (struct usb_interface *intf, pm_message_t message)
  1070. {
  1071. struct usbnet *dev = usb_get_intfdata(intf);
  1072. if (!dev->suspend_count++) {
  1073. /*
  1074. * accelerate emptying of the rx and queues, to avoid
  1075. * having everything error out.
  1076. */
  1077. netif_device_detach (dev->net);
  1078. (void) unlink_urbs (dev, &dev->rxq);
  1079. (void) unlink_urbs (dev, &dev->txq);
  1080. /*
  1081. * reattach so runtime management can use and
  1082. * wake the device
  1083. */
  1084. netif_device_attach (dev->net);
  1085. }
  1086. return 0;
  1087. }
  1088. EXPORT_SYMBOL_GPL(usbnet_suspend);
  1089. int usbnet_resume (struct usb_interface *intf)
  1090. {
  1091. struct usbnet *dev = usb_get_intfdata(intf);
  1092. if (!--dev->suspend_count)
  1093. tasklet_schedule (&dev->bh);
  1094. return 0;
  1095. }
  1096. EXPORT_SYMBOL_GPL(usbnet_resume);
  1097. /*-------------------------------------------------------------------------*/
  1098. static int __init usbnet_init(void)
  1099. {
  1100. /* compiler should optimize this out */
  1101. BUILD_BUG_ON (sizeof (((struct sk_buff *)0)->cb)
  1102. < sizeof (struct skb_data));
  1103. random_ether_addr(node_id);
  1104. return 0;
  1105. }
  1106. module_init(usbnet_init);
  1107. static void __exit usbnet_exit(void)
  1108. {
  1109. }
  1110. module_exit(usbnet_exit);
  1111. MODULE_AUTHOR("David Brownell");
  1112. MODULE_DESCRIPTION("USB network driver framework");
  1113. MODULE_LICENSE("GPL");