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(0x0846, 0x4200)}, /* Netgear WG121 */
39 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
40 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
41 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
42 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
43 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
44 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
45 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
46 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
47 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
48 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
50 /* Version 2 devices (3887) */
51 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
52 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
53 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
54 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
55 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
56 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
57 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
58 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
59 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
60 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
61 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
62 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
63 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
64 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
65 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
66 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
67 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
68 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
72 MODULE_DEVICE_TABLE(usb, p54u_table);
74 static void p54u_rx_cb(struct urb *urb)
76 struct sk_buff *skb = (struct sk_buff *) urb->context;
77 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
78 struct ieee80211_hw *dev = info->dev;
79 struct p54u_priv *priv = dev->priv;
81 if (unlikely(urb->status)) {
87 skb_unlink(skb, &priv->rx_queue);
88 skb_put(skb, urb->actual_length);
90 skb_pull(skb, sizeof(struct net2280_tx_hdr));
92 if (p54_rx(dev, skb)) {
93 skb = dev_alloc_skb(MAX_RX_SIZE);
96 /* TODO check rx queue length and refill *somewhere* */
100 info = (struct p54u_rx_info *) skb->cb;
103 urb->transfer_buffer = skb_tail_pointer(skb);
105 skb_queue_tail(&priv->rx_queue, skb);
108 skb_queue_tail(&priv->rx_queue, skb);
111 usb_submit_urb(urb, GFP_ATOMIC);
114 static void p54u_tx_cb(struct urb *urb)
119 static void p54u_tx_free_cb(struct urb *urb)
121 kfree(urb->transfer_buffer);
125 static int p54u_init_urbs(struct ieee80211_hw *dev)
127 struct p54u_priv *priv = dev->priv;
130 struct p54u_rx_info *info;
132 while (skb_queue_len(&priv->rx_queue) < 32) {
133 skb = __dev_alloc_skb(MAX_RX_SIZE, GFP_KERNEL);
136 entry = usb_alloc_urb(0, GFP_KERNEL);
141 usb_fill_bulk_urb(entry, priv->udev, usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), skb_tail_pointer(skb), MAX_RX_SIZE, p54u_rx_cb, skb);
142 info = (struct p54u_rx_info *) skb->cb;
145 skb_queue_tail(&priv->rx_queue, skb);
146 usb_submit_urb(entry, GFP_KERNEL);
152 static void p54u_free_urbs(struct ieee80211_hw *dev)
154 struct p54u_priv *priv = dev->priv;
155 struct p54u_rx_info *info;
158 while ((skb = skb_dequeue(&priv->rx_queue))) {
159 info = (struct p54u_rx_info *) skb->cb;
163 usb_kill_urb(info->urb);
168 static void p54u_tx_3887(struct ieee80211_hw *dev, struct p54_control_hdr *data,
169 size_t len, int free_on_tx)
171 struct p54u_priv *priv = dev->priv;
172 struct urb *addr_urb, *data_urb;
174 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
178 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
180 usb_free_urb(addr_urb);
184 usb_fill_bulk_urb(addr_urb, priv->udev,
185 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), &data->req_id,
186 sizeof(data->req_id), p54u_tx_cb, dev);
187 usb_fill_bulk_urb(data_urb, priv->udev,
188 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), data, len,
189 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
191 usb_submit_urb(addr_urb, GFP_ATOMIC);
192 usb_submit_urb(data_urb, GFP_ATOMIC);
195 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct p54_control_hdr *data,
196 size_t len, int free_on_tx)
198 struct p54u_priv *priv = dev->priv;
199 struct urb *int_urb, *data_urb;
200 struct net2280_tx_hdr *hdr;
201 struct net2280_reg_write *reg;
203 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
207 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
213 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
216 usb_free_urb(int_urb);
220 reg->port = cpu_to_le16(NET2280_DEV_U32);
221 reg->addr = cpu_to_le32(P54U_DEV_BASE);
222 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
224 len += sizeof(*data);
225 hdr = (void *)data - sizeof(*hdr);
226 memset(hdr, 0, sizeof(*hdr));
227 hdr->device_addr = data->req_id;
228 hdr->len = cpu_to_le16(len);
230 usb_fill_bulk_urb(int_urb, priv->udev,
231 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
232 p54u_tx_free_cb, dev);
233 usb_submit_urb(int_urb, GFP_ATOMIC);
235 usb_fill_bulk_urb(data_urb, priv->udev,
236 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), hdr, len + sizeof(*hdr),
237 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
238 usb_submit_urb(data_urb, GFP_ATOMIC);
241 static int p54u_write(struct p54u_priv *priv,
242 struct net2280_reg_write *buf,
243 enum net2280_op_type type,
244 __le32 addr, __le32 val)
250 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
252 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
254 buf->port = cpu_to_le16(type);
258 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
261 static int p54u_read(struct p54u_priv *priv, void *buf,
262 enum net2280_op_type type,
263 __le32 addr, __le32 *val)
265 struct net2280_reg_read *read = buf;
275 read->port = cpu_to_le16(type);
278 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
279 read, sizeof(*read), &alen, 1000);
283 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
284 reg, sizeof(*reg), &alen, 1000);
292 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
293 void *data, size_t len)
296 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
297 data, len, &alen, 2000);
300 static int p54u_read_eeprom(struct ieee80211_hw *dev)
302 struct p54u_priv *priv = dev->priv;
304 struct p54_control_hdr *hdr;
306 size_t offset = priv->hw_type ? 0x10 : 0x20;
308 buf = kmalloc(0x2020, GFP_KERNEL);
310 printk(KERN_ERR "prism54usb: cannot allocate memory for"
311 "eeprom readback!\n");
316 *((u32 *) buf) = priv->common.rx_start;
317 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
319 printk(KERN_ERR "prism54usb: addr send failed\n");
323 struct net2280_reg_write *reg = buf;
324 reg->port = cpu_to_le16(NET2280_DEV_U32);
325 reg->addr = cpu_to_le32(P54U_DEV_BASE);
326 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
327 err = p54u_bulk_msg(priv, P54U_PIPE_DEV, buf, sizeof(*reg));
329 printk(KERN_ERR "prism54usb: dev_int send failed\n");
334 hdr = buf + priv->common.tx_hdr_len;
335 p54_fill_eeprom_readback(hdr);
336 hdr->req_id = cpu_to_le32(priv->common.rx_start);
337 if (priv->common.tx_hdr_len) {
338 struct net2280_tx_hdr *tx_hdr = buf;
339 tx_hdr->device_addr = hdr->req_id;
340 tx_hdr->len = cpu_to_le16(EEPROM_READBACK_LEN);
343 /* we can just pretend to send 0x2000 bytes of nothing in the headers */
344 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf,
345 EEPROM_READBACK_LEN + priv->common.tx_hdr_len);
347 printk(KERN_ERR "prism54usb: eeprom req send failed\n");
351 err = usb_bulk_msg(priv->udev,
352 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
353 buf, 0x2020, &alen, 1000);
354 if (!err && alen > offset) {
355 p54_parse_eeprom(dev, (u8 *)buf + offset, alen - offset);
357 printk(KERN_ERR "prism54usb: eeprom read failed!\n");
367 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
369 static char start_string[] = "~~~~<\r";
370 struct p54u_priv *priv = dev->priv;
371 const struct firmware *fw_entry = NULL;
374 u8 *buf, *tmp, *data;
375 unsigned int left, remains, block_size;
376 struct x2_header *hdr;
377 unsigned long timeout;
379 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
381 printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!\n");
386 memcpy(buf, start_string, 4);
387 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
389 printk(KERN_ERR "p54usb: reset failed! (%d)\n", err);
393 err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);
395 printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!\n");
396 goto err_req_fw_failed;
399 p54_parse_firmware(dev, fw_entry);
401 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
402 strcpy(buf, start_string);
403 left -= strlen(start_string);
404 tmp += strlen(start_string);
406 data = fw_entry->data;
407 remains = fw_entry->size;
409 hdr = (struct x2_header *)(buf + strlen(start_string));
410 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
411 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
412 hdr->fw_length = cpu_to_le32(fw_entry->size);
413 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
415 left -= sizeof(*hdr);
443 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
445 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
446 goto err_upload_failed;
450 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
453 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
454 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
456 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
457 goto err_upload_failed;
460 timeout = jiffies + msecs_to_jiffies(1000);
461 while (!(err = usb_bulk_msg(priv->udev,
462 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
463 if (alen > 2 && !memcmp(buf, "OK", 2))
466 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
467 printk(KERN_INFO "prism54usb: firmware upload failed!\n");
472 if (time_after(jiffies, timeout)) {
473 printk(KERN_ERR "prism54usb: firmware boot timed out!\n");
479 goto err_upload_failed;
483 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
485 printk(KERN_ERR "prism54usb: firmware boot failed!\n");
486 goto err_upload_failed;
489 timeout = jiffies + msecs_to_jiffies(1000);
490 while (!(err = usb_bulk_msg(priv->udev,
491 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
492 if (alen > 0 && buf[0] == 'g')
495 if (time_after(jiffies, timeout)) {
501 goto err_upload_failed;
504 release_firmware(fw_entry);
512 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
514 struct p54u_priv *priv = dev->priv;
515 const struct firmware *fw_entry = NULL;
516 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
520 unsigned int remains, offset;
523 buf = kmalloc(512, GFP_KERNEL);
525 printk(KERN_ERR "p54usb: firmware buffer alloc failed!\n");
529 err = request_firmware(&fw_entry, "isl3890usb", &priv->udev->dev);
531 printk(KERN_ERR "p54usb: cannot find firmware (isl3890usb)!\n");
536 p54_parse_firmware(dev, fw_entry);
538 #define P54U_WRITE(type, addr, data) \
540 err = p54u_write(priv, buf, type,\
541 cpu_to_le32((u32)(unsigned long)addr), data);\
546 #define P54U_READ(type, addr) \
548 err = p54u_read(priv, buf, type,\
549 cpu_to_le32((u32)(unsigned long)addr), ®);\
554 /* power down net2280 bridge */
555 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
556 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
557 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
558 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
562 /* power up bridge */
563 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
564 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
565 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
569 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
570 cpu_to_le32(NET2280_CLK_30Mhz |
572 NET2280_PCI_SOFT_RESET));
576 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
577 cpu_to_le32(PCI_COMMAND_MEMORY |
578 PCI_COMMAND_MASTER));
580 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
581 cpu_to_le32(NET2280_BASE));
583 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
584 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
585 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
587 // TODO: we really need this?
588 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
590 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
591 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
592 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
593 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
595 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
596 cpu_to_le32(NET2280_BASE2));
598 /* finally done setting up the bridge */
600 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
601 cpu_to_le32(PCI_COMMAND_MEMORY |
602 PCI_COMMAND_MASTER));
604 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
605 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
606 cpu_to_le32(P54U_DEV_BASE));
608 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
609 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
610 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
613 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
615 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
616 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
617 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
618 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
619 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
623 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
624 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
628 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
629 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
633 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
634 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
636 /* finally, we can upload firmware now! */
637 remains = fw_entry->size;
638 data = fw_entry->data;
639 offset = ISL38XX_DEV_FIRMWARE_ADDR;
642 unsigned int block_len = min(remains, (unsigned int)512);
643 memcpy(buf, data, block_len);
645 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
647 printk(KERN_ERR "prism54usb: firmware block upload "
652 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
653 cpu_to_le32(0xc0000f00));
655 P54U_WRITE(NET2280_DEV_U32,
656 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
657 P54U_WRITE(NET2280_DEV_U32,
658 0x0020 | (unsigned long)&devreg->direct_mem_win,
661 P54U_WRITE(NET2280_DEV_U32,
662 0x0024 | (unsigned long)&devreg->direct_mem_win,
663 cpu_to_le32(block_len));
664 P54U_WRITE(NET2280_DEV_U32,
665 0x0028 | (unsigned long)&devreg->direct_mem_win,
666 cpu_to_le32(offset));
668 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
669 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
670 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
671 cpu_to_le32(block_len >> 2));
672 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
673 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
677 P54U_READ(NET2280_DEV_U32,
678 0x002C | (unsigned long)&devreg->direct_mem_win);
679 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
680 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
681 printk(KERN_ERR "prism54usb: firmware DMA transfer "
686 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
687 cpu_to_le32(NET2280_FIFO_FLUSH));
689 remains -= block_len;
695 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
696 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
697 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
698 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
699 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
703 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
704 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
706 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
707 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
711 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
712 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
714 /* start up the firmware */
715 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
716 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
718 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
719 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
721 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
722 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
723 NET2280_USB_INTERRUPT_ENABLE));
725 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
726 cpu_to_le32(ISL38XX_DEV_INT_RESET));
728 err = usb_interrupt_msg(priv->udev,
729 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
730 buf, sizeof(__le32), &alen, 1000);
731 if (err || alen != sizeof(__le32))
734 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
735 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
737 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
740 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
741 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
742 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
748 release_firmware(fw_entry);
753 static int p54u_open(struct ieee80211_hw *dev)
755 struct p54u_priv *priv = dev->priv;
758 err = p54u_init_urbs(dev);
763 priv->common.open = p54u_init_urbs;
768 static void p54u_stop(struct ieee80211_hw *dev)
770 /* TODO: figure out how to reliably stop the 3887 and net2280 so
771 the hardware is still usable next time we want to start it.
772 until then, we just stop listening to the hardware.. */
777 static int __devinit p54u_probe(struct usb_interface *intf,
778 const struct usb_device_id *id)
780 struct usb_device *udev = interface_to_usbdev(intf);
781 struct ieee80211_hw *dev;
782 struct p54u_priv *priv;
784 unsigned int i, recognized_pipes;
785 DECLARE_MAC_BUF(mac);
787 dev = p54_init_common(sizeof(*priv));
789 printk(KERN_ERR "prism54usb: ieee80211 alloc failed\n");
795 SET_IEEE80211_DEV(dev, &intf->dev);
796 usb_set_intfdata(intf, dev);
801 /* really lazy and simple way of figuring out if we're a 3887 */
802 /* TODO: should just stick the identification in the device table */
803 i = intf->altsetting->desc.bNumEndpoints;
804 recognized_pipes = 0;
806 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
811 case P54U_PIPE_DATA | USB_DIR_IN:
812 case P54U_PIPE_MGMT | USB_DIR_IN:
813 case P54U_PIPE_BRG | USB_DIR_IN:
814 case P54U_PIPE_DEV | USB_DIR_IN:
815 case P54U_PIPE_INT | USB_DIR_IN:
819 priv->common.open = p54u_open;
821 if (recognized_pipes < P54U_PIPE_NUMBER) {
822 priv->hw_type = P54U_3887;
823 priv->common.tx = p54u_tx_3887;
825 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
826 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
827 priv->common.tx = p54u_tx_net2280;
829 priv->common.stop = p54u_stop;
832 err = p54u_upload_firmware_3887(dev);
834 err = p54u_upload_firmware_net2280(dev);
838 err = p54u_read_eeprom(dev);
842 if (!is_valid_ether_addr(dev->wiphy->perm_addr)) {
843 u8 perm_addr[ETH_ALEN];
845 printk(KERN_WARNING "prism54usb: Invalid hwaddr! Using randomly generated MAC addr\n");
846 random_ether_addr(perm_addr);
847 SET_IEEE80211_PERM_ADDR(dev, perm_addr);
850 skb_queue_head_init(&priv->rx_queue);
852 err = ieee80211_register_hw(dev);
854 printk(KERN_ERR "prism54usb: Cannot register netdevice\n");
858 printk(KERN_INFO "%s: hwaddr %s, isl38%02x\n",
859 wiphy_name(dev->wiphy),
860 print_mac(mac, dev->wiphy->perm_addr),
861 priv->common.version);
866 ieee80211_free_hw(dev);
867 usb_set_intfdata(intf, NULL);
872 static void __devexit p54u_disconnect(struct usb_interface *intf)
874 struct ieee80211_hw *dev = usb_get_intfdata(intf);
875 struct p54u_priv *priv;
880 ieee80211_unregister_hw(dev);
883 usb_put_dev(interface_to_usbdev(intf));
884 p54_free_common(dev);
885 ieee80211_free_hw(dev);
888 static struct usb_driver p54u_driver = {
889 .name = "prism54usb",
890 .id_table = p54u_table,
892 .disconnect = p54u_disconnect,
895 static int __init p54u_init(void)
897 return usb_register(&p54u_driver);
900 static void __exit p54u_exit(void)
902 usb_deregister(&p54u_driver);
905 module_init(p54u_init);
906 module_exit(p54u_exit);