drivers/net/wireless/ath/ath9k/htc_drv_main.c

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