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 void 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                         goto fail_tx;
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;
1074
1075 fail_tx:
1076         dev_kfree_skb_any(skb);
1077 }
1078
1079 static int ath9k_htc_start(struct ieee80211_hw *hw)
1080 {
1081         struct ath9k_htc_priv *priv = hw->priv;
1082         struct ath_hw *ah = priv->ah;
1083         struct ath_common *common = ath9k_hw_common(ah);
1084         struct ieee80211_channel *curchan = hw->conf.channel;
1085         struct ath9k_channel *init_channel;
1086         int ret = 0;
1087         enum htc_phymode mode;
1088         __be16 htc_mode;
1089         u8 cmd_rsp;
1090
1091         mutex_lock(&priv->mutex);
1092
1093         ath_dbg(common, ATH_DBG_CONFIG,
1094                 "Starting driver with initial channel: %d MHz\n",
1095                 curchan->center_freq);
1096
1097         /* Ensure that HW is awake before flushing RX */
1098         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1099         WMI_CMD(WMI_FLUSH_RECV_CMDID);
1100
1101         /* setup initial channel */
1102         init_channel = ath9k_cmn_get_curchannel(hw, ah);
1103
1104         ath9k_hw_htc_resetinit(ah);
1105         ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
1106         if (ret) {
1107                 ath_err(common,
1108                         "Unable to reset hardware; reset status %d (freq %u MHz)\n",
1109                         ret, curchan->center_freq);
1110                 mutex_unlock(&priv->mutex);
1111                 return ret;
1112         }
1113
1114         ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
1115                                &priv->curtxpow);
1116
1117         mode = ath9k_htc_get_curmode(priv, init_channel);
1118         htc_mode = cpu_to_be16(mode);
1119         WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
1120         WMI_CMD(WMI_ATH_INIT_CMDID);
1121         WMI_CMD(WMI_START_RECV_CMDID);
1122
1123         ath9k_host_rx_init(priv);
1124
1125         ret = ath9k_htc_update_cap_target(priv);
1126         if (ret)
1127                 ath_dbg(common, ATH_DBG_CONFIG,
1128                         "Failed to update capability in target\n");
1129
1130         priv->op_flags &= ~OP_INVALID;
1131         htc_start(priv->htc);
1132
1133         spin_lock_bh(&priv->tx_lock);
1134         priv->tx_queues_stop = false;
1135         spin_unlock_bh(&priv->tx_lock);
1136
1137         ieee80211_wake_queues(hw);
1138
1139         if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE) {
1140                 ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
1141                                            AR_STOMP_LOW_WLAN_WGHT);
1142                 ath9k_hw_btcoex_enable(ah);
1143                 ath_htc_resume_btcoex_work(priv);
1144         }
1145         mutex_unlock(&priv->mutex);
1146
1147         return ret;
1148 }
1149
1150 static void ath9k_htc_stop(struct ieee80211_hw *hw)
1151 {
1152         struct ath9k_htc_priv *priv = hw->priv;
1153         struct ath_hw *ah = priv->ah;
1154         struct ath_common *common = ath9k_hw_common(ah);
1155         int ret = 0;
1156         u8 cmd_rsp;
1157
1158         mutex_lock(&priv->mutex);
1159
1160         if (priv->op_flags & OP_INVALID) {
1161                 ath_dbg(common, ATH_DBG_ANY, "Device not present\n");
1162                 mutex_unlock(&priv->mutex);
1163                 return;
1164         }
1165
1166         ath9k_htc_ps_wakeup(priv);
1167         htc_stop(priv->htc);
1168         WMI_CMD(WMI_DISABLE_INTR_CMDID);
1169         WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
1170         WMI_CMD(WMI_STOP_RECV_CMDID);
1171
1172         tasklet_kill(&priv->swba_tasklet);
1173         tasklet_kill(&priv->rx_tasklet);
1174         tasklet_kill(&priv->tx_tasklet);
1175
1176         skb_queue_purge(&priv->tx_queue);
1177
1178         mutex_unlock(&priv->mutex);
1179
1180         /* Cancel all the running timers/work .. */
1181         cancel_work_sync(&priv->fatal_work);
1182         cancel_work_sync(&priv->ps_work);
1183         cancel_delayed_work_sync(&priv->ath9k_led_blink_work);
1184         ath9k_htc_stop_ani(priv);
1185         ath9k_led_stop_brightness(priv);
1186
1187         mutex_lock(&priv->mutex);
1188
1189         if (ah->btcoex_hw.enabled) {
1190                 ath9k_hw_btcoex_disable(ah);
1191                 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1192                         ath_htc_cancel_btcoex_work(priv);
1193         }
1194
1195         /* Remove a monitor interface if it's present. */
1196         if (priv->ah->is_monitoring)
1197                 ath9k_htc_remove_monitor_interface(priv);
1198
1199         ath9k_hw_phy_disable(ah);
1200         ath9k_hw_disable(ah);
1201         ath9k_htc_ps_restore(priv);
1202         ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1203
1204         priv->op_flags |= OP_INVALID;
1205
1206         ath_dbg(common, ATH_DBG_CONFIG, "Driver halt\n");
1207         mutex_unlock(&priv->mutex);
1208 }
1209
1210 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1211                                    struct ieee80211_vif *vif)
1212 {
1213         struct ath9k_htc_priv *priv = hw->priv;
1214         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1215         struct ath_common *common = ath9k_hw_common(priv->ah);
1216         struct ath9k_htc_target_vif hvif;
1217         int ret = 0;
1218         u8 cmd_rsp;
1219
1220         mutex_lock(&priv->mutex);
1221
1222         if (priv->nvifs >= ATH9K_HTC_MAX_VIF) {
1223                 mutex_unlock(&priv->mutex);
1224                 return -ENOBUFS;
1225         }
1226
1227         if (priv->num_ibss_vif ||
1228             (priv->nvifs && vif->type == NL80211_IFTYPE_ADHOC)) {
1229                 ath_err(common, "IBSS coexistence with other modes is not allowed\n");
1230                 mutex_unlock(&priv->mutex);
1231                 return -ENOBUFS;
1232         }
1233
1234         if (((vif->type == NL80211_IFTYPE_AP) ||
1235              (vif->type == NL80211_IFTYPE_ADHOC)) &&
1236             ((priv->num_ap_vif + priv->num_ibss_vif) >= ATH9K_HTC_MAX_BCN_VIF)) {
1237                 ath_err(common, "Max. number of beaconing interfaces reached\n");
1238                 mutex_unlock(&priv->mutex);
1239                 return -ENOBUFS;
1240         }
1241
1242         ath9k_htc_ps_wakeup(priv);
1243         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1244         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1245
1246         switch (vif->type) {
1247         case NL80211_IFTYPE_STATION:
1248                 hvif.opmode = cpu_to_be32(HTC_M_STA);
1249                 break;
1250         case NL80211_IFTYPE_ADHOC:
1251                 hvif.opmode = cpu_to_be32(HTC_M_IBSS);
1252                 break;
1253         case NL80211_IFTYPE_AP:
1254                 hvif.opmode = cpu_to_be32(HTC_M_HOSTAP);
1255                 break;
1256         default:
1257                 ath_err(common,
1258                         "Interface type %d not yet supported\n", vif->type);
1259                 ret = -EOPNOTSUPP;
1260                 goto out;
1261         }
1262
1263         /* Index starts from zero on the target */
1264         avp->index = hvif.index = ffz(priv->vif_slot);
1265         hvif.rtsthreshold = cpu_to_be16(2304);
1266         WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1267         if (ret)
1268                 goto out;
1269
1270         /*
1271          * We need a node in target to tx mgmt frames
1272          * before association.
1273          */
1274         ret = ath9k_htc_add_station(priv, vif, NULL);
1275         if (ret) {
1276                 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1277                 goto out;
1278         }
1279
1280         ath9k_htc_set_bssid_mask(priv, vif);
1281
1282         priv->vif_slot |= (1 << avp->index);
1283         priv->nvifs++;
1284         priv->vif = vif;
1285
1286         INC_VIF(priv, vif->type);
1287         ath9k_htc_set_opmode(priv);
1288
1289         if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1290             !(priv->op_flags & OP_ANI_RUNNING))
1291                 ath9k_htc_start_ani(priv);
1292
1293         ath_dbg(common, ATH_DBG_CONFIG,
1294                 "Attach a VIF of type: %d at idx: %d\n", vif->type, avp->index);
1295
1296 out:
1297         ath9k_htc_ps_restore(priv);
1298         mutex_unlock(&priv->mutex);
1299
1300         return ret;
1301 }
1302
1303 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1304                                        struct ieee80211_vif *vif)
1305 {
1306         struct ath9k_htc_priv *priv = hw->priv;
1307         struct ath_common *common = ath9k_hw_common(priv->ah);
1308         struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1309         struct ath9k_htc_target_vif hvif;
1310         int ret = 0;
1311         u8 cmd_rsp;
1312
1313         mutex_lock(&priv->mutex);
1314         ath9k_htc_ps_wakeup(priv);
1315
1316         memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1317         memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1318         hvif.index = avp->index;
1319         WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1320         priv->nvifs--;
1321         priv->vif_slot &= ~(1 << avp->index);
1322
1323         ath9k_htc_remove_station(priv, vif, NULL);
1324         priv->vif = NULL;
1325
1326         DEC_VIF(priv, vif->type);
1327         ath9k_htc_set_opmode(priv);
1328
1329         /*
1330          * Stop ANI only if there are no associated station interfaces.
1331          */
1332         if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1333                 priv->rearm_ani = false;
1334                 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1335                                                    ath9k_htc_vif_iter, priv);
1336                 if (!priv->rearm_ani)
1337                         ath9k_htc_stop_ani(priv);
1338         }
1339
1340         ath_dbg(common, ATH_DBG_CONFIG, "Detach Interface at idx: %d\n", avp->index);
1341
1342         ath9k_htc_ps_restore(priv);
1343         mutex_unlock(&priv->mutex);
1344 }
1345
1346 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1347 {
1348         struct ath9k_htc_priv *priv = hw->priv;
1349         struct ath_common *common = ath9k_hw_common(priv->ah);
1350         struct ieee80211_conf *conf = &hw->conf;
1351
1352         mutex_lock(&priv->mutex);
1353
1354         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1355                 bool enable_radio = false;
1356                 bool idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1357
1358                 mutex_lock(&priv->htc_pm_lock);
1359                 if (!idle && priv->ps_idle)
1360                         enable_radio = true;
1361                 priv->ps_idle = idle;
1362                 mutex_unlock(&priv->htc_pm_lock);
1363
1364                 if (enable_radio) {
1365                         ath_dbg(common, ATH_DBG_CONFIG,
1366                                 "not-idle: enabling radio\n");
1367                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1368                         ath9k_htc_radio_enable(hw);
1369                 }
1370         }
1371
1372         /*
1373          * Monitor interface should be added before
1374          * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1375          */
1376         if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1377                 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1378                     !priv->ah->is_monitoring)
1379                         ath9k_htc_add_monitor_interface(priv);
1380                 else if (priv->ah->is_monitoring)
1381                         ath9k_htc_remove_monitor_interface(priv);
1382         }
1383
1384         if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1385                 struct ieee80211_channel *curchan = hw->conf.channel;
1386                 int pos = curchan->hw_value;
1387
1388                 ath_dbg(common, ATH_DBG_CONFIG, "Set channel: %d MHz\n",
1389                         curchan->center_freq);
1390
1391                 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1392                                           hw->conf.channel,
1393                                           hw->conf.channel_type);
1394
1395                 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1396                         ath_err(common, "Unable to set channel\n");
1397                         mutex_unlock(&priv->mutex);
1398                         return -EINVAL;
1399                 }
1400
1401         }
1402
1403         if (changed & IEEE80211_CONF_CHANGE_PS) {
1404                 if (conf->flags & IEEE80211_CONF_PS) {
1405                         ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1406                         priv->ps_enabled = true;
1407                 } else {
1408                         priv->ps_enabled = false;
1409                         cancel_work_sync(&priv->ps_work);
1410                         ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1411                 }
1412         }
1413
1414         if (changed & IEEE80211_CONF_CHANGE_POWER) {
1415                 priv->txpowlimit = 2 * conf->power_level;
1416                 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1417                                        priv->txpowlimit, &priv->curtxpow);
1418         }
1419
1420         if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1421                 mutex_lock(&priv->htc_pm_lock);
1422                 if (!priv->ps_idle) {
1423                         mutex_unlock(&priv->htc_pm_lock);
1424                         goto out;
1425                 }
1426                 mutex_unlock(&priv->htc_pm_lock);
1427
1428                 ath_dbg(common, ATH_DBG_CONFIG,
1429                         "idle: disabling radio\n");
1430                 ath9k_htc_radio_disable(hw);
1431         }
1432
1433 out:
1434         mutex_unlock(&priv->mutex);
1435         return 0;
1436 }
1437
1438 #define SUPPORTED_FILTERS                       \
1439         (FIF_PROMISC_IN_BSS |                   \
1440         FIF_ALLMULTI |                          \
1441         FIF_CONTROL |                           \
1442         FIF_PSPOLL |                            \
1443         FIF_OTHER_BSS |                         \
1444         FIF_BCN_PRBRESP_PROMISC |               \
1445         FIF_PROBE_REQ |                         \
1446         FIF_FCSFAIL)
1447
1448 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1449                                        unsigned int changed_flags,
1450                                        unsigned int *total_flags,
1451                                        u64 multicast)
1452 {
1453         struct ath9k_htc_priv *priv = hw->priv;
1454         u32 rfilt;
1455
1456         mutex_lock(&priv->mutex);
1457         ath9k_htc_ps_wakeup(priv);
1458
1459         changed_flags &= SUPPORTED_FILTERS;
1460         *total_flags &= SUPPORTED_FILTERS;
1461
1462         priv->rxfilter = *total_flags;
1463         rfilt = ath9k_htc_calcrxfilter(priv);
1464         ath9k_hw_setrxfilter(priv->ah, rfilt);
1465
1466         ath_dbg(ath9k_hw_common(priv->ah), ATH_DBG_CONFIG,
1467                 "Set HW RX filter: 0x%x\n", rfilt);
1468
1469         ath9k_htc_ps_restore(priv);
1470         mutex_unlock(&priv->mutex);
1471 }
1472
1473 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1474                              struct ieee80211_vif *vif,
1475                              struct ieee80211_sta *sta)
1476 {
1477         struct ath9k_htc_priv *priv = hw->priv;
1478         int ret;
1479
1480         mutex_lock(&priv->mutex);
1481         ath9k_htc_ps_wakeup(priv);
1482         ret = ath9k_htc_add_station(priv, vif, sta);
1483         if (!ret)
1484                 ath9k_htc_init_rate(priv, sta);
1485         ath9k_htc_ps_restore(priv);
1486         mutex_unlock(&priv->mutex);
1487
1488         return ret;
1489 }
1490
1491 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1492                                 struct ieee80211_vif *vif,
1493                                 struct ieee80211_sta *sta)
1494 {
1495         struct ath9k_htc_priv *priv = hw->priv;
1496         int ret;
1497
1498         mutex_lock(&priv->mutex);
1499         ath9k_htc_ps_wakeup(priv);
1500         ret = ath9k_htc_remove_station(priv, vif, sta);
1501         ath9k_htc_ps_restore(priv);
1502         mutex_unlock(&priv->mutex);
1503
1504         return ret;
1505 }
1506
1507 static int ath9k_htc_conf_tx(struct ieee80211_hw *hw, u16 queue,
1508                              const struct ieee80211_tx_queue_params *params)
1509 {
1510         struct ath9k_htc_priv *priv = hw->priv;
1511         struct ath_common *common = ath9k_hw_common(priv->ah);
1512         struct ath9k_tx_queue_info qi;
1513         int ret = 0, qnum;
1514
1515         if (queue >= WME_NUM_AC)
1516                 return 0;
1517
1518         mutex_lock(&priv->mutex);
1519         ath9k_htc_ps_wakeup(priv);
1520
1521         memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
1522
1523         qi.tqi_aifs = params->aifs;
1524         qi.tqi_cwmin = params->cw_min;
1525         qi.tqi_cwmax = params->cw_max;
1526         qi.tqi_burstTime = params->txop;
1527
1528         qnum = get_hw_qnum(queue, priv->hwq_map);
1529
1530         ath_dbg(common, ATH_DBG_CONFIG,
1531                 "Configure tx [queue/hwq] [%d/%d],  aifs: %d, cw_min: %d, cw_max: %d, txop: %d\n",
1532                 queue, qnum, params->aifs, params->cw_min,
1533                 params->cw_max, params->txop);
1534
1535         ret = ath_htc_txq_update(priv, qnum, &qi);
1536         if (ret) {
1537                 ath_err(common, "TXQ Update failed\n");
1538                 goto out;
1539         }
1540
1541         if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1542             (qnum == priv->hwq_map[WME_AC_BE]))
1543                     ath9k_htc_beaconq_config(priv);
1544 out:
1545         ath9k_htc_ps_restore(priv);
1546         mutex_unlock(&priv->mutex);
1547
1548         return ret;
1549 }
1550
1551 static int ath9k_htc_set_key(struct ieee80211_hw *hw,
1552                              enum set_key_cmd cmd,
1553                              struct ieee80211_vif *vif,
1554                              struct ieee80211_sta *sta,
1555                              struct ieee80211_key_conf *key)
1556 {
1557         struct ath9k_htc_priv *priv = hw->priv;
1558         struct ath_common *common = ath9k_hw_common(priv->ah);
1559         int ret = 0;
1560
1561         if (htc_modparam_nohwcrypt)
1562                 return -ENOSPC;
1563
1564         mutex_lock(&priv->mutex);
1565         ath_dbg(common, ATH_DBG_CONFIG, "Set HW Key\n");
1566         ath9k_htc_ps_wakeup(priv);
1567
1568         switch (cmd) {
1569         case SET_KEY:
1570                 ret = ath_key_config(common, vif, sta, key);
1571                 if (ret >= 0) {
1572                         key->hw_key_idx = ret;
1573                         /* push IV and Michael MIC generation to stack */
1574                         key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
1575                         if (key->cipher == WLAN_CIPHER_SUITE_TKIP)
1576                                 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIC;
1577                         if (priv->ah->sw_mgmt_crypto &&
1578                             key->cipher == WLAN_CIPHER_SUITE_CCMP)
1579                                 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT;
1580                         ret = 0;
1581                 }
1582                 break;
1583         case DISABLE_KEY:
1584                 ath_key_delete(common, key);
1585                 break;
1586         default:
1587                 ret = -EINVAL;
1588         }
1589
1590         ath9k_htc_ps_restore(priv);
1591         mutex_unlock(&priv->mutex);
1592
1593         return ret;
1594 }
1595
1596 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1597                                        struct ieee80211_vif *vif,
1598                                        struct ieee80211_bss_conf *bss_conf,
1599                                        u32 changed)
1600 {
1601         struct ath9k_htc_priv *priv = hw->priv;
1602         struct ath_hw *ah = priv->ah;
1603         struct ath_common *common = ath9k_hw_common(ah);
1604         bool set_assoc;
1605
1606         mutex_lock(&priv->mutex);
1607         ath9k_htc_ps_wakeup(priv);
1608
1609         /*
1610          * Set the HW AID/BSSID only for the first station interface
1611          * or in IBSS mode.
1612          */
1613         set_assoc = !!((priv->ah->opmode == NL80211_IFTYPE_ADHOC) ||
1614                        ((priv->ah->opmode == NL80211_IFTYPE_STATION) &&
1615                         (priv->num_sta_vif == 1)));
1616
1617
1618         if (changed & BSS_CHANGED_ASSOC) {
1619                 if (set_assoc) {
1620                         ath_dbg(common, ATH_DBG_CONFIG, "BSS Changed ASSOC %d\n",
1621                                 bss_conf->assoc);
1622
1623                         common->curaid = bss_conf->assoc ?
1624                                 bss_conf->aid : 0;
1625
1626                         if (bss_conf->assoc)
1627                                 ath9k_htc_start_ani(priv);
1628                         else
1629                                 ath9k_htc_stop_ani(priv);
1630                 }
1631         }
1632
1633         if (changed & BSS_CHANGED_BSSID) {
1634                 if (set_assoc) {
1635                         memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1636                         ath9k_hw_write_associd(ah);
1637
1638                         ath_dbg(common, ATH_DBG_CONFIG,
1639                                 "BSSID: %pM aid: 0x%x\n",
1640                                 common->curbssid, common->curaid);
1641                 }
1642         }
1643
1644         if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1645                 ath_dbg(common, ATH_DBG_CONFIG,
1646                         "Beacon enabled for BSS: %pM\n", bss_conf->bssid);
1647                 priv->op_flags |= OP_ENABLE_BEACON;
1648                 ath9k_htc_beacon_config(priv, vif);
1649         }
1650
1651         if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1652                 /*
1653                  * Disable SWBA interrupt only if there are no
1654                  * AP/IBSS interfaces.
1655                  */
1656                 if ((priv->num_ap_vif <= 1) || priv->num_ibss_vif) {
1657                         ath_dbg(common, ATH_DBG_CONFIG,
1658                                 "Beacon disabled for BSS: %pM\n",
1659                                 bss_conf->bssid);
1660                         priv->op_flags &= ~OP_ENABLE_BEACON;
1661                         ath9k_htc_beacon_config(priv, vif);
1662                 }
1663         }
1664
1665         if (changed & BSS_CHANGED_BEACON_INT) {
1666                 /*
1667                  * Reset the HW TSF for the first AP interface.
1668                  */
1669                 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1670                     (priv->nvifs == 1) &&
1671                     (priv->num_ap_vif == 1) &&
1672                     (vif->type == NL80211_IFTYPE_AP)) {
1673                         priv->op_flags |= OP_TSF_RESET;
1674                 }
1675                 ath_dbg(common, ATH_DBG_CONFIG,
1676                         "Beacon interval changed for BSS: %pM\n",
1677                         bss_conf->bssid);
1678                 ath9k_htc_beacon_config(priv, vif);
1679         }
1680
1681         if (changed & BSS_CHANGED_ERP_SLOT) {
1682                 if (bss_conf->use_short_slot)
1683                         ah->slottime = 9;
1684                 else
1685                         ah->slottime = 20;
1686
1687                 ath9k_hw_init_global_settings(ah);
1688         }
1689
1690         if (changed & BSS_CHANGED_HT)
1691                 ath9k_htc_update_rate(priv, vif, bss_conf);
1692
1693         ath9k_htc_ps_restore(priv);
1694         mutex_unlock(&priv->mutex);
1695 }
1696
1697 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw)
1698 {
1699         struct ath9k_htc_priv *priv = hw->priv;
1700         u64 tsf;
1701
1702         mutex_lock(&priv->mutex);
1703         ath9k_htc_ps_wakeup(priv);
1704         tsf = ath9k_hw_gettsf64(priv->ah);
1705         ath9k_htc_ps_restore(priv);
1706         mutex_unlock(&priv->mutex);
1707
1708         return tsf;
1709 }
1710
1711 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw, u64 tsf)
1712 {
1713         struct ath9k_htc_priv *priv = hw->priv;
1714
1715         mutex_lock(&priv->mutex);
1716         ath9k_htc_ps_wakeup(priv);
1717         ath9k_hw_settsf64(priv->ah, tsf);
1718         ath9k_htc_ps_restore(priv);
1719         mutex_unlock(&priv->mutex);
1720 }
1721
1722 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw)
1723 {
1724         struct ath9k_htc_priv *priv = hw->priv;
1725
1726         mutex_lock(&priv->mutex);
1727         ath9k_htc_ps_wakeup(priv);
1728         ath9k_hw_reset_tsf(priv->ah);
1729         ath9k_htc_ps_restore(priv);
1730         mutex_unlock(&priv->mutex);
1731 }
1732
1733 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1734                                   struct ieee80211_vif *vif,
1735                                   enum ieee80211_ampdu_mlme_action action,
1736                                   struct ieee80211_sta *sta,
1737                                   u16 tid, u16 *ssn, u8 buf_size)
1738 {
1739         struct ath9k_htc_priv *priv = hw->priv;
1740         struct ath9k_htc_sta *ista;
1741         int ret = 0;
1742
1743         mutex_lock(&priv->mutex);
1744
1745         switch (action) {
1746         case IEEE80211_AMPDU_RX_START:
1747                 break;
1748         case IEEE80211_AMPDU_RX_STOP:
1749                 break;
1750         case IEEE80211_AMPDU_TX_START:
1751                 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1752                 if (!ret)
1753                         ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1754                 break;
1755         case IEEE80211_AMPDU_TX_STOP:
1756                 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1757                 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1758                 break;
1759         case IEEE80211_AMPDU_TX_OPERATIONAL:
1760                 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1761                 spin_lock_bh(&priv->tx_lock);
1762                 ista->tid_state[tid] = AGGR_OPERATIONAL;
1763                 spin_unlock_bh(&priv->tx_lock);
1764                 break;
1765         default:
1766                 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1767         }
1768
1769         mutex_unlock(&priv->mutex);
1770
1771         return ret;
1772 }
1773
1774 static void ath9k_htc_sw_scan_start(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         cancel_work_sync(&priv->ps_work);
1783         ath9k_htc_stop_ani(priv);
1784         mutex_unlock(&priv->mutex);
1785 }
1786
1787 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
1788 {
1789         struct ath9k_htc_priv *priv = hw->priv;
1790
1791         mutex_lock(&priv->mutex);
1792         spin_lock_bh(&priv->beacon_lock);
1793         priv->op_flags &= ~OP_SCANNING;
1794         spin_unlock_bh(&priv->beacon_lock);
1795         ath9k_htc_ps_wakeup(priv);
1796         ath9k_htc_vif_reconfig(priv);
1797         ath9k_htc_ps_restore(priv);
1798         mutex_unlock(&priv->mutex);
1799 }
1800
1801 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1802 {
1803         return 0;
1804 }
1805
1806 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1807                                          u8 coverage_class)
1808 {
1809         struct ath9k_htc_priv *priv = hw->priv;
1810
1811         mutex_lock(&priv->mutex);
1812         ath9k_htc_ps_wakeup(priv);
1813         priv->ah->coverage_class = coverage_class;
1814         ath9k_hw_init_global_settings(priv->ah);
1815         ath9k_htc_ps_restore(priv);
1816         mutex_unlock(&priv->mutex);
1817 }
1818
1819 struct ieee80211_ops ath9k_htc_ops = {
1820         .tx                 = ath9k_htc_tx,
1821         .start              = ath9k_htc_start,
1822         .stop               = ath9k_htc_stop,
1823         .add_interface      = ath9k_htc_add_interface,
1824         .remove_interface   = ath9k_htc_remove_interface,
1825         .config             = ath9k_htc_config,
1826         .configure_filter   = ath9k_htc_configure_filter,
1827         .sta_add            = ath9k_htc_sta_add,
1828         .sta_remove         = ath9k_htc_sta_remove,
1829         .conf_tx            = ath9k_htc_conf_tx,
1830         .bss_info_changed   = ath9k_htc_bss_info_changed,
1831         .set_key            = ath9k_htc_set_key,
1832         .get_tsf            = ath9k_htc_get_tsf,
1833         .set_tsf            = ath9k_htc_set_tsf,
1834         .reset_tsf          = ath9k_htc_reset_tsf,
1835         .ampdu_action       = ath9k_htc_ampdu_action,
1836         .sw_scan_start      = ath9k_htc_sw_scan_start,
1837         .sw_scan_complete   = ath9k_htc_sw_scan_complete,
1838         .set_rts_threshold  = ath9k_htc_set_rts_threshold,
1839         .rfkill_poll        = ath9k_htc_rfkill_poll_state,
1840         .set_coverage_class = ath9k_htc_set_coverage_class,
1841 };