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 = NULL;
 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
 278         if (!fastcc)
 279                 caldata = &priv->caldata;
 280
 281         ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
 282         if (ret) {
 283                 ath_err(common,
 284                         "Unable to reset channel (%u Mhz) reset status %d\n",
 285                         channel->center_freq, ret);
 286                 goto err;
 287         }
 288
 289         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 290                                &priv->curtxpow);
 291
 292         WMI_CMD(WMI_START_RECV_CMDID);
 293         if (ret)
 294                 goto err;
 295
 296         ath9k_host_rx_init(priv);
 297
 298         mode = ath9k_htc_get_curmode(priv, hchan);
 299         htc_mode = cpu_to_be16(mode);
 300         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 301         if (ret)
 302                 goto err;
 303
 304         WMI_CMD(WMI_ENABLE_INTR_CMDID);
 305         if (ret)
 306                 goto err;
 307
 308         htc_start(priv->htc);
 309
 310         if (!test_bit(ATH_OP_SCANNING, &common->op_flags) &&
 311             !(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL))
 312                 ath9k_htc_vif_reconfig(priv);
 313
 314         mod_timer(&priv->tx.cleanup_timer,
 315                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 316
 317         /* perform spectral scan if requested. */
 318         if (test_bit(ATH_OP_SCANNING, &common->op_flags) &&
 319                      priv->spec_priv.spectral_mode == SPECTRAL_CHANSCAN)
 320                 ath9k_cmn_spectral_scan_trigger(common, &priv->spec_priv);
 321 err:
 322         ath9k_htc_ps_restore(priv);
 323         return ret;
 324 }
 325
 326 /*
 327  * Monitor mode handling is a tad complicated because the firmware requires
 328  * an interface to be created exclusively, while mac80211 doesn't associate
 329  * an interface with the mode.
 330  *
 331  * So, for now, only one monitor interface can be configured.
 332  */
 333 static void __ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
 334 {
 335         struct ath_common *common = ath9k_hw_common(priv->ah);
 336         struct ath9k_htc_target_vif hvif;
 337         int ret = 0;
 338         u8 cmd_rsp;
 339
 340         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
 341         memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
 342         hvif.index = priv->mon_vif_idx;
 343         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
 344         if (ret) {
 345                 ath_err(common, "Unable to remove monitor interface at idx: %d\n",
 346                         priv->mon_vif_idx);
 347         }
 348
 349         priv->nvifs--;
 350         priv->vif_slot &= ~(1 << priv->mon_vif_idx);
 351 }
 352
 353 static int ath9k_htc_add_monitor_interface(struct ath9k_htc_priv *priv)
 354 {
 355         struct ath_common *common = ath9k_hw_common(priv->ah);
 356         struct ath9k_htc_target_vif hvif;
 357         struct ath9k_htc_target_sta tsta;
 358         int ret = 0, sta_idx;
 359         u8 cmd_rsp;
 360
 361         if ((priv->nvifs >= ATH9K_HTC_MAX_VIF) ||
 362             (priv->nstations >= ATH9K_HTC_MAX_STA)) {
 363                 ret = -ENOBUFS;
 364                 goto err_vif;
 365         }
 366
 367         sta_idx = ffz(priv->sta_slot);
 368         if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA)) {
 369                 ret = -ENOBUFS;
 370                 goto err_vif;
 371         }
 372
 373         /*
 374          * Add an interface.
 375          */
 376         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
 377         memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
 378
 379         hvif.opmode = HTC_M_MONITOR;
 380         hvif.index = ffz(priv->vif_slot);
 381
 382         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
 383         if (ret)
 384                 goto err_vif;
 385
 386         /*
 387          * Assign the monitor interface index as a special case here.
 388          * This is needed when the interface is brought down.
 389          */
 390         priv->mon_vif_idx = hvif.index;
 391         priv->vif_slot |= (1 << hvif.index);
 392
 393         /*
 394          * Set the hardware mode to monitor only if there are no
 395          * other interfaces.
 396          */
 397         if (!priv->nvifs)
 398                 priv->ah->opmode = NL80211_IFTYPE_MONITOR;
 399
 400         priv->nvifs++;
 401
 402         /*
 403          * Associate a station with the interface for packet injection.
 404          */
 405         memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
 406
 407         memcpy(&tsta.macaddr, common->macaddr, ETH_ALEN);
 408
 409         tsta.is_vif_sta = 1;
 410         tsta.sta_index = sta_idx;
 411         tsta.vif_index = hvif.index;
 412         tsta.maxampdu = cpu_to_be16(0xffff);
 413
 414         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
 415         if (ret) {
 416                 ath_err(common, "Unable to add station entry for monitor mode\n");
 417                 goto err_sta;
 418         }
 419
 420         priv->sta_slot |= (1 << sta_idx);
 421         priv->nstations++;
 422         priv->vif_sta_pos[priv->mon_vif_idx] = sta_idx;
 423         priv->ah->is_monitoring = true;
 424
 425         ath_dbg(common, CONFIG,
 426                 "Attached a monitor interface at idx: %d, sta idx: %d\n",
 427                 priv->mon_vif_idx, sta_idx);
 428
 429         return 0;
 430
 431 err_sta:
 432         /*
 433          * Remove the interface from the target.
 434          */
 435         __ath9k_htc_remove_monitor_interface(priv);
 436 err_vif:
 437         ath_dbg(common, FATAL, "Unable to attach a monitor interface\n");
 438
 439         return ret;
 440 }
 441
 442 static int ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
 443 {
 444         struct ath_common *common = ath9k_hw_common(priv->ah);
 445         int ret = 0;
 446         u8 cmd_rsp, sta_idx;
 447
 448         __ath9k_htc_remove_monitor_interface(priv);
 449
 450         sta_idx = priv->vif_sta_pos[priv->mon_vif_idx];
 451
 452         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
 453         if (ret) {
 454                 ath_err(common, "Unable to remove station entry for monitor mode\n");
 455                 return ret;
 456         }
 457
 458         priv->sta_slot &= ~(1 << sta_idx);
 459         priv->nstations--;
 460         priv->ah->is_monitoring = false;
 461
 462         ath_dbg(common, CONFIG,
 463                 "Removed a monitor interface at idx: %d, sta idx: %d\n",
 464                 priv->mon_vif_idx, sta_idx);
 465
 466         return 0;
 467 }
 468
 469 static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
 470                                  struct ieee80211_vif *vif,
 471                                  struct ieee80211_sta *sta)
 472 {
 473         struct ath_common *common = ath9k_hw_common(priv->ah);
 474         struct ath9k_htc_target_sta tsta;
 475         struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
 476         struct ath9k_htc_sta *ista;
 477         int ret, sta_idx;
 478         u8 cmd_rsp;
 479         u16 maxampdu;
 480
 481         if (priv->nstations >= ATH9K_HTC_MAX_STA)
 482                 return -ENOBUFS;
 483
 484         sta_idx = ffz(priv->sta_slot);
 485         if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA))
 486                 return -ENOBUFS;
 487
 488         memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
 489
 490         if (sta) {
 491                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
 492                 memcpy(&tsta.macaddr, sta->addr, ETH_ALEN);
 493                 memcpy(&tsta.bssid, common->curbssid, ETH_ALEN);
 494                 ista->index = sta_idx;
 495                 tsta.is_vif_sta = 0;
 496                 maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
 497                                  sta->ht_cap.ampdu_factor);
 498                 tsta.maxampdu = cpu_to_be16(maxampdu);
 499         } else {
 500                 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN);
 501                 tsta.is_vif_sta = 1;
 502                 tsta.maxampdu = cpu_to_be16(0xffff);
 503         }
 504
 505         tsta.sta_index = sta_idx;
 506         tsta.vif_index = avp->index;
 507
 508         WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
 509         if (ret) {
 510                 if (sta)
 511                         ath_err(common,
 512                                 "Unable to add station entry for: %pM\n",
 513                                 sta->addr);
 514                 return ret;
 515         }
 516
 517         if (sta) {
 518                 ath_dbg(common, CONFIG,
 519                         "Added a station entry for: %pM (idx: %d)\n",
 520                         sta->addr, tsta.sta_index);
 521         } else {
 522                 ath_dbg(common, CONFIG,
 523                         "Added a station entry for VIF %d (idx: %d)\n",
 524                         avp->index, tsta.sta_index);
 525         }
 526
 527         priv->sta_slot |= (1 << sta_idx);
 528         priv->nstations++;
 529         if (!sta)
 530                 priv->vif_sta_pos[avp->index] = sta_idx;
 531
 532         return 0;
 533 }
 534
 535 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
 536                                     struct ieee80211_vif *vif,
 537                                     struct ieee80211_sta *sta)
 538 {
 539         struct ath_common *common = ath9k_hw_common(priv->ah);
 540         struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
 541         struct ath9k_htc_sta *ista;
 542         int ret;
 543         u8 cmd_rsp, sta_idx;
 544
 545         if (sta) {
 546                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
 547                 sta_idx = ista->index;
 548         } else {
 549                 sta_idx = priv->vif_sta_pos[avp->index];
 550         }
 551
 552         WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
 553         if (ret) {
 554                 if (sta)
 555                         ath_err(common,
 556                                 "Unable to remove station entry for: %pM\n",
 557                                 sta->addr);
 558                 return ret;
 559         }
 560
 561         if (sta) {
 562                 ath_dbg(common, CONFIG,
 563                         "Removed a station entry for: %pM (idx: %d)\n",
 564                         sta->addr, sta_idx);
 565         } else {
 566                 ath_dbg(common, CONFIG,
 567                         "Removed a station entry for VIF %d (idx: %d)\n",
 568                         avp->index, sta_idx);
 569         }
 570
 571         priv->sta_slot &= ~(1 << sta_idx);
 572         priv->nstations--;
 573
 574         return 0;
 575 }
 576
 577 int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv,
 578                                 u8 enable_coex)
 579 {
 580         struct ath9k_htc_cap_target tcap;
 581         int ret;
 582         u8 cmd_rsp;
 583
 584         memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target));
 585
 586         tcap.ampdu_limit = cpu_to_be32(0xffff);
 587         tcap.ampdu_subframes = 0xff;
 588         tcap.enable_coex = enable_coex;
 589         tcap.tx_chainmask = priv->ah->caps.tx_chainmask;
 590
 591         WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap);
 592
 593         return ret;
 594 }
 595
 596 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv,
 597                                  struct ieee80211_sta *sta,
 598                                  struct ath9k_htc_target_rate *trate)
 599 {
 600         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
 601         struct ieee80211_supported_band *sband;
 602         u32 caps = 0;
 603         int i, j;
 604
 605         sband = priv->hw->wiphy->bands[priv->hw->conf.chandef.chan->band];
 606
 607         for (i = 0, j = 0; i < sband->n_bitrates; i++) {
 608                 if (sta->supp_rates[sband->band] & BIT(i)) {
 609                         trate->rates.legacy_rates.rs_rates[j]
 610                                 = (sband->bitrates[i].bitrate * 2) / 10;
 611                         j++;
 612                 }
 613         }
 614         trate->rates.legacy_rates.rs_nrates = j;
 615
 616         if (sta->ht_cap.ht_supported) {
 617                 for (i = 0, j = 0; i < 77; i++) {
 618                         if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
 619                                 trate->rates.ht_rates.rs_rates[j++] = i;
 620                         if (j == ATH_HTC_RATE_MAX)
 621                                 break;
 622                 }
 623                 trate->rates.ht_rates.rs_nrates = j;
 624
 625                 caps = WLAN_RC_HT_FLAG;
 626                 if (sta->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)
 627                         caps |= ATH_RC_TX_STBC_FLAG;
 628                 if (sta->ht_cap.mcs.rx_mask[1])
 629                         caps |= WLAN_RC_DS_FLAG;
 630                 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
 631                      (conf_is_ht40(&priv->hw->conf)))
 632                         caps |= WLAN_RC_40_FLAG;
 633                 if (conf_is_ht40(&priv->hw->conf) &&
 634                     (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
 635                         caps |= WLAN_RC_SGI_FLAG;
 636                 else if (conf_is_ht20(&priv->hw->conf) &&
 637                          (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20))
 638                         caps |= WLAN_RC_SGI_FLAG;
 639         }
 640
 641         trate->sta_index = ista->index;
 642         trate->isnew = 1;
 643         trate->capflags = cpu_to_be32(caps);
 644 }
 645
 646 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
 647                                     struct ath9k_htc_target_rate *trate)
 648 {
 649         struct ath_common *common = ath9k_hw_common(priv->ah);
 650         int ret;
 651         u8 cmd_rsp;
 652
 653         WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
 654         if (ret) {
 655                 ath_err(common,
 656                         "Unable to initialize Rate information on target\n");
 657         }
 658
 659         return ret;
 660 }
 661
 662 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
 663                                 struct ieee80211_sta *sta)
 664 {
 665         struct ath_common *common = ath9k_hw_common(priv->ah);
 666         struct ath9k_htc_target_rate trate;
 667         int ret;
 668
 669         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 670         ath9k_htc_setup_rate(priv, sta, &trate);
 671         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 672         if (!ret)
 673                 ath_dbg(common, CONFIG,
 674                         "Updated target sta: %pM, rate caps: 0x%X\n",
 675                         sta->addr, be32_to_cpu(trate.capflags));
 676 }
 677
 678 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
 679                                   struct ieee80211_vif *vif,
 680                                   struct ieee80211_bss_conf *bss_conf)
 681 {
 682         struct ath_common *common = ath9k_hw_common(priv->ah);
 683         struct ath9k_htc_target_rate trate;
 684         struct ieee80211_sta *sta;
 685         int ret;
 686
 687         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
 688
 689         rcu_read_lock();
 690         sta = ieee80211_find_sta(vif, bss_conf->bssid);
 691         if (!sta) {
 692                 rcu_read_unlock();
 693                 return;
 694         }
 695         ath9k_htc_setup_rate(priv, sta, &trate);
 696         rcu_read_unlock();
 697
 698         ret = ath9k_htc_send_rate_cmd(priv, &trate);
 699         if (!ret)
 700                 ath_dbg(common, CONFIG,
 701                         "Updated target sta: %pM, rate caps: 0x%X\n",
 702                         bss_conf->bssid, be32_to_cpu(trate.capflags));
 703 }
 704
 705 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
 706                                   struct ieee80211_vif *vif,
 707                                   struct ieee80211_sta *sta,
 708                                   enum ieee80211_ampdu_mlme_action action,
 709                                   u16 tid)
 710 {
 711         struct ath_common *common = ath9k_hw_common(priv->ah);
 712         struct ath9k_htc_target_aggr aggr;
 713         struct ath9k_htc_sta *ista;
 714         int ret = 0;
 715         u8 cmd_rsp;
 716
 717         if (tid >= ATH9K_HTC_MAX_TID)
 718                 return -EINVAL;
 719
 720         memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr));
 721         ista = (struct ath9k_htc_sta *) sta->drv_priv;
 722
 723         aggr.sta_index = ista->index;
 724         aggr.tidno = tid & 0xf;
 725         aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false;
 726
 727         WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
 728         if (ret)
 729                 ath_dbg(common, CONFIG,
 730                         "Unable to %s TX aggregation for (%pM, %d)\n",
 731                         (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
 732         else
 733                 ath_dbg(common, CONFIG,
 734                         "%s TX aggregation for (%pM, %d)\n",
 735                         (aggr.aggr_enable) ? "Starting" : "Stopping",
 736                         sta->addr, tid);
 737
 738         spin_lock_bh(&priv->tx.tx_lock);
 739         ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
 740         spin_unlock_bh(&priv->tx.tx_lock);
 741
 742         return ret;
 743 }
 744
 745 /*******/
 746 /* ANI */
 747 /*******/
 748
 749 void ath9k_htc_start_ani(struct ath9k_htc_priv *priv)
 750 {
 751         struct ath_common *common = ath9k_hw_common(priv->ah);
 752         unsigned long timestamp = jiffies_to_msecs(jiffies);
 753
 754         common->ani.longcal_timer = timestamp;
 755         common->ani.shortcal_timer = timestamp;
 756         common->ani.checkani_timer = timestamp;
 757
 758         set_bit(ATH_OP_ANI_RUN, &common->op_flags);
 759
 760         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 761                                      msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
 762 }
 763
 764 void ath9k_htc_stop_ani(struct ath9k_htc_priv *priv)
 765 {
 766         struct ath_common *common = ath9k_hw_common(priv->ah);
 767         cancel_delayed_work_sync(&priv->ani_work);
 768         clear_bit(ATH_OP_ANI_RUN, &common->op_flags);
 769 }
 770
 771 void ath9k_htc_ani_work(struct work_struct *work)
 772 {
 773         struct ath9k_htc_priv *priv =
 774                 container_of(work, struct ath9k_htc_priv, ani_work.work);
 775         struct ath_hw *ah = priv->ah;
 776         struct ath_common *common = ath9k_hw_common(ah);
 777         bool longcal = false;
 778         bool shortcal = false;
 779         bool aniflag = false;
 780         unsigned int timestamp = jiffies_to_msecs(jiffies);
 781         u32 cal_interval, short_cal_interval;
 782
 783         short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
 784                 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
 785
 786         /* Only calibrate if awake */
 787         if (ah->power_mode != ATH9K_PM_AWAKE)
 788                 goto set_timer;
 789
 790         /* Long calibration runs independently of short calibration. */
 791         if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
 792                 longcal = true;
 793                 ath_dbg(common, ANI, "longcal @%lu\n", jiffies);
 794                 common->ani.longcal_timer = timestamp;
 795         }
 796
 797         /*
 798          * Short calibration applies only while caldone
 799          * is false or -ETIMEDOUT
 800          */
 801         if (common->ani.caldone <= 0) {
 802                 if ((timestamp - common->ani.shortcal_timer) >=
 803                     short_cal_interval) {
 804                         shortcal = true;
 805                         ath_dbg(common, ANI, "shortcal @%lu\n", jiffies);
 806                         common->ani.shortcal_timer = timestamp;
 807                         common->ani.resetcal_timer = timestamp;
 808                 }
 809         } else {
 810                 if ((timestamp - common->ani.resetcal_timer) >=
 811                     ATH_RESTART_CALINTERVAL) {
 812                         common->ani.caldone = ath9k_hw_reset_calvalid(ah);
 813                         if (common->ani.caldone)
 814                                 common->ani.resetcal_timer = timestamp;
 815                 }
 816         }
 817
 818         /* Verify whether we must check ANI */
 819         if ((timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
 820                 aniflag = true;
 821                 common->ani.checkani_timer = timestamp;
 822         }
 823
 824         /* Skip all processing if there's nothing to do. */
 825         if (longcal || shortcal || aniflag) {
 826
 827                 ath9k_htc_ps_wakeup(priv);
 828
 829                 /* Call ANI routine if necessary */
 830                 if (aniflag)
 831                         ath9k_hw_ani_monitor(ah, ah->curchan);
 832
 833                 /* Perform calibration if necessary */
 834                 if (longcal || shortcal)
 835                         common->ani.caldone =
 836                                 ath9k_hw_calibrate(ah, ah->curchan,
 837                                                    ah->rxchainmask, longcal);
 838
 839                 ath9k_htc_ps_restore(priv);
 840         }
 841
 842 set_timer:
 843         /*
 844         * Set timer interval based on previous results.
 845         * The interval must be the shortest necessary to satisfy ANI,
 846         * short calibration and long calibration.
 847         */
 848         cal_interval = ATH_LONG_CALINTERVAL;
 849         cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
 850         /*
 851          * Short calibration applies only while caldone
 852          * is false or -ETIMEDOUT
 853          */
 854         if (common->ani.caldone <= 0)
 855                 cal_interval = min(cal_interval, (u32)short_cal_interval);
 856
 857         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 858                                      msecs_to_jiffies(cal_interval));
 859 }
 860
 861 /**********************/
 862 /* mac80211 Callbacks */
 863 /**********************/
 864
 865 static void ath9k_htc_tx(struct ieee80211_hw *hw,
 866                          struct ieee80211_tx_control *control,
 867                          struct sk_buff *skb)
 868 {
 869         struct ieee80211_hdr *hdr;
 870         struct ath9k_htc_priv *priv = hw->priv;
 871         struct ath_common *common = ath9k_hw_common(priv->ah);
 872         int padpos, padsize, ret, slot;
 873
 874         hdr = (struct ieee80211_hdr *) skb->data;
 875
 876         /* Add the padding after the header if this is not already done */
 877         padpos = ieee80211_hdrlen(hdr->frame_control);
 878         padsize = padpos & 3;
 879         if (padsize && skb->len > padpos) {
 880                 if (skb_headroom(skb) < padsize) {
 881                         ath_dbg(common, XMIT, "No room for padding\n");
 882                         goto fail_tx;
 883                 }
 884                 skb_push(skb, padsize);
 885                 memmove(skb->data, skb->data + padsize, padpos);
 886         }
 887
 888         slot = ath9k_htc_tx_get_slot(priv);
 889         if (slot < 0) {
 890                 ath_dbg(common, XMIT, "No free TX slot\n");
 891                 goto fail_tx;
 892         }
 893
 894         ret = ath9k_htc_tx_start(priv, control->sta, skb, slot, false);
 895         if (ret != 0) {
 896                 ath_dbg(common, XMIT, "Tx failed\n");
 897                 goto clear_slot;
 898         }
 899
 900         ath9k_htc_check_stop_queues(priv);
 901
 902         return;
 903
 904 clear_slot:
 905         ath9k_htc_tx_clear_slot(priv, slot);
 906 fail_tx:
 907         dev_kfree_skb_any(skb);
 908 }
 909
 910 static int ath9k_htc_start(struct ieee80211_hw *hw)
 911 {
 912         struct ath9k_htc_priv *priv = hw->priv;
 913         struct ath_hw *ah = priv->ah;
 914         struct ath_common *common = ath9k_hw_common(ah);
 915         struct ieee80211_channel *curchan = hw->conf.chandef.chan;
 916         struct ath9k_channel *init_channel;
 917         int ret = 0;
 918         enum htc_phymode mode;
 919         __be16 htc_mode;
 920         u8 cmd_rsp;
 921
 922         mutex_lock(&priv->mutex);
 923
 924         ath_dbg(common, CONFIG,
 925                 "Starting driver with initial channel: %d MHz\n",
 926                 curchan->center_freq);
 927
 928         /* Ensure that HW is awake before flushing RX */
 929         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 930         WMI_CMD(WMI_FLUSH_RECV_CMDID);
 931
 932         /* setup initial channel */
 933         init_channel = ath9k_cmn_get_channel(hw, ah, &hw->conf.chandef);
 934
 935         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 936         if (ret) {
 937                 ath_err(common,
 938                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
 939                         ret, curchan->center_freq);
 940                 mutex_unlock(&priv->mutex);
 941                 return ret;
 942         }
 943
 944         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 945                                &priv->curtxpow);
 946
 947         mode = ath9k_htc_get_curmode(priv, init_channel);
 948         htc_mode = cpu_to_be16(mode);
 949         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 950         WMI_CMD(WMI_ATH_INIT_CMDID);
 951         WMI_CMD(WMI_START_RECV_CMDID);
 952
 953         ath9k_host_rx_init(priv);
 954
 955         ret = ath9k_htc_update_cap_target(priv, 0);
 956         if (ret)
 957                 ath_dbg(common, CONFIG,
 958                         "Failed to update capability in target\n");
 959
 960         clear_bit(ATH_OP_INVALID, &common->op_flags);
 961         htc_start(priv->htc);
 962
 963         spin_lock_bh(&priv->tx.tx_lock);
 964         priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
 965         spin_unlock_bh(&priv->tx.tx_lock);
 966
 967         ieee80211_wake_queues(hw);
 968
 969         mod_timer(&priv->tx.cleanup_timer,
 970                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 971
 972         ath9k_htc_start_btcoex(priv);
 973
 974         mutex_unlock(&priv->mutex);
 975
 976         return ret;
 977 }
 978
 979 static void ath9k_htc_stop(struct ieee80211_hw *hw)
 980 {
 981         struct ath9k_htc_priv *priv = hw->priv;
 982         struct ath_hw *ah = priv->ah;
 983         struct ath_common *common = ath9k_hw_common(ah);
 984         int ret __attribute__ ((unused));
 985         u8 cmd_rsp;
 986
 987         mutex_lock(&priv->mutex);
 988
 989         if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
 990                 ath_dbg(common, ANY, "Device not present\n");
 991                 mutex_unlock(&priv->mutex);
 992                 return;
 993         }
 994
 995         ath9k_htc_ps_wakeup(priv);
 996
 997         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 998         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 999         WMI_CMD(WMI_STOP_RECV_CMDID);
