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(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */
40 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
41 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
42 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
43 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
44 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
45 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
46 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
47 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
48 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
49 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
50 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
51 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
52 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
53 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
54 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
55 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
56 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
58 /* Version 2 devices (3887) */
59 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
60 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
61 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
62 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
63 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
64 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
65 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
66 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
67 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
68 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
69 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
70 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
71 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
72 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
73 * just noting it here for clarity */
74 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
75 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
76 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
77 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
78 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
79 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
80 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
81 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
82 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
83 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
84 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
85 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
86 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
90 MODULE_DEVICE_TABLE(usb, p54u_table);
94 enum p54u_hw_type type;
96 const char *fw_legacy;
98 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
100 .type = P54U_NET2280,
103 .fw_legacy = "isl3890usb",
104 .hw = "ISL3886 + net2280",
110 .fw_legacy = "isl3887usb_bare",
115 static void p54u_rx_cb(struct urb *urb)
117 struct sk_buff *skb = (struct sk_buff *) urb->context;
118 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
119 struct ieee80211_hw *dev = info->dev;
120 struct p54u_priv *priv = dev->priv;
122 skb_unlink(skb, &priv->rx_queue);
124 if (unlikely(urb->status)) {
125 dev_kfree_skb_irq(skb);
129 skb_put(skb, urb->actual_length);
131 if (priv->hw_type == P54U_NET2280)
132 skb_pull(skb, priv->common.tx_hdr_len);
133 if (priv->common.fw_interface == FW_LM87) {
138 if (p54_rx(dev, skb)) {
139 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
140 if (unlikely(!skb)) {
141 /* TODO check rx queue length and refill *somewhere* */
145 info = (struct p54u_rx_info *) skb->cb;
148 urb->transfer_buffer = skb_tail_pointer(skb);
151 if (priv->hw_type == P54U_NET2280)
152 skb_push(skb, priv->common.tx_hdr_len);
153 if (priv->common.fw_interface == FW_LM87) {
157 skb_reset_tail_pointer(skb);
159 urb->transfer_buffer = skb_tail_pointer(skb);
161 skb_queue_tail(&priv->rx_queue, skb);
162 usb_anchor_urb(urb, &priv->submitted);
163 if (usb_submit_urb(urb, GFP_ATOMIC)) {
164 skb_unlink(skb, &priv->rx_queue);
165 usb_unanchor_urb(urb);
166 dev_kfree_skb_irq(skb);
170 static void p54u_tx_cb(struct urb *urb)
172 struct sk_buff *skb = urb->context;
173 struct ieee80211_hw *dev = (struct ieee80211_hw *)
174 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
176 p54_free_skb(dev, skb);
179 static void p54u_tx_dummy_cb(struct urb *urb) { }
181 static void p54u_free_urbs(struct ieee80211_hw *dev)
183 struct p54u_priv *priv = dev->priv;
184 usb_kill_anchored_urbs(&priv->submitted);
187 static int p54u_init_urbs(struct ieee80211_hw *dev)
189 struct p54u_priv *priv = dev->priv;
190 struct urb *entry = NULL;
192 struct p54u_rx_info *info;
195 while (skb_queue_len(&priv->rx_queue) < 32) {
196 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
201 entry = usb_alloc_urb(0, GFP_KERNEL);
207 usb_fill_bulk_urb(entry, priv->udev,
208 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
209 skb_tail_pointer(skb),
210 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
211 info = (struct p54u_rx_info *) skb->cb;
214 skb_queue_tail(&priv->rx_queue, skb);
216 usb_anchor_urb(entry, &priv->submitted);
217 ret = usb_submit_urb(entry, GFP_KERNEL);
219 skb_unlink(skb, &priv->rx_queue);
220 usb_unanchor_urb(entry);
236 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
242 chk ^= le32_to_cpu(*data++);
243 chk = (chk >> 5) ^ (chk << 3);
246 return cpu_to_le32(chk);
249 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
251 struct p54u_priv *priv = dev->priv;
252 struct urb *data_urb;
253 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
255 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
257 p54_free_skb(dev, skb);
261 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
262 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
264 usb_fill_bulk_urb(data_urb, priv->udev,
265 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
266 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
267 p54u_tx_cb : p54u_tx_dummy_cb, skb);
268 data_urb->transfer_flags |= URB_ZERO_PACKET;
270 usb_anchor_urb(data_urb, &priv->submitted);
271 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
272 usb_unanchor_urb(data_urb);
273 p54_free_skb(dev, skb);
275 usb_free_urb(data_urb);
278 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
280 struct p54u_priv *priv = dev->priv;
281 struct urb *int_urb = NULL, *data_urb = NULL;
282 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
283 struct net2280_reg_write *reg = NULL;
286 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
290 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
294 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
298 reg->port = cpu_to_le16(NET2280_DEV_U32);
299 reg->addr = cpu_to_le32(P54U_DEV_BASE);
300 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
302 memset(hdr, 0, sizeof(*hdr));
303 hdr->len = cpu_to_le16(skb->len);
304 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
306 usb_fill_bulk_urb(int_urb, priv->udev,
307 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
308 p54u_tx_dummy_cb, dev);
311 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
312 * free what is inside the transfer_buffer after the last reference to
313 * the int_urb is dropped.
315 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
318 usb_fill_bulk_urb(data_urb, priv->udev,
319 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
320 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
321 p54u_tx_cb : p54u_tx_dummy_cb, skb);
322 data_urb->transfer_flags |= URB_ZERO_PACKET;
324 usb_anchor_urb(int_urb, &priv->submitted);
325 err = usb_submit_urb(int_urb, GFP_ATOMIC);
327 usb_unanchor_urb(int_urb);
331 usb_anchor_urb(data_urb, &priv->submitted);
332 err = usb_submit_urb(data_urb, GFP_ATOMIC);
334 usb_unanchor_urb(data_urb);
338 usb_free_urb(int_urb);
339 usb_free_urb(data_urb);
343 p54_free_skb(dev, skb);
347 static int p54u_write(struct p54u_priv *priv,
348 struct net2280_reg_write *buf,
349 enum net2280_op_type type,
350 __le32 addr, __le32 val)
356 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
358 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
360 buf->port = cpu_to_le16(type);
364 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
367 static int p54u_read(struct p54u_priv *priv, void *buf,
368 enum net2280_op_type type,
369 __le32 addr, __le32 *val)
371 struct net2280_reg_read *read = buf;
381 read->port = cpu_to_le16(type);
384 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
385 read, sizeof(*read), &alen, 1000);
389 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
390 reg, sizeof(*reg), &alen, 1000);
398 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
399 void *data, size_t len)
402 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
403 data, len, &alen, 2000);
406 static int p54u_device_reset(struct ieee80211_hw *dev)
408 struct p54u_priv *priv = dev->priv;
409 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
412 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
414 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
415 "device for reset (%d)!\n", ret);
420 ret = usb_reset_device(priv->udev);
422 usb_unlock_device(priv->udev);
425 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
426 "device (%d)!\n", ret);
431 static const char p54u_romboot_3887[] = "~~~~";
432 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
434 struct p54u_priv *priv = dev->priv;
438 buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
441 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
445 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
446 "boot ROM (%d)!\n", ret);
451 static const char p54u_firmware_upload_3887[] = "<\r";
452 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
454 struct p54u_priv *priv = dev->priv;
459 unsigned int left, remains, block_size;
460 struct x2_header *hdr;
461 unsigned long timeout;
463 err = p54u_firmware_reset_3887(dev);
467 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
469 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
474 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
475 strcpy(buf, p54u_firmware_upload_3887);
476 left -= strlen(p54u_firmware_upload_3887);
477 tmp += strlen(p54u_firmware_upload_3887);
479 data = priv->fw->data;
480 remains = priv->fw->size;
482 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
483 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
484 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
485 hdr->fw_length = cpu_to_le32(priv->fw->size);
486 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
488 left -= sizeof(*hdr);
516 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
518 dev_err(&priv->udev->dev, "(p54usb) firmware "
520 goto err_upload_failed;
524 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
527 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
529 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
531 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
532 goto err_upload_failed;
534 timeout = jiffies + msecs_to_jiffies(1000);
535 while (!(err = usb_bulk_msg(priv->udev,
536 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
537 if (alen > 2 && !memcmp(buf, "OK", 2))
540 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
545 if (time_after(jiffies, timeout)) {
546 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
553 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
554 goto err_upload_failed;
559 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
561 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
562 goto err_upload_failed;
565 timeout = jiffies + msecs_to_jiffies(1000);
566 while (!(err = usb_bulk_msg(priv->udev,
567 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
568 if (alen > 0 && buf[0] == 'g')
571 if (time_after(jiffies, timeout)) {
577 goto err_upload_failed;
584 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
586 struct p54u_priv *priv = dev->priv;
587 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
591 unsigned int remains, offset;
594 buf = kmalloc(512, GFP_KERNEL);
596 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
601 #define P54U_WRITE(type, addr, data) \
603 err = p54u_write(priv, buf, type,\
604 cpu_to_le32((u32)(unsigned long)addr), data);\
609 #define P54U_READ(type, addr) \
611 err = p54u_read(priv, buf, type,\
612 cpu_to_le32((u32)(unsigned long)addr), ®);\
617 /* power down net2280 bridge */
618 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
619 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
620 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
621 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
625 /* power up bridge */
626 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
627 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
628 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
632 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
633 cpu_to_le32(NET2280_CLK_30Mhz |
635 NET2280_PCI_SOFT_RESET));
639 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
640 cpu_to_le32(PCI_COMMAND_MEMORY |
641 PCI_COMMAND_MASTER));
643 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
644 cpu_to_le32(NET2280_BASE));
646 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
647 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
648 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
650 // TODO: we really need this?
651 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
653 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
654 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
655 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
656 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
658 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
659 cpu_to_le32(NET2280_BASE2));
661 /* finally done setting up the bridge */
663 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
664 cpu_to_le32(PCI_COMMAND_MEMORY |
665 PCI_COMMAND_MASTER));
667 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
668 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
669 cpu_to_le32(P54U_DEV_BASE));
671 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
672 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
673 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
676 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
678 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
679 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
680 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
681 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
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 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
692 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
696 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
697 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
699 /* finally, we can upload firmware now! */
700 remains = priv->fw->size;
701 data = priv->fw->data;
702 offset = ISL38XX_DEV_FIRMWARE_ADDR;
705 unsigned int block_len = min(remains, (unsigned int)512);
706 memcpy(buf, data, block_len);
708 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
710 dev_err(&priv->udev->dev, "(p54usb) firmware block "
715 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
716 cpu_to_le32(0xc0000f00));
718 P54U_WRITE(NET2280_DEV_U32,
719 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
720 P54U_WRITE(NET2280_DEV_U32,
721 0x0020 | (unsigned long)&devreg->direct_mem_win,
724 P54U_WRITE(NET2280_DEV_U32,
725 0x0024 | (unsigned long)&devreg->direct_mem_win,
726 cpu_to_le32(block_len));
727 P54U_WRITE(NET2280_DEV_U32,
728 0x0028 | (unsigned long)&devreg->direct_mem_win,
729 cpu_to_le32(offset));
731 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
732 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
733 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
734 cpu_to_le32(block_len >> 2));
735 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
736 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
740 P54U_READ(NET2280_DEV_U32,
741 0x002C | (unsigned long)&devreg->direct_mem_win);
742 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
743 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
744 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
745 "transfer failed\n");
749 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
750 cpu_to_le32(NET2280_FIFO_FLUSH));
752 remains -= block_len;
758 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
759 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
760 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
761 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
762 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);
769 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
770 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
774 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
775 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
777 /* start up the firmware */
778 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
779 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
781 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
782 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
784 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
785 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
786 NET2280_USB_INTERRUPT_ENABLE));
788 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
789 cpu_to_le32(ISL38XX_DEV_INT_RESET));
791 err = usb_interrupt_msg(priv->udev,
792 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
793 buf, sizeof(__le32), &alen, 1000);
794 if (err || alen != sizeof(__le32))
797 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
798 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
800 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
803 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
804 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
805 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
815 static int p54u_load_firmware(struct ieee80211_hw *dev)
817 struct p54u_priv *priv = dev->priv;
820 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
822 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
823 if (p54u_fwlist[i].type == priv->hw_type)
826 if (i == __NUM_P54U_HWTYPES)
829 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
831 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
832 "(%d)!\n", p54u_fwlist[i].fw, err);
834 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
840 err = p54_parse_firmware(dev, priv->fw);
844 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
845 dev_err(&priv->udev->dev, "wrong firmware, please get "
846 "a firmware for \"%s\" and try again.\n",
853 release_firmware(priv->fw);
858 static int p54u_open(struct ieee80211_hw *dev)
860 struct p54u_priv *priv = dev->priv;
863 err = p54u_init_urbs(dev);
868 priv->common.open = p54u_init_urbs;
873 static void p54u_stop(struct ieee80211_hw *dev)
875 /* TODO: figure out how to reliably stop the 3887 and net2280 so
876 the hardware is still usable next time we want to start it.
877 until then, we just stop listening to the hardware.. */
881 static int __devinit p54u_probe(struct usb_interface *intf,
882 const struct usb_device_id *id)
884 struct usb_device *udev = interface_to_usbdev(intf);
885 struct ieee80211_hw *dev;
886 struct p54u_priv *priv;
888 unsigned int i, recognized_pipes;
890 dev = p54_init_common(sizeof(*priv));
893 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
898 priv->hw_type = P54U_INVALID_HW;
900 SET_IEEE80211_DEV(dev, &intf->dev);
901 usb_set_intfdata(intf, dev);
904 skb_queue_head_init(&priv->rx_queue);
905 init_usb_anchor(&priv->submitted);
909 /* really lazy and simple way of figuring out if we're a 3887 */
910 /* TODO: should just stick the identification in the device table */
911 i = intf->altsetting->desc.bNumEndpoints;
912 recognized_pipes = 0;
914 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
919 case P54U_PIPE_DATA | USB_DIR_IN:
920 case P54U_PIPE_MGMT | USB_DIR_IN:
921 case P54U_PIPE_BRG | USB_DIR_IN:
922 case P54U_PIPE_DEV | USB_DIR_IN:
923 case P54U_PIPE_INT | USB_DIR_IN:
927 priv->common.open = p54u_open;
928 priv->common.stop = p54u_stop;
929 if (recognized_pipes < P54U_PIPE_NUMBER) {
931 /* ISL3887 needs a full reset on resume */
932 udev->reset_resume = 1;
933 #endif /* CONFIG_PM */
934 err = p54u_device_reset(dev);
936 priv->hw_type = P54U_3887;
937 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
938 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
939 priv->common.tx = p54u_tx_lm87;
940 priv->upload_fw = p54u_upload_firmware_3887;
942 priv->hw_type = P54U_NET2280;
943 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
944 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
945 priv->common.tx = p54u_tx_net2280;
946 priv->upload_fw = p54u_upload_firmware_net2280;
948 err = p54u_load_firmware(dev);
952 err = priv->upload_fw(dev);
957 err = p54_read_eeprom(dev);
962 err = p54_register_common(dev, &udev->dev);
969 release_firmware(priv->fw);
972 p54_free_common(dev);
973 usb_set_intfdata(intf, NULL);
978 static void __devexit p54u_disconnect(struct usb_interface *intf)
980 struct ieee80211_hw *dev = usb_get_intfdata(intf);
981 struct p54u_priv *priv;
986 p54_unregister_common(dev);
989 usb_put_dev(interface_to_usbdev(intf));
990 release_firmware(priv->fw);
991 p54_free_common(dev);
994 static int p54u_pre_reset(struct usb_interface *intf)
996 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1005 static int p54u_resume(struct usb_interface *intf)
1007 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1008 struct p54u_priv *priv;
1014 if (unlikely(!(priv->upload_fw && priv->fw)))
1017 return priv->upload_fw(dev);
1020 static int p54u_post_reset(struct usb_interface *intf)
1022 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1023 struct p54u_priv *priv;
1026 err = p54u_resume(intf);
1030 /* reinitialize old device state */
1032 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1033 ieee80211_restart_hw(dev);
1040 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1042 return p54u_pre_reset(intf);
1045 #endif /* CONFIG_PM */
1047 static struct usb_driver p54u_driver = {
1049 .id_table = p54u_table,
1050 .probe = p54u_probe,
1051 .disconnect = p54u_disconnect,
1052 .pre_reset = p54u_pre_reset,
1053 .post_reset = p54u_post_reset,
1055 .suspend = p54u_suspend,
1056 .resume = p54u_resume,
1057 .reset_resume = p54u_resume,
1058 #endif /* CONFIG_PM */
1062 static int __init p54u_init(void)
1064 return usb_register(&p54u_driver);
1067 static void __exit p54u_exit(void)
1069 usb_deregister(&p54u_driver);
1072 module_init(p54u_init);
1073 module_exit(p54u_exit);