aboutsummaryrefslogtreecommitdiffstats
path: root/drivers/net/wireless/ar9170/usb.c
diff options
context:
space:
mode:
authorLuis R. Rodriguez <lrodriguez@atheros.com>2009-03-30 22:30:33 -0400
committerJohn W. Linville <linville@tuxdriver.com>2009-04-22 16:54:38 -0400
commit203c4805e91786f9a010bc7945a0fde70c9da28e (patch)
tree00415276b2fe65713f066ffe07b11ad2d8b6bea8 /drivers/net/wireless/ar9170/usb.c
parent1878f77e13b9d720b78c4f818b94bfd4a7f596e5 (diff)
atheros: put atheros wireless drivers into ath/
Signed-off-by: Luis R. Rodriguez <lrodriguez@atheros.com> Signed-off-by: John W. Linville <linville@tuxdriver.com>
Diffstat (limited to 'drivers/net/wireless/ar9170/usb.c')
-rw-r--r--drivers/net/wireless/ar9170/usb.c822
1 files changed, 0 insertions, 822 deletions
diff --git a/drivers/net/wireless/ar9170/usb.c b/drivers/net/wireless/ar9170/usb.c
deleted file mode 100644
index fddda477095c..000000000000
--- a/drivers/net/wireless/ar9170/usb.c
+++ /dev/null
@@ -1,822 +0,0 @@
1/*
2 * Atheros AR9170 driver
3 *
4 * USB - frontend
5 *
6 * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
7 * Copyright 2009, Christian Lamparter <chunkeey@web.de>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; see the file COPYING. If not, see
21 * http://www.gnu.org/licenses/.
22 *
23 * This file incorporates work covered by the following copyright and
24 * permission notice:
25 * Copyright (c) 2007-2008 Atheros Communications, Inc.
26 *
27 * Permission to use, copy, modify, and/or distribute this software for any
28 * purpose with or without fee is hereby granted, provided that the above
29 * copyright notice and this permission notice appear in all copies.
30 *
31 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
32 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
33 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
34 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
35 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
36 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
37 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
38 */
39
40#include <linux/module.h>
41#include <linux/usb.h>
42#include <linux/firmware.h>
43#include <linux/etherdevice.h>
44#include <net/mac80211.h>
45#include "ar9170.h"
46#include "cmd.h"
47#include "hw.h"
48#include "usb.h"
49
50MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
51MODULE_AUTHOR("Christian Lamparter <chunkeey@web.de>");
52MODULE_LICENSE("GPL");
53MODULE_DESCRIPTION("Atheros AR9170 802.11n USB wireless");
54MODULE_FIRMWARE("ar9170-1.fw");
55MODULE_FIRMWARE("ar9170-2.fw");
56
57static struct usb_device_id ar9170_usb_ids[] = {
58 /* Atheros 9170 */
59 { USB_DEVICE(0x0cf3, 0x9170) },
60 /* Atheros TG121N */
61 { USB_DEVICE(0x0cf3, 0x1001) },
62 /* Cace Airpcap NX */
63 { USB_DEVICE(0xcace, 0x0300) },
64 /* D-Link DWA 160A */
65 { USB_DEVICE(0x07d1, 0x3c10) },
66 /* Netgear WNDA3100 */
67 { USB_DEVICE(0x0846, 0x9010) },
68 /* Netgear WN111 v2 */
69 { USB_DEVICE(0x0846, 0x9001) },
70 /* Zydas ZD1221 */
71 { USB_DEVICE(0x0ace, 0x1221) },
72 /* ZyXEL NWD271N */
73 { USB_DEVICE(0x0586, 0x3417) },
74 /* Z-Com UB81 BG */
75 { USB_DEVICE(0x0cde, 0x0023) },
76 /* Z-Com UB82 ABG */
77 { USB_DEVICE(0x0cde, 0x0026) },
78 /* Arcadyan WN7512 */
79 { USB_DEVICE(0x083a, 0xf522) },
80 /* Planex GWUS300 */
81 { USB_DEVICE(0x2019, 0x5304) },
82 /* IO-Data WNGDNUS2 */
83 { USB_DEVICE(0x04bb, 0x093f) },
84
85 /* terminate */
86 {}
87};
88MODULE_DEVICE_TABLE(usb, ar9170_usb_ids);
89
90static void ar9170_usb_tx_urb_complete_free(struct urb *urb)
91{
92 struct sk_buff *skb = urb->context;
93 struct ar9170_usb *aru = (struct ar9170_usb *)
94 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
95
96 if (!aru) {
97 dev_kfree_skb_irq(skb);
98 return ;
99 }
100
101 ar9170_handle_tx_status(&aru->common, skb, false,
102 AR9170_TX_STATUS_COMPLETE);
103}
104
105static void ar9170_usb_tx_urb_complete(struct urb *urb)
106{
107}
108
109static void ar9170_usb_irq_completed(struct urb *urb)
110{
111 struct ar9170_usb *aru = urb->context;
112
113 switch (urb->status) {
114 /* everything is fine */
115 case 0:
116 break;
117
118 /* disconnect */
119 case -ENOENT:
120 case -ECONNRESET:
121 case -ENODEV:
122 case -ESHUTDOWN:
123 goto free;
124
125 default:
126 goto resubmit;
127 }
128
129 print_hex_dump_bytes("ar9170 irq: ", DUMP_PREFIX_OFFSET,
130 urb->transfer_buffer, urb->actual_length);
131
132resubmit:
133 usb_anchor_urb(urb, &aru->rx_submitted);
134 if (usb_submit_urb(urb, GFP_ATOMIC)) {
135 usb_unanchor_urb(urb);
136 goto free;
137 }
138
139 return;
140
141free:
142 usb_buffer_free(aru->udev, 64, urb->transfer_buffer, urb->transfer_dma);
143}
144
145static void ar9170_usb_rx_completed(struct urb *urb)
146{
147 struct sk_buff *skb = urb->context;
148 struct ar9170_usb *aru = (struct ar9170_usb *)
149 usb_get_intfdata(usb_ifnum_to_if(urb->dev, 0));
150 int err;
151
152 if (!aru)
153 goto free;
154
155 switch (urb->status) {
156 /* everything is fine */
157 case 0:
158 break;
159
160 /* disconnect */
161 case -ENOENT:
162 case -ECONNRESET:
163 case -ENODEV:
164 case -ESHUTDOWN:
165 goto free;
166
167 default:
168 goto resubmit;
169 }
170
171 skb_put(skb, urb->actual_length);
172 ar9170_rx(&aru->common, skb);
173
174resubmit:
175 skb_reset_tail_pointer(skb);
176 skb_trim(skb, 0);
177
178 usb_anchor_urb(urb, &aru->rx_submitted);
179 err = usb_submit_urb(urb, GFP_ATOMIC);
180 if (err) {
181 usb_unanchor_urb(urb);
182 dev_kfree_skb_irq(skb);
183 }
184
185 return ;
186
187free:
188 dev_kfree_skb_irq(skb);
189 return;
190}
191
192static int ar9170_usb_prep_rx_urb(struct ar9170_usb *aru,
193 struct urb *urb, gfp_t gfp)
194{
195 struct sk_buff *skb;
196
197 skb = __dev_alloc_skb(AR9170_MAX_RX_BUFFER_SIZE + 32, gfp);
198 if (!skb)
199 return -ENOMEM;
200
201 /* reserve some space for mac80211's radiotap */
202 skb_reserve(skb, 32);
203
204 usb_fill_bulk_urb(urb, aru->udev,
205 usb_rcvbulkpipe(aru->udev, AR9170_EP_RX),
206 skb->data, min(skb_tailroom(skb),
207 AR9170_MAX_RX_BUFFER_SIZE),
208 ar9170_usb_rx_completed, skb);
209
210 return 0;
211}
212
213static int ar9170_usb_alloc_rx_irq_urb(struct ar9170_usb *aru)
214{
215 struct urb *urb = NULL;
216 void *ibuf;
217 int err = -ENOMEM;
218
219 /* initialize interrupt endpoint */
220 urb = usb_alloc_urb(0, GFP_KERNEL);
221 if (!urb)
222 goto out;
223
224 ibuf = usb_buffer_alloc(aru->udev, 64, GFP_KERNEL, &urb->transfer_dma);
225 if (!ibuf)
226 goto out;
227
228 usb_fill_int_urb(urb, aru->udev,
229 usb_rcvintpipe(aru->udev, AR9170_EP_IRQ), ibuf,
230 64, ar9170_usb_irq_completed, aru, 1);
231 urb->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
232
233 usb_anchor_urb(urb, &aru->rx_submitted);
234 err = usb_submit_urb(urb, GFP_KERNEL);
235 if (err) {
236 usb_unanchor_urb(urb);
237 usb_buffer_free(aru->udev, 64, urb->transfer_buffer,
238 urb->transfer_dma);
239 }
240
241out:
242 usb_free_urb(urb);
243 return err;
244}
245
246static int ar9170_usb_alloc_rx_bulk_urbs(struct ar9170_usb *aru)
247{
248 struct urb *urb;
249 int i;
250 int err = -EINVAL;
251
252 for (i = 0; i < AR9170_NUM_RX_URBS; i++) {
253 err = -ENOMEM;
254 urb = usb_alloc_urb(0, GFP_KERNEL);
255 if (!urb)
256 goto err_out;
257
258 err = ar9170_usb_prep_rx_urb(aru, urb, GFP_KERNEL);
259 if (err) {
260 usb_free_urb(urb);
261 goto err_out;
262 }
263
264 usb_anchor_urb(urb, &aru->rx_submitted);
265 err = usb_submit_urb(urb, GFP_KERNEL);
266 if (err) {
267 usb_unanchor_urb(urb);
268 dev_kfree_skb_any((void *) urb->transfer_buffer);
269 usb_free_urb(urb);
270 goto err_out;
271 }
272 usb_free_urb(urb);
273 }
274
275 /* the device now waiting for a firmware. */
276 aru->common.state = AR9170_IDLE;
277 return 0;
278
279err_out:
280
281 usb_kill_anchored_urbs(&aru->rx_submitted);
282 return err;
283}
284
285static void ar9170_usb_cancel_urbs(struct ar9170_usb *aru)
286{
287 int ret;
288
289 aru->common.state = AR9170_UNKNOWN_STATE;
290
291 usb_unlink_anchored_urbs(&aru->tx_submitted);
292
293 /* give the LED OFF command and the deauth frame a chance to air. */
294 ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
295 msecs_to_jiffies(100));
296 if (ret == 0)
297 dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
298 usb_poison_anchored_urbs(&aru->tx_submitted);
299
300 usb_poison_anchored_urbs(&aru->rx_submitted);
301}
302
303static int ar9170_usb_exec_cmd(struct ar9170 *ar, enum ar9170_cmd cmd,
304 unsigned int plen, void *payload,
305 unsigned int outlen, void *out)
306{
307 struct ar9170_usb *aru = (void *) ar;
308 struct urb *urb = NULL;
309 unsigned long flags;
310 int err = -ENOMEM;
311
312 if (unlikely(!IS_ACCEPTING_CMD(ar)))
313 return -EPERM;
314
315 if (WARN_ON(plen > AR9170_MAX_CMD_LEN - 4))
316 return -EINVAL;
317
318 urb = usb_alloc_urb(0, GFP_ATOMIC);
319 if (unlikely(!urb))
320 goto err_free;
321
322 ar->cmdbuf[0] = cpu_to_le32(plen);
323 ar->cmdbuf[0] |= cpu_to_le32(cmd << 8);
324 /* writing multiple regs fills this buffer already */
325 if (plen && payload != (u8 *)(&ar->cmdbuf[1]))
326 memcpy(&ar->cmdbuf[1], payload, plen);
327
328 spin_lock_irqsave(&aru->common.cmdlock, flags);
329 aru->readbuf = (u8 *)out;
330 aru->readlen = outlen;
331 spin_unlock_irqrestore(&aru->common.cmdlock, flags);
332
333 usb_fill_int_urb(urb, aru->udev,
334 usb_sndbulkpipe(aru->udev, AR9170_EP_CMD),
335 aru->common.cmdbuf, plen + 4,
336 ar9170_usb_tx_urb_complete, NULL, 1);
337
338 usb_anchor_urb(urb, &aru->tx_submitted);
339 err = usb_submit_urb(urb, GFP_ATOMIC);
340 if (err) {
341 usb_unanchor_urb(urb);
342 usb_free_urb(urb);
343 goto err_unbuf;
344 }
345 usb_free_urb(urb);
346
347 err = wait_for_completion_timeout(&aru->cmd_wait, HZ);
348 if (err == 0) {
349 err = -ETIMEDOUT;
350 goto err_unbuf;
351 }
352
353 if (outlen >= 0 && aru->readlen != outlen) {
354 err = -EMSGSIZE;
355 goto err_unbuf;
356 }
357
358 return 0;
359
360err_unbuf:
361 /* Maybe the device was removed in the second we were waiting? */
362 if (IS_STARTED(ar)) {
363 dev_err(&aru->udev->dev, "no command feedback "
364 "received (%d).\n", err);
365
366 /* provide some maybe useful debug information */
367 print_hex_dump_bytes("ar9170 cmd: ", DUMP_PREFIX_NONE,
368 aru->common.cmdbuf, plen + 4);
369 dump_stack();
370 }
371
372 /* invalidate to avoid completing the next prematurely */
373 spin_lock_irqsave(&aru->common.cmdlock, flags);
374 aru->readbuf = NULL;
375 aru->readlen = 0;
376 spin_unlock_irqrestore(&aru->common.cmdlock, flags);
377
378err_free:
379
380 return err;
381}
382
383static int ar9170_usb_tx(struct ar9170 *ar, struct sk_buff *skb,
384 bool txstatus_needed, unsigned int extra_len)
385{
386 struct ar9170_usb *aru = (struct ar9170_usb *) ar;
387 struct urb *urb;
388 int err;
389
390 if (unlikely(!IS_STARTED(ar))) {
391 /* Seriously, what were you drink... err... thinking!? */
392 return -EPERM;
393 }
394
395 urb = usb_alloc_urb(0, GFP_ATOMIC);
396 if (unlikely(!urb))
397 return -ENOMEM;
398
399 usb_fill_bulk_urb(urb, aru->udev,
400 usb_sndbulkpipe(aru->udev, AR9170_EP_TX),
401 skb->data, skb->len + extra_len, (txstatus_needed ?
402 ar9170_usb_tx_urb_complete :
403 ar9170_usb_tx_urb_complete_free), skb);
404 urb->transfer_flags |= URB_ZERO_PACKET;
405
406 usb_anchor_urb(urb, &aru->tx_submitted);
407 err = usb_submit_urb(urb, GFP_ATOMIC);
408 if (unlikely(err))
409 usb_unanchor_urb(urb);
410
411 usb_free_urb(urb);
412 return err;
413}
414
415static void ar9170_usb_callback_cmd(struct ar9170 *ar, u32 len , void *buffer)
416{
417 struct ar9170_usb *aru = (void *) ar;
418 unsigned long flags;
419 u32 in, out;
420
421 if (!buffer)
422 return ;
423
424 in = le32_to_cpup((__le32 *)buffer);
425 out = le32_to_cpu(ar->cmdbuf[0]);
426
427 /* mask off length byte */
428 out &= ~0xFF;
429
430 if (aru->readlen >= 0) {
431 /* add expected length */
432 out |= aru->readlen;
433 } else {
434 /* add obtained length */
435 out |= in & 0xFF;
436 }
437
438 /*
439 * Some commands (e.g: AR9170_CMD_FREQUENCY) have a variable response
440 * length and we cannot predict the correct length in advance.
441 * So we only check if we provided enough space for the data.
442 */
443 if (unlikely(out < in)) {
444 dev_warn(&aru->udev->dev, "received invalid command response "
445 "got %d bytes, instead of %d bytes "
446 "and the resp length is %d bytes\n",
447 in, out, len);
448 print_hex_dump_bytes("ar9170 invalid resp: ",
449 DUMP_PREFIX_OFFSET, buffer, len);
450 /*
451 * Do not complete, then the command times out,
452 * and we get a stack trace from there.
453 */
454 return ;
455 }
456
457 spin_lock_irqsave(&aru->common.cmdlock, flags);
458 if (aru->readbuf && len > 0) {
459 memcpy(aru->readbuf, buffer + 4, len - 4);
460 aru->readbuf = NULL;
461 }
462 complete(&aru->cmd_wait);
463 spin_unlock_irqrestore(&aru->common.cmdlock, flags);
464}
465
466static int ar9170_usb_upload(struct ar9170_usb *aru, const void *data,
467 size_t len, u32 addr, bool complete)
468{
469 int transfer, err;
470 u8 *buf = kmalloc(4096, GFP_KERNEL);
471
472 if (!buf)
473 return -ENOMEM;
474
475 while (len) {
476 transfer = min_t(int, len, 4096);
477 memcpy(buf, data, transfer);
478
479 err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
480 0x30 /* FW DL */, 0x40 | USB_DIR_OUT,
481 addr >> 8, 0, buf, transfer, 1000);
482
483 if (err < 0) {
484 kfree(buf);
485 return err;
486 }
487
488 len -= transfer;
489 data += transfer;
490 addr += transfer;
491 }
492 kfree(buf);
493
494 if (complete) {
495 err = usb_control_msg(aru->udev, usb_sndctrlpipe(aru->udev, 0),
496 0x31 /* FW DL COMPLETE */,
497 0x40 | USB_DIR_OUT, 0, 0, NULL, 0, 5000);
498 }
499
500 return 0;
501}
502
503static int ar9170_usb_request_firmware(struct ar9170_usb *aru)
504{
505 int err = 0;
506
507 err = request_firmware(&aru->init_values, "ar9170-1.fw",
508 &aru->udev->dev);
509 if (err) {
510 dev_err(&aru->udev->dev, "file with init values not found.\n");
511 return err;
512 }
513
514 err = request_firmware(&aru->firmware, "ar9170-2.fw", &aru->udev->dev);
515 if (err) {
516 release_firmware(aru->init_values);
517 dev_err(&aru->udev->dev, "firmware file not found.\n");
518 return err;
519 }
520
521 return err;
522}
523
524static int ar9170_usb_reset(struct ar9170_usb *aru)
525{
526 int ret, lock = (aru->intf->condition != USB_INTERFACE_BINDING);
527
528 if (lock) {
529 ret = usb_lock_device_for_reset(aru->udev, aru->intf);
530 if (ret < 0) {
531 dev_err(&aru->udev->dev, "unable to lock device "
532 "for reset (%d).\n", ret);
533 return ret;
534 }
535 }
536
537 ret = usb_reset_device(aru->udev);
538 if (lock)
539 usb_unlock_device(aru->udev);
540
541 /* let it rest - for a second - */
542 msleep(1000);
543
544 return ret;
545}
546
547static int ar9170_usb_upload_firmware(struct ar9170_usb *aru)
548{
549 int err;
550
551 /* First, upload initial values to device RAM */
552 err = ar9170_usb_upload(aru, aru->init_values->data,
553 aru->init_values->size, 0x102800, false);
554 if (err) {
555 dev_err(&aru->udev->dev, "firmware part 1 "
556 "upload failed (%d).\n", err);
557 return err;
558 }
559
560 /* Then, upload the firmware itself and start it */
561 return ar9170_usb_upload(aru, aru->firmware->data, aru->firmware->size,
562 0x200000, true);
563}
564
565static int ar9170_usb_init_transport(struct ar9170_usb *aru)
566{
567 struct ar9170 *ar = (void *) &aru->common;
568 int err;
569
570 ar9170_regwrite_begin(ar);
571
572 /* Set USB Rx stream mode MAX packet number to 2 */
573 ar9170_regwrite(AR9170_USB_REG_MAX_AGG_UPLOAD, 0x4);
574
575 /* Set USB Rx stream mode timeout to 10us */
576 ar9170_regwrite(AR9170_USB_REG_UPLOAD_TIME_CTL, 0x80);
577
578 ar9170_regwrite_finish();
579
580 err = ar9170_regwrite_result();
581 if (err)
582 dev_err(&aru->udev->dev, "USB setup failed (%d).\n", err);
583
584 return err;
585}
586
587static void ar9170_usb_stop(struct ar9170 *ar)
588{
589 struct ar9170_usb *aru = (void *) ar;
590 int ret;
591
592 if (IS_ACCEPTING_CMD(ar))
593 aru->common.state = AR9170_STOPPED;
594
595 /* lets wait a while until the tx - queues are dried out */
596 ret = usb_wait_anchor_empty_timeout(&aru->tx_submitted,
597 msecs_to_jiffies(1000));
598 if (ret == 0)
599 dev_err(&aru->udev->dev, "kill pending tx urbs.\n");
600
601 usb_poison_anchored_urbs(&aru->tx_submitted);
602
603 /*
604 * Note:
605 * So far we freed all tx urbs, but we won't dare to touch any rx urbs.
606 * Else we would end up with a unresponsive device...
607 */
608}
609
610static int ar9170_usb_open(struct ar9170 *ar)
611{
612 struct ar9170_usb *aru = (void *) ar;
613 int err;
614
615 usb_unpoison_anchored_urbs(&aru->tx_submitted);
616 err = ar9170_usb_init_transport(aru);
617 if (err) {
618 usb_poison_anchored_urbs(&aru->tx_submitted);
619 return err;
620 }
621
622 aru->common.state = AR9170_IDLE;
623 return 0;
624}
625
626static int ar9170_usb_init_device(struct ar9170_usb *aru)
627{
628 int err;
629
630 err = ar9170_usb_alloc_rx_irq_urb(aru);
631 if (err)
632 goto err_out;
633
634 err = ar9170_usb_alloc_rx_bulk_urbs(aru);
635 if (err)
636 goto err_unrx;
637
638 err = ar9170_usb_upload_firmware(aru);
639 if (err) {
640 err = ar9170_echo_test(&aru->common, 0x60d43110);
641 if (err) {
642 /* force user invention, by disabling the device */
643 err = usb_driver_set_configuration(aru->udev, -1);
644 dev_err(&aru->udev->dev, "device is in a bad state. "
645 "please reconnect it!\n");
646 goto err_unrx;
647 }
648 }
649
650 return 0;
651
652err_unrx:
653 ar9170_usb_cancel_urbs(aru);
654
655err_out:
656 return err;
657}
658
659static int ar9170_usb_probe(struct usb_interface *intf,
660 const struct usb_device_id *id)
661{
662 struct ar9170_usb *aru;
663 struct ar9170 *ar;
664 struct usb_device *udev;
665 int err;
666
667 aru = ar9170_alloc(sizeof(*aru));
668 if (IS_ERR(aru)) {
669 err = PTR_ERR(aru);
670 goto out;
671 }
672
673 udev = interface_to_usbdev(intf);
674 usb_get_dev(udev);
675 aru->udev = udev;
676 aru->intf = intf;
677 ar = &aru->common;
678
679 usb_set_intfdata(intf, aru);
680 SET_IEEE80211_DEV(ar->hw, &udev->dev);
681
682 init_usb_anchor(&aru->rx_submitted);
683 init_usb_anchor(&aru->tx_submitted);
684 init_completion(&aru->cmd_wait);
685
686 aru->common.stop = ar9170_usb_stop;
687 aru->common.open = ar9170_usb_open;
688 aru->common.tx = ar9170_usb_tx;
689 aru->common.exec_cmd = ar9170_usb_exec_cmd;
690 aru->common.callback_cmd = ar9170_usb_callback_cmd;
691
692 err = ar9170_usb_reset(aru);
693 if (err)
694 goto err_freehw;
695
696 err = ar9170_usb_request_firmware(aru);
697 if (err)
698 goto err_freehw;
699
700 err = ar9170_usb_init_device(aru);
701 if (err)
702 goto err_freefw;
703
704 err = ar9170_usb_open(ar);
705 if (err)
706 goto err_unrx;
707
708 err = ar9170_register(ar, &udev->dev);
709
710 ar9170_usb_stop(ar);
711 if (err)
712 goto err_unrx;
713
714 return 0;
715
716err_unrx:
717 ar9170_usb_cancel_urbs(aru);
718
719err_freefw:
720 release_firmware(aru->init_values);
721 release_firmware(aru->firmware);
722
723err_freehw:
724 usb_set_intfdata(intf, NULL);
725 usb_put_dev(udev);
726 ieee80211_free_hw(ar->hw);
727out:
728 return err;
729}
730
731static void ar9170_usb_disconnect(struct usb_interface *intf)
732{
733 struct ar9170_usb *aru = usb_get_intfdata(intf);
734
735 if (!aru)
736 return;
737
738 aru->common.state = AR9170_IDLE;
739 ar9170_unregister(&aru->common);
740 ar9170_usb_cancel_urbs(aru);
741
742 release_firmware(aru->init_values);
743 release_firmware(aru->firmware);
744
745 usb_put_dev(aru->udev);
746 usb_set_intfdata(intf, NULL);
747 ieee80211_free_hw(aru->common.hw);
748}
749
750#ifdef CONFIG_PM
751static int ar9170_suspend(struct usb_interface *intf,
752 pm_message_t message)
753{
754 struct ar9170_usb *aru = usb_get_intfdata(intf);
755
756 if (!aru)
757 return -ENODEV;
758
759 aru->common.state = AR9170_IDLE;
760 ar9170_usb_cancel_urbs(aru);
761
762 return 0;
763}
764
765static int ar9170_resume(struct usb_interface *intf)
766{
767 struct ar9170_usb *aru = usb_get_intfdata(intf);
768 int err;
769
770 if (!aru)
771 return -ENODEV;
772
773 usb_unpoison_anchored_urbs(&aru->rx_submitted);
774 usb_unpoison_anchored_urbs(&aru->tx_submitted);
775
776 /*
777 * FIXME: firmware upload will fail on resume.
778 * but this is better than a hang!
779 */
780
781 err = ar9170_usb_init_device(aru);
782 if (err)
783 goto err_unrx;
784
785 err = ar9170_usb_open(&aru->common);
786 if (err)
787 goto err_unrx;
788
789 return 0;
790
791err_unrx:
792 aru->common.state = AR9170_IDLE;
793 ar9170_usb_cancel_urbs(aru);
794
795 return err;
796}
797#endif /* CONFIG_PM */
798
799static struct usb_driver ar9170_driver = {
800 .name = "ar9170usb",
801 .probe = ar9170_usb_probe,
802 .disconnect = ar9170_usb_disconnect,
803 .id_table = ar9170_usb_ids,
804 .soft_unbind = 1,
805#ifdef CONFIG_PM
806 .suspend = ar9170_suspend,
807 .resume = ar9170_resume,
808#endif /* CONFIG_PM */
809};
810
811static int __init ar9170_init(void)
812{
813 return usb_register(&ar9170_driver);
814}
815
816static void __exit ar9170_exit(void)
817{
818 usb_deregister(&ar9170_driver);
819}
820
821module_init(ar9170_init);
822module_exit(ar9170_exit);
generated by cgit v1.2.2 (git 2.25.0) at 2024-12-26 12:17:09 -0500