drivers/net/wireless/ath/ath9k/htc_drv_main.c

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