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(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
43 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
44 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
45 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
46 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
47 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
48 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
49 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
51 /* Version 2 devices (3887) */
52 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
53 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
54 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
55 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
56 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
57 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
58 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
59 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
60 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
61 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
62 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
63 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
64 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
65 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
66 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
67 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
68 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
69 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
70 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
71 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
72 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
73 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
77 MODULE_DEVICE_TABLE(usb, p54u_table);
79 static void p54u_rx_cb(struct urb *urb)
81 struct sk_buff *skb = (struct sk_buff *) urb->context;
82 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
83 struct ieee80211_hw *dev = info->dev;
84 struct p54u_priv *priv = dev->priv;
86 if (unlikely(urb->status)) {
92 skb_unlink(skb, &priv->rx_queue);
93 skb_put(skb, urb->actual_length);
95 skb_pull(skb, sizeof(struct net2280_tx_hdr));
97 if (p54_rx(dev, skb)) {
98 skb = dev_alloc_skb(MAX_RX_SIZE);
101 /* TODO check rx queue length and refill *somewhere* */
105 info = (struct p54u_rx_info *) skb->cb;
108 urb->transfer_buffer = skb_tail_pointer(skb);
110 skb_queue_tail(&priv->rx_queue, skb);
113 skb_queue_tail(&priv->rx_queue, skb);
116 usb_submit_urb(urb, GFP_ATOMIC);
119 static void p54u_tx_cb(struct urb *urb)
124 static void p54u_tx_free_cb(struct urb *urb)
126 kfree(urb->transfer_buffer);
130 static int p54u_init_urbs(struct ieee80211_hw *dev)
132 struct p54u_priv *priv = dev->priv;
135 struct p54u_rx_info *info;
137 while (skb_queue_len(&priv->rx_queue) < 32) {
138 skb = __dev_alloc_skb(MAX_RX_SIZE, GFP_KERNEL);
141 entry = usb_alloc_urb(0, GFP_KERNEL);
146 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);
147 info = (struct p54u_rx_info *) skb->cb;
150 skb_queue_tail(&priv->rx_queue, skb);
151 usb_submit_urb(entry, GFP_KERNEL);
157 static void p54u_free_urbs(struct ieee80211_hw *dev)
159 struct p54u_priv *priv = dev->priv;
160 struct p54u_rx_info *info;
163 while ((skb = skb_dequeue(&priv->rx_queue))) {
164 info = (struct p54u_rx_info *) skb->cb;
168 usb_kill_urb(info->urb);
173 static void p54u_tx_3887(struct ieee80211_hw *dev, struct p54_control_hdr *data,
174 size_t len, int free_on_tx)
176 struct p54u_priv *priv = dev->priv;
177 struct urb *addr_urb, *data_urb;
179 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
183 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
185 usb_free_urb(addr_urb);
189 usb_fill_bulk_urb(addr_urb, priv->udev,
190 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), &data->req_id,
191 sizeof(data->req_id), p54u_tx_cb, dev);
192 usb_fill_bulk_urb(data_urb, priv->udev,
193 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), data, len,
194 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
196 usb_submit_urb(addr_urb, GFP_ATOMIC);
197 usb_submit_urb(data_urb, GFP_ATOMIC);
200 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct p54_control_hdr *data,
201 size_t len, int free_on_tx)
203 struct p54u_priv *priv = dev->priv;
204 struct urb *int_urb, *data_urb;
205 struct net2280_tx_hdr *hdr;
206 struct net2280_reg_write *reg;
208 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
212 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
218 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
221 usb_free_urb(int_urb);
225 reg->port = cpu_to_le16(NET2280_DEV_U32);
226 reg->addr = cpu_to_le32(P54U_DEV_BASE);
227 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
229 len += sizeof(*data);
230 hdr = (void *)data - sizeof(*hdr);
231 memset(hdr, 0, sizeof(*hdr));
232 hdr->device_addr = data->req_id;
233 hdr->len = cpu_to_le16(len);
235 usb_fill_bulk_urb(int_urb, priv->udev,
236 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
237 p54u_tx_free_cb, dev);
238 usb_submit_urb(int_urb, GFP_ATOMIC);
240 usb_fill_bulk_urb(data_urb, priv->udev,
241 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), hdr, len + sizeof(*hdr),
242 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
243 usb_submit_urb(data_urb, GFP_ATOMIC);
246 static int p54u_write(struct p54u_priv *priv,
247 struct net2280_reg_write *buf,
248 enum net2280_op_type type,
249 __le32 addr, __le32 val)
255 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
257 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
259 buf->port = cpu_to_le16(type);
263 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
266 static int p54u_read(struct p54u_priv *priv, void *buf,
267 enum net2280_op_type type,
268 __le32 addr, __le32 *val)
270 struct net2280_reg_read *read = buf;
280 read->port = cpu_to_le16(type);
283 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
284 read, sizeof(*read), &alen, 1000);
288 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
289 reg, sizeof(*reg), &alen, 1000);
297 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
298 void *data, size_t len)
301 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
302 data, len, &alen, 2000);
305 static int p54u_read_eeprom(struct ieee80211_hw *dev)
307 struct p54u_priv *priv = dev->priv;
309 struct p54_control_hdr *hdr;
311 size_t offset = priv->hw_type ? 0x10 : 0x20;
313 buf = kmalloc(0x2020, GFP_KERNEL);
315 printk(KERN_ERR "prism54usb: cannot allocate memory for "
316 "eeprom readback!\n");
321 *((u32 *) buf) = priv->common.rx_start;
322 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
324 printk(KERN_ERR "prism54usb: addr send failed\n");
328 struct net2280_reg_write *reg = buf;
329 reg->port = cpu_to_le16(NET2280_DEV_U32);
330 reg->addr = cpu_to_le32(P54U_DEV_BASE);
331 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
332 err = p54u_bulk_msg(priv, P54U_PIPE_DEV, buf, sizeof(*reg));
334 printk(KERN_ERR "prism54usb: dev_int send failed\n");
339 hdr = buf + priv->common.tx_hdr_len;
340 p54_fill_eeprom_readback(hdr);
341 hdr->req_id = cpu_to_le32(priv->common.rx_start);
342 if (priv->common.tx_hdr_len) {
343 struct net2280_tx_hdr *tx_hdr = buf;
344 tx_hdr->device_addr = hdr->req_id;
345 tx_hdr->len = cpu_to_le16(EEPROM_READBACK_LEN);
348 /* we can just pretend to send 0x2000 bytes of nothing in the headers */
349 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf,
350 EEPROM_READBACK_LEN + priv->common.tx_hdr_len);
352 printk(KERN_ERR "prism54usb: eeprom req send failed\n");
356 err = usb_bulk_msg(priv->udev,
357 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
358 buf, 0x2020, &alen, 1000);
359 if (!err && alen > offset) {
360 p54_parse_eeprom(dev, (u8 *)buf + offset, alen - offset);
362 printk(KERN_ERR "prism54usb: eeprom read failed!\n");
372 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
374 static char start_string[] = "~~~~<\r";
375 struct p54u_priv *priv = dev->priv;
376 const struct firmware *fw_entry = NULL;
381 unsigned int left, remains, block_size;
382 struct x2_header *hdr;
383 unsigned long timeout;
385 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
387 printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!\n");
392 memcpy(buf, start_string, 4);
393 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
395 printk(KERN_ERR "p54usb: reset failed! (%d)\n", err);
399 err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);
401 printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!\n");
402 goto err_req_fw_failed;
405 p54_parse_firmware(dev, fw_entry);
407 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
408 strcpy(buf, start_string);
409 left -= strlen(start_string);
410 tmp += strlen(start_string);
412 data = fw_entry->data;
413 remains = fw_entry->size;
415 hdr = (struct x2_header *)(buf + strlen(start_string));
416 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
417 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
418 hdr->fw_length = cpu_to_le32(fw_entry->size);
419 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
421 left -= sizeof(*hdr);
449 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
451 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
452 goto err_upload_failed;
456 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
459 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
460 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
462 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
463 goto err_upload_failed;
466 timeout = jiffies + msecs_to_jiffies(1000);
467 while (!(err = usb_bulk_msg(priv->udev,
468 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
469 if (alen > 2 && !memcmp(buf, "OK", 2))
472 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
473 printk(KERN_INFO "prism54usb: firmware upload failed!\n");
478 if (time_after(jiffies, timeout)) {
479 printk(KERN_ERR "prism54usb: firmware boot timed out!\n");
485 goto err_upload_failed;
489 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
491 printk(KERN_ERR "prism54usb: firmware boot failed!\n");
492 goto err_upload_failed;
495 timeout = jiffies + msecs_to_jiffies(1000);
496 while (!(err = usb_bulk_msg(priv->udev,
497 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
498 if (alen > 0 && buf[0] == 'g')
501 if (time_after(jiffies, timeout)) {
507 goto err_upload_failed;
510 release_firmware(fw_entry);
518 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
520 struct p54u_priv *priv = dev->priv;
521 const struct firmware *fw_entry = NULL;
522 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
526 unsigned int remains, offset;
529 buf = kmalloc(512, GFP_KERNEL);
531 printk(KERN_ERR "p54usb: firmware buffer alloc failed!\n");
535 err = request_firmware(&fw_entry, "isl3890usb", &priv->udev->dev);
537 printk(KERN_ERR "p54usb: cannot find firmware (isl3890usb)!\n");
542 p54_parse_firmware(dev, fw_entry);
544 #define P54U_WRITE(type, addr, data) \
546 err = p54u_write(priv, buf, type,\
547 cpu_to_le32((u32)(unsigned long)addr), data);\
552 #define P54U_READ(type, addr) \
554 err = p54u_read(priv, buf, type,\
555 cpu_to_le32((u32)(unsigned long)addr), ®);\
560 /* power down net2280 bridge */
561 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
562 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
563 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
564 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
568 /* power up bridge */
569 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
570 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
571 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
575 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
576 cpu_to_le32(NET2280_CLK_30Mhz |
578 NET2280_PCI_SOFT_RESET));
582 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
583 cpu_to_le32(PCI_COMMAND_MEMORY |
584 PCI_COMMAND_MASTER));
586 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
587 cpu_to_le32(NET2280_BASE));
589 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
590 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
591 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
593 // TODO: we really need this?
594 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
596 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
597 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
598 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
599 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
601 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
602 cpu_to_le32(NET2280_BASE2));
604 /* finally done setting up the bridge */
606 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
607 cpu_to_le32(PCI_COMMAND_MEMORY |
608 PCI_COMMAND_MASTER));
610 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
611 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
612 cpu_to_le32(P54U_DEV_BASE));
614 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
615 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
616 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
619 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
621 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
622 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
623 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
624 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
625 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
629 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
630 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
634 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
635 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
639 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
640 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
642 /* finally, we can upload firmware now! */
643 remains = fw_entry->size;
644 data = fw_entry->data;
645 offset = ISL38XX_DEV_FIRMWARE_ADDR;
648 unsigned int block_len = min(remains, (unsigned int)512);
649 memcpy(buf, data, block_len);
651 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
653 printk(KERN_ERR "prism54usb: firmware block upload "
658 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
659 cpu_to_le32(0xc0000f00));
661 P54U_WRITE(NET2280_DEV_U32,
662 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
663 P54U_WRITE(NET2280_DEV_U32,
664 0x0020 | (unsigned long)&devreg->direct_mem_win,
667 P54U_WRITE(NET2280_DEV_U32,
668 0x0024 | (unsigned long)&devreg->direct_mem_win,
669 cpu_to_le32(block_len));
670 P54U_WRITE(NET2280_DEV_U32,
671 0x0028 | (unsigned long)&devreg->direct_mem_win,
672 cpu_to_le32(offset));
674 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
675 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
676 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
677 cpu_to_le32(block_len >> 2));
678 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
679 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
683 P54U_READ(NET2280_DEV_U32,
684 0x002C | (unsigned long)&devreg->direct_mem_win);
685 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
686 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
687 printk(KERN_ERR "prism54usb: firmware DMA transfer "
692 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
693 cpu_to_le32(NET2280_FIFO_FLUSH));
695 remains -= block_len;
701 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
702 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
703 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
704 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
709 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
710 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
712 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
713 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
717 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
718 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
720 /* start up the firmware */
721 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
722 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
724 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
725 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
727 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
728 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
729 NET2280_USB_INTERRUPT_ENABLE));
731 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
732 cpu_to_le32(ISL38XX_DEV_INT_RESET));
734 err = usb_interrupt_msg(priv->udev,
735 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
736 buf, sizeof(__le32), &alen, 1000);
737 if (err || alen != sizeof(__le32))
740 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
741 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
743 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
746 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
747 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
748 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
754 release_firmware(fw_entry);
759 static int p54u_open(struct ieee80211_hw *dev)
761 struct p54u_priv *priv = dev->priv;
764 err = p54u_init_urbs(dev);
769 priv->common.open = p54u_init_urbs;
774 static void p54u_stop(struct ieee80211_hw *dev)
776 /* TODO: figure out how to reliably stop the 3887 and net2280 so
777 the hardware is still usable next time we want to start it.
778 until then, we just stop listening to the hardware.. */
783 static int __devinit p54u_probe(struct usb_interface *intf,
784 const struct usb_device_id *id)
786 struct usb_device *udev = interface_to_usbdev(intf);
787 struct ieee80211_hw *dev;
788 struct p54u_priv *priv;
790 unsigned int i, recognized_pipes;
791 DECLARE_MAC_BUF(mac);
793 dev = p54_init_common(sizeof(*priv));
795 printk(KERN_ERR "prism54usb: ieee80211 alloc failed\n");
801 SET_IEEE80211_DEV(dev, &intf->dev);
802 usb_set_intfdata(intf, dev);
807 /* really lazy and simple way of figuring out if we're a 3887 */
808 /* TODO: should just stick the identification in the device table */
809 i = intf->altsetting->desc.bNumEndpoints;
810 recognized_pipes = 0;
812 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
817 case P54U_PIPE_DATA | USB_DIR_IN:
818 case P54U_PIPE_MGMT | USB_DIR_IN:
819 case P54U_PIPE_BRG | USB_DIR_IN:
820 case P54U_PIPE_DEV | USB_DIR_IN:
821 case P54U_PIPE_INT | USB_DIR_IN:
825 priv->common.open = p54u_open;
827 if (recognized_pipes < P54U_PIPE_NUMBER) {
828 priv->hw_type = P54U_3887;
829 priv->common.tx = p54u_tx_3887;
831 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
832 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
833 priv->common.tx = p54u_tx_net2280;
835 priv->common.stop = p54u_stop;
838 err = p54u_upload_firmware_3887(dev);
840 err = p54u_upload_firmware_net2280(dev);
844 err = p54u_read_eeprom(dev);
848 if (!is_valid_ether_addr(dev->wiphy->perm_addr)) {
849 u8 perm_addr[ETH_ALEN];
851 printk(KERN_WARNING "prism54usb: Invalid hwaddr! Using randomly generated MAC addr\n");
852 random_ether_addr(perm_addr);
853 SET_IEEE80211_PERM_ADDR(dev, perm_addr);
856 skb_queue_head_init(&priv->rx_queue);
858 err = ieee80211_register_hw(dev);
860 printk(KERN_ERR "prism54usb: Cannot register netdevice\n");
864 printk(KERN_INFO "%s: hwaddr %s, isl38%02x\n",
865 wiphy_name(dev->wiphy),
866 print_mac(mac, dev->wiphy->perm_addr),
867 priv->common.version);
872 ieee80211_free_hw(dev);
873 usb_set_intfdata(intf, NULL);
878 static void __devexit p54u_disconnect(struct usb_interface *intf)
880 struct ieee80211_hw *dev = usb_get_intfdata(intf);
881 struct p54u_priv *priv;
886 ieee80211_unregister_hw(dev);
889 usb_put_dev(interface_to_usbdev(intf));
890 p54_free_common(dev);
891 ieee80211_free_hw(dev);
894 static struct usb_driver p54u_driver = {
895 .name = "prism54usb",
896 .id_table = p54u_table,
898 .disconnect = p54u_disconnect,
901 static int __init p54u_init(void)
903 return usb_register(&p54u_driver);
906 static void __exit p54u_exit(void)
908 usb_deregister(&p54u_driver);
911 module_init(p54u_init);
912 module_exit(p54u_exit);