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