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");
36 static struct usb_device_id p54u_table
[] __devinitdata
= {
37 /* Version 1 devices (pci chip + net2280) */
38 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
39 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
40 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
41 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
42 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
43 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
44 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
45 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
46 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
47 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
48 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
49 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
50 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
51 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
52 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
53 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
54 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
55 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
57 /* Version 2 devices (3887) */
58 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
59 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
60 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
61 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
62 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
63 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
64 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
65 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
66 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
67 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
68 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
69 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
70 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
71 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
72 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
73 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
74 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
75 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
76 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
77 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
78 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
79 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
80 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
81 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
82 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
83 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
87 MODULE_DEVICE_TABLE(usb
, p54u_table
);
91 enum p54u_hw_type type
;
93 const char *fw_legacy
;
95 } p54u_fwlist
[__NUM_P54U_HWTYPES
] = {
100 .fw_legacy
= "isl3890usb",
101 .hw
= "ISL3886 + net2280",
107 .fw_legacy
= "isl3887usb_bare",
112 static void p54u_rx_cb(struct urb
*urb
)
114 struct sk_buff
*skb
= (struct sk_buff
*) urb
->context
;
115 struct p54u_rx_info
*info
= (struct p54u_rx_info
*)skb
->cb
;
116 struct ieee80211_hw
*dev
= info
->dev
;
117 struct p54u_priv
*priv
= dev
->priv
;
119 skb_unlink(skb
, &priv
->rx_queue
);
121 if (unlikely(urb
->status
)) {
122 dev_kfree_skb_irq(skb
);
126 skb_put(skb
, urb
->actual_length
);
128 if (priv
->hw_type
== P54U_NET2280
)
129 skb_pull(skb
, priv
->common
.tx_hdr_len
);
130 if (priv
->common
.fw_interface
== FW_LM87
) {
135 if (p54_rx(dev
, skb
)) {
136 skb
= dev_alloc_skb(priv
->common
.rx_mtu
+ 32);
137 if (unlikely(!skb
)) {
138 /* TODO check rx queue length and refill *somewhere* */
142 info
= (struct p54u_rx_info
*) skb
->cb
;
145 urb
->transfer_buffer
= skb_tail_pointer(skb
);
148 if (priv
->hw_type
== P54U_NET2280
)
149 skb_push(skb
, priv
->common
.tx_hdr_len
);
150 if (priv
->common
.fw_interface
== FW_LM87
) {
154 skb_reset_tail_pointer(skb
);
156 urb
->transfer_buffer
= skb_tail_pointer(skb
);
158 skb_queue_tail(&priv
->rx_queue
, skb
);
159 usb_anchor_urb(urb
, &priv
->submitted
);
160 if (usb_submit_urb(urb
, GFP_ATOMIC
)) {
161 skb_unlink(skb
, &priv
->rx_queue
);
162 usb_unanchor_urb(urb
);
163 dev_kfree_skb_irq(skb
);
167 static void p54u_tx_cb(struct urb
*urb
)
169 struct sk_buff
*skb
= urb
->context
;
170 struct ieee80211_hw
*dev
= (struct ieee80211_hw
*)
171 usb_get_intfdata(usb_ifnum_to_if(urb
->dev
, 0));
173 p54_free_skb(dev
, skb
);
176 static void p54u_tx_dummy_cb(struct urb
*urb
) { }
178 static void p54u_free_urbs(struct ieee80211_hw
*dev
)
180 struct p54u_priv
*priv
= dev
->priv
;
181 usb_kill_anchored_urbs(&priv
->submitted
);
184 static int p54u_init_urbs(struct ieee80211_hw
*dev
)
186 struct p54u_priv
*priv
= dev
->priv
;
187 struct urb
*entry
= NULL
;
189 struct p54u_rx_info
*info
;
192 while (skb_queue_len(&priv
->rx_queue
) < 32) {
193 skb
= __dev_alloc_skb(priv
->common
.rx_mtu
+ 32, GFP_KERNEL
);
198 entry
= usb_alloc_urb(0, GFP_KERNEL
);
204 usb_fill_bulk_urb(entry
, priv
->udev
,
205 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
206 skb_tail_pointer(skb
),
207 priv
->common
.rx_mtu
+ 32, p54u_rx_cb
, skb
);
208 info
= (struct p54u_rx_info
*) skb
->cb
;
211 skb_queue_tail(&priv
->rx_queue
, skb
);
213 usb_anchor_urb(entry
, &priv
->submitted
);
214 ret
= usb_submit_urb(entry
, GFP_KERNEL
);
216 skb_unlink(skb
, &priv
->rx_queue
);
217 usb_unanchor_urb(entry
);
233 static __le32
p54u_lm87_chksum(const __le32
*data
, size_t length
)
239 chk
^= le32_to_cpu(*data
++);
240 chk
= (chk
>> 5) ^ (chk
<< 3);
243 return cpu_to_le32(chk
);
246 static void p54u_tx_lm87(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
248 struct p54u_priv
*priv
= dev
->priv
;
249 struct urb
*data_urb
;
250 struct lm87_tx_hdr
*hdr
= (void *)skb
->data
- sizeof(*hdr
);
252 data_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
254 p54_free_skb(dev
, skb
);
258 hdr
->chksum
= p54u_lm87_chksum((__le32
*)skb
->data
, skb
->len
);
259 hdr
->device_addr
= ((struct p54_hdr
*)skb
->data
)->req_id
;
261 usb_fill_bulk_urb(data_urb
, priv
->udev
,
262 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
263 hdr
, skb
->len
+ sizeof(*hdr
), FREE_AFTER_TX(skb
) ?
264 p54u_tx_cb
: p54u_tx_dummy_cb
, skb
);
265 data_urb
->transfer_flags
|= URB_ZERO_PACKET
;
267 usb_anchor_urb(data_urb
, &priv
->submitted
);
268 if (usb_submit_urb(data_urb
, GFP_ATOMIC
)) {
269 usb_unanchor_urb(data_urb
);
270 p54_free_skb(dev
, skb
);
272 usb_free_urb(data_urb
);
275 static void p54u_tx_net2280(struct ieee80211_hw
*dev
, struct sk_buff
*skb
)
277 struct p54u_priv
*priv
= dev
->priv
;
278 struct urb
*int_urb
= NULL
, *data_urb
= NULL
;
279 struct net2280_tx_hdr
*hdr
= (void *)skb
->data
- sizeof(*hdr
);
280 struct net2280_reg_write
*reg
= NULL
;
283 reg
= kmalloc(sizeof(*reg
), GFP_ATOMIC
);
287 int_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
291 data_urb
= usb_alloc_urb(0, GFP_ATOMIC
);
295 reg
->port
= cpu_to_le16(NET2280_DEV_U32
);
296 reg
->addr
= cpu_to_le32(P54U_DEV_BASE
);
297 reg
->val
= cpu_to_le32(ISL38XX_DEV_INT_DATA
);
299 memset(hdr
, 0, sizeof(*hdr
));
300 hdr
->len
= cpu_to_le16(skb
->len
);
301 hdr
->device_addr
= ((struct p54_hdr
*) skb
->data
)->req_id
;
303 usb_fill_bulk_urb(int_urb
, priv
->udev
,
304 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DEV
), reg
, sizeof(*reg
),
305 p54u_tx_dummy_cb
, dev
);
308 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
309 * free what is inside the transfer_buffer after the last reference to
310 * the int_urb is dropped.
312 int_urb
->transfer_flags
|= URB_FREE_BUFFER
| URB_ZERO_PACKET
;
315 usb_fill_bulk_urb(data_urb
, priv
->udev
,
316 usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DATA
),
317 hdr
, skb
->len
+ sizeof(*hdr
), FREE_AFTER_TX(skb
) ?
318 p54u_tx_cb
: p54u_tx_dummy_cb
, skb
);
319 data_urb
->transfer_flags
|= URB_ZERO_PACKET
;
321 usb_anchor_urb(int_urb
, &priv
->submitted
);
322 err
= usb_submit_urb(int_urb
, GFP_ATOMIC
);
324 usb_unanchor_urb(int_urb
);
328 usb_anchor_urb(data_urb
, &priv
->submitted
);
329 err
= usb_submit_urb(data_urb
, GFP_ATOMIC
);
331 usb_unanchor_urb(data_urb
);
335 usb_free_urb(int_urb
);
336 usb_free_urb(data_urb
);
340 p54_free_skb(dev
, skb
);
344 static int p54u_write(struct p54u_priv
*priv
,
345 struct net2280_reg_write
*buf
,
346 enum net2280_op_type type
,
347 __le32 addr
, __le32 val
)
353 ep
= usb_sndbulkpipe(priv
->udev
, P54U_PIPE_DEV
);
355 ep
= usb_sndbulkpipe(priv
->udev
, P54U_PIPE_BRG
);
357 buf
->port
= cpu_to_le16(type
);
361 return usb_bulk_msg(priv
->udev
, ep
, buf
, sizeof(*buf
), &alen
, 1000);
364 static int p54u_read(struct p54u_priv
*priv
, void *buf
,
365 enum net2280_op_type type
,
366 __le32 addr
, __le32
*val
)
368 struct net2280_reg_read
*read
= buf
;
378 read
->port
= cpu_to_le16(type
);
381 err
= usb_bulk_msg(priv
->udev
, usb_sndbulkpipe(priv
->udev
, ep
),
382 read
, sizeof(*read
), &alen
, 1000);
386 err
= usb_bulk_msg(priv
->udev
, usb_rcvbulkpipe(priv
->udev
, ep
),
387 reg
, sizeof(*reg
), &alen
, 1000);
395 static int p54u_bulk_msg(struct p54u_priv
*priv
, unsigned int ep
,
396 void *data
, size_t len
)
399 return usb_bulk_msg(priv
->udev
, usb_sndbulkpipe(priv
->udev
, ep
),
400 data
, len
, &alen
, 2000);
403 static int p54u_device_reset(struct ieee80211_hw
*dev
)
405 struct p54u_priv
*priv
= dev
->priv
;
406 int ret
, lock
= (priv
->intf
->condition
!= USB_INTERFACE_BINDING
);
409 ret
= usb_lock_device_for_reset(priv
->udev
, priv
->intf
);
411 dev_err(&priv
->udev
->dev
, "(p54usb) unable to lock "
412 "device for reset (%d)!\n", ret
);
417 ret
= usb_reset_device(priv
->udev
);
419 usb_unlock_device(priv
->udev
);
422 dev_err(&priv
->udev
->dev
, "(p54usb) unable to reset "
423 "device (%d)!\n", ret
);
428 static const char p54u_romboot_3887
[] = "~~~~";
429 static int p54u_firmware_reset_3887(struct ieee80211_hw
*dev
)
431 struct p54u_priv
*priv
= dev
->priv
;
435 buf
= kmalloc(4, GFP_KERNEL
);
438 memcpy(buf
, p54u_romboot_3887
, 4);
439 ret
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
,
443 dev_err(&priv
->udev
->dev
, "(p54usb) unable to jump to "
444 "boot ROM (%d)!\n", ret
);
449 static const char p54u_firmware_upload_3887
[] = "<\r";
450 static int p54u_upload_firmware_3887(struct ieee80211_hw
*dev
)
452 struct p54u_priv
*priv
= dev
->priv
;
457 unsigned int left
, remains
, block_size
;
458 struct x2_header
*hdr
;
459 unsigned long timeout
;
461 err
= p54u_firmware_reset_3887(dev
);
465 tmp
= buf
= kmalloc(P54U_FW_BLOCK
, GFP_KERNEL
);
467 dev_err(&priv
->udev
->dev
, "(p54usb) cannot allocate firmware"
472 left
= block_size
= min((size_t)P54U_FW_BLOCK
, priv
->fw
->size
);
473 strcpy(buf
, p54u_firmware_upload_3887
);
474 left
-= strlen(p54u_firmware_upload_3887
);
475 tmp
+= strlen(p54u_firmware_upload_3887
);
477 data
= priv
->fw
->data
;
478 remains
= priv
->fw
->size
;
480 hdr
= (struct x2_header
*)(buf
+ strlen(p54u_firmware_upload_3887
));
481 memcpy(hdr
->signature
, X2_SIGNATURE
, X2_SIGNATURE_SIZE
);
482 hdr
->fw_load_addr
= cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR
);
483 hdr
->fw_length
= cpu_to_le32(priv
->fw
->size
);
484 hdr
->crc
= cpu_to_le32(~crc32_le(~0, (void *)&hdr
->fw_load_addr
,
486 left
-= sizeof(*hdr
);
514 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, block_size
);
516 dev_err(&priv
->udev
->dev
, "(p54usb) firmware "
518 goto err_upload_failed
;
522 left
= block_size
= min((unsigned int)P54U_FW_BLOCK
, remains
);
525 *((__le32
*)buf
) = cpu_to_le32(~crc32_le(~0, priv
->fw
->data
,
527 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, sizeof(u32
));
529 dev_err(&priv
->udev
->dev
, "(p54usb) firmware upload failed!\n");
530 goto err_upload_failed
;
532 timeout
= jiffies
+ msecs_to_jiffies(1000);
533 while (!(err
= usb_bulk_msg(priv
->udev
,
534 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
), buf
, 128, &alen
, 1000))) {
535 if (alen
> 2 && !memcmp(buf
, "OK", 2))
538 if (alen
> 5 && !memcmp(buf
, "ERROR", 5)) {
543 if (time_after(jiffies
, timeout
)) {
544 dev_err(&priv
->udev
->dev
, "(p54usb) firmware boot "
551 dev_err(&priv
->udev
->dev
, "(p54usb) firmware upload failed!\n");
552 goto err_upload_failed
;
557 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, 2);
559 dev_err(&priv
->udev
->dev
, "(p54usb) firmware boot failed!\n");
560 goto err_upload_failed
;
563 timeout
= jiffies
+ msecs_to_jiffies(1000);
564 while (!(err
= usb_bulk_msg(priv
->udev
,
565 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_DATA
), buf
, 128, &alen
, 1000))) {
566 if (alen
> 0 && buf
[0] == 'g')
569 if (time_after(jiffies
, timeout
)) {
575 goto err_upload_failed
;
582 static int p54u_upload_firmware_net2280(struct ieee80211_hw
*dev
)
584 struct p54u_priv
*priv
= dev
->priv
;
585 const struct p54p_csr
*devreg
= (const struct p54p_csr
*) P54U_DEV_BASE
;
589 unsigned int remains
, offset
;
592 buf
= kmalloc(512, GFP_KERNEL
);
594 dev_err(&priv
->udev
->dev
, "(p54usb) firmware buffer "
599 #define P54U_WRITE(type, addr, data) \
601 err = p54u_write(priv, buf, type,\
602 cpu_to_le32((u32)(unsigned long)addr), data);\
607 #define P54U_READ(type, addr) \
609 err = p54u_read(priv, buf, type,\
610 cpu_to_le32((u32)(unsigned long)addr), ®);\
615 /* power down net2280 bridge */
616 P54U_READ(NET2280_BRG_U32
, NET2280_GPIOCTL
);
617 reg
|= cpu_to_le32(P54U_BRG_POWER_DOWN
);
618 reg
&= cpu_to_le32(~P54U_BRG_POWER_UP
);
619 P54U_WRITE(NET2280_BRG_U32
, NET2280_GPIOCTL
, reg
);
623 /* power up bridge */
624 reg
|= cpu_to_le32(P54U_BRG_POWER_UP
);
625 reg
&= cpu_to_le32(~P54U_BRG_POWER_DOWN
);
626 P54U_WRITE(NET2280_BRG_U32
, NET2280_GPIOCTL
, reg
);
630 P54U_WRITE(NET2280_BRG_U32
, NET2280_DEVINIT
,
631 cpu_to_le32(NET2280_CLK_30Mhz
|
633 NET2280_PCI_SOFT_RESET
));
637 P54U_WRITE(NET2280_BRG_CFG_U16
, PCI_COMMAND
,
638 cpu_to_le32(PCI_COMMAND_MEMORY
|
639 PCI_COMMAND_MASTER
));
641 P54U_WRITE(NET2280_BRG_CFG_U32
, PCI_BASE_ADDRESS_0
,
642 cpu_to_le32(NET2280_BASE
));
644 P54U_READ(NET2280_BRG_CFG_U16
, PCI_STATUS
);
645 reg
|= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT
);
646 P54U_WRITE(NET2280_BRG_CFG_U16
, PCI_STATUS
, reg
);
648 // TODO: we really need this?
649 P54U_READ(NET2280_BRG_U32
, NET2280_RELNUM
);
651 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPA_RSP
,
652 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE
));
653 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPC_RSP
,
654 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE
));
656 P54U_WRITE(NET2280_BRG_CFG_U32
, PCI_BASE_ADDRESS_2
,
657 cpu_to_le32(NET2280_BASE2
));
659 /* finally done setting up the bridge */
661 P54U_WRITE(NET2280_DEV_CFG_U16
, 0x10000 | PCI_COMMAND
,
662 cpu_to_le32(PCI_COMMAND_MEMORY
|
663 PCI_COMMAND_MASTER
));
665 P54U_WRITE(NET2280_DEV_CFG_U16
, 0x10000 | 0x40 /* TRDY timeout */, 0);
666 P54U_WRITE(NET2280_DEV_CFG_U32
, 0x10000 | PCI_BASE_ADDRESS_0
,
667 cpu_to_le32(P54U_DEV_BASE
));
669 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
, 0);
670 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
671 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
674 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_enable
, 0);
676 P54U_READ(NET2280_DEV_U32
, &devreg
->ctrl_stat
);
677 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
678 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT
);
679 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
680 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
684 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
685 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
689 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
690 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
694 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
695 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
697 /* finally, we can upload firmware now! */
698 remains
= priv
->fw
->size
;
699 data
= priv
->fw
->data
;
700 offset
= ISL38XX_DEV_FIRMWARE_ADDR
;
703 unsigned int block_len
= min(remains
, (unsigned int)512);
704 memcpy(buf
, data
, block_len
);
706 err
= p54u_bulk_msg(priv
, P54U_PIPE_DATA
, buf
, block_len
);
708 dev_err(&priv
->udev
->dev
, "(p54usb) firmware block "
713 P54U_WRITE(NET2280_DEV_U32
, &devreg
->direct_mem_base
,
714 cpu_to_le32(0xc0000f00));
716 P54U_WRITE(NET2280_DEV_U32
,
717 0x0020 | (unsigned long)&devreg
->direct_mem_win
, 0);
718 P54U_WRITE(NET2280_DEV_U32
,
719 0x0020 | (unsigned long)&devreg
->direct_mem_win
,
722 P54U_WRITE(NET2280_DEV_U32
,
723 0x0024 | (unsigned long)&devreg
->direct_mem_win
,
724 cpu_to_le32(block_len
));
725 P54U_WRITE(NET2280_DEV_U32
,
726 0x0028 | (unsigned long)&devreg
->direct_mem_win
,
727 cpu_to_le32(offset
));
729 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_addr
,
730 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR
));
731 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_len
,
732 cpu_to_le32(block_len
>> 2));
733 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dma_ctrl
,
734 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER
));
738 P54U_READ(NET2280_DEV_U32
,
739 0x002C | (unsigned long)&devreg
->direct_mem_win
);
740 if (!(reg
& cpu_to_le32(ISL38XX_DMA_STATUS_DONE
)) ||
741 !(reg
& cpu_to_le32(ISL38XX_DMA_STATUS_READY
))) {
742 dev_err(&priv
->udev
->dev
, "(p54usb) firmware DMA "
743 "transfer failed\n");
747 P54U_WRITE(NET2280_BRG_U32
, NET2280_EPA_STAT
,
748 cpu_to_le32(NET2280_FIFO_FLUSH
));
750 remains
-= block_len
;
756 P54U_READ(NET2280_DEV_U32
, &devreg
->ctrl_stat
);
757 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
758 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN
);
759 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT
);
760 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
764 reg
|= cpu_to_le32(ISL38XX_CTRL_STAT_RESET
);
765 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
767 reg
&= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET
);
768 P54U_WRITE(NET2280_DEV_U32
, &devreg
->ctrl_stat
, reg
);
772 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
773 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
775 /* start up the firmware */
776 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_enable
,
777 cpu_to_le32(ISL38XX_INT_IDENT_INIT
));
779 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
780 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
782 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
,
783 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE
|
784 NET2280_USB_INTERRUPT_ENABLE
));
786 P54U_WRITE(NET2280_DEV_U32
, &devreg
->dev_int
,
787 cpu_to_le32(ISL38XX_DEV_INT_RESET
));
789 err
= usb_interrupt_msg(priv
->udev
,
790 usb_rcvbulkpipe(priv
->udev
, P54U_PIPE_INT
),
791 buf
, sizeof(__le32
), &alen
, 1000);
792 if (err
|| alen
!= sizeof(__le32
))
795 P54U_READ(NET2280_DEV_U32
, &devreg
->int_ident
);
796 P54U_WRITE(NET2280_DEV_U32
, &devreg
->int_ack
, reg
);
798 if (!(reg
& cpu_to_le32(ISL38XX_INT_IDENT_INIT
)))
801 P54U_WRITE(NET2280_BRG_U32
, NET2280_USBIRQENB1
, 0);
802 P54U_WRITE(NET2280_BRG_U32
, NET2280_IRQSTAT1
,
803 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT
));
813 static int p54u_load_firmware(struct ieee80211_hw
*dev
)
815 struct p54u_priv
*priv
= dev
->priv
;
818 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist
) != __NUM_P54U_HWTYPES
);
820 for (i
= 0; i
< __NUM_P54U_HWTYPES
; i
++)
821 if (p54u_fwlist
[i
].type
== priv
->hw_type
)
824 if (i
== __NUM_P54U_HWTYPES
)
827 err
= request_firmware(&priv
->fw
, p54u_fwlist
[i
].fw
, &priv
->udev
->dev
);
829 dev_err(&priv
->udev
->dev
, "(p54usb) cannot load firmware %s "
830 "(%d)!\n", p54u_fwlist
[i
].fw
, err
);
832 err
= request_firmware(&priv
->fw
, p54u_fwlist
[i
].fw_legacy
,
838 err
= p54_parse_firmware(dev
, priv
->fw
);
842 if (priv
->common
.fw_interface
!= p54u_fwlist
[i
].intf
) {
843 dev_err(&priv
->udev
->dev
, "wrong firmware, please get "
844 "a firmware for \"%s\" and try again.\n",
851 release_firmware(priv
->fw
);
856 static int p54u_open(struct ieee80211_hw
*dev
)
858 struct p54u_priv
*priv
= dev
->priv
;
861 err
= p54u_init_urbs(dev
);
866 priv
->common
.open
= p54u_init_urbs
;
871 static void p54u_stop(struct ieee80211_hw
*dev
)
873 /* TODO: figure out how to reliably stop the 3887 and net2280 so
874 the hardware is still usable next time we want to start it.
875 until then, we just stop listening to the hardware.. */
880 static int __devinit
p54u_probe(struct usb_interface
*intf
,
881 const struct usb_device_id
*id
)
883 struct usb_device
*udev
= interface_to_usbdev(intf
);
884 struct ieee80211_hw
*dev
;
885 struct p54u_priv
*priv
;
887 unsigned int i
, recognized_pipes
;
889 dev
= p54_init_common(sizeof(*priv
));
892 dev_err(&udev
->dev
, "(p54usb) ieee80211 alloc failed\n");
897 priv
->hw_type
= P54U_INVALID_HW
;
899 SET_IEEE80211_DEV(dev
, &intf
->dev
);
900 usb_set_intfdata(intf
, dev
);
903 skb_queue_head_init(&priv
->rx_queue
);
904 init_usb_anchor(&priv
->submitted
);
908 /* really lazy and simple way of figuring out if we're a 3887 */
909 /* TODO: should just stick the identification in the device table */
910 i
= intf
->altsetting
->desc
.bNumEndpoints
;
911 recognized_pipes
= 0;
913 switch (intf
->altsetting
->endpoint
[i
].desc
.bEndpointAddress
) {
918 case P54U_PIPE_DATA
| USB_DIR_IN
:
919 case P54U_PIPE_MGMT
| USB_DIR_IN
:
920 case P54U_PIPE_BRG
| USB_DIR_IN
:
921 case P54U_PIPE_DEV
| USB_DIR_IN
:
922 case P54U_PIPE_INT
| USB_DIR_IN
:
926 priv
->common
.open
= p54u_open
;
927 priv
->common
.stop
= p54u_stop
;
928 if (recognized_pipes
< P54U_PIPE_NUMBER
) {
930 /* ISL3887 needs a full reset on resume */
931 udev
->reset_resume
= 1;
932 err
= p54u_device_reset(dev
);
935 priv
->hw_type
= P54U_3887
;
936 dev
->extra_tx_headroom
+= sizeof(struct lm87_tx_hdr
);
937 priv
->common
.tx_hdr_len
= sizeof(struct lm87_tx_hdr
);
938 priv
->common
.tx
= p54u_tx_lm87
;
939 priv
->upload_fw
= p54u_upload_firmware_3887
;
941 priv
->hw_type
= P54U_NET2280
;
942 dev
->extra_tx_headroom
+= sizeof(struct net2280_tx_hdr
);
943 priv
->common
.tx_hdr_len
= sizeof(struct net2280_tx_hdr
);
944 priv
->common
.tx
= p54u_tx_net2280
;
945 priv
->upload_fw
= p54u_upload_firmware_net2280
;
947 err
= p54u_load_firmware(dev
);
951 err
= priv
->upload_fw(dev
);
956 err
= p54_read_eeprom(dev
);
961 err
= p54_register_common(dev
, &udev
->dev
);
968 release_firmware(priv
->fw
);
971 p54_free_common(dev
);
972 usb_set_intfdata(intf
, NULL
);
977 static void __devexit
p54u_disconnect(struct usb_interface
*intf
)
979 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
980 struct p54u_priv
*priv
;
985 p54_unregister_common(dev
);
988 usb_put_dev(interface_to_usbdev(intf
));
989 release_firmware(priv
->fw
);
990 p54_free_common(dev
);
993 static int p54u_pre_reset(struct usb_interface
*intf
)
995 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1004 static int p54u_resume(struct usb_interface
*intf
)
1006 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1007 struct p54u_priv
*priv
;
1013 if (unlikely(!(priv
->upload_fw
&& priv
->fw
)))
1016 return priv
->upload_fw(dev
);
1019 static int p54u_post_reset(struct usb_interface
*intf
)
1021 struct ieee80211_hw
*dev
= usb_get_intfdata(intf
);
1022 struct p54u_priv
*priv
;
1025 err
= p54u_resume(intf
);
1029 /* reinitialize old device state */
1031 if (priv
->common
.mode
!= NL80211_IFTYPE_UNSPECIFIED
)
1032 ieee80211_restart_hw(dev
);
1039 static int p54u_suspend(struct usb_interface
*intf
, pm_message_t message
)
1041 return p54u_pre_reset(intf
);
1044 #endif /* CONFIG_PM */
1046 static struct usb_driver p54u_driver
= {
1048 .id_table
= p54u_table
,
1049 .probe
= p54u_probe
,
1050 .disconnect
= p54u_disconnect
,
1051 .pre_reset
= p54u_pre_reset
,
1052 .post_reset
= p54u_post_reset
,
1054 .suspend
= p54u_suspend
,
1055 .resume
= p54u_resume
,
1056 .reset_resume
= p54u_resume
,
1057 #endif /* CONFIG_PM */
1061 static int __init
p54u_init(void)
1063 return usb_register(&p54u_driver
);
1066 static void __exit
p54u_exit(void)
1068 usb_deregister(&p54u_driver
);
1071 module_init(p54u_init
);
1072 module_exit(p54u_exit
);