kernel/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         /* Short calibration applies only while caldone is false */
 798         if (!common->ani.caldone) {
 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);
 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         if (!common->ani.caldone)
 848                 cal_interval = min(cal_interval, (u32)short_cal_interval);
 849
 850         ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
 851                                      msecs_to_jiffies(cal_interval));
 852 }
 853
 854 /**********************/
 855 /* mac80211 Callbacks */
 856 /**********************/
 857
 858 static void ath9k_htc_tx(struct ieee80211_hw *hw,
 859                          struct ieee80211_tx_control *control,
 860                          struct sk_buff *skb)
 861 {
 862         struct ieee80211_hdr *hdr;
 863         struct ath9k_htc_priv *priv = hw->priv;
 864         struct ath_common *common = ath9k_hw_common(priv->ah);
 865         int padpos, padsize, ret, slot;
 866
 867         hdr = (struct ieee80211_hdr *) skb->data;
 868
 869         /* Add the padding after the header if this is not already done */
 870         padpos = ieee80211_hdrlen(hdr->frame_control);
 871         padsize = padpos & 3;
 872         if (padsize && skb->len > padpos) {
 873                 if (skb_headroom(skb) < padsize) {
 874                         ath_dbg(common, XMIT, "No room for padding\n");
 875                         goto fail_tx;
 876                 }
 877                 skb_push(skb, padsize);
 878                 memmove(skb->data, skb->data + padsize, padpos);
 879         }
 880
 881         slot = ath9k_htc_tx_get_slot(priv);
 882         if (slot < 0) {
 883                 ath_dbg(common, XMIT, "No free TX slot\n");
 884                 goto fail_tx;
 885         }
 886
 887         ret = ath9k_htc_tx_start(priv, control->sta, skb, slot, false);
 888         if (ret != 0) {
 889                 ath_dbg(common, XMIT, "Tx failed\n");
 890                 goto clear_slot;
 891         }
 892
 893         ath9k_htc_check_stop_queues(priv);
 894
 895         return;
 896
 897 clear_slot:
 898         ath9k_htc_tx_clear_slot(priv, slot);
 899 fail_tx:
 900         dev_kfree_skb_any(skb);
 901 }
 902
 903 static int ath9k_htc_start(struct ieee80211_hw *hw)
 904 {
 905         struct ath9k_htc_priv *priv = hw->priv;
 906         struct ath_hw *ah = priv->ah;
 907         struct ath_common *common = ath9k_hw_common(ah);
 908         struct ieee80211_channel *curchan = hw->conf.chandef.chan;
 909         struct ath9k_channel *init_channel;
 910         int ret = 0;
 911         enum htc_phymode mode;
 912         __be16 htc_mode;
 913         u8 cmd_rsp;
 914
 915         mutex_lock(&priv->mutex);
 916
 917         ath_dbg(common, CONFIG,
 918                 "Starting driver with initial channel: %d MHz\n",
 919                 curchan->center_freq);
 920
 921         /* Ensure that HW is awake before flushing RX */
 922         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
 923         WMI_CMD(WMI_FLUSH_RECV_CMDID);
 924
 925         /* setup initial channel */
 926         init_channel = ath9k_cmn_get_channel(hw, ah, &hw->conf.chandef);
 927
 928         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
 929         if (ret) {
 930                 ath_err(common,
 931                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
 932                         ret, curchan->center_freq);
 933                 mutex_unlock(&priv->mutex);
 934                 return ret;
 935         }
 936
 937         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
 938                                &priv->curtxpow);
 939
 940         mode = ath9k_htc_get_curmode(priv, init_channel);
 941         htc_mode = cpu_to_be16(mode);
 942         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
 943         WMI_CMD(WMI_ATH_INIT_CMDID);
 944         WMI_CMD(WMI_START_RECV_CMDID);
 945
 946         ath9k_host_rx_init(priv);
 947
 948         ret = ath9k_htc_update_cap_target(priv, 0);
 949         if (ret)
 950                 ath_dbg(common, CONFIG,
 951                         "Failed to update capability in target\n");
 952
 953         clear_bit(ATH_OP_INVALID, &common->op_flags);
 954         htc_start(priv->htc);
 955
 956         spin_lock_bh(&priv->tx.tx_lock);
 957         priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
 958         spin_unlock_bh(&priv->tx.tx_lock);
 959
 960         ieee80211_wake_queues(hw);
 961
 962         mod_timer(&priv->tx.cleanup_timer,
 963                   jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
 964
 965         ath9k_htc_start_btcoex(priv);
 966
 967         mutex_unlock(&priv->mutex);
 968
 969         return ret;
 970 }
 971
 972 static void ath9k_htc_stop(struct ieee80211_hw *hw)
 973 {
 974         struct ath9k_htc_priv *priv = hw->priv;
 975         struct ath_hw *ah = priv->ah;
 976         struct ath_common *common = ath9k_hw_common(ah);
 977         int ret __attribute__ ((unused));
 978         u8 cmd_rsp;
 979
 980         mutex_lock(&priv->mutex);
 981
 982         if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
 983                 ath_dbg(common, ANY, "Device not present\n");
 984                 mutex_unlock(&priv->mutex);
 985                 return;
 986         }
 987
 988         ath9k_htc_ps_wakeup(priv);
 989
 990         WMI_CMD(WMI_DISABLE_INTR_CMDID);
 991         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
 992         WMI_CMD(WMI_STOP_RECV_CMDID);
 993
 994         tasklet_kill(&priv->rx_tasklet);
 995
 996         del_timer_sync(&priv->tx.cleanup_timer);
 997         ath9k_htc_tx_drain(priv);
 998         ath9k_wmi_event_drain(priv);
 999
