]> git.proxmox.com Git - mirror_ubuntu-jammy-kernel.git/blob - drivers/net/wireless/ath/carl9170/main.c
projects / mirror_ubuntu-jammy-kernel.git / blob
? search:


f293b3ff475628a389c1337df81d24cb3b3b5640
[mirror_ubuntu-jammy-kernel.git] / drivers / net / wireless / ath / carl9170 / main.c
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
362 /* Set "disable hw crypto offload" whenever the module parameter
363 * nohwcrypt is true or if the firmware does not support it.
364 */
365 ar->disable_offload = modparam_nohwcrypt |
366 ar->fw.disable_offload_fw;
367 ar->rx_software_decryption = ar->disable_offload;
368
369 for (i = 0; i < ar->hw->queues; i++) {
370 ar->queue_stop_timeout[i] = jiffies;
371 ar->max_queue_stop_timeout[i] = 0;
372 }
373
374 atomic_set(&ar->mem_allocs, 0);
375
376 err = carl9170_usb_open(ar);
377 if (err)
378 goto out;
379
380 err = carl9170_init_mac(ar);
381 if (err)
382 goto out;
383
384 err = carl9170_set_qos(ar);
385 if (err)
386 goto out;
387
388 if (ar->fw.rx_filter) {
389 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA |
390 CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD);
391 if (err)
392 goto out;
393 }
394
395 err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER,
396 AR9170_DMA_TRIGGER_RXQ);
397 if (err)
398 goto out;
399
400 /* Clear key-cache */
401 for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) {
402 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
403 0, NULL, 0);
404 if (err)
405 goto out;
406
407 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
408 1, NULL, 0);
409 if (err)
410 goto out;
411
412 if (i < AR9170_CAM_MAX_USER) {
413 err = carl9170_disable_key(ar, i);
414 if (err)
415 goto out;
416 }
417 }
418
419 carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED);
420
421 ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
422 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
423
424 ieee80211_wake_queues(ar->hw);
425 err = 0;
426
427 out:
428 mutex_unlock(&ar->mutex);
429 return err;
430 }
431
432 static void carl9170_cancel_worker(struct ar9170 *ar)
433 {
434 cancel_delayed_work_sync(&ar->stat_work);
435 cancel_delayed_work_sync(&ar->tx_janitor);
436 #ifdef CONFIG_CARL9170_LEDS
437 cancel_delayed_work_sync(&ar->led_work);
438 #endif /* CONFIG_CARL9170_LEDS */
439 cancel_work_sync(&ar->ps_work);
440 cancel_work_sync(&ar->ping_work);
441 cancel_work_sync(&ar->ampdu_work);
442 }
443
444 static void carl9170_op_stop(struct ieee80211_hw *hw)
445 {
446 struct ar9170 *ar = hw->priv;
447
448 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
449
450 ieee80211_stop_queues(ar->hw);
451
452 mutex_lock(&ar->mutex);
453 if (IS_ACCEPTING_CMD(ar)) {
454 RCU_INIT_POINTER(ar->beacon_iter, NULL);
455
456 carl9170_led_set_state(ar, 0);
457
458 /* stop DMA */
459 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
460 carl9170_usb_stop(ar);
461 }
462
463 carl9170_zap_queues(ar);
464 mutex_unlock(&ar->mutex);
465
466 carl9170_cancel_worker(ar);
467 }
468
469 static void carl9170_restart_work(struct work_struct *work)
470 {
471 struct ar9170 *ar = container_of(work, struct ar9170,
472 restart_work);
473 int err = -EIO;
474
475 ar->usedkeys = 0;
476 ar->filter_state = 0;
477 carl9170_cancel_worker(ar);
478
479 mutex_lock(&ar->mutex);
480 if (!ar->force_usb_reset) {
481 err = carl9170_usb_restart(ar);
482 if (net_ratelimit()) {
483 if (err)
484 dev_err(&ar->udev->dev, "Failed to restart device (%d).\n", err);
485 else
486 dev_info(&ar->udev->dev, "device restarted successfully.\n");
487 }
488 }
489 carl9170_zap_queues(ar);
490 mutex_unlock(&ar->mutex);
491
492 if (!err && !ar->force_usb_reset) {
493 ar->restart_counter++;
494 atomic_set(&ar->pending_restarts, 0);
495
496 ieee80211_restart_hw(ar->hw);
497 } else {
498 /*
499 * The reset was unsuccessful and the device seems to
500 * be dead. But there's still one option: a low-level
501 * usb subsystem reset...
502 */
503
504 carl9170_usb_reset(ar);
505 }
506 }
507
508 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
509 {
510 carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
511
512 /*
513 * Sometimes, an error can trigger several different reset events.
514 * By ignoring these *surplus* reset events, the device won't be
515 * killed again, right after it has recovered.
516 */
517 if (atomic_inc_return(&ar->pending_restarts) > 1) {
518 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
519 return;
520 }
521
522 ieee80211_stop_queues(ar->hw);
523
524 dev_err(&ar->udev->dev, "restart device (%d)\n", r);
525
526 if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
527 !WARN_ON(r >= __CARL9170_RR_LAST))
528 ar->last_reason = r;
529
530 if (!ar->registered)
531 return;
532
533 if (!IS_ACCEPTING_CMD(ar) || ar->needs_full_reset)
534 ar->force_usb_reset = true;
535
536 ieee80211_queue_work(ar->hw, &ar->restart_work);
537
538 /*
539 * At this point, the device instance might have vanished/disabled.
540 * So, don't put any code which access the ar9170 struct
541 * without proper protection.
542 */
543 }
544
545 static void carl9170_ping_work(struct work_struct *work)
546 {
547 struct ar9170 *ar = container_of(work, struct ar9170, ping_work);
548 int err;
549
550 if (!IS_STARTED(ar))
551 return;
552
553 mutex_lock(&ar->mutex);
554 err = carl9170_echo_test(ar, 0xdeadbeef);
555 if (err)
556 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE);
557 mutex_unlock(&ar->mutex);
558 }
559
560 static int carl9170_init_interface(struct ar9170 *ar,
561 struct ieee80211_vif *vif)
562 {
563 struct ath_common *common = &ar->common;
564 int err;
565
566 if (!vif) {
567 WARN_ON_ONCE(IS_STARTED(ar));
568 return 0;
569 }
570
571 memcpy(common->macaddr, vif->addr, ETH_ALEN);
572
573 /* We have to fall back to software crypto, whenever
574 * the user choose to participates in an IBSS. HW
575 * offload for IBSS RSN is not supported by this driver.
576 *
577 * NOTE: If the previous main interface has already
578 * disabled hw crypto offload, we have to keep this
579 * previous disable_offload setting as it was.
580 * Altough ideally, we should notify mac80211 and tell
581 * it to forget about any HW crypto offload for now.
582 */
583 ar->disable_offload |= ((vif->type != NL80211_IFTYPE_STATION) &&
584 (vif->type != NL80211_IFTYPE_AP));
585
586 /* While the driver supports HW offload in a single
587 * P2P client configuration, it doesn't support HW
588 * offload in the favourit, concurrent P2P GO+CLIENT
589 * configuration. Hence, HW offload will always be
590 * disabled for P2P.
591 */
592 ar->disable_offload |= vif->p2p;
593
594 ar->rx_software_decryption = ar->disable_offload;
595
596 err = carl9170_set_operating_mode(ar);
597 return err;
598 }
599
600 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
601 struct ieee80211_vif *vif)
602 {
603 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
604 struct ieee80211_vif *main_vif, *old_main = NULL;
605 struct ar9170 *ar = hw->priv;
606 int vif_id = -1, err = 0;
607
608 mutex_lock(&ar->mutex);
609 rcu_read_lock();
610 if (vif_priv->active) {
611 /*
612 * Skip the interface structure initialization,
613 * if the vif survived the _restart call.
614 */
615 vif_id = vif_priv->id;
616 vif_priv->enable_beacon = false;
617
618 spin_lock_bh(&ar->beacon_lock);
619 dev_kfree_skb_any(vif_priv->beacon);
620 vif_priv->beacon = NULL;
621 spin_unlock_bh(&ar->beacon_lock);
622
623 goto init;
624 }
625
626 /* Because the AR9170 HW's MAC doesn't provide full support for
627 * multiple, independent interfaces [of different operation modes].
628 * We have to select ONE main interface [main mode of HW], but we
629 * can have multiple slaves [AKA: entry in the ACK-table].
630 *
631 * The first (from HEAD/TOP) interface in the ar->vif_list is
632 * always the main intf. All following intfs in this list
633 * are considered to be slave intfs.
634 */
635 main_vif = carl9170_get_main_vif(ar);
636
637 if (main_vif) {
638 switch (main_vif->type) {
639 case NL80211_IFTYPE_STATION:
640 if (vif->type == NL80211_IFTYPE_STATION)
641 break;
642
643 /* P2P GO [master] use-case
644 * Because the P2P GO station is selected dynamically
645 * by all participating peers of a WIFI Direct network,
646 * the driver has be able to change the main interface
647 * operating mode on the fly.
648 */
649 if (main_vif->p2p && vif->p2p &&
650 vif->type == NL80211_IFTYPE_AP) {
651 old_main = main_vif;
652 break;
653 }
654
655 err = -EBUSY;
656 rcu_read_unlock();
657
658 goto unlock;
659
660 case NL80211_IFTYPE_MESH_POINT:
661 case NL80211_IFTYPE_AP:
662 if ((vif->type == NL80211_IFTYPE_STATION) ||
663 (vif->type == NL80211_IFTYPE_WDS) ||
664 (vif->type == NL80211_IFTYPE_AP) ||
665 (vif->type == NL80211_IFTYPE_MESH_POINT))
666 break;
667
668 err = -EBUSY;
669 rcu_read_unlock();
670 goto unlock;
671
672 default:
673 rcu_read_unlock();
674 goto unlock;
675 }
676 }
677
678 vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
679
680 if (vif_id < 0) {
681 rcu_read_unlock();
682
683 err = -ENOSPC;
684 goto unlock;
685 }
686
687 BUG_ON(ar->vif_priv[vif_id].id != vif_id);
688
689 vif_priv->active = true;
690 vif_priv->id = vif_id;
691 vif_priv->enable_beacon = false;
692 ar->vifs++;
693 if (old_main) {
694 /* We end up in here, if the main interface is being replaced.
695 * Put the new main interface at the HEAD of the list and the
696 * previous inteface will automatically become second in line.
697 */
698 list_add_rcu(&vif_priv->list, &ar->vif_list);
699 } else {
700 /* Add new inteface. If the list is empty, it will become the
701 * main inteface, otherwise it will be slave.
702 */
703 list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
704 }
705 rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
706
707 init:
708 main_vif = carl9170_get_main_vif(ar);
709
710 if (main_vif == vif) {
711 rcu_assign_pointer(ar->beacon_iter, vif_priv);
712 rcu_read_unlock();
713
714 if (old_main) {
715 struct carl9170_vif_info *old_main_priv =
716 (void *) old_main->drv_priv;
717 /* downgrade old main intf to slave intf.
718 * NOTE: We are no longer under rcu_read_lock.
719 * But we are still holding ar->mutex, so the
720 * vif data [id, addr] is safe.
721 */
722 err = carl9170_mod_virtual_mac(ar, old_main_priv->id,
723 old_main->addr);
724 if (err)
725 goto unlock;
726 }
727
728 err = carl9170_init_interface(ar, vif);
729 if (err)
730 goto unlock;
731 } else {
732 rcu_read_unlock();
733 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
734
735 if (err)
736 goto unlock;
737 }
738
739 if (ar->fw.tx_seq_table) {
740 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4,
741 0);
742 if (err)
743 goto unlock;
744 }
745
746 unlock:
747 if (err && (vif_id >= 0)) {
748 vif_priv->active = false;
749 bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
750 ar->vifs--;
751 RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL);
752 list_del_rcu(&vif_priv->list);
753 mutex_unlock(&ar->mutex);
754 synchronize_rcu();
755 } else {
756 if (ar->vifs > 1)
757 ar->ps.off_override |= PS_OFF_VIF;
758
759 mutex_unlock(&ar->mutex);
760 }
761
762 return err;
763 }
764
765 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
766 struct ieee80211_vif *vif)
767 {
768 struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
769 struct ieee80211_vif *main_vif;
770 struct ar9170 *ar = hw->priv;
771 unsigned int id;
772
773 mutex_lock(&ar->mutex);
774
775 if (WARN_ON_ONCE(!vif_priv->active))
776 goto unlock;
777
778 ar->vifs--;
779
780 rcu_read_lock();
781 main_vif = carl9170_get_main_vif(ar);
782
783 id = vif_priv->id;
784
785 vif_priv->active = false;
786 WARN_ON(vif_priv->enable_beacon);
787 vif_priv->enable_beacon = false;
788 list_del_rcu(&vif_priv->list);
789 RCU_INIT_POINTER(ar->vif_priv[id].vif, NULL);
790
791 if (vif == main_vif) {
792 rcu_read_unlock();
793
794 if (ar->vifs) {
795 WARN_ON(carl9170_init_interface(ar,
796 carl9170_get_main_vif(ar)));
797 } else {
798 carl9170_set_operating_mode(ar);
799 }
800 } else {
801 rcu_read_unlock();
802
803 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
804 }
805
806 carl9170_update_beacon(ar, false);
807 carl9170_flush_cab(ar, id);
808
809 spin_lock_bh(&ar->beacon_lock);
810 dev_kfree_skb_any(vif_priv->beacon);
811 vif_priv->beacon = NULL;
812 spin_unlock_bh(&ar->beacon_lock);
813
814 bitmap_release_region(&ar->vif_bitmap, id, 0);
815
816 carl9170_set_beacon_timers(ar);
817
818 if (ar->vifs == 1)
819 ar->ps.off_override &= ~PS_OFF_VIF;
820
821 unlock:
822 mutex_unlock(&ar->mutex);
823
824 synchronize_rcu();
825 }
826
827 void carl9170_ps_check(struct ar9170 *ar)
828 {
829 ieee80211_queue_work(ar->hw, &ar->ps_work);
830 }
831
832 /* caller must hold ar->mutex */
833 static int carl9170_ps_update(struct ar9170 *ar)
834 {
835 bool ps = false;
836 int err = 0;
837
838 if (!ar->ps.off_override)
839 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
840
841 if (ps != ar->ps.state) {
842 err = carl9170_powersave(ar, ps);
843 if (err)
844 return err;
845
846 if (ar->ps.state && !ps) {
847 ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
848 ar->ps.last_action);
849 }
850
851 if (ps)
852 ar->ps.last_slept = jiffies;
853
854 ar->ps.last_action = jiffies;
855 ar->ps.state = ps;
856 }
857
858 return 0;
859 }
860
861 static void carl9170_ps_work(struct work_struct *work)
862 {
863 struct ar9170 *ar = container_of(work, struct ar9170,
864 ps_work);
865 mutex_lock(&ar->mutex);
866 if (IS_STARTED(ar))
867 WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
868 mutex_unlock(&ar->mutex);
869 }
870
871 static int carl9170_update_survey(struct ar9170 *ar, bool flush, bool noise)
872 {
873 int err;
874
875 if (noise) {
876 err = carl9170_get_noisefloor(ar);
877 if (err)
878 return err;
879 }
880
881 if (ar->fw.hw_counters) {
882 err = carl9170_collect_tally(ar);
883 if (err)
884 return err;
885 }
886
887 if (flush)
888 memset(&ar->tally, 0, sizeof(ar->tally));
889
890 return 0;
891 }
892
893 static void carl9170_stat_work(struct work_struct *work)
894 {
895 struct ar9170 *ar = container_of(work, struct ar9170, stat_work.work);
896 int err;
897
898 mutex_lock(&ar->mutex);
899 err = carl9170_update_survey(ar, false, true);
900 mutex_unlock(&ar->mutex);
901
902 if (err)
903 return;
904
905 ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
906 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
907 }
908
909 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
910 {
911 struct ar9170 *ar = hw->priv;
912 int err = 0;
913
914 mutex_lock(&ar->mutex);
915 if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
916 /* TODO */
917 err = 0;
918 }
919
920 if (changed & IEEE80211_CONF_CHANGE_PS) {
921 err = carl9170_ps_update(ar);
922 if (err)
923 goto out;
924 }
925
926 if (changed & IEEE80211_CONF_CHANGE_SMPS) {
927 /* TODO */
928 err = 0;
929 }
930
931 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
932 /* adjust slot time for 5 GHz */
933 err = carl9170_set_slot_time(ar);
934 if (err)
935 goto out;
936
937 err = carl9170_update_survey(ar, true, false);
938 if (err)
939 goto out;
940
941 err = carl9170_set_channel(ar, hw->conf.channel,
942 hw->conf.channel_type, CARL9170_RFI_NONE);
943 if (err)
944 goto out;
945
946 err = carl9170_update_survey(ar, false, true);
947 if (err)
948 goto out;
949
950 err = carl9170_set_dyn_sifs_ack(ar);
951 if (err)
952 goto out;
953
954 err = carl9170_set_rts_cts_rate(ar);
955 if (err)
956 goto out;
957 }
958
959 if (changed & IEEE80211_CONF_CHANGE_POWER) {
960 err = carl9170_set_mac_tpc(ar, ar->hw->conf.channel);
961 if (err)
962 goto out;
963 }
964
965 out:
966 mutex_unlock(&ar->mutex);
967 return err;
968 }
969
970 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
971 struct netdev_hw_addr_list *mc_list)
972 {
973 struct netdev_hw_addr *ha;
974 u64 mchash;
975
976 /* always get broadcast frames */
977 mchash = 1ULL << (0xff >> 2);
978
979 netdev_hw_addr_list_for_each(ha, mc_list)
980 mchash |= 1ULL << (ha->addr[5] >> 2);
981
982 return mchash;
983 }
984
985 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
986 unsigned int changed_flags,
987 unsigned int *new_flags,
988 u64 multicast)
989 {
990 struct ar9170 *ar = hw->priv;
991
992 /* mask supported flags */
993 *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
994
995 if (!IS_ACCEPTING_CMD(ar))
996 return;
997
998 mutex_lock(&ar->mutex);
999
1000 ar->filter_state = *new_flags;
1001 /*
1002 * We can support more by setting the sniffer bit and
1003 * then checking the error flags, later.
1004 */
1005
1006 if (*new_flags & FIF_ALLMULTI)
1007 multicast = ~0ULL;
1008
1009 if (multicast != ar->cur_mc_hash)
1010 WARN_ON(carl9170_update_multicast(ar, multicast));
1011
1012 if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
1013 ar->sniffer_enabled = !!(*new_flags &
1014 (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS));
1015
1016 WARN_ON(carl9170_set_operating_mode(ar));
1017 }
1018
1019 if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) {
1020 u32 rx_filter = 0;
1021
1022 if (!ar->fw.ba_filter)
1023 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
1024
1025 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL)))
1026 rx_filter |= CARL9170_RX_FILTER_BAD;
1027
1028 if (!(*new_flags & FIF_CONTROL))
1029 rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
1030
1031 if (!(*new_flags & FIF_PSPOLL))
1032 rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL;
1033
1034 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) {
1035 rx_filter |= CARL9170_RX_FILTER_OTHER_RA;
1036 rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL;
1037 }
1038
1039 WARN_ON(carl9170_rx_filter(ar, rx_filter));
1040 }
1041
1042 mutex_unlock(&ar->mutex);
1043 }
1044
1045
1046 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw,
1047 struct ieee80211_vif *vif,
1048 struct ieee80211_bss_conf *bss_conf,
1049 u32 changed)
1050 {
1051 struct ar9170 *ar = hw->priv;
1052 struct ath_common *common = &ar->common;
1053 int err = 0;
1054 struct carl9170_vif_info *vif_priv;
1055 struct ieee80211_vif *main_vif;
1056
1057 mutex_lock(&ar->mutex);
1058 vif_priv = (void *) vif->drv_priv;
1059 main_vif = carl9170_get_main_vif(ar);
1060 if (WARN_ON(!main_vif))
1061 goto out;
1062
1063 if (changed & BSS_CHANGED_BEACON_ENABLED) {
1064 struct carl9170_vif_info *iter;
1065 int i = 0;
1066
1067 vif_priv->enable_beacon = bss_conf->enable_beacon;
1068 rcu_read_lock();
1069 list_for_each_entry_rcu(iter, &ar->vif_list, list) {
1070 if (iter->active && iter->enable_beacon)
1071 i++;
1072
1073 }
1074 rcu_read_unlock();
1075
1076 ar->beacon_enabled = i;
1077 }
1078
1079 if (changed & BSS_CHANGED_BEACON) {
1080 err = carl9170_update_beacon(ar, false);
1081 if (err)
1082 goto out;
1083 }
1084
1085 if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON |
1086 BSS_CHANGED_BEACON_INT)) {
1087
1088 if (main_vif != vif) {
1089 bss_conf->beacon_int = main_vif->bss_conf.beacon_int;
1090 bss_conf->dtim_period = main_vif->bss_conf.dtim_period;
1091 }
1092
1093 /*
1094 * Therefore a hard limit for the broadcast traffic should
1095 * prevent false alarms.
1096 */
1097 if (vif->type != NL80211_IFTYPE_STATION &&
1098 (bss_conf->beacon_int * bss_conf->dtim_period >=
1099 (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) {
1100 err = -EINVAL;
1101 goto out;
1102 }
1103
1104 err = carl9170_set_beacon_timers(ar);
1105 if (err)
1106 goto out;
1107 }
1108
1109 if (changed & BSS_CHANGED_HT) {
1110 /* TODO */
1111 err = 0;
1112 if (err)
1113 goto out;
1114 }
1115
1116 if (main_vif != vif)
1117 goto out;
1118
1119 /*
1120 * The following settings can only be changed by the
1121 * master interface.
1122 */
1123
1124 if (changed & BSS_CHANGED_BSSID) {
1125 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1126 err = carl9170_set_operating_mode(ar);
1127 if (err)
1128 goto out;
1129 }
1130
1131 if (changed & BSS_CHANGED_ASSOC) {
1132 ar->common.curaid = bss_conf->aid;
1133 err = carl9170_set_beacon_timers(ar);
1134 if (err)
1135 goto out;
1136 }
1137
1138 if (changed & BSS_CHANGED_ERP_SLOT) {
1139 err = carl9170_set_slot_time(ar);
1140 if (err)
1141 goto out;
1142 }
1143
1144 if (changed & BSS_CHANGED_BASIC_RATES) {
1145 err = carl9170_set_mac_rates(ar);
1146 if (err)
1147 goto out;
1148 }
1149
1150 out:
1151 WARN_ON_ONCE(err && IS_STARTED(ar));
1152 mutex_unlock(&ar->mutex);
1153 }
1154
1155 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw,
1156 struct ieee80211_vif *vif)
1157 {
1158 struct ar9170 *ar = hw->priv;
1159 struct carl9170_tsf_rsp tsf;
1160 int err;
1161
1162 mutex_lock(&ar->mutex);
1163 err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF,
1164 0, NULL, sizeof(tsf), &tsf);
1165 mutex_unlock(&ar->mutex);
1166 if (WARN_ON(err))
1167 return 0;
1168
1169 return le64_to_cpu(tsf.tsf_64);
1170 }
1171
1172 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1173 struct ieee80211_vif *vif,
1174 struct ieee80211_sta *sta,
1175 struct ieee80211_key_conf *key)
1176 {
1177 struct ar9170 *ar = hw->priv;
1178 int err = 0, i;
1179 u8 ktype;
1180
1181 if (ar->disable_offload || !vif)
1182 return -EOPNOTSUPP;
1183
1184 /* Fall back to software encryption whenever the driver is connected
1185 * to more than one network.
1186 *
1187 * This is very unfortunate, because some machines cannot handle
1188 * the high througput speed in 802.11n networks.
1189 */
1190
1191 if (!is_main_vif(ar, vif)) {
1192 mutex_lock(&ar->mutex);
1193 goto err_softw;
1194 }
1195
1196 /*
1197 * While the hardware supports *catch-all* key, for offloading
1198 * group-key en-/de-cryption. The way of how the hardware
1199 * decides which keyId maps to which key, remains a mystery...
1200 */
1201 if ((vif->type != NL80211_IFTYPE_STATION &&
1202 vif->type != NL80211_IFTYPE_ADHOC) &&
1203 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1204 return -EOPNOTSUPP;
1205
1206 switch (key->cipher) {
1207 case WLAN_CIPHER_SUITE_WEP40:
1208 ktype = AR9170_ENC_ALG_WEP64;
1209 break;
1210 case WLAN_CIPHER_SUITE_WEP104:
1211 ktype = AR9170_ENC_ALG_WEP128;
1212 break;
1213 case WLAN_CIPHER_SUITE_TKIP:
1214 ktype = AR9170_ENC_ALG_TKIP;
1215 break;
1216 case WLAN_CIPHER_SUITE_CCMP:
1217 ktype = AR9170_ENC_ALG_AESCCMP;
1218 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1219 break;
1220 default:
1221 return -EOPNOTSUPP;
1222 }
1223
1224 mutex_lock(&ar->mutex);
1225 if (cmd == SET_KEY) {
1226 if (!IS_STARTED(ar)) {
1227 err = -EOPNOTSUPP;
1228 goto out;
1229 }
1230
1231 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1232 sta = NULL;
1233
1234 i = 64 + key->keyidx;
1235 } else {
1236 for (i = 0; i < 64; i++)
1237 if (!(ar->usedkeys & BIT(i)))
1238 break;
1239 if (i == 64)
1240 goto err_softw;
1241 }
1242
1243 key->hw_key_idx = i;
1244
1245 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1246 ktype, 0, key->key,
1247 min_t(u8, 16, key->keylen));
1248 if (err)
1249 goto out;
1250
1251 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1252 err = carl9170_upload_key(ar, i, sta ? sta->addr :
1253 NULL, ktype, 1,
1254 key->key + 16, 16);
1255 if (err)
1256 goto out;
1257
1258 /*
1259 * hardware is not capable generating MMIC
1260 * of fragmented frames!
1261 */
1262 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1263 }
1264
1265 if (i < 64)
1266 ar->usedkeys |= BIT(i);
1267
1268 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1269 } else {
1270 if (!IS_STARTED(ar)) {
1271 /* The device is gone... together with the key ;-) */
1272 err = 0;
1273 goto out;
1274 }
1275
1276 if (key->hw_key_idx < 64) {
1277 ar->usedkeys &= ~BIT(key->hw_key_idx);
1278 } else {
1279 err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1280 AR9170_ENC_ALG_NONE, 0,
1281 NULL, 0);
1282 if (err)
1283 goto out;
1284
1285 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1286 err = carl9170_upload_key(ar, key->hw_key_idx,
1287 NULL,
1288 AR9170_ENC_ALG_NONE,
1289 1, NULL, 0);
1290 if (err)
1291 goto out;
1292 }
1293
1294 }
1295
1296 err = carl9170_disable_key(ar, key->hw_key_idx);
1297 if (err)
1298 goto out;
1299 }
1300
1301 out:
1302 mutex_unlock(&ar->mutex);
1303 return err;
1304
1305 err_softw:
1306 if (!ar->rx_software_decryption) {
1307 ar->rx_software_decryption = true;
1308 carl9170_set_operating_mode(ar);
1309 }
1310 mutex_unlock(&ar->mutex);
1311 return -ENOSPC;
1312 }
1313
1314 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1315 struct ieee80211_vif *vif,
1316 struct ieee80211_sta *sta)
1317 {
1318 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1319 unsigned int i;
1320
1321 atomic_set(&sta_info->pending_frames, 0);
1322
1323 if (sta->ht_cap.ht_supported) {
1324 if (sta->ht_cap.ampdu_density > 6) {
1325 /*
1326 * HW does support 16us AMPDU density.
1327 * No HT-Xmit for station.
1328 */
1329
1330 return 0;
1331 }
1332
1333 for (i = 0; i < ARRAY_SIZE(sta_info->agg); i++)
1334 RCU_INIT_POINTER(sta_info->agg[i], NULL);
1335
1336 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor);
1337 sta_info->ht_sta = true;
1338 }
1339
1340 return 0;
1341 }
1342
1343 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1344 struct ieee80211_vif *vif,
1345 struct ieee80211_sta *sta)
1346 {
1347 struct ar9170 *ar = hw->priv;
1348 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1349 unsigned int i;
1350 bool cleanup = false;
1351
1352 if (sta->ht_cap.ht_supported) {
1353
1354 sta_info->ht_sta = false;
1355
1356 rcu_read_lock();
1357 for (i = 0; i < ARRAY_SIZE(sta_info->agg); i++) {
1358 struct carl9170_sta_tid *tid_info;
1359
1360 tid_info = rcu_dereference(sta_info->agg[i]);
1361 RCU_INIT_POINTER(sta_info->agg[i], NULL);
1362
1363 if (!tid_info)
1364 continue;
1365
1366 spin_lock_bh(&ar->tx_ampdu_list_lock);
1367 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1368 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1369 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1370 cleanup = true;
1371 }
1372 rcu_read_unlock();
1373
1374 if (cleanup)
1375 carl9170_ampdu_gc(ar);
1376 }
1377
1378 return 0;
1379 }
1380
1381 static int carl9170_op_conf_tx(struct ieee80211_hw *hw,
1382 struct ieee80211_vif *vif, u16 queue,
1383 const struct ieee80211_tx_queue_params *param)
1384 {
1385 struct ar9170 *ar = hw->priv;
1386 int ret;
1387
1388 mutex_lock(&ar->mutex);
1389 if (queue < ar->hw->queues) {
1390 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param));
1391 ret = carl9170_set_qos(ar);
1392 } else {
1393 ret = -EINVAL;
1394 }
1395
1396 mutex_unlock(&ar->mutex);
1397 return ret;
1398 }
1399
1400 static void carl9170_ampdu_work(struct work_struct *work)
1401 {
1402 struct ar9170 *ar = container_of(work, struct ar9170,
1403 ampdu_work);
1404
1405 if (!IS_STARTED(ar))
1406 return;
1407
1408 mutex_lock(&ar->mutex);
1409 carl9170_ampdu_gc(ar);
1410 mutex_unlock(&ar->mutex);
1411 }
1412
1413 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1414 struct ieee80211_vif *vif,
1415 enum ieee80211_ampdu_mlme_action action,
1416 struct ieee80211_sta *sta,
1417 u16 tid, u16 *ssn, u8 buf_size)
1418 {
1419 struct ar9170 *ar = hw->priv;
1420 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1421 struct carl9170_sta_tid *tid_info;
1422
1423 if (modparam_noht)
1424 return -EOPNOTSUPP;
1425
1426 switch (action) {
1427 case IEEE80211_AMPDU_TX_START:
1428 if (!sta_info->ht_sta)
1429 return -EOPNOTSUPP;
1430
1431 rcu_read_lock();
1432 if (rcu_dereference(sta_info->agg[tid])) {
1433 rcu_read_unlock();
1434 return -EBUSY;
1435 }
1436
1437 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1438 GFP_ATOMIC);
1439 if (!tid_info) {
1440 rcu_read_unlock();
1441 return -ENOMEM;
1442 }
1443
1444 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1445 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1446 tid_info->tid = tid;
1447 tid_info->max = sta_info->ampdu_max_len;
1448
1449 INIT_LIST_HEAD(&tid_info->list);
1450 INIT_LIST_HEAD(&tid_info->tmp_list);
1451 skb_queue_head_init(&tid_info->queue);
1452 spin_lock_init(&tid_info->lock);
1453
1454 spin_lock_bh(&ar->tx_ampdu_list_lock);
1455 ar->tx_ampdu_list_len++;
1456 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1457 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1458 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1459 rcu_read_unlock();
1460
1461 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1462 break;
1463
1464 case IEEE80211_AMPDU_TX_STOP_CONT:
1465 case IEEE80211_AMPDU_TX_STOP_FLUSH:
1466 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1467 rcu_read_lock();
1468 tid_info = rcu_dereference(sta_info->agg[tid]);
1469 if (tid_info) {
1470 spin_lock_bh(&ar->tx_ampdu_list_lock);
1471 if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1472 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1473 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1474 }
1475
1476 RCU_INIT_POINTER(sta_info->agg[tid], NULL);
1477 rcu_read_unlock();
1478
1479 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1480 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1481 break;
1482
1483 case IEEE80211_AMPDU_TX_OPERATIONAL:
1484 rcu_read_lock();
1485 tid_info = rcu_dereference(sta_info->agg[tid]);
1486
1487 sta_info->stats[tid].clear = true;
1488 sta_info->stats[tid].req = false;
1489
1490 if (tid_info) {
1491 bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1492 tid_info->state = CARL9170_TID_STATE_IDLE;
1493 }
1494 rcu_read_unlock();
1495
1496 if (WARN_ON_ONCE(!tid_info))
1497 return -EFAULT;
1498
1499 break;
1500
1501 case IEEE80211_AMPDU_RX_START:
1502 case IEEE80211_AMPDU_RX_STOP:
1503 /* Handled by hardware */
1504 break;
1505
1506 default:
1507 return -EOPNOTSUPP;
1508 }
1509
1510 return 0;
1511 }
1512
1513 #ifdef CONFIG_CARL9170_WPC
1514 static int carl9170_register_wps_button(struct ar9170 *ar)
1515 {
1516 struct input_dev *input;
1517 int err;
1518
1519 if (!(ar->features & CARL9170_WPS_BUTTON))
1520 return 0;
1521
1522 input = input_allocate_device();
1523 if (!input)
1524 return -ENOMEM;
1525
1526 snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1527 wiphy_name(ar->hw->wiphy));
1528
1529 snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1530 "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1531
1532 input->name = ar->wps.name;
1533 input->phys = ar->wps.phys;
1534 input->id.bustype = BUS_USB;
1535 input->dev.parent = &ar->hw->wiphy->dev;
1536
1537 input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1538
1539 err = input_register_device(input);
1540 if (err) {
1541 input_free_device(input);
1542 return err;
1543 }
1544
1545 ar->wps.pbc = input;
1546 return 0;
1547 }
1548 #endif /* CONFIG_CARL9170_WPC */
1549
1550 #ifdef CONFIG_CARL9170_HWRNG
1551 static int carl9170_rng_get(struct ar9170 *ar)
1552 {
1553
1554 #define RW (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32))
1555 #define RB (CARL9170_MAX_CMD_PAYLOAD_LEN)
1556
1557 static const __le32 rng_load[RW] = {
1558 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)};
1559
1560 u32 buf[RW];
1561
1562 unsigned int i, off = 0, transfer, count;
1563 int err;
1564
1565 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN);
1566
1567 if (!IS_ACCEPTING_CMD(ar) || !ar->rng.initialized)
1568 return -EAGAIN;
1569
1570 count = ARRAY_SIZE(ar->rng.cache);
1571 while (count) {
1572 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1573 RB, (u8 *) rng_load,
1574 RB, (u8 *) buf);
1575 if (err)
1576 return err;
1577
1578 transfer = min_t(unsigned int, count, RW);
1579 for (i = 0; i < transfer; i++)
1580 ar->rng.cache[off + i] = buf[i];
1581
1582 off += transfer;
1583 count -= transfer;
1584 }
1585
1586 ar->rng.cache_idx = 0;
1587
1588 #undef RW
1589 #undef RB
1590 return 0;
1591 }
1592
1593 static int carl9170_rng_read(struct hwrng *rng, u32 *data)
1594 {
1595 struct ar9170 *ar = (struct ar9170 *)rng->priv;
1596 int ret = -EIO;
1597
1598 mutex_lock(&ar->mutex);
1599 if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) {
1600 ret = carl9170_rng_get(ar);
1601 if (ret) {
1602 mutex_unlock(&ar->mutex);
1603 return ret;
1604 }
1605 }
1606
1607 *data = ar->rng.cache[ar->rng.cache_idx++];
1608 mutex_unlock(&ar->mutex);
1609
1610 return sizeof(u16);
1611 }
1612
1613 static void carl9170_unregister_hwrng(struct ar9170 *ar)
1614 {
1615 if (ar->rng.initialized) {
1616 hwrng_unregister(&ar->rng.rng);
1617 ar->rng.initialized = false;
1618 }
1619 }
1620
1621 static int carl9170_register_hwrng(struct ar9170 *ar)
1622 {
1623 int err;
1624
1625 snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name),
1626 "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy));
1627 ar->rng.rng.name = ar->rng.name;
1628 ar->rng.rng.data_read = carl9170_rng_read;
1629 ar->rng.rng.priv = (unsigned long)ar;
1630
1631 if (WARN_ON(ar->rng.initialized))
1632 return -EALREADY;
1633
1634 err = hwrng_register(&ar->rng.rng);
1635 if (err) {
1636 dev_err(&ar->udev->dev, "Failed to register the random "
1637 "number generator (%d)\n", err);
1638 return err;
1639 }
1640
1641 ar->rng.initialized = true;
1642
1643 err = carl9170_rng_get(ar);
1644 if (err) {
1645 carl9170_unregister_hwrng(ar);
1646 return err;
1647 }
1648
1649 return 0;
1650 }
1651 #endif /* CONFIG_CARL9170_HWRNG */
1652
1653 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1654 struct survey_info *survey)
1655 {
1656 struct ar9170 *ar = hw->priv;
1657 struct ieee80211_channel *chan;
1658 struct ieee80211_supported_band *band;
1659 int err, b, i;
1660
1661 chan = ar->channel;
1662 if (!chan)
1663 return -ENODEV;
1664
1665 if (idx == chan->hw_value) {
1666 mutex_lock(&ar->mutex);
1667 err = carl9170_update_survey(ar, false, true);
1668 mutex_unlock(&ar->mutex);
1669 if (err)
1670 return err;
1671 }
1672
1673 for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
1674 band = ar->hw->wiphy->bands[b];
1675
1676 if (!band)
1677 continue;
1678
1679 for (i = 0; i < band->n_channels; i++) {
1680 if (band->channels[i].hw_value == idx) {
1681 chan = &band->channels[i];
1682 goto found;
1683 }
1684 }
1685 }
1686 return -ENOENT;
1687
1688 found:
1689 memcpy(survey, &ar->survey[idx], sizeof(*survey));
1690
1691 survey->channel = chan;
1692 survey->filled = SURVEY_INFO_NOISE_DBM;
1693
1694 if (ar->channel == chan)
1695 survey->filled |= SURVEY_INFO_IN_USE;
1696
1697 if (ar->fw.hw_counters) {
1698 survey->filled |= SURVEY_INFO_CHANNEL_TIME |
1699 SURVEY_INFO_CHANNEL_TIME_BUSY |
1700 SURVEY_INFO_CHANNEL_TIME_TX;
1701 }
1702
1703 return 0;
1704 }
1705
1706 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1707 {
1708 struct ar9170 *ar = hw->priv;
1709 unsigned int vid;
1710
1711 mutex_lock(&ar->mutex);
1712 for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1713 carl9170_flush_cab(ar, vid);
1714
1715 carl9170_flush(ar, drop);
1716 mutex_unlock(&ar->mutex);
1717 }
1718
1719 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1720 struct ieee80211_low_level_stats *stats)
1721 {
1722 struct ar9170 *ar = hw->priv;
1723
1724 memset(stats, 0, sizeof(*stats));
1725 stats->dot11ACKFailureCount = ar->tx_ack_failures;
1726 stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1727 return 0;
1728 }
1729
1730 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1731 struct ieee80211_vif *vif,
1732 enum sta_notify_cmd cmd,
1733 struct ieee80211_sta *sta)
1734 {
1735 struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1736
1737 switch (cmd) {
1738 case STA_NOTIFY_SLEEP:
1739 sta_info->sleeping = true;
1740 if (atomic_read(&sta_info->pending_frames))
1741 ieee80211_sta_block_awake(hw, sta, true);
1742 break;
1743
1744 case STA_NOTIFY_AWAKE:
1745 sta_info->sleeping = false;
1746 break;
1747 }
1748 }
1749
1750 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1751 {
1752 struct ar9170 *ar = hw->priv;
1753
1754 return !!atomic_read(&ar->tx_total_queued);
1755 }
1756
1757 static const struct ieee80211_ops carl9170_ops = {
1758 .start = carl9170_op_start,
1759 .stop = carl9170_op_stop,
1760 .tx = carl9170_op_tx,
1761 .flush = carl9170_op_flush,
1762 .add_interface = carl9170_op_add_interface,
1763 .remove_interface = carl9170_op_remove_interface,
1764 .config = carl9170_op_config,
1765 .prepare_multicast = carl9170_op_prepare_multicast,
1766 .configure_filter = carl9170_op_configure_filter,
1767 .conf_tx = carl9170_op_conf_tx,
1768 .bss_info_changed = carl9170_op_bss_info_changed,
1769 .get_tsf = carl9170_op_get_tsf,
1770 .set_key = carl9170_op_set_key,
1771 .sta_add = carl9170_op_sta_add,
1772 .sta_remove = carl9170_op_sta_remove,
1773 .sta_notify = carl9170_op_sta_notify,
1774 .get_survey = carl9170_op_get_survey,
1775 .get_stats = carl9170_op_get_stats,
1776 .ampdu_action = carl9170_op_ampdu_action,
1777 .tx_frames_pending = carl9170_tx_frames_pending,
1778 };
1779
1780 void *carl9170_alloc(size_t priv_size)
1781 {
1782 struct ieee80211_hw *hw;
1783 struct ar9170 *ar;
1784 struct sk_buff *skb;
1785 int i;
1786
1787 /*
1788 * this buffer is used for rx stream reconstruction.
1789 * Under heavy load this device (or the transport layer?)
1790 * tends to split the streams into separate rx descriptors.
1791 */
1792
1793 skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1794 if (!skb)
1795 goto err_nomem;
1796
1797 hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1798 if (!hw)
1799 goto err_nomem;
1800
1801 ar = hw->priv;
1802 ar->hw = hw;
1803 ar->rx_failover = skb;
1804
1805 memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1806 ar->rx_has_plcp = false;
1807
1808 /*
1809 * Here's a hidden pitfall!
1810 *
1811 * All 4 AC queues work perfectly well under _legacy_ operation.
1812 * However as soon as aggregation is enabled, the traffic flow
1813 * gets very bumpy. Therefore we have to _switch_ to a
1814 * software AC with a single HW queue.
1815 */
1816 hw->queues = __AR9170_NUM_TXQ;
1817
1818 mutex_init(&ar->mutex);
1819 spin_lock_init(&ar->beacon_lock);
1820 spin_lock_init(&ar->cmd_lock);
1821 spin_lock_init(&ar->tx_stats_lock);
1822 spin_lock_init(&ar->tx_ampdu_list_lock);
1823 spin_lock_init(&ar->mem_lock);
1824 spin_lock_init(&ar->state_lock);
1825 atomic_set(&ar->pending_restarts, 0);
1826 ar->vifs = 0;
1827 for (i = 0; i < ar->hw->queues; i++) {
1828 skb_queue_head_init(&ar->tx_status[i]);
1829 skb_queue_head_init(&ar->tx_pending[i]);
1830
1831 INIT_LIST_HEAD(&ar->bar_list[i]);
1832 spin_lock_init(&ar->bar_list_lock[i]);
1833 }
1834 INIT_WORK(&ar->ps_work, carl9170_ps_work);
1835 INIT_WORK(&ar->ping_work, carl9170_ping_work);
1836 INIT_WORK(&ar->restart_work, carl9170_restart_work);
1837 INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1838 INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1839 INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1840 INIT_LIST_HEAD(&ar->tx_ampdu_list);
1841 rcu_assign_pointer(ar->tx_ampdu_iter,
1842 (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1843
1844 bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1845 INIT_LIST_HEAD(&ar->vif_list);
1846 init_completion(&ar->tx_flush);
1847
1848 /* firmware decides which modes we support */
1849 hw->wiphy->interface_modes = 0;
1850
1851 hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1852 IEEE80211_HW_MFP_CAPABLE |
1853 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1854 IEEE80211_HW_SUPPORTS_PS |
1855 IEEE80211_HW_PS_NULLFUNC_STACK |
1856 IEEE80211_HW_NEED_DTIM_BEFORE_ASSOC |
1857 IEEE80211_HW_SIGNAL_DBM;
1858
1859 if (!modparam_noht) {
1860 /*
1861 * see the comment above, why we allow the user
1862 * to disable HT by a module parameter.
1863 */
1864 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1865 }
1866
1867 hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1868 hw->sta_data_size = sizeof(struct carl9170_sta_info);
1869 hw->vif_data_size = sizeof(struct carl9170_vif_info);
1870
1871 hw->max_rates = CARL9170_TX_MAX_RATES;
1872 hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1873
1874 for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1875 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1876
1877 return ar;
1878
1879 err_nomem:
1880 kfree_skb(skb);
1881 return ERR_PTR(-ENOMEM);
1882 }
1883
1884 static int carl9170_read_eeprom(struct ar9170 *ar)
1885 {
1886 #define RW 8 /* number of words to read at once */
1887 #define RB (sizeof(u32) * RW)
1888 u8 *eeprom = (void *)&ar->eeprom;
1889 __le32 offsets[RW];
1890 int i, j, err;
1891
1892 BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1893
1894 BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1895 #ifndef __CHECKER__
1896 /* don't want to handle trailing remains */
1897 BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1898 #endif
1899
1900 for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1901 for (j = 0; j < RW; j++)
1902 offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1903 RB * i + 4 * j);
1904
1905 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1906 RB, (u8 *) &offsets,
1907 RB, eeprom + RB * i);
1908 if (err)
1909 return err;
1910 }
1911
1912 #undef RW
1913 #undef RB
1914 return 0;
1915 }
1916
1917 static int carl9170_parse_eeprom(struct ar9170 *ar)
1918 {
1919 struct ath_regulatory *regulatory = &ar->common.regulatory;
1920 unsigned int rx_streams, tx_streams, tx_params = 0;
1921 int bands = 0;
1922 int chans = 0;
1923
1924 if (ar->eeprom.length == cpu_to_le16(0xffff))
1925 return -ENODATA;
1926
1927 rx_streams = hweight8(ar->eeprom.rx_mask);
1928 tx_streams = hweight8(ar->eeprom.tx_mask);
1929
1930 if (rx_streams != tx_streams) {
1931 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1932
1933 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1934 IEEE80211_HT_MCS_TX_MAX_STREAMS));
1935
1936 tx_params = (tx_streams - 1) <<
1937 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1938
1939 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1940 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1941 }
1942
1943 if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1944 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1945 &carl9170_band_2GHz;
1946 chans += carl9170_band_2GHz.n_channels;
1947 bands++;
1948 }
1949 if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1950 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1951 &carl9170_band_5GHz;
1952 chans += carl9170_band_5GHz.n_channels;
1953 bands++;
1954 }
1955
1956 if (!bands)
1957 return -EINVAL;
1958
1959 ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL);
1960 if (!ar->survey)
1961 return -ENOMEM;
1962 ar->num_channels = chans;
1963
1964 /*
1965 * I measured this, a bandswitch takes roughly
1966 * 135 ms and a frequency switch about 80.
1967 *
1968 * FIXME: measure these values again once EEPROM settings
1969 * are used, that will influence them!
1970 */
1971 if (bands == 2)
1972 ar->hw->channel_change_time = 135 * 1000;
1973 else
1974 ar->hw->channel_change_time = 80 * 1000;
1975
1976 regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1977
1978 /* second part of wiphy init */
1979 SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1980
1981 return 0;
1982 }
1983
1984 static void carl9170_reg_notifier(struct wiphy *wiphy,
1985 struct regulatory_request *request)
1986 {
1987 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1988 struct ar9170 *ar = hw->priv;
1989
1990 ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1991 }
1992
1993 int carl9170_register(struct ar9170 *ar)
1994 {
1995 struct ath_regulatory *regulatory = &ar->common.regulatory;
1996 int err = 0, i;
1997
1998 if (WARN_ON(ar->mem_bitmap))
1999 return -EINVAL;
2000
2001 ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
2002 sizeof(unsigned long), GFP_KERNEL);
2003
2004 if (!ar->mem_bitmap)
2005 return -ENOMEM;
2006
2007 /* try to read EEPROM, init MAC addr */
2008 err = carl9170_read_eeprom(ar);
2009 if (err)
2010 return err;
2011
2012 err = carl9170_parse_eeprom(ar);
2013 if (err)
2014 return err;
2015
2016 err = ath_regd_init(regulatory, ar->hw->wiphy,
2017 carl9170_reg_notifier);
2018 if (err)
2019 return err;
2020
2021 if (modparam_noht) {
2022 carl9170_band_2GHz.ht_cap.ht_supported = false;
2023 carl9170_band_5GHz.ht_cap.ht_supported = false;
2024 }
2025
2026 for (i = 0; i < ar->fw.vif_num; i++) {
2027 ar->vif_priv[i].id = i;
2028 ar->vif_priv[i].vif = NULL;
2029 }
2030
2031 err = ieee80211_register_hw(ar->hw);
2032 if (err)
2033 return err;
2034
2035 /* mac80211 interface is now registered */
2036 ar->registered = true;
2037
2038 if (!ath_is_world_regd(regulatory))
2039 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
2040
2041 #ifdef CONFIG_CARL9170_DEBUGFS
2042 carl9170_debugfs_register(ar);
2043 #endif /* CONFIG_CARL9170_DEBUGFS */
2044
2045 err = carl9170_led_init(ar);
2046 if (err)
2047 goto err_unreg;
2048
2049 #ifdef CONFIG_CARL9170_LEDS
2050 err = carl9170_led_register(ar);
2051 if (err)
2052 goto err_unreg;
2053 #endif /* CONFIG_CARL9170_LEDS */
2054
2055 #ifdef CONFIG_CARL9170_WPC
2056 err = carl9170_register_wps_button(ar);
2057 if (err)
2058 goto err_unreg;
2059 #endif /* CONFIG_CARL9170_WPC */
2060
2061 #ifdef CONFIG_CARL9170_HWRNG
2062 err = carl9170_register_hwrng(ar);
2063 if (err)
2064 goto err_unreg;
2065 #endif /* CONFIG_CARL9170_HWRNG */
2066
2067 dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
2068 wiphy_name(ar->hw->wiphy));
2069
2070 return 0;
2071
2072 err_unreg:
2073 carl9170_unregister(ar);
2074 return err;
2075 }
2076
2077 void carl9170_unregister(struct ar9170 *ar)
2078 {
2079 if (!ar->registered)
2080 return;
2081
2082 ar->registered = false;
2083
2084 #ifdef CONFIG_CARL9170_LEDS
2085 carl9170_led_unregister(ar);
2086 #endif /* CONFIG_CARL9170_LEDS */
2087
2088 #ifdef CONFIG_CARL9170_DEBUGFS
2089 carl9170_debugfs_unregister(ar);
2090 #endif /* CONFIG_CARL9170_DEBUGFS */
2091
2092 #ifdef CONFIG_CARL9170_WPC
2093 if (ar->wps.pbc) {
2094 input_unregister_device(ar->wps.pbc);
2095 ar->wps.pbc = NULL;
2096 }
2097 #endif /* CONFIG_CARL9170_WPC */
2098
2099 #ifdef CONFIG_CARL9170_HWRNG
2100 carl9170_unregister_hwrng(ar);
2101 #endif /* CONFIG_CARL9170_HWRNG */
2102
2103 carl9170_cancel_worker(ar);
2104 cancel_work_sync(&ar->restart_work);
2105
2106 ieee80211_unregister_hw(ar->hw);
2107 }
2108
2109 void carl9170_free(struct ar9170 *ar)
2110 {
2111 WARN_ON(ar->registered);
2112 WARN_ON(IS_INITIALIZED(ar));
2113
2114 kfree_skb(ar->rx_failover);
2115 ar->rx_failover = NULL;
2116
2117 kfree(ar->mem_bitmap);
2118 ar->mem_bitmap = NULL;
2119
2120 kfree(ar->survey);
2121 ar->survey = NULL;
2122
2123 mutex_destroy(&ar->mutex);
2124
2125 ieee80211_free_hw(ar->hw);
2126 }
Ubuntu Jammy Linux kernel mirror