projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'for-2.6.27' of git://git.infradead.org/users/dwmw2/firmware-2.6
[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/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 "p54usb.h"
26
27 MODULE_AUTHOR("Michael Wu <flamingice@sourmilk.net>");
28 MODULE_DESCRIPTION("Prism54 USB wireless driver");
29 MODULE_LICENSE("GPL");
30 MODULE_ALIAS("prism54usb");
31
32 static struct usb_device_id p54u_table[] __devinitdata = {
33 /* Version 1 devices (pci chip + net2280) */
34 {USB_DEVICE(0x0506, 0x0a11)}, /* 3COM 3CRWE254G72 */
35 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
36 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
37 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
38 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
39 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
40 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
41 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
42 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
43 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
44 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
45 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
46 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
47 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
48 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
49 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
50
51 /* Version 2 devices (3887) */
52 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
53 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
54 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
55 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
56 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
57 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
58 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
59 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
60 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
61 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
62 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
63 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
64 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
65 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
66 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
67 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
68 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
69 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
70 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
71 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
72 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
73 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
74 {}
75 };
76
77 MODULE_DEVICE_TABLE(usb, p54u_table);
78
79 static void p54u_rx_cb(struct urb *urb)
80 {
81 struct sk_buff *skb = (struct sk_buff *) urb->context;
82 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
83 struct ieee80211_hw *dev = info->dev;
84 struct p54u_priv *priv = dev->priv;
85
86 if (unlikely(urb->status)) {
87 info->urb = NULL;
88 usb_free_urb(urb);
89 return;
90 }
91
92 skb_unlink(skb, &priv->rx_queue);
93 skb_put(skb, urb->actual_length);
94 if (!priv->hw_type)
95 skb_pull(skb, sizeof(struct net2280_tx_hdr));
96
97 if (p54_rx(dev, skb)) {
98 skb = dev_alloc_skb(MAX_RX_SIZE);
99 if (unlikely(!skb)) {
100 usb_free_urb(urb);
101 /* TODO check rx queue length and refill *somewhere* */
102 return;
103 }
104
105 info = (struct p54u_rx_info *) skb->cb;
106 info->urb = urb;
107 info->dev = dev;
108 urb->transfer_buffer = skb_tail_pointer(skb);
109 urb->context = skb;
110 skb_queue_tail(&priv->rx_queue, skb);
111 } else {
112 skb_trim(skb, 0);
113 skb_queue_tail(&priv->rx_queue, skb);
114 }
115
116 usb_submit_urb(urb, GFP_ATOMIC);
117 }
118
119 static void p54u_tx_cb(struct urb *urb)
120 {
121 usb_free_urb(urb);
122 }
123
124 static void p54u_tx_free_cb(struct urb *urb)
125 {
126 kfree(urb->transfer_buffer);
127 usb_free_urb(urb);
128 }
129
130 static int p54u_init_urbs(struct ieee80211_hw *dev)
131 {
132 struct p54u_priv *priv = dev->priv;
133 struct urb *entry;
134 struct sk_buff *skb;
135 struct p54u_rx_info *info;
136
137 while (skb_queue_len(&priv->rx_queue) < 32) {
138 skb = __dev_alloc_skb(MAX_RX_SIZE, GFP_KERNEL);
139 if (!skb)
140 break;
141 entry = usb_alloc_urb(0, GFP_KERNEL);
142 if (!entry) {
143 kfree_skb(skb);
144 break;
145 }
146 usb_fill_bulk_urb(entry, priv->udev, usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), skb_tail_pointer(skb), MAX_RX_SIZE, p54u_rx_cb, skb);
147 info = (struct p54u_rx_info *) skb->cb;
148 info->urb = entry;
149 info->dev = dev;
150 skb_queue_tail(&priv->rx_queue, skb);
151 usb_submit_urb(entry, GFP_KERNEL);
152 }
153
154 return 0;
155 }
156
157 static void p54u_free_urbs(struct ieee80211_hw *dev)
158 {
159 struct p54u_priv *priv = dev->priv;
160 struct p54u_rx_info *info;
161 struct sk_buff *skb;
162
163 while ((skb = skb_dequeue(&priv->rx_queue))) {
164 info = (struct p54u_rx_info *) skb->cb;
165 if (!info->urb)
166 continue;
167
168 usb_kill_urb(info->urb);
169 kfree_skb(skb);
170 }
171 }
172
173 static void p54u_tx_3887(struct ieee80211_hw *dev, struct p54_control_hdr *data,
174 size_t len, int free_on_tx)
175 {
176 struct p54u_priv *priv = dev->priv;
177 struct urb *addr_urb, *data_urb;
178
179 addr_urb = usb_alloc_urb(0, GFP_ATOMIC);
180 if (!addr_urb)
181 return;
182
183 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
184 if (!data_urb) {
185 usb_free_urb(addr_urb);
186 return;
187 }
188
189 usb_fill_bulk_urb(addr_urb, priv->udev,
190 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), &data->req_id,
191 sizeof(data->req_id), p54u_tx_cb, dev);
192 usb_fill_bulk_urb(data_urb, priv->udev,
193 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), data, len,
194 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
195
196 usb_submit_urb(addr_urb, GFP_ATOMIC);
197 usb_submit_urb(data_urb, GFP_ATOMIC);
198 }
199
200 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct p54_control_hdr *data,
201 size_t len, int free_on_tx)
202 {
203 struct p54u_priv *priv = dev->priv;
204 struct urb *int_urb, *data_urb;
205 struct net2280_tx_hdr *hdr;
206 struct net2280_reg_write *reg;
207
208 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
209 if (!reg)
210 return;
211
212 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
213 if (!int_urb) {
214 kfree(reg);
215 return;
216 }
217
218 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
219 if (!data_urb) {
220 kfree(reg);
221 usb_free_urb(int_urb);
222 return;
223 }
224
225 reg->port = cpu_to_le16(NET2280_DEV_U32);
226 reg->addr = cpu_to_le32(P54U_DEV_BASE);
227 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
228
229 len += sizeof(*data);
230 hdr = (void *)data - sizeof(*hdr);
231 memset(hdr, 0, sizeof(*hdr));
232 hdr->device_addr = data->req_id;
233 hdr->len = cpu_to_le16(len);
234
235 usb_fill_bulk_urb(int_urb, priv->udev,
236 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
237 p54u_tx_free_cb, dev);
238 usb_submit_urb(int_urb, GFP_ATOMIC);
239
240 usb_fill_bulk_urb(data_urb, priv->udev,
241 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA), hdr, len + sizeof(*hdr),
242 free_on_tx ? p54u_tx_free_cb : p54u_tx_cb, dev);
243 usb_submit_urb(data_urb, GFP_ATOMIC);
244 }
245
246 static int p54u_write(struct p54u_priv *priv,
247 struct net2280_reg_write *buf,
248 enum net2280_op_type type,
249 __le32 addr, __le32 val)
250 {
251 unsigned int ep;
252 int alen;
253
254 if (type & 0x0800)
255 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
256 else
257 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
258
259 buf->port = cpu_to_le16(type);
260 buf->addr = addr;
261 buf->val = val;
262
263 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
264 }
265
266 static int p54u_read(struct p54u_priv *priv, void *buf,
267 enum net2280_op_type type,
268 __le32 addr, __le32 *val)
269 {
270 struct net2280_reg_read *read = buf;
271 __le32 *reg = buf;
272 unsigned int ep;
273 int alen, err;
274
275 if (type & 0x0800)
276 ep = P54U_PIPE_DEV;
277 else
278 ep = P54U_PIPE_BRG;
279
280 read->port = cpu_to_le16(type);
281 read->addr = addr;
282
283 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
284 read, sizeof(*read), &alen, 1000);
285 if (err)
286 return err;
287
288 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
289 reg, sizeof(*reg), &alen, 1000);
290 if (err)
291 return err;
292
293 *val = *reg;
294 return 0;
295 }
296
297 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
298 void *data, size_t len)
299 {
300 int alen;
301 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
302 data, len, &alen, 2000);
303 }
304
305 static int p54u_read_eeprom(struct ieee80211_hw *dev)
306 {
307 struct p54u_priv *priv = dev->priv;
308 void *buf;
309 struct p54_control_hdr *hdr;
310 int err, alen;
311 size_t offset = priv->hw_type ? 0x10 : 0x20;
312
313 buf = kmalloc(0x2020, GFP_KERNEL);
314 if (!buf) {
315 printk(KERN_ERR "prism54usb: cannot allocate memory for "
316 "eeprom readback!\n");
317 return -ENOMEM;
318 }
319
320 if (priv->hw_type) {
321 *((u32 *) buf) = priv->common.rx_start;
322 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
323 if (err) {
324 printk(KERN_ERR "prism54usb: addr send failed\n");
325 goto fail;
326 }
327 } else {
328 struct net2280_reg_write *reg = buf;
329 reg->port = cpu_to_le16(NET2280_DEV_U32);
330 reg->addr = cpu_to_le32(P54U_DEV_BASE);
331 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
332 err = p54u_bulk_msg(priv, P54U_PIPE_DEV, buf, sizeof(*reg));
333 if (err) {
334 printk(KERN_ERR "prism54usb: dev_int send failed\n");
335 goto fail;
336 }
337 }
338
339 hdr = buf + priv->common.tx_hdr_len;
340 p54_fill_eeprom_readback(hdr);
341 hdr->req_id = cpu_to_le32(priv->common.rx_start);
342 if (priv->common.tx_hdr_len) {
343 struct net2280_tx_hdr *tx_hdr = buf;
344 tx_hdr->device_addr = hdr->req_id;
345 tx_hdr->len = cpu_to_le16(EEPROM_READBACK_LEN);
346 }
347
348 /* we can just pretend to send 0x2000 bytes of nothing in the headers */
349 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf,
350 EEPROM_READBACK_LEN + priv->common.tx_hdr_len);
351 if (err) {
352 printk(KERN_ERR "prism54usb: eeprom req send failed\n");
353 goto fail;
354 }
355
356 err = usb_bulk_msg(priv->udev,
357 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
358 buf, 0x2020, &alen, 1000);
359 if (!err && alen > offset) {
360 p54_parse_eeprom(dev, (u8 *)buf + offset, alen - offset);
361 } else {
362 printk(KERN_ERR "prism54usb: eeprom read failed!\n");
363 err = -EINVAL;
364 goto fail;
365 }
366
367 fail:
368 kfree(buf);
369 return err;
370 }
371
372 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
373 {
374 static char start_string[] = "~~~~<\r";
375 struct p54u_priv *priv = dev->priv;
376 const struct firmware *fw_entry = NULL;
377 int err, alen;
378 u8 carry = 0;
379 u8 *buf, *tmp;
380 const u8 *data;
381 unsigned int left, remains, block_size;
382 struct x2_header *hdr;
383 unsigned long timeout;
384
385 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
386 if (!buf) {
387 printk(KERN_ERR "p54usb: cannot allocate firmware upload buffer!\n");
388 err = -ENOMEM;
389 goto err_bufalloc;
390 }
391
392 memcpy(buf, start_string, 4);
393 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 4);
394 if (err) {
395 printk(KERN_ERR "p54usb: reset failed! (%d)\n", err);
396 goto err_reset;
397 }
398
399 err = request_firmware(&fw_entry, "isl3887usb_bare", &priv->udev->dev);
400 if (err) {
401 printk(KERN_ERR "p54usb: cannot find firmware (isl3887usb_bare)!\n");
402 goto err_req_fw_failed;
403 }
404
405 p54_parse_firmware(dev, fw_entry);
406
407 left = block_size = min((size_t)P54U_FW_BLOCK, fw_entry->size);
408 strcpy(buf, start_string);
409 left -= strlen(start_string);
410 tmp += strlen(start_string);
411
412 data = fw_entry->data;
413 remains = fw_entry->size;
414
415 hdr = (struct x2_header *)(buf + strlen(start_string));
416 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
417 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
418 hdr->fw_length = cpu_to_le32(fw_entry->size);
419 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
420 sizeof(u32)*2));
421 left -= sizeof(*hdr);
422 tmp += sizeof(*hdr);
423
424 while (remains) {
425 while (left--) {
426 if (carry) {
427 *tmp++ = carry;
428 carry = 0;
429 remains--;
430 continue;
431 }
432 switch (*data) {
433 case '~':
434 *tmp++ = '}';
435 carry = '^';
436 break;
437 case '}':
438 *tmp++ = '}';
439 carry = ']';
440 break;
441 default:
442 *tmp++ = *data;
443 remains--;
444 break;
445 }
446 data++;
447 }
448
449 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
450 if (err) {
451 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
452 goto err_upload_failed;
453 }
454
455 tmp = buf;
456 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
457 }
458
459 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, fw_entry->data, fw_entry->size));
460 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, sizeof(u32));
461 if (err) {
462 printk(KERN_ERR "prism54usb: firmware upload failed!\n");
463 goto err_upload_failed;
464 }
465
466 timeout = jiffies + msecs_to_jiffies(1000);
467 while (!(err = usb_bulk_msg(priv->udev,
468 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
469 if (alen > 2 && !memcmp(buf, "OK", 2))
470 break;
471
472 if (alen > 5 && !memcmp(buf, "ERROR", 5)) {
473 printk(KERN_INFO "prism54usb: firmware upload failed!\n");
474 err = -EINVAL;
475 break;
476 }
477
478 if (time_after(jiffies, timeout)) {
479 printk(KERN_ERR "prism54usb: firmware boot timed out!\n");
480 err = -ETIMEDOUT;
481 break;
482 }
483 }
484 if (err)
485 goto err_upload_failed;
486
487 buf[0] = 'g';
488 buf[1] = '\r';
489 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, 2);
490 if (err) {
491 printk(KERN_ERR "prism54usb: firmware boot failed!\n");
492 goto err_upload_failed;
493 }
494
495 timeout = jiffies + msecs_to_jiffies(1000);
496 while (!(err = usb_bulk_msg(priv->udev,
497 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA), buf, 128, &alen, 1000))) {
498 if (alen > 0 && buf[0] == 'g')
499 break;
500
501 if (time_after(jiffies, timeout)) {
502 err = -ETIMEDOUT;
503 break;
504 }
505 }
506 if (err)
507 goto err_upload_failed;
508
509 err_upload_failed:
510 release_firmware(fw_entry);
511 err_req_fw_failed:
512 err_reset:
513 kfree(buf);
514 err_bufalloc:
515 return err;
516 }
517
518 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
519 {
520 struct p54u_priv *priv = dev->priv;
521 const struct firmware *fw_entry = NULL;
522 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
523 int err, alen;
524 void *buf;
525 __le32 reg;
526 unsigned int remains, offset;
527 const u8 *data;
528
529 buf = kmalloc(512, GFP_KERNEL);
530 if (!buf) {
531 printk(KERN_ERR "p54usb: firmware buffer alloc failed!\n");
532 return -ENOMEM;
533 }
534
535 err = request_firmware(&fw_entry, "isl3890usb", &priv->udev->dev);
536 if (err) {
537 printk(KERN_ERR "p54usb: cannot find firmware (isl3890usb)!\n");
538 kfree(buf);
539 return err;
540 }
541
542 p54_parse_firmware(dev, fw_entry);
543
544 #define P54U_WRITE(type, addr, data) \
545 do {\
546 err = p54u_write(priv, buf, type,\
547 cpu_to_le32((u32)(unsigned long)addr), data);\
548 if (err) \
549 goto fail;\
550 } while (0)
551
552 #define P54U_READ(type, addr) \
553 do {\
554 err = p54u_read(priv, buf, type,\
555 cpu_to_le32((u32)(unsigned long)addr), &reg);\
556 if (err)\
557 goto fail;\
558 } while (0)
559
560 /* power down net2280 bridge */
561 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
562 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
563 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
564 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
565
566 mdelay(100);
567
568 /* power up bridge */
569 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
570 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
571 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
572
573 mdelay(100);
574
575 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
576 cpu_to_le32(NET2280_CLK_30Mhz |
577 NET2280_PCI_ENABLE |
578 NET2280_PCI_SOFT_RESET));
579
580 mdelay(20);
581
582 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
583 cpu_to_le32(PCI_COMMAND_MEMORY |
584 PCI_COMMAND_MASTER));
585
586 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
587 cpu_to_le32(NET2280_BASE));
588
589 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
590 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
591 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
592
593 // TODO: we really need this?
594 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
595
596 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
597 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
598 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
599 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
600
601 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
602 cpu_to_le32(NET2280_BASE2));
603
604 /* finally done setting up the bridge */
605
606 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
607 cpu_to_le32(PCI_COMMAND_MEMORY |
608 PCI_COMMAND_MASTER));
609
610 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
611 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
612 cpu_to_le32(P54U_DEV_BASE));
613
614 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
615 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
616 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
617
618 /* do romboot */
619 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
620
621 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
622 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
623 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
624 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
625 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
626
627 mdelay(20);
628
629 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
630 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
631
632 mdelay(20);
633
634 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
635 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
636
637 mdelay(100);
638
639 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
640 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
641
642 /* finally, we can upload firmware now! */
643 remains = fw_entry->size;
644 data = fw_entry->data;
645 offset = ISL38XX_DEV_FIRMWARE_ADDR;
646
647 while (remains) {
648 unsigned int block_len = min(remains, (unsigned int)512);
649 memcpy(buf, data, block_len);
650
651 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
652 if (err) {
653 printk(KERN_ERR "prism54usb: firmware block upload "
654 "failed\n");
655 goto fail;
656 }
657
658 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
659 cpu_to_le32(0xc0000f00));
660
661 P54U_WRITE(NET2280_DEV_U32,
662 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
663 P54U_WRITE(NET2280_DEV_U32,
664 0x0020 | (unsigned long)&devreg->direct_mem_win,
665 cpu_to_le32(1));
666
667 P54U_WRITE(NET2280_DEV_U32,
668 0x0024 | (unsigned long)&devreg->direct_mem_win,
669 cpu_to_le32(block_len));
670 P54U_WRITE(NET2280_DEV_U32,
671 0x0028 | (unsigned long)&devreg->direct_mem_win,
672 cpu_to_le32(offset));
673
674 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
675 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
676 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
677 cpu_to_le32(block_len >> 2));
678 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
679 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
680
681 mdelay(10);
682
683 P54U_READ(NET2280_DEV_U32,
684 0x002C | (unsigned long)&devreg->direct_mem_win);
685 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
686 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
687 printk(KERN_ERR "prism54usb: firmware DMA transfer "
688 "failed\n");
689 goto fail;
690 }
691
692 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
693 cpu_to_le32(NET2280_FIFO_FLUSH));
694
695 remains -= block_len;
696 data += block_len;
697 offset += block_len;
698 }
699
700 /* do ramboot */
701 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
702 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
703 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
704 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
705 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
706
707 mdelay(20);
708
709 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
710 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
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 /* start up the firmware */
721 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
722 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
723
724 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
725 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
726
727 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
728 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
729 NET2280_USB_INTERRUPT_ENABLE));
730
731 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
732 cpu_to_le32(ISL38XX_DEV_INT_RESET));
733
734 err = usb_interrupt_msg(priv->udev,
735 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
736 buf, sizeof(__le32), &alen, 1000);
737 if (err || alen != sizeof(__le32))
738 goto fail;
739
740 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
741 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
742
743 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
744 err = -EINVAL;
745
746 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
747 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
748 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
749
750 #undef P54U_WRITE
751 #undef P54U_READ
752
753 fail:
754 release_firmware(fw_entry);
755 kfree(buf);
756 return err;
757 }
758
759 static int p54u_open(struct ieee80211_hw *dev)
760 {
761 struct p54u_priv *priv = dev->priv;
762 int err;
763
764 err = p54u_init_urbs(dev);
765 if (err) {
766 return err;
767 }
768
769 priv->common.open = p54u_init_urbs;
770
771 return 0;
772 }
773
774 static void p54u_stop(struct ieee80211_hw *dev)
775 {
776 /* TODO: figure out how to reliably stop the 3887 and net2280 so
777 the hardware is still usable next time we want to start it.
778 until then, we just stop listening to the hardware.. */
779 p54u_free_urbs(dev);
780 return;
781 }
782
783 static int __devinit p54u_probe(struct usb_interface *intf,
784 const struct usb_device_id *id)
785 {
786 struct usb_device *udev = interface_to_usbdev(intf);
787 struct ieee80211_hw *dev;
788 struct p54u_priv *priv;
789 int err;
790 unsigned int i, recognized_pipes;
791 DECLARE_MAC_BUF(mac);
792
793 dev = p54_init_common(sizeof(*priv));
794 if (!dev) {
795 printk(KERN_ERR "prism54usb: ieee80211 alloc failed\n");
796 return -ENOMEM;
797 }
798
799 priv = dev->priv;
800
801 SET_IEEE80211_DEV(dev, &intf->dev);
802 usb_set_intfdata(intf, dev);
803 priv->udev = udev;
804
805 usb_get_dev(udev);
806
807 /* really lazy and simple way of figuring out if we're a 3887 */
808 /* TODO: should just stick the identification in the device table */
809 i = intf->altsetting->desc.bNumEndpoints;
810 recognized_pipes = 0;
811 while (i--) {
812 switch (intf->altsetting->endpoint[i].desc.bEndpointAddress) {
813 case P54U_PIPE_DATA:
814 case P54U_PIPE_MGMT:
815 case P54U_PIPE_BRG:
816 case P54U_PIPE_DEV:
817 case P54U_PIPE_DATA | USB_DIR_IN:
818 case P54U_PIPE_MGMT | USB_DIR_IN:
819 case P54U_PIPE_BRG | USB_DIR_IN:
820 case P54U_PIPE_DEV | USB_DIR_IN:
821 case P54U_PIPE_INT | USB_DIR_IN:
822 recognized_pipes++;
823 }
824 }
825 priv->common.open = p54u_open;
826
827 if (recognized_pipes < P54U_PIPE_NUMBER) {
828 priv->hw_type = P54U_3887;
829 priv->common.tx = p54u_tx_3887;
830 } else {
831 dev->extra_tx_headroom += sizeof(struct net2280_tx_hdr);
832 priv->common.tx_hdr_len = sizeof(struct net2280_tx_hdr);
833 priv->common.tx = p54u_tx_net2280;
834 }
835 priv->common.stop = p54u_stop;
836
837 if (priv->hw_type)
838 err = p54u_upload_firmware_3887(dev);
839 else
840 err = p54u_upload_firmware_net2280(dev);
841 if (err)
842 goto err_free_dev;
843
844 err = p54u_read_eeprom(dev);
845 if (err)
846 goto err_free_dev;
847
848 if (!is_valid_ether_addr(dev->wiphy->perm_addr)) {
849 u8 perm_addr[ETH_ALEN];
850
851 printk(KERN_WARNING "prism54usb: Invalid hwaddr! Using randomly generated MAC addr\n");
852 random_ether_addr(perm_addr);
853 SET_IEEE80211_PERM_ADDR(dev, perm_addr);
854 }
855
856 skb_queue_head_init(&priv->rx_queue);
857
858 err = ieee80211_register_hw(dev);
859 if (err) {
860 printk(KERN_ERR "prism54usb: Cannot register netdevice\n");
861 goto err_free_dev;
862 }
863
864 printk(KERN_INFO "%s: hwaddr %s, isl38%02x\n",
865 wiphy_name(dev->wiphy),
866 print_mac(mac, dev->wiphy->perm_addr),
867 priv->common.version);
868
869 return 0;
870
871 err_free_dev:
872 ieee80211_free_hw(dev);
873 usb_set_intfdata(intf, NULL);
874 usb_put_dev(udev);
875 return err;
876 }
877
878 static void __devexit p54u_disconnect(struct usb_interface *intf)
879 {
880 struct ieee80211_hw *dev = usb_get_intfdata(intf);
881 struct p54u_priv *priv;
882
883 if (!dev)
884 return;
885
886 ieee80211_unregister_hw(dev);
887
888 priv = dev->priv;
889 usb_put_dev(interface_to_usbdev(intf));
890 p54_free_common(dev);
891 ieee80211_free_hw(dev);
892 }
893
894 static struct usb_driver p54u_driver = {
895 .name = "prism54usb",
896 .id_table = p54u_table,
897 .probe = p54u_probe,
898 .disconnect = p54u_disconnect,
899 };
900
901 static int __init p54u_init(void)
902 {
903 return usb_register(&p54u_driver);
904 }
905
906 static void __exit p54u_exit(void)
907 {
908 usb_deregister(&p54u_driver);
909 }
910
911 module_init(p54u_init);
912 module_exit(p54u_exit);
kernel source for telekom puls (alcatel/mediatek)