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