drivers/net/wireless/ath/ath9k/main.c

   1 /*
   2  * Copyright (c) 2008-2011 Atheros Communications Inc.
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/nl80211.h>
  18 #include <linux/delay.h>
  19 #include "ath9k.h"
  20 #include "btcoex.h"
  21
  22 static void ath9k_set_assoc_state(struct ath_softc *sc,
  23                                   struct ieee80211_vif *vif);
  24
  25 u8 ath9k_parse_mpdudensity(u8 mpdudensity)
  26 {
  27         /*
  28          * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
  29          *   0 for no restriction
  30          *   1 for 1/4 us
  31          *   2 for 1/2 us
  32          *   3 for 1 us
  33          *   4 for 2 us
  34          *   5 for 4 us
  35          *   6 for 8 us
  36          *   7 for 16 us
  37          */
  38         switch (mpdudensity) {
  39         case 0:
  40                 return 0;
  41         case 1:
  42         case 2:
  43         case 3:
  44                 /* Our lower layer calculations limit our precision to
  45                    1 microsecond */
  46                 return 1;
  47         case 4:
  48                 return 2;
  49         case 5:
  50                 return 4;
  51         case 6:
  52                 return 8;
  53         case 7:
  54                 return 16;
  55         default:
  56                 return 0;
  57         }
  58 }
  59
  60 static bool ath9k_has_pending_frames(struct ath_softc *sc, struct ath_txq *txq)
  61 {
  62         bool pending = false;
  63
  64         spin_lock_bh(&txq->axq_lock);
  65
  66         if (txq->axq_depth || !list_empty(&txq->axq_acq))
  67                 pending = true;
  68
  69         spin_unlock_bh(&txq->axq_lock);
  70         return pending;
  71 }
  72
  73 static bool ath9k_setpower(struct ath_softc *sc, enum ath9k_power_mode mode)
  74 {
  75         unsigned long flags;
  76         bool ret;
  77
  78         spin_lock_irqsave(&sc->sc_pm_lock, flags);
  79         ret = ath9k_hw_setpower(sc->sc_ah, mode);
  80         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
  81
  82         return ret;
  83 }
  84
  85 void ath9k_ps_wakeup(struct ath_softc *sc)
  86 {
  87         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
  88         unsigned long flags;
  89         enum ath9k_power_mode power_mode;
  90
  91         spin_lock_irqsave(&sc->sc_pm_lock, flags);
  92         if (++sc->ps_usecount != 1)
  93                 goto unlock;
  94
  95         power_mode = sc->sc_ah->power_mode;
  96         ath9k_hw_setpower(sc->sc_ah, ATH9K_PM_AWAKE);
  97
  98         /*
  99          * While the hardware is asleep, the cycle counters contain no
 100          * useful data. Better clear them now so that they don't mess up
 101          * survey data results.
 102          */
 103         if (power_mode != ATH9K_PM_AWAKE) {
 104                 spin_lock(&common->cc_lock);
 105                 ath_hw_cycle_counters_update(common);
 106                 memset(&common->cc_survey, 0, sizeof(common->cc_survey));
 107                 memset(&common->cc_ani, 0, sizeof(common->cc_ani));
 108                 spin_unlock(&common->cc_lock);
 109         }
 110
 111  unlock:
 112         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 113 }
 114
 115 void ath9k_ps_restore(struct ath_softc *sc)
 116 {
 117         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 118         enum ath9k_power_mode mode;
 119         unsigned long flags;
 120         bool reset;
 121
 122         spin_lock_irqsave(&sc->sc_pm_lock, flags);
 123         if (--sc->ps_usecount != 0)
 124                 goto unlock;
 125
 126         if (sc->ps_idle) {
 127                 ath9k_hw_setrxabort(sc->sc_ah, 1);
 128                 ath9k_hw_stopdmarecv(sc->sc_ah, &reset);
 129                 mode = ATH9K_PM_FULL_SLEEP;
 130         } else if (sc->ps_enabled &&
 131                    !(sc->ps_flags & (PS_WAIT_FOR_BEACON |
 132                                      PS_WAIT_FOR_CAB |
 133                                      PS_WAIT_FOR_PSPOLL_DATA |
 134                                      PS_WAIT_FOR_TX_ACK |
 135                                      PS_WAIT_FOR_ANI))) {
 136                 mode = ATH9K_PM_NETWORK_SLEEP;
 137                 if (ath9k_hw_btcoex_is_enabled(sc->sc_ah))
 138                         ath9k_btcoex_stop_gen_timer(sc);
 139         } else {
 140                 goto unlock;
 141         }
 142
 143         spin_lock(&common->cc_lock);
 144         ath_hw_cycle_counters_update(common);
 145         spin_unlock(&common->cc_lock);
 146
 147         ath9k_hw_setpower(sc->sc_ah, mode);
 148
 149  unlock:
 150         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 151 }
 152
 153 static void __ath_cancel_work(struct ath_softc *sc)
 154 {
 155         cancel_work_sync(&sc->paprd_work);
 156         cancel_work_sync(&sc->hw_check_work);
 157         cancel_delayed_work_sync(&sc->tx_complete_work);
 158         cancel_delayed_work_sync(&sc->hw_pll_work);
 159
 160 #ifdef CONFIG_ATH9K_BTCOEX_SUPPORT
 161         if (ath9k_hw_mci_is_enabled(sc->sc_ah))
 162                 cancel_work_sync(&sc->mci_work);
 163 #endif
 164 }
 165
 166 static void ath_cancel_work(struct ath_softc *sc)
 167 {
 168         __ath_cancel_work(sc);
 169         cancel_work_sync(&sc->hw_reset_work);
 170 }
 171
 172 static void ath_restart_work(struct ath_softc *sc)
 173 {
 174         ieee80211_queue_delayed_work(sc->hw, &sc->tx_complete_work, 0);
 175
 176         if (AR_SREV_9340(sc->sc_ah) || AR_SREV_9485(sc->sc_ah) ||
 177             AR_SREV_9550(sc->sc_ah))
 178                 ieee80211_queue_delayed_work(sc->hw, &sc->hw_pll_work,
 179                                      msecs_to_jiffies(ATH_PLL_WORK_INTERVAL));
 180
 181         ath_start_rx_poll(sc, 3);
 182         ath_start_ani(sc);
 183 }
 184
 185 static bool ath_prepare_reset(struct ath_softc *sc, bool retry_tx)
 186 {
 187         struct ath_hw *ah = sc->sc_ah;
 188         bool ret = true;
 189
 190         ieee80211_stop_queues(sc->hw);
 191
 192         sc->hw_busy_count = 0;
 193         ath_stop_ani(sc);
 194         del_timer_sync(&sc->rx_poll_timer);
 195
 196         ath9k_debug_samp_bb_mac(sc);
 197         ath9k_hw_disable_interrupts(ah);
 198
 199         tasklet_disable(&sc->intr_tq);
 200
 201         if (!ath_stoprecv(sc))
 202                 ret = false;
 203
 204         if (!ath_drain_all_txq(sc, retry_tx))
 205                 ret = false;
 206
 207         tasklet_enable(&sc->intr_tq);
 208
 209         return ret;
 210 }
 211
 212 static bool ath_complete_reset(struct ath_softc *sc, bool start)
 213 {
 214         struct ath_hw *ah = sc->sc_ah;
 215         struct ath_common *common = ath9k_hw_common(ah);
 216         unsigned long flags;
 217
 218         if (ath_startrecv(sc) != 0) {
 219                 ath_err(common, "Unable to restart recv logic\n");
 220                 return false;
 221         }
 222
 223         ath9k_cmn_update_txpow(ah, sc->curtxpow,
 224                                sc->config.txpowlimit, &sc->curtxpow);
 225
 226         clear_bit(SC_OP_HW_RESET, &sc->sc_flags);
 227         ath9k_hw_set_interrupts(ah);
 228         ath9k_hw_enable_interrupts(ah);
 229
 230         if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) && start) {
 231                 if (!test_bit(SC_OP_BEACONS, &sc->sc_flags))
 232                         goto work;
 233
 234                 ath9k_set_beacon(sc);
 235
 236                 if (ah->opmode == NL80211_IFTYPE_STATION &&
 237                     test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
 238                         spin_lock_irqsave(&sc->sc_pm_lock, flags);
 239                         sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
 240                         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 241                 }
 242         work:
 243                 ath_restart_work(sc);
 244         }
 245
 246         if ((ah->caps.hw_caps & ATH9K_HW_CAP_ANT_DIV_COMB) && sc->ant_rx != 3)
 247                 ath_ant_comb_update(sc);
 248
 249         ieee80211_wake_queues(sc->hw);
 250
 251         return true;
 252 }
 253
 254 static int ath_reset_internal(struct ath_softc *sc, struct ath9k_channel *hchan,
 255                               bool retry_tx)
 256 {
 257         struct ath_hw *ah = sc->sc_ah;
 258         struct ath_common *common = ath9k_hw_common(ah);
 259         struct ath9k_hw_cal_data *caldata = NULL;
 260         bool fastcc = true;
 261         int r;
 262
 263         __ath_cancel_work(sc);
 264
 265         spin_lock_bh(&sc->sc_pcu_lock);
 266
 267         if (!(sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)) {
 268                 fastcc = false;
 269                 caldata = &sc->caldata;
 270         }
 271
 272         if (!hchan) {
 273                 fastcc = false;
 274                 hchan = ah->curchan;
 275         }
 276
 277         if (!ath_prepare_reset(sc, retry_tx))
 278                 fastcc = false;
 279
 280         ath_dbg(common, CONFIG, "Reset to %u MHz, HT40: %d fastcc: %d\n",
 281                 hchan->channel, IS_CHAN_HT40(hchan), fastcc);
 282
 283         r = ath9k_hw_reset(ah, hchan, caldata, fastcc);
 284         if (r) {
 285                 ath_err(common,
 286                         "Unable to reset channel, reset status %d\n", r);
 287                 goto out;
 288         }
 289
 290         if (ath9k_hw_mci_is_enabled(sc->sc_ah) &&
 291             (sc->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL))
 292                 ath9k_mci_set_txpower(sc, true, false);
 293
 294         if (!ath_complete_reset(sc, true))
 295                 r = -EIO;
 296
 297 out:
 298         spin_unlock_bh(&sc->sc_pcu_lock);
 299         return r;
 300 }
 301
 302
 303 /*
 304  * Set/change channels.  If the channel is really being changed, it's done
 305  * by reseting the chip.  To accomplish this we must first cleanup any pending
 306  * DMA, then restart stuff.
 307 */
 308 static int ath_set_channel(struct ath_softc *sc, struct ieee80211_hw *hw,
 309                     struct ath9k_channel *hchan)
 310 {
 311         int r;
 312
 313         if (test_bit(SC_OP_INVALID, &sc->sc_flags))
 314                 return -EIO;
 315
 316         r = ath_reset_internal(sc, hchan, false);
 317
 318         return r;
 319 }
 320
 321 static void ath_node_attach(struct ath_softc *sc, struct ieee80211_sta *sta,
 322                             struct ieee80211_vif *vif)
 323 {
 324         struct ath_node *an;
 325         u8 density;
 326         an = (struct ath_node *)sta->drv_priv;
 327
 328         an->sc = sc;
 329         an->sta = sta;
 330         an->vif = vif;
 331
 332         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT) {
 333                 ath_tx_node_init(sc, an);
 334                 an->maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 335                                      sta->ht_cap.ampdu_factor);
 336                 density = ath9k_parse_mpdudensity(sta->ht_cap.ampdu_density);
 337                 an->mpdudensity = density;
 338         }
 339 }
 340
 341 static void ath_node_detach(struct ath_softc *sc, struct ieee80211_sta *sta)
 342 {
 343         struct ath_node *an = (struct ath_node *)sta->drv_priv;
 344
 345         if (sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_HT)
 346                 ath_tx_node_cleanup(sc, an);
 347 }
 348
 349 void ath9k_tasklet(unsigned long data)
 350 {
 351         struct ath_softc *sc = (struct ath_softc *)data;
 352         struct ath_hw *ah = sc->sc_ah;
 353         struct ath_common *common = ath9k_hw_common(ah);
 354         enum ath_reset_type type;
 355         unsigned long flags;
 356         u32 status = sc->intrstatus;
 357         u32 rxmask;
 358
 359         ath9k_ps_wakeup(sc);
 360         spin_lock(&sc->sc_pcu_lock);
 361
 362         if ((status & ATH9K_INT_FATAL) ||
 363             (status & ATH9K_INT_BB_WATCHDOG)) {
 364
 365                 if (status & ATH9K_INT_FATAL)
 366                         type = RESET_TYPE_FATAL_INT;
 367                 else
 368                         type = RESET_TYPE_BB_WATCHDOG;
 369
 370                 ath9k_queue_reset(sc, type);
 371                 goto out;
 372         }
 373
 374         spin_lock_irqsave(&sc->sc_pm_lock, flags);
 375         if ((status & ATH9K_INT_TSFOOR) && sc->ps_enabled) {
 376                 /*
 377                  * TSF sync does not look correct; remain awake to sync with
 378                  * the next Beacon.
 379                  */
 380                 ath_dbg(common, PS, "TSFOOR - Sync with next Beacon\n");
 381                 sc->ps_flags |= PS_WAIT_FOR_BEACON | PS_BEACON_SYNC;
 382         }
 383         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 384
 385         if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
 386                 rxmask = (ATH9K_INT_RXHP | ATH9K_INT_RXLP | ATH9K_INT_RXEOL |
 387                           ATH9K_INT_RXORN);
 388         else
 389                 rxmask = (ATH9K_INT_RX | ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
 390
 391         if (status & rxmask) {
 392                 /* Check for high priority Rx first */
 393                 if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
 394                     (status & ATH9K_INT_RXHP))
 395                         ath_rx_tasklet(sc, 0, true);
 396
 397                 ath_rx_tasklet(sc, 0, false);
 398         }
 399
 400         if (status & ATH9K_INT_TX) {
 401                 if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
 402                         ath_tx_edma_tasklet(sc);
 403                 else
 404                         ath_tx_tasklet(sc);
 405         }
 406
 407         ath9k_btcoex_handle_interrupt(sc, status);
 408
 409 out:
 410         /* re-enable hardware interrupt */
 411         ath9k_hw_enable_interrupts(ah);
 412
 413         spin_unlock(&sc->sc_pcu_lock);
 414         ath9k_ps_restore(sc);
 415 }
 416
 417 irqreturn_t ath_isr(int irq, void *dev)
 418 {
 419 #define SCHED_INTR (                            \
 420                 ATH9K_INT_FATAL |               \
 421                 ATH9K_INT_BB_WATCHDOG |         \
 422                 ATH9K_INT_RXORN |               \
 423                 ATH9K_INT_RXEOL |               \
 424                 ATH9K_INT_RX |                  \
 425                 ATH9K_INT_RXLP |                \
 426                 ATH9K_INT_RXHP |                \
 427                 ATH9K_INT_TX |                  \
 428                 ATH9K_INT_BMISS |               \
 429                 ATH9K_INT_CST |                 \
 430                 ATH9K_INT_TSFOOR |              \
 431                 ATH9K_INT_GENTIMER |            \
 432                 ATH9K_INT_MCI)
 433
 434         struct ath_softc *sc = dev;
 435         struct ath_hw *ah = sc->sc_ah;
 436         struct ath_common *common = ath9k_hw_common(ah);
 437         enum ath9k_int status;
 438         bool sched = false;
 439
 440         /*
 441          * The hardware is not ready/present, don't
 442          * touch anything. Note this can happen early
 443          * on if the IRQ is shared.
 444          */
 445         if (test_bit(SC_OP_INVALID, &sc->sc_flags))
 446                 return IRQ_NONE;
 447
 448         /* shared irq, not for us */
 449
 450         if (!ath9k_hw_intrpend(ah))
 451                 return IRQ_NONE;
 452
 453         if (test_bit(SC_OP_HW_RESET, &sc->sc_flags)) {
 454                 ath9k_hw_kill_interrupts(ah);
 455                 return IRQ_HANDLED;
 456         }
 457
 458         /*
 459          * Figure out the reason(s) for the interrupt.  Note
 460          * that the hal returns a pseudo-ISR that may include
 461          * bits we haven't explicitly enabled so we mask the
 462          * value to insure we only process bits we requested.
 463          */
 464         ath9k_hw_getisr(ah, &status);   /* NB: clears ISR too */
 465         status &= ah->imask;    /* discard unasked-for bits */
 466
 467         /*
 468          * If there are no status bits set, then this interrupt was not
 469          * for me (should have been caught above).
 470          */
 471         if (!status)
 472                 return IRQ_NONE;
 473
 474         /* Cache the status */
 475         sc->intrstatus = status;
 476
 477         if (status & SCHED_INTR)
 478                 sched = true;
 479
 480         /*
 481          * If a FATAL or RXORN interrupt is received, we have to reset the
 482          * chip immediately.
 483          */
 484         if ((status & ATH9K_INT_FATAL) || ((status & ATH9K_INT_RXORN) &&
 485             !(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)))
 486                 goto chip_reset;
 487
 488         if ((ah->caps.hw_caps & ATH9K_HW_CAP_EDMA) &&
 489             (status & ATH9K_INT_BB_WATCHDOG)) {
 490
 491                 spin_lock(&common->cc_lock);
 492                 ath_hw_cycle_counters_update(common);
 493                 ar9003_hw_bb_watchdog_dbg_info(ah);
 494                 spin_unlock(&common->cc_lock);
 495
 496                 goto chip_reset;
 497         }
 498 #ifdef CONFIG_PM_SLEEP
 499         if (status & ATH9K_INT_BMISS) {
 500                 if (atomic_read(&sc->wow_sleep_proc_intr) == 0) {
 501                         ath_dbg(common, ANY, "during WoW we got a BMISS\n");
 502                         atomic_inc(&sc->wow_got_bmiss_intr);
 503                         atomic_dec(&sc->wow_sleep_proc_intr);
 504                 }
 505         }
 506 #endif
 507         if (status & ATH9K_INT_SWBA)
 508                 tasklet_schedule(&sc->bcon_tasklet);
 509
 510         if (status & ATH9K_INT_TXURN)
 511                 ath9k_hw_updatetxtriglevel(ah, true);
 512
 513         if (status & ATH9K_INT_RXEOL) {
 514                 ah->imask &= ~(ATH9K_INT_RXEOL | ATH9K_INT_RXORN);
 515                 ath9k_hw_set_interrupts(ah);
 516         }
 517
 518         if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
 519                 if (status & ATH9K_INT_TIM_TIMER) {
 520                         if (ATH_DBG_WARN_ON_ONCE(sc->ps_idle))
 521                                 goto chip_reset;
 522                         /* Clear RxAbort bit so that we can
 523                          * receive frames */
 524                         ath9k_setpower(sc, ATH9K_PM_AWAKE);
 525                         spin_lock(&sc->sc_pm_lock);
 526                         ath9k_hw_setrxabort(sc->sc_ah, 0);
 527                         sc->ps_flags |= PS_WAIT_FOR_BEACON;
 528                         spin_unlock(&sc->sc_pm_lock);
 529                 }
 530
 531 chip_reset:
 532
 533         ath_debug_stat_interrupt(sc, status);
 534
 535         if (sched) {
 536                 /* turn off every interrupt */
 537                 ath9k_hw_disable_interrupts(ah);
 538                 tasklet_schedule(&sc->intr_tq);
 539         }
 540
 541         return IRQ_HANDLED;
 542
 543 #undef SCHED_INTR
 544 }
 545
 546 static int ath_reset(struct ath_softc *sc, bool retry_tx)
 547 {
 548         int r;
 549
 550         ath9k_ps_wakeup(sc);
 551
 552         r = ath_reset_internal(sc, NULL, retry_tx);
 553
 554         if (retry_tx) {
 555                 int i;
 556                 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
 557                         if (ATH_TXQ_SETUP(sc, i)) {
 558                                 spin_lock_bh(&sc->tx.txq[i].axq_lock);
 559                                 ath_txq_schedule(sc, &sc->tx.txq[i]);
 560                                 spin_unlock_bh(&sc->tx.txq[i].axq_lock);
 561                         }
 562                 }
 563         }
 564
 565         ath9k_ps_restore(sc);
 566
 567         return r;
 568 }
 569
 570 void ath9k_queue_reset(struct ath_softc *sc, enum ath_reset_type type)
 571 {
 572 #ifdef CONFIG_ATH9K_DEBUGFS
 573         RESET_STAT_INC(sc, type);
 574 #endif
 575         set_bit(SC_OP_HW_RESET, &sc->sc_flags);
 576         ieee80211_queue_work(sc->hw, &sc->hw_reset_work);
 577 }
 578
 579 void ath_reset_work(struct work_struct *work)
 580 {
 581         struct ath_softc *sc = container_of(work, struct ath_softc, hw_reset_work);
 582
 583         ath_reset(sc, true);
 584 }
 585
 586 /**********************/
 587 /* mac80211 callbacks */
 588 /**********************/
 589
 590 static int ath9k_start(struct ieee80211_hw *hw)
 591 {
 592         struct ath_softc *sc = hw->priv;
 593         struct ath_hw *ah = sc->sc_ah;
 594         struct ath_common *common = ath9k_hw_common(ah);
 595         struct ieee80211_channel *curchan = hw->conf.channel;
 596         struct ath9k_channel *init_channel;
 597         int r;
 598
 599         ath_dbg(common, CONFIG,
 600                 "Starting driver with initial channel: %d MHz\n",
 601                 curchan->center_freq);
 602
 603         ath9k_ps_wakeup(sc);
 604         mutex_lock(&sc->mutex);
 605
 606         init_channel = ath9k_cmn_get_curchannel(hw, ah);
 607
 608         /* Reset SERDES registers */
 609         ath9k_hw_configpcipowersave(ah, false);
 610
 611         /*
 612          * The basic interface to setting the hardware in a good
 613          * state is ``reset''.  On return the hardware is known to
 614          * be powered up and with interrupts disabled.  This must
 615          * be followed by initialization of the appropriate bits
 616          * and then setup of the interrupt mask.
 617          */
 618         spin_lock_bh(&sc->sc_pcu_lock);
 619
 620         atomic_set(&ah->intr_ref_cnt, -1);
 621
 622         r = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 623         if (r) {
 624                 ath_err(common,
 625                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
 626                         r, curchan->center_freq);
 627                 ah->reset_power_on = false;
 628         }
 629
 630         /* Setup our intr mask. */
 631         ah->imask = ATH9K_INT_TX | ATH9K_INT_RXEOL |
 632                     ATH9K_INT_RXORN | ATH9K_INT_FATAL |
 633                     ATH9K_INT_GLOBAL;
 634
 635         if (ah->caps.hw_caps & ATH9K_HW_CAP_EDMA)
 636                 ah->imask |= ATH9K_INT_RXHP |
 637                              ATH9K_INT_RXLP |
 638                              ATH9K_INT_BB_WATCHDOG;
 639         else
 640                 ah->imask |= ATH9K_INT_RX;
 641
 642         ah->imask |= ATH9K_INT_GTT;
 643
 644         if (ah->caps.hw_caps & ATH9K_HW_CAP_HT)
 645                 ah->imask |= ATH9K_INT_CST;
 646
 647         ath_mci_enable(sc);
 648
 649         clear_bit(SC_OP_INVALID, &sc->sc_flags);
 650         sc->sc_ah->is_monitoring = false;
 651
 652         if (!ath_complete_reset(sc, false))
 653                 ah->reset_power_on = false;
 654
 655         if (ah->led_pin >= 0) {
 656                 ath9k_hw_cfg_output(ah, ah->led_pin,
 657                                     AR_GPIO_OUTPUT_MUX_AS_OUTPUT);
 658                 ath9k_hw_set_gpio(ah, ah->led_pin, 0);
 659         }
 660
 661         /*
 662          * Reset key cache to sane defaults (all entries cleared) instead of
 663          * semi-random values after suspend/resume.
 664          */
 665         ath9k_cmn_init_crypto(sc->sc_ah);
 666
 667         spin_unlock_bh(&sc->sc_pcu_lock);
 668
 669         mutex_unlock(&sc->mutex);
 670
 671         ath9k_ps_restore(sc);
 672
 673         return 0;
 674 }
 675
 676 static void ath9k_tx(struct ieee80211_hw *hw,
 677                      struct ieee80211_tx_control *control,
 678                      struct sk_buff *skb)
 679 {
 680         struct ath_softc *sc = hw->priv;
 681         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 682         struct ath_tx_control txctl;
 683         struct ieee80211_hdr *hdr = (struct ieee80211_hdr *) skb->data;
 684         unsigned long flags;
 685
 686         if (sc->ps_enabled) {
 687                 /*
 688                  * mac80211 does not set PM field for normal data frames, so we
 689                  * need to update that based on the current PS mode.
 690                  */
 691                 if (ieee80211_is_data(hdr->frame_control) &&
 692                     !ieee80211_is_nullfunc(hdr->frame_control) &&
 693                     !ieee80211_has_pm(hdr->frame_control)) {
 694                         ath_dbg(common, PS,
 695                                 "Add PM=1 for a TX frame while in PS mode\n");
 696                         hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PM);
 697                 }
 698         }
 699
 700         if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_NETWORK_SLEEP)) {
 701                 /*
 702                  * We are using PS-Poll and mac80211 can request TX while in
 703                  * power save mode. Need to wake up hardware for the TX to be
 704                  * completed and if needed, also for RX of buffered frames.
 705                  */
 706                 ath9k_ps_wakeup(sc);
 707                 spin_lock_irqsave(&sc->sc_pm_lock, flags);
 708                 if (!(sc->sc_ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP))
 709                         ath9k_hw_setrxabort(sc->sc_ah, 0);
 710                 if (ieee80211_is_pspoll(hdr->frame_control)) {
 711                         ath_dbg(common, PS,
 712                                 "Sending PS-Poll to pick a buffered frame\n");
 713                         sc->ps_flags |= PS_WAIT_FOR_PSPOLL_DATA;
 714                 } else {
 715                         ath_dbg(common, PS, "Wake up to complete TX\n");
 716                         sc->ps_flags |= PS_WAIT_FOR_TX_ACK;
 717                 }
 718                 /*
 719                  * The actual restore operation will happen only after
 720                  * the ps_flags bit is cleared. We are just dropping
 721                  * the ps_usecount here.
 722                  */
 723                 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
 724                 ath9k_ps_restore(sc);
 725         }
 726
 727         /*
 728          * Cannot tx while the hardware is in full sleep, it first needs a full
 729          * chip reset to recover from that
 730          */
 731         if (unlikely(sc->sc_ah->power_mode == ATH9K_PM_FULL_SLEEP)) {
 732                 ath_err(common, "TX while HW is in FULL_SLEEP mode\n");
 733                 goto exit;
 734         }
 735
 736         memset(&txctl, 0, sizeof(struct ath_tx_control));
 737         txctl.txq = sc->tx.txq_map[skb_get_queue_mapping(skb)];
 738         txctl.sta = control->sta;
 739
 740         ath_dbg(common, XMIT, "transmitting packet, skb: %p\n", skb);
 741
 742         if (ath_tx_start(hw, skb, &txctl) != 0) {
 743                 ath_dbg(common, XMIT, "TX failed\n");
 744                 TX_STAT_INC(txctl.txq->axq_qnum, txfailed);
 745                 goto exit;
 746         }
 747
 748         return;
 749 exit:
 750         ieee80211_free_txskb(hw, skb);
 751 }
 752
 753 static void ath9k_stop(struct ieee80211_hw *hw)
 754 {
 755         struct ath_softc *sc = hw->priv;
 756         struct ath_hw *ah = sc->sc_ah;
 757         struct ath_common *common = ath9k_hw_common(ah);
 758         bool prev_idle;
 759
 760         mutex_lock(&sc->mutex);
 761
 762         ath_cancel_work(sc);
 763         del_timer_sync(&sc->rx_poll_timer);
 764
 765         if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
 766                 ath_dbg(common, ANY, "Device not present\n");
 767                 mutex_unlock(&sc->mutex);
 768                 return;
 769         }
 770
 771         /* Ensure HW is awake when we try to shut it down. */
 772         ath9k_ps_wakeup(sc);
 773
 774         spin_lock_bh(&sc->sc_pcu_lock);
 775
 776         /* prevent tasklets to enable interrupts once we disable them */
 777         ah->imask &= ~ATH9K_INT_GLOBAL;
 778
 779         /* make sure h/w will not generate any interrupt
 780          * before setting the invalid flag. */
 781         ath9k_hw_disable_interrupts(ah);
 782
 783         spin_unlock_bh(&sc->sc_pcu_lock);
 784
 785         /* we can now sync irq and kill any running tasklets, since we already
 786          * disabled interrupts and not holding a spin lock */
 787         synchronize_irq(sc->irq);
 788         tasklet_kill(&sc->intr_tq);
 789         tasklet_kill(&sc->bcon_tasklet);
 790
 791         prev_idle = sc->ps_idle;
 792         sc->ps_idle = true;
 793
 794         spin_lock_bh(&sc->sc_pcu_lock);
 795
 796         if (ah->led_pin >= 0) {
 797                 ath9k_hw_set_gpio(ah, ah->led_pin, 1);
 798                 ath9k_hw_cfg_gpio_input(ah, ah->led_pin);
 799         }
 800
 801         ath_prepare_reset(sc, false);
 802
 803         if (sc->rx.frag) {
 804                 dev_kfree_skb_any(sc->rx.frag);
 805                 sc->rx.frag = NULL;
 806         }
 807
 808         if (!ah->curchan)
 809                 ah->curchan = ath9k_cmn_get_curchannel(hw, ah);
 810
 811         ath9k_hw_reset(ah, ah->curchan, ah->caldata, false);
 812         ath9k_hw_phy_disable(ah);
 813
 814         ath9k_hw_configpcipowersave(ah, true);
 815
 816         spin_unlock_bh(&sc->sc_pcu_lock);
 817
 818         ath9k_ps_restore(sc);
 819
 820         set_bit(SC_OP_INVALID, &sc->sc_flags);
 821         sc->ps_idle = prev_idle;
 822
 823         mutex_unlock(&sc->mutex);
 824
 825         ath_dbg(common, CONFIG, "Driver halt\n");
 826 }
 827
 828 bool ath9k_uses_beacons(int type)
 829 {
 830         switch (type) {
 831         case NL80211_IFTYPE_AP:
 832         case NL80211_IFTYPE_ADHOC:
 833         case NL80211_IFTYPE_MESH_POINT:
 834                 return true;
 835         default:
 836                 return false;
 837         }
 838 }
 839
 840 static void ath9k_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 841 {
 842         struct ath9k_vif_iter_data *iter_data = data;
 843         int i;
 844
 845         if (iter_data->hw_macaddr)
 846                 for (i = 0; i < ETH_ALEN; i++)
 847                         iter_data->mask[i] &=
 848                                 ~(iter_data->hw_macaddr[i] ^ mac[i]);
 849
 850         switch (vif->type) {
 851         case NL80211_IFTYPE_AP:
 852                 iter_data->naps++;
 853                 break;
 854         case NL80211_IFTYPE_STATION:
 855                 iter_data->nstations++;
 856                 break;
 857         case NL80211_IFTYPE_ADHOC:
 858                 iter_data->nadhocs++;
 859                 break;
 860         case NL80211_IFTYPE_MESH_POINT:
 861                 iter_data->nmeshes++;
 862                 break;
 863         case NL80211_IFTYPE_WDS:
 864                 iter_data->nwds++;
 865                 break;
 866         default:
 867                 break;
 868         }
 869 }
 870
 871 static void ath9k_sta_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 872 {
 873         struct ath_softc *sc = data;
 874         struct ath_vif *avp = (void *)vif->drv_priv;
 875
 876         if (vif->type != NL80211_IFTYPE_STATION)
 877                 return;
 878
 879         if (avp->primary_sta_vif)
 880                 ath9k_set_assoc_state(sc, vif);
 881 }
 882
 883 /* Called with sc->mutex held. */
 884 void ath9k_calculate_iter_data(struct ieee80211_hw *hw,
 885                                struct ieee80211_vif *vif,
 886                                struct ath9k_vif_iter_data *iter_data)
 887 {
 888         struct ath_softc *sc = hw->priv;
 889         struct ath_hw *ah = sc->sc_ah;
 890         struct ath_common *common = ath9k_hw_common(ah);
 891
 892         /*
 893          * Use the hardware MAC address as reference, the hardware uses it
 894          * together with the BSSID mask when matching addresses.
 895          */
 896         memset(iter_data, 0, sizeof(*iter_data));
 897         iter_data->hw_macaddr = common->macaddr;
 898         memset(&iter_data->mask, 0xff, ETH_ALEN);
 899
 900         if (vif)
 901                 ath9k_vif_iter(iter_data, vif->addr, vif);
 902
 903         /* Get list of all active MAC addresses */
 904         ieee80211_iterate_active_interfaces_atomic(
 905                 sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
 906                 ath9k_vif_iter, iter_data);
 907 }
 908
 909 /* Called with sc->mutex held. */
 910 static void ath9k_calculate_summary_state(struct ieee80211_hw *hw,
 911                                           struct ieee80211_vif *vif)
 912 {
 913         struct ath_softc *sc = hw->priv;
 914         struct ath_hw *ah = sc->sc_ah;
 915         struct ath_common *common = ath9k_hw_common(ah);
 916         struct ath9k_vif_iter_data iter_data;
 917         enum nl80211_iftype old_opmode = ah->opmode;
 918
 919         ath9k_calculate_iter_data(hw, vif, &iter_data);
 920
 921         memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
 922         ath_hw_setbssidmask(common);
 923
 924         if (iter_data.naps > 0) {
 925                 ath9k_hw_set_tsfadjust(ah, true);
 926                 ah->opmode = NL80211_IFTYPE_AP;
 927         } else {
 928                 ath9k_hw_set_tsfadjust(ah, false);
 929
 930                 if (iter_data.nmeshes)
 931                         ah->opmode = NL80211_IFTYPE_MESH_POINT;
 932                 else if (iter_data.nwds)
 933                         ah->opmode = NL80211_IFTYPE_AP;
 934                 else if (iter_data.nadhocs)
 935                         ah->opmode = NL80211_IFTYPE_ADHOC;
 936                 else
 937                         ah->opmode = NL80211_IFTYPE_STATION;
 938         }
 939
 940         ath9k_hw_setopmode(ah);
 941
 942         if ((iter_data.nstations + iter_data.nadhocs + iter_data.nmeshes) > 0)
 943                 ah->imask |= ATH9K_INT_TSFOOR;
 944         else
 945                 ah->imask &= ~ATH9K_INT_TSFOOR;
 946
 947         ath9k_hw_set_interrupts(ah);
 948
 949         /*
 950          * If we are changing the opmode to STATION,
 951          * a beacon sync needs to be done.
 952          */
 953         if (ah->opmode == NL80211_IFTYPE_STATION &&
 954             old_opmode == NL80211_IFTYPE_AP &&
 955             test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
 956                 ieee80211_iterate_active_interfaces_atomic(
 957                         sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
 958                         ath9k_sta_vif_iter, sc);
 959         }
 960 }
 961
 962 static int ath9k_add_interface(struct ieee80211_hw *hw,
 963                                struct ieee80211_vif *vif)
 964 {
 965         struct ath_softc *sc = hw->priv;
 966         struct ath_hw *ah = sc->sc_ah;
 967         struct ath_common *common = ath9k_hw_common(ah);
 968
 969         mutex_lock(&sc->mutex);
 970
 971         ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
 972         sc->nvifs++;
 973
 974         ath9k_ps_wakeup(sc);
 975         ath9k_calculate_summary_state(hw, vif);
 976         ath9k_ps_restore(sc);
 977
 978         if (ath9k_uses_beacons(vif->type))
 979                 ath9k_beacon_assign_slot(sc, vif);
 980
 981         mutex_unlock(&sc->mutex);
 982         return 0;
 983 }
 984
 985 static int ath9k_change_interface(struct ieee80211_hw *hw,
 986                                   struct ieee80211_vif *vif,
 987                                   enum nl80211_iftype new_type,
 988                                   bool p2p)
 989 {
 990         struct ath_softc *sc = hw->priv;
 991         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
 992
 993         ath_dbg(common, CONFIG, "Change Interface\n");
 994         mutex_lock(&sc->mutex);
 995
 996         if (ath9k_uses_beacons(vif->type))
 997                 ath9k_beacon_remove_slot(sc, vif);
 998
 999         vif->type = new_type;
1000         vif->p2p = p2p;
1001
1002         ath9k_ps_wakeup(sc);
1003         ath9k_calculate_summary_state(hw, vif);
1004         ath9k_ps_restore(sc);
1005
1006         if (ath9k_uses_beacons(vif->type))
1007                 ath9k_beacon_assign_slot(sc, vif);
1008
1009         mutex_unlock(&sc->mutex);
1010         return 0;
1011 }
1012
1013 static void ath9k_remove_interface(struct ieee80211_hw *hw,
1014                                    struct ieee80211_vif *vif)
1015 {
1016         struct ath_softc *sc = hw->priv;
1017         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1018
1019         ath_dbg(common, CONFIG, "Detach Interface\n");
1020
1021         mutex_lock(&sc->mutex);
1022
1023         sc->nvifs--;
1024
1025         if (ath9k_uses_beacons(vif->type))
1026                 ath9k_beacon_remove_slot(sc, vif);
1027
1028         ath9k_ps_wakeup(sc);
1029         ath9k_calculate_summary_state(hw, NULL);
1030         ath9k_ps_restore(sc);
1031
1032         mutex_unlock(&sc->mutex);
1033 }
1034
1035 static void ath9k_enable_ps(struct ath_softc *sc)
1036 {
1037         struct ath_hw *ah = sc->sc_ah;
1038         struct ath_common *common = ath9k_hw_common(ah);
1039
1040         sc->ps_enabled = true;
1041         if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1042                 if ((ah->imask & ATH9K_INT_TIM_TIMER) == 0) {
1043                         ah->imask |= ATH9K_INT_TIM_TIMER;
1044                         ath9k_hw_set_interrupts(ah);
1045                 }
1046                 ath9k_hw_setrxabort(ah, 1);
1047         }
1048         ath_dbg(common, PS, "PowerSave enabled\n");
1049 }
1050
1051 static void ath9k_disable_ps(struct ath_softc *sc)
1052 {
1053         struct ath_hw *ah = sc->sc_ah;
1054         struct ath_common *common = ath9k_hw_common(ah);
1055
1056         sc->ps_enabled = false;
1057         ath9k_hw_setpower(ah, ATH9K_PM_AWAKE);
1058         if (!(ah->caps.hw_caps & ATH9K_HW_CAP_AUTOSLEEP)) {
1059                 ath9k_hw_setrxabort(ah, 0);
1060                 sc->ps_flags &= ~(PS_WAIT_FOR_BEACON |
1061                                   PS_WAIT_FOR_CAB |
1062                                   PS_WAIT_FOR_PSPOLL_DATA |
1063                                   PS_WAIT_FOR_TX_ACK);
1064                 if (ah->imask & ATH9K_INT_TIM_TIMER) {
1065                         ah->imask &= ~ATH9K_INT_TIM_TIMER;
1066                         ath9k_hw_set_interrupts(ah);
1067                 }
1068         }
1069         ath_dbg(common, PS, "PowerSave disabled\n");
1070 }
1071
1072 static int ath9k_config(struct ieee80211_hw *hw, u32 changed)
1073 {
1074         struct ath_softc *sc = hw->priv;
1075         struct ath_hw *ah = sc->sc_ah;
1076         struct ath_common *common = ath9k_hw_common(ah);
1077         struct ieee80211_conf *conf = &hw->conf;
1078         bool reset_channel = false;
1079
1080         ath9k_ps_wakeup(sc);
1081         mutex_lock(&sc->mutex);
1082
1083         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1084                 sc->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1085                 if (sc->ps_idle) {
1086                         ath_cancel_work(sc);
1087                         ath9k_stop_btcoex(sc);
1088                 } else {
1089                         ath9k_start_btcoex(sc);
1090                         /*
1091                          * The chip needs a reset to properly wake up from
1092                          * full sleep
1093                          */
1094                         reset_channel = ah->chip_fullsleep;
1095                 }
1096         }
1097
1098         /*
1099          * We just prepare to enable PS. We have to wait until our AP has
1100          * ACK'd our null data frame to disable RX otherwise we'll ignore
1101          * those ACKs and end up retransmitting the same null data frames.
1102          * IEEE80211_CONF_CHANGE_PS is only passed by mac80211 for STA mode.
1103          */
1104         if (changed & IEEE80211_CONF_CHANGE_PS) {
1105                 unsigned long flags;
1106                 spin_lock_irqsave(&sc->sc_pm_lock, flags);
1107                 if (conf->flags & IEEE80211_CONF_PS)
1108                         ath9k_enable_ps(sc);
1109                 else
1110                         ath9k_disable_ps(sc);
1111                 spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1112         }
1113
1114         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1115                 if (conf->flags & IEEE80211_CONF_MONITOR) {
1116                         ath_dbg(common, CONFIG, "Monitor mode is enabled\n");
1117                         sc->sc_ah->is_monitoring = true;
1118                 } else {
1119                         ath_dbg(common, CONFIG, "Monitor mode is disabled\n");
1120                         sc->sc_ah->is_monitoring = false;
1121                 }
1122         }
1123
1124         if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || reset_channel) {
1125                 struct ieee80211_channel *curchan = hw->conf.channel;
1126                 int pos = curchan->hw_value;
1127                 int old_pos = -1;
1128                 unsigned long flags;
1129
1130                 if (ah->curchan)
1131                         old_pos = ah->curchan - &ah->channels[0];
1132
1133                 ath_dbg(common, CONFIG, "Set channel: %d MHz type: %d\n",
1134                         curchan->center_freq, conf->channel_type);
1135
1136                 /* update survey stats for the old channel before switching */
1137                 spin_lock_irqsave(&common->cc_lock, flags);
1138                 ath_update_survey_stats(sc);
1139                 spin_unlock_irqrestore(&common->cc_lock, flags);
1140
1141                 /*
1142                  * Preserve the current channel values, before updating
1143                  * the same channel
1144                  */
1145                 if (ah->curchan && (old_pos == pos))
1146                         ath9k_hw_getnf(ah, ah->curchan);
1147
1148                 ath9k_cmn_update_ichannel(&sc->sc_ah->channels[pos],
1149                                           curchan, conf->channel_type);
1150
1151                 /*
1152                  * If the operating channel changes, change the survey in-use flags
1153                  * along with it.
1154                  * Reset the survey data for the new channel, unless we're switching
1155                  * back to the operating channel from an off-channel operation.
1156                  */
1157                 if (!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) &&
1158                     sc->cur_survey != &sc->survey[pos]) {
1159
1160                         if (sc->cur_survey)
1161                                 sc->cur_survey->filled &= ~SURVEY_INFO_IN_USE;
1162
1163                         sc->cur_survey = &sc->survey[pos];
1164
1165                         memset(sc->cur_survey, 0, sizeof(struct survey_info));
1166                         sc->cur_survey->filled |= SURVEY_INFO_IN_USE;
1167                 } else if (!(sc->survey[pos].filled & SURVEY_INFO_IN_USE)) {
1168                         memset(&sc->survey[pos], 0, sizeof(struct survey_info));
1169                 }
1170
1171                 if (ath_set_channel(sc, hw, &sc->sc_ah->channels[pos]) < 0) {
1172                         ath_err(common, "Unable to set channel\n");
1173                         mutex_unlock(&sc->mutex);
1174                         ath9k_ps_restore(sc);
1175                         return -EINVAL;
1176                 }
1177
1178                 /*
1179                  * The most recent snapshot of channel->noisefloor for the old
1180                  * channel is only available after the hardware reset. Copy it to
1181                  * the survey stats now.
1182                  */
1183                 if (old_pos >= 0)
1184                         ath_update_survey_nf(sc, old_pos);
1185         }
1186
1187         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1188                 ath_dbg(common, CONFIG, "Set power: %d\n", conf->power_level);
1189                 sc->config.txpowlimit = 2 * conf->power_level;
1190                 ath9k_cmn_update_txpow(ah, sc->curtxpow,
1191                                        sc->config.txpowlimit, &sc->curtxpow);
1192         }
1193
1194         mutex_unlock(&sc->mutex);
1195         ath9k_ps_restore(sc);
1196
1197         return 0;
1198 }
1199
1200 #define SUPPORTED_FILTERS                       \
1201         (FIF_PROMISC_IN_BSS |                   \
1202         FIF_ALLMULTI |                          \
1203         FIF_CONTROL |                           \
1204         FIF_PSPOLL |                            \
1205         FIF_OTHER_BSS |                         \
1206         FIF_BCN_PRBRESP_PROMISC |               \
1207         FIF_PROBE_REQ |                         \
1208         FIF_FCSFAIL)
1209
1210 /* FIXME: sc->sc_full_reset ? */
1211 static void ath9k_configure_filter(struct ieee80211_hw *hw,
1212                                    unsigned int changed_flags,
1213                                    unsigned int *total_flags,
1214                                    u64 multicast)
1215 {
1216         struct ath_softc *sc = hw->priv;
1217         u32 rfilt;
1218
1219         changed_flags &= SUPPORTED_FILTERS;
1220         *total_flags &= SUPPORTED_FILTERS;
1221
1222         sc->rx.rxfilter = *total_flags;
1223         ath9k_ps_wakeup(sc);
1224         rfilt = ath_calcrxfilter(sc);
1225         ath9k_hw_setrxfilter(sc->sc_ah, rfilt);
1226         ath9k_ps_restore(sc);
1227
1228         ath_dbg(ath9k_hw_common(sc->sc_ah), CONFIG, "Set HW RX filter: 0x%x\n",
1229                 rfilt);
1230 }
1231
1232 static int ath9k_sta_add(struct ieee80211_hw *hw,
1233                          struct ieee80211_vif *vif,
1234                          struct ieee80211_sta *sta)
1235 {
1236         struct ath_softc *sc = hw->priv;
1237         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1238         struct ath_node *an = (struct ath_node *) sta->drv_priv;
1239         struct ieee80211_key_conf ps_key = { };
1240
1241         ath_node_attach(sc, sta, vif);
1242
1243         if (vif->type != NL80211_IFTYPE_AP &&
1244             vif->type != NL80211_IFTYPE_AP_VLAN)
1245                 return 0;
1246
1247         an->ps_key = ath_key_config(common, vif, sta, &ps_key);
1248
1249         return 0;
1250 }
1251
1252 static void ath9k_del_ps_key(struct ath_softc *sc,
1253                              struct ieee80211_vif *vif,
1254                              struct ieee80211_sta *sta)
1255 {
1256         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1257         struct ath_node *an = (struct ath_node *) sta->drv_priv;
1258         struct ieee80211_key_conf ps_key = { .hw_key_idx = an->ps_key };
1259
1260         if (!an->ps_key)
1261             return;
1262
1263         ath_key_delete(common, &ps_key);
1264 }
1265
1266 static int ath9k_sta_remove(struct ieee80211_hw *hw,
1267                             struct ieee80211_vif *vif,
1268                             struct ieee80211_sta *sta)
1269 {
1270         struct ath_softc *sc = hw->priv;
1271
1272         ath9k_del_ps_key(sc, vif, sta);
1273         ath_node_detach(sc, sta);
1274
1275         return 0;
1276 }
1277
1278 static void ath9k_sta_notify(struct ieee80211_hw *hw,
1279                          struct ieee80211_vif *vif,
1280                          enum sta_notify_cmd cmd,
1281                          struct ieee80211_sta *sta)
1282 {
1283         struct ath_softc *sc = hw->priv;
1284         struct ath_node *an = (struct ath_node *) sta->drv_priv;
1285
1286         if (!sta->ht_cap.ht_supported)
1287                 return;
1288
1289         switch (cmd) {
1290         case STA_NOTIFY_SLEEP:
1291                 an->sleeping = true;
1292                 ath_tx_aggr_sleep(sta, sc, an);
1293                 break;
1294         case STA_NOTIFY_AWAKE:
1295                 an->sleeping = false;
1296                 ath_tx_aggr_wakeup(sc, an);
1297                 break;
1298         }
1299 }
1300
1301 static int ath9k_conf_tx(struct ieee80211_hw *hw,
1302                          struct ieee80211_vif *vif, u16 queue,
1303                          const struct ieee80211_tx_queue_params *params)
1304 {
1305         struct ath_softc *sc = hw->priv;
1306         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1307         struct ath_txq *txq;
1308         struct ath9k_tx_queue_info qi;
1309         int ret = 0;
1310
1311         if (queue >= IEEE80211_NUM_ACS)
1312                 return 0;
1313
1314         txq = sc->tx.txq_map[queue];
1315
1316         ath9k_ps_wakeup(sc);
1317         mutex_lock(&sc->mutex);
1318
1319         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1320
1321         qi.tqi_aifs = params->aifs;
1322         qi.tqi_cwmin = params->cw_min;
1323         qi.tqi_cwmax = params->cw_max;
1324         qi.tqi_burstTime = params->txop * 32;
1325
1326         ath_dbg(common, CONFIG,
1327                 "Configure tx [queue/halq] [%d/%d], aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1328                 queue, txq->axq_qnum, params->aifs, params->cw_min,
1329                 params->cw_max, params->txop);
1330
1331         ath_update_max_aggr_framelen(sc, queue, qi.tqi_burstTime);
1332         ret = ath_txq_update(sc, txq->axq_qnum, &qi);
1333         if (ret)
1334                 ath_err(common, "TXQ Update failed\n");
1335
1336         mutex_unlock(&sc->mutex);
1337         ath9k_ps_restore(sc);
1338
1339         return ret;
1340 }
1341
1342 static int ath9k_set_key(struct ieee80211_hw *hw,
1343                          enum set_key_cmd cmd,
1344                          struct ieee80211_vif *vif,
1345                          struct ieee80211_sta *sta,
1346                          struct ieee80211_key_conf *key)
1347 {
1348         struct ath_softc *sc = hw->priv;
1349         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1350         int ret = 0;
1351
1352         if (ath9k_modparam_nohwcrypt)
1353                 return -ENOSPC;
1354
1355         if ((vif->type == NL80211_IFTYPE_ADHOC ||
1356              vif->type == NL80211_IFTYPE_MESH_POINT) &&
1357             (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1358              key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1359             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1360                 /*
1361                  * For now, disable hw crypto for the RSN IBSS group keys. This
1362                  * could be optimized in the future to use a modified key cache
1363                  * design to support per-STA RX GTK, but until that gets
1364                  * implemented, use of software crypto for group addressed
1365                  * frames is a acceptable to allow RSN IBSS to be used.
1366                  */
1367                 return -EOPNOTSUPP;
1368         }
1369
1370         mutex_lock(&sc->mutex);
1371         ath9k_ps_wakeup(sc);
1372         ath_dbg(common, CONFIG, "Set HW Key\n");
1373
1374         switch (cmd) {
1375         case SET_KEY:
1376                 if (sta)
1377                         ath9k_del_ps_key(sc, vif, sta);
1378
1379                 ret = ath_key_config(common, vif, sta, key);
1380                 if (ret >= 0) {
1381                         key->hw_key_idx = ret;
1382                         /* push IV and Michael MIC generation to stack */
1383                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1384                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1385                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1386                         if (sc->sc_ah->sw_mgmt_crypto &&
1387                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1388                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1389                         ret = 0;
1390                 }
1391                 break;
1392         case DISABLE_KEY:
1393                 ath_key_delete(common, key);
1394                 break;
1395         default:
1396                 ret = -EINVAL;
1397         }
1398
1399         ath9k_ps_restore(sc);
1400         mutex_unlock(&sc->mutex);
1401
1402         return ret;
1403 }
1404
1405 static void ath9k_set_assoc_state(struct ath_softc *sc,
1406                                   struct ieee80211_vif *vif)
1407 {
1408         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1409         struct ath_vif *avp = (void *)vif->drv_priv;
1410         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1411         unsigned long flags;
1412
1413         set_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1414         avp->primary_sta_vif = true;
1415
1416         /*
1417          * Set the AID, BSSID and do beacon-sync only when
1418          * the HW opmode is STATION.
1419          *
1420          * But the primary bit is set above in any case.
1421          */
1422         if (sc->sc_ah->opmode != NL80211_IFTYPE_STATION)
1423                 return;
1424
1425         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1426         common->curaid = bss_conf->aid;
1427         ath9k_hw_write_associd(sc->sc_ah);
1428
1429         sc->last_rssi = ATH_RSSI_DUMMY_MARKER;
1430         sc->sc_ah->stats.avgbrssi = ATH_RSSI_DUMMY_MARKER;
1431
1432         spin_lock_irqsave(&sc->sc_pm_lock, flags);
1433         sc->ps_flags |= PS_BEACON_SYNC | PS_WAIT_FOR_BEACON;
1434         spin_unlock_irqrestore(&sc->sc_pm_lock, flags);
1435
1436         if (ath9k_hw_mci_is_enabled(sc->sc_ah))
1437                 ath9k_mci_update_wlan_channels(sc, false);
1438
1439         ath_dbg(common, CONFIG,
1440                 "Primary Station interface: %pM, BSSID: %pM\n",
1441                 vif->addr, common->curbssid);
1442 }
1443
1444 static void ath9k_bss_assoc_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1445 {
1446         struct ath_softc *sc = data;
1447         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1448
1449         if (test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags))
1450                 return;
1451
1452         if (bss_conf->assoc)
1453                 ath9k_set_assoc_state(sc, vif);
1454 }
1455
1456 static void ath9k_bss_info_changed(struct ieee80211_hw *hw,
1457                                    struct ieee80211_vif *vif,
1458                                    struct ieee80211_bss_conf *bss_conf,
1459                                    u32 changed)
1460 {
1461 #define CHECK_ANI                               \
1462         (BSS_CHANGED_ASSOC |                    \
1463          BSS_CHANGED_IBSS |                     \
1464          BSS_CHANGED_BEACON_ENABLED)
1465
1466         struct ath_softc *sc = hw->priv;
1467         struct ath_hw *ah = sc->sc_ah;
1468         struct ath_common *common = ath9k_hw_common(ah);
1469         struct ath_vif *avp = (void *)vif->drv_priv;
1470         int slottime;
1471
1472         ath9k_ps_wakeup(sc);
1473         mutex_lock(&sc->mutex);
1474
1475         if (changed & BSS_CHANGED_ASSOC) {
1476                 ath_dbg(common, CONFIG, "BSSID %pM Changed ASSOC %d\n",
1477                         bss_conf->bssid, bss_conf->assoc);
1478
1479                 if (avp->primary_sta_vif && !bss_conf->assoc) {
1480                         clear_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags);
1481                         avp->primary_sta_vif = false;
1482
1483                         if (ah->opmode == NL80211_IFTYPE_STATION)
1484                                 clear_bit(SC_OP_BEACONS, &sc->sc_flags);
1485                 }
1486
1487                 ieee80211_iterate_active_interfaces_atomic(
1488                         sc->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1489                         ath9k_bss_assoc_iter, sc);
1490
1491                 if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags) &&
1492                     ah->opmode == NL80211_IFTYPE_STATION) {
1493                         memset(common->curbssid, 0, ETH_ALEN);
1494                         common->curaid = 0;
1495                         ath9k_hw_write_associd(sc->sc_ah);
1496                         if (ath9k_hw_mci_is_enabled(sc->sc_ah))
1497                                 ath9k_mci_update_wlan_channels(sc, true);
1498                 }
1499         }
1500
1501         if (changed & BSS_CHANGED_IBSS) {
1502                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1503                 common->curaid = bss_conf->aid;
1504                 ath9k_hw_write_associd(sc->sc_ah);
1505         }
1506
1507         if ((changed & BSS_CHANGED_BEACON_ENABLED) ||
1508             (changed & BSS_CHANGED_BEACON_INT)) {
1509                 if (ah->opmode == NL80211_IFTYPE_AP &&
1510                     bss_conf->enable_beacon)
1511                         ath9k_set_tsfadjust(sc, vif);
1512                 if (ath9k_allow_beacon_config(sc, vif))
1513                         ath9k_beacon_config(sc, vif, changed);
1514         }
1515
1516         if (changed & BSS_CHANGED_ERP_SLOT) {
1517                 if (bss_conf->use_short_slot)
1518                         slottime = 9;
1519                 else
1520                         slottime = 20;
1521                 if (vif->type == NL80211_IFTYPE_AP) {
1522                         /*
1523                          * Defer update, so that connected stations can adjust
1524                          * their settings at the same time.
1525                          * See beacon.c for more details
1526                          */
1527                         sc->beacon.slottime = slottime;
1528                         sc->beacon.updateslot = UPDATE;
1529                 } else {
1530                         ah->slottime = slottime;
1531                         ath9k_hw_init_global_settings(ah);
1532                 }
1533         }
1534
1535         if (changed & CHECK_ANI)
1536                 ath_check_ani(sc);
1537
1538         mutex_unlock(&sc->mutex);
1539         ath9k_ps_restore(sc);
1540
1541 #undef CHECK_ANI
1542 }
1543
1544 static u64 ath9k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1545 {
1546         struct ath_softc *sc = hw->priv;
1547         u64 tsf;
1548
1549         mutex_lock(&sc->mutex);
1550         ath9k_ps_wakeup(sc);
1551         tsf = ath9k_hw_gettsf64(sc->sc_ah);
1552         ath9k_ps_restore(sc);
1553         mutex_unlock(&sc->mutex);
1554
1555         return tsf;
1556 }
1557
1558 static void ath9k_set_tsf(struct ieee80211_hw *hw,
1559                           struct ieee80211_vif *vif,
1560                           u64 tsf)
1561 {
1562         struct ath_softc *sc = hw->priv;
1563
1564         mutex_lock(&sc->mutex);
1565         ath9k_ps_wakeup(sc);
1566         ath9k_hw_settsf64(sc->sc_ah, tsf);
1567         ath9k_ps_restore(sc);
1568         mutex_unlock(&sc->mutex);
1569 }
1570
1571 static void ath9k_reset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1572 {
1573         struct ath_softc *sc = hw->priv;
1574
1575         mutex_lock(&sc->mutex);
1576
1577         ath9k_ps_wakeup(sc);
1578         ath9k_hw_reset_tsf(sc->sc_ah);
1579         ath9k_ps_restore(sc);
1580
1581         mutex_unlock(&sc->mutex);
1582 }
1583
1584 static int ath9k_ampdu_action(struct ieee80211_hw *hw,
1585                               struct ieee80211_vif *vif,
1586                               enum ieee80211_ampdu_mlme_action action,
1587                               struct ieee80211_sta *sta,
1588                               u16 tid, u16 *ssn, u8 buf_size)
1589 {
1590         struct ath_softc *sc = hw->priv;
1591         int ret = 0;
1592
1593         local_bh_disable();
1594
1595         switch (action) {
1596         case IEEE80211_AMPDU_RX_START:
1597                 break;
1598         case IEEE80211_AMPDU_RX_STOP:
1599                 break;
1600         case IEEE80211_AMPDU_TX_START:
1601                 ath9k_ps_wakeup(sc);
1602                 ret = ath_tx_aggr_start(sc, sta, tid, ssn);
1603                 if (!ret)
1604                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1605                 ath9k_ps_restore(sc);
1606                 break;
1607         case IEEE80211_AMPDU_TX_STOP:
1608                 ath9k_ps_wakeup(sc);
1609                 ath_tx_aggr_stop(sc, sta, tid);
1610                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1611                 ath9k_ps_restore(sc);
1612                 break;
1613         case IEEE80211_AMPDU_TX_OPERATIONAL:
1614                 ath9k_ps_wakeup(sc);
1615                 ath_tx_aggr_resume(sc, sta, tid);
1616                 ath9k_ps_restore(sc);
1617                 break;
1618         default:
1619                 ath_err(ath9k_hw_common(sc->sc_ah), "Unknown AMPDU action\n");
1620         }
1621
1622         local_bh_enable();
1623
1624         return ret;
1625 }
1626
1627 static int ath9k_get_survey(struct ieee80211_hw *hw, int idx,
1628                              struct survey_info *survey)
1629 {
1630         struct ath_softc *sc = hw->priv;
1631         struct ath_common *common = ath9k_hw_common(sc->sc_ah);
1632         struct ieee80211_supported_band *sband;
1633         struct ieee80211_channel *chan;
1634         unsigned long flags;
1635         int pos;
1636
1637         spin_lock_irqsave(&common->cc_lock, flags);
1638         if (idx == 0)
1639                 ath_update_survey_stats(sc);
1640
1641         sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
1642         if (sband && idx >= sband->n_channels) {
1643                 idx -= sband->n_channels;
1644                 sband = NULL;
1645         }
1646
1647         if (!sband)
1648                 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
1649
1650         if (!sband || idx >= sband->n_channels) {
1651                 spin_unlock_irqrestore(&common->cc_lock, flags);
1652                 return -ENOENT;
1653         }
1654
1655         chan = &sband->channels[idx];
1656         pos = chan->hw_value;
1657         memcpy(survey, &sc->survey[pos], sizeof(*survey));
1658         survey->channel = chan;
1659         spin_unlock_irqrestore(&common->cc_lock, flags);
1660
1661         return 0;
1662 }
1663
1664 static void ath9k_set_coverage_class(struct ieee80211_hw *hw, u8 coverage_class)
1665 {
1666         struct ath_softc *sc = hw->priv;
1667         struct ath_hw *ah = sc->sc_ah;
1668
1669         mutex_lock(&sc->mutex);
1670         ah->coverage_class = coverage_class;
1671
1672         ath9k_ps_wakeup(sc);
1673         ath9k_hw_init_global_settings(ah);
1674         ath9k_ps_restore(sc);
1675
1676         mutex_unlock(&sc->mutex);
1677 }
1678
1679 static void ath9k_flush(struct ieee80211_hw *hw, bool drop)
1680 {
1681         struct ath_softc *sc = hw->priv;
1682         struct ath_hw *ah = sc->sc_ah;
1683         struct ath_common *common = ath9k_hw_common(ah);
1684         int timeout = 200; /* ms */
1685         int i, j;
1686         bool drain_txq;
1687
1688         mutex_lock(&sc->mutex);
1689         cancel_delayed_work_sync(&sc->tx_complete_work);
1690
1691         if (ah->ah_flags & AH_UNPLUGGED) {
1692                 ath_dbg(common, ANY, "Device has been unplugged!\n");
1693                 mutex_unlock(&sc->mutex);
1694                 return;
1695         }
1696
1697         if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
1698                 ath_dbg(common, ANY, "Device not present\n");
1699                 mutex_unlock(&sc->mutex);
1700                 return;
1701         }
1702
1703         for (j = 0; j < timeout; j++) {
1704                 bool npend = false;
1705
1706                 if (j)
1707                         usleep_range(1000, 2000);
1708
1709                 for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1710                         if (!ATH_TXQ_SETUP(sc, i))
1711                                 continue;
1712
1713                         npend = ath9k_has_pending_frames(sc, &sc->tx.txq[i]);
1714
1715                         if (npend)
1716                                 break;
1717                 }
1718
1719                 if (!npend)
1720                     break;
1721         }
1722
1723         if (drop) {
1724                 ath9k_ps_wakeup(sc);
1725                 spin_lock_bh(&sc->sc_pcu_lock);
1726                 drain_txq = ath_drain_all_txq(sc, false);
1727                 spin_unlock_bh(&sc->sc_pcu_lock);
1728
1729                 if (!drain_txq)
1730                         ath_reset(sc, false);
1731
1732                 ath9k_ps_restore(sc);
1733                 ieee80211_wake_queues(hw);
1734         }
1735
1736         ieee80211_queue_delayed_work(hw, &sc->tx_complete_work, 0);
1737         mutex_unlock(&sc->mutex);
1738 }
1739
1740 static bool ath9k_tx_frames_pending(struct ieee80211_hw *hw)
1741 {
1742         struct ath_softc *sc = hw->priv;
1743         int i;
1744
1745         for (i = 0; i < ATH9K_NUM_TX_QUEUES; i++) {
1746                 if (!ATH_TXQ_SETUP(sc, i))
1747                         continue;
1748
1749                 if (ath9k_has_pending_frames(sc, &sc->tx.txq[i]))
1750                         return true;
1751         }
1752         return false;
1753 }
1754
1755 static int ath9k_tx_last_beacon(struct ieee80211_hw *hw)
1756 {
1757         struct ath_softc *sc = hw->priv;
1758         struct ath_hw *ah = sc->sc_ah;
1759         struct ieee80211_vif *vif;
1760         struct ath_vif *avp;
1761         struct ath_buf *bf;
1762         struct ath_tx_status ts;
1763         bool edma = !!(ah->caps.hw_caps & ATH9K_HW_CAP_EDMA);
1764         int status;
1765
1766         vif = sc->beacon.bslot[0];
1767         if (!vif)
1768                 return 0;
1769
1770         if (!vif->bss_conf.enable_beacon)
1771                 return 0;
1772
1773         avp = (void *)vif->drv_priv;
1774
1775         if (!sc->beacon.tx_processed && !edma) {
1776                 tasklet_disable(&sc->bcon_tasklet);
1777
1778                 bf = avp->av_bcbuf;
1779                 if (!bf || !bf->bf_mpdu)
1780                         goto skip;
1781
1782                 status = ath9k_hw_txprocdesc(ah, bf->bf_desc, &ts);
1783                 if (status == -EINPROGRESS)
1784                         goto skip;
1785
1786                 sc->beacon.tx_processed = true;
1787                 sc->beacon.tx_last = !(ts.ts_status & ATH9K_TXERR_MASK);
1788
1789 skip:
1790                 tasklet_enable(&sc->bcon_tasklet);
1791         }
1792
1793         return sc->beacon.tx_last;
1794 }
1795
1796 static int ath9k_get_stats(struct ieee80211_hw *hw,
1797                            struct ieee80211_low_level_stats *stats)
1798 {
1799         struct ath_softc *sc = hw->priv;
1800         struct ath_hw *ah = sc->sc_ah;
1801         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1802
1803         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1804         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1805         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1806         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1807         return 0;
1808 }
1809
1810 static u32 fill_chainmask(u32 cap, u32 new)
1811 {
1812         u32 filled = 0;
1813         int i;
1814
1815         for (i = 0; cap && new; i++, cap >>= 1) {
1816                 if (!(cap & BIT(0)))
1817                         continue;
1818
1819                 if (new & BIT(0))
1820                         filled |= BIT(i);
1821
1822                 new >>= 1;
1823         }
1824
1825         return filled;
1826 }
1827
1828 static bool validate_antenna_mask(struct ath_hw *ah, u32 val)
1829 {
1830         switch (val & 0x7) {
1831         case 0x1:
1832         case 0x3:
1833         case 0x7:
1834                 return true;
1835         case 0x2:
1836                 return (ah->caps.rx_chainmask == 1);
1837         default:
1838                 return false;
1839         }
1840 }
1841
1842 static int ath9k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
1843 {
1844         struct ath_softc *sc = hw->priv;
1845         struct ath_hw *ah = sc->sc_ah;
1846
1847         if (ah->caps.rx_chainmask != 1)
1848                 rx_ant |= tx_ant;
1849
1850         if (!validate_antenna_mask(ah, rx_ant) || !tx_ant)
1851                 return -EINVAL;
1852
1853         sc->ant_rx = rx_ant;
1854         sc->ant_tx = tx_ant;
1855
1856         if (ah->caps.rx_chainmask == 1)
1857                 return 0;
1858
1859         /* AR9100 runs into calibration issues if not all rx chains are enabled */
1860         if (AR_SREV_9100(ah))
1861                 ah->rxchainmask = 0x7;
1862         else
1863                 ah->rxchainmask = fill_chainmask(ah->caps.rx_chainmask, rx_ant);
1864
1865         ah->txchainmask = fill_chainmask(ah->caps.tx_chainmask, tx_ant);
1866         ath9k_reload_chainmask_settings(sc);
1867
1868         return 0;
1869 }
1870
1871 static int ath9k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
1872 {
1873         struct ath_softc *sc = hw->priv;
1874
1875         *tx_ant = sc->ant_tx;
1876         *rx_ant = sc->ant_rx;
1877         return 0;
1878 }
1879
1880 #ifdef CONFIG_PM_SLEEP
1881
1882 static void ath9k_wow_map_triggers(struct ath_softc *sc,
1883                                    struct cfg80211_wowlan *wowlan,
1884                                    u32 *wow_triggers)
1885 {
1886         if (wowlan->disconnect)
1887                 *wow_triggers |= AH_WOW_LINK_CHANGE |
1888                                  AH_WOW_BEACON_MISS;
1889         if (wowlan->magic_pkt)
1890                 *wow_triggers |= AH_WOW_MAGIC_PATTERN_EN;
1891
1892         if (wowlan->n_patterns)
1893                 *wow_triggers |= AH_WOW_USER_PATTERN_EN;
1894
1895         sc->wow_enabled = *wow_triggers;
1896
1897 }
1898
1899 static void ath9k_wow_add_disassoc_deauth_pattern(struct ath_softc *sc)
1900 {
1901         struct ath_hw *ah = sc->sc_ah;
1902         struct ath_common *common = ath9k_hw_common(ah);
1903         struct ath9k_hw_capabilities *pcaps = &ah->caps;
1904         int pattern_count = 0;
1905         int i, byte_cnt;
1906         u8 dis_deauth_pattern[MAX_PATTERN_SIZE];
1907         u8 dis_deauth_mask[MAX_PATTERN_SIZE];
1908
1909         memset(dis_deauth_pattern, 0, MAX_PATTERN_SIZE);
1910         memset(dis_deauth_mask, 0, MAX_PATTERN_SIZE);
1911
1912         /*
1913          * Create Dissassociate / Deauthenticate packet filter
1914          *
1915          *     2 bytes        2 byte    6 bytes   6 bytes  6 bytes
1916          *  +--------------+----------+---------+--------+--------+----
1917          *  + Frame Control+ Duration +   DA    +  SA    +  BSSID +
1918          *  +--------------+----------+---------+--------+--------+----
1919          *
1920          * The above is the management frame format for disassociate/
1921          * deauthenticate pattern, from this we need to match the first byte
1922          * of 'Frame Control' and DA, SA, and BSSID fields
1923          * (skipping 2nd byte of FC and Duration feild.
1924          *
1925          * Disassociate pattern
1926          * --------------------
1927          * Frame control = 00 00 1010
1928          * DA, SA, BSSID = x:x:x:x:x:x
1929          * Pattern will be A0000000 | x:x:x:x:x:x | x:x:x:x:x:x
1930          *                          | x:x:x:x:x:x  -- 22 bytes
1931          *
1932          * Deauthenticate pattern
1933          * ----------------------
1934          * Frame control = 00 00 1100
1935          * DA, SA, BSSID = x:x:x:x:x:x
1936          * Pattern will be C0000000 | x:x:x:x:x:x | x:x:x:x:x:x
1937          *                          | x:x:x:x:x:x  -- 22 bytes
1938          */
1939
1940         /* Create Disassociate Pattern first */
1941
1942         byte_cnt = 0;
1943
1944         /* Fill out the mask with all FF's */
1945
1946         for (i = 0; i < MAX_PATTERN_MASK_SIZE; i++)
1947                 dis_deauth_mask[i] = 0xff;
1948
1949         /* copy the first byte of frame control field */
1950         dis_deauth_pattern[byte_cnt] = 0xa0;
1951         byte_cnt++;
1952
1953         /* skip 2nd byte of frame control and Duration field */
1954         byte_cnt += 3;
1955
1956         /*
1957          * need not match the destination mac address, it can be a broadcast
1958          * mac address or an unicast to this station
1959          */
1960         byte_cnt += 6;
1961
1962         /* copy the source mac address */
1963         memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
1964
1965         byte_cnt += 6;
1966
1967         /* copy the bssid, its same as the source mac address */
1968
1969         memcpy((dis_deauth_pattern + byte_cnt), common->curbssid, ETH_ALEN);
1970
1971         /* Create Disassociate pattern mask */
1972
1973         if (pcaps->hw_caps & ATH9K_HW_WOW_PATTERN_MATCH_EXACT) {
1974
1975                 if (pcaps->hw_caps & ATH9K_HW_WOW_PATTERN_MATCH_DWORD) {
1976                         /*
1977                          * for AR9280, because of hardware limitation, the
1978                          * first 4 bytes have to be matched for all patterns.
1979                          * the mask for disassociation and de-auth pattern
1980                          * matching need to enable the first 4 bytes.
1981                          * also the duration field needs to be filled.
1982                          */
1983                         dis_deauth_mask[0] = 0xf0;
1984
1985                         /*
1986                          * fill in duration field
1987                          FIXME: what is the exact value ?
1988                          */
1989                         dis_deauth_pattern[2] = 0xff;
1990                         dis_deauth_pattern[3] = 0xff;
1991                 } else {
1992                         dis_deauth_mask[0] = 0xfe;
1993                 }
1994
1995                 dis_deauth_mask[1] = 0x03;
1996                 dis_deauth_mask[2] = 0xc0;
1997         } else {
1998                 dis_deauth_mask[0] = 0xef;
1999                 dis_deauth_mask[1] = 0x3f;
2000                 dis_deauth_mask[2] = 0x00;
2001                 dis_deauth_mask[3] = 0xfc;
2002         }
2003
2004         ath_dbg(common, WOW, "Adding disassoc/deauth patterns for WoW\n");
2005
2006         ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
2007                                    pattern_count, byte_cnt);
2008
2009         pattern_count++;
2010         /*
2011          * for de-authenticate pattern, only the first byte of the frame
2012          * control field gets changed from 0xA0 to 0xC0
2013          */
2014         dis_deauth_pattern[0] = 0xC0;
2015
2016         ath9k_hw_wow_apply_pattern(ah, dis_deauth_pattern, dis_deauth_mask,
2017                                    pattern_count, byte_cnt);
2018
2019 }
2020
2021 static void ath9k_wow_add_pattern(struct ath_softc *sc,
2022                                   struct cfg80211_wowlan *wowlan)
2023 {
2024         struct ath_hw *ah = sc->sc_ah;
2025         struct ath9k_wow_pattern *wow_pattern = NULL;
2026         struct cfg80211_wowlan_trig_pkt_pattern *patterns = wowlan->patterns;
2027         int mask_len;
2028         s8 i = 0;
2029
2030         if (!wowlan->n_patterns)
2031                 return;
2032
2033         /*
2034          * Add the new user configured patterns
2035          */
2036         for (i = 0; i < wowlan->n_patterns; i++) {
2037
2038                 wow_pattern = kzalloc(sizeof(*wow_pattern), GFP_KERNEL);
2039
2040                 if (!wow_pattern)
2041                         return;
2042
2043                 /*
2044                  * TODO: convert the generic user space pattern to
2045                  * appropriate chip specific/802.11 pattern.
2046                  */
2047
2048                 mask_len = DIV_ROUND_UP(wowlan->patterns[i].pattern_len, 8);
2049                 memset(wow_pattern->pattern_bytes, 0, MAX_PATTERN_SIZE);
2050                 memset(wow_pattern->mask_bytes, 0, MAX_PATTERN_SIZE);
2051                 memcpy(wow_pattern->pattern_bytes, patterns[i].pattern,
2052                        patterns[i].pattern_len);
2053                 memcpy(wow_pattern->mask_bytes, patterns[i].mask, mask_len);
2054                 wow_pattern->pattern_len = patterns[i].pattern_len;
2055
2056                 /*
2057                  * just need to take care of deauth and disssoc pattern,
2058                  * make sure we don't overwrite them.
2059                  */
2060
2061                 ath9k_hw_wow_apply_pattern(ah, wow_pattern->pattern_bytes,
2062                                            wow_pattern->mask_bytes,
2063                                            i + 2,
2064                                            wow_pattern->pattern_len);
2065                 kfree(wow_pattern);
2066
2067         }
2068
2069 }
2070
2071 static int ath9k_suspend(struct ieee80211_hw *hw,
2072                          struct cfg80211_wowlan *wowlan)
2073 {
2074         struct ath_softc *sc = hw->priv;
2075         struct ath_hw *ah = sc->sc_ah;
2076         struct ath_common *common = ath9k_hw_common(ah);
2077         u32 wow_triggers_enabled = 0;
2078         int ret = 0;
2079
2080         mutex_lock(&sc->mutex);
2081
2082         ath_cancel_work(sc);
2083         ath_stop_ani(sc);
2084         del_timer_sync(&sc->rx_poll_timer);
2085
2086         if (test_bit(SC_OP_INVALID, &sc->sc_flags)) {
2087                 ath_dbg(common, ANY, "Device not present\n");
2088                 ret = -EINVAL;
2089                 goto fail_wow;
2090         }
2091
2092         if (WARN_ON(!wowlan)) {
2093                 ath_dbg(common, WOW, "None of the WoW triggers enabled\n");
2094                 ret = -EINVAL;
2095                 goto fail_wow;
2096         }
2097
2098         if (!device_can_wakeup(sc->dev)) {
2099                 ath_dbg(common, WOW, "device_can_wakeup failed, WoW is not enabled\n");
2100                 ret = 1;
2101                 goto fail_wow;
2102         }
2103
2104         /*
2105          * none of the sta vifs are associated
2106          * and we are not currently handling multivif
2107          * cases, for instance we have to seperately
2108          * configure 'keep alive frame' for each
2109          * STA.
2110          */
2111
2112         if (!test_bit(SC_OP_PRIM_STA_VIF, &sc->sc_flags)) {
2113                 ath_dbg(common, WOW, "None of the STA vifs are associated\n");
2114                 ret = 1;
2115                 goto fail_wow;
2116         }
2117
2118         if (sc->nvifs > 1) {
2119                 ath_dbg(common, WOW, "WoW for multivif is not yet supported\n");
2120                 ret = 1;
2121                 goto fail_wow;
2122         }
2123
2124         ath9k_wow_map_triggers(sc, wowlan, &wow_triggers_enabled);
2125
2126         ath_dbg(common, WOW, "WoW triggers enabled 0x%x\n",
2127                 wow_triggers_enabled);
2128
2129         ath9k_ps_wakeup(sc);
2130
2131         ath9k_stop_btcoex(sc);
2132
2133         /*
2134          * Enable wake up on recieving disassoc/deauth
2135          * frame by default.
2136          */
2137         ath9k_wow_add_disassoc_deauth_pattern(sc);
2138
2139         if (wow_triggers_enabled & AH_WOW_USER_PATTERN_EN)
2140                 ath9k_wow_add_pattern(sc, wowlan);
2141
2142         spin_lock_bh(&sc->sc_pcu_lock);
2143         /*
2144          * To avoid false wake, we enable beacon miss interrupt only
2145          * when we go to sleep. We save the current interrupt mask
2146          * so we can restore it after the system wakes up
2147          */
2148         sc->wow_intr_before_sleep = ah->imask;
2149         ah->imask &= ~ATH9K_INT_GLOBAL;
2150         ath9k_hw_disable_interrupts(ah);
2151         ah->imask = ATH9K_INT_BMISS | ATH9K_INT_GLOBAL;
2152         ath9k_hw_set_interrupts(ah);
2153         ath9k_hw_enable_interrupts(ah);
2154
2155         spin_unlock_bh(&sc->sc_pcu_lock);
2156
2157         /*
2158          * we can now sync irq and kill any running tasklets, since we already
2159          * disabled interrupts and not holding a spin lock
2160          */
2161         synchronize_irq(sc->irq);
2162         tasklet_kill(&sc->intr_tq);
2163
2164         ath9k_hw_wow_enable(ah, wow_triggers_enabled);
2165
2166         ath9k_ps_restore(sc);
2167         ath_dbg(common, ANY, "WoW enabled in ath9k\n");
2168         atomic_inc(&sc->wow_sleep_proc_intr);
2169
2170 fail_wow:
2171         mutex_unlock(&sc->mutex);
2172         return ret;
2173 }
2174
2175 static int ath9k_resume(struct ieee80211_hw *hw)
2176 {
2177         struct ath_softc *sc = hw->priv;
2178         struct ath_hw *ah = sc->sc_ah;
2179         struct ath_common *common = ath9k_hw_common(ah);
2180         u32 wow_status;
2181
2182         mutex_lock(&sc->mutex);
2183
2184         ath9k_ps_wakeup(sc);
2185
2186         spin_lock_bh(&sc->sc_pcu_lock);
2187
2188         ath9k_hw_disable_interrupts(ah);
2189         ah->imask = sc->wow_intr_before_sleep;
2190         ath9k_hw_set_interrupts(ah);
2191         ath9k_hw_enable_interrupts(ah);
2192
2193         spin_unlock_bh(&sc->sc_pcu_lock);
2194
2195         wow_status = ath9k_hw_wow_wakeup(ah);
2196
2197         if (atomic_read(&sc->wow_got_bmiss_intr) == 0) {
2198                 /*
2199                  * some devices may not pick beacon miss
2200                  * as the reason they woke up so we add
2201                  * that here for that shortcoming.
2202                  */
2203                 wow_status |= AH_WOW_BEACON_MISS;
2204                 atomic_dec(&sc->wow_got_bmiss_intr);
2205                 ath_dbg(common, ANY, "Beacon miss interrupt picked up during WoW sleep\n");
2206         }
2207
2208         atomic_dec(&sc->wow_sleep_proc_intr);
2209
2210         if (wow_status) {
2211                 ath_dbg(common, ANY, "Waking up due to WoW triggers %s with WoW status = %x\n",
2212                         ath9k_hw_wow_event_to_string(wow_status), wow_status);
2213         }
2214
2215         ath_restart_work(sc);
2216         ath9k_start_btcoex(sc);
2217
2218         ath9k_ps_restore(sc);
2219         mutex_unlock(&sc->mutex);
2220
2221         return 0;
2222 }
2223
2224 static void ath9k_set_wakeup(struct ieee80211_hw *hw, bool enabled)
2225 {
2226         struct ath_softc *sc = hw->priv;
2227
2228         mutex_lock(&sc->mutex);
2229         device_init_wakeup(sc->dev, 1);
2230         device_set_wakeup_enable(sc->dev, enabled);
2231         mutex_unlock(&sc->mutex);
2232 }
2233
2234 #endif
2235
2236 struct ieee80211_ops ath9k_ops = {
2237         .tx                 = ath9k_tx,
2238         .start              = ath9k_start,
2239         .stop               = ath9k_stop,
2240         .add_interface      = ath9k_add_interface,
2241         .change_interface   = ath9k_change_interface,
2242         .remove_interface   = ath9k_remove_interface,
2243         .config             = ath9k_config,
2244         .configure_filter   = ath9k_configure_filter,
2245         .sta_add            = ath9k_sta_add,
2246         .sta_remove         = ath9k_sta_remove,
2247         .sta_notify         = ath9k_sta_notify,
2248         .conf_tx            = ath9k_conf_tx,
2249         .bss_info_changed   = ath9k_bss_info_changed,
2250         .set_key            = ath9k_set_key,
2251         .get_tsf            = ath9k_get_tsf,
2252         .set_tsf            = ath9k_set_tsf,
2253         .reset_tsf          = ath9k_reset_tsf,
2254         .ampdu_action       = ath9k_ampdu_action,
2255         .get_survey         = ath9k_get_survey,
2256         .rfkill_poll        = ath9k_rfkill_poll_state,
2257         .set_coverage_class = ath9k_set_coverage_class,
2258         .flush              = ath9k_flush,
2259         .tx_frames_pending  = ath9k_tx_frames_pending,
2260         .tx_last_beacon     = ath9k_tx_last_beacon,
2261         .get_stats          = ath9k_get_stats,
2262         .set_antenna        = ath9k_set_antenna,
2263         .get_antenna        = ath9k_get_antenna,
2264
2265 #ifdef CONFIG_PM_SLEEP
2266         .suspend            = ath9k_suspend,
2267         .resume             = ath9k_resume,
2268         .set_wakeup         = ath9k_set_wakeup,
2269 #endif
2270
2271 #ifdef CONFIG_ATH9K_DEBUGFS
2272         .get_et_sset_count  = ath9k_get_et_sset_count,
2273         .get_et_stats       = ath9k_get_et_stats,
2274         .get_et_strings     = ath9k_get_et_strings,
2275 #endif
2276
2277 #if defined(CONFIG_MAC80211_DEBUGFS) && defined(CONFIG_ATH9K_DEBUGFS)
2278         .sta_add_debugfs    = ath9k_sta_add_debugfs,
2279         .sta_remove_debugfs = ath9k_sta_remove_debugfs,
2280 #endif
2281 };