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");
32 static struct usb_device_id p54u_table[] __devinitdata = {
33 /* Version 1 devices (pci chip + net2280) */
34 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
35 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
36 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
37 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
38 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
39 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
40 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
41 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
42 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
43 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
44 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
45 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
46 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
47 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
48 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
49 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
50 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
52 /* Version 2 devices (3887) */
53 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
54 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
55 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
56 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
57 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
58 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
59 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
60 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
61 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
62 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
63 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
64 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
65 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
66 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
67 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
68 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
69 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
70 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
71 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
72 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
73 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
74 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
78 MODULE_DEVICE_TABLE(usb, p54u_table);
80 static void p54u_rx_cb(struct urb *urb)
82 struct sk_buff *skb = (struct sk_buff *) urb->context;
83 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
84 struct ieee80211_hw *dev = info->dev;
85 struct p54u_priv *priv = dev->priv;
87 if (unlikely(urb->status)) {
93 skb_unlink(skb, &priv->rx_queue);
94 skb_put(skb, urb->actual_length);
96 if (priv->hw_type == P54U_NET2280)
97 skb_pull(skb, priv->common.tx_hdr_len);
98 if (priv->common.fw_interface == FW_LM87) {
103 if (p54_rx(dev, skb)) {
104 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
105 if (unlikely(!skb)) {
107 /* TODO check rx queue length and refill *somewhere* */
111 info = (struct p54u_rx_info *) skb->cb;
114 urb->transfer_buffer = skb_tail_pointer(skb);
116 skb_queue_tail(&priv->rx_queue, 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);
135 usb_submit_urb(urb, GFP_ATOMIC);
138 static void p54u_tx_reuse_skb_cb(struct urb *urb)
140 struct sk_buff *skb = urb->context;
141 struct p54u_priv *priv = (struct p54u_priv *)((struct ieee80211_hw *)
142 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0)))->priv;
144 skb_pull(skb, priv->common.tx_hdr_len);
148 static void p54u_tx_cb(struct urb *urb)
153 static void p54u_tx_free_cb(struct urb *urb)
155 kfree(urb->transfer_buffer);
159 static void p54u_tx_free_skb_cb(struct urb *urb)
161 struct sk_buff *skb = urb->context;
162 struct ieee80211_hw *dev = (struct ieee80211_hw *)
163 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
165 p54_free_skb(dev, skb);
169 static int p54u_init_urbs(struct ieee80211_hw *dev)
171 struct p54u_priv *priv = dev->priv;
174 struct p54u_rx_info *info;
176 while (skb_queue_len(&priv->rx_queue) < 32) {
177 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
180 entry = usb_alloc_urb(0, GFP_KERNEL);
185 usb_fill_bulk_urb(entry, priv->udev,
186 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
187 skb_tail_pointer(skb),
188 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
189 info = (struct p54u_rx_info *) skb->cb;
192 skb_queue_tail(&priv->rx_queue, skb);
193 usb_submit_urb(entry, GFP_KERNEL);
199 static void p54u_free_urbs(struct ieee80211_hw *dev)
201 struct p54u_priv *priv = dev->priv;
202 struct p54u_rx_info *info;
205 while ((skb = skb_dequeue(&priv->rx_queue))) {
206 info = (struct p54u_rx_info *) skb->cb;
210 usb_kill_urb(info->urb);
215 static void p54u_tx_3887(struct ieee80211_hw *dev, struct sk_buff *skb,
218 struct p54u_priv *priv = dev->priv;
219 struct urb *addr_urb, *data_urb;
221 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
225 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
227 usb_free_urb(addr_urb);
231 usb_fill_bulk_urb(addr_urb, priv->udev,
232 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
233 &((struct p54_control_hdr *)skb->data)->req_id, 4,
235 usb_fill_bulk_urb(data_urb, priv->udev,
236 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
238 free_on_tx ? p54u_tx_free_skb_cb :
239 p54u_tx_reuse_skb_cb, skb);
241 usb_submit_urb(addr_urb, GFP_ATOMIC);
242 usb_submit_urb(data_urb, GFP_ATOMIC);
245 static __le32 p54u_lm87_chksum(const u32 *data, size_t length)
252 chk = (chk >> 5) ^ (chk << 3);
255 return cpu_to_le32(chk);
258 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb,
261 struct p54u_priv *priv = dev->priv;
262 struct urb *data_urb;
263 struct lm87_tx_hdr *hdr;
265 __le32 addr = ((struct p54_control_hdr *)skb->data)->req_id;
267 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
271 checksum = p54u_lm87_chksum((u32 *)skb->data, skb->len);
272 hdr = (struct lm87_tx_hdr *)skb_push(skb, sizeof(*hdr));
273 hdr->chksum = checksum;
274 hdr->device_addr = addr;
276 usb_fill_bulk_urb(data_urb, priv->udev,
277 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
279 free_on_tx ? p54u_tx_free_skb_cb :
280 p54u_tx_reuse_skb_cb, skb);
282 usb_submit_urb(data_urb, GFP_ATOMIC);
285 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb,
288 struct p54u_priv *priv = dev->priv;
289 struct urb *int_urb, *data_urb;
290 struct net2280_tx_hdr *hdr;
291 struct net2280_reg_write *reg;
293 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
297 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
303 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
306 usb_free_urb(int_urb);
310 reg->port = cpu_to_le16(NET2280_DEV_U32);
311 reg->addr = cpu_to_le32(P54U_DEV_BASE);
312 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
314 hdr = (void *)skb_push(skb, sizeof(*hdr));
315 memset(hdr, 0, sizeof(*hdr));
316 hdr->device_addr = ((struct p54_control_hdr *)skb->data)->req_id;
317 hdr->len = cpu_to_le16(skb->len + sizeof(struct p54_control_hdr));
319 usb_fill_bulk_urb(int_urb, priv->udev,
320 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
321 p54u_tx_free_cb, dev);
322 usb_submit_urb(int_urb, GFP_ATOMIC);
324 usb_fill_bulk_urb(data_urb, priv->udev,
325 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
327 free_on_tx ? p54u_tx_free_skb_cb :
328 p54u_tx_reuse_skb_cb, skb);
329 usb_submit_urb(data_urb, GFP_ATOMIC);
332 static int p54u_write(struct p54u_priv *priv,
333 struct net2280_reg_write *buf,
334 enum net2280_op_type type,
335 __le32 addr, __le32 val)
341 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
343 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
345 buf->port = cpu_to_le16(type);
349 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
352 static int p54u_read(struct p54u_priv *priv, void *buf,
353 enum net2280_op_type type,
354 __le32 addr, __le32 *val)
356 struct net2280_reg_read *read = buf;
366 read->port = cpu_to_le16(type);
369 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
370 read, sizeof(*read), &alen, 1000);
374 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
375 reg, sizeof(*reg), &alen, 1000);
383 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
384 void *data, size_t len)
387 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
388 data, len, &alen, 2000);
391 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
393 static char start_string[] = "~~~~<\r";
394 struct p54u_priv *priv = dev->priv;
395 const struct firmware *fw_entry = NULL;
400 unsigned int left, remains, block_size;
401 struct x2_header *hdr;
402 unsigned long timeout;
404 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
406 printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!\n");
411 memcpy(buf, start_string, 4);
412 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
414 printk(KERN_ERR "p54usb: reset failed! (%d)\n", err);
418 err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);
420 printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!\n");
421 goto err_req_fw_failed;
424 err = p54_parse_firmware(dev, fw_entry);
426 goto err_upload_failed;
428 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
429 strcpy(buf, start_string);
430 left -= strlen(start_string);
431 tmp += strlen(start_string);
433 data = fw_entry->data;
434 remains = fw_entry->size;
436 hdr = (struct x2_header *)(buf + strlen(start_string));
437 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
438 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
439 hdr->fw_length = cpu_to_le32(fw_entry->size);
440 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
442 left -= sizeof(*hdr);
470 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
472 printk(KERN_ERR "p54usb: firmware upload failed!\n");
473 goto err_upload_failed;
477 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
480 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
481 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
483 printk(KERN_ERR "p54usb: firmware upload failed!\n");
484 goto err_upload_failed;
487 timeout = jiffies + msecs_to_jiffies(1000);
488 while (!(err = usb_bulk_msg(priv->udev,
489 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
490 if (alen > 2 && !memcmp(buf, "OK", 2))
493 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
494 printk(KERN_INFO "p54usb: firmware upload failed!\n");
499 if (time_after(jiffies, timeout)) {
500 printk(KERN_ERR "p54usb: firmware boot timed out!\n");
506 goto err_upload_failed;
510 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
512 printk(KERN_ERR "p54usb: firmware boot failed!\n");
513 goto err_upload_failed;
516 timeout = jiffies + msecs_to_jiffies(1000);
517 while (!(err = usb_bulk_msg(priv->udev,
518 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
519 if (alen > 0 && buf[0] == 'g')
522 if (time_after(jiffies, timeout)) {
528 goto err_upload_failed;
531 release_firmware(fw_entry);
539 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
541 struct p54u_priv *priv = dev->priv;
542 const struct firmware *fw_entry = NULL;
543 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
547 unsigned int remains, offset;
550 buf = kmalloc(512, GFP_KERNEL);
552 printk(KERN_ERR "p54usb: firmware buffer alloc failed!\n");
556 err = request_firmware(&fw_entry, "isl3890usb", &priv->udev->dev);
558 printk(KERN_ERR "p54usb: cannot find firmware (isl3890usb)!\n");
563 err = p54_parse_firmware(dev, fw_entry);
566 release_firmware(fw_entry);
570 #define P54U_WRITE(type, addr, data) \
572 err = p54u_write(priv, buf, type,\
573 cpu_to_le32((u32)(unsigned long)addr), data);\
578 #define P54U_READ(type, addr) \
580 err = p54u_read(priv, buf, type,\
581 cpu_to_le32((u32)(unsigned long)addr), ®);\
586 /* power down net2280 bridge */
587 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
588 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
589 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
590 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
594 /* power up bridge */
595 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
596 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
597 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
601 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
602 cpu_to_le32(NET2280_CLK_30Mhz |
604 NET2280_PCI_SOFT_RESET));
608 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
609 cpu_to_le32(PCI_COMMAND_MEMORY |
610 PCI_COMMAND_MASTER));
612 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
613 cpu_to_le32(NET2280_BASE));
615 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
616 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
617 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
619 // TODO: we really need this?
620 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
622 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
623 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
624 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
625 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
627 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
628 cpu_to_le32(NET2280_BASE2));
630 /* finally done setting up the bridge */
632 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
633 cpu_to_le32(PCI_COMMAND_MEMORY |
634 PCI_COMMAND_MASTER));
636 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
637 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
638 cpu_to_le32(P54U_DEV_BASE));
640 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
641 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
642 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
645 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
647 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
648 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
649 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
650 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
651 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
655 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
656 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
660 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
661 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
665 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
666 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
668 /* finally, we can upload firmware now! */
669 remains = fw_entry->size;
670 data = fw_entry->data;
671 offset = ISL38XX_DEV_FIRMWARE_ADDR;
674 unsigned int block_len = min(remains, (unsigned int)512);
675 memcpy(buf, data, block_len);
677 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
679 printk(KERN_ERR "p54usb: firmware block upload "
684 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
685 cpu_to_le32(0xc0000f00));
687 P54U_WRITE(NET2280_DEV_U32,
688 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
689 P54U_WRITE(NET2280_DEV_U32,
690 0x0020 | (unsigned long)&devreg->direct_mem_win,
693 P54U_WRITE(NET2280_DEV_U32,
694 0x0024 | (unsigned long)&devreg->direct_mem_win,
695 cpu_to_le32(block_len));
696 P54U_WRITE(NET2280_DEV_U32,
697 0x0028 | (unsigned long)&devreg->direct_mem_win,
698 cpu_to_le32(offset));
700 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
701 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
702 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
703 cpu_to_le32(block_len >> 2));
704 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
705 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
709 P54U_READ(NET2280_DEV_U32,
710 0x002C | (unsigned long)&devreg->direct_mem_win);
711 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
712 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
713 printk(KERN_ERR "p54usb: firmware DMA transfer "
718 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
719 cpu_to_le32(NET2280_FIFO_FLUSH));
721 remains -= block_len;
727 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
728 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
729 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
730 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
731 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
735 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
736 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
738 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
739 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
743 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
744 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
746 /* start up the firmware */
747 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
748 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
750 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
751 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
753 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
754 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
755 NET2280_USB_INTERRUPT_ENABLE));
757 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
758 cpu_to_le32(ISL38XX_DEV_INT_RESET));
760 err = usb_interrupt_msg(priv->udev,
761 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
762 buf, sizeof(__le32), &alen, 1000);
763 if (err || alen != sizeof(__le32))
766 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
767 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
769 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
772 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
773 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
774 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
780 release_firmware(fw_entry);
785 static int p54u_open(struct ieee80211_hw *dev)
787 struct p54u_priv *priv = dev->priv;
790 err = p54u_init_urbs(dev);
795 priv->common.open = p54u_init_urbs;
800 static void p54u_stop(struct ieee80211_hw *dev)
802 /* TODO: figure out how to reliably stop the 3887 and net2280 so
803 the hardware is still usable next time we want to start it.
804 until then, we just stop listening to the hardware.. */
809 static int __devinit p54u_probe(struct usb_interface *intf,
810 const struct usb_device_id *id)
812 struct usb_device *udev = interface_to_usbdev(intf);
813 struct ieee80211_hw *dev;
814 struct p54u_priv *priv;
816 unsigned int i, recognized_pipes;
818 dev = p54_init_common(sizeof(*priv));
820 printk(KERN_ERR "p54usb: ieee80211 alloc failed\n");
826 SET_IEEE80211_DEV(dev, &intf->dev);
827 usb_set_intfdata(intf, dev);
832 /* really lazy and simple way of figuring out if we're a 3887 */
833 /* TODO: should just stick the identification in the device table */
834 i = intf->altsetting->desc.bNumEndpoints;
835 recognized_pipes = 0;
837 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
842 case P54U_PIPE_DATA | USB_DIR_IN:
843 case P54U_PIPE_MGMT | USB_DIR_IN:
844 case P54U_PIPE_BRG | USB_DIR_IN:
845 case P54U_PIPE_DEV | USB_DIR_IN:
846 case P54U_PIPE_INT | USB_DIR_IN:
850 priv->common.open = p54u_open;
851 priv->common.stop = p54u_stop;
852 if (recognized_pipes < P54U_PIPE_NUMBER) {
853 priv->hw_type = P54U_3887;
854 err = p54u_upload_firmware_3887(dev);
855 if (priv->common.fw_interface == FW_LM87) {
856 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
857 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
858 priv->common.tx = p54u_tx_lm87;
860 priv->common.tx = p54u_tx_3887;
862 priv->hw_type = P54U_NET2280;
863 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
864 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
865 priv->common.tx = p54u_tx_net2280;
866 err = p54u_upload_firmware_net2280(dev);
871 skb_queue_head_init(&priv->rx_queue);
874 err = p54_read_eeprom(dev);
879 err = ieee80211_register_hw(dev);
881 printk(KERN_ERR "p54usb: Cannot register netdevice\n");
888 ieee80211_free_hw(dev);
889 usb_set_intfdata(intf, NULL);
894 static void __devexit p54u_disconnect(struct usb_interface *intf)
896 struct ieee80211_hw *dev = usb_get_intfdata(intf);
897 struct p54u_priv *priv;
902 ieee80211_unregister_hw(dev);
905 usb_put_dev(interface_to_usbdev(intf));
906 p54_free_common(dev);
907 ieee80211_free_hw(dev);
910 static struct usb_driver p54u_driver = {
912 .id_table = p54u_table,
914 .disconnect = p54u_disconnect,
917 static int __init p54u_init(void)
919 return usb_register(&p54u_driver);
922 static void __exit p54u_exit(void)
924 usb_deregister(&p54u_driver);
927 module_init(p54u_init);
928 module_exit(p54u_exit);