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