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>
27 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
28 MODULE_DESCRIPTION("Prism54 USB wireless driver");
29 MODULE_LICENSE("GPL");
30 MODULE_ALIAS("prism54usb");
31 MODULE_FIRMWARE("isl3886usb");
32 MODULE_FIRMWARE("isl3887usb");
34 static struct usb_device_id p54u_table[] __devinitdata = {
35 /* Version 1 devices (pci chip + net2280) */
36 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
37 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
38 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
39 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
40 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
41 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
42 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
43 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
44 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
45 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
46 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
47 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
48 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
49 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
50 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
51 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
52 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
54 /* Version 2 devices (3887) */
55 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
56 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
57 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
58 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
59 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
60 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
61 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
62 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
63 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
64 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
65 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
66 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
67 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
68 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
69 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
70 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
71 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
72 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
73 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
74 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
75 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
76 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
80 MODULE_DEVICE_TABLE(usb, p54u_table);
82 static void p54u_rx_cb(struct urb *urb)
84 struct sk_buff *skb = (struct sk_buff *) urb->context;
85 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
86 struct ieee80211_hw *dev = info->dev;
87 struct p54u_priv *priv = dev->priv;
89 skb_unlink(skb, &priv->rx_queue);
91 if (unlikely(urb->status)) {
92 dev_kfree_skb_irq(skb);
96 skb_put(skb, urb->actual_length);
98 if (priv->hw_type == P54U_NET2280)
99 skb_pull(skb, priv->common.tx_hdr_len);
100 if (priv->common.fw_interface == FW_LM87) {
105 if (p54_rx(dev, skb)) {
106 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
107 if (unlikely(!skb)) {
108 /* TODO check rx queue length and refill *somewhere* */
112 info = (struct p54u_rx_info *) skb->cb;
115 urb->transfer_buffer = skb_tail_pointer(skb);
118 if (priv->hw_type == P54U_NET2280)
119 skb_push(skb, priv->common.tx_hdr_len);
120 if (priv->common.fw_interface == FW_LM87) {
124 skb_reset_tail_pointer(skb);
126 if (urb->transfer_buffer != skb_tail_pointer(skb)) {
127 /* this should not happen */
129 urb->transfer_buffer = skb_tail_pointer(skb);
132 skb_queue_tail(&priv->rx_queue, skb);
133 usb_anchor_urb(urb, &priv->submitted);
134 if (usb_submit_urb(urb, GFP_ATOMIC)) {
135 skb_unlink(skb, &priv->rx_queue);
136 usb_unanchor_urb(urb);
137 dev_kfree_skb_irq(skb);
141 static void p54u_tx_reuse_skb_cb(struct urb *urb)
143 struct sk_buff *skb = urb->context;
144 struct p54u_priv *priv = (struct p54u_priv *)((struct ieee80211_hw *)
145 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)))->priv;
147 skb_pull(skb, priv->common.tx_hdr_len);
150 static void p54u_tx_free_skb_cb(struct urb *urb)
152 struct sk_buff *skb = urb->context;
153 struct ieee80211_hw *dev = (struct ieee80211_hw *)
154 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
156 p54_free_skb(dev, skb);
159 static void p54u_tx_dummy_cb(struct urb *urb) { }
161 static void p54u_free_urbs(struct ieee80211_hw *dev)
163 struct p54u_priv *priv = dev->priv;
164 usb_kill_anchored_urbs(&priv->submitted);
167 static int p54u_init_urbs(struct ieee80211_hw *dev)
169 struct p54u_priv *priv = dev->priv;
170 struct urb *entry = NULL;
172 struct p54u_rx_info *info;
175 while (skb_queue_len(&priv->rx_queue) < 32) {
176 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
181 entry = usb_alloc_urb(0, GFP_KERNEL);
187 usb_fill_bulk_urb(entry, priv->udev,
188 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
189 skb_tail_pointer(skb),
190 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
191 info = (struct p54u_rx_info *) skb->cb;
194 skb_queue_tail(&priv->rx_queue, skb);
196 usb_anchor_urb(entry, &priv->submitted);
197 ret = usb_submit_urb(entry, GFP_KERNEL);
199 skb_unlink(skb, &priv->rx_queue);
200 usb_unanchor_urb(entry);
216 static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb,
219 struct p54u_priv *priv = dev->priv;
220 struct urb *addr_urb, *data_urb;
223 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
227 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
229 usb_free_urb(addr_urb);
233 usb_fill_bulk_urb(addr_urb, priv->udev,
234 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
235 &((struct p54_hdr *)skb->data)->req_id, 4,
236 p54u_tx_dummy_cb, dev);
237 usb_fill_bulk_urb(data_urb, priv->udev,
238 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
240 free_on_tx ? p54u_tx_free_skb_cb :
241 p54u_tx_reuse_skb_cb, skb);
243 usb_anchor_urb(addr_urb, &priv->submitted);
244 err = usb_submit_urb(addr_urb, GFP_ATOMIC);
246 usb_unanchor_urb(addr_urb);
250 usb_anchor_urb(addr_urb, &priv->submitted);
251 err = usb_submit_urb(data_urb, GFP_ATOMIC);
253 usb_unanchor_urb(data_urb);
256 usb_free_urb(addr_urb);
257 usb_free_urb(data_urb);
260 p54_free_skb(dev, skb);
263 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
269 chk ^= le32_to_cpu(*data++);
270 chk = (chk >> 5) ^ (chk << 3);
273 return cpu_to_le32(chk);
276 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb,
279 struct p54u_priv *priv = dev->priv;
280 struct urb *data_urb;
281 struct lm87_tx_hdr *hdr;
283 __le32 addr = ((struct p54_hdr *)skb->data)->req_id;
285 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
289 checksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
290 hdr = (struct lm87_tx_hdr *)skb_push(skb, sizeof(*hdr));
291 hdr->chksum = checksum;
292 hdr->device_addr = addr;
294 usb_fill_bulk_urb(data_urb, priv->udev,
295 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
297 free_on_tx ? p54u_tx_free_skb_cb :
298 p54u_tx_reuse_skb_cb, skb);
300 usb_anchor_urb(data_urb, &priv->submitted);
301 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
302 usb_unanchor_urb(data_urb);
303 skb_pull(skb, sizeof(*hdr));
304 p54_free_skb(dev, skb);
306 usb_free_urb(data_urb);
309 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb,
312 struct p54u_priv *priv = dev->priv;
313 struct urb *int_urb, *data_urb;
314 struct net2280_tx_hdr *hdr;
315 struct net2280_reg_write *reg;
318 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
322 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
328 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
331 usb_free_urb(int_urb);
335 reg->port = cpu_to_le16(NET2280_DEV_U32);
336 reg->addr = cpu_to_le32(P54U_DEV_BASE);
337 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
339 hdr = (void *)skb_push(skb, sizeof(*hdr));
340 memset(hdr, 0, sizeof(*hdr));
341 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
342 hdr->len = cpu_to_le16(skb->len + sizeof(struct p54_hdr));
344 usb_fill_bulk_urb(int_urb, priv->udev,
345 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
346 p54u_tx_dummy_cb, dev);
349 * This flag triggers a code path in the USB subsystem that will
350 * free what's inside the transfer_buffer after the callback routine
353 int_urb->transfer_flags |= URB_FREE_BUFFER;
355 usb_fill_bulk_urb(data_urb, priv->udev,
356 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
358 free_on_tx ? p54u_tx_free_skb_cb :
359 p54u_tx_reuse_skb_cb, skb);
361 usb_anchor_urb(int_urb, &priv->submitted);
362 err = usb_submit_urb(int_urb, GFP_ATOMIC);
364 usb_unanchor_urb(int_urb);
368 usb_anchor_urb(data_urb, &priv->submitted);
369 err = usb_submit_urb(data_urb, GFP_ATOMIC);
371 usb_unanchor_urb(data_urb);
375 usb_free_urb(int_urb);
376 usb_free_urb(data_urb);
379 skb_pull(skb, sizeof(*hdr));
380 p54_free_skb(dev, skb);
384 static int p54u_write(struct p54u_priv *priv,
385 struct net2280_reg_write *buf,
386 enum net2280_op_type type,
387 __le32 addr, __le32 val)
393 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
395 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
397 buf->port = cpu_to_le16(type);
401 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
404 static int p54u_read(struct p54u_priv *priv, void *buf,
405 enum net2280_op_type type,
406 __le32 addr, __le32 *val)
408 struct net2280_reg_read *read = buf;
418 read->port = cpu_to_le16(type);
421 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
422 read, sizeof(*read), &alen, 1000);
426 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
427 reg, sizeof(*reg), &alen, 1000);
435 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
436 void *data, size_t len)
439 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
440 data, len, &alen, 2000);
443 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
445 static char start_string[] = "~~~~<\r";
446 struct p54u_priv *priv = dev->priv;
447 const struct firmware *fw_entry = NULL;
452 unsigned int left, remains, block_size;
453 struct x2_header *hdr;
454 unsigned long timeout;
456 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
458 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
464 memcpy(buf, start_string, 4);
465 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
467 dev_err(&priv->udev->dev, "(p54usb) reset failed! (%d)\n", err);
471 err = request_firmware(&fw_entry, "isl3887usb", &priv->udev->dev);
473 dev_err(&priv->udev->dev, "p54usb: cannot find firmware "
475 err = request_firmware(&fw_entry, "isl3887usb_bare",
478 goto err_req_fw_failed;
481 err = p54_parse_firmware(dev, fw_entry);
483 goto err_upload_failed;
485 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
486 strcpy(buf, start_string);
487 left -= strlen(start_string);
488 tmp += strlen(start_string);
490 data = fw_entry->data;
491 remains = fw_entry->size;
493 hdr = (struct x2_header *)(buf + strlen(start_string));
494 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
495 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
496 hdr->fw_length = cpu_to_le32(fw_entry->size);
497 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
499 left -= sizeof(*hdr);
527 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
529 dev_err(&priv->udev->dev, "(p54usb) firmware "
531 goto err_upload_failed;
535 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
538 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
539 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
541 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
542 goto err_upload_failed;
544 timeout = jiffies + msecs_to_jiffies(1000);
545 while (!(err = usb_bulk_msg(priv->udev,
546 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
547 if (alen > 2 && !memcmp(buf, "OK", 2))
550 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
555 if (time_after(jiffies, timeout)) {
556 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
563 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
564 goto err_upload_failed;
569 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
571 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
572 goto err_upload_failed;
575 timeout = jiffies + msecs_to_jiffies(1000);
576 while (!(err = usb_bulk_msg(priv->udev,
577 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
578 if (alen > 0 && buf[0] == 'g')
581 if (time_after(jiffies, timeout)) {
587 goto err_upload_failed;
590 release_firmware(fw_entry);
598 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
600 struct p54u_priv *priv = dev->priv;
601 const struct firmware *fw_entry = NULL;
602 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
606 unsigned int remains, offset;
609 buf = kmalloc(512, GFP_KERNEL);
611 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
616 err = request_firmware(&fw_entry, "isl3886usb", &priv->udev->dev);
618 dev_err(&priv->udev->dev, "(p54usb) cannot find firmware "
620 err = request_firmware(&fw_entry, "isl3890usb",
628 err = p54_parse_firmware(dev, fw_entry);
631 release_firmware(fw_entry);
635 #define P54U_WRITE(type, addr, data) \
637 err = p54u_write(priv, buf, type,\
638 cpu_to_le32((u32)(unsigned long)addr), data);\
643 #define P54U_READ(type, addr) \
645 err = p54u_read(priv, buf, type,\
646 cpu_to_le32((u32)(unsigned long)addr), ®);\
651 /* power down net2280 bridge */
652 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
653 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
654 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
655 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
659 /* power up bridge */
660 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
661 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
662 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
666 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
667 cpu_to_le32(NET2280_CLK_30Mhz |
669 NET2280_PCI_SOFT_RESET));
673 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
674 cpu_to_le32(PCI_COMMAND_MEMORY |
675 PCI_COMMAND_MASTER));
677 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
678 cpu_to_le32(NET2280_BASE));
680 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
681 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
682 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
684 // TODO: we really need this?
685 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
687 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
688 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
689 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
690 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
692 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
693 cpu_to_le32(NET2280_BASE2));
695 /* finally done setting up the bridge */
697 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
698 cpu_to_le32(PCI_COMMAND_MEMORY |
699 PCI_COMMAND_MASTER));
701 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
702 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
703 cpu_to_le32(P54U_DEV_BASE));
705 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
706 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
707 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
710 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
712 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
713 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
714 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
715 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
716 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
720 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
721 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
725 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
726 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
730 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
731 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
733 /* finally, we can upload firmware now! */
734 remains = fw_entry->size;
735 data = fw_entry->data;
736 offset = ISL38XX_DEV_FIRMWARE_ADDR;
739 unsigned int block_len = min(remains, (unsigned int)512);
740 memcpy(buf, data, block_len);
742 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
744 dev_err(&priv->udev->dev, "(p54usb) firmware block "
749 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
750 cpu_to_le32(0xc0000f00));
752 P54U_WRITE(NET2280_DEV_U32,
753 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
754 P54U_WRITE(NET2280_DEV_U32,
755 0x0020 | (unsigned long)&devreg->direct_mem_win,
758 P54U_WRITE(NET2280_DEV_U32,
759 0x0024 | (unsigned long)&devreg->direct_mem_win,
760 cpu_to_le32(block_len));
761 P54U_WRITE(NET2280_DEV_U32,
762 0x0028 | (unsigned long)&devreg->direct_mem_win,
763 cpu_to_le32(offset));
765 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
766 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
767 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
768 cpu_to_le32(block_len >> 2));
769 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
770 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
774 P54U_READ(NET2280_DEV_U32,
775 0x002C | (unsigned long)&devreg->direct_mem_win);
776 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
777 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
778 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
779 "transfer failed\n");
783 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
784 cpu_to_le32(NET2280_FIFO_FLUSH));
786 remains -= block_len;
792 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
793 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
794 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
795 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
796 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
800 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
801 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
803 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
804 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
808 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
809 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
811 /* start up the firmware */
812 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
813 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
815 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
816 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
818 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
819 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
820 NET2280_USB_INTERRUPT_ENABLE));
822 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
823 cpu_to_le32(ISL38XX_DEV_INT_RESET));
825 err = usb_interrupt_msg(priv->udev,
826 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
827 buf, sizeof(__le32), &alen, 1000);
828 if (err || alen != sizeof(__le32))
831 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
832 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
834 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
837 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
838 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
839 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
845 release_firmware(fw_entry);
850 static int p54u_open(struct ieee80211_hw *dev)
852 struct p54u_priv *priv = dev->priv;
855 err = p54u_init_urbs(dev);
860 priv->common.open = p54u_init_urbs;
865 static void p54u_stop(struct ieee80211_hw *dev)
867 /* TODO: figure out how to reliably stop the 3887 and net2280 so
868 the hardware is still usable next time we want to start it.
869 until then, we just stop listening to the hardware.. */
874 static int __devinit p54u_probe(struct usb_interface *intf,
875 const struct usb_device_id *id)
877 struct usb_device *udev = interface_to_usbdev(intf);
878 struct ieee80211_hw *dev;
879 struct p54u_priv *priv;
881 unsigned int i, recognized_pipes;
883 dev = p54_init_common(sizeof(*priv));
886 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
892 SET_IEEE80211_DEV(dev, &intf->dev);
893 usb_set_intfdata(intf, dev);
898 /* really lazy and simple way of figuring out if we're a 3887 */
899 /* TODO: should just stick the identification in the device table */
900 i = intf->altsetting->desc.bNumEndpoints;
901 recognized_pipes = 0;
903 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
908 case P54U_PIPE_DATA | USB_DIR_IN:
909 case P54U_PIPE_MGMT | USB_DIR_IN:
910 case P54U_PIPE_BRG | USB_DIR_IN:
911 case P54U_PIPE_DEV | USB_DIR_IN:
912 case P54U_PIPE_INT | USB_DIR_IN:
916 priv->common.open = p54u_open;
917 priv->common.stop = p54u_stop;
918 if (recognized_pipes < P54U_PIPE_NUMBER) {
919 priv->hw_type = P54U_3887;
920 err = p54u_upload_firmware_3887(dev);
921 if (priv->common.fw_interface == FW_LM87) {
922 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
923 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
924 priv->common.tx = p54u_tx_lm87;
926 priv->common.tx = p54u_tx_3887;
928 priv->hw_type = P54U_NET2280;
929 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
930 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
931 priv->common.tx = p54u_tx_net2280;
932 err = p54u_upload_firmware_net2280(dev);
937 skb_queue_head_init(&priv->rx_queue);
938 init_usb_anchor(&priv->submitted);
941 err = p54_read_eeprom(dev);
946 err = ieee80211_register_hw(dev);
948 dev_err(&udev->dev, "(p54usb) Cannot register netdevice\n");
955 ieee80211_free_hw(dev);
956 usb_set_intfdata(intf, NULL);
961 static void __devexit p54u_disconnect(struct usb_interface *intf)
963 struct ieee80211_hw *dev = usb_get_intfdata(intf);
964 struct p54u_priv *priv;
969 ieee80211_unregister_hw(dev);
972 usb_put_dev(interface_to_usbdev(intf));
973 p54_free_common(dev);
974 ieee80211_free_hw(dev);
977 static struct usb_driver p54u_driver = {
979 .id_table = p54u_table,
981 .disconnect = p54u_disconnect,
984 static int __init p54u_init(void)
986 return usb_register(&p54u_driver);
989 static void __exit p54u_exit(void)
991 usb_deregister(&p54u_driver);
994 module_init(p54u_init);
995 module_exit(p54u_exit);