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