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