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[0], 3, 15, 1023,  0); /* BEST EFFORT */
 349         CARL9170_FILL_QUEUE(ar->edcf[1], 2, 7,    15, 94); /* VIDEO */
 350         CARL9170_FILL_QUEUE(ar->edcf[2], 2, 3,     7, 47); /* VOICE */
 351         CARL9170_FILL_QUEUE(ar->edcf[3], 7, 15, 1023,  0); /* BACKGROUND */
 352         CARL9170_FILL_QUEUE(ar->edcf[4], 2, 3,     7,  0); /* SPECIAL */
 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_wake_queues(ar->hw);
 417         err = 0;
 418
 419 out:
 420         mutex_unlock(&ar->mutex);
 421         return err;
 422 }
 423
 424 static void carl9170_cancel_worker(struct ar9170 *ar)
 425 {
 426         cancel_delayed_work_sync(&ar->tx_janitor);
 427 #ifdef CONFIG_CARL9170_LEDS
 428         cancel_delayed_work_sync(&ar->led_work);
 429 #endif /* CONFIG_CARL9170_LEDS */
 430         cancel_work_sync(&ar->ps_work);
 431         cancel_work_sync(&ar->ampdu_work);
 432 }
 433
 434 static void carl9170_op_stop(struct ieee80211_hw *hw)
 435 {
 436         struct ar9170 *ar = hw->priv;
 437
 438         carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
 439
 440         ieee80211_stop_queues(ar->hw);
 441
 442         mutex_lock(&ar->mutex);
 443         if (IS_ACCEPTING_CMD(ar)) {
 444                 rcu_assign_pointer(ar->beacon_iter, NULL);
 445
 446                 carl9170_led_set_state(ar, 0);
 447
 448                 /* stop DMA */
 449                 carl9170_write_reg(ar, AR9170_MAC_REG_DMA_TRIGGER, 0);
 450                 carl9170_usb_stop(ar);
 451         }
 452
 453         carl9170_zap_queues(ar);
 454         mutex_unlock(&ar->mutex);
 455
 456         carl9170_cancel_worker(ar);
 457 }
 458
 459 static void carl9170_restart_work(struct work_struct *work)
 460 {
 461         struct ar9170 *ar = container_of(work, struct ar9170,
 462                                          restart_work);
 463         int err;
 464
 465         ar->usedkeys = 0;
 466         ar->filter_state = 0;
 467         carl9170_cancel_worker(ar);
 468
 469         mutex_lock(&ar->mutex);
 470         err = carl9170_usb_restart(ar);
 471         if (net_ratelimit()) {
 472                 if (err) {
 473                         dev_err(&ar->udev->dev, "Failed to restart device "
 474                                 " (%d).\n", err);
 475                  } else {
 476                         dev_info(&ar->udev->dev, "device restarted "
 477                                  "successfully.\n");
 478                 }
 479         }
 480
 481         carl9170_zap_queues(ar);
 482         mutex_unlock(&ar->mutex);
 483         if (!err) {
 484                 ar->restart_counter++;
 485                 atomic_set(&ar->pending_restarts, 0);
 486
 487                 ieee80211_restart_hw(ar->hw);
 488         } else {
 489                 /*
 490                  * The reset was unsuccessful and the device seems to
 491                  * be dead. But there's still one option: a low-level
 492                  * usb subsystem reset...
 493                  */
 494
 495                 carl9170_usb_reset(ar);
 496         }
 497 }
 498
 499 void carl9170_restart(struct ar9170 *ar, const enum carl9170_restart_reasons r)
 500 {
 501         carl9170_set_state_when(ar, CARL9170_STARTED, CARL9170_IDLE);
 502
 503         /*
 504          * Sometimes, an error can trigger several different reset events.
 505          * By ignoring these *surplus* reset events, the device won't be
 506          * killed again, right after it has recovered.
 507          */
 508         if (atomic_inc_return(&ar->pending_restarts) > 1) {
 509                 dev_dbg(&ar->udev->dev, "ignoring restart (%d)\n", r);
 510                 return;
 511         }
 512
 513         ieee80211_stop_queues(ar->hw);
 514
 515         dev_err(&ar->udev->dev, "restart device (%d)\n", r);
 516
 517         if (!WARN_ON(r == CARL9170_RR_NO_REASON) ||
 518             !WARN_ON(r >= __CARL9170_RR_LAST))
 519                 ar->last_reason = r;
 520
 521         if (!ar->registered)
 522                 return;
 523
 524         if (IS_ACCEPTING_CMD(ar) && !ar->needs_full_reset)
 525                 ieee80211_queue_work(ar->hw, &ar->restart_work);
 526         else
 527                 carl9170_usb_reset(ar);
 528
 529         /*
 530          * At this point, the device instance might have vanished/disabled.
 531          * So, don't put any code which access the ar9170 struct
 532          * without proper protection.
 533          */
 534 }
 535
 536 static int carl9170_init_interface(struct ar9170 *ar,
 537                                    struct ieee80211_vif *vif)
 538 {
 539         struct ath_common *common = &ar->common;
 540         int err;
 541
 542         if (!vif) {
 543                 WARN_ON_ONCE(IS_STARTED(ar));
 544                 return 0;
 545         }
 546
 547         memcpy(common->macaddr, vif->addr, ETH_ALEN);
 548
 549         if (modparam_nohwcrypt ||
 550             ((vif->type != NL80211_IFTYPE_STATION) &&
 551              (vif->type != NL80211_IFTYPE_AP))) {
 552                 ar->rx_software_decryption = true;
 553                 ar->disable_offload = true;
 554         }
 555
 556         err = carl9170_set_operating_mode(ar);
 557         return err;
 558 }
 559
 560 static int carl9170_op_add_interface(struct ieee80211_hw *hw,
 561                                      struct ieee80211_vif *vif)
 562 {
 563         struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
 564         struct ieee80211_vif *main_vif;
 565         struct ar9170 *ar = hw->priv;
 566         int vif_id = -1, err = 0;
 567
 568         mutex_lock(&ar->mutex);
 569         rcu_read_lock();
 570         if (vif_priv->active) {
 571                 /*
 572                  * Skip the interface structure initialization,
 573                  * if the vif survived the _restart call.
 574                  */
 575                 vif_id = vif_priv->id;
 576                 vif_priv->enable_beacon = false;
 577
 578                 spin_lock_bh(&ar->beacon_lock);
 579                 dev_kfree_skb_any(vif_priv->beacon);
 580                 vif_priv->beacon = NULL;
 581                 spin_unlock_bh(&ar->beacon_lock);
 582
 583                 goto init;
 584         }
 585
 586         main_vif = carl9170_get_main_vif(ar);
 587
 588         if (main_vif) {
 589                 switch (main_vif->type) {
 590                 case NL80211_IFTYPE_STATION:
 591                         if (vif->type == NL80211_IFTYPE_STATION)
 592                                 break;
 593
 594                         err = -EBUSY;
 595                         rcu_read_unlock();
 596
 597                         goto unlock;
 598
 599                 case NL80211_IFTYPE_AP:
 600                         if ((vif->type == NL80211_IFTYPE_STATION) ||
 601                             (vif->type == NL80211_IFTYPE_WDS) ||
 602                             (vif->type == NL80211_IFTYPE_AP))
 603                                 break;
 604
 605                         err = -EBUSY;
 606                         rcu_read_unlock();
 607                         goto unlock;
 608
 609                 default:
 610                         rcu_read_unlock();
 611                         goto unlock;
 612                 }
 613         }
 614
 615         vif_id = bitmap_find_free_region(&ar->vif_bitmap, ar->fw.vif_num, 0);
 616
 617         if (vif_id < 0) {
 618                 rcu_read_unlock();
 619
 620                 err = -ENOSPC;
 621                 goto unlock;
 622         }
 623
 624         BUG_ON(ar->vif_priv[vif_id].id != vif_id);
 625
 626         vif_priv->active = true;
 627         vif_priv->id = vif_id;
 628         vif_priv->enable_beacon = false;
 629         ar->vifs++;
 630         list_add_tail_rcu(&vif_priv->list, &ar->vif_list);
 631         rcu_assign_pointer(ar->vif_priv[vif_id].vif, vif);
 632
 633 init:
 634         if (carl9170_get_main_vif(ar) == vif) {
 635                 rcu_assign_pointer(ar->beacon_iter, vif_priv);
 636                 rcu_read_unlock();
 637
 638                 err = carl9170_init_interface(ar, vif);
 639                 if (err)
 640                         goto unlock;
 641         } else {
 642                 rcu_read_unlock();
 643                 err = carl9170_mod_virtual_mac(ar, vif_id, vif->addr);
 644
 645                 if (err)
 646                         goto unlock;
 647         }
 648
 649 unlock:
 650         if (err && (vif_id >= 0)) {
 651                 vif_priv->active = false;
 652                 bitmap_release_region(&ar->vif_bitmap, vif_id, 0);
 653                 ar->vifs--;
 654                 rcu_assign_pointer(ar->vif_priv[vif_id].vif, NULL);
 655                 list_del_rcu(&vif_priv->list);
 656                 mutex_unlock(&ar->mutex);
 657                 synchronize_rcu();
 658         } else {
 659                 if (ar->vifs > 1)
 660                         ar->ps.off_override |= PS_OFF_VIF;
 661
 662                 mutex_unlock(&ar->mutex);
 663         }
 664
 665         return err;
 666 }
 667
 668 static void carl9170_op_remove_interface(struct ieee80211_hw *hw,
 669                                          struct ieee80211_vif *vif)
 670 {
 671         struct carl9170_vif_info *vif_priv = (void *) vif->drv_priv;
 672         struct ieee80211_vif *main_vif;
 673         struct ar9170 *ar = hw->priv;
 674         unsigned int id;
 675
 676         mutex_lock(&ar->mutex);
 677
 678         if (WARN_ON_ONCE(!vif_priv->active))
 679                 goto unlock;
 680
 681         ar->vifs--;
 682
 683         rcu_read_lock();
 684         main_vif = carl9170_get_main_vif(ar);
 685
 686         id = vif_priv->id;
 687
 688         vif_priv->active = false;
 689         WARN_ON(vif_priv->enable_beacon);
 690         vif_priv->enable_beacon = false;
 691         list_del_rcu(&vif_priv->list);
 692         rcu_assign_pointer(ar->vif_priv[id].vif, NULL);
 693
 694         if (vif == main_vif) {
 695                 rcu_read_unlock();
 696
 697                 if (ar->vifs) {
 698                         WARN_ON(carl9170_init_interface(ar,
 699                                         carl9170_get_main_vif(ar)));
 700                 } else {
 701                         carl9170_set_operating_mode(ar);
 702                 }
 703         } else {
 704                 rcu_read_unlock();
 705
 706                 WARN_ON(carl9170_mod_virtual_mac(ar, id, NULL));
 707         }
 708
 709         carl9170_update_beacon(ar, false);
 710         carl9170_flush_cab(ar, id);
 711
 712         spin_lock_bh(&ar->beacon_lock);
 713         dev_kfree_skb_any(vif_priv->beacon);
 714         vif_priv->beacon = NULL;
 715         spin_unlock_bh(&ar->beacon_lock);
 716
 717         bitmap_release_region(&ar->vif_bitmap, id, 0);
 718
 719         carl9170_set_beacon_timers(ar);
 720
 721         if (ar->vifs == 1)
 722                 ar->ps.off_override &= ~PS_OFF_VIF;
 723
 724 unlock:
 725         mutex_unlock(&ar->mutex);
 726
 727         synchronize_rcu();
 728 }
 729
 730 void carl9170_ps_check(struct ar9170 *ar)
 731 {
 732         ieee80211_queue_work(ar->hw, &ar->ps_work);
 733 }
 734
 735 /* caller must hold ar->mutex */
 736 static int carl9170_ps_update(struct ar9170 *ar)
 737 {
 738         bool ps = false;
 739         int err = 0;
 740
 741         if (!ar->ps.off_override)
 742                 ps = (ar->hw->conf.flags & IEEE80211_CONF_PS);
 743
 744         if (ps != ar->ps.state) {
 745                 err = carl9170_powersave(ar, ps);
 746                 if (err)
 747                         return err;
 748
 749                 if (ar->ps.state && !ps) {
 750                         ar->ps.sleep_ms = jiffies_to_msecs(jiffies -
 751                                 ar->ps.last_action);
 752                 }
 753
 754                 if (ps)
 755                         ar->ps.last_slept = jiffies;
 756
 757                 ar->ps.last_action = jiffies;
 758                 ar->ps.state = ps;
 759         }
 760
 761         return 0;
 762 }
 763
 764 static void carl9170_ps_work(struct work_struct *work)
 765 {
 766         struct ar9170 *ar = container_of(work, struct ar9170,
 767                                          ps_work);
 768         mutex_lock(&ar->mutex);
 769         if (IS_STARTED(ar))
 770                 WARN_ON_ONCE(carl9170_ps_update(ar) != 0);
 771         mutex_unlock(&ar->mutex);
 772 }
 773
 774
 775 static int carl9170_op_config(struct ieee80211_hw *hw, u32 changed)
 776 {
 777         struct ar9170 *ar = hw->priv;
 778         int err = 0;
 779
 780         mutex_lock(&ar->mutex);
 781         if (changed & IEEE80211_CONF_CHANGE_LISTEN_INTERVAL) {
 782                 /* TODO */
 783                 err = 0;
 784         }
 785
 786         if (changed & IEEE80211_CONF_CHANGE_PS) {
 787                 err = carl9170_ps_update(ar);
 788                 if (err)
 789                         goto out;
 790         }
 791
 792         if (changed & IEEE80211_CONF_CHANGE_POWER) {
 793                 /* TODO */
 794                 err = 0;
 795         }
 796
 797         if (changed & IEEE80211_CONF_CHANGE_SMPS) {
 798                 /* TODO */
 799                 err = 0;
 800         }
 801
 802         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
 803                 /* adjust slot time for 5 GHz */
 804                 err = carl9170_set_slot_time(ar);
 805                 if (err)
 806                         goto out;
 807
 808                 err = carl9170_set_channel(ar, hw->conf.channel,
 809                         hw->conf.channel_type, CARL9170_RFI_NONE);
 810                 if (err)
 811                         goto out;
 812
 813                 err = carl9170_set_dyn_sifs_ack(ar);
 814                 if (err)
 815                         goto out;
 816
 817                 err = carl9170_set_rts_cts_rate(ar);
 818                 if (err)
 819                         goto out;
 820         }
 821
 822 out:
 823         mutex_unlock(&ar->mutex);
 824         return err;
 825 }
 826
 827 static u64 carl9170_op_prepare_multicast(struct ieee80211_hw *hw,
 828                                          struct netdev_hw_addr_list *mc_list)
 829 {
 830         struct netdev_hw_addr *ha;
 831         u64 mchash;
 832
 833         /* always get broadcast frames */
 834         mchash = 1ULL << (0xff >> 2);
 835
 836         netdev_hw_addr_list_for_each(ha, mc_list)
 837                 mchash |= 1ULL << (ha->addr[5] >> 2);
 838
 839         return mchash;
 840 }
 841
 842 static void carl9170_op_configure_filter(struct ieee80211_hw *hw,
 843                                          unsigned int changed_flags,
 844                                          unsigned int *new_flags,
 845                                          u64 multicast)
 846 {
 847         struct ar9170 *ar = hw->priv;
 848
 849         /* mask supported flags */
 850         *new_flags &= FIF_ALLMULTI | ar->rx_filter_caps;
 851
 852         if (!IS_ACCEPTING_CMD(ar))
 853                 return;
 854
 855         mutex_lock(&ar->mutex);
 856
 857         ar->filter_state = *new_flags;
 858         /*
 859          * We can support more by setting the sniffer bit and
 860          * then checking the error flags, later.
 861          */
 862
 863         if (changed_flags & FIF_ALLMULTI && *new_flags & FIF_ALLMULTI)
 864                 multicast = ~0ULL;
 865
 866         if (multicast != ar->cur_mc_hash)
 867                 WARN_ON(carl9170_update_multicast(ar, multicast));
 868
 869         if (changed_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS)) {
 870                 ar->sniffer_enabled = !!(*new_flags &
 871                         (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS));
 872
 873                 WARN_ON(carl9170_set_operating_mode(ar));
 874         }
 875
 876         if (ar->fw.rx_filter && changed_flags & ar->rx_filter_caps) {
 877                 u32 rx_filter = 0;
 878
 879                 if (!(*new_flags & (FIF_FCSFAIL | FIF_PLCPFAIL)))
 880                         rx_filter |= CARL9170_RX_FILTER_BAD;
 881
 882                 if (!(*new_flags & FIF_CONTROL))
 883                         rx_filter |= CARL9170_RX_FILTER_CTL_OTHER;
 884
 885                 if (!(*new_flags & FIF_PSPOLL))
 886                         rx_filter |= CARL9170_RX_FILTER_CTL_PSPOLL;
 887
 888                 if (!(*new_flags & (FIF_OTHER_BSS | FIF_PROMISC_IN_BSS))) {
 889                         rx_filter |= CARL9170_RX_FILTER_OTHER_RA;
 890                         rx_filter |= CARL9170_RX_FILTER_DECRY_FAIL;
 891                 }
 892
 893                 WARN_ON(carl9170_rx_filter(ar, rx_filter));
 894         }
 895
 896         mutex_unlock(&ar->mutex);
 897 }
 898
 899
 900 static void carl9170_op_bss_info_changed(struct ieee80211_hw *hw,
 901                                          struct ieee80211_vif *vif,
 902                                          struct ieee80211_bss_conf *bss_conf,
 903                                          u32 changed)
 904 {
 905         struct ar9170 *ar = hw->priv;
 906         struct ath_common *common = &ar->common;
 907         int err = 0;
 908         struct carl9170_vif_info *vif_priv;
 909         struct ieee80211_vif *main_vif;
 910
 911         mutex_lock(&ar->mutex);
 912         vif_priv = (void *) vif->drv_priv;
 913         main_vif = carl9170_get_main_vif(ar);
 914         if (WARN_ON(!main_vif))
 915                 goto out;
 916
 917         if (changed & BSS_CHANGED_BEACON_ENABLED) {
 918                 struct carl9170_vif_info *iter;
 919                 int i = 0;
 920
 921                 vif_priv->enable_beacon = bss_conf->enable_beacon;
 922                 rcu_read_lock();
 923                 list_for_each_entry_rcu(iter, &ar->vif_list, list) {
 924                         if (iter->active && iter->enable_beacon)
 925                                 i++;
 926
 927                 }
 928                 rcu_read_unlock();
 929
 930                 ar->beacon_enabled = i;
 931         }
 932
 933         if (changed & BSS_CHANGED_BEACON) {
 934                 err = carl9170_update_beacon(ar, false);
 935                 if (err)
 936                         goto out;
 937         }
 938
 939         if (changed & (BSS_CHANGED_BEACON_ENABLED | BSS_CHANGED_BEACON |
 940                        BSS_CHANGED_BEACON_INT)) {
 941
 942                 if (main_vif != vif) {
 943                         bss_conf->beacon_int = main_vif->bss_conf.beacon_int;
 944                         bss_conf->dtim_period = main_vif->bss_conf.dtim_period;
 945                 }
 946
 947                 /*
 948                  * Therefore a hard limit for the broadcast traffic should
 949                  * prevent false alarms.
 950                  */
 951                 if (vif->type != NL80211_IFTYPE_STATION &&
 952                     (bss_conf->beacon_int * bss_conf->dtim_period >=
 953                      (CARL9170_QUEUE_STUCK_TIMEOUT / 2))) {
 954                         err = -EINVAL;
 955                         goto out;
 956                 }
 957
 958                 err = carl9170_set_beacon_timers(ar);
 959                 if (err)
 960                         goto out;
 961         }
 962
 963         if (changed & BSS_CHANGED_HT) {
 964                 /* TODO */
 965                 err = 0;
 966                 if (err)
 967                         goto out;
 968         }
 969
 970         if (main_vif != vif)
 971                 goto out;
 972
 973         /*
 974          * The following settings can only be changed by the
 975          * master interface.
 976          */
 977
 978         if (changed & BSS_CHANGED_BSSID) {
 979                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
 980                 err = carl9170_set_operating_mode(ar);
 981                 if (err)
 982                         goto out;
 983         }
 984
 985         if (changed & BSS_CHANGED_ASSOC) {
 986                 ar->common.curaid = bss_conf->aid;
 987                 err = carl9170_set_beacon_timers(ar);
 988                 if (err)
 989                         goto out;
 990         }
 991
 992         if (changed & BSS_CHANGED_ERP_SLOT) {
 993                 err = carl9170_set_slot_time(ar);
 994                 if (err)
 995                         goto out;
 996         }
 997
 998         if (changed & BSS_CHANGED_BASIC_RATES) {
 999                 err = carl9170_set_mac_rates(ar);
1000                 if (err)
1001                         goto out;
1002         }
1003
1004 out:
1005         WARN_ON_ONCE(err && IS_STARTED(ar));
1006         mutex_unlock(&ar->mutex);
1007 }
1008
1009 static u64 carl9170_op_get_tsf(struct ieee80211_hw *hw)
1010 {
1011         struct ar9170 *ar = hw->priv;
1012         struct carl9170_tsf_rsp tsf;
1013         int err;
1014
1015         mutex_lock(&ar->mutex);
1016         err = carl9170_exec_cmd(ar, CARL9170_CMD_READ_TSF,
1017                                 0, NULL, sizeof(tsf), &tsf);
1018         mutex_unlock(&ar->mutex);
1019         if (WARN_ON(err))
1020                 return 0;
1021
1022         return le64_to_cpu(tsf.tsf_64);
1023 }
1024
1025 static int carl9170_op_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
1026                                struct ieee80211_vif *vif,
1027                                struct ieee80211_sta *sta,
1028                                struct ieee80211_key_conf *key)
1029 {
1030         struct ar9170 *ar = hw->priv;
1031         int err = 0, i;
1032         u8 ktype;
1033
1034         if (ar->disable_offload || !vif)
1035                 return -EOPNOTSUPP;
1036
1037         /*
1038          * We have to fall back to software encryption, whenever
1039          * the user choose to participates in an IBSS or is connected
1040          * to more than one network.
1041          *
1042          * This is very unfortunate, because some machines cannot handle
1043          * the high througput speed in 802.11n networks.
1044          */
1045
1046         if (!is_main_vif(ar, vif))
1047                 goto err_softw;
1048
1049         /*
1050          * While the hardware supports *catch-all* key, for offloading
1051          * group-key en-/de-cryption. The way of how the hardware
1052          * decides which keyId maps to which key, remains a mystery...
1053          */
1054         if ((vif->type != NL80211_IFTYPE_STATION &&
1055              vif->type != NL80211_IFTYPE_ADHOC) &&
1056             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
1057                 return -EOPNOTSUPP;
1058
1059         switch (key->cipher) {
1060         case WLAN_CIPHER_SUITE_WEP40:
1061                 ktype = AR9170_ENC_ALG_WEP64;
1062                 break;
1063         case WLAN_CIPHER_SUITE_WEP104:
1064                 ktype = AR9170_ENC_ALG_WEP128;
1065                 break;
1066         case WLAN_CIPHER_SUITE_TKIP:
1067                 ktype = AR9170_ENC_ALG_TKIP;
1068                 break;
1069         case WLAN_CIPHER_SUITE_CCMP:
1070                 ktype = AR9170_ENC_ALG_AESCCMP;
1071                 break;
1072         default:
1073                 return -EOPNOTSUPP;
1074         }
1075
1076         mutex_lock(&ar->mutex);
1077         if (cmd == SET_KEY) {
1078                 if (!IS_STARTED(ar)) {
1079                         err = -EOPNOTSUPP;
1080                         goto out;
1081                 }
1082
1083                 if (!(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1084                         sta = NULL;
1085
1086                         i = 64 + key->keyidx;
1087                 } else {
1088                         for (i = 0; i < 64; i++)
1089                                 if (!(ar->usedkeys & BIT(i)))
1090                                         break;
1091                         if (i == 64)
1092                                 goto err_softw;
1093                 }
1094
1095                 key->hw_key_idx = i;
1096
1097                 err = carl9170_upload_key(ar, i, sta ? sta->addr : NULL,
1098                                           ktype, 0, key->key,
1099                                           min_t(u8, 16, key->keylen));
1100                 if (err)
1101                         goto out;
1102
1103                 if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1104                         err = carl9170_upload_key(ar, i, sta ? sta->addr :
1105                                                   NULL, ktype, 1,
1106                                                   key->key + 16, 16);
1107                         if (err)
1108                                 goto out;
1109
1110                         /*
1111                          * hardware is not capable generating MMIC
1112                          * of fragmented frames!
1113                          */
1114                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1115                 }
1116
1117                 if (i < 64)
1118                         ar->usedkeys |= BIT(i);
1119
1120                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1121         } else {
1122                 if (!IS_STARTED(ar)) {
1123                         /* The device is gone... together with the key ;-) */
1124                         err = 0;
1125                         goto out;
1126                 }
1127
1128                 if (key->hw_key_idx < 64) {
1129                         ar->usedkeys &= ~BIT(key->hw_key_idx);
1130                 } else {
1131                         err = carl9170_upload_key(ar, key->hw_key_idx, NULL,
1132                                                   AR9170_ENC_ALG_NONE, 0,
1133                                                   NULL, 0);
1134                         if (err)
1135                                 goto out;
1136
1137                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP) {
1138                                 err = carl9170_upload_key(ar, key->hw_key_idx,
1139                                                           NULL,
1140                                                           AR9170_ENC_ALG_NONE,
1141                                                           1, NULL, 0);
1142                                 if (err)
1143                                         goto out;
1144                         }
1145
1146                 }
1147
1148                 err = carl9170_disable_key(ar, key->hw_key_idx);
1149                 if (err)
1150                         goto out;
1151         }
1152
1153 out:
1154         mutex_unlock(&ar->mutex);
1155         return err;
1156
1157 err_softw:
1158         if (!ar->rx_software_decryption) {
1159                 ar->rx_software_decryption = true;
1160                 carl9170_set_operating_mode(ar);
1161         }
1162         mutex_unlock(&ar->mutex);
1163         return -ENOSPC;
1164 }
1165
1166 static int carl9170_op_sta_add(struct ieee80211_hw *hw,
1167                                struct ieee80211_vif *vif,
1168                                struct ieee80211_sta *sta)
1169 {
1170         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1171         unsigned int i;
1172
1173         if (sta->ht_cap.ht_supported) {
1174                 if (sta->ht_cap.ampdu_density > 6) {
1175                         /*
1176                          * HW does support 16us AMPDU density.
1177                          * No HT-Xmit for station.
1178                          */
1179
1180                         return 0;
1181                 }
1182
1183                 for (i = 0; i < CARL9170_NUM_TID; i++)
1184                         rcu_assign_pointer(sta_info->agg[i], NULL);
1185
1186                 sta_info->ampdu_max_len = 1 << (3 + sta->ht_cap.ampdu_factor);
1187                 sta_info->ht_sta = true;
1188         }
1189
1190         return 0;
1191 }
1192
1193 static int carl9170_op_sta_remove(struct ieee80211_hw *hw,
1194                                 struct ieee80211_vif *vif,
1195                                 struct ieee80211_sta *sta)
1196 {
1197         struct ar9170 *ar = hw->priv;
1198         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1199         unsigned int i;
1200         bool cleanup = false;
1201
1202         if (sta->ht_cap.ht_supported) {
1203
1204                 sta_info->ht_sta = false;
1205
1206                 rcu_read_lock();
1207                 for (i = 0; i < CARL9170_NUM_TID; i++) {
1208                         struct carl9170_sta_tid *tid_info;
1209
1210                         tid_info = rcu_dereference(sta_info->agg[i]);
1211                         rcu_assign_pointer(sta_info->agg[i], NULL);
1212
1213                         if (!tid_info)
1214                                 continue;
1215
1216                         spin_lock_bh(&ar->tx_ampdu_list_lock);
1217                         if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1218                                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1219                         spin_unlock_bh(&ar->tx_ampdu_list_lock);
1220                         cleanup = true;
1221                 }
1222                 rcu_read_unlock();
1223
1224                 if (cleanup)
1225                         carl9170_ampdu_gc(ar);
1226         }
1227
1228         return 0;
1229 }
1230
1231 static int carl9170_op_conf_tx(struct ieee80211_hw *hw, u16 queue,
1232                                const struct ieee80211_tx_queue_params *param)
1233 {
1234         struct ar9170 *ar = hw->priv;
1235         int ret;
1236
1237         mutex_lock(&ar->mutex);
1238         if (queue < ar->hw->queues) {
1239                 memcpy(&ar->edcf[ar9170_qmap[queue]], param, sizeof(*param));
1240                 ret = carl9170_set_qos(ar);
1241         } else {
1242                 ret = -EINVAL;
1243         }
1244
1245         mutex_unlock(&ar->mutex);
1246         return ret;
1247 }
1248
1249 static void carl9170_ampdu_work(struct work_struct *work)
1250 {
1251         struct ar9170 *ar = container_of(work, struct ar9170,
1252                                          ampdu_work);
1253
1254         if (!IS_STARTED(ar))
1255                 return;
1256
1257         mutex_lock(&ar->mutex);
1258         carl9170_ampdu_gc(ar);
1259         mutex_unlock(&ar->mutex);
1260 }
1261
1262 static int carl9170_op_ampdu_action(struct ieee80211_hw *hw,
1263                                     struct ieee80211_vif *vif,
1264                                     enum ieee80211_ampdu_mlme_action action,
1265                                     struct ieee80211_sta *sta,
1266                                     u16 tid, u16 *ssn)
1267 {
1268         struct ar9170 *ar = hw->priv;
1269         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1270         struct carl9170_sta_tid *tid_info;
1271
1272         if (modparam_noht)
1273                 return -EOPNOTSUPP;
1274
1275         switch (action) {
1276         case IEEE80211_AMPDU_TX_START:
1277                 if (!sta_info->ht_sta)
1278                         return -EOPNOTSUPP;
1279
1280                 rcu_read_lock();
1281                 if (rcu_dereference(sta_info->agg[tid])) {
1282                         rcu_read_unlock();
1283                         return -EBUSY;
1284                 }
1285
1286                 tid_info = kzalloc(sizeof(struct carl9170_sta_tid),
1287                                    GFP_ATOMIC);
1288                 if (!tid_info) {
1289                         rcu_read_unlock();
1290                         return -ENOMEM;
1291                 }
1292
1293                 tid_info->hsn = tid_info->bsn = tid_info->snx = (*ssn);
1294                 tid_info->state = CARL9170_TID_STATE_PROGRESS;
1295                 tid_info->tid = tid;
1296                 tid_info->max = sta_info->ampdu_max_len;
1297
1298                 INIT_LIST_HEAD(&tid_info->list);
1299                 INIT_LIST_HEAD(&tid_info->tmp_list);
1300                 skb_queue_head_init(&tid_info->queue);
1301                 spin_lock_init(&tid_info->lock);
1302
1303                 spin_lock_bh(&ar->tx_ampdu_list_lock);
1304                 ar->tx_ampdu_list_len++;
1305                 list_add_tail_rcu(&tid_info->list, &ar->tx_ampdu_list);
1306                 rcu_assign_pointer(sta_info->agg[tid], tid_info);
1307                 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1308                 rcu_read_unlock();
1309
1310                 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1311                 break;
1312
1313         case IEEE80211_AMPDU_TX_STOP:
1314                 rcu_read_lock();
1315                 tid_info = rcu_dereference(sta_info->agg[tid]);
1316                 if (tid_info) {
1317                         spin_lock_bh(&ar->tx_ampdu_list_lock);
1318                         if (tid_info->state > CARL9170_TID_STATE_SHUTDOWN)
1319                                 tid_info->state = CARL9170_TID_STATE_SHUTDOWN;
1320                         spin_unlock_bh(&ar->tx_ampdu_list_lock);
1321                 }
1322
1323                 rcu_assign_pointer(sta_info->agg[tid], NULL);
1324                 rcu_read_unlock();
1325
1326                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1327                 ieee80211_queue_work(ar->hw, &ar->ampdu_work);
1328                 break;
1329
1330         case IEEE80211_AMPDU_TX_OPERATIONAL:
1331                 rcu_read_lock();
1332                 tid_info = rcu_dereference(sta_info->agg[tid]);
1333
1334                 sta_info->stats[tid].clear = true;
1335
1336                 if (tid_info) {
1337                         bitmap_zero(tid_info->bitmap, CARL9170_BAW_SIZE);
1338                         tid_info->state = CARL9170_TID_STATE_IDLE;
1339                 }
1340                 rcu_read_unlock();
1341
1342                 if (WARN_ON_ONCE(!tid_info))
1343                         return -EFAULT;
1344
1345                 break;
1346
1347         case IEEE80211_AMPDU_RX_START:
1348         case IEEE80211_AMPDU_RX_STOP:
1349                 /* Handled by hardware */
1350                 break;
1351
1352         default:
1353                 return -EOPNOTSUPP;
1354         }
1355
1356         return 0;
1357 }
1358
1359 #ifdef CONFIG_CARL9170_WPC
1360 static int carl9170_register_wps_button(struct ar9170 *ar)
1361 {
1362         struct input_dev *input;
1363         int err;
1364
1365         if (!(ar->features & CARL9170_WPS_BUTTON))
1366                 return 0;
1367
1368         input = input_allocate_device();
1369         if (!input)
1370                 return -ENOMEM;
1371
1372         snprintf(ar->wps.name, sizeof(ar->wps.name), "%s WPS Button",
1373                  wiphy_name(ar->hw->wiphy));
1374
1375         snprintf(ar->wps.phys, sizeof(ar->wps.phys),
1376                  "ieee80211/%s/input0", wiphy_name(ar->hw->wiphy));
1377
1378         input->name = ar->wps.name;
1379         input->phys = ar->wps.phys;
1380         input->id.bustype = BUS_USB;
1381         input->dev.parent = &ar->hw->wiphy->dev;
1382
1383         input_set_capability(input, EV_KEY, KEY_WPS_BUTTON);
1384
1385         err = input_register_device(input);
1386         if (err) {
1387                 input_free_device(input);
1388                 return err;
1389         }
1390
1391         ar->wps.pbc = input;
1392         return 0;
1393 }
1394 #endif /* CONFIG_CARL9170_WPC */
1395
1396 static int carl9170_op_get_survey(struct ieee80211_hw *hw, int idx,
1397                                 struct survey_info *survey)
1398 {
1399         struct ar9170 *ar = hw->priv;
1400         int err;
1401
1402         if (idx != 0)
1403                 return -ENOENT;
1404
1405         mutex_lock(&ar->mutex);
1406         err = carl9170_get_noisefloor(ar);
1407         mutex_unlock(&ar->mutex);
1408         if (err)
1409                 return err;
1410
1411         survey->channel = ar->channel;
1412         survey->filled = SURVEY_INFO_NOISE_DBM;
1413         survey->noise = ar->noise[0];
1414         return 0;
1415 }
1416
1417 static void carl9170_op_flush(struct ieee80211_hw *hw, bool drop)
1418 {
1419         struct ar9170 *ar = hw->priv;
1420         unsigned int vid;
1421
1422         mutex_lock(&ar->mutex);
1423         for_each_set_bit(vid, &ar->vif_bitmap, ar->fw.vif_num)
1424                 carl9170_flush_cab(ar, vid);
1425
1426         carl9170_flush(ar, drop);
1427         mutex_unlock(&ar->mutex);
1428 }
1429
1430 static int carl9170_op_get_stats(struct ieee80211_hw *hw,
1431                                  struct ieee80211_low_level_stats *stats)
1432 {
1433         struct ar9170 *ar = hw->priv;
1434
1435         memset(stats, 0, sizeof(*stats));
1436         stats->dot11ACKFailureCount = ar->tx_ack_failures;
1437         stats->dot11FCSErrorCount = ar->tx_fcs_errors;
1438         return 0;
1439 }
1440
1441 static void carl9170_op_sta_notify(struct ieee80211_hw *hw,
1442                                    struct ieee80211_vif *vif,
1443                                    enum sta_notify_cmd cmd,
1444                                    struct ieee80211_sta *sta)
1445 {
1446         struct ar9170 *ar = hw->priv;
1447         struct carl9170_sta_info *sta_info = (void *) sta->drv_priv;
1448         struct sk_buff *skb, *tmp;
1449         struct sk_buff_head free;
1450         int i;
1451
1452         switch (cmd) {
1453         case STA_NOTIFY_SLEEP:
1454                 /*
1455                  * Since the peer is no longer listening, we have to return
1456                  * as many SKBs as possible back to the mac80211 stack.
1457                  * It will deal with the retry procedure, once the peer
1458                  * has become available again.
1459                  *
1460                  * NB: Ideally, the driver should return the all frames in
1461                  * the correct, ascending order. However, I think that this
1462                  * functionality should be implemented in the stack and not
1463                  * here...
1464                  */
1465
1466                 __skb_queue_head_init(&free);
1467
1468                 if (sta->ht_cap.ht_supported) {
1469                         rcu_read_lock();
1470                         for (i = 0; i < CARL9170_NUM_TID; i++) {
1471                                 struct carl9170_sta_tid *tid_info;
1472
1473                                 tid_info = rcu_dereference(sta_info->agg[i]);
1474
1475                                 if (!tid_info)
1476                                         continue;
1477
1478                                 spin_lock_bh(&ar->tx_ampdu_list_lock);
1479                                 if (tid_info->state >
1480                                     CARL9170_TID_STATE_SUSPEND)
1481                                         tid_info->state =
1482                                                 CARL9170_TID_STATE_SUSPEND;
1483                                 spin_unlock_bh(&ar->tx_ampdu_list_lock);
1484
1485                                 spin_lock_bh(&tid_info->lock);
1486                                 while ((skb = __skb_dequeue(&tid_info->queue)))
1487                                         __skb_queue_tail(&free, skb);
1488                                 spin_unlock_bh(&tid_info->lock);
1489                         }
1490                         rcu_read_unlock();
1491                 }
1492
1493                 for (i = 0; i < ar->hw->queues; i++) {
1494                         spin_lock_bh(&ar->tx_pending[i].lock);
1495                         skb_queue_walk_safe(&ar->tx_pending[i], skb, tmp) {
1496                                 struct _carl9170_tx_superframe *super;
1497                                 struct ieee80211_hdr *hdr;
1498                                 struct ieee80211_tx_info *info;
1499
1500                                 super = (void *) skb->data;
1501                                 hdr = (void *) super->frame_data;
1502
1503                                 if (compare_ether_addr(hdr->addr1, sta->addr))
1504                                         continue;
1505
1506                                 __skb_unlink(skb, &ar->tx_pending[i]);
1507
1508                                 info = IEEE80211_SKB_CB(skb);
1509                                 if (info->flags & IEEE80211_TX_CTL_AMPDU)
1510                                         atomic_dec(&ar->tx_ampdu_upload);
1511
1512                                 carl9170_tx_status(ar, skb, false);
1513                         }
1514                         spin_unlock_bh(&ar->tx_pending[i].lock);
1515                 }
1516
1517                 while ((skb = __skb_dequeue(&free)))
1518                         carl9170_tx_status(ar, skb, false);
1519
1520                 break;
1521
1522         case STA_NOTIFY_AWAKE:
1523                 if (!sta->ht_cap.ht_supported)
1524                         return;
1525
1526                 rcu_read_lock();
1527                 for (i = 0; i < CARL9170_NUM_TID; i++) {
1528                         struct carl9170_sta_tid *tid_info;
1529
1530                         tid_info = rcu_dereference(sta_info->agg[i]);
1531
1532                         if (!tid_info)
1533                                 continue;
1534
1535                         if ((tid_info->state == CARL9170_TID_STATE_SUSPEND))
1536                                 tid_info->state = CARL9170_TID_STATE_IDLE;
1537                 }
1538                 rcu_read_unlock();
1539                 break;
1540         }
1541 }
1542
1543 static const struct ieee80211_ops carl9170_ops = {
1544         .start                  = carl9170_op_start,
1545         .stop                   = carl9170_op_stop,
1546         .tx                     = carl9170_op_tx,
1547         .flush                  = carl9170_op_flush,
1548         .add_interface          = carl9170_op_add_interface,
1549         .remove_interface       = carl9170_op_remove_interface,
1550         .config                 = carl9170_op_config,
1551         .prepare_multicast      = carl9170_op_prepare_multicast,
1552         .configure_filter       = carl9170_op_configure_filter,
1553         .conf_tx                = carl9170_op_conf_tx,
1554         .bss_info_changed       = carl9170_op_bss_info_changed,
1555         .get_tsf                = carl9170_op_get_tsf,
1556         .set_key                = carl9170_op_set_key,
1557         .sta_add                = carl9170_op_sta_add,
1558         .sta_remove             = carl9170_op_sta_remove,
1559         .sta_notify             = carl9170_op_sta_notify,
1560         .get_survey             = carl9170_op_get_survey,
1561         .get_stats              = carl9170_op_get_stats,
1562         .ampdu_action           = carl9170_op_ampdu_action,
1563 };
1564
1565 void *carl9170_alloc(size_t priv_size)
1566 {
1567         struct ieee80211_hw *hw;
1568         struct ar9170 *ar;
1569         struct sk_buff *skb;
1570         int i;
1571
1572         /*
1573          * this buffer is used for rx stream reconstruction.
1574          * Under heavy load this device (or the transport layer?)
1575          * tends to split the streams into separate rx descriptors.
1576          */
1577
1578         skb = __dev_alloc_skb(AR9170_RX_STREAM_MAX_SIZE, GFP_KERNEL);
1579         if (!skb)
1580                 goto err_nomem;
1581
1582         hw = ieee80211_alloc_hw(priv_size, &carl9170_ops);
1583         if (!hw)
1584                 goto err_nomem;
1585
1586         ar = hw->priv;
1587         ar->hw = hw;
1588         ar->rx_failover = skb;
1589
1590         memset(&ar->rx_plcp, 0, sizeof(struct ar9170_rx_head));
1591         ar->rx_has_plcp = false;
1592
1593         /*
1594          * Here's a hidden pitfall!
1595          *
1596          * All 4 AC queues work perfectly well under _legacy_ operation.
1597          * However as soon as aggregation is enabled, the traffic flow
1598          * gets very bumpy. Therefore we have to _switch_ to a
1599          * software AC with a single HW queue.
1600          */
1601         hw->queues = __AR9170_NUM_TXQ;
1602
1603         mutex_init(&ar->mutex);
1604         spin_lock_init(&ar->beacon_lock);
1605         spin_lock_init(&ar->cmd_lock);
1606         spin_lock_init(&ar->tx_stats_lock);
1607         spin_lock_init(&ar->tx_ampdu_list_lock);
1608         spin_lock_init(&ar->mem_lock);
1609         spin_lock_init(&ar->state_lock);
1610         atomic_set(&ar->pending_restarts, 0);
1611         ar->vifs = 0;
1612         for (i = 0; i < ar->hw->queues; i++) {
1613                 skb_queue_head_init(&ar->tx_status[i]);
1614                 skb_queue_head_init(&ar->tx_pending[i]);
1615         }
1616         INIT_WORK(&ar->ps_work, carl9170_ps_work);
1617         INIT_WORK(&ar->restart_work, carl9170_restart_work);
1618         INIT_WORK(&ar->ampdu_work, carl9170_ampdu_work);
1619         INIT_DELAYED_WORK(&ar->tx_janitor, carl9170_tx_janitor);
1620         INIT_LIST_HEAD(&ar->tx_ampdu_list);
1621         rcu_assign_pointer(ar->tx_ampdu_iter,
1622                            (struct carl9170_sta_tid *) &ar->tx_ampdu_list);
1623
1624         bitmap_zero(&ar->vif_bitmap, ar->fw.vif_num);
1625         INIT_LIST_HEAD(&ar->vif_list);
1626         init_completion(&ar->tx_flush);
1627
1628         /*
1629          * Note:
1630          * IBSS/ADHOC and AP mode are only enabled, if the firmware
1631          * supports these modes. The code which will add the
1632          * additional interface_modes is in fw.c.
1633          */
1634         hw->wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION);
1635
1636         hw->flags |= IEEE80211_HW_RX_INCLUDES_FCS |
1637                      IEEE80211_HW_REPORTS_TX_ACK_STATUS |
1638                      IEEE80211_HW_SUPPORTS_PS |
1639                      IEEE80211_HW_PS_NULLFUNC_STACK |
1640                      IEEE80211_HW_SIGNAL_DBM;
1641
1642         if (!modparam_noht) {
1643                 /*
1644                  * see the comment above, why we allow the user
1645                  * to disable HT by a module parameter.
1646                  */
1647                 hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
1648         }
1649
1650         hw->extra_tx_headroom = sizeof(struct _carl9170_tx_superframe);
1651         hw->sta_data_size = sizeof(struct carl9170_sta_info);
1652         hw->vif_data_size = sizeof(struct carl9170_vif_info);
1653
1654         hw->max_rates = CARL9170_TX_MAX_RATES;
1655         hw->max_rate_tries = CARL9170_TX_USER_RATE_TRIES;
1656
1657         for (i = 0; i < ARRAY_SIZE(ar->noise); i++)
1658                 ar->noise[i] = -95; /* ATH_DEFAULT_NOISE_FLOOR */
1659
1660         hw->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
1661         return ar;
1662
1663 err_nomem:
1664         kfree_skb(skb);
1665         return ERR_PTR(-ENOMEM);
1666 }
1667
1668 static int carl9170_read_eeprom(struct ar9170 *ar)
1669 {
1670 #define RW      8       /* number of words to read at once */
1671 #define RB      (sizeof(u32) * RW)
1672         u8 *eeprom = (void *)&ar->eeprom;
1673         __le32 offsets[RW];
1674         int i, j, err;
1675
1676         BUILD_BUG_ON(sizeof(ar->eeprom) & 3);
1677
1678         BUILD_BUG_ON(RB > CARL9170_MAX_CMD_LEN - 4);
1679 #ifndef __CHECKER__
1680         /* don't want to handle trailing remains */
1681         BUILD_BUG_ON(sizeof(ar->eeprom) % RB);
1682 #endif
1683
1684         for (i = 0; i < sizeof(ar->eeprom)/RB; i++) {
1685                 for (j = 0; j < RW; j++)
1686                         offsets[j] = cpu_to_le32(AR9170_EEPROM_START +
1687                                                  RB * i + 4 * j);
1688
1689                 err = carl9170_exec_cmd(ar, CARL9170_CMD_RREG,
1690                                         RB, (u8 *) &offsets,
1691                                         RB, eeprom + RB * i);
1692                 if (err)
1693                         return err;
1694         }
1695
1696 #undef RW
1697 #undef RB
1698         return 0;
1699 }
1700
1701 static int carl9170_parse_eeprom(struct ar9170 *ar)
1702 {
1703         struct ath_regulatory *regulatory = &ar->common.regulatory;
1704         unsigned int rx_streams, tx_streams, tx_params = 0;
1705         int bands = 0;
1706
1707         if (ar->eeprom.length == cpu_to_le16(0xffff))
1708                 return -ENODATA;
1709
1710         rx_streams = hweight8(ar->eeprom.rx_mask);
1711         tx_streams = hweight8(ar->eeprom.tx_mask);
1712
1713         if (rx_streams != tx_streams) {
1714                 tx_params = IEEE80211_HT_MCS_TX_RX_DIFF;
1715
1716                 WARN_ON(!(tx_streams >= 1 && tx_streams <=
1717                         IEEE80211_HT_MCS_TX_MAX_STREAMS));
1718
1719                 tx_params = (tx_streams - 1) <<
1720                             IEEE80211_HT_MCS_TX_MAX_STREAMS_SHIFT;
1721
1722                 carl9170_band_2GHz.ht_cap.mcs.tx_params |= tx_params;
1723                 carl9170_band_5GHz.ht_cap.mcs.tx_params |= tx_params;
1724         }
1725
1726         if (ar->eeprom.operating_flags & AR9170_OPFLAG_2GHZ) {
1727                 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] =
1728                         &carl9170_band_2GHz;
1729                 bands++;
1730         }
1731         if (ar->eeprom.operating_flags & AR9170_OPFLAG_5GHZ) {
1732                 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] =
1733                         &carl9170_band_5GHz;
1734                 bands++;
1735         }
1736
1737         /*
1738          * I measured this, a bandswitch takes roughly
1739          * 135 ms and a frequency switch about 80.
1740          *
1741          * FIXME: measure these values again once EEPROM settings
1742          *        are used, that will influence them!
1743          */
1744         if (bands == 2)
1745                 ar->hw->channel_change_time = 135 * 1000;
1746         else
1747                 ar->hw->channel_change_time = 80 * 1000;
1748
1749         regulatory->current_rd = le16_to_cpu(ar->eeprom.reg_domain[0]);
1750         regulatory->current_rd_ext = le16_to_cpu(ar->eeprom.reg_domain[1]);
1751
1752         /* second part of wiphy init */
1753         SET_IEEE80211_PERM_ADDR(ar->hw, ar->eeprom.mac_address);
1754
1755         return bands ? 0 : -EINVAL;
1756 }
1757
1758 static int carl9170_reg_notifier(struct wiphy *wiphy,
1759                                  struct regulatory_request *request)
1760 {
1761         struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1762         struct ar9170 *ar = hw->priv;
1763
1764         return ath_reg_notifier_apply(wiphy, request, &ar->common.regulatory);
1765 }
1766
1767 int carl9170_register(struct ar9170 *ar)
1768 {
1769         struct ath_regulatory *regulatory = &ar->common.regulatory;
1770         int err = 0, i;
1771
1772         if (WARN_ON(ar->mem_bitmap))
1773                 return -EINVAL;
1774
1775         ar->mem_bitmap = kzalloc(roundup(ar->fw.mem_blocks, BITS_PER_LONG) *
1776                                  sizeof(unsigned long), GFP_KERNEL);
1777
1778         if (!ar->mem_bitmap)
1779                 return -ENOMEM;
1780
1781         /* try to read EEPROM, init MAC addr */
1782         err = carl9170_read_eeprom(ar);
1783         if (err)
1784                 return err;
1785
1786         err = carl9170_fw_fix_eeprom(ar);
1787         if (err)
1788                 return err;
1789
1790         err = carl9170_parse_eeprom(ar);
1791         if (err)
1792                 return err;
1793
1794         err = ath_regd_init(regulatory, ar->hw->wiphy,
1795                             carl9170_reg_notifier);
1796         if (err)
1797                 return err;
1798
1799         if (modparam_noht) {
1800                 carl9170_band_2GHz.ht_cap.ht_supported = false;
1801                 carl9170_band_5GHz.ht_cap.ht_supported = false;
1802         }
1803
1804         for (i = 0; i < ar->fw.vif_num; i++) {
1805                 ar->vif_priv[i].id = i;
1806                 ar->vif_priv[i].vif = NULL;
1807         }
1808
1809         err = ieee80211_register_hw(ar->hw);
1810         if (err)
1811                 return err;
1812
1813         /* mac80211 interface is now registered */
1814         ar->registered = true;
1815
1816         if (!ath_is_world_regd(regulatory))
1817                 regulatory_hint(ar->hw->wiphy, regulatory->alpha2);
1818
1819 #ifdef CONFIG_CARL9170_DEBUGFS
1820         carl9170_debugfs_register(ar);
1821 #endif /* CONFIG_CARL9170_DEBUGFS */
1822
1823         err = carl9170_led_init(ar);
1824         if (err)
1825                 goto err_unreg;
1826
1827 #ifdef CONFIG_CARL9170_LEDS
1828         err = carl9170_led_register(ar);
1829         if (err)
1830                 goto err_unreg;
1831 #endif /* CONFIG_CAR9L170_LEDS */
1832
1833 #ifdef CONFIG_CARL9170_WPC
1834         err = carl9170_register_wps_button(ar);
1835         if (err)
1836                 goto err_unreg;
1837 #endif /* CONFIG_CARL9170_WPC */
1838
1839         dev_info(&ar->udev->dev, "Atheros AR9170 is registered as '%s'\n",
1840                  wiphy_name(ar->hw->wiphy));
1841
1842         return 0;
1843
1844 err_unreg:
1845         carl9170_unregister(ar);
1846         return err;
1847 }
1848
1849 void carl9170_unregister(struct ar9170 *ar)
1850 {
1851         if (!ar->registered)
1852                 return;
1853
1854         ar->registered = false;
1855
1856 #ifdef CONFIG_CARL9170_LEDS
1857         carl9170_led_unregister(ar);
1858 #endif /* CONFIG_CARL9170_LEDS */
1859
1860 #ifdef CONFIG_CARL9170_DEBUGFS
1861         carl9170_debugfs_unregister(ar);
1862 #endif /* CONFIG_CARL9170_DEBUGFS */
1863
1864 #ifdef CONFIG_CARL9170_WPC
1865         if (ar->wps.pbc) {
1866                 input_unregister_device(ar->wps.pbc);
1867                 ar->wps.pbc = NULL;
1868         }
1869 #endif /* CONFIG_CARL9170_WPC */
1870
1871         carl9170_cancel_worker(ar);
1872         cancel_work_sync(&ar->restart_work);
1873
1874         ieee80211_unregister_hw(ar->hw);
1875 }
1876
1877 void carl9170_free(struct ar9170 *ar)
1878 {
1879         WARN_ON(ar->registered);
1880         WARN_ON(IS_INITIALIZED(ar));
1881
1882         kfree_skb(ar->rx_failover);
1883         ar->rx_failover = NULL;
1884
1885         kfree(ar->mem_bitmap);
1886         ar->mem_bitmap = NULL;
1887
1888         mutex_destroy(&ar->mutex);
1889
1890         ieee80211_free_hw(ar->hw);
1891 }