1000         mutex_unlock(&priv->mutex);
1001
1002         /* Cancel all the running timers/work .. */
1003         cancel_work_sync(&priv->fatal_work);
1004         cancel_work_sync(&priv->ps_work);
1005
1006 #ifdef CONFIG_MAC80211_LEDS
1007         cancel_work_sync(&priv->led_work);
1008 #endif
1009         ath9k_htc_stop_ani(priv);
1010
1011         mutex_lock(&priv->mutex);
1012
1013         ath9k_htc_stop_btcoex(priv);
1014
1015         /* Remove a monitor interface if it's present. */
1016         if (priv->ah->is_monitoring)
1017                 ath9k_htc_remove_monitor_interface(priv);
1018
1019         ath9k_hw_phy_disable(ah);
1020         ath9k_hw_disable(ah);
1021         ath9k_htc_ps_restore(priv);
1022         ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1023
1024         set_bit(ATH_OP_INVALID, &common->op_flags);
1025
1026         ath_dbg(common, CONFIG, "Driver halt\n");
1027         mutex_unlock(&priv->mutex);
1028 }
1029
1030 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1031                                    struct ieee80211_vif *vif)
1032 {
1033         struct ath9k_htc_priv *priv = hw->priv;
1034         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1035         struct ath_common *common = ath9k_hw_common(priv->ah);
1036         struct ath9k_htc_target_vif hvif;
1037         int ret = 0;
1038         u8 cmd_rsp;
1039
1040         mutex_lock(&priv->mutex);
1041
1042         ath9k_htc_ps_wakeup(priv);
1043         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1044         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1045
1046         switch (vif->type) {
1047         case NL80211_IFTYPE_STATION:
1048                 hvif.opmode = HTC_M_STA;
1049                 break;
1050         case NL80211_IFTYPE_ADHOC:
1051                 hvif.opmode = HTC_M_IBSS;
1052                 break;
1053         case NL80211_IFTYPE_AP:
1054                 hvif.opmode = HTC_M_HOSTAP;
1055                 break;
1056         case NL80211_IFTYPE_MESH_POINT:
1057                 hvif.opmode = HTC_M_WDS;        /* close enough */
1058                 break;
1059         default:
1060                 ath_err(common,
1061                         "Interface type %d not yet supported\n", vif->type);
1062                 ret = -EOPNOTSUPP;
1063                 goto out;
1064         }
1065
1066         /* Index starts from zero on the target */
1067         avp->index = hvif.index = ffz(priv->vif_slot);
1068         hvif.rtsthreshold = cpu_to_be16(2304);
1069         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1070         if (ret)
1071                 goto out;
1072
1073         /*
1074          * We need a node in target to tx mgmt frames
1075          * before association.
1076          */
1077         ret = ath9k_htc_add_station(priv, vif, NULL);
1078         if (ret) {
1079                 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1080                 goto out;
1081         }
1082
1083         ath9k_htc_set_mac_bssid_mask(priv, vif);
1084
1085         priv->vif_slot |= (1 << avp->index);
1086         priv->nvifs++;
1087
1088         INC_VIF(priv, vif->type);
1089
1090         if ((vif->type == NL80211_IFTYPE_AP) ||
1091             (vif->type == NL80211_IFTYPE_MESH_POINT) ||
1092             (vif->type == NL80211_IFTYPE_ADHOC))
1093                 ath9k_htc_assign_bslot(priv, vif);
1094
1095         ath9k_htc_set_opmode(priv);
1096
1097         if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1098             !test_bit(ATH_OP_ANI_RUN, &common->op_flags)) {
1099                 ath9k_hw_set_tsfadjust(priv->ah, true);
1100                 ath9k_htc_start_ani(priv);
1101         }
1102
1103         ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n",
1104                 vif->type, avp->index);
1105
1106 out:
1107         ath9k_htc_ps_restore(priv);
1108         mutex_unlock(&priv->mutex);
1109
1110         return ret;
1111 }
1112
1113 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1114                                        struct ieee80211_vif *vif)
1115 {
1116         struct ath9k_htc_priv *priv = hw->priv;
1117         struct ath_common *common = ath9k_hw_common(priv->ah);
1118         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1119         struct ath9k_htc_target_vif hvif;
1120         int ret = 0;
1121         u8 cmd_rsp;
1122
1123         mutex_lock(&priv->mutex);
1124         ath9k_htc_ps_wakeup(priv);
1125
1126         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1127         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1128         hvif.index = avp->index;
1129         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1130         if (ret) {
1131                 ath_err(common, "Unable to remove interface at idx: %d\n",
1132                         avp->index);
1133         }
1134         priv->nvifs--;
1135         priv->vif_slot &= ~(1 << avp->index);
1136
1137         ath9k_htc_remove_station(priv, vif, NULL);
1138
1139         DEC_VIF(priv, vif->type);
1140
1141         if ((vif->type == NL80211_IFTYPE_AP) ||
1142              vif->type == NL80211_IFTYPE_MESH_POINT ||
1143             (vif->type == NL80211_IFTYPE_ADHOC))
1144                 ath9k_htc_remove_bslot(priv, vif);
1145
1146         ath9k_htc_set_opmode(priv);
1147
1148         ath9k_htc_set_mac_bssid_mask(priv, vif);
1149
1150         /*
1151          * Stop ANI only if there are no associated station interfaces.
1152          */
1153         if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1154                 priv->rearm_ani = false;
1155                 ieee80211_iterate_active_interfaces_atomic(
1156                         priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1157                         ath9k_htc_vif_iter, priv);
1158                 if (!priv->rearm_ani)
1159                         ath9k_htc_stop_ani(priv);
1160         }
1161
1162         ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index);
1163
1164         ath9k_htc_ps_restore(priv);
1165         mutex_unlock(&priv->mutex);
1166 }
1167
1168 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1169 {
1170         struct ath9k_htc_priv *priv = hw->priv;
1171         struct ath_common *common = ath9k_hw_common(priv->ah);
1172         struct ieee80211_conf *conf = &hw->conf;
1173         bool chip_reset = false;
1174         int ret = 0;
1175
1176         mutex_lock(&priv->mutex);
1177         ath9k_htc_ps_wakeup(priv);
1178
1179         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1180                 mutex_lock(&priv->htc_pm_lock);
1181
1182                 priv->ps_idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1183                 if (!priv->ps_idle)
1184                         chip_reset = true;
1185
1186                 mutex_unlock(&priv->htc_pm_lock);
1187         }
1188
1189         /*
1190          * Monitor interface should be added before
1191          * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1192          */
1193         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1194                 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1195                     !priv->ah->is_monitoring)
1196                         ath9k_htc_add_monitor_interface(priv);
1197                 else if (priv->ah->is_monitoring)
1198                         ath9k_htc_remove_monitor_interface(priv);
1199         }
1200
1201         if ((changed & IEEE80211_CONF_CHANGE_CHANNEL) || chip_reset) {
1202                 struct ieee80211_channel *curchan = hw->conf.chandef.chan;
1203                 int pos = curchan->hw_value;
1204
1205                 ath_dbg(common, CONFIG, "Set channel: %d MHz\n",
1206                         curchan->center_freq);
1207
1208                 ath9k_cmn_get_channel(hw, priv->ah, &hw->conf.chandef);
1209                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1210                         ath_err(common, "Unable to set channel\n");
1211                         ret = -EINVAL;
1212                         goto out;
1213                 }
1214
1215         }
1216
1217         if (changed & IEEE80211_CONF_CHANGE_PS) {
1218                 if (conf->flags & IEEE80211_CONF_PS) {
1219                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1220                         priv->ps_enabled = true;
1221                 } else {
1222                         priv->ps_enabled = false;
1223                         cancel_work_sync(&priv->ps_work);
1224                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1225                 }
1226         }
1227
1228         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1229                 priv->txpowlimit = 2 * conf->power_level;
1230                 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1231                                        priv->txpowlimit, &priv->curtxpow);
1232         }
1233
1234 out:
1235         ath9k_htc_ps_restore(priv);
1236         mutex_unlock(&priv->mutex);
1237         return ret;
1238 }
1239
1240 #define SUPPORTED_FILTERS                       \
1241         (FIF_PROMISC_IN_BSS |                   \
1242         FIF_ALLMULTI |                          \
1243         FIF_CONTROL |                           \
1244         FIF_PSPOLL |                            \
1245         FIF_OTHER_BSS |                         \
1246         FIF_BCN_PRBRESP_PROMISC |               \
1247         FIF_PROBE_REQ |                         \
1248         FIF_FCSFAIL)
1249
1250 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1251                                        unsigned int changed_flags,
1252                                        unsigned int *total_flags,
1253                                        u64 multicast)
1254 {
1255         struct ath9k_htc_priv *priv = hw->priv;
1256         struct ath_common *common = ath9k_hw_common(priv->ah);
1257         u32 rfilt;
1258
1259         mutex_lock(&priv->mutex);
1260         changed_flags &= SUPPORTED_FILTERS;
1261         *total_flags &= SUPPORTED_FILTERS;
1262
1263         if (test_bit(ATH_OP_INVALID, &common->op_flags)) {
1264                 ath_dbg(ath9k_hw_common(priv->ah), ANY,
1265                         "Unable to configure filter on invalid state\n");
1266                 mutex_unlock(&priv->mutex);
1267                 return;
1268         }
1269         ath9k_htc_ps_wakeup(priv);
1270
1271         priv->rxfilter = *total_flags;
1272         rfilt = ath9k_htc_calcrxfilter(priv);
1273         ath9k_hw_setrxfilter(priv->ah, rfilt);
1274
1275         ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1276                 rfilt);
1277
1278         ath9k_htc_ps_restore(priv);
1279         mutex_unlock(&priv->mutex);
1280 }
1281
1282 static void ath9k_htc_sta_rc_update_work(struct work_struct *work)
1283 {
1284         struct ath9k_htc_sta *ista =
1285             container_of(work, struct ath9k_htc_sta, rc_update_work);
1286         struct ieee80211_sta *sta =
1287             container_of((void *)ista, struct ieee80211_sta, drv_priv);
1288         struct ath9k_htc_priv *priv = ista->htc_priv;
1289         struct ath_common *common = ath9k_hw_common(priv->ah);
1290         struct ath9k_htc_target_rate trate;
1291
1292         mutex_lock(&priv->mutex);
1293         ath9k_htc_ps_wakeup(priv);
1294
1295         memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
1296         ath9k_htc_setup_rate(priv, sta, &trate);
1297         if (!ath9k_htc_send_rate_cmd(priv, &trate))
1298                 ath_dbg(common, CONFIG,
1299                         "Supported rates for sta: %pM updated, rate caps: 0x%X\n",
1300                         sta->addr, be32_to_cpu(trate.capflags));
1301         else
1302                 ath_dbg(common, CONFIG,
1303                         "Unable to update supported rates for sta: %pM\n",
1304                         sta->addr);
1305
1306         ath9k_htc_ps_restore(priv);
1307         mutex_unlock(&priv->mutex);
1308 }
1309
1310 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1311                              struct ieee80211_vif *vif,
1312                              struct ieee80211_sta *sta)
1313 {
1314         struct ath9k_htc_priv *priv = hw->priv;
1315         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1316         int ret;
1317
1318         mutex_lock(&priv->mutex);
1319         ath9k_htc_ps_wakeup(priv);
1320         ret = ath9k_htc_add_station(priv, vif, sta);
1321         if (!ret) {
1322                 INIT_WORK(&ista->rc_update_work, ath9k_htc_sta_rc_update_work);
1323                 ista->htc_priv = priv;
1324                 ath9k_htc_init_rate(priv, sta);
1325         }
1326         ath9k_htc_ps_restore(priv);
1327         mutex_unlock(&priv->mutex);
1328
1329         return ret;
1330 }
1331
1332 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1333                                 struct ieee80211_vif *vif,
1334                                 struct ieee80211_sta *sta)
1335 {
1336         struct ath9k_htc_priv *priv = hw->priv;
1337         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1338         int ret;
1339
1340         cancel_work_sync(&ista->rc_update_work);
1341
1342         mutex_lock(&priv->mutex);
1343         ath9k_htc_ps_wakeup(priv);
1344         htc_sta_drain(priv->htc, ista->index);
1345         ret = ath9k_htc_remove_station(priv, vif, sta);
1346         ath9k_htc_ps_restore(priv);
1347         mutex_unlock(&priv->mutex);
1348
1349         return ret;
1350 }
1351
1352 static void ath9k_htc_sta_rc_update(struct ieee80211_hw *hw,
1353                                     struct ieee80211_vif *vif,
1354                                     struct ieee80211_sta *sta, u32 changed)
1355 {
1356         struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
1357
1358         if (!(changed & IEEE80211_RC_SUPP_RATES_CHANGED))
1359                 return;
1360
1361         schedule_work(&ista->rc_update_work);
1362 }
1363
1364 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw,
1365                              struct ieee80211_vif *vif, u16 queue,
1366                              const struct ieee80211_tx_queue_params *params)
1367 {
1368         struct ath9k_htc_priv *priv = hw->priv;
1369         struct ath_common *common = ath9k_hw_common(priv->ah);
1370         struct ath9k_tx_queue_info qi;
1371         int ret = 0, qnum;
1372
1373         if (queue >= IEEE80211_NUM_ACS)
1374                 return 0;
1375
1376         mutex_lock(&priv->mutex);
1377         ath9k_htc_ps_wakeup(priv);
1378
1379         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1380
1381         qi.tqi_aifs = params->aifs;
1382         qi.tqi_cwmin = params->cw_min;
1383         qi.tqi_cwmax = params->cw_max;
1384         qi.tqi_burstTime = params->txop * 32;
1385
1386         qnum = get_hw_qnum(queue, priv->hwq_map);
1387
1388         ath_dbg(common, CONFIG,
1389                 "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1390                 queue, qnum, params->aifs, params->cw_min,
1391                 params->cw_max, params->txop);
1392
1393         ret = ath_htc_txq_update(priv, qnum, &qi);
1394         if (ret) {
1395                 ath_err(common, "TXQ Update failed\n");
1396                 goto out;
1397         }
1398
1399         if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1400             (qnum == priv->hwq_map[IEEE80211_AC_BE]))
1401                     ath9k_htc_beaconq_config(priv);
1402 out:
1403         ath9k_htc_ps_restore(priv);
1404         mutex_unlock(&priv->mutex);
1405
1406         return ret;
1407 }
1408
1409 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1410                              enum set_key_cmd cmd,
1411                              struct ieee80211_vif *vif,
1412                              struct ieee80211_sta *sta,
1413                              struct ieee80211_key_conf *key)
1414 {
1415         struct ath9k_htc_priv *priv = hw->priv;
1416         struct ath_common *common = ath9k_hw_common(priv->ah);
1417         int ret = 0;
1418
1419         if (htc_modparam_nohwcrypt)
1420                 return -ENOSPC;
1421
1422         if ((vif->type == NL80211_IFTYPE_ADHOC ||
1423              vif->type == NL80211_IFTYPE_MESH_POINT) &&
1424             (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
1425              key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
1426             !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) {
1427                 /*
1428                  * For now, disable hw crypto for the RSN IBSS group keys. This
1429                  * could be optimized in the future to use a modified key cache
1430                  * design to support per-STA RX GTK, but until that gets
1431                  * implemented, use of software crypto for group addressed
1432                  * frames is a acceptable to allow RSN IBSS to be used.
1433                  */
1434                 return -EOPNOTSUPP;
1435         }
1436
1437         mutex_lock(&priv->mutex);
1438         ath_dbg(common, CONFIG, "Set HW Key\n");
1439         ath9k_htc_ps_wakeup(priv);
1440
1441         switch (cmd) {
1442         case SET_KEY:
1443                 ret = ath_key_config(common, vif, sta, key);
1444                 if (ret >= 0) {
1445                         key->hw_key_idx = ret;
1446                         /* push IV and Michael MIC generation to stack */
1447                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1448                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1449                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1450                         if (priv->ah->sw_mgmt_crypto_tx &&
1451                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1452                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
1453                         ret = 0;
1454                 }
1455                 break;
1456         case DISABLE_KEY:
1457                 ath_key_delete(common, key);
1458                 break;
1459         default:
1460                 ret = -EINVAL;
1461         }
1462
1463         ath9k_htc_ps_restore(priv);
1464         mutex_unlock(&priv->mutex);
1465
1466         return ret;
1467 }
1468
1469 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1470 {
1471         struct ath_common *common = ath9k_hw_common(priv->ah);
1472
1473         ath9k_hw_write_associd(priv->ah);
1474         ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1475                 common->curbssid, common->curaid);
1476 }
1477
1478 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
1479 {
1480         struct ath9k_htc_priv *priv = (struct ath9k_htc_priv *)data;
1481         struct ath_common *common = ath9k_hw_common(priv->ah);
1482         struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
1483
1484         if ((vif->type == NL80211_IFTYPE_STATION) && bss_conf->assoc) {
1485                 common->curaid = bss_conf->aid;
1486                 common->last_rssi = ATH_RSSI_DUMMY_MARKER;
1487                 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1488                 set_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1489         }
1490 }
1491
1492 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1493 {
1494         if (priv->num_sta_assoc_vif == 1) {
1495                 ieee80211_iterate_active_interfaces_atomic(
1496                         priv->hw, IEEE80211_IFACE_ITER_RESUME_ALL,
1497                         ath9k_htc_bss_iter, priv);
1498                 ath9k_htc_set_bssid(priv);
1499         }
1500 }
1501
1502 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1503                                        struct ieee80211_vif *vif,
1504                                        struct ieee80211_bss_conf *bss_conf,
1505                                        u32 changed)
1506 {
1507         struct ath9k_htc_priv *priv = hw->priv;
1508         struct ath_hw *ah = priv->ah;
1509         struct ath_common *common = ath9k_hw_common(ah);
1510         int slottime;
1511
1512         mutex_lock(&priv->mutex);
1513         ath9k_htc_ps_wakeup(priv);
1514
1515         if (changed & BSS_CHANGED_ASSOC) {
1516                 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1517                         bss_conf->assoc);
1518
1519                 bss_conf->assoc ?
1520                         priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1521
1522                 if (!bss_conf->assoc)
1523                         clear_bit(ATH_OP_PRIM_STA_VIF, &common->op_flags);
1524
1525                 if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1526                         ath9k_htc_choose_set_bssid(priv);
1527                         if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1))
1528                                 ath9k_htc_start_ani(priv);
1529                         else if (priv->num_sta_assoc_vif == 0)
1530                                 ath9k_htc_stop_ani(priv);
1531                 }
1532         }
1533
1534         if (changed & BSS_CHANGED_IBSS) {
1535                 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1536                         common->curaid = bss_conf->aid;
1537                         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1538                         ath9k_htc_set_bssid(priv);
1539                 }
1540         }
1541
1542         if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1543                 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1544                         bss_conf->bssid);
1545                 ath9k_htc_set_tsfadjust(priv, vif);
1546                 priv->cur_beacon_conf.enable_beacon = 1;
1547                 ath9k_htc_beacon_config(priv, vif);
1548         }
1549
1550         if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1551                 /*
1552                  * Disable SWBA interrupt only if there are no
1553                  * concurrent AP/mesh or IBSS interfaces.
1554                  */
1555                 if ((priv->num_ap_vif + priv->num_mbss_vif <= 1) ||
1556                      priv->num_ibss_vif) {
1557                         ath_dbg(common, CONFIG,
1558                                 "Beacon disabled for BSS: %pM\n",
1559                                 bss_conf->bssid);
1560                         priv->cur_beacon_conf.enable_beacon = 0;
1561                         ath9k_htc_beacon_config(priv, vif);
1562                 }
1563         }
1564
1565         if (changed & BSS_CHANGED_BEACON_INT) {
1566                 /*
1567                  * Reset the HW TSF for the first AP or mesh interface.
1568                  */
1569                 if (priv->nvifs == 1 &&
1570                     ((priv->ah->opmode == NL80211_IFTYPE_AP &&
1571                       vif->type == NL80211_IFTYPE_AP &&
1572                       priv->num_ap_vif == 1) ||
1573                     (priv->ah->opmode == NL80211_IFTYPE_MESH_POINT &&
1574                       vif->type == NL80211_IFTYPE_MESH_POINT &&
1575                       priv->num_mbss_vif == 1))) {
1576                         set_bit(OP_TSF_RESET, &priv->op_flags);
1577                 }
1578                 ath_dbg(common, CONFIG,
1579                         "Beacon interval changed for BSS: %pM\n",
1580                         bss_conf->bssid);
1581                 ath9k_htc_beacon_config(priv, vif);
1582         }
1583
1584         if (changed & BSS_CHANGED_ERP_SLOT) {
1585                 if (bss_conf->use_short_slot)
1586                         slottime = 9;
1587                 else
1588                         slottime = 20;
1589                 if (vif->type == NL80211_IFTYPE_AP) {
1590                         /*
1591                          * Defer update, so that connected stations can adjust
1592                          * their settings at the same time.
1593                          * See beacon.c for more details
1594                          */
1595                         priv->beacon.slottime = slottime;
1596                         priv->beacon.updateslot = UPDATE;
1597                 } else {
1598                         ah->slottime = slottime;
1599                         ath9k_hw_init_global_settings(ah);
1600                 }
1601         }
1602
1603         if (changed & BSS_CHANGED_HT)
1604                 ath9k_htc_update_rate(priv, vif, bss_conf);
1605
1606         ath9k_htc_ps_restore(priv);
1607         mutex_unlock(&priv->mutex);
1608 }
1609
1610 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1611                              struct ieee80211_vif *vif)
1612 {
1613         struct ath9k_htc_priv *priv = hw->priv;
1614         u64 tsf;
1615
1616         mutex_lock(&priv->mutex);
1617         ath9k_htc_ps_wakeup(priv);
1618         tsf = ath9k_hw_gettsf64(priv->ah);
1619         ath9k_htc_ps_restore(priv);
1620         mutex_unlock(&priv->mutex);
1621
1622         return tsf;
1623 }
1624
1625 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1626                               struct ieee80211_vif *vif, u64 tsf)
1627 {
1628         struct ath9k_htc_priv *priv = hw->priv;
1629
1630         mutex_lock(&priv->mutex);
1631         ath9k_htc_ps_wakeup(priv);
1632         ath9k_hw_settsf64(priv->ah, tsf);
1633         ath9k_htc_ps_restore(priv);
1634         mutex_unlock(&priv->mutex);
1635 }
1636
1637 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1638                                 struct ieee80211_vif *vif)
1639 {
1640         struct ath9k_htc_priv *priv = hw->priv;
1641
1642         mutex_lock(&priv->mutex);
1643         ath9k_htc_ps_wakeup(priv);
1644         ath9k_hw_reset_tsf(priv->ah);
1645         ath9k_htc_ps_restore(priv);
1646         mutex_unlock(&priv->mutex);
1647 }
1648
1649 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1650                                   struct ieee80211_vif *vif,
1651                                   enum ieee80211_ampdu_mlme_action action,
1652                                   struct ieee80211_sta *sta,
1653                                   u16 tid, u16 *ssn, u8 buf_size)
1654 {
1655         struct ath9k_htc_priv *priv = hw->priv;
1656         struct ath9k_htc_sta *ista;
1657         int ret = 0;
1658
1659         mutex_lock(&priv->mutex);
1660         ath9k_htc_ps_wakeup(priv);
1661
1662         switch (action) {
1663         case IEEE80211_AMPDU_RX_START:
1664                 break;
1665         case IEEE80211_AMPDU_RX_STOP:
1666                 break;
1667         case IEEE80211_AMPDU_TX_START:
1668                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1669                 if (!ret)
1670                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1671                 break;
1672         case IEEE80211_AMPDU_TX_STOP_CONT:
1673         case IEEE80211_AMPDU_TX_STOP_FLUSH:
1674         case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1675                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1676                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1677                 break;
1678         case IEEE80211_AMPDU_TX_OPERATIONAL:
1679                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1680                 spin_lock_bh(&priv->tx.tx_lock);
1681                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1682                 spin_unlock_bh(&priv->tx.tx_lock);
1683                 break;
1684         default:
1685                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1686         }
1687
1688         ath9k_htc_ps_restore(priv);
1689         mutex_unlock(&priv->mutex);
1690
1691         return ret;
1692 }
1693
1694 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw,
1695                                     struct ieee80211_vif *vif,
1696                                     const u8 *mac_addr)
1697 {
1698         struct ath9k_htc_priv *priv = hw->priv;
1699         struct ath_common *common = ath9k_hw_common(priv->ah);
1700
1701         mutex_lock(&priv->mutex);
1702         spin_lock_bh(&priv->beacon_lock);
1703         set_bit(ATH_OP_SCANNING, &common->op_flags);
1704         spin_unlock_bh(&priv->beacon_lock);
1705         cancel_work_sync(&priv->ps_work);
1706         ath9k_htc_stop_ani(priv);
1707         mutex_unlock(&priv->mutex);
1708 }
1709
1710 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw,
1711                                        struct ieee80211_vif *vif)
1712 {
1713         struct ath9k_htc_priv *priv = hw->priv;
1714         struct ath_common *common = ath9k_hw_common(priv->ah);
1715
1716         mutex_lock(&priv->mutex);
1717         spin_lock_bh(&priv->beacon_lock);
1718         clear_bit(ATH_OP_SCANNING, &common->op_flags);
1719         spin_unlock_bh(&priv->beacon_lock);
1720         ath9k_htc_ps_wakeup(priv);
1721         ath9k_htc_vif_reconfig(priv);
1722         ath9k_htc_ps_restore(priv);
1723         mutex_unlock(&priv->mutex);
1724 }
1725
1726 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1727 {
1728         return 0;
1729 }
1730
1731 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1732                                          s16 coverage_class)
1733 {
1734         struct ath9k_htc_priv *priv = hw->priv;
1735
1736         mutex_lock(&priv->mutex);
1737         ath9k_htc_ps_wakeup(priv);
1738         priv->ah->coverage_class = coverage_class;
1739         ath9k_hw_init_global_settings(priv->ah);
1740         ath9k_htc_ps_restore(priv);
1741         mutex_unlock(&priv->mutex);
1742 }
1743
1744 /*
1745  * Currently, this is used only for selecting the minimum rate
1746  * for management frames, rate selection for data frames remain
1747  * unaffected.
1748  */
1749 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1750                                       struct ieee80211_vif *vif,
1751                                       const struct cfg80211_bitrate_mask *mask)
1752 {
1753         struct ath9k_htc_priv *priv = hw->priv;
1754         struct ath_common *common = ath9k_hw_common(priv->ah);
1755         struct ath9k_htc_target_rate_mask tmask;
1756         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1757         int ret = 0;
1758         u8 cmd_rsp;
1759
1760         memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1761
1762         tmask.vif_index = avp->index;
1763         tmask.band = IEEE80211_BAND_2GHZ;
1764         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1765
1766         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1767         if (ret) {
1768                 ath_err(common,
1769                         "Unable to set 2G rate mask for "
1770                         "interface at idx: %d\n", avp->index);
1771                 goto out;
1772         }
1773
1774         tmask.band = IEEE80211_BAND_5GHZ;
1775         tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1776
1777         WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1778         if (ret) {
1779                 ath_err(common,
1780                         "Unable to set 5G rate mask for "
1781                         "interface at idx: %d\n", avp->index);
1782                 goto out;
1783         }
1784
1785         ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1786                 mask->control[IEEE80211_BAND_2GHZ].legacy,
1787                 mask->control[IEEE80211_BAND_5GHZ].legacy);
1788 out:
1789         return ret;
1790 }
1791
1792
1793 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1794                                struct ieee80211_low_level_stats *stats)
1795 {
1796         struct ath9k_htc_priv *priv = hw->priv;
1797         struct ath_hw *ah = priv->ah;
1798         struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1799
1800         stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1801         stats->dot11RTSFailureCount = mib_stats->rts_bad;
1802         stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1803         stats->dot11RTSSuccessCount = mib_stats->rts_good;
1804
1805         return 0;
1806 }
1807
1808 struct base_eep_header *ath9k_htc_get_eeprom_base(struct ath9k_htc_priv *priv)
1809 {
1810         struct base_eep_header *pBase = NULL;
1811         /*
1812          * This can be done since all the 3 EEPROM families have the
1813          * same base header upto a certain point, and we are interested in
1814          * the data only upto that point.
1815          */
1816
1817         if (AR_SREV_9271(priv->ah))
1818                 pBase = (struct base_eep_header *)
1819                         &priv->ah->eeprom.map4k.baseEepHeader;
1820         else if (priv->ah->hw_version.usbdev == AR9280_USB)
1821                 pBase = (struct base_eep_header *)
1822                         &priv->ah->eeprom.def.baseEepHeader;
1823         else if (priv->ah->hw_version.usbdev == AR9287_USB)
1824                 pBase = (struct base_eep_header *)
1825                         &priv->ah->eeprom.map9287.baseEepHeader;
1826         return pBase;
1827 }
1828
1829
1830 static int ath9k_htc_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant,
1831                                  u32 *rx_ant)
1832 {
1833         struct ath9k_htc_priv *priv = hw->priv;
1834         struct base_eep_header *pBase = ath9k_htc_get_eeprom_base(priv);
1835         if (pBase) {
1836                 *tx_ant = pBase->txMask;
1837                 *rx_ant = pBase->rxMask;
1838         } else {
1839                 *tx_ant = 0;
1840                 *rx_ant = 0;
1841         }
1842         return 0;
1843 }
1844
1845 struct ieee80211_ops ath9k_htc_ops = {
1846         .tx                 = ath9k_htc_tx,
1847         .start              = ath9k_htc_start,
1848         .stop               = ath9k_htc_stop,
1849         .add_interface      = ath9k_htc_add_interface,
1850         .remove_interface   = ath9k_htc_remove_interface,
1851         .config             = ath9k_htc_config,
1852         .configure_filter   = ath9k_htc_configure_filter,
1853         .sta_add            = ath9k_htc_sta_add,
1854         .sta_remove         = ath9k_htc_sta_remove,
1855         .conf_tx            = ath9k_htc_conf_tx,
1856         .sta_rc_update      = ath9k_htc_sta_rc_update,
1857         .bss_info_changed   = ath9k_htc_bss_info_changed,
1858         .set_key            = ath9k_htc_set_key,
1859         .get_tsf            = ath9k_htc_get_tsf,
1860         .set_tsf            = ath9k_htc_set_tsf,
1861         .reset_tsf          = ath9k_htc_reset_tsf,
1862         .ampdu_action       = ath9k_htc_ampdu_action,
1863         .sw_scan_start      = ath9k_htc_sw_scan_start,
1864         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1865         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1866         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1867         .set_coverage_class = ath9k_htc_set_coverage_class,
1868         .set_bitrate_mask   = ath9k_htc_set_bitrate_mask,
1869         .get_stats          = ath9k_htc_get_stats,
1870         .get_antenna        = ath9k_htc_get_antenna,
1871
1872 #ifdef CONFIG_ATH9K_HTC_DEBUGFS
1873         .get_et_sset_count  = ath9k_htc_get_et_sset_count,
1874         .get_et_stats       = ath9k_htc_get_et_stats,
1875         .get_et_strings     = ath9k_htc_get_et_strings,
1876 #endif
1877 };