projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
p54usb: fix random traffic stalls (LM87)
[deliverable/linux.git] / drivers / net / wireless / p54 / p54usb.c
1
2 /*
3 * Linux device driver for USB based Prism54
4 *
5 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
6 *
7 * Based on the islsm (softmac prism54) driver, which is:
8 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15 #include <linux/init.h>
16 #include <linux/usb.h>
17 #include <linux/pci.h>
18 #include <linux/firmware.h>
19 #include <linux/etherdevice.h>
20 #include <linux/delay.h>
21 #include <linux/crc32.h>
22 #include <net/mac80211.h>
23
24 #include "p54.h"
25 #include "p54usb.h"
26
27 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
28 MODULE_DESCRIPTION("Prism54 USB wireless driver");
29 MODULE_LICENSE("GPL");
30 MODULE_ALIAS("prism54usb");
31 MODULE_FIRMWARE("isl3886usb");
32 MODULE_FIRMWARE("isl3887usb");
33
34 static struct usb_device_id p54u_table[] __devinitdata = {
35 /* Version 1 devices (pci chip + net2280) */
36 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
37 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
38 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
39 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
40 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
41 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
42 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
43 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
44 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
45 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
46 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
47 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
48 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
49 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
50 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
51 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
52 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
53
54 /* Version 2 devices (3887) */
55 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
56 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
57 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
58 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
59 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
60 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
61 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
62 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
63 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
64 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
65 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
66 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
67 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
68 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
69 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
70 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
71 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
72 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
73 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
74 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
75 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
76 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
77 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
78 {}
79 };
80
81 MODULE_DEVICE_TABLE(usb, p54u_table);
82
83 static void p54u_rx_cb(struct urb *urb)
84 {
85 struct sk_buff *skb = (struct sk_buff *) urb->context;
86 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
87 struct ieee80211_hw *dev = info->dev;
88 struct p54u_priv *priv = dev->priv;
89
90 skb_unlink(skb, &priv->rx_queue);
91
92 if (unlikely(urb->status)) {
93 dev_kfree_skb_irq(skb);
94 return;
95 }
96
97 skb_put(skb, urb->actual_length);
98
99 if (priv->hw_type == P54U_NET2280)
100 skb_pull(skb, priv->common.tx_hdr_len);
101 if (priv->common.fw_interface == FW_LM87) {
102 skb_pull(skb, 4);
103 skb_put(skb, 4);
104 }
105
106 if (p54_rx(dev, skb)) {
107 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
108 if (unlikely(!skb)) {
109 /* TODO check rx queue length and refill *somewhere* */
110 return;
111 }
112
113 info = (struct p54u_rx_info *) skb->cb;
114 info->urb = urb;
115 info->dev = dev;
116 urb->transfer_buffer = skb_tail_pointer(skb);
117 urb->context = skb;
118 } else {
119 if (priv->hw_type == P54U_NET2280)
120 skb_push(skb, priv->common.tx_hdr_len);
121 if (priv->common.fw_interface == FW_LM87) {
122 skb_push(skb, 4);
123 skb_put(skb, 4);
124 }
125 skb_reset_tail_pointer(skb);
126 skb_trim(skb, 0);
127 if (urb->transfer_buffer != skb_tail_pointer(skb)) {
128 /* this should not happen */
129 WARN_ON(1);
130 urb->transfer_buffer = skb_tail_pointer(skb);
131 }
132 }
133 skb_queue_tail(&priv->rx_queue, skb);
134 usb_anchor_urb(urb, &priv->submitted);
135 if (usb_submit_urb(urb, GFP_ATOMIC)) {
136 skb_unlink(skb, &priv->rx_queue);
137 usb_unanchor_urb(urb);
138 dev_kfree_skb_irq(skb);
139 }
140 }
141
142 static void p54u_tx_cb(struct urb *urb)
143 {
144 struct sk_buff *skb = urb->context;
145 struct ieee80211_hw *dev = (struct ieee80211_hw *)
146 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
147 struct p54u_priv *priv = dev->priv;
148
149 skb_pull(skb, priv->common.tx_hdr_len);
150 if (FREE_AFTER_TX(skb))
151 p54_free_skb(dev, skb);
152 }
153
154 static void p54u_tx_dummy_cb(struct urb *urb) { }
155
156 static void p54u_free_urbs(struct ieee80211_hw *dev)
157 {
158 struct p54u_priv *priv = dev->priv;
159 usb_kill_anchored_urbs(&priv->submitted);
160 }
161
162 static int p54u_init_urbs(struct ieee80211_hw *dev)
163 {
164 struct p54u_priv *priv = dev->priv;
165 struct urb *entry = NULL;
166 struct sk_buff *skb;
167 struct p54u_rx_info *info;
168 int ret = 0;
169
170 while (skb_queue_len(&priv->rx_queue) < 32) {
171 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
172 if (!skb) {
173 ret = -ENOMEM;
174 goto err;
175 }
176 entry = usb_alloc_urb(0, GFP_KERNEL);
177 if (!entry) {
178 ret = -ENOMEM;
179 goto err;
180 }
181
182 usb_fill_bulk_urb(entry, priv->udev,
183 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
184 skb_tail_pointer(skb),
185 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
186 info = (struct p54u_rx_info *) skb->cb;
187 info->urb = entry;
188 info->dev = dev;
189 skb_queue_tail(&priv->rx_queue, skb);
190
191 usb_anchor_urb(entry, &priv->submitted);
192 ret = usb_submit_urb(entry, GFP_KERNEL);
193 if (ret) {
194 skb_unlink(skb, &priv->rx_queue);
195 usb_unanchor_urb(entry);
196 goto err;
197 }
198 usb_free_urb(entry);
199 entry = NULL;
200 }
201
202 return 0;
203
204 err:
205 usb_free_urb(entry);
206 kfree_skb(skb);
207 p54u_free_urbs(dev);
208 return ret;
209 }
210
211 static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb)
212 {
213 struct p54u_priv *priv = dev->priv;
214 struct urb *addr_urb, *data_urb;
215 int err = 0;
216
217 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
218 if (!addr_urb)
219 return;
220
221 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
222 if (!data_urb) {
223 usb_free_urb(addr_urb);
224 return;
225 }
226
227 usb_fill_bulk_urb(addr_urb, priv->udev,
228 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
229 &((struct p54_hdr *)skb->data)->req_id, 4,
230 p54u_tx_dummy_cb, dev);
231 usb_fill_bulk_urb(data_urb, priv->udev,
232 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
233 skb->data, skb->len, p54u_tx_cb, skb);
234
235 usb_anchor_urb(addr_urb, &priv->submitted);
236 err = usb_submit_urb(addr_urb, GFP_ATOMIC);
237 if (err) {
238 usb_unanchor_urb(addr_urb);
239 goto out;
240 }
241
242 usb_anchor_urb(addr_urb, &priv->submitted);
243 err = usb_submit_urb(data_urb, GFP_ATOMIC);
244 if (err)
245 usb_unanchor_urb(data_urb);
246
247 out:
248 usb_free_urb(addr_urb);
249 usb_free_urb(data_urb);
250
251 if (err)
252 p54_free_skb(dev, skb);
253 }
254
255 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
256 {
257 u32 chk = 0;
258
259 length >>= 2;
260 while (length--) {
261 chk ^= le32_to_cpu(*data++);
262 chk = (chk >> 5) ^ (chk << 3);
263 }
264
265 return cpu_to_le32(chk);
266 }
267
268 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
269 {
270 struct p54u_priv *priv = dev->priv;
271 struct urb *data_urb;
272 struct lm87_tx_hdr *hdr;
273 __le32 checksum;
274 __le32 addr = ((struct p54_hdr *)skb->data)->req_id;
275
276 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
277 if (!data_urb)
278 return;
279
280 checksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
281 hdr = (struct lm87_tx_hdr *)skb_push(skb, sizeof(*hdr));
282 hdr->chksum = checksum;
283 hdr->device_addr = addr;
284
285 usb_fill_bulk_urb(data_urb, priv->udev,
286 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
287 skb->data, skb->len, p54u_tx_cb, skb);
288 data_urb->transfer_flags |= URB_ZERO_PACKET;
289
290 usb_anchor_urb(data_urb, &priv->submitted);
291 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
292 usb_unanchor_urb(data_urb);
293 skb_pull(skb, sizeof(*hdr));
294 p54_free_skb(dev, skb);
295 }
296 usb_free_urb(data_urb);
297 }
298
299 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
300 {
301 struct p54u_priv *priv = dev->priv;
302 struct urb *int_urb, *data_urb;
303 struct net2280_tx_hdr *hdr;
304 struct net2280_reg_write *reg;
305 int err = 0;
306 __le32 addr = ((struct p54_hdr *) skb->data)->req_id;
307 __le16 len = cpu_to_le16(skb->len);
308
309 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
310 if (!reg)
311 return;
312
313 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
314 if (!int_urb) {
315 kfree(reg);
316 return;
317 }
318
319 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
320 if (!data_urb) {
321 kfree(reg);
322 usb_free_urb(int_urb);
323 return;
324 }
325
326 reg->port = cpu_to_le16(NET2280_DEV_U32);
327 reg->addr = cpu_to_le32(P54U_DEV_BASE);
328 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
329
330 hdr = (void *)skb_push(skb, sizeof(*hdr));
331 memset(hdr, 0, sizeof(*hdr));
332 hdr->len = len;
333 hdr->device_addr = addr;
334
335 usb_fill_bulk_urb(int_urb, priv->udev,
336 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
337 p54u_tx_dummy_cb, dev);
338
339 /*
340 * This flag triggers a code path in the USB subsystem that will
341 * free what's inside the transfer_buffer after the callback routine
342 * has completed.
343 */
344 int_urb->transfer_flags |= URB_FREE_BUFFER;
345
346 usb_fill_bulk_urb(data_urb, priv->udev,
347 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
348 skb->data, skb->len, p54u_tx_cb, skb);
349
350 usb_anchor_urb(int_urb, &priv->submitted);
351 err = usb_submit_urb(int_urb, GFP_ATOMIC);
352 if (err) {
353 usb_unanchor_urb(int_urb);
354 goto out;
355 }
356
357 usb_anchor_urb(data_urb, &priv->submitted);
358 err = usb_submit_urb(data_urb, GFP_ATOMIC);
359 if (err) {
360 usb_unanchor_urb(data_urb);
361 goto out;
362 }
363 out:
364 usb_free_urb(int_urb);
365 usb_free_urb(data_urb);
366
367 if (err) {
368 skb_pull(skb, sizeof(*hdr));
369 p54_free_skb(dev, skb);
370 }
371 }
372
373 static int p54u_write(struct p54u_priv *priv,
374 struct net2280_reg_write *buf,
375 enum net2280_op_type type,
376 __le32 addr, __le32 val)
377 {
378 unsigned int ep;
379 int alen;
380
381 if (type & 0x0800)
382 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
383 else
384 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
385
386 buf->port = cpu_to_le16(type);
387 buf->addr = addr;
388 buf->val = val;
389
390 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
391 }
392
393 static int p54u_read(struct p54u_priv *priv, void *buf,
394 enum net2280_op_type type,
395 __le32 addr, __le32 *val)
396 {
397 struct net2280_reg_read *read = buf;
398 __le32 *reg = buf;
399 unsigned int ep;
400 int alen, err;
401
402 if (type & 0x0800)
403 ep = P54U_PIPE_DEV;
404 else
405 ep = P54U_PIPE_BRG;
406
407 read->port = cpu_to_le16(type);
408 read->addr = addr;
409
410 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
411 read, sizeof(*read), &alen, 1000);
412 if (err)
413 return err;
414
415 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
416 reg, sizeof(*reg), &alen, 1000);
417 if (err)
418 return err;
419
420 *val = *reg;
421 return 0;
422 }
423
424 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
425 void *data, size_t len)
426 {
427 int alen;
428 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
429 data, len, &alen, 2000);
430 }
431
432 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
433 {
434 static char start_string[] = "~~~~<\r";
435 struct p54u_priv *priv = dev->priv;
436 const struct firmware *fw_entry = NULL;
437 int err, alen;
438 u8 carry = 0;
439 u8 *buf, *tmp;
440 const u8 *data;
441 unsigned int left, remains, block_size;
442 struct x2_header *hdr;
443 unsigned long timeout;
444
445 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
446 if (!buf) {
447 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
448 "upload buffer!\n");
449 err = -ENOMEM;
450 goto err_bufalloc;
451 }
452
453 memcpy(buf, start_string, 4);
454 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
455 if (err) {
456 dev_err(&priv->udev->dev, "(p54usb) reset failed! (%d)\n", err);
457 goto err_reset;
458 }
459
460 err = request_firmware(&fw_entry, "isl3887usb", &priv->udev->dev);
461 if (err) {
462 dev_err(&priv->udev->dev, "p54usb: cannot find firmware "
463 "(isl3887usb)\n");
464 err = request_firmware(&fw_entry, "isl3887usb_bare",
465 &priv->udev->dev);
466 if (err)
467 goto err_req_fw_failed;
468 }
469
470 err = p54_parse_firmware(dev, fw_entry);
471 if (err)
472 goto err_upload_failed;
473
474 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
475 strcpy(buf, start_string);
476 left -= strlen(start_string);
477 tmp += strlen(start_string);
478
479 data = fw_entry->data;
480 remains = fw_entry->size;
481
482 hdr = (struct x2_header *)(buf + strlen(start_string));
483 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
484 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
485 hdr->fw_length = cpu_to_le32(fw_entry->size);
486 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
487 sizeof(u32)*2));
488 left -= sizeof(*hdr);
489 tmp += sizeof(*hdr);
490
491 while (remains) {
492 while (left--) {
493 if (carry) {
494 *tmp++ = carry;
495 carry = 0;
496 remains--;
497 continue;
498 }
499 switch (*data) {
500 case '~':
501 *tmp++ = '}';
502 carry = '^';
503 break;
504 case '}':
505 *tmp++ = '}';
506 carry = ']';
507 break;
508 default:
509 *tmp++ = *data;
510 remains--;
511 break;
512 }
513 data++;
514 }
515
516 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
517 if (err) {
518 dev_err(&priv->udev->dev, "(p54usb) firmware "
519 "upload failed!\n");
520 goto err_upload_failed;
521 }
522
523 tmp = buf;
524 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
525 }
526
527 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
528 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
529 if (err) {
530 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
531 goto err_upload_failed;
532 }
533 timeout = jiffies + msecs_to_jiffies(1000);
534 while (!(err = usb_bulk_msg(priv->udev,
535 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
536 if (alen > 2 && !memcmp(buf, "OK", 2))
537 break;
538
539 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
540 err = -EINVAL;
541 break;
542 }
543
544 if (time_after(jiffies, timeout)) {
545 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
546 "timed out!\n");
547 err = -ETIMEDOUT;
548 break;
549 }
550 }
551 if (err) {
552 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
553 goto err_upload_failed;
554 }
555
556 buf[0] = 'g';
557 buf[1] = '\r';
558 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
559 if (err) {
560 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
561 goto err_upload_failed;
562 }
563
564 timeout = jiffies + msecs_to_jiffies(1000);
565 while (!(err = usb_bulk_msg(priv->udev,
566 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
567 if (alen > 0 && buf[0] == 'g')
568 break;
569
570 if (time_after(jiffies, timeout)) {
571 err = -ETIMEDOUT;
572 break;
573 }
574 }
575 if (err)
576 goto err_upload_failed;
577
578 err_upload_failed:
579 release_firmware(fw_entry);
580 err_req_fw_failed:
581 err_reset:
582 kfree(buf);
583 err_bufalloc:
584 return err;
585 }
586
587 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
588 {
589 struct p54u_priv *priv = dev->priv;
590 const struct firmware *fw_entry = NULL;
591 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
592 int err, alen;
593 void *buf;
594 __le32 reg;
595 unsigned int remains, offset;
596 const u8 *data;
597
598 buf = kmalloc(512, GFP_KERNEL);
599 if (!buf) {
600 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
601 "alloc failed!\n");
602 return -ENOMEM;
603 }
604
605 err = request_firmware(&fw_entry, "isl3886usb", &priv->udev->dev);
606 if (err) {
607 dev_err(&priv->udev->dev, "(p54usb) cannot find firmware "
608 "(isl3886usb)\n");
609 err = request_firmware(&fw_entry, "isl3890usb",
610 &priv->udev->dev);
611 if (err) {
612 kfree(buf);
613 return err;
614 }
615 }
616
617 err = p54_parse_firmware(dev, fw_entry);
618 if (err) {
619 kfree(buf);
620 release_firmware(fw_entry);
621 return err;
622 }
623
624 #define P54U_WRITE(type, addr, data) \
625 do {\
626 err = p54u_write(priv, buf, type,\
627 cpu_to_le32((u32)(unsigned long)addr), data);\
628 if (err) \
629 goto fail;\
630 } while (0)
631
632 #define P54U_READ(type, addr) \
633 do {\
634 err = p54u_read(priv, buf, type,\
635 cpu_to_le32((u32)(unsigned long)addr), &reg);\
636 if (err)\
637 goto fail;\
638 } while (0)
639
640 /* power down net2280 bridge */
641 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
642 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
643 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
644 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
645
646 mdelay(100);
647
648 /* power up bridge */
649 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
650 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
651 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
652
653 mdelay(100);
654
655 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
656 cpu_to_le32(NET2280_CLK_30Mhz |
657 NET2280_PCI_ENABLE |
658 NET2280_PCI_SOFT_RESET));
659
660 mdelay(20);
661
662 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
663 cpu_to_le32(PCI_COMMAND_MEMORY |
664 PCI_COMMAND_MASTER));
665
666 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
667 cpu_to_le32(NET2280_BASE));
668
669 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
670 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
671 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
672
673 // TODO: we really need this?
674 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
675
676 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
677 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
678 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
679 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
680
681 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
682 cpu_to_le32(NET2280_BASE2));
683
684 /* finally done setting up the bridge */
685
686 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
687 cpu_to_le32(PCI_COMMAND_MEMORY |
688 PCI_COMMAND_MASTER));
689
690 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
691 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
692 cpu_to_le32(P54U_DEV_BASE));
693
694 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
695 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
696 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
697
698 /* do romboot */
699 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
700
701 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
702 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
703 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
704 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
706
707 mdelay(20);
708
709 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
710 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
711
712 mdelay(20);
713
714 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
715 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
716
717 mdelay(100);
718
719 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
720 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
721
722 /* finally, we can upload firmware now! */
723 remains = fw_entry->size;
724 data = fw_entry->data;
725 offset = ISL38XX_DEV_FIRMWARE_ADDR;
726
727 while (remains) {
728 unsigned int block_len = min(remains, (unsigned int)512);
729 memcpy(buf, data, block_len);
730
731 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
732 if (err) {
733 dev_err(&priv->udev->dev, "(p54usb) firmware block "
734 "upload failed\n");
735 goto fail;
736 }
737
738 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
739 cpu_to_le32(0xc0000f00));
740
741 P54U_WRITE(NET2280_DEV_U32,
742 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
743 P54U_WRITE(NET2280_DEV_U32,
744 0x0020 | (unsigned long)&devreg->direct_mem_win,
745 cpu_to_le32(1));
746
747 P54U_WRITE(NET2280_DEV_U32,
748 0x0024 | (unsigned long)&devreg->direct_mem_win,
749 cpu_to_le32(block_len));
750 P54U_WRITE(NET2280_DEV_U32,
751 0x0028 | (unsigned long)&devreg->direct_mem_win,
752 cpu_to_le32(offset));
753
754 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
755 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
756 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
757 cpu_to_le32(block_len >> 2));
758 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
759 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
760
761 mdelay(10);
762
763 P54U_READ(NET2280_DEV_U32,
764 0x002C | (unsigned long)&devreg->direct_mem_win);
765 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
766 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
767 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
768 "transfer failed\n");
769 goto fail;
770 }
771
772 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
773 cpu_to_le32(NET2280_FIFO_FLUSH));
774
775 remains -= block_len;
776 data += block_len;
777 offset += block_len;
778 }
779
780 /* do ramboot */
781 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
782 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
783 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
784 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
785 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
786
787 mdelay(20);
788
789 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
790 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
791
792 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
793 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
794
795 mdelay(100);
796
797 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
798 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
799
800 /* start up the firmware */
801 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
802 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
803
804 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
805 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
806
807 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
808 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
809 NET2280_USB_INTERRUPT_ENABLE));
810
811 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
812 cpu_to_le32(ISL38XX_DEV_INT_RESET));
813
814 err = usb_interrupt_msg(priv->udev,
815 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
816 buf, sizeof(__le32), &alen, 1000);
817 if (err || alen != sizeof(__le32))
818 goto fail;
819
820 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
821 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
822
823 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
824 err = -EINVAL;
825
826 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
827 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
828 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
829
830 #undef P54U_WRITE
831 #undef P54U_READ
832
833 fail:
834 release_firmware(fw_entry);
835 kfree(buf);
836 return err;
837 }
838
839 static int p54u_open(struct ieee80211_hw *dev)
840 {
841 struct p54u_priv *priv = dev->priv;
842 int err;
843
844 err = p54u_init_urbs(dev);
845 if (err) {
846 return err;
847 }
848
849 priv->common.open = p54u_init_urbs;
850
851 return 0;
852 }
853
854 static void p54u_stop(struct ieee80211_hw *dev)
855 {
856 /* TODO: figure out how to reliably stop the 3887 and net2280 so
857 the hardware is still usable next time we want to start it.
858 until then, we just stop listening to the hardware.. */
859 p54u_free_urbs(dev);
860 return;
861 }
862
863 static int __devinit p54u_probe(struct usb_interface *intf,
864 const struct usb_device_id *id)
865 {
866 struct usb_device *udev = interface_to_usbdev(intf);
867 struct ieee80211_hw *dev;
868 struct p54u_priv *priv;
869 int err;
870 unsigned int i, recognized_pipes;
871
872 dev = p54_init_common(sizeof(*priv));
873
874 if (!dev) {
875 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
876 return -ENOMEM;
877 }
878
879 priv = dev->priv;
880
881 SET_IEEE80211_DEV(dev, &intf->dev);
882 usb_set_intfdata(intf, dev);
883 priv->udev = udev;
884
885 usb_get_dev(udev);
886
887 /* really lazy and simple way of figuring out if we're a 3887 */
888 /* TODO: should just stick the identification in the device table */
889 i = intf->altsetting->desc.bNumEndpoints;
890 recognized_pipes = 0;
891 while (i--) {
892 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
893 case P54U_PIPE_DATA:
894 case P54U_PIPE_MGMT:
895 case P54U_PIPE_BRG:
896 case P54U_PIPE_DEV:
897 case P54U_PIPE_DATA | USB_DIR_IN:
898 case P54U_PIPE_MGMT | USB_DIR_IN:
899 case P54U_PIPE_BRG | USB_DIR_IN:
900 case P54U_PIPE_DEV | USB_DIR_IN:
901 case P54U_PIPE_INT | USB_DIR_IN:
902 recognized_pipes++;
903 }
904 }
905 priv->common.open = p54u_open;
906 priv->common.stop = p54u_stop;
907 if (recognized_pipes < P54U_PIPE_NUMBER) {
908 priv->hw_type = P54U_3887;
909 err = p54u_upload_firmware_3887(dev);
910 if (priv->common.fw_interface == FW_LM87) {
911 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
912 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
913 priv->common.tx = p54u_tx_lm87;
914 } else
915 priv->common.tx = p54u_tx_3887;
916 } else {
917 priv->hw_type = P54U_NET2280;
918 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
919 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
920 priv->common.tx = p54u_tx_net2280;
921 err = p54u_upload_firmware_net2280(dev);
922 }
923 if (err)
924 goto err_free_dev;
925
926 skb_queue_head_init(&priv->rx_queue);
927 init_usb_anchor(&priv->submitted);
928
929 p54u_open(dev);
930 err = p54_read_eeprom(dev);
931 p54u_stop(dev);
932 if (err)
933 goto err_free_dev;
934
935 err = ieee80211_register_hw(dev);
936 if (err) {
937 dev_err(&udev->dev, "(p54usb) Cannot register netdevice\n");
938 goto err_free_dev;
939 }
940
941 return 0;
942
943 err_free_dev:
944 ieee80211_free_hw(dev);
945 usb_set_intfdata(intf, NULL);
946 usb_put_dev(udev);
947 return err;
948 }
949
950 static void __devexit p54u_disconnect(struct usb_interface *intf)
951 {
952 struct ieee80211_hw *dev = usb_get_intfdata(intf);
953 struct p54u_priv *priv;
954
955 if (!dev)
956 return;
957
958 ieee80211_unregister_hw(dev);
959
960 priv = dev->priv;
961 usb_put_dev(interface_to_usbdev(intf));
962 p54_free_common(dev);
963 ieee80211_free_hw(dev);
964 }
965
966 static struct usb_driver p54u_driver = {
967 .name = "p54usb",
968 .id_table = p54u_table,
969 .probe = p54u_probe,
970 .disconnect = p54u_disconnect,
971 };
972
973 static int __init p54u_init(void)
974 {
975 return usb_register(&p54u_driver);
976 }
977
978 static void __exit p54u_exit(void)
979 {
980 usb_deregister(&p54u_driver);
981 }
982
983 module_init(p54u_init);
984 module_exit(p54u_exit);
Linux kernel - Deliverables
This page took 0.068681 seconds and 5 git commands to generate.