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