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