?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
initial commit with v2.6.32.60
[linux-2.6.32.60-moxart.git] / drivers / net / wireless / p54 / p54usb.c
blobcb74ac655e4d62d985d02c855628320fd3feacdc
1
2 /*
3 * Linux device driver for USB based Prism54
4 *
5 * Copyright (c) 2006, Michael Wu <flamingice@sourmilk.net>
6 *
7 * Based on the islsm (softmac prism54) driver, which is:
8 * Copyright 2004-2006 Jean-Baptiste Note <jbnote@gmail.com>, et al.
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License version 2 as
12 * published by the Free Software Foundation.
13 */
14
15 #include <linux/init.h>
16 #include <linux/usb.h>
17 #include <linux/pci.h>
18 #include <linux/firmware.h>
19 #include <linux/etherdevice.h>
20 #include <linux/delay.h>
21 #include <linux/crc32.h>
22 #include <net/mac80211.h>
23
24 #include "p54.h"
25 #include "lmac.h"
26 #include "p54usb.h"
27
28 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
29 MODULE_DESCRIPTION("Prism54 USB wireless driver");
30 MODULE_LICENSE("GPL");
31 MODULE_ALIAS("prism54usb");
32 MODULE_FIRMWARE("isl3886usb");
33 MODULE_FIRMWARE("isl3887usb");
34
35 /*
36 * Note:
37 *
38 * Always update our wiki's device list (located at:
39 * http://wireless.kernel.org/en/users/Drivers/p54/devices ),
40 * whenever you add a new device.
41 */
42
43 static struct usb_device_id p54u_table[] __devinitdata = {
44 /* Version 1 devices (pci chip + net2280) */
45 {USB_DEVICE(0x0411, 0x0050)}, /* Buffalo WLI2-USB2-G54 */
46 {USB_DEVICE(0x045e, 0x00c2)}, /* Microsoft MN-710 */
47 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
48 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
49 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
50 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
51 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
52 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
53 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
54 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
55 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
56 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
57 {USB_DEVICE(0x0bf8, 0x1007)}, /* Fujitsu E-5400 USB */
58 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
59 {USB_DEVICE(0x0db0, 0x6826)}, /* MSI UB54G (MS-6826) */
60 {USB_DEVICE(0x107b, 0x55f2)}, /* Gateway WGU-210 (Gemtek) */
61 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
62 {USB_DEVICE(0x1435, 0x0210)}, /* Inventel UR054G */
63 {USB_DEVICE(0x15a9, 0x0002)}, /* Gemtek WUBI-100GW 802.11g */
64 {USB_DEVICE(0x1630, 0x0005)}, /* 2Wire 802.11g USB (v1) / Z-Com */
65 {USB_DEVICE(0x182d, 0x096b)}, /* Sitecom WL-107 */
66 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
67 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
68 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
69 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
70 {USB_DEVICE(0x2001, 0x3762)}, /* Conceptronic C54U */
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, 0xc501)}, /* Zoom Wireless-G 4410 */
84 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
85 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
86 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
87 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
88 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
89 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
90 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
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 = (struct ieee80211_hw *)
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 = kmalloc(4, GFP_KERNEL);
459 if (!buf)
460 return -ENOMEM;
461 memcpy(buf, p54u_romboot_3887, 4);
462 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
463 buf, 4);
464 kfree(buf);
465 if (ret)
466 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
467 "boot ROM (%d)!\n", ret);
468
469 return ret;
470 }
471
472 static const char p54u_firmware_upload_3887[] = "<\r";
473 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
474 {
475 struct p54u_priv *priv = dev->priv;
476 int err, alen;
477 u8 carry = 0;
478 u8 *buf, *tmp;
479 const u8 *data;
480 unsigned int left, remains, block_size;
481 struct x2_header *hdr;
482 unsigned long timeout;
483
484 err = p54u_firmware_reset_3887(dev);
485 if (err)
486 return err;
487
488 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
489 if (!buf) {
490 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
491 "upload buffer!\n");
492 return -ENOMEM;
493 }
494
495 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
496 strcpy(buf, p54u_firmware_upload_3887);
497 left -= strlen(p54u_firmware_upload_3887);
498 tmp += strlen(p54u_firmware_upload_3887);
499
500 data = priv->fw->data;
501 remains = priv->fw->size;
502
503 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
504 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
505 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
506 hdr->fw_length = cpu_to_le32(priv->fw->size);
507 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
508 sizeof(u32)*2));
509 left -= sizeof(*hdr);
510 tmp += sizeof(*hdr);
511
512 while (remains) {
513 while (left--) {
514 if (carry) {
515 *tmp++ = carry;
516 carry = 0;
517 remains--;
518 continue;
519 }
520 switch (*data) {
521 case '~':
522 *tmp++ = '}';
523 carry = '^';
524 break;
525 case '}':
526 *tmp++ = '}';
527 carry = ']';
528 break;
529 default:
530 *tmp++ = *data;
531 remains--;
532 break;
533 }
534 data++;
535 }
536
537 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
538 if (err) {
539 dev_err(&priv->udev->dev, "(p54usb) firmware "
540 "upload failed!\n");
541 goto err_upload_failed;
542 }
543
544 tmp = buf;
545 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
546 }
547
548 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
549 priv->fw->size));
550 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
551 if (err) {
552 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
553 goto err_upload_failed;
554 }
555 timeout = jiffies + msecs_to_jiffies(1000);
556 while (!(err = usb_bulk_msg(priv->udev,
557 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
558 if (alen > 2 && !memcmp(buf, "OK", 2))
559 break;
560
561 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
562 err = -EINVAL;
563 break;
564 }
565
566 if (time_after(jiffies, timeout)) {
567 dev_err(&priv->udev->dev, "(p54usb) firmware boot "
568 "timed out!\n");
569 err = -ETIMEDOUT;
570 break;
571 }
572 }
573 if (err) {
574 dev_err(&priv->udev->dev, "(p54usb) firmware upload failed!\n");
575 goto err_upload_failed;
576 }
577
578 buf[0] = 'g';
579 buf[1] = '\r';
580 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
581 if (err) {
582 dev_err(&priv->udev->dev, "(p54usb) firmware boot failed!\n");
583 goto err_upload_failed;
584 }
585
586 timeout = jiffies + msecs_to_jiffies(1000);
587 while (!(err = usb_bulk_msg(priv->udev,
588 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
589 if (alen > 0 && buf[0] == 'g')
590 break;
591
592 if (time_after(jiffies, timeout)) {
593 err = -ETIMEDOUT;
594 break;
595 }
596 }
597 if (err)
598 goto err_upload_failed;
599
600 err_upload_failed:
601 kfree(buf);
602 return err;
603 }
604
605 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
606 {
607 struct p54u_priv *priv = dev->priv;
608 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
609 int err, alen;
610 void *buf;
611 __le32 reg;
612 unsigned int remains, offset;
613 const u8 *data;
614
615 buf = kmalloc(512, GFP_KERNEL);
616 if (!buf) {
617 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
618 "alloc failed!\n");
619 return -ENOMEM;
620 }
621
622 #define P54U_WRITE(type, addr, data) \
623 do {\
624 err = p54u_write(priv, buf, type,\
625 cpu_to_le32((u32)(unsigned long)addr), data);\
626 if (err) \
627 goto fail;\
628 } while (0)
629
630 #define P54U_READ(type, addr) \
631 do {\
632 err = p54u_read(priv, buf, type,\
633 cpu_to_le32((u32)(unsigned long)addr), &reg);\
634 if (err)\
635 goto fail;\
636 } while (0)
637
638 /* power down net2280 bridge */
639 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
640 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
641 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
642 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
643
644 mdelay(100);
645
646 /* power up bridge */
647 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
648 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
649 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
650
651 mdelay(100);
652
653 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
654 cpu_to_le32(NET2280_CLK_30Mhz |
655 NET2280_PCI_ENABLE |
656 NET2280_PCI_SOFT_RESET));
657
658 mdelay(20);
659
660 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
661 cpu_to_le32(PCI_COMMAND_MEMORY |
662 PCI_COMMAND_MASTER));
663
664 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
665 cpu_to_le32(NET2280_BASE));
666
667 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
668 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
669 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
670
671 // TODO: we really need this?
672 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
673
674 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
675 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
676 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
677 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
678
679 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
680 cpu_to_le32(NET2280_BASE2));
681
682 /* finally done setting up the bridge */
683
684 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
685 cpu_to_le32(PCI_COMMAND_MEMORY |
686 PCI_COMMAND_MASTER));
687
688 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
689 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
690 cpu_to_le32(P54U_DEV_BASE));
691
692 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
693 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
694 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
695
696 /* do romboot */
697 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
698
699 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
700 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
701 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
702 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
703 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
704
705 mdelay(20);
706
707 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
708 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
709
710 mdelay(20);
711
712 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
713 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
714
715 mdelay(100);
716
717 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
718 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
719
720 /* finally, we can upload firmware now! */
721 remains = priv->fw->size;
722 data = priv->fw->data;
723 offset = ISL38XX_DEV_FIRMWARE_ADDR;
724
725 while (remains) {
726 unsigned int block_len = min(remains, (unsigned int)512);
727 memcpy(buf, data, block_len);
728
729 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
730 if (err) {
731 dev_err(&priv->udev->dev, "(p54usb) firmware block "
732 "upload failed\n");
733 goto fail;
734 }
735
736 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
737 cpu_to_le32(0xc0000f00));
738
739 P54U_WRITE(NET2280_DEV_U32,
740 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
741 P54U_WRITE(NET2280_DEV_U32,
742 0x0020 | (unsigned long)&devreg->direct_mem_win,
743 cpu_to_le32(1));
744
745 P54U_WRITE(NET2280_DEV_U32,
746 0x0024 | (unsigned long)&devreg->direct_mem_win,
747 cpu_to_le32(block_len));
748 P54U_WRITE(NET2280_DEV_U32,
749 0x0028 | (unsigned long)&devreg->direct_mem_win,
750 cpu_to_le32(offset));
751
752 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
753 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
754 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
755 cpu_to_le32(block_len >> 2));
756 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
757 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
758
759 mdelay(10);
760
761 P54U_READ(NET2280_DEV_U32,
762 0x002C | (unsigned long)&devreg->direct_mem_win);
763 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
764 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
765 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
766 "transfer failed\n");
767 goto fail;
768 }
769
770 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
771 cpu_to_le32(NET2280_FIFO_FLUSH));
772
773 remains -= block_len;
774 data += block_len;
775 offset += block_len;
776 }
777
778 /* do ramboot */
779 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
780 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
781 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
782 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
783 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
784
785 mdelay(20);
786
787 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
788 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
789
790 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
791 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
792
793 mdelay(100);
794
795 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
796 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
797
798 /* start up the firmware */
799 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
800 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
801
802 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
803 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
804
805 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
806 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
807 NET2280_USB_INTERRUPT_ENABLE));
808
809 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
810 cpu_to_le32(ISL38XX_DEV_INT_RESET));
811
812 err = usb_interrupt_msg(priv->udev,
813 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
814 buf, sizeof(__le32), &alen, 1000);
815 if (err || alen != sizeof(__le32))
816 goto fail;
817
818 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
819 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
820
821 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
822 err = -EINVAL;
823
824 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
825 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
826 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
827
828 #undef P54U_WRITE
829 #undef P54U_READ
830
831 fail:
832 kfree(buf);
833 return err;
834 }
835
836 static int p54u_load_firmware(struct ieee80211_hw *dev)
837 {
838 struct p54u_priv *priv = dev->priv;
839 int err, i;
840
841 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
842
843 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
844 if (p54u_fwlist[i].type == priv->hw_type)
845 break;
846
847 if (i == __NUM_P54U_HWTYPES)
848 return -EOPNOTSUPP;
849
850 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
851 if (err) {
852 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
853 "(%d)!\n", p54u_fwlist[i].fw, err);
854
855 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
856 &priv->udev->dev);
857 if (err)
858 return err;
859 }
860
861 err = p54_parse_firmware(dev, priv->fw);
862 if (err)
863 goto out;
864
865 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
866 dev_err(&priv->udev->dev, "wrong firmware, please get "
867 "a firmware for \"%s\" and try again.\n",
868 p54u_fwlist[i].hw);
869 err = -EINVAL;
870 }
871
872 out:
873 if (err)
874 release_firmware(priv->fw);
875
876 return err;
877 }
878
879 static int p54u_open(struct ieee80211_hw *dev)
880 {
881 struct p54u_priv *priv = dev->priv;
882 int err;
883
884 err = p54u_init_urbs(dev);
885 if (err) {
886 return err;
887 }
888
889 priv->common.open = p54u_init_urbs;
890
891 return 0;
892 }
893
894 static void p54u_stop(struct ieee80211_hw *dev)
895 {
896 /* TODO: figure out how to reliably stop the 3887 and net2280 so
897 the hardware is still usable next time we want to start it.
898 until then, we just stop listening to the hardware.. */
899 p54u_free_urbs(dev);
900 return;
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);
Linux ARM platform port for MOXA ART SoC