3 * Linux device driver for USB based Prism54
5 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
7 * Based on the islsm (softmac prism54) driver, which is:
8 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
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.
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>
29 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
30 MODULE_DESCRIPTION("Prism54 USB wireless driver");
31 MODULE_LICENSE("GPL");
32 MODULE_ALIAS("prism54usb");
33 MODULE_FIRMWARE("isl3886usb");
34 MODULE_FIRMWARE("isl3887usb");
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.
44 static 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(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
60 {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */
61 {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */
62 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
63 {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */
64 {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */
65 {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
66 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
67 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
68 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
69 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
70 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
71 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
72 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
74 /* Version 2 devices (3887) */
75 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
76 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
77 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
78 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
79 {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */
80 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
81 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
82 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
83 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
84 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
85 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
86 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
87 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
88 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
89 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
90 * just noting it here for clarity */
91 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
92 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
93 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
94 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
95 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
96 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
97 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
98 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
99 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
100 {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */
101 {USB_DEVICE(0x1740, 0x1000)}, /* Senao NUB-350 */
102 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
103 {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */
104 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
105 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
106 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
110 MODULE_DEVICE_TABLE(usb
, p54u_table
);
112 static const struct {
114 enum p54u_hw_type type
;
116 const char *fw_legacy
;
118 } p54u_fwlist
[__NUM_P54U_HWTYPES
] = {
120 .type
= P54U_NET2280
,
123 .fw_legacy
= "isl3890usb",
124 .hw
= "ISL3886 + net2280",
130 .fw_legacy
= "isl3887usb_bare",
135 static void p54u_rx_cb(struct urb
*urb
)
137 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
138 struct p54u_rx_info
*info
= (struct p54u_rx_info
*)skb
->cb
;
139 struct ieee80211_hw
*dev
= info
->dev
;
140 struct p54u_priv
*priv
= dev
->priv
;
142 skb_unlink(skb
, &priv
->rx_queue
);
144 if (unlikely(urb
->status
)) {
145 dev_kfree_skb_irq(skb
);
149 skb_put(skb
, urb
->actual_length
);
151 if (priv
->hw_type
== P54U_NET2280
)
152 skb_pull(skb
, priv
->common
.tx_hdr_len
);
153 if (priv
->common
.fw_interface
== FW_LM87
) {
158 if (p54_rx(dev
, skb
)) {
159 skb
= dev_alloc_skb(priv
->common
.rx_mtu
+ 32);
160 if (unlikely(!skb
)) {
161 /* TODO check rx queue length and refill *somewhere* */
165 info
= (struct p54u_rx_info
*) skb
->cb
;
168 urb
->transfer_buffer
= skb_tail_pointer(skb
);
171 if (priv
->hw_type
== P54U_NET2280
)
172 skb_push(skb
, priv
->common
.tx_hdr_len
);
173 if (priv
->common
.fw_interface
== FW_LM87
) {
177 skb_reset_tail_pointer(skb
);
179 urb
->transfer_buffer
= skb_tail_pointer(skb
);
181 skb_queue_tail(&priv
->rx_queue
, skb
);
182 usb_anchor_urb(urb
, &priv
->submitted
);
183 if (usb_submit_urb(urb
, GFP_ATOMIC
)) {
184 skb_unlink(skb
, &priv
->rx_queue
);
185 usb_unanchor_urb(urb
);
186 dev_kfree_skb_irq(skb
);
190 static void p54u_tx_cb(struct urb
*urb
)
192 struct sk_buff
*skb
= urb
->context
;
193 struct ieee80211_hw
*dev
=
194 usb_get_intfdata(usb_ifnum_to_if(urb
->dev
, 0));
196 p54_free_skb(dev
, skb
);
199 static void p54u_tx_dummy_cb(struct urb
*urb
) { }
201 static void p54u_free_urbs(struct ieee80211_hw
*dev
)
203 struct p54u_priv
*priv
= dev
->priv
;
204 usb_kill_anchored_urbs(&priv
->submitted
);
207 static int p54u_init_urbs(struct ieee80211_hw
*dev
)
209 struct p54u_priv
*priv
= dev
->priv
;
210 struct urb
*entry
= NULL
;
212 struct p54u_rx_info
*info
;
215 while (skb_queue_len(&priv
->rx_queue
) < 32) {
216 skb
= __dev_alloc_skb(priv
->common
.rx_mtu
+ 32, GFP_KERNEL
);
221 entry
= usb_alloc_urb(0, GFP_KERNEL
);
227 usb_fill_bulk_urb(entry
, priv
->udev
,
228 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
229 skb_tail_pointer(skb
),
230 priv
->common
.rx_mtu
+ 32, p54u_rx_cb
, skb
);
231 info
= (struct p54u_rx_info
*) skb
->cb
;
234 skb_queue_tail(&priv
->rx_queue
, skb
);
236 usb_anchor_urb(entry
, &priv
->submitted
);
237 ret
= usb_submit_urb(entry
, GFP_KERNEL
);
239 skb_unlink(skb
, &priv
->rx_queue
);
240 usb_unanchor_urb(entry
);
256 static __le32
p54u_lm87_chksum(const __le32
*data
, size_t length
)
262 chk
^= le32_to_cpu(*data
++);
263 chk
= (chk
>> 5) ^ (chk
<< 3);
266 return cpu_to_le32(chk
);
269 static void p54u_tx_lm87(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
271 struct p54u_priv
*priv
= dev
->priv
;
272 struct urb
*data_urb
;
273 struct lm87_tx_hdr
*hdr
= (void *)skb
->data
- sizeof(*hdr
);
275 data_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
277 p54_free_skb(dev
, skb
);
281 hdr
->chksum
= p54u_lm87_chksum((__le32
*)skb
->data
, skb
->len
);
282 hdr
->device_addr
= ((struct p54_hdr
*)skb
->data
)->req_id
;
284 usb_fill_bulk_urb(data_urb
, priv
->udev
,
285 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
286 hdr
, skb
->len
+ sizeof(*hdr
), FREE_AFTER_TX(skb
) ?
287 p54u_tx_cb
: p54u_tx_dummy_cb
, skb
);
288 data_urb
->transfer_flags
|= URB_ZERO_PACKET
;
290 usb_anchor_urb(data_urb
, &priv
->submitted
);
291 if (usb_submit_urb(data_urb
, GFP_ATOMIC
)) {
292 usb_unanchor_urb(data_urb
);
293 p54_free_skb(dev
, skb
);
295 usb_free_urb(data_urb
);
298 static void p54u_tx_net2280(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
300 struct p54u_priv
*priv
= dev
->priv
;
301 struct urb
*int_urb
= NULL
, *data_urb
= NULL
;
302 struct net2280_tx_hdr
*hdr
= (void *)skb
->data
- sizeof(*hdr
);
303 struct net2280_reg_write
*reg
= NULL
;
306 reg
= kmalloc(sizeof(*reg
), GFP_ATOMIC
);
310 int_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
314 data_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
318 reg
->port
= cpu_to_le16(NET2280_DEV_U32
);
319 reg
->addr
= cpu_to_le32(P54U_DEV_BASE
);
320 reg
->val
= cpu_to_le32(ISL38XX_DEV_INT_DATA
);
322 memset(hdr
, 0, sizeof(*hdr
));
323 hdr
->len
= cpu_to_le16(skb
->len
);
324 hdr
->device_addr
= ((struct p54_hdr
*) skb
->data
)->req_id
;
326 usb_fill_bulk_urb(int_urb
, priv
->udev
,
327 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DEV
), reg
, sizeof(*reg
),
328 p54u_tx_dummy_cb
, dev
);
331 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
332 * free what is inside the transfer_buffer after the last reference to
333 * the int_urb is dropped.
335 int_urb
->transfer_flags
|= URB_FREE_BUFFER
| URB_ZERO_PACKET
;
338 usb_fill_bulk_urb(data_urb
, priv
->udev
,
339 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
340 hdr
, skb
->len
+ sizeof(*hdr
), FREE_AFTER_TX(skb
) ?
341 p54u_tx_cb
: p54u_tx_dummy_cb
, skb
);
342 data_urb
->transfer_flags
|= URB_ZERO_PACKET
;
344 usb_anchor_urb(int_urb
, &priv
->submitted
);
345 err
= usb_submit_urb(int_urb
, GFP_ATOMIC
);
347 usb_unanchor_urb(int_urb
);
351 usb_anchor_urb(data_urb
, &priv
->submitted
);
352 err
= usb_submit_urb(data_urb
, GFP_ATOMIC
);
354 usb_unanchor_urb(data_urb
);
358 usb_free_urb(int_urb
);
359 usb_free_urb(data_urb
);
363 p54_free_skb(dev
, skb
);
367 static int p54u_write(struct p54u_priv
*priv
,
368 struct net2280_reg_write
*buf
,
369 enum net2280_op_type type
,
370 __le32 addr
, __le32 val
)
376 ep
= usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DEV
);
378 ep
= usb_sndbulkpipe(priv
->udev
, P54U_PIPE_BRG
);
380 buf
->port
= cpu_to_le16(type
);
384 return usb_bulk_msg(priv
->udev
, ep
, buf
, sizeof(*buf
), &alen
, 1000);
387 static int p54u_read(struct p54u_priv
*priv
, void *buf
,
388 enum net2280_op_type type
,
389 __le32 addr
, __le32
*val
)
391 struct net2280_reg_read
*read
= buf
;
401 read
->port
= cpu_to_le16(type
);
404 err
= usb_bulk_msg(priv
->udev
, usb_sndbulkpipe(priv
->udev
, ep
),
405 read
, sizeof(*read
), &alen
, 1000);
409 err
= usb_bulk_msg(priv
->udev
, usb_rcvbulkpipe(priv
->udev
, ep
),
410 reg
, sizeof(*reg
), &alen
, 1000);
418 static int p54u_bulk_msg(struct p54u_priv
*priv
, unsigned int ep
,
419 void *data
, size_t len
)
422 return usb_bulk_msg(priv
->udev
, usb_sndbulkpipe(priv
->udev
, ep
),
423 data
, len
, &alen
, 2000);
426 static int p54u_device_reset(struct ieee80211_hw
*dev
)
428 struct p54u_priv
*priv
= dev
->priv
;
429 int ret
, lock
= (priv
->intf
->condition
!= USB_INTERFACE_BINDING
);
432 ret
= usb_lock_device_for_reset(priv
->udev
, priv
->intf
);
434 dev_err(&priv
->udev
->dev
, "(p54usb) unable to lock "
435 "device for reset (%d)!\n", ret
);
440 ret
= usb_reset_device(priv
->udev
);
442 usb_unlock_device(priv
->udev
);
445 dev_err(&priv
->udev
->dev
, "(p54usb) unable to reset "
446 "device (%d)!\n", ret
);
451 static const char p54u_romboot_3887
[] = "~~~~";
452 static int p54u_firmware_reset_3887(struct ieee80211_hw
*dev
)
454 struct p54u_priv
*priv
= dev
->priv
;
458 buf
= kmemdup(p54u_romboot_3887
, 4, GFP_KERNEL
);
461 ret
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
,
465 dev_err(&priv
->udev
->dev
, "(p54usb) unable to jump to "
466 "boot ROM (%d)!\n", ret
);
471 static const char p54u_firmware_upload_3887
[] = "<\r";
472 static int p54u_upload_firmware_3887(struct ieee80211_hw
*dev
)
474 struct p54u_priv
*priv
= dev
->priv
;
479 unsigned int left
, remains
, block_size
;
480 struct x2_header
*hdr
;
481 unsigned long timeout
;
483 err
= p54u_firmware_reset_3887(dev
);
487 tmp
= buf
= kmalloc(P54U_FW_BLOCK
, GFP_KERNEL
);
489 dev_err(&priv
->udev
->dev
, "(p54usb) cannot allocate firmware"
494 left
= block_size
= min((size_t)P54U_FW_BLOCK
, priv
->fw
->size
);
495 strcpy(buf
, p54u_firmware_upload_3887
);
496 left
-= strlen(p54u_firmware_upload_3887
);
497 tmp
+= strlen(p54u_firmware_upload_3887
);
499 data
= priv
->fw
->data
;
500 remains
= priv
->fw
->size
;
502 hdr
= (struct x2_header
*)(buf
+ strlen(p54u_firmware_upload_3887
));
503 memcpy(hdr
->signature
, X2_SIGNATURE
, X2_SIGNATURE_SIZE
);
504 hdr
->fw_load_addr
= cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR
);
505 hdr
->fw_length
= cpu_to_le32(priv
->fw
->size
);
506 hdr
->crc
= cpu_to_le32(~crc32_le(~0, (void *)&hdr
->fw_load_addr
,
508 left
-= sizeof(*hdr
);
536 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, block_size
);
538 dev_err(&priv
->udev
->dev
, "(p54usb) firmware "
540 goto err_upload_failed
;
544 left
= block_size
= min((unsigned int)P54U_FW_BLOCK
, remains
);
547 *((__le32
*)buf
) = cpu_to_le32(~crc32_le(~0, priv
->fw
->data
,
549 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, sizeof(u32
));
551 dev_err(&priv
->udev
->dev
, "(p54usb) firmware upload failed!\n");
552 goto err_upload_failed
;
554 timeout
= jiffies
+ msecs_to_jiffies(1000);
555 while (!(err
= usb_bulk_msg(priv
->udev
,
556 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
), buf
, 128, &alen
, 1000))) {
557 if (alen
> 2 && !memcmp(buf
, "OK", 2))
560 if (alen
> 5 && !memcmp(buf
, "ERROR", 5)) {
565 if (time_after(jiffies
, timeout
)) {
566 dev_err(&priv
->udev
->dev
, "(p54usb) firmware boot "
573 dev_err(&priv
->udev
->dev
, "(p54usb) firmware upload failed!\n");
574 goto err_upload_failed
;
579 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, 2);
581 dev_err(&priv
->udev
->dev
, "(p54usb) firmware boot failed!\n");
582 goto err_upload_failed
;
585 timeout
= jiffies
+ msecs_to_jiffies(1000);
586 while (!(err
= usb_bulk_msg(priv
->udev
,
587 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
), buf
, 128, &alen
, 1000))) {
588 if (alen
> 0 && buf
[0] == 'g')
591 if (time_after(jiffies
, timeout
)) {
597 goto err_upload_failed
;
604 static int p54u_upload_firmware_net2280(struct ieee80211_hw
*dev
)
606 struct p54u_priv
*priv
= dev
->priv
;
607 const struct p54p_csr
*devreg
= (const struct p54p_csr
*) P54U_DEV_BASE
;
611 unsigned int remains
, offset
;
614 buf
= kmalloc(512, GFP_KERNEL
);
616 dev_err(&priv
->udev
->dev
, "(p54usb) firmware buffer "
621 #define P54U_WRITE(type, addr, data) \
623 err = p54u_write(priv, buf, type,\
624 cpu_to_le32((u32)(unsigned long)addr), data);\
629 #define P54U_READ(type, addr) \
631 err = p54u_read(priv, buf, type,\
632 cpu_to_le32((u32)(unsigned long)addr), ®);\
637 /* power down net2280 bridge */
638 P54U_READ(NET2280_BRG_U32
, NET2280_GPIOCTL
);
639 reg
|= cpu_to_le32(P54U_BRG_POWER_DOWN
);
640 reg
&= cpu_to_le32(~P54U_BRG_POWER_UP
);
641 P54U_WRITE(NET2280_BRG_U32
, NET2280_GPIOCTL
, reg
);
645 /* power up bridge */
646 reg
|= cpu_to_le32(P54U_BRG_POWER_UP
);
647 reg
&= cpu_to_le32(~P54U_BRG_POWER_DOWN
);
648 P54U_WRITE(NET2280_BRG_U32
, NET2280_GPIOCTL
, reg
);
652 P54U_WRITE(NET2280_BRG_U32
, NET2280_DEVINIT
,
653 cpu_to_le32(NET2280_CLK_30Mhz
|
655 NET2280_PCI_SOFT_RESET
));
659 P54U_WRITE(NET2280_BRG_CFG_U16
, PCI_COMMAND
,
660 cpu_to_le32(PCI_COMMAND_MEMORY
|
661 PCI_COMMAND_MASTER
));
663 P54U_WRITE(NET2280_BRG_CFG_U32
, PCI_BASE_ADDRESS_0
,
664 cpu_to_le32(NET2280_BASE
));
666 P54U_READ(NET2280_BRG_CFG_U16
, PCI_STATUS
);
667 reg
|= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT
);
668 P54U_WRITE(NET2280_BRG_CFG_U16
, PCI_STATUS
, reg
);
670 // TODO: we really need this?
671 P54U_READ(NET2280_BRG_U32
, NET2280_RELNUM
);
673 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPA_RSP
,
674 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE
));
675 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPC_RSP
,
676 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE
));
678 P54U_WRITE(NET2280_BRG_CFG_U32
, PCI_BASE_ADDRESS_2
,
679 cpu_to_le32(NET2280_BASE2
));
681 /* finally done setting up the bridge */
683 P54U_WRITE(NET2280_DEV_CFG_U16
, 0x10000 | PCI_COMMAND
,
684 cpu_to_le32(PCI_COMMAND_MEMORY
|
685 PCI_COMMAND_MASTER
));
687 P54U_WRITE(NET2280_DEV_CFG_U16
, 0x10000 | 0x40 /* TRDY timeout */, 0);
688 P54U_WRITE(NET2280_DEV_CFG_U32
, 0x10000 | PCI_BASE_ADDRESS_0
,
689 cpu_to_le32(P54U_DEV_BASE
));
691 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
, 0);
692 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
693 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
696 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_enable
, 0);
698 P54U_READ(NET2280_DEV_U32
, &devreg
->ctrl_stat
);
699 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
700 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT
);
701 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
702 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
706 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
707 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
711 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
712 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
716 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
717 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
719 /* finally, we can upload firmware now! */
720 remains
= priv
->fw
->size
;
721 data
= priv
->fw
->data
;
722 offset
= ISL38XX_DEV_FIRMWARE_ADDR
;
725 unsigned int block_len
= min(remains
, (unsigned int)512);
726 memcpy(buf
, data
, block_len
);
728 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, block_len
);
730 dev_err(&priv
->udev
->dev
, "(p54usb) firmware block "
735 P54U_WRITE(NET2280_DEV_U32
, &devreg
->direct_mem_base
,
736 cpu_to_le32(0xc0000f00));
738 P54U_WRITE(NET2280_DEV_U32
,
739 0x0020 | (unsigned long)&devreg
->direct_mem_win
, 0);
740 P54U_WRITE(NET2280_DEV_U32
,
741 0x0020 | (unsigned long)&devreg
->direct_mem_win
,
744 P54U_WRITE(NET2280_DEV_U32
,
745 0x0024 | (unsigned long)&devreg
->direct_mem_win
,
746 cpu_to_le32(block_len
));
747 P54U_WRITE(NET2280_DEV_U32
,
748 0x0028 | (unsigned long)&devreg
->direct_mem_win
,
749 cpu_to_le32(offset
));
751 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_addr
,
752 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR
));
753 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_len
,
754 cpu_to_le32(block_len
>> 2));
755 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_ctrl
,
756 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER
));
760 P54U_READ(NET2280_DEV_U32
,
761 0x002C | (unsigned long)&devreg
->direct_mem_win
);
762 if (!(reg
& cpu_to_le32(ISL38XX_DMA_STATUS_DONE
)) ||
763 !(reg
& cpu_to_le32(ISL38XX_DMA_STATUS_READY
))) {
764 dev_err(&priv
->udev
->dev
, "(p54usb) firmware DMA "
765 "transfer failed\n");
769 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPA_STAT
,
770 cpu_to_le32(NET2280_FIFO_FLUSH
));
772 remains
-= block_len
;
778 P54U_READ(NET2280_DEV_U32
, &devreg
->ctrl_stat
);
779 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
780 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
781 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT
);
782 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
786 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
787 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
789 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
790 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
794 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
795 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
797 /* start up the firmware */
798 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_enable
,
799 cpu_to_le32(ISL38XX_INT_IDENT_INIT
));
801 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
802 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
804 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
,
805 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE
|
806 NET2280_USB_INTERRUPT_ENABLE
));
808 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dev_int
,
809 cpu_to_le32(ISL38XX_DEV_INT_RESET
));
811 err
= usb_interrupt_msg(priv
->udev
,
812 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_INT
),
813 buf
, sizeof(__le32
), &alen
, 1000);
814 if (err
|| alen
!= sizeof(__le32
))
817 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
818 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
820 if (!(reg
& cpu_to_le32(ISL38XX_INT_IDENT_INIT
)))
823 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
, 0);
824 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
825 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
835 static int p54u_load_firmware(struct ieee80211_hw
*dev
)
837 struct p54u_priv
*priv
= dev
->priv
;
840 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist
) != __NUM_P54U_HWTYPES
);
842 for (i
= 0; i
< __NUM_P54U_HWTYPES
; i
++)
843 if (p54u_fwlist
[i
].type
== priv
->hw_type
)
846 if (i
== __NUM_P54U_HWTYPES
)
849 err
= request_firmware(&priv
->fw
, p54u_fwlist
[i
].fw
, &priv
->udev
->dev
);
851 dev_err(&priv
->udev
->dev
, "(p54usb) cannot load firmware %s "
852 "(%d)!\n", p54u_fwlist
[i
].fw
, err
);
854 err
= request_firmware(&priv
->fw
, p54u_fwlist
[i
].fw_legacy
,
860 err
= p54_parse_firmware(dev
, priv
->fw
);
864 if (priv
->common
.fw_interface
!= p54u_fwlist
[i
].intf
) {
865 dev_err(&priv
->udev
->dev
, "wrong firmware, please get "
866 "a firmware for \"%s\" and try again.\n",
873 release_firmware(priv
->fw
);
878 static int p54u_open(struct ieee80211_hw
*dev
)
880 struct p54u_priv
*priv
= dev
->priv
;
883 err
= p54u_init_urbs(dev
);
888 priv
->common
.open
= p54u_init_urbs
;
893 static void p54u_stop(struct ieee80211_hw
*dev
)
895 /* TODO: figure out how to reliably stop the 3887 and net2280 so
896 the hardware is still usable next time we want to start it.
897 until then, we just stop listening to the hardware.. */
901 static int __devinit
p54u_probe(struct usb_interface
*intf
,
902 const struct usb_device_id
*id
)
904 struct usb_device
*udev
= interface_to_usbdev(intf
);
905 struct ieee80211_hw
*dev
;
906 struct p54u_priv
*priv
;
908 unsigned int i
, recognized_pipes
;
910 dev
= p54_init_common(sizeof(*priv
));
913 dev_err(&udev
->dev
, "(p54usb) ieee80211 alloc failed\n");
918 priv
->hw_type
= P54U_INVALID_HW
;
920 SET_IEEE80211_DEV(dev
, &intf
->dev
);
921 usb_set_intfdata(intf
, dev
);
924 skb_queue_head_init(&priv
->rx_queue
);
925 init_usb_anchor(&priv
->submitted
);
929 /* really lazy and simple way of figuring out if we're a 3887 */
930 /* TODO: should just stick the identification in the device table */
931 i
= intf
->altsetting
->desc
.bNumEndpoints
;
932 recognized_pipes
= 0;
934 switch (intf
->altsetting
->endpoint
[i
].desc
.bEndpointAddress
) {
939 case P54U_PIPE_DATA
| USB_DIR_IN
:
940 case P54U_PIPE_MGMT
| USB_DIR_IN
:
941 case P54U_PIPE_BRG
| USB_DIR_IN
:
942 case P54U_PIPE_DEV
| USB_DIR_IN
:
943 case P54U_PIPE_INT
| USB_DIR_IN
:
947 priv
->common
.open
= p54u_open
;
948 priv
->common
.stop
= p54u_stop
;
949 if (recognized_pipes
< P54U_PIPE_NUMBER
) {
951 /* ISL3887 needs a full reset on resume */
952 udev
->reset_resume
= 1;
953 #endif /* CONFIG_PM */
954 err
= p54u_device_reset(dev
);
956 priv
->hw_type
= P54U_3887
;
957 dev
->extra_tx_headroom
+= sizeof(struct lm87_tx_hdr
);
958 priv
->common
.tx_hdr_len
= sizeof(struct lm87_tx_hdr
);
959 priv
->common
.tx
= p54u_tx_lm87
;
960 priv
->upload_fw
= p54u_upload_firmware_3887
;
962 priv
->hw_type
= P54U_NET2280
;
963 dev
->extra_tx_headroom
+= sizeof(struct net2280_tx_hdr
);
964 priv
->common
.tx_hdr_len
= sizeof(struct net2280_tx_hdr
);
965 priv
->common
.tx
= p54u_tx_net2280
;
966 priv
->upload_fw
= p54u_upload_firmware_net2280
;
968 err
= p54u_load_firmware(dev
);
972 err
= priv
->upload_fw(dev
);
977 err
= p54_read_eeprom(dev
);
982 err
= p54_register_common(dev
, &udev
->dev
);
989 release_firmware(priv
->fw
);
992 p54_free_common(dev
);
993 usb_set_intfdata(intf
, NULL
);
998 static void __devexit
p54u_disconnect(struct usb_interface
*intf
)
1000 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1001 struct p54u_priv
*priv
;
1006 p54_unregister_common(dev
);
1009 usb_put_dev(interface_to_usbdev(intf
));
1010 release_firmware(priv
->fw
);
1011 p54_free_common(dev
);
1014 static int p54u_pre_reset(struct usb_interface
*intf
)
1016 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1025 static int p54u_resume(struct usb_interface
*intf
)
1027 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1028 struct p54u_priv
*priv
;
1034 if (unlikely(!(priv
->upload_fw
&& priv
->fw
)))
1037 return priv
->upload_fw(dev
);
1040 static int p54u_post_reset(struct usb_interface
*intf
)
1042 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1043 struct p54u_priv
*priv
;
1046 err
= p54u_resume(intf
);
1050 /* reinitialize old device state */
1052 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
)
1053 ieee80211_restart_hw(dev
);
1060 static int p54u_suspend(struct usb_interface
*intf
, pm_message_t message
)
1062 return p54u_pre_reset(intf
);
1065 #endif /* CONFIG_PM */
1067 static struct usb_driver p54u_driver
= {
1069 .id_table
= p54u_table
,
1070 .probe
= p54u_probe
,
1071 .disconnect
= p54u_disconnect
,
1072 .pre_reset
= p54u_pre_reset
,
1073 .post_reset
= p54u_post_reset
,
1075 .suspend
= p54u_suspend
,
1076 .resume
= p54u_resume
,
1077 .reset_resume
= p54u_resume
,
1078 #endif /* CONFIG_PM */
1082 static int __init
p54u_init(void)
1084 return usb_register(&p54u_driver
);
1087 static void __exit
p54u_exit(void)
1089 usb_deregister(&p54u_driver
);
1092 module_init(p54u_init
);
1093 module_exit(p54u_exit
);