2 * Copyright (c) 2010-2011 Atheros Communications Inc.
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.
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.
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)
27 enum htc_phymode mode;
31 switch (ichan->chanmode) {
34 case CHANNEL_G_HT40PLUS:
35 case CHANNEL_G_HT40MINUS:
40 case CHANNEL_A_HT40PLUS:
41 case CHANNEL_A_HT40MINUS:
53 bool ath9k_htc_setpower(struct ath9k_htc_priv *priv,
54 enum ath9k_power_mode mode)
58 mutex_lock(&priv->htc_pm_lock);
59 ret = ath9k_hw_setpower(priv->ah, mode);
60 mutex_unlock(&priv->htc_pm_lock);
65 void ath9k_htc_ps_wakeup(struct ath9k_htc_priv *priv)
67 mutex_lock(&priv->htc_pm_lock);
68 if (++priv->ps_usecount != 1)
70 ath9k_hw_setpower(priv->ah, ATH9K_PM_AWAKE);
73 mutex_unlock(&priv->htc_pm_lock);
76 void ath9k_htc_ps_restore(struct ath9k_htc_priv *priv)
78 mutex_lock(&priv->htc_pm_lock);
79 if (--priv->ps_usecount != 0)
83 ath9k_hw_setpower(priv->ah, ATH9K_PM_FULL_SLEEP);
84 else if (priv->ps_enabled)
85 ath9k_hw_setpower(priv->ah, ATH9K_PM_NETWORK_SLEEP);
88 mutex_unlock(&priv->htc_pm_lock);
91 void ath9k_ps_work(struct work_struct *work)
93 struct ath9k_htc_priv *priv =
94 container_of(work, struct ath9k_htc_priv,
96 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
98 /* The chip wakes up after receiving the first beacon
99 while network sleep is enabled. For the driver to
100 be in sync with the hw, set the chip to awake and
101 only then set it to sleep.
103 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
106 static void ath9k_htc_vif_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
108 struct ath9k_htc_priv *priv = data;
109 struct ieee80211_bss_conf *bss_conf = &vif->bss_conf;
111 if ((vif->type == NL80211_IFTYPE_AP) && bss_conf->enable_beacon)
112 priv->reconfig_beacon = true;
114 if (bss_conf->assoc) {
115 priv->rearm_ani = true;
116 priv->reconfig_beacon = true;
120 static void ath9k_htc_vif_reconfig(struct ath9k_htc_priv *priv)
122 priv->rearm_ani = false;
123 priv->reconfig_beacon = false;
125 ieee80211_iterate_active_interfaces_atomic(priv->hw,
126 ath9k_htc_vif_iter, priv);
128 ath9k_htc_start_ani(priv);
130 if (priv->reconfig_beacon) {
131 ath9k_htc_ps_wakeup(priv);
132 ath9k_htc_beacon_reconfig(priv);
133 ath9k_htc_ps_restore(priv);
137 static void ath9k_htc_bssid_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
139 struct ath9k_vif_iter_data *iter_data = data;
142 for (i = 0; i < ETH_ALEN; i++)
143 iter_data->mask[i] &= ~(iter_data->hw_macaddr[i] ^ mac[i]);
146 static void ath9k_htc_set_bssid_mask(struct ath9k_htc_priv *priv,
147 struct ieee80211_vif *vif)
149 struct ath_common *common = ath9k_hw_common(priv->ah);
150 struct ath9k_vif_iter_data iter_data;
153 * Use the hardware MAC address as reference, the hardware uses it
154 * together with the BSSID mask when matching addresses.
156 iter_data.hw_macaddr = common->macaddr;
157 memset(&iter_data.mask, 0xff, ETH_ALEN);
160 ath9k_htc_bssid_iter(&iter_data, vif->addr, vif);
162 /* Get list of all active MAC addresses */
163 ieee80211_iterate_active_interfaces_atomic(priv->hw, ath9k_htc_bssid_iter,
166 memcpy(common->bssidmask, iter_data.mask, ETH_ALEN);
167 ath_hw_setbssidmask(common);
170 static void ath9k_htc_set_opmode(struct ath9k_htc_priv *priv)
172 if (priv->num_ibss_vif)
173 priv->ah->opmode = NL80211_IFTYPE_ADHOC;
174 else if (priv->num_ap_vif)
175 priv->ah->opmode = NL80211_IFTYPE_AP;
177 priv->ah->opmode = NL80211_IFTYPE_STATION;
179 ath9k_hw_setopmode(priv->ah);
182 void ath9k_htc_reset(struct ath9k_htc_priv *priv)
184 struct ath_hw *ah = priv->ah;
185 struct ath_common *common = ath9k_hw_common(ah);
186 struct ieee80211_channel *channel = priv->hw->conf.channel;
187 struct ath9k_hw_cal_data *caldata = NULL;
188 enum htc_phymode mode;
193 mutex_lock(&priv->mutex);
194 ath9k_htc_ps_wakeup(priv);
196 ath9k_htc_stop_ani(priv);
197 ieee80211_stop_queues(priv->hw);
199 del_timer_sync(&priv->tx.cleanup_timer);
200 ath9k_htc_tx_drain(priv);
202 WMI_CMD(WMI_DISABLE_INTR_CMDID);
203 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
204 WMI_CMD(WMI_STOP_RECV_CMDID);
206 ath9k_wmi_event_drain(priv);
208 caldata = &priv->caldata;
209 ret = ath9k_hw_reset(ah, ah->curchan, caldata, false);
212 "Unable to reset device (%u Mhz) reset status %d\n",
213 channel->center_freq, ret);
216 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
219 WMI_CMD(WMI_START_RECV_CMDID);
220 ath9k_host_rx_init(priv);
222 mode = ath9k_htc_get_curmode(priv, ah->curchan);
223 htc_mode = cpu_to_be16(mode);
224 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
226 WMI_CMD(WMI_ENABLE_INTR_CMDID);
227 htc_start(priv->htc);
228 ath9k_htc_vif_reconfig(priv);
229 ieee80211_wake_queues(priv->hw);
231 mod_timer(&priv->tx.cleanup_timer,
232 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
234 ath9k_htc_ps_restore(priv);
235 mutex_unlock(&priv->mutex);
238 static int ath9k_htc_set_channel(struct ath9k_htc_priv *priv,
239 struct ieee80211_hw *hw,
240 struct ath9k_channel *hchan)
242 struct ath_hw *ah = priv->ah;
243 struct ath_common *common = ath9k_hw_common(ah);
244 struct ieee80211_conf *conf = &common->hw->conf;
246 struct ieee80211_channel *channel = hw->conf.channel;
247 struct ath9k_hw_cal_data *caldata = NULL;
248 enum htc_phymode mode;
253 if (priv->op_flags & OP_INVALID)
256 fastcc = !!(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL);
258 ath9k_htc_ps_wakeup(priv);
260 del_timer_sync(&priv->tx.cleanup_timer);
261 ath9k_htc_tx_drain(priv);
263 WMI_CMD(WMI_DISABLE_INTR_CMDID);
264 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
265 WMI_CMD(WMI_STOP_RECV_CMDID);
267 ath9k_wmi_event_drain(priv);
269 ath_dbg(common, CONFIG,
270 "(%u MHz) -> (%u MHz), HT: %d, HT40: %d fastcc: %d\n",
271 priv->ah->curchan->channel,
272 channel->center_freq, conf_is_ht(conf), conf_is_ht40(conf),
276 caldata = &priv->caldata;
278 ret = ath9k_hw_reset(ah, hchan, caldata, fastcc);
281 "Unable to reset channel (%u Mhz) reset status %d\n",
282 channel->center_freq, ret);
286 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
289 WMI_CMD(WMI_START_RECV_CMDID);
293 ath9k_host_rx_init(priv);
295 mode = ath9k_htc_get_curmode(priv, hchan);
296 htc_mode = cpu_to_be16(mode);
297 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
301 WMI_CMD(WMI_ENABLE_INTR_CMDID);
305 htc_start(priv->htc);
307 if (!(priv->op_flags & OP_SCANNING) &&
308 !(hw->conf.flags & IEEE80211_CONF_OFFCHANNEL))
309 ath9k_htc_vif_reconfig(priv);
311 mod_timer(&priv->tx.cleanup_timer,
312 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
315 ath9k_htc_ps_restore(priv);
320 * Monitor mode handling is a tad complicated because the firmware requires
321 * an interface to be created exclusively, while mac80211 doesn't associate
322 * an interface with the mode.
324 * So, for now, only one monitor interface can be configured.
326 static void __ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
328 struct ath_common *common = ath9k_hw_common(priv->ah);
329 struct ath9k_htc_target_vif hvif;
333 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
334 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
335 hvif.index = priv->mon_vif_idx;
336 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
338 ath_err(common, "Unable to remove monitor interface at idx: %d\n",
343 priv->vif_slot &= ~(1 << priv->mon_vif_idx);
346 static int ath9k_htc_add_monitor_interface(struct ath9k_htc_priv *priv)
348 struct ath_common *common = ath9k_hw_common(priv->ah);
349 struct ath9k_htc_target_vif hvif;
350 struct ath9k_htc_target_sta tsta;
351 int ret = 0, sta_idx;
354 if ((priv->nvifs >= ATH9K_HTC_MAX_VIF) ||
355 (priv->nstations >= ATH9K_HTC_MAX_STA)) {
360 sta_idx = ffz(priv->sta_slot);
361 if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA)) {
369 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
370 memcpy(&hvif.myaddr, common->macaddr, ETH_ALEN);
372 hvif.opmode = HTC_M_MONITOR;
373 hvif.index = ffz(priv->vif_slot);
375 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
380 * Assign the monitor interface index as a special case here.
381 * This is needed when the interface is brought down.
383 priv->mon_vif_idx = hvif.index;
384 priv->vif_slot |= (1 << hvif.index);
387 * Set the hardware mode to monitor only if there are no
391 priv->ah->opmode = NL80211_IFTYPE_MONITOR;
396 * Associate a station with the interface for packet injection.
398 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
400 memcpy(&tsta.macaddr, common->macaddr, ETH_ALEN);
403 tsta.sta_index = sta_idx;
404 tsta.vif_index = hvif.index;
405 tsta.maxampdu = cpu_to_be16(0xffff);
407 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
409 ath_err(common, "Unable to add station entry for monitor mode\n");
413 priv->sta_slot |= (1 << sta_idx);
415 priv->vif_sta_pos[priv->mon_vif_idx] = sta_idx;
416 priv->ah->is_monitoring = true;
418 ath_dbg(common, CONFIG,
419 "Attached a monitor interface at idx: %d, sta idx: %d\n",
420 priv->mon_vif_idx, sta_idx);
426 * Remove the interface from the target.
428 __ath9k_htc_remove_monitor_interface(priv);
430 ath_dbg(common, FATAL, "Unable to attach a monitor interface\n");
435 static int ath9k_htc_remove_monitor_interface(struct ath9k_htc_priv *priv)
437 struct ath_common *common = ath9k_hw_common(priv->ah);
441 __ath9k_htc_remove_monitor_interface(priv);
443 sta_idx = priv->vif_sta_pos[priv->mon_vif_idx];
445 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
447 ath_err(common, "Unable to remove station entry for monitor mode\n");
451 priv->sta_slot &= ~(1 << sta_idx);
453 priv->ah->is_monitoring = false;
455 ath_dbg(common, CONFIG,
456 "Removed a monitor interface at idx: %d, sta idx: %d\n",
457 priv->mon_vif_idx, sta_idx);
462 static int ath9k_htc_add_station(struct ath9k_htc_priv *priv,
463 struct ieee80211_vif *vif,
464 struct ieee80211_sta *sta)
466 struct ath_common *common = ath9k_hw_common(priv->ah);
467 struct ath9k_htc_target_sta tsta;
468 struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
469 struct ath9k_htc_sta *ista;
474 if (priv->nstations >= ATH9K_HTC_MAX_STA)
477 sta_idx = ffz(priv->sta_slot);
478 if ((sta_idx < 0) || (sta_idx > ATH9K_HTC_MAX_STA))
481 memset(&tsta, 0, sizeof(struct ath9k_htc_target_sta));
484 ista = (struct ath9k_htc_sta *) sta->drv_priv;
485 memcpy(&tsta.macaddr, sta->addr, ETH_ALEN);
486 memcpy(&tsta.bssid, common->curbssid, ETH_ALEN);
488 ista->index = sta_idx;
490 memcpy(&tsta.macaddr, vif->addr, ETH_ALEN);
494 tsta.sta_index = sta_idx;
495 tsta.vif_index = avp->index;
498 tsta.maxampdu = cpu_to_be16(0xffff);
500 maxampdu = 1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
501 sta->ht_cap.ampdu_factor);
502 tsta.maxampdu = cpu_to_be16(maxampdu);
505 WMI_CMD_BUF(WMI_NODE_CREATE_CMDID, &tsta);
509 "Unable to add station entry for: %pM\n",
515 ath_dbg(common, CONFIG,
516 "Added a station entry for: %pM (idx: %d)\n",
517 sta->addr, tsta.sta_index);
519 ath_dbg(common, CONFIG,
520 "Added a station entry for VIF %d (idx: %d)\n",
521 avp->index, tsta.sta_index);
524 priv->sta_slot |= (1 << sta_idx);
527 priv->vif_sta_pos[avp->index] = sta_idx;
532 static int ath9k_htc_remove_station(struct ath9k_htc_priv *priv,
533 struct ieee80211_vif *vif,
534 struct ieee80211_sta *sta)
536 struct ath_common *common = ath9k_hw_common(priv->ah);
537 struct ath9k_htc_vif *avp = (struct ath9k_htc_vif *) vif->drv_priv;
538 struct ath9k_htc_sta *ista;
543 ista = (struct ath9k_htc_sta *) sta->drv_priv;
544 sta_idx = ista->index;
546 sta_idx = priv->vif_sta_pos[avp->index];
549 WMI_CMD_BUF(WMI_NODE_REMOVE_CMDID, &sta_idx);
553 "Unable to remove station entry for: %pM\n",
559 ath_dbg(common, CONFIG,
560 "Removed a station entry for: %pM (idx: %d)\n",
563 ath_dbg(common, CONFIG,
564 "Removed a station entry for VIF %d (idx: %d)\n",
565 avp->index, sta_idx);
568 priv->sta_slot &= ~(1 << sta_idx);
574 int ath9k_htc_update_cap_target(struct ath9k_htc_priv *priv,
577 struct ath9k_htc_cap_target tcap;
581 memset(&tcap, 0, sizeof(struct ath9k_htc_cap_target));
583 tcap.ampdu_limit = cpu_to_be32(0xffff);
584 tcap.ampdu_subframes = 0xff;
585 tcap.enable_coex = enable_coex;
586 tcap.tx_chainmask = priv->ah->caps.tx_chainmask;
588 WMI_CMD_BUF(WMI_TARGET_IC_UPDATE_CMDID, &tcap);
593 static void ath9k_htc_setup_rate(struct ath9k_htc_priv *priv,
594 struct ieee80211_sta *sta,
595 struct ath9k_htc_target_rate *trate)
597 struct ath9k_htc_sta *ista = (struct ath9k_htc_sta *) sta->drv_priv;
598 struct ieee80211_supported_band *sband;
602 sband = priv->hw->wiphy->bands[priv->hw->conf.channel->band];
604 for (i = 0, j = 0; i < sband->n_bitrates; i++) {
605 if (sta->supp_rates[sband->band] & BIT(i)) {
606 trate->rates.legacy_rates.rs_rates[j]
607 = (sband->bitrates[i].bitrate * 2) / 10;
611 trate->rates.legacy_rates.rs_nrates = j;
613 if (sta->ht_cap.ht_supported) {
614 for (i = 0, j = 0; i < 77; i++) {
615 if (sta->ht_cap.mcs.rx_mask[i/8] & (1<<(i%8)))
616 trate->rates.ht_rates.rs_rates[j++] = i;
617 if (j == ATH_HTC_RATE_MAX)
620 trate->rates.ht_rates.rs_nrates = j;
622 caps = WLAN_RC_HT_FLAG;
623 if (sta->ht_cap.mcs.rx_mask[1])
624 caps |= WLAN_RC_DS_FLAG;
625 if ((sta->ht_cap.cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) &&
626 (conf_is_ht40(&priv->hw->conf)))
627 caps |= WLAN_RC_40_FLAG;
628 if (conf_is_ht40(&priv->hw->conf) &&
629 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40))
630 caps |= WLAN_RC_SGI_FLAG;
631 else if (conf_is_ht20(&priv->hw->conf) &&
632 (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20))
633 caps |= WLAN_RC_SGI_FLAG;
636 trate->sta_index = ista->index;
638 trate->capflags = cpu_to_be32(caps);
641 static int ath9k_htc_send_rate_cmd(struct ath9k_htc_priv *priv,
642 struct ath9k_htc_target_rate *trate)
644 struct ath_common *common = ath9k_hw_common(priv->ah);
648 WMI_CMD_BUF(WMI_RC_RATE_UPDATE_CMDID, trate);
651 "Unable to initialize Rate information on target\n");
657 static void ath9k_htc_init_rate(struct ath9k_htc_priv *priv,
658 struct ieee80211_sta *sta)
660 struct ath_common *common = ath9k_hw_common(priv->ah);
661 struct ath9k_htc_target_rate trate;
664 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
665 ath9k_htc_setup_rate(priv, sta, &trate);
666 ret = ath9k_htc_send_rate_cmd(priv, &trate);
668 ath_dbg(common, CONFIG,
669 "Updated target sta: %pM, rate caps: 0x%X\n",
670 sta->addr, be32_to_cpu(trate.capflags));
673 static void ath9k_htc_update_rate(struct ath9k_htc_priv *priv,
674 struct ieee80211_vif *vif,
675 struct ieee80211_bss_conf *bss_conf)
677 struct ath_common *common = ath9k_hw_common(priv->ah);
678 struct ath9k_htc_target_rate trate;
679 struct ieee80211_sta *sta;
682 memset(&trate, 0, sizeof(struct ath9k_htc_target_rate));
685 sta = ieee80211_find_sta(vif, bss_conf->bssid);
690 ath9k_htc_setup_rate(priv, sta, &trate);
693 ret = ath9k_htc_send_rate_cmd(priv, &trate);
695 ath_dbg(common, CONFIG,
696 "Updated target sta: %pM, rate caps: 0x%X\n",
697 bss_conf->bssid, be32_to_cpu(trate.capflags));
700 static int ath9k_htc_tx_aggr_oper(struct ath9k_htc_priv *priv,
701 struct ieee80211_vif *vif,
702 struct ieee80211_sta *sta,
703 enum ieee80211_ampdu_mlme_action action,
706 struct ath_common *common = ath9k_hw_common(priv->ah);
707 struct ath9k_htc_target_aggr aggr;
708 struct ath9k_htc_sta *ista;
712 if (tid >= ATH9K_HTC_MAX_TID)
715 memset(&aggr, 0, sizeof(struct ath9k_htc_target_aggr));
716 ista = (struct ath9k_htc_sta *) sta->drv_priv;
718 aggr.sta_index = ista->index;
719 aggr.tidno = tid & 0xf;
720 aggr.aggr_enable = (action == IEEE80211_AMPDU_TX_START) ? true : false;
722 WMI_CMD_BUF(WMI_TX_AGGR_ENABLE_CMDID, &aggr);
724 ath_dbg(common, CONFIG,
725 "Unable to %s TX aggregation for (%pM, %d)\n",
726 (aggr.aggr_enable) ? "start" : "stop", sta->addr, tid);
728 ath_dbg(common, CONFIG,
729 "%s TX aggregation for (%pM, %d)\n",
730 (aggr.aggr_enable) ? "Starting" : "Stopping",
733 spin_lock_bh(&priv->tx.tx_lock);
734 ista->tid_state[tid] = (aggr.aggr_enable && !ret) ? AGGR_START : AGGR_STOP;
735 spin_unlock_bh(&priv->tx.tx_lock);
744 void ath9k_htc_start_ani(struct ath9k_htc_priv *priv)
746 struct ath_common *common = ath9k_hw_common(priv->ah);
747 unsigned long timestamp = jiffies_to_msecs(jiffies);
749 common->ani.longcal_timer = timestamp;
750 common->ani.shortcal_timer = timestamp;
751 common->ani.checkani_timer = timestamp;
753 priv->op_flags |= OP_ANI_RUNNING;
755 ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
756 msecs_to_jiffies(ATH_ANI_POLLINTERVAL));
759 void ath9k_htc_stop_ani(struct ath9k_htc_priv *priv)
761 cancel_delayed_work_sync(&priv->ani_work);
762 priv->op_flags &= ~OP_ANI_RUNNING;
765 void ath9k_htc_ani_work(struct work_struct *work)
767 struct ath9k_htc_priv *priv =
768 container_of(work, struct ath9k_htc_priv, ani_work.work);
769 struct ath_hw *ah = priv->ah;
770 struct ath_common *common = ath9k_hw_common(ah);
771 bool longcal = false;
772 bool shortcal = false;
773 bool aniflag = false;
774 unsigned int timestamp = jiffies_to_msecs(jiffies);
775 u32 cal_interval, short_cal_interval;
777 short_cal_interval = (ah->opmode == NL80211_IFTYPE_AP) ?
778 ATH_AP_SHORT_CALINTERVAL : ATH_STA_SHORT_CALINTERVAL;
780 /* Only calibrate if awake */
781 if (ah->power_mode != ATH9K_PM_AWAKE)
784 /* Long calibration runs independently of short calibration. */
785 if ((timestamp - common->ani.longcal_timer) >= ATH_LONG_CALINTERVAL) {
787 ath_dbg(common, ANI, "longcal @%lu\n", jiffies);
788 common->ani.longcal_timer = timestamp;
791 /* Short calibration applies only while caldone is false */
792 if (!common->ani.caldone) {
793 if ((timestamp - common->ani.shortcal_timer) >=
794 short_cal_interval) {
796 ath_dbg(common, ANI, "shortcal @%lu\n", jiffies);
797 common->ani.shortcal_timer = timestamp;
798 common->ani.resetcal_timer = timestamp;
801 if ((timestamp - common->ani.resetcal_timer) >=
802 ATH_RESTART_CALINTERVAL) {
803 common->ani.caldone = ath9k_hw_reset_calvalid(ah);
804 if (common->ani.caldone)
805 common->ani.resetcal_timer = timestamp;
809 /* Verify whether we must check ANI */
810 if (ah->config.enable_ani &&
811 (timestamp - common->ani.checkani_timer) >= ATH_ANI_POLLINTERVAL) {
813 common->ani.checkani_timer = timestamp;
816 /* Skip all processing if there's nothing to do. */
817 if (longcal || shortcal || aniflag) {
819 ath9k_htc_ps_wakeup(priv);
821 /* Call ANI routine if necessary */
823 ath9k_hw_ani_monitor(ah, ah->curchan);
825 /* Perform calibration if necessary */
826 if (longcal || shortcal)
827 common->ani.caldone =
828 ath9k_hw_calibrate(ah, ah->curchan,
829 ah->rxchainmask, longcal);
831 ath9k_htc_ps_restore(priv);
836 * Set timer interval based on previous results.
837 * The interval must be the shortest necessary to satisfy ANI,
838 * short calibration and long calibration.
840 cal_interval = ATH_LONG_CALINTERVAL;
841 if (ah->config.enable_ani)
842 cal_interval = min(cal_interval, (u32)ATH_ANI_POLLINTERVAL);
843 if (!common->ani.caldone)
844 cal_interval = min(cal_interval, (u32)short_cal_interval);
846 ieee80211_queue_delayed_work(common->hw, &priv->ani_work,
847 msecs_to_jiffies(cal_interval));
850 /**********************/
851 /* mac80211 Callbacks */
852 /**********************/
854 static void ath9k_htc_tx(struct ieee80211_hw *hw, struct sk_buff *skb)
856 struct ieee80211_hdr *hdr;
857 struct ath9k_htc_priv *priv = hw->priv;
858 struct ath_common *common = ath9k_hw_common(priv->ah);
859 int padpos, padsize, ret, slot;
861 hdr = (struct ieee80211_hdr *) skb->data;
863 /* Add the padding after the header if this is not already done */
864 padpos = ath9k_cmn_padpos(hdr->frame_control);
865 padsize = padpos & 3;
866 if (padsize && skb->len > padpos) {
867 if (skb_headroom(skb) < padsize) {
868 ath_dbg(common, XMIT, "No room for padding\n");
871 skb_push(skb, padsize);
872 memmove(skb->data, skb->data + padsize, padpos);
875 slot = ath9k_htc_tx_get_slot(priv);
877 ath_dbg(common, XMIT, "No free TX slot\n");
881 ret = ath9k_htc_tx_start(priv, skb, slot, false);
883 ath_dbg(common, XMIT, "Tx failed\n");
887 ath9k_htc_check_stop_queues(priv);
892 ath9k_htc_tx_clear_slot(priv, slot);
894 dev_kfree_skb_any(skb);
897 static int ath9k_htc_start(struct ieee80211_hw *hw)
899 struct ath9k_htc_priv *priv = hw->priv;
900 struct ath_hw *ah = priv->ah;
901 struct ath_common *common = ath9k_hw_common(ah);
902 struct ieee80211_channel *curchan = hw->conf.channel;
903 struct ath9k_channel *init_channel;
905 enum htc_phymode mode;
909 mutex_lock(&priv->mutex);
911 ath_dbg(common, CONFIG,
912 "Starting driver with initial channel: %d MHz\n",
913 curchan->center_freq);
915 /* Ensure that HW is awake before flushing RX */
916 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
917 WMI_CMD(WMI_FLUSH_RECV_CMDID);
919 /* setup initial channel */
920 init_channel = ath9k_cmn_get_curchannel(hw, ah);
922 ath9k_hw_htc_resetinit(ah);
923 ret = ath9k_hw_reset(ah, init_channel, ah->caldata, false);
926 "Unable to reset hardware; reset status %d (freq %u MHz)\n",
927 ret, curchan->center_freq);
928 mutex_unlock(&priv->mutex);
932 ath9k_cmn_update_txpow(ah, priv->curtxpow, priv->txpowlimit,
935 mode = ath9k_htc_get_curmode(priv, init_channel);
936 htc_mode = cpu_to_be16(mode);
937 WMI_CMD_BUF(WMI_SET_MODE_CMDID, &htc_mode);
938 WMI_CMD(WMI_ATH_INIT_CMDID);
939 WMI_CMD(WMI_START_RECV_CMDID);
941 ath9k_host_rx_init(priv);
943 ret = ath9k_htc_update_cap_target(priv, 0);
945 ath_dbg(common, CONFIG,
946 "Failed to update capability in target\n");
948 priv->op_flags &= ~OP_INVALID;
949 htc_start(priv->htc);
951 spin_lock_bh(&priv->tx.tx_lock);
952 priv->tx.flags &= ~ATH9K_HTC_OP_TX_QUEUES_STOP;
953 spin_unlock_bh(&priv->tx.tx_lock);
955 ieee80211_wake_queues(hw);
957 mod_timer(&priv->tx.cleanup_timer,
958 jiffies + msecs_to_jiffies(ATH9K_HTC_TX_CLEANUP_INTERVAL));
960 if (ath9k_hw_get_btcoex_scheme(ah) == ATH_BTCOEX_CFG_3WIRE) {
961 ath9k_hw_btcoex_set_weight(ah, AR_BT_COEX_WGHT,
962 AR_STOMP_LOW_WLAN_WGHT);
963 ath9k_hw_btcoex_enable(ah);
964 ath_htc_resume_btcoex_work(priv);
966 mutex_unlock(&priv->mutex);
971 static void ath9k_htc_stop(struct ieee80211_hw *hw)
973 struct ath9k_htc_priv *priv = hw->priv;
974 struct ath_hw *ah = priv->ah;
975 struct ath_common *common = ath9k_hw_common(ah);
976 int ret __attribute__ ((unused));
979 mutex_lock(&priv->mutex);
981 if (priv->op_flags & OP_INVALID) {
982 ath_dbg(common, ANY, "Device not present\n");
983 mutex_unlock(&priv->mutex);
987 ath9k_htc_ps_wakeup(priv);
989 WMI_CMD(WMI_DISABLE_INTR_CMDID);
990 WMI_CMD(WMI_DRAIN_TXQ_ALL_CMDID);
991 WMI_CMD(WMI_STOP_RECV_CMDID);
993 tasklet_kill(&priv->rx_tasklet);
995 del_timer_sync(&priv->tx.cleanup_timer);
996 ath9k_htc_tx_drain(priv);
997 ath9k_wmi_event_drain(priv);
999 mutex_unlock(&priv->mutex);
1001 /* Cancel all the running timers/work .. */
1002 cancel_work_sync(&priv->fatal_work);
1003 cancel_work_sync(&priv->ps_work);
1005 #ifdef CONFIG_MAC80211_LEDS
1006 cancel_work_sync(&priv->led_work);
1008 ath9k_htc_stop_ani(priv);
1010 mutex_lock(&priv->mutex);
1012 if (ah->btcoex_hw.enabled &&
1013 ath9k_hw_get_btcoex_scheme(ah) != ATH_BTCOEX_CFG_NONE) {
1014 ath9k_hw_btcoex_disable(ah);
1015 if (ah->btcoex_hw.scheme == ATH_BTCOEX_CFG_3WIRE)
1016 ath_htc_cancel_btcoex_work(priv);
1019 /* Remove a monitor interface if it's present. */
1020 if (priv->ah->is_monitoring)
1021 ath9k_htc_remove_monitor_interface(priv);
1023 ath9k_hw_phy_disable(ah);
1024 ath9k_hw_disable(ah);
1025 ath9k_htc_ps_restore(priv);
1026 ath9k_htc_setpower(priv, ATH9K_PM_FULL_SLEEP);
1028 priv->op_flags |= OP_INVALID;
1030 ath_dbg(common, CONFIG, "Driver halt\n");
1031 mutex_unlock(&priv->mutex);
1034 static int ath9k_htc_add_interface(struct ieee80211_hw *hw,
1035 struct ieee80211_vif *vif)
1037 struct ath9k_htc_priv *priv = hw->priv;
1038 struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1039 struct ath_common *common = ath9k_hw_common(priv->ah);
1040 struct ath9k_htc_target_vif hvif;
1044 mutex_lock(&priv->mutex);
1046 if (priv->nvifs >= ATH9K_HTC_MAX_VIF) {
1047 mutex_unlock(&priv->mutex);
1051 if (priv->num_ibss_vif ||
1052 (priv->nvifs && vif->type == NL80211_IFTYPE_ADHOC)) {
1053 ath_err(common, "IBSS coexistence with other modes is not allowed\n");
1054 mutex_unlock(&priv->mutex);
1058 if (((vif->type == NL80211_IFTYPE_AP) ||
1059 (vif->type == NL80211_IFTYPE_ADHOC)) &&
1060 ((priv->num_ap_vif + priv->num_ibss_vif) >= ATH9K_HTC_MAX_BCN_VIF)) {
1061 ath_err(common, "Max. number of beaconing interfaces reached\n");
1062 mutex_unlock(&priv->mutex);
1066 ath9k_htc_ps_wakeup(priv);
1067 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1068 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1070 switch (vif->type) {
1071 case NL80211_IFTYPE_STATION:
1072 hvif.opmode = HTC_M_STA;
1074 case NL80211_IFTYPE_ADHOC:
1075 hvif.opmode = HTC_M_IBSS;
1077 case NL80211_IFTYPE_AP:
1078 hvif.opmode = HTC_M_HOSTAP;
1082 "Interface type %d not yet supported\n", vif->type);
1087 /* Index starts from zero on the target */
1088 avp->index = hvif.index = ffz(priv->vif_slot);
1089 hvif.rtsthreshold = cpu_to_be16(2304);
1090 WMI_CMD_BUF(WMI_VAP_CREATE_CMDID, &hvif);
1095 * We need a node in target to tx mgmt frames
1096 * before association.
1098 ret = ath9k_htc_add_station(priv, vif, NULL);
1100 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1104 ath9k_htc_set_bssid_mask(priv, vif);
1106 priv->vif_slot |= (1 << avp->index);
1109 INC_VIF(priv, vif->type);
1111 if ((vif->type == NL80211_IFTYPE_AP) ||
1112 (vif->type == NL80211_IFTYPE_ADHOC))
1113 ath9k_htc_assign_bslot(priv, vif);
1115 ath9k_htc_set_opmode(priv);
1117 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1118 !(priv->op_flags & OP_ANI_RUNNING)) {
1119 ath9k_hw_set_tsfadjust(priv->ah, 1);
1120 ath9k_htc_start_ani(priv);
1123 ath_dbg(common, CONFIG, "Attach a VIF of type: %d at idx: %d\n",
1124 vif->type, avp->index);
1127 ath9k_htc_ps_restore(priv);
1128 mutex_unlock(&priv->mutex);
1133 static void ath9k_htc_remove_interface(struct ieee80211_hw *hw,
1134 struct ieee80211_vif *vif)
1136 struct ath9k_htc_priv *priv = hw->priv;
1137 struct ath_common *common = ath9k_hw_common(priv->ah);
1138 struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1139 struct ath9k_htc_target_vif hvif;
1143 mutex_lock(&priv->mutex);
1144 ath9k_htc_ps_wakeup(priv);
1146 memset(&hvif, 0, sizeof(struct ath9k_htc_target_vif));
1147 memcpy(&hvif.myaddr, vif->addr, ETH_ALEN);
1148 hvif.index = avp->index;
1149 WMI_CMD_BUF(WMI_VAP_REMOVE_CMDID, &hvif);
1151 ath_err(common, "Unable to remove interface at idx: %d\n",
1155 priv->vif_slot &= ~(1 << avp->index);
1157 ath9k_htc_remove_station(priv, vif, NULL);
1159 DEC_VIF(priv, vif->type);
1161 if ((vif->type == NL80211_IFTYPE_AP) ||
1162 (vif->type == NL80211_IFTYPE_ADHOC))
1163 ath9k_htc_remove_bslot(priv, vif);
1165 ath9k_htc_set_opmode(priv);
1167 ath9k_htc_set_bssid_mask(priv, vif);
1170 * Stop ANI only if there are no associated station interfaces.
1172 if ((vif->type == NL80211_IFTYPE_AP) && (priv->num_ap_vif == 0)) {
1173 priv->rearm_ani = false;
1174 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1175 ath9k_htc_vif_iter, priv);
1176 if (!priv->rearm_ani)
1177 ath9k_htc_stop_ani(priv);
1180 ath_dbg(common, CONFIG, "Detach Interface at idx: %d\n", avp->index);
1182 ath9k_htc_ps_restore(priv);
1183 mutex_unlock(&priv->mutex);
1186 static int ath9k_htc_config(struct ieee80211_hw *hw, u32 changed)
1188 struct ath9k_htc_priv *priv = hw->priv;
1189 struct ath_common *common = ath9k_hw_common(priv->ah);
1190 struct ieee80211_conf *conf = &hw->conf;
1192 mutex_lock(&priv->mutex);
1194 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1195 bool enable_radio = false;
1196 bool idle = !!(conf->flags & IEEE80211_CONF_IDLE);
1198 mutex_lock(&priv->htc_pm_lock);
1199 if (!idle && priv->ps_idle)
1200 enable_radio = true;
1201 priv->ps_idle = idle;
1202 mutex_unlock(&priv->htc_pm_lock);
1205 ath_dbg(common, CONFIG, "not-idle: enabling radio\n");
1206 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1207 ath9k_htc_radio_enable(hw);
1212 * Monitor interface should be added before
1213 * IEEE80211_CONF_CHANGE_CHANNEL is handled.
1215 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1216 if ((conf->flags & IEEE80211_CONF_MONITOR) &&
1217 !priv->ah->is_monitoring)
1218 ath9k_htc_add_monitor_interface(priv);
1219 else if (priv->ah->is_monitoring)
1220 ath9k_htc_remove_monitor_interface(priv);
1223 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1224 struct ieee80211_channel *curchan = hw->conf.channel;
1225 int pos = curchan->hw_value;
1227 ath_dbg(common, CONFIG, "Set channel: %d MHz\n",
1228 curchan->center_freq);
1230 ath9k_cmn_update_ichannel(&priv->ah->channels[pos],
1232 hw->conf.channel_type);
1234 if (ath9k_htc_set_channel(priv, hw, &priv->ah->channels[pos]) < 0) {
1235 ath_err(common, "Unable to set channel\n");
1236 mutex_unlock(&priv->mutex);
1242 if (changed & IEEE80211_CONF_CHANGE_PS) {
1243 if (conf->flags & IEEE80211_CONF_PS) {
1244 ath9k_htc_setpower(priv, ATH9K_PM_NETWORK_SLEEP);
1245 priv->ps_enabled = true;
1247 priv->ps_enabled = false;
1248 cancel_work_sync(&priv->ps_work);
1249 ath9k_htc_setpower(priv, ATH9K_PM_AWAKE);
1253 if (changed & IEEE80211_CONF_CHANGE_POWER) {
1254 priv->txpowlimit = 2 * conf->power_level;
1255 ath9k_cmn_update_txpow(priv->ah, priv->curtxpow,
1256 priv->txpowlimit, &priv->curtxpow);
1259 if (changed & IEEE80211_CONF_CHANGE_IDLE) {
1260 mutex_lock(&priv->htc_pm_lock);
1261 if (!priv->ps_idle) {
1262 mutex_unlock(&priv->htc_pm_lock);
1265 mutex_unlock(&priv->htc_pm_lock);
1267 ath_dbg(common, CONFIG, "idle: disabling radio\n");
1268 ath9k_htc_radio_disable(hw);
1272 mutex_unlock(&priv->mutex);
1276 #define SUPPORTED_FILTERS \
1277 (FIF_PROMISC_IN_BSS | \
1282 FIF_BCN_PRBRESP_PROMISC | \
1286 static void ath9k_htc_configure_filter(struct ieee80211_hw *hw,
1287 unsigned int changed_flags,
1288 unsigned int *total_flags,
1291 struct ath9k_htc_priv *priv = hw->priv;
1294 mutex_lock(&priv->mutex);
1295 changed_flags &= SUPPORTED_FILTERS;
1296 *total_flags &= SUPPORTED_FILTERS;
1298 if (priv->op_flags & OP_INVALID) {
1299 ath_dbg(ath9k_hw_common(priv->ah), ANY,
1300 "Unable to configure filter on invalid state\n");
1301 mutex_unlock(&priv->mutex);
1304 ath9k_htc_ps_wakeup(priv);
1306 priv->rxfilter = *total_flags;
1307 rfilt = ath9k_htc_calcrxfilter(priv);
1308 ath9k_hw_setrxfilter(priv->ah, rfilt);
1310 ath_dbg(ath9k_hw_common(priv->ah), CONFIG, "Set HW RX filter: 0x%x\n",
1313 ath9k_htc_ps_restore(priv);
1314 mutex_unlock(&priv->mutex);
1317 static int ath9k_htc_sta_add(struct ieee80211_hw *hw,
1318 struct ieee80211_vif *vif,
1319 struct ieee80211_sta *sta)
1321 struct ath9k_htc_priv *priv = hw->priv;
1324 mutex_lock(&priv->mutex);
1325 ath9k_htc_ps_wakeup(priv);
1326 ret = ath9k_htc_add_station(priv, vif, sta);
1328 ath9k_htc_init_rate(priv, sta);
1329 ath9k_htc_ps_restore(priv);
1330 mutex_unlock(&priv->mutex);
1335 static int ath9k_htc_sta_remove(struct ieee80211_hw *hw,
1336 struct ieee80211_vif *vif,
1337 struct ieee80211_sta *sta)
1339 struct ath9k_htc_priv *priv = hw->priv;
1340 struct ath9k_htc_sta *ista;
1343 mutex_lock(&priv->mutex);
1344 ath9k_htc_ps_wakeup(priv);
1345 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1346 htc_sta_drain(priv->htc, ista->index);
1347 ret = ath9k_htc_remove_station(priv, vif, sta);
1348 ath9k_htc_ps_restore(priv);
1349 mutex_unlock(&priv->mutex);
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)
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;
1363 if (queue >= WME_NUM_AC)
1366 mutex_lock(&priv->mutex);
1367 ath9k_htc_ps_wakeup(priv);
1369 memset(&qi, 0, sizeof(struct ath9k_tx_queue_info));
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;
1376 qnum = get_hw_qnum(queue, priv->hwq_map);
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);
1383 ret = ath_htc_txq_update(priv, qnum, &qi);
1385 ath_err(common, "TXQ Update failed\n");
1389 if ((priv->ah->opmode == NL80211_IFTYPE_ADHOC) &&
1390 (qnum == priv->hwq_map[WME_AC_BE]))
1391 ath9k_htc_beaconq_config(priv);
1393 ath9k_htc_ps_restore(priv);
1394 mutex_unlock(&priv->mutex);
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)
1405 struct ath9k_htc_priv *priv = hw->priv;
1406 struct ath_common *common = ath9k_hw_common(priv->ah);
1409 if (htc_modparam_nohwcrypt)
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)) {
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.
1427 mutex_lock(&priv->mutex);
1428 ath_dbg(common, CONFIG, "Set HW Key\n");
1429 ath9k_htc_ps_wakeup(priv);
1433 ret = ath_key_config(common, vif, sta, key);
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;
1447 ath_key_delete(common, key);
1453 ath9k_htc_ps_restore(priv);
1454 mutex_unlock(&priv->mutex);
1459 static void ath9k_htc_set_bssid(struct ath9k_htc_priv *priv)
1461 struct ath_common *common = ath9k_hw_common(priv->ah);
1463 ath9k_hw_write_associd(priv->ah);
1464 ath_dbg(common, CONFIG, "BSSID: %pM aid: 0x%x\n",
1465 common->curbssid, common->curaid);
1468 static void ath9k_htc_bss_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
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;
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);
1480 static void ath9k_htc_choose_set_bssid(struct ath9k_htc_priv *priv)
1482 if (priv->num_sta_assoc_vif == 1) {
1483 ieee80211_iterate_active_interfaces_atomic(priv->hw,
1484 ath9k_htc_bss_iter, priv);
1485 ath9k_htc_set_bssid(priv);
1489 static void ath9k_htc_bss_info_changed(struct ieee80211_hw *hw,
1490 struct ieee80211_vif *vif,
1491 struct ieee80211_bss_conf *bss_conf,
1494 struct ath9k_htc_priv *priv = hw->priv;
1495 struct ath_hw *ah = priv->ah;
1496 struct ath_common *common = ath9k_hw_common(ah);
1498 mutex_lock(&priv->mutex);
1499 ath9k_htc_ps_wakeup(priv);
1501 if (changed & BSS_CHANGED_ASSOC) {
1502 ath_dbg(common, CONFIG, "BSS Changed ASSOC %d\n",
1506 priv->num_sta_assoc_vif++ : priv->num_sta_assoc_vif--;
1508 if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1509 if (bss_conf->assoc && (priv->num_sta_assoc_vif == 1))
1510 ath9k_htc_start_ani(priv);
1511 else if (priv->num_sta_assoc_vif == 0)
1512 ath9k_htc_stop_ani(priv);
1516 if (changed & BSS_CHANGED_BSSID) {
1517 if (priv->ah->opmode == NL80211_IFTYPE_ADHOC) {
1518 common->curaid = bss_conf->aid;
1519 memcpy(common->curbssid, bss_conf->bssid, ETH_ALEN);
1520 ath9k_htc_set_bssid(priv);
1521 } else if (priv->ah->opmode == NL80211_IFTYPE_STATION) {
1522 ath9k_htc_choose_set_bssid(priv);
1526 if ((changed & BSS_CHANGED_BEACON_ENABLED) && bss_conf->enable_beacon) {
1527 ath_dbg(common, CONFIG, "Beacon enabled for BSS: %pM\n",
1529 ath9k_htc_set_tsfadjust(priv, vif);
1530 priv->op_flags |= OP_ENABLE_BEACON;
1531 ath9k_htc_beacon_config(priv, vif);
1534 if ((changed & BSS_CHANGED_BEACON_ENABLED) && !bss_conf->enable_beacon) {
1536 * Disable SWBA interrupt only if there are no
1537 * AP/IBSS interfaces.
1539 if ((priv->num_ap_vif <= 1) || priv->num_ibss_vif) {
1540 ath_dbg(common, CONFIG,
1541 "Beacon disabled for BSS: %pM\n",
1543 priv->op_flags &= ~OP_ENABLE_BEACON;
1544 ath9k_htc_beacon_config(priv, vif);
1548 if (changed & BSS_CHANGED_BEACON_INT) {
1550 * Reset the HW TSF for the first AP interface.
1552 if ((priv->ah->opmode == NL80211_IFTYPE_AP) &&
1553 (priv->nvifs == 1) &&
1554 (priv->num_ap_vif == 1) &&
1555 (vif->type == NL80211_IFTYPE_AP)) {
1556 priv->op_flags |= OP_TSF_RESET;
1558 ath_dbg(common, CONFIG,
1559 "Beacon interval changed for BSS: %pM\n",
1561 ath9k_htc_beacon_config(priv, vif);
1564 if (changed & BSS_CHANGED_ERP_SLOT) {
1565 if (bss_conf->use_short_slot)
1570 ath9k_hw_init_global_settings(ah);
1573 if (changed & BSS_CHANGED_HT)
1574 ath9k_htc_update_rate(priv, vif, bss_conf);
1576 ath9k_htc_ps_restore(priv);
1577 mutex_unlock(&priv->mutex);
1580 static u64 ath9k_htc_get_tsf(struct ieee80211_hw *hw,
1581 struct ieee80211_vif *vif)
1583 struct ath9k_htc_priv *priv = hw->priv;
1586 mutex_lock(&priv->mutex);
1587 ath9k_htc_ps_wakeup(priv);
1588 tsf = ath9k_hw_gettsf64(priv->ah);
1589 ath9k_htc_ps_restore(priv);
1590 mutex_unlock(&priv->mutex);
1595 static void ath9k_htc_set_tsf(struct ieee80211_hw *hw,
1596 struct ieee80211_vif *vif, u64 tsf)
1598 struct ath9k_htc_priv *priv = hw->priv;
1600 mutex_lock(&priv->mutex);
1601 ath9k_htc_ps_wakeup(priv);
1602 ath9k_hw_settsf64(priv->ah, tsf);
1603 ath9k_htc_ps_restore(priv);
1604 mutex_unlock(&priv->mutex);
1607 static void ath9k_htc_reset_tsf(struct ieee80211_hw *hw,
1608 struct ieee80211_vif *vif)
1610 struct ath9k_htc_priv *priv = hw->priv;
1612 mutex_lock(&priv->mutex);
1613 ath9k_htc_ps_wakeup(priv);
1614 ath9k_hw_reset_tsf(priv->ah);
1615 ath9k_htc_ps_restore(priv);
1616 mutex_unlock(&priv->mutex);
1619 static int ath9k_htc_ampdu_action(struct ieee80211_hw *hw,
1620 struct ieee80211_vif *vif,
1621 enum ieee80211_ampdu_mlme_action action,
1622 struct ieee80211_sta *sta,
1623 u16 tid, u16 *ssn, u8 buf_size)
1625 struct ath9k_htc_priv *priv = hw->priv;
1626 struct ath9k_htc_sta *ista;
1629 mutex_lock(&priv->mutex);
1630 ath9k_htc_ps_wakeup(priv);
1633 case IEEE80211_AMPDU_RX_START:
1635 case IEEE80211_AMPDU_RX_STOP:
1637 case IEEE80211_AMPDU_TX_START:
1638 ret = ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1640 ieee80211_start_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1642 case IEEE80211_AMPDU_TX_STOP:
1643 ath9k_htc_tx_aggr_oper(priv, vif, sta, action, tid);
1644 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1646 case IEEE80211_AMPDU_TX_OPERATIONAL:
1647 ista = (struct ath9k_htc_sta *) sta->drv_priv;
1648 spin_lock_bh(&priv->tx.tx_lock);
1649 ista->tid_state[tid] = AGGR_OPERATIONAL;
1650 spin_unlock_bh(&priv->tx.tx_lock);
1653 ath_err(ath9k_hw_common(priv->ah), "Unknown AMPDU action\n");
1656 ath9k_htc_ps_restore(priv);
1657 mutex_unlock(&priv->mutex);
1662 static void ath9k_htc_sw_scan_start(struct ieee80211_hw *hw)
1664 struct ath9k_htc_priv *priv = hw->priv;
1666 mutex_lock(&priv->mutex);
1667 spin_lock_bh(&priv->beacon_lock);
1668 priv->op_flags |= OP_SCANNING;
1669 spin_unlock_bh(&priv->beacon_lock);
1670 cancel_work_sync(&priv->ps_work);
1671 ath9k_htc_stop_ani(priv);
1672 mutex_unlock(&priv->mutex);
1675 static void ath9k_htc_sw_scan_complete(struct ieee80211_hw *hw)
1677 struct ath9k_htc_priv *priv = hw->priv;
1679 mutex_lock(&priv->mutex);
1680 spin_lock_bh(&priv->beacon_lock);
1681 priv->op_flags &= ~OP_SCANNING;
1682 spin_unlock_bh(&priv->beacon_lock);
1683 ath9k_htc_ps_wakeup(priv);
1684 ath9k_htc_vif_reconfig(priv);
1685 ath9k_htc_ps_restore(priv);
1686 mutex_unlock(&priv->mutex);
1689 static int ath9k_htc_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
1694 static void ath9k_htc_set_coverage_class(struct ieee80211_hw *hw,
1697 struct ath9k_htc_priv *priv = hw->priv;
1699 mutex_lock(&priv->mutex);
1700 ath9k_htc_ps_wakeup(priv);
1701 priv->ah->coverage_class = coverage_class;
1702 ath9k_hw_init_global_settings(priv->ah);
1703 ath9k_htc_ps_restore(priv);
1704 mutex_unlock(&priv->mutex);
1708 * Currently, this is used only for selecting the minimum rate
1709 * for management frames, rate selection for data frames remain
1712 static int ath9k_htc_set_bitrate_mask(struct ieee80211_hw *hw,
1713 struct ieee80211_vif *vif,
1714 const struct cfg80211_bitrate_mask *mask)
1716 struct ath9k_htc_priv *priv = hw->priv;
1717 struct ath_common *common = ath9k_hw_common(priv->ah);
1718 struct ath9k_htc_target_rate_mask tmask;
1719 struct ath9k_htc_vif *avp = (void *)vif->drv_priv;
1723 memset(&tmask, 0, sizeof(struct ath9k_htc_target_rate_mask));
1725 tmask.vif_index = avp->index;
1726 tmask.band = IEEE80211_BAND_2GHZ;
1727 tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_2GHZ].legacy);
1729 WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1732 "Unable to set 2G rate mask for "
1733 "interface at idx: %d\n", avp->index);
1737 tmask.band = IEEE80211_BAND_5GHZ;
1738 tmask.mask = cpu_to_be32(mask->control[IEEE80211_BAND_5GHZ].legacy);
1740 WMI_CMD_BUF(WMI_BITRATE_MASK_CMDID, &tmask);
1743 "Unable to set 5G rate mask for "
1744 "interface at idx: %d\n", avp->index);
1748 ath_dbg(common, CONFIG, "Set bitrate masks: 0x%x, 0x%x\n",
1749 mask->control[IEEE80211_BAND_2GHZ].legacy,
1750 mask->control[IEEE80211_BAND_5GHZ].legacy);
1756 static int ath9k_htc_get_stats(struct ieee80211_hw *hw,
1757 struct ieee80211_low_level_stats *stats)
1759 struct ath9k_htc_priv *priv = hw->priv;
1760 struct ath_hw *ah = priv->ah;
1761 struct ath9k_mib_stats *mib_stats = &ah->ah_mibStats;
1763 stats->dot11ACKFailureCount = mib_stats->ackrcv_bad;
1764 stats->dot11RTSFailureCount = mib_stats->rts_bad;
1765 stats->dot11FCSErrorCount = mib_stats->fcs_bad;
1766 stats->dot11RTSSuccessCount = mib_stats->rts_good;
1771 struct ieee80211_ops ath9k_htc_ops = {
1773 .start = ath9k_htc_start,
1774 .stop = ath9k_htc_stop,
1775 .add_interface = ath9k_htc_add_interface,
1776 .remove_interface = ath9k_htc_remove_interface,
1777 .config = ath9k_htc_config,
1778 .configure_filter = ath9k_htc_configure_filter,
1779 .sta_add = ath9k_htc_sta_add,
1780 .sta_remove = ath9k_htc_sta_remove,
1781 .conf_tx = ath9k_htc_conf_tx,
1782 .bss_info_changed = ath9k_htc_bss_info_changed,
1783 .set_key = ath9k_htc_set_key,
1784 .get_tsf = ath9k_htc_get_tsf,
1785 .set_tsf = ath9k_htc_set_tsf,
1786 .reset_tsf = ath9k_htc_reset_tsf,
1787 .ampdu_action = ath9k_htc_ampdu_action,
1788 .sw_scan_start = ath9k_htc_sw_scan_start,
1789 .sw_scan_complete = ath9k_htc_sw_scan_complete,
1790 .set_rts_threshold = ath9k_htc_set_rts_threshold,
1791 .rfkill_poll = ath9k_htc_rfkill_poll_state,
1792 .set_coverage_class = ath9k_htc_set_coverage_class,
1793 .set_bitrate_mask = ath9k_htc_set_bitrate_mask,
1794 .get_stats = ath9k_htc_get_stats,