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                 mutex_lock(&ar->mutex);
1120                 goto err_softw;
1121         }
1122
1123         /*
1124          * While the hardware supports *catch-all* key, for offloading
1125          * group-key en-/de-cryption. The way of how the hardware
1126          * decides which keyId maps to which key, remains a mystery...
1127          */
1128         if ((vif->type != NL80211_IFTYPE_STATION &&
1129              vif->type != NL80211_IFTYPE_ADHOC) &&
1130             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1131                 return -EOPNOTSUPP;
1132
1133         switch (key->cipher) {
1134         case WLAN_CIPHER_SUITE_WEP40:
1135                 ktype = AR9170_ENC_ALG_WEP64;
1136                 break;
1137         case WLAN_CIPHER_SUITE_WEP104:
1138                 ktype = AR9170_ENC_ALG_WEP128;
1139                 break;
1140         case WLAN_CIPHER_SUITE_TKIP:
1141                 ktype = AR9170_ENC_ALG_TKIP;
1142                 break;
1143         case WLAN_CIPHER_SUITE_CCMP:
1144                 ktype = AR9170_ENC_ALG_AESCCMP;
1145                 break;
1146         default:
1147                 return -EOPNOTSUPP;
1148         }
1149
1150         mutex_lock(&ar->mutex);
1151         if (cmd == SET_KEY) {
1152                 if (!IS_STARTED(ar)) {
1153                         err = -EOPNOTSUPP;
1154                         goto out;
1155                 }
1156
1157                 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1158                         sta = NULL;
1159
1160                         i = 64 + key->keyidx;
1161                 } else {
1162                         for (i = 0; i < 64; i++)
1163                                 if (!(ar->usedkeys & BIT(i)))
1164                                         break;
1165                         if (i == 64)
1166                                 goto err_softw;
1167                 }
1168
1169                 key->hw_key_idx = i;
1170
1171                 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1172                                           ktype, 0, key->key,
1173                                           min_t(u8, 16, key->keylen));
1174                 if (err)
1175                         goto out;
1176
1177                 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1178                         err = carl9170_upload_key(ar, i, sta ? sta->addr :
1179                                                   NULL, ktype, 1,
1180                                                   key->key + 16, 16);
1181                         if (err)
1182                                 goto out;
1183
1184                         /*
1185                          * hardware is not capable generating MMIC
1186                          * of fragmented frames!
1187                          */
1188                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1189                 }
1190
1191                 if (i < 64)
1192                         ar->usedkeys |= BIT(i);
1193
1194                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1195         } else {
1196                 if (!IS_STARTED(ar)) {
1197                         /* The device is gone... together with the key ;-) */
1198                         err = 0;
1199                         goto out;
1200                 }
1201
1202                 if (key->hw_key_idx < 64) {
1203                         ar->usedkeys &= ~BIT(key->hw_key_idx);
1204                 } else {
1205                         err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1206                                                   AR9170_ENC_ALG_NONE, 0,
1207                                                   NULL, 0);
1208                         if (err)
1209                                 goto out;
1210
1211                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1212                                 err = carl9170_upload_key(ar, key->hw_key_idx,
1213                                                           NULL,
1214                                                           AR9170_ENC_ALG_NONE,
1215                                                           1, NULL, 0);
1216                                 if (err)
1217                                         goto out;
1218                         }
1219
1220                 }
1221
1222                 err = carl9170_disable_key(ar, key->hw_key_idx);
1223                 if (err)
1224                         goto out;
1225         }
1226
1227 out:
1228         mutex_unlock(&ar->mutex);
1229         return err;
1230
1231 err_softw:
1232         if (!ar->rx_software_decryption) {
1233                 ar->rx_software_decryption = true;
1234                 carl9170_set_operating_mode(ar);
1235         }
1236         mutex_unlock(&ar->mutex);
1237         return -ENOSPC;
1238 }
1239
1240 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1241                                struct ieee80211_vif *vif,
1242                                struct ieee80211_sta *sta)
1243 {
1244         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1245         unsigned int i;
1246
1247         atomic_set(&sta_info->pending_frames, 0);
1248
1249         if (sta->ht_cap.ht_supported) {
1250                 if (sta->ht_cap.ampdu_density > 6) {
1251                         /*
1252                          * HW does support 16us AMPDU density.
1253                          * No HT-Xmit for station.
1254                          */
1255
1256                         return 0;
1257                 }
1258
1259                 for (i = 0; i < CARL9170_NUM_TID; i++)
1260                         rcu_assign_pointer(sta_info->agg[i], NULL);
1261
1262                 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor);
1263                 sta_info->ht_sta = true;
1264         }
1265
1266         return 0;
1267 }
1268
1269 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1270                                 struct ieee80211_vif *vif,
1271                                 struct ieee80211_sta *sta)
1272 {
1273         struct ar9170 *ar = hw->priv;
1274         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1275         unsigned int i;
1276         bool cleanup = false;
1277
1278         if (sta->ht_cap.ht_supported) {
1279
1280                 sta_info->ht_sta = false;
1281
1282                 rcu_read_lock();
1283                 for (i = 0; i < CARL9170_NUM_TID; i++) {
1284                         struct carl9170_sta_tid *tid_info;
1285
1286                         tid_info = rcu_dereference(sta_info->agg[i]);
1287                         rcu_assign_pointer(sta_info->agg[i], NULL);
1288
1289                         if (!tid_info)
1290                                 continue;
1291
1292                         spin_lock_bh(&ar->tx_ampdu_list_lock);
1293                         if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1294                                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1295                         spin_unlock_bh(&ar->tx_ampdu_list_lock);
1296                         cleanup = true;
1297                 }
1298                 rcu_read_unlock();
1299
1300                 if (cleanup)
1301                         carl9170_ampdu_gc(ar);
1302         }
1303
1304         return 0;
1305 }
1306
1307 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1308                                const struct ieee80211_tx_queue_params *param)
1309 {
1310         struct ar9170 *ar = hw->priv;
1311         int ret;
1312
1313         mutex_lock(&ar->mutex);
1314         if (queue < ar->hw->queues) {
1315                 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param));
1316                 ret = carl9170_set_qos(ar);
1317         } else {
1318                 ret = -EINVAL;
1319         }
1320
1321         mutex_unlock(&ar->mutex);
1322         return ret;
1323 }
1324
1325 static void carl9170_ampdu_work(struct work_struct *work)
1326 {
1327         struct ar9170 *ar = container_of(work, struct ar9170,
1328                                          ampdu_work);
1329
1330         if (!IS_STARTED(ar))
1331                 return;
1332
1333         mutex_lock(&ar->mutex);
1334         carl9170_ampdu_gc(ar);
1335         mutex_unlock(&ar->mutex);
1336 }
1337
1338 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1339                                     struct ieee80211_vif *vif,
1340                                     enum ieee80211_ampdu_mlme_action action,
1341                                     struct ieee80211_sta *sta,
1342                                     u16 tid, u16 *ssn, u8 buf_size)
1343 {
1344         struct ar9170 *ar = hw->priv;
1345         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1346         struct carl9170_sta_tid *tid_info;
1347
1348         if (modparam_noht)
1349                 return -EOPNOTSUPP;
1350
1351         switch (action) {
1352         case IEEE80211_AMPDU_TX_START:
1353                 if (!sta_info->ht_sta)
1354                         return -EOPNOTSUPP;
1355
1356                 rcu_read_lock();
1357                 if (rcu_dereference(sta_info->agg[tid])) {
1358                         rcu_read_unlock();
1359                         return -EBUSY;
1360                 }
1361
1362                 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1363                                    GFP_ATOMIC);
1364                 if (!tid_info) {
1365                         rcu_read_unlock();
1366                         return -ENOMEM;
1367                 }
1368
1369                 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1370                 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1371                 tid_info->tid = tid;
1372                 tid_info->max = sta_info->ampdu_max_len;
1373
1374                 INIT_LIST_HEAD(&tid_info->list);
1375                 INIT_LIST_HEAD(&tid_info->tmp_list);
1376                 skb_queue_head_init(&tid_info->queue);
1377                 spin_lock_init(&tid_info->lock);
1378
1379                 spin_lock_bh(&ar->tx_ampdu_list_lock);
1380                 ar->tx_ampdu_list_len++;
1381                 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1382                 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1383                 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1384                 rcu_read_unlock();
1385
1386                 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1387                 break;
1388
1389         case IEEE80211_AMPDU_TX_STOP:
1390                 rcu_read_lock();
1391                 tid_info = rcu_dereference(sta_info->agg[tid]);
1392                 if (tid_info) {
1393                         spin_lock_bh(&ar->tx_ampdu_list_lock);
1394                         if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1395                                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1396                         spin_unlock_bh(&ar->tx_ampdu_list_lock);
1397                 }
1398
1399                 rcu_assign_pointer(sta_info->agg[tid], NULL);
1400                 rcu_read_unlock();
1401
1402                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1403                 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1404                 break;
1405
1406         case IEEE80211_AMPDU_TX_OPERATIONAL:
1407                 rcu_read_lock();
1408                 tid_info = rcu_dereference(sta_info->agg[tid]);
1409
1410                 sta_info->stats[tid].clear = true;
1411                 sta_info->stats[tid].req = false;
1412
1413                 if (tid_info) {
1414                         bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1415                         tid_info->state = CARL9170_TID_STATE_IDLE;
1416                 }
1417                 rcu_read_unlock();
1418
1419                 if (WARN_ON_ONCE(!tid_info))
1420                         return -EFAULT;
1421
1422                 break;
1423
1424         case IEEE80211_AMPDU_RX_START:
1425         case IEEE80211_AMPDU_RX_STOP:
1426                 /* Handled by hardware */
1427                 break;
1428
1429         default:
1430                 return -EOPNOTSUPP;
1431         }
1432
1433         return 0;
1434 }
1435
1436 #ifdef CONFIG_CARL9170_WPC
1437 static int carl9170_register_wps_button(struct ar9170 *ar)
1438 {
1439         struct input_dev *input;
1440         int err;
1441
1442         if (!(ar->features & CARL9170_WPS_BUTTON))
1443                 return 0;
1444
1445         input = input_allocate_device();
1446         if (!input)
1447                 return -ENOMEM;
1448
1449         snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1450                  wiphy_name(ar->hw->wiphy));
1451
1452         snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1453                  "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1454
1455         input->name = ar->wps.name;
1456         input->phys = ar->wps.phys;
1457         input->id.bustype = BUS_USB;
1458         input->dev.parent = &ar->hw->wiphy->dev;
1459
1460         input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1461
1462         err = input_register_device(input);
1463         if (err) {
1464                 input_free_device(input);
1465                 return err;
1466         }
1467
1468         ar->wps.pbc = input;
1469         return 0;
1470 }
1471 #endif /* CONFIG_CARL9170_WPC */
1472
1473 #ifdef CONFIG_CARL9170_HWRNG
1474 static int carl9170_rng_get(struct ar9170 *ar)
1475 {
1476
1477 #define RW      (CARL9170_MAX_CMD_PAYLOAD_LEN / sizeof(u32))
1478 #define RB      (CARL9170_MAX_CMD_PAYLOAD_LEN)
1479
1480         static const __le32 rng_load[RW] = {
1481                 [0 ... (RW - 1)] = cpu_to_le32(AR9170_RAND_REG_NUM)};
1482
1483         u32 buf[RW];
1484
1485         unsigned int i, off = 0, transfer, count;
1486         int err;
1487
1488         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_PAYLOAD_LEN);
1489
1490         if (!IS_ACCEPTING_CMD(ar) || !ar->rng.initialized)
1491                 return -EAGAIN;
1492
1493         count = ARRAY_SIZE(ar->rng.cache);
1494         while (count) {
1495                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1496                                         RB, (u8 *) rng_load,
1497                                         RB, (u8 *) buf);
1498                 if (err)
1499                         return err;
1500
1501                 transfer = min_t(unsigned int, count, RW);
1502                 for (i = 0; i < transfer; i++)
1503                         ar->rng.cache[off + i] = buf[i];
1504
1505                 off += transfer;
1506                 count -= transfer;
1507         }
1508
1509         ar->rng.cache_idx = 0;
1510
1511 #undef RW
1512 #undef RB
1513         return 0;
1514 }
1515
1516 static int carl9170_rng_read(struct hwrng *rng, u32 *data)
1517 {
1518         struct ar9170 *ar = (struct ar9170 *)rng->priv;
1519         int ret = -EIO;
1520
1521         mutex_lock(&ar->mutex);
1522         if (ar->rng.cache_idx >= ARRAY_SIZE(ar->rng.cache)) {
1523                 ret = carl9170_rng_get(ar);
1524                 if (ret) {
1525                         mutex_unlock(&ar->mutex);
1526                         return ret;
1527                 }
1528         }
1529
1530         *data = ar->rng.cache[ar->rng.cache_idx++];
1531         mutex_unlock(&ar->mutex);
1532
1533         return sizeof(u16);
1534 }
1535
1536 static void carl9170_unregister_hwrng(struct ar9170 *ar)
1537 {
1538         if (ar->rng.initialized) {
1539                 hwrng_unregister(&ar->rng.rng);
1540                 ar->rng.initialized = false;
1541         }
1542 }
1543
1544 static int carl9170_register_hwrng(struct ar9170 *ar)
1545 {
1546         int err;
1547
1548         snprintf(ar->rng.name, ARRAY_SIZE(ar->rng.name),
1549                  "%s_%s", KBUILD_MODNAME, wiphy_name(ar->hw->wiphy));
1550         ar->rng.rng.name = ar->rng.name;
1551         ar->rng.rng.data_read = carl9170_rng_read;
1552         ar->rng.rng.priv = (unsigned long)ar;
1553
1554         if (WARN_ON(ar->rng.initialized))
1555                 return -EALREADY;
1556
1557         err = hwrng_register(&ar->rng.rng);
1558         if (err) {
1559                 dev_err(&ar->udev->dev, "Failed to register the random "
1560                         "number generator (%d)\n", err);
1561                 return err;
1562         }
1563
1564         ar->rng.initialized = true;
1565
1566         err = carl9170_rng_get(ar);
1567         if (err) {
1568                 carl9170_unregister_hwrng(ar);
1569                 return err;
1570         }
1571
1572         return 0;
1573 }
1574 #endif /* CONFIG_CARL9170_HWRNG */
1575
1576 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1577                                 struct survey_info *survey)
1578 {
1579         struct ar9170 *ar = hw->priv;
1580         struct ieee80211_channel *chan;
1581         struct ieee80211_supported_band *band;
1582         int err, b, i;
1583
1584         chan = ar->channel;
1585         if (!chan)
1586                 return -ENODEV;
1587
1588         if (idx == chan->hw_value) {
1589                 mutex_lock(&ar->mutex);
1590                 err = carl9170_update_survey(ar, false, true);
1591                 mutex_unlock(&ar->mutex);
1592                 if (err)
1593                         return err;
1594         }
1595
1596         for (b = 0; b < IEEE80211_NUM_BANDS; b++) {
1597                 band = ar->hw->wiphy->bands[b];
1598
1599                 if (!band)
1600                         continue;
1601
1602                 for (i = 0; i < band->n_channels; i++) {
1603                         if (band->channels[i].hw_value == idx) {
1604                                 chan = &band->channels[i];
1605                                 goto found;
1606                         }
1607                 }
1608         }
1609         return -ENOENT;
1610
1611 found:
1612         memcpy(survey, &ar->survey[idx], sizeof(*survey));
1613
1614         survey->channel = chan;
1615         survey->filled = SURVEY_INFO_NOISE_DBM;
1616
1617         if (ar->channel == chan)
1618                 survey->filled |= SURVEY_INFO_IN_USE;
1619
1620         if (ar->fw.hw_counters) {
1621                 survey->filled |= SURVEY_INFO_CHANNEL_TIME |
1622                                   SURVEY_INFO_CHANNEL_TIME_BUSY |
1623                                   SURVEY_INFO_CHANNEL_TIME_TX;
1624         }
1625
1626         return 0;
1627 }
1628
1629 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1630 {
1631         struct ar9170 *ar = hw->priv;
1632         unsigned int vid;
1633
1634         mutex_lock(&ar->mutex);
1635         for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1636                 carl9170_flush_cab(ar, vid);
1637
1638         carl9170_flush(ar, drop);
1639         mutex_unlock(&ar->mutex);
1640 }
1641
1642 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1643                                  struct ieee80211_low_level_stats *stats)
1644 {
1645         struct ar9170 *ar = hw->priv;
1646
1647         memset(stats, 0, sizeof(*stats));
1648         stats->dot11ACKFailureCount = ar->tx_ack_failures;
1649         stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1650         return 0;
1651 }
1652
1653 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1654                                    struct ieee80211_vif *vif,
1655                                    enum sta_notify_cmd cmd,
1656                                    struct ieee80211_sta *sta)
1657 {
1658         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1659
1660         switch (cmd) {
1661         case STA_NOTIFY_SLEEP:
1662                 sta_info->sleeping = true;
1663                 if (atomic_read(&sta_info->pending_frames))
1664                         ieee80211_sta_block_awake(hw, sta, true);
1665                 break;
1666
1667         case STA_NOTIFY_AWAKE:
1668                 sta_info->sleeping = false;
1669                 break;
1670         }
1671 }
1672
1673 static bool carl9170_tx_frames_pending(struct ieee80211_hw *hw)
1674 {
1675         struct ar9170 *ar = hw->priv;
1676
1677         return !!atomic_read(&ar->tx_total_queued);
1678 }
1679
1680 static const struct ieee80211_ops carl9170_ops = {
1681         .start                  = carl9170_op_start,
1682         .stop                   = carl9170_op_stop,
1683         .tx                     = carl9170_op_tx,
1684         .flush                  = carl9170_op_flush,
1685         .add_interface          = carl9170_op_add_interface,
1686         .remove_interface       = carl9170_op_remove_interface,
1687         .config                 = carl9170_op_config,
1688         .prepare_multicast      = carl9170_op_prepare_multicast,
1689         .configure_filter       = carl9170_op_configure_filter,
1690         .conf_tx                = carl9170_op_conf_tx,
1691         .bss_info_changed       = carl9170_op_bss_info_changed,
1692         .get_tsf                = carl9170_op_get_tsf,
1693         .set_key                = carl9170_op_set_key,
1694         .sta_add                = carl9170_op_sta_add,
1695         .sta_remove             = carl9170_op_sta_remove,
1696         .sta_notify             = carl9170_op_sta_notify,
1697         .get_survey             = carl9170_op_get_survey,
1698         .get_stats              = carl9170_op_get_stats,
1699         .ampdu_action           = carl9170_op_ampdu_action,
1700         .tx_frames_pending      = carl9170_tx_frames_pending,
1701 };
1702
1703 void *carl9170_alloc(size_t priv_size)
1704 {
1705         struct ieee80211_hw *hw;
1706         struct ar9170 *ar;
1707         struct sk_buff *skb;
1708         int i;
1709
1710         /*
1711          * this buffer is used for rx stream reconstruction.
1712          * Under heavy load this device (or the transport layer?)
1713          * tends to split the streams into separate rx descriptors.
1714          */
1715
1716         skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1717         if (!skb)
1718                 goto err_nomem;
1719
1720         hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1721         if (!hw)
1722                 goto err_nomem;
1723
1724         ar = hw->priv;
1725         ar->hw = hw;
1726         ar->rx_failover = skb;
1727
1728         memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1729         ar->rx_has_plcp = false;
1730
1731         /*
1732          * Here's a hidden pitfall!
1733          *
1734          * All 4 AC queues work perfectly well under _legacy_ operation.
1735          * However as soon as aggregation is enabled, the traffic flow
1736          * gets very bumpy. Therefore we have to _switch_ to a
1737          * software AC with a single HW queue.
1738          */
1739         hw->queues = __AR9170_NUM_TXQ;
1740
1741         mutex_init(&ar->mutex);
1742         spin_lock_init(&ar->beacon_lock);
1743         spin_lock_init(&ar->cmd_lock);
1744         spin_lock_init(&ar->tx_stats_lock);
1745         spin_lock_init(&ar->tx_ampdu_list_lock);
1746         spin_lock_init(&ar->mem_lock);
1747         spin_lock_init(&ar->state_lock);
1748         atomic_set(&ar->pending_restarts, 0);
1749         ar->vifs = 0;
1750         for (i = 0; i < ar->hw->queues; i++) {
1751                 skb_queue_head_init(&ar->tx_status[i]);
1752                 skb_queue_head_init(&ar->tx_pending[i]);
1753         }
1754         INIT_WORK(&ar->ps_work, carl9170_ps_work);
1755         INIT_WORK(&ar->ping_work, carl9170_ping_work);
1756         INIT_WORK(&ar->restart_work, carl9170_restart_work);
1757         INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1758         INIT_DELAYED_WORK(&ar->stat_work, carl9170_stat_work);
1759         INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1760         INIT_LIST_HEAD(&ar->tx_ampdu_list);
1761         rcu_assign_pointer(ar->tx_ampdu_iter,
1762                            (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1763
1764         bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1765         INIT_LIST_HEAD(&ar->vif_list);
1766         init_completion(&ar->tx_flush);
1767
1768         /* firmware decides which modes we support */
1769         hw->wiphy->interface_modes = 0;
1770
1771         hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1772                      IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1773                      IEEE80211_HW_SUPPORTS_PS |
1774                      IEEE80211_HW_PS_NULLFUNC_STACK |
1775                      IEEE80211_HW_NEED_DTIM_PERIOD |
1776                      IEEE80211_HW_SIGNAL_DBM;
1777
1778         if (!modparam_noht) {
1779                 /*
1780                  * see the comment above, why we allow the user
1781                  * to disable HT by a module parameter.
1782                  */
1783                 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1784         }
1785
1786         hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1787         hw->sta_data_size = sizeof(struct carl9170_sta_info);
1788         hw->vif_data_size = sizeof(struct carl9170_vif_info);
1789
1790         hw->max_rates = CARL9170_TX_MAX_RATES;
1791         hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1792
1793         for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1794                 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1795
1796         hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1797         return ar;
1798
1799 err_nomem:
1800         kfree_skb(skb);
1801         return ERR_PTR(-ENOMEM);
1802 }
1803
1804 static int carl9170_read_eeprom(struct ar9170 *ar)
1805 {
1806 #define RW      8       /* number of words to read at once */
1807 #define RB      (sizeof(u32) * RW)
1808         u8 *eeprom = (void *)&ar->eeprom;
1809         __le32 offsets[RW];
1810         int i, j, err;
1811
1812         BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1813
1814         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1815 #ifndef __CHECKER__
1816         /* don't want to handle trailing remains */
1817         BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1818 #endif
1819
1820         for (i = 0; i < sizeof(ar->eeprom) / RB; i++) {
1821                 for (j = 0; j < RW; j++)
1822                         offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1823                                                  RB * i + 4 * j);
1824
1825                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1826                                         RB, (u8 *) &offsets,
1827                                         RB, eeprom + RB * i);
1828                 if (err)
1829                         return err;
1830         }
1831
1832 #undef RW
1833 #undef RB
1834         return 0;
1835 }
1836
1837 static int carl9170_parse_eeprom(struct ar9170 *ar)
1838 {
1839         struct ath_regulatory *regulatory = &ar->common.regulatory;
1840         unsigned int rx_streams, tx_streams, tx_params = 0;
1841         int bands = 0;
1842         int chans = 0;
1843
1844         if (ar->eeprom.length == cpu_to_le16(0xffff))
1845                 return -ENODATA;
1846
1847         rx_streams = hweight8(ar->eeprom.rx_mask);
1848         tx_streams = hweight8(ar->eeprom.tx_mask);
1849
1850         if (rx_streams != tx_streams) {
1851                 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1852
1853                 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1854                         IEEE80211_HT_MCS_TX_MAX_STREAMS));
1855
1856                 tx_params = (tx_streams - 1) <<
1857                             IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1858
1859                 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1860                 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1861         }
1862
1863         if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1864                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1865                         &carl9170_band_2GHz;
1866                 chans += carl9170_band_2GHz.n_channels;
1867                 bands++;
1868         }
1869         if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1870                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1871                         &carl9170_band_5GHz;
1872                 chans += carl9170_band_5GHz.n_channels;
1873                 bands++;
1874         }
1875
1876         if (!bands)
1877                 return -EINVAL;
1878
1879         ar->survey = kzalloc(sizeof(struct survey_info) * chans, GFP_KERNEL);
1880         if (!ar->survey)
1881                 return -ENOMEM;
1882         ar->num_channels = chans;
1883
1884         /*
1885          * I measured this, a bandswitch takes roughly
1886          * 135 ms and a frequency switch about 80.
1887          *
1888          * FIXME: measure these values again once EEPROM settings
1889          *        are used, that will influence them!
1890          */
1891         if (bands == 2)
1892                 ar->hw->channel_change_time = 135 * 1000;
1893         else
1894                 ar->hw->channel_change_time = 80 * 1000;
1895
1896         regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1897         regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]);
1898
1899         /* second part of wiphy init */
1900         SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1901
1902         return 0;
1903 }
1904
1905 static int carl9170_reg_notifier(struct wiphy *wiphy,
1906                                  struct regulatory_request *request)
1907 {
1908         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1909         struct ar9170 *ar = hw->priv;
1910
1911         return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1912 }
1913
1914 int carl9170_register(struct ar9170 *ar)
1915 {
1916         struct ath_regulatory *regulatory = &ar->common.regulatory;
1917         int err = 0, i;
1918
1919         if (WARN_ON(ar->mem_bitmap))
1920                 return -EINVAL;
1921
1922         ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
1923                                  sizeof(unsigned long), GFP_KERNEL);
1924
1925         if (!ar->mem_bitmap)
1926                 return -ENOMEM;
1927
1928         /* try to read EEPROM, init MAC addr */
1929         err = carl9170_read_eeprom(ar);
1930         if (err)
1931                 return err;
1932
1933         err = carl9170_fw_fix_eeprom(ar);
1934         if (err)
1935                 return err;
1936
1937         err = carl9170_parse_eeprom(ar);
1938         if (err)
1939                 return err;
1940
1941         err = ath_regd_init(regulatory, ar->hw->wiphy,
1942                             carl9170_reg_notifier);
1943         if (err)
1944                 return err;
1945
1946         if (modparam_noht) {
1947                 carl9170_band_2GHz.ht_cap.ht_supported = false;
1948                 carl9170_band_5GHz.ht_cap.ht_supported = false;
1949         }
1950
1951         for (i = 0; i < ar->fw.vif_num; i++) {
1952                 ar->vif_priv[i].id = i;
1953                 ar->vif_priv[i].vif = NULL;
1954         }
1955
1956         err = ieee80211_register_hw(ar->hw);
1957         if (err)
1958                 return err;
1959
1960         /* mac80211 interface is now registered */
1961         ar->registered = true;
1962
1963         if (!ath_is_world_regd(regulatory))
1964                 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1965
1966 #ifdef CONFIG_CARL9170_DEBUGFS
1967         carl9170_debugfs_register(ar);
1968 #endif /* CONFIG_CARL9170_DEBUGFS */
1969
1970         err = carl9170_led_init(ar);
1971         if (err)
1972                 goto err_unreg;
1973
1974 #ifdef CONFIG_CARL9170_LEDS
1975         err = carl9170_led_register(ar);
1976         if (err)
1977                 goto err_unreg;
1978 #endif /* CONFIG_CARL9170_LEDS */
1979
1980 #ifdef CONFIG_CARL9170_WPC
1981         err = carl9170_register_wps_button(ar);
1982         if (err)
1983                 goto err_unreg;
1984 #endif /* CONFIG_CARL9170_WPC */
1985
1986 #ifdef CONFIG_CARL9170_HWRNG
1987         err = carl9170_register_hwrng(ar);
1988         if (err)
1989                 goto err_unreg;
1990 #endif /* CONFIG_CARL9170_HWRNG */
1991
1992         dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
1993                  wiphy_name(ar->hw->wiphy));
1994
1995         return 0;
1996
1997 err_unreg:
1998         carl9170_unregister(ar);
1999         return err;
2000 }
2001
2002 void carl9170_unregister(struct ar9170 *ar)
2003 {
2004         if (!ar->registered)
2005                 return;
2006
2007         ar->registered = false;
2008
2009 #ifdef CONFIG_CARL9170_LEDS
2010         carl9170_led_unregister(ar);
2011 #endif /* CONFIG_CARL9170_LEDS */
2012
2013 #ifdef CONFIG_CARL9170_DEBUGFS
2014         carl9170_debugfs_unregister(ar);
2015 #endif /* CONFIG_CARL9170_DEBUGFS */
2016
2017 #ifdef CONFIG_CARL9170_WPC
2018         if (ar->wps.pbc) {
2019                 input_unregister_device(ar->wps.pbc);
2020                 ar->wps.pbc = NULL;
2021         }
2022 #endif /* CONFIG_CARL9170_WPC */
2023
2024 #ifdef CONFIG_CARL9170_HWRNG
2025         carl9170_unregister_hwrng(ar);
2026 #endif /* CONFIG_CARL9170_HWRNG */
2027
2028         carl9170_cancel_worker(ar);
2029         cancel_work_sync(&ar->restart_work);
2030
2031         ieee80211_unregister_hw(ar->hw);
2032 }
2033
2034 void carl9170_free(struct ar9170 *ar)
2035 {
2036         WARN_ON(ar->registered);
2037         WARN_ON(IS_INITIALIZED(ar));
2038
2039         kfree_skb(ar->rx_failover);
2040         ar->rx_failover = NULL;
2041
2042         kfree(ar->mem_bitmap);
2043         ar->mem_bitmap = NULL;
2044
2045         kfree(ar->survey);
2046         ar->survey = NULL;
2047
2048         mutex_destroy(&ar->mutex);
2049
2050         ieee80211_free_hw(ar->hw);
2051 }