cris: add arch/cris/include/asm/serial.h
[linux-2.6/next.git] / drivers / net / wireless / p54 / p54usb.c
bloba8f3bc740dfaf8354abff344f5ab7665bd8faf58
2 /*
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>
25 #include "p54.h"
26 #include "lmac.h"
27 #include "p54usb.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");
37 * Note:
39 * Always update our wiki's device list (located at:
40 * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
41 * whenever you add a new device.
44 static struct usb_device_id p54u_table[] __devinitdata = {
45 /* Version 1 devices (pci chip + net2280) */
46 {USB_DEVICE(0x0411, 0x0050)}, /* Buffalo WLI2-USB2-G54 */
47 {USB_DEVICE(0x045e, 0x00c2)}, /* Microsoft MN-710 */
48 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
49 {USB_DEVICE(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */
50 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
51 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
52 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
53 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
54 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
55 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
56 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
57 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
58 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
59 {USB_DEVICE(0x0bf8, 0x1007)}, /* Fujitsu E-5400 USB */
60 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
61 {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */
62 {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */
63 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
64 {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */
65 {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */
66 {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
67 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
68 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
69 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
70 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
71 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
72 {USB_DEVICE(0x2001, 0x3762)}, /* Conceptronic C54U */
73 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
74 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
76 /* Version 2 devices (3887) */
77 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
78 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
79 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
80 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
81 {USB_DEVICE(0x06a9, 0x000e)}, /* Westell 802.11g USB (A90-211WG-01) */
82 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
83 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
84 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
85 {USB_DEVICE(0x083a, 0xc501)}, /* Zoom Wireless-G 4410 */
86 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
87 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
88 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
89 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
90 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
91 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
92 /* {USB_DEVICE(0x0cde, 0x0006)}, * Medion MD40900 already listed above,
93 * just noting it here for clarity */
94 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
95 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
96 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
97 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
98 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
99 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
100 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
101 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
102 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
103 {USB_DEVICE(0x1668, 0x1050)}, /* Actiontec 802UIG-1 */
104 {USB_DEVICE(0x1740, 0x1000)}, /* Senao NUB-350 */
105 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
106 {USB_DEVICE(0x2001, 0x3705)}, /* D-Link DWL-G120 rev C1 */
107 {USB_DEVICE(0x413c, 0x5513)}, /* Dell WLA3310 USB Wireless Adapter */
108 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
109 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
113 MODULE_DEVICE_TABLE(usb, p54u_table);
115 static const struct {
116 u32 intf;
117 enum p54u_hw_type type;
118 const char *fw;
119 const char *fw_legacy;
120 char hw[20];
121 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
123 .type = P54U_NET2280,
124 .intf = FW_LM86,
125 .fw = "isl3886usb",
126 .fw_legacy = "isl3890usb",
127 .hw = "ISL3886 + net2280",
130 .type = P54U_3887,
131 .intf = FW_LM87,
132 .fw = "isl3887usb",
133 .fw_legacy = "isl3887usb_bare",
134 .hw = "ISL3887",
138 static void p54u_rx_cb(struct urb *urb)
140 struct sk_buff *skb = (struct sk_buff *) urb->context;
141 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
142 struct ieee80211_hw *dev = info->dev;
143 struct p54u_priv *priv = dev->priv;
145 skb_unlink(skb, &priv->rx_queue);
147 if (unlikely(urb->status)) {
148 dev_kfree_skb_irq(skb);
149 return;
152 skb_put(skb, urb->actual_length);
154 if (priv->hw_type == P54U_NET2280)
155 skb_pull(skb, priv->common.tx_hdr_len);
156 if (priv->common.fw_interface == FW_LM87) {
157 skb_pull(skb, 4);
158 skb_put(skb, 4);
161 if (p54_rx(dev, skb)) {
162 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
163 if (unlikely(!skb)) {
164 /* TODO check rx queue length and refill *somewhere* */
165 return;
168 info = (struct p54u_rx_info *) skb->cb;
169 info->urb = urb;
170 info->dev = dev;
171 urb->transfer_buffer = skb_tail_pointer(skb);
172 urb->context = skb;
173 } else {
174 if (priv->hw_type == P54U_NET2280)
175 skb_push(skb, priv->common.tx_hdr_len);
176 if (priv->common.fw_interface == FW_LM87) {
177 skb_push(skb, 4);
178 skb_put(skb, 4);
180 skb_reset_tail_pointer(skb);
181 skb_trim(skb, 0);
182 urb->transfer_buffer = skb_tail_pointer(skb);
184 skb_queue_tail(&priv->rx_queue, skb);
185 usb_anchor_urb(urb, &priv->submitted);
186 if (usb_submit_urb(urb, GFP_ATOMIC)) {
187 skb_unlink(skb, &priv->rx_queue);
188 usb_unanchor_urb(urb);
189 dev_kfree_skb_irq(skb);
193 static void p54u_tx_cb(struct urb *urb)
195 struct sk_buff *skb = urb->context;
196 struct ieee80211_hw *dev =
197 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
199 p54_free_skb(dev, skb);
202 static void p54u_tx_dummy_cb(struct urb *urb) { }
204 static void p54u_free_urbs(struct ieee80211_hw *dev)
206 struct p54u_priv *priv = dev->priv;
207 usb_kill_anchored_urbs(&priv->submitted);
210 static int p54u_init_urbs(struct ieee80211_hw *dev)
212 struct p54u_priv *priv = dev->priv;
213 struct urb *entry = NULL;
214 struct sk_buff *skb;
215 struct p54u_rx_info *info;
216 int ret = 0;
218 while (skb_queue_len(&priv->rx_queue) < 32) {
219 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
220 if (!skb) {
221 ret = -ENOMEM;
222 goto err;
224 entry = usb_alloc_urb(0, GFP_KERNEL);
225 if (!entry) {
226 ret = -ENOMEM;
227 goto err;
230 usb_fill_bulk_urb(entry, priv->udev,
231 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
232 skb_tail_pointer(skb),
233 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
234 info = (struct p54u_rx_info *) skb->cb;
235 info->urb = entry;
236 info->dev = dev;
237 skb_queue_tail(&priv->rx_queue, skb);
239 usb_anchor_urb(entry, &priv->submitted);
240 ret = usb_submit_urb(entry, GFP_KERNEL);
241 if (ret) {
242 skb_unlink(skb, &priv->rx_queue);
243 usb_unanchor_urb(entry);
244 goto err;
246 usb_free_urb(entry);
247 entry = NULL;
250 return 0;
252 err:
253 usb_free_urb(entry);
254 kfree_skb(skb);
255 p54u_free_urbs(dev);
256 return ret;
259 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
261 u32 chk = 0;
263 length >>= 2;
264 while (length--) {
265 chk ^= le32_to_cpu(*data++);
266 chk = (chk >> 5) ^ (chk << 3);
269 return cpu_to_le32(chk);
272 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
274 struct p54u_priv *priv = dev->priv;
275 struct urb *data_urb;
276 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
278 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
279 if (!data_urb) {
280 p54_free_skb(dev, skb);
281 return;
284 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
285 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
287 usb_fill_bulk_urb(data_urb, priv->udev,
288 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
289 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
290 p54u_tx_cb : p54u_tx_dummy_cb, skb);
291 data_urb->transfer_flags |= URB_ZERO_PACKET;
293 usb_anchor_urb(data_urb, &priv->submitted);
294 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
295 usb_unanchor_urb(data_urb);
296 p54_free_skb(dev, skb);
298 usb_free_urb(data_urb);
301 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
303 struct p54u_priv *priv = dev->priv;
304 struct urb *int_urb = NULL, *data_urb = NULL;
305 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
306 struct net2280_reg_write *reg = NULL;
307 int err = -ENOMEM;
309 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
310 if (!reg)
311 goto out;
313 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
314 if (!int_urb)
315 goto out;
317 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
318 if (!data_urb)
319 goto out;
321 reg->port = cpu_to_le16(NET2280_DEV_U32);
322 reg->addr = cpu_to_le32(P54U_DEV_BASE);
323 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
325 memset(hdr, 0, sizeof(*hdr));
326 hdr->len = cpu_to_le16(skb->len);
327 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
329 usb_fill_bulk_urb(int_urb, priv->udev,
330 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
331 p54u_tx_dummy_cb, dev);
334 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
335 * free what is inside the transfer_buffer after the last reference to
336 * the int_urb is dropped.
338 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
339 reg = NULL;
341 usb_fill_bulk_urb(data_urb, priv->udev,
342 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
343 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
344 p54u_tx_cb : p54u_tx_dummy_cb, skb);
345 data_urb->transfer_flags |= URB_ZERO_PACKET;
347 usb_anchor_urb(int_urb, &priv->submitted);
348 err = usb_submit_urb(int_urb, GFP_ATOMIC);
349 if (err) {
350 usb_unanchor_urb(int_urb);
351 goto out;
354 usb_anchor_urb(data_urb, &priv->submitted);
355 err = usb_submit_urb(data_urb, GFP_ATOMIC);
356 if (err) {
357 usb_unanchor_urb(data_urb);
358 goto out;
360 out:
361 usb_free_urb(int_urb);
362 usb_free_urb(data_urb);
364 if (err) {
365 kfree(reg);
366 p54_free_skb(dev, skb);
370 static int p54u_write(struct p54u_priv *priv,
371 struct net2280_reg_write *buf,
372 enum net2280_op_type type,
373 __le32 addr, __le32 val)
375 unsigned int ep;
376 int alen;
378 if (type & 0x0800)
379 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
380 else
381 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
383 buf->port = cpu_to_le16(type);
384 buf->addr = addr;
385 buf->val = val;
387 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
390 static int p54u_read(struct p54u_priv *priv, void *buf,
391 enum net2280_op_type type,
392 __le32 addr, __le32 *val)
394 struct net2280_reg_read *read = buf;
395 __le32 *reg = buf;
396 unsigned int ep;
397 int alen, err;
399 if (type & 0x0800)
400 ep = P54U_PIPE_DEV;
401 else
402 ep = P54U_PIPE_BRG;
404 read->port = cpu_to_le16(type);
405 read->addr = addr;
407 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
408 read, sizeof(*read), &alen, 1000);
409 if (err)
410 return err;
412 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
413 reg, sizeof(*reg), &alen, 1000);
414 if (err)
415 return err;
417 *val = *reg;
418 return 0;
421 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
422 void *data, size_t len)
424 int alen;
425 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
426 data, len, &alen, 2000);
429 static int p54u_device_reset(struct ieee80211_hw *dev)
431 struct p54u_priv *priv = dev->priv;
432 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
434 if (lock) {
435 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
436 if (ret < 0) {
437 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
438 "device for reset (%d)!\n", ret);
439 return ret;
443 ret = usb_reset_device(priv->udev);
444 if (lock)
445 usb_unlock_device(priv->udev);
447 if (ret)
448 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
449 "device (%d)!\n", ret);
451 return ret;
454 static const char p54u_romboot_3887[] = "~~~~";
455 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
457 struct p54u_priv *priv = dev->priv;
458 u8 *buf;
459 int ret;
461 buf = kmemdup(p54u_romboot_3887, 4, GFP_KERNEL);
462 if (!buf)
463 return -ENOMEM;
464 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
465 buf, 4);
466 kfree(buf);
467 if (ret)
468 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
469 "boot ROM (%d)!\n", ret);
471 return ret;
474 static const char p54u_firmware_upload_3887[] = "<\r";
475 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
477 struct p54u_priv *priv = dev->priv;
478 int err, alen;
479 u8 carry = 0;
480 u8 *buf, *tmp;
481 const u8 *data;
482 unsigned int left, remains, block_size;
483 struct x2_header *hdr;
484 unsigned long timeout;
486 err = p54u_firmware_reset_3887(dev);
487 if (err)
488 return err;
490 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
491 if (!buf) {
492 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
493 "upload buffer!\n");
494 return -ENOMEM;
497 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
498 strcpy(buf, p54u_firmware_upload_3887);
499 left -= strlen(p54u_firmware_upload_3887);
500 tmp += strlen(p54u_firmware_upload_3887);
502 data = priv->fw->data;
503 remains = priv->fw->size;
505 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
506 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
507 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
508 hdr->fw_length = cpu_to_le32(priv->fw->size);
509 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
510 sizeof(u32)*2));
511 left -= sizeof(*hdr);
512 tmp += sizeof(*hdr);
514 while (remains) {
515 while (left--) {
516 if (carry) {
517 *tmp++ = carry;
518 carry = 0;
519 remains--;
520 continue;
522 switch (*data) {
523 case '~':
524 *tmp++ = '}';
525 carry = '^';
526 break;
527 case '}':
528 *tmp++ = '}';
529 carry = ']';
530 break;
531 default:
532 *tmp++ = *data;
533 remains--;
534 break;
536 data++;
539 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
540 if (err) {
541 dev_err(&priv->udev->dev, "(p54usb) firmware "
542 "upload failed!\n");
543 goto err_upload_failed;
546 tmp = buf;
547 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
550 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
551 priv->fw->size));
552 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
553 if (err) {
554 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
555 goto err_upload_failed;
557 timeout = jiffies + msecs_to_jiffies(1000);
558 while (!(err = usb_bulk_msg(priv->udev,
559 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
560 if (alen > 2 && !memcmp(buf, "OK", 2))
561 break;
563 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
564 err = -EINVAL;
565 break;
568 if (time_after(jiffies, timeout)) {
569 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
570 "timed out!\n");
571 err = -ETIMEDOUT;
572 break;
575 if (err) {
576 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
577 goto err_upload_failed;
580 buf[0] = 'g';
581 buf[1] = '\r';
582 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
583 if (err) {
584 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
585 goto err_upload_failed;
588 timeout = jiffies + msecs_to_jiffies(1000);
589 while (!(err = usb_bulk_msg(priv->udev,
590 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
591 if (alen > 0 && buf[0] == 'g')
592 break;
594 if (time_after(jiffies, timeout)) {
595 err = -ETIMEDOUT;
596 break;
599 if (err)
600 goto err_upload_failed;
602 err_upload_failed:
603 kfree(buf);
604 return err;
607 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
609 struct p54u_priv *priv = dev->priv;
610 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
611 int err, alen;
612 void *buf;
613 __le32 reg;
614 unsigned int remains, offset;
615 const u8 *data;
617 buf = kmalloc(512, GFP_KERNEL);
618 if (!buf) {
619 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
620 "alloc failed!\n");
621 return -ENOMEM;
624 #define P54U_WRITE(type, addr, data) \
625 do {\
626 err = p54u_write(priv, buf, type,\
627 cpu_to_le32((u32)(unsigned long)addr), data);\
628 if (err) \
629 goto fail;\
630 } while (0)
632 #define P54U_READ(type, addr) \
633 do {\
634 err = p54u_read(priv, buf, type,\
635 cpu_to_le32((u32)(unsigned long)addr), &reg);\
636 if (err)\
637 goto fail;\
638 } while (0)
640 /* power down net2280 bridge */
641 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
642 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
643 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
644 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
646 mdelay(100);
648 /* power up bridge */
649 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
650 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
651 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
653 mdelay(100);
655 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
656 cpu_to_le32(NET2280_CLK_30Mhz |
657 NET2280_PCI_ENABLE |
658 NET2280_PCI_SOFT_RESET));
660 mdelay(20);
662 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
663 cpu_to_le32(PCI_COMMAND_MEMORY |
664 PCI_COMMAND_MASTER));
666 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
667 cpu_to_le32(NET2280_BASE));
669 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
670 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
671 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
673 // TODO: we really need this?
674 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
676 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
677 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
678 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
679 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
681 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
682 cpu_to_le32(NET2280_BASE2));
684 /* finally done setting up the bridge */
686 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
687 cpu_to_le32(PCI_COMMAND_MEMORY |
688 PCI_COMMAND_MASTER));
690 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
691 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
692 cpu_to_le32(P54U_DEV_BASE));
694 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
695 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
696 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
698 /* do romboot */
699 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
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_RAMBOOT);
704 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
707 mdelay(20);
709 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
710 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
712 mdelay(20);
714 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
715 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
717 mdelay(100);
719 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
720 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
722 /* finally, we can upload firmware now! */
723 remains = priv->fw->size;
724 data = priv->fw->data;
725 offset = ISL38XX_DEV_FIRMWARE_ADDR;
727 while (remains) {
728 unsigned int block_len = min(remains, (unsigned int)512);
729 memcpy(buf, data, block_len);
731 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
732 if (err) {
733 dev_err(&priv->udev->dev, "(p54usb) firmware block "
734 "upload failed\n");
735 goto fail;
738 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
739 cpu_to_le32(0xc0000f00));
741 P54U_WRITE(NET2280_DEV_U32,
742 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
743 P54U_WRITE(NET2280_DEV_U32,
744 0x0020 | (unsigned long)&devreg->direct_mem_win,
745 cpu_to_le32(1));
747 P54U_WRITE(NET2280_DEV_U32,
748 0x0024 | (unsigned long)&devreg->direct_mem_win,
749 cpu_to_le32(block_len));
750 P54U_WRITE(NET2280_DEV_U32,
751 0x0028 | (unsigned long)&devreg->direct_mem_win,
752 cpu_to_le32(offset));
754 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
755 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
756 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
757 cpu_to_le32(block_len >> 2));
758 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
759 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
761 mdelay(10);
763 P54U_READ(NET2280_DEV_U32,
764 0x002C | (unsigned long)&devreg->direct_mem_win);
765 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
766 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
767 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
768 "transfer failed\n");
769 goto fail;
772 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
773 cpu_to_le32(NET2280_FIFO_FLUSH));
775 remains -= block_len;
776 data += block_len;
777 offset += block_len;
780 /* do ramboot */
781 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
782 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
783 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
784 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
785 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
787 mdelay(20);
789 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
790 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
792 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
793 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
795 mdelay(100);
797 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
798 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
800 /* start up the firmware */
801 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
802 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
804 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
805 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
807 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
808 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
809 NET2280_USB_INTERRUPT_ENABLE));
811 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
812 cpu_to_le32(ISL38XX_DEV_INT_RESET));
814 err = usb_interrupt_msg(priv->udev,
815 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
816 buf, sizeof(__le32), &alen, 1000);
817 if (err || alen != sizeof(__le32))
818 goto fail;
820 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
821 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
823 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
824 err = -EINVAL;
826 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
827 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
828 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
830 #undef P54U_WRITE
831 #undef P54U_READ
833 fail:
834 kfree(buf);
835 return err;
838 static int p54u_load_firmware(struct ieee80211_hw *dev)
840 struct p54u_priv *priv = dev->priv;
841 int err, i;
843 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
845 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
846 if (p54u_fwlist[i].type == priv->hw_type)
847 break;
849 if (i == __NUM_P54U_HWTYPES)
850 return -EOPNOTSUPP;
852 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
853 if (err) {
854 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
855 "(%d)!\n", p54u_fwlist[i].fw, err);
857 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
858 &priv->udev->dev);
859 if (err)
860 return err;
863 err = p54_parse_firmware(dev, priv->fw);
864 if (err)
865 goto out;
867 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
868 dev_err(&priv->udev->dev, "wrong firmware, please get "
869 "a firmware for \"%s\" and try again.\n",
870 p54u_fwlist[i].hw);
871 err = -EINVAL;
874 out:
875 if (err)
876 release_firmware(priv->fw);
878 return err;
881 static int p54u_open(struct ieee80211_hw *dev)
883 struct p54u_priv *priv = dev->priv;
884 int err;
886 err = p54u_init_urbs(dev);
887 if (err) {
888 return err;
891 priv->common.open = p54u_init_urbs;
893 return 0;
896 static void p54u_stop(struct ieee80211_hw *dev)
898 /* TODO: figure out how to reliably stop the 3887 and net2280 so
899 the hardware is still usable next time we want to start it.
900 until then, we just stop listening to the hardware.. */
901 p54u_free_urbs(dev);
904 static int __devinit p54u_probe(struct usb_interface *intf,
905 const struct usb_device_id *id)
907 struct usb_device *udev = interface_to_usbdev(intf);
908 struct ieee80211_hw *dev;
909 struct p54u_priv *priv;
910 int err;
911 unsigned int i, recognized_pipes;
913 dev = p54_init_common(sizeof(*priv));
915 if (!dev) {
916 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
917 return -ENOMEM;
920 priv = dev->priv;
921 priv->hw_type = P54U_INVALID_HW;
923 SET_IEEE80211_DEV(dev, &intf->dev);
924 usb_set_intfdata(intf, dev);
925 priv->udev = udev;
926 priv->intf = intf;
927 skb_queue_head_init(&priv->rx_queue);
928 init_usb_anchor(&priv->submitted);
930 usb_get_dev(udev);
932 /* really lazy and simple way of figuring out if we're a 3887 */
933 /* TODO: should just stick the identification in the device table */
934 i = intf->altsetting->desc.bNumEndpoints;
935 recognized_pipes = 0;
936 while (i--) {
937 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
938 case P54U_PIPE_DATA:
939 case P54U_PIPE_MGMT:
940 case P54U_PIPE_BRG:
941 case P54U_PIPE_DEV:
942 case P54U_PIPE_DATA | USB_DIR_IN:
943 case P54U_PIPE_MGMT | USB_DIR_IN:
944 case P54U_PIPE_BRG | USB_DIR_IN:
945 case P54U_PIPE_DEV | USB_DIR_IN:
946 case P54U_PIPE_INT | USB_DIR_IN:
947 recognized_pipes++;
950 priv->common.open = p54u_open;
951 priv->common.stop = p54u_stop;
952 if (recognized_pipes < P54U_PIPE_NUMBER) {
953 #ifdef CONFIG_PM
954 /* ISL3887 needs a full reset on resume */
955 udev->reset_resume = 1;
956 #endif /* CONFIG_PM */
957 err = p54u_device_reset(dev);
959 priv->hw_type = P54U_3887;
960 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
961 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
962 priv->common.tx = p54u_tx_lm87;
963 priv->upload_fw = p54u_upload_firmware_3887;
964 } else {
965 priv->hw_type = P54U_NET2280;
966 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
967 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
968 priv->common.tx = p54u_tx_net2280;
969 priv->upload_fw = p54u_upload_firmware_net2280;
971 err = p54u_load_firmware(dev);
972 if (err)
973 goto err_free_dev;
975 err = priv->upload_fw(dev);
976 if (err)
977 goto err_free_fw;
979 p54u_open(dev);
980 err = p54_read_eeprom(dev);
981 p54u_stop(dev);
982 if (err)
983 goto err_free_fw;
985 err = p54_register_common(dev, &udev->dev);
986 if (err)
987 goto err_free_fw;
989 return 0;
991 err_free_fw:
992 release_firmware(priv->fw);
994 err_free_dev:
995 p54_free_common(dev);
996 usb_set_intfdata(intf, NULL);
997 usb_put_dev(udev);
998 return err;
1001 static void __devexit p54u_disconnect(struct usb_interface *intf)
1003 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1004 struct p54u_priv *priv;
1006 if (!dev)
1007 return;
1009 p54_unregister_common(dev);
1011 priv = dev->priv;
1012 usb_put_dev(interface_to_usbdev(intf));
1013 release_firmware(priv->fw);
1014 p54_free_common(dev);
1017 static int p54u_pre_reset(struct usb_interface *intf)
1019 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1021 if (!dev)
1022 return -ENODEV;
1024 p54u_stop(dev);
1025 return 0;
1028 static int p54u_resume(struct usb_interface *intf)
1030 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1031 struct p54u_priv *priv;
1033 if (!dev)
1034 return -ENODEV;
1036 priv = dev->priv;
1037 if (unlikely(!(priv->upload_fw && priv->fw)))
1038 return 0;
1040 return priv->upload_fw(dev);
1043 static int p54u_post_reset(struct usb_interface *intf)
1045 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1046 struct p54u_priv *priv;
1047 int err;
1049 err = p54u_resume(intf);
1050 if (err)
1051 return err;
1053 /* reinitialize old device state */
1054 priv = dev->priv;
1055 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1056 ieee80211_restart_hw(dev);
1058 return 0;
1061 #ifdef CONFIG_PM
1063 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1065 return p54u_pre_reset(intf);
1068 #endif /* CONFIG_PM */
1070 static struct usb_driver p54u_driver = {
1071 .name = "p54usb",
1072 .id_table = p54u_table,
1073 .probe = p54u_probe,
1074 .disconnect = p54u_disconnect,
1075 .pre_reset = p54u_pre_reset,
1076 .post_reset = p54u_post_reset,
1077 #ifdef CONFIG_PM
1078 .suspend = p54u_suspend,
1079 .resume = p54u_resume,
1080 .reset_resume = p54u_resume,
1081 #endif /* CONFIG_PM */
1082 .soft_unbind = 1,
1085 static int __init p54u_init(void)
1087 return usb_register(&p54u_driver);
1090 static void __exit p54u_exit(void)
1092 usb_deregister(&p54u_driver);
1095 module_init(p54u_init);
1096 module_exit(p54u_exit);