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