Add the prism54-mac80211 version from #2560
[openwrt/svn-archive/archive.git] / package / p54 / src / p54usb.c
1
2 /*
3 * Linux device driver for USB based Prism54
4 *
5 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
6 *
7 * Based on the islsm (softmac prism54) driver, which is:
8 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
9 *
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.
13 */
14
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>
23
24 #include "p54.h"
25 #include "p54usb.h"
26
27 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
28 MODULE_DESCRIPTION("Prism54 USB wireless driver");
29 MODULE_LICENSE("GPL");
30 MODULE_ALIAS("prism54usb");
31
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 */
49
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(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
66 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
67 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
68 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
69 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
70 {}
71 };
72
73 MODULE_DEVICE_TABLE(usb, p54u_table);
74
75 static void p54u_rx_cb(struct urb *urb)
76 {
77 struct sk_buff *skb = (struct sk_buff *) urb->context;
78 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
79 struct ieee80211_hw *dev = info->dev;
80 struct p54u_priv *priv = dev->priv;
81
82 if (unlikely(urb->status)) {
83 info->urb = NULL;
84 usb_free_urb(urb);
85 return;
86 }
87
88 skb_unlink(skb, &priv->rx_queue);
89 skb_put(skb, urb->actual_length);
90 if (!priv->hw_type)
91 skb_pull(skb, sizeof(struct net2280_tx_hdr));
92
93 if (p54_rx(dev, skb)) {
94 skb = dev_alloc_skb(MAX_RX_SIZE);
95 if (unlikely(!skb)) {
96 usb_free_urb(urb);
97 /* TODO check rx queue length and refill *somewhere* */
98 return;
99 }
100
101 info = (struct p54u_rx_info *) skb->cb;
102 info->urb = urb;
103 info->dev = dev;
104 urb->transfer_buffer = skb_tail_pointer(skb);
105 urb->context = skb;
106 skb_queue_tail(&priv->rx_queue, skb);
107 } else {
108 skb_trim(skb, 0);
109 skb_queue_tail(&priv->rx_queue, skb);
110 }
111
112 usb_submit_urb(urb, GFP_ATOMIC);
113 }
114
115 static void p54u_tx_cb(struct urb *urb)
116 {
117 usb_free_urb(urb);
118 }
119
120 static void p54u_tx_free_cb(struct urb *urb)
121 {
122 kfree(urb->transfer_buffer);
123 usb_free_urb(urb);
124 }
125
126 static int p54u_init_urbs(struct ieee80211_hw *dev)
127 {
128 struct p54u_priv *priv = dev->priv;
129 struct urb *entry;
130 struct sk_buff *skb;
131 struct p54u_rx_info *info;
132
133 while (skb_queue_len(&priv->rx_queue) < 32) {
134 skb = __dev_alloc_skb(MAX_RX_SIZE, GFP_KERNEL);
135 if (!skb)
136 break;
137 entry = usb_alloc_urb(0, GFP_KERNEL);
138 if (!entry) {
139 kfree_skb(skb);
140 break;
141 }
142 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);
143 info = (struct p54u_rx_info *) skb->cb;
144 info->urb = entry;
145 info->dev = dev;
146 skb_queue_tail(&priv->rx_queue, skb);
147 usb_submit_urb(entry, GFP_KERNEL);
148 }
149
150 return 0;
151 }
152
153 static void p54u_free_urbs(struct ieee80211_hw *dev)
154 {
155 struct p54u_priv *priv = dev->priv;
156 struct p54u_rx_info *info;
157 struct sk_buff *skb;
158
159 while ((skb = skb_dequeue(&priv->rx_queue))) {
160 info = (struct p54u_rx_info *) skb->cb;
161 if (!info->urb)
162 continue;
163
164 usb_kill_urb(info->urb);
165 kfree_skb(skb);
166 }
167 }
168
169 static void p54u_tx_3887(struct ieee80211_hw *dev, struct p54_control_hdr *data,
170 size_t len, int free_on_tx)
171 {
172 struct p54u_priv *priv = dev->priv;
173 struct urb *addr_urb, *data_urb;
174
175 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
176 if (!addr_urb)
177 return;
178
179 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
180 if (!data_urb) {
181 usb_free_urb(addr_urb);
182 return;
183 }
184
185 usb_fill_bulk_urb(addr_urb, priv->udev,
186 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), &data->req_id,
187 sizeof(data->req_id), p54u_tx_cb, dev);
188 usb_fill_bulk_urb(data_urb, priv->udev,
189 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), data, len,
190 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
191
192 usb_submit_urb(addr_urb, GFP_ATOMIC);
193 usb_submit_urb(data_urb, GFP_ATOMIC);
194 }
195
196 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct p54_control_hdr *data,
197 size_t len, int free_on_tx)
198 {
199 struct p54u_priv *priv = dev->priv;
200 struct urb *int_urb, *data_urb;
201 struct net2280_tx_hdr *hdr;
202 struct net2280_reg_write *reg;
203
204 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
205 if (!reg)
206 return;
207
208 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
209 if (!int_urb) {
210 kfree(reg);
211 return;
212 }
213
214 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
215 if (!data_urb) {
216 kfree(reg);
217 usb_free_urb(int_urb);
218 return;
219 }
220
221 reg->port = cpu_to_le16(NET2280_DEV_U32);
222 reg->addr = cpu_to_le32(P54U_DEV_BASE);
223 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
224
225 len += sizeof(*data);
226 hdr = (void *)data - sizeof(*hdr);
227 memset(hdr, 0, sizeof(*hdr));
228 hdr->device_addr = data->req_id;
229 hdr->len = cpu_to_le16(len);
230
231 usb_fill_bulk_urb(int_urb, priv->udev,
232 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
233 p54u_tx_free_cb, dev);
234 usb_submit_urb(int_urb, GFP_ATOMIC);
235
236 usb_fill_bulk_urb(data_urb, priv->udev,
237 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), hdr, len + sizeof(*hdr),
238 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
239 usb_submit_urb(data_urb, GFP_ATOMIC);
240 }
241
242 static int p54u_write(struct p54u_priv *priv,
243 struct net2280_reg_write *buf,
244 enum net2280_op_type type,
245 __le32 addr, __le32 val)
246 {
247 unsigned int ep;
248 int alen;
249
250 if (type & 0x0800)
251 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
252 else
253 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
254
255 buf->port = cpu_to_le16(type);
256 buf->addr = addr;
257 buf->val = val;
258
259 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
260 }
261
262 static int p54u_read(struct p54u_priv *priv, void *buf,
263 enum net2280_op_type type,
264 __le32 addr, __le32 *val)
265 {
266 struct net2280_reg_read *read = buf;
267 __le32 *reg = buf;
268 unsigned int ep;
269 int alen, err;
270
271 if (type & 0x0800)
272 ep = P54U_PIPE_DEV;
273 else
274 ep = P54U_PIPE_BRG;
275
276 read->port = cpu_to_le16(type);
277 read->addr = addr;
278
279 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
280 read, sizeof(*read), &alen, 1000);
281 if (err)
282 return err;
283
284 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
285 reg, sizeof(*reg), &alen, 1000);
286 if (err)
287 return err;
288
289 *val = *reg;
290 return 0;
291 }
292
293 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
294 void *data, size_t len)
295 {
296 int alen;
297 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
298 data, len, &alen, 2000);
299 }
300
301 static int p54u_read_eeprom(struct ieee80211_hw *dev)
302 {
303 struct p54u_priv *priv = dev->priv;
304 void *buf;
305 struct p54_control_hdr *hdr;
306 int err, alen;
307 size_t offset = priv->hw_type ? 0x10 : 0x20;
308
309 buf = kmalloc(0x2020, GFP_KERNEL);
310 if (!buf) {
311 printk(KERN_ERR "prism54usb: cannot allocate memory for"
312 "eeprom readback!\n");
313 return -ENOMEM;
314 }
315
316 if (priv->hw_type) {
317 *((u32 *) buf) = priv->common.rx_start;
318 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
319 if (err) {
320 printk(KERN_ERR "prism54usb: addr send failed\n");
321 goto fail;
322 }
323 } else {
324 struct net2280_reg_write *reg = buf;
325 reg->port = cpu_to_le16(NET2280_DEV_U32);
326 reg->addr = cpu_to_le32(P54U_DEV_BASE);
327 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
328 err = p54u_bulk_msg(priv, P54U_PIPE_DEV, buf, sizeof(*reg));
329 if (err) {
330 printk(KERN_ERR "prism54usb: dev_int send failed\n");
331 goto fail;
332 }
333 }
334
335 hdr = buf + priv->common.tx_hdr_len;
336 p54_fill_eeprom_readback(hdr);
337 hdr->req_id = cpu_to_le32(priv->common.rx_start);
338 if (priv->common.tx_hdr_len) {
339 struct net2280_tx_hdr *tx_hdr = buf;
340 tx_hdr->device_addr = hdr->req_id;
341 tx_hdr->len = cpu_to_le16(EEPROM_READBACK_LEN);
342 }
343
344 /* we can just pretend to send 0x2000 bytes of nothing in the headers */
345 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf,
346 EEPROM_READBACK_LEN + priv->common.tx_hdr_len);
347 if (err) {
348 printk(KERN_ERR "prism54usb: eeprom req send failed\n");
349 goto fail;
350 }
351
352 err = usb_bulk_msg(priv->udev,
353 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
354 buf, 0x2020, &alen, 1000);
355 if (!err && alen > offset) {
356 p54_parse_eeprom(dev, (u8 *)buf + offset, alen - offset);
357 } else {
358 printk(KERN_ERR "prism54usb: eeprom read failed!\n");
359 err = -EINVAL;
360 goto fail;
361 }
362
363 fail:
364 kfree(buf);
365 return err;
366 }
367
368 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
369 {
370 static char start_string[] = "~~~~<\r";
371 struct p54u_priv *priv = dev->priv;
372 const struct firmware *fw_entry = NULL;
373 int err, alen;
374 u8 carry = 0;
375 u8 *buf, *tmp, *data;
376 unsigned int left, remains, block_size;
377 struct x2_header *hdr;
378 unsigned long timeout;
379
380 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
381 if (!buf) {
382 printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!\n");
383 err = -ENOMEM;
384 goto err_bufalloc;
385 }
386
387 memcpy(buf, start_string, 4);
388 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
389 if (err) {
390 printk(KERN_ERR "p54usb: reset failed! (%d)\n", err);
391 goto err_reset;
392 }
393
394 err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);
395 if (err) {
396 printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!\n");
397 goto err_req_fw_failed;
398 }
399
400 p54_parse_firmware(dev, fw_entry);
401
402 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
403 strcpy(buf, start_string);
404 left -= strlen(start_string);
405 tmp += strlen(start_string);
406
407 data = fw_entry->data;
408 remains = fw_entry->size;
409
410 hdr = (struct x2_header *)(buf + strlen(start_string));
411 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
412 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
413 hdr->fw_length = cpu_to_le32(fw_entry->size);
414 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
415 sizeof(u32)*2));
416 left -= sizeof(*hdr);
417 tmp += sizeof(*hdr);
418
419 while (remains) {
420 while (left--) {
421 if (carry) {
422 *tmp++ = carry;
423 carry = 0;
424 remains--;
425 continue;
426 }
427 switch (*data) {
428 case '~':
429 *tmp++ = '}';
430 carry = '^';
431 break;
432 case '}':
433 *tmp++ = '}';
434 carry = ']';
435 break;
436 default:
437 *tmp++ = *data;
438 remains--;
439 break;
440 }
441 data++;
442 }
443
444 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
445 if (err) {
446 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
447 goto err_upload_failed;
448 }
449
450 tmp = buf;
451 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
452 }
453
454 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
455 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
456 if (err) {
457 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
458 goto err_upload_failed;
459 }
460
461 timeout = jiffies + msecs_to_jiffies(1000);
462 while (!(err = usb_bulk_msg(priv->udev,
463 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
464 if (alen > 2 && !memcmp(buf, "OK", 2))
465 break;
466
467 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
468 printk(KERN_INFO "prism54usb: firmware upload failed!\n");
469 err = -EINVAL;
470 break;
471 }
472
473 if (time_after(jiffies, timeout)) {
474 printk(KERN_ERR "prism54usb: firmware boot timed out!\n");
475 err = -ETIMEDOUT;
476 break;
477 }
478 }
479 if (err)
480 goto err_upload_failed;
481
482 buf[0] = 'g';
483 buf[1] = '\r';
484 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
485 if (err) {
486 printk(KERN_ERR "prism54usb: firmware boot failed!\n");
487 goto err_upload_failed;
488 }
489
490 timeout = jiffies + msecs_to_jiffies(1000);
491 while (!(err = usb_bulk_msg(priv->udev,
492 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
493 if (alen > 0 && buf[0] == 'g')
494 break;
495
496 if (time_after(jiffies, timeout)) {
497 err = -ETIMEDOUT;
498 break;
499 }
500 }
501 if (err)
502 goto err_upload_failed;
503
504 err_upload_failed:
505 release_firmware(fw_entry);
506 err_req_fw_failed:
507 err_reset:
508 kfree(buf);
509 err_bufalloc:
510 return err;
511 }
512
513 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
514 {
515 struct p54u_priv *priv = dev->priv;
516 const struct firmware *fw_entry = NULL;
517 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
518 int err, alen;
519 void *buf;
520 __le32 reg;
521 unsigned int remains, offset;
522 u8 *data;
523
524 buf = kmalloc(512, GFP_KERNEL);
525 if (!buf) {
526 printk(KERN_ERR "p54usb: firmware buffer alloc failed!\n");
527 return -ENOMEM;
528 }
529
530 err = request_firmware(&fw_entry, "isl3890usb", &priv->udev->dev);
531 if (err) {
532 printk(KERN_ERR "p54usb: cannot find firmware (isl3890usb)!\n");
533 kfree(buf);
534 return err;
535 }
536
537 p54_parse_firmware(dev, fw_entry);
538
539 #define P54U_WRITE(type, addr, data) \
540 do {\
541 err = p54u_write(priv, buf, type,\
542 cpu_to_le32((u32)(unsigned long)addr), data);\
543 if (err) \
544 goto fail;\
545 } while (0)
546
547 #define P54U_READ(type, addr) \
548 do {\
549 err = p54u_read(priv, buf, type,\
550 cpu_to_le32((u32)(unsigned long)addr), &reg);\
551 if (err)\
552 goto fail;\
553 } while (0)
554
555 /* power down net2280 bridge */
556 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
557 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
558 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
559 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
560
561 mdelay(100);
562
563 /* power up bridge */
564 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
565 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
566 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
567
568 mdelay(100);
569
570 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
571 cpu_to_le32(NET2280_CLK_30Mhz |
572 NET2280_PCI_ENABLE |
573 NET2280_PCI_SOFT_RESET));
574
575 mdelay(20);
576
577 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
578 cpu_to_le32(PCI_COMMAND_MEMORY |
579 PCI_COMMAND_MASTER));
580
581 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
582 cpu_to_le32(NET2280_BASE));
583
584 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
585 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
586 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
587
588 // TODO: we really need this?
589 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
590
591 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
592 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
593 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
594 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
595
596 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
597 cpu_to_le32(NET2280_BASE2));
598
599 /* finally done setting up the bridge */
600
601 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
602 cpu_to_le32(PCI_COMMAND_MEMORY |
603 PCI_COMMAND_MASTER));
604
605 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
606 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
607 cpu_to_le32(P54U_DEV_BASE));
608
609 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
610 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
611 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
612
613 /* do romboot */
614 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
615
616 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
617 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
618 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
619 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
620 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
621
622 mdelay(20);
623
624 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
625 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
626
627 mdelay(20);
628
629 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
630 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
631
632 mdelay(100);
633
634 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
635 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
636
637 /* finally, we can upload firmware now! */
638 remains = fw_entry->size;
639 data = fw_entry->data;
640 offset = ISL38XX_DEV_FIRMWARE_ADDR;
641
642 while (remains) {
643 unsigned int block_len = min(remains, (unsigned int)512);
644 memcpy(buf, data, block_len);
645
646 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
647 if (err) {
648 printk(KERN_ERR "prism54usb: firmware block upload "
649 "failed\n");
650 goto fail;
651 }
652
653 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
654 cpu_to_le32(0xc0000f00));
655
656 P54U_WRITE(NET2280_DEV_U32,
657 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
658 P54U_WRITE(NET2280_DEV_U32,
659 0x0020 | (unsigned long)&devreg->direct_mem_win,
660 cpu_to_le32(1));
661
662 P54U_WRITE(NET2280_DEV_U32,
663 0x0024 | (unsigned long)&devreg->direct_mem_win,
664 cpu_to_le32(block_len));
665 P54U_WRITE(NET2280_DEV_U32,
666 0x0028 | (unsigned long)&devreg->direct_mem_win,
667 cpu_to_le32(offset));
668
669 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
670 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
671 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
672 cpu_to_le32(block_len >> 2));
673 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
674 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
675
676 mdelay(10);
677
678 P54U_READ(NET2280_DEV_U32,
679 0x002C | (unsigned long)&devreg->direct_mem_win);
680 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
681 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
682 printk(KERN_ERR "prism54usb: firmware DMA transfer "
683 "failed\n");
684 goto fail;
685 }
686
687 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
688 cpu_to_le32(NET2280_FIFO_FLUSH));
689
690 remains -= block_len;
691 data += block_len;
692 offset += block_len;
693 }
694
695 /* do ramboot */
696 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
697 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
698 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
699 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
700 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
701
702 mdelay(20);
703
704 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
706
707 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
708 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
709
710 mdelay(100);
711
712 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
713 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
714
715 /* start up the firmware */
716 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
717 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
718
719 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
720 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
721
722 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
723 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
724 NET2280_USB_INTERRUPT_ENABLE));
725
726 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
727 cpu_to_le32(ISL38XX_DEV_INT_RESET));
728
729 err = usb_interrupt_msg(priv->udev,
730 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
731 buf, sizeof(__le32), &alen, 1000);
732 if (err || alen != sizeof(__le32))
733 goto fail;
734
735 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
736 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
737
738 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
739 err = -EINVAL;
740
741 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
742 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
743 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
744
745 #undef P54U_WRITE
746 #undef P54U_READ
747
748 fail:
749 release_firmware(fw_entry);
750 kfree(buf);
751 return err;
752 }
753
754 static int p54u_open(struct ieee80211_hw *dev)
755 {
756 struct p54u_priv *priv = dev->priv;
757 int err;
758
759 err = p54u_init_urbs(dev);
760 if (err) {
761 return err;
762 }
763
764 priv->common.open = p54u_init_urbs;
765
766 return 0;
767 }
768
769 static void p54u_stop(struct ieee80211_hw *dev)
770 {
771 /* TODO: figure out how to reliably stop the 3887 and net2280 so
772 the hardware is still usable next time we want to start it.
773 until then, we just stop listening to the hardware.. */
774 p54u_free_urbs(dev);
775 return;
776 }
777
778 static int __devinit p54u_probe(struct usb_interface *intf,
779 const struct usb_device_id *id)
780 {
781 struct usb_device *udev = interface_to_usbdev(intf);
782 struct ieee80211_hw *dev;
783 struct p54u_priv *priv;
784 int err;
785 unsigned int i, recognized_pipes;
786
787 dev = p54_init_common(sizeof(*priv));
788 if (!dev) {
789 printk(KERN_ERR "prism54usb: ieee80211 alloc failed\n");
790 return -ENOMEM;
791 }
792
793 priv = dev->priv;
794
795 SET_IEEE80211_DEV(dev, &intf->dev);
796 usb_set_intfdata(intf, dev);
797 priv->udev = udev;
798
799 usb_get_dev(udev);
800
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;
805 while (i--) {
806 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
807 case P54U_PIPE_DATA:
808 case P54U_PIPE_MGMT:
809 case P54U_PIPE_BRG:
810 case P54U_PIPE_DEV:
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:
816 recognized_pipes++;
817 }
818 }
819 priv->common.open = p54u_open;
820
821 if (recognized_pipes < P54U_PIPE_NUMBER) {
822 priv->hw_type = P54U_3887;
823 priv->common.tx = p54u_tx_3887;
824 } else {
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;
828 }
829 priv->common.stop = p54u_stop;
830
831 if (priv->hw_type)
832 err = p54u_upload_firmware_3887(dev);
833 else
834 err = p54u_upload_firmware_net2280(dev);
835 if (err)
836 goto err_free_dev;
837
838 err = p54u_read_eeprom(dev);
839 if (err)
840 goto err_free_dev;
841
842 if (!is_valid_ether_addr(dev->wiphy->perm_addr)) {
843 u8 perm_addr[ETH_ALEN];
844
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);
848 }
849
850 skb_queue_head_init(&priv->rx_queue);
851
852 err = ieee80211_register_hw(dev);
853 if (err) {
854 printk(KERN_ERR "prism54usb: Cannot register netdevice\n");
855 goto err_free_dev;
856 }
857
858 printk(KERN_INFO "%s: hwaddr " MAC_FMT ", isl38%02x\n",
859 wiphy_name(dev->wiphy), MAC_ARG(dev->wiphy->perm_addr),
860 priv->common.version);
861
862 return 0;
863
864 err_free_dev:
865 ieee80211_free_hw(dev);
866 usb_set_intfdata(intf, NULL);
867 usb_put_dev(udev);
868 return err;
869 }
870
871 static void __devexit p54u_disconnect(struct usb_interface *intf)
872 {
873 struct ieee80211_hw *dev = usb_get_intfdata(intf);
874 struct p54u_priv *priv;
875
876 if (!dev)
877 return;
878
879 ieee80211_unregister_hw(dev);
880
881 priv = dev->priv;
882 usb_put_dev(interface_to_usbdev(intf));
883 p54_free_common(dev);
884 ieee80211_free_hw(dev);
885 }
886
887 static struct usb_driver p54u_driver = {
888 .name = "prism54usb",
889 .id_table = p54u_table,
890 .probe = p54u_probe,
891 .disconnect = p54u_disconnect,
892 };
893
894 static int __init p54u_init(void)
895 {
896 return usb_register(&p54u_driver);
897 }
898
899 static void __exit p54u_exit(void)
900 {
901 usb_deregister(&p54u_driver);
902 }
903
904 module_init(p54u_init);
905 module_exit(p54u_exit);