1000
1001         tasklet_kill(&priv->rx_tasklet);
1002
1003         del_timer_sync(&priv->tx.cleanup_timer);
1004         ath9k_htc_tx_drain(priv);
1005         ath9k_wmi_event_drain(priv);
1006
1007         mutex_unlock(&priv->mutex);
1008
1009         /* Cancel all the running timers/work .. */
1010         cancel_work_sync(&priv->fatal_work);
1011         cancel_work_sync(&priv->ps_work);
1012
1013 #ifdef CONFIG_MAC80211_LEDS
1014         cancel_work_sync(&priv->led_work);
1015 #endif
1016         ath9k_htc_stop_ani(priv);
1017
1018         mutex_lock(&priv->mutex);
1019
1020         ath9k_htc_stop_btcoex(priv);
1021
1022         /* Remove a monitor interface if it's present. */
1023         if (priv->ah->is_monitoring)
1024                 ath9k_htc_remove_monitor_interface(priv);
1025
1026         ath9k_hw_phy_disable(ah);
1027         ath9k_hw_disable(ah);
1028         ath9k_htc_ps_restore(priv);
1029         ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1030
1031         set_bit(ATH_OP_INVALID, &common->op_flags);
1032
1033         ath_dbg(common, CONFIG, "Driver halt\n");
1034         mutex_unlock(&priv->mutex);
1035 }
1036
1037 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1038                                    struct ieee80211_vif *vif)
1039 {
1040         struct ath9k_htc_priv *priv = hw->priv;
1041         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1042         struct ath_common *common = ath9k_hw_common(priv->ah);
1043         struct ath9k_htc_target_vif hvif;
1044         int ret = 0;
1045         u8 cmd_rsp;
1046
1047         mutex_lock(&priv->mutex);
1048
1049         ath9k_htc_ps_wakeup(priv);
1050         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1051         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1052
1053         switch (vif->type) {
1054         case NL80211_IFTYPE_STATION:
1055                 hvif.opmode = HTC_M_STA;
1056                 break;
1057         case NL80211_IFTYPE_ADHOC:
1058                 hvif.opmode = HTC_M_IBSS;
1059                 break;
1060         case NL80211_IFTYPE_AP:
1061                 hvif.opmode = HTC_M_HOSTAP;
1062                 break;
1063         case NL80211_IFTYPE_MESH_POINT:
1064                 hvif.opmode = HTC_M_WDS;        /* close enough */
1065                 break;
1066         default:
1067                 ath_err(common,
1068                         "Interface type %d not yet supported\n", vif->type);
1069                 ret = -EOPNOTSUPP;
1070                 goto out;
1071         }
1072
1073         /* Index starts from zero on the target */
1074         avp->index = hvif.index = ffz(priv->vif_slot);
1075         hvif.rtsthreshold = cpu_to_be16(2304);
1076         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1077         if (ret)
1078                 goto out;
1079
1080         /*
1081          * We need a node in target to tx mgmt frames
1082          * before association.
1083          */
1084         ret = ath9k_htc_add_station(priv, vif, NULL);
1085         if (ret) {
1086                 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1087                 goto out;
1088         }
1089
1090         ath9k_htc_set_mac_bssid_mask(priv, vif);
1091
1092         priv->vif_slot |= (1 << avp->index);
1093         priv->nvifs++;
1094
1095         INC_VIF(priv, vif->type);
1096
1097         if ((vif->type == NL80211_IFTYPE_AP) ||
1098             (vif->type == NL80211_IFTYPE_MESH_POINT) ||
1099             (vif->type == NL80211_IFTYPE_ADHOC))
1100                 ath9k_htc_assign_bslot(priv, vif);
1101
1102         ath9k_htc_set_opmode(priv);
1103
1104         if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1105             !test_bit(ATH_OP_ANI_RUN, &common->op_flags)) {
1106                 ath9k_hw_set_tsfadjust(priv->ah, true);
1107                 ath9k_htc_start_ani(priv);
1108         }
1109
1110         ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n",
1111                 vif->type, avp->index);
1112
1113 out:
1114         ath9k_htc_ps_restore(priv);
1115         mutex_unlock(&priv->mutex);
1116
1117         return ret;
1118 }
1119
1120 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1121                                        struct ieee80211_vif *vif)
1122 {
1123         struct ath9k_htc_priv *priv = hw->priv;
1124         struct ath_common *common = ath9k_hw_common(priv->ah);
1125         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1126         struct ath9k_htc_target_vif hvif;
1127         int ret = 0;
1128         u8 cmd_rsp;
1129
1130         mutex_lock(&priv->mutex);
1131         ath9k_htc_ps_wakeup(priv);
1132
1133         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1134         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1135         hvif.index = avp->index;
1136         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1137         if (ret) {
1138                 ath_err(common, "Unable to remove interface at idx: %d\n",
1139                         avp->index);
1140         }
1141         priv->nvifs--;
1142         priv->vif_slot &= ~(1 << avp->index);
1143
1144         if (priv->csa_vif == vif)
1145                 priv->csa_vif = NULL;
1146
1147         ath9k_htc_remove_station(priv, vif, NULL);
1148
1149         DEC_VIF(priv, vif->type);
1150
1151         if ((vif->type == NL80211_IFTYPE_AP) ||
1152              vif->type == NL80211_IFTYPE_MESH_POINT ||
1153             (vif->type == NL80211_IFTYPE_ADHOC))
1154                 ath9k_htc_remove_bslot(priv, vif);
1155
1156         ath9k_htc_set_opmode(priv);
1157
1158         ath9k_htc_set_mac_bssid_mask(priv, vif);
1159
1160         /*
1161          * Stop ANI only if there are no associated station interfaces.
1162          */
1163         if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1164                 priv->rearm_ani = false;
1165                 ieee80211_iterate_active_interfaces_atomic(
1166                         priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1167                         ath9k_htc_vif_iter, priv);
1168                 if (!priv->rearm_ani)
1169                         ath9k_htc_stop_ani(priv);
1170         }
1171
1172         ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index);
1173
1174         ath9k_htc_ps_restore(priv);
1175         mutex_unlock(&priv->mutex);
1176 }
1177
1178 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1179 {
1180         struct ath9k_htc_priv *priv = hw->priv;
1181         struct ath_common *common = ath9k_hw_common(priv->ah);
1182         struct ieee80211_conf *conf = &hw->conf;
1183         bool chip_reset = false;
1184         int ret = 0;
1185
1186         mutex_lock(&priv->mutex);
1187         ath9k_htc_ps_wakeup(priv);
1188
1189         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1190                 mutex_lock(&priv->htc_pm_lock);
1191
1192                 priv->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1193                 if (!priv->ps_idle)
1194                         chip_reset = true;
1195
1196                 mutex_unlock(&priv->htc_pm_lock);
1197         }
1198
1199         /*
1200          * Monitor interface should be added before
1201          * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1202          */
1203         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1204                 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1205                     !priv->ah->is_monitoring)
1206                         ath9k_htc_add_monitor_interface(priv);
1207                 else if (priv->ah->is_monitoring)
1208                         ath9k_htc_remove_monitor_interface(priv);
1209         }
1210
1211         if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || chip_reset) {
1212                 struct ieee80211_channel *curchan = hw->conf.chandef.chan;
1213                 int pos = curchan->hw_value;
1214
1215                 ath_dbg(common, CONFIG, "Set channel: %d MHz\n",
1216                         curchan->center_freq);
1217
1218                 ath9k_cmn_get_channel(hw, priv->ah, &hw->conf.chandef);
1219                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1220                         ath_err(common, "Unable to set channel\n");
1221                         ret = -EINVAL;
1222                         goto out;
1223                 }
1224
1225         }
1226
1227         if (changed & IEEE80211_CONF_CHANGE_PS) {
1228                 if (conf->flags & IEEE80211_CONF_PS) {
1229                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1230                         priv->ps_enabled = true;
1231                 } else {
1232                         priv->ps_enabled = false;
1233                         cancel_work_sync(&priv->ps_work);
1234                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1235                 }
1236         }
1237
1238         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1239                 priv->txpowlimit = 2 * conf->power_level;
1240                 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1241                                        priv->txpowlimit, &priv->curtxpow);
1242         }
1243
1244 out:
1245         ath9k_htc_ps_restore(priv);
1246         mutex_unlock(&priv->mutex);
1247         return ret;
1248 }
1249
1250 #define SUPPORTED_FILTERS                       \
1251         (FIF_ALLMULTI |                         \
1252         FIF_CONTROL |                           \
1253         FIF_PSPOLL |                            \
1254         FIF_OTHER_BSS |                         \
1255         FIF_BCN_PRBRESP_PROMISC |               \
1256         FIF_PROBE_REQ |                         \
1257         FIF_FCSFAIL)
1258
1259 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1260                                        unsigned int changed_flags,
1261                                        unsigned int *total_flags,
1262                                        u64 multicast)
1263 {
1264         struct ath9k_htc_priv *priv = hw->priv;
1265         struct ath_common *common = ath9k_hw_common(priv->ah);
1266         u32 rfilt;
1267
1268         mutex_lock(&priv->mutex);
1269         changed_flags &= SUPPORTED_FILTERS;
1270         *total_flags &= SUPPORTED_FILTERS;
1271
1272         if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
1273                 ath_dbg(ath9k_hw_common(priv->ah), ANY,
1274                         "Unable to configure filter on invalid state\n");
1275                 mutex_unlock(&priv->mutex);
1276                 return;
1277         }
1278         ath9k_htc_ps_wakeup(priv);
1279
1280         priv->rxfilter = *total_flags;
1281         rfilt = ath9k_htc_calcrxfilter(priv);
1282         ath9k_hw_setrxfilter(priv->ah, rfilt);
1283
1284         ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1285                 rfilt);
1286
1287         ath9k_htc_ps_restore(priv);
1288         mutex_unlock(&priv->mutex);
1289 }
1290
1291 static void ath9k_htc_sta_rc_update_work(struct work_struct *work)
1292 {
1293         struct ath9k_htc_sta *ista =
1294             container_of(work, struct ath9k_htc_sta, rc_update_work);
1295         struct ieee80211_sta *sta =
1296             container_of((void *)ista, struct ieee80211_sta, drv_priv);
1297         struct ath9k_htc_priv *priv = ista->htc_priv;
1298         struct ath_common *common = ath9k_hw_common(priv->ah);
1299         struct ath9k_htc_target_rate trate;
1300
1301         mutex_lock(&priv->mutex);
1302         ath9k_htc_ps_wakeup(priv);
1303
1304         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
1305         ath9k_htc_setup_rate(priv, sta, &trate);
1306         if (!ath9k_htc_send_rate_cmd(priv, &trate))
1307                 ath_dbg(common, CONFIG,
1308                         "Supported rates for sta: %pM updated, rate caps: 0x%X\n",
1309                         sta->addr, be32_to_cpu(trate.capflags));
1310         else
1311                 ath_dbg(common, CONFIG,
1312                         "Unable to update supported rates for sta: %pM\n",
1313                         sta->addr);
1314
1315         ath9k_htc_ps_restore(priv);
1316         mutex_unlock(&priv->mutex);
1317 }
1318
1319 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1320                              struct ieee80211_vif *vif,
1321                              struct ieee80211_sta *sta)
1322 {
1323         struct ath9k_htc_priv *priv = hw->priv;
1324         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1325         int ret;
1326
1327         mutex_lock(&priv->mutex);
1328         ath9k_htc_ps_wakeup(priv);
1329         ret = ath9k_htc_add_station(priv, vif, sta);
1330         if (!ret) {
1331                 INIT_WORK(&ista->rc_update_work, ath9k_htc_sta_rc_update_work);
1332                 ista->htc_priv = priv;
1333                 ath9k_htc_init_rate(priv, sta);
1334         }
1335         ath9k_htc_ps_restore(priv);
1336         mutex_unlock(&priv->mutex);
1337
1338         return ret;
1339 }
1340
1341 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1342                                 struct ieee80211_vif *vif,
1343                                 struct ieee80211_sta *sta)
1344 {
1345         struct ath9k_htc_priv *priv = hw->priv;
1346         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1347         int ret;
1348
1349         cancel_work_sync(&ista->rc_update_work);
1350
1351         mutex_lock(&priv->mutex);
1352         ath9k_htc_ps_wakeup(priv);
1353         htc_sta_drain(priv->htc, ista->index);
1354         ret = ath9k_htc_remove_station(priv, vif, sta);
1355         ath9k_htc_ps_restore(priv);
1356         mutex_unlock(&priv->mutex);
1357
1358         return ret;
1359 }
1360
1361 static void ath9k_htc_sta_rc_update(struct ieee80211_hw *hw,
1362                                     struct ieee80211_vif *vif,
1363                                     struct ieee80211_sta *sta, u32 changed)
1364 {
1365         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1366
1367         if (!(changed & IEEE80211_RC_SUPP_RATES_CHANGED))
1368                 return;
1369
1370         schedule_work(&ista->rc_update_work);
1371 }
1372
1373 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1374                              struct ieee80211_vif *vif, 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);
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 = (struct ath9k_htc_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) && bss_conf->assoc) {
1494                 common->curaid = bss_conf->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                                        u32 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                         bss_conf->assoc);
1527
1528                 bss_conf->assoc ?
1529                         priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1530
1531                 if (!bss_conf->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 (bss_conf->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 = bss_conf->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                                   enum ieee80211_ampdu_mlme_action action,
1661                                   struct ieee80211_sta *sta,
1662                                   u16 tid, u16 *ssn, u8 buf_size, bool amsdu)
1663 {
1664         struct ath9k_htc_priv *priv = hw->priv;
1665         struct ath9k_htc_sta *ista;
1666         int ret = 0;
1667
1668         mutex_lock(&priv->mutex);
1669         ath9k_htc_ps_wakeup(priv);
1670
1671         switch (action) {
1672         case IEEE80211_AMPDU_RX_START:
1673                 break;
1674         case IEEE80211_AMPDU_RX_STOP:
1675                 break;
1676         case IEEE80211_AMPDU_TX_START:
1677                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1678                 if (!ret)
1679                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1680                 break;
1681         case IEEE80211_AMPDU_TX_STOP_CONT:
1682         case IEEE80211_AMPDU_TX_STOP_FLUSH:
1683         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1684                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1685                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1686                 break;
1687         case IEEE80211_AMPDU_TX_OPERATIONAL:
1688                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1689                 spin_lock_bh(&priv->tx.tx_lock);
1690                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1691                 spin_unlock_bh(&priv->tx.tx_lock);
1692                 break;
1693         default:
1694                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1695         }
1696
1697         ath9k_htc_ps_restore(priv);
1698         mutex_unlock(&priv->mutex);
1699
1700         return ret;
1701 }
1702
1703 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw,
1704                                     struct ieee80211_vif *vif,
1705                                     const u8 *mac_addr)
1706 {
1707         struct ath9k_htc_priv *priv = hw->priv;
1708         struct ath_common *common = ath9k_hw_common(priv->ah);
1709
1710         mutex_lock(&priv->mutex);
1711         spin_lock_bh(&priv->beacon_lock);
1712         set_bit(ATH_OP_SCANNING, &common->op_flags);
1713         spin_unlock_bh(&priv->beacon_lock);
1714         cancel_work_sync(&priv->ps_work);
1715         ath9k_htc_stop_ani(priv);
1716         mutex_unlock(&priv->mutex);
1717 }
1718
1719 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw,
1720                                        struct ieee80211_vif *vif)
1721 {
1722         struct ath9k_htc_priv *priv = hw->priv;
1723         struct ath_common *common = ath9k_hw_common(priv->ah);
1724
1725         mutex_lock(&priv->mutex);
1726         spin_lock_bh(&priv->beacon_lock);
1727         clear_bit(ATH_OP_SCANNING, &common->op_flags);
1728         spin_unlock_bh(&priv->beacon_lock);
1729         ath9k_htc_ps_wakeup(priv);
1730         ath9k_htc_vif_reconfig(priv);
1731         ath9k_htc_ps_restore(priv);
1732         mutex_unlock(&priv->mutex);
1733 }
1734
1735 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1736 {
1737         return 0;
1738 }
1739
1740 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1741                                          s16 coverage_class)
1742 {
1743         struct ath9k_htc_priv *priv = hw->priv;
1744
1745         mutex_lock(&priv->mutex);
1746         ath9k_htc_ps_wakeup(priv);
1747         priv->ah->coverage_class = coverage_class;
1748         ath9k_hw_init_global_settings(priv->ah);
1749         ath9k_htc_ps_restore(priv);
1750         mutex_unlock(&priv->mutex);
1751 }
1752
1753 /*
1754  * Currently, this is used only for selecting the minimum rate
1755  * for management frames, rate selection for data frames remain
1756  * unaffected.
1757  */
1758 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1759                                       struct ieee80211_vif *vif,
1760                                       const struct cfg80211_bitrate_mask *mask)
1761 {
1762         struct ath9k_htc_priv *priv = hw->priv;
1763         struct ath_common *common = ath9k_hw_common(priv->ah);
1764         struct ath9k_htc_target_rate_mask tmask;
1765         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1766         int ret = 0;
1767         u8 cmd_rsp;
1768
1769         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1770
1771         tmask.vif_index = avp->index;
1772         tmask.band = IEEE80211_BAND_2GHZ;
1773         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1774
1775         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1776         if (ret) {
1777                 ath_err(common,
1778                         "Unable to set 2G rate mask for "
1779                         "interface at idx: %d\n", avp->index);
1780                 goto out;
1781         }
1782
1783         tmask.band = IEEE80211_BAND_5GHZ;
1784         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1785
1786         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1787         if (ret) {
1788                 ath_err(common,
1789                         "Unable to set 5G rate mask for "
1790                         "interface at idx: %d\n", avp->index);
1791                 goto out;
1792         }
1793
1794         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1795                 mask->control[IEEE80211_BAND_2GHZ].legacy,
1796                 mask->control[IEEE80211_BAND_5GHZ].legacy);
1797 out:
1798         return ret;
1799 }
1800
1801
1802 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1803                                struct ieee80211_low_level_stats *stats)
1804 {
1805         struct ath9k_htc_priv *priv = hw->priv;
1806         struct ath_hw *ah = priv->ah;
1807         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1808
1809         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1810         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1811         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1812         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1813
1814         return 0;
1815 }
1816
1817 struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv)
1818 {
1819         struct base_eep_header *pBase = NULL;
1820         /*
1821          * This can be done since all the 3 EEPROM families have the
1822          * same base header upto a certain point, and we are interested in
1823          * the data only upto that point.
1824          */
1825
1826         if (AR_SREV_9271(priv->ah))
1827                 pBase = (struct base_eep_header *)
1828                         &priv->ah->eeprom.map4k.baseEepHeader;
1829         else if (priv->ah->hw_version.usbdev == AR9280_USB)
1830                 pBase = (struct base_eep_header *)
1831                         &priv->ah->eeprom.def.baseEepHeader;
1832         else if (priv->ah->hw_version.usbdev == AR9287_USB)
1833                 pBase = (struct base_eep_header *)
1834                         &priv->ah->eeprom.map9287.baseEepHeader;
1835         return pBase;
1836 }
1837
1838
1839 static int ath9k_htc_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant,
1840                                  u32 *rx_ant)
1841 {
1842         struct ath9k_htc_priv *priv = hw->priv;
1843         struct base_eep_header *pBase = ath9k_htc_get_eeprom_base(priv);
1844         if (pBase) {
1845                 *tx_ant = pBase->txMask;
1846                 *rx_ant = pBase->rxMask;
1847         } else {
1848                 *tx_ant = 0;
1849                 *rx_ant = 0;
1850         }
1851         return 0;
1852 }
1853
1854 static void ath9k_htc_channel_switch_beacon(struct ieee80211_hw *hw,
1855                                             struct ieee80211_vif *vif,
1856                                             struct cfg80211_chan_def *chandef)
1857 {
1858         struct ath9k_htc_priv *priv = hw->priv;
1859
1860         /* mac80211 does not support CSA in multi-if cases (yet) */
1861         if (WARN_ON(priv->csa_vif))
1862                 return;
1863
1864         priv->csa_vif = vif;
1865 }
1866
1867 struct ieee80211_ops ath9k_htc_ops = {
1868         .tx                 = ath9k_htc_tx,
1869         .start              = ath9k_htc_start,
1870         .stop               = ath9k_htc_stop,
1871         .add_interface      = ath9k_htc_add_interface,
1872         .remove_interface   = ath9k_htc_remove_interface,
1873         .config             = ath9k_htc_config,
1874         .configure_filter   = ath9k_htc_configure_filter,
1875         .sta_add            = ath9k_htc_sta_add,
1876         .sta_remove         = ath9k_htc_sta_remove,
1877         .conf_tx            = ath9k_htc_conf_tx,
1878         .sta_rc_update      = ath9k_htc_sta_rc_update,
1879         .bss_info_changed   = ath9k_htc_bss_info_changed,
1880         .set_key            = ath9k_htc_set_key,
1881         .get_tsf            = ath9k_htc_get_tsf,
1882         .set_tsf            = ath9k_htc_set_tsf,
1883         .reset_tsf          = ath9k_htc_reset_tsf,
1884         .ampdu_action       = ath9k_htc_ampdu_action,
1885         .sw_scan_start      = ath9k_htc_sw_scan_start,
1886         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1887         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1888         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1889         .set_coverage_class = ath9k_htc_set_coverage_class,
1890         .set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1891         .get_stats          = ath9k_htc_get_stats,
1892         .get_antenna        = ath9k_htc_get_antenna,
1893         .channel_switch_beacon  = ath9k_htc_channel_switch_beacon,
1894
1895 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
1896         .get_et_sset_count  = ath9k_htc_get_et_sset_count,
1897         .get_et_stats       = ath9k_htc_get_et_stats,
1898         .get_et_strings     = ath9k_htc_get_et_strings,
1899 #endif
1900 };