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