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