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