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