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(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
65 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
66 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
67 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
68 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
69 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
70 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
71 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
73 /* Version 2 devices (3887) */
74 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
75 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
76 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
77 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
78 {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */
79 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
80 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
81 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
82 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
83 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
84 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
85 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
86 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
87 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
88 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
89 * just noting it here for clarity */
90 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
91 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
92 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
93 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
94 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
95 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
96 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
97 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
98 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
99 {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */
100 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
101 {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */
102 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
103 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
104 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
108 MODULE_DEVICE_TABLE(usb, p54u_table);
110 static const struct {
112 enum p54u_hw_type type;
114 const char *fw_legacy;
116 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
118 .type = P54U_NET2280,
121 .fw_legacy = "isl3890usb",
122 .hw = "ISL3886 + net2280",
128 .fw_legacy = "isl3887usb_bare",
133 static void p54u_rx_cb(struct urb *urb)
135 struct sk_buff *skb = (struct sk_buff *) urb->context;
136 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
137 struct ieee80211_hw *dev = info->dev;
138 struct p54u_priv *priv = dev->priv;
140 skb_unlink(skb, &priv->rx_queue);
142 if (unlikely(urb->status)) {
143 dev_kfree_skb_irq(skb);
147 skb_put(skb, urb->actual_length);
149 if (priv->hw_type == P54U_NET2280)
150 skb_pull(skb, priv->common.tx_hdr_len);
151 if (priv->common.fw_interface == FW_LM87) {
156 if (p54_rx(dev, skb)) {
157 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
158 if (unlikely(!skb)) {
159 /* TODO check rx queue length and refill *somewhere* */
163 info = (struct p54u_rx_info *) skb->cb;
166 urb->transfer_buffer = skb_tail_pointer(skb);
169 if (priv->hw_type == P54U_NET2280)
170 skb_push(skb, priv->common.tx_hdr_len);
171 if (priv->common.fw_interface == FW_LM87) {
175 skb_reset_tail_pointer(skb);
177 urb->transfer_buffer = skb_tail_pointer(skb);
179 skb_queue_tail(&priv->rx_queue, skb);
180 usb_anchor_urb(urb, &priv->submitted);
181 if (usb_submit_urb(urb, GFP_ATOMIC)) {
182 skb_unlink(skb, &priv->rx_queue);
183 usb_unanchor_urb(urb);
184 dev_kfree_skb_irq(skb);
188 static void p54u_tx_cb(struct urb *urb)
190 struct sk_buff *skb = urb->context;
191 struct ieee80211_hw *dev = (struct ieee80211_hw *)
192 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
194 p54_free_skb(dev, skb);
197 static void p54u_tx_dummy_cb(struct urb *urb) { }
199 static void p54u_free_urbs(struct ieee80211_hw *dev)
201 struct p54u_priv *priv = dev->priv;
202 usb_kill_anchored_urbs(&priv->submitted);
205 static int p54u_init_urbs(struct ieee80211_hw *dev)
207 struct p54u_priv *priv = dev->priv;
208 struct urb *entry = NULL;
210 struct p54u_rx_info *info;
213 while (skb_queue_len(&priv->rx_queue) < 32) {
214 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
219 entry = usb_alloc_urb(0, GFP_KERNEL);
225 usb_fill_bulk_urb(entry, priv->udev,
226 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
227 skb_tail_pointer(skb),
228 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
229 info = (struct p54u_rx_info *) skb->cb;
232 skb_queue_tail(&priv->rx_queue, skb);
234 usb_anchor_urb(entry, &priv->submitted);
235 ret = usb_submit_urb(entry, GFP_KERNEL);
237 skb_unlink(skb, &priv->rx_queue);
238 usb_unanchor_urb(entry);
254 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
260 chk ^= le32_to_cpu(*data++);
261 chk = (chk >> 5) ^ (chk << 3);
264 return cpu_to_le32(chk);
267 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
269 struct p54u_priv *priv = dev->priv;
270 struct urb *data_urb;
271 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
273 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
275 p54_free_skb(dev, skb);
279 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
280 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
282 usb_fill_bulk_urb(data_urb, priv->udev,
283 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
284 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
285 p54u_tx_cb : p54u_tx_dummy_cb, skb);
286 data_urb->transfer_flags |= URB_ZERO_PACKET;
288 usb_anchor_urb(data_urb, &priv->submitted);
289 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
290 usb_unanchor_urb(data_urb);
291 p54_free_skb(dev, skb);
293 usb_free_urb(data_urb);
296 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
298 struct p54u_priv *priv = dev->priv;
299 struct urb *int_urb = NULL, *data_urb = NULL;
300 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
301 struct net2280_reg_write *reg = NULL;
304 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
308 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
312 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
316 reg->port = cpu_to_le16(NET2280_DEV_U32);
317 reg->addr = cpu_to_le32(P54U_DEV_BASE);
318 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
320 memset(hdr, 0, sizeof(*hdr));
321 hdr->len = cpu_to_le16(skb->len);
322 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
324 usb_fill_bulk_urb(int_urb, priv->udev,
325 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
326 p54u_tx_dummy_cb, dev);
329 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
330 * free what is inside the transfer_buffer after the last reference to
331 * the int_urb is dropped.
333 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
336 usb_fill_bulk_urb(data_urb, priv->udev,
337 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
338 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
339 p54u_tx_cb : p54u_tx_dummy_cb, skb);
340 data_urb->transfer_flags |= URB_ZERO_PACKET;
342 usb_anchor_urb(int_urb, &priv->submitted);
343 err = usb_submit_urb(int_urb, GFP_ATOMIC);
345 usb_unanchor_urb(int_urb);
349 usb_anchor_urb(data_urb, &priv->submitted);
350 err = usb_submit_urb(data_urb, GFP_ATOMIC);
352 usb_unanchor_urb(data_urb);
356 usb_free_urb(int_urb);
357 usb_free_urb(data_urb);
361 p54_free_skb(dev, skb);
365 static int p54u_write(struct p54u_priv *priv,
366 struct net2280_reg_write *buf,
367 enum net2280_op_type type,
368 __le32 addr, __le32 val)
374 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
376 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
378 buf->port = cpu_to_le16(type);
382 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
385 static int p54u_read(struct p54u_priv *priv, void *buf,
386 enum net2280_op_type type,
387 __le32 addr, __le32 *val)
389 struct net2280_reg_read *read = buf;
399 read->port = cpu_to_le16(type);
402 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
403 read, sizeof(*read), &alen, 1000);
407 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
408 reg, sizeof(*reg), &alen, 1000);
416 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
417 void *data, size_t len)
420 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
421 data, len, &alen, 2000);
424 static int p54u_device_reset(struct ieee80211_hw *dev)
426 struct p54u_priv *priv = dev->priv;
427 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
430 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
432 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
433 "device for reset (%d)!\n", ret);
438 ret = usb_reset_device(priv->udev);
440 usb_unlock_device(priv->udev);
443 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
444 "device (%d)!\n", ret);
449 static const char p54u_romboot_3887[] = "~~~~";
450 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
452 struct p54u_priv *priv = dev->priv;
456 buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
459 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
463 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
464 "boot ROM (%d)!\n", ret);
469 static const char p54u_firmware_upload_3887[] = "<\r";
470 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
472 struct p54u_priv *priv = dev->priv;
477 unsigned int left, remains, block_size;
478 struct x2_header *hdr;
479 unsigned long timeout;
481 err = p54u_firmware_reset_3887(dev);
485 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
487 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
492 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
493 strcpy(buf, p54u_firmware_upload_3887);
494 left -= strlen(p54u_firmware_upload_3887);
495 tmp += strlen(p54u_firmware_upload_3887);
497 data = priv->fw->data;
498 remains = priv->fw->size;
500 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
501 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
502 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
503 hdr->fw_length = cpu_to_le32(priv->fw->size);
504 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
506 left -= sizeof(*hdr);
534 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
536 dev_err(&priv->udev->dev, "(p54usb) firmware "
538 goto err_upload_failed;
542 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
545 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
547 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
549 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
550 goto err_upload_failed;
552 timeout = jiffies + msecs_to_jiffies(1000);
553 while (!(err = usb_bulk_msg(priv->udev,
554 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
555 if (alen > 2 && !memcmp(buf, "OK", 2))
558 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
563 if (time_after(jiffies, timeout)) {
564 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
571 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
572 goto err_upload_failed;
577 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
579 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
580 goto err_upload_failed;
583 timeout = jiffies + msecs_to_jiffies(1000);
584 while (!(err = usb_bulk_msg(priv->udev,
585 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
586 if (alen > 0 && buf[0] == 'g')
589 if (time_after(jiffies, timeout)) {
595 goto err_upload_failed;
602 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
604 struct p54u_priv *priv = dev->priv;
605 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
609 unsigned int remains, offset;
612 buf = kmalloc(512, GFP_KERNEL);
614 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
619 #define P54U_WRITE(type, addr, data) \
621 err = p54u_write(priv, buf, type,\
622 cpu_to_le32((u32)(unsigned long)addr), data);\
627 #define P54U_READ(type, addr) \
629 err = p54u_read(priv, buf, type,\
630 cpu_to_le32((u32)(unsigned long)addr), ®);\
635 /* power down net2280 bridge */
636 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
637 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
638 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
639 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
643 /* power up bridge */
644 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
645 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
646 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
650 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
651 cpu_to_le32(NET2280_CLK_30Mhz |
653 NET2280_PCI_SOFT_RESET));
657 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
658 cpu_to_le32(PCI_COMMAND_MEMORY |
659 PCI_COMMAND_MASTER));
661 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
662 cpu_to_le32(NET2280_BASE));
664 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
665 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
666 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
668 // TODO: we really need this?
669 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
671 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
672 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
673 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
674 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
676 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
677 cpu_to_le32(NET2280_BASE2));
679 /* finally done setting up the bridge */
681 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
682 cpu_to_le32(PCI_COMMAND_MEMORY |
683 PCI_COMMAND_MASTER));
685 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
686 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
687 cpu_to_le32(P54U_DEV_BASE));
689 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
690 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
691 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
694 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
696 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
697 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
698 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
699 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
700 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
704 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
709 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
710 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
714 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
715 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
717 /* finally, we can upload firmware now! */
718 remains = priv->fw->size;
719 data = priv->fw->data;
720 offset = ISL38XX_DEV_FIRMWARE_ADDR;
723 unsigned int block_len = min(remains, (unsigned int)512);
724 memcpy(buf, data, block_len);
726 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
728 dev_err(&priv->udev->dev, "(p54usb) firmware block "
733 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
734 cpu_to_le32(0xc0000f00));
736 P54U_WRITE(NET2280_DEV_U32,
737 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
738 P54U_WRITE(NET2280_DEV_U32,
739 0x0020 | (unsigned long)&devreg->direct_mem_win,
742 P54U_WRITE(NET2280_DEV_U32,
743 0x0024 | (unsigned long)&devreg->direct_mem_win,
744 cpu_to_le32(block_len));
745 P54U_WRITE(NET2280_DEV_U32,
746 0x0028 | (unsigned long)&devreg->direct_mem_win,
747 cpu_to_le32(offset));
749 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
750 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
751 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
752 cpu_to_le32(block_len >> 2));
753 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
754 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
758 P54U_READ(NET2280_DEV_U32,
759 0x002C | (unsigned long)&devreg->direct_mem_win);
760 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
761 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
762 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
763 "transfer failed\n");
767 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
768 cpu_to_le32(NET2280_FIFO_FLUSH));
770 remains -= block_len;
776 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
777 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
778 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
779 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
780 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
784 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
785 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
787 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
788 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
792 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
793 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
795 /* start up the firmware */
796 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
797 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
799 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
800 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
802 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
803 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
804 NET2280_USB_INTERRUPT_ENABLE));
806 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
807 cpu_to_le32(ISL38XX_DEV_INT_RESET));
809 err = usb_interrupt_msg(priv->udev,
810 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
811 buf, sizeof(__le32), &alen, 1000);
812 if (err || alen != sizeof(__le32))
815 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
816 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
818 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
821 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
822 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
823 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
833 static int p54u_load_firmware(struct ieee80211_hw *dev)
835 struct p54u_priv *priv = dev->priv;
838 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
840 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
841 if (p54u_fwlist[i].type == priv->hw_type)
844 if (i == __NUM_P54U_HWTYPES)
847 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
849 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
850 "(%d)!\n", p54u_fwlist[i].fw, err);
852 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
858 err = p54_parse_firmware(dev, priv->fw);
862 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
863 dev_err(&priv->udev->dev, "wrong firmware, please get "
864 "a firmware for \"%s\" and try again.\n",
871 release_firmware(priv->fw);
876 static int p54u_open(struct ieee80211_hw *dev)
878 struct p54u_priv *priv = dev->priv;
881 err = p54u_init_urbs(dev);
886 priv->common.open = p54u_init_urbs;
891 static void p54u_stop(struct ieee80211_hw *dev)
893 /* TODO: figure out how to reliably stop the 3887 and net2280 so
894 the hardware is still usable next time we want to start it.
895 until then, we just stop listening to the hardware.. */
899 static int __devinit p54u_probe(struct usb_interface *intf,
900 const struct usb_device_id *id)
902 struct usb_device *udev = interface_to_usbdev(intf);
903 struct ieee80211_hw *dev;
904 struct p54u_priv *priv;
906 unsigned int i, recognized_pipes;
908 dev = p54_init_common(sizeof(*priv));
911 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
916 priv->hw_type = P54U_INVALID_HW;
918 SET_IEEE80211_DEV(dev, &intf->dev);
919 usb_set_intfdata(intf, dev);
922 skb_queue_head_init(&priv->rx_queue);
923 init_usb_anchor(&priv->submitted);
927 /* really lazy and simple way of figuring out if we're a 3887 */
928 /* TODO: should just stick the identification in the device table */
929 i = intf->altsetting->desc.bNumEndpoints;
930 recognized_pipes = 0;
932 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
937 case P54U_PIPE_DATA | USB_DIR_IN:
938 case P54U_PIPE_MGMT | USB_DIR_IN:
939 case P54U_PIPE_BRG | USB_DIR_IN:
940 case P54U_PIPE_DEV | USB_DIR_IN:
941 case P54U_PIPE_INT | USB_DIR_IN:
945 priv->common.open = p54u_open;
946 priv->common.stop = p54u_stop;
947 if (recognized_pipes < P54U_PIPE_NUMBER) {
949 /* ISL3887 needs a full reset on resume */
950 udev->reset_resume = 1;
951 #endif /* CONFIG_PM */
952 err = p54u_device_reset(dev);
954 priv->hw_type = P54U_3887;
955 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
956 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
957 priv->common.tx = p54u_tx_lm87;
958 priv->upload_fw = p54u_upload_firmware_3887;
960 priv->hw_type = P54U_NET2280;
961 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
962 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
963 priv->common.tx = p54u_tx_net2280;
964 priv->upload_fw = p54u_upload_firmware_net2280;
966 err = p54u_load_firmware(dev);
970 err = priv->upload_fw(dev);
975 err = p54_read_eeprom(dev);
980 err = p54_register_common(dev, &udev->dev);
987 release_firmware(priv->fw);
990 p54_free_common(dev);
991 usb_set_intfdata(intf, NULL);
996 static void __devexit p54u_disconnect(struct usb_interface *intf)
998 struct ieee80211_hw *dev = usb_get_intfdata(intf);
999 struct p54u_priv *priv;
1004 p54_unregister_common(dev);
1007 usb_put_dev(interface_to_usbdev(intf));
1008 release_firmware(priv->fw);
1009 p54_free_common(dev);
1012 static int p54u_pre_reset(struct usb_interface *intf)
1014 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1023 static int p54u_resume(struct usb_interface *intf)
1025 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1026 struct p54u_priv *priv;
1032 if (unlikely(!(priv->upload_fw && priv->fw)))
1035 return priv->upload_fw(dev);
1038 static int p54u_post_reset(struct usb_interface *intf)
1040 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1041 struct p54u_priv *priv;
1044 err = p54u_resume(intf);
1048 /* reinitialize old device state */
1050 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1051 ieee80211_restart_hw(dev);
1058 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1060 return p54u_pre_reset(intf);
1063 #endif /* CONFIG_PM */
1065 static struct usb_driver p54u_driver = {
1067 .id_table = p54u_table,
1068 .probe = p54u_probe,
1069 .disconnect = p54u_disconnect,
1070 .pre_reset = p54u_pre_reset,
1071 .post_reset = p54u_post_reset,
1073 .suspend = p54u_suspend,
1074 .resume = p54u_resume,
1075 .reset_resume = p54u_resume,
1076 #endif /* CONFIG_PM */
1080 static int __init p54u_init(void)
1082 return usb_register(&p54u_driver);
1085 static void __exit p54u_exit(void)
1087 usb_deregister(&p54u_driver);
1090 module_init(p54u_init);
1091 module_exit(p54u_exit);