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                 ista->index = sta_idx;
 493                 tsta.is_vif_sta = 0;
 494                 maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 495                                  sta->ht_cap.ampdu_factor);
 496                 tsta.maxampdu = cpu_to_be16(maxampdu);
 497         } else {
 498                 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN);
 499                 tsta.is_vif_sta = 1;
 500                 tsta.maxampdu = cpu_to_be16(0xffff);
 501         }
 502
 503         tsta.sta_index = sta_idx;
 504         tsta.vif_index = avp->index;
 505
 506         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
 507         if (ret) {
 508                 if (sta)
 509                         ath_err(common,
 510                                 "Unable to add station entry for: %pM\n",
 511                                 sta->addr);
 512                 return ret;
 513         }
 514
 515         if (sta) {
 516                 ath_dbg(common, CONFIG,
 517                         "Added a station entry for: %pM (idx: %d)\n",
 518                         sta->addr, tsta.sta_index);
 519         } else {
 520                 ath_dbg(common, CONFIG,
 521                         "Added a station entry for VIF %d (idx: %d)\n",
 522                         avp->index, tsta.sta_index);
 523         }
 524
 525         priv->sta_slot |= (1 << sta_idx);
 526         priv->nstations++;
 527         if (!sta)
 528                 priv->vif_sta_pos[avp->index] = sta_idx;
 529
 530         return 0;
 531 }
 532
 533 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
 534                                     struct ieee80211_vif *vif,
 535                                     struct ieee80211_sta *sta)
 536 {
 537         struct ath_common *common = ath9k_hw_common(priv->ah);
 538         struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
 539         struct ath9k_htc_sta *ista;
 540         int ret;
 541         u8 cmd_rsp, sta_idx;
 542
 543         if (sta) {
 544                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
 545                 sta_idx = ista->index;
 546         } else {
 547                 sta_idx = priv->vif_sta_pos[avp->index];
 548         }
 549
 550         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
 551         if (ret) {
 552                 if (sta)
 553                         ath_err(common,
 554                                 "Unable to remove station entry for: %pM\n",
 555                                 sta->addr);
 556                 return ret;
 557         }
 558
 559         if (sta) {
 560                 ath_dbg(common, CONFIG,
 561                         "Removed a station entry for: %pM (idx: %d)\n",
 562                         sta->addr, sta_idx);
 563         } else {
 564                 ath_dbg(common, CONFIG,
 565                         "Removed a station entry for VIF %d (idx: %d)\n",
 566                         avp->index, sta_idx);
 567         }
 568
 569         priv->sta_slot &= ~(1 << sta_idx);
 570         priv->nstations--;
 571
 572         return 0;
 573 }
 574
 575 int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv,
 576                                 u8 enable_coex)
 577 {
 578         struct ath9k_htc_cap_target tcap;
 579         int ret;
 580         u8 cmd_rsp;
 581
 582         memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target));
 583
 584         tcap.ampdu_limit = cpu_to_be32(0xffff);
 585         tcap.ampdu_subframes = 0xff;
 586         tcap.enable_coex = enable_coex;
 587         tcap.tx_chainmask = priv->ah->caps.tx_chainmask;
 588
 589         WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap);
 590
 591         return ret;
 592 }
 593
 594 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv,
 595                                  struct ieee80211_sta *sta,
 596                                  struct ath9k_htc_target_rate *trate)
 597 {
 598         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
 599         struct ieee80211_supported_band *sband;
 600         u32 caps = 0;
 601         int i, j;
 602
 603         sband = priv->hw->wiphy->bands[priv->hw->conf.channel->band];
 604
 605         for (i = 0, j = 0; i < sband->n_bitrates; i++) {
 606                 if (sta->supp_rates[sband->band] & BIT(i)) {
 607                         trate->rates.legacy_rates.rs_rates[j]
 608                                 = (sband->bitrates[i].bitrate * 2) / 10;
 609                         j++;
 610                 }
 611         }
 612         trate->rates.legacy_rates.rs_nrates = j;
 613
 614         if (sta->ht_cap.ht_supported) {
 615                 for (i = 0, j = 0; i < 77; i++) {
 616                         if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
 617                                 trate->rates.ht_rates.rs_rates[j++] = i;
 618                         if (j == ATH_HTC_RATE_MAX)
 619                                 break;
 620                 }
 621                 trate->rates.ht_rates.rs_nrates = j;
 622
 623                 caps = WLAN_RC_HT_FLAG;
 624                 if (sta->ht_cap.mcs.rx_mask[1])
 625                         caps |= WLAN_RC_DS_FLAG;
 626                 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
 627                      (conf_is_ht40(&priv->hw->conf)))
 628                         caps |= WLAN_RC_40_FLAG;
 629                 if (conf_is_ht40(&priv->hw->conf) &&
 630                     (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
 631                         caps |= WLAN_RC_SGI_FLAG;
 632                 else if (conf_is_ht20(&priv->hw->conf) &&
 633                          (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20))
 634                         caps |= WLAN_RC_SGI_FLAG;
 635         }
 636
 637         trate->sta_index = ista->index;
 638         trate->isnew = 1;
 639         trate->capflags = cpu_to_be32(caps);
 640 }
 641
 642 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
 643                                     struct ath9k_htc_target_rate *trate)
 644 {
 645         struct ath_common *common = ath9k_hw_common(priv->ah);
 646         int ret;
 647         u8 cmd_rsp;
 648
 649         WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
 650         if (ret) {
 651                 ath_err(common,
 652                         "Unable to initialize Rate information on target\n");
 653         }
 654
 655         return ret;
 656 }
 657
 658 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
 659                                 struct ieee80211_sta *sta)
 660 {
 661         struct ath_common *common = ath9k_hw_common(priv->ah);
 662         struct ath9k_htc_target_rate trate;
 663         int ret;
 664
 665         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 666         ath9k_htc_setup_rate(priv, sta, &trate);
 667         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 668         if (!ret)
 669                 ath_dbg(common, CONFIG,
 670                         "Updated target sta: %pM, rate caps: 0x%X\n",
 671                         sta->addr, be32_to_cpu(trate.capflags));
 672 }
 673
 674 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
 675                                   struct ieee80211_vif *vif,
 676                                   struct ieee80211_bss_conf *bss_conf)
 677 {
 678         struct ath_common *common = ath9k_hw_common(priv->ah);
 679         struct ath9k_htc_target_rate trate;
 680         struct ieee80211_sta *sta;
 681         int ret;
 682
 683         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 684
 685         rcu_read_lock();
 686         sta = ieee80211_find_sta(vif, bss_conf->bssid);
 687         if (!sta) {
 688                 rcu_read_unlock();
 689                 return;
 690         }
 691         ath9k_htc_setup_rate(priv, sta, &trate);
 692         rcu_read_unlock();
 693
 694         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 695         if (!ret)
 696                 ath_dbg(common, CONFIG,
 697                         "Updated target sta: %pM, rate caps: 0x%X\n",
 698                         bss_conf->bssid, be32_to_cpu(trate.capflags));
 699 }
 700
 701 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
 702                                   struct ieee80211_vif *vif,
 703                                   struct ieee80211_sta *sta,
 704                                   enum ieee80211_ampdu_mlme_action action,
 705                                   u16 tid)
 706 {
 707         struct ath_common *common = ath9k_hw_common(priv->ah);
 708         struct ath9k_htc_target_aggr aggr;
 709         struct ath9k_htc_sta *ista;
 710         int ret = 0;
 711         u8 cmd_rsp;
 712
 713         if (tid >= ATH9K_HTC_MAX_TID)
 714                 return -EINVAL;
 715
 716         memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr));
 717         ista = (struct ath9k_htc_sta *) sta->drv_priv;
 718
 719         aggr.sta_index = ista->index;
 720         aggr.tidno = tid & 0xf;
 721         aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false;
 722
 723         WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
 724         if (ret)
 725                 ath_dbg(common, CONFIG,
 726                         "Unable to %s TX aggregation for (%pM, %d)\n",
 727                         (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
 728         else
 729                 ath_dbg(common, CONFIG,
 730                         "%s TX aggregation for (%pM, %d)\n",
 731                         (aggr.aggr_enable) ? "Starting" : "Stopping",
 732                         sta->addr, tid);
 733
 734         spin_lock_bh(&priv->tx.tx_lock);
 735         ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
 736         spin_unlock_bh(&priv->tx.tx_lock);
 737
 738         return ret;
 739 }
 740
 741 /*******/
 742 /* ANI */
 743 /*******/
 744
 745 void ath9k_htc_start_ani(struct ath9k_htc_priv *priv)
 746 {
 747         struct ath_common *common = ath9k_hw_common(priv->ah);
 748         unsigned long timestamp = jiffies_to_msecs(jiffies);
 749
 750         common->ani.longcal_timer = timestamp;
 751         common->ani.shortcal_timer = timestamp;
 752         common->ani.checkani_timer = timestamp;
 753
 754         set_bit(OP_ANI_RUNNING, &priv->op_flags);
 755
 756         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 757                                      msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
 758 }
 759
 760 void ath9k_htc_stop_ani(struct ath9k_htc_priv *priv)
 761 {
 762         cancel_delayed_work_sync(&priv->ani_work);
 763         clear_bit(OP_ANI_RUNNING, &priv->op_flags);
 764 }
 765
 766 void ath9k_htc_ani_work(struct work_struct *work)
 767 {
 768         struct ath9k_htc_priv *priv =
 769                 container_of(work, struct ath9k_htc_priv, ani_work.work);
 770         struct ath_hw *ah = priv->ah;
 771         struct ath_common *common = ath9k_hw_common(ah);
 772         bool longcal = false;
 773         bool shortcal = false;
 774         bool aniflag = false;
 775         unsigned int timestamp = jiffies_to_msecs(jiffies);
 776         u32 cal_interval, short_cal_interval;
 777
 778         short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
 779                 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
 780
 781         /* Only calibrate if awake */
 782         if (ah->power_mode != ATH9K_PM_AWAKE)
 783                 goto set_timer;
 784
 785         /* Long calibration runs independently of short calibration. */
 786         if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
 787                 longcal = true;
 788                 ath_dbg(common, ANI, "longcal @%lu\n", jiffies);
 789                 common->ani.longcal_timer = timestamp;
 790         }
 791
 792         /* Short calibration applies only while caldone is false */
 793         if (!common->ani.caldone) {
 794                 if ((timestamp - common->ani.shortcal_timer) >=
 795                     short_cal_interval) {
 796                         shortcal = true;
 797                         ath_dbg(common, ANI, "shortcal @%lu\n", jiffies);
 798                         common->ani.shortcal_timer = timestamp;
 799                         common->ani.resetcal_timer = timestamp;
 800                 }
 801         } else {
 802                 if ((timestamp - common->ani.resetcal_timer) >=
 803                     ATH_RESTART_CALINTERVAL) {
 804                         common->ani.caldone = ath9k_hw_reset_calvalid(ah);
 805                         if (common->ani.caldone)
 806                                 common->ani.resetcal_timer = timestamp;
 807                 }
 808         }
 809
 810         /* Verify whether we must check ANI */
 811         if (ah->config.enable_ani &&
 812             (timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
 813                 aniflag = true;
 814                 common->ani.checkani_timer = timestamp;
 815         }
 816
 817         /* Skip all processing if there's nothing to do. */
 818         if (longcal || shortcal || aniflag) {
 819
 820                 ath9k_htc_ps_wakeup(priv);
 821
 822                 /* Call ANI routine if necessary */
 823                 if (aniflag)
 824                         ath9k_hw_ani_monitor(ah, ah->curchan);
 825
 826                 /* Perform calibration if necessary */
 827                 if (longcal || shortcal)
 828                         common->ani.caldone =
 829                                 ath9k_hw_calibrate(ah, ah->curchan,
 830                                                    ah->rxchainmask, longcal);
 831
 832                 ath9k_htc_ps_restore(priv);
 833         }
 834
 835 set_timer:
 836         /*
 837         * Set timer interval based on previous results.
 838         * The interval must be the shortest necessary to satisfy ANI,
 839         * short calibration and long calibration.
 840         */
 841         cal_interval = ATH_LONG_CALINTERVAL;
 842         if (ah->config.enable_ani)
 843                 cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
 844         if (!common->ani.caldone)
 845                 cal_interval = min(cal_interval, (u32)short_cal_interval);
 846
 847         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 848                                      msecs_to_jiffies(cal_interval));
 849 }
 850
 851 /**********************/
 852 /* mac80211 Callbacks */
 853 /**********************/
 854
 855 static void ath9k_htc_tx(struct ieee80211_hw *hw,
 856                          struct ieee80211_tx_control *control,
 857                          struct sk_buff *skb)
 858 {
 859         struct ieee80211_hdr *hdr;
 860         struct ath9k_htc_priv *priv = hw->priv;
 861         struct ath_common *common = ath9k_hw_common(priv->ah);
 862         int padpos, padsize, ret, slot;
 863
 864         hdr = (struct ieee80211_hdr *) skb->data;
 865
 866         /* Add the padding after the header if this is not already done */
 867         padpos = ath9k_cmn_padpos(hdr->frame_control);
 868         padsize = padpos & 3;
 869         if (padsize && skb->len > padpos) {
 870                 if (skb_headroom(skb) < padsize) {
 871                         ath_dbg(common, XMIT, "No room for padding\n");
 872                         goto fail_tx;
 873                 }
 874                 skb_push(skb, padsize);
 875                 memmove(skb->data, skb->data + padsize, padpos);
 876         }
 877
 878         slot = ath9k_htc_tx_get_slot(priv);
 879         if (slot < 0) {
 880                 ath_dbg(common, XMIT, "No free TX slot\n");
 881                 goto fail_tx;
 882         }
 883
 884         ret = ath9k_htc_tx_start(priv, control->sta, skb, slot, false);
 885         if (ret != 0) {
 886                 ath_dbg(common, XMIT, "Tx failed\n");
 887                 goto clear_slot;
 888         }
 889
 890         ath9k_htc_check_stop_queues(priv);
 891
 892         return;
 893
 894 clear_slot:
 895         ath9k_htc_tx_clear_slot(priv, slot);
 896 fail_tx:
 897         dev_kfree_skb_any(skb);
 898 }
 899
 900 static int ath9k_htc_start(struct ieee80211_hw *hw)
 901 {
 902         struct ath9k_htc_priv *priv = hw->priv;
 903         struct ath_hw *ah = priv->ah;
 904         struct ath_common *common = ath9k_hw_common(ah);
 905         struct ieee80211_channel *curchan = hw->conf.channel;
 906         struct ath9k_channel *init_channel;
 907         int ret = 0;
 908         enum htc_phymode mode;
 909         __be16 htc_mode;
 910         u8 cmd_rsp;
 911
 912         mutex_lock(&priv->mutex);
 913
 914         ath_dbg(common, CONFIG,
 915                 "Starting driver with initial channel: %d MHz\n",
 916                 curchan->center_freq);
 917
 918         /* Ensure that HW is awake before flushing RX */
 919         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 920         WMI_CMD(WMI_FLUSH_RECV_CMDID);
 921
 922         /* setup initial channel */
 923         init_channel = ath9k_cmn_get_curchannel(hw, ah);
 924
 925         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 926         if (ret) {
 927                 ath_err(common,
 928                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
 929                         ret, curchan->center_freq);
 930                 mutex_unlock(&priv->mutex);
 931                 return ret;
 932         }
 933
 934         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 935                                &priv->curtxpow);
 936
 937         mode = ath9k_htc_get_curmode(priv, init_channel);
 938         htc_mode = cpu_to_be16(mode);
 939         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 940         WMI_CMD(WMI_ATH_INIT_CMDID);
 941         WMI_CMD(WMI_START_RECV_CMDID);
 942
 943         ath9k_host_rx_init(priv);
 944
 945         ret = ath9k_htc_update_cap_target(priv, 0);
 946         if (ret)
 947                 ath_dbg(common, CONFIG,
 948                         "Failed to update capability in target\n");
 949
 950         clear_bit(OP_INVALID, &priv->op_flags);
 951         htc_start(priv->htc);
 952
 953         spin_lock_bh(&priv->tx.tx_lock);
 954         priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
 955         spin_unlock_bh(&priv->tx.tx_lock);
 956
 957         ieee80211_wake_queues(hw);
 958
 959         mod_timer(&priv->tx.cleanup_timer,
 960                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 961
 962         ath9k_htc_start_btcoex(priv);
 963
 964         mutex_unlock(&priv->mutex);
 965
 966         return ret;
 967 }
 968
 969 static void ath9k_htc_stop(struct ieee80211_hw *hw)
 970 {
 971         struct ath9k_htc_priv *priv = hw->priv;
 972         struct ath_hw *ah = priv->ah;
 973         struct ath_common *common = ath9k_hw_common(ah);
 974         int ret __attribute__ ((unused));
 975         u8 cmd_rsp;
 976
 977         mutex_lock(&priv->mutex);
 978
 979         if (test_bit(OP_INVALID, &priv->op_flags)) {
 980                 ath_dbg(common, ANY, "Device not present\n");
 981                 mutex_unlock(&priv->mutex);
 982                 return;
 983         }
 984
 985         ath9k_htc_ps_wakeup(priv);
 986
 987         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 988         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 989         WMI_CMD(WMI_STOP_RECV_CMDID);
 990
 991         tasklet_kill(&priv->rx_tasklet);
 992
 993         del_timer_sync(&priv->tx.cleanup_timer);
 994         ath9k_htc_tx_drain(priv);
 995         ath9k_wmi_event_drain(priv);
 996
 997         mutex_unlock(&priv->mutex);
 998
 999         /* Cancel all the running timers/work .. */
1000         cancel_work_sync(&priv->fatal_work);
1001         cancel_work_sync(&priv->ps_work);
1002
1003 #ifdef CONFIG_MAC80211_LEDS
1004         cancel_work_sync(&priv->led_work);
1005 #endif
1006         ath9k_htc_stop_ani(priv);
1007
1008         mutex_lock(&priv->mutex);
1009
1010         ath9k_htc_stop_btcoex(priv);
1011
1012         /* Remove a monitor interface if it's present. */
1013         if (priv->ah->is_monitoring)
1014                 ath9k_htc_remove_monitor_interface(priv);
1015
1016         ath9k_hw_phy_disable(ah);
1017         ath9k_hw_disable(ah);
1018         ath9k_htc_ps_restore(priv);
1019         ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1020
1021         set_bit(OP_INVALID, &priv->op_flags);
1022
1023         ath_dbg(common, CONFIG, "Driver halt\n");
1024         mutex_unlock(&priv->mutex);
1025 }
1026
1027 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1028                                    struct ieee80211_vif *vif)
1029 {
1030         struct ath9k_htc_priv *priv = hw->priv;
1031         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1032         struct ath_common *common = ath9k_hw_common(priv->ah);
1033         struct ath9k_htc_target_vif hvif;
1034         int ret = 0;
1035         u8 cmd_rsp;
1036
1037         mutex_lock(&priv->mutex);
1038
1039         if (priv->nvifs >= ATH9K_HTC_MAX_VIF) {
1040                 mutex_unlock(&priv->mutex);
1041                 return -ENOBUFS;
1042         }
1043
1044         if (priv->num_ibss_vif ||
1045             (priv->nvifs && vif->type == NL80211_IFTYPE_ADHOC)) {
1046                 ath_err(common, "IBSS coexistence with other modes is not allowed\n");
1047                 mutex_unlock(&priv->mutex);
1048                 return -ENOBUFS;
1049         }
1050
1051         if (((vif->type == NL80211_IFTYPE_AP) ||
1052              (vif->type == NL80211_IFTYPE_ADHOC)) &&
1053             ((priv->num_ap_vif + priv->num_ibss_vif) >= ATH9K_HTC_MAX_BCN_VIF)) {
1054                 ath_err(common, "Max. number of beaconing interfaces reached\n");
1055                 mutex_unlock(&priv->mutex);
1056                 return -ENOBUFS;
1057         }
1058
1059         ath9k_htc_ps_wakeup(priv);
1060         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1061         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1062
1063         switch (vif->type) {
1064         case NL80211_IFTYPE_STATION:
1065                 hvif.opmode = HTC_M_STA;
1066                 break;
1067         case NL80211_IFTYPE_ADHOC:
1068                 hvif.opmode = HTC_M_IBSS;
1069                 break;
1070         case NL80211_IFTYPE_AP:
1071                 hvif.opmode = HTC_M_HOSTAP;
1072                 break;
1073         default:
1074                 ath_err(common,
1075                         "Interface type %d not yet supported\n", vif->type);
1076                 ret = -EOPNOTSUPP;
1077                 goto out;
1078         }
1079
1080         /* Index starts from zero on the target */
1081         avp->index = hvif.index = ffz(priv->vif_slot);
1082         hvif.rtsthreshold = cpu_to_be16(2304);
1083         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1084         if (ret)
1085                 goto out;
1086
1087         /*
1088          * We need a node in target to tx mgmt frames
1089          * before association.
1090          */
1091         ret = ath9k_htc_add_station(priv, vif, NULL);
1092         if (ret) {
1093                 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1094                 goto out;
1095         }
1096
1097         ath9k_htc_set_bssid_mask(priv, vif);
1098
1099         priv->vif_slot |= (1 << avp->index);
1100         priv->nvifs++;
1101
1102         INC_VIF(priv, vif->type);
1103
1104         if ((vif->type == NL80211_IFTYPE_AP) ||
1105             (vif->type == NL80211_IFTYPE_ADHOC))
1106                 ath9k_htc_assign_bslot(priv, vif);
1107
1108         ath9k_htc_set_opmode(priv);
1109
1110         if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1111             !test_bit(OP_ANI_RUNNING, &priv->op_flags)) {
1112                 ath9k_hw_set_tsfadjust(priv->ah, true);
1113                 ath9k_htc_start_ani(priv);
1114         }
1115
1116         ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n",
1117                 vif->type, avp->index);
1118
1119 out:
1120         ath9k_htc_ps_restore(priv);
1121         mutex_unlock(&priv->mutex);
1122
1123         return ret;
1124 }
1125
1126 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1127                                        struct ieee80211_vif *vif)
1128 {
1129         struct ath9k_htc_priv *priv = hw->priv;
1130         struct ath_common *common = ath9k_hw_common(priv->ah);
1131         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1132         struct ath9k_htc_target_vif hvif;
1133         int ret = 0;
1134         u8 cmd_rsp;
1135
1136         mutex_lock(&priv->mutex);
1137         ath9k_htc_ps_wakeup(priv);
1138
1139         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1140         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1141         hvif.index = avp->index;
1142         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1143         if (ret) {
1144                 ath_err(common, "Unable to remove interface at idx: %d\n",
1145                         avp->index);
1146         }
1147         priv->nvifs--;
1148         priv->vif_slot &= ~(1 << avp->index);
1149
1150         ath9k_htc_remove_station(priv, vif, NULL);
1151
1152         DEC_VIF(priv, vif->type);
1153
1154         if ((vif->type == NL80211_IFTYPE_AP) ||
1155             (vif->type == NL80211_IFTYPE_ADHOC))
1156                 ath9k_htc_remove_bslot(priv, vif);
1157
1158         ath9k_htc_set_opmode(priv);
1159
1160         ath9k_htc_set_bssid_mask(priv, vif);
1161
1162         /*
1163          * Stop ANI only if there are no associated station interfaces.
1164          */
1165         if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1166                 priv->rearm_ani = false;
1167                 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1168                                                    ath9k_htc_vif_iter, priv);
1169                 if (!priv->rearm_ani)
1170                         ath9k_htc_stop_ani(priv);
1171         }
1172
1173         ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index);
1174
1175         ath9k_htc_ps_restore(priv);
1176         mutex_unlock(&priv->mutex);
1177 }
1178
1179 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1180 {
1181         struct ath9k_htc_priv *priv = hw->priv;
1182         struct ath_common *common = ath9k_hw_common(priv->ah);
1183         struct ieee80211_conf *conf = &hw->conf;
1184         bool chip_reset = false;
1185         int ret = 0;
1186
1187         mutex_lock(&priv->mutex);
1188         ath9k_htc_ps_wakeup(priv);
1189
1190         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1191                 mutex_lock(&priv->htc_pm_lock);
1192
1193                 priv->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1194                 if (priv->ps_idle)
1195                         chip_reset = true;
1196
1197                 mutex_unlock(&priv->htc_pm_lock);
1198         }
1199
1200         /*
1201          * Monitor interface should be added before
1202          * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1203          */
1204         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1205                 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1206                     !priv->ah->is_monitoring)
1207                         ath9k_htc_add_monitor_interface(priv);
1208                 else if (priv->ah->is_monitoring)
1209                         ath9k_htc_remove_monitor_interface(priv);
1210         }
1211
1212         if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || chip_reset) {
1213                 struct ieee80211_channel *curchan = hw->conf.channel;
1214                 int pos = curchan->hw_value;
1215
1216                 ath_dbg(common, CONFIG, "Set channel: %d MHz\n",
1217                         curchan->center_freq);
1218
1219                 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1220                                           hw->conf.channel,
1221                                           hw->conf.channel_type);
1222
1223                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1224                         ath_err(common, "Unable to set channel\n");
1225                         ret = -EINVAL;
1226                         goto out;
1227                 }
1228
1229         }
1230
1231         if (changed & IEEE80211_CONF_CHANGE_PS) {
1232                 if (conf->flags & IEEE80211_CONF_PS) {
1233                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1234                         priv->ps_enabled = true;
1235                 } else {
1236                         priv->ps_enabled = false;
1237                         cancel_work_sync(&priv->ps_work);
1238                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1239                 }
1240         }
1241
1242         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1243                 priv->txpowlimit = 2 * conf->power_level;
1244                 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1245                                        priv->txpowlimit, &priv->curtxpow);
1246         }
1247
1248 out:
1249         ath9k_htc_ps_restore(priv);
1250         mutex_unlock(&priv->mutex);
1251         return ret;
1252 }
1253
1254 #define SUPPORTED_FILTERS                       \
1255         (FIF_PROMISC_IN_BSS |                   \
1256         FIF_ALLMULTI |                          \
1257         FIF_CONTROL |                           \
1258         FIF_PSPOLL |                            \
1259         FIF_OTHER_BSS |                         \
1260         FIF_BCN_PRBRESP_PROMISC |               \
1261         FIF_PROBE_REQ |                         \
1262         FIF_FCSFAIL)
1263
1264 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1265                                        unsigned int changed_flags,
1266                                        unsigned int *total_flags,
1267                                        u64 multicast)
1268 {
1269         struct ath9k_htc_priv *priv = hw->priv;
1270         u32 rfilt;
1271
1272         mutex_lock(&priv->mutex);
1273         changed_flags &= SUPPORTED_FILTERS;
1274         *total_flags &= SUPPORTED_FILTERS;
1275
1276         if (test_bit(OP_INVALID, &priv->op_flags)) {
1277                 ath_dbg(ath9k_hw_common(priv->ah), ANY,
1278                         "Unable to configure filter on invalid state\n");
1279                 mutex_unlock(&priv->mutex);
1280                 return;
1281         }
1282         ath9k_htc_ps_wakeup(priv);
1283
1284         priv->rxfilter = *total_flags;
1285         rfilt = ath9k_htc_calcrxfilter(priv);
1286         ath9k_hw_setrxfilter(priv->ah, rfilt);
1287
1288         ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1289                 rfilt);
1290
1291         ath9k_htc_ps_restore(priv);
1292         mutex_unlock(&priv->mutex);
1293 }
1294
1295 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1296                              struct ieee80211_vif *vif,
1297                              struct ieee80211_sta *sta)
1298 {
1299         struct ath9k_htc_priv *priv = hw->priv;
1300         int ret;
1301
1302         mutex_lock(&priv->mutex);
1303         ath9k_htc_ps_wakeup(priv);
1304         ret = ath9k_htc_add_station(priv, vif, sta);
1305         if (!ret)
1306                 ath9k_htc_init_rate(priv, sta);
1307         ath9k_htc_ps_restore(priv);
1308         mutex_unlock(&priv->mutex);
1309
1310         return ret;
1311 }
1312
1313 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1314                                 struct ieee80211_vif *vif,
1315                                 struct ieee80211_sta *sta)
1316 {
1317         struct ath9k_htc_priv *priv = hw->priv;
1318         struct ath9k_htc_sta *ista;
1319         int ret;
1320
1321         mutex_lock(&priv->mutex);
1322         ath9k_htc_ps_wakeup(priv);
1323         ista = (struct ath9k_htc_sta *) sta->drv_priv;
1324         htc_sta_drain(priv->htc, ista->index);
1325         ret = ath9k_htc_remove_station(priv, vif, sta);
1326         ath9k_htc_ps_restore(priv);
1327         mutex_unlock(&priv->mutex);
1328
1329         return ret;
1330 }
1331
1332 static void ath9k_htc_sta_rc_update(struct ieee80211_hw *hw,
1333                                     struct ieee80211_vif *vif,
1334                                     struct ieee80211_sta *sta, u32 changed)
1335 {
1336         struct ath9k_htc_priv *priv = hw->priv;
1337         struct ath_common *common = ath9k_hw_common(priv->ah);
1338         struct ath9k_htc_target_rate trate;
1339
1340         mutex_lock(&priv->mutex);
1341         ath9k_htc_ps_wakeup(priv);
1342
1343         if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
1344                 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
1345                 ath9k_htc_setup_rate(priv, sta, &trate);
1346                 if (!ath9k_htc_send_rate_cmd(priv, &trate))
1347                         ath_dbg(common, CONFIG,
1348                                 "Supported rates for sta: %pM updated, rate caps: 0x%X\n",
1349                                 sta->addr, be32_to_cpu(trate.capflags));
1350                 else
1351                         ath_dbg(common, CONFIG,
1352                                 "Unable to update supported rates for sta: %pM\n",
1353                                 sta->addr);
1354         }
1355
1356         ath9k_htc_ps_restore(priv);
1357         mutex_unlock(&priv->mutex);
1358 }
1359
1360 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1361                              struct ieee80211_vif *vif, u16 queue,
1362                              const struct ieee80211_tx_queue_params *params)
1363 {
1364         struct ath9k_htc_priv *priv = hw->priv;
1365         struct ath_common *common = ath9k_hw_common(priv->ah);
1366         struct ath9k_tx_queue_info qi;
1367         int ret = 0, qnum;
1368
1369         if (queue >= WME_NUM_AC)
1370                 return 0;
1371
1372         mutex_lock(&priv->mutex);
1373         ath9k_htc_ps_wakeup(priv);
1374
1375         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1376
1377         qi.tqi_aifs = params->aifs;
1378         qi.tqi_cwmin = params->cw_min;
1379         qi.tqi_cwmax = params->cw_max;
1380         qi.tqi_burstTime = params->txop * 32;
1381
1382         qnum = get_hw_qnum(queue, priv->hwq_map);
1383
1384         ath_dbg(common, CONFIG,
1385                 "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1386                 queue, qnum, params->aifs, params->cw_min,
1387                 params->cw_max, params->txop);
1388
1389         ret = ath_htc_txq_update(priv, qnum, &qi);
1390         if (ret) {
1391                 ath_err(common, "TXQ Update failed\n");
1392                 goto out;
1393         }
1394
1395         if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1396             (qnum == priv->hwq_map[WME_AC_BE]))
1397                     ath9k_htc_beaconq_config(priv);
1398 out:
1399         ath9k_htc_ps_restore(priv);
1400         mutex_unlock(&priv->mutex);
1401
1402         return ret;
1403 }
1404
1405 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1406                              enum set_key_cmd cmd,
1407                              struct ieee80211_vif *vif,
1408                              struct ieee80211_sta *sta,
1409                              struct ieee80211_key_conf *key)
1410 {
1411         struct ath9k_htc_priv *priv = hw->priv;
1412         struct ath_common *common = ath9k_hw_common(priv->ah);
1413         int ret = 0;
1414
1415         if (htc_modparam_nohwcrypt)
1416                 return -ENOSPC;
1417
1418         if ((vif->type == NL80211_IFTYPE_ADHOC ||
1419              vif->type == NL80211_IFTYPE_MESH_POINT) &&
1420             (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1421              key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1422             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1423                 /*
1424                  * For now, disable hw crypto for the RSN IBSS group keys. This
1425                  * could be optimized in the future to use a modified key cache
1426                  * design to support per-STA RX GTK, but until that gets
1427                  * implemented, use of software crypto for group addressed
1428                  * frames is a acceptable to allow RSN IBSS to be used.
1429                  */
1430                 return -EOPNOTSUPP;
1431         }
1432
1433         mutex_lock(&priv->mutex);
1434         ath_dbg(common, CONFIG, "Set HW Key\n");
1435         ath9k_htc_ps_wakeup(priv);
1436
1437         switch (cmd) {
1438         case SET_KEY:
1439                 ret = ath_key_config(common, vif, sta, key);
1440                 if (ret >= 0) {
1441                         key->hw_key_idx = ret;
1442                         /* push IV and Michael MIC generation to stack */
1443                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1444                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1445                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1446                         if (priv->ah->sw_mgmt_crypto &&
1447                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1448                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1449                         ret = 0;
1450                 }
1451                 break;
1452         case DISABLE_KEY:
1453                 ath_key_delete(common, key);
1454                 break;
1455         default:
1456                 ret = -EINVAL;
1457         }
1458
1459         ath9k_htc_ps_restore(priv);
1460         mutex_unlock(&priv->mutex);
1461
1462         return ret;
1463 }
1464
1465 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1466 {
1467         struct ath_common *common = ath9k_hw_common(priv->ah);
1468
1469         ath9k_hw_write_associd(priv->ah);
1470         ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1471                 common->curbssid, common->curaid);
1472 }
1473
1474 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1475 {
1476         struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data;
1477         struct ath_common *common = ath9k_hw_common(priv->ah);
1478         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1479
1480         if ((vif->type == NL80211_IFTYPE_STATION) && bss_conf->assoc) {
1481                 common->curaid = bss_conf->aid;
1482                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1483         }
1484 }
1485
1486 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1487 {
1488         if (priv->num_sta_assoc_vif == 1) {
1489                 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1490                                                            ath9k_htc_bss_iter, priv);
1491                 ath9k_htc_set_bssid(priv);
1492         }
1493 }
1494
1495 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1496                                        struct ieee80211_vif *vif,
1497                                        struct ieee80211_bss_conf *bss_conf,
1498                                        u32 changed)
1499 {
1500         struct ath9k_htc_priv *priv = hw->priv;
1501         struct ath_hw *ah = priv->ah;
1502         struct ath_common *common = ath9k_hw_common(ah);
1503
1504         mutex_lock(&priv->mutex);
1505         ath9k_htc_ps_wakeup(priv);
1506
1507         if (changed & BSS_CHANGED_ASSOC) {
1508                 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1509                         bss_conf->assoc);
1510
1511                 bss_conf->assoc ?
1512                         priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1513
1514                 if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1515                         ath9k_htc_choose_set_bssid(priv);
1516                         if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1))
1517                                 ath9k_htc_start_ani(priv);
1518                         else if (priv->num_sta_assoc_vif == 0)
1519                                 ath9k_htc_stop_ani(priv);
1520                 }
1521         }
1522
1523         if (changed & BSS_CHANGED_IBSS) {
1524                 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1525                         common->curaid = bss_conf->aid;
1526                         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1527                         ath9k_htc_set_bssid(priv);
1528                 }
1529         }
1530
1531         if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1532                 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1533                         bss_conf->bssid);
1534                 ath9k_htc_set_tsfadjust(priv, vif);
1535                 set_bit(OP_ENABLE_BEACON, &priv->op_flags);
1536                 ath9k_htc_beacon_config(priv, vif);
1537         }
1538
1539         if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1540                 /*
1541                  * Disable SWBA interrupt only if there are no
1542                  * AP/IBSS interfaces.
1543                  */
1544                 if ((priv->num_ap_vif <= 1) || priv->num_ibss_vif) {
1545                         ath_dbg(common, CONFIG,
1546                                 "Beacon disabled for BSS: %pM\n",
1547                                 bss_conf->bssid);
1548                         clear_bit(OP_ENABLE_BEACON, &priv->op_flags);
1549                         ath9k_htc_beacon_config(priv, vif);
1550                 }
1551         }
1552
1553         if (changed & BSS_CHANGED_BEACON_INT) {
1554                 /*
1555                  * Reset the HW TSF for the first AP interface.
1556                  */
1557                 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1558                     (priv->nvifs == 1) &&
1559                     (priv->num_ap_vif == 1) &&
1560                     (vif->type == NL80211_IFTYPE_AP)) {
1561                         set_bit(OP_TSF_RESET, &priv->op_flags);
1562                 }
1563                 ath_dbg(common, CONFIG,
1564                         "Beacon interval changed for BSS: %pM\n",
1565                         bss_conf->bssid);
1566                 ath9k_htc_beacon_config(priv, vif);
1567         }
1568
1569         if (changed & BSS_CHANGED_ERP_SLOT) {
1570                 if (bss_conf->use_short_slot)
1571                         ah->slottime = 9;
1572                 else
1573                         ah->slottime = 20;
1574
1575                 ath9k_hw_init_global_settings(ah);
1576         }
1577
1578         if (changed & BSS_CHANGED_HT)
1579                 ath9k_htc_update_rate(priv, vif, bss_conf);
1580
1581         ath9k_htc_ps_restore(priv);
1582         mutex_unlock(&priv->mutex);
1583 }
1584
1585 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1586                              struct ieee80211_vif *vif)
1587 {
1588         struct ath9k_htc_priv *priv = hw->priv;
1589         u64 tsf;
1590
1591         mutex_lock(&priv->mutex);
1592         ath9k_htc_ps_wakeup(priv);
1593         tsf = ath9k_hw_gettsf64(priv->ah);
1594         ath9k_htc_ps_restore(priv);
1595         mutex_unlock(&priv->mutex);
1596
1597         return tsf;
1598 }
1599
1600 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1601                               struct ieee80211_vif *vif, u64 tsf)
1602 {
1603         struct ath9k_htc_priv *priv = hw->priv;
1604
1605         mutex_lock(&priv->mutex);
1606         ath9k_htc_ps_wakeup(priv);
1607         ath9k_hw_settsf64(priv->ah, tsf);
1608         ath9k_htc_ps_restore(priv);
1609         mutex_unlock(&priv->mutex);
1610 }
1611
1612 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1613                                 struct ieee80211_vif *vif)
1614 {
1615         struct ath9k_htc_priv *priv = hw->priv;
1616
1617         mutex_lock(&priv->mutex);
1618         ath9k_htc_ps_wakeup(priv);
1619         ath9k_hw_reset_tsf(priv->ah);
1620         ath9k_htc_ps_restore(priv);
1621         mutex_unlock(&priv->mutex);
1622 }
1623
1624 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1625                                   struct ieee80211_vif *vif,
1626                                   enum ieee80211_ampdu_mlme_action action,
1627                                   struct ieee80211_sta *sta,
1628                                   u16 tid, u16 *ssn, u8 buf_size)
1629 {
1630         struct ath9k_htc_priv *priv = hw->priv;
1631         struct ath9k_htc_sta *ista;
1632         int ret = 0;
1633
1634         mutex_lock(&priv->mutex);
1635         ath9k_htc_ps_wakeup(priv);
1636
1637         switch (action) {
1638         case IEEE80211_AMPDU_RX_START:
1639                 break;
1640         case IEEE80211_AMPDU_RX_STOP:
1641                 break;
1642         case IEEE80211_AMPDU_TX_START:
1643                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1644                 if (!ret)
1645                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1646                 break;
1647         case IEEE80211_AMPDU_TX_STOP:
1648                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1649                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1650                 break;
1651         case IEEE80211_AMPDU_TX_OPERATIONAL:
1652                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1653                 spin_lock_bh(&priv->tx.tx_lock);
1654                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1655                 spin_unlock_bh(&priv->tx.tx_lock);
1656                 break;
1657         default:
1658                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1659         }
1660
1661         ath9k_htc_ps_restore(priv);
1662         mutex_unlock(&priv->mutex);
1663
1664         return ret;
1665 }
1666
1667 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw)
1668 {
1669         struct ath9k_htc_priv *priv = hw->priv;
1670
1671         mutex_lock(&priv->mutex);
1672         spin_lock_bh(&priv->beacon_lock);
1673         set_bit(OP_SCANNING, &priv->op_flags);
1674         spin_unlock_bh(&priv->beacon_lock);
1675         cancel_work_sync(&priv->ps_work);
1676         ath9k_htc_stop_ani(priv);
1677         mutex_unlock(&priv->mutex);
1678 }
1679
1680 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
1681 {
1682         struct ath9k_htc_priv *priv = hw->priv;
1683
1684         mutex_lock(&priv->mutex);
1685         spin_lock_bh(&priv->beacon_lock);
1686         clear_bit(OP_SCANNING, &priv->op_flags);
1687         spin_unlock_bh(&priv->beacon_lock);
1688         ath9k_htc_ps_wakeup(priv);
1689         ath9k_htc_vif_reconfig(priv);
1690         ath9k_htc_ps_restore(priv);
1691         mutex_unlock(&priv->mutex);
1692 }
1693
1694 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1695 {
1696         return 0;
1697 }
1698
1699 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1700                                          u8 coverage_class)
1701 {
1702         struct ath9k_htc_priv *priv = hw->priv;
1703
1704         mutex_lock(&priv->mutex);
1705         ath9k_htc_ps_wakeup(priv);
1706         priv->ah->coverage_class = coverage_class;
1707         ath9k_hw_init_global_settings(priv->ah);
1708         ath9k_htc_ps_restore(priv);
1709         mutex_unlock(&priv->mutex);
1710 }
1711
1712 /*
1713  * Currently, this is used only for selecting the minimum rate
1714  * for management frames, rate selection for data frames remain
1715  * unaffected.
1716  */
1717 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1718                                       struct ieee80211_vif *vif,
1719                                       const struct cfg80211_bitrate_mask *mask)
1720 {
1721         struct ath9k_htc_priv *priv = hw->priv;
1722         struct ath_common *common = ath9k_hw_common(priv->ah);
1723         struct ath9k_htc_target_rate_mask tmask;
1724         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1725         int ret = 0;
1726         u8 cmd_rsp;
1727
1728         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1729
1730         tmask.vif_index = avp->index;
1731         tmask.band = IEEE80211_BAND_2GHZ;
1732         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1733
1734         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1735         if (ret) {
1736                 ath_err(common,
1737                         "Unable to set 2G rate mask for "
1738                         "interface at idx: %d\n", avp->index);
1739                 goto out;
1740         }
1741
1742         tmask.band = IEEE80211_BAND_5GHZ;
1743         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1744
1745         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1746         if (ret) {
1747                 ath_err(common,
1748                         "Unable to set 5G rate mask for "
1749                         "interface at idx: %d\n", avp->index);
1750                 goto out;
1751         }
1752
1753         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1754                 mask->control[IEEE80211_BAND_2GHZ].legacy,
1755                 mask->control[IEEE80211_BAND_5GHZ].legacy);
1756 out:
1757         return ret;
1758 }
1759
1760
1761 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1762                                struct ieee80211_low_level_stats *stats)
1763 {
1764         struct ath9k_htc_priv *priv = hw->priv;
1765         struct ath_hw *ah = priv->ah;
1766         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1767
1768         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1769         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1770         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1771         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1772
1773         return 0;
1774 }
1775
1776 struct ieee80211_ops ath9k_htc_ops = {
1777         .tx                 = ath9k_htc_tx,
1778         .start              = ath9k_htc_start,
1779         .stop               = ath9k_htc_stop,
1780         .add_interface      = ath9k_htc_add_interface,
1781         .remove_interface   = ath9k_htc_remove_interface,
1782         .config             = ath9k_htc_config,
1783         .configure_filter   = ath9k_htc_configure_filter,
1784         .sta_add            = ath9k_htc_sta_add,
1785         .sta_remove         = ath9k_htc_sta_remove,
1786         .conf_tx            = ath9k_htc_conf_tx,
1787         .sta_rc_update      = ath9k_htc_sta_rc_update,
1788         .bss_info_changed   = ath9k_htc_bss_info_changed,
1789         .set_key            = ath9k_htc_set_key,
1790         .get_tsf            = ath9k_htc_get_tsf,
1791         .set_tsf            = ath9k_htc_set_tsf,
1792         .reset_tsf          = ath9k_htc_reset_tsf,
1793         .ampdu_action       = ath9k_htc_ampdu_action,
1794         .sw_scan_start      = ath9k_htc_sw_scan_start,
1795         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1796         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1797         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1798         .set_coverage_class = ath9k_htc_set_coverage_class,
1799         .set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1800         .get_stats          = ath9k_htc_get_stats,
1801 };