1 | /* |
2 | * Atheros CARL9170 driver |
3 | * |
4 | * USB - frontend |
5 | * |
6 | * Copyright 2008, Johannes Berg <johannes@sipsolutions.net> |
7 | * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com> |
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/slab.h> |
42 | #include <linux/usb.h> |
43 | #include <linux/firmware.h> |
44 | #include <linux/etherdevice.h> |
45 | #include <linux/device.h> |
46 | #include <net/mac80211.h> |
47 | #include "carl9170.h" |
48 | #include "cmd.h" |
49 | #include "hw.h" |
50 | #include "fwcmd.h" |
51 | |
52 | MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>" ); |
53 | MODULE_AUTHOR("Christian Lamparter <chunkeey@googlemail.com>" ); |
54 | MODULE_LICENSE("GPL" ); |
55 | MODULE_DESCRIPTION("Atheros AR9170 802.11n USB wireless" ); |
56 | MODULE_FIRMWARE(CARL9170FW_NAME); |
57 | MODULE_ALIAS("ar9170usb" ); |
58 | MODULE_ALIAS("arusb_lnx" ); |
59 | |
60 | /* |
61 | * Note: |
62 | * |
63 | * Always update our wiki's device list (located at: |
64 | * https://wireless.wiki.kernel.org/en/users/Drivers/ar9170/devices ), |
65 | * whenever you add a new device. |
66 | */ |
67 | static const struct usb_device_id carl9170_usb_ids[] = { |
68 | /* Atheros 9170 */ |
69 | { USB_DEVICE(0x0cf3, 0x9170) }, |
70 | /* Atheros TG121N */ |
71 | { USB_DEVICE(0x0cf3, 0x1001) }, |
72 | /* TP-Link TL-WN821N v2 */ |
73 | { USB_DEVICE(0x0cf3, 0x1002), .driver_info = CARL9170_WPS_BUTTON | |
74 | CARL9170_ONE_LED }, |
75 | /* 3Com Dual Band 802.11n USB Adapter */ |
76 | { USB_DEVICE(0x0cf3, 0x1010) }, |
77 | /* H3C Dual Band 802.11n USB Adapter */ |
78 | { USB_DEVICE(0x0cf3, 0x1011) }, |
79 | /* Cace Airpcap NX */ |
80 | { USB_DEVICE(0xcace, 0x0300) }, |
81 | /* D-Link DWA 160 A1 */ |
82 | { USB_DEVICE(0x07d1, 0x3c10) }, |
83 | /* D-Link DWA 160 A2 */ |
84 | { USB_DEVICE(0x07d1, 0x3a09) }, |
85 | /* D-Link DWA 130 D */ |
86 | { USB_DEVICE(0x07d1, 0x3a0f) }, |
87 | /* Netgear WNA1000 */ |
88 | { USB_DEVICE(0x0846, 0x9040) }, |
89 | /* Netgear WNDA3100 (v1) */ |
90 | { USB_DEVICE(0x0846, 0x9010) }, |
91 | /* Netgear WN111 v2 */ |
92 | { USB_DEVICE(0x0846, 0x9001), .driver_info = CARL9170_ONE_LED }, |
93 | /* Zydas ZD1221 */ |
94 | { USB_DEVICE(0x0ace, 0x1221) }, |
95 | /* Proxim ORiNOCO 802.11n USB */ |
96 | { USB_DEVICE(0x1435, 0x0804) }, |
97 | /* WNC Generic 11n USB Dongle */ |
98 | { USB_DEVICE(0x1435, 0x0326) }, |
99 | /* ZyXEL NWD271N */ |
100 | { USB_DEVICE(0x0586, 0x3417) }, |
101 | /* Z-Com UB81 BG */ |
102 | { USB_DEVICE(0x0cde, 0x0023) }, |
103 | /* Z-Com UB82 ABG */ |
104 | { USB_DEVICE(0x0cde, 0x0026) }, |
105 | /* Sphairon Homelink 1202 */ |
106 | { USB_DEVICE(0x0cde, 0x0027) }, |
107 | /* Arcadyan WN7512 */ |
108 | { USB_DEVICE(0x083a, 0xf522) }, |
109 | /* Planex GWUS300 */ |
110 | { USB_DEVICE(0x2019, 0x5304) }, |
111 | /* IO-Data WNGDNUS2 */ |
112 | { USB_DEVICE(0x04bb, 0x093f) }, |
113 | /* NEC WL300NU-G */ |
114 | { USB_DEVICE(0x0409, 0x0249) }, |
115 | /* NEC WL300NU-AG */ |
116 | { USB_DEVICE(0x0409, 0x02b4) }, |
117 | /* AVM FRITZ!WLAN USB Stick N */ |
118 | { USB_DEVICE(0x057c, 0x8401) }, |
119 | /* AVM FRITZ!WLAN USB Stick N 2.4 */ |
120 | { USB_DEVICE(0x057c, 0x8402) }, |
121 | /* Qwest/Actiontec 802AIN Wireless N USB Network Adapter */ |
122 | { USB_DEVICE(0x1668, 0x1200) }, |
123 | /* Airlive X.USB a/b/g/n */ |
124 | { USB_DEVICE(0x1b75, 0x9170) }, |
125 | |
126 | /* terminate */ |
127 | {} |
128 | }; |
129 | MODULE_DEVICE_TABLE(usb, carl9170_usb_ids); |
130 | |
131 | static struct usb_driver carl9170_driver; |
132 | |
133 | static void carl9170_usb_submit_data_urb(struct ar9170 *ar) |
134 | { |
135 | struct urb *urb; |
136 | int err; |
137 | |
138 | if (atomic_inc_return(v: &ar->tx_anch_urbs) > AR9170_NUM_TX_URBS) |
139 | goto err_acc; |
140 | |
141 | urb = usb_get_from_anchor(anchor: &ar->tx_wait); |
142 | if (!urb) |
143 | goto err_acc; |
144 | |
145 | usb_anchor_urb(urb, anchor: &ar->tx_anch); |
146 | |
147 | err = usb_submit_urb(urb, GFP_ATOMIC); |
148 | if (unlikely(err)) { |
149 | if (net_ratelimit()) { |
150 | dev_err(&ar->udev->dev, "tx submit failed (%d)\n" , |
151 | urb->status); |
152 | } |
153 | |
154 | usb_unanchor_urb(urb); |
155 | usb_anchor_urb(urb, anchor: &ar->tx_err); |
156 | } |
157 | |
158 | usb_free_urb(urb); |
159 | |
160 | if (likely(err == 0)) |
161 | return; |
162 | |
163 | err_acc: |
164 | atomic_dec(v: &ar->tx_anch_urbs); |
165 | } |
166 | |
167 | static void carl9170_usb_tx_data_complete(struct urb *urb) |
168 | { |
169 | struct ar9170 *ar = usb_get_intfdata(intf: usb_ifnum_to_if(dev: urb->dev, ifnum: 0)); |
170 | |
171 | if (WARN_ON_ONCE(!ar)) { |
172 | dev_kfree_skb_irq(skb: urb->context); |
173 | return; |
174 | } |
175 | |
176 | atomic_dec(v: &ar->tx_anch_urbs); |
177 | |
178 | switch (urb->status) { |
179 | /* everything is fine */ |
180 | case 0: |
181 | carl9170_tx_callback(ar, skb: urb->context); |
182 | break; |
183 | |
184 | /* disconnect */ |
185 | case -ENOENT: |
186 | case -ECONNRESET: |
187 | case -ENODEV: |
188 | case -ESHUTDOWN: |
189 | /* |
190 | * Defer the frame clean-up to the tasklet worker. |
191 | * This is necessary, because carl9170_tx_drop |
192 | * does not work in an irqsave context. |
193 | */ |
194 | usb_anchor_urb(urb, anchor: &ar->tx_err); |
195 | return; |
196 | |
197 | /* a random transmission error has occurred? */ |
198 | default: |
199 | if (net_ratelimit()) { |
200 | dev_err(&ar->udev->dev, "tx failed (%d)\n" , |
201 | urb->status); |
202 | } |
203 | |
204 | usb_anchor_urb(urb, anchor: &ar->tx_err); |
205 | break; |
206 | } |
207 | |
208 | if (likely(IS_STARTED(ar))) |
209 | carl9170_usb_submit_data_urb(ar); |
210 | } |
211 | |
212 | static int carl9170_usb_submit_cmd_urb(struct ar9170 *ar) |
213 | { |
214 | struct urb *urb; |
215 | int err; |
216 | |
217 | if (atomic_inc_return(v: &ar->tx_cmd_urbs) != 1) { |
218 | atomic_dec(v: &ar->tx_cmd_urbs); |
219 | return 0; |
220 | } |
221 | |
222 | urb = usb_get_from_anchor(anchor: &ar->tx_cmd); |
223 | if (!urb) { |
224 | atomic_dec(v: &ar->tx_cmd_urbs); |
225 | return 0; |
226 | } |
227 | |
228 | usb_anchor_urb(urb, anchor: &ar->tx_anch); |
229 | err = usb_submit_urb(urb, GFP_ATOMIC); |
230 | if (unlikely(err)) { |
231 | usb_unanchor_urb(urb); |
232 | atomic_dec(v: &ar->tx_cmd_urbs); |
233 | } |
234 | usb_free_urb(urb); |
235 | |
236 | return err; |
237 | } |
238 | |
239 | static void carl9170_usb_cmd_complete(struct urb *urb) |
240 | { |
241 | struct ar9170 *ar = urb->context; |
242 | int err = 0; |
243 | |
244 | if (WARN_ON_ONCE(!ar)) |
245 | return; |
246 | |
247 | atomic_dec(v: &ar->tx_cmd_urbs); |
248 | |
249 | switch (urb->status) { |
250 | /* everything is fine */ |
251 | case 0: |
252 | break; |
253 | |
254 | /* disconnect */ |
255 | case -ENOENT: |
256 | case -ECONNRESET: |
257 | case -ENODEV: |
258 | case -ESHUTDOWN: |
259 | return; |
260 | |
261 | default: |
262 | err = urb->status; |
263 | break; |
264 | } |
265 | |
266 | if (!IS_INITIALIZED(ar)) |
267 | return; |
268 | |
269 | if (err) |
270 | dev_err(&ar->udev->dev, "submit cmd cb failed (%d).\n" , err); |
271 | |
272 | err = carl9170_usb_submit_cmd_urb(ar); |
273 | if (err) |
274 | dev_err(&ar->udev->dev, "submit cmd failed (%d).\n" , err); |
275 | } |
276 | |
277 | static void carl9170_usb_rx_irq_complete(struct urb *urb) |
278 | { |
279 | struct ar9170 *ar = urb->context; |
280 | |
281 | if (WARN_ON_ONCE(!ar)) |
282 | return; |
283 | |
284 | switch (urb->status) { |
285 | /* everything is fine */ |
286 | case 0: |
287 | break; |
288 | |
289 | /* disconnect */ |
290 | case -ENOENT: |
291 | case -ECONNRESET: |
292 | case -ENODEV: |
293 | case -ESHUTDOWN: |
294 | return; |
295 | |
296 | default: |
297 | goto resubmit; |
298 | } |
299 | |
300 | /* |
301 | * While the carl9170 firmware does not use this EP, the |
302 | * firmware loader in the EEPROM unfortunately does. |
303 | * Therefore we need to be ready to handle out-of-band |
304 | * responses and traps in case the firmware crashed and |
305 | * the loader took over again. |
306 | */ |
307 | carl9170_handle_command_response(ar, buf: urb->transfer_buffer, |
308 | len: urb->actual_length); |
309 | |
310 | resubmit: |
311 | usb_anchor_urb(urb, anchor: &ar->rx_anch); |
312 | if (unlikely(usb_submit_urb(urb, GFP_ATOMIC))) |
313 | usb_unanchor_urb(urb); |
314 | } |
315 | |
316 | static int carl9170_usb_submit_rx_urb(struct ar9170 *ar, gfp_t gfp) |
317 | { |
318 | struct urb *urb; |
319 | int err = 0, runs = 0; |
320 | |
321 | while ((atomic_read(v: &ar->rx_anch_urbs) < AR9170_NUM_RX_URBS) && |
322 | (runs++ < AR9170_NUM_RX_URBS)) { |
323 | err = -ENOSPC; |
324 | urb = usb_get_from_anchor(anchor: &ar->rx_pool); |
325 | if (urb) { |
326 | usb_anchor_urb(urb, anchor: &ar->rx_anch); |
327 | err = usb_submit_urb(urb, mem_flags: gfp); |
328 | if (unlikely(err)) { |
329 | usb_unanchor_urb(urb); |
330 | usb_anchor_urb(urb, anchor: &ar->rx_pool); |
331 | } else { |
332 | atomic_dec(v: &ar->rx_pool_urbs); |
333 | atomic_inc(v: &ar->rx_anch_urbs); |
334 | } |
335 | usb_free_urb(urb); |
336 | } |
337 | } |
338 | |
339 | return err; |
340 | } |
341 | |
342 | static void carl9170_usb_rx_work(struct ar9170 *ar) |
343 | { |
344 | struct urb *urb; |
345 | int i; |
346 | |
347 | for (i = 0; i < AR9170_NUM_RX_URBS_POOL; i++) { |
348 | urb = usb_get_from_anchor(anchor: &ar->rx_work); |
349 | if (!urb) |
350 | break; |
351 | |
352 | atomic_dec(v: &ar->rx_work_urbs); |
353 | if (IS_INITIALIZED(ar)) { |
354 | carl9170_rx(ar, buf: urb->transfer_buffer, |
355 | len: urb->actual_length); |
356 | } |
357 | |
358 | usb_anchor_urb(urb, anchor: &ar->rx_pool); |
359 | atomic_inc(v: &ar->rx_pool_urbs); |
360 | |
361 | usb_free_urb(urb); |
362 | |
363 | carl9170_usb_submit_rx_urb(ar, GFP_ATOMIC); |
364 | } |
365 | } |
366 | |
367 | void carl9170_usb_handle_tx_err(struct ar9170 *ar) |
368 | { |
369 | struct urb *urb; |
370 | |
371 | while ((urb = usb_get_from_anchor(anchor: &ar->tx_err))) { |
372 | struct sk_buff *skb = urb->context; |
373 | |
374 | carl9170_tx_drop(ar, skb); |
375 | carl9170_tx_callback(ar, skb); |
376 | usb_free_urb(urb); |
377 | } |
378 | } |
379 | |
380 | static void carl9170_usb_tasklet(struct tasklet_struct *t) |
381 | { |
382 | struct ar9170 *ar = from_tasklet(ar, t, usb_tasklet); |
383 | |
384 | if (!IS_INITIALIZED(ar)) |
385 | return; |
386 | |
387 | carl9170_usb_rx_work(ar); |
388 | |
389 | /* |
390 | * Strictly speaking: The tx scheduler is not part of the USB system. |
391 | * But the rx worker returns frames back to the mac80211-stack and |
392 | * this is the _perfect_ place to generate the next transmissions. |
393 | */ |
394 | if (IS_STARTED(ar)) |
395 | carl9170_tx_scheduler(ar); |
396 | } |
397 | |
398 | static void carl9170_usb_rx_complete(struct urb *urb) |
399 | { |
400 | struct ar9170 *ar = urb->context; |
401 | int err; |
402 | |
403 | if (WARN_ON_ONCE(!ar)) |
404 | return; |
405 | |
406 | atomic_dec(v: &ar->rx_anch_urbs); |
407 | |
408 | switch (urb->status) { |
409 | case 0: |
410 | /* rx path */ |
411 | usb_anchor_urb(urb, anchor: &ar->rx_work); |
412 | atomic_inc(v: &ar->rx_work_urbs); |
413 | break; |
414 | |
415 | case -ENOENT: |
416 | case -ECONNRESET: |
417 | case -ENODEV: |
418 | case -ESHUTDOWN: |
419 | /* handle disconnect events*/ |
420 | return; |
421 | |
422 | default: |
423 | /* handle all other errors */ |
424 | usb_anchor_urb(urb, anchor: &ar->rx_pool); |
425 | atomic_inc(v: &ar->rx_pool_urbs); |
426 | break; |
427 | } |
428 | |
429 | err = carl9170_usb_submit_rx_urb(ar, GFP_ATOMIC); |
430 | if (unlikely(err)) { |
431 | /* |
432 | * usb_submit_rx_urb reported a problem. |
433 | * In case this is due to a rx buffer shortage, |
434 | * elevate the tasklet worker priority to |
435 | * the highest available level. |
436 | */ |
437 | tasklet_hi_schedule(t: &ar->usb_tasklet); |
438 | |
439 | if (atomic_read(v: &ar->rx_anch_urbs) == 0) { |
440 | /* |
441 | * The system is too slow to cope with |
442 | * the enormous workload. We have simply |
443 | * run out of active rx urbs and this |
444 | * unfortunately leads to an unpredictable |
445 | * device. |
446 | */ |
447 | |
448 | ieee80211_queue_work(hw: ar->hw, work: &ar->ping_work); |
449 | } |
450 | } else { |
451 | /* |
452 | * Using anything less than _high_ priority absolutely |
453 | * kills the rx performance my UP-System... |
454 | */ |
455 | tasklet_hi_schedule(t: &ar->usb_tasklet); |
456 | } |
457 | } |
458 | |
459 | static struct urb *carl9170_usb_alloc_rx_urb(struct ar9170 *ar, gfp_t gfp) |
460 | { |
461 | struct urb *urb; |
462 | void *buf; |
463 | |
464 | buf = kmalloc(size: ar->fw.rx_size, flags: gfp); |
465 | if (!buf) |
466 | return NULL; |
467 | |
468 | urb = usb_alloc_urb(iso_packets: 0, mem_flags: gfp); |
469 | if (!urb) { |
470 | kfree(objp: buf); |
471 | return NULL; |
472 | } |
473 | |
474 | usb_fill_bulk_urb(urb, dev: ar->udev, usb_rcvbulkpipe(ar->udev, |
475 | AR9170_USB_EP_RX), transfer_buffer: buf, buffer_length: ar->fw.rx_size, |
476 | complete_fn: carl9170_usb_rx_complete, context: ar); |
477 | |
478 | urb->transfer_flags |= URB_FREE_BUFFER; |
479 | |
480 | return urb; |
481 | } |
482 | |
483 | static int carl9170_usb_send_rx_irq_urb(struct ar9170 *ar) |
484 | { |
485 | struct urb *urb = NULL; |
486 | void *ibuf; |
487 | int err = -ENOMEM; |
488 | |
489 | urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
490 | if (!urb) |
491 | goto out; |
492 | |
493 | ibuf = kmalloc(AR9170_USB_EP_CTRL_MAX, GFP_KERNEL); |
494 | if (!ibuf) |
495 | goto out; |
496 | |
497 | usb_fill_int_urb(urb, dev: ar->udev, usb_rcvintpipe(ar->udev, |
498 | AR9170_USB_EP_IRQ), transfer_buffer: ibuf, AR9170_USB_EP_CTRL_MAX, |
499 | complete_fn: carl9170_usb_rx_irq_complete, context: ar, interval: 1); |
500 | |
501 | urb->transfer_flags |= URB_FREE_BUFFER; |
502 | |
503 | usb_anchor_urb(urb, anchor: &ar->rx_anch); |
504 | err = usb_submit_urb(urb, GFP_KERNEL); |
505 | if (err) |
506 | usb_unanchor_urb(urb); |
507 | |
508 | out: |
509 | usb_free_urb(urb); |
510 | return err; |
511 | } |
512 | |
513 | static int carl9170_usb_init_rx_bulk_urbs(struct ar9170 *ar) |
514 | { |
515 | struct urb *urb; |
516 | int i, err = -EINVAL; |
517 | |
518 | /* |
519 | * The driver actively maintains a second shadow |
520 | * pool for inactive, but fully-prepared rx urbs. |
521 | * |
522 | * The pool should help the driver to master huge |
523 | * workload spikes without running the risk of |
524 | * undersupplying the hardware or wasting time by |
525 | * processing rx data (streams) inside the urb |
526 | * completion (hardirq context). |
527 | */ |
528 | for (i = 0; i < AR9170_NUM_RX_URBS_POOL; i++) { |
529 | urb = carl9170_usb_alloc_rx_urb(ar, GFP_KERNEL); |
530 | if (!urb) { |
531 | err = -ENOMEM; |
532 | goto err_out; |
533 | } |
534 | |
535 | usb_anchor_urb(urb, anchor: &ar->rx_pool); |
536 | atomic_inc(v: &ar->rx_pool_urbs); |
537 | usb_free_urb(urb); |
538 | } |
539 | |
540 | err = carl9170_usb_submit_rx_urb(ar, GFP_KERNEL); |
541 | if (err) |
542 | goto err_out; |
543 | |
544 | /* the device now waiting for the firmware. */ |
545 | carl9170_set_state_when(ar, min: CARL9170_STOPPED, newstate: CARL9170_IDLE); |
546 | return 0; |
547 | |
548 | err_out: |
549 | |
550 | usb_scuttle_anchored_urbs(anchor: &ar->rx_pool); |
551 | usb_scuttle_anchored_urbs(anchor: &ar->rx_work); |
552 | usb_kill_anchored_urbs(anchor: &ar->rx_anch); |
553 | return err; |
554 | } |
555 | |
556 | static int carl9170_usb_flush(struct ar9170 *ar) |
557 | { |
558 | struct urb *urb; |
559 | int ret, err = 0; |
560 | |
561 | while ((urb = usb_get_from_anchor(anchor: &ar->tx_wait))) { |
562 | struct sk_buff *skb = urb->context; |
563 | carl9170_tx_drop(ar, skb); |
564 | carl9170_tx_callback(ar, skb); |
565 | usb_free_urb(urb); |
566 | } |
567 | |
568 | ret = usb_wait_anchor_empty_timeout(anchor: &ar->tx_cmd, timeout: 1000); |
569 | if (ret == 0) |
570 | err = -ETIMEDOUT; |
571 | |
572 | /* lets wait a while until the tx - queues are dried out */ |
573 | ret = usb_wait_anchor_empty_timeout(anchor: &ar->tx_anch, timeout: 1000); |
574 | if (ret == 0) |
575 | err = -ETIMEDOUT; |
576 | |
577 | usb_kill_anchored_urbs(anchor: &ar->tx_anch); |
578 | carl9170_usb_handle_tx_err(ar); |
579 | |
580 | return err; |
581 | } |
582 | |
583 | static void carl9170_usb_cancel_urbs(struct ar9170 *ar) |
584 | { |
585 | int err; |
586 | |
587 | carl9170_set_state(ar, newstate: CARL9170_UNKNOWN_STATE); |
588 | |
589 | err = carl9170_usb_flush(ar); |
590 | if (err) |
591 | dev_err(&ar->udev->dev, "stuck tx urbs!\n" ); |
592 | |
593 | usb_poison_anchored_urbs(anchor: &ar->tx_anch); |
594 | carl9170_usb_handle_tx_err(ar); |
595 | usb_poison_anchored_urbs(anchor: &ar->rx_anch); |
596 | |
597 | tasklet_kill(t: &ar->usb_tasklet); |
598 | |
599 | usb_scuttle_anchored_urbs(anchor: &ar->rx_work); |
600 | usb_scuttle_anchored_urbs(anchor: &ar->rx_pool); |
601 | usb_scuttle_anchored_urbs(anchor: &ar->tx_cmd); |
602 | } |
603 | |
604 | int __carl9170_exec_cmd(struct ar9170 *ar, struct carl9170_cmd *cmd, |
605 | const bool free_buf) |
606 | { |
607 | struct urb *urb; |
608 | int err = 0; |
609 | |
610 | if (!IS_INITIALIZED(ar)) { |
611 | err = -EPERM; |
612 | goto err_free; |
613 | } |
614 | |
615 | if (WARN_ON(cmd->hdr.len > CARL9170_MAX_CMD_LEN - 4)) { |
616 | err = -EINVAL; |
617 | goto err_free; |
618 | } |
619 | |
620 | urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC); |
621 | if (!urb) { |
622 | err = -ENOMEM; |
623 | goto err_free; |
624 | } |
625 | |
626 | if (ar->usb_ep_cmd_is_bulk) |
627 | usb_fill_bulk_urb(urb, dev: ar->udev, |
628 | usb_sndbulkpipe(ar->udev, AR9170_USB_EP_CMD), |
629 | transfer_buffer: cmd, buffer_length: cmd->hdr.len + 4, |
630 | complete_fn: carl9170_usb_cmd_complete, context: ar); |
631 | else |
632 | usb_fill_int_urb(urb, dev: ar->udev, |
633 | usb_sndintpipe(ar->udev, AR9170_USB_EP_CMD), |
634 | transfer_buffer: cmd, buffer_length: cmd->hdr.len + 4, |
635 | complete_fn: carl9170_usb_cmd_complete, context: ar, interval: 1); |
636 | |
637 | if (free_buf) |
638 | urb->transfer_flags |= URB_FREE_BUFFER; |
639 | |
640 | usb_anchor_urb(urb, anchor: &ar->tx_cmd); |
641 | usb_free_urb(urb); |
642 | |
643 | return carl9170_usb_submit_cmd_urb(ar); |
644 | |
645 | err_free: |
646 | if (free_buf) |
647 | kfree(objp: cmd); |
648 | |
649 | return err; |
650 | } |
651 | |
652 | int carl9170_exec_cmd(struct ar9170 *ar, const enum carl9170_cmd_oids cmd, |
653 | unsigned int plen, void *payload, unsigned int outlen, void *out) |
654 | { |
655 | int err = -ENOMEM; |
656 | unsigned long time_left; |
657 | |
658 | if (!IS_ACCEPTING_CMD(ar)) |
659 | return -EIO; |
660 | |
661 | if (!(cmd & CARL9170_CMD_ASYNC_FLAG)) |
662 | might_sleep(); |
663 | |
664 | ar->cmd.hdr.len = plen; |
665 | ar->cmd.hdr.cmd = cmd; |
666 | /* writing multiple regs fills this buffer already */ |
667 | if (plen && payload != (u8 *)(ar->cmd.data)) |
668 | memcpy(ar->cmd.data, payload, plen); |
669 | |
670 | spin_lock_bh(lock: &ar->cmd_lock); |
671 | ar->readbuf = out; |
672 | ar->readlen = outlen; |
673 | spin_unlock_bh(lock: &ar->cmd_lock); |
674 | |
675 | reinit_completion(x: &ar->cmd_wait); |
676 | err = __carl9170_exec_cmd(ar, cmd: &ar->cmd, free_buf: false); |
677 | |
678 | if (!(cmd & CARL9170_CMD_ASYNC_FLAG)) { |
679 | time_left = wait_for_completion_timeout(x: &ar->cmd_wait, HZ); |
680 | if (time_left == 0) { |
681 | err = -ETIMEDOUT; |
682 | goto err_unbuf; |
683 | } |
684 | |
685 | if (ar->readlen != outlen) { |
686 | err = -EMSGSIZE; |
687 | goto err_unbuf; |
688 | } |
689 | } |
690 | |
691 | return 0; |
692 | |
693 | err_unbuf: |
694 | /* Maybe the device was removed in the moment we were waiting? */ |
695 | if (IS_STARTED(ar)) { |
696 | dev_err(&ar->udev->dev, "no command feedback " |
697 | "received (%d).\n" , err); |
698 | |
699 | /* provide some maybe useful debug information */ |
700 | print_hex_dump_bytes("carl9170 cmd: " , DUMP_PREFIX_NONE, |
701 | &ar->cmd, plen + 4); |
702 | |
703 | carl9170_restart(ar, r: CARL9170_RR_COMMAND_TIMEOUT); |
704 | } |
705 | |
706 | /* invalidate to avoid completing the next command prematurely */ |
707 | spin_lock_bh(lock: &ar->cmd_lock); |
708 | ar->readbuf = NULL; |
709 | ar->readlen = 0; |
710 | spin_unlock_bh(lock: &ar->cmd_lock); |
711 | |
712 | return err; |
713 | } |
714 | |
715 | void carl9170_usb_tx(struct ar9170 *ar, struct sk_buff *skb) |
716 | { |
717 | struct urb *urb; |
718 | struct ar9170_stream *tx_stream; |
719 | void *data; |
720 | unsigned int len; |
721 | |
722 | if (!IS_STARTED(ar)) |
723 | goto err_drop; |
724 | |
725 | urb = usb_alloc_urb(iso_packets: 0, GFP_ATOMIC); |
726 | if (!urb) |
727 | goto err_drop; |
728 | |
729 | if (ar->fw.tx_stream) { |
730 | tx_stream = (void *) (skb->data - sizeof(*tx_stream)); |
731 | |
732 | len = skb->len + sizeof(*tx_stream); |
733 | tx_stream->length = cpu_to_le16(len); |
734 | tx_stream->tag = cpu_to_le16(AR9170_TX_STREAM_TAG); |
735 | data = tx_stream; |
736 | } else { |
737 | data = skb->data; |
738 | len = skb->len; |
739 | } |
740 | |
741 | usb_fill_bulk_urb(urb, dev: ar->udev, usb_sndbulkpipe(ar->udev, |
742 | AR9170_USB_EP_TX), transfer_buffer: data, buffer_length: len, |
743 | complete_fn: carl9170_usb_tx_data_complete, context: skb); |
744 | |
745 | urb->transfer_flags |= URB_ZERO_PACKET; |
746 | |
747 | usb_anchor_urb(urb, anchor: &ar->tx_wait); |
748 | |
749 | usb_free_urb(urb); |
750 | |
751 | carl9170_usb_submit_data_urb(ar); |
752 | return; |
753 | |
754 | err_drop: |
755 | carl9170_tx_drop(ar, skb); |
756 | carl9170_tx_callback(ar, skb); |
757 | } |
758 | |
759 | static void carl9170_release_firmware(struct ar9170 *ar) |
760 | { |
761 | if (ar->fw.fw) { |
762 | release_firmware(fw: ar->fw.fw); |
763 | memset(&ar->fw, 0, sizeof(ar->fw)); |
764 | } |
765 | } |
766 | |
767 | void carl9170_usb_stop(struct ar9170 *ar) |
768 | { |
769 | int ret; |
770 | |
771 | carl9170_set_state_when(ar, min: CARL9170_IDLE, newstate: CARL9170_STOPPED); |
772 | |
773 | ret = carl9170_usb_flush(ar); |
774 | if (ret) |
775 | dev_err(&ar->udev->dev, "kill pending tx urbs.\n" ); |
776 | |
777 | usb_poison_anchored_urbs(anchor: &ar->tx_anch); |
778 | carl9170_usb_handle_tx_err(ar); |
779 | |
780 | /* kill any pending command */ |
781 | spin_lock_bh(lock: &ar->cmd_lock); |
782 | ar->readlen = 0; |
783 | spin_unlock_bh(lock: &ar->cmd_lock); |
784 | complete(&ar->cmd_wait); |
785 | |
786 | /* |
787 | * Note: |
788 | * So far we freed all tx urbs, but we won't dare to touch any rx urbs. |
789 | * Else we would end up with a unresponsive device... |
790 | */ |
791 | } |
792 | |
793 | int carl9170_usb_open(struct ar9170 *ar) |
794 | { |
795 | usb_unpoison_anchored_urbs(anchor: &ar->tx_anch); |
796 | |
797 | carl9170_set_state_when(ar, min: CARL9170_STOPPED, newstate: CARL9170_IDLE); |
798 | return 0; |
799 | } |
800 | |
801 | static int carl9170_usb_load_firmware(struct ar9170 *ar) |
802 | { |
803 | const u8 *data; |
804 | u8 *buf; |
805 | unsigned int transfer; |
806 | size_t len; |
807 | u32 addr; |
808 | int err = 0; |
809 | |
810 | buf = kmalloc(size: 4096, GFP_KERNEL); |
811 | if (!buf) { |
812 | err = -ENOMEM; |
813 | goto err_out; |
814 | } |
815 | |
816 | data = ar->fw.fw->data; |
817 | len = ar->fw.fw->size; |
818 | addr = ar->fw.address; |
819 | |
820 | /* this removes the miniboot image */ |
821 | data += ar->fw.offset; |
822 | len -= ar->fw.offset; |
823 | |
824 | while (len) { |
825 | transfer = min_t(unsigned int, len, 4096u); |
826 | memcpy(buf, data, transfer); |
827 | |
828 | err = usb_control_msg(dev: ar->udev, usb_sndctrlpipe(ar->udev, 0), |
829 | request: 0x30 /* FW DL */, requesttype: 0x40 | USB_DIR_OUT, |
830 | value: addr >> 8, index: 0, data: buf, size: transfer, timeout: 100); |
831 | |
832 | if (err < 0) { |
833 | kfree(objp: buf); |
834 | goto err_out; |
835 | } |
836 | |
837 | len -= transfer; |
838 | data += transfer; |
839 | addr += transfer; |
840 | } |
841 | kfree(objp: buf); |
842 | |
843 | err = usb_control_msg(dev: ar->udev, usb_sndctrlpipe(ar->udev, 0), |
844 | request: 0x31 /* FW DL COMPLETE */, |
845 | requesttype: 0x40 | USB_DIR_OUT, value: 0, index: 0, NULL, size: 0, timeout: 200); |
846 | |
847 | if (wait_for_completion_timeout(x: &ar->fw_boot_wait, HZ) == 0) { |
848 | err = -ETIMEDOUT; |
849 | goto err_out; |
850 | } |
851 | |
852 | err = carl9170_echo_test(ar, v: 0x4a110123); |
853 | if (err) |
854 | goto err_out; |
855 | |
856 | /* now, start the command response counter */ |
857 | ar->cmd_seq = -1; |
858 | |
859 | return 0; |
860 | |
861 | err_out: |
862 | dev_err(&ar->udev->dev, "firmware upload failed (%d).\n" , err); |
863 | return err; |
864 | } |
865 | |
866 | int carl9170_usb_restart(struct ar9170 *ar) |
867 | { |
868 | int err = 0; |
869 | |
870 | if (ar->intf->condition != USB_INTERFACE_BOUND) |
871 | return 0; |
872 | |
873 | /* |
874 | * Disable the command response sequence counter check. |
875 | * We already know that the device/firmware is in a bad state. |
876 | * So, no extra points are awarded to anyone who reminds the |
877 | * driver about that. |
878 | */ |
879 | ar->cmd_seq = -2; |
880 | |
881 | err = carl9170_reboot(ar); |
882 | |
883 | carl9170_usb_stop(ar); |
884 | |
885 | if (err) |
886 | goto err_out; |
887 | |
888 | tasklet_schedule(t: &ar->usb_tasklet); |
889 | |
890 | /* The reboot procedure can take quite a while to complete. */ |
891 | msleep(msecs: 1100); |
892 | |
893 | err = carl9170_usb_open(ar); |
894 | if (err) |
895 | goto err_out; |
896 | |
897 | err = carl9170_usb_load_firmware(ar); |
898 | if (err) |
899 | goto err_out; |
900 | |
901 | return 0; |
902 | |
903 | err_out: |
904 | carl9170_usb_cancel_urbs(ar); |
905 | return err; |
906 | } |
907 | |
908 | void carl9170_usb_reset(struct ar9170 *ar) |
909 | { |
910 | /* |
911 | * This is the last resort to get the device going again |
912 | * without any *user replugging action*. |
913 | * |
914 | * But there is a catch: usb_reset really is like a physical |
915 | * *reconnect*. The mac80211 state will be lost in the process. |
916 | * Therefore a userspace application, which is monitoring |
917 | * the link must step in. |
918 | */ |
919 | carl9170_usb_cancel_urbs(ar); |
920 | |
921 | carl9170_usb_stop(ar); |
922 | |
923 | usb_queue_reset_device(dev: ar->intf); |
924 | } |
925 | |
926 | static int carl9170_usb_init_device(struct ar9170 *ar) |
927 | { |
928 | int err; |
929 | |
930 | /* |
931 | * The carl9170 firmware let's the driver know when it's |
932 | * ready for action. But we have to be prepared to gracefully |
933 | * handle all spurious [flushed] messages after each (re-)boot. |
934 | * Thus the command response counter remains disabled until it |
935 | * can be safely synchronized. |
936 | */ |
937 | ar->cmd_seq = -2; |
938 | |
939 | err = carl9170_usb_send_rx_irq_urb(ar); |
940 | if (err) |
941 | goto err_out; |
942 | |
943 | err = carl9170_usb_init_rx_bulk_urbs(ar); |
944 | if (err) |
945 | goto err_unrx; |
946 | |
947 | err = carl9170_usb_open(ar); |
948 | if (err) |
949 | goto err_unrx; |
950 | |
951 | mutex_lock(&ar->mutex); |
952 | err = carl9170_usb_load_firmware(ar); |
953 | mutex_unlock(lock: &ar->mutex); |
954 | if (err) |
955 | goto err_stop; |
956 | |
957 | return 0; |
958 | |
959 | err_stop: |
960 | carl9170_usb_stop(ar); |
961 | |
962 | err_unrx: |
963 | carl9170_usb_cancel_urbs(ar); |
964 | |
965 | err_out: |
966 | return err; |
967 | } |
968 | |
969 | static void carl9170_usb_firmware_failed(struct ar9170 *ar) |
970 | { |
971 | /* Store a copies of the usb_interface and usb_device pointer locally. |
972 | * This is because release_driver initiates carl9170_usb_disconnect, |
973 | * which in turn frees our driver context (ar). |
974 | */ |
975 | struct usb_interface *intf = ar->intf; |
976 | struct usb_device *udev = ar->udev; |
977 | |
978 | complete(&ar->fw_load_wait); |
979 | /* at this point 'ar' could be already freed. Don't use it anymore */ |
980 | ar = NULL; |
981 | |
982 | /* unbind anything failed */ |
983 | usb_lock_device(udev); |
984 | usb_driver_release_interface(driver: &carl9170_driver, iface: intf); |
985 | usb_unlock_device(udev); |
986 | |
987 | usb_put_intf(intf); |
988 | } |
989 | |
990 | static void carl9170_usb_firmware_finish(struct ar9170 *ar) |
991 | { |
992 | struct usb_interface *intf = ar->intf; |
993 | int err; |
994 | |
995 | err = carl9170_parse_firmware(ar); |
996 | if (err) |
997 | goto err_freefw; |
998 | |
999 | err = carl9170_usb_init_device(ar); |
1000 | if (err) |
1001 | goto err_freefw; |
1002 | |
1003 | err = carl9170_register(ar); |
1004 | |
1005 | carl9170_usb_stop(ar); |
1006 | if (err) |
1007 | goto err_unrx; |
1008 | |
1009 | complete(&ar->fw_load_wait); |
1010 | usb_put_intf(intf); |
1011 | return; |
1012 | |
1013 | err_unrx: |
1014 | carl9170_usb_cancel_urbs(ar); |
1015 | |
1016 | err_freefw: |
1017 | carl9170_release_firmware(ar); |
1018 | carl9170_usb_firmware_failed(ar); |
1019 | } |
1020 | |
1021 | static void carl9170_usb_firmware_step2(const struct firmware *fw, |
1022 | void *context) |
1023 | { |
1024 | struct ar9170 *ar = context; |
1025 | |
1026 | if (fw) { |
1027 | ar->fw.fw = fw; |
1028 | carl9170_usb_firmware_finish(ar); |
1029 | return; |
1030 | } |
1031 | |
1032 | dev_err(&ar->udev->dev, "firmware not found.\n" ); |
1033 | carl9170_usb_firmware_failed(ar); |
1034 | } |
1035 | |
1036 | static int carl9170_usb_probe(struct usb_interface *intf, |
1037 | const struct usb_device_id *id) |
1038 | { |
1039 | struct usb_endpoint_descriptor *ep; |
1040 | struct ar9170 *ar; |
1041 | struct usb_device *udev; |
1042 | int i, err; |
1043 | |
1044 | err = usb_reset_device(interface_to_usbdev(intf)); |
1045 | if (err) |
1046 | return err; |
1047 | |
1048 | ar = carl9170_alloc(priv_size: sizeof(*ar)); |
1049 | if (IS_ERR(ptr: ar)) |
1050 | return PTR_ERR(ptr: ar); |
1051 | |
1052 | udev = interface_to_usbdev(intf); |
1053 | ar->udev = udev; |
1054 | ar->intf = intf; |
1055 | ar->features = id->driver_info; |
1056 | |
1057 | /* We need to remember the type of endpoint 4 because it differs |
1058 | * between high- and full-speed configuration. The high-speed |
1059 | * configuration specifies it as interrupt and the full-speed |
1060 | * configuration as bulk endpoint. This information is required |
1061 | * later when sending urbs to that endpoint. |
1062 | */ |
1063 | for (i = 0; i < intf->cur_altsetting->desc.bNumEndpoints; ++i) { |
1064 | ep = &intf->cur_altsetting->endpoint[i].desc; |
1065 | |
1066 | if (usb_endpoint_num(epd: ep) == AR9170_USB_EP_CMD && |
1067 | usb_endpoint_dir_out(epd: ep) && |
1068 | usb_endpoint_type(epd: ep) == USB_ENDPOINT_XFER_BULK) |
1069 | ar->usb_ep_cmd_is_bulk = true; |
1070 | } |
1071 | |
1072 | usb_set_intfdata(intf, data: ar); |
1073 | SET_IEEE80211_DEV(hw: ar->hw, dev: &intf->dev); |
1074 | |
1075 | init_usb_anchor(anchor: &ar->rx_anch); |
1076 | init_usb_anchor(anchor: &ar->rx_pool); |
1077 | init_usb_anchor(anchor: &ar->rx_work); |
1078 | init_usb_anchor(anchor: &ar->tx_wait); |
1079 | init_usb_anchor(anchor: &ar->tx_anch); |
1080 | init_usb_anchor(anchor: &ar->tx_cmd); |
1081 | init_usb_anchor(anchor: &ar->tx_err); |
1082 | init_completion(x: &ar->cmd_wait); |
1083 | init_completion(x: &ar->fw_boot_wait); |
1084 | init_completion(x: &ar->fw_load_wait); |
1085 | tasklet_setup(t: &ar->usb_tasklet, callback: carl9170_usb_tasklet); |
1086 | |
1087 | atomic_set(v: &ar->tx_cmd_urbs, i: 0); |
1088 | atomic_set(v: &ar->tx_anch_urbs, i: 0); |
1089 | atomic_set(v: &ar->rx_work_urbs, i: 0); |
1090 | atomic_set(v: &ar->rx_anch_urbs, i: 0); |
1091 | atomic_set(v: &ar->rx_pool_urbs, i: 0); |
1092 | |
1093 | usb_get_intf(intf); |
1094 | |
1095 | carl9170_set_state(ar, newstate: CARL9170_STOPPED); |
1096 | |
1097 | err = request_firmware_nowait(THIS_MODULE, uevent: 1, CARL9170FW_NAME, |
1098 | device: &ar->udev->dev, GFP_KERNEL, context: ar, cont: carl9170_usb_firmware_step2); |
1099 | if (err) { |
1100 | usb_put_intf(intf); |
1101 | carl9170_free(ar); |
1102 | } |
1103 | return err; |
1104 | } |
1105 | |
1106 | static void carl9170_usb_disconnect(struct usb_interface *intf) |
1107 | { |
1108 | struct ar9170 *ar = usb_get_intfdata(intf); |
1109 | |
1110 | if (WARN_ON(!ar)) |
1111 | return; |
1112 | |
1113 | wait_for_completion(&ar->fw_load_wait); |
1114 | |
1115 | if (IS_INITIALIZED(ar)) { |
1116 | carl9170_reboot(ar); |
1117 | carl9170_usb_stop(ar); |
1118 | } |
1119 | |
1120 | carl9170_usb_cancel_urbs(ar); |
1121 | carl9170_unregister(ar); |
1122 | |
1123 | usb_set_intfdata(intf, NULL); |
1124 | |
1125 | carl9170_release_firmware(ar); |
1126 | carl9170_free(ar); |
1127 | } |
1128 | |
1129 | #ifdef CONFIG_PM |
1130 | static int carl9170_usb_suspend(struct usb_interface *intf, |
1131 | pm_message_t message) |
1132 | { |
1133 | struct ar9170 *ar = usb_get_intfdata(intf); |
1134 | |
1135 | if (!ar) |
1136 | return -ENODEV; |
1137 | |
1138 | carl9170_usb_cancel_urbs(ar); |
1139 | |
1140 | return 0; |
1141 | } |
1142 | |
1143 | static int carl9170_usb_resume(struct usb_interface *intf) |
1144 | { |
1145 | struct ar9170 *ar = usb_get_intfdata(intf); |
1146 | int err; |
1147 | |
1148 | if (!ar) |
1149 | return -ENODEV; |
1150 | |
1151 | usb_unpoison_anchored_urbs(anchor: &ar->rx_anch); |
1152 | carl9170_set_state(ar, newstate: CARL9170_STOPPED); |
1153 | |
1154 | /* |
1155 | * The USB documentation demands that [for suspend] all traffic |
1156 | * to and from the device has to stop. This would be fine, but |
1157 | * there's a catch: the device[usb phy] does not come back. |
1158 | * |
1159 | * Upon resume the firmware will "kill" itself and the |
1160 | * boot-code sorts out the magic voodoo. |
1161 | * Not very nice, but there's not much what could go wrong. |
1162 | */ |
1163 | msleep(msecs: 1100); |
1164 | |
1165 | err = carl9170_usb_init_device(ar); |
1166 | if (err) |
1167 | goto err_unrx; |
1168 | |
1169 | return 0; |
1170 | |
1171 | err_unrx: |
1172 | carl9170_usb_cancel_urbs(ar); |
1173 | |
1174 | return err; |
1175 | } |
1176 | #endif /* CONFIG_PM */ |
1177 | |
1178 | static struct usb_driver carl9170_driver = { |
1179 | .name = KBUILD_MODNAME, |
1180 | .probe = carl9170_usb_probe, |
1181 | .disconnect = carl9170_usb_disconnect, |
1182 | .id_table = carl9170_usb_ids, |
1183 | .soft_unbind = 1, |
1184 | #ifdef CONFIG_PM |
1185 | .suspend = carl9170_usb_suspend, |
1186 | .resume = carl9170_usb_resume, |
1187 | .reset_resume = carl9170_usb_resume, |
1188 | #endif /* CONFIG_PM */ |
1189 | .disable_hub_initiated_lpm = 1, |
1190 | }; |
1191 | |
1192 | module_usb_driver(carl9170_driver); |
1193 | |