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