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