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 (vif->cfg.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->deflink.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->deflink.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->deflink.ht_cap.ht_supported) {
 614                 for (i = 0, j = 0; i < 77; i++) {
 615                         if (sta->deflink.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->deflink.ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)
 624                         caps |= ATH_RC_TX_STBC_FLAG;
 625                 if (sta->deflink.ht_cap.mcs.rx_mask[1])
 626                         caps |= WLAN_RC_DS_FLAG;
 627                 if ((sta->deflink.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->deflink.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->deflink.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;
 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, bool suspend)
 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_MCAST_ACTION |                      \
1255         FIF_FCSFAIL)
1256
1257 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1258                                        unsigned int changed_flags,
1259                                        unsigned int *total_flags,
1260                                        u64 multicast)
1261 {
1262         struct ath9k_htc_priv *priv = hw->priv;
1263         struct ath_common *common = ath9k_hw_common(priv->ah);
1264         u32 rfilt;
1265
1266         mutex_lock(&priv->mutex);
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_link_sta *link_sta,
1361                                     u32 changed)
1362 {
1363         struct ieee80211_sta *sta = link_sta->sta;
1364         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1365
1366         if (!(changed & IEEE80211_RC_SUPP_RATES_CHANGED))
1367                 return;
1368
1369         schedule_work(&ista->rc_update_work);
1370 }
1371
1372 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1373                              struct ieee80211_vif *vif,
1374                              unsigned int link_id, u16 queue,
1375                              const struct ieee80211_tx_queue_params *params)
1376 {
1377         struct ath9k_htc_priv *priv = hw->priv;
1378         struct ath_common *common = ath9k_hw_common(priv->ah);
1379         struct ath9k_tx_queue_info qi;
1380         int ret = 0, qnum;
1381
1382         if (queue >= IEEE80211_NUM_ACS)
1383                 return 0;
1384
1385         mutex_lock(&priv->mutex);
1386         ath9k_htc_ps_wakeup(priv);
1387
1388         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1389
1390         qi.tqi_aifs = params->aifs;
1391         qi.tqi_cwmin = params->cw_min;
1392         qi.tqi_cwmax = params->cw_max;
1393         qi.tqi_burstTime = params->txop * 32;
1394
1395         qnum = get_hw_qnum(queue, priv->hwq_map);
1396
1397         ath_dbg(common, CONFIG,
1398                 "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1399                 queue, qnum, params->aifs, params->cw_min,
1400                 params->cw_max, params->txop);
1401
1402         ret = ath_htc_txq_update(priv, qnum, &qi);
1403         if (ret) {
1404                 ath_err(common, "TXQ Update failed\n");
1405                 goto out;
1406         }
1407
1408         if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1409             (qnum == priv->hwq_map[IEEE80211_AC_BE]))
1410                     ath9k_htc_beaconq_config(priv);
1411 out:
1412         ath9k_htc_ps_restore(priv);
1413         mutex_unlock(&priv->mutex);
1414
1415         return ret;
1416 }
1417
1418 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1419                              enum set_key_cmd cmd,
1420                              struct ieee80211_vif *vif,
1421                              struct ieee80211_sta *sta,
1422                              struct ieee80211_key_conf *key)
1423 {
1424         struct ath9k_htc_priv *priv = hw->priv;
1425         struct ath_common *common = ath9k_hw_common(priv->ah);
1426         int ret = 0;
1427
1428         if (htc_modparam_nohwcrypt)
1429                 return -ENOSPC;
1430
1431         if ((vif->type == NL80211_IFTYPE_ADHOC ||
1432              vif->type == NL80211_IFTYPE_MESH_POINT) &&
1433             (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1434              key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1435             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1436                 /*
1437                  * For now, disable hw crypto for the RSN IBSS group keys. This
1438                  * could be optimized in the future to use a modified key cache
1439                  * design to support per-STA RX GTK, but until that gets
1440                  * implemented, use of software crypto for group addressed
1441                  * frames is a acceptable to allow RSN IBSS to be used.
1442                  */
1443                 return -EOPNOTSUPP;
1444         }
1445
1446         mutex_lock(&priv->mutex);
1447         ath_dbg(common, CONFIG, "Set HW Key\n");
1448         ath9k_htc_ps_wakeup(priv);
1449
1450         switch (cmd) {
1451         case SET_KEY:
1452                 ret = ath_key_config(common, vif, sta, key);
1453                 if (ret >= 0) {
1454                         key->hw_key_idx = ret;
1455                         /* push IV and Michael MIC generation to stack */
1456                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1457                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1458                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1459                         if (priv->ah->sw_mgmt_crypto_tx &&
1460                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1461                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1462                         ret = 0;
1463                 }
1464                 break;
1465         case DISABLE_KEY:
1466                 ath_key_delete(common, key->hw_key_idx);
1467                 break;
1468         default:
1469                 ret = -EINVAL;
1470         }
1471
1472         ath9k_htc_ps_restore(priv);
1473         mutex_unlock(&priv->mutex);
1474
1475         return ret;
1476 }
1477
1478 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1479 {
1480         struct ath_common *common = ath9k_hw_common(priv->ah);
1481
1482         ath9k_hw_write_associd(priv->ah);
1483         ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1484                 common->curbssid, common->curaid);
1485 }
1486
1487 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1488 {
1489         struct ath9k_htc_priv *priv = data;
1490         struct ath_common *common = ath9k_hw_common(priv->ah);
1491         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1492
1493         if ((vif->type == NL80211_IFTYPE_STATION) && vif->cfg.assoc) {
1494                 common->curaid = vif->cfg.aid;
1495                 common->last_rssi = ATH_RSSI_DUMMY_MARKER;
1496                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1497                 set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1498         }
1499 }
1500
1501 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1502 {
1503         if (priv->num_sta_assoc_vif == 1) {
1504                 ieee80211_iterate_active_interfaces_atomic(
1505                         priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1506                         ath9k_htc_bss_iter, priv);
1507                 ath9k_htc_set_bssid(priv);
1508         }
1509 }
1510
1511 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1512                                        struct ieee80211_vif *vif,
1513                                        struct ieee80211_bss_conf *bss_conf,
1514                                        u64 changed)
1515 {
1516         struct ath9k_htc_priv *priv = hw->priv;
1517         struct ath_hw *ah = priv->ah;
1518         struct ath_common *common = ath9k_hw_common(ah);
1519         int slottime;
1520
1521         mutex_lock(&priv->mutex);
1522         ath9k_htc_ps_wakeup(priv);
1523
1524         if (changed & BSS_CHANGED_ASSOC) {
1525                 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1526                         vif->cfg.assoc);
1527
1528                 vif->cfg.assoc ?
1529                         priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1530
1531                 if (!vif->cfg.assoc)
1532                         clear_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1533
1534                 if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1535                         ath9k_htc_choose_set_bssid(priv);
1536                         if (vif->cfg.assoc && (priv->num_sta_assoc_vif == 1))
1537                                 ath9k_htc_start_ani(priv);
1538                         else if (priv->num_sta_assoc_vif == 0)
1539                                 ath9k_htc_stop_ani(priv);
1540                 }
1541         }
1542
1543         if (changed & BSS_CHANGED_IBSS) {
1544                 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1545                         common->curaid = vif->cfg.aid;
1546                         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1547                         ath9k_htc_set_bssid(priv);
1548                 }
1549         }
1550
1551         if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1552                 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1553                         bss_conf->bssid);
1554                 ath9k_htc_set_tsfadjust(priv, vif);
1555                 priv->cur_beacon_conf.enable_beacon = 1;
1556                 ath9k_htc_beacon_config(priv, vif);
1557         }
1558
1559         if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1560                 /*
1561                  * Disable SWBA interrupt only if there are no
1562                  * concurrent AP/mesh or IBSS interfaces.
1563                  */
1564                 if ((priv->num_ap_vif + priv->num_mbss_vif <= 1) ||
1565                      priv->num_ibss_vif) {
1566                         ath_dbg(common, CONFIG,
1567                                 "Beacon disabled for BSS: %pM\n",
1568                                 bss_conf->bssid);
1569                         priv->cur_beacon_conf.enable_beacon = 0;
1570                         ath9k_htc_beacon_config(priv, vif);
1571                 }
1572         }
1573
1574         if (changed & BSS_CHANGED_BEACON_INT) {
1575                 /*
1576                  * Reset the HW TSF for the first AP or mesh interface.
1577                  */
1578                 if (priv->nvifs == 1 &&
1579                     ((priv->ah->opmode == NL80211_IFTYPE_AP &&
1580                       vif->type == NL80211_IFTYPE_AP &&
1581                       priv->num_ap_vif == 1) ||
1582                     (priv->ah->opmode == NL80211_IFTYPE_MESH_POINT &&
1583                       vif->type == NL80211_IFTYPE_MESH_POINT &&
1584                       priv->num_mbss_vif == 1))) {
1585                         set_bit(OP_TSF_RESET, &priv->op_flags);
1586                 }
1587                 ath_dbg(common, CONFIG,
1588                         "Beacon interval changed for BSS: %pM\n",
1589                         bss_conf->bssid);
1590                 ath9k_htc_beacon_config(priv, vif);
1591         }
1592
1593         if (changed & BSS_CHANGED_ERP_SLOT) {
1594                 if (bss_conf->use_short_slot)
1595                         slottime = 9;
1596                 else
1597                         slottime = 20;
1598                 if (vif->type == NL80211_IFTYPE_AP) {
1599                         /*
1600                          * Defer update, so that connected stations can adjust
1601                          * their settings at the same time.
1602                          * See beacon.c for more details
1603                          */
1604                         priv->beacon.slottime = slottime;
1605                         priv->beacon.updateslot = UPDATE;
1606                 } else {
1607                         ah->slottime = slottime;
1608                         ath9k_hw_init_global_settings(ah);
1609                 }
1610         }
1611
1612         if (changed & BSS_CHANGED_HT)
1613                 ath9k_htc_update_rate(priv, vif, bss_conf);
1614
1615         ath9k_htc_ps_restore(priv);
1616         mutex_unlock(&priv->mutex);
1617 }
1618
1619 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1620                              struct ieee80211_vif *vif)
1621 {
1622         struct ath9k_htc_priv *priv = hw->priv;
1623         u64 tsf;
1624
1625         mutex_lock(&priv->mutex);
1626         ath9k_htc_ps_wakeup(priv);
1627         tsf = ath9k_hw_gettsf64(priv->ah);
1628         ath9k_htc_ps_restore(priv);
1629         mutex_unlock(&priv->mutex);
1630
1631         return tsf;
1632 }
1633
1634 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1635                               struct ieee80211_vif *vif, u64 tsf)
1636 {
1637         struct ath9k_htc_priv *priv = hw->priv;
1638
1639         mutex_lock(&priv->mutex);
1640         ath9k_htc_ps_wakeup(priv);
1641         ath9k_hw_settsf64(priv->ah, tsf);
1642         ath9k_htc_ps_restore(priv);
1643         mutex_unlock(&priv->mutex);
1644 }
1645
1646 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1647                                 struct ieee80211_vif *vif)
1648 {
1649         struct ath9k_htc_priv *priv = hw->priv;
1650
1651         mutex_lock(&priv->mutex);
1652         ath9k_htc_ps_wakeup(priv);
1653         ath9k_hw_reset_tsf(priv->ah);
1654         ath9k_htc_ps_restore(priv);
1655         mutex_unlock(&priv->mutex);
1656 }
1657
1658 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1659                                   struct ieee80211_vif *vif,
1660                                   struct ieee80211_ampdu_params *params)
1661 {
1662         struct ath9k_htc_priv *priv = hw->priv;
1663         struct ath9k_htc_sta *ista;
1664         int ret = 0;
1665         struct ieee80211_sta *sta = params->sta;
1666         enum ieee80211_ampdu_mlme_action action = params->action;
1667         u16 tid = params->tid;
1668
1669         mutex_lock(&priv->mutex);
1670         ath9k_htc_ps_wakeup(priv);
1671
1672         switch (action) {
1673         case IEEE80211_AMPDU_RX_START:
1674                 break;
1675         case IEEE80211_AMPDU_RX_STOP:
1676                 break;
1677         case IEEE80211_AMPDU_TX_START:
1678                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1679                 if (!ret)
1680                         ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
1681                 break;
1682         case IEEE80211_AMPDU_TX_STOP_CONT:
1683         case IEEE80211_AMPDU_TX_STOP_FLUSH:
1684         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1685                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1686                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1687                 break;
1688         case IEEE80211_AMPDU_TX_OPERATIONAL:
1689                 if (tid >= ATH9K_HTC_MAX_TID) {
1690                         ret = -EINVAL;
1691                         break;
1692                 }
1693                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1694                 spin_lock_bh(&priv->tx.tx_lock);
1695                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1696                 spin_unlock_bh(&priv->tx.tx_lock);
1697                 break;
1698         default:
1699                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1700         }
1701
1702         ath9k_htc_ps_restore(priv);
1703         mutex_unlock(&priv->mutex);
1704
1705         return ret;
1706 }
1707
1708 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw,
1709                                     struct ieee80211_vif *vif,
1710                                     const u8 *mac_addr)
1711 {
1712         struct ath9k_htc_priv *priv = hw->priv;
1713         struct ath_common *common = ath9k_hw_common(priv->ah);
1714
1715         mutex_lock(&priv->mutex);
1716         spin_lock_bh(&priv->beacon_lock);
1717         set_bit(ATH_OP_SCANNING, &common->op_flags);
1718         spin_unlock_bh(&priv->beacon_lock);
1719         cancel_work_sync(&priv->ps_work);
1720         ath9k_htc_stop_ani(priv);
1721         mutex_unlock(&priv->mutex);
1722 }
1723
1724 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw,
1725                                        struct ieee80211_vif *vif)
1726 {
1727         struct ath9k_htc_priv *priv = hw->priv;
1728         struct ath_common *common = ath9k_hw_common(priv->ah);
1729
1730         mutex_lock(&priv->mutex);
1731         spin_lock_bh(&priv->beacon_lock);
1732         clear_bit(ATH_OP_SCANNING, &common->op_flags);
1733         spin_unlock_bh(&priv->beacon_lock);
1734         ath9k_htc_ps_wakeup(priv);
1735         ath9k_htc_vif_reconfig(priv);
1736         ath9k_htc_ps_restore(priv);
1737         mutex_unlock(&priv->mutex);
1738 }
1739
1740 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1741 {
1742         return 0;
1743 }
1744
1745 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1746                                          s16 coverage_class)
1747 {
1748         struct ath9k_htc_priv *priv = hw->priv;
1749
1750         mutex_lock(&priv->mutex);
1751         ath9k_htc_ps_wakeup(priv);
1752         priv->ah->coverage_class = coverage_class;
1753         ath9k_hw_init_global_settings(priv->ah);
1754         ath9k_htc_ps_restore(priv);
1755         mutex_unlock(&priv->mutex);
1756 }
1757
1758 /*
1759  * Currently, this is used only for selecting the minimum rate
1760  * for management frames, rate selection for data frames remain
1761  * unaffected.
1762  */
1763 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1764                                       struct ieee80211_vif *vif,
1765                                       const struct cfg80211_bitrate_mask *mask)
1766 {
1767         struct ath9k_htc_priv *priv = hw->priv;
1768         struct ath_common *common = ath9k_hw_common(priv->ah);
1769         struct ath9k_htc_target_rate_mask tmask;
1770         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1771         int ret = 0;
1772         u8 cmd_rsp;
1773
1774         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1775
1776         tmask.vif_index = avp->index;
1777         tmask.band = NL80211_BAND_2GHZ;
1778         tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_2GHZ].legacy);
1779
1780         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1781         if (ret) {
1782                 ath_err(common,
1783                         "Unable to set 2G rate mask for "
1784                         "interface at idx: %d\n", avp->index);
1785                 goto out;
1786         }
1787
1788         tmask.band = NL80211_BAND_5GHZ;
1789         tmask.mask = cpu_to_be32(mask->control[NL80211_BAND_5GHZ].legacy);
1790
1791         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1792         if (ret) {
1793                 ath_err(common,
1794                         "Unable to set 5G rate mask for "
1795                         "interface at idx: %d\n", avp->index);
1796                 goto out;
1797         }
1798
1799         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1800                 mask->control[NL80211_BAND_2GHZ].legacy,
1801                 mask->control[NL80211_BAND_5GHZ].legacy);
1802 out:
1803         return ret;
1804 }
1805
1806
1807 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1808                                struct ieee80211_low_level_stats *stats)
1809 {
1810         struct ath9k_htc_priv *priv = hw->priv;
1811         struct ath_hw *ah = priv->ah;
1812         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1813
1814         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1815         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1816         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1817         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1818
1819         return 0;
1820 }
1821
1822 struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv)
1823 {
1824         struct base_eep_header *pBase = NULL;
1825         /*
1826          * This can be done since all the 3 EEPROM families have the
1827          * same base header upto a certain point, and we are interested in
1828          * the data only upto that point.
1829          */
1830
1831         if (AR_SREV_9271(priv->ah))
1832                 pBase = (struct base_eep_header *)
1833                         &priv->ah->eeprom.map4k.baseEepHeader;
1834         else if (priv->ah->hw_version.usbdev == AR9280_USB)
1835                 pBase = (struct base_eep_header *)
1836                         &priv->ah->eeprom.def.baseEepHeader;
1837         else if (priv->ah->hw_version.usbdev == AR9287_USB)
1838                 pBase = (struct base_eep_header *)
1839                         &priv->ah->eeprom.map9287.baseEepHeader;
1840         return pBase;
1841 }
1842
1843
1844 static int ath9k_htc_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant,
1845                                  u32 *rx_ant)
1846 {
1847         struct ath9k_htc_priv *priv = hw->priv;
1848         struct base_eep_header *pBase = ath9k_htc_get_eeprom_base(priv);
1849         if (pBase) {
1850                 *tx_ant = pBase->txMask;
1851                 *rx_ant = pBase->rxMask;
1852         } else {
1853                 *tx_ant = 0;
1854                 *rx_ant = 0;
1855         }
1856         return 0;
1857 }
1858
1859 static void ath9k_htc_channel_switch_beacon(struct ieee80211_hw *hw,
1860                                             struct ieee80211_vif *vif,
1861                                             struct cfg80211_chan_def *chandef)
1862 {
1863         struct ath9k_htc_priv *priv = hw->priv;
1864
1865         /* mac80211 does not support CSA in multi-if cases (yet) */
1866         if (WARN_ON(priv->csa_vif))
1867                 return;
1868
1869         priv->csa_vif = vif;
1870 }
1871
1872 struct ieee80211_ops ath9k_htc_ops = {
1873         .add_chanctx = ieee80211_emulate_add_chanctx,
1874         .remove_chanctx = ieee80211_emulate_remove_chanctx,
1875         .change_chanctx = ieee80211_emulate_change_chanctx,
1876         .switch_vif_chanctx = ieee80211_emulate_switch_vif_chanctx,
1877         .tx                 = ath9k_htc_tx,
1878         .wake_tx_queue      = ieee80211_handle_wake_tx_queue,
1879         .start              = ath9k_htc_start,
1880         .stop               = ath9k_htc_stop,
1881         .add_interface      = ath9k_htc_add_interface,
1882         .remove_interface   = ath9k_htc_remove_interface,
1883         .config             = ath9k_htc_config,
1884         .configure_filter   = ath9k_htc_configure_filter,
1885         .sta_add            = ath9k_htc_sta_add,
1886         .sta_remove         = ath9k_htc_sta_remove,
1887         .conf_tx            = ath9k_htc_conf_tx,
1888         .link_sta_rc_update = ath9k_htc_sta_rc_update,
1889         .bss_info_changed   = ath9k_htc_bss_info_changed,
1890         .set_key            = ath9k_htc_set_key,
1891         .get_tsf            = ath9k_htc_get_tsf,
1892         .set_tsf            = ath9k_htc_set_tsf,
1893         .reset_tsf          = ath9k_htc_reset_tsf,
1894         .ampdu_action       = ath9k_htc_ampdu_action,
1895         .sw_scan_start      = ath9k_htc_sw_scan_start,
1896         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1897         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1898         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1899         .set_coverage_class = ath9k_htc_set_coverage_class,
1900         .set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1901         .get_stats          = ath9k_htc_get_stats,
1902         .get_antenna        = ath9k_htc_get_antenna,
1903         .channel_switch_beacon  = ath9k_htc_channel_switch_beacon,
1904
1905 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
1906         .get_et_sset_count  = ath9k_htc_get_et_sset_count,
1907         .get_et_stats       = ath9k_htc_get_et_stats,
1908         .get_et_strings     = ath9k_htc_get_et_strings,
1909 #endif
1910 };