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