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

   1 /*
   2  * Copyright (c) 2010-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 "htc.h"
  18
  19 /*************/
  20 /* Utilities */
  21 /*************/
  22
  23 /* HACK Alert: Use 11NG for 2.4, use 11NA for 5 */
  24 static enum htc_phymode ath9k_htc_get_curmode(struct ath9k_htc_priv *priv,
  25                                               struct ath9k_channel *ichan)
  26 {
  27         enum htc_phymode mode;
  28
  29         mode = -EINVAL;
  30
  31         switch (ichan->chanmode) {
  32         case CHANNEL_G:
  33         case CHANNEL_G_HT20:
  34         case CHANNEL_G_HT40PLUS:
  35         case CHANNEL_G_HT40MINUS:
  36                 mode = HTC_MODE_11NG;
  37                 break;
  38         case CHANNEL_A:
  39         case CHANNEL_A_HT20:
  40         case CHANNEL_A_HT40PLUS:
  41         case CHANNEL_A_HT40MINUS:
  42                 mode = HTC_MODE_11NA;
  43                 break;
  44         default:
  45                 break;
  46         }
  47
  48         WARN_ON(mode < 0);
  49
  50         return mode;
  51 }
  52
  53 bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
  54                         enum ath9k_power_mode mode)
  55 {
  56         bool ret;
  57
  58         mutex_lock(&priv->htc_pm_lock);
  59         ret = ath9k_hw_setpower(priv->ah, mode);
  60         mutex_unlock(&priv->htc_pm_lock);
  61
  62         return ret;
  63 }
  64
  65 void ath9k_htc_ps_wakeup(struct ath9k_htc_priv *priv)
  66 {
  67         mutex_lock(&priv->htc_pm_lock);
  68         if (++priv->ps_usecount != 1)
  69                 goto unlock;
  70         ath9k_hw_setpower(priv->ah, ATH9K_PM_AWAKE);
  71
  72 unlock:
  73         mutex_unlock(&priv->htc_pm_lock);
  74 }
  75
  76 void ath9k_htc_ps_restore(struct ath9k_htc_priv *priv)
  77 {
  78         bool reset;
  79
  80         mutex_lock(&priv->htc_pm_lock);
  81         if (--priv->ps_usecount != 0)
  82                 goto unlock;
  83
  84         if (priv->ps_idle) {
  85                 ath9k_hw_setrxabort(priv->ah, true);
  86                 ath9k_hw_stopdmarecv(priv->ah, &reset);
  87                 ath9k_hw_setpower(priv->ah, ATH9K_PM_FULL_SLEEP);
  88         } else if (priv->ps_enabled) {
  89                 ath9k_hw_setpower(priv->ah, ATH9K_PM_NETWORK_SLEEP);
  90         }
  91
  92 unlock:
  93         mutex_unlock(&priv->htc_pm_lock);
  94 }
  95
  96 void ath9k_ps_work(struct work_struct *work)
  97 {
  98         struct ath9k_htc_priv *priv =
  99                 container_of(work, struct ath9k_htc_priv,
 100                              ps_work);
 101         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 102
 103         /* The chip wakes up after receiving the first beacon
 104            while network sleep is enabled. For the driver to
 105            be in sync with the hw, set the chip to awake and
 106            only then set it to sleep.
 107          */
 108         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
 109 }
 110
 111 static void ath9k_htc_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 112 {
 113         struct ath9k_htc_priv *priv = data;
 114         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
 115
 116         if ((vif->type == NL80211_IFTYPE_AP) && bss_conf->enable_beacon)
 117                 priv->reconfig_beacon = true;
 118
 119         if (bss_conf->assoc) {
 120                 priv->rearm_ani = true;
 121                 priv->reconfig_beacon = true;
 122         }
 123 }
 124
 125 static void ath9k_htc_vif_reconfig(struct ath9k_htc_priv *priv)
 126 {
 127         priv->rearm_ani = false;
 128         priv->reconfig_beacon = false;
 129
 130         ieee80211_iterate_active_interfaces_atomic(priv->hw,
 131                                                    ath9k_htc_vif_iter, priv);
 132         if (priv->rearm_ani)
 133                 ath9k_htc_start_ani(priv);
 134
 135         if (priv->reconfig_beacon) {
 136                 ath9k_htc_ps_wakeup(priv);
 137                 ath9k_htc_beacon_reconfig(priv);
 138                 ath9k_htc_ps_restore(priv);
 139         }
 140 }
 141
 142 static void ath9k_htc_bssid_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
 143 {
 144         struct ath9k_vif_iter_data *iter_data = data;
 145         int i;
 146
 147         for (i = 0; i < ETH_ALEN; i++)
 148                 iter_data->mask[i] &= ~(iter_data->hw_macaddr[i] ^ mac[i]);
 149 }
 150
 151 static void ath9k_htc_set_bssid_mask(struct ath9k_htc_priv *priv,
 152                                      struct ieee80211_vif *vif)
 153 {
 154         struct ath_common *common = ath9k_hw_common(priv->ah);
 155         struct ath9k_vif_iter_data iter_data;
 156
 157         /*
 158          * Use the hardware MAC address as reference, the hardware uses it
 159          * together with the BSSID mask when matching addresses.
 160          */
 161         iter_data.hw_macaddr = common->macaddr;
 162         memset(&iter_data.mask, 0xff, ETH_ALEN);
 163
 164         if (vif)
 165                 ath9k_htc_bssid_iter(&iter_data, vif->addr, vif);
 166
 167         /* Get list of all active MAC addresses */
 168         ieee80211_iterate_active_interfaces_atomic(priv->hw, ath9k_htc_bssid_iter,
 169                                                    &iter_data);
 170
 171         memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
 172         ath_hw_setbssidmask(common);
 173 }
 174
 175 static void ath9k_htc_set_opmode(struct ath9k_htc_priv *priv)
 176 {
 177         if (priv->num_ibss_vif)
 178                 priv->ah->opmode = NL80211_IFTYPE_ADHOC;
 179         else if (priv->num_ap_vif)
 180                 priv->ah->opmode = NL80211_IFTYPE_AP;
 181         else
 182                 priv->ah->opmode = NL80211_IFTYPE_STATION;
 183
 184         ath9k_hw_setopmode(priv->ah);
 185 }
 186
 187 void ath9k_htc_reset(struct ath9k_htc_priv *priv)
 188 {
 189         struct ath_hw *ah = priv->ah;
 190         struct ath_common *common = ath9k_hw_common(ah);
 191         struct ieee80211_channel *channel = priv->hw->conf.channel;
 192         struct ath9k_hw_cal_data *caldata = NULL;
 193         enum htc_phymode mode;
 194         __be16 htc_mode;
 195         u8 cmd_rsp;
 196         int ret;
 197
 198         mutex_lock(&priv->mutex);
 199         ath9k_htc_ps_wakeup(priv);
 200
 201         ath9k_htc_stop_ani(priv);
 202         ieee80211_stop_queues(priv->hw);
 203
 204         del_timer_sync(&priv->tx.cleanup_timer);
 205         ath9k_htc_tx_drain(priv);
 206
 207         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 208         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 209         WMI_CMD(WMI_STOP_RECV_CMDID);
 210
 211         ath9k_wmi_event_drain(priv);
 212
 213         caldata = &priv->caldata;
 214         ret = ath9k_hw_reset(ah, ah->curchan, caldata, false);
 215         if (ret) {
 216                 ath_err(common,
 217                         "Unable to reset device (%u Mhz) reset status %d\n",
 218                         channel->center_freq, ret);
 219         }
 220
 221         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 222                                &priv->curtxpow);
 223
 224         WMI_CMD(WMI_START_RECV_CMDID);
 225         ath9k_host_rx_init(priv);
 226
 227         mode = ath9k_htc_get_curmode(priv, ah->curchan);
 228         htc_mode = cpu_to_be16(mode);
 229         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 230
 231         WMI_CMD(WMI_ENABLE_INTR_CMDID);
 232         htc_start(priv->htc);
 233         ath9k_htc_vif_reconfig(priv);
 234         ieee80211_wake_queues(priv->hw);
 235
 236         mod_timer(&priv->tx.cleanup_timer,
 237                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 238
 239         ath9k_htc_ps_restore(priv);
 240         mutex_unlock(&priv->mutex);
 241 }
 242
 243 static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv,
 244                                  struct ieee80211_hw *hw,
 245                                  struct ath9k_channel *hchan)
 246 {
 247         struct ath_hw *ah = priv->ah;
 248         struct ath_common *common = ath9k_hw_common(ah);
 249         struct ieee80211_conf *conf = &common->hw->conf;
 250         bool fastcc;
 251         struct ieee80211_channel *channel = hw->conf.channel;
 252         struct ath9k_hw_cal_data *caldata = NULL;
 253         enum htc_phymode mode;
 254         __be16 htc_mode;
 255         u8 cmd_rsp;
 256         int ret;
 257
 258         if (test_bit(OP_INVALID, &priv->op_flags))
 259                 return -EIO;
 260
 261         fastcc = !!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL);
 262
 263         ath9k_htc_ps_wakeup(priv);
 264
 265         del_timer_sync(&priv->tx.cleanup_timer);
 266         ath9k_htc_tx_drain(priv);
 267
 268         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 269         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 270         WMI_CMD(WMI_STOP_RECV_CMDID);
 271
 272         ath9k_wmi_event_drain(priv);
 273
 274         ath_dbg(common, CONFIG,
 275                 "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n",
 276                 priv->ah->curchan->channel,
 277                 channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf),
 278                 fastcc);
 279
 280         if (!fastcc)
 281                 caldata = &priv->caldata;
 282
 283         ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
 284         if (ret) {
 285                 ath_err(common,
 286                         "Unable to reset channel (%u Mhz) reset status %d\n",
 287                         channel->center_freq, ret);
 288                 goto err;
 289         }
 290
 291         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 292                                &priv->curtxpow);
 293
 294         WMI_CMD(WMI_START_RECV_CMDID);
 295         if (ret)
 296                 goto err;
 297
 298         ath9k_host_rx_init(priv);
 299
 300         mode = ath9k_htc_get_curmode(priv, hchan);
 301         htc_mode = cpu_to_be16(mode);
 302         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 303         if (ret)
 304                 goto err;
 305
 306         WMI_CMD(WMI_ENABLE_INTR_CMDID);
 307         if (ret)
 308                 goto err;
 309
 310         htc_start(priv->htc);
 311
 312         if (!test_bit(OP_SCANNING, &priv->op_flags) &&
 313             !(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL))
 314                 ath9k_htc_vif_reconfig(priv);
 315
 316         mod_timer(&priv->tx.cleanup_timer,
 317                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 318
 319 err:
 320         ath9k_htc_ps_restore(priv);
 321         return ret;
 322 }
 323
 324 /*
 325  * Monitor mode handling is a tad complicated because the firmware requires
 326  * an interface to be created exclusively, while mac80211 doesn't associate
 327  * an interface with the mode.
 328  *
 329  * So, for now, only one monitor interface can be configured.
 330  */
 331 static void __ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
 332 {
 333         struct ath_common *common = ath9k_hw_common(priv->ah);
 334         struct ath9k_htc_target_vif hvif;
 335         int ret = 0;
 336         u8 cmd_rsp;
 337
 338         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
 339         memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
 340         hvif.index = priv->mon_vif_idx;
 341         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
 342         if (ret) {
 343                 ath_err(common, "Unable to remove monitor interface at idx: %d\n",
 344                         priv->mon_vif_idx);
 345         }
 346
 347         priv->nvifs--;
 348         priv->vif_slot &= ~(1 << priv->mon_vif_idx);
 349 }
 350
 351 static int ath9k_htc_add_monitor_interface(struct ath9k_htc_priv *priv)
 352 {
 353         struct ath_common *common = ath9k_hw_common(priv->ah);
 354         struct ath9k_htc_target_vif hvif;
 355         struct ath9k_htc_target_sta tsta;
 356         int ret = 0, sta_idx;
 357         u8 cmd_rsp;
 358
 359         if ((priv->nvifs >= ATH9K_HTC_MAX_VIF) ||
 360             (priv->nstations >= ATH9K_HTC_MAX_STA)) {
 361                 ret = -ENOBUFS;
 362                 goto err_vif;
 363         }
 364
 365         sta_idx = ffz(priv->sta_slot);
 366         if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA)) {
 367                 ret = -ENOBUFS;
 368                 goto err_vif;
 369         }
 370
 371         /*
 372          * Add an interface.
 373          */
 374         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
 375         memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
 376
 377         hvif.opmode = HTC_M_MONITOR;
 378         hvif.index = ffz(priv->vif_slot);
 379
 380         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
 381         if (ret)
 382                 goto err_vif;
 383
 384         /*
 385          * Assign the monitor interface index as a special case here.
 386          * This is needed when the interface is brought down.
 387          */
 388         priv->mon_vif_idx = hvif.index;
 389         priv->vif_slot |= (1 << hvif.index);
 390
 391         /*
 392          * Set the hardware mode to monitor only if there are no
 393          * other interfaces.
 394          */
 395         if (!priv->nvifs)
 396                 priv->ah->opmode = NL80211_IFTYPE_MONITOR;
 397
 398         priv->nvifs++;
 399
 400         /*
 401          * Associate a station with the interface for packet injection.
 402          */
 403         memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
 404
 405         memcpy(&tsta.macaddr, common->macaddr, ETH_ALEN);
 406
 407         tsta.is_vif_sta = 1;
 408         tsta.sta_index = sta_idx;
 409         tsta.vif_index = hvif.index;
 410         tsta.maxampdu = cpu_to_be16(0xffff);
 411
 412         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
 413         if (ret) {
 414                 ath_err(common, "Unable to add station entry for monitor mode\n");
 415                 goto err_sta;
 416         }
 417
 418         priv->sta_slot |= (1 << sta_idx);
 419         priv->nstations++;
 420         priv->vif_sta_pos[priv->mon_vif_idx] = sta_idx;
 421         priv->ah->is_monitoring = true;
 422
 423         ath_dbg(common, CONFIG,
 424                 "Attached a monitor interface at idx: %d, sta idx: %d\n",
 425                 priv->mon_vif_idx, sta_idx);
 426
 427         return 0;
 428
 429 err_sta:
 430         /*
 431          * Remove the interface from the target.
 432          */
 433         __ath9k_htc_remove_monitor_interface(priv);
 434 err_vif:
 435         ath_dbg(common, FATAL, "Unable to attach a monitor interface\n");
 436
 437         return ret;
 438 }
 439
 440 static int ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
 441 {
 442         struct ath_common *common = ath9k_hw_common(priv->ah);
 443         int ret = 0;
 444         u8 cmd_rsp, sta_idx;
 445
 446         __ath9k_htc_remove_monitor_interface(priv);
 447
 448         sta_idx = priv->vif_sta_pos[priv->mon_vif_idx];
 449
 450         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
 451         if (ret) {
 452                 ath_err(common, "Unable to remove station entry for monitor mode\n");
 453                 return ret;
 454         }
 455
 456         priv->sta_slot &= ~(1 << sta_idx);
 457         priv->nstations--;
 458         priv->ah->is_monitoring = false;
 459
 460         ath_dbg(common, CONFIG,
 461                 "Removed a monitor interface at idx: %d, sta idx: %d\n",
 462                 priv->mon_vif_idx, sta_idx);
 463
 464         return 0;
 465 }
 466
 467 static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
 468                                  struct ieee80211_vif *vif,
 469                                  struct ieee80211_sta *sta)
 470 {
 471         struct ath_common *common = ath9k_hw_common(priv->ah);
 472         struct ath9k_htc_target_sta tsta;
 473         struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
 474         struct ath9k_htc_sta *ista;
 475         int ret, sta_idx;
 476         u8 cmd_rsp;
 477         u16 maxampdu;
 478
 479         if (priv->nstations >= ATH9K_HTC_MAX_STA)
 480                 return -ENOBUFS;
 481
 482         sta_idx = ffz(priv->sta_slot);
 483         if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA))
 484                 return -ENOBUFS;
 485
 486         memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
 487
 488         if (sta) {
 489                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
 490                 memcpy(&tsta.macaddr, sta->addr, ETH_ALEN);
 491                 memcpy(&tsta.bssid, common->curbssid, ETH_ALEN);
 492                 tsta.is_vif_sta = 0;
 493                 ista->index = sta_idx;
 494         } else {
 495                 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN);
 496                 tsta.is_vif_sta = 1;
 497         }
 498
 499         tsta.sta_index = sta_idx;
 500         tsta.vif_index = avp->index;
 501
 502         if (!sta) {
 503                 tsta.maxampdu = cpu_to_be16(0xffff);
 504         } else {
 505                 maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 506                                  sta->ht_cap.ampdu_factor);
 507                 tsta.maxampdu = cpu_to_be16(maxampdu);
 508         }
 509
 510         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
 511         if (ret) {
 512                 if (sta)
 513                         ath_err(common,
 514                                 "Unable to add station entry for: %pM\n",
 515                                 sta->addr);
 516                 return ret;
 517         }
 518
 519         if (sta) {
 520                 ath_dbg(common, CONFIG,
 521                         "Added a station entry for: %pM (idx: %d)\n",
 522                         sta->addr, tsta.sta_index);
 523         } else {
 524                 ath_dbg(common, CONFIG,
 525                         "Added a station entry for VIF %d (idx: %d)\n",
 526                         avp->index, tsta.sta_index);
 527         }
 528
 529         priv->sta_slot |= (1 << sta_idx);
 530         priv->nstations++;
 531         if (!sta)
 532                 priv->vif_sta_pos[avp->index] = sta_idx;
 533
 534         return 0;
 535 }
 536
 537 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
 538                                     struct ieee80211_vif *vif,
 539                                     struct ieee80211_sta *sta)
 540 {
 541         struct ath_common *common = ath9k_hw_common(priv->ah);
 542         struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
 543         struct ath9k_htc_sta *ista;
 544         int ret;
 545         u8 cmd_rsp, sta_idx;
 546
 547         if (sta) {
 548                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
 549                 sta_idx = ista->index;
 550         } else {
 551                 sta_idx = priv->vif_sta_pos[avp->index];
 552         }
 553
 554         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
 555         if (ret) {
 556                 if (sta)
 557                         ath_err(common,
 558                                 "Unable to remove station entry for: %pM\n",
 559                                 sta->addr);
 560                 return ret;
 561         }
 562
 563         if (sta) {
 564                 ath_dbg(common, CONFIG,
 565                         "Removed a station entry for: %pM (idx: %d)\n",
 566                         sta->addr, sta_idx);
 567         } else {
 568                 ath_dbg(common, CONFIG,
 569                         "Removed a station entry for VIF %d (idx: %d)\n",
 570                         avp->index, sta_idx);
 571         }
 572
 573         priv->sta_slot &= ~(1 << sta_idx);
 574         priv->nstations--;
 575
 576         return 0;
 577 }
 578
 579 int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv,
 580                                 u8 enable_coex)
 581 {
 582         struct ath9k_htc_cap_target tcap;
 583         int ret;
 584         u8 cmd_rsp;
 585
 586         memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target));
 587
 588         tcap.ampdu_limit = cpu_to_be32(0xffff);
 589         tcap.ampdu_subframes = 0xff;
 590         tcap.enable_coex = enable_coex;
 591         tcap.tx_chainmask = priv->ah->caps.tx_chainmask;
 592
 593         WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap);
 594
 595         return ret;
 596 }
 597
 598 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv,
 599                                  struct ieee80211_sta *sta,
 600                                  struct ath9k_htc_target_rate *trate)
 601 {
 602         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
 603         struct ieee80211_supported_band *sband;
 604         u32 caps = 0;
 605         int i, j;
 606
 607         sband = priv->hw->wiphy->bands[priv->hw->conf.channel->band];
 608
 609         for (i = 0, j = 0; i < sband->n_bitrates; i++) {
 610                 if (sta->supp_rates[sband->band] & BIT(i)) {
 611                         trate->rates.legacy_rates.rs_rates[j]
 612                                 = (sband->bitrates[i].bitrate * 2) / 10;
 613                         j++;
 614                 }
 615         }
 616         trate->rates.legacy_rates.rs_nrates = j;
 617
 618         if (sta->ht_cap.ht_supported) {
 619                 for (i = 0, j = 0; i < 77; i++) {
 620                         if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
 621                                 trate->rates.ht_rates.rs_rates[j++] = i;
 622                         if (j == ATH_HTC_RATE_MAX)
 623                                 break;
 624                 }
 625                 trate->rates.ht_rates.rs_nrates = j;
 626
 627                 caps = WLAN_RC_HT_FLAG;
 628                 if (sta->ht_cap.mcs.rx_mask[1])
 629                         caps |= WLAN_RC_DS_FLAG;
 630                 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
 631                      (conf_is_ht40(&priv->hw->conf)))
 632                         caps |= WLAN_RC_40_FLAG;
 633                 if (conf_is_ht40(&priv->hw->conf) &&
 634                     (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
 635                         caps |= WLAN_RC_SGI_FLAG;
 636                 else if (conf_is_ht20(&priv->hw->conf) &&
 637                          (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20))
 638                         caps |= WLAN_RC_SGI_FLAG;
 639         }
 640
 641         trate->sta_index = ista->index;
 642         trate->isnew = 1;
 643         trate->capflags = cpu_to_be32(caps);
 644 }
 645
 646 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
 647                                     struct ath9k_htc_target_rate *trate)
 648 {
 649         struct ath_common *common = ath9k_hw_common(priv->ah);
 650         int ret;
 651         u8 cmd_rsp;
 652
 653         WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
 654         if (ret) {
 655                 ath_err(common,
 656                         "Unable to initialize Rate information on target\n");
 657         }
 658
 659         return ret;
 660 }
 661
 662 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
 663                                 struct ieee80211_sta *sta)
 664 {
 665         struct ath_common *common = ath9k_hw_common(priv->ah);
 666         struct ath9k_htc_target_rate trate;
 667         int ret;
 668
 669         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 670         ath9k_htc_setup_rate(priv, sta, &trate);
 671         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 672         if (!ret)
 673                 ath_dbg(common, CONFIG,
 674                         "Updated target sta: %pM, rate caps: 0x%X\n",
 675                         sta->addr, be32_to_cpu(trate.capflags));
 676 }
 677
 678 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
 679                                   struct ieee80211_vif *vif,
 680                                   struct ieee80211_bss_conf *bss_conf)
 681 {
 682         struct ath_common *common = ath9k_hw_common(priv->ah);
 683         struct ath9k_htc_target_rate trate;
 684         struct ieee80211_sta *sta;
 685         int ret;
 686
 687         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 688
 689         rcu_read_lock();
 690         sta = ieee80211_find_sta(vif, bss_conf->bssid);
 691         if (!sta) {
 692                 rcu_read_unlock();
 693                 return;
 694         }
 695         ath9k_htc_setup_rate(priv, sta, &trate);
 696         rcu_read_unlock();
 697
 698         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 699         if (!ret)
 700                 ath_dbg(common, CONFIG,
 701                         "Updated target sta: %pM, rate caps: 0x%X\n",
 702                         bss_conf->bssid, be32_to_cpu(trate.capflags));
 703 }
 704
 705 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
 706                                   struct ieee80211_vif *vif,
 707                                   struct ieee80211_sta *sta,
 708                                   enum ieee80211_ampdu_mlme_action action,
 709                                   u16 tid)
 710 {
 711         struct ath_common *common = ath9k_hw_common(priv->ah);
 712         struct ath9k_htc_target_aggr aggr;
 713         struct ath9k_htc_sta *ista;
 714         int ret = 0;
 715         u8 cmd_rsp;
 716
 717         if (tid >= ATH9K_HTC_MAX_TID)
 718                 return -EINVAL;
 719
 720         memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr));
 721         ista = (struct ath9k_htc_sta *) sta->drv_priv;
 722
 723         aggr.sta_index = ista->index;
 724         aggr.tidno = tid & 0xf;
 725         aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false;
 726
 727         WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
 728         if (ret)
 729                 ath_dbg(common, CONFIG,
 730                         "Unable to %s TX aggregation for (%pM, %d)\n",
 731                         (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
 732         else
 733                 ath_dbg(common, CONFIG,
 734                         "%s TX aggregation for (%pM, %d)\n",
 735                         (aggr.aggr_enable) ? "Starting" : "Stopping",
 736                         sta->addr, tid);
 737
 738         spin_lock_bh(&priv->tx.tx_lock);
 739         ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
 740         spin_unlock_bh(&priv->tx.tx_lock);
 741
 742         return ret;
 743 }
 744
 745 /*******/
 746 /* ANI */
 747 /*******/
 748
 749 void ath9k_htc_start_ani(struct ath9k_htc_priv *priv)
 750 {
 751         struct ath_common *common = ath9k_hw_common(priv->ah);
 752         unsigned long timestamp = jiffies_to_msecs(jiffies);
 753
 754         common->ani.longcal_timer = timestamp;
 755         common->ani.shortcal_timer = timestamp;
 756         common->ani.checkani_timer = timestamp;
 757
 758         set_bit(OP_ANI_RUNNING, &priv->op_flags);
 759
 760         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 761                                      msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
 762 }
 763
 764 void ath9k_htc_stop_ani(struct ath9k_htc_priv *priv)
 765 {
 766         cancel_delayed_work_sync(&priv->ani_work);
 767         clear_bit(OP_ANI_RUNNING, &priv->op_flags);
 768 }
 769
 770 void ath9k_htc_ani_work(struct work_struct *work)
 771 {
 772         struct ath9k_htc_priv *priv =
 773                 container_of(work, struct ath9k_htc_priv, ani_work.work);
 774         struct ath_hw *ah = priv->ah;
 775         struct ath_common *common = ath9k_hw_common(ah);
 776         bool longcal = false;
 777         bool shortcal = false;
 778         bool aniflag = false;
 779         unsigned int timestamp = jiffies_to_msecs(jiffies);
 780         u32 cal_interval, short_cal_interval;
 781
 782         short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
 783                 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
 784
 785         /* Only calibrate if awake */
 786         if (ah->power_mode != ATH9K_PM_AWAKE)
 787                 goto set_timer;
 788
 789         /* Long calibration runs independently of short calibration. */
 790         if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
 791                 longcal = true;
 792                 ath_dbg(common, ANI, "longcal @%lu\n", jiffies);
 793                 common->ani.longcal_timer = timestamp;
 794         }
 795
 796         /* Short calibration applies only while caldone is false */
 797         if (!common->ani.caldone) {
 798                 if ((timestamp - common->ani.shortcal_timer) >=
 799                     short_cal_interval) {
 800                         shortcal = true;
 801                         ath_dbg(common, ANI, "shortcal @%lu\n", jiffies);
 802                         common->ani.shortcal_timer = timestamp;
 803                         common->ani.resetcal_timer = timestamp;
 804                 }
 805         } else {
 806                 if ((timestamp - common->ani.resetcal_timer) >=
 807                     ATH_RESTART_CALINTERVAL) {
 808                         common->ani.caldone = ath9k_hw_reset_calvalid(ah);
 809                         if (common->ani.caldone)
 810                                 common->ani.resetcal_timer = timestamp;
 811                 }
 812         }
 813
 814         /* Verify whether we must check ANI */
 815         if (ah->config.enable_ani &&
 816             (timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
 817                 aniflag = true;
 818                 common->ani.checkani_timer = timestamp;
 819         }
 820
 821         /* Skip all processing if there's nothing to do. */
 822         if (longcal || shortcal || aniflag) {
 823
 824                 ath9k_htc_ps_wakeup(priv);
 825
 826                 /* Call ANI routine if necessary */
 827                 if (aniflag)
 828                         ath9k_hw_ani_monitor(ah, ah->curchan);
 829
 830                 /* Perform calibration if necessary */
 831                 if (longcal || shortcal)
 832                         common->ani.caldone =
 833                                 ath9k_hw_calibrate(ah, ah->curchan,
 834                                                    ah->rxchainmask, longcal);
 835
 836                 ath9k_htc_ps_restore(priv);
 837         }
 838
 839 set_timer:
 840         /*
 841         * Set timer interval based on previous results.
 842         * The interval must be the shortest necessary to satisfy ANI,
 843         * short calibration and long calibration.
 844         */
 845         cal_interval = ATH_LONG_CALINTERVAL;
 846         if (ah->config.enable_ani)
 847                 cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
 848         if (!common->ani.caldone)
 849                 cal_interval = min(cal_interval, (u32)short_cal_interval);
 850
 851         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 852                                      msecs_to_jiffies(cal_interval));
 853 }
 854
 855 /**********************/
 856 /* mac80211 Callbacks */
 857 /**********************/
 858
 859 static void ath9k_htc_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
 860 {
 861         struct ieee80211_hdr *hdr;
 862         struct ath9k_htc_priv *priv = hw->priv;
 863         struct ath_common *common = ath9k_hw_common(priv->ah);
 864         int padpos, padsize, ret, slot;
 865
 866         hdr = (struct ieee80211_hdr *) skb->data;
 867
 868         /* Add the padding after the header if this is not already done */
 869         padpos = ath9k_cmn_padpos(hdr->frame_control);
 870         padsize = padpos & 3;
 871         if (padsize && skb->len > padpos) {
 872                 if (skb_headroom(skb) < padsize) {
 873                         ath_dbg(common, XMIT, "No room for padding\n");
 874                         goto fail_tx;
 875                 }
 876                 skb_push(skb, padsize);
 877                 memmove(skb->data, skb->data + padsize, padpos);
 878         }
 879
 880         slot = ath9k_htc_tx_get_slot(priv);
 881         if (slot < 0) {
 882                 ath_dbg(common, XMIT, "No free TX slot\n");
 883                 goto fail_tx;
 884         }
 885
 886         ret = ath9k_htc_tx_start(priv, skb, slot, false);
 887         if (ret != 0) {
 888                 ath_dbg(common, XMIT, "Tx failed\n");
 889                 goto clear_slot;
 890         }
 891
 892         ath9k_htc_check_stop_queues(priv);
 893
 894         return;
 895
 896 clear_slot:
 897         ath9k_htc_tx_clear_slot(priv, slot);
 898 fail_tx:
 899         dev_kfree_skb_any(skb);
 900 }
 901
 902 static int ath9k_htc_start(struct ieee80211_hw *hw)
 903 {
 904         struct ath9k_htc_priv *priv = hw->priv;
 905         struct ath_hw *ah = priv->ah;
 906         struct ath_common *common = ath9k_hw_common(ah);
 907         struct ieee80211_channel *curchan = hw->conf.channel;
 908         struct ath9k_channel *init_channel;
 909         int ret = 0;
 910         enum htc_phymode mode;
 911         __be16 htc_mode;
 912         u8 cmd_rsp;
 913
 914         mutex_lock(&priv->mutex);
 915
 916         ath_dbg(common, CONFIG,
 917                 "Starting driver with initial channel: %d MHz\n",
 918                 curchan->center_freq);
 919
 920         /* Ensure that HW is awake before flushing RX */
 921         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 922         WMI_CMD(WMI_FLUSH_RECV_CMDID);
 923
 924         /* setup initial channel */
 925         init_channel = ath9k_cmn_get_curchannel(hw, ah);
 926
 927         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 928         if (ret) {
 929                 ath_err(common,
 930                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
 931                         ret, curchan->center_freq);
 932                 mutex_unlock(&priv->mutex);
 933                 return ret;
 934         }
 935
 936         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 937                                &priv->curtxpow);
 938
 939         mode = ath9k_htc_get_curmode(priv, init_channel);
 940         htc_mode = cpu_to_be16(mode);
 941         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 942         WMI_CMD(WMI_ATH_INIT_CMDID);
 943         WMI_CMD(WMI_START_RECV_CMDID);
 944
 945         ath9k_host_rx_init(priv);
 946
 947         ret = ath9k_htc_update_cap_target(priv, 0);
 948         if (ret)
 949                 ath_dbg(common, CONFIG,
 950                         "Failed to update capability in target\n");
 951
 952         clear_bit(OP_INVALID, &priv->op_flags);
 953         htc_start(priv->htc);
 954
 955         spin_lock_bh(&priv->tx.tx_lock);
 956         priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
 957         spin_unlock_bh(&priv->tx.tx_lock);
 958
 959         ieee80211_wake_queues(hw);
 960
 961         mod_timer(&priv->tx.cleanup_timer,
 962                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 963
 964         ath9k_htc_start_btcoex(priv);
 965
 966         mutex_unlock(&priv->mutex);
 967
 968         return ret;
 969 }
 970
 971 static void ath9k_htc_stop(struct ieee80211_hw *hw)
 972 {
 973         struct ath9k_htc_priv *priv = hw->priv;
 974         struct ath_hw *ah = priv->ah;
 975         struct ath_common *common = ath9k_hw_common(ah);
 976         int ret __attribute__ ((unused));
 977         u8 cmd_rsp;
 978
 979         mutex_lock(&priv->mutex);
 980
 981         if (test_bit(OP_INVALID, &priv->op_flags)) {
 982                 ath_dbg(common, ANY, "Device not present\n");
 983                 mutex_unlock(&priv->mutex);
 984                 return;
 985         }
 986
 987         ath9k_htc_ps_wakeup(priv);
 988
 989         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 990         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 991         WMI_CMD(WMI_STOP_RECV_CMDID);
 992
 993         tasklet_kill(&priv->rx_tasklet);
 994
 995         del_timer_sync(&priv->tx.cleanup_timer);
 996         ath9k_htc_tx_drain(priv);
 997         ath9k_wmi_event_drain(priv);
 998
 999         mutex_unlock(&priv->mutex);
1000
1001         /* Cancel all the running timers/work .. */
1002         cancel_work_sync(&priv->fatal_work);
1003         cancel_work_sync(&priv->ps_work);
1004
1005 #ifdef CONFIG_MAC80211_LEDS
1006         cancel_work_sync(&priv->led_work);
1007 #endif
1008         ath9k_htc_stop_ani(priv);
1009
1010         mutex_lock(&priv->mutex);
1011
1012         ath9k_htc_stop_btcoex(priv);
1013
1014         /* Remove a monitor interface if it's present. */
1015         if (priv->ah->is_monitoring)
1016                 ath9k_htc_remove_monitor_interface(priv);
1017
1018         ath9k_hw_phy_disable(ah);
1019         ath9k_hw_disable(ah);
1020         ath9k_htc_ps_restore(priv);
1021         ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1022
1023         set_bit(OP_INVALID, &priv->op_flags);
1024
1025         ath_dbg(common, CONFIG, "Driver halt\n");
1026         mutex_unlock(&priv->mutex);
1027 }
1028
1029 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1030                                    struct ieee80211_vif *vif)
1031 {
1032         struct ath9k_htc_priv *priv = hw->priv;
1033         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1034         struct ath_common *common = ath9k_hw_common(priv->ah);
1035         struct ath9k_htc_target_vif hvif;
1036         int ret = 0;
1037         u8 cmd_rsp;
1038
1039         mutex_lock(&priv->mutex);
1040
1041         if (priv->nvifs >= ATH9K_HTC_MAX_VIF) {
1042                 mutex_unlock(&priv->mutex);
1043                 return -ENOBUFS;
1044         }
1045
1046         if (priv->num_ibss_vif ||
1047             (priv->nvifs && vif->type == NL80211_IFTYPE_ADHOC)) {
1048                 ath_err(common, "IBSS coexistence with other modes is not allowed\n");
1049                 mutex_unlock(&priv->mutex);
1050                 return -ENOBUFS;
1051         }
1052
1053         if (((vif->type == NL80211_IFTYPE_AP) ||
1054              (vif->type == NL80211_IFTYPE_ADHOC)) &&
1055             ((priv->num_ap_vif + priv->num_ibss_vif) >= ATH9K_HTC_MAX_BCN_VIF)) {
1056                 ath_err(common, "Max. number of beaconing interfaces reached\n");
1057                 mutex_unlock(&priv->mutex);
1058                 return -ENOBUFS;
1059         }
1060
1061         ath9k_htc_ps_wakeup(priv);
1062         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1063         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1064
1065         switch (vif->type) {
1066         case NL80211_IFTYPE_STATION:
1067                 hvif.opmode = HTC_M_STA;
1068                 break;
1069         case NL80211_IFTYPE_ADHOC:
1070                 hvif.opmode = HTC_M_IBSS;
1071                 break;
1072         case NL80211_IFTYPE_AP:
1073                 hvif.opmode = HTC_M_HOSTAP;
1074                 break;
1075         default:
1076                 ath_err(common,
1077                         "Interface type %d not yet supported\n", vif->type);
1078                 ret = -EOPNOTSUPP;
1079                 goto out;
1080         }
1081
1082         /* Index starts from zero on the target */
1083         avp->index = hvif.index = ffz(priv->vif_slot);
1084         hvif.rtsthreshold = cpu_to_be16(2304);
1085         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1086         if (ret)
1087                 goto out;
1088
1089         /*
1090          * We need a node in target to tx mgmt frames
1091          * before association.
1092          */
1093         ret = ath9k_htc_add_station(priv, vif, NULL);
1094         if (ret) {
1095                 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1096                 goto out;
1097         }
1098
1099         ath9k_htc_set_bssid_mask(priv, vif);
1100
1101         priv->vif_slot |= (1 << avp->index);
1102         priv->nvifs++;
1103
1104         INC_VIF(priv, vif->type);
1105
1106         if ((vif->type == NL80211_IFTYPE_AP) ||
1107             (vif->type == NL80211_IFTYPE_ADHOC))
1108                 ath9k_htc_assign_bslot(priv, vif);
1109
1110         ath9k_htc_set_opmode(priv);
1111
1112         if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1113             !test_bit(OP_ANI_RUNNING, &priv->op_flags)) {
1114                 ath9k_hw_set_tsfadjust(priv->ah, true);
1115                 ath9k_htc_start_ani(priv);
1116         }
1117
1118         ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n",
1119                 vif->type, avp->index);
1120
1121 out:
1122         ath9k_htc_ps_restore(priv);
1123         mutex_unlock(&priv->mutex);
1124
1125         return ret;
1126 }
1127
1128 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1129                                        struct ieee80211_vif *vif)
1130 {
1131         struct ath9k_htc_priv *priv = hw->priv;
1132         struct ath_common *common = ath9k_hw_common(priv->ah);
1133         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1134         struct ath9k_htc_target_vif hvif;
1135         int ret = 0;
1136         u8 cmd_rsp;
1137
1138         mutex_lock(&priv->mutex);
1139         ath9k_htc_ps_wakeup(priv);
1140
1141         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1142         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1143         hvif.index = avp->index;
1144         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1145         if (ret) {
1146                 ath_err(common, "Unable to remove interface at idx: %d\n",
1147                         avp->index);
1148         }
1149         priv->nvifs--;
1150         priv->vif_slot &= ~(1 << avp->index);
1151
1152         ath9k_htc_remove_station(priv, vif, NULL);
1153
1154         DEC_VIF(priv, vif->type);
1155
1156         if ((vif->type == NL80211_IFTYPE_AP) ||
1157             (vif->type == NL80211_IFTYPE_ADHOC))
1158                 ath9k_htc_remove_bslot(priv, vif);
1159
1160         ath9k_htc_set_opmode(priv);
1161
1162         ath9k_htc_set_bssid_mask(priv, vif);
1163
1164         /*
1165          * Stop ANI only if there are no associated station interfaces.
1166          */
1167         if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1168                 priv->rearm_ani = false;
1169                 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1170                                                    ath9k_htc_vif_iter, priv);
1171                 if (!priv->rearm_ani)
1172                         ath9k_htc_stop_ani(priv);
1173         }
1174
1175         ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index);
1176
1177         ath9k_htc_ps_restore(priv);
1178         mutex_unlock(&priv->mutex);
1179 }
1180
1181 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1182 {
1183         struct ath9k_htc_priv *priv = hw->priv;
1184         struct ath_common *common = ath9k_hw_common(priv->ah);
1185         struct ieee80211_conf *conf = &hw->conf;
1186         bool chip_reset = false;
1187         int ret = 0;
1188
1189         mutex_lock(&priv->mutex);
1190         ath9k_htc_ps_wakeup(priv);
1191
1192         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1193                 mutex_lock(&priv->htc_pm_lock);
1194
1195                 priv->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1196                 if (priv->ps_idle)
1197                         chip_reset = true;
1198
1199                 mutex_unlock(&priv->htc_pm_lock);
1200         }
1201
1202         /*
1203          * Monitor interface should be added before
1204          * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1205          */
1206         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1207                 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1208                     !priv->ah->is_monitoring)
1209                         ath9k_htc_add_monitor_interface(priv);
1210                 else if (priv->ah->is_monitoring)
1211                         ath9k_htc_remove_monitor_interface(priv);
1212         }
1213
1214         if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || chip_reset) {
1215                 struct ieee80211_channel *curchan = hw->conf.channel;
1216                 int pos = curchan->hw_value;
1217
1218                 ath_dbg(common, CONFIG, "Set channel: %d MHz\n",
1219                         curchan->center_freq);
1220
1221                 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1222                                           hw->conf.channel,
1223                                           hw->conf.channel_type);
1224
1225                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1226                         ath_err(common, "Unable to set channel\n");
1227                         ret = -EINVAL;
1228                         goto out;
1229                 }
1230
1231         }
1232
1233         if (changed & IEEE80211_CONF_CHANGE_PS) {
1234                 if (conf->flags & IEEE80211_CONF_PS) {
1235                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1236                         priv->ps_enabled = true;
1237                 } else {
1238                         priv->ps_enabled = false;
1239                         cancel_work_sync(&priv->ps_work);
1240                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1241                 }
1242         }
1243
1244         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1245                 priv->txpowlimit = 2 * conf->power_level;
1246                 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1247                                        priv->txpowlimit, &priv->curtxpow);
1248         }
1249
1250 out:
1251         ath9k_htc_ps_restore(priv);
1252         mutex_unlock(&priv->mutex);
1253         return ret;
1254 }
1255
1256 #define SUPPORTED_FILTERS                       \
1257         (FIF_PROMISC_IN_BSS |                   \
1258         FIF_ALLMULTI |                          \
1259         FIF_CONTROL |                           \
1260         FIF_PSPOLL |                            \
1261         FIF_OTHER_BSS |                         \
1262         FIF_BCN_PRBRESP_PROMISC |               \
1263         FIF_PROBE_REQ |                         \
1264         FIF_FCSFAIL)
1265
1266 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1267                                        unsigned int changed_flags,
1268                                        unsigned int *total_flags,
1269                                        u64 multicast)
1270 {
1271         struct ath9k_htc_priv *priv = hw->priv;
1272         u32 rfilt;
1273
1274         mutex_lock(&priv->mutex);
1275         changed_flags &= SUPPORTED_FILTERS;
1276         *total_flags &= SUPPORTED_FILTERS;
1277
1278         if (test_bit(OP_INVALID, &priv->op_flags)) {
1279                 ath_dbg(ath9k_hw_common(priv->ah), ANY,
1280                         "Unable to configure filter on invalid state\n");
1281                 mutex_unlock(&priv->mutex);
1282                 return;
1283         }
1284         ath9k_htc_ps_wakeup(priv);
1285
1286         priv->rxfilter = *total_flags;
1287         rfilt = ath9k_htc_calcrxfilter(priv);
1288         ath9k_hw_setrxfilter(priv->ah, rfilt);
1289
1290         ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1291                 rfilt);
1292
1293         ath9k_htc_ps_restore(priv);
1294         mutex_unlock(&priv->mutex);
1295 }
1296
1297 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1298                              struct ieee80211_vif *vif,
1299                              struct ieee80211_sta *sta)
1300 {
1301         struct ath9k_htc_priv *priv = hw->priv;
1302         int ret;
1303
1304         mutex_lock(&priv->mutex);
1305         ath9k_htc_ps_wakeup(priv);
1306         ret = ath9k_htc_add_station(priv, vif, sta);
1307         if (!ret)
1308                 ath9k_htc_init_rate(priv, sta);
1309         ath9k_htc_ps_restore(priv);
1310         mutex_unlock(&priv->mutex);
1311
1312         return ret;
1313 }
1314
1315 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1316                                 struct ieee80211_vif *vif,
1317                                 struct ieee80211_sta *sta)
1318 {
1319         struct ath9k_htc_priv *priv = hw->priv;
1320         struct ath9k_htc_sta *ista;
1321         int ret;
1322
1323         mutex_lock(&priv->mutex);
1324         ath9k_htc_ps_wakeup(priv);
1325         ista = (struct ath9k_htc_sta *) sta->drv_priv;
1326         htc_sta_drain(priv->htc, ista->index);
1327         ret = ath9k_htc_remove_station(priv, vif, sta);
1328         ath9k_htc_ps_restore(priv);
1329         mutex_unlock(&priv->mutex);
1330
1331         return ret;
1332 }
1333
1334 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1335                              struct ieee80211_vif *vif, u16 queue,
1336                              const struct ieee80211_tx_queue_params *params)
1337 {
1338         struct ath9k_htc_priv *priv = hw->priv;
1339         struct ath_common *common = ath9k_hw_common(priv->ah);
1340         struct ath9k_tx_queue_info qi;
1341         int ret = 0, qnum;
1342
1343         if (queue >= WME_NUM_AC)
1344                 return 0;
1345
1346         mutex_lock(&priv->mutex);
1347         ath9k_htc_ps_wakeup(priv);
1348
1349         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1350
1351         qi.tqi_aifs = params->aifs;
1352         qi.tqi_cwmin = params->cw_min;
1353         qi.tqi_cwmax = params->cw_max;
1354         qi.tqi_burstTime = params->txop * 32;
1355
1356         qnum = get_hw_qnum(queue, priv->hwq_map);
1357
1358         ath_dbg(common, CONFIG,
1359                 "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1360                 queue, qnum, params->aifs, params->cw_min,
1361                 params->cw_max, params->txop);
1362
1363         ret = ath_htc_txq_update(priv, qnum, &qi);
1364         if (ret) {
1365                 ath_err(common, "TXQ Update failed\n");
1366                 goto out;
1367         }
1368
1369         if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1370             (qnum == priv->hwq_map[WME_AC_BE]))
1371                     ath9k_htc_beaconq_config(priv);
1372 out:
1373         ath9k_htc_ps_restore(priv);
1374         mutex_unlock(&priv->mutex);
1375
1376         return ret;
1377 }
1378
1379 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1380                              enum set_key_cmd cmd,
1381                              struct ieee80211_vif *vif,
1382                              struct ieee80211_sta *sta,
1383                              struct ieee80211_key_conf *key)
1384 {
1385         struct ath9k_htc_priv *priv = hw->priv;
1386         struct ath_common *common = ath9k_hw_common(priv->ah);
1387         int ret = 0;
1388
1389         if (htc_modparam_nohwcrypt)
1390                 return -ENOSPC;
1391
1392         if ((vif->type == NL80211_IFTYPE_ADHOC ||
1393              vif->type == NL80211_IFTYPE_MESH_POINT) &&
1394             (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1395              key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1396             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1397                 /*
1398                  * For now, disable hw crypto for the RSN IBSS group keys. This
1399                  * could be optimized in the future to use a modified key cache
1400                  * design to support per-STA RX GTK, but until that gets
1401                  * implemented, use of software crypto for group addressed
1402                  * frames is a acceptable to allow RSN IBSS to be used.
1403                  */
1404                 return -EOPNOTSUPP;
1405         }
1406
1407         mutex_lock(&priv->mutex);
1408         ath_dbg(common, CONFIG, "Set HW Key\n");
1409         ath9k_htc_ps_wakeup(priv);
1410
1411         switch (cmd) {
1412         case SET_KEY:
1413                 ret = ath_key_config(common, vif, sta, key);
1414                 if (ret >= 0) {
1415                         key->hw_key_idx = ret;
1416                         /* push IV and Michael MIC generation to stack */
1417                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1418                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1419                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1420                         if (priv->ah->sw_mgmt_crypto &&
1421                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1422                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
1423                         ret = 0;
1424                 }
1425                 break;
1426         case DISABLE_KEY:
1427                 ath_key_delete(common, key);
1428                 break;
1429         default:
1430                 ret = -EINVAL;
1431         }
1432
1433         ath9k_htc_ps_restore(priv);
1434         mutex_unlock(&priv->mutex);
1435
1436         return ret;
1437 }
1438
1439 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1440 {
1441         struct ath_common *common = ath9k_hw_common(priv->ah);
1442
1443         ath9k_hw_write_associd(priv->ah);
1444         ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1445                 common->curbssid, common->curaid);
1446 }
1447
1448 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1449 {
1450         struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data;
1451         struct ath_common *common = ath9k_hw_common(priv->ah);
1452         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1453
1454         if ((vif->type == NL80211_IFTYPE_STATION) && bss_conf->assoc) {
1455                 common->curaid = bss_conf->aid;
1456                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1457         }
1458 }
1459
1460 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1461 {
1462         if (priv->num_sta_assoc_vif == 1) {
1463                 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1464                                                            ath9k_htc_bss_iter, priv);
1465                 ath9k_htc_set_bssid(priv);
1466         }
1467 }
1468
1469 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1470                                        struct ieee80211_vif *vif,
1471                                        struct ieee80211_bss_conf *bss_conf,
1472                                        u32 changed)
1473 {
1474         struct ath9k_htc_priv *priv = hw->priv;
1475         struct ath_hw *ah = priv->ah;
1476         struct ath_common *common = ath9k_hw_common(ah);
1477
1478         mutex_lock(&priv->mutex);
1479         ath9k_htc_ps_wakeup(priv);
1480
1481         if (changed & BSS_CHANGED_ASSOC) {
1482                 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1483                         bss_conf->assoc);
1484
1485                 bss_conf->assoc ?
1486                         priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1487
1488                 if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1489                         ath9k_htc_choose_set_bssid(priv);
1490                         if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1))
1491                                 ath9k_htc_start_ani(priv);
1492                         else if (priv->num_sta_assoc_vif == 0)
1493                                 ath9k_htc_stop_ani(priv);
1494                 }
1495         }
1496
1497         if (changed & BSS_CHANGED_IBSS) {
1498                 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1499                         common->curaid = bss_conf->aid;
1500                         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1501                         ath9k_htc_set_bssid(priv);
1502                 }
1503         }
1504
1505         if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1506                 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1507                         bss_conf->bssid);
1508                 ath9k_htc_set_tsfadjust(priv, vif);
1509                 set_bit(OP_ENABLE_BEACON, &priv->op_flags);
1510                 ath9k_htc_beacon_config(priv, vif);
1511         }
1512
1513         if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1514                 /*
1515                  * Disable SWBA interrupt only if there are no
1516                  * AP/IBSS interfaces.
1517                  */
1518                 if ((priv->num_ap_vif <= 1) || priv->num_ibss_vif) {
1519                         ath_dbg(common, CONFIG,
1520                                 "Beacon disabled for BSS: %pM\n",
1521                                 bss_conf->bssid);
1522                         clear_bit(OP_ENABLE_BEACON, &priv->op_flags);
1523                         ath9k_htc_beacon_config(priv, vif);
1524                 }
1525         }
1526
1527         if (changed & BSS_CHANGED_BEACON_INT) {
1528                 /*
1529                  * Reset the HW TSF for the first AP interface.
1530                  */
1531                 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1532                     (priv->nvifs == 1) &&
1533                     (priv->num_ap_vif == 1) &&
1534                     (vif->type == NL80211_IFTYPE_AP)) {
1535                         set_bit(OP_TSF_RESET, &priv->op_flags);
1536                 }
1537                 ath_dbg(common, CONFIG,
1538                         "Beacon interval changed for BSS: %pM\n",
1539                         bss_conf->bssid);
1540                 ath9k_htc_beacon_config(priv, vif);
1541         }
1542
1543         if (changed & BSS_CHANGED_ERP_SLOT) {
1544                 if (bss_conf->use_short_slot)
1545                         ah->slottime = 9;
1546                 else
1547                         ah->slottime = 20;
1548
1549                 ath9k_hw_init_global_settings(ah);
1550         }
1551
1552         if (changed & BSS_CHANGED_HT)
1553                 ath9k_htc_update_rate(priv, vif, bss_conf);
1554
1555         ath9k_htc_ps_restore(priv);
1556         mutex_unlock(&priv->mutex);
1557 }
1558
1559 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1560                              struct ieee80211_vif *vif)
1561 {
1562         struct ath9k_htc_priv *priv = hw->priv;
1563         u64 tsf;
1564
1565         mutex_lock(&priv->mutex);
1566         ath9k_htc_ps_wakeup(priv);
1567         tsf = ath9k_hw_gettsf64(priv->ah);
1568         ath9k_htc_ps_restore(priv);
1569         mutex_unlock(&priv->mutex);
1570
1571         return tsf;
1572 }
1573
1574 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1575                               struct ieee80211_vif *vif, u64 tsf)
1576 {
1577         struct ath9k_htc_priv *priv = hw->priv;
1578
1579         mutex_lock(&priv->mutex);
1580         ath9k_htc_ps_wakeup(priv);
1581         ath9k_hw_settsf64(priv->ah, tsf);
1582         ath9k_htc_ps_restore(priv);
1583         mutex_unlock(&priv->mutex);
1584 }
1585
1586 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1587                                 struct ieee80211_vif *vif)
1588 {
1589         struct ath9k_htc_priv *priv = hw->priv;
1590
1591         mutex_lock(&priv->mutex);
1592         ath9k_htc_ps_wakeup(priv);
1593         ath9k_hw_reset_tsf(priv->ah);
1594         ath9k_htc_ps_restore(priv);
1595         mutex_unlock(&priv->mutex);
1596 }
1597
1598 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1599                                   struct ieee80211_vif *vif,
1600                                   enum ieee80211_ampdu_mlme_action action,
1601                                   struct ieee80211_sta *sta,
1602                                   u16 tid, u16 *ssn, u8 buf_size)
1603 {
1604         struct ath9k_htc_priv *priv = hw->priv;
1605         struct ath9k_htc_sta *ista;
1606         int ret = 0;
1607
1608         mutex_lock(&priv->mutex);
1609         ath9k_htc_ps_wakeup(priv);
1610
1611         switch (action) {
1612         case IEEE80211_AMPDU_RX_START:
1613                 break;
1614         case IEEE80211_AMPDU_RX_STOP:
1615                 break;
1616         case IEEE80211_AMPDU_TX_START:
1617                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1618                 if (!ret)
1619                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1620                 break;
1621         case IEEE80211_AMPDU_TX_STOP:
1622                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1623                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1624                 break;
1625         case IEEE80211_AMPDU_TX_OPERATIONAL:
1626                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1627                 spin_lock_bh(&priv->tx.tx_lock);
1628                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1629                 spin_unlock_bh(&priv->tx.tx_lock);
1630                 break;
1631         default:
1632                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1633         }
1634
1635         ath9k_htc_ps_restore(priv);
1636         mutex_unlock(&priv->mutex);
1637
1638         return ret;
1639 }
1640
1641 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw)
1642 {
1643         struct ath9k_htc_priv *priv = hw->priv;
1644
1645         mutex_lock(&priv->mutex);
1646         spin_lock_bh(&priv->beacon_lock);
1647         set_bit(OP_SCANNING, &priv->op_flags);
1648         spin_unlock_bh(&priv->beacon_lock);
1649         cancel_work_sync(&priv->ps_work);
1650         ath9k_htc_stop_ani(priv);
1651         mutex_unlock(&priv->mutex);
1652 }
1653
1654 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
1655 {
1656         struct ath9k_htc_priv *priv = hw->priv;
1657
1658         mutex_lock(&priv->mutex);
1659         spin_lock_bh(&priv->beacon_lock);
1660         clear_bit(OP_SCANNING, &priv->op_flags);
1661         spin_unlock_bh(&priv->beacon_lock);
1662         ath9k_htc_ps_wakeup(priv);
1663         ath9k_htc_vif_reconfig(priv);
1664         ath9k_htc_ps_restore(priv);
1665         mutex_unlock(&priv->mutex);
1666 }
1667
1668 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1669 {
1670         return 0;
1671 }
1672
1673 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1674                                          u8 coverage_class)
1675 {
1676         struct ath9k_htc_priv *priv = hw->priv;
1677
1678         mutex_lock(&priv->mutex);
1679         ath9k_htc_ps_wakeup(priv);
1680         priv->ah->coverage_class = coverage_class;
1681         ath9k_hw_init_global_settings(priv->ah);
1682         ath9k_htc_ps_restore(priv);
1683         mutex_unlock(&priv->mutex);
1684 }
1685
1686 /*
1687  * Currently, this is used only for selecting the minimum rate
1688  * for management frames, rate selection for data frames remain
1689  * unaffected.
1690  */
1691 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1692                                       struct ieee80211_vif *vif,
1693                                       const struct cfg80211_bitrate_mask *mask)
1694 {
1695         struct ath9k_htc_priv *priv = hw->priv;
1696         struct ath_common *common = ath9k_hw_common(priv->ah);
1697         struct ath9k_htc_target_rate_mask tmask;
1698         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1699         int ret = 0;
1700         u8 cmd_rsp;
1701
1702         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1703
1704         tmask.vif_index = avp->index;
1705         tmask.band = IEEE80211_BAND_2GHZ;
1706         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1707
1708         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1709         if (ret) {
1710                 ath_err(common,
1711                         "Unable to set 2G rate mask for "
1712                         "interface at idx: %d\n", avp->index);
1713                 goto out;
1714         }
1715
1716         tmask.band = IEEE80211_BAND_5GHZ;
1717         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1718
1719         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1720         if (ret) {
1721                 ath_err(common,
1722                         "Unable to set 5G rate mask for "
1723                         "interface at idx: %d\n", avp->index);
1724                 goto out;
1725         }
1726
1727         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1728                 mask->control[IEEE80211_BAND_2GHZ].legacy,
1729                 mask->control[IEEE80211_BAND_5GHZ].legacy);
1730 out:
1731         return ret;
1732 }
1733
1734
1735 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1736                                struct ieee80211_low_level_stats *stats)
1737 {
1738         struct ath9k_htc_priv *priv = hw->priv;
1739         struct ath_hw *ah = priv->ah;
1740         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1741
1742         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1743         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1744         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1745         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1746
1747         return 0;
1748 }
1749
1750 struct ieee80211_ops ath9k_htc_ops = {
1751         .tx                 = ath9k_htc_tx,
1752         .start              = ath9k_htc_start,
1753         .stop               = ath9k_htc_stop,
1754         .add_interface      = ath9k_htc_add_interface,
1755         .remove_interface   = ath9k_htc_remove_interface,
1756         .config             = ath9k_htc_config,
1757         .configure_filter   = ath9k_htc_configure_filter,
1758         .sta_add            = ath9k_htc_sta_add,
1759         .sta_remove         = ath9k_htc_sta_remove,
1760         .conf_tx            = ath9k_htc_conf_tx,
1761         .bss_info_changed   = ath9k_htc_bss_info_changed,
1762         .set_key            = ath9k_htc_set_key,
1763         .get_tsf            = ath9k_htc_get_tsf,
1764         .set_tsf            = ath9k_htc_set_tsf,
1765         .reset_tsf          = ath9k_htc_reset_tsf,
1766         .ampdu_action       = ath9k_htc_ampdu_action,
1767         .sw_scan_start      = ath9k_htc_sw_scan_start,
1768         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1769         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1770         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1771         .set_coverage_class = ath9k_htc_set_coverage_class,
1772         .set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1773         .get_stats          = ath9k_htc_get_stats,
1774 };