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/firmware.h>
19 #include <linux/etherdevice.h>
20 #include <linux/delay.h>
21 #include <linux/crc32.h>
22 #include <net/mac80211.h>
28 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
29 MODULE_DESCRIPTION("Prism54 USB wireless driver");
30 MODULE_LICENSE("GPL");
31 MODULE_ALIAS("prism54usb");
32 MODULE_FIRMWARE("isl3886usb");
33 MODULE_FIRMWARE("isl3887usb");
35 static struct usb_device_id p54u_table[] __devinitdata = {
36 /* Version 1 devices (pci chip + net2280) */
37 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
38 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
39 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
40 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
41 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
42 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
43 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
44 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
45 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
46 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
47 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
48 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
49 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
50 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
51 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
52 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
53 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
55 /* Version 2 devices (3887) */
56 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
57 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
58 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
59 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
60 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
61 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
62 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
63 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
64 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
65 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
66 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
67 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
68 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
69 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
70 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
71 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
72 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
73 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
74 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
75 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
76 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
77 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
78 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
79 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
80 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
84 MODULE_DEVICE_TABLE(usb, p54u_table);
88 enum p54u_hw_type type;
90 const char *fw_legacy;
92 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
97 .fw_legacy = "isl3890usb",
98 .hw = "ISL3886 + net2280",
104 .fw_legacy = "isl3887usb_bare",
109 static void p54u_rx_cb(struct urb *urb)
111 struct sk_buff *skb = (struct sk_buff *) urb->context;
112 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
113 struct ieee80211_hw *dev = info->dev;
114 struct p54u_priv *priv = dev->priv;
116 skb_unlink(skb, &priv->rx_queue);
118 if (unlikely(urb->status)) {
119 dev_kfree_skb_irq(skb);
123 skb_put(skb, urb->actual_length);
125 if (priv->hw_type == P54U_NET2280)
126 skb_pull(skb, priv->common.tx_hdr_len);
127 if (priv->common.fw_interface == FW_LM87) {
132 if (p54_rx(dev, skb)) {
133 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
134 if (unlikely(!skb)) {
135 /* TODO check rx queue length and refill *somewhere* */
139 info = (struct p54u_rx_info *) skb->cb;
142 urb->transfer_buffer = skb_tail_pointer(skb);
145 if (priv->hw_type == P54U_NET2280)
146 skb_push(skb, priv->common.tx_hdr_len);
147 if (priv->common.fw_interface == FW_LM87) {
151 skb_reset_tail_pointer(skb);
153 urb->transfer_buffer = skb_tail_pointer(skb);
155 skb_queue_tail(&priv->rx_queue, skb);
156 usb_anchor_urb(urb, &priv->submitted);
157 if (usb_submit_urb(urb, GFP_ATOMIC)) {
158 skb_unlink(skb, &priv->rx_queue);
159 usb_unanchor_urb(urb);
160 dev_kfree_skb_irq(skb);
164 static void p54u_tx_cb(struct urb *urb)
166 struct sk_buff *skb = urb->context;
167 struct ieee80211_hw *dev = (struct ieee80211_hw *)
168 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
170 p54_free_skb(dev, skb);
173 static void p54u_tx_dummy_cb(struct urb *urb) { }
175 static void p54u_free_urbs(struct ieee80211_hw *dev)
177 struct p54u_priv *priv = dev->priv;
178 usb_kill_anchored_urbs(&priv->submitted);
181 static int p54u_init_urbs(struct ieee80211_hw *dev)
183 struct p54u_priv *priv = dev->priv;
184 struct urb *entry = NULL;
186 struct p54u_rx_info *info;
189 while (skb_queue_len(&priv->rx_queue) < 32) {
190 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
195 entry = usb_alloc_urb(0, GFP_KERNEL);
201 usb_fill_bulk_urb(entry, priv->udev,
202 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
203 skb_tail_pointer(skb),
204 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
205 info = (struct p54u_rx_info *) skb->cb;
208 skb_queue_tail(&priv->rx_queue, skb);
210 usb_anchor_urb(entry, &priv->submitted);
211 ret = usb_submit_urb(entry, GFP_KERNEL);
213 skb_unlink(skb, &priv->rx_queue);
214 usb_unanchor_urb(entry);
230 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
236 chk ^= le32_to_cpu(*data++);
237 chk = (chk >> 5) ^ (chk << 3);
240 return cpu_to_le32(chk);
243 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
245 struct p54u_priv *priv = dev->priv;
246 struct urb *data_urb;
247 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
249 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
251 p54_free_skb(dev, skb);
255 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
256 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
258 usb_fill_bulk_urb(data_urb, priv->udev,
259 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
260 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
261 p54u_tx_cb : p54u_tx_dummy_cb, skb);
262 data_urb->transfer_flags |= URB_ZERO_PACKET;
264 usb_anchor_urb(data_urb, &priv->submitted);
265 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
266 usb_unanchor_urb(data_urb);
267 p54_free_skb(dev, skb);
269 usb_free_urb(data_urb);
272 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
274 struct p54u_priv *priv = dev->priv;
275 struct urb *int_urb = NULL, *data_urb = NULL;
276 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
277 struct net2280_reg_write *reg = NULL;
280 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
284 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
288 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
292 reg->port = cpu_to_le16(NET2280_DEV_U32);
293 reg->addr = cpu_to_le32(P54U_DEV_BASE);
294 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
296 memset(hdr, 0, sizeof(*hdr));
297 hdr->len = cpu_to_le16(skb->len);
298 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
300 usb_fill_bulk_urb(int_urb, priv->udev,
301 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
302 p54u_tx_dummy_cb, dev);
305 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
306 * free what is inside the transfer_buffer after the last reference to
307 * the int_urb is dropped.
309 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
312 usb_fill_bulk_urb(data_urb, priv->udev,
313 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
314 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
315 p54u_tx_cb : p54u_tx_dummy_cb, skb);
316 data_urb->transfer_flags |= URB_ZERO_PACKET;
318 usb_anchor_urb(int_urb, &priv->submitted);
319 err = usb_submit_urb(int_urb, GFP_ATOMIC);
321 usb_unanchor_urb(int_urb);
325 usb_anchor_urb(data_urb, &priv->submitted);
326 err = usb_submit_urb(data_urb, GFP_ATOMIC);
328 usb_unanchor_urb(data_urb);
332 usb_free_urb(int_urb);
333 usb_free_urb(data_urb);
337 p54_free_skb(dev, skb);
341 static int p54u_write(struct p54u_priv *priv,
342 struct net2280_reg_write *buf,
343 enum net2280_op_type type,
344 __le32 addr, __le32 val)
350 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
352 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
354 buf->port = cpu_to_le16(type);
358 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
361 static int p54u_read(struct p54u_priv *priv, void *buf,
362 enum net2280_op_type type,
363 __le32 addr, __le32 *val)
365 struct net2280_reg_read *read = buf;
375 read->port = cpu_to_le16(type);
378 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
379 read, sizeof(*read), &alen, 1000);
383 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
384 reg, sizeof(*reg), &alen, 1000);
392 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
393 void *data, size_t len)
396 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
397 data, len, &alen, 2000);
400 static int p54u_device_reset(struct ieee80211_hw *dev)
402 struct p54u_priv *priv = dev->priv;
403 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
406 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
408 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
409 "device for reset (%d)!\n", ret);
414 ret = usb_reset_device(priv->udev);
416 usb_unlock_device(priv->udev);
419 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
420 "device (%d)!\n", ret);
425 static const char p54u_romboot_3887[] = "~~~~";
426 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
428 struct p54u_priv *priv = dev->priv;
432 buf = kmalloc(4, GFP_KERNEL);
435 memcpy(buf, p54u_romboot_3887, 4);
436 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
440 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
441 "boot ROM (%d)!\n", ret);
446 static const char p54u_firmware_upload_3887[] = "<\r";
447 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
449 struct p54u_priv *priv = dev->priv;
454 unsigned int left, remains, block_size;
455 struct x2_header *hdr;
456 unsigned long timeout;
458 err = p54u_firmware_reset_3887(dev);
462 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
464 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
469 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
470 strcpy(buf, p54u_firmware_upload_3887);
471 left -= strlen(p54u_firmware_upload_3887);
472 tmp += strlen(p54u_firmware_upload_3887);
474 data = priv->fw->data;
475 remains = priv->fw->size;
477 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
478 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
479 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
480 hdr->fw_length = cpu_to_le32(priv->fw->size);
481 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
483 left -= sizeof(*hdr);
511 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
513 dev_err(&priv->udev->dev, "(p54usb) firmware "
515 goto err_upload_failed;
519 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
522 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
524 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
526 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
527 goto err_upload_failed;
529 timeout = jiffies + msecs_to_jiffies(1000);
530 while (!(err = usb_bulk_msg(priv->udev,
531 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
532 if (alen > 2 && !memcmp(buf, "OK", 2))
535 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
540 if (time_after(jiffies, timeout)) {
541 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
548 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
549 goto err_upload_failed;
554 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
556 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
557 goto err_upload_failed;
560 timeout = jiffies + msecs_to_jiffies(1000);
561 while (!(err = usb_bulk_msg(priv->udev,
562 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
563 if (alen > 0 && buf[0] == 'g')
566 if (time_after(jiffies, timeout)) {
572 goto err_upload_failed;
579 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
581 struct p54u_priv *priv = dev->priv;
582 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
586 unsigned int remains, offset;
589 buf = kmalloc(512, GFP_KERNEL);
591 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
596 #define P54U_WRITE(type, addr, data) \
598 err = p54u_write(priv, buf, type,\
599 cpu_to_le32((u32)(unsigned long)addr), data);\
604 #define P54U_READ(type, addr) \
606 err = p54u_read(priv, buf, type,\
607 cpu_to_le32((u32)(unsigned long)addr), ®);\
612 /* power down net2280 bridge */
613 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
614 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
615 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
616 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
620 /* power up bridge */
621 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
622 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
623 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
627 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
628 cpu_to_le32(NET2280_CLK_30Mhz |
630 NET2280_PCI_SOFT_RESET));
634 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
635 cpu_to_le32(PCI_COMMAND_MEMORY |
636 PCI_COMMAND_MASTER));
638 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
639 cpu_to_le32(NET2280_BASE));
641 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
642 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
643 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
645 // TODO: we really need this?
646 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
648 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
649 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
650 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
651 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
653 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
654 cpu_to_le32(NET2280_BASE2));
656 /* finally done setting up the bridge */
658 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
659 cpu_to_le32(PCI_COMMAND_MEMORY |
660 PCI_COMMAND_MASTER));
662 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
663 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
664 cpu_to_le32(P54U_DEV_BASE));
666 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
667 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
668 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
671 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
673 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
674 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
675 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
676 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
677 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
681 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
682 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
686 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
687 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
691 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
692 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
694 /* finally, we can upload firmware now! */
695 remains = priv->fw->size;
696 data = priv->fw->data;
697 offset = ISL38XX_DEV_FIRMWARE_ADDR;
700 unsigned int block_len = min(remains, (unsigned int)512);
701 memcpy(buf, data, block_len);
703 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
705 dev_err(&priv->udev->dev, "(p54usb) firmware block "
710 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
711 cpu_to_le32(0xc0000f00));
713 P54U_WRITE(NET2280_DEV_U32,
714 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
715 P54U_WRITE(NET2280_DEV_U32,
716 0x0020 | (unsigned long)&devreg->direct_mem_win,
719 P54U_WRITE(NET2280_DEV_U32,
720 0x0024 | (unsigned long)&devreg->direct_mem_win,
721 cpu_to_le32(block_len));
722 P54U_WRITE(NET2280_DEV_U32,
723 0x0028 | (unsigned long)&devreg->direct_mem_win,
724 cpu_to_le32(offset));
726 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
727 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
728 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
729 cpu_to_le32(block_len >> 2));
730 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
731 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
735 P54U_READ(NET2280_DEV_U32,
736 0x002C | (unsigned long)&devreg->direct_mem_win);
737 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
738 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
739 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
740 "transfer failed\n");
744 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
745 cpu_to_le32(NET2280_FIFO_FLUSH));
747 remains -= block_len;
753 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
754 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
755 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
756 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
757 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
761 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
762 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);
769 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
770 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
772 /* start up the firmware */
773 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
774 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
776 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
777 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
779 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
780 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
781 NET2280_USB_INTERRUPT_ENABLE));
783 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
784 cpu_to_le32(ISL38XX_DEV_INT_RESET));
786 err = usb_interrupt_msg(priv->udev,
787 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
788 buf, sizeof(__le32), &alen, 1000);
789 if (err || alen != sizeof(__le32))
792 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
793 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
795 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
798 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
799 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
800 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
810 static int p54u_load_firmware(struct ieee80211_hw *dev)
812 struct p54u_priv *priv = dev->priv;
815 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
817 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
818 if (p54u_fwlist[i].type == priv->hw_type)
821 if (i == __NUM_P54U_HWTYPES)
824 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
826 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
827 "(%d)!\n", p54u_fwlist[i].fw, err);
829 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
835 err = p54_parse_firmware(dev, priv->fw);
839 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
840 dev_err(&priv->udev->dev, "wrong firmware, please get "
841 "a firmware for \"%s\" and try again.\n",
848 release_firmware(priv->fw);
853 static int p54u_open(struct ieee80211_hw *dev)
855 struct p54u_priv *priv = dev->priv;
858 err = p54u_init_urbs(dev);
863 priv->common.open = p54u_init_urbs;
868 static void p54u_stop(struct ieee80211_hw *dev)
870 /* TODO: figure out how to reliably stop the 3887 and net2280 so
871 the hardware is still usable next time we want to start it.
872 until then, we just stop listening to the hardware.. */
877 static int __devinit p54u_probe(struct usb_interface *intf,
878 const struct usb_device_id *id)
880 struct usb_device *udev = interface_to_usbdev(intf);
881 struct ieee80211_hw *dev;
882 struct p54u_priv *priv;
884 unsigned int i, recognized_pipes;
886 dev = p54_init_common(sizeof(*priv));
889 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
894 priv->hw_type = P54U_INVALID_HW;
896 SET_IEEE80211_DEV(dev, &intf->dev);
897 usb_set_intfdata(intf, dev);
900 skb_queue_head_init(&priv->rx_queue);
901 init_usb_anchor(&priv->submitted);
905 /* really lazy and simple way of figuring out if we're a 3887 */
906 /* TODO: should just stick the identification in the device table */
907 i = intf->altsetting->desc.bNumEndpoints;
908 recognized_pipes = 0;
910 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
915 case P54U_PIPE_DATA | USB_DIR_IN:
916 case P54U_PIPE_MGMT | USB_DIR_IN:
917 case P54U_PIPE_BRG | USB_DIR_IN:
918 case P54U_PIPE_DEV | USB_DIR_IN:
919 case P54U_PIPE_INT | USB_DIR_IN:
923 priv->common.open = p54u_open;
924 priv->common.stop = p54u_stop;
925 if (recognized_pipes < P54U_PIPE_NUMBER) {
927 /* ISL3887 needs a full reset on resume */
928 udev->reset_resume = 1;
929 err = p54u_device_reset(dev);
932 priv->hw_type = P54U_3887;
933 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
934 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
935 priv->common.tx = p54u_tx_lm87;
936 priv->upload_fw = p54u_upload_firmware_3887;
938 priv->hw_type = P54U_NET2280;
939 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
940 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
941 priv->common.tx = p54u_tx_net2280;
942 priv->upload_fw = p54u_upload_firmware_net2280;
944 err = p54u_load_firmware(dev);
948 err = priv->upload_fw(dev);
953 err = p54_read_eeprom(dev);
958 err = p54_register_common(dev, &udev->dev);
965 release_firmware(priv->fw);
968 p54_free_common(dev);
969 usb_set_intfdata(intf, NULL);
974 static void __devexit p54u_disconnect(struct usb_interface *intf)
976 struct ieee80211_hw *dev = usb_get_intfdata(intf);
977 struct p54u_priv *priv;
982 p54_unregister_common(dev);
985 usb_put_dev(interface_to_usbdev(intf));
986 release_firmware(priv->fw);
987 p54_free_common(dev);
990 static int p54u_pre_reset(struct usb_interface *intf)
992 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1001 static int p54u_resume(struct usb_interface *intf)
1003 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1004 struct p54u_priv *priv;
1010 if (unlikely(!(priv->upload_fw && priv->fw)))
1013 return priv->upload_fw(dev);
1016 static int p54u_post_reset(struct usb_interface *intf)
1018 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1019 struct p54u_priv *priv;
1022 err = p54u_resume(intf);
1026 /* reinitialize old device state */
1028 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1029 ieee80211_restart_hw(dev);
1036 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1038 return p54u_pre_reset(intf);
1041 #endif /* CONFIG_PM */
1043 static struct usb_driver p54u_driver = {
1045 .id_table = p54u_table,
1046 .probe = p54u_probe,
1047 .disconnect = p54u_disconnect,
1048 .pre_reset = p54u_pre_reset,
1049 .post_reset = p54u_post_reset,
1051 .suspend = p54u_suspend,
1052 .resume = p54u_resume,
1053 .reset_resume = p54u_resume,
1054 #endif /* CONFIG_PM */
1058 static int __init p54u_init(void)
1060 return usb_register(&p54u_driver);
1063 static void __exit p54u_exit(void)
1065 usb_deregister(&p54u_driver);
1068 module_init(p54u_init);
1069 module_exit(p54u_exit);