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 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1472                                 struct survey_info *survey)
1473 {
1474         struct ar9170 *ar = hw->priv;
1475         struct ieee80211_channel *chan;
1476         struct ieee80211_supported_band *band;
1477         int err, b, i;
1478
1479         chan = ar->channel;
1480         if (!chan)
1481                 return -ENODEV;
1482
1483         if (idx == chan->hw_value) {
1484                 mutex_lock(&ar->mutex);
1485                 err = carl9170_update_survey(ar, false, true);
1486                 mutex_unlock(&ar->mutex);
1487                 if (err)
1488                         return err;
1489         }
1490
1491         for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
1492                 band = ar->hw->wiphy->bands[b];
1493
1494                 if (!band)
1495                         continue;
1496
1497                 for (i = 0; i < band->n_channels; i++) {
1498                         if (band->channels[i].hw_value == idx) {
1499                                 chan = &band->channels[i];
1500                                 goto found;
1501                         }
1502                 }
1503         }
1504         return -ENOENT;
1505
1506 found:
1507         memcpy(survey, &ar->survey[idx], sizeof(*survey));
1508
1509         survey->channel = chan;
1510         survey->filled = SURVEY_INFO_NOISE_DBM;
1511
1512         if (ar->channel == chan)
1513                 survey->filled |= SURVEY_INFO_IN_USE;
1514
1515         if (ar->fw.hw_counters) {
1516                 survey->filled |= SURVEY_INFO_CHANNEL_TIME |
1517                                   SURVEY_INFO_CHANNEL_TIME_BUSY |
1518                                   SURVEY_INFO_CHANNEL_TIME_TX;
1519         }
1520
1521         return 0;
1522 }
1523
1524 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1525 {
1526         struct ar9170 *ar = hw->priv;
1527         unsigned int vid;
1528
1529         mutex_lock(&ar->mutex);
1530         for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1531                 carl9170_flush_cab(ar, vid);
1532
1533         carl9170_flush(ar, drop);
1534         mutex_unlock(&ar->mutex);
1535 }
1536
1537 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1538                                  struct ieee80211_low_level_stats *stats)
1539 {
1540         struct ar9170 *ar = hw->priv;
1541
1542         memset(stats, 0, sizeof(*stats));
1543         stats->dot11ACKFailureCount = ar->tx_ack_failures;
1544         stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1545         return 0;
1546 }
1547
1548 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1549                                    struct ieee80211_vif *vif,
1550                                    enum sta_notify_cmd cmd,
1551                                    struct ieee80211_sta *sta)
1552 {
1553         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1554
1555         switch (cmd) {
1556         case STA_NOTIFY_SLEEP:
1557                 sta_info->sleeping = true;
1558                 if (atomic_read(&sta_info->pending_frames))
1559                         ieee80211_sta_block_awake(hw, sta, true);
1560                 break;
1561
1562         case STA_NOTIFY_AWAKE:
1563                 sta_info->sleeping = false;
1564                 break;
1565         }
1566 }
1567
1568 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1569 {
1570         struct ar9170 *ar = hw->priv;
1571
1572         return !!atomic_read(&ar->tx_total_queued);
1573 }
1574
1575 static const struct ieee80211_ops carl9170_ops = {
1576         .start                  = carl9170_op_start,
1577         .stop                   = carl9170_op_stop,
1578         .tx                     = carl9170_op_tx,
1579         .flush                  = carl9170_op_flush,
1580         .add_interface          = carl9170_op_add_interface,
1581         .remove_interface       = carl9170_op_remove_interface,
1582         .config                 = carl9170_op_config,
1583         .prepare_multicast      = carl9170_op_prepare_multicast,
1584         .configure_filter       = carl9170_op_configure_filter,
1585         .conf_tx                = carl9170_op_conf_tx,
1586         .bss_info_changed       = carl9170_op_bss_info_changed,
1587         .get_tsf                = carl9170_op_get_tsf,
1588         .set_key                = carl9170_op_set_key,
1589         .sta_add                = carl9170_op_sta_add,
1590         .sta_remove             = carl9170_op_sta_remove,
1591         .sta_notify             = carl9170_op_sta_notify,
1592         .get_survey             = carl9170_op_get_survey,
1593         .get_stats              = carl9170_op_get_stats,
1594         .ampdu_action           = carl9170_op_ampdu_action,
1595         .tx_frames_pending      = carl9170_tx_frames_pending,
1596 };
1597
1598 void *carl9170_alloc(size_t priv_size)
1599 {
1600         struct ieee80211_hw *hw;
1601         struct ar9170 *ar;
1602         struct sk_buff *skb;
1603         int i;
1604
1605         /*
1606          * this buffer is used for rx stream reconstruction.
1607          * Under heavy load this device (or the transport layer?)
1608          * tends to split the streams into separate rx descriptors.
1609          */
1610
1611         skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1612         if (!skb)
1613                 goto err_nomem;
1614
1615         hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1616         if (!hw)
1617                 goto err_nomem;
1618
1619         ar = hw->priv;
1620         ar->hw = hw;
1621         ar->rx_failover = skb;
1622
1623         memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1624         ar->rx_has_plcp = false;
1625
1626         /*
1627          * Here's a hidden pitfall!
1628          *
1629          * All 4 AC queues work perfectly well under _legacy_ operation.
1630          * However as soon as aggregation is enabled, the traffic flow
1631          * gets very bumpy. Therefore we have to _switch_ to a
1632          * software AC with a single HW queue.
1633          */
1634         hw->queues = __AR9170_NUM_TXQ;
1635
1636         mutex_init(&ar->mutex);
1637         spin_lock_init(&ar->beacon_lock);
1638         spin_lock_init(&ar->cmd_lock);
1639         spin_lock_init(&ar->tx_stats_lock);
1640         spin_lock_init(&ar->tx_ampdu_list_lock);
1641         spin_lock_init(&ar->mem_lock);
1642         spin_lock_init(&ar->state_lock);
1643         atomic_set(&ar->pending_restarts, 0);
1644         ar->vifs = 0;
1645         for (i = 0; i < ar->hw->queues; i++) {
1646                 skb_queue_head_init(&ar->tx_status[i]);
1647                 skb_queue_head_init(&ar->tx_pending[i]);
1648         }
1649         INIT_WORK(&ar->ps_work, carl9170_ps_work);
1650         INIT_WORK(&ar->ping_work, carl9170_ping_work);
1651         INIT_WORK(&ar->restart_work, carl9170_restart_work);
1652         INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1653         INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1654         INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1655         INIT_LIST_HEAD(&ar->tx_ampdu_list);
1656         rcu_assign_pointer(ar->tx_ampdu_iter,
1657                            (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1658
1659         bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1660         INIT_LIST_HEAD(&ar->vif_list);
1661         init_completion(&ar->tx_flush);
1662
1663         /* firmware decides which modes we support */
1664         hw->wiphy->interface_modes = 0;
1665
1666         hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1667                      IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1668                      IEEE80211_HW_SUPPORTS_PS |
1669                      IEEE80211_HW_PS_NULLFUNC_STACK |
1670                      IEEE80211_HW_NEED_DTIM_PERIOD |
1671                      IEEE80211_HW_SIGNAL_DBM;
1672
1673         if (!modparam_noht) {
1674                 /*
1675                  * see the comment above, why we allow the user
1676                  * to disable HT by a module parameter.
1677                  */
1678                 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1679         }
1680
1681         hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1682         hw->sta_data_size = sizeof(struct carl9170_sta_info);
1683         hw->vif_data_size = sizeof(struct carl9170_vif_info);
1684
1685         hw->max_rates = CARL9170_TX_MAX_RATES;
1686         hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1687
1688         for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1689                 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1690
1691         hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1692         return ar;
1693
1694 err_nomem:
1695         kfree_skb(skb);
1696         return ERR_PTR(-ENOMEM);
1697 }
1698
1699 static int carl9170_read_eeprom(struct ar9170 *ar)
1700 {
1701 #define RW      8       /* number of words to read at once */
1702 #define RB      (sizeof(u32) * RW)
1703         u8 *eeprom = (void *)&ar->eeprom;
1704         __le32 offsets[RW];
1705         int i, j, err;
1706
1707         BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1708
1709         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1710 #ifndef __CHECKER__
1711         /* don't want to handle trailing remains */
1712         BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1713 #endif
1714
1715         for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1716                 for (j = 0; j < RW; j++)
1717                         offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1718                                                  RB * i + 4 * j);
1719
1720                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1721                                         RB, (u8 *) &offsets,
1722                                         RB, eeprom + RB * i);
1723                 if (err)
1724                         return err;
1725         }
1726
1727 #undef RW
1728 #undef RB
1729         return 0;
1730 }
1731
1732 static int carl9170_parse_eeprom(struct ar9170 *ar)
1733 {
1734         struct ath_regulatory *regulatory = &ar->common.regulatory;
1735         unsigned int rx_streams, tx_streams, tx_params = 0;
1736         int bands = 0;
1737         int chans = 0;
1738
1739         if (ar->eeprom.length == cpu_to_le16(0xffff))
1740                 return -ENODATA;
1741
1742         rx_streams = hweight8(ar->eeprom.rx_mask);
1743         tx_streams = hweight8(ar->eeprom.tx_mask);
1744
1745         if (rx_streams != tx_streams) {
1746                 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1747
1748                 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1749                         IEEE80211_HT_MCS_TX_MAX_STREAMS));
1750
1751                 tx_params = (tx_streams - 1) <<
1752                             IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1753
1754                 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1755                 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1756         }
1757
1758         if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1759                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1760                         &carl9170_band_2GHz;
1761                 chans += carl9170_band_2GHz.n_channels;
1762                 bands++;
1763         }
1764         if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1765                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1766                         &carl9170_band_5GHz;
1767                 chans += carl9170_band_5GHz.n_channels;
1768                 bands++;
1769         }
1770
1771         if (!bands)
1772                 return -EINVAL;
1773
1774         ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL);
1775         if (!ar->survey)
1776                 return -ENOMEM;
1777         ar->num_channels = chans;
1778
1779         /*
1780          * I measured this, a bandswitch takes roughly
1781          * 135 ms and a frequency switch about 80.
1782          *
1783          * FIXME: measure these values again once EEPROM settings
1784          *        are used, that will influence them!
1785          */
1786         if (bands == 2)
1787                 ar->hw->channel_change_time = 135 * 1000;
1788         else
1789                 ar->hw->channel_change_time = 80 * 1000;
1790
1791         regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1792         regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]);
1793
1794         /* second part of wiphy init */
1795         SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1796
1797         return 0;
1798 }
1799
1800 static int carl9170_reg_notifier(struct wiphy *wiphy,
1801                                  struct regulatory_request *request)
1802 {
1803         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1804         struct ar9170 *ar = hw->priv;
1805
1806         return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1807 }
1808
1809 int carl9170_register(struct ar9170 *ar)
1810 {
1811         struct ath_regulatory *regulatory = &ar->common.regulatory;
1812         int err = 0, i;
1813
1814         if (WARN_ON(ar->mem_bitmap))
1815                 return -EINVAL;
1816
1817         ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
1818                                  sizeof(unsigned long), GFP_KERNEL);
1819
1820         if (!ar->mem_bitmap)
1821                 return -ENOMEM;
1822
1823         /* try to read EEPROM, init MAC addr */
1824         err = carl9170_read_eeprom(ar);
1825         if (err)
1826                 return err;
1827
1828         err = carl9170_fw_fix_eeprom(ar);
1829         if (err)
1830                 return err;
1831
1832         err = carl9170_parse_eeprom(ar);
1833         if (err)
1834                 return err;
1835
1836         err = ath_regd_init(regulatory, ar->hw->wiphy,
1837                             carl9170_reg_notifier);
1838         if (err)
1839                 return err;
1840
1841         if (modparam_noht) {
1842                 carl9170_band_2GHz.ht_cap.ht_supported = false;
1843                 carl9170_band_5GHz.ht_cap.ht_supported = false;
1844         }
1845
1846         for (i = 0; i < ar->fw.vif_num; i++) {
1847                 ar->vif_priv[i].id = i;
1848                 ar->vif_priv[i].vif = NULL;
1849         }
1850
1851         err = ieee80211_register_hw(ar->hw);
1852         if (err)
1853                 return err;
1854
1855         /* mac80211 interface is now registered */
1856         ar->registered = true;
1857
1858         if (!ath_is_world_regd(regulatory))
1859                 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1860
1861 #ifdef CONFIG_CARL9170_DEBUGFS
1862         carl9170_debugfs_register(ar);
1863 #endif /* CONFIG_CARL9170_DEBUGFS */
1864
1865         err = carl9170_led_init(ar);
1866         if (err)
1867                 goto err_unreg;
1868
1869 #ifdef CONFIG_CARL9170_LEDS
1870         err = carl9170_led_register(ar);
1871         if (err)
1872                 goto err_unreg;
1873 #endif /* CONFIG_CARL9170_LEDS */
1874
1875 #ifdef CONFIG_CARL9170_WPC
1876         err = carl9170_register_wps_button(ar);
1877         if (err)
1878                 goto err_unreg;
1879 #endif /* CONFIG_CARL9170_WPC */
1880
1881         dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
1882                  wiphy_name(ar->hw->wiphy));
1883
1884         return 0;
1885
1886 err_unreg:
1887         carl9170_unregister(ar);
1888         return err;
1889 }
1890
1891 void carl9170_unregister(struct ar9170 *ar)
1892 {
1893         if (!ar->registered)
1894                 return;
1895
1896         ar->registered = false;
1897
1898 #ifdef CONFIG_CARL9170_LEDS
1899         carl9170_led_unregister(ar);
1900 #endif /* CONFIG_CARL9170_LEDS */
1901
1902 #ifdef CONFIG_CARL9170_DEBUGFS
1903         carl9170_debugfs_unregister(ar);
1904 #endif /* CONFIG_CARL9170_DEBUGFS */
1905
1906 #ifdef CONFIG_CARL9170_WPC
1907         if (ar->wps.pbc) {
1908                 input_unregister_device(ar->wps.pbc);
1909                 ar->wps.pbc = NULL;
1910         }
1911 #endif /* CONFIG_CARL9170_WPC */
1912
1913         carl9170_cancel_worker(ar);
1914         cancel_work_sync(&ar->restart_work);
1915
1916         ieee80211_unregister_hw(ar->hw);
1917 }
1918
1919 void carl9170_free(struct ar9170 *ar)
1920 {
1921         WARN_ON(ar->registered);
1922         WARN_ON(IS_INITIALIZED(ar));
1923
1924         kfree_skb(ar->rx_failover);
1925         ar->rx_failover = NULL;
1926
1927         kfree(ar->mem_bitmap);
1928         ar->mem_bitmap = NULL;
1929
1930         kfree(ar->survey);
1931         ar->survey = NULL;
1932
1933         mutex_destroy(&ar->mutex);
1934
1935         ieee80211_free_hw(ar->hw);
1936 }