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