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