Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
kaweth.c
Go to the documentation of this file.
1 /****************************************************************
2  *
3  * kaweth.c - driver for KL5KUSB101 based USB->Ethernet
4  *
5  * (c) 2000 Interlan Communications
6  * (c) 2000 Stephane Alnet
7  * (C) 2001 Brad Hards
8  * (C) 2002 Oliver Neukum
9  *
10  * Original author: The Zapman <[email protected]>
11  * Inspired by, and much credit goes to Michael Rothwell
12  * <[email protected]> for the test equipment, help, and patience
13  * Based off of (and with thanks to) Petko Manolov's pegaus.c driver.
14  * Also many thanks to Joel Silverman and Ed Surprenant at Kawasaki
15  * for providing the firmware and driver resources.
16  *
17  * This program is free software; you can redistribute it and/or
18  * modify it under the terms of the GNU General Public License as
19  * published by the Free Software Foundation; either version 2, or
20  * (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License
28  * along with this program; if not, write to the Free Software Foundation,
29  * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
30  *
31  ****************************************************************/
32 
33 /* TODO:
34  * Develop test procedures for USB net interfaces
35  * Run test procedures
36  * Fix bugs from previous two steps
37  * Snoop other OSs for any tricks we're not doing
38  * Reduce arbitrary timeouts
39  * Smart multicast support
40  * Temporary MAC change support
41  * Tunable SOFs parameter - ioctl()?
42  * Ethernet stats collection
43  * Code formatting improvements
44  */
45 
46 #include <linux/module.h>
47 #include <linux/slab.h>
48 #include <linux/string.h>
49 #include <linux/init.h>
50 #include <linux/delay.h>
51 #include <linux/netdevice.h>
52 #include <linux/etherdevice.h>
53 #include <linux/usb.h>
54 #include <linux/types.h>
55 #include <linux/ethtool.h>
56 #include <linux/dma-mapping.h>
57 #include <linux/wait.h>
58 #include <linux/firmware.h>
59 #include <asm/uaccess.h>
60 #include <asm/byteorder.h>
61 
62 #undef DEBUG
63 
64 #define KAWETH_MTU 1514
65 #define KAWETH_BUF_SIZE 1664
66 #define KAWETH_TX_TIMEOUT (5 * HZ)
67 #define KAWETH_SCRATCH_SIZE 32
68 #define KAWETH_FIRMWARE_BUF_SIZE 4096
69 #define KAWETH_CONTROL_TIMEOUT (30000)
70 
71 #define KAWETH_STATUS_BROKEN 0x0000001
72 #define KAWETH_STATUS_CLOSING 0x0000002
73 #define KAWETH_STATUS_SUSPENDING 0x0000004
74 
75 #define KAWETH_STATUS_BLOCKED (KAWETH_STATUS_CLOSING | KAWETH_STATUS_SUSPENDING)
76 
77 #define KAWETH_PACKET_FILTER_PROMISCUOUS 0x01
78 #define KAWETH_PACKET_FILTER_ALL_MULTICAST 0x02
79 #define KAWETH_PACKET_FILTER_DIRECTED 0x04
80 #define KAWETH_PACKET_FILTER_BROADCAST 0x08
81 #define KAWETH_PACKET_FILTER_MULTICAST 0x10
82 
83 /* Table 7 */
84 #define KAWETH_COMMAND_GET_ETHERNET_DESC 0x00
85 #define KAWETH_COMMAND_MULTICAST_FILTERS 0x01
86 #define KAWETH_COMMAND_SET_PACKET_FILTER 0x02
87 #define KAWETH_COMMAND_STATISTICS 0x03
88 #define KAWETH_COMMAND_SET_TEMP_MAC 0x06
89 #define KAWETH_COMMAND_GET_TEMP_MAC 0x07
90 #define KAWETH_COMMAND_SET_URB_SIZE 0x08
91 #define KAWETH_COMMAND_SET_SOFS_WAIT 0x09
92 #define KAWETH_COMMAND_SCAN 0xFF
93 
94 #define KAWETH_SOFS_TO_WAIT 0x05
95 
96 #define INTBUFFERSIZE 4
97 
98 #define STATE_OFFSET 0
99 #define STATE_MASK 0x40
100 #define STATE_SHIFT 5
101 
102 #define IS_BLOCKED(s) (s & KAWETH_STATUS_BLOCKED)
103 
104 
105 MODULE_AUTHOR("Michael Zappe <[email protected]>, Stephane Alnet <[email protected]>, Brad Hards <[email protected]> and Oliver Neukum <[email protected]>");
106 MODULE_DESCRIPTION("KL5USB101 USB Ethernet driver");
107 MODULE_LICENSE("GPL");
108 MODULE_FIRMWARE("kaweth/new_code.bin");
109 MODULE_FIRMWARE("kaweth/new_code_fix.bin");
110 MODULE_FIRMWARE("kaweth/trigger_code.bin");
111 MODULE_FIRMWARE("kaweth/trigger_code_fix.bin");
112 
113 static const char driver_name[] = "kaweth";
114 
115 static int kaweth_probe(
116  struct usb_interface *intf,
117  const struct usb_device_id *id /* from id_table */
118  );
119 static void kaweth_disconnect(struct usb_interface *intf);
120 static int kaweth_internal_control_msg(struct usb_device *usb_dev,
121  unsigned int pipe,
122  struct usb_ctrlrequest *cmd, void *data,
123  int len, int timeout);
124 static int kaweth_suspend(struct usb_interface *intf, pm_message_t message);
125 static int kaweth_resume(struct usb_interface *intf);
126 
127 /****************************************************************
128  * usb_device_id
129  ****************************************************************/
130 static struct usb_device_id usb_klsi_table[] = {
131  { USB_DEVICE(0x03e8, 0x0008) }, /* AOX Endpoints USB Ethernet */
132  { USB_DEVICE(0x04bb, 0x0901) }, /* I-O DATA USB-ET/T */
133  { USB_DEVICE(0x0506, 0x03e8) }, /* 3Com 3C19250 */
134  { USB_DEVICE(0x0506, 0x11f8) }, /* 3Com 3C460 */
135  { USB_DEVICE(0x0557, 0x2002) }, /* ATEN USB Ethernet */
136  { USB_DEVICE(0x0557, 0x4000) }, /* D-Link DSB-650C */
137  { USB_DEVICE(0x0565, 0x0002) }, /* Peracom Enet */
138  { USB_DEVICE(0x0565, 0x0003) }, /* Optus@Home UEP1045A */
139  { USB_DEVICE(0x0565, 0x0005) }, /* Peracom Enet2 */
140  { USB_DEVICE(0x05e9, 0x0008) }, /* KLSI KL5KUSB101B */
141  { USB_DEVICE(0x05e9, 0x0009) }, /* KLSI KL5KUSB101B (Board change) */
142  { USB_DEVICE(0x066b, 0x2202) }, /* Linksys USB10T */
143  { USB_DEVICE(0x06e1, 0x0008) }, /* ADS USB-10BT */
144  { USB_DEVICE(0x06e1, 0x0009) }, /* ADS USB-10BT */
145  { USB_DEVICE(0x0707, 0x0100) }, /* SMC 2202USB */
146  { USB_DEVICE(0x07aa, 0x0001) }, /* Correga K.K. */
147  { USB_DEVICE(0x07b8, 0x4000) }, /* D-Link DU-E10 */
148  { USB_DEVICE(0x07c9, 0xb010) }, /* Allied Telesyn AT-USB10 USB Ethernet Adapter */
149  { USB_DEVICE(0x0846, 0x1001) }, /* NetGear EA-101 */
150  { USB_DEVICE(0x0846, 0x1002) }, /* NetGear EA-101 */
151  { USB_DEVICE(0x085a, 0x0008) }, /* PortGear Ethernet Adapter */
152  { USB_DEVICE(0x085a, 0x0009) }, /* PortGear Ethernet Adapter */
153  { USB_DEVICE(0x087d, 0x5704) }, /* Jaton USB Ethernet Device Adapter */
154  { USB_DEVICE(0x0951, 0x0008) }, /* Kingston Technology USB Ethernet Adapter */
155  { USB_DEVICE(0x095a, 0x3003) }, /* Portsmith Express Ethernet Adapter */
156  { USB_DEVICE(0x10bd, 0x1427) }, /* ASANTE USB To Ethernet Adapter */
157  { USB_DEVICE(0x1342, 0x0204) }, /* Mobility USB-Ethernet Adapter */
158  { USB_DEVICE(0x13d2, 0x0400) }, /* Shark Pocket Adapter */
159  { USB_DEVICE(0x1485, 0x0001) }, /* Silicom U2E */
160  { USB_DEVICE(0x1485, 0x0002) }, /* Psion Dacom Gold Port Ethernet */
161  { USB_DEVICE(0x1645, 0x0005) }, /* Entrega E45 */
162  { USB_DEVICE(0x1645, 0x0008) }, /* Entrega USB Ethernet Adapter */
163  { USB_DEVICE(0x1645, 0x8005) }, /* PortGear Ethernet Adapter */
164  { USB_DEVICE(0x1668, 0x0323) }, /* Actiontec USB Ethernet */
165  { USB_DEVICE(0x2001, 0x4000) }, /* D-link DSB-650C */
166  {} /* Null terminator */
167 };
168 
169 MODULE_DEVICE_TABLE (usb, usb_klsi_table);
170 
171 /****************************************************************
172  * kaweth_driver
173  ****************************************************************/
174 static struct usb_driver kaweth_driver = {
175  .name = driver_name,
176  .probe = kaweth_probe,
177  .disconnect = kaweth_disconnect,
178  .suspend = kaweth_suspend,
179  .resume = kaweth_resume,
180  .id_table = usb_klsi_table,
181  .supports_autosuspend = 1,
182  .disable_hub_initiated_lpm = 1,
183 };
184 
185 typedef __u8 eth_addr_t[6];
186 
187 /****************************************************************
188  * usb_eth_dev
189  ****************************************************************/
190 struct usb_eth_dev {
191  char *name;
192  __u16 vendor;
193  __u16 device;
194  void *pdata;
195 };
196 
197 /****************************************************************
198  * kaweth_ethernet_configuration
199  * Refer Table 8
200  ****************************************************************/
201 struct kaweth_ethernet_configuration
202 {
203  __u8 size;
204  __u8 reserved1;
205  __u8 reserved2;
206  eth_addr_t hw_addr;
207  __u32 statistics_mask;
208  __le16 segment_size;
209  __u16 max_multicast_filters;
210  __u8 reserved3;
211 } __packed;
212 
213 /****************************************************************
214  * kaweth_device
215  ****************************************************************/
216 struct kaweth_device
217 {
218  spinlock_t device_lock;
219 
220  __u32 status;
221  int end;
222  int suspend_lowmem_rx;
223  int suspend_lowmem_ctrl;
224  int linkstate;
225  int opened;
226  struct delayed_work lowmem_work;
227 
228  struct usb_device *dev;
229  struct usb_interface *intf;
230  struct net_device *net;
231  wait_queue_head_t term_wait;
232 
233  struct urb *rx_urb;
234  struct urb *tx_urb;
235  struct urb *irq_urb;
236 
237  dma_addr_t intbufferhandle;
238  __u8 *intbuffer;
239  dma_addr_t rxbufferhandle;
240  __u8 *rx_buf;
241 
242 
243  struct sk_buff *tx_skb;
244 
245  __u8 *firmware_buf;
246  __u8 scratch[KAWETH_SCRATCH_SIZE];
247  __u16 packet_filter_bitmap;
248 
249  struct kaweth_ethernet_configuration configuration;
250 
251  struct net_device_stats stats;
252 };
253 
254 /****************************************************************
255  * kaweth_control
256  ****************************************************************/
257 static int kaweth_control(struct kaweth_device *kaweth,
258  unsigned int pipe,
259  __u8 request,
260  __u8 requesttype,
261  __u16 value,
262  __u16 index,
263  void *data,
264  __u16 size,
265  int timeout)
266 {
267  struct usb_ctrlrequest *dr;
268  int retval;
269 
270  netdev_dbg(kaweth->net, "kaweth_control()\n");
271 
272  if(in_interrupt()) {
273  netdev_dbg(kaweth->net, "in_interrupt()\n");
274  return -EBUSY;
275  }
276 
277  dr = kmalloc(sizeof(struct usb_ctrlrequest), GFP_ATOMIC);
278  if (!dr)
279  return -ENOMEM;
280 
281  dr->bRequestType = requesttype;
282  dr->bRequest = request;
283  dr->wValue = cpu_to_le16(value);
284  dr->wIndex = cpu_to_le16(index);
285  dr->wLength = cpu_to_le16(size);
286 
287  retval = kaweth_internal_control_msg(kaweth->dev,
288  pipe,
289  dr,
290  data,
291  size,
292  timeout);
293 
294  kfree(dr);
295  return retval;
296 }
297 
298 /****************************************************************
299  * kaweth_read_configuration
300  ****************************************************************/
301 static int kaweth_read_configuration(struct kaweth_device *kaweth)
302 {
303  int retval;
304 
305  netdev_dbg(kaweth->net, "Reading kaweth configuration\n");
306 
307  retval = kaweth_control(kaweth,
308  usb_rcvctrlpipe(kaweth->dev, 0),
309  KAWETH_COMMAND_GET_ETHERNET_DESC,
310  USB_TYPE_VENDOR | USB_DIR_IN | USB_RECIP_DEVICE,
311  0,
312  0,
313  (void *)&kaweth->configuration,
314  sizeof(kaweth->configuration),
315  KAWETH_CONTROL_TIMEOUT);
316 
317  return retval;
318 }
319 
320 /****************************************************************
321  * kaweth_set_urb_size
322  ****************************************************************/
323 static int kaweth_set_urb_size(struct kaweth_device *kaweth, __u16 urb_size)
324 {
325  int retval;
326 
327  netdev_dbg(kaweth->net, "Setting URB size to %d\n", (unsigned)urb_size);
328 
329  retval = kaweth_control(kaweth,
330  usb_sndctrlpipe(kaweth->dev, 0),
331  KAWETH_COMMAND_SET_URB_SIZE,
332  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
333  urb_size,
334  0,
335  (void *)&kaweth->scratch,
336  0,
337  KAWETH_CONTROL_TIMEOUT);
338 
339  return retval;
340 }
341 
342 /****************************************************************
343  * kaweth_set_sofs_wait
344  ****************************************************************/
345 static int kaweth_set_sofs_wait(struct kaweth_device *kaweth, __u16 sofs_wait)
346 {
347  int retval;
348 
349  netdev_dbg(kaweth->net, "Set SOFS wait to %d\n", (unsigned)sofs_wait);
350 
351  retval = kaweth_control(kaweth,
352  usb_sndctrlpipe(kaweth->dev, 0),
353  KAWETH_COMMAND_SET_SOFS_WAIT,
354  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
355  sofs_wait,
356  0,
357  (void *)&kaweth->scratch,
358  0,
359  KAWETH_CONTROL_TIMEOUT);
360 
361  return retval;
362 }
363 
364 /****************************************************************
365  * kaweth_set_receive_filter
366  ****************************************************************/
367 static int kaweth_set_receive_filter(struct kaweth_device *kaweth,
368  __u16 receive_filter)
369 {
370  int retval;
371 
372  netdev_dbg(kaweth->net, "Set receive filter to %d\n",
373  (unsigned)receive_filter);
374 
375  retval = kaweth_control(kaweth,
376  usb_sndctrlpipe(kaweth->dev, 0),
377  KAWETH_COMMAND_SET_PACKET_FILTER,
378  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
379  receive_filter,
380  0,
381  (void *)&kaweth->scratch,
382  0,
383  KAWETH_CONTROL_TIMEOUT);
384 
385  return retval;
386 }
387 
388 /****************************************************************
389  * kaweth_download_firmware
390  ****************************************************************/
391 static int kaweth_download_firmware(struct kaweth_device *kaweth,
392  const char *fwname,
393  __u8 interrupt,
394  __u8 type)
395 {
396  const struct firmware *fw;
397  int data_len;
398  int ret;
399 
400  ret = request_firmware(&fw, fwname, &kaweth->dev->dev);
401  if (ret) {
402  dev_err(&kaweth->intf->dev, "Firmware request failed\n");
403  return ret;
404  }
405 
406  if (fw->size > KAWETH_FIRMWARE_BUF_SIZE) {
407  dev_err(&kaweth->intf->dev, "Firmware too big: %zu\n",
408  fw->size);
409  release_firmware(fw);
410  return -ENOSPC;
411  }
412  data_len = fw->size;
413  memcpy(kaweth->firmware_buf, fw->data, fw->size);
414 
415  release_firmware(fw);
416 
417  kaweth->firmware_buf[2] = (data_len & 0xFF) - 7;
418  kaweth->firmware_buf[3] = data_len >> 8;
419  kaweth->firmware_buf[4] = type;
420  kaweth->firmware_buf[5] = interrupt;
421 
422  netdev_dbg(kaweth->net, "High: %i, Low:%i\n", kaweth->firmware_buf[3],
423  kaweth->firmware_buf[2]);
424 
425  netdev_dbg(kaweth->net,
426  "Downloading firmware at %p to kaweth device at %p\n",
427  kaweth->firmware_buf, kaweth);
428  netdev_dbg(kaweth->net, "Firmware length: %d\n", data_len);
429 
430  return kaweth_control(kaweth,
431  usb_sndctrlpipe(kaweth->dev, 0),
432  KAWETH_COMMAND_SCAN,
433  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
434  0,
435  0,
436  (void *)kaweth->firmware_buf,
437  data_len,
438  KAWETH_CONTROL_TIMEOUT);
439 }
440 
441 /****************************************************************
442  * kaweth_trigger_firmware
443  ****************************************************************/
444 static int kaweth_trigger_firmware(struct kaweth_device *kaweth,
445  __u8 interrupt)
446 {
447  kaweth->firmware_buf[0] = 0xB6;
448  kaweth->firmware_buf[1] = 0xC3;
449  kaweth->firmware_buf[2] = 0x01;
450  kaweth->firmware_buf[3] = 0x00;
451  kaweth->firmware_buf[4] = 0x06;
452  kaweth->firmware_buf[5] = interrupt;
453  kaweth->firmware_buf[6] = 0x00;
454  kaweth->firmware_buf[7] = 0x00;
455 
456  netdev_dbg(kaweth->net, "Triggering firmware\n");
457 
458  return kaweth_control(kaweth,
459  usb_sndctrlpipe(kaweth->dev, 0),
460  KAWETH_COMMAND_SCAN,
461  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
462  0,
463  0,
464  (void *)kaweth->firmware_buf,
465  8,
466  KAWETH_CONTROL_TIMEOUT);
467 }
468 
469 /****************************************************************
470  * kaweth_reset
471  ****************************************************************/
472 static int kaweth_reset(struct kaweth_device *kaweth)
473 {
474  int result;
475 
476  netdev_dbg(kaweth->net, "kaweth_reset(%p)\n", kaweth);
477  result = usb_reset_configuration(kaweth->dev);
478  mdelay(10);
479 
480  netdev_dbg(kaweth->net, "kaweth_reset() returns %d.\n", result);
481 
482  return result;
483 }
484 
485 static void kaweth_usb_receive(struct urb *);
486 static int kaweth_resubmit_rx_urb(struct kaweth_device *, gfp_t);
487 
488 /****************************************************************
489  int_callback
490 *****************************************************************/
491 
492 static void kaweth_resubmit_int_urb(struct kaweth_device *kaweth, gfp_t mf)
493 {
494  int status;
495 
496  status = usb_submit_urb (kaweth->irq_urb, mf);
497  if (unlikely(status == -ENOMEM)) {
498  kaweth->suspend_lowmem_ctrl = 1;
499  schedule_delayed_work(&kaweth->lowmem_work, HZ/4);
500  } else {
501  kaweth->suspend_lowmem_ctrl = 0;
502  }
503 
504  if (status)
505  dev_err(&kaweth->intf->dev,
506  "can't resubmit intr, %s-%s, status %d\n",
507  kaweth->dev->bus->bus_name,
508  kaweth->dev->devpath, status);
509 }
510 
511 static void int_callback(struct urb *u)
512 {
513  struct kaweth_device *kaweth = u->context;
514  int act_state;
515  int status = u->status;
516 
517  switch (status) {
518  case 0: /* success */
519  break;
520  case -ECONNRESET: /* unlink */
521  case -ENOENT:
522  case -ESHUTDOWN:
523  return;
524  /* -EPIPE: should clear the halt */
525  default: /* error */
526  goto resubmit;
527  }
528 
529  /* we check the link state to report changes */
530  if (kaweth->linkstate != (act_state = ( kaweth->intbuffer[STATE_OFFSET] | STATE_MASK) >> STATE_SHIFT)) {
531  if (act_state)
532  netif_carrier_on(kaweth->net);
533  else
534  netif_carrier_off(kaweth->net);
535 
536  kaweth->linkstate = act_state;
537  }
538 resubmit:
539  kaweth_resubmit_int_urb(kaweth, GFP_ATOMIC);
540 }
541 
542 static void kaweth_resubmit_tl(struct work_struct *work)
543 {
544  struct kaweth_device *kaweth =
545  container_of(work, struct kaweth_device, lowmem_work.work);
546 
547  if (IS_BLOCKED(kaweth->status))
548  return;
549 
550  if (kaweth->suspend_lowmem_rx)
551  kaweth_resubmit_rx_urb(kaweth, GFP_NOIO);
552 
553  if (kaweth->suspend_lowmem_ctrl)
554  kaweth_resubmit_int_urb(kaweth, GFP_NOIO);
555 }
556 
557 
558 /****************************************************************
559  * kaweth_resubmit_rx_urb
560  ****************************************************************/
561 static int kaweth_resubmit_rx_urb(struct kaweth_device *kaweth,
562  gfp_t mem_flags)
563 {
564  int result;
565 
566  usb_fill_bulk_urb(kaweth->rx_urb,
567  kaweth->dev,
568  usb_rcvbulkpipe(kaweth->dev, 1),
569  kaweth->rx_buf,
570  KAWETH_BUF_SIZE,
571  kaweth_usb_receive,
572  kaweth);
573  kaweth->rx_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
574  kaweth->rx_urb->transfer_dma = kaweth->rxbufferhandle;
575 
576  if((result = usb_submit_urb(kaweth->rx_urb, mem_flags))) {
577  if (result == -ENOMEM) {
578  kaweth->suspend_lowmem_rx = 1;
579  schedule_delayed_work(&kaweth->lowmem_work, HZ/4);
580  }
581  dev_err(&kaweth->intf->dev, "resubmitting rx_urb %d failed\n",
582  result);
583  } else {
584  kaweth->suspend_lowmem_rx = 0;
585  }
586 
587  return result;
588 }
589 
590 static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth);
591 
592 /****************************************************************
593  * kaweth_usb_receive
594  ****************************************************************/
595 static void kaweth_usb_receive(struct urb *urb)
596 {
597  struct device *dev = &urb->dev->dev;
598  struct kaweth_device *kaweth = urb->context;
599  struct net_device *net = kaweth->net;
600  int status = urb->status;
601 
602  int count = urb->actual_length;
603  int count2 = urb->transfer_buffer_length;
604 
605  __u16 pkt_len = le16_to_cpup((__le16 *)kaweth->rx_buf);
606 
607  struct sk_buff *skb;
608 
609  if (unlikely(status == -EPIPE)) {
610  kaweth->stats.rx_errors++;
611  kaweth->end = 1;
612  wake_up(&kaweth->term_wait);
613  dev_dbg(dev, "Status was -EPIPE.\n");
614  return;
615  }
616  if (unlikely(status == -ECONNRESET || status == -ESHUTDOWN)) {
617  /* we are killed - set a flag and wake the disconnect handler */
618  kaweth->end = 1;
619  wake_up(&kaweth->term_wait);
620  dev_dbg(dev, "Status was -ECONNRESET or -ESHUTDOWN.\n");
621  return;
622  }
623  if (unlikely(status == -EPROTO || status == -ETIME ||
624  status == -EILSEQ)) {
625  kaweth->stats.rx_errors++;
626  dev_dbg(dev, "Status was -EPROTO, -ETIME, or -EILSEQ.\n");
627  return;
628  }
629  if (unlikely(status == -EOVERFLOW)) {
630  kaweth->stats.rx_errors++;
631  dev_dbg(dev, "Status was -EOVERFLOW.\n");
632  }
633  spin_lock(&kaweth->device_lock);
634  if (IS_BLOCKED(kaweth->status)) {
635  spin_unlock(&kaweth->device_lock);
636  return;
637  }
638  spin_unlock(&kaweth->device_lock);
639 
640  if(status && status != -EREMOTEIO && count != 1) {
641  dev_err(&kaweth->intf->dev,
642  "%s RX status: %d count: %d packet_len: %d\n",
643  net->name, status, count, (int)pkt_len);
644  kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
645  return;
646  }
647 
648  if(kaweth->net && (count > 2)) {
649  if(pkt_len > (count - 2)) {
650  dev_err(&kaweth->intf->dev,
651  "Packet length too long for USB frame (pkt_len: %x, count: %x)\n",
652  pkt_len, count);
653  dev_err(&kaweth->intf->dev, "Packet len & 2047: %x\n",
654  pkt_len & 2047);
655  dev_err(&kaweth->intf->dev, "Count 2: %x\n", count2);
656  kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
657  return;
658  }
659 
660  if(!(skb = dev_alloc_skb(pkt_len+2))) {
661  kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
662  return;
663  }
664 
665  skb_reserve(skb, 2); /* Align IP on 16 byte boundaries */
666 
667  skb_copy_to_linear_data(skb, kaweth->rx_buf + 2, pkt_len);
668 
669  skb_put(skb, pkt_len);
670 
671  skb->protocol = eth_type_trans(skb, net);
672 
673  netif_rx(skb);
674 
675  kaweth->stats.rx_packets++;
676  kaweth->stats.rx_bytes += pkt_len;
677  }
678 
679  kaweth_resubmit_rx_urb(kaweth, GFP_ATOMIC);
680 }
681 
682 /****************************************************************
683  * kaweth_open
684  ****************************************************************/
685 static int kaweth_open(struct net_device *net)
686 {
687  struct kaweth_device *kaweth = netdev_priv(net);
688  int res;
689 
690  netdev_dbg(kaweth->net, "Opening network device.\n");
691 
692  res = usb_autopm_get_interface(kaweth->intf);
693  if (res) {
694  dev_err(&kaweth->intf->dev, "Interface cannot be resumed.\n");
695  return -EIO;
696  }
697  res = kaweth_resubmit_rx_urb(kaweth, GFP_KERNEL);
698  if (res)
699  goto err_out;
700 
701  usb_fill_int_urb(
702  kaweth->irq_urb,
703  kaweth->dev,
704  usb_rcvintpipe(kaweth->dev, 3),
705  kaweth->intbuffer,
706  INTBUFFERSIZE,
707  int_callback,
708  kaweth,
709  250); /* overriding the descriptor */
710  kaweth->irq_urb->transfer_dma = kaweth->intbufferhandle;
711  kaweth->irq_urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
712 
713  res = usb_submit_urb(kaweth->irq_urb, GFP_KERNEL);
714  if (res) {
715  usb_kill_urb(kaweth->rx_urb);
716  goto err_out;
717  }
718  kaweth->opened = 1;
719 
720  netif_start_queue(net);
721 
722  kaweth_async_set_rx_mode(kaweth);
723  return 0;
724 
725 err_out:
726  usb_autopm_put_interface(kaweth->intf);
727  return -EIO;
728 }
729 
730 /****************************************************************
731  * kaweth_kill_urbs
732  ****************************************************************/
733 static void kaweth_kill_urbs(struct kaweth_device *kaweth)
734 {
735  usb_kill_urb(kaweth->irq_urb);
736  usb_kill_urb(kaweth->rx_urb);
737  usb_kill_urb(kaweth->tx_urb);
738 
739  cancel_delayed_work_sync(&kaweth->lowmem_work);
740 
741  /* a scheduled work may have resubmitted,
742  we hit them again */
743  usb_kill_urb(kaweth->irq_urb);
744  usb_kill_urb(kaweth->rx_urb);
745 }
746 
747 /****************************************************************
748  * kaweth_close
749  ****************************************************************/
750 static int kaweth_close(struct net_device *net)
751 {
752  struct kaweth_device *kaweth = netdev_priv(net);
753 
754  netif_stop_queue(net);
755  kaweth->opened = 0;
756 
757  kaweth->status |= KAWETH_STATUS_CLOSING;
758 
759  kaweth_kill_urbs(kaweth);
760 
761  kaweth->status &= ~KAWETH_STATUS_CLOSING;
762 
763  usb_autopm_put_interface(kaweth->intf);
764 
765  return 0;
766 }
767 
768 static u32 kaweth_get_link(struct net_device *dev)
769 {
770  struct kaweth_device *kaweth = netdev_priv(dev);
771 
772  return kaweth->linkstate;
773 }
774 
775 static const struct ethtool_ops ops = {
776  .get_link = kaweth_get_link
777 };
778 
779 /****************************************************************
780  * kaweth_usb_transmit_complete
781  ****************************************************************/
782 static void kaweth_usb_transmit_complete(struct urb *urb)
783 {
784  struct kaweth_device *kaweth = urb->context;
785  struct sk_buff *skb = kaweth->tx_skb;
786  int status = urb->status;
787 
788  if (unlikely(status != 0))
789  if (status != -ENOENT)
790  dev_dbg(&urb->dev->dev, "%s: TX status %d.\n",
791  kaweth->net->name, status);
792 
793  netif_wake_queue(kaweth->net);
794  dev_kfree_skb_irq(skb);
795 }
796 
797 /****************************************************************
798  * kaweth_start_xmit
799  ****************************************************************/
800 static netdev_tx_t kaweth_start_xmit(struct sk_buff *skb,
801  struct net_device *net)
802 {
803  struct kaweth_device *kaweth = netdev_priv(net);
804  __le16 *private_header;
805 
806  int res;
807 
808  spin_lock_irq(&kaweth->device_lock);
809 
810  kaweth_async_set_rx_mode(kaweth);
811  netif_stop_queue(net);
812  if (IS_BLOCKED(kaweth->status)) {
813  goto skip;
814  }
815 
816  /* We now decide whether we can put our special header into the sk_buff */
817  if (skb_cloned(skb) || skb_headroom(skb) < 2) {
818  /* no such luck - we make our own */
819  struct sk_buff *copied_skb;
820  copied_skb = skb_copy_expand(skb, 2, 0, GFP_ATOMIC);
821  dev_kfree_skb_irq(skb);
822  skb = copied_skb;
823  if (!copied_skb) {
824  kaweth->stats.tx_errors++;
825  netif_start_queue(net);
826  spin_unlock_irq(&kaweth->device_lock);
827  return NETDEV_TX_OK;
828  }
829  }
830 
831  private_header = (__le16 *)__skb_push(skb, 2);
832  *private_header = cpu_to_le16(skb->len-2);
833  kaweth->tx_skb = skb;
834 
835  usb_fill_bulk_urb(kaweth->tx_urb,
836  kaweth->dev,
837  usb_sndbulkpipe(kaweth->dev, 2),
838  private_header,
839  skb->len,
840  kaweth_usb_transmit_complete,
841  kaweth);
842  kaweth->end = 0;
843 
844  if((res = usb_submit_urb(kaweth->tx_urb, GFP_ATOMIC)))
845  {
846  dev_warn(&net->dev, "kaweth failed tx_urb %d\n", res);
847 skip:
848  kaweth->stats.tx_errors++;
849 
850  netif_start_queue(net);
851  dev_kfree_skb_irq(skb);
852  }
853  else
854  {
855  kaweth->stats.tx_packets++;
856  kaweth->stats.tx_bytes += skb->len;
857  }
858 
859  spin_unlock_irq(&kaweth->device_lock);
860 
861  return NETDEV_TX_OK;
862 }
863 
864 /****************************************************************
865  * kaweth_set_rx_mode
866  ****************************************************************/
867 static void kaweth_set_rx_mode(struct net_device *net)
868 {
869  struct kaweth_device *kaweth = netdev_priv(net);
870 
871  __u16 packet_filter_bitmap = KAWETH_PACKET_FILTER_DIRECTED |
872  KAWETH_PACKET_FILTER_BROADCAST |
873  KAWETH_PACKET_FILTER_MULTICAST;
874 
875  netdev_dbg(net, "Setting Rx mode to %d\n", packet_filter_bitmap);
876 
877  netif_stop_queue(net);
878 
879  if (net->flags & IFF_PROMISC) {
880  packet_filter_bitmap |= KAWETH_PACKET_FILTER_PROMISCUOUS;
881  }
882  else if (!netdev_mc_empty(net) || (net->flags & IFF_ALLMULTI)) {
883  packet_filter_bitmap |= KAWETH_PACKET_FILTER_ALL_MULTICAST;
884  }
885 
886  kaweth->packet_filter_bitmap = packet_filter_bitmap;
887  netif_wake_queue(net);
888 }
889 
890 /****************************************************************
891  * kaweth_async_set_rx_mode
892  ****************************************************************/
893 static void kaweth_async_set_rx_mode(struct kaweth_device *kaweth)
894 {
895  int result;
896  __u16 packet_filter_bitmap = kaweth->packet_filter_bitmap;
897 
898  kaweth->packet_filter_bitmap = 0;
899  if (packet_filter_bitmap == 0)
900  return;
901 
902  if (in_interrupt())
903  return;
904 
905  result = kaweth_control(kaweth,
906  usb_sndctrlpipe(kaweth->dev, 0),
907  KAWETH_COMMAND_SET_PACKET_FILTER,
908  USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_DEVICE,
909  packet_filter_bitmap,
910  0,
911  (void *)&kaweth->scratch,
912  0,
913  KAWETH_CONTROL_TIMEOUT);
914 
915  if(result < 0) {
916  dev_err(&kaweth->intf->dev, "Failed to set Rx mode: %d\n",
917  result);
918  }
919  else {
920  netdev_dbg(kaweth->net, "Set Rx mode to %d\n",
921  packet_filter_bitmap);
922  }
923 }
924 
925 /****************************************************************
926  * kaweth_netdev_stats
927  ****************************************************************/
928 static struct net_device_stats *kaweth_netdev_stats(struct net_device *dev)
929 {
930  struct kaweth_device *kaweth = netdev_priv(dev);
931  return &kaweth->stats;
932 }
933 
934 /****************************************************************
935  * kaweth_tx_timeout
936  ****************************************************************/
937 static void kaweth_tx_timeout(struct net_device *net)
938 {
939  struct kaweth_device *kaweth = netdev_priv(net);
940 
941  dev_warn(&net->dev, "%s: Tx timed out. Resetting.\n", net->name);
942  kaweth->stats.tx_errors++;
943  net->trans_start = jiffies;
944 
945  usb_unlink_urb(kaweth->tx_urb);
946 }
947 
948 /****************************************************************
949  * kaweth_suspend
950  ****************************************************************/
951 static int kaweth_suspend(struct usb_interface *intf, pm_message_t message)
952 {
953  struct kaweth_device *kaweth = usb_get_intfdata(intf);
954  unsigned long flags;
955 
956  dev_dbg(&intf->dev, "Suspending device\n");
957  spin_lock_irqsave(&kaweth->device_lock, flags);
958  kaweth->status |= KAWETH_STATUS_SUSPENDING;
959  spin_unlock_irqrestore(&kaweth->device_lock, flags);
960 
961  kaweth_kill_urbs(kaweth);
962  return 0;
963 }
964 
965 /****************************************************************
966  * kaweth_resume
967  ****************************************************************/
968 static int kaweth_resume(struct usb_interface *intf)
969 {
970  struct kaweth_device *kaweth = usb_get_intfdata(intf);
971  unsigned long flags;
972 
973  dev_dbg(&intf->dev, "Resuming device\n");
974  spin_lock_irqsave(&kaweth->device_lock, flags);
975  kaweth->status &= ~KAWETH_STATUS_SUSPENDING;
976  spin_unlock_irqrestore(&kaweth->device_lock, flags);
977 
978  if (!kaweth->opened)
979  return 0;
980  kaweth_resubmit_rx_urb(kaweth, GFP_NOIO);
981  kaweth_resubmit_int_urb(kaweth, GFP_NOIO);
982 
983  return 0;
984 }
985 
986 /****************************************************************
987  * kaweth_probe
988  ****************************************************************/
989 
990 
991 static const struct net_device_ops kaweth_netdev_ops = {
992  .ndo_open = kaweth_open,
993  .ndo_stop = kaweth_close,
994  .ndo_start_xmit = kaweth_start_xmit,
995  .ndo_tx_timeout = kaweth_tx_timeout,
996  .ndo_set_rx_mode = kaweth_set_rx_mode,
997  .ndo_get_stats = kaweth_netdev_stats,
998  .ndo_change_mtu = eth_change_mtu,
999  .ndo_set_mac_address = eth_mac_addr,
1000  .ndo_validate_addr = eth_validate_addr,
1001 };
1002 
1003 static int kaweth_probe(
1004  struct usb_interface *intf,
1005  const struct usb_device_id *id /* from id_table */
1006  )
1007 {
1008  struct device *dev = &intf->dev;
1009  struct usb_device *udev = interface_to_usbdev(intf);
1010  struct kaweth_device *kaweth;
1011  struct net_device *netdev;
1012  const eth_addr_t bcast_addr = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
1013  int result = 0;
1014 
1015  dev_dbg(dev,
1016  "Kawasaki Device Probe (Device number:%d): 0x%4.4x:0x%4.4x:0x%4.4x\n",
1017  udev->devnum, le16_to_cpu(udev->descriptor.idVendor),
1018  le16_to_cpu(udev->descriptor.idProduct),
1019  le16_to_cpu(udev->descriptor.bcdDevice));
1020 
1021  dev_dbg(dev, "Device at %p\n", udev);
1022 
1023  dev_dbg(dev, "Descriptor length: %x type: %x\n",
1024  (int)udev->descriptor.bLength,
1025  (int)udev->descriptor.bDescriptorType);
1026 
1027  netdev = alloc_etherdev(sizeof(*kaweth));
1028  if (!netdev)
1029  return -ENOMEM;
1030 
1031  kaweth = netdev_priv(netdev);
1032  kaweth->dev = udev;
1033  kaweth->net = netdev;
1034 
1035  spin_lock_init(&kaweth->device_lock);
1036  init_waitqueue_head(&kaweth->term_wait);
1037 
1038  dev_dbg(dev, "Resetting.\n");
1039 
1040  kaweth_reset(kaweth);
1041 
1042  /*
1043  * If high byte of bcdDevice is nonzero, firmware is already
1044  * downloaded. Don't try to do it again, or we'll hang the device.
1045  */
1046 
1047  if (le16_to_cpu(udev->descriptor.bcdDevice) >> 8) {
1048  dev_info(dev, "Firmware present in device.\n");
1049  } else {
1050  /* Download the firmware */
1051  dev_info(dev, "Downloading firmware...\n");
1052  kaweth->firmware_buf = (__u8 *)__get_free_page(GFP_KERNEL);
1053  if ((result = kaweth_download_firmware(kaweth,
1054  "kaweth/new_code.bin",
1055  100,
1056  2)) < 0) {
1057  dev_err(dev, "Error downloading firmware (%d)\n",
1058  result);
1059  goto err_fw;
1060  }
1061 
1062  if ((result = kaweth_download_firmware(kaweth,
1063  "kaweth/new_code_fix.bin",
1064  100,
1065  3)) < 0) {
1066  dev_err(dev, "Error downloading firmware fix (%d)\n",
1067  result);
1068  goto err_fw;
1069  }
1070 
1071  if ((result = kaweth_download_firmware(kaweth,
1072  "kaweth/trigger_code.bin",
1073  126,
1074  2)) < 0) {
1075  dev_err(dev, "Error downloading trigger code (%d)\n",
1076  result);
1077  goto err_fw;
1078 
1079  }
1080 
1081  if ((result = kaweth_download_firmware(kaweth,
1082  "kaweth/trigger_code_fix.bin",
1083  126,
1084  3)) < 0) {
1085  dev_err(dev, "Error downloading trigger code fix (%d)\n", result);
1086  goto err_fw;
1087  }
1088 
1089 
1090  if ((result = kaweth_trigger_firmware(kaweth, 126)) < 0) {
1091  dev_err(dev, "Error triggering firmware (%d)\n", result);
1092  goto err_fw;
1093  }
1094 
1095  /* Device will now disappear for a moment... */
1096  dev_info(dev, "Firmware loaded. I'll be back...\n");
1097 err_fw:
1098  free_page((unsigned long)kaweth->firmware_buf);
1099  free_netdev(netdev);
1100  return -EIO;
1101  }
1102 
1103  result = kaweth_read_configuration(kaweth);
1104 
1105  if(result < 0) {
1106  dev_err(dev, "Error reading configuration (%d), no net device created\n", result);
1107  goto err_free_netdev;
1108  }
1109 
1110  dev_info(dev, "Statistics collection: %x\n", kaweth->configuration.statistics_mask);
1111  dev_info(dev, "Multicast filter limit: %x\n", kaweth->configuration.max_multicast_filters & ((1 << 15) - 1));
1112  dev_info(dev, "MTU: %d\n", le16_to_cpu(kaweth->configuration.segment_size));
1113  dev_info(dev, "Read MAC address %pM\n", kaweth->configuration.hw_addr);
1114 
1115  if(!memcmp(&kaweth->configuration.hw_addr,
1116  &bcast_addr,
1117  sizeof(bcast_addr))) {
1118  dev_err(dev, "Firmware not functioning properly, no net device created\n");
1119  goto err_free_netdev;
1120  }
1121 
1122  if(kaweth_set_urb_size(kaweth, KAWETH_BUF_SIZE) < 0) {
1123  dev_dbg(dev, "Error setting URB size\n");
1124  goto err_free_netdev;
1125  }
1126 
1127  if(kaweth_set_sofs_wait(kaweth, KAWETH_SOFS_TO_WAIT) < 0) {
1128  dev_err(dev, "Error setting SOFS wait\n");
1129  goto err_free_netdev;
1130  }
1131 
1132  result = kaweth_set_receive_filter(kaweth,
1133  KAWETH_PACKET_FILTER_DIRECTED |
1134  KAWETH_PACKET_FILTER_BROADCAST |
1135  KAWETH_PACKET_FILTER_MULTICAST);
1136 
1137  if(result < 0) {
1138  dev_err(dev, "Error setting receive filter\n");
1139  goto err_free_netdev;
1140  }
1141 
1142  dev_dbg(dev, "Initializing net device.\n");
1143 
1144  kaweth->intf = intf;
1145 
1146  kaweth->tx_urb = usb_alloc_urb(0, GFP_KERNEL);
1147  if (!kaweth->tx_urb)
1148  goto err_free_netdev;
1149  kaweth->rx_urb = usb_alloc_urb(0, GFP_KERNEL);
1150  if (!kaweth->rx_urb)
1151  goto err_only_tx;
1152  kaweth->irq_urb = usb_alloc_urb(0, GFP_KERNEL);
1153  if (!kaweth->irq_urb)
1154  goto err_tx_and_rx;
1155 
1156  kaweth->intbuffer = usb_alloc_coherent( kaweth->dev,
1157  INTBUFFERSIZE,
1158  GFP_KERNEL,
1159  &kaweth->intbufferhandle);
1160  if (!kaweth->intbuffer)
1161  goto err_tx_and_rx_and_irq;
1162  kaweth->rx_buf = usb_alloc_coherent( kaweth->dev,
1163  KAWETH_BUF_SIZE,
1164  GFP_KERNEL,
1165  &kaweth->rxbufferhandle);
1166  if (!kaweth->rx_buf)
1167  goto err_all_but_rxbuf;
1168 
1169  memcpy(netdev->broadcast, &bcast_addr, sizeof(bcast_addr));
1170  memcpy(netdev->dev_addr, &kaweth->configuration.hw_addr,
1171  sizeof(kaweth->configuration.hw_addr));
1172 
1173  netdev->netdev_ops = &kaweth_netdev_ops;
1174  netdev->watchdog_timeo = KAWETH_TX_TIMEOUT;
1175  netdev->mtu = le16_to_cpu(kaweth->configuration.segment_size);
1176  SET_ETHTOOL_OPS(netdev, &ops);
1177 
1178  /* kaweth is zeroed as part of alloc_netdev */
1179  INIT_DELAYED_WORK(&kaweth->lowmem_work, kaweth_resubmit_tl);
1180  usb_set_intfdata(intf, kaweth);
1181 
1182 #if 0
1183 // dma_supported() is deeply broken on almost all architectures
1184  if (dma_supported (dev, 0xffffffffffffffffULL))
1185  kaweth->net->features |= NETIF_F_HIGHDMA;
1186 #endif
1187 
1188  SET_NETDEV_DEV(netdev, dev);
1189  if (register_netdev(netdev) != 0) {
1190  dev_err(dev, "Error registering netdev.\n");
1191  goto err_intfdata;
1192  }
1193 
1194  dev_info(dev, "kaweth interface created at %s\n",
1195  kaweth->net->name);
1196 
1197  dev_dbg(dev, "Kaweth probe returning.\n");
1198 
1199  return 0;
1200 
1201 err_intfdata:
1202  usb_set_intfdata(intf, NULL);
1203  usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle);
1204 err_all_but_rxbuf:
1205  usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle);
1206 err_tx_and_rx_and_irq:
1207  usb_free_urb(kaweth->irq_urb);
1208 err_tx_and_rx:
1209  usb_free_urb(kaweth->rx_urb);
1210 err_only_tx:
1211  usb_free_urb(kaweth->tx_urb);
1212 err_free_netdev:
1213  free_netdev(netdev);
1214 
1215  return -EIO;
1216 }
1217 
1218 /****************************************************************
1219  * kaweth_disconnect
1220  ****************************************************************/
1221 static void kaweth_disconnect(struct usb_interface *intf)
1222 {
1223  struct kaweth_device *kaweth = usb_get_intfdata(intf);
1224  struct net_device *netdev;
1225 
1226  dev_info(&intf->dev, "Unregistering\n");
1227 
1228  usb_set_intfdata(intf, NULL);
1229  if (!kaweth) {
1230  dev_warn(&intf->dev, "unregistering non-existent device\n");
1231  return;
1232  }
1233  netdev = kaweth->net;
1234 
1235  netdev_dbg(kaweth->net, "Unregistering net device\n");
1236  unregister_netdev(netdev);
1237 
1238  usb_free_urb(kaweth->rx_urb);
1239  usb_free_urb(kaweth->tx_urb);
1240  usb_free_urb(kaweth->irq_urb);
1241 
1242  usb_free_coherent(kaweth->dev, KAWETH_BUF_SIZE, (void *)kaweth->rx_buf, kaweth->rxbufferhandle);
1243  usb_free_coherent(kaweth->dev, INTBUFFERSIZE, (void *)kaweth->intbuffer, kaweth->intbufferhandle);
1244 
1245  free_netdev(netdev);
1246 }
1247 
1248 
1249 // FIXME this completion stuff is a modified clone of
1250 // an OLD version of some stuff in usb.c ...
1251 struct usb_api_data {
1252  wait_queue_head_t wqh;
1253  int done;
1254 };
1255 
1256 /*-------------------------------------------------------------------*
1257  * completion handler for compatibility wrappers (sync control/bulk) *
1258  *-------------------------------------------------------------------*/
1259 static void usb_api_blocking_completion(struct urb *urb)
1260 {
1261  struct usb_api_data *awd = (struct usb_api_data *)urb->context;
1262 
1263  awd->done=1;
1264  wake_up(&awd->wqh);
1265 }
1266 
1267 /*-------------------------------------------------------------------*
1268  * COMPATIBILITY STUFF *
1269  *-------------------------------------------------------------------*/
1270 
1271 // Starts urb and waits for completion or timeout
1272 static int usb_start_wait_urb(struct urb *urb, int timeout, int* actual_length)
1273 {
1274  struct usb_api_data awd;
1275  int status;
1276 
1277  init_waitqueue_head(&awd.wqh);
1278  awd.done = 0;
1279 
1280  urb->context = &awd;
1281  status = usb_submit_urb(urb, GFP_NOIO);
1282  if (status) {
1283  // something went wrong
1284  usb_free_urb(urb);
1285  return status;
1286  }
1287 
1288  if (!wait_event_timeout(awd.wqh, awd.done, timeout)) {
1289  // timeout
1290  dev_warn(&urb->dev->dev, "usb_control/bulk_msg: timeout\n");
1291  usb_kill_urb(urb); // remove urb safely
1292  status = -ETIMEDOUT;
1293  }
1294  else {
1295  status = urb->status;
1296  }
1297 
1298  if (actual_length) {
1299  *actual_length = urb->actual_length;
1300  }
1301 
1302  usb_free_urb(urb);
1303  return status;
1304 }
1305 
1306 /*-------------------------------------------------------------------*/
1307 // returns status (negative) or length (positive)
1308 static int kaweth_internal_control_msg(struct usb_device *usb_dev,
1309  unsigned int pipe,
1310  struct usb_ctrlrequest *cmd, void *data,
1311  int len, int timeout)
1312 {
1313  struct urb *urb;
1314  int retv;
1315  int length = 0; /* shut up GCC */
1316 
1317  urb = usb_alloc_urb(0, GFP_ATOMIC);
1318  if (!urb)
1319  return -ENOMEM;
1320 
1321  usb_fill_control_urb(urb, usb_dev, pipe, (unsigned char*)cmd, data,
1322  len, usb_api_blocking_completion, NULL);
1323 
1324  retv = usb_start_wait_urb(urb, timeout, &length);
1325  if (retv < 0) {
1326  return retv;
1327  }
1328  else {
1329  return length;
1330  }
1331 }
1332 
1333 module_usb_driver(kaweth_driver);
Generated on Thu Jan 10 2013 14:07:38 for Linux Kernel by   doxygen 1.8.2