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(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
60 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
61 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
62 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
63 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
64 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
65 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
66 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
67 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
68 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
69 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
70 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
71 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
72 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
73 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
74 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
75 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
76 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
77 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
78 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
79 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
80 {}
81 };
82
83 MODULE_DEVICE_TABLE(usb, p54u_table);
84
85 static const struct {
86 u32 intf;
87 enum p54u_hw_type type;
88 const char *fw;
89 const char *fw_legacy;
90 char hw[20];
91 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
92 {
93 .type = P54U_NET2280,
94 .intf = FW_LM86,
95 .fw = "isl3886usb",
96 .fw_legacy = "isl3890usb",
97 .hw = "ISL3886 + net2280",
98 },
99 {
100 .type = P54U_3887,
101 .intf = FW_LM87,
102 .fw = "isl3887usb",
103 .fw_legacy = "isl3887usb_bare",
104 .hw = "ISL3887",
105 },
106 };
107
108 static void p54u_rx_cb(struct urb *urb)
109 {
110 struct sk_buff *skb = (struct sk_buff *) urb->context;
111 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
112 struct ieee80211_hw *dev = info->dev;
113 struct p54u_priv *priv = dev->priv;
114
115 skb_unlink(skb, &priv->rx_queue);
116
117 if (unlikely(urb->status)) {
118 dev_kfree_skb_irq(skb);
119 return;
120 }
121
122 skb_put(skb, urb->actual_length);
123
124 if (priv->hw_type == P54U_NET2280)
125 skb_pull(skb, priv->common.tx_hdr_len);
126 if (priv->common.fw_interface == FW_LM87) {
127 skb_pull(skb, 4);
128 skb_put(skb, 4);
129 }
130
131 if (p54_rx(dev, skb)) {
132 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
133 if (unlikely(!skb)) {
134 /* TODO check rx queue length and refill *somewhere* */
135 return;
136 }
137
138 info = (struct p54u_rx_info *) skb->cb;
139 info->urb = urb;
140 info->dev = dev;
141 urb->transfer_buffer = skb_tail_pointer(skb);
142 urb->context = skb;
143 } else {
144 if (priv->hw_type == P54U_NET2280)
145 skb_push(skb, priv->common.tx_hdr_len);
146 if (priv->common.fw_interface == FW_LM87) {
147 skb_push(skb, 4);
148 skb_put(skb, 4);
149 }
150 skb_reset_tail_pointer(skb);
151 skb_trim(skb, 0);
152 urb->transfer_buffer = skb_tail_pointer(skb);
153 }
154 skb_queue_tail(&priv->rx_queue, skb);
155 usb_anchor_urb(urb, &priv->submitted);
156 if (usb_submit_urb(urb, GFP_ATOMIC)) {
157 skb_unlink(skb, &priv->rx_queue);
158 usb_unanchor_urb(urb);
159 dev_kfree_skb_irq(skb);
160 }
161 }
162
163 static void p54u_tx_cb(struct urb *urb)
164 {
165 struct sk_buff *skb = urb->context;
166 struct ieee80211_hw *dev = (struct ieee80211_hw *)
167 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
168
169 p54_free_skb(dev, skb);
170 }
171
172 static void p54u_tx_dummy_cb(struct urb *urb) { }
173
174 static void p54u_free_urbs(struct ieee80211_hw *dev)
175 {
176 struct p54u_priv *priv = dev->priv;
177 usb_kill_anchored_urbs(&priv->submitted);
178 }
179
180 static int p54u_init_urbs(struct ieee80211_hw *dev)
181 {
182 struct p54u_priv *priv = dev->priv;
183 struct urb *entry = NULL;
184 struct sk_buff *skb;
185 struct p54u_rx_info *info;
186 int ret = 0;
187
188 while (skb_queue_len(&priv->rx_queue) < 32) {
189 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
190 if (!skb) {
191 ret = -ENOMEM;
192 goto err;
193 }
194 entry = usb_alloc_urb(0, GFP_KERNEL);
195 if (!entry) {
196 ret = -ENOMEM;
197 goto err;
198 }
199
200 usb_fill_bulk_urb(entry, priv->udev,
201 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
202 skb_tail_pointer(skb),
203 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
204 info = (struct p54u_rx_info *) skb->cb;
205 info->urb = entry;
206 info->dev = dev;
207 skb_queue_tail(&priv->rx_queue, skb);
208
209 usb_anchor_urb(entry, &priv->submitted);
210 ret = usb_submit_urb(entry, GFP_KERNEL);
211 if (ret) {
212 skb_unlink(skb, &priv->rx_queue);
213 usb_unanchor_urb(entry);
214 goto err;
215 }
216 usb_free_urb(entry);
217 entry = NULL;
218 }
219
220 return 0;
221
222 err:
223 usb_free_urb(entry);
224 kfree_skb(skb);
225 p54u_free_urbs(dev);
226 return ret;
227 }
228
229 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
230 {
231 u32 chk = 0;
232
233 length >>= 2;
234 while (length--) {
235 chk ^= le32_to_cpu(*data++);
236 chk = (chk >> 5) ^ (chk << 3);
237 }
238
239 return cpu_to_le32(chk);
240 }
241
242 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
243 {
244 struct p54u_priv *priv = dev->priv;
245 struct urb *data_urb;
246 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
247
248 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
249 if (!data_urb)
250 return;
251
252 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
253 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
254
255 usb_fill_bulk_urb(data_urb, priv->udev,
256 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
257 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
258 p54u_tx_cb : p54u_tx_dummy_cb, skb);
259 data_urb->transfer_flags |= URB_ZERO_PACKET;
260
261 usb_anchor_urb(data_urb, &priv->submitted);
262 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
263 usb_unanchor_urb(data_urb);
264 p54_free_skb(dev, skb);
265 }
266 usb_free_urb(data_urb);
267 }
268
269 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
270 {
271 struct p54u_priv *priv = dev->priv;
272 struct urb *int_urb, *data_urb;
273 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
274 struct net2280_reg_write *reg;
275 int err = 0;
276
277 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
278 if (!reg)
279 return;
280
281 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
282 if (!int_urb) {
283 kfree(reg);
284 return;
285 }
286
287 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
288 if (!data_urb) {
289 kfree(reg);
290 usb_free_urb(int_urb);
291 return;
292 }
293
294 reg->port = cpu_to_le16(NET2280_DEV_U32);
295 reg->addr = cpu_to_le32(P54U_DEV_BASE);
296 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
297
298 memset(hdr, 0, sizeof(*hdr));
299 hdr->len = cpu_to_le16(skb->len);
300 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
301
302 usb_fill_bulk_urb(int_urb, priv->udev,
303 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
304 p54u_tx_dummy_cb, dev);
305
306 /*
307 * This flag triggers a code path in the USB subsystem that will
308 * free what's inside the transfer_buffer after the callback routine
309 * has completed.
310 */
311 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
312
313 usb_fill_bulk_urb(data_urb, priv->udev,
314 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
315 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
316 p54u_tx_cb : p54u_tx_dummy_cb, skb);
317 data_urb->transfer_flags |= URB_ZERO_PACKET;
318
319 usb_anchor_urb(int_urb, &priv->submitted);
320 err = usb_submit_urb(int_urb, GFP_ATOMIC);
321 if (err) {
322 usb_unanchor_urb(int_urb);
323 goto out;
324 }
325
326 usb_anchor_urb(data_urb, &priv->submitted);
327 err = usb_submit_urb(data_urb, GFP_ATOMIC);
328 if (err) {
329 usb_unanchor_urb(data_urb);
330 goto out;
331 }
332 out:
333 usb_free_urb(int_urb);
334 usb_free_urb(data_urb);
335
336 if (err) {
337 skb_pull(skb, sizeof(*hdr));
338 p54_free_skb(dev, skb);
339 }
340 }
341
342 static int p54u_write(struct p54u_priv *priv,
343 struct net2280_reg_write *buf,
344 enum net2280_op_type type,
345 __le32 addr, __le32 val)
346 {
347 unsigned int ep;
348 int alen;
349
350 if (type & 0x0800)
351 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
352 else
353 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
354
355 buf->port = cpu_to_le16(type);
356 buf->addr = addr;
357 buf->val = val;
358
359 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
360 }
361
362 static int p54u_read(struct p54u_priv *priv, void *buf,
363 enum net2280_op_type type,
364 __le32 addr, __le32 *val)
365 {
366 struct net2280_reg_read *read = buf;
367 __le32 *reg = buf;
368 unsigned int ep;
369 int alen, err;
370
371 if (type & 0x0800)
372 ep = P54U_PIPE_DEV;
373 else
374 ep = P54U_PIPE_BRG;
375
376 read->port = cpu_to_le16(type);
377 read->addr = addr;
378
379 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
380 read, sizeof(*read), &alen, 1000);
381 if (err)
382 return err;
383
384 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
385 reg, sizeof(*reg), &alen, 1000);
386 if (err)
387 return err;
388
389 *val = *reg;
390 return 0;
391 }
392
393 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
394 void *data, size_t len)
395 {
396 int alen;
397 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
398 data, len, &alen, 2000);
399 }
400
401 static int p54u_device_reset(struct ieee80211_hw *dev)
402 {
403 struct p54u_priv *priv = dev->priv;
404 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
405
406 if (lock) {
407 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
408 if (ret < 0) {
409 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
410 "device for reset (%d)!\n", ret);
411 return ret;
412 }
413 }
414
415 ret = usb_reset_device(priv->udev);
416 if (lock)
417 usb_unlock_device(priv->udev);
418
419 if (ret)
420 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
421 "device (%d)!\n", ret);
422
423 return ret;
424 }
425
426 static const char p54u_romboot_3887[] = "~~~~";
427 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
428 {
429 struct p54u_priv *priv = dev->priv;
430 u8 *buf;
431 int ret;
432
433 buf = kmalloc(4, GFP_KERNEL);
434 if (!buf)
435 return -ENOMEM;
436 memcpy(buf, p54u_romboot_3887, 4);
437 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
438 buf, 4);
439 kfree(buf);
440 if (ret)
441 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
442 "boot ROM (%d)!\n", ret);
443
444 return ret;
445 }
446
447 static const char p54u_firmware_upload_3887[] = "<\r";
448 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
449 {
450 struct p54u_priv *priv = dev->priv;
451 int err, alen;
452 u8 carry = 0;
453 u8 *buf, *tmp;
454 const u8 *data;
455 unsigned int left, remains, block_size;
456 struct x2_header *hdr;
457 unsigned long timeout;
458
459 err = p54u_firmware_reset_3887(dev);
460 if (err)
461 return err;
462
463 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
464 if (!buf) {
465 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
466 "upload buffer!\n");
467 return -ENOMEM;
468 }
469
470 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
471 strcpy(buf, p54u_firmware_upload_3887);
472 left -= strlen(p54u_firmware_upload_3887);
473 tmp += strlen(p54u_firmware_upload_3887);
474
475 data = priv->fw->data;
476 remains = priv->fw->size;
477
478 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
479 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
480 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
481 hdr->fw_length = cpu_to_le32(priv->fw->size);
482 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
483 sizeof(u32)*2));
484 left -= sizeof(*hdr);
485 tmp += sizeof(*hdr);
486
487 while (remains) {
488 while (left--) {
489 if (carry) {
490 *tmp++ = carry;
491 carry = 0;
492 remains--;
493 continue;
494 }
495 switch (*data) {
496 case '~':
497 *tmp++ = '}';
498 carry = '^';
499 break;
500 case '}':
501 *tmp++ = '}';
502 carry = ']';
503 break;
504 default:
505 *tmp++ = *data;
506 remains--;
507 break;
508 }
509 data++;
510 }
511
512 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
513 if (err) {
514 dev_err(&priv->udev->dev, "(p54usb) firmware "
515 "upload failed!\n");
516 goto err_upload_failed;
517 }
518
519 tmp = buf;
520 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
521 }
522
523 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
524 priv->fw->size));
525 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
526 if (err) {
527 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
528 goto err_upload_failed;
529 }
530 timeout = jiffies + msecs_to_jiffies(1000);
531 while (!(err = usb_bulk_msg(priv->udev,
532 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
533 if (alen > 2 && !memcmp(buf, "OK", 2))
534 break;
535
536 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
537 err = -EINVAL;
538 break;
539 }
540
541 if (time_after(jiffies, timeout)) {
542 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
543 "timed out!\n");
544 err = -ETIMEDOUT;
545 break;
546 }
547 }
548 if (err) {
549 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
550 goto err_upload_failed;
551 }
552
553 buf[0] = 'g';
554 buf[1] = '\r';
555 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
556 if (err) {
557 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
558 goto err_upload_failed;
559 }
560
561 timeout = jiffies + msecs_to_jiffies(1000);
562 while (!(err = usb_bulk_msg(priv->udev,
563 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
564 if (alen > 0 && buf[0] == 'g')
565 break;
566
567 if (time_after(jiffies, timeout)) {
568 err = -ETIMEDOUT;
569 break;
570 }
571 }
572 if (err)
573 goto err_upload_failed;
574
575 err_upload_failed:
576 kfree(buf);
577 return err;
578 }
579
580 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
581 {
582 struct p54u_priv *priv = dev->priv;
583 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
584 int err, alen;
585 void *buf;
586 __le32 reg;
587 unsigned int remains, offset;
588 const u8 *data;
589
590 buf = kmalloc(512, GFP_KERNEL);
591 if (!buf) {
592 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
593 "alloc failed!\n");
594 return -ENOMEM;
595 }
596
597 #define P54U_WRITE(type, addr, data) \
598 do {\
599 err = p54u_write(priv, buf, type,\
600 cpu_to_le32((u32)(unsigned long)addr), data);\
601 if (err) \
602 goto fail;\
603 } while (0)
604
605 #define P54U_READ(type, addr) \
606 do {\
607 err = p54u_read(priv, buf, type,\
608 cpu_to_le32((u32)(unsigned long)addr), ®);\
609 if (err)\
610 goto fail;\
611 } while (0)
612
613 /* power down net2280 bridge */
614 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
615 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
616 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
617 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
618
619 mdelay(100);
620
621 /* power up bridge */
622 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
623 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
624 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
625
626 mdelay(100);
627
628 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
629 cpu_to_le32(NET2280_CLK_30Mhz |
630 NET2280_PCI_ENABLE |
631 NET2280_PCI_SOFT_RESET));
632
633 mdelay(20);
634
635 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
636 cpu_to_le32(PCI_COMMAND_MEMORY |
637 PCI_COMMAND_MASTER));
638
639 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
640 cpu_to_le32(NET2280_BASE));
641
642 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
643 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
644 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
645
646 // TODO: we really need this?
647 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
648
649 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
650 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
651 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
652 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
653
654 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
655 cpu_to_le32(NET2280_BASE2));
656
657 /* finally done setting up the bridge */
658
659 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
660 cpu_to_le32(PCI_COMMAND_MEMORY |
661 PCI_COMMAND_MASTER));
662
663 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
664 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
665 cpu_to_le32(P54U_DEV_BASE));
666
667 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
668 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
669 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
670
671 /* do romboot */
672 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
673
674 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
675 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
676 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
677 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
678 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
679
680 mdelay(20);
681
682 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
683 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
684
685 mdelay(20);
686
687 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
688 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
689
690 mdelay(100);
691
692 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
693 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
694
695 /* finally, we can upload firmware now! */
696 remains = priv->fw->size;
697 data = priv->fw->data;
698 offset = ISL38XX_DEV_FIRMWARE_ADDR;
699
700 while (remains) {
701 unsigned int block_len = min(remains, (unsigned int)512);
702 memcpy(buf, data, block_len);
703
704 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
705 if (err) {
706 dev_err(&priv->udev->dev, "(p54usb) firmware block "
707 "upload failed\n");
708 goto fail;
709 }
710
711 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
712 cpu_to_le32(0xc0000f00));
713
714 P54U_WRITE(NET2280_DEV_U32,
715 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
716 P54U_WRITE(NET2280_DEV_U32,
717 0x0020 | (unsigned long)&devreg->direct_mem_win,
718 cpu_to_le32(1));
719
720 P54U_WRITE(NET2280_DEV_U32,
721 0x0024 | (unsigned long)&devreg->direct_mem_win,
722 cpu_to_le32(block_len));
723 P54U_WRITE(NET2280_DEV_U32,
724 0x0028 | (unsigned long)&devreg->direct_mem_win,
725 cpu_to_le32(offset));
726
727 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
728 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
729 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
730 cpu_to_le32(block_len >> 2));
731 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
732 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
733
734 mdelay(10);
735
736 P54U_READ(NET2280_DEV_U32,
737 0x002C | (unsigned long)&devreg->direct_mem_win);
738 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
739 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
740 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
741 "transfer failed\n");
742 goto fail;
743 }
744
745 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
746 cpu_to_le32(NET2280_FIFO_FLUSH));
747
748 remains -= block_len;
749 data += block_len;
750 offset += block_len;
751 }
752
753 /* do ramboot */
754 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
755 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
756 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
757 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
758 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
759
760 mdelay(20);
761
762 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
763 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
764
765 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
766 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
767
768 mdelay(100);
769
770 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
771 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
772
773 /* start up the firmware */
774 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
775 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
776
777 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
778 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
779
780 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
781 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
782 NET2280_USB_INTERRUPT_ENABLE));
783
784 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
785 cpu_to_le32(ISL38XX_DEV_INT_RESET));
786
787 err = usb_interrupt_msg(priv->udev,
788 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
789 buf, sizeof(__le32), &alen, 1000);
790 if (err || alen != sizeof(__le32))
791 goto fail;
792
793 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
794 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
795
796 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
797 err = -EINVAL;
798
799 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
800 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
801 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
802
803 #undef P54U_WRITE
804 #undef P54U_READ
805
806 fail:
807 kfree(buf);
808 return err;
809 }
810
811 static int p54u_load_firmware(struct ieee80211_hw *dev)
812 {
813 struct p54u_priv *priv = dev->priv;
814 int err, i;
815
816 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
817
818 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
819 if (p54u_fwlist[i].type == priv->hw_type)
820 break;
821
822 if (i == __NUM_P54U_HWTYPES)
823 return -EOPNOTSUPP;
824
825 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
826 if (err) {
827 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
828 "(%d)!\n", p54u_fwlist[i].fw, err);
829
830 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
831 &priv->udev->dev);
832 if (err)
833 return err;
834 }
835
836 err = p54_parse_firmware(dev, priv->fw);
837 if (err)
838 goto out;
839
840 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
841 dev_err(&priv->udev->dev, "wrong firmware, please get "
842 "a firmware for \"%s\" and try again.\n",
843 p54u_fwlist[i].hw);
844 err = -EINVAL;
845 }
846
847 out:
848 if (err)
849 release_firmware(priv->fw);
850
851 return err;
852 }
853
854 static int p54u_open(struct ieee80211_hw *dev)
855 {
856 struct p54u_priv *priv = dev->priv;
857 int err;
858
859 err = p54u_init_urbs(dev);
860 if (err) {
861 return err;
862 }
863
864 priv->common.open = p54u_init_urbs;
865
866 return 0;
867 }
868
869 static void p54u_stop(struct ieee80211_hw *dev)
870 {
871 /* TODO: figure out how to reliably stop the 3887 and net2280 so
872 the hardware is still usable next time we want to start it.
873 until then, we just stop listening to the hardware.. */
874 p54u_free_urbs(dev);
875 return;
876 }
877
878 static int __devinit p54u_probe(struct usb_interface *intf,
879 const struct usb_device_id *id)
880 {
881 struct usb_device *udev = interface_to_usbdev(intf);
882 struct ieee80211_hw *dev;
883 struct p54u_priv *priv;
884 int err;
885 unsigned int i, recognized_pipes;
886
887 dev = p54_init_common(sizeof(*priv));
888
889 if (!dev) {
890 dev_err(&udev->dev, "(p54usb) ieee80211 alloc failed\n");
891 return -ENOMEM;
892 }
893
894 priv = dev->priv;
895 priv->hw_type = P54U_INVALID_HW;
896
897 SET_IEEE80211_DEV(dev, &intf->dev);
898 usb_set_intfdata(intf, dev);
899 priv->udev = udev;
900 priv->intf = intf;
901 skb_queue_head_init(&priv->rx_queue);
902 init_usb_anchor(&priv->submitted);
903
904 usb_get_dev(udev);
905
906 /* really lazy and simple way of figuring out if we're a 3887 */
907 /* TODO: should just stick the identification in the device table */
908 i = intf->altsetting->desc.bNumEndpoints;
909 recognized_pipes = 0;
910 while (i--) {
911 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
912 case P54U_PIPE_DATA:
913 case P54U_PIPE_MGMT:
914 case P54U_PIPE_BRG:
915 case P54U_PIPE_DEV:
916 case P54U_PIPE_DATA | USB_DIR_IN:
917 case P54U_PIPE_MGMT | USB_DIR_IN:
918 case P54U_PIPE_BRG | USB_DIR_IN:
919 case P54U_PIPE_DEV | USB_DIR_IN:
920 case P54U_PIPE_INT | USB_DIR_IN:
921 recognized_pipes++;
922 }
923 }
924 priv->common.open = p54u_open;
925 priv->common.stop = p54u_stop;
926 if (recognized_pipes < P54U_PIPE_NUMBER) {
927 #ifdef CONFIG_PM
928 /* ISL3887 needs a full reset on resume */
929 udev->reset_resume = 1;
930 err = p54u_device_reset(dev);
931 #endif
932
933 priv->hw_type = P54U_3887;
934 dev->extra_tx_headroom += sizeof(struct lm87_tx_hdr);
935 priv->common.tx_hdr_len = sizeof(struct lm87_tx_hdr);
936 priv->common.tx = p54u_tx_lm87;
937 priv->upload_fw = p54u_upload_firmware_3887;
938 } else {
939 priv->hw_type = P54U_NET2280;
940 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
941 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
942 priv->common.tx = p54u_tx_net2280;
943 priv->upload_fw = p54u_upload_firmware_net2280;
944 }
945 err = p54u_load_firmware(dev);
946 if (err)
947 goto err_free_dev;
948
949 err = priv->upload_fw(dev);
950 if (err)
951 goto err_free_fw;
952
953 p54u_open(dev);
954 err = p54_read_eeprom(dev);
955 p54u_stop(dev);
956 if (err)
957 goto err_free_fw;
958
959 err = p54_register_common(dev, &udev->dev);
960 if (err)
961 goto err_free_fw;
962
963 return 0;
964
965 err_free_fw:
966 release_firmware(priv->fw);
967
968 err_free_dev:
969 ieee80211_free_hw(dev);
970 usb_set_intfdata(intf, NULL);
971 usb_put_dev(udev);
972 return err;
973 }
974
975 static void __devexit p54u_disconnect(struct usb_interface *intf)
976 {
977 struct ieee80211_hw *dev = usb_get_intfdata(intf);
978 struct p54u_priv *priv;
979
980 if (!dev)
981 return;
982
983 ieee80211_unregister_hw(dev);
984
985 priv = dev->priv;
986 usb_put_dev(interface_to_usbdev(intf));
987 release_firmware(priv->fw);
988 p54_free_common(dev);
989 ieee80211_free_hw(dev);
990 }
991
992 static int p54u_pre_reset(struct usb_interface *intf)
993 {
994 struct ieee80211_hw *dev = usb_get_intfdata(intf);
995
996 if (!dev)
997 return -ENODEV;
998
999 p54u_stop(dev);
1000 return 0;
1001 }
1002
1003 static int p54u_resume(struct usb_interface *intf)
1004 {
1005 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1006 struct p54u_priv *priv;
1007
1008 if (!dev)
1009 return -ENODEV;
1010
1011 priv = dev->priv;
1012 if (unlikely(!(priv->upload_fw && priv->fw)))
1013 return 0;
1014
1015 return priv->upload_fw(dev);
1016 }
1017
1018 static int p54u_post_reset(struct usb_interface *intf)
1019 {
1020 struct ieee80211_hw *dev = usb_get_intfdata(intf);
1021 struct p54u_priv *priv;
1022 int err;
1023
1024 err = p54u_resume(intf);
1025 if (err)
1026 return err;
1027
1028 /* reinitialize old device state */
1029 priv = dev->priv;
1030 if (priv->common.mode != NL80211_IFTYPE_UNSPECIFIED)
1031 ieee80211_restart_hw(dev);
1032
1033 return 0;
1034 }
1035
1036 #ifdef CONFIG_PM
1037
1038 static int p54u_suspend(struct usb_interface *intf, pm_message_t message)
1039 {
1040 return p54u_pre_reset(intf);
1041 }
1042
1043 #endif /* CONFIG_PM */
1044
1045 static struct usb_driver p54u_driver = {
1046 .name = "p54usb",
1047 .id_table = p54u_table,
1048 .probe = p54u_probe,
1049 .disconnect = p54u_disconnect,
1050 .pre_reset = p54u_pre_reset,
1051 .post_reset = p54u_post_reset,
1052 #ifdef CONFIG_PM
1053 .suspend = p54u_suspend,
1054 .resume = p54u_resume,
1055 .reset_resume = p54u_resume,
1056 #endif /* CONFIG_PM */
1057 .soft_unbind = 1,
1058 };
1059
1060 static int __init p54u_init(void)
1061 {
1062 return usb_register(&p54u_driver);
1063 }
1064
1065 static void __exit p54u_exit(void)
1066 {
1067 usb_deregister(&p54u_driver);
1068 }
1069
1070 module_init(p54u_init);
1071 module_exit(p54u_exit);
1072
|
This page was automatically generated by the
LXR engine.
|