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