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