Loading...
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/slab.h>
19#include <linux/firmware.h>
20#include <linux/etherdevice.h>
21#include <linux/delay.h>
22#include <linux/crc32.h>
23#include <net/mac80211.h>
24
25#include "p54.h"
26#include "lmac.h"
27#include "p54usb.h"
28
29MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
30MODULE_DESCRIPTION("Prism54 USB wireless driver");
31MODULE_LICENSE("GPL");
32MODULE_ALIAS("prism54usb");
33MODULE_FIRMWARE("isl3886usb");
34MODULE_FIRMWARE("isl3887usb");
35
36/*
37 * Note:
38 *
39 * Always update our wiki's device list (located at:
40 * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
41 * whenever you add a new device.
42 */
43
44static struct usb_device_id p54u_table[] __devinitdata = {
45 /* Version 1 devices (pci chip + net2280) */
46 {USB_DEVICE(0x0411, 0x0050)}, /* Buffalo WLI2-USB2-G54 */
47 {USB_DEVICE(0x045e, 0x00c2)}, /* Microsoft MN-710 */
48 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
49 {USB_DEVICE(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */
50 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
51 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
52 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
53 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
54 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
55 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
56 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
57 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
58 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
59 {USB_DEVICE(0x0bf8, 0x1007)}, /* Fujitsu E-5400 USB */
60 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
61 {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */
62 {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */
63 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
64 {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */
65 {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */
66 {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
67 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
68 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
69 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
70 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
71 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
72 {USB_DEVICE(0x2001, 0x3762)}, /* Conceptronic C54U */
73 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
74 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
75
76 /* Version 2 devices (3887) */
77 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
78 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
79 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
80 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
81 {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */
82 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
83 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
84 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
85 {USB_DEVICE(0x083a, 0xc501)}, /* Zoom Wireless-G 4410 */
86 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
87 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
88 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
89 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
90 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
91 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
92 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
93 * just noting it here for clarity */
94 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
95 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
96 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
97 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
98 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
99 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
100 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
101 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
102 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
103 {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */
104 {USB_DEVICE(0x1740, 0x1000)}, /* Senao NUB-350 */
105 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
106 {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */
107 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
108 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
109 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
110 {}
111};
112
113MODULE_DEVICE_TABLE(usb, p54u_table);
114
115static const struct {
116 u32 intf;
117 enum p54u_hw_type type;
118 const char *fw;
119 const char *fw_legacy;
120 char hw[20];
121} p54u_fwlist[__NUM_P54U_HWTYPES] = {
122 {
123 .type = P54U_NET2280,
124 .intf = FW_LM86,
125 .fw = "isl3886usb",
126 .fw_legacy = "isl3890usb",
127 .hw = "ISL3886 + net2280",
128 },
129 {
130 .type = P54U_3887,
131 .intf = FW_LM87,
132 .fw = "isl3887usb",
133 .fw_legacy = "isl3887usb_bare",
134 .hw = "ISL3887",
135 },
136};
137
138static void p54u_rx_cb(struct urb *urb)
139{
140 struct sk_buff *skb = (struct sk_buff *) urb->context;
141 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
142 struct ieee80211_hw *dev = info->dev;
143 struct p54u_priv *priv = dev->priv;
144
145 skb_unlink(skb, &priv->rx_queue);
146
147 if (unlikely(urb->status)) {
148 dev_kfree_skb_irq(skb);
149 return;
150 }
151
152 skb_put(skb, urb->actual_length);
153
154 if (priv->hw_type == P54U_NET2280)
155 skb_pull(skb, priv->common.tx_hdr_len);
156 if (priv->common.fw_interface == FW_LM87) {
157 skb_pull(skb, 4);
158 skb_put(skb, 4);
159 }
160
161 if (p54_rx(dev, skb)) {
162 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
163 if (unlikely(!skb)) {
164 /* TODO check rx queue length and refill *somewhere* */
165 return;
166 }
167
168 info = (struct p54u_rx_info *) skb->cb;
169 info->urb = urb;
170 info->dev = dev;
171 urb->transfer_buffer = skb_tail_pointer(skb);
172 urb->context = skb;
173 } else {
174 if (priv->hw_type == P54U_NET2280)
175 skb_push(skb, priv->common.tx_hdr_len);
176 if (priv->common.fw_interface == FW_LM87) {
177 skb_push(skb, 4);
178 skb_put(skb, 4);
179 }
180 skb_reset_tail_pointer(skb);
181 skb_trim(skb, 0);
182 urb->transfer_buffer = skb_tail_pointer(skb);
183 }
184 skb_queue_tail(&priv->rx_queue, skb);
185 usb_anchor_urb(urb, &priv->submitted);
186 if (usb_submit_urb(urb, GFP_ATOMIC)) {
187 skb_unlink(skb, &priv->rx_queue);
188 usb_unanchor_urb(urb);
189 dev_kfree_skb_irq(skb);
190 }
191}
192
193static void p54u_tx_cb(struct urb *urb)
194{
195 struct sk_buff *skb = urb->context;
196 struct ieee80211_hw *dev =
197 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
198
199 p54_free_skb(dev, skb);
200}
201
202static void p54u_tx_dummy_cb(struct urb *urb) { }
203
204static void p54u_free_urbs(struct ieee80211_hw *dev)
205{
206 struct p54u_priv *priv = dev->priv;
207 usb_kill_anchored_urbs(&priv->submitted);
208}
209
210static int p54u_init_urbs(struct ieee80211_hw *dev)
211{
212 struct p54u_priv *priv = dev->priv;
213 struct urb *entry = NULL;
214 struct sk_buff *skb;
215 struct p54u_rx_info *info;
216 int ret = 0;
217
218 while (skb_queue_len(&priv->rx_queue) < 32) {
219 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
220 if (!skb) {
221 ret = -ENOMEM;
222 goto err;
223 }
224 entry = usb_alloc_urb(0, GFP_KERNEL);
225 if (!entry) {
226 ret = -ENOMEM;
227 goto err;
228 }
229
230 usb_fill_bulk_urb(entry, priv->udev,
231 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
232 skb_tail_pointer(skb),
233 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
234 info = (struct p54u_rx_info *) skb->cb;
235 info->urb = entry;
236 info->dev = dev;
237 skb_queue_tail(&priv->rx_queue, skb);
238
239 usb_anchor_urb(entry, &priv->submitted);
240 ret = usb_submit_urb(entry, GFP_KERNEL);
241 if (ret) {
242 skb_unlink(skb, &priv->rx_queue);
243 usb_unanchor_urb(entry);
244 goto err;
245 }
246 usb_free_urb(entry);
247 entry = NULL;
248 }
249
250 return 0;
251
252 err:
253 usb_free_urb(entry);
254 kfree_skb(skb);
255 p54u_free_urbs(dev);
256 return ret;
257}
258
259static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
260{
261 u32 chk = 0;
262
263 length >>= 2;
264 while (length--) {
265 chk ^= le32_to_cpu(*data++);
266 chk = (chk >> 5) ^ (chk << 3);
267 }
268
269 return cpu_to_le32(chk);
270}
271
272static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
273{
274 struct p54u_priv *priv = dev->priv;
275 struct urb *data_urb;
276 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
277
278 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
279 if (!data_urb) {
280 p54_free_skb(dev, skb);
281 return;
282 }
283
284 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
285 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
286
287 usb_fill_bulk_urb(data_urb, priv->udev,
288 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
289 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
290 p54u_tx_cb : p54u_tx_dummy_cb, skb);
291 data_urb->transfer_flags |= URB_ZERO_PACKET;
292
293 usb_anchor_urb(data_urb, &priv->submitted);
294 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
295 usb_unanchor_urb(data_urb);
296 p54_free_skb(dev, skb);
297 }
298 usb_free_urb(data_urb);
299}
300
301static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
302{
303 struct p54u_priv *priv = dev->priv;
304 struct urb *int_urb = NULL, *data_urb = NULL;
305 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
306 struct net2280_reg_write *reg = NULL;
307 int err = -ENOMEM;
308
309 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
310 if (!reg)
311 goto out;
312
313 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
314 if (!int_urb)
315 goto out;
316
317 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
318 if (!data_urb)
319 goto out;
320
321 reg->port = cpu_to_le16(NET2280_DEV_U32);
322 reg->addr = cpu_to_le32(P54U_DEV_BASE);
323 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
324
325 memset(hdr, 0, sizeof(*hdr));
326 hdr->len = cpu_to_le16(skb->len);
327 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
328
329 usb_fill_bulk_urb(int_urb, priv->udev,
330 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
331 p54u_tx_dummy_cb, dev);
332
333 /*
334 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
335 * free what is inside the transfer_buffer after the last reference to
336 * the int_urb is dropped.
337 */
338 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
339 reg = NULL;
340
341 usb_fill_bulk_urb(data_urb, priv->udev,
342 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
343 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
344 p54u_tx_cb : p54u_tx_dummy_cb, skb);
345 data_urb->transfer_flags |= URB_ZERO_PACKET;
346
347 usb_anchor_urb(int_urb, &priv->submitted);
348 err = usb_submit_urb(int_urb, GFP_ATOMIC);
349 if (err) {
350 usb_unanchor_urb(int_urb);
351 goto out;
352 }
353
354 usb_anchor_urb(data_urb, &priv->submitted);
355 err = usb_submit_urb(data_urb, GFP_ATOMIC);
356 if (err) {
357 usb_unanchor_urb(data_urb);
358 goto out;
359 }
360out:
361 usb_free_urb(int_urb);
362 usb_free_urb(data_urb);
363
364 if (err) {
365 kfree(reg);
366 p54_free_skb(dev, skb);
367 }
368}
369
370static int p54u_write(struct p54u_priv *priv,
371 struct net2280_reg_write *buf,
372 enum net2280_op_type type,
373 __le32 addr, __le32 val)
374{
375 unsigned int ep;
376 int alen;
377
378 if (type & 0x0800)
379 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
380 else
381 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
382
383 buf->port = cpu_to_le16(type);
384 buf->addr = addr;
385 buf->val = val;
386
387 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
388}
389
390static int p54u_read(struct p54u_priv *priv, void *buf,
391 enum net2280_op_type type,
392 __le32 addr, __le32 *val)
393{
394 struct net2280_reg_read *read = buf;
395 __le32 *reg = buf;
396 unsigned int ep;
397 int alen, err;
398
399 if (type & 0x0800)
400 ep = P54U_PIPE_DEV;
401 else
402 ep = P54U_PIPE_BRG;
403
404 read->port = cpu_to_le16(type);
405 read->addr = addr;
406
407 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
408 read, sizeof(*read), &alen, 1000);
409 if (err)
410 return err;
411
412 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
413 reg, sizeof(*reg), &alen, 1000);
414 if (err)
415 return err;
416
417 *val = *reg;
418 return 0;
419}
420
421static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
422 void *data, size_t len)
423{
424 int alen;
425 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
426 data, len, &alen, 2000);
427}
428
429static int p54u_device_reset(struct ieee80211_hw *dev)
430{
431 struct p54u_priv *priv = dev->priv;
432 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
433
434 if (lock) {
435 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
436 if (ret < 0) {
437 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
438 "device for reset (%d)!\n", ret);
439 return ret;
440 }
441 }
442
443 ret = usb_reset_device(priv->udev);
444 if (lock)
445 usb_unlock_device(priv->udev);
446
447 if (ret)
448 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
449 "device (%d)!\n", ret);
450
451 return ret;
452}
453
454static const char p54u_romboot_3887[] = "~~~~";
455static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
456{
457 struct p54u_priv *priv = dev->priv;
458 u8 *buf;
459 int ret;
460
461 buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
462 if (!buf)
463 return -ENOMEM;
464 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
465 buf, 4);
466 kfree(buf);
467 if (ret)
468 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
469 "boot ROM (%d)!\n", ret);
470
471 return ret;
472}
473
474static const char p54u_firmware_upload_3887[] = "<\r";
475static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
476{
477 struct p54u_priv *priv = dev->priv;
478 int err, alen;
479 u8 carry = 0;
480 u8 *buf, *tmp;
481 const u8 *data;
482 unsigned int left, remains, block_size;
483 struct x2_header *hdr;
484 unsigned long timeout;
485
486 err = p54u_firmware_reset_3887(dev);
487 if (err)
488 return err;
489
490 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
491 if (!buf) {
492 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
493 "upload buffer!\n");
494 return -ENOMEM;
495 }
496
497 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
498 strcpy(buf, p54u_firmware_upload_3887);
499 left -= strlen(p54u_firmware_upload_3887);
500 tmp += strlen(p54u_firmware_upload_3887);
501
502 data = priv->fw->data;
503 remains = priv->fw->size;
504
505 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
506 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
507 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
508 hdr->fw_length = cpu_to_le32(priv->fw->size);
509 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
510 sizeof(u32)*2));
511 left -= sizeof(*hdr);
512 tmp += sizeof(*hdr);
513
514 while (remains) {
515 while (left--) {
516 if (carry) {
517 *tmp++ = carry;
518 carry = 0;
519 remains--;
520 continue;
521 }
522 switch (*data) {
523 case '~':
524 *tmp++ = '}';
525 carry = '^';
526 break;
527 case '}':
528 *tmp++ = '}';
529 carry = ']';
530 break;
531 default:
532 *tmp++ = *data;
533 remains--;
534 break;
535 }
536 data++;
537 }
538
539 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
540 if (err) {
541 dev_err(&priv->udev->dev, "(p54usb) firmware "
542 "upload failed!\n");
543 goto err_upload_failed;
544 }
545
546 tmp = buf;
547 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
548 }
549
550 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
551 priv->fw->size));
552 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
553 if (err) {
554 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
555 goto err_upload_failed;
556 }
557 timeout = jiffies + msecs_to_jiffies(1000);
558 while (!(err = usb_bulk_msg(priv->udev,
559 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
560 if (alen > 2 && !memcmp(buf, "OK", 2))
561 break;
562
563 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
564 err = -EINVAL;
565 break;
566 }
567
568 if (time_after(jiffies, timeout)) {
569 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
570 "timed out!\n");
571 err = -ETIMEDOUT;
572 break;
573 }
574 }
575 if (err) {
576 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
577 goto err_upload_failed;
578 }
579
580 buf[0] = 'g';
581 buf[1] = '\r';
582 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
583 if (err) {
584 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
585 goto err_upload_failed;
586 }
587
588 timeout = jiffies + msecs_to_jiffies(1000);
589 while (!(err = usb_bulk_msg(priv->udev,
590 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
591 if (alen > 0 && buf[0] == 'g')
592 break;
593
594 if (time_after(jiffies, timeout)) {
595 err = -ETIMEDOUT;
596 break;
597 }
598 }
599 if (err)
600 goto err_upload_failed;
601
602err_upload_failed:
603 kfree(buf);
604 return err;
605}
606
607static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
608{
609 struct p54u_priv *priv = dev->priv;
610 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
611 int err, alen;
612 void *buf;
613 __le32 reg;
614 unsigned int remains, offset;
615 const u8 *data;
616
617 buf = kmalloc(512, GFP_KERNEL);
618 if (!buf) {
619 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
620 "alloc failed!\n");
621 return -ENOMEM;
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), ®);\
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 = priv->fw->size;
724 data = priv->fw->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
833fail:
834 kfree(buf);
835 return err;
836}
837
838static int p54u_load_firmware(struct ieee80211_hw *dev)
839{
840 struct p54u_priv *priv = dev->priv;
841 int err, i;
842
843 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
844
845 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
846 if (p54u_fwlist[i].type == priv->hw_type)
847 break;
848
849 if (i == __NUM_P54U_HWTYPES)
850 return -EOPNOTSUPP;
851
852 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
853 if (err) {
854 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
855 "(%d)!\n", p54u_fwlist[i].fw, err);
856
857 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
858 &priv->udev->dev);
859 if (err)
860 return err;
861 }
862
863 err = p54_parse_firmware(dev, priv->fw);
864 if (err)
865 goto out;
866
867 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
868 dev_err(&priv->udev->dev, "wrong firmware, please get "
869 "a firmware for \"%s\" and try again.\n",
870 p54u_fwlist[i].hw);
871 err = -EINVAL;
872 }
873
874out:
875 if (err)
876 release_firmware(priv->fw);
877
878 return err;
879}
880
881static int p54u_open(struct ieee80211_hw *dev)
882{
883 struct p54u_priv *priv = dev->priv;
884 int err;
885
886 err = p54u_init_urbs(dev);
887 if (err) {
888 return err;
889 }
890
891 priv->common.open = p54u_init_urbs;
892
893 return 0;
894}
895
896static void p54u_stop(struct ieee80211_hw *dev)
897{
898 /* TODO: figure out how to reliably stop the 3887 and net2280 so
899 the hardware is still usable next time we want to start it.
900 until then, we just stop listening to the hardware.. */
901 p54u_free_urbs(dev);
902}
903
904static int __devinit p54u_probe(struct usb_interface *intf,
905 const struct usb_device_id *id)
906{
907 struct usb_device *udev = interface_to_usbdev(intf);
908 struct ieee80211_hw *dev;
909 struct p54u_priv *priv;
910 int err;
911 unsigned int i, recognized_pipes;
912
913 dev = p54_init_common(sizeof(*priv));
914
915 if (!dev) {
916 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
917 return -ENOMEM;
918 }
919
920 priv = dev->priv;
921 priv->hw_type = P54U_INVALID_HW;
922
923 SET_IEEE80211_DEV(dev, &intf->dev);
924 usb_set_intfdata(intf, dev);
925 priv->udev = udev;
926 priv->intf = intf;
927 skb_queue_head_init(&priv->rx_queue);
928 init_usb_anchor(&priv->submitted);
929
930 usb_get_dev(udev);
931
932 /* really lazy and simple way of figuring out if we're a 3887 */
933 /* TODO: should just stick the identification in the device table */
934 i = intf->altsetting->desc.bNumEndpoints;
935 recognized_pipes = 0;
936 while (i--) {
937 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
938 case P54U_PIPE_DATA:
939 case P54U_PIPE_MGMT:
940 case P54U_PIPE_BRG:
941 case P54U_PIPE_DEV:
942 case P54U_PIPE_DATA | USB_DIR_IN:
943 case P54U_PIPE_MGMT | USB_DIR_IN:
944 case P54U_PIPE_BRG | USB_DIR_IN:
945 case P54U_PIPE_DEV | USB_DIR_IN:
946 case P54U_PIPE_INT | USB_DIR_IN:
947 recognized_pipes++;
948 }
949 }
950 priv->common.open = p54u_open;
951 priv->common.stop = p54u_stop;
952 if (recognized_pipes < P54U_PIPE_NUMBER) {
953#ifdef CONFIG_PM
954 /* ISL3887 needs a full reset on resume */
955 udev->reset_resume = 1;
956#endif /* CONFIG_PM */
957 err = p54u_device_reset(dev);
958
959 priv->hw_type = P54U_3887;
960 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
961 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
962 priv->common.tx = p54u_tx_lm87;
963 priv->upload_fw = p54u_upload_firmware_3887;
964 } else {
965 priv->hw_type = P54U_NET2280;
966 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
967 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
968 priv->common.tx = p54u_tx_net2280;
969 priv->upload_fw = p54u_upload_firmware_net2280;
970 }
971 err = p54u_load_firmware(dev);
972 if (err)
973 goto err_free_dev;
974
975 err = priv->upload_fw(dev);
976 if (err)
977 goto err_free_fw;
978
979 p54u_open(dev);
980 err = p54_read_eeprom(dev);
981 p54u_stop(dev);
982 if (err)
983 goto err_free_fw;
984
985 err = p54_register_common(dev, &udev->dev);
986 if (err)
987 goto err_free_fw;
988
989 return 0;
990
991err_free_fw:
992 release_firmware(priv->fw);
993
994err_free_dev:
995 p54_free_common(dev);
996 usb_set_intfdata(intf, NULL);
997 usb_put_dev(udev);
998 return err;
999}
1000
1001static void __devexit p54u_disconnect(struct usb_interface *intf)
1002{
1003 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1004 struct p54u_priv *priv;
1005
1006 if (!dev)
1007 return;
1008
1009 p54_unregister_common(dev);
1010
1011 priv = dev->priv;
1012 usb_put_dev(interface_to_usbdev(intf));
1013 release_firmware(priv->fw);
1014 p54_free_common(dev);
1015}
1016
1017static int p54u_pre_reset(struct usb_interface *intf)
1018{
1019 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1020
1021 if (!dev)
1022 return -ENODEV;
1023
1024 p54u_stop(dev);
1025 return 0;
1026}
1027
1028static int p54u_resume(struct usb_interface *intf)
1029{
1030 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1031 struct p54u_priv *priv;
1032
1033 if (!dev)
1034 return -ENODEV;
1035
1036 priv = dev->priv;
1037 if (unlikely(!(priv->upload_fw && priv->fw)))
1038 return 0;
1039
1040 return priv->upload_fw(dev);
1041}
1042
1043static int p54u_post_reset(struct usb_interface *intf)
1044{
1045 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1046 struct p54u_priv *priv;
1047 int err;
1048
1049 err = p54u_resume(intf);
1050 if (err)
1051 return err;
1052
1053 /* reinitialize old device state */
1054 priv = dev->priv;
1055 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1056 ieee80211_restart_hw(dev);
1057
1058 return 0;
1059}
1060
1061#ifdef CONFIG_PM
1062
1063static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1064{
1065 return p54u_pre_reset(intf);
1066}
1067
1068#endif /* CONFIG_PM */
1069
1070static struct usb_driver p54u_driver = {
1071 .name = "p54usb",
1072 .id_table = p54u_table,
1073 .probe = p54u_probe,
1074 .disconnect = p54u_disconnect,
1075 .pre_reset = p54u_pre_reset,
1076 .post_reset = p54u_post_reset,
1077#ifdef CONFIG_PM
1078 .suspend = p54u_suspend,
1079 .resume = p54u_resume,
1080 .reset_resume = p54u_resume,
1081#endif /* CONFIG_PM */
1082 .soft_unbind = 1,
1083};
1084
1085static int __init p54u_init(void)
1086{
1087 return usb_register(&p54u_driver);
1088}
1089
1090static void __exit p54u_exit(void)
1091{
1092 usb_deregister(&p54u_driver);
1093}
1094
1095module_init(p54u_init);
1096module_exit(p54u_exit);
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/slab.h>
19#include <linux/firmware.h>
20#include <linux/etherdevice.h>
21#include <linux/delay.h>
22#include <linux/crc32.h>
23#include <linux/module.h>
24#include <net/mac80211.h>
25
26#include "p54.h"
27#include "lmac.h"
28#include "p54usb.h"
29
30MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
31MODULE_DESCRIPTION("Prism54 USB wireless driver");
32MODULE_LICENSE("GPL");
33MODULE_ALIAS("prism54usb");
34MODULE_FIRMWARE("isl3886usb");
35MODULE_FIRMWARE("isl3887usb");
36
37/*
38 * Note:
39 *
40 * Always update our wiki's device list (located at:
41 * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
42 * whenever you add a new device.
43 */
44
45static struct usb_device_id p54u_table[] = {
46 /* Version 1 devices (pci chip + net2280) */
47 {USB_DEVICE(0x0411, 0x0050)}, /* Buffalo WLI2-USB2-G54 */
48 {USB_DEVICE(0x045e, 0x00c2)}, /* Microsoft MN-710 */
49 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
50 {USB_DEVICE(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */
51 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
52 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
53 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
54 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
55 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
56 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
57 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
58 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
59 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
60 {USB_DEVICE(0x0bf8, 0x1007)}, /* Fujitsu E-5400 USB */
61 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
62 {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */
63 {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */
64 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
65 {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */
66 {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */
67 {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
68 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
69 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
70 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
71 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
72 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
73 {USB_DEVICE(0x2001, 0x3762)}, /* Conceptronic C54U */
74 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
75 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
76
77 /* Version 2 devices (3887) */
78 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
79 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
80 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
81 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
82 {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */
83 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
84 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
85 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
86 {USB_DEVICE(0x083a, 0xc501)}, /* Zoom Wireless-G 4410 */
87 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
88 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
89 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
90 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
91 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
92 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
93 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
94 * just noting it here for clarity */
95 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
96 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
97 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
98 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
99 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
100 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
101 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
102 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
103 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
104 {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */
105 {USB_DEVICE(0x1740, 0x1000)}, /* Senao NUB-350 */
106 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
107 {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */
108 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
109 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
110 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
111 {}
112};
113
114MODULE_DEVICE_TABLE(usb, p54u_table);
115
116static const struct {
117 u32 intf;
118 enum p54u_hw_type type;
119 const char *fw;
120 char hw[20];
121} p54u_fwlist[__NUM_P54U_HWTYPES] = {
122 {
123 .type = P54U_NET2280,
124 .intf = FW_LM86,
125 .fw = "isl3886usb",
126 .hw = "ISL3886 + net2280",
127 },
128 {
129 .type = P54U_3887,
130 .intf = FW_LM87,
131 .fw = "isl3887usb",
132 .hw = "ISL3887",
133 },
134};
135
136static void p54u_rx_cb(struct urb *urb)
137{
138 struct sk_buff *skb = (struct sk_buff *) urb->context;
139 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
140 struct ieee80211_hw *dev = info->dev;
141 struct p54u_priv *priv = dev->priv;
142
143 skb_unlink(skb, &priv->rx_queue);
144
145 if (unlikely(urb->status)) {
146 dev_kfree_skb_irq(skb);
147 return;
148 }
149
150 skb_put(skb, urb->actual_length);
151
152 if (priv->hw_type == P54U_NET2280)
153 skb_pull(skb, priv->common.tx_hdr_len);
154 if (priv->common.fw_interface == FW_LM87) {
155 skb_pull(skb, 4);
156 skb_put(skb, 4);
157 }
158
159 if (p54_rx(dev, skb)) {
160 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
161 if (unlikely(!skb)) {
162 /* TODO check rx queue length and refill *somewhere* */
163 return;
164 }
165
166 info = (struct p54u_rx_info *) skb->cb;
167 info->urb = urb;
168 info->dev = dev;
169 urb->transfer_buffer = skb_tail_pointer(skb);
170 urb->context = skb;
171 } else {
172 if (priv->hw_type == P54U_NET2280)
173 skb_push(skb, priv->common.tx_hdr_len);
174 if (priv->common.fw_interface == FW_LM87) {
175 skb_push(skb, 4);
176 skb_put(skb, 4);
177 }
178 skb_reset_tail_pointer(skb);
179 skb_trim(skb, 0);
180 urb->transfer_buffer = skb_tail_pointer(skb);
181 }
182 skb_queue_tail(&priv->rx_queue, skb);
183 usb_anchor_urb(urb, &priv->submitted);
184 if (usb_submit_urb(urb, GFP_ATOMIC)) {
185 skb_unlink(skb, &priv->rx_queue);
186 usb_unanchor_urb(urb);
187 dev_kfree_skb_irq(skb);
188 }
189}
190
191static void p54u_tx_cb(struct urb *urb)
192{
193 struct sk_buff *skb = urb->context;
194 struct ieee80211_hw *dev =
195 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
196
197 p54_free_skb(dev, skb);
198}
199
200static void p54u_tx_dummy_cb(struct urb *urb) { }
201
202static void p54u_free_urbs(struct ieee80211_hw *dev)
203{
204 struct p54u_priv *priv = dev->priv;
205 usb_kill_anchored_urbs(&priv->submitted);
206}
207
208static void p54u_stop(struct ieee80211_hw *dev)
209{
210 /*
211 * TODO: figure out how to reliably stop the 3887 and net2280 so
212 * the hardware is still usable next time we want to start it.
213 * until then, we just stop listening to the hardware..
214 */
215 p54u_free_urbs(dev);
216}
217
218static int p54u_init_urbs(struct ieee80211_hw *dev)
219{
220 struct p54u_priv *priv = dev->priv;
221 struct urb *entry = NULL;
222 struct sk_buff *skb;
223 struct p54u_rx_info *info;
224 int ret = 0;
225
226 while (skb_queue_len(&priv->rx_queue) < 32) {
227 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
228 if (!skb) {
229 ret = -ENOMEM;
230 goto err;
231 }
232 entry = usb_alloc_urb(0, GFP_KERNEL);
233 if (!entry) {
234 ret = -ENOMEM;
235 goto err;
236 }
237
238 usb_fill_bulk_urb(entry, priv->udev,
239 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
240 skb_tail_pointer(skb),
241 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
242 info = (struct p54u_rx_info *) skb->cb;
243 info->urb = entry;
244 info->dev = dev;
245 skb_queue_tail(&priv->rx_queue, skb);
246
247 usb_anchor_urb(entry, &priv->submitted);
248 ret = usb_submit_urb(entry, GFP_KERNEL);
249 if (ret) {
250 skb_unlink(skb, &priv->rx_queue);
251 usb_unanchor_urb(entry);
252 goto err;
253 }
254 usb_free_urb(entry);
255 entry = NULL;
256 }
257
258 return 0;
259
260 err:
261 usb_free_urb(entry);
262 kfree_skb(skb);
263 p54u_free_urbs(dev);
264 return ret;
265}
266
267static int p54u_open(struct ieee80211_hw *dev)
268{
269 /*
270 * TODO: Because we don't know how to reliably stop the 3887 and
271 * the isl3886+net2280, other than brutally cut off all
272 * communications. We have to reinitialize the urbs on every start.
273 */
274 return p54u_init_urbs(dev);
275}
276
277static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
278{
279 u32 chk = 0;
280
281 length >>= 2;
282 while (length--) {
283 chk ^= le32_to_cpu(*data++);
284 chk = (chk >> 5) ^ (chk << 3);
285 }
286
287 return cpu_to_le32(chk);
288}
289
290static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
291{
292 struct p54u_priv *priv = dev->priv;
293 struct urb *data_urb;
294 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
295
296 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
297 if (!data_urb) {
298 p54_free_skb(dev, skb);
299 return;
300 }
301
302 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
303 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
304
305 usb_fill_bulk_urb(data_urb, priv->udev,
306 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
307 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
308 p54u_tx_cb : p54u_tx_dummy_cb, skb);
309 data_urb->transfer_flags |= URB_ZERO_PACKET;
310
311 usb_anchor_urb(data_urb, &priv->submitted);
312 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
313 usb_unanchor_urb(data_urb);
314 p54_free_skb(dev, skb);
315 }
316 usb_free_urb(data_urb);
317}
318
319static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
320{
321 struct p54u_priv *priv = dev->priv;
322 struct urb *int_urb = NULL, *data_urb = NULL;
323 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
324 struct net2280_reg_write *reg = NULL;
325 int err = -ENOMEM;
326
327 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
328 if (!reg)
329 goto out;
330
331 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
332 if (!int_urb)
333 goto out;
334
335 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
336 if (!data_urb)
337 goto out;
338
339 reg->port = cpu_to_le16(NET2280_DEV_U32);
340 reg->addr = cpu_to_le32(P54U_DEV_BASE);
341 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
342
343 memset(hdr, 0, sizeof(*hdr));
344 hdr->len = cpu_to_le16(skb->len);
345 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
346
347 usb_fill_bulk_urb(int_urb, priv->udev,
348 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
349 p54u_tx_dummy_cb, dev);
350
351 /*
352 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
353 * free what is inside the transfer_buffer after the last reference to
354 * the int_urb is dropped.
355 */
356 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
357 reg = NULL;
358
359 usb_fill_bulk_urb(data_urb, priv->udev,
360 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
361 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
362 p54u_tx_cb : p54u_tx_dummy_cb, skb);
363 data_urb->transfer_flags |= URB_ZERO_PACKET;
364
365 usb_anchor_urb(int_urb, &priv->submitted);
366 err = usb_submit_urb(int_urb, GFP_ATOMIC);
367 if (err) {
368 usb_unanchor_urb(int_urb);
369 goto out;
370 }
371
372 usb_anchor_urb(data_urb, &priv->submitted);
373 err = usb_submit_urb(data_urb, GFP_ATOMIC);
374 if (err) {
375 usb_unanchor_urb(data_urb);
376 goto out;
377 }
378out:
379 usb_free_urb(int_urb);
380 usb_free_urb(data_urb);
381
382 if (err) {
383 kfree(reg);
384 p54_free_skb(dev, skb);
385 }
386}
387
388static int p54u_write(struct p54u_priv *priv,
389 struct net2280_reg_write *buf,
390 enum net2280_op_type type,
391 __le32 addr, __le32 val)
392{
393 unsigned int ep;
394 int alen;
395
396 if (type & 0x0800)
397 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
398 else
399 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
400
401 buf->port = cpu_to_le16(type);
402 buf->addr = addr;
403 buf->val = val;
404
405 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
406}
407
408static int p54u_read(struct p54u_priv *priv, void *buf,
409 enum net2280_op_type type,
410 __le32 addr, __le32 *val)
411{
412 struct net2280_reg_read *read = buf;
413 __le32 *reg = buf;
414 unsigned int ep;
415 int alen, err;
416
417 if (type & 0x0800)
418 ep = P54U_PIPE_DEV;
419 else
420 ep = P54U_PIPE_BRG;
421
422 read->port = cpu_to_le16(type);
423 read->addr = addr;
424
425 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
426 read, sizeof(*read), &alen, 1000);
427 if (err)
428 return err;
429
430 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
431 reg, sizeof(*reg), &alen, 1000);
432 if (err)
433 return err;
434
435 *val = *reg;
436 return 0;
437}
438
439static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
440 void *data, size_t len)
441{
442 int alen;
443 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
444 data, len, &alen, 2000);
445}
446
447static int p54u_device_reset(struct ieee80211_hw *dev)
448{
449 struct p54u_priv *priv = dev->priv;
450 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
451
452 if (lock) {
453 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
454 if (ret < 0) {
455 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
456 "device for reset (%d)!\n", ret);
457 return ret;
458 }
459 }
460
461 ret = usb_reset_device(priv->udev);
462 if (lock)
463 usb_unlock_device(priv->udev);
464
465 if (ret)
466 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
467 "device (%d)!\n", ret);
468
469 return ret;
470}
471
472static const char p54u_romboot_3887[] = "~~~~";
473static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
474{
475 struct p54u_priv *priv = dev->priv;
476 u8 *buf;
477 int ret;
478
479 buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
480 if (!buf)
481 return -ENOMEM;
482 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
483 buf, 4);
484 kfree(buf);
485 if (ret)
486 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
487 "boot ROM (%d)!\n", ret);
488
489 return ret;
490}
491
492static const char p54u_firmware_upload_3887[] = "<\r";
493static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
494{
495 struct p54u_priv *priv = dev->priv;
496 int err, alen;
497 u8 carry = 0;
498 u8 *buf, *tmp;
499 const u8 *data;
500 unsigned int left, remains, block_size;
501 struct x2_header *hdr;
502 unsigned long timeout;
503
504 err = p54u_firmware_reset_3887(dev);
505 if (err)
506 return err;
507
508 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
509 if (!buf) {
510 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
511 "upload buffer!\n");
512 return -ENOMEM;
513 }
514
515 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
516 strcpy(buf, p54u_firmware_upload_3887);
517 left -= strlen(p54u_firmware_upload_3887);
518 tmp += strlen(p54u_firmware_upload_3887);
519
520 data = priv->fw->data;
521 remains = priv->fw->size;
522
523 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
524 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
525 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
526 hdr->fw_length = cpu_to_le32(priv->fw->size);
527 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
528 sizeof(u32)*2));
529 left -= sizeof(*hdr);
530 tmp += sizeof(*hdr);
531
532 while (remains) {
533 while (left--) {
534 if (carry) {
535 *tmp++ = carry;
536 carry = 0;
537 remains--;
538 continue;
539 }
540 switch (*data) {
541 case '~':
542 *tmp++ = '}';
543 carry = '^';
544 break;
545 case '}':
546 *tmp++ = '}';
547 carry = ']';
548 break;
549 default:
550 *tmp++ = *data;
551 remains--;
552 break;
553 }
554 data++;
555 }
556
557 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
558 if (err) {
559 dev_err(&priv->udev->dev, "(p54usb) firmware "
560 "upload failed!\n");
561 goto err_upload_failed;
562 }
563
564 tmp = buf;
565 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
566 }
567
568 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
569 priv->fw->size));
570 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
571 if (err) {
572 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
573 goto err_upload_failed;
574 }
575 timeout = jiffies + msecs_to_jiffies(1000);
576 while (!(err = usb_bulk_msg(priv->udev,
577 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
578 if (alen > 2 && !memcmp(buf, "OK", 2))
579 break;
580
581 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
582 err = -EINVAL;
583 break;
584 }
585
586 if (time_after(jiffies, timeout)) {
587 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
588 "timed out!\n");
589 err = -ETIMEDOUT;
590 break;
591 }
592 }
593 if (err) {
594 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
595 goto err_upload_failed;
596 }
597
598 buf[0] = 'g';
599 buf[1] = '\r';
600 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
601 if (err) {
602 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
603 goto err_upload_failed;
604 }
605
606 timeout = jiffies + msecs_to_jiffies(1000);
607 while (!(err = usb_bulk_msg(priv->udev,
608 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
609 if (alen > 0 && buf[0] == 'g')
610 break;
611
612 if (time_after(jiffies, timeout)) {
613 err = -ETIMEDOUT;
614 break;
615 }
616 }
617 if (err)
618 goto err_upload_failed;
619
620err_upload_failed:
621 kfree(buf);
622 return err;
623}
624
625static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
626{
627 struct p54u_priv *priv = dev->priv;
628 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
629 int err, alen;
630 void *buf;
631 __le32 reg;
632 unsigned int remains, offset;
633 const u8 *data;
634
635 buf = kmalloc(512, GFP_KERNEL);
636 if (!buf) {
637 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
638 "alloc failed!\n");
639 return -ENOMEM;
640 }
641
642#define P54U_WRITE(type, addr, data) \
643 do {\
644 err = p54u_write(priv, buf, type,\
645 cpu_to_le32((u32)(unsigned long)addr), data);\
646 if (err) \
647 goto fail;\
648 } while (0)
649
650#define P54U_READ(type, addr) \
651 do {\
652 err = p54u_read(priv, buf, type,\
653 cpu_to_le32((u32)(unsigned long)addr), ®);\
654 if (err)\
655 goto fail;\
656 } while (0)
657
658 /* power down net2280 bridge */
659 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
660 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
661 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
662 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
663
664 mdelay(100);
665
666 /* power up bridge */
667 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
668 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
669 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
670
671 mdelay(100);
672
673 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
674 cpu_to_le32(NET2280_CLK_30Mhz |
675 NET2280_PCI_ENABLE |
676 NET2280_PCI_SOFT_RESET));
677
678 mdelay(20);
679
680 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
681 cpu_to_le32(PCI_COMMAND_MEMORY |
682 PCI_COMMAND_MASTER));
683
684 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
685 cpu_to_le32(NET2280_BASE));
686
687 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
688 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
689 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
690
691 // TODO: we really need this?
692 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
693
694 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
695 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
696 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
697 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
698
699 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
700 cpu_to_le32(NET2280_BASE2));
701
702 /* finally done setting up the bridge */
703
704 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
705 cpu_to_le32(PCI_COMMAND_MEMORY |
706 PCI_COMMAND_MASTER));
707
708 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
709 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
710 cpu_to_le32(P54U_DEV_BASE));
711
712 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
713 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
714 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
715
716 /* do romboot */
717 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
718
719 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
720 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
721 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
722 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
723 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
724
725 mdelay(20);
726
727 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
728 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
729
730 mdelay(20);
731
732 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
733 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
734
735 mdelay(100);
736
737 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
738 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
739
740 /* finally, we can upload firmware now! */
741 remains = priv->fw->size;
742 data = priv->fw->data;
743 offset = ISL38XX_DEV_FIRMWARE_ADDR;
744
745 while (remains) {
746 unsigned int block_len = min(remains, (unsigned int)512);
747 memcpy(buf, data, block_len);
748
749 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
750 if (err) {
751 dev_err(&priv->udev->dev, "(p54usb) firmware block "
752 "upload failed\n");
753 goto fail;
754 }
755
756 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
757 cpu_to_le32(0xc0000f00));
758
759 P54U_WRITE(NET2280_DEV_U32,
760 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
761 P54U_WRITE(NET2280_DEV_U32,
762 0x0020 | (unsigned long)&devreg->direct_mem_win,
763 cpu_to_le32(1));
764
765 P54U_WRITE(NET2280_DEV_U32,
766 0x0024 | (unsigned long)&devreg->direct_mem_win,
767 cpu_to_le32(block_len));
768 P54U_WRITE(NET2280_DEV_U32,
769 0x0028 | (unsigned long)&devreg->direct_mem_win,
770 cpu_to_le32(offset));
771
772 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
773 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
774 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
775 cpu_to_le32(block_len >> 2));
776 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
777 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
778
779 mdelay(10);
780
781 P54U_READ(NET2280_DEV_U32,
782 0x002C | (unsigned long)&devreg->direct_mem_win);
783 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
784 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
785 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
786 "transfer failed\n");
787 goto fail;
788 }
789
790 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
791 cpu_to_le32(NET2280_FIFO_FLUSH));
792
793 remains -= block_len;
794 data += block_len;
795 offset += block_len;
796 }
797
798 /* do ramboot */
799 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
800 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
801 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
802 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
803 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
804
805 mdelay(20);
806
807 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
808 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
809
810 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
811 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
812
813 mdelay(100);
814
815 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
816 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
817
818 /* start up the firmware */
819 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
820 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
821
822 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
823 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
824
825 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
826 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
827 NET2280_USB_INTERRUPT_ENABLE));
828
829 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
830 cpu_to_le32(ISL38XX_DEV_INT_RESET));
831
832 err = usb_interrupt_msg(priv->udev,
833 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
834 buf, sizeof(__le32), &alen, 1000);
835 if (err || alen != sizeof(__le32))
836 goto fail;
837
838 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
839 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
840
841 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
842 err = -EINVAL;
843
844 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
845 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
846 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
847
848#undef P54U_WRITE
849#undef P54U_READ
850
851fail:
852 kfree(buf);
853 return err;
854}
855
856static int p54_find_type(struct p54u_priv *priv)
857{
858 int i;
859
860 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
861 if (p54u_fwlist[i].type == priv->hw_type)
862 break;
863 if (i == __NUM_P54U_HWTYPES)
864 return -EOPNOTSUPP;
865
866 return i;
867}
868
869static int p54u_start_ops(struct p54u_priv *priv)
870{
871 struct ieee80211_hw *dev = priv->common.hw;
872 int ret;
873
874 ret = p54_parse_firmware(dev, priv->fw);
875 if (ret)
876 goto err_out;
877
878 ret = p54_find_type(priv);
879 if (ret < 0)
880 goto err_out;
881
882 if (priv->common.fw_interface != p54u_fwlist[ret].intf) {
883 dev_err(&priv->udev->dev, "wrong firmware, please get "
884 "a firmware for \"%s\" and try again.\n",
885 p54u_fwlist[ret].hw);
886 ret = -ENODEV;
887 goto err_out;
888 }
889
890 ret = priv->upload_fw(dev);
891 if (ret)
892 goto err_out;
893
894 ret = p54u_open(dev);
895 if (ret)
896 goto err_out;
897
898 ret = p54_read_eeprom(dev);
899 if (ret)
900 goto err_stop;
901
902 p54u_stop(dev);
903
904 ret = p54_register_common(dev, &priv->udev->dev);
905 if (ret)
906 goto err_stop;
907
908 return 0;
909
910err_stop:
911 p54u_stop(dev);
912
913err_out:
914 /*
915 * p54u_disconnect will do the rest of the
916 * cleanup
917 */
918 return ret;
919}
920
921static void p54u_load_firmware_cb(const struct firmware *firmware,
922 void *context)
923{
924 struct p54u_priv *priv = context;
925 struct usb_device *udev = priv->udev;
926 int err;
927
928 complete(&priv->fw_wait_load);
929 if (firmware) {
930 priv->fw = firmware;
931 err = p54u_start_ops(priv);
932 } else {
933 err = -ENOENT;
934 dev_err(&udev->dev, "Firmware not found.\n");
935 }
936
937 if (err) {
938 struct device *parent = priv->udev->dev.parent;
939
940 dev_err(&udev->dev, "failed to initialize device (%d)\n", err);
941
942 if (parent)
943 device_lock(parent);
944
945 device_release_driver(&udev->dev);
946 /*
947 * At this point p54u_disconnect has already freed
948 * the "priv" context. Do not use it anymore!
949 */
950 priv = NULL;
951
952 if (parent)
953 device_unlock(parent);
954 }
955
956 usb_put_dev(udev);
957}
958
959static int p54u_load_firmware(struct ieee80211_hw *dev,
960 struct usb_interface *intf)
961{
962 struct usb_device *udev = interface_to_usbdev(intf);
963 struct p54u_priv *priv = dev->priv;
964 struct device *device = &udev->dev;
965 int err, i;
966
967 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
968
969 init_completion(&priv->fw_wait_load);
970 i = p54_find_type(priv);
971 if (i < 0)
972 return i;
973
974 dev_info(&priv->udev->dev, "Loading firmware file %s\n",
975 p54u_fwlist[i].fw);
976
977 usb_get_dev(udev);
978 err = request_firmware_nowait(THIS_MODULE, 1, p54u_fwlist[i].fw,
979 device, GFP_KERNEL, priv,
980 p54u_load_firmware_cb);
981 if (err) {
982 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
983 "(%d)!\n", p54u_fwlist[i].fw, err);
984 }
985
986 return err;
987}
988
989static int __devinit p54u_probe(struct usb_interface *intf,
990 const struct usb_device_id *id)
991{
992 struct usb_device *udev = interface_to_usbdev(intf);
993 struct ieee80211_hw *dev;
994 struct p54u_priv *priv;
995 int err;
996 unsigned int i, recognized_pipes;
997
998 dev = p54_init_common(sizeof(*priv));
999
1000 if (!dev) {
1001 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
1002 return -ENOMEM;
1003 }
1004
1005 priv = dev->priv;
1006 priv->hw_type = P54U_INVALID_HW;
1007
1008 SET_IEEE80211_DEV(dev, &intf->dev);
1009 usb_set_intfdata(intf, dev);
1010 priv->udev = udev;
1011 priv->intf = intf;
1012 skb_queue_head_init(&priv->rx_queue);
1013 init_usb_anchor(&priv->submitted);
1014
1015 usb_get_dev(udev);
1016
1017 /* really lazy and simple way of figuring out if we're a 3887 */
1018 /* TODO: should just stick the identification in the device table */
1019 i = intf->altsetting->desc.bNumEndpoints;
1020 recognized_pipes = 0;
1021 while (i--) {
1022 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
1023 case P54U_PIPE_DATA:
1024 case P54U_PIPE_MGMT:
1025 case P54U_PIPE_BRG:
1026 case P54U_PIPE_DEV:
1027 case P54U_PIPE_DATA | USB_DIR_IN:
1028 case P54U_PIPE_MGMT | USB_DIR_IN:
1029 case P54U_PIPE_BRG | USB_DIR_IN:
1030 case P54U_PIPE_DEV | USB_DIR_IN:
1031 case P54U_PIPE_INT | USB_DIR_IN:
1032 recognized_pipes++;
1033 }
1034 }
1035 priv->common.open = p54u_open;
1036 priv->common.stop = p54u_stop;
1037 if (recognized_pipes < P54U_PIPE_NUMBER) {
1038#ifdef CONFIG_PM
1039 /* ISL3887 needs a full reset on resume */
1040 udev->reset_resume = 1;
1041#endif /* CONFIG_PM */
1042 err = p54u_device_reset(dev);
1043
1044 priv->hw_type = P54U_3887;
1045 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
1046 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
1047 priv->common.tx = p54u_tx_lm87;
1048 priv->upload_fw = p54u_upload_firmware_3887;
1049 } else {
1050 priv->hw_type = P54U_NET2280;
1051 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
1052 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
1053 priv->common.tx = p54u_tx_net2280;
1054 priv->upload_fw = p54u_upload_firmware_net2280;
1055 }
1056 err = p54u_load_firmware(dev, intf);
1057 return err;
1058}
1059
1060static void __devexit p54u_disconnect(struct usb_interface *intf)
1061{
1062 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1063 struct p54u_priv *priv;
1064
1065 if (!dev)
1066 return;
1067
1068 priv = dev->priv;
1069 wait_for_completion(&priv->fw_wait_load);
1070 p54_unregister_common(dev);
1071
1072 usb_put_dev(interface_to_usbdev(intf));
1073 release_firmware(priv->fw);
1074 p54_free_common(dev);
1075}
1076
1077static int p54u_pre_reset(struct usb_interface *intf)
1078{
1079 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1080
1081 if (!dev)
1082 return -ENODEV;
1083
1084 p54u_stop(dev);
1085 return 0;
1086}
1087
1088static int p54u_resume(struct usb_interface *intf)
1089{
1090 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1091 struct p54u_priv *priv;
1092
1093 if (!dev)
1094 return -ENODEV;
1095
1096 priv = dev->priv;
1097 if (unlikely(!(priv->upload_fw && priv->fw)))
1098 return 0;
1099
1100 return priv->upload_fw(dev);
1101}
1102
1103static int p54u_post_reset(struct usb_interface *intf)
1104{
1105 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1106 struct p54u_priv *priv;
1107 int err;
1108
1109 err = p54u_resume(intf);
1110 if (err)
1111 return err;
1112
1113 /* reinitialize old device state */
1114 priv = dev->priv;
1115 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1116 ieee80211_restart_hw(dev);
1117
1118 return 0;
1119}
1120
1121#ifdef CONFIG_PM
1122
1123static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1124{
1125 return p54u_pre_reset(intf);
1126}
1127
1128#endif /* CONFIG_PM */
1129
1130static struct usb_driver p54u_driver = {
1131 .name = "p54usb",
1132 .id_table = p54u_table,
1133 .probe = p54u_probe,
1134 .disconnect = __devexit_p(p54u_disconnect),
1135 .pre_reset = p54u_pre_reset,
1136 .post_reset = p54u_post_reset,
1137#ifdef CONFIG_PM
1138 .suspend = p54u_suspend,
1139 .resume = p54u_resume,
1140 .reset_resume = p54u_resume,
1141#endif /* CONFIG_PM */
1142 .soft_unbind = 1,
1143 .disable_hub_initiated_lpm = 1,
1144};
1145
1146module_usb_driver(p54u_driver);