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