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

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