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