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