?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
drivers/net: Remove unnecessary returns from void function()s
[firewire-audio.git] / drivers / net / wireless / p54 / p54usb.c
blobd5b197b4d5bb492ac70c8e2a98297a2e82e5e356
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(0x06b9, 0x0120)}, /* Thomson SpeedTouch 120g */
40 {USB_DEVICE(0x0707, 0xee06)}, /* SMC 2862W-G */
41 {USB_DEVICE(0x07aa, 0x001c)}, /* Corega CG-WLUSB2GT */
42 {USB_DEVICE(0x083a, 0x4501)}, /* Accton 802.11g WN4501 USB */
43 {USB_DEVICE(0x083a, 0x4502)}, /* Siemens Gigaset USB Adapter */
44 {USB_DEVICE(0x083a, 0x5501)}, /* Phillips CPWUA054 */
45 {USB_DEVICE(0x0846, 0x4200)}, /* Netgear WG121 */
46 {USB_DEVICE(0x0846, 0x4210)}, /* Netgear WG121 the second ? */
47 {USB_DEVICE(0x0846, 0x4220)}, /* Netgear WG111 */
48 {USB_DEVICE(0x09aa, 0x1000)}, /* Spinnaker Proto board */
49 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion 40900, Roper Europe */
50 {USB_DEVICE(0x124a, 0x4023)}, /* Shuttle PN15, Airvast WM168g, IOGear GWU513 */
51 {USB_DEVICE(0x1915, 0x2234)}, /* Linksys WUSB54G OEM */
52 {USB_DEVICE(0x1915, 0x2235)}, /* Linksys WUSB54G Portable OEM */
53 {USB_DEVICE(0x2001, 0x3701)}, /* DLink DWL-G120 Spinnaker */
54 {USB_DEVICE(0x2001, 0x3703)}, /* DLink DWL-G122 */
55 {USB_DEVICE(0x5041, 0x2234)}, /* Linksys WUSB54G */
56 {USB_DEVICE(0x5041, 0x2235)}, /* Linksys WUSB54G Portable */
57
58 /* Version 2 devices (3887) */
59 {USB_DEVICE(0x0471, 0x1230)}, /* Philips CPWUA054/00 */
60 {USB_DEVICE(0x050d, 0x7050)}, /* Belkin F5D7050 ver 1000 */
61 {USB_DEVICE(0x0572, 0x2000)}, /* Cohiba Proto board */
62 {USB_DEVICE(0x0572, 0x2002)}, /* Cohiba Proto board */
63 {USB_DEVICE(0x06b9, 0x0121)}, /* Thomson SpeedTouch 121g */
64 {USB_DEVICE(0x0707, 0xee13)}, /* SMC 2862W-G version 2 */
65 {USB_DEVICE(0x083a, 0x4521)}, /* Siemens Gigaset USB Adapter 54 version 2 */
66 {USB_DEVICE(0x083a, 0xf503)}, /* Accton FD7050E ver 1010ec */
67 {USB_DEVICE(0x0846, 0x4240)}, /* Netgear WG111 (v2) */
68 {USB_DEVICE(0x0915, 0x2000)}, /* Cohiba Proto board */
69 {USB_DEVICE(0x0915, 0x2002)}, /* Cohiba Proto board */
70 {USB_DEVICE(0x0baf, 0x0118)}, /* U.S. Robotics U5 802.11g Adapter*/
71 {USB_DEVICE(0x0bf8, 0x1009)}, /* FUJITSU E-5400 USB D1700*/
72 {USB_DEVICE(0x0cde, 0x0006)}, /* Medion MD40900 */
73 {USB_DEVICE(0x0cde, 0x0008)}, /* Sagem XG703A */
74 {USB_DEVICE(0x0cde, 0x0015)}, /* Zcomax XG-705A */
75 {USB_DEVICE(0x0d8e, 0x3762)}, /* DLink DWL-G120 Cohiba */
76 {USB_DEVICE(0x124a, 0x4025)}, /* IOGear GWU513 (GW3887IK chip) */
77 {USB_DEVICE(0x1260, 0xee22)}, /* SMC 2862W-G version 2 */
78 {USB_DEVICE(0x13b1, 0x000a)}, /* Linksys WUSB54G ver 2 */
79 {USB_DEVICE(0x13B1, 0x000C)}, /* Linksys WUSB54AG */
80 {USB_DEVICE(0x1413, 0x5400)}, /* Telsey 802.11g USB2.0 Adapter */
81 {USB_DEVICE(0x1435, 0x0427)}, /* Inventel UR054G */
82 {USB_DEVICE(0x2001, 0x3704)}, /* DLink DWL-G122 rev A2 */
83 {USB_DEVICE(0x413c, 0x8102)}, /* Spinnaker DUT */
84 {USB_DEVICE(0x413c, 0x8104)}, /* Cohiba Proto board */
85 {}
86 };
87
88 MODULE_DEVICE_TABLE(usb, p54u_table);
89
90 static const struct {
91 u32 intf;
92 enum p54u_hw_type type;
93 const char *fw;
94 const char *fw_legacy;
95 char hw[20];
96 } p54u_fwlist[__NUM_P54U_HWTYPES] = {
97 {
98 .type = P54U_NET2280,
99 .intf = FW_LM86,
100 .fw = "isl3886usb",
101 .fw_legacy = "isl3890usb",
102 .hw = "ISL3886 + net2280",
103 },
104 {
105 .type = P54U_3887,
106 .intf = FW_LM87,
107 .fw = "isl3887usb",
108 .fw_legacy = "isl3887usb_bare",
109 .hw = "ISL3887",
110 },
111 };
112
113 static void p54u_rx_cb(struct urb *urb)
114 {
115 struct sk_buff *skb = (struct sk_buff *) urb->context;
116 struct p54u_rx_info *info = (struct p54u_rx_info *)skb->cb;
117 struct ieee80211_hw *dev = info->dev;
118 struct p54u_priv *priv = dev->priv;
119
120 skb_unlink(skb, &priv->rx_queue);
121
122 if (unlikely(urb->status)) {
123 dev_kfree_skb_irq(skb);
124 return;
125 }
126
127 skb_put(skb, urb->actual_length);
128
129 if (priv->hw_type == P54U_NET2280)
130 skb_pull(skb, priv->common.tx_hdr_len);
131 if (priv->common.fw_interface == FW_LM87) {
132 skb_pull(skb, 4);
133 skb_put(skb, 4);
134 }
135
136 if (p54_rx(dev, skb)) {
137 skb = dev_alloc_skb(priv->common.rx_mtu + 32);
138 if (unlikely(!skb)) {
139 /* TODO check rx queue length and refill *somewhere* */
140 return;
141 }
142
143 info = (struct p54u_rx_info *) skb->cb;
144 info->urb = urb;
145 info->dev = dev;
146 urb->transfer_buffer = skb_tail_pointer(skb);
147 urb->context = skb;
148 } else {
149 if (priv->hw_type == P54U_NET2280)
150 skb_push(skb, priv->common.tx_hdr_len);
151 if (priv->common.fw_interface == FW_LM87) {
152 skb_push(skb, 4);
153 skb_put(skb, 4);
154 }
155 skb_reset_tail_pointer(skb);
156 skb_trim(skb, 0);
157 urb->transfer_buffer = skb_tail_pointer(skb);
158 }
159 skb_queue_tail(&priv->rx_queue, skb);
160 usb_anchor_urb(urb, &priv->submitted);
161 if (usb_submit_urb(urb, GFP_ATOMIC)) {
162 skb_unlink(skb, &priv->rx_queue);
163 usb_unanchor_urb(urb);
164 dev_kfree_skb_irq(skb);
165 }
166 }
167
168 static void p54u_tx_cb(struct urb *urb)
169 {
170 struct sk_buff *skb = urb->context;
171 struct ieee80211_hw *dev = (struct ieee80211_hw *)
172 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
173
174 p54_free_skb(dev, skb);
175 }
176
177 static void p54u_tx_dummy_cb(struct urb *urb) { }
178
179 static void p54u_free_urbs(struct ieee80211_hw *dev)
180 {
181 struct p54u_priv *priv = dev->priv;
182 usb_kill_anchored_urbs(&priv->submitted);
183 }
184
185 static int p54u_init_urbs(struct ieee80211_hw *dev)
186 {
187 struct p54u_priv *priv = dev->priv;
188 struct urb *entry = NULL;
189 struct sk_buff *skb;
190 struct p54u_rx_info *info;
191 int ret = 0;
192
193 while (skb_queue_len(&priv->rx_queue) < 32) {
194 skb = __dev_alloc_skb(priv->common.rx_mtu + 32, GFP_KERNEL);
195 if (!skb) {
196 ret = -ENOMEM;
197 goto err;
198 }
199 entry = usb_alloc_urb(0, GFP_KERNEL);
200 if (!entry) {
201 ret = -ENOMEM;
202 goto err;
203 }
204
205 usb_fill_bulk_urb(entry, priv->udev,
206 usb_rcvbulkpipe(priv->udev, P54U_PIPE_DATA),
207 skb_tail_pointer(skb),
208 priv->common.rx_mtu + 32, p54u_rx_cb, skb);
209 info = (struct p54u_rx_info *) skb->cb;
210 info->urb = entry;
211 info->dev = dev;
212 skb_queue_tail(&priv->rx_queue, skb);
213
214 usb_anchor_urb(entry, &priv->submitted);
215 ret = usb_submit_urb(entry, GFP_KERNEL);
216 if (ret) {
217 skb_unlink(skb, &priv->rx_queue);
218 usb_unanchor_urb(entry);
219 goto err;
220 }
221 usb_free_urb(entry);
222 entry = NULL;
223 }
224
225 return 0;
226
227 err:
228 usb_free_urb(entry);
229 kfree_skb(skb);
230 p54u_free_urbs(dev);
231 return ret;
232 }
233
234 static __le32 p54u_lm87_chksum(const __le32 *data, size_t length)
235 {
236 u32 chk = 0;
237
238 length >>= 2;
239 while (length--) {
240 chk ^= le32_to_cpu(*data++);
241 chk = (chk >> 5) ^ (chk << 3);
242 }
243
244 return cpu_to_le32(chk);
245 }
246
247 static void p54u_tx_lm87(struct ieee80211_hw *dev, struct sk_buff *skb)
248 {
249 struct p54u_priv *priv = dev->priv;
250 struct urb *data_urb;
251 struct lm87_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
252
253 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
254 if (!data_urb) {
255 p54_free_skb(dev, skb);
256 return;
257 }
258
259 hdr->chksum = p54u_lm87_chksum((__le32 *)skb->data, skb->len);
260 hdr->device_addr = ((struct p54_hdr *)skb->data)->req_id;
261
262 usb_fill_bulk_urb(data_urb, priv->udev,
263 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
264 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
265 p54u_tx_cb : p54u_tx_dummy_cb, skb);
266 data_urb->transfer_flags |= URB_ZERO_PACKET;
267
268 usb_anchor_urb(data_urb, &priv->submitted);
269 if (usb_submit_urb(data_urb, GFP_ATOMIC)) {
270 usb_unanchor_urb(data_urb);
271 p54_free_skb(dev, skb);
272 }
273 usb_free_urb(data_urb);
274 }
275
276 static void p54u_tx_net2280(struct ieee80211_hw *dev, struct sk_buff *skb)
277 {
278 struct p54u_priv *priv = dev->priv;
279 struct urb *int_urb = NULL, *data_urb = NULL;
280 struct net2280_tx_hdr *hdr = (void *)skb->data - sizeof(*hdr);
281 struct net2280_reg_write *reg = NULL;
282 int err = -ENOMEM;
283
284 reg = kmalloc(sizeof(*reg), GFP_ATOMIC);
285 if (!reg)
286 goto out;
287
288 int_urb = usb_alloc_urb(0, GFP_ATOMIC);
289 if (!int_urb)
290 goto out;
291
292 data_urb = usb_alloc_urb(0, GFP_ATOMIC);
293 if (!data_urb)
294 goto out;
295
296 reg->port = cpu_to_le16(NET2280_DEV_U32);
297 reg->addr = cpu_to_le32(P54U_DEV_BASE);
298 reg->val = cpu_to_le32(ISL38XX_DEV_INT_DATA);
299
300 memset(hdr, 0, sizeof(*hdr));
301 hdr->len = cpu_to_le16(skb->len);
302 hdr->device_addr = ((struct p54_hdr *) skb->data)->req_id;
303
304 usb_fill_bulk_urb(int_urb, priv->udev,
305 usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV), reg, sizeof(*reg),
306 p54u_tx_dummy_cb, dev);
307
308 /*
309 * URB_FREE_BUFFER triggers a code path in the USB subsystem that will
310 * free what is inside the transfer_buffer after the last reference to
311 * the int_urb is dropped.
312 */
313 int_urb->transfer_flags |= URB_FREE_BUFFER | URB_ZERO_PACKET;
314 reg = NULL;
315
316 usb_fill_bulk_urb(data_urb, priv->udev,
317 usb_sndbulkpipe(priv->udev, P54U_PIPE_DATA),
318 hdr, skb->len + sizeof(*hdr), FREE_AFTER_TX(skb) ?
319 p54u_tx_cb : p54u_tx_dummy_cb, skb);
320 data_urb->transfer_flags |= URB_ZERO_PACKET;
321
322 usb_anchor_urb(int_urb, &priv->submitted);
323 err = usb_submit_urb(int_urb, GFP_ATOMIC);
324 if (err) {
325 usb_unanchor_urb(int_urb);
326 goto out;
327 }
328
329 usb_anchor_urb(data_urb, &priv->submitted);
330 err = usb_submit_urb(data_urb, GFP_ATOMIC);
331 if (err) {
332 usb_unanchor_urb(data_urb);
333 goto out;
334 }
335 out:
336 usb_free_urb(int_urb);
337 usb_free_urb(data_urb);
338
339 if (err) {
340 kfree(reg);
341 p54_free_skb(dev, skb);
342 }
343 }
344
345 static int p54u_write(struct p54u_priv *priv,
346 struct net2280_reg_write *buf,
347 enum net2280_op_type type,
348 __le32 addr, __le32 val)
349 {
350 unsigned int ep;
351 int alen;
352
353 if (type & 0x0800)
354 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_DEV);
355 else
356 ep = usb_sndbulkpipe(priv->udev, P54U_PIPE_BRG);
357
358 buf->port = cpu_to_le16(type);
359 buf->addr = addr;
360 buf->val = val;
361
362 return usb_bulk_msg(priv->udev, ep, buf, sizeof(*buf), &alen, 1000);
363 }
364
365 static int p54u_read(struct p54u_priv *priv, void *buf,
366 enum net2280_op_type type,
367 __le32 addr, __le32 *val)
368 {
369 struct net2280_reg_read *read = buf;
370 __le32 *reg = buf;
371 unsigned int ep;
372 int alen, err;
373
374 if (type & 0x0800)
375 ep = P54U_PIPE_DEV;
376 else
377 ep = P54U_PIPE_BRG;
378
379 read->port = cpu_to_le16(type);
380 read->addr = addr;
381
382 err = usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
383 read, sizeof(*read), &alen, 1000);
384 if (err)
385 return err;
386
387 err = usb_bulk_msg(priv->udev, usb_rcvbulkpipe(priv->udev, ep),
388 reg, sizeof(*reg), &alen, 1000);
389 if (err)
390 return err;
391
392 *val = *reg;
393 return 0;
394 }
395
396 static int p54u_bulk_msg(struct p54u_priv *priv, unsigned int ep,
397 void *data, size_t len)
398 {
399 int alen;
400 return usb_bulk_msg(priv->udev, usb_sndbulkpipe(priv->udev, ep),
401 data, len, &alen, 2000);
402 }
403
404 static int p54u_device_reset(struct ieee80211_hw *dev)
405 {
406 struct p54u_priv *priv = dev->priv;
407 int ret, lock = (priv->intf->condition != USB_INTERFACE_BINDING);
408
409 if (lock) {
410 ret = usb_lock_device_for_reset(priv->udev, priv->intf);
411 if (ret < 0) {
412 dev_err(&priv->udev->dev, "(p54usb) unable to lock "
413 "device for reset (%d)!\n", ret);
414 return ret;
415 }
416 }
417
418 ret = usb_reset_device(priv->udev);
419 if (lock)
420 usb_unlock_device(priv->udev);
421
422 if (ret)
423 dev_err(&priv->udev->dev, "(p54usb) unable to reset "
424 "device (%d)!\n", ret);
425
426 return ret;
427 }
428
429 static const char p54u_romboot_3887[] = "~~~~";
430 static int p54u_firmware_reset_3887(struct ieee80211_hw *dev)
431 {
432 struct p54u_priv *priv = dev->priv;
433 u8 *buf;
434 int ret;
435
436 buf = kmalloc(4, GFP_KERNEL);
437 if (!buf)
438 return -ENOMEM;
439 memcpy(buf, p54u_romboot_3887, 4);
440 ret = p54u_bulk_msg(priv, P54U_PIPE_DATA,
441 buf, 4);
442 kfree(buf);
443 if (ret)
444 dev_err(&priv->udev->dev, "(p54usb) unable to jump to "
445 "boot ROM (%d)!\n", ret);
446
447 return ret;
448 }
449
450 static const char p54u_firmware_upload_3887[] = "<\r";
451 static int p54u_upload_firmware_3887(struct ieee80211_hw *dev)
452 {
453 struct p54u_priv *priv = dev->priv;
454 int err, alen;
455 u8 carry = 0;
456 u8 *buf, *tmp;
457 const u8 *data;
458 unsigned int left, remains, block_size;
459 struct x2_header *hdr;
460 unsigned long timeout;
461
462 err = p54u_firmware_reset_3887(dev);
463 if (err)
464 return err;
465
466 tmp = buf = kmalloc(P54U_FW_BLOCK, GFP_KERNEL);
467 if (!buf) {
468 dev_err(&priv->udev->dev, "(p54usb) cannot allocate firmware"
469 "upload buffer!\n");
470 return -ENOMEM;
471 }
472
473 left = block_size = min((size_t)P54U_FW_BLOCK, priv->fw->size);
474 strcpy(buf, p54u_firmware_upload_3887);
475 left -= strlen(p54u_firmware_upload_3887);
476 tmp += strlen(p54u_firmware_upload_3887);
477
478 data = priv->fw->data;
479 remains = priv->fw->size;
480
481 hdr = (struct x2_header *)(buf + strlen(p54u_firmware_upload_3887));
482 memcpy(hdr->signature, X2_SIGNATURE, X2_SIGNATURE_SIZE);
483 hdr->fw_load_addr = cpu_to_le32(ISL38XX_DEV_FIRMWARE_ADDR);
484 hdr->fw_length = cpu_to_le32(priv->fw->size);
485 hdr->crc = cpu_to_le32(~crc32_le(~0, (void *)&hdr->fw_load_addr,
486 sizeof(u32)*2));
487 left -= sizeof(*hdr);
488 tmp += sizeof(*hdr);
489
490 while (remains) {
491 while (left--) {
492 if (carry) {
493 *tmp++ = carry;
494 carry = 0;
495 remains--;
496 continue;
497 }
498 switch (*data) {
499 case '~':
500 *tmp++ = '}';
501 carry = '^';
502 break;
503 case '}':
504 *tmp++ = '}';
505 carry = ']';
506 break;
507 default:
508 *tmp++ = *data;
509 remains--;
510 break;
511 }
512 data++;
513 }
514
515 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_size);
516 if (err) {
517 dev_err(&priv->udev->dev, "(p54usb) firmware "
518 "upload failed!\n");
519 goto err_upload_failed;
520 }
521
522 tmp = buf;
523 left = block_size = min((unsigned int)P54U_FW_BLOCK, remains);
524 }
525
526 *((__le32 *)buf) = cpu_to_le32(~crc32_le(~0, priv->fw->data,
527 priv->fw->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 kfree(buf);
580 return err;
581 }
582
583 static int p54u_upload_firmware_net2280(struct ieee80211_hw *dev)
584 {
585 struct p54u_priv *priv = dev->priv;
586 const struct p54p_csr *devreg = (const struct p54p_csr *) P54U_DEV_BASE;
587 int err, alen;
588 void *buf;
589 __le32 reg;
590 unsigned int remains, offset;
591 const u8 *data;
592
593 buf = kmalloc(512, GFP_KERNEL);
594 if (!buf) {
595 dev_err(&priv->udev->dev, "(p54usb) firmware buffer "
596 "alloc failed!\n");
597 return -ENOMEM;
598 }
599
600 #define P54U_WRITE(type, addr, data) \
601 do {\
602 err = p54u_write(priv, buf, type,\
603 cpu_to_le32((u32)(unsigned long)addr), data);\
604 if (err) \
605 goto fail;\
606 } while (0)
607
608 #define P54U_READ(type, addr) \
609 do {\
610 err = p54u_read(priv, buf, type,\
611 cpu_to_le32((u32)(unsigned long)addr), &reg);\
612 if (err)\
613 goto fail;\
614 } while (0)
615
616 /* power down net2280 bridge */
617 P54U_READ(NET2280_BRG_U32, NET2280_GPIOCTL);
618 reg |= cpu_to_le32(P54U_BRG_POWER_DOWN);
619 reg &= cpu_to_le32(~P54U_BRG_POWER_UP);
620 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
621
622 mdelay(100);
623
624 /* power up bridge */
625 reg |= cpu_to_le32(P54U_BRG_POWER_UP);
626 reg &= cpu_to_le32(~P54U_BRG_POWER_DOWN);
627 P54U_WRITE(NET2280_BRG_U32, NET2280_GPIOCTL, reg);
628
629 mdelay(100);
630
631 P54U_WRITE(NET2280_BRG_U32, NET2280_DEVINIT,
632 cpu_to_le32(NET2280_CLK_30Mhz |
633 NET2280_PCI_ENABLE |
634 NET2280_PCI_SOFT_RESET));
635
636 mdelay(20);
637
638 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_COMMAND,
639 cpu_to_le32(PCI_COMMAND_MEMORY |
640 PCI_COMMAND_MASTER));
641
642 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_0,
643 cpu_to_le32(NET2280_BASE));
644
645 P54U_READ(NET2280_BRG_CFG_U16, PCI_STATUS);
646 reg |= cpu_to_le32(PCI_STATUS_REC_MASTER_ABORT);
647 P54U_WRITE(NET2280_BRG_CFG_U16, PCI_STATUS, reg);
648
649 // TODO: we really need this?
650 P54U_READ(NET2280_BRG_U32, NET2280_RELNUM);
651
652 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_RSP,
653 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
654 P54U_WRITE(NET2280_BRG_U32, NET2280_EPC_RSP,
655 cpu_to_le32(NET2280_CLEAR_NAK_OUT_PACKETS_MODE));
656
657 P54U_WRITE(NET2280_BRG_CFG_U32, PCI_BASE_ADDRESS_2,
658 cpu_to_le32(NET2280_BASE2));
659
660 /* finally done setting up the bridge */
661
662 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | PCI_COMMAND,
663 cpu_to_le32(PCI_COMMAND_MEMORY |
664 PCI_COMMAND_MASTER));
665
666 P54U_WRITE(NET2280_DEV_CFG_U16, 0x10000 | 0x40 /* TRDY timeout */, 0);
667 P54U_WRITE(NET2280_DEV_CFG_U32, 0x10000 | PCI_BASE_ADDRESS_0,
668 cpu_to_le32(P54U_DEV_BASE));
669
670 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
671 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
672 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
673
674 /* do romboot */
675 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable, 0);
676
677 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
678 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
679 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RAMBOOT);
680 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
681 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
682
683 mdelay(20);
684
685 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
686 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
687
688 mdelay(20);
689
690 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
691 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
692
693 mdelay(100);
694
695 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
696 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
697
698 /* finally, we can upload firmware now! */
699 remains = priv->fw->size;
700 data = priv->fw->data;
701 offset = ISL38XX_DEV_FIRMWARE_ADDR;
702
703 while (remains) {
704 unsigned int block_len = min(remains, (unsigned int)512);
705 memcpy(buf, data, block_len);
706
707 err = p54u_bulk_msg(priv, P54U_PIPE_DATA, buf, block_len);
708 if (err) {
709 dev_err(&priv->udev->dev, "(p54usb) firmware block "
710 "upload failed\n");
711 goto fail;
712 }
713
714 P54U_WRITE(NET2280_DEV_U32, &devreg->direct_mem_base,
715 cpu_to_le32(0xc0000f00));
716
717 P54U_WRITE(NET2280_DEV_U32,
718 0x0020 | (unsigned long)&devreg->direct_mem_win, 0);
719 P54U_WRITE(NET2280_DEV_U32,
720 0x0020 | (unsigned long)&devreg->direct_mem_win,
721 cpu_to_le32(1));
722
723 P54U_WRITE(NET2280_DEV_U32,
724 0x0024 | (unsigned long)&devreg->direct_mem_win,
725 cpu_to_le32(block_len));
726 P54U_WRITE(NET2280_DEV_U32,
727 0x0028 | (unsigned long)&devreg->direct_mem_win,
728 cpu_to_le32(offset));
729
730 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_addr,
731 cpu_to_le32(NET2280_EPA_FIFO_PCI_ADDR));
732 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_len,
733 cpu_to_le32(block_len >> 2));
734 P54U_WRITE(NET2280_DEV_U32, &devreg->dma_ctrl,
735 cpu_to_le32(ISL38XX_DMA_MASTER_CONTROL_TRIGGER));
736
737 mdelay(10);
738
739 P54U_READ(NET2280_DEV_U32,
740 0x002C | (unsigned long)&devreg->direct_mem_win);
741 if (!(reg & cpu_to_le32(ISL38XX_DMA_STATUS_DONE)) ||
742 !(reg & cpu_to_le32(ISL38XX_DMA_STATUS_READY))) {
743 dev_err(&priv->udev->dev, "(p54usb) firmware DMA "
744 "transfer failed\n");
745 goto fail;
746 }
747
748 P54U_WRITE(NET2280_BRG_U32, NET2280_EPA_STAT,
749 cpu_to_le32(NET2280_FIFO_FLUSH));
750
751 remains -= block_len;
752 data += block_len;
753 offset += block_len;
754 }
755
756 /* do ramboot */
757 P54U_READ(NET2280_DEV_U32, &devreg->ctrl_stat);
758 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
759 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_CLKRUN);
760 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RAMBOOT);
761 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
762
763 mdelay(20);
764
765 reg |= cpu_to_le32(ISL38XX_CTRL_STAT_RESET);
766 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
767
768 reg &= cpu_to_le32(~ISL38XX_CTRL_STAT_RESET);
769 P54U_WRITE(NET2280_DEV_U32, &devreg->ctrl_stat, reg);
770
771 mdelay(100);
772
773 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
774 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
775
776 /* start up the firmware */
777 P54U_WRITE(NET2280_DEV_U32, &devreg->int_enable,
778 cpu_to_le32(ISL38XX_INT_IDENT_INIT));
779
780 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
781 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
782
783 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1,
784 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT_ENABLE |
785 NET2280_USB_INTERRUPT_ENABLE));
786
787 P54U_WRITE(NET2280_DEV_U32, &devreg->dev_int,
788 cpu_to_le32(ISL38XX_DEV_INT_RESET));
789
790 err = usb_interrupt_msg(priv->udev,
791 usb_rcvbulkpipe(priv->udev, P54U_PIPE_INT),
792 buf, sizeof(__le32), &alen, 1000);
793 if (err || alen != sizeof(__le32))
794 goto fail;
795
796 P54U_READ(NET2280_DEV_U32, &devreg->int_ident);
797 P54U_WRITE(NET2280_DEV_U32, &devreg->int_ack, reg);
798
799 if (!(reg & cpu_to_le32(ISL38XX_INT_IDENT_INIT)))
800 err = -EINVAL;
801
802 P54U_WRITE(NET2280_BRG_U32, NET2280_USBIRQENB1, 0);
803 P54U_WRITE(NET2280_BRG_U32, NET2280_IRQSTAT1,
804 cpu_to_le32(NET2280_PCI_INTA_INTERRUPT));
805
806 #undef P54U_WRITE
807 #undef P54U_READ
808
809 fail:
810 kfree(buf);
811 return err;
812 }
813
814 static int p54u_load_firmware(struct ieee80211_hw *dev)
815 {
816 struct p54u_priv *priv = dev->priv;
817 int err, i;
818
819 BUILD_BUG_ON(ARRAY_SIZE(p54u_fwlist) != __NUM_P54U_HWTYPES);
820
821 for (i = 0; i < __NUM_P54U_HWTYPES; i++)
822 if (p54u_fwlist[i].type == priv->hw_type)
823 break;
824
825 if (i == __NUM_P54U_HWTYPES)
826 return -EOPNOTSUPP;
827
828 err = request_firmware(&priv->fw, p54u_fwlist[i].fw, &priv->udev->dev);
829 if (err) {
830 dev_err(&priv->udev->dev, "(p54usb) cannot load firmware %s "
831 "(%d)!\n", p54u_fwlist[i].fw, err);
832
833 err = request_firmware(&priv->fw, p54u_fwlist[i].fw_legacy,
834 &priv->udev->dev);
835 if (err)
836 return err;
837 }
838
839 err = p54_parse_firmware(dev, priv->fw);
840 if (err)
841 goto out;
842
843 if (priv->common.fw_interface != p54u_fwlist[i].intf) {
844 dev_err(&priv->udev->dev, "wrong firmware, please get "
845 "a firmware for \"%s\" and try again.\n",
846 p54u_fwlist[i].hw);
847 err = -EINVAL;
848 }
849
850 out:
851 if (err)
852 release_firmware(priv->fw);
853
854 return err;
855 }
856
857 static int p54u_open(struct ieee80211_hw *dev)
858 {
859 struct p54u_priv *priv = dev->priv;
860 int err;
861
862 err = p54u_init_urbs(dev);
863 if (err) {
864 return err;
865 }
866
867 priv->common.open = p54u_init_urbs;
868
869 return 0;
870 }
871
872 static void p54u_stop(struct ieee80211_hw *dev)
873 {
874 /* TODO: figure out how to reliably stop the 3887 and net2280 so
875 the hardware is still usable next time we want to start it.
876 until then, we just stop listening to the hardware.. */
877 p54u_free_urbs(dev);
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);
AMDTP streaming driver for the Linux FireWire stack (Juju)