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