drivers/net/wireless/ath/carl9170/main.c

   1 /*
   2  * Atheros CARL9170 driver
   3  *
   4  * mac80211 interaction code
   5  *
   6  * Copyright 2008, Johannes Berg <johannes@sipsolutions.net>
   7  * Copyright 2009, 2010, Christian Lamparter <chunkeey@googlemail.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; see the file COPYING.  If not, see
  21  * http://www.gnu.org/licenses/.
  22  *
  23  * This file incorporates work covered by the following copyright and
  24  * permission notice:
  25  *    Copyright (c) 2007-2008 Atheros Communications, Inc.
  26  *
  27  *    Permission to use, copy, modify, and/or distribute this software for any
  28  *    purpose with or without fee is hereby granted, provided that the above
  29  *    copyright notice and this permission notice appear in all copies.
  30  *
  31  *    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  32  *    WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  33  *    MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  34  *    ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  35  *    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  36  *    ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  37  *    OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  38  */
  39
  40 #include <linux/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         bitmap_zero(ar->mem_bitmap, ar->fw.mem_blocks);
 311
 312         rcu_read_lock();
 313         list_for_each_entry_rcu(cvif, &ar->vif_list, list) {
 314                 spin_lock_bh(&ar->beacon_lock);
 315                 dev_kfree_skb_any(cvif->beacon);
 316                 cvif->beacon = NULL;
 317                 spin_unlock_bh(&ar->beacon_lock);
 318         }
 319         rcu_read_unlock();
 320
 321         atomic_set(&ar->tx_ampdu_upload, 0);
 322         atomic_set(&ar->tx_ampdu_scheduler, 0);
 323         atomic_set(&ar->tx_total_pending, 0);
 324         atomic_set(&ar->tx_total_queued, 0);
 325         atomic_set(&ar->mem_free_blocks, ar->fw.mem_blocks);
 326 }
 327
 328 #define CARL9170_FILL_QUEUE(queue, ai_fs, cwmin, cwmax, _txop)          \
 329 do {                                                                    \
 330         queue.aifs = ai_fs;                                             \
 331         queue.cw_min = cwmin;                                           \
 332         queue.cw_max = cwmax;                                           \
 333         queue.txop = _txop;                                             \
 334 } while (0)
 335
 336 static int carl9170_op_start(struct ieee80211_hw *hw)
 337 {
 338         struct ar9170 *ar = hw->priv;
 339         int err, i;
 340
 341         mutex_lock(&ar->mutex);
 342
 343         carl9170_zap_queues(ar);
 344
 345         /* reset QoS defaults */
 346         CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VO], 2, 3,     7, 47);
 347         CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_VI], 2, 7,    15, 94);
 348         CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BE], 3, 15, 1023,  0);
 349         CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_BK], 7, 15, 1023,  0);
 350         CARL9170_FILL_QUEUE(ar->edcf[AR9170_TXQ_SPECIAL], 2, 3, 7, 0);
 351
 352         ar->current_factor = ar->current_density = -1;
 353         /* "The first key is unique." */
 354         ar->usedkeys = 1;
 355         ar->filter_state = 0;
 356         ar->ps.last_action = jiffies;
 357         ar->ps.last_slept = jiffies;
 358         ar->erp_mode = CARL9170_ERP_AUTO;
 359
 360         /* Set "disable hw crypto offload" whenever the module parameter
 361          * nohwcrypt is true or if the firmware does not support it.
 362          */
 363         ar->disable_offload = modparam_nohwcrypt |
 364                 ar->fw.disable_offload_fw;
 365         ar->rx_software_decryption = ar->disable_offload;
 366
 367         for (i = 0; i < ar->hw->queues; i++) {
 368                 ar->queue_stop_timeout[i] = jiffies;
 369                 ar->max_queue_stop_timeout[i] = 0;
 370         }
 371
 372         atomic_set(&ar->mem_allocs, 0);
 373
 374         err = carl9170_usb_open(ar);
 375         if (err)
 376                 goto out;
 377
 378         err = carl9170_init_mac(ar);
 379         if (err)
 380                 goto out;
 381
 382         err = carl9170_set_qos(ar);
 383         if (err)
 384                 goto out;
 385
 386         if (ar->fw.rx_filter) {
 387                 err = carl9170_rx_filter(ar, CARL9170_RX_FILTER_OTHER_RA |
 388                         CARL9170_RX_FILTER_CTL_OTHER | CARL9170_RX_FILTER_BAD);
 389                 if (err)
 390                         goto out;
 391         }
 392
 393         err = carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER,
 394                                  AR9170_DMA_TRIGGER_RXQ);
 395         if (err)
 396                 goto out;
 397
 398         /* Clear key-cache */
 399         for (i = 0; i < AR9170_CAM_MAX_USER + 4; i++) {
 400                 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
 401                                           0, NULL, 0);
 402                 if (err)
 403                         goto out;
 404
 405                 err = carl9170_upload_key(ar, i, NULL, AR9170_ENC_ALG_NONE,
 406                                           1, NULL, 0);
 407                 if (err)
 408                         goto out;
 409
 410                 if (i < AR9170_CAM_MAX_USER) {
 411                         err = carl9170_disable_key(ar, i);
 412                         if (err)
 413                                 goto out;
 414                 }
 415         }
 416
 417         carl9170_set_state_when(ar, CARL9170_IDLE, CARL9170_STARTED);
 418
 419         ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
 420                 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
 421
 422         ieee80211_wake_queues(ar->hw);
 423         err = 0;
 424
 425 out:
 426         mutex_unlock(&ar->mutex);
 427         return err;
 428 }
 429
 430 static void carl9170_cancel_worker(struct ar9170 *ar)
 431 {
 432         cancel_delayed_work_sync(&ar->stat_work);
 433         cancel_delayed_work_sync(&ar->tx_janitor);
 434 #ifdef CONFIG_CARL9170_LEDS
 435         cancel_delayed_work_sync(&ar->led_work);
 436 #endif /* CONFIG_CARL9170_LEDS */
 437         cancel_work_sync(&ar->ps_work);
 438         cancel_work_sync(&ar->ping_work);
 439         cancel_work_sync(&ar->ampdu_work);
 440 }
 441
 442 static void carl9170_op_stop(struct ieee80211_hw *hw)
 443 {
 444         struct ar9170 *ar = hw->priv;
 445
 446         carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
 447
 448         ieee80211_stop_queues(ar->hw);
 449
 450         mutex_lock(&ar->mutex);
 451         if (IS_ACCEPTING_CMD(ar)) {
 452                 RCU_INIT_POINTER(ar->beacon_iter, NULL);
 453
 454                 carl9170_led_set_state(ar, 0);
 455
 456                 /* stop DMA */
 457                 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
 458                 carl9170_usb_stop(ar);
 459         }
 460
 461         carl9170_zap_queues(ar);
 462         mutex_unlock(&ar->mutex);
 463
 464         carl9170_cancel_worker(ar);
 465 }
 466
 467 static void carl9170_restart_work(struct work_struct *work)
 468 {
 469         struct ar9170 *ar = container_of(work, struct ar9170,
 470                                          restart_work);
 471         int err = -EIO;
 472
 473         ar->usedkeys = 0;
 474         ar->filter_state = 0;
 475         carl9170_cancel_worker(ar);
 476
 477         mutex_lock(&ar->mutex);
 478         if (!ar->force_usb_reset) {
 479                 err = carl9170_usb_restart(ar);
 480                 if (net_ratelimit()) {
 481                         if (err)
 482                                 dev_err(&ar->udev->dev, "Failed to restart device (%d).\n", err);
 483                         else
 484                                 dev_info(&ar->udev->dev, "device restarted successfully.\n");
 485                 }
 486         }
 487         carl9170_zap_queues(ar);
 488         mutex_unlock(&ar->mutex);
 489
 490         if (!err && !ar->force_usb_reset) {
 491                 ar->restart_counter++;
 492                 atomic_set(&ar->pending_restarts, 0);
 493
 494                 ieee80211_restart_hw(ar->hw);
 495         } else {
 496                 /*
 497                  * The reset was unsuccessful and the device seems to
 498                  * be dead. But there's still one option: a low-level
 499                  * usb subsystem reset...
 500                  */
 501
 502                 carl9170_usb_reset(ar);
 503         }
 504 }
 505
 506 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
 507 {
 508         carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
 509
 510         /*
 511          * Sometimes, an error can trigger several different reset events.
 512          * By ignoring these *surplus* reset events, the device won't be
 513          * killed again, right after it has recovered.
 514          */
 515         if (atomic_inc_return(&ar->pending_restarts) > 1) {
 516                 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
 517                 return;
 518         }
 519
 520         ieee80211_stop_queues(ar->hw);
 521
 522         dev_err(&ar->udev->dev, "restart device (%d)\n", r);
 523
 524         if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
 525             !WARN_ON(r >= __CARL9170_RR_LAST))
 526                 ar->last_reason = r;
 527
 528         if (!ar->registered)
 529                 return;
 530
 531         if (!IS_ACCEPTING_CMD(ar) || ar->needs_full_reset)
 532                 ar->force_usb_reset = true;
 533
 534         ieee80211_queue_work(ar->hw, &ar->restart_work);
 535
 536         /*
 537          * At this point, the device instance might have vanished/disabled.
 538          * So, don't put any code which access the ar9170 struct
 539          * without proper protection.
 540          */
 541 }
 542
 543 static void carl9170_ping_work(struct work_struct *work)
 544 {
 545         struct ar9170 *ar = container_of(work, struct ar9170, ping_work);
 546         int err;
 547
 548         if (!IS_STARTED(ar))
 549                 return;
 550
 551         mutex_lock(&ar->mutex);
 552         err = carl9170_echo_test(ar, 0xdeadbeef);
 553         if (err)
 554                 carl9170_restart(ar, CARL9170_RR_UNRESPONSIVE_DEVICE);
 555         mutex_unlock(&ar->mutex);
 556 }
 557
 558 static int carl9170_init_interface(struct ar9170 *ar,
 559                                    struct ieee80211_vif *vif)
 560 {
 561         struct ath_common *common = &ar->common;
 562         int err;
 563
 564         if (!vif) {
 565                 WARN_ON_ONCE(IS_STARTED(ar));
 566                 return 0;
 567         }
 568
 569         memcpy(common->macaddr, vif->addr, ETH_ALEN);
 570
 571         /* We have to fall back to software crypto, whenever
 572          * the user choose to participates in an IBSS. HW
 573          * offload for IBSS RSN is not supported by this driver.
 574          *
 575          * NOTE: If the previous main interface has already
 576          * disabled hw crypto offload, we have to keep this
 577          * previous disable_offload setting as it was.
 578          * Altough ideally, we should notify mac80211 and tell
 579          * it to forget about any HW crypto offload for now.
 580          */
 581         ar->disable_offload |= ((vif->type != NL80211_IFTYPE_STATION) &&
 582             (vif->type != NL80211_IFTYPE_AP));
 583
 584         /* The driver used to have P2P GO+CLIENT support,
 585          * but since this was dropped and we don't know if
 586          * there are any gremlins lurking in the shadows,
 587          * so best we keep HW offload disabled for P2P.
 588          */
 589         ar->disable_offload |= vif->p2p;
 590
 591         ar->rx_software_decryption = ar->disable_offload;
 592
 593         err = carl9170_set_operating_mode(ar);
 594         return err;
 595 }
 596
 597 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
 598                                      struct ieee80211_vif *vif)
 599 {
 600         struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
 601         struct ieee80211_vif *main_vif, *old_main = NULL;
 602         struct ar9170 *ar = hw->priv;
 603         int vif_id = -1, err = 0;
 604
 605         mutex_lock(&ar->mutex);
 606         rcu_read_lock();
 607         if (vif_priv->active) {
 608                 /*
 609                  * Skip the interface structure initialization,
 610                  * if the vif survived the _restart call.
 611                  */
 612                 vif_id = vif_priv->id;
 613                 vif_priv->enable_beacon = false;
 614
 615                 spin_lock_bh(&ar->beacon_lock);
 616                 dev_kfree_skb_any(vif_priv->beacon);
 617                 vif_priv->beacon = NULL;
 618                 spin_unlock_bh(&ar->beacon_lock);
 619
 620                 goto init;
 621         }
 622
 623         /* Because the AR9170 HW's MAC doesn't provide full support for
 624          * multiple, independent interfaces [of different operation modes].
 625          * We have to select ONE main interface [main mode of HW], but we
 626          * can have multiple slaves [AKA: entry in the ACK-table].
 627          *
 628          * The first (from HEAD/TOP) interface in the ar->vif_list is
 629          * always the main intf. All following intfs in this list
 630          * are considered to be slave intfs.
 631          */
 632         main_vif = carl9170_get_main_vif(ar);
 633
 634         if (main_vif) {
 635                 switch (main_vif->type) {
 636                 case NL80211_IFTYPE_STATION:
 637                         if (vif->type == NL80211_IFTYPE_STATION)
 638                                 break;
 639
 640                         err = -EBUSY;
 641                         rcu_read_unlock();
 642
 643                         goto unlock;
 644
 645                 case NL80211_IFTYPE_MESH_POINT:
 646                 case NL80211_IFTYPE_AP:
 647                         if ((vif->type == NL80211_IFTYPE_STATION) ||
 648                             (vif->type == NL80211_IFTYPE_AP) ||
 649                             (vif->type == NL80211_IFTYPE_MESH_POINT))
 650                                 break;
 651
 652                         err = -EBUSY;
 653                         rcu_read_unlock();
 654                         goto unlock;
 655
 656                 default:
 657                         rcu_read_unlock();
 658                         goto unlock;
 659                 }
 660         }
 661
 662         vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
 663
 664         if (vif_id < 0) {
 665                 rcu_read_unlock();
 666
 667                 err = -ENOSPC;
 668                 goto unlock;
 669         }
 670
 671         BUG_ON(ar->vif_priv[vif_id].id != vif_id);
 672
 673         vif_priv->active = true;
 674         vif_priv->id = vif_id;
 675         vif_priv->enable_beacon = false;
 676         ar->vifs++;
 677         if (old_main) {
 678                 /* We end up in here, if the main interface is being replaced.
 679                  * Put the new main interface at the HEAD of the list and the
 680                  * previous inteface will automatically become second in line.
 681                  */
 682                 list_add_rcu(&vif_priv->list, &ar->vif_list);
 683         } else {
 684                 /* Add new inteface. If the list is empty, it will become the
 685                  * main inteface, otherwise it will be slave.
 686                  */
 687                 list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
 688         }
 689         rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
 690
 691 init:
 692         main_vif = carl9170_get_main_vif(ar);
 693
 694         if (main_vif == vif) {
 695                 rcu_assign_pointer(ar->beacon_iter, vif_priv);
 696                 rcu_read_unlock();
 697
 698                 if (old_main) {
 699                         struct carl9170_vif_info *old_main_priv =
 700                                 (void *) old_main->drv_priv;
 701                         /* downgrade old main intf to slave intf.
 702                          * NOTE: We are no longer under rcu_read_lock.
 703                          * But we are still holding ar->mutex, so the
 704                          * vif data [id, addr] is safe.
 705                          */
 706                         err = carl9170_mod_virtual_mac(ar, old_main_priv->id,
 707                                                        old_main->addr);
 708                         if (err)
 709                                 goto unlock;
 710                 }
 711
 712                 err = carl9170_init_interface(ar, vif);
 713                 if (err)
 714                         goto unlock;
 715         } else {
 716                 rcu_read_unlock();
 717                 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
 718
 719                 if (err)
 720                         goto unlock;
 721         }
 722
 723         if (ar->fw.tx_seq_table) {
 724                 err = carl9170_write_reg(ar, ar->fw.tx_seq_table + vif_id * 4,
 725                                          0);
 726                 if (err)
 727                         goto unlock;
 728         }
 729
 730 unlock:
 731         if (err && (vif_id >= 0)) {
 732                 vif_priv->active = false;
 733                 bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
 734                 ar->vifs--;
 735                 RCU_INIT_POINTER(ar->vif_priv[vif_id].vif, NULL);
 736                 list_del_rcu(&vif_priv->list);
 737                 mutex_unlock(&ar->mutex);
 738                 synchronize_rcu();
 739         } else {
 740                 if (ar->vifs > 1)
 741                         ar->ps.off_override |= PS_OFF_VIF;
 742
 743                 mutex_unlock(&ar->mutex);
 744         }
 745
 746         return err;
 747 }
 748
 749 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
 750                                          struct ieee80211_vif *vif)
 751 {
 752         struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
 753         struct ieee80211_vif *main_vif;
 754         struct ar9170 *ar = hw->priv;
 755         unsigned int id;
 756
 757         mutex_lock(&ar->mutex);
 758
 759         if (WARN_ON_ONCE(!vif_priv->active))
 760                 goto unlock;
 761
 762         ar->vifs--;
 763
 764         rcu_read_lock();
 765         main_vif = carl9170_get_main_vif(ar);
 766
 767         id = vif_priv->id;
 768
 769         vif_priv->active = false;
 770         WARN_ON(vif_priv->enable_beacon);
 771         vif_priv->enable_beacon = false;
 772         list_del_rcu(&vif_priv->list);
 773         RCU_INIT_POINTER(ar->vif_priv[id].vif, NULL);
 774
 775         if (vif == main_vif) {
 776                 rcu_read_unlock();
 777
 778                 if (ar->vifs) {
 779                         WARN_ON(carl9170_init_interface(ar,
 780                                         carl9170_get_main_vif(ar)));
 781                 } else {
 782                         carl9170_set_operating_mode(ar);
 783                 }
 784         } else {
 785                 rcu_read_unlock();
 786
 787                 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
 788         }
 789
 790         carl9170_update_beacon(ar, false);
 791         carl9170_flush_cab(ar, id);
 792
 793         spin_lock_bh(&ar->beacon_lock);
 794         dev_kfree_skb_any(vif_priv->beacon);
 795         vif_priv->beacon = NULL;
 796         spin_unlock_bh(&ar->beacon_lock);
 797
 798         bitmap_release_region(&ar->vif_bitmap, id, 0);
 799
 800         carl9170_set_beacon_timers(ar);
 801
 802         if (ar->vifs == 1)
 803                 ar->ps.off_override &= ~PS_OFF_VIF;
 804
 805 unlock:
 806         mutex_unlock(&ar->mutex);
 807
 808         synchronize_rcu();
 809 }
 810
 811 void carl9170_ps_check(struct ar9170 *ar)
 812 {
 813         ieee80211_queue_work(ar->hw, &ar->ps_work);
 814 }
 815
 816 /* caller must hold ar->mutex */
 817 static int carl9170_ps_update(struct ar9170 *ar)
 818 {
 819         bool ps = false;
 820         int err = 0;
 821
 822         if (!ar->ps.off_override)
 823                 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
 824
 825         if (ps != ar->ps.state) {
 826                 err = carl9170_powersave(ar, ps);
 827                 if (err)
 828                         return err;
 829
 830                 if (ar->ps.state && !ps) {
 831                         ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
 832                                 ar->ps.last_action);
 833                 }
 834
 835                 if (ps)
 836                         ar->ps.last_slept = jiffies;
 837
 838                 ar->ps.last_action = jiffies;
 839                 ar->ps.state = ps;
 840         }
 841
 842         return 0;
 843 }
 844
 845 static void carl9170_ps_work(struct work_struct *work)
 846 {
 847         struct ar9170 *ar = container_of(work, struct ar9170,
 848                                          ps_work);
 849         mutex_lock(&ar->mutex);
 850         if (IS_STARTED(ar))
 851                 WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
 852         mutex_unlock(&ar->mutex);
 853 }
 854
 855 static int carl9170_update_survey(struct ar9170 *ar, bool flush, bool noise)
 856 {
 857         int err;
 858
 859         if (noise) {
 860                 err = carl9170_get_noisefloor(ar);
 861                 if (err)
 862                         return err;
 863         }
 864
 865         if (ar->fw.hw_counters) {
 866                 err = carl9170_collect_tally(ar);
 867                 if (err)
 868                         return err;
 869         }
 870
 871         if (flush)
 872                 memset(&ar->tally, 0, sizeof(ar->tally));
 873
 874         return 0;
 875 }
 876
 877 static void carl9170_stat_work(struct work_struct *work)
 878 {
 879         struct ar9170 *ar = container_of(work, struct ar9170, stat_work.work);
 880         int err;
 881
 882         mutex_lock(&ar->mutex);
 883         err = carl9170_update_survey(ar, false, true);
 884         mutex_unlock(&ar->mutex);
 885
 886         if (err)
 887                 return;
 888
 889         ieee80211_queue_delayed_work(ar->hw, &ar->stat_work,
 890                 round_jiffies(msecs_to_jiffies(CARL9170_STAT_WORK)));
 891 }
 892
 893 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
 894 {
 895         struct ar9170 *ar = hw->priv;
 896         int err = 0;
 897
 898         mutex_lock(&ar->mutex);
 899         if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
 900                 /* TODO */
 901                 err = 0;
 902         }
 903
 904         if (changed & IEEE80211_CONF_CHANGE_PS) {
 905                 err = carl9170_ps_update(ar);
 906                 if (err)
 907                         goto out;
 908         }
 909
 910         if (changed & IEEE80211_CONF_CHANGE_SMPS) {
 911                 /* TODO */
 912                 err = 0;
 913         }
 914
 915         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
 916                 enum nl80211_channel_type channel_type =
 917                         cfg80211_get_chandef_type(&hw->conf.chandef);
 918
 919                 /* adjust slot time for 5 GHz */
 920                 err = carl9170_set_slot_time(ar);
 921                 if (err)
 922                         goto out;
 923
 924                 err = carl9170_update_survey(ar, true, false);
 925                 if (err)
 926                         goto out;
 927
 928                 err = carl9170_set_channel(ar, hw->conf.chandef.chan,
 929                                            channel_type);
 930                 if (err)
 931                         goto out;
 932
 933                 err = carl9170_update_survey(ar, false, true);
 934                 if (err)
 935                         goto out;
 936
 937                 err = carl9170_set_dyn_sifs_ack(ar);
 938                 if (err)
 939                         goto out;
 940
 941                 err = carl9170_set_rts_cts_rate(ar);
 942                 if (err)
 943                         goto out;
 944         }
 945
 946         if (changed & IEEE80211_CONF_CHANGE_POWER) {
 947                 err = carl9170_set_mac_tpc(ar, ar->hw->conf.chandef.chan);
 948                 if (err)
 949                         goto out;
 950         }
 951
 952 out:
 953         mutex_unlock(&ar->mutex);
 954         return err;
 955 }
 956
 957 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
 958                                          struct netdev_hw_addr_list *mc_list)
 959 {
 960         struct netdev_hw_addr *ha;
 961         u64 mchash;
 962
 963         /* always get broadcast frames */
 964         mchash = 1ULL << (0xff >> 2);
 965
 966         netdev_hw_addr_list_for_each(ha, mc_list)
 967                 mchash |= 1ULL << (ha->addr[5] >> 2);
 968
 969         return mchash;
 970 }
 971
 972 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
 973                                          unsigned int changed_flags,
 974                                          unsigned int *new_flags,
 975                                          u64 multicast)
 976 {
 977         struct ar9170 *ar = hw->priv;
 978
 979         /* mask supported flags */
 980         *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
 981
 982         if (!IS_ACCEPTING_CMD(ar))
 983                 return;
 984
 985         mutex_lock(&ar->mutex);
 986
 987         ar->filter_state = *new_flags;
 988         /*
 989          * We can support more by setting the sniffer bit and
 990          * then checking the error flags, later.
 991          */
 992
 993         if (*new_flags & FIF_ALLMULTI)
 994                 multicast = ~0ULL;
 995
 996         if (multicast != ar->cur_mc_hash)
 997                 WARN_ON(carl9170_update_multicast(ar, multicast));
 998
 999         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                                          u32 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 = bss_conf->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, u16 queue,
1369                                const struct ieee80211_tx_queue_params *param)
1370 {
1371         struct ar9170 *ar = hw->priv;
1372         int ret;
1373
1374         mutex_lock(&ar->mutex);
1375         memcpy(&ar->edcf[ar9170_qmap(queue)], param, sizeof(*param));
1376         ret = carl9170_set_qos(ar);
1377         mutex_unlock(&ar->mutex);
1378         return ret;
1379 }
1380
1381 static void carl9170_ampdu_work(struct work_struct *work)
1382 {
1383         struct ar9170 *ar = container_of(work, struct ar9170,
1384                                          ampdu_work);
1385
1386         if (!IS_STARTED(ar))
1387                 return;
1388
1389         mutex_lock(&ar->mutex);
1390         carl9170_ampdu_gc(ar);
1391         mutex_unlock(&ar->mutex);
1392 }
1393
1394 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1395                                     struct ieee80211_vif *vif,
1396                                     struct ieee80211_ampdu_params *params)
1397 {
1398         struct ieee80211_sta *sta = params->sta;
1399         enum ieee80211_ampdu_mlme_action action = params->action;
1400         u16 tid = params->tid;
1401         u16 *ssn = &params->ssn;
1402         struct ar9170 *ar = hw->priv;
1403         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1404         struct carl9170_sta_tid *tid_info;
1405
1406         if (modparam_noht)
1407                 return -EOPNOTSUPP;
1408
1409         switch (action) {
1410         case IEEE80211_AMPDU_TX_START:
1411                 if (!sta_info->ht_sta)
1412                         return -EOPNOTSUPP;
1413
1414                 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1415                                    GFP_KERNEL);
1416                 if (!tid_info)
1417                         return -ENOMEM;
1418
1419                 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1420                 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1421                 tid_info->tid = tid;
1422                 tid_info->max = sta_info->ampdu_max_len;
1423                 tid_info->sta = sta;
1424                 tid_info->vif = vif;
1425
1426                 INIT_LIST_HEAD(&tid_info->list);
1427                 INIT_LIST_HEAD(&tid_info->tmp_list);
1428                 skb_queue_head_init(&tid_info->queue);
1429                 spin_lock_init(&tid_info->lock);
1430
1431                 spin_lock_bh(&ar->tx_ampdu_list_lock);
1432                 ar->tx_ampdu_list_len++;
1433                 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1434                 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1435                 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1436
1437                 return IEEE80211_AMPDU_TX_START_IMMEDIATE;
1438
1439         case IEEE80211_AMPDU_TX_STOP_CONT:
1440         case IEEE80211_AMPDU_TX_STOP_FLUSH:
1441         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1442                 rcu_read_lock();
1443                 tid_info = rcu_dereference(sta_info->agg[tid]);
1444                 if (tid_info) {
1445                         spin_lock_bh(&ar->tx_ampdu_list_lock);
1446                         if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1447                                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1448                         spin_unlock_bh(&ar->tx_ampdu_list_lock);
1449                 }
1450
1451                 RCU_INIT_POINTER(sta_info->agg[tid], NULL);
1452                 rcu_read_unlock();
1453
1454                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1455                 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1456                 break;
1457
1458         case IEEE80211_AMPDU_TX_OPERATIONAL:
1459                 rcu_read_lock();
1460                 tid_info = rcu_dereference(sta_info->agg[tid]);
1461
1462                 sta_info->stats[tid].clear = true;
1463                 sta_info->stats[tid].req = false;
1464
1465                 if (tid_info) {
1466                         bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1467                         tid_info->state = CARL9170_TID_STATE_IDLE;
1468                 }
1469                 rcu_read_unlock();
1470
1471                 if (WARN_ON_ONCE(!tid_info))
1472                         return -EFAULT;
1473
1474                 break;
1475
1476         case IEEE80211_AMPDU_RX_START:
1477         case IEEE80211_AMPDU_RX_STOP:
1478                 /* Handled by hardware */
1479                 break;
1480
1481         default:
1482                 return -EOPNOTSUPP;
1483         }
1484
1485         return 0;
1486 }
1487
1488 #ifdef CONFIG_CARL9170_WPC
1489 static int carl9170_register_wps_button(struct ar9170 *ar)
1490 {
1491         struct input_dev *input;
1492         int err;
1493
1494         if (!(ar->features & CARL9170_WPS_BUTTON))
1495                 return 0;
1496
1497         input = devm_input_allocate_device(&ar->udev->dev);
1498         if (!input)
1499                 return -ENOMEM;
1500
1501         snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1502                  wiphy_name(ar->hw->wiphy));
1503
1504         snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1505                  "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1506
1507         input->name = ar->wps.name;
1508         input->phys = ar->wps.phys;
1509         input->id.bustype = BUS_USB;
1510         input->dev.parent = &ar->hw->wiphy->dev;
1511
1512         input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1513
1514         err = input_register_device(input);
1515         if (err)
1516                 return err;
1517
1518         ar->wps.pbc = input;
1519         return 0;
1520 }
1521 #endif /* CONFIG_CARL9170_WPC */
1522
1523 #ifdef CONFIG_CARL9170_HWRNG
1524 static int carl9170_rng_get(struct ar9170 *ar)
1525 {
1526
1527 #define RW      (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32))
1528 #define RB      (CARL9170_MAX_CMD_PAYLOAD_LEN)
1529
1530         static const __le32 rng_load[RW] = {
1531                 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)};
1532
1533         u32 buf[RW];
1534
1535         unsigned int i, off = 0, transfer, count;
1536         int err;
1537
1538         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN);
1539
1540         if (!IS_ACCEPTING_CMD(ar))
1541                 return -EAGAIN;
1542
1543         count = ARRAY_SIZE(ar->rng.cache);
1544         while (count) {
1545                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1546                                         RB, (u8 *) rng_load,
1547                                         RB, (u8 *) buf);
1548                 if (err)
1549                         return err;
1550
1551                 transfer = min_t(unsigned int, count, RW);
1552                 for (i = 0; i < transfer; i++)
1553                         ar->rng.cache[off + i] = buf[i];
1554
1555                 off += transfer;
1556                 count -= transfer;
1557         }
1558
1559         ar->rng.cache_idx = 0;
1560
1561 #undef RW
1562 #undef RB
1563         return 0;
1564 }
1565
1566 static int carl9170_rng_read(struct hwrng *rng, u32 *data)
1567 {
1568         struct ar9170 *ar = (struct ar9170 *)rng->priv;
1569         int ret = -EIO;
1570
1571         mutex_lock(&ar->mutex);
1572         if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) {
1573                 ret = carl9170_rng_get(ar);
1574                 if (ret) {
1575                         mutex_unlock(&ar->mutex);
1576                         return ret;
1577                 }
1578         }
1579
1580         *data = ar->rng.cache[ar->rng.cache_idx++];
1581         mutex_unlock(&ar->mutex);
1582
1583         return sizeof(u16);
1584 }
1585
1586 static int carl9170_register_hwrng(struct ar9170 *ar)
1587 {
1588         int err;
1589
1590         snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name),
1591                  "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy));
1592         ar->rng.rng.name = ar->rng.name;
1593         ar->rng.rng.data_read = carl9170_rng_read;
1594         ar->rng.rng.priv = (unsigned long)ar;
1595
1596         err = devm_hwrng_register(&ar->udev->dev, &ar->rng.rng);
1597         if (err) {
1598                 dev_err(&ar->udev->dev, "Failed to register the random "
1599                         "number generator (%d)\n", err);
1600                 return err;
1601         }
1602
1603         return carl9170_rng_get(ar);
1604 }
1605 #endif /* CONFIG_CARL9170_HWRNG */
1606
1607 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1608                                 struct survey_info *survey)
1609 {
1610         struct ar9170 *ar = hw->priv;
1611         struct ieee80211_channel *chan;
1612         struct ieee80211_supported_band *band;
1613         int err, b, i;
1614
1615         chan = ar->channel;
1616         if (!chan)
1617                 return -ENODEV;
1618
1619         if (idx == chan->hw_value) {
1620                 mutex_lock(&ar->mutex);
1621                 err = carl9170_update_survey(ar, false, true);
1622                 mutex_unlock(&ar->mutex);
1623                 if (err)
1624                         return err;
1625         }
1626
1627         for (b = 0; b < NUM_NL80211_BANDS; b++) {
1628                 band = ar->hw->wiphy->bands[b];
1629
1630                 if (!band)
1631                         continue;
1632
1633                 for (i = 0; i < band->n_channels; i++) {
1634                         if (band->channels[i].hw_value == idx) {
1635                                 chan = &band->channels[i];
1636                                 goto found;
1637                         }
1638                 }
1639         }
1640         return -ENOENT;
1641
1642 found:
1643         memcpy(survey, &ar->survey[idx], sizeof(*survey));
1644
1645         survey->channel = chan;
1646         survey->filled = SURVEY_INFO_NOISE_DBM;
1647
1648         if (ar->channel == chan)
1649                 survey->filled |= SURVEY_INFO_IN_USE;
1650
1651         if (ar->fw.hw_counters) {
1652                 survey->filled |= SURVEY_INFO_TIME |
1653                                   SURVEY_INFO_TIME_BUSY |
1654                                   SURVEY_INFO_TIME_TX;
1655         }
1656
1657         return 0;
1658 }
1659
1660 static void carl9170_op_flush(struct ieee80211_hw *hw,
1661                               struct ieee80211_vif *vif,
1662                               u32 queues, bool drop)
1663 {
1664         struct ar9170 *ar = hw->priv;
1665         unsigned int vid;
1666
1667         mutex_lock(&ar->mutex);
1668         for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1669                 carl9170_flush_cab(ar, vid);
1670
1671         carl9170_flush(ar, drop);
1672         mutex_unlock(&ar->mutex);
1673 }
1674
1675 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1676                                  struct ieee80211_low_level_stats *stats)
1677 {
1678         struct ar9170 *ar = hw->priv;
1679
1680         memset(stats, 0, sizeof(*stats));
1681         stats->dot11ACKFailureCount = ar->tx_ack_failures;
1682         stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1683         return 0;
1684 }
1685
1686 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1687                                    struct ieee80211_vif *vif,
1688                                    enum sta_notify_cmd cmd,
1689                                    struct ieee80211_sta *sta)
1690 {
1691         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1692
1693         switch (cmd) {
1694         case STA_NOTIFY_SLEEP:
1695                 sta_info->sleeping = true;
1696                 if (atomic_read(&sta_info->pending_frames))
1697                         ieee80211_sta_block_awake(hw, sta, true);
1698                 break;
1699
1700         case STA_NOTIFY_AWAKE:
1701                 sta_info->sleeping = false;
1702                 break;
1703         }
1704 }
1705
1706 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1707 {
1708         struct ar9170 *ar = hw->priv;
1709
1710         return !!atomic_read(&ar->tx_total_queued);
1711 }
1712
1713 static const struct ieee80211_ops carl9170_ops = {
1714         .start                  = carl9170_op_start,
1715         .stop                   = carl9170_op_stop,
1716         .tx                     = carl9170_op_tx,
1717         .flush                  = carl9170_op_flush,
1718         .add_interface          = carl9170_op_add_interface,
1719         .remove_interface       = carl9170_op_remove_interface,
1720         .config                 = carl9170_op_config,
1721         .prepare_multicast      = carl9170_op_prepare_multicast,
1722         .configure_filter       = carl9170_op_configure_filter,
1723         .conf_tx                = carl9170_op_conf_tx,
1724         .bss_info_changed       = carl9170_op_bss_info_changed,
1725         .get_tsf                = carl9170_op_get_tsf,
1726         .set_key                = carl9170_op_set_key,
1727         .sta_add                = carl9170_op_sta_add,
1728         .sta_remove             = carl9170_op_sta_remove,
1729         .sta_notify             = carl9170_op_sta_notify,
1730         .get_survey             = carl9170_op_get_survey,
1731         .get_stats              = carl9170_op_get_stats,
1732         .ampdu_action           = carl9170_op_ampdu_action,
1733         .tx_frames_pending      = carl9170_tx_frames_pending,
1734 };
1735
1736 void *carl9170_alloc(size_t priv_size)
1737 {
1738         struct ieee80211_hw *hw;
1739         struct ar9170 *ar;
1740         struct sk_buff *skb;
1741         int i;
1742
1743         /*
1744          * this buffer is used for rx stream reconstruction.
1745          * Under heavy load this device (or the transport layer?)
1746          * tends to split the streams into separate rx descriptors.
1747          */
1748
1749         skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1750         if (!skb)
1751                 goto err_nomem;
1752
1753         hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1754         if (!hw)
1755                 goto err_nomem;
1756
1757         ar = hw->priv;
1758         ar->hw = hw;
1759         ar->rx_failover = skb;
1760
1761         memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1762         ar->rx_has_plcp = false;
1763
1764         /*
1765          * Here's a hidden pitfall!
1766          *
1767          * All 4 AC queues work perfectly well under _legacy_ operation.
1768          * However as soon as aggregation is enabled, the traffic flow
1769          * gets very bumpy. Therefore we have to _switch_ to a
1770          * software AC with a single HW queue.
1771          */
1772         hw->queues = __AR9170_NUM_TXQ;
1773
1774         mutex_init(&ar->mutex);
1775         spin_lock_init(&ar->beacon_lock);
1776         spin_lock_init(&ar->cmd_lock);
1777         spin_lock_init(&ar->tx_stats_lock);
1778         spin_lock_init(&ar->tx_ampdu_list_lock);
1779         spin_lock_init(&ar->mem_lock);
1780         spin_lock_init(&ar->state_lock);
1781         atomic_set(&ar->pending_restarts, 0);
1782         ar->vifs = 0;
1783         for (i = 0; i < ar->hw->queues; i++) {
1784                 skb_queue_head_init(&ar->tx_status[i]);
1785                 skb_queue_head_init(&ar->tx_pending[i]);
1786
1787                 INIT_LIST_HEAD(&ar->bar_list[i]);
1788                 spin_lock_init(&ar->bar_list_lock[i]);
1789         }
1790         INIT_WORK(&ar->ps_work, carl9170_ps_work);
1791         INIT_WORK(&ar->ping_work, carl9170_ping_work);
1792         INIT_WORK(&ar->restart_work, carl9170_restart_work);
1793         INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1794         INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1795         INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1796         INIT_LIST_HEAD(&ar->tx_ampdu_list);
1797         rcu_assign_pointer(ar->tx_ampdu_iter,
1798                            (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1799
1800         bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1801         INIT_LIST_HEAD(&ar->vif_list);
1802         init_completion(&ar->tx_flush);
1803
1804         /* firmware decides which modes we support */
1805         hw->wiphy->interface_modes = 0;
1806
1807         ieee80211_hw_set(hw, RX_INCLUDES_FCS);
1808         ieee80211_hw_set(hw, MFP_CAPABLE);
1809         ieee80211_hw_set(hw, REPORTS_TX_ACK_STATUS);
1810         ieee80211_hw_set(hw, SUPPORTS_PS);
1811         ieee80211_hw_set(hw, PS_NULLFUNC_STACK);
1812         ieee80211_hw_set(hw, NEED_DTIM_BEFORE_ASSOC);
1813         ieee80211_hw_set(hw, SUPPORTS_RC_TABLE);
1814         ieee80211_hw_set(hw, SIGNAL_DBM);
1815         ieee80211_hw_set(hw, SUPPORTS_HT_CCK_RATES);
1816
1817         if (!modparam_noht) {
1818                 /*
1819                  * see the comment above, why we allow the user
1820                  * to disable HT by a module parameter.
1821                  */
1822                 ieee80211_hw_set(hw, AMPDU_AGGREGATION);
1823         }
1824
1825         hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1826         hw->sta_data_size = sizeof(struct carl9170_sta_info);
1827         hw->vif_data_size = sizeof(struct carl9170_vif_info);
1828
1829         hw->max_rates = CARL9170_TX_MAX_RATES;
1830         hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1831
1832         for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1833                 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1834
1835         wiphy_ext_feature_set(hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
1836
1837         return ar;
1838
1839 err_nomem:
1840         kfree_skb(skb);
1841         return ERR_PTR(-ENOMEM);
1842 }
1843
1844 static int carl9170_read_eeprom(struct ar9170 *ar)
1845 {
1846 #define RW      8       /* number of words to read at once */
1847 #define RB      (sizeof(u32) * RW)
1848         u8 *eeprom = (void *)&ar->eeprom;
1849         __le32 offsets[RW];
1850         int i, j, err;
1851
1852         BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1853
1854         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1855 #ifndef __CHECKER__
1856         /* don't want to handle trailing remains */
1857         BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1858 #endif
1859
1860         for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1861                 for (j = 0; j < RW; j++)
1862                         offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1863                                                  RB * i + 4 * j);
1864
1865                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1866                                         RB, (u8 *) &offsets,
1867                                         RB, eeprom + RB * i);
1868                 if (err)
1869                         return err;
1870         }
1871
1872 #undef RW
1873 #undef RB
1874         return 0;
1875 }
1876
1877 static int carl9170_parse_eeprom(struct ar9170 *ar)
1878 {
1879         struct ath_regulatory *regulatory = &ar->common.regulatory;
1880         unsigned int rx_streams, tx_streams, tx_params = 0;
1881         int bands = 0;
1882         int chans = 0;
1883
1884         if (ar->eeprom.length == cpu_to_le16(0xffff))
1885                 return -ENODATA;
1886
1887         rx_streams = hweight8(ar->eeprom.rx_mask);
1888         tx_streams = hweight8(ar->eeprom.tx_mask);
1889
1890         if (rx_streams != tx_streams) {
1891                 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1892
1893                 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1894                         IEEE80211_HT_MCS_TX_MAX_STREAMS));
1895
1896                 tx_params |= (tx_streams - 1) <<
1897                             IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1898
1899                 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1900                 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1901         }
1902
1903         if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1904                 ar->hw->wiphy->bands[NL80211_BAND_2GHZ] =
1905                         &carl9170_band_2GHz;
1906                 chans += carl9170_band_2GHz.n_channels;
1907                 bands++;
1908         }
1909         if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1910                 ar->hw->wiphy->bands[NL80211_BAND_5GHZ] =
1911                         &carl9170_band_5GHz;
1912                 chans += carl9170_band_5GHz.n_channels;
1913                 bands++;
1914         }
1915
1916         if (!bands)
1917                 return -EINVAL;
1918
1919         ar->survey = devm_kcalloc(&ar->udev->dev, chans,
1920                                   sizeof(struct survey_info), GFP_KERNEL);
1921         if (!ar->survey)
1922                 return -ENOMEM;
1923         ar->num_channels = chans;
1924
1925         regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1926
1927         /* second part of wiphy init */
1928         SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1929
1930         return 0;
1931 }
1932
1933 static void carl9170_reg_notifier(struct wiphy *wiphy,
1934                                   struct regulatory_request *request)
1935 {
1936         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1937         struct ar9170 *ar = hw->priv;
1938
1939         ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1940 }
1941
1942 int carl9170_register(struct ar9170 *ar)
1943 {
1944         struct ath_regulatory *regulatory = &ar->common.regulatory;
1945         int err = 0, i;
1946
1947         ar->mem_bitmap = devm_bitmap_zalloc(&ar->udev->dev, ar->fw.mem_blocks, GFP_KERNEL);
1948         if (!ar->mem_bitmap)
1949                 return -ENOMEM;
1950
1951         /* try to read EEPROM, init MAC addr */
1952         err = carl9170_read_eeprom(ar);
1953         if (err)
1954                 return err;
1955
1956         err = carl9170_parse_eeprom(ar);
1957         if (err)
1958                 return err;
1959
1960         err = ath_regd_init(regulatory, ar->hw->wiphy,
1961                             carl9170_reg_notifier);
1962         if (err)
1963                 return err;
1964
1965         if (modparam_noht) {
1966                 carl9170_band_2GHz.ht_cap.ht_supported = false;
1967                 carl9170_band_5GHz.ht_cap.ht_supported = false;
1968         }
1969
1970         for (i = 0; i < ar->fw.vif_num; i++) {
1971                 ar->vif_priv[i].id = i;
1972                 ar->vif_priv[i].vif = NULL;
1973         }
1974
1975         err = ieee80211_register_hw(ar->hw);
1976         if (err)
1977                 return err;
1978
1979         /* mac80211 interface is now registered */
1980         ar->registered = true;
1981
1982         if (!ath_is_world_regd(regulatory))
1983                 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1984
1985 #ifdef CONFIG_CARL9170_DEBUGFS
1986         carl9170_debugfs_register(ar);
1987 #endif /* CONFIG_CARL9170_DEBUGFS */
1988
1989         err = carl9170_led_init(ar);
1990         if (err)
1991                 goto err_unreg;
1992
1993 #ifdef CONFIG_CARL9170_LEDS
1994         err = carl9170_led_register(ar);
1995         if (err)
1996                 goto err_unreg;
1997 #endif /* CONFIG_CARL9170_LEDS */
1998
1999 #ifdef CONFIG_CARL9170_WPC
2000         err = carl9170_register_wps_button(ar);
2001         if (err)
2002                 goto err_unreg;
2003 #endif /* CONFIG_CARL9170_WPC */
2004
2005 #ifdef CONFIG_CARL9170_HWRNG
2006         err = carl9170_register_hwrng(ar);
2007         if (err)
2008                 goto err_unreg;
2009 #endif /* CONFIG_CARL9170_HWRNG */
2010
2011         dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
2012                  wiphy_name(ar->hw->wiphy));
2013
2014         return 0;
2015
2016 err_unreg:
2017         carl9170_unregister(ar);
2018         return err;
2019 }
2020
2021 void carl9170_unregister(struct ar9170 *ar)
2022 {
2023         if (!ar->registered)
2024                 return;
2025
2026         ar->registered = false;
2027
2028 #ifdef CONFIG_CARL9170_LEDS
2029         carl9170_led_unregister(ar);
2030 #endif /* CONFIG_CARL9170_LEDS */
2031
2032 #ifdef CONFIG_CARL9170_DEBUGFS
2033         carl9170_debugfs_unregister(ar);
2034 #endif /* CONFIG_CARL9170_DEBUGFS */
2035
2036         carl9170_cancel_worker(ar);
2037         cancel_work_sync(&ar->restart_work);
2038
2039         ieee80211_unregister_hw(ar->hw);
2040 }
2041
2042 void carl9170_free(struct ar9170 *ar)
2043 {
2044         WARN_ON(ar->registered);
2045         WARN_ON(IS_INITIALIZED(ar));
2046
2047         kfree_skb(ar->rx_failover);
2048         ar->rx_failover = NULL;
2049
2050         mutex_destroy(&ar->mutex);
2051
2052         ieee80211_free_hw(ar->hw);
2053 }