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