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