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(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
40 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
41 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
42 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
43 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
44 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
45 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
46 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
47 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
48 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
49 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
50 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
51 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
52 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
53 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
54 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
56 /* Version 2 devices (3887) */
57 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
58 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
59 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
60 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
61 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
62 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
63 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
64 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
65 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
66 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
67 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
68 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
69 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
70 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
71 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
72 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
73 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
74 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
75 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
76 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
77 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
78 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
79 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
80 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
81 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
82 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
86 MODULE_DEVICE_TABLE(usb, p54u_table);
90 enum p54u_hw_type type;
92 const char *fw_legacy;
94 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
99 .fw_legacy = "isl3890usb",
100 .hw = "ISL3886 + net2280",
106 .fw_legacy = "isl3887usb_bare",
111 static void p54u_rx_cb(struct urb *urb)
113 struct sk_buff *skb = (struct sk_buff *) urb->context;
114 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
115 struct ieee80211_hw *dev = info->dev;
116 struct p54u_priv *priv = dev->priv;
118 skb_unlink(skb, &priv->rx_queue);
120 if (unlikely(urb->status)) {
121 dev_kfree_skb_irq(skb);
125 skb_put(skb, urb->actual_length);
127 if (priv->hw_type == P54U_NET2280)
128 skb_pull(skb, priv->common.tx_hdr_len);
129 if (priv->common.fw_interface == FW_LM87) {
134 if (p54_rx(dev, skb)) {
135 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
136 if (unlikely(!skb)) {
137 /* TODO check rx queue length and refill *somewhere* */
141 info = (struct p54u_rx_info *) skb->cb;
144 urb->transfer_buffer = skb_tail_pointer(skb);
147 if (priv->hw_type == P54U_NET2280)
148 skb_push(skb, priv->common.tx_hdr_len);
149 if (priv->common.fw_interface == FW_LM87) {
153 skb_reset_tail_pointer(skb);
155 urb->transfer_buffer = skb_tail_pointer(skb);
157 skb_queue_tail(&priv->rx_queue, skb);
158 usb_anchor_urb(urb, &priv->submitted);
159 if (usb_submit_urb(urb, GFP_ATOMIC)) {
160 skb_unlink(skb, &priv->rx_queue);
161 usb_unanchor_urb(urb);
162 dev_kfree_skb_irq(skb);
166 static void p54u_tx_cb(struct urb *urb)
168 struct sk_buff *skb = urb->context;
169 struct ieee80211_hw *dev = (struct ieee80211_hw *)
170 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
172 p54_free_skb(dev, skb);
175 static void p54u_tx_dummy_cb(struct urb *urb) { }
177 static void p54u_free_urbs(struct ieee80211_hw *dev)
179 struct p54u_priv *priv = dev->priv;
180 usb_kill_anchored_urbs(&priv->submitted);
183 static int p54u_init_urbs(struct ieee80211_hw *dev)
185 struct p54u_priv *priv = dev->priv;
186 struct urb *entry = NULL;
188 struct p54u_rx_info *info;
191 while (skb_queue_len(&priv->rx_queue) < 32) {
192 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
197 entry = usb_alloc_urb(0, GFP_KERNEL);
203 usb_fill_bulk_urb(entry, priv->udev,
204 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
205 skb_tail_pointer(skb),
206 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
207 info = (struct p54u_rx_info *) skb->cb;
210 skb_queue_tail(&priv->rx_queue, skb);
212 usb_anchor_urb(entry, &priv->submitted);
213 ret = usb_submit_urb(entry, GFP_KERNEL);
215 skb_unlink(skb, &priv->rx_queue);
216 usb_unanchor_urb(entry);
232 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
238 chk ^= le32_to_cpu(*data++);
239 chk = (chk >> 5) ^ (chk << 3);
242 return cpu_to_le32(chk);
245 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
247 struct p54u_priv *priv = dev->priv;
248 struct urb *data_urb;
249 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
251 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
253 p54_free_skb(dev, skb);
257 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
258 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
260 usb_fill_bulk_urb(data_urb, priv->udev,
261 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
262 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
263 p54u_tx_cb : p54u_tx_dummy_cb, skb);
264 data_urb->transfer_flags |= URB_ZERO_PACKET;
266 usb_anchor_urb(data_urb, &priv->submitted);
267 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
268 usb_unanchor_urb(data_urb);
269 p54_free_skb(dev, skb);
271 usb_free_urb(data_urb);
274 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
276 struct p54u_priv *priv = dev->priv;
277 struct urb *int_urb = NULL, *data_urb = NULL;
278 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
279 struct net2280_reg_write *reg = NULL;
282 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
286 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
290 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
294 reg->port = cpu_to_le16(NET2280_DEV_U32);
295 reg->addr = cpu_to_le32(P54U_DEV_BASE);
296 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
298 memset(hdr, 0, sizeof(*hdr));
299 hdr->len = cpu_to_le16(skb->len);
300 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
302 usb_fill_bulk_urb(int_urb, priv->udev,
303 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
304 p54u_tx_dummy_cb, dev);
307 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
308 * free what is inside the transfer_buffer after the last reference to
309 * the int_urb is dropped.
311 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
314 usb_fill_bulk_urb(data_urb, priv->udev,
315 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
316 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
317 p54u_tx_cb : p54u_tx_dummy_cb, skb);
318 data_urb->transfer_flags |= URB_ZERO_PACKET;
320 usb_anchor_urb(int_urb, &priv->submitted);
321 err = usb_submit_urb(int_urb, GFP_ATOMIC);
323 usb_unanchor_urb(int_urb);
327 usb_anchor_urb(data_urb, &priv->submitted);
328 err = usb_submit_urb(data_urb, GFP_ATOMIC);
330 usb_unanchor_urb(data_urb);
334 usb_free_urb(int_urb);
335 usb_free_urb(data_urb);
339 p54_free_skb(dev, skb);
343 static int p54u_write(struct p54u_priv *priv,
344 struct net2280_reg_write *buf,
345 enum net2280_op_type type,
346 __le32 addr, __le32 val)
352 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
354 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
356 buf->port = cpu_to_le16(type);
360 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
363 static int p54u_read(struct p54u_priv *priv, void *buf,
364 enum net2280_op_type type,
365 __le32 addr, __le32 *val)
367 struct net2280_reg_read *read = buf;
377 read->port = cpu_to_le16(type);
380 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
381 read, sizeof(*read), &alen, 1000);
385 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
386 reg, sizeof(*reg), &alen, 1000);
394 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
395 void *data, size_t len)
398 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
399 data, len, &alen, 2000);
402 static int p54u_device_reset(struct ieee80211_hw *dev)
404 struct p54u_priv *priv = dev->priv;
405 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
408 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
410 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
411 "device for reset (%d)!\n", ret);
416 ret = usb_reset_device(priv->udev);
418 usb_unlock_device(priv->udev);
421 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
422 "device (%d)!\n", ret);
427 static const char p54u_romboot_3887[] = "~~~~";
428 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
430 struct p54u_priv *priv = dev->priv;
434 buf = kmalloc(4, GFP_KERNEL);
437 memcpy(buf, p54u_romboot_3887, 4);
438 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
442 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
443 "boot ROM (%d)!\n", ret);
448 static const char p54u_firmware_upload_3887[] = "<\r";
449 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
451 struct p54u_priv *priv = dev->priv;
456 unsigned int left, remains, block_size;
457 struct x2_header *hdr;
458 unsigned long timeout;
460 err = p54u_firmware_reset_3887(dev);
464 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
466 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
471 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
472 strcpy(buf, p54u_firmware_upload_3887);
473 left -= strlen(p54u_firmware_upload_3887);
474 tmp += strlen(p54u_firmware_upload_3887);
476 data = priv->fw->data;
477 remains = priv->fw->size;
479 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
480 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
481 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
482 hdr->fw_length = cpu_to_le32(priv->fw->size);
483 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
485 left -= sizeof(*hdr);
513 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
515 dev_err(&priv->udev->dev, "(p54usb) firmware "
517 goto err_upload_failed;
521 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
524 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
526 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
528 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
529 goto err_upload_failed;
531 timeout = jiffies + msecs_to_jiffies(1000);
532 while (!(err = usb_bulk_msg(priv->udev,
533 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
534 if (alen > 2 && !memcmp(buf, "OK", 2))
537 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
542 if (time_after(jiffies, timeout)) {
543 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
550 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
551 goto err_upload_failed;
556 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
558 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
559 goto err_upload_failed;
562 timeout = jiffies + msecs_to_jiffies(1000);
563 while (!(err = usb_bulk_msg(priv->udev,
564 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
565 if (alen > 0 && buf[0] == 'g')
568 if (time_after(jiffies, timeout)) {
574 goto err_upload_failed;
581 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
583 struct p54u_priv *priv = dev->priv;
584 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
588 unsigned int remains, offset;
591 buf = kmalloc(512, GFP_KERNEL);
593 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
598 #define P54U_WRITE(type, addr, data) \
600 err = p54u_write(priv, buf, type,\
601 cpu_to_le32((u32)(unsigned long)addr), data);\
606 #define P54U_READ(type, addr) \
608 err = p54u_read(priv, buf, type,\
609 cpu_to_le32((u32)(unsigned long)addr), ®);\
614 /* power down net2280 bridge */
615 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
616 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
617 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
618 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
622 /* power up bridge */
623 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
624 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
625 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
629 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
630 cpu_to_le32(NET2280_CLK_30Mhz |
632 NET2280_PCI_SOFT_RESET));
636 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
637 cpu_to_le32(PCI_COMMAND_MEMORY |
638 PCI_COMMAND_MASTER));
640 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
641 cpu_to_le32(NET2280_BASE));
643 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
644 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
645 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
647 // TODO: we really need this?
648 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
650 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
651 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
652 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
653 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
655 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
656 cpu_to_le32(NET2280_BASE2));
658 /* finally done setting up the bridge */
660 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
661 cpu_to_le32(PCI_COMMAND_MEMORY |
662 PCI_COMMAND_MASTER));
664 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
665 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
666 cpu_to_le32(P54U_DEV_BASE));
668 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
669 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
670 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
673 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
675 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
676 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
677 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
678 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
679 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
683 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
684 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
688 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
689 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
693 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
694 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
696 /* finally, we can upload firmware now! */
697 remains = priv->fw->size;
698 data = priv->fw->data;
699 offset = ISL38XX_DEV_FIRMWARE_ADDR;
702 unsigned int block_len = min(remains, (unsigned int)512);
703 memcpy(buf, data, block_len);
705 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
707 dev_err(&priv->udev->dev, "(p54usb) firmware block "
712 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
713 cpu_to_le32(0xc0000f00));
715 P54U_WRITE(NET2280_DEV_U32,
716 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
717 P54U_WRITE(NET2280_DEV_U32,
718 0x0020 | (unsigned long)&devreg->direct_mem_win,
721 P54U_WRITE(NET2280_DEV_U32,
722 0x0024 | (unsigned long)&devreg->direct_mem_win,
723 cpu_to_le32(block_len));
724 P54U_WRITE(NET2280_DEV_U32,
725 0x0028 | (unsigned long)&devreg->direct_mem_win,
726 cpu_to_le32(offset));
728 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
729 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
730 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
731 cpu_to_le32(block_len >> 2));
732 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
733 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
737 P54U_READ(NET2280_DEV_U32,
738 0x002C | (unsigned long)&devreg->direct_mem_win);
739 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
740 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
741 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
742 "transfer failed\n");
746 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
747 cpu_to_le32(NET2280_FIFO_FLUSH));
749 remains -= block_len;
755 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
756 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
757 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
758 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
759 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
763 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
764 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
766 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
767 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
771 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
772 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
774 /* start up the firmware */
775 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
776 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
778 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
779 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
781 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
782 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
783 NET2280_USB_INTERRUPT_ENABLE));
785 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
786 cpu_to_le32(ISL38XX_DEV_INT_RESET));
788 err = usb_interrupt_msg(priv->udev,
789 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
790 buf, sizeof(__le32), &alen, 1000);
791 if (err || alen != sizeof(__le32))
794 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
795 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
797 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
800 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
801 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
802 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
812 static int p54u_load_firmware(struct ieee80211_hw *dev)
814 struct p54u_priv *priv = dev->priv;
817 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
819 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
820 if (p54u_fwlist[i].type == priv->hw_type)
823 if (i == __NUM_P54U_HWTYPES)
826 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
828 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
829 "(%d)!\n", p54u_fwlist[i].fw, err);
831 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
837 err = p54_parse_firmware(dev, priv->fw);
841 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
842 dev_err(&priv->udev->dev, "wrong firmware, please get "
843 "a firmware for \"%s\" and try again.\n",
850 release_firmware(priv->fw);
855 static int p54u_open(struct ieee80211_hw *dev)
857 struct p54u_priv *priv = dev->priv;
860 err = p54u_init_urbs(dev);
865 priv->common.open = p54u_init_urbs;
870 static void p54u_stop(struct ieee80211_hw *dev)
872 /* TODO: figure out how to reliably stop the 3887 and net2280 so
873 the hardware is still usable next time we want to start it.
874 until then, we just stop listening to the hardware.. */
879 static int __devinit p54u_probe(struct usb_interface *intf,
880 const struct usb_device_id *id)
882 struct usb_device *udev = interface_to_usbdev(intf);
883 struct ieee80211_hw *dev;
884 struct p54u_priv *priv;
886 unsigned int i, recognized_pipes;
888 dev = p54_init_common(sizeof(*priv));
891 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
896 priv->hw_type = P54U_INVALID_HW;
898 SET_IEEE80211_DEV(dev, &intf->dev);
899 usb_set_intfdata(intf, dev);
902 skb_queue_head_init(&priv->rx_queue);
903 init_usb_anchor(&priv->submitted);
907 /* really lazy and simple way of figuring out if we're a 3887 */
908 /* TODO: should just stick the identification in the device table */
909 i = intf->altsetting->desc.bNumEndpoints;
910 recognized_pipes = 0;
912 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
917 case P54U_PIPE_DATA | USB_DIR_IN:
918 case P54U_PIPE_MGMT | USB_DIR_IN:
919 case P54U_PIPE_BRG | USB_DIR_IN:
920 case P54U_PIPE_DEV | USB_DIR_IN:
921 case P54U_PIPE_INT | USB_DIR_IN:
925 priv->common.open = p54u_open;
926 priv->common.stop = p54u_stop;
927 if (recognized_pipes < P54U_PIPE_NUMBER) {
929 /* ISL3887 needs a full reset on resume */
930 udev->reset_resume = 1;
931 err = p54u_device_reset(dev);
934 priv->hw_type = P54U_3887;
935 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
936 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
937 priv->common.tx = p54u_tx_lm87;
938 priv->upload_fw = p54u_upload_firmware_3887;
940 priv->hw_type = P54U_NET2280;
941 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
942 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
943 priv->common.tx = p54u_tx_net2280;
944 priv->upload_fw = p54u_upload_firmware_net2280;
946 err = p54u_load_firmware(dev);
950 err = priv->upload_fw(dev);
955 err = p54_read_eeprom(dev);
960 err = p54_register_common(dev, &udev->dev);
967 release_firmware(priv->fw);
970 p54_free_common(dev);
971 usb_set_intfdata(intf, NULL);
976 static void __devexit p54u_disconnect(struct usb_interface *intf)
978 struct ieee80211_hw *dev = usb_get_intfdata(intf);
979 struct p54u_priv *priv;
984 p54_unregister_common(dev);
987 usb_put_dev(interface_to_usbdev(intf));
988 release_firmware(priv->fw);
989 p54_free_common(dev);
992 static int p54u_pre_reset(struct usb_interface *intf)
994 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1003 static int p54u_resume(struct usb_interface *intf)
1005 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1006 struct p54u_priv *priv;
1012 if (unlikely(!(priv->upload_fw && priv->fw)))
1015 return priv->upload_fw(dev);
1018 static int p54u_post_reset(struct usb_interface *intf)
1020 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1021 struct p54u_priv *priv;
1024 err = p54u_resume(intf);
1028 /* reinitialize old device state */
1030 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1031 ieee80211_restart_hw(dev);
1038 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1040 return p54u_pre_reset(intf);
1043 #endif /* CONFIG_PM */
1045 static struct usb_driver p54u_driver = {
1047 .id_table = p54u_table,
1048 .probe = p54u_probe,
1049 .disconnect = p54u_disconnect,
1050 .pre_reset = p54u_pre_reset,
1051 .post_reset = p54u_post_reset,
1053 .suspend = p54u_suspend,
1054 .resume = p54u_resume,
1055 .reset_resume = p54u_resume,
1056 #endif /* CONFIG_PM */
1060 static int __init p54u_init(void)
1062 return usb_register(&p54u_driver);
1065 static void __exit p54u_exit(void)
1067 usb_deregister(&p54u_driver);
1070 module_init(p54u_init);
1071 module_exit(p54u_exit);