?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
spi-topcliff-pch: add recovery processing in case wait-event timeout
[zen-stable.git] / drivers / net / wireless / ath / carl9170 / main.c
blobdb774212161bc820225fb9f14564302be55cc3be
1 /*
2 * Atheros CARL9170 driver
3 *
4 * mac80211 interaction code
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/init.h>
41 #include <linux/slab.h>
42 #include <linux/module.h>
43 #include <linux/etherdevice.h>
44 #include <linux/random.h>
45 #include <net/mac80211.h>
46 #include <net/cfg80211.h>
47 #include "hw.h"
48 #include "carl9170.h"
49 #include "cmd.h"
50
51 static bool modparam_nohwcrypt;
52 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, S_IRUGO);
53 MODULE_PARM_DESC(nohwcrypt, "Disable hardware crypto offload.");
54
55 int modparam_noht;
56 module_param_named(noht, modparam_noht, int, S_IRUGO);
57 MODULE_PARM_DESC(noht, "Disable MPDU aggregation.");
58
59 #define RATE(_bitrate, _hw_rate, _txpidx, _flags) { \
60 .bitrate = (_bitrate), \
61 .flags = (_flags), \
62 .hw_value = (_hw_rate) | (_txpidx) << 4, \
63 }
64
65 struct ieee80211_rate __carl9170_ratetable[] = {
66 RATE(10, 0, 0, 0),
67 RATE(20, 1, 1, IEEE80211_RATE_SHORT_PREAMBLE),
68 RATE(55, 2, 2, IEEE80211_RATE_SHORT_PREAMBLE),
69 RATE(110, 3, 3, IEEE80211_RATE_SHORT_PREAMBLE),
70 RATE(60, 0xb, 0, 0),
71 RATE(90, 0xf, 0, 0),
72 RATE(120, 0xa, 0, 0),
73 RATE(180, 0xe, 0, 0),
74 RATE(240, 0x9, 0, 0),
75 RATE(360, 0xd, 1, 0),
76 RATE(480, 0x8, 2, 0),
77 RATE(540, 0xc, 3, 0),
78 };
79 #undef RATE
80
81 #define carl9170_g_ratetable (__carl9170_ratetable + 0)
82 #define carl9170_g_ratetable_size 12
83 #define carl9170_a_ratetable (__carl9170_ratetable + 4)
84 #define carl9170_a_ratetable_size 8
85
86 /*
87 * NB: The hw_value is used as an index into the carl9170_phy_freq_params
88 * array in phy.c so that we don't have to do frequency lookups!
89 */
90 #define CHAN(_freq, _idx) { \
91 .center_freq = (_freq), \
92 .hw_value = (_idx), \
93 .max_power = 18, /* XXX */ \
94 }
95
96 static struct ieee80211_channel carl9170_2ghz_chantable[] = {
97 CHAN(2412, 0),
98 CHAN(2417, 1),
99 CHAN(2422, 2),
100 CHAN(2427, 3),
101 CHAN(2432, 4),
102 CHAN(2437, 5),
103 CHAN(2442, 6),
104 CHAN(2447, 7),
105 CHAN(2452, 8),
106 CHAN(2457, 9),
107 CHAN(2462, 10),
108 CHAN(2467, 11),
109 CHAN(2472, 12),
110 CHAN(2484, 13),
111 };
112
113 static struct ieee80211_channel carl9170_5ghz_chantable[] = {
114 CHAN(4920, 14),
115 CHAN(4940, 15),
116 CHAN(4960, 16),
117 CHAN(4980, 17),
118 CHAN(5040, 18),
119 CHAN(5060, 19),
120 CHAN(5080, 20),
121 CHAN(5180, 21),
122 CHAN(5200, 22),
123 CHAN(5220, 23),
124 CHAN(5240, 24),
125 CHAN(5260, 25),
126 CHAN(5280, 26),
127 CHAN(5300, 27),
128 CHAN(5320, 28),
129 CHAN(5500, 29),
130 CHAN(5520, 30),
131 CHAN(5540, 31),
132 CHAN(5560, 32),
133 CHAN(5580, 33),
134 CHAN(5600, 34),
135 CHAN(5620, 35),
136 CHAN(5640, 36),
137 CHAN(5660, 37),
138 CHAN(5680, 38),
139 CHAN(5700, 39),
140 CHAN(5745, 40),
141 CHAN(5765, 41),
142 CHAN(5785, 42),
143 CHAN(5805, 43),
144 CHAN(5825, 44),
145 CHAN(5170, 45),
146 CHAN(5190, 46),
147 CHAN(5210, 47),
148 CHAN(5230, 48),
149 };
150 #undef CHAN
151
152 #define CARL9170_HT_CAP \
153 { \
154 .ht_supported = true, \
155 .cap = IEEE80211_HT_CAP_MAX_AMSDU | \
156 IEEE80211_HT_CAP_SUP_WIDTH_20_40 | \
157 IEEE80211_HT_CAP_SGI_40 | \
158 IEEE80211_HT_CAP_DSSSCCK40 | \
159 IEEE80211_HT_CAP_SM_PS, \
160 .ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K, \
161 .ampdu_density = IEEE80211_HT_MPDU_DENSITY_8, \
162 .mcs = { \
163 .rx_mask = { 0xff, 0xff, 0, 0, 0x1, 0, 0, 0, 0, 0, }, \
164 .rx_highest = cpu_to_le16(300), \
165 .tx_params = IEEE80211_HT_MCS_TX_DEFINED, \
166 }, \
167 }
168
169 static struct ieee80211_supported_band carl9170_band_2GHz = {
170 .channels = carl9170_2ghz_chantable,
171 .n_channels = ARRAY_SIZE(carl9170_2ghz_chantable),
172 .bitrates = carl9170_g_ratetable,
173 .n_bitrates = carl9170_g_ratetable_size,
174 .ht_cap = CARL9170_HT_CAP,
175 };
176
177 static struct ieee80211_supported_band carl9170_band_5GHz = {
178 .channels = carl9170_5ghz_chantable,
179 .n_channels = ARRAY_SIZE(carl9170_5ghz_chantable),
180 .bitrates = carl9170_a_ratetable,
181 .n_bitrates = carl9170_a_ratetable_size,
182 .ht_cap = CARL9170_HT_CAP,
183 };
184
185 static void carl9170_ampdu_gc(struct ar9170 *ar)
186 {
187 struct carl9170_sta_tid *tid_info;
188 LIST_HEAD(tid_gc);
189
190 rcu_read_lock();
191 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
192 spin_lock_bh(&ar->tx_ampdu_list_lock);
193 if (tid_info->state == CARL9170_TID_STATE_SHUTDOWN) {
194 tid_info->state = CARL9170_TID_STATE_KILLED;
195 list_del_rcu(&tid_info->list);
196 ar->tx_ampdu_list_len--;
197 list_add_tail(&tid_info->tmp_list, &tid_gc);
198 }
199 spin_unlock_bh(&ar->tx_ampdu_list_lock);
200
201 }
202 rcu_assign_pointer(ar->tx_ampdu_iter, tid_info);
203 rcu_read_unlock();
204
205 synchronize_rcu();
206
207 while (!list_empty(&tid_gc)) {
208 struct sk_buff *skb;
209 tid_info = list_first_entry(&tid_gc, struct carl9170_sta_tid,
210 tmp_list);
211
212 while ((skb = __skb_dequeue(&tid_info->queue)))
213 carl9170_tx_status(ar, skb, false);
214
215 list_del_init(&tid_info->tmp_list);
216 kfree(tid_info);
217 }
218 }
219
220 static void carl9170_flush(struct ar9170 *ar, bool drop_queued)
221 {
222 if (drop_queued) {
223 int i;
224
225 /*
226 * We can only drop frames which have not been uploaded
227 * to the device yet.
228 */
229
230 for (i = 0; i < ar->hw->queues; i++) {
231 struct sk_buff *skb;
232
233 while ((skb = skb_dequeue(&ar->tx_pending[i]))) {
234 struct ieee80211_tx_info *info;
235
236 info = IEEE80211_SKB_CB(skb);
237 if (info->flags & IEEE80211_TX_CTL_AMPDU)
238 atomic_dec(&ar->tx_ampdu_upload);
239
240 carl9170_tx_status(ar, skb, false);
241 }
242 }
243 }
244
245 /* Wait for all other outstanding frames to timeout. */
246 if (atomic_read(&ar->tx_total_queued))
247 WARN_ON(wait_for_completion_timeout(&ar->tx_flush, HZ) == 0);
248 }
249
250 static void carl9170_flush_ba(struct ar9170 *ar)
251 {
252 struct sk_buff_head free;
253 struct carl9170_sta_tid *tid_info;
254 struct sk_buff *skb;
255
256 __skb_queue_head_init(&free);
257
258 rcu_read_lock();
259 spin_lock_bh(&ar->tx_ampdu_list_lock);
260 list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
261 if (tid_info->state > CARL9170_TID_STATE_SUSPEND) {
262 tid_info->state = CARL9170_TID_STATE_SUSPEND;
263
264 spin_lock(&tid_info->lock);
265 while ((skb = __skb_dequeue(&tid_info->queue)))
266 __skb_queue_tail(&free, skb);
267 spin_unlock(&tid_info->lock);
268 }
269 }
270 spin_unlock_bh(&ar->tx_ampdu_list_lock);
271 rcu_read_unlock();
272
273 while ((skb = __skb_dequeue(&free)))
274 carl9170_tx_status(ar, skb, false);
275 }
276
277 static void carl9170_zap_queues(struct ar9170 *ar)
278 {
279 struct carl9170_vif_info *cvif;
280 unsigned int i;
281
282 carl9170_ampdu_gc(ar);
283
284 carl9170_flush_ba(ar);
285 carl9170_flush(ar, true);
286
287 for (i = 0; i < ar->hw->queues; i++) {
288 spin_lock_bh(&ar->tx_status[i].lock);
289 while (!skb_queue_empty(&ar->tx_status[i])) {
290 struct sk_buff *skb;
291
292 skb = skb_peek(&ar->tx_status[i]);
293 carl9170_tx_get_skb(skb);
294 spin_unlock_bh(&ar->tx_status[i].lock);
295 carl9170_tx_drop(ar, skb);
296 spin_lock_bh(&ar->tx_status[i].lock);
297 carl9170_tx_put_skb(skb);
298 }
299 spin_unlock_bh(&ar->tx_status[i].lock);
300 }
301
302 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_SOFT < 1);
303 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD < CARL9170_NUM_TX_LIMIT_SOFT);
304 BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD >= CARL9170_BAW_BITS);
305
306 /* reinitialize queues statistics */
307 memset(&ar->tx_stats, 0, sizeof(ar->tx_stats));
308 for (i = 0; i < ar->hw->queues; i++)
309 ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD;
310
311 for (i = 0; i < DIV_ROUND_UP(ar->fw.mem_blocks, BITS_PER_LONG); i++)
312 ar->mem_bitmap[i] = 0;
313
314 rcu_read_lock();
315 list_for_each_entry_rcu(cvif, &ar->vif_list, list) {
316 spin_lock_bh(&ar->beacon_lock);
317 dev_kfree_skb_any(cvif->beacon);
318 cvif->beacon = NULL;
319 spin_unlock_bh(&ar->beacon_lock);
320 }
321 rcu_read_unlock();
322
323 atomic_set(&ar->tx_ampdu_upload, 0);
324 atomic_set(&ar->tx_ampdu_scheduler, 0);
325 atomic_set(&ar->tx_total_pending, 0);
326 atomic_set(&ar->tx_total_queued, 0);
327 atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks);
328 }
329
330 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop) \
331 do { \
332 queue.aifs = ai_fs; \
333 queue.cw_min = cwmin; \
334 queue.cw_max = cwmax; \
335 queue.txop = _txop; \
336 } while (0)
337
338 static int carl9170_op_start(struct ieee80211_hw *hw)
339 {
340 struct ar9170 *ar = hw->priv;
341 int err, i;
342
343 mutex_lock(&ar->mutex);
344
345 carl9170_zap_queues(ar);
346
347 /* reset QoS defaults */
348 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VO], 2, 3, 7, 47);
349 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VI], 2, 7, 15, 94);
350 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BE], 3, 15, 1023, 0);
351 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BK], 7, 15, 1023, 0);
352 CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_SPECIAL], 2, 3, 7, 0);
353
354 ar->current_factor = ar->current_density = -1;
355 /* "The first key is unique." */
356 ar->usedkeys = 1;
357 ar->filter_state = 0;
358 ar->ps.last_action = jiffies;
359 ar->ps.last_slept = jiffies;
360 ar->erp_mode = CARL9170_ERP_AUTO;
361 ar->rx_software_decryption = false;
362 ar->disable_offload = false;
363
364 for (i = 0; i < ar->hw->queues; i++) {
365 ar->queue_stop_timeout[i] = jiffies;
366 ar->max_queue_stop_timeout[i] = 0;
367 }
368
369 atomic_set(&ar->mem_allocs, 0);
370
371 err = carl9170_usb_open(ar);
372 if (err)
373 goto out;
374
375 err = carl9170_init_mac(ar);
376 if (err)
377 goto out;
378
379 err = carl9170_set_qos(ar);
380 if (err)
381 goto out;
382
383 if (ar->fw.rx_filter) {
384 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA |
385 CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD);
386 if (err)
387 goto out;
388 }
389
390 err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER,
391 AR9170_DMA_TRIGGER_RXQ);
392 if (err)
393 goto out;
394
395 /* Clear key-cache */
396 for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) {
397 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
398 0, NULL, 0);
399 if (err)
400 goto out;
401
402 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
403 1, NULL, 0);
404 if (err)
405 goto out;
406
407 if (i < AR9170_CAM_MAX_USER) {
408 err = carl9170_disable_key(ar, i);
409 if (err)
410 goto out;
411 }
412 }
413
414 carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED);
415
416 ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
417 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
418
419 ieee80211_wake_queues(ar->hw);
420 err = 0;
421
422 out:
423 mutex_unlock(&ar->mutex);
424 return err;
425 }
426
427 static void carl9170_cancel_worker(struct ar9170 *ar)
428 {
429 cancel_delayed_work_sync(&ar->stat_work);
430 cancel_delayed_work_sync(&ar->tx_janitor);
431 #ifdef CONFIG_CARL9170_LEDS
432 cancel_delayed_work_sync(&ar->led_work);
433 #endif /* CONFIG_CARL9170_LEDS */
434 cancel_work_sync(&ar->ps_work);
435 cancel_work_sync(&ar->ping_work);
436 cancel_work_sync(&ar->ampdu_work);
437 }
438
439 static void carl9170_op_stop(struct ieee80211_hw *hw)
440 {
441 struct ar9170 *ar = hw->priv;
442
443 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
444
445 ieee80211_stop_queues(ar->hw);
446
447 mutex_lock(&ar->mutex);
448 if (IS_ACCEPTING_CMD(ar)) {
449 RCU_INIT_POINTER(ar->beacon_iter, NULL);
450
451 carl9170_led_set_state(ar, 0);
452
453 /* stop DMA */
454 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
455 carl9170_usb_stop(ar);
456 }
457
458 carl9170_zap_queues(ar);
459 mutex_unlock(&ar->mutex);
460
461 carl9170_cancel_worker(ar);
462 }
463
464 static void carl9170_restart_work(struct work_struct *work)
465 {
466 struct ar9170 *ar = container_of(work, struct ar9170,
467 restart_work);
468 int err;
469
470 ar->usedkeys = 0;
471 ar->filter_state = 0;
472 carl9170_cancel_worker(ar);
473
474 mutex_lock(&ar->mutex);
475 err = carl9170_usb_restart(ar);
476 if (net_ratelimit()) {
477 if (err) {
478 dev_err(&ar->udev->dev, "Failed to restart device "
479 " (%d).\n", err);
480 } else {
481 dev_info(&ar->udev->dev, "device restarted "
482 "successfully.\n");
483 }
484 }
485
486 carl9170_zap_queues(ar);
487 mutex_unlock(&ar->mutex);
488 if (!err) {
489 ar->restart_counter++;
490 atomic_set(&ar->pending_restarts, 0);
491
492 ieee80211_restart_hw(ar->hw);
493 } else {
494 /*
495 * The reset was unsuccessful and the device seems to
496 * be dead. But there's still one option: a low-level
497 * usb subsystem reset...
498 */
499
500 carl9170_usb_reset(ar);
501 }
502 }
503
504 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
505 {
506 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
507
508 /*
509 * Sometimes, an error can trigger several different reset events.
510 * By ignoring these *surplus* reset events, the device won't be
511 * killed again, right after it has recovered.
512 */
513 if (atomic_inc_return(&ar->pending_restarts) > 1) {
514 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
515 return;
516 }
517
518 ieee80211_stop_queues(ar->hw);
519
520 dev_err(&ar->udev->dev, "restart device (%d)\n", r);
521
522 if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
523 !WARN_ON(r >= __CARL9170_RR_LAST))
524 ar->last_reason = r;
525
526 if (!ar->registered)
527 return;
528
529 if (IS_ACCEPTING_CMD(ar) && !ar->needs_full_reset)
530 ieee80211_queue_work(ar->hw, &ar->restart_work);
531 else
532 carl9170_usb_reset(ar);
533
534 /*
535 * At this point, the device instance might have vanished/disabled.
536 * So, don't put any code which access the ar9170 struct
537 * without proper protection.
538 */
539 }
540
541 static void carl9170_ping_work(struct work_struct *work)
542 {
543 struct ar9170 *ar = container_of(work, struct ar9170, ping_work);
544 int err;
545
546 if (!IS_STARTED(ar))
547 return;
548
549 mutex_lock(&ar->mutex);
550 err = carl9170_echo_test(ar, 0xdeadbeef);
551 if (err)
552 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE);
553 mutex_unlock(&ar->mutex);
554 }
555
556 static int carl9170_init_interface(struct ar9170 *ar,
557 struct ieee80211_vif *vif)
558 {
559 struct ath_common *common = &ar->common;
560 int err;
561
562 if (!vif) {
563 WARN_ON_ONCE(IS_STARTED(ar));
564 return 0;
565 }
566
567 memcpy(common->macaddr, vif->addr, ETH_ALEN);
568
569 if (modparam_nohwcrypt ||
570 ((vif->type != NL80211_IFTYPE_STATION) &&
571 (vif->type != NL80211_IFTYPE_AP))) {
572 ar->rx_software_decryption = true;
573 ar->disable_offload = true;
574 }
575
576 err = carl9170_set_operating_mode(ar);
577 return err;
578 }
579
580 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
581 struct ieee80211_vif *vif)
582 {
583 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
584 struct ieee80211_vif *main_vif;
585 struct ar9170 *ar = hw->priv;
586 int vif_id = -1, err = 0;
587
588 mutex_lock(&ar->mutex);
589 rcu_read_lock();
590 if (vif_priv->active) {
591 /*
592 * Skip the interface structure initialization,
593 * if the vif survived the _restart call.
594 */
595 vif_id = vif_priv->id;
596 vif_priv->enable_beacon = false;
597
598 spin_lock_bh(&ar->beacon_lock);
599 dev_kfree_skb_any(vif_priv->beacon);
600 vif_priv->beacon = NULL;
601 spin_unlock_bh(&ar->beacon_lock);
602
603 goto init;
604 }
605
606 main_vif = carl9170_get_main_vif(ar);
607
608 if (main_vif) {
609 switch (main_vif->type) {
610 case NL80211_IFTYPE_STATION:
611 if (vif->type == NL80211_IFTYPE_STATION)
612 break;
613
614 err = -EBUSY;
615 rcu_read_unlock();
616
617 goto unlock;
618
619 case NL80211_IFTYPE_AP:
620 if ((vif->type == NL80211_IFTYPE_STATION) ||
621 (vif->type == NL80211_IFTYPE_WDS) ||
622 (vif->type == NL80211_IFTYPE_AP))
623 break;
624
625 err = -EBUSY;
626 rcu_read_unlock();
627 goto unlock;
628
629 default:
630 rcu_read_unlock();
631 goto unlock;
632 }
633 }
634
635 vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
636
637 if (vif_id < 0) {
638 rcu_read_unlock();
639
640 err = -ENOSPC;
641 goto unlock;
642 }
643
644 BUG_ON(ar->vif_priv[vif_id].id != vif_id);
645
646 vif_priv->active = true;
647 vif_priv->id = vif_id;
648 vif_priv->enable_beacon = false;
649 ar->vifs++;
650 list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
651 rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
652
653 init:
654 if (carl9170_get_main_vif(ar) == vif) {
655 rcu_assign_pointer(ar->beacon_iter, vif_priv);
656 rcu_read_unlock();
657
658 err = carl9170_init_interface(ar, vif);
659 if (err)
660 goto unlock;
661 } else {
662 rcu_read_unlock();
663 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
664
665 if (err)
666 goto unlock;
667 }
668
669 if (ar->fw.tx_seq_table) {
670 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4,
671 0);
672 if (err)
673 goto unlock;
674 }
675
676 unlock:
677 if (err && (vif_id >= 0)) {
678 vif_priv->active = false;
679 bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
680 ar->vifs--;
681 RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL);
682 list_del_rcu(&vif_priv->list);
683 mutex_unlock(&ar->mutex);
684 synchronize_rcu();
685 } else {
686 if (ar->vifs > 1)
687 ar->ps.off_override |= PS_OFF_VIF;
688
689 mutex_unlock(&ar->mutex);
690 }
691
692 return err;
693 }
694
695 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
696 struct ieee80211_vif *vif)
697 {
698 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
699 struct ieee80211_vif *main_vif;
700 struct ar9170 *ar = hw->priv;
701 unsigned int id;
702
703 mutex_lock(&ar->mutex);
704
705 if (WARN_ON_ONCE(!vif_priv->active))
706 goto unlock;
707
708 ar->vifs--;
709
710 rcu_read_lock();
711 main_vif = carl9170_get_main_vif(ar);
712
713 id = vif_priv->id;
714
715 vif_priv->active = false;
716 WARN_ON(vif_priv->enable_beacon);
717 vif_priv->enable_beacon = false;
718 list_del_rcu(&vif_priv->list);
719 RCU_INIT_POINTER(ar->vif_priv[id].vif, NULL);
720
721 if (vif == main_vif) {
722 rcu_read_unlock();
723
724 if (ar->vifs) {
725 WARN_ON(carl9170_init_interface(ar,
726 carl9170_get_main_vif(ar)));
727 } else {
728 carl9170_set_operating_mode(ar);
729 }
730 } else {
731 rcu_read_unlock();
732
733 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
734 }
735
736 carl9170_update_beacon(ar, false);
737 carl9170_flush_cab(ar, id);
738
739 spin_lock_bh(&ar->beacon_lock);
740 dev_kfree_skb_any(vif_priv->beacon);
741 vif_priv->beacon = NULL;
742 spin_unlock_bh(&ar->beacon_lock);
743
744 bitmap_release_region(&ar->vif_bitmap, id, 0);
745
746 carl9170_set_beacon_timers(ar);
747
748 if (ar->vifs == 1)
749 ar->ps.off_override &= ~PS_OFF_VIF;
750
751 unlock:
752 mutex_unlock(&ar->mutex);
753
754 synchronize_rcu();
755 }
756
757 void carl9170_ps_check(struct ar9170 *ar)
758 {
759 ieee80211_queue_work(ar->hw, &ar->ps_work);
760 }
761
762 /* caller must hold ar->mutex */
763 static int carl9170_ps_update(struct ar9170 *ar)
764 {
765 bool ps = false;
766 int err = 0;
767
768 if (!ar->ps.off_override)
769 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
770
771 if (ps != ar->ps.state) {
772 err = carl9170_powersave(ar, ps);
773 if (err)
774 return err;
775
776 if (ar->ps.state && !ps) {
777 ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
778 ar->ps.last_action);
779 }
780
781 if (ps)
782 ar->ps.last_slept = jiffies;
783
784 ar->ps.last_action = jiffies;
785 ar->ps.state = ps;
786 }
787
788 return 0;
789 }
790
791 static void carl9170_ps_work(struct work_struct *work)
792 {
793 struct ar9170 *ar = container_of(work, struct ar9170,
794 ps_work);
795 mutex_lock(&ar->mutex);
796 if (IS_STARTED(ar))
797 WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
798 mutex_unlock(&ar->mutex);
799 }
800
801 static int carl9170_update_survey(struct ar9170 *ar, bool flush, bool noise)
802 {
803 int err;
804
805 if (noise) {
806 err = carl9170_get_noisefloor(ar);
807 if (err)
808 return err;
809 }
810
811 if (ar->fw.hw_counters) {
812 err = carl9170_collect_tally(ar);
813 if (err)
814 return err;
815 }
816
817 if (flush)
818 memset(&ar->tally, 0, sizeof(ar->tally));
819
820 return 0;
821 }
822
823 static void carl9170_stat_work(struct work_struct *work)
824 {
825 struct ar9170 *ar = container_of(work, struct ar9170, stat_work.work);
826 int err;
827
828 mutex_lock(&ar->mutex);
829 err = carl9170_update_survey(ar, false, true);
830 mutex_unlock(&ar->mutex);
831
832 if (err)
833 return;
834
835 ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
836 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
837 }
838
839 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
840 {
841 struct ar9170 *ar = hw->priv;
842 int err = 0;
843
844 mutex_lock(&ar->mutex);
845 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
846 /* TODO */
847 err = 0;
848 }
849
850 if (changed & IEEE80211_CONF_CHANGE_PS) {
851 err = carl9170_ps_update(ar);
852 if (err)
853 goto out;
854 }
855
856 if (changed & IEEE80211_CONF_CHANGE_POWER) {
857 /* TODO */
858 err = 0;
859 }
860
861 if (changed & IEEE80211_CONF_CHANGE_SMPS) {
862 /* TODO */
863 err = 0;
864 }
865
866 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
867 /* adjust slot time for 5 GHz */
868 err = carl9170_set_slot_time(ar);
869 if (err)
870 goto out;
871
872 err = carl9170_update_survey(ar, true, false);
873 if (err)
874 goto out;
875
876 err = carl9170_set_channel(ar, hw->conf.channel,
877 hw->conf.channel_type, CARL9170_RFI_NONE);
878 if (err)
879 goto out;
880
881 err = carl9170_update_survey(ar, false, true);
882 if (err)
883 goto out;
884
885 err = carl9170_set_dyn_sifs_ack(ar);
886 if (err)
887 goto out;
888
889 err = carl9170_set_rts_cts_rate(ar);
890 if (err)
891 goto out;
892 }
893
894 out:
895 mutex_unlock(&ar->mutex);
896 return err;
897 }
898
899 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
900 struct netdev_hw_addr_list *mc_list)
901 {
902 struct netdev_hw_addr *ha;
903 u64 mchash;
904
905 /* always get broadcast frames */
906 mchash = 1ULL << (0xff >> 2);
907
908 netdev_hw_addr_list_for_each(ha, mc_list)
909 mchash |= 1ULL << (ha->addr[5] >> 2);
910
911 return mchash;
912 }
913
914 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
915 unsigned int changed_flags,
916 unsigned int *new_flags,
917 u64 multicast)
918 {
919 struct ar9170 *ar = hw->priv;
920
921 /* mask supported flags */
922 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
923
924 if (!IS_ACCEPTING_CMD(ar))
925 return;
926
927 mutex_lock(&ar->mutex);
928
929 ar->filter_state = *new_flags;
930 /*
931 * We can support more by setting the sniffer bit and
932 * then checking the error flags, later.
933 */
934
935 if (*new_flags & FIF_ALLMULTI)
936 multicast = ~0ULL;
937
938 if (multicast != ar->cur_mc_hash)
939 WARN_ON(carl9170_update_multicast(ar, multicast));
940
941 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
942 ar->sniffer_enabled = !!(*new_flags &
943 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS));
944
945 WARN_ON(carl9170_set_operating_mode(ar));
946 }
947
948 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) {
949 u32 rx_filter = 0;
950
951 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL)))
952 rx_filter |= CARL9170_RX_FILTER_BAD;
953
954 if (!(*new_flags & FIF_CONTROL))
955 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
956
957 if (!(*new_flags & FIF_PSPOLL))
958 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL;
959
960 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) {
961 rx_filter |= CARL9170_RX_FILTER_OTHER_RA;
962 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL;
963 }
964
965 WARN_ON(carl9170_rx_filter(ar, rx_filter));
966 }
967
968 mutex_unlock(&ar->mutex);
969 }
970
971
972 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw,
973 struct ieee80211_vif *vif,
974 struct ieee80211_bss_conf *bss_conf,
975 u32 changed)
976 {
977 struct ar9170 *ar = hw->priv;
978 struct ath_common *common = &ar->common;
979 int err = 0;
980 struct carl9170_vif_info *vif_priv;
981 struct ieee80211_vif *main_vif;
982
983 mutex_lock(&ar->mutex);
984 vif_priv = (void *) vif->drv_priv;
985 main_vif = carl9170_get_main_vif(ar);
986 if (WARN_ON(!main_vif))
987 goto out;
988
989 if (changed & BSS_CHANGED_BEACON_ENABLED) {
990 struct carl9170_vif_info *iter;
991 int i = 0;
992
993 vif_priv->enable_beacon = bss_conf->enable_beacon;
994 rcu_read_lock();
995 list_for_each_entry_rcu(iter, &ar->vif_list, list) {
996 if (iter->active && iter->enable_beacon)
997 i++;
998
999 }
1000 rcu_read_unlock();
1001
1002 ar->beacon_enabled = i;
1003 }
1004
1005 if (changed & BSS_CHANGED_BEACON) {
1006 err = carl9170_update_beacon(ar, false);
1007 if (err)
1008 goto out;
1009 }
1010
1011 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON |
1012 BSS_CHANGED_BEACON_INT)) {
1013
1014 if (main_vif != vif) {
1015 bss_conf->beacon_int = main_vif->bss_conf.beacon_int;
1016 bss_conf->dtim_period = main_vif->bss_conf.dtim_period;
1017 }
1018
1019 /*
1020 * Therefore a hard limit for the broadcast traffic should
1021 * prevent false alarms.
1022 */
1023 if (vif->type != NL80211_IFTYPE_STATION &&
1024 (bss_conf->beacon_int * bss_conf->dtim_period >=
1025 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) {
1026 err = -EINVAL;
1027 goto out;
1028 }
1029
1030 err = carl9170_set_beacon_timers(ar);
1031 if (err)
1032 goto out;
1033 }
1034
1035 if (changed & BSS_CHANGED_HT) {
1036 /* TODO */
1037 err = 0;
1038 if (err)
1039 goto out;
1040 }
1041
1042 if (main_vif != vif)
1043 goto out;
1044
1045 /*
1046 * The following settings can only be changed by the
1047 * master interface.
1048 */
1049
1050 if (changed & BSS_CHANGED_BSSID) {
1051 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1052 err = carl9170_set_operating_mode(ar);
1053 if (err)
1054 goto out;
1055 }
1056
1057 if (changed & BSS_CHANGED_ASSOC) {
1058 ar->common.curaid = bss_conf->aid;
1059 err = carl9170_set_beacon_timers(ar);
1060 if (err)
1061 goto out;
1062 }
1063
1064 if (changed & BSS_CHANGED_ERP_SLOT) {
1065 err = carl9170_set_slot_time(ar);
1066 if (err)
1067 goto out;
1068 }
1069
1070 if (changed & BSS_CHANGED_BASIC_RATES) {
1071 err = carl9170_set_mac_rates(ar);
1072 if (err)
1073 goto out;
1074 }
1075
1076 out:
1077 WARN_ON_ONCE(err && IS_STARTED(ar));
1078 mutex_unlock(&ar->mutex);
1079 }
1080
1081 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw,
1082 struct ieee80211_vif *vif)
1083 {
1084 struct ar9170 *ar = hw->priv;
1085 struct carl9170_tsf_rsp tsf;
1086 int err;
1087
1088 mutex_lock(&ar->mutex);
1089 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF,
1090 0, NULL, sizeof(tsf), &tsf);
1091 mutex_unlock(&ar->mutex);
1092 if (WARN_ON(err))
1093 return 0;
1094
1095 return le64_to_cpu(tsf.tsf_64);
1096 }
1097
1098 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1099 struct ieee80211_vif *vif,
1100 struct ieee80211_sta *sta,
1101 struct ieee80211_key_conf *key)
1102 {
1103 struct ar9170 *ar = hw->priv;
1104 int err = 0, i;
1105 u8 ktype;
1106
1107 if (ar->disable_offload || !vif)
1108 return -EOPNOTSUPP;
1109
1110 /*
1111 * We have to fall back to software encryption, whenever
1112 * the user choose to participates in an IBSS or is connected
1113 * to more than one network.
1114 *
1115 * This is very unfortunate, because some machines cannot handle
1116 * the high througput speed in 802.11n networks.
1117 */
1118
1119 if (!is_main_vif(ar, vif)) {
1120 mutex_lock(&ar->mutex);
1121 goto err_softw;
1122 }
1123
1124 /*
1125 * While the hardware supports *catch-all* key, for offloading
1126 * group-key en-/de-cryption. The way of how the hardware
1127 * decides which keyId maps to which key, remains a mystery...
1128 */
1129 if ((vif->type != NL80211_IFTYPE_STATION &&
1130 vif->type != NL80211_IFTYPE_ADHOC) &&
1131 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1132 return -EOPNOTSUPP;
1133
1134 switch (key->cipher) {
1135 case WLAN_CIPHER_SUITE_WEP40:
1136 ktype = AR9170_ENC_ALG_WEP64;
1137 break;
1138 case WLAN_CIPHER_SUITE_WEP104:
1139 ktype = AR9170_ENC_ALG_WEP128;
1140 break;
1141 case WLAN_CIPHER_SUITE_TKIP:
1142 ktype = AR9170_ENC_ALG_TKIP;
1143 break;
1144 case WLAN_CIPHER_SUITE_CCMP:
1145 ktype = AR9170_ENC_ALG_AESCCMP;
1146 break;
1147 default:
1148 return -EOPNOTSUPP;
1149 }
1150
1151 mutex_lock(&ar->mutex);
1152 if (cmd == SET_KEY) {
1153 if (!IS_STARTED(ar)) {
1154 err = -EOPNOTSUPP;
1155 goto out;
1156 }
1157
1158 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1159 sta = NULL;
1160
1161 i = 64 + key->keyidx;
1162 } else {
1163 for (i = 0; i < 64; i++)
1164 if (!(ar->usedkeys & BIT(i)))
1165 break;
1166 if (i == 64)
1167 goto err_softw;
1168 }
1169
1170 key->hw_key_idx = i;
1171
1172 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1173 ktype, 0, key->key,
1174 min_t(u8, 16, key->keylen));
1175 if (err)
1176 goto out;
1177
1178 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1179 err = carl9170_upload_key(ar, i, sta ? sta->addr :
1180 NULL, ktype, 1,
1181 key->key + 16, 16);
1182 if (err)
1183 goto out;
1184
1185 /*
1186 * hardware is not capable generating MMIC
1187 * of fragmented frames!
1188 */
1189 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1190 }
1191
1192 if (i < 64)
1193 ar->usedkeys |= BIT(i);
1194
1195 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1196 } else {
1197 if (!IS_STARTED(ar)) {
1198 /* The device is gone... together with the key ;-) */
1199 err = 0;
1200 goto out;
1201 }
1202
1203 if (key->hw_key_idx < 64) {
1204 ar->usedkeys &= ~BIT(key->hw_key_idx);
1205 } else {
1206 err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1207 AR9170_ENC_ALG_NONE, 0,
1208 NULL, 0);
1209 if (err)
1210 goto out;
1211
1212 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1213 err = carl9170_upload_key(ar, key->hw_key_idx,
1214 NULL,
1215 AR9170_ENC_ALG_NONE,
1216 1, NULL, 0);
1217 if (err)
1218 goto out;
1219 }
1220
1221 }
1222
1223 err = carl9170_disable_key(ar, key->hw_key_idx);
1224 if (err)
1225 goto out;
1226 }
1227
1228 out:
1229 mutex_unlock(&ar->mutex);
1230 return err;
1231
1232 err_softw:
1233 if (!ar->rx_software_decryption) {
1234 ar->rx_software_decryption = true;
1235 carl9170_set_operating_mode(ar);
1236 }
1237 mutex_unlock(&ar->mutex);
1238 return -ENOSPC;
1239 }
1240
1241 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1242 struct ieee80211_vif *vif,
1243 struct ieee80211_sta *sta)
1244 {
1245 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1246 unsigned int i;
1247
1248 atomic_set(&sta_info->pending_frames, 0);
1249
1250 if (sta->ht_cap.ht_supported) {
1251 if (sta->ht_cap.ampdu_density > 6) {
1252 /*
1253 * HW does support 16us AMPDU density.
1254 * No HT-Xmit for station.
1255 */
1256
1257 return 0;
1258 }
1259
1260 for (i = 0; i < CARL9170_NUM_TID; i++)
1261 RCU_INIT_POINTER(sta_info->agg[i], NULL);
1262
1263 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor);
1264 sta_info->ht_sta = true;
1265 }
1266
1267 return 0;
1268 }
1269
1270 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1271 struct ieee80211_vif *vif,
1272 struct ieee80211_sta *sta)
1273 {
1274 struct ar9170 *ar = hw->priv;
1275 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1276 unsigned int i;
1277 bool cleanup = false;
1278
1279 if (sta->ht_cap.ht_supported) {
1280
1281 sta_info->ht_sta = false;
1282
1283 rcu_read_lock();
1284 for (i = 0; i < CARL9170_NUM_TID; i++) {
1285 struct carl9170_sta_tid *tid_info;
1286
1287 tid_info = rcu_dereference(sta_info->agg[i]);
1288 RCU_INIT_POINTER(sta_info->agg[i], NULL);
1289
1290 if (!tid_info)
1291 continue;
1292
1293 spin_lock_bh(&ar->tx_ampdu_list_lock);
1294 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1295 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1296 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1297 cleanup = true;
1298 }
1299 rcu_read_unlock();
1300
1301 if (cleanup)
1302 carl9170_ampdu_gc(ar);
1303 }
1304
1305 return 0;
1306 }
1307
1308 static int carl9170_op_conf_tx(struct ieee80211_hw *hw,
1309 struct ieee80211_vif *vif, u16 queue,
1310 const struct ieee80211_tx_queue_params *param)
1311 {
1312 struct ar9170 *ar = hw->priv;
1313 int ret;
1314
1315 mutex_lock(&ar->mutex);
1316 if (queue < ar->hw->queues) {
1317 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param));
1318 ret = carl9170_set_qos(ar);
1319 } else {
1320 ret = -EINVAL;
1321 }
1322
1323 mutex_unlock(&ar->mutex);
1324 return ret;
1325 }
1326
1327 static void carl9170_ampdu_work(struct work_struct *work)
1328 {
1329 struct ar9170 *ar = container_of(work, struct ar9170,
1330 ampdu_work);
1331
1332 if (!IS_STARTED(ar))
1333 return;
1334
1335 mutex_lock(&ar->mutex);
1336 carl9170_ampdu_gc(ar);
1337 mutex_unlock(&ar->mutex);
1338 }
1339
1340 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1341 struct ieee80211_vif *vif,
1342 enum ieee80211_ampdu_mlme_action action,
1343 struct ieee80211_sta *sta,
1344 u16 tid, u16 *ssn, u8 buf_size)
1345 {
1346 struct ar9170 *ar = hw->priv;
1347 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1348 struct carl9170_sta_tid *tid_info;
1349
1350 if (modparam_noht)
1351 return -EOPNOTSUPP;
1352
1353 switch (action) {
1354 case IEEE80211_AMPDU_TX_START:
1355 if (!sta_info->ht_sta)
1356 return -EOPNOTSUPP;
1357
1358 rcu_read_lock();
1359 if (rcu_dereference(sta_info->agg[tid])) {
1360 rcu_read_unlock();
1361 return -EBUSY;
1362 }
1363
1364 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1365 GFP_ATOMIC);
1366 if (!tid_info) {
1367 rcu_read_unlock();
1368 return -ENOMEM;
1369 }
1370
1371 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1372 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1373 tid_info->tid = tid;
1374 tid_info->max = sta_info->ampdu_max_len;
1375
1376 INIT_LIST_HEAD(&tid_info->list);
1377 INIT_LIST_HEAD(&tid_info->tmp_list);
1378 skb_queue_head_init(&tid_info->queue);
1379 spin_lock_init(&tid_info->lock);
1380
1381 spin_lock_bh(&ar->tx_ampdu_list_lock);
1382 ar->tx_ampdu_list_len++;
1383 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1384 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1385 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1386 rcu_read_unlock();
1387
1388 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1389 break;
1390
1391 case IEEE80211_AMPDU_TX_STOP:
1392 rcu_read_lock();
1393 tid_info = rcu_dereference(sta_info->agg[tid]);
1394 if (tid_info) {
1395 spin_lock_bh(&ar->tx_ampdu_list_lock);
1396 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1397 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1398 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1399 }
1400
1401 RCU_INIT_POINTER(sta_info->agg[tid], NULL);
1402 rcu_read_unlock();
1403
1404 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1405 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1406 break;
1407
1408 case IEEE80211_AMPDU_TX_OPERATIONAL:
1409 rcu_read_lock();
1410 tid_info = rcu_dereference(sta_info->agg[tid]);
1411
1412 sta_info->stats[tid].clear = true;
1413 sta_info->stats[tid].req = false;
1414
1415 if (tid_info) {
1416 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1417 tid_info->state = CARL9170_TID_STATE_IDLE;
1418 }
1419 rcu_read_unlock();
1420
1421 if (WARN_ON_ONCE(!tid_info))
1422 return -EFAULT;
1423
1424 break;
1425
1426 case IEEE80211_AMPDU_RX_START:
1427 case IEEE80211_AMPDU_RX_STOP:
1428 /* Handled by hardware */
1429 break;
1430
1431 default:
1432 return -EOPNOTSUPP;
1433 }
1434
1435 return 0;
1436 }
1437
1438 #ifdef CONFIG_CARL9170_WPC
1439 static int carl9170_register_wps_button(struct ar9170 *ar)
1440 {
1441 struct input_dev *input;
1442 int err;
1443
1444 if (!(ar->features & CARL9170_WPS_BUTTON))
1445 return 0;
1446
1447 input = input_allocate_device();
1448 if (!input)
1449 return -ENOMEM;
1450
1451 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1452 wiphy_name(ar->hw->wiphy));
1453
1454 snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1455 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1456
1457 input->name = ar->wps.name;
1458 input->phys = ar->wps.phys;
1459 input->id.bustype = BUS_USB;
1460 input->dev.parent = &ar->hw->wiphy->dev;
1461
1462 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1463
1464 err = input_register_device(input);
1465 if (err) {
1466 input_free_device(input);
1467 return err;
1468 }
1469
1470 ar->wps.pbc = input;
1471 return 0;
1472 }
1473 #endif /* CONFIG_CARL9170_WPC */
1474
1475 #ifdef CONFIG_CARL9170_HWRNG
1476 static int carl9170_rng_get(struct ar9170 *ar)
1477 {
1478
1479 #define RW (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32))
1480 #define RB (CARL9170_MAX_CMD_PAYLOAD_LEN)
1481
1482 static const __le32 rng_load[RW] = {
1483 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)};
1484
1485 u32 buf[RW];
1486
1487 unsigned int i, off = 0, transfer, count;
1488 int err;
1489
1490 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN);
1491
1492 if (!IS_ACCEPTING_CMD(ar) || !ar->rng.initialized)
1493 return -EAGAIN;
1494
1495 count = ARRAY_SIZE(ar->rng.cache);
1496 while (count) {
1497 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1498 RB, (u8 *) rng_load,
1499 RB, (u8 *) buf);
1500 if (err)
1501 return err;
1502
1503 transfer = min_t(unsigned int, count, RW);
1504 for (i = 0; i < transfer; i++)
1505 ar->rng.cache[off + i] = buf[i];
1506
1507 off += transfer;
1508 count -= transfer;
1509 }
1510
1511 ar->rng.cache_idx = 0;
1512
1513 #undef RW
1514 #undef RB
1515 return 0;
1516 }
1517
1518 static int carl9170_rng_read(struct hwrng *rng, u32 *data)
1519 {
1520 struct ar9170 *ar = (struct ar9170 *)rng->priv;
1521 int ret = -EIO;
1522
1523 mutex_lock(&ar->mutex);
1524 if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) {
1525 ret = carl9170_rng_get(ar);
1526 if (ret) {
1527 mutex_unlock(&ar->mutex);
1528 return ret;
1529 }
1530 }
1531
1532 *data = ar->rng.cache[ar->rng.cache_idx++];
1533 mutex_unlock(&ar->mutex);
1534
1535 return sizeof(u16);
1536 }
1537
1538 static void carl9170_unregister_hwrng(struct ar9170 *ar)
1539 {
1540 if (ar->rng.initialized) {
1541 hwrng_unregister(&ar->rng.rng);
1542 ar->rng.initialized = false;
1543 }
1544 }
1545
1546 static int carl9170_register_hwrng(struct ar9170 *ar)
1547 {
1548 int err;
1549
1550 snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name),
1551 "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy));
1552 ar->rng.rng.name = ar->rng.name;
1553 ar->rng.rng.data_read = carl9170_rng_read;
1554 ar->rng.rng.priv = (unsigned long)ar;
1555
1556 if (WARN_ON(ar->rng.initialized))
1557 return -EALREADY;
1558
1559 err = hwrng_register(&ar->rng.rng);
1560 if (err) {
1561 dev_err(&ar->udev->dev, "Failed to register the random "
1562 "number generator (%d)\n", err);
1563 return err;
1564 }
1565
1566 ar->rng.initialized = true;
1567
1568 err = carl9170_rng_get(ar);
1569 if (err) {
1570 carl9170_unregister_hwrng(ar);
1571 return err;
1572 }
1573
1574 return 0;
1575 }
1576 #endif /* CONFIG_CARL9170_HWRNG */
1577
1578 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1579 struct survey_info *survey)
1580 {
1581 struct ar9170 *ar = hw->priv;
1582 struct ieee80211_channel *chan;
1583 struct ieee80211_supported_band *band;
1584 int err, b, i;
1585
1586 chan = ar->channel;
1587 if (!chan)
1588 return -ENODEV;
1589
1590 if (idx == chan->hw_value) {
1591 mutex_lock(&ar->mutex);
1592 err = carl9170_update_survey(ar, false, true);
1593 mutex_unlock(&ar->mutex);
1594 if (err)
1595 return err;
1596 }
1597
1598 for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
1599 band = ar->hw->wiphy->bands[b];
1600
1601 if (!band)
1602 continue;
1603
1604 for (i = 0; i < band->n_channels; i++) {
1605 if (band->channels[i].hw_value == idx) {
1606 chan = &band->channels[i];
1607 goto found;
1608 }
1609 }
1610 }
1611 return -ENOENT;
1612
1613 found:
1614 memcpy(survey, &ar->survey[idx], sizeof(*survey));
1615
1616 survey->channel = chan;
1617 survey->filled = SURVEY_INFO_NOISE_DBM;
1618
1619 if (ar->channel == chan)
1620 survey->filled |= SURVEY_INFO_IN_USE;
1621
1622 if (ar->fw.hw_counters) {
1623 survey->filled |= SURVEY_INFO_CHANNEL_TIME |
1624 SURVEY_INFO_CHANNEL_TIME_BUSY |
1625 SURVEY_INFO_CHANNEL_TIME_TX;
1626 }
1627
1628 return 0;
1629 }
1630
1631 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1632 {
1633 struct ar9170 *ar = hw->priv;
1634 unsigned int vid;
1635
1636 mutex_lock(&ar->mutex);
1637 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1638 carl9170_flush_cab(ar, vid);
1639
1640 carl9170_flush(ar, drop);
1641 mutex_unlock(&ar->mutex);
1642 }
1643
1644 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1645 struct ieee80211_low_level_stats *stats)
1646 {
1647 struct ar9170 *ar = hw->priv;
1648
1649 memset(stats, 0, sizeof(*stats));
1650 stats->dot11ACKFailureCount = ar->tx_ack_failures;
1651 stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1652 return 0;
1653 }
1654
1655 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1656 struct ieee80211_vif *vif,
1657 enum sta_notify_cmd cmd,
1658 struct ieee80211_sta *sta)
1659 {
1660 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1661
1662 switch (cmd) {
1663 case STA_NOTIFY_SLEEP:
1664 sta_info->sleeping = true;
1665 if (atomic_read(&sta_info->pending_frames))
1666 ieee80211_sta_block_awake(hw, sta, true);
1667 break;
1668
1669 case STA_NOTIFY_AWAKE:
1670 sta_info->sleeping = false;
1671 break;
1672 }
1673 }
1674
1675 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1676 {
1677 struct ar9170 *ar = hw->priv;
1678
1679 return !!atomic_read(&ar->tx_total_queued);
1680 }
1681
1682 static const struct ieee80211_ops carl9170_ops = {
1683 .start = carl9170_op_start,
1684 .stop = carl9170_op_stop,
1685 .tx = carl9170_op_tx,
1686 .flush = carl9170_op_flush,
1687 .add_interface = carl9170_op_add_interface,
1688 .remove_interface = carl9170_op_remove_interface,
1689 .config = carl9170_op_config,
1690 .prepare_multicast = carl9170_op_prepare_multicast,
1691 .configure_filter = carl9170_op_configure_filter,
1692 .conf_tx = carl9170_op_conf_tx,
1693 .bss_info_changed = carl9170_op_bss_info_changed,
1694 .get_tsf = carl9170_op_get_tsf,
1695 .set_key = carl9170_op_set_key,
1696 .sta_add = carl9170_op_sta_add,
1697 .sta_remove = carl9170_op_sta_remove,
1698 .sta_notify = carl9170_op_sta_notify,
1699 .get_survey = carl9170_op_get_survey,
1700 .get_stats = carl9170_op_get_stats,
1701 .ampdu_action = carl9170_op_ampdu_action,
1702 .tx_frames_pending = carl9170_tx_frames_pending,
1703 };
1704
1705 void *carl9170_alloc(size_t priv_size)
1706 {
1707 struct ieee80211_hw *hw;
1708 struct ar9170 *ar;
1709 struct sk_buff *skb;
1710 int i;
1711
1712 /*
1713 * this buffer is used for rx stream reconstruction.
1714 * Under heavy load this device (or the transport layer?)
1715 * tends to split the streams into separate rx descriptors.
1716 */
1717
1718 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1719 if (!skb)
1720 goto err_nomem;
1721
1722 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1723 if (!hw)
1724 goto err_nomem;
1725
1726 ar = hw->priv;
1727 ar->hw = hw;
1728 ar->rx_failover = skb;
1729
1730 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1731 ar->rx_has_plcp = false;
1732
1733 /*
1734 * Here's a hidden pitfall!
1735 *
1736 * All 4 AC queues work perfectly well under _legacy_ operation.
1737 * However as soon as aggregation is enabled, the traffic flow
1738 * gets very bumpy. Therefore we have to _switch_ to a
1739 * software AC with a single HW queue.
1740 */
1741 hw->queues = __AR9170_NUM_TXQ;
1742
1743 mutex_init(&ar->mutex);
1744 spin_lock_init(&ar->beacon_lock);
1745 spin_lock_init(&ar->cmd_lock);
1746 spin_lock_init(&ar->tx_stats_lock);
1747 spin_lock_init(&ar->tx_ampdu_list_lock);
1748 spin_lock_init(&ar->mem_lock);
1749 spin_lock_init(&ar->state_lock);
1750 atomic_set(&ar->pending_restarts, 0);
1751 ar->vifs = 0;
1752 for (i = 0; i < ar->hw->queues; i++) {
1753 skb_queue_head_init(&ar->tx_status[i]);
1754 skb_queue_head_init(&ar->tx_pending[i]);
1755 }
1756 INIT_WORK(&ar->ps_work, carl9170_ps_work);
1757 INIT_WORK(&ar->ping_work, carl9170_ping_work);
1758 INIT_WORK(&ar->restart_work, carl9170_restart_work);
1759 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1760 INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1761 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1762 INIT_LIST_HEAD(&ar->tx_ampdu_list);
1763 rcu_assign_pointer(ar->tx_ampdu_iter,
1764 (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1765
1766 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1767 INIT_LIST_HEAD(&ar->vif_list);
1768 init_completion(&ar->tx_flush);
1769
1770 /* firmware decides which modes we support */
1771 hw->wiphy->interface_modes = 0;
1772
1773 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1774 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1775 IEEE80211_HW_SUPPORTS_PS |
1776 IEEE80211_HW_PS_NULLFUNC_STACK |
1777 IEEE80211_HW_NEED_DTIM_PERIOD |
1778 IEEE80211_HW_SIGNAL_DBM;
1779
1780 if (!modparam_noht) {
1781 /*
1782 * see the comment above, why we allow the user
1783 * to disable HT by a module parameter.
1784 */
1785 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1786 }
1787
1788 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1789 hw->sta_data_size = sizeof(struct carl9170_sta_info);
1790 hw->vif_data_size = sizeof(struct carl9170_vif_info);
1791
1792 hw->max_rates = CARL9170_TX_MAX_RATES;
1793 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1794
1795 for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1796 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1797
1798 hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1799 return ar;
1800
1801 err_nomem:
1802 kfree_skb(skb);
1803 return ERR_PTR(-ENOMEM);
1804 }
1805
1806 static int carl9170_read_eeprom(struct ar9170 *ar)
1807 {
1808 #define RW 8 /* number of words to read at once */
1809 #define RB (sizeof(u32) * RW)
1810 u8 *eeprom = (void *)&ar->eeprom;
1811 __le32 offsets[RW];
1812 int i, j, err;
1813
1814 BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1815
1816 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1817 #ifndef __CHECKER__
1818 /* don't want to handle trailing remains */
1819 BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1820 #endif
1821
1822 for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1823 for (j = 0; j < RW; j++)
1824 offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1825 RB * i + 4 * j);
1826
1827 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1828 RB, (u8 *) &offsets,
1829 RB, eeprom + RB * i);
1830 if (err)
1831 return err;
1832 }
1833
1834 #undef RW
1835 #undef RB
1836 return 0;
1837 }
1838
1839 static int carl9170_parse_eeprom(struct ar9170 *ar)
1840 {
1841 struct ath_regulatory *regulatory = &ar->common.regulatory;
1842 unsigned int rx_streams, tx_streams, tx_params = 0;
1843 int bands = 0;
1844 int chans = 0;
1845
1846 if (ar->eeprom.length == cpu_to_le16(0xffff))
1847 return -ENODATA;
1848
1849 rx_streams = hweight8(ar->eeprom.rx_mask);
1850 tx_streams = hweight8(ar->eeprom.tx_mask);
1851
1852 if (rx_streams != tx_streams) {
1853 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1854
1855 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1856 IEEE80211_HT_MCS_TX_MAX_STREAMS));
1857
1858 tx_params = (tx_streams - 1) <<
1859 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1860
1861 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1862 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1863 }
1864
1865 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1866 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1867 &carl9170_band_2GHz;
1868 chans += carl9170_band_2GHz.n_channels;
1869 bands++;
1870 }
1871 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1872 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1873 &carl9170_band_5GHz;
1874 chans += carl9170_band_5GHz.n_channels;
1875 bands++;
1876 }
1877
1878 if (!bands)
1879 return -EINVAL;
1880
1881 ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL);
1882 if (!ar->survey)
1883 return -ENOMEM;
1884 ar->num_channels = chans;
1885
1886 /*
1887 * I measured this, a bandswitch takes roughly
1888 * 135 ms and a frequency switch about 80.
1889 *
1890 * FIXME: measure these values again once EEPROM settings
1891 * are used, that will influence them!
1892 */
1893 if (bands == 2)
1894 ar->hw->channel_change_time = 135 * 1000;
1895 else
1896 ar->hw->channel_change_time = 80 * 1000;
1897
1898 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1899
1900 /* second part of wiphy init */
1901 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1902
1903 return 0;
1904 }
1905
1906 static int carl9170_reg_notifier(struct wiphy *wiphy,
1907 struct regulatory_request *request)
1908 {
1909 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1910 struct ar9170 *ar = hw->priv;
1911
1912 return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1913 }
1914
1915 int carl9170_register(struct ar9170 *ar)
1916 {
1917 struct ath_regulatory *regulatory = &ar->common.regulatory;
1918 int err = 0, i;
1919
1920 if (WARN_ON(ar->mem_bitmap))
1921 return -EINVAL;
1922
1923 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
1924 sizeof(unsigned long), GFP_KERNEL);
1925
1926 if (!ar->mem_bitmap)
1927 return -ENOMEM;
1928
1929 /* try to read EEPROM, init MAC addr */
1930 err = carl9170_read_eeprom(ar);
1931 if (err)
1932 return err;
1933
1934 err = carl9170_fw_fix_eeprom(ar);
1935 if (err)
1936 return err;
1937
1938 err = carl9170_parse_eeprom(ar);
1939 if (err)
1940 return err;
1941
1942 err = ath_regd_init(regulatory, ar->hw->wiphy,
1943 carl9170_reg_notifier);
1944 if (err)
1945 return err;
1946
1947 if (modparam_noht) {
1948 carl9170_band_2GHz.ht_cap.ht_supported = false;
1949 carl9170_band_5GHz.ht_cap.ht_supported = false;
1950 }
1951
1952 for (i = 0; i < ar->fw.vif_num; i++) {
1953 ar->vif_priv[i].id = i;
1954 ar->vif_priv[i].vif = NULL;
1955 }
1956
1957 err = ieee80211_register_hw(ar->hw);
1958 if (err)
1959 return err;
1960
1961 /* mac80211 interface is now registered */
1962 ar->registered = true;
1963
1964 if (!ath_is_world_regd(regulatory))
1965 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1966
1967 #ifdef CONFIG_CARL9170_DEBUGFS
1968 carl9170_debugfs_register(ar);
1969 #endif /* CONFIG_CARL9170_DEBUGFS */
1970
1971 err = carl9170_led_init(ar);
1972 if (err)
1973 goto err_unreg;
1974
1975 #ifdef CONFIG_CARL9170_LEDS
1976 err = carl9170_led_register(ar);
1977 if (err)
1978 goto err_unreg;
1979 #endif /* CONFIG_CARL9170_LEDS */
1980
1981 #ifdef CONFIG_CARL9170_WPC
1982 err = carl9170_register_wps_button(ar);
1983 if (err)
1984 goto err_unreg;
1985 #endif /* CONFIG_CARL9170_WPC */
1986
1987 #ifdef CONFIG_CARL9170_HWRNG
1988 err = carl9170_register_hwrng(ar);
1989 if (err)
1990 goto err_unreg;
1991 #endif /* CONFIG_CARL9170_HWRNG */
1992
1993 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
1994 wiphy_name(ar->hw->wiphy));
1995
1996 return 0;
1997
1998 err_unreg:
1999 carl9170_unregister(ar);
2000 return err;
2001 }
2002
2003 void carl9170_unregister(struct ar9170 *ar)
2004 {
2005 if (!ar->registered)
2006 return;
2007
2008 ar->registered = false;
2009
2010 #ifdef CONFIG_CARL9170_LEDS
2011 carl9170_led_unregister(ar);
2012 #endif /* CONFIG_CARL9170_LEDS */
2013
2014 #ifdef CONFIG_CARL9170_DEBUGFS
2015 carl9170_debugfs_unregister(ar);
2016 #endif /* CONFIG_CARL9170_DEBUGFS */
2017
2018 #ifdef CONFIG_CARL9170_WPC
2019 if (ar->wps.pbc) {
2020 input_unregister_device(ar->wps.pbc);
2021 ar->wps.pbc = NULL;
2022 }
2023 #endif /* CONFIG_CARL9170_WPC */
2024
2025 #ifdef CONFIG_CARL9170_HWRNG
2026 carl9170_unregister_hwrng(ar);
2027 #endif /* CONFIG_CARL9170_HWRNG */
2028
2029 carl9170_cancel_worker(ar);
2030 cancel_work_sync(&ar->restart_work);
2031
2032 ieee80211_unregister_hw(ar->hw);
2033 }
2034
2035 void carl9170_free(struct ar9170 *ar)
2036 {
2037 WARN_ON(ar->registered);
2038 WARN_ON(IS_INITIALIZED(ar));
2039
2040 kfree_skb(ar->rx_failover);
2041 ar->rx_failover = NULL;
2042
2043 kfree(ar->mem_bitmap);
2044 ar->mem_bitmap = NULL;
2045
2046 kfree(ar->survey);
2047 ar->survey = NULL;
2048
2049 mutex_destroy(&ar->mutex);
2050
2051 ieee80211_free_hw(ar->hw);
2052 }