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