ath/carl9170/main.c

0001 /*
0002  * Atheros CARL9170 driver
0003  *
0004  * mac80211 interaction code
0005  *
0006  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
0007  * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>
0008  *
0009  * This program is free software; you can redistribute it and/or modify
0010  * it under the terms of the GNU General Public License as published by
0011  * the Free Software Foundation; either version 2 of the License, or
0012  * (at your option) any later version.
0013  *
0014  * This program is distributed in the hope that it will be useful,
0015  * but WITHOUT ANY WARRANTY; without even the implied warranty of
0016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
0017  * GNU General Public License for more details.
0018  *
0019  * You should have received a copy of the GNU General Public License
0020  * along with this program; see the file COPYING.  If not, see
0021  * http://www.gnu.org/licenses/.
0022  *
0023  * This file incorporates work covered by the following copyright and
0024  * permission notice:
0025  *    Copyright (c) 2007-2008 Atheros Communications, Inc.
0026  *
0027  *    Permission to use, copy, modify, and/or distribute this software for any
0028  *    purpose with or without fee is hereby granted, provided that the above
0029  *    copyright notice and this permission notice appear in all copies.
0030  *
0031  *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
0032  *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
0033  *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
0034  *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
0035  *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
0036  *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
0037  *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
0038  */
0039
0040 #include <linux/slab.h>
0041 #include <linux/module.h>
0042 #include <linux/etherdevice.h>
0043 #include <linux/random.h>
0044 #include <net/mac80211.h>
0045 #include <net/cfg80211.h>
0046 #include "hw.h"
0047 #include "carl9170.h"
0048 #include "cmd.h"
0049
0050 static bool modparam_nohwcrypt;
0051 module_param_named(nohwcrypt, modparam_nohwcrypt, bool, 0444);
0052 MODULE_PARM_DESC(nohwcrypt, "Disable hardware crypto offload.");
0053
0054 int modparam_noht;
0055 module_param_named(noht, modparam_noht, int, 0444);
0056 MODULE_PARM_DESC(noht, "Disable MPDU aggregation.");
0057
0058 #define RATE(_bitrate, _hw_rate, _txpidx, _flags) { \
0059     .bitrate    = (_bitrate),           \
0060     .flags      = (_flags),         \
0061     .hw_value   = (_hw_rate) | (_txpidx) << 4,  \
0062 }
0063
0064 struct ieee80211_rate __carl9170_ratetable[] = {
0065     RATE(10, 0, 0, 0),
0066     RATE(20, 1, 1, IEEE80211_RATE_SHORT_PREAMBLE),
0067     RATE(55, 2, 2, IEEE80211_RATE_SHORT_PREAMBLE),
0068     RATE(110, 3, 3, IEEE80211_RATE_SHORT_PREAMBLE),
0069     RATE(60, 0xb, 0, 0),
0070     RATE(90, 0xf, 0, 0),
0071     RATE(120, 0xa, 0, 0),
0072     RATE(180, 0xe, 0, 0),
0073     RATE(240, 0x9, 0, 0),
0074     RATE(360, 0xd, 1, 0),
0075     RATE(480, 0x8, 2, 0),
0076     RATE(540, 0xc, 3, 0),
0077 };
0078 #undef RATE
0079
0080 #define carl9170_g_ratetable    (__carl9170_ratetable + 0)
0081 #define carl9170_g_ratetable_size   12
0082 #define carl9170_a_ratetable    (__carl9170_ratetable + 4)
0083 #define carl9170_a_ratetable_size   8
0084
0085 /*
0086  * NB: The hw_value is used as an index into the carl9170_phy_freq_params
0087  *     array in phy.c so that we don't have to do frequency lookups!
0088  */
0089 #define CHAN(_freq, _idx) {     \
0090     .center_freq    = (_freq),  \
0091     .hw_value   = (_idx),   \
0092     .max_power  = 18, /* XXX */ \
0093 }
0094
0095 static struct ieee80211_channel carl9170_2ghz_chantable[] = {
0096     CHAN(2412,  0),
0097     CHAN(2417,  1),
0098     CHAN(2422,  2),
0099     CHAN(2427,  3),
0100     CHAN(2432,  4),
0101     CHAN(2437,  5),
0102     CHAN(2442,  6),
0103     CHAN(2447,  7),
0104     CHAN(2452,  8),
0105     CHAN(2457,  9),
0106     CHAN(2462, 10),
0107     CHAN(2467, 11),
0108     CHAN(2472, 12),
0109     CHAN(2484, 13),
0110 };
0111
0112 static struct ieee80211_channel carl9170_5ghz_chantable[] = {
0113     CHAN(4920, 14),
0114     CHAN(4940, 15),
0115     CHAN(4960, 16),
0116     CHAN(4980, 17),
0117     CHAN(5040, 18),
0118     CHAN(5060, 19),
0119     CHAN(5080, 20),
0120     CHAN(5180, 21),
0121     CHAN(5200, 22),
0122     CHAN(5220, 23),
0123     CHAN(5240, 24),
0124     CHAN(5260, 25),
0125     CHAN(5280, 26),
0126     CHAN(5300, 27),
0127     CHAN(5320, 28),
0128     CHAN(5500, 29),
0129     CHAN(5520, 30),
0130     CHAN(5540, 31),
0131     CHAN(5560, 32),
0132     CHAN(5580, 33),
0133     CHAN(5600, 34),
0134     CHAN(5620, 35),
0135     CHAN(5640, 36),
0136     CHAN(5660, 37),
0137     CHAN(5680, 38),
0138     CHAN(5700, 39),
0139     CHAN(5745, 40),
0140     CHAN(5765, 41),
0141     CHAN(5785, 42),
0142     CHAN(5805, 43),
0143     CHAN(5825, 44),
0144     CHAN(5170, 45),
0145     CHAN(5190, 46),
0146     CHAN(5210, 47),
0147     CHAN(5230, 48),
0148 };
0149 #undef CHAN
0150
0151 #define CARL9170_HT_CAP                         \
0152 {                                   \
0153     .ht_supported   = true,                     \
0154     .cap        = IEEE80211_HT_CAP_MAX_AMSDU |          \
0155               IEEE80211_HT_CAP_SUP_WIDTH_20_40 |        \
0156               IEEE80211_HT_CAP_SGI_40 |         \
0157               IEEE80211_HT_CAP_DSSSCCK40 |          \
0158               IEEE80211_HT_CAP_SM_PS,           \
0159     .ampdu_factor   = IEEE80211_HT_MAX_AMPDU_64K,           \
0160     .ampdu_density  = IEEE80211_HT_MPDU_DENSITY_8,          \
0161     .mcs        = {                     \
0162         .rx_mask = { 0xff, 0xff, 0, 0, 0x1, 0, 0, 0, 0, 0, },   \
0163         .rx_highest = cpu_to_le16(300),             \
0164         .tx_params = IEEE80211_HT_MCS_TX_DEFINED,       \
0165     },                              \
0166 }
0167
0168 static struct ieee80211_supported_band carl9170_band_2GHz = {
0169     .channels   = carl9170_2ghz_chantable,
0170     .n_channels = ARRAY_SIZE(carl9170_2ghz_chantable),
0171     .bitrates   = carl9170_g_ratetable,
0172     .n_bitrates = carl9170_g_ratetable_size,
0173     .ht_cap     = CARL9170_HT_CAP,
0174 };
0175
0176 static struct ieee80211_supported_band carl9170_band_5GHz = {
0177     .channels   = carl9170_5ghz_chantable,
0178     .n_channels = ARRAY_SIZE(carl9170_5ghz_chantable),
0179     .bitrates   = carl9170_a_ratetable,
0180     .n_bitrates = carl9170_a_ratetable_size,
0181     .ht_cap     = CARL9170_HT_CAP,
0182 };
0183
0184 static void carl9170_ampdu_gc(struct ar9170 *ar)
0185 {
0186     struct carl9170_sta_tid *tid_info;
0187     LIST_HEAD(tid_gc);
0188
0189     rcu_read_lock();
0190     list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
0191         spin_lock_bh(&ar->tx_ampdu_list_lock);
0192         if (tid_info->state == CARL9170_TID_STATE_SHUTDOWN) {
0193             tid_info->state = CARL9170_TID_STATE_KILLED;
0194             list_del_rcu(&tid_info->list);
0195             ar->tx_ampdu_list_len--;
0196             list_add_tail(&tid_info->tmp_list, &tid_gc);
0197         }
0198         spin_unlock_bh(&ar->tx_ampdu_list_lock);
0199
0200     }
0201     rcu_assign_pointer(ar->tx_ampdu_iter, tid_info);
0202     rcu_read_unlock();
0203
0204     synchronize_rcu();
0205
0206     while (!list_empty(&tid_gc)) {
0207         struct sk_buff *skb;
0208         tid_info = list_first_entry(&tid_gc, struct carl9170_sta_tid,
0209                         tmp_list);
0210
0211         while ((skb = __skb_dequeue(&tid_info->queue)))
0212             carl9170_tx_status(ar, skb, false);
0213
0214         list_del_init(&tid_info->tmp_list);
0215         kfree(tid_info);
0216     }
0217 }
0218
0219 static void carl9170_flush(struct ar9170 *ar, bool drop_queued)
0220 {
0221     if (drop_queued) {
0222         int i;
0223
0224         /*
0225          * We can only drop frames which have not been uploaded
0226          * to the device yet.
0227          */
0228
0229         for (i = 0; i < ar->hw->queues; i++) {
0230             struct sk_buff *skb;
0231
0232             while ((skb = skb_dequeue(&ar->tx_pending[i]))) {
0233                 struct ieee80211_tx_info *info;
0234
0235                 info = IEEE80211_SKB_CB(skb);
0236                 if (info->flags & IEEE80211_TX_CTL_AMPDU)
0237                     atomic_dec(&ar->tx_ampdu_upload);
0238
0239                 carl9170_tx_status(ar, skb, false);
0240             }
0241         }
0242     }
0243
0244     /* Wait for all other outstanding frames to timeout. */
0245     if (atomic_read(&ar->tx_total_queued))
0246         WARN_ON(wait_for_completion_timeout(&ar->tx_flush, HZ) == 0);
0247 }
0248
0249 static void carl9170_flush_ba(struct ar9170 *ar)
0250 {
0251     struct sk_buff_head free;
0252     struct carl9170_sta_tid *tid_info;
0253     struct sk_buff *skb;
0254
0255     __skb_queue_head_init(&free);
0256
0257     rcu_read_lock();
0258     spin_lock_bh(&ar->tx_ampdu_list_lock);
0259     list_for_each_entry_rcu(tid_info, &ar->tx_ampdu_list, list) {
0260         if (tid_info->state > CARL9170_TID_STATE_SUSPEND) {
0261             tid_info->state = CARL9170_TID_STATE_SUSPEND;
0262
0263             spin_lock(&tid_info->lock);
0264             while ((skb = __skb_dequeue(&tid_info->queue)))
0265                 __skb_queue_tail(&free, skb);
0266             spin_unlock(&tid_info->lock);
0267         }
0268     }
0269     spin_unlock_bh(&ar->tx_ampdu_list_lock);
0270     rcu_read_unlock();
0271
0272     while ((skb = __skb_dequeue(&free)))
0273         carl9170_tx_status(ar, skb, false);
0274 }
0275
0276 static void carl9170_zap_queues(struct ar9170 *ar)
0277 {
0278     struct carl9170_vif_info *cvif;
0279     unsigned int i;
0280
0281     carl9170_ampdu_gc(ar);
0282
0283     carl9170_flush_ba(ar);
0284     carl9170_flush(ar, true);
0285
0286     for (i = 0; i < ar->hw->queues; i++) {
0287         spin_lock_bh(&ar->tx_status[i].lock);
0288         while (!skb_queue_empty(&ar->tx_status[i])) {
0289             struct sk_buff *skb;
0290
0291             skb = skb_peek(&ar->tx_status[i]);
0292             carl9170_tx_get_skb(skb);
0293             spin_unlock_bh(&ar->tx_status[i].lock);
0294             carl9170_tx_drop(ar, skb);
0295             spin_lock_bh(&ar->tx_status[i].lock);
0296             carl9170_tx_put_skb(skb);
0297         }
0298         spin_unlock_bh(&ar->tx_status[i].lock);
0299     }
0300
0301     BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_SOFT < 1);
0302     BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD < CARL9170_NUM_TX_LIMIT_SOFT);
0303     BUILD_BUG_ON(CARL9170_NUM_TX_LIMIT_HARD >= CARL9170_BAW_BITS);
0304
0305     /* reinitialize queues statistics */
0306     memset(&ar->tx_stats, 0, sizeof(ar->tx_stats));
0307     for (i = 0; i < ar->hw->queues; i++)
0308         ar->tx_stats[i].limit = CARL9170_NUM_TX_LIMIT_HARD;
0309
0310     bitmap_zero(ar->mem_bitmap, ar->fw.mem_blocks);
0311
0312     rcu_read_lock();
0313     list_for_each_entry_rcu(cvif, &ar->vif_list, list) {
0314         spin_lock_bh(&ar->beacon_lock);
0315         dev_kfree_skb_any(cvif->beacon);
0316         cvif->beacon = NULL;
0317         spin_unlock_bh(&ar->beacon_lock);
0318     }
0319     rcu_read_unlock();
0320
0321     atomic_set(&ar->tx_ampdu_upload, 0);
0322     atomic_set(&ar->tx_ampdu_scheduler, 0);
0323     atomic_set(&ar->tx_total_pending, 0);
0324     atomic_set(&ar->tx_total_queued, 0);
0325     atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks);
0326 }
0327
0328 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop)      \
0329 do {                                    \
0330     queue.aifs = ai_fs;                     \
0331     queue.cw_min = cwmin;                       \
0332     queue.cw_max = cwmax;                       \
0333     queue.txop = _txop;                     \
0334 } while (0)
0335
0336 static int carl9170_op_start(struct ieee80211_hw *hw)
0337 {
0338     struct ar9170 *ar = hw->priv;
0339     int err, i;
0340
0341     mutex_lock(&ar->mutex);
0342
0343     carl9170_zap_queues(ar);
0344
0345     /* reset QoS defaults */
0346     CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VO], 2, 3,     7, 47);
0347     CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VI], 2, 7,    15, 94);
0348     CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BE], 3, 15, 1023,  0);
0349     CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BK], 7, 15, 1023,  0);
0350     CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_SPECIAL], 2, 3, 7, 0);
0351
0352     ar->current_factor = ar->current_density = -1;
0353     /* "The first key is unique." */
0354     ar->usedkeys = 1;
0355     ar->filter_state = 0;
0356     ar->ps.last_action = jiffies;
0357     ar->ps.last_slept = jiffies;
0358     ar->erp_mode = CARL9170_ERP_AUTO;
0359
0360     /* Set "disable hw crypto offload" whenever the module parameter
0361      * nohwcrypt is true or if the firmware does not support it.
0362      */
0363     ar->disable_offload = modparam_nohwcrypt |
0364         ar->fw.disable_offload_fw;
0365     ar->rx_software_decryption = ar->disable_offload;
0366
0367     for (i = 0; i < ar->hw->queues; i++) {
0368         ar->queue_stop_timeout[i] = jiffies;
0369         ar->max_queue_stop_timeout[i] = 0;
0370     }
0371
0372     atomic_set(&ar->mem_allocs, 0);
0373
0374     err = carl9170_usb_open(ar);
0375     if (err)
0376         goto out;
0377
0378     err = carl9170_init_mac(ar);
0379     if (err)
0380         goto out;
0381
0382     err = carl9170_set_qos(ar);
0383     if (err)
0384         goto out;
0385
0386     if (ar->fw.rx_filter) {
0387         err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA |
0388             CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD);
0389         if (err)
0390             goto out;
0391     }
0392
0393     err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER,
0394                  AR9170_DMA_TRIGGER_RXQ);
0395     if (err)
0396         goto out;
0397
0398     /* Clear key-cache */
0399     for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) {
0400         err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
0401                       0, NULL, 0);
0402         if (err)
0403             goto out;
0404
0405         err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
0406                       1, NULL, 0);
0407         if (err)
0408             goto out;
0409
0410         if (i < AR9170_CAM_MAX_USER) {
0411             err = carl9170_disable_key(ar, i);
0412             if (err)
0413                 goto out;
0414         }
0415     }
0416
0417     carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED);
0418
0419     ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
0420         round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
0421
0422     ieee80211_wake_queues(ar->hw);
0423     err = 0;
0424
0425 out:
0426     mutex_unlock(&ar->mutex);
0427     return err;
0428 }
0429
0430 static void carl9170_cancel_worker(struct ar9170 *ar)
0431 {
0432     cancel_delayed_work_sync(&ar->stat_work);
0433     cancel_delayed_work_sync(&ar->tx_janitor);
0434 #ifdef CONFIG_CARL9170_LEDS
0435     cancel_delayed_work_sync(&ar->led_work);
0436 #endif /* CONFIG_CARL9170_LEDS */
0437     cancel_work_sync(&ar->ps_work);
0438     cancel_work_sync(&ar->ping_work);
0439     cancel_work_sync(&ar->ampdu_work);
0440 }
0441
0442 static void carl9170_op_stop(struct ieee80211_hw *hw)
0443 {
0444     struct ar9170 *ar = hw->priv;
0445
0446     carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
0447
0448     ieee80211_stop_queues(ar->hw);
0449
0450     mutex_lock(&ar->mutex);
0451     if (IS_ACCEPTING_CMD(ar)) {
0452         RCU_INIT_POINTER(ar->beacon_iter, NULL);
0453
0454         carl9170_led_set_state(ar, 0);
0455
0456         /* stop DMA */
0457         carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
0458         carl9170_usb_stop(ar);
0459     }
0460
0461     carl9170_zap_queues(ar);
0462     mutex_unlock(&ar->mutex);
0463
0464     carl9170_cancel_worker(ar);
0465 }
0466
0467 static void carl9170_restart_work(struct work_struct *work)
0468 {
0469     struct ar9170 *ar = container_of(work, struct ar9170,
0470                      restart_work);
0471     int err = -EIO;
0472
0473     ar->usedkeys = 0;
0474     ar->filter_state = 0;
0475     carl9170_cancel_worker(ar);
0476
0477     mutex_lock(&ar->mutex);
0478     if (!ar->force_usb_reset) {
0479         err = carl9170_usb_restart(ar);
0480         if (net_ratelimit()) {
0481             if (err)
0482                 dev_err(&ar->udev->dev, "Failed to restart device (%d).\n", err);
0483             else
0484                 dev_info(&ar->udev->dev, "device restarted successfully.\n");
0485         }
0486     }
0487     carl9170_zap_queues(ar);
0488     mutex_unlock(&ar->mutex);
0489
0490     if (!err && !ar->force_usb_reset) {
0491         ar->restart_counter++;
0492         atomic_set(&ar->pending_restarts, 0);
0493
0494         ieee80211_restart_hw(ar->hw);
0495     } else {
0496         /*
0497          * The reset was unsuccessful and the device seems to
0498          * be dead. But there's still one option: a low-level
0499          * usb subsystem reset...
0500          */
0501
0502         carl9170_usb_reset(ar);
0503     }
0504 }
0505
0506 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
0507 {
0508     carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
0509
0510     /*
0511      * Sometimes, an error can trigger several different reset events.
0512      * By ignoring these *surplus* reset events, the device won't be
0513      * killed again, right after it has recovered.
0514      */
0515     if (atomic_inc_return(&ar->pending_restarts) > 1) {
0516         dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
0517         return;
0518     }
0519
0520     ieee80211_stop_queues(ar->hw);
0521
0522     dev_err(&ar->udev->dev, "restart device (%d)\n", r);
0523
0524     if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
0525         !WARN_ON(r >= __CARL9170_RR_LAST))
0526         ar->last_reason = r;
0527
0528     if (!ar->registered)
0529         return;
0530
0531     if (!IS_ACCEPTING_CMD(ar) || ar->needs_full_reset)
0532         ar->force_usb_reset = true;
0533
0534     ieee80211_queue_work(ar->hw, &ar->restart_work);
0535
0536     /*
0537      * At this point, the device instance might have vanished/disabled.
0538      * So, don't put any code which access the ar9170 struct
0539      * without proper protection.
0540      */
0541 }
0542
0543 static void carl9170_ping_work(struct work_struct *work)
0544 {
0545     struct ar9170 *ar = container_of(work, struct ar9170, ping_work);
0546     int err;
0547
0548     if (!IS_STARTED(ar))
0549         return;
0550
0551     mutex_lock(&ar->mutex);
0552     err = carl9170_echo_test(ar, 0xdeadbeef);
0553     if (err)
0554         carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE);
0555     mutex_unlock(&ar->mutex);
0556 }
0557
0558 static int carl9170_init_interface(struct ar9170 *ar,
0559                    struct ieee80211_vif *vif)
0560 {
0561     struct ath_common *common = &ar->common;
0562     int err;
0563
0564     if (!vif) {
0565         WARN_ON_ONCE(IS_STARTED(ar));
0566         return 0;
0567     }
0568
0569     memcpy(common->macaddr, vif->addr, ETH_ALEN);
0570
0571     /* We have to fall back to software crypto, whenever
0572      * the user choose to participates in an IBSS. HW
0573      * offload for IBSS RSN is not supported by this driver.
0574      *
0575      * NOTE: If the previous main interface has already
0576      * disabled hw crypto offload, we have to keep this
0577      * previous disable_offload setting as it was.
0578      * Altough ideally, we should notify mac80211 and tell
0579      * it to forget about any HW crypto offload for now.
0580      */
0581     ar->disable_offload |= ((vif->type != NL80211_IFTYPE_STATION) &&
0582         (vif->type != NL80211_IFTYPE_AP));
0583
0584     /* The driver used to have P2P GO+CLIENT support,
0585      * but since this was dropped and we don't know if
0586      * there are any gremlins lurking in the shadows,
0587      * so best we keep HW offload disabled for P2P.
0588      */
0589     ar->disable_offload |= vif->p2p;
0590
0591     ar->rx_software_decryption = ar->disable_offload;
0592
0593     err = carl9170_set_operating_mode(ar);
0594     return err;
0595 }
0596
0597 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
0598                      struct ieee80211_vif *vif)
0599 {
0600     struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
0601     struct ieee80211_vif *main_vif, *old_main = NULL;
0602     struct ar9170 *ar = hw->priv;
0603     int vif_id = -1, err = 0;
0604
0605     mutex_lock(&ar->mutex);
0606     rcu_read_lock();
0607     if (vif_priv->active) {
0608         /*
0609          * Skip the interface structure initialization,
0610          * if the vif survived the _restart call.
0611          */
0612         vif_id = vif_priv->id;
0613         vif_priv->enable_beacon = false;
0614
0615         spin_lock_bh(&ar->beacon_lock);
0616         dev_kfree_skb_any(vif_priv->beacon);
0617         vif_priv->beacon = NULL;
0618         spin_unlock_bh(&ar->beacon_lock);
0619
0620         goto init;
0621     }
0622
0623     /* Because the AR9170 HW's MAC doesn't provide full support for
0624      * multiple, independent interfaces [of different operation modes].
0625      * We have to select ONE main interface [main mode of HW], but we
0626      * can have multiple slaves [AKA: entry in the ACK-table].
0627      *
0628      * The first (from HEAD/TOP) interface in the ar->vif_list is
0629      * always the main intf. All following intfs in this list
0630      * are considered to be slave intfs.
0631      */
0632     main_vif = carl9170_get_main_vif(ar);
0633
0634     if (main_vif) {
0635         switch (main_vif->type) {
0636         case NL80211_IFTYPE_STATION:
0637             if (vif->type == NL80211_IFTYPE_STATION)
0638                 break;
0639
0640             err = -EBUSY;
0641             rcu_read_unlock();
0642
0643             goto unlock;
0644
0645         case NL80211_IFTYPE_MESH_POINT:
0646         case NL80211_IFTYPE_AP:
0647             if ((vif->type == NL80211_IFTYPE_STATION) ||
0648                 (vif->type == NL80211_IFTYPE_AP) ||
0649                 (vif->type == NL80211_IFTYPE_MESH_POINT))
0650                 break;
0651
0652             err = -EBUSY;
0653             rcu_read_unlock();
0654             goto unlock;
0655
0656         default:
0657             rcu_read_unlock();
0658             goto unlock;
0659         }
0660     }
0661
0662     vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
0663
0664     if (vif_id < 0) {
0665         rcu_read_unlock();
0666
0667         err = -ENOSPC;
0668         goto unlock;
0669     }
0670
0671     BUG_ON(ar->vif_priv[vif_id].id != vif_id);
0672
0673     vif_priv->active = true;
0674     vif_priv->id = vif_id;
0675     vif_priv->enable_beacon = false;
0676     ar->vifs++;
0677     if (old_main) {
0678         /* We end up in here, if the main interface is being replaced.
0679          * Put the new main interface at the HEAD of the list and the
0680          * previous inteface will automatically become second in line.
0681          */
0682         list_add_rcu(&vif_priv->list, &ar->vif_list);
0683     } else {
0684         /* Add new inteface. If the list is empty, it will become the
0685          * main inteface, otherwise it will be slave.
0686          */
0687         list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
0688     }
0689     rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
0690
0691 init:
0692     main_vif = carl9170_get_main_vif(ar);
0693
0694     if (main_vif == vif) {
0695         rcu_assign_pointer(ar->beacon_iter, vif_priv);
0696         rcu_read_unlock();
0697
0698         if (old_main) {
0699             struct carl9170_vif_info *old_main_priv =
0700                 (void *) old_main->drv_priv;
0701             /* downgrade old main intf to slave intf.
0702              * NOTE: We are no longer under rcu_read_lock.
0703              * But we are still holding ar->mutex, so the
0704              * vif data [id, addr] is safe.
0705              */
0706             err = carl9170_mod_virtual_mac(ar, old_main_priv->id,
0707                                old_main->addr);
0708             if (err)
0709                 goto unlock;
0710         }
0711
0712         err = carl9170_init_interface(ar, vif);
0713         if (err)
0714             goto unlock;
0715     } else {
0716         rcu_read_unlock();
0717         err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
0718
0719         if (err)
0720             goto unlock;
0721     }
0722
0723     if (ar->fw.tx_seq_table) {
0724         err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4,
0725                      0);
0726         if (err)
0727             goto unlock;
0728     }
0729
0730 unlock:
0731     if (err && (vif_id >= 0)) {
0732         vif_priv->active = false;
0733         bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
0734         ar->vifs--;
0735         RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL);
0736         list_del_rcu(&vif_priv->list);
0737         mutex_unlock(&ar->mutex);
0738         synchronize_rcu();
0739     } else {
0740         if (ar->vifs > 1)
0741             ar->ps.off_override |= PS_OFF_VIF;
0742
0743         mutex_unlock(&ar->mutex);
0744     }
0745
0746     return err;
0747 }
0748
0749 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
0750                      struct ieee80211_vif *vif)
0751 {
0752     struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
0753     struct ieee80211_vif *main_vif;
0754     struct ar9170 *ar = hw->priv;
0755     unsigned int id;
0756
0757     mutex_lock(&ar->mutex);
0758
0759     if (WARN_ON_ONCE(!vif_priv->active))
0760         goto unlock;
0761
0762     ar->vifs--;
0763
0764     rcu_read_lock();
0765     main_vif = carl9170_get_main_vif(ar);
0766
0767     id = vif_priv->id;
0768
0769     vif_priv->active = false;
0770     WARN_ON(vif_priv->enable_beacon);
0771     vif_priv->enable_beacon = false;
0772     list_del_rcu(&vif_priv->list);
0773     RCU_INIT_POINTER(ar->vif_priv[id].vif, NULL);
0774
0775     if (vif == main_vif) {
0776         rcu_read_unlock();
0777
0778         if (ar->vifs) {
0779             WARN_ON(carl9170_init_interface(ar,
0780                     carl9170_get_main_vif(ar)));
0781         } else {
0782             carl9170_set_operating_mode(ar);
0783         }
0784     } else {
0785         rcu_read_unlock();
0786
0787         WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
0788     }
0789
0790     carl9170_update_beacon(ar, false);
0791     carl9170_flush_cab(ar, id);
0792
0793     spin_lock_bh(&ar->beacon_lock);
0794     dev_kfree_skb_any(vif_priv->beacon);
0795     vif_priv->beacon = NULL;
0796     spin_unlock_bh(&ar->beacon_lock);
0797
0798     bitmap_release_region(&ar->vif_bitmap, id, 0);
0799
0800     carl9170_set_beacon_timers(ar);
0801
0802     if (ar->vifs == 1)
0803         ar->ps.off_override &= ~PS_OFF_VIF;
0804
0805 unlock:
0806     mutex_unlock(&ar->mutex);
0807
0808     synchronize_rcu();
0809 }
0810
0811 void carl9170_ps_check(struct ar9170 *ar)
0812 {
0813     ieee80211_queue_work(ar->hw, &ar->ps_work);
0814 }
0815
0816 /* caller must hold ar->mutex */
0817 static int carl9170_ps_update(struct ar9170 *ar)
0818 {
0819     bool ps = false;
0820     int err = 0;
0821
0822     if (!ar->ps.off_override)
0823         ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
0824
0825     if (ps != ar->ps.state) {
0826         err = carl9170_powersave(ar, ps);
0827         if (err)
0828             return err;
0829
0830         if (ar->ps.state && !ps) {
0831             ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
0832                 ar->ps.last_action);
0833         }
0834
0835         if (ps)
0836             ar->ps.last_slept = jiffies;
0837
0838         ar->ps.last_action = jiffies;
0839         ar->ps.state = ps;
0840     }
0841
0842     return 0;
0843 }
0844
0845 static void carl9170_ps_work(struct work_struct *work)
0846 {
0847     struct ar9170 *ar = container_of(work, struct ar9170,
0848                      ps_work);
0849     mutex_lock(&ar->mutex);
0850     if (IS_STARTED(ar))
0851         WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
0852     mutex_unlock(&ar->mutex);
0853 }
0854
0855 static int carl9170_update_survey(struct ar9170 *ar, bool flush, bool noise)
0856 {
0857     int err;
0858
0859     if (noise) {
0860         err = carl9170_get_noisefloor(ar);
0861         if (err)
0862             return err;
0863     }
0864
0865     if (ar->fw.hw_counters) {
0866         err = carl9170_collect_tally(ar);
0867         if (err)
0868             return err;
0869     }
0870
0871     if (flush)
0872         memset(&ar->tally, 0, sizeof(ar->tally));
0873
0874     return 0;
0875 }
0876
0877 static void carl9170_stat_work(struct work_struct *work)
0878 {
0879     struct ar9170 *ar = container_of(work, struct ar9170, stat_work.work);
0880     int err;
0881
0882     mutex_lock(&ar->mutex);
0883     err = carl9170_update_survey(ar, false, true);
0884     mutex_unlock(&ar->mutex);
0885
0886     if (err)
0887         return;
0888
0889     ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
0890         round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
0891 }
0892
0893 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
0894 {
0895     struct ar9170 *ar = hw->priv;
0896     int err = 0;
0897
0898     mutex_lock(&ar->mutex);
0899     if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
0900         /* TODO */
0901         err = 0;
0902     }
0903
0904     if (changed & IEEE80211_CONF_CHANGE_PS) {
0905         err = carl9170_ps_update(ar);
0906         if (err)
0907             goto out;
0908     }
0909
0910     if (changed & IEEE80211_CONF_CHANGE_SMPS) {
0911         /* TODO */
0912         err = 0;
0913     }
0914
0915     if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
0916         enum nl80211_channel_type channel_type =
0917             cfg80211_get_chandef_type(&hw->conf.chandef);
0918
0919         /* adjust slot time for 5 GHz */
0920         err = carl9170_set_slot_time(ar);
0921         if (err)
0922             goto out;
0923
0924         err = carl9170_update_survey(ar, true, false);
0925         if (err)
0926             goto out;
0927
0928         err = carl9170_set_channel(ar, hw->conf.chandef.chan,
0929                        channel_type);
0930         if (err)
0931             goto out;
0932
0933         err = carl9170_update_survey(ar, false, true);
0934         if (err)
0935             goto out;
0936
0937         err = carl9170_set_dyn_sifs_ack(ar);
0938         if (err)
0939             goto out;
0940
0941         err = carl9170_set_rts_cts_rate(ar);
0942         if (err)
0943             goto out;
0944     }
0945
0946     if (changed & IEEE80211_CONF_CHANGE_POWER) {
0947         err = carl9170_set_mac_tpc(ar, ar->hw->conf.chandef.chan);
0948         if (err)
0949             goto out;
0950     }
0951
0952 out:
0953     mutex_unlock(&ar->mutex);
0954     return err;
0955 }
0956
0957 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
0958                      struct netdev_hw_addr_list *mc_list)
0959 {
0960     struct netdev_hw_addr *ha;
0961     u64 mchash;
0962
0963     /* always get broadcast frames */
0964     mchash = 1ULL << (0xff >> 2);
0965
0966     netdev_hw_addr_list_for_each(ha, mc_list)
0967         mchash |= 1ULL << (ha->addr[5] >> 2);
0968
0969     return mchash;
0970 }
0971
0972 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
0973                      unsigned int changed_flags,
0974                      unsigned int *new_flags,
0975                      u64 multicast)
0976 {
0977     struct ar9170 *ar = hw->priv;
0978
0979     /* mask supported flags */
0980     *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
0981
0982     if (!IS_ACCEPTING_CMD(ar))
0983         return;
0984
0985     mutex_lock(&ar->mutex);
0986
0987     ar->filter_state = *new_flags;
0988     /*
0989      * We can support more by setting the sniffer bit and
0990      * then checking the error flags, later.
0991      */
0992
0993     if (*new_flags & FIF_ALLMULTI)
0994         multicast = ~0ULL;
0995
0996     if (multicast != ar->cur_mc_hash)
0997         WARN_ON(carl9170_update_multicast(ar, multicast));
0998
0999     if (changed_flags & FIF_OTHER_BSS) {
1000         ar->sniffer_enabled = !!(*new_flags & FIF_OTHER_BSS);
1001
1002         WARN_ON(carl9170_set_operating_mode(ar));
1003     }
1004
1005     if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) {
1006         u32 rx_filter = 0;
1007
1008         if (!ar->fw.ba_filter)
1009             rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
1010
1011         if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL)))
1012             rx_filter |= CARL9170_RX_FILTER_BAD;
1013
1014         if (!(*new_flags & FIF_CONTROL))
1015             rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
1016
1017         if (!(*new_flags & FIF_PSPOLL))
1018             rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL;
1019
1020         if (!(*new_flags & FIF_OTHER_BSS)) {
1021             rx_filter |= CARL9170_RX_FILTER_OTHER_RA;
1022             rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL;
1023         }
1024
1025         WARN_ON(carl9170_rx_filter(ar, rx_filter));
1026     }
1027
1028     mutex_unlock(&ar->mutex);
1029 }
1030
1031
1032 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw,
1033                      struct ieee80211_vif *vif,
1034                      struct ieee80211_bss_conf *bss_conf,
1035                      u64 changed)
1036 {
1037     struct ar9170 *ar = hw->priv;
1038     struct ath_common *common = &ar->common;
1039     int err = 0;
1040     struct carl9170_vif_info *vif_priv;
1041     struct ieee80211_vif *main_vif;
1042
1043     mutex_lock(&ar->mutex);
1044     vif_priv = (void *) vif->drv_priv;
1045     main_vif = carl9170_get_main_vif(ar);
1046     if (WARN_ON(!main_vif))
1047         goto out;
1048
1049     if (changed & BSS_CHANGED_BEACON_ENABLED) {
1050         struct carl9170_vif_info *iter;
1051         int i = 0;
1052
1053         vif_priv->enable_beacon = bss_conf->enable_beacon;
1054         rcu_read_lock();
1055         list_for_each_entry_rcu(iter, &ar->vif_list, list) {
1056             if (iter->active && iter->enable_beacon)
1057                 i++;
1058
1059         }
1060         rcu_read_unlock();
1061
1062         ar->beacon_enabled = i;
1063     }
1064
1065     if (changed & BSS_CHANGED_BEACON) {
1066         err = carl9170_update_beacon(ar, false);
1067         if (err)
1068             goto out;
1069     }
1070
1071     if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON |
1072                BSS_CHANGED_BEACON_INT)) {
1073
1074         if (main_vif != vif) {
1075             bss_conf->beacon_int = main_vif->bss_conf.beacon_int;
1076             bss_conf->dtim_period = main_vif->bss_conf.dtim_period;
1077         }
1078
1079         /*
1080          * Therefore a hard limit for the broadcast traffic should
1081          * prevent false alarms.
1082          */
1083         if (vif->type != NL80211_IFTYPE_STATION &&
1084             (bss_conf->beacon_int * bss_conf->dtim_period >=
1085              (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) {
1086             err = -EINVAL;
1087             goto out;
1088         }
1089
1090         err = carl9170_set_beacon_timers(ar);
1091         if (err)
1092             goto out;
1093     }
1094
1095     if (changed & BSS_CHANGED_HT) {
1096         /* TODO */
1097         err = 0;
1098         if (err)
1099             goto out;
1100     }
1101
1102     if (main_vif != vif)
1103         goto out;
1104
1105     /*
1106      * The following settings can only be changed by the
1107      * master interface.
1108      */
1109
1110     if (changed & BSS_CHANGED_BSSID) {
1111         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1112         err = carl9170_set_operating_mode(ar);
1113         if (err)
1114             goto out;
1115     }
1116
1117     if (changed & BSS_CHANGED_ASSOC) {
1118         ar->common.curaid = vif->cfg.aid;
1119         err = carl9170_set_beacon_timers(ar);
1120         if (err)
1121             goto out;
1122     }
1123
1124     if (changed & BSS_CHANGED_ERP_SLOT) {
1125         err = carl9170_set_slot_time(ar);
1126         if (err)
1127             goto out;
1128     }
1129
1130     if (changed & BSS_CHANGED_BASIC_RATES) {
1131         err = carl9170_set_mac_rates(ar);
1132         if (err)
1133             goto out;
1134     }
1135
1136 out:
1137     WARN_ON_ONCE(err && IS_STARTED(ar));
1138     mutex_unlock(&ar->mutex);
1139 }
1140
1141 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw,
1142                    struct ieee80211_vif *vif)
1143 {
1144     struct ar9170 *ar = hw->priv;
1145     struct carl9170_tsf_rsp tsf;
1146     int err;
1147
1148     mutex_lock(&ar->mutex);
1149     err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF,
1150                 0, NULL, sizeof(tsf), &tsf);
1151     mutex_unlock(&ar->mutex);
1152     if (WARN_ON(err))
1153         return 0;
1154
1155     return le64_to_cpu(tsf.tsf_64);
1156 }
1157
1158 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1159                    struct ieee80211_vif *vif,
1160                    struct ieee80211_sta *sta,
1161                    struct ieee80211_key_conf *key)
1162 {
1163     struct ar9170 *ar = hw->priv;
1164     int err = 0, i;
1165     u8 ktype;
1166
1167     if (ar->disable_offload || !vif)
1168         return -EOPNOTSUPP;
1169
1170     /* Fall back to software encryption whenever the driver is connected
1171      * to more than one network.
1172      *
1173      * This is very unfortunate, because some machines cannot handle
1174      * the high througput speed in 802.11n networks.
1175      */
1176
1177     if (!is_main_vif(ar, vif)) {
1178         mutex_lock(&ar->mutex);
1179         goto err_softw;
1180     }
1181
1182     /*
1183      * While the hardware supports *catch-all* key, for offloading
1184      * group-key en-/de-cryption. The way of how the hardware
1185      * decides which keyId maps to which key, remains a mystery...
1186      */
1187     if ((vif->type != NL80211_IFTYPE_STATION &&
1188          vif->type != NL80211_IFTYPE_ADHOC) &&
1189         !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1190         return -EOPNOTSUPP;
1191
1192     switch (key->cipher) {
1193     case WLAN_CIPHER_SUITE_WEP40:
1194         ktype = AR9170_ENC_ALG_WEP64;
1195         break;
1196     case WLAN_CIPHER_SUITE_WEP104:
1197         ktype = AR9170_ENC_ALG_WEP128;
1198         break;
1199     case WLAN_CIPHER_SUITE_TKIP:
1200         ktype = AR9170_ENC_ALG_TKIP;
1201         break;
1202     case WLAN_CIPHER_SUITE_CCMP:
1203         ktype = AR9170_ENC_ALG_AESCCMP;
1204         key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1205         break;
1206     default:
1207         return -EOPNOTSUPP;
1208     }
1209
1210     mutex_lock(&ar->mutex);
1211     if (cmd == SET_KEY) {
1212         if (!IS_STARTED(ar)) {
1213             err = -EOPNOTSUPP;
1214             goto out;
1215         }
1216
1217         if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1218             sta = NULL;
1219
1220             i = 64 + key->keyidx;
1221         } else {
1222             for (i = 0; i < 64; i++)
1223                 if (!(ar->usedkeys & BIT(i)))
1224                     break;
1225             if (i == 64)
1226                 goto err_softw;
1227         }
1228
1229         key->hw_key_idx = i;
1230
1231         err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1232                       ktype, 0, key->key,
1233                       min_t(u8, 16, key->keylen));
1234         if (err)
1235             goto out;
1236
1237         if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1238             err = carl9170_upload_key(ar, i, sta ? sta->addr :
1239                           NULL, ktype, 1,
1240                           key->key + 16, 16);
1241             if (err)
1242                 goto out;
1243
1244             /*
1245              * hardware is not capable generating MMIC
1246              * of fragmented frames!
1247              */
1248             key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1249         }
1250
1251         if (i < 64)
1252             ar->usedkeys |= BIT(i);
1253
1254         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1255     } else {
1256         if (!IS_STARTED(ar)) {
1257             /* The device is gone... together with the key ;-) */
1258             err = 0;
1259             goto out;
1260         }
1261
1262         if (key->hw_key_idx < 64) {
1263             ar->usedkeys &= ~BIT(key->hw_key_idx);
1264         } else {
1265             err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1266                           AR9170_ENC_ALG_NONE, 0,
1267                           NULL, 0);
1268             if (err)
1269                 goto out;
1270
1271             if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1272                 err = carl9170_upload_key(ar, key->hw_key_idx,
1273                               NULL,
1274                               AR9170_ENC_ALG_NONE,
1275                               1, NULL, 0);
1276                 if (err)
1277                     goto out;
1278             }
1279
1280         }
1281
1282         err = carl9170_disable_key(ar, key->hw_key_idx);
1283         if (err)
1284             goto out;
1285     }
1286
1287 out:
1288     mutex_unlock(&ar->mutex);
1289     return err;
1290
1291 err_softw:
1292     if (!ar->rx_software_decryption) {
1293         ar->rx_software_decryption = true;
1294         carl9170_set_operating_mode(ar);
1295     }
1296     mutex_unlock(&ar->mutex);
1297     return -ENOSPC;
1298 }
1299
1300 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1301                    struct ieee80211_vif *vif,
1302                    struct ieee80211_sta *sta)
1303 {
1304     struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1305     unsigned int i;
1306
1307     atomic_set(&sta_info->pending_frames, 0);
1308
1309     if (sta->deflink.ht_cap.ht_supported) {
1310         if (sta->deflink.ht_cap.ampdu_density > 6) {
1311             /*
1312              * HW does support 16us AMPDU density.
1313              * No HT-Xmit for station.
1314              */
1315
1316             return 0;
1317         }
1318
1319         for (i = 0; i < ARRAY_SIZE(sta_info->agg); i++)
1320             RCU_INIT_POINTER(sta_info->agg[i], NULL);
1321
1322         sta_info->ampdu_max_len = 1 << (3 + sta->deflink.ht_cap.ampdu_factor);
1323         sta_info->ht_sta = true;
1324     }
1325
1326     return 0;
1327 }
1328
1329 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1330                 struct ieee80211_vif *vif,
1331                 struct ieee80211_sta *sta)
1332 {
1333     struct ar9170 *ar = hw->priv;
1334     struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1335     unsigned int i;
1336     bool cleanup = false;
1337
1338     if (sta->deflink.ht_cap.ht_supported) {
1339
1340         sta_info->ht_sta = false;
1341
1342         rcu_read_lock();
1343         for (i = 0; i < ARRAY_SIZE(sta_info->agg); i++) {
1344             struct carl9170_sta_tid *tid_info;
1345
1346             tid_info = rcu_dereference(sta_info->agg[i]);
1347             RCU_INIT_POINTER(sta_info->agg[i], NULL);
1348
1349             if (!tid_info)
1350                 continue;
1351
1352             spin_lock_bh(&ar->tx_ampdu_list_lock);
1353             if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1354                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1355             spin_unlock_bh(&ar->tx_ampdu_list_lock);
1356             cleanup = true;
1357         }
1358         rcu_read_unlock();
1359
1360         if (cleanup)
1361             carl9170_ampdu_gc(ar);
1362     }
1363
1364     return 0;
1365 }
1366
1367 static int carl9170_op_conf_tx(struct ieee80211_hw *hw,
1368                    struct ieee80211_vif *vif,
1369                    unsigned int link_id, 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_KERNEL);
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 = devm_input_allocate_device(&ar->udev->dev);
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         return err;
1518
1519     ar->wps.pbc = input;
1520     return 0;
1521 }
1522 #endif /* CONFIG_CARL9170_WPC */
1523
1524 #ifdef CONFIG_CARL9170_HWRNG
1525 static int carl9170_rng_get(struct ar9170 *ar)
1526 {
1527
1528 #define RW  (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32))
1529 #define RB  (CARL9170_MAX_CMD_PAYLOAD_LEN)
1530
1531     static const __le32 rng_load[RW] = {
1532         [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)};
1533
1534     u32 buf[RW];
1535
1536     unsigned int i, off = 0, transfer, count;
1537     int err;
1538
1539     BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN);
1540
1541     if (!IS_ACCEPTING_CMD(ar))
1542         return -EAGAIN;
1543
1544     count = ARRAY_SIZE(ar->rng.cache);
1545     while (count) {
1546         err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1547                     RB, (u8 *) rng_load,
1548                     RB, (u8 *) buf);
1549         if (err)
1550             return err;
1551
1552         transfer = min_t(unsigned int, count, RW);
1553         for (i = 0; i < transfer; i++)
1554             ar->rng.cache[off + i] = buf[i];
1555
1556         off += transfer;
1557         count -= transfer;
1558     }
1559
1560     ar->rng.cache_idx = 0;
1561
1562 #undef RW
1563 #undef RB
1564     return 0;
1565 }
1566
1567 static int carl9170_rng_read(struct hwrng *rng, u32 *data)
1568 {
1569     struct ar9170 *ar = (struct ar9170 *)rng->priv;
1570     int ret = -EIO;
1571
1572     mutex_lock(&ar->mutex);
1573     if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) {
1574         ret = carl9170_rng_get(ar);
1575         if (ret) {
1576             mutex_unlock(&ar->mutex);
1577             return ret;
1578         }
1579     }
1580
1581     *data = ar->rng.cache[ar->rng.cache_idx++];
1582     mutex_unlock(&ar->mutex);
1583
1584     return sizeof(u16);
1585 }
1586
1587 static int carl9170_register_hwrng(struct ar9170 *ar)
1588 {
1589     int err;
1590
1591     snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name),
1592          "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy));
1593     ar->rng.rng.name = ar->rng.name;
1594     ar->rng.rng.data_read = carl9170_rng_read;
1595     ar->rng.rng.priv = (unsigned long)ar;
1596
1597     err = devm_hwrng_register(&ar->udev->dev, &ar->rng.rng);
1598     if (err) {
1599         dev_err(&ar->udev->dev, "Failed to register the random "
1600             "number generator (%d)\n", err);
1601         return err;
1602     }
1603
1604     return carl9170_rng_get(ar);
1605 }
1606 #endif /* CONFIG_CARL9170_HWRNG */
1607
1608 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1609                 struct survey_info *survey)
1610 {
1611     struct ar9170 *ar = hw->priv;
1612     struct ieee80211_channel *chan;
1613     struct ieee80211_supported_band *band;
1614     int err, b, i;
1615
1616     chan = ar->channel;
1617     if (!chan)
1618         return -ENODEV;
1619
1620     if (idx == chan->hw_value) {
1621         mutex_lock(&ar->mutex);
1622         err = carl9170_update_survey(ar, false, true);
1623         mutex_unlock(&ar->mutex);
1624         if (err)
1625             return err;
1626     }
1627
1628     for (b = 0; b < NUM_NL80211_BANDS; b++) {
1629         band = ar->hw->wiphy->bands[b];
1630
1631         if (!band)
1632             continue;
1633
1634         for (i = 0; i < band->n_channels; i++) {
1635             if (band->channels[i].hw_value == idx) {
1636                 chan = &band->channels[i];
1637                 goto found;
1638             }
1639         }
1640     }
1641     return -ENOENT;
1642
1643 found:
1644     memcpy(survey, &ar->survey[idx], sizeof(*survey));
1645
1646     survey->channel = chan;
1647     survey->filled = SURVEY_INFO_NOISE_DBM;
1648
1649     if (ar->channel == chan)
1650         survey->filled |= SURVEY_INFO_IN_USE;
1651
1652     if (ar->fw.hw_counters) {
1653         survey->filled |= SURVEY_INFO_TIME |
1654                   SURVEY_INFO_TIME_BUSY |
1655                   SURVEY_INFO_TIME_TX;
1656     }
1657
1658     return 0;
1659 }
1660
1661 static void carl9170_op_flush(struct ieee80211_hw *hw,
1662                   struct ieee80211_vif *vif,
1663                   u32 queues, bool drop)
1664 {
1665     struct ar9170 *ar = hw->priv;
1666     unsigned int vid;
1667
1668     mutex_lock(&ar->mutex);
1669     for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1670         carl9170_flush_cab(ar, vid);
1671
1672     carl9170_flush(ar, drop);
1673     mutex_unlock(&ar->mutex);
1674 }
1675
1676 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1677                  struct ieee80211_low_level_stats *stats)
1678 {
1679     struct ar9170 *ar = hw->priv;
1680
1681     memset(stats, 0, sizeof(*stats));
1682     stats->dot11ACKFailureCount = ar->tx_ack_failures;
1683     stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1684     return 0;
1685 }
1686
1687 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1688                    struct ieee80211_vif *vif,
1689                    enum sta_notify_cmd cmd,
1690                    struct ieee80211_sta *sta)
1691 {
1692     struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1693
1694     switch (cmd) {
1695     case STA_NOTIFY_SLEEP:
1696         sta_info->sleeping = true;
1697         if (atomic_read(&sta_info->pending_frames))
1698             ieee80211_sta_block_awake(hw, sta, true);
1699         break;
1700
1701     case STA_NOTIFY_AWAKE:
1702         sta_info->sleeping = false;
1703         break;
1704     }
1705 }
1706
1707 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1708 {
1709     struct ar9170 *ar = hw->priv;
1710
1711     return !!atomic_read(&ar->tx_total_queued);
1712 }
1713
1714 static const struct ieee80211_ops carl9170_ops = {
1715     .start          = carl9170_op_start,
1716     .stop           = carl9170_op_stop,
1717     .tx         = carl9170_op_tx,
1718     .flush          = carl9170_op_flush,
1719     .add_interface      = carl9170_op_add_interface,
1720     .remove_interface   = carl9170_op_remove_interface,
1721     .config         = carl9170_op_config,
1722     .prepare_multicast  = carl9170_op_prepare_multicast,
1723     .configure_filter   = carl9170_op_configure_filter,
1724     .conf_tx        = carl9170_op_conf_tx,
1725     .bss_info_changed   = carl9170_op_bss_info_changed,
1726     .get_tsf        = carl9170_op_get_tsf,
1727     .set_key        = carl9170_op_set_key,
1728     .sta_add        = carl9170_op_sta_add,
1729     .sta_remove     = carl9170_op_sta_remove,
1730     .sta_notify     = carl9170_op_sta_notify,
1731     .get_survey     = carl9170_op_get_survey,
1732     .get_stats      = carl9170_op_get_stats,
1733     .ampdu_action       = carl9170_op_ampdu_action,
1734     .tx_frames_pending  = carl9170_tx_frames_pending,
1735 };
1736
1737 void *carl9170_alloc(size_t priv_size)
1738 {
1739     struct ieee80211_hw *hw;
1740     struct ar9170 *ar;
1741     struct sk_buff *skb;
1742     int i;
1743
1744     /*
1745      * this buffer is used for rx stream reconstruction.
1746      * Under heavy load this device (or the transport layer?)
1747      * tends to split the streams into separate rx descriptors.
1748      */
1749
1750     skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1751     if (!skb)
1752         goto err_nomem;
1753
1754     hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1755     if (!hw)
1756         goto err_nomem;
1757
1758     ar = hw->priv;
1759     ar->hw = hw;
1760     ar->rx_failover = skb;
1761
1762     memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1763     ar->rx_has_plcp = false;
1764
1765     /*
1766      * Here's a hidden pitfall!
1767      *
1768      * All 4 AC queues work perfectly well under _legacy_ operation.
1769      * However as soon as aggregation is enabled, the traffic flow
1770      * gets very bumpy. Therefore we have to _switch_ to a
1771      * software AC with a single HW queue.
1772      */
1773     hw->queues = __AR9170_NUM_TXQ;
1774
1775     mutex_init(&ar->mutex);
1776     spin_lock_init(&ar->beacon_lock);
1777     spin_lock_init(&ar->cmd_lock);
1778     spin_lock_init(&ar->tx_stats_lock);
1779     spin_lock_init(&ar->tx_ampdu_list_lock);
1780     spin_lock_init(&ar->mem_lock);
1781     spin_lock_init(&ar->state_lock);
1782     atomic_set(&ar->pending_restarts, 0);
1783     ar->vifs = 0;
1784     for (i = 0; i < ar->hw->queues; i++) {
1785         skb_queue_head_init(&ar->tx_status[i]);
1786         skb_queue_head_init(&ar->tx_pending[i]);
1787
1788         INIT_LIST_HEAD(&ar->bar_list[i]);
1789         spin_lock_init(&ar->bar_list_lock[i]);
1790     }
1791     INIT_WORK(&ar->ps_work, carl9170_ps_work);
1792     INIT_WORK(&ar->ping_work, carl9170_ping_work);
1793     INIT_WORK(&ar->restart_work, carl9170_restart_work);
1794     INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1795     INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1796     INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1797     INIT_LIST_HEAD(&ar->tx_ampdu_list);
1798     rcu_assign_pointer(ar->tx_ampdu_iter,
1799                (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1800
1801     bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1802     INIT_LIST_HEAD(&ar->vif_list);
1803     init_completion(&ar->tx_flush);
1804
1805     /* firmware decides which modes we support */
1806     hw->wiphy->interface_modes = 0;
1807
1808     ieee80211_hw_set(hw, RX_INCLUDES_FCS);
1809     ieee80211_hw_set(hw, MFP_CAPABLE);
1810     ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
1811     ieee80211_hw_set(hw, SUPPORTS_PS);
1812     ieee80211_hw_set(hw, PS_NULLFUNC_STACK);
1813     ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
1814     ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
1815     ieee80211_hw_set(hw, SIGNAL_DBM);
1816     ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
1817
1818     if (!modparam_noht) {
1819         /*
1820          * see the comment above, why we allow the user
1821          * to disable HT by a module parameter.
1822          */
1823         ieee80211_hw_set(hw, AMPDU_AGGREGATION);
1824     }
1825
1826     hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1827     hw->sta_data_size = sizeof(struct carl9170_sta_info);
1828     hw->vif_data_size = sizeof(struct carl9170_vif_info);
1829
1830     hw->max_rates = CARL9170_TX_MAX_RATES;
1831     hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1832
1833     for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1834         ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1835
1836     wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
1837
1838     return ar;
1839
1840 err_nomem:
1841     kfree_skb(skb);
1842     return ERR_PTR(-ENOMEM);
1843 }
1844
1845 static int carl9170_read_eeprom(struct ar9170 *ar)
1846 {
1847 #define RW  8   /* number of words to read at once */
1848 #define RB  (sizeof(u32) * RW)
1849     u8 *eeprom = (void *)&ar->eeprom;
1850     __le32 offsets[RW];
1851     int i, j, err;
1852
1853     BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1854
1855     BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1856 #ifndef __CHECKER__
1857     /* don't want to handle trailing remains */
1858     BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1859 #endif
1860
1861     for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1862         for (j = 0; j < RW; j++)
1863             offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1864                          RB * i + 4 * j);
1865
1866         err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1867                     RB, (u8 *) &offsets,
1868                     RB, eeprom + RB * i);
1869         if (err)
1870             return err;
1871     }
1872
1873 #undef RW
1874 #undef RB
1875     return 0;
1876 }
1877
1878 static int carl9170_parse_eeprom(struct ar9170 *ar)
1879 {
1880     struct ath_regulatory *regulatory = &ar->common.regulatory;
1881     unsigned int rx_streams, tx_streams, tx_params = 0;
1882     int bands = 0;
1883     int chans = 0;
1884
1885     if (ar->eeprom.length == cpu_to_le16(0xffff))
1886         return -ENODATA;
1887
1888     rx_streams = hweight8(ar->eeprom.rx_mask);
1889     tx_streams = hweight8(ar->eeprom.tx_mask);
1890
1891     if (rx_streams != tx_streams) {
1892         tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1893
1894         WARN_ON(!(tx_streams >= 1 && tx_streams <=
1895             IEEE80211_HT_MCS_TX_MAX_STREAMS));
1896
1897         tx_params |= (tx_streams - 1) <<
1898                 IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1899
1900         carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1901         carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1902     }
1903
1904     if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1905         ar->hw->wiphy->bands[NL80211_BAND_2GHZ] =
1906             &carl9170_band_2GHz;
1907         chans += carl9170_band_2GHz.n_channels;
1908         bands++;
1909     }
1910     if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1911         ar->hw->wiphy->bands[NL80211_BAND_5GHZ] =
1912             &carl9170_band_5GHz;
1913         chans += carl9170_band_5GHz.n_channels;
1914         bands++;
1915     }
1916
1917     if (!bands)
1918         return -EINVAL;
1919
1920     ar->survey = devm_kcalloc(&ar->udev->dev, chans,
1921                   sizeof(struct survey_info), GFP_KERNEL);
1922     if (!ar->survey)
1923         return -ENOMEM;
1924     ar->num_channels = chans;
1925
1926     regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1927
1928     /* second part of wiphy init */
1929     SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1930
1931     return 0;
1932 }
1933
1934 static void carl9170_reg_notifier(struct wiphy *wiphy,
1935                   struct regulatory_request *request)
1936 {
1937     struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1938     struct ar9170 *ar = hw->priv;
1939
1940     ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1941 }
1942
1943 int carl9170_register(struct ar9170 *ar)
1944 {
1945     struct ath_regulatory *regulatory = &ar->common.regulatory;
1946     int err = 0, i;
1947
1948     ar->mem_bitmap = devm_bitmap_zalloc(&ar->udev->dev, ar->fw.mem_blocks, GFP_KERNEL);
1949     if (!ar->mem_bitmap)
1950         return -ENOMEM;
1951
1952     /* try to read EEPROM, init MAC addr */
1953     err = carl9170_read_eeprom(ar);
1954     if (err)
1955         return err;
1956
1957     err = carl9170_parse_eeprom(ar);
1958     if (err)
1959         return err;
1960
1961     err = ath_regd_init(regulatory, ar->hw->wiphy,
1962                 carl9170_reg_notifier);
1963     if (err)
1964         return err;
1965
1966     if (modparam_noht) {
1967         carl9170_band_2GHz.ht_cap.ht_supported = false;
1968         carl9170_band_5GHz.ht_cap.ht_supported = false;
1969     }
1970
1971     for (i = 0; i < ar->fw.vif_num; i++) {
1972         ar->vif_priv[i].id = i;
1973         ar->vif_priv[i].vif = NULL;
1974     }
1975
1976     err = ieee80211_register_hw(ar->hw);
1977     if (err)
1978         return err;
1979
1980     /* mac80211 interface is now registered */
1981     ar->registered = true;
1982
1983     if (!ath_is_world_regd(regulatory))
1984         regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1985
1986 #ifdef CONFIG_CARL9170_DEBUGFS
1987     carl9170_debugfs_register(ar);
1988 #endif /* CONFIG_CARL9170_DEBUGFS */
1989
1990     err = carl9170_led_init(ar);
1991     if (err)
1992         goto err_unreg;
1993
1994 #ifdef CONFIG_CARL9170_LEDS
1995     err = carl9170_led_register(ar);
1996     if (err)
1997         goto err_unreg;
1998 #endif /* CONFIG_CARL9170_LEDS */
1999
2000 #ifdef CONFIG_CARL9170_WPC
2001     err = carl9170_register_wps_button(ar);
2002     if (err)
2003         goto err_unreg;
2004 #endif /* CONFIG_CARL9170_WPC */
2005
2006 #ifdef CONFIG_CARL9170_HWRNG
2007     err = carl9170_register_hwrng(ar);
2008     if (err)
2009         goto err_unreg;
2010 #endif /* CONFIG_CARL9170_HWRNG */
2011
2012     dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
2013          wiphy_name(ar->hw->wiphy));
2014
2015     return 0;
2016
2017 err_unreg:
2018     carl9170_unregister(ar);
2019     return err;
2020 }
2021
2022 void carl9170_unregister(struct ar9170 *ar)
2023 {
2024     if (!ar->registered)
2025         return;
2026
2027     ar->registered = false;
2028
2029 #ifdef CONFIG_CARL9170_LEDS
2030     carl9170_led_unregister(ar);
2031 #endif /* CONFIG_CARL9170_LEDS */
2032
2033 #ifdef CONFIG_CARL9170_DEBUGFS
2034     carl9170_debugfs_unregister(ar);
2035 #endif /* CONFIG_CARL9170_DEBUGFS */
2036
2037     carl9170_cancel_worker(ar);
2038     cancel_work_sync(&ar->restart_work);
2039
2040     ieee80211_unregister_hw(ar->hw);
2041 }
2042
2043 void carl9170_free(struct ar9170 *ar)
2044 {
2045     WARN_ON(ar->registered);
2046     WARN_ON(IS_INITIALIZED(ar));
2047
2048     kfree_skb(ar->rx_failover);
2049     ar->rx_failover = NULL;
2050
2051     mutex_destroy(&ar->mutex);
2052
2053     ieee80211_free_hw(ar->hw);
2054 }