2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
34 static int ath10k_send_key(struct ath10k_vif *arvif,
35 struct ieee80211_key_conf *key,
39 struct wmi_vdev_install_key_arg arg = {
40 .vdev_id = arvif->vdev_id,
41 .key_idx = key->keyidx,
42 .key_len = key->keylen,
47 lockdep_assert_held(&arvif->ar->conf_mutex);
49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50 arg.key_flags = WMI_KEY_PAIRWISE;
52 arg.key_flags = WMI_KEY_GROUP;
54 switch (key->cipher) {
55 case WLAN_CIPHER_SUITE_CCMP:
56 arg.key_cipher = WMI_CIPHER_AES_CCM;
57 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
58 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
60 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
62 case WLAN_CIPHER_SUITE_TKIP:
63 arg.key_cipher = WMI_CIPHER_TKIP;
64 arg.key_txmic_len = 8;
65 arg.key_rxmic_len = 8;
67 case WLAN_CIPHER_SUITE_WEP40:
68 case WLAN_CIPHER_SUITE_WEP104:
69 arg.key_cipher = WMI_CIPHER_WEP;
70 /* AP/IBSS mode requires self-key to be groupwise
71 * Otherwise pairwise key must be set */
72 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
73 arg.key_flags = WMI_KEY_PAIRWISE;
76 ath10k_warn("cipher %d is not supported\n", key->cipher);
80 if (cmd == DISABLE_KEY) {
81 arg.key_cipher = WMI_CIPHER_NONE;
85 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
88 static int ath10k_install_key(struct ath10k_vif *arvif,
89 struct ieee80211_key_conf *key,
93 struct ath10k *ar = arvif->ar;
96 lockdep_assert_held(&ar->conf_mutex);
98 reinit_completion(&ar->install_key_done);
100 ret = ath10k_send_key(arvif, key, cmd, macaddr);
104 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
111 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
114 struct ath10k *ar = arvif->ar;
115 struct ath10k_peer *peer;
119 lockdep_assert_held(&ar->conf_mutex);
121 spin_lock_bh(&ar->data_lock);
122 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
123 spin_unlock_bh(&ar->data_lock);
128 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
129 if (arvif->wep_keys[i] == NULL)
132 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
137 peer->keys[i] = arvif->wep_keys[i];
143 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
146 struct ath10k *ar = arvif->ar;
147 struct ath10k_peer *peer;
152 lockdep_assert_held(&ar->conf_mutex);
154 spin_lock_bh(&ar->data_lock);
155 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
156 spin_unlock_bh(&ar->data_lock);
161 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
162 if (peer->keys[i] == NULL)
165 ret = ath10k_install_key(arvif, peer->keys[i],
167 if (ret && first_errno == 0)
171 ath10k_warn("failed to remove peer wep key %d: %d\n",
174 peer->keys[i] = NULL;
180 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
181 struct ieee80211_key_conf *key)
183 struct ath10k *ar = arvif->ar;
184 struct ath10k_peer *peer;
190 lockdep_assert_held(&ar->conf_mutex);
193 /* since ath10k_install_key we can't hold data_lock all the
194 * time, so we try to remove the keys incrementally */
195 spin_lock_bh(&ar->data_lock);
197 list_for_each_entry(peer, &ar->peers, list) {
198 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
199 if (peer->keys[i] == key) {
200 memcpy(addr, peer->addr, ETH_ALEN);
201 peer->keys[i] = NULL;
206 if (i < ARRAY_SIZE(peer->keys))
209 spin_unlock_bh(&ar->data_lock);
211 if (i == ARRAY_SIZE(peer->keys))
214 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
215 if (ret && first_errno == 0)
219 ath10k_warn("failed to remove key for %pM: %d\n",
227 /*********************/
228 /* General utilities */
229 /*********************/
231 static inline enum wmi_phy_mode
232 chan_to_phymode(const struct cfg80211_chan_def *chandef)
234 enum wmi_phy_mode phymode = MODE_UNKNOWN;
236 switch (chandef->chan->band) {
237 case IEEE80211_BAND_2GHZ:
238 switch (chandef->width) {
239 case NL80211_CHAN_WIDTH_20_NOHT:
242 case NL80211_CHAN_WIDTH_20:
243 phymode = MODE_11NG_HT20;
245 case NL80211_CHAN_WIDTH_40:
246 phymode = MODE_11NG_HT40;
248 case NL80211_CHAN_WIDTH_5:
249 case NL80211_CHAN_WIDTH_10:
250 case NL80211_CHAN_WIDTH_80:
251 case NL80211_CHAN_WIDTH_80P80:
252 case NL80211_CHAN_WIDTH_160:
253 phymode = MODE_UNKNOWN;
257 case IEEE80211_BAND_5GHZ:
258 switch (chandef->width) {
259 case NL80211_CHAN_WIDTH_20_NOHT:
262 case NL80211_CHAN_WIDTH_20:
263 phymode = MODE_11NA_HT20;
265 case NL80211_CHAN_WIDTH_40:
266 phymode = MODE_11NA_HT40;
268 case NL80211_CHAN_WIDTH_80:
269 phymode = MODE_11AC_VHT80;
271 case NL80211_CHAN_WIDTH_5:
272 case NL80211_CHAN_WIDTH_10:
273 case NL80211_CHAN_WIDTH_80P80:
274 case NL80211_CHAN_WIDTH_160:
275 phymode = MODE_UNKNOWN;
283 WARN_ON(phymode == MODE_UNKNOWN);
287 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
290 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
291 * 0 for no restriction
300 switch (mpdudensity) {
306 /* Our lower layer calculations limit our precision to
322 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
326 lockdep_assert_held(&ar->conf_mutex);
328 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
330 ath10k_warn("failed to create wmi peer %pM on vdev %i: %i\n",
335 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
337 ath10k_warn("failed to wait for created wmi peer %pM on vdev %i: %i\n",
341 spin_lock_bh(&ar->data_lock);
343 spin_unlock_bh(&ar->data_lock);
348 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
350 struct ath10k *ar = arvif->ar;
354 param = ar->wmi.pdev_param->sta_kickout_th;
355 ret = ath10k_wmi_pdev_set_param(ar, param,
356 ATH10K_KICKOUT_THRESHOLD);
358 ath10k_warn("failed to set kickout threshold on vdev %i: %d\n",
359 arvif->vdev_id, ret);
363 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
364 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
365 ATH10K_KEEPALIVE_MIN_IDLE);
367 ath10k_warn("failed to set keepalive minimum idle time on vdev %i: %d\n",
368 arvif->vdev_id, ret);
372 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
373 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
374 ATH10K_KEEPALIVE_MAX_IDLE);
376 ath10k_warn("failed to set keepalive maximum idle time on vdev %i: %d\n",
377 arvif->vdev_id, ret);
381 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
382 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
383 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
385 ath10k_warn("failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
386 arvif->vdev_id, ret);
393 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
395 struct ath10k *ar = arvif->ar;
398 if (value != 0xFFFFFFFF)
399 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
402 vdev_param = ar->wmi.vdev_param->rts_threshold;
403 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
406 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
408 struct ath10k *ar = arvif->ar;
411 if (value != 0xFFFFFFFF)
412 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
413 ATH10K_FRAGMT_THRESHOLD_MIN,
414 ATH10K_FRAGMT_THRESHOLD_MAX);
416 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
417 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
420 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
424 lockdep_assert_held(&ar->conf_mutex);
426 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
430 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
434 spin_lock_bh(&ar->data_lock);
436 spin_unlock_bh(&ar->data_lock);
441 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
443 struct ath10k_peer *peer, *tmp;
445 lockdep_assert_held(&ar->conf_mutex);
447 spin_lock_bh(&ar->data_lock);
448 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
449 if (peer->vdev_id != vdev_id)
452 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
453 peer->addr, vdev_id);
455 list_del(&peer->list);
459 spin_unlock_bh(&ar->data_lock);
462 static void ath10k_peer_cleanup_all(struct ath10k *ar)
464 struct ath10k_peer *peer, *tmp;
466 lockdep_assert_held(&ar->conf_mutex);
468 spin_lock_bh(&ar->data_lock);
469 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
470 list_del(&peer->list);
474 spin_unlock_bh(&ar->data_lock);
477 /************************/
478 /* Interface management */
479 /************************/
481 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
485 lockdep_assert_held(&ar->conf_mutex);
487 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
488 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
495 static bool ath10k_monitor_is_enabled(struct ath10k *ar)
497 lockdep_assert_held(&ar->conf_mutex);
499 ath10k_dbg(ATH10K_DBG_MAC,
500 "mac monitor refs: promisc %d monitor %d cac %d\n",
501 ar->promisc, ar->monitor,
502 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags));
504 return ar->promisc || ar->monitor ||
505 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
508 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
510 struct cfg80211_chan_def *chandef = &ar->chandef;
511 struct ieee80211_channel *channel = chandef->chan;
512 struct wmi_vdev_start_request_arg arg = {};
515 lockdep_assert_held(&ar->conf_mutex);
517 arg.vdev_id = vdev_id;
518 arg.channel.freq = channel->center_freq;
519 arg.channel.band_center_freq1 = chandef->center_freq1;
521 /* TODO setup this dynamically, what in case we
522 don't have any vifs? */
523 arg.channel.mode = chan_to_phymode(chandef);
524 arg.channel.chan_radar =
525 !!(channel->flags & IEEE80211_CHAN_RADAR);
527 arg.channel.min_power = 0;
528 arg.channel.max_power = channel->max_power * 2;
529 arg.channel.max_reg_power = channel->max_reg_power * 2;
530 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
532 ret = ath10k_wmi_vdev_start(ar, &arg);
534 ath10k_warn("failed to request monitor vdev %i start: %d\n",
539 ret = ath10k_vdev_setup_sync(ar);
541 ath10k_warn("failed to synchronize setup for monitor vdev %i: %d\n",
546 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
548 ath10k_warn("failed to put up monitor vdev %i: %d\n",
553 ar->monitor_vdev_id = vdev_id;
555 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
556 ar->monitor_vdev_id);
560 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
562 ath10k_warn("failed to stop monitor vdev %i after start failure: %d\n",
563 ar->monitor_vdev_id, ret);
568 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
572 lockdep_assert_held(&ar->conf_mutex);
574 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
576 ath10k_warn("failed to put down monitor vdev %i: %d\n",
577 ar->monitor_vdev_id, ret);
579 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
581 ath10k_warn("failed to to request monitor vdev %i stop: %d\n",
582 ar->monitor_vdev_id, ret);
584 ret = ath10k_vdev_setup_sync(ar);
586 ath10k_warn("failed to synchronise monitor vdev %i: %d\n",
587 ar->monitor_vdev_id, ret);
589 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
590 ar->monitor_vdev_id);
594 static int ath10k_monitor_vdev_create(struct ath10k *ar)
598 lockdep_assert_held(&ar->conf_mutex);
600 bit = ffs(ar->free_vdev_map);
602 ath10k_warn("failed to find free vdev id for monitor vdev\n");
606 ar->monitor_vdev_id = bit - 1;
607 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
609 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
610 WMI_VDEV_TYPE_MONITOR,
613 ath10k_warn("failed to request monitor vdev %i creation: %d\n",
614 ar->monitor_vdev_id, ret);
618 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
619 ar->monitor_vdev_id);
625 * Restore the ID to the global map.
627 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
631 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
635 lockdep_assert_held(&ar->conf_mutex);
637 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
639 ath10k_warn("failed to request wmi monitor vdev %i removal: %d\n",
640 ar->monitor_vdev_id, ret);
644 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
646 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
647 ar->monitor_vdev_id);
651 static int ath10k_monitor_start(struct ath10k *ar)
655 lockdep_assert_held(&ar->conf_mutex);
657 if (!ath10k_monitor_is_enabled(ar)) {
658 ath10k_warn("trying to start monitor with no references\n");
662 if (ar->monitor_started) {
663 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor already started\n");
667 ret = ath10k_monitor_vdev_create(ar);
669 ath10k_warn("failed to create monitor vdev: %d\n", ret);
673 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
675 ath10k_warn("failed to start monitor vdev: %d\n", ret);
676 ath10k_monitor_vdev_delete(ar);
680 ar->monitor_started = true;
681 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor started\n");
686 static void ath10k_monitor_stop(struct ath10k *ar)
690 lockdep_assert_held(&ar->conf_mutex);
692 if (ath10k_monitor_is_enabled(ar)) {
693 ath10k_dbg(ATH10K_DBG_MAC,
694 "mac monitor will be stopped later\n");
698 if (!ar->monitor_started) {
699 ath10k_dbg(ATH10K_DBG_MAC,
700 "mac monitor probably failed to start earlier\n");
704 ret = ath10k_monitor_vdev_stop(ar);
706 ath10k_warn("failed to stop monitor vdev: %d\n", ret);
708 ret = ath10k_monitor_vdev_delete(ar);
710 ath10k_warn("failed to delete monitor vdev: %d\n", ret);
712 ar->monitor_started = false;
713 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor stopped\n");
716 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
718 struct ath10k *ar = arvif->ar;
719 u32 vdev_param, rts_cts = 0;
721 lockdep_assert_held(&ar->conf_mutex);
723 vdev_param = ar->wmi.vdev_param->enable_rtscts;
725 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
726 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
728 if (arvif->num_legacy_stations > 0)
729 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
732 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
736 static int ath10k_start_cac(struct ath10k *ar)
740 lockdep_assert_held(&ar->conf_mutex);
742 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
744 ret = ath10k_monitor_start(ar);
746 ath10k_warn("failed to start monitor (cac): %d\n", ret);
747 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
751 ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
752 ar->monitor_vdev_id);
757 static int ath10k_stop_cac(struct ath10k *ar)
759 lockdep_assert_held(&ar->conf_mutex);
761 /* CAC is not running - do nothing */
762 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
765 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
766 ath10k_monitor_stop(ar);
768 ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n");
773 static void ath10k_recalc_radar_detection(struct ath10k *ar)
777 lockdep_assert_held(&ar->conf_mutex);
781 if (!ar->radar_enabled)
784 if (ar->num_started_vdevs > 0)
787 ret = ath10k_start_cac(ar);
790 * Not possible to start CAC on current channel so starting
791 * radiation is not allowed, make this channel DFS_UNAVAILABLE
792 * by indicating that radar was detected.
794 ath10k_warn("failed to start CAC: %d\n", ret);
795 ieee80211_radar_detected(ar->hw);
799 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
801 struct ath10k *ar = arvif->ar;
802 struct cfg80211_chan_def *chandef = &ar->chandef;
803 struct wmi_vdev_start_request_arg arg = {};
806 lockdep_assert_held(&ar->conf_mutex);
808 reinit_completion(&ar->vdev_setup_done);
810 arg.vdev_id = arvif->vdev_id;
811 arg.dtim_period = arvif->dtim_period;
812 arg.bcn_intval = arvif->beacon_interval;
814 arg.channel.freq = chandef->chan->center_freq;
815 arg.channel.band_center_freq1 = chandef->center_freq1;
816 arg.channel.mode = chan_to_phymode(chandef);
818 arg.channel.min_power = 0;
819 arg.channel.max_power = chandef->chan->max_power * 2;
820 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
821 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
823 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
824 arg.ssid = arvif->u.ap.ssid;
825 arg.ssid_len = arvif->u.ap.ssid_len;
826 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
828 /* For now allow DFS for AP mode */
829 arg.channel.chan_radar =
830 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
831 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
832 arg.ssid = arvif->vif->bss_conf.ssid;
833 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
836 ath10k_dbg(ATH10K_DBG_MAC,
837 "mac vdev %d start center_freq %d phymode %s\n",
838 arg.vdev_id, arg.channel.freq,
839 ath10k_wmi_phymode_str(arg.channel.mode));
842 ret = ath10k_wmi_vdev_restart(ar, &arg);
844 ret = ath10k_wmi_vdev_start(ar, &arg);
847 ath10k_warn("failed to start WMI vdev %i: %d\n",
852 ret = ath10k_vdev_setup_sync(ar);
854 ath10k_warn("failed to synchronise setup for vdev %i: %d\n",
859 ar->num_started_vdevs++;
860 ath10k_recalc_radar_detection(ar);
865 static int ath10k_vdev_start(struct ath10k_vif *arvif)
867 return ath10k_vdev_start_restart(arvif, false);
870 static int ath10k_vdev_restart(struct ath10k_vif *arvif)
872 return ath10k_vdev_start_restart(arvif, true);
875 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
877 struct ath10k *ar = arvif->ar;
880 lockdep_assert_held(&ar->conf_mutex);
882 reinit_completion(&ar->vdev_setup_done);
884 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
886 ath10k_warn("failed to stop WMI vdev %i: %d\n",
887 arvif->vdev_id, ret);
891 ret = ath10k_vdev_setup_sync(ar);
893 ath10k_warn("failed to syncronise setup for vdev %i: %d\n",
894 arvif->vdev_id, ret);
898 WARN_ON(ar->num_started_vdevs == 0);
900 if (ar->num_started_vdevs != 0) {
901 ar->num_started_vdevs--;
902 ath10k_recalc_radar_detection(ar);
908 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
909 struct ieee80211_bss_conf *info)
913 lockdep_assert_held(&arvif->ar->conf_mutex);
915 if (!info->enable_beacon) {
916 ath10k_vdev_stop(arvif);
918 arvif->is_started = false;
919 arvif->is_up = false;
921 spin_lock_bh(&arvif->ar->data_lock);
923 dma_unmap_single(arvif->ar->dev,
924 ATH10K_SKB_CB(arvif->beacon)->paddr,
925 arvif->beacon->len, DMA_TO_DEVICE);
926 dev_kfree_skb_any(arvif->beacon);
928 arvif->beacon = NULL;
929 arvif->beacon_sent = false;
931 spin_unlock_bh(&arvif->ar->data_lock);
936 arvif->tx_seq_no = 0x1000;
938 ret = ath10k_vdev_start(arvif);
943 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
945 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
948 ath10k_warn("failed to bring up vdev %d: %i\n",
949 arvif->vdev_id, ret);
950 ath10k_vdev_stop(arvif);
954 arvif->is_started = true;
957 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
960 static void ath10k_control_ibss(struct ath10k_vif *arvif,
961 struct ieee80211_bss_conf *info,
962 const u8 self_peer[ETH_ALEN])
967 lockdep_assert_held(&arvif->ar->conf_mutex);
969 if (!info->ibss_joined) {
970 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
972 ath10k_warn("failed to delete IBSS self peer %pM for vdev %d: %d\n",
973 self_peer, arvif->vdev_id, ret);
975 if (is_zero_ether_addr(arvif->bssid))
978 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
981 ath10k_warn("failed to delete IBSS BSSID peer %pM for vdev %d: %d\n",
982 arvif->bssid, arvif->vdev_id, ret);
986 memset(arvif->bssid, 0, ETH_ALEN);
991 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
993 ath10k_warn("failed to create IBSS self peer %pM for vdev %d: %d\n",
994 self_peer, arvif->vdev_id, ret);
998 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
999 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1000 ATH10K_DEFAULT_ATIM);
1002 ath10k_warn("failed to set IBSS ATIM for vdev %d: %d\n",
1003 arvif->vdev_id, ret);
1007 * Review this when mac80211 gains per-interface powersave support.
1009 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1011 struct ath10k *ar = arvif->ar;
1012 struct ieee80211_conf *conf = &ar->hw->conf;
1013 enum wmi_sta_powersave_param param;
1014 enum wmi_sta_ps_mode psmode;
1017 lockdep_assert_held(&arvif->ar->conf_mutex);
1019 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1022 if (conf->flags & IEEE80211_CONF_PS) {
1023 psmode = WMI_STA_PS_MODE_ENABLED;
1024 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1026 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1027 conf->dynamic_ps_timeout);
1029 ath10k_warn("failed to set inactivity time for vdev %d: %i\n",
1030 arvif->vdev_id, ret);
1034 psmode = WMI_STA_PS_MODE_DISABLED;
1037 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1038 arvif->vdev_id, psmode ? "enable" : "disable");
1040 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1042 ath10k_warn("failed to set PS Mode %d for vdev %d: %d\n",
1043 psmode, arvif->vdev_id, ret);
1050 /**********************/
1051 /* Station management */
1052 /**********************/
1054 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1055 struct ath10k_vif *arvif,
1056 struct ieee80211_sta *sta,
1057 struct ieee80211_bss_conf *bss_conf,
1058 struct wmi_peer_assoc_complete_arg *arg)
1060 lockdep_assert_held(&ar->conf_mutex);
1062 memcpy(arg->addr, sta->addr, ETH_ALEN);
1063 arg->vdev_id = arvif->vdev_id;
1064 arg->peer_aid = sta->aid;
1065 arg->peer_flags |= WMI_PEER_AUTH;
1067 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
1069 * Seems FW have problems with Power Save in STA
1070 * mode when we setup this parameter to high (eg. 5).
1071 * Often we see that FW don't send NULL (with clean P flags)
1072 * frame even there is info about buffered frames in beacons.
1073 * Sometimes we have to wait more than 10 seconds before FW
1074 * will wakeup. Often sending one ping from AP to our device
1075 * just fail (more than 50%).
1077 * Seems setting this FW parameter to 1 couse FW
1078 * will check every beacon and will wakup immediately
1079 * after detection buffered data.
1081 arg->peer_listen_intval = 1;
1083 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1085 arg->peer_num_spatial_streams = 1;
1088 * The assoc capabilities are available only in managed mode.
1090 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
1091 arg->peer_caps = bss_conf->assoc_capability;
1094 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1095 struct ath10k_vif *arvif,
1096 struct wmi_peer_assoc_complete_arg *arg)
1098 struct ieee80211_vif *vif = arvif->vif;
1099 struct ieee80211_bss_conf *info = &vif->bss_conf;
1100 struct cfg80211_bss *bss;
1101 const u8 *rsnie = NULL;
1102 const u8 *wpaie = NULL;
1104 lockdep_assert_held(&ar->conf_mutex);
1106 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1107 info->bssid, NULL, 0, 0, 0);
1109 const struct cfg80211_bss_ies *ies;
1112 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1114 ies = rcu_dereference(bss->ies);
1116 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1117 WLAN_OUI_TYPE_MICROSOFT_WPA,
1121 cfg80211_put_bss(ar->hw->wiphy, bss);
1124 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1125 if (rsnie || wpaie) {
1126 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1127 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1131 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1132 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1136 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1137 struct ieee80211_sta *sta,
1138 struct wmi_peer_assoc_complete_arg *arg)
1140 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1141 const struct ieee80211_supported_band *sband;
1142 const struct ieee80211_rate *rates;
1146 lockdep_assert_held(&ar->conf_mutex);
1148 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1149 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1150 rates = sband->bitrates;
1152 rateset->num_rates = 0;
1154 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1155 if (!(ratemask & 1))
1158 rateset->rates[rateset->num_rates] = rates->hw_value;
1159 rateset->num_rates++;
1163 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1164 struct ieee80211_sta *sta,
1165 struct wmi_peer_assoc_complete_arg *arg)
1167 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1170 lockdep_assert_held(&ar->conf_mutex);
1172 if (!ht_cap->ht_supported)
1175 arg->peer_flags |= WMI_PEER_HT;
1176 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1177 ht_cap->ampdu_factor)) - 1;
1179 arg->peer_mpdu_density =
1180 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1182 arg->peer_ht_caps = ht_cap->cap;
1183 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1185 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1186 arg->peer_flags |= WMI_PEER_LDPC;
1188 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1189 arg->peer_flags |= WMI_PEER_40MHZ;
1190 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1193 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1194 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1196 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1197 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1199 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1200 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1201 arg->peer_flags |= WMI_PEER_STBC;
1204 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1206 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1207 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1208 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1209 arg->peer_rate_caps |= stbc;
1210 arg->peer_flags |= WMI_PEER_STBC;
1213 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1214 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1215 else if (ht_cap->mcs.rx_mask[1])
1216 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1218 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1219 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1220 arg->peer_ht_rates.rates[n++] = i;
1223 * This is a workaround for HT-enabled STAs which break the spec
1224 * and have no HT capabilities RX mask (no HT RX MCS map).
1226 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1227 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1229 * Firmware asserts if such situation occurs.
1232 arg->peer_ht_rates.num_rates = 8;
1233 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1234 arg->peer_ht_rates.rates[i] = i;
1236 arg->peer_ht_rates.num_rates = n;
1237 arg->peer_num_spatial_streams = sta->rx_nss;
1240 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1242 arg->peer_ht_rates.num_rates,
1243 arg->peer_num_spatial_streams);
1246 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1247 struct ath10k_vif *arvif,
1248 struct ieee80211_sta *sta)
1254 lockdep_assert_held(&ar->conf_mutex);
1256 if (sta->wme && sta->uapsd_queues) {
1257 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1258 sta->uapsd_queues, sta->max_sp);
1260 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1261 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1262 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1263 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1264 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1265 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1266 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1267 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1268 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1269 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1270 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1271 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1274 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1275 max_sp = sta->max_sp;
1277 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1279 WMI_AP_PS_PEER_PARAM_UAPSD,
1282 ath10k_warn("failed to set ap ps peer param uapsd for vdev %i: %d\n",
1283 arvif->vdev_id, ret);
1287 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1289 WMI_AP_PS_PEER_PARAM_MAX_SP,
1292 ath10k_warn("failed to set ap ps peer param max sp for vdev %i: %d\n",
1293 arvif->vdev_id, ret);
1297 /* TODO setup this based on STA listen interval and
1298 beacon interval. Currently we don't know
1299 sta->listen_interval - mac80211 patch required.
1300 Currently use 10 seconds */
1301 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1302 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 10);
1304 ath10k_warn("failed to set ap ps peer param ageout time for vdev %i: %d\n",
1305 arvif->vdev_id, ret);
1313 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1314 struct ieee80211_sta *sta,
1315 struct wmi_peer_assoc_complete_arg *arg)
1317 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1320 if (!vht_cap->vht_supported)
1323 arg->peer_flags |= WMI_PEER_VHT;
1324 arg->peer_vht_caps = vht_cap->cap;
1327 ampdu_factor = (vht_cap->cap &
1328 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1329 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1331 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1332 * zero in VHT IE. Using it would result in degraded throughput.
1333 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1334 * it if VHT max_mpdu is smaller. */
1335 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1336 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1337 ampdu_factor)) - 1);
1339 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1340 arg->peer_flags |= WMI_PEER_80MHZ;
1342 arg->peer_vht_rates.rx_max_rate =
1343 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1344 arg->peer_vht_rates.rx_mcs_set =
1345 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1346 arg->peer_vht_rates.tx_max_rate =
1347 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1348 arg->peer_vht_rates.tx_mcs_set =
1349 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1351 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1352 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1355 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1356 struct ath10k_vif *arvif,
1357 struct ieee80211_sta *sta,
1358 struct ieee80211_bss_conf *bss_conf,
1359 struct wmi_peer_assoc_complete_arg *arg)
1361 switch (arvif->vdev_type) {
1362 case WMI_VDEV_TYPE_AP:
1364 arg->peer_flags |= WMI_PEER_QOS;
1366 if (sta->wme && sta->uapsd_queues) {
1367 arg->peer_flags |= WMI_PEER_APSD;
1368 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1371 case WMI_VDEV_TYPE_STA:
1373 arg->peer_flags |= WMI_PEER_QOS;
1380 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1381 struct ath10k_vif *arvif,
1382 struct ieee80211_sta *sta,
1383 struct wmi_peer_assoc_complete_arg *arg)
1385 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1387 switch (ar->hw->conf.chandef.chan->band) {
1388 case IEEE80211_BAND_2GHZ:
1389 if (sta->ht_cap.ht_supported) {
1390 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1391 phymode = MODE_11NG_HT40;
1393 phymode = MODE_11NG_HT20;
1399 case IEEE80211_BAND_5GHZ:
1403 if (sta->vht_cap.vht_supported) {
1404 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1405 phymode = MODE_11AC_VHT80;
1406 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1407 phymode = MODE_11AC_VHT40;
1408 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1409 phymode = MODE_11AC_VHT20;
1410 } else if (sta->ht_cap.ht_supported) {
1411 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1412 phymode = MODE_11NA_HT40;
1414 phymode = MODE_11NA_HT20;
1424 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1425 sta->addr, ath10k_wmi_phymode_str(phymode));
1427 arg->peer_phymode = phymode;
1428 WARN_ON(phymode == MODE_UNKNOWN);
1431 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1432 struct ath10k_vif *arvif,
1433 struct ieee80211_sta *sta,
1434 struct ieee80211_bss_conf *bss_conf,
1435 struct wmi_peer_assoc_complete_arg *arg)
1437 lockdep_assert_held(&ar->conf_mutex);
1439 memset(arg, 0, sizeof(*arg));
1441 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1442 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1443 ath10k_peer_assoc_h_rates(ar, sta, arg);
1444 ath10k_peer_assoc_h_ht(ar, sta, arg);
1445 ath10k_peer_assoc_h_vht(ar, sta, arg);
1446 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1447 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
1452 static const u32 ath10k_smps_map[] = {
1453 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1454 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1455 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1456 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1459 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1461 const struct ieee80211_sta_ht_cap *ht_cap)
1465 if (!ht_cap->ht_supported)
1468 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1469 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1471 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1474 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1475 WMI_PEER_SMPS_STATE,
1476 ath10k_smps_map[smps]);
1479 /* can be called only in mac80211 callbacks due to `key_count` usage */
1480 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1481 struct ieee80211_vif *vif,
1482 struct ieee80211_bss_conf *bss_conf)
1484 struct ath10k *ar = hw->priv;
1485 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1486 struct ieee80211_sta_ht_cap ht_cap;
1487 struct wmi_peer_assoc_complete_arg peer_arg;
1488 struct ieee80211_sta *ap_sta;
1491 lockdep_assert_held(&ar->conf_mutex);
1495 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1497 ath10k_warn("failed to find station entry for bss %pM vdev %i\n",
1498 bss_conf->bssid, arvif->vdev_id);
1503 /* ap_sta must be accessed only within rcu section which must be left
1504 * before calling ath10k_setup_peer_smps() which might sleep. */
1505 ht_cap = ap_sta->ht_cap;
1507 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1508 bss_conf, &peer_arg);
1510 ath10k_warn("failed to prepare peer assoc for %pM vdev %i: %d\n",
1511 bss_conf->bssid, arvif->vdev_id, ret);
1518 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1520 ath10k_warn("failed to run peer assoc for %pM vdev %i: %d\n",
1521 bss_conf->bssid, arvif->vdev_id, ret);
1525 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1527 ath10k_warn("failed to setup peer SMPS for vdev %i: %d\n",
1528 arvif->vdev_id, ret);
1532 ath10k_dbg(ATH10K_DBG_MAC,
1533 "mac vdev %d up (associated) bssid %pM aid %d\n",
1534 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1536 arvif->aid = bss_conf->aid;
1537 memcpy(arvif->bssid, bss_conf->bssid, ETH_ALEN);
1539 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1541 ath10k_warn("failed to set vdev %d up: %d\n",
1542 arvif->vdev_id, ret);
1546 arvif->is_up = true;
1552 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1553 struct ieee80211_vif *vif)
1555 struct ath10k *ar = hw->priv;
1556 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1559 lockdep_assert_held(&ar->conf_mutex);
1562 * For some reason, calling VDEV-DOWN before VDEV-STOP
1563 * makes the FW to send frames via HTT after disassociation.
1564 * No idea why this happens, even though VDEV-DOWN is supposed
1565 * to be analogous to link down, so just stop the VDEV.
1567 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1570 /* FIXME: check return value */
1571 ret = ath10k_vdev_stop(arvif);
1574 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1575 * report beacons from previously associated network through HTT.
1576 * This in turn would spam mac80211 WARN_ON if we bring down all
1577 * interfaces as it expects there is no rx when no interface is
1580 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1582 /* FIXME: why don't we print error if wmi call fails? */
1583 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1585 arvif->def_wep_key_idx = 0;
1587 arvif->is_started = false;
1588 arvif->is_up = false;
1591 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1592 struct ieee80211_sta *sta, bool reassoc)
1594 struct wmi_peer_assoc_complete_arg peer_arg;
1597 lockdep_assert_held(&ar->conf_mutex);
1599 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1601 ath10k_warn("failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1602 sta->addr, arvif->vdev_id, ret);
1606 peer_arg.peer_reassoc = reassoc;
1607 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1609 ath10k_warn("failed to run peer assoc for STA %pM vdev %i: %d\n",
1610 sta->addr, arvif->vdev_id, ret);
1614 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap);
1616 ath10k_warn("failed to setup peer SMPS for vdev %d: %d\n",
1617 arvif->vdev_id, ret);
1622 arvif->num_legacy_stations++;
1623 ret = ath10k_recalc_rtscts_prot(arvif);
1625 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1626 arvif->vdev_id, ret);
1631 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1633 ath10k_warn("failed to install peer wep keys for vdev %i: %d\n",
1634 arvif->vdev_id, ret);
1638 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1640 ath10k_warn("failed to set qos params for STA %pM for vdev %i: %d\n",
1641 sta->addr, arvif->vdev_id, ret);
1648 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1649 struct ieee80211_sta *sta)
1653 lockdep_assert_held(&ar->conf_mutex);
1656 arvif->num_legacy_stations--;
1657 ret = ath10k_recalc_rtscts_prot(arvif);
1659 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1660 arvif->vdev_id, ret);
1665 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1667 ath10k_warn("failed to clear all peer wep keys for vdev %i: %d\n",
1668 arvif->vdev_id, ret);
1679 static int ath10k_update_channel_list(struct ath10k *ar)
1681 struct ieee80211_hw *hw = ar->hw;
1682 struct ieee80211_supported_band **bands;
1683 enum ieee80211_band band;
1684 struct ieee80211_channel *channel;
1685 struct wmi_scan_chan_list_arg arg = {0};
1686 struct wmi_channel_arg *ch;
1692 lockdep_assert_held(&ar->conf_mutex);
1694 bands = hw->wiphy->bands;
1695 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1699 for (i = 0; i < bands[band]->n_channels; i++) {
1700 if (bands[band]->channels[i].flags &
1701 IEEE80211_CHAN_DISABLED)
1708 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1709 arg.channels = kzalloc(len, GFP_KERNEL);
1714 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1718 for (i = 0; i < bands[band]->n_channels; i++) {
1719 channel = &bands[band]->channels[i];
1721 if (channel->flags & IEEE80211_CHAN_DISABLED)
1724 ch->allow_ht = true;
1726 /* FIXME: when should we really allow VHT? */
1727 ch->allow_vht = true;
1730 !(channel->flags & IEEE80211_CHAN_NO_IR);
1733 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1736 !!(channel->flags & IEEE80211_CHAN_RADAR);
1738 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1739 ch->passive = passive;
1741 ch->freq = channel->center_freq;
1743 ch->max_power = channel->max_power * 2;
1744 ch->max_reg_power = channel->max_reg_power * 2;
1745 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1746 ch->reg_class_id = 0; /* FIXME */
1748 /* FIXME: why use only legacy modes, why not any
1749 * HT/VHT modes? Would that even make any
1751 if (channel->band == IEEE80211_BAND_2GHZ)
1752 ch->mode = MODE_11G;
1754 ch->mode = MODE_11A;
1756 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1759 ath10k_dbg(ATH10K_DBG_WMI,
1760 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1761 ch - arg.channels, arg.n_channels,
1762 ch->freq, ch->max_power, ch->max_reg_power,
1763 ch->max_antenna_gain, ch->mode);
1769 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1770 kfree(arg.channels);
1775 static enum wmi_dfs_region
1776 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1778 switch (dfs_region) {
1779 case NL80211_DFS_UNSET:
1780 return WMI_UNINIT_DFS_DOMAIN;
1781 case NL80211_DFS_FCC:
1782 return WMI_FCC_DFS_DOMAIN;
1783 case NL80211_DFS_ETSI:
1784 return WMI_ETSI_DFS_DOMAIN;
1785 case NL80211_DFS_JP:
1786 return WMI_MKK4_DFS_DOMAIN;
1788 return WMI_UNINIT_DFS_DOMAIN;
1791 static void ath10k_regd_update(struct ath10k *ar)
1793 struct reg_dmn_pair_mapping *regpair;
1795 enum wmi_dfs_region wmi_dfs_reg;
1796 enum nl80211_dfs_regions nl_dfs_reg;
1798 lockdep_assert_held(&ar->conf_mutex);
1800 ret = ath10k_update_channel_list(ar);
1802 ath10k_warn("failed to update channel list: %d\n", ret);
1804 regpair = ar->ath_common.regulatory.regpair;
1806 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1807 nl_dfs_reg = ar->dfs_detector->region;
1808 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1810 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1813 /* Target allows setting up per-band regdomain but ath_common provides
1814 * a combined one only */
1815 ret = ath10k_wmi_pdev_set_regdomain(ar,
1816 regpair->reg_domain,
1817 regpair->reg_domain, /* 2ghz */
1818 regpair->reg_domain, /* 5ghz */
1819 regpair->reg_2ghz_ctl,
1820 regpair->reg_5ghz_ctl,
1823 ath10k_warn("failed to set pdev regdomain: %d\n", ret);
1826 static void ath10k_reg_notifier(struct wiphy *wiphy,
1827 struct regulatory_request *request)
1829 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1830 struct ath10k *ar = hw->priv;
1833 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1835 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1836 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1837 request->dfs_region);
1838 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1839 request->dfs_region);
1841 ath10k_warn("DFS region 0x%X not supported, will trigger radar for every pulse\n",
1842 request->dfs_region);
1845 mutex_lock(&ar->conf_mutex);
1846 if (ar->state == ATH10K_STATE_ON)
1847 ath10k_regd_update(ar);
1848 mutex_unlock(&ar->conf_mutex);
1855 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1857 if (ieee80211_is_mgmt(hdr->frame_control))
1858 return HTT_DATA_TX_EXT_TID_MGMT;
1860 if (!ieee80211_is_data_qos(hdr->frame_control))
1861 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1863 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1864 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1866 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1869 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1870 struct ieee80211_tx_info *info)
1872 if (info->control.vif)
1873 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1875 if (ar->monitor_started)
1876 return ar->monitor_vdev_id;
1878 ath10k_warn("failed to resolve vdev id\n");
1882 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1883 * Control in the header.
1885 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
1887 struct ieee80211_hdr *hdr = (void *)skb->data;
1888 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
1891 if (!ieee80211_is_data_qos(hdr->frame_control))
1894 qos_ctl = ieee80211_get_qos_ctl(hdr);
1895 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1896 skb->data, (void *)qos_ctl - (void *)skb->data);
1897 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1899 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1900 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1901 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1902 * it is safe to downgrade to NullFunc.
1904 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1905 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1906 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1910 static void ath10k_tx_wep_key_work(struct work_struct *work)
1912 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1914 int ret, keyidx = arvif->def_wep_key_newidx;
1916 mutex_lock(&arvif->ar->conf_mutex);
1918 if (arvif->ar->state != ATH10K_STATE_ON)
1921 if (arvif->def_wep_key_idx == keyidx)
1924 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1925 arvif->vdev_id, keyidx);
1927 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1929 arvif->ar->wmi.vdev_param->def_keyid,
1932 ath10k_warn("failed to update wep key index for vdev %d: %d\n",
1938 arvif->def_wep_key_idx = keyidx;
1941 mutex_unlock(&arvif->ar->conf_mutex);
1944 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
1945 struct ieee80211_key_conf *key,
1946 struct sk_buff *skb)
1948 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1949 struct ath10k *ar = arvif->ar;
1950 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1952 if (!ieee80211_has_protected(hdr->frame_control))
1958 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1959 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1962 if (key->keyidx == arvif->def_wep_key_idx)
1965 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1966 * queueing frames until key index is updated is not an option because
1967 * sk_buff may need more processing to be done, e.g. offchannel */
1968 arvif->def_wep_key_newidx = key->keyidx;
1969 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1972 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
1973 struct ieee80211_vif *vif,
1974 struct sk_buff *skb)
1976 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1977 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1979 /* This is case only for P2P_GO */
1980 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1981 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1984 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1985 spin_lock_bh(&ar->data_lock);
1986 if (arvif->u.ap.noa_data)
1987 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1989 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1990 arvif->u.ap.noa_data,
1991 arvif->u.ap.noa_len);
1992 spin_unlock_bh(&ar->data_lock);
1996 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1998 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2001 if (ar->htt.target_version_major >= 3) {
2002 /* Since HTT 3.0 there is no separate mgmt tx command */
2003 ret = ath10k_htt_tx(&ar->htt, skb);
2007 if (ieee80211_is_mgmt(hdr->frame_control)) {
2008 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2010 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2011 ATH10K_MAX_NUM_MGMT_PENDING) {
2012 ath10k_warn("reached WMI management tranmist queue limit\n");
2017 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2018 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2020 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2022 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2024 ieee80211_is_nullfunc(hdr->frame_control)) {
2025 /* FW does not report tx status properly for NullFunc frames
2026 * unless they are sent through mgmt tx path. mac80211 sends
2027 * those frames when it detects link/beacon loss and depends
2028 * on the tx status to be correct. */
2029 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2031 ret = ath10k_htt_tx(&ar->htt, skb);
2036 ath10k_warn("failed to transmit packet, dropping: %d\n", ret);
2037 ieee80211_free_txskb(ar->hw, skb);
2041 void ath10k_offchan_tx_purge(struct ath10k *ar)
2043 struct sk_buff *skb;
2046 skb = skb_dequeue(&ar->offchan_tx_queue);
2050 ieee80211_free_txskb(ar->hw, skb);
2054 void ath10k_offchan_tx_work(struct work_struct *work)
2056 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2057 struct ath10k_peer *peer;
2058 struct ieee80211_hdr *hdr;
2059 struct sk_buff *skb;
2060 const u8 *peer_addr;
2064 /* FW requirement: We must create a peer before FW will send out
2065 * an offchannel frame. Otherwise the frame will be stuck and
2066 * never transmitted. We delete the peer upon tx completion.
2067 * It is unlikely that a peer for offchannel tx will already be
2068 * present. However it may be in some rare cases so account for that.
2069 * Otherwise we might remove a legitimate peer and break stuff. */
2072 skb = skb_dequeue(&ar->offchan_tx_queue);
2076 mutex_lock(&ar->conf_mutex);
2078 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2081 hdr = (struct ieee80211_hdr *)skb->data;
2082 peer_addr = ieee80211_get_DA(hdr);
2083 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2085 spin_lock_bh(&ar->data_lock);
2086 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2087 spin_unlock_bh(&ar->data_lock);
2090 /* FIXME: should this use ath10k_warn()? */
2091 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2092 peer_addr, vdev_id);
2095 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2097 ath10k_warn("failed to create peer %pM on vdev %d: %d\n",
2098 peer_addr, vdev_id, ret);
2101 spin_lock_bh(&ar->data_lock);
2102 reinit_completion(&ar->offchan_tx_completed);
2103 ar->offchan_tx_skb = skb;
2104 spin_unlock_bh(&ar->data_lock);
2106 ath10k_tx_htt(ar, skb);
2108 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2111 ath10k_warn("timed out waiting for offchannel skb %p\n",
2115 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2117 ath10k_warn("failed to delete peer %pM on vdev %d: %d\n",
2118 peer_addr, vdev_id, ret);
2121 mutex_unlock(&ar->conf_mutex);
2125 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2127 struct sk_buff *skb;
2130 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2134 ieee80211_free_txskb(ar->hw, skb);
2138 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2140 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2141 struct sk_buff *skb;
2145 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2149 ret = ath10k_wmi_mgmt_tx(ar, skb);
2151 ath10k_warn("failed to transmit management frame via WMI: %d\n",
2153 ieee80211_free_txskb(ar->hw, skb);
2163 * This gets called if we dont get a heart-beat during scan.
2164 * This may indicate the FW has hung and we need to abort the
2165 * scan manually to prevent cancel_hw_scan() from deadlocking
2167 void ath10k_reset_scan(unsigned long ptr)
2169 struct ath10k *ar = (struct ath10k *)ptr;
2171 spin_lock_bh(&ar->data_lock);
2172 if (!ar->scan.in_progress) {
2173 spin_unlock_bh(&ar->data_lock);
2177 ath10k_warn("scan timed out, firmware problem?\n");
2179 if (ar->scan.is_roc)
2180 ieee80211_remain_on_channel_expired(ar->hw);
2182 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
2184 ar->scan.in_progress = false;
2185 complete_all(&ar->scan.completed);
2186 spin_unlock_bh(&ar->data_lock);
2189 static int ath10k_abort_scan(struct ath10k *ar)
2191 struct wmi_stop_scan_arg arg = {
2192 .req_id = 1, /* FIXME */
2193 .req_type = WMI_SCAN_STOP_ONE,
2194 .u.scan_id = ATH10K_SCAN_ID,
2198 lockdep_assert_held(&ar->conf_mutex);
2200 del_timer_sync(&ar->scan.timeout);
2202 spin_lock_bh(&ar->data_lock);
2203 if (!ar->scan.in_progress) {
2204 spin_unlock_bh(&ar->data_lock);
2208 ar->scan.aborting = true;
2209 spin_unlock_bh(&ar->data_lock);
2211 ret = ath10k_wmi_stop_scan(ar, &arg);
2213 ath10k_warn("failed to stop wmi scan: %d\n", ret);
2214 spin_lock_bh(&ar->data_lock);
2215 ar->scan.in_progress = false;
2216 ath10k_offchan_tx_purge(ar);
2217 spin_unlock_bh(&ar->data_lock);
2221 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2223 ath10k_warn("timed out while waiting for scan to stop\n");
2225 /* scan completion may be done right after we timeout here, so let's
2226 * check the in_progress and tell mac80211 scan is completed. if we
2227 * don't do that and FW fails to send us scan completion indication
2228 * then userspace won't be able to scan anymore */
2231 spin_lock_bh(&ar->data_lock);
2232 if (ar->scan.in_progress) {
2233 ath10k_warn("failed to stop scan, it's still in progress\n");
2234 ar->scan.in_progress = false;
2235 ath10k_offchan_tx_purge(ar);
2238 spin_unlock_bh(&ar->data_lock);
2243 static int ath10k_start_scan(struct ath10k *ar,
2244 const struct wmi_start_scan_arg *arg)
2248 lockdep_assert_held(&ar->conf_mutex);
2250 ret = ath10k_wmi_start_scan(ar, arg);
2254 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2256 ath10k_abort_scan(ar);
2260 /* the scan can complete earlier, before we even
2261 * start the timer. in that case the timer handler
2262 * checks ar->scan.in_progress and bails out if its
2263 * false. Add a 200ms margin to account event/command
2265 mod_timer(&ar->scan.timeout, jiffies +
2266 msecs_to_jiffies(arg->max_scan_time+200));
2270 /**********************/
2271 /* mac80211 callbacks */
2272 /**********************/
2274 static void ath10k_tx(struct ieee80211_hw *hw,
2275 struct ieee80211_tx_control *control,
2276 struct sk_buff *skb)
2278 struct ath10k *ar = hw->priv;
2279 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2280 struct ieee80211_vif *vif = info->control.vif;
2281 struct ieee80211_key_conf *key = info->control.hw_key;
2282 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2284 /* We should disable CCK RATE due to P2P */
2285 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2286 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2288 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2289 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2290 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
2292 /* it makes no sense to process injected frames like that */
2293 if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2294 ath10k_tx_h_nwifi(hw, skb);
2295 ath10k_tx_h_update_wep_key(vif, key, skb);
2296 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2297 ath10k_tx_h_seq_no(vif, skb);
2300 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2301 spin_lock_bh(&ar->data_lock);
2302 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2303 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2304 spin_unlock_bh(&ar->data_lock);
2306 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2308 skb_queue_tail(&ar->offchan_tx_queue, skb);
2309 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2313 ath10k_tx_htt(ar, skb);
2316 /* Must not be called with conf_mutex held as workers can use that also. */
2317 static void ath10k_drain_tx(struct ath10k *ar)
2319 /* make sure rcu-protected mac80211 tx path itself is drained */
2322 ath10k_offchan_tx_purge(ar);
2323 ath10k_mgmt_over_wmi_tx_purge(ar);
2325 cancel_work_sync(&ar->offchan_tx_work);
2326 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2329 void ath10k_halt(struct ath10k *ar)
2331 struct ath10k_vif *arvif;
2333 lockdep_assert_held(&ar->conf_mutex);
2335 if (ath10k_monitor_is_enabled(ar)) {
2336 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2337 ar->promisc = false;
2338 ar->monitor = false;
2339 ath10k_monitor_stop(ar);
2342 del_timer_sync(&ar->scan.timeout);
2343 ath10k_reset_scan((unsigned long)ar);
2344 ath10k_peer_cleanup_all(ar);
2345 ath10k_core_stop(ar);
2346 ath10k_hif_power_down(ar);
2348 spin_lock_bh(&ar->data_lock);
2349 list_for_each_entry(arvif, &ar->arvifs, list) {
2353 dma_unmap_single(arvif->ar->dev,
2354 ATH10K_SKB_CB(arvif->beacon)->paddr,
2355 arvif->beacon->len, DMA_TO_DEVICE);
2356 dev_kfree_skb_any(arvif->beacon);
2357 arvif->beacon = NULL;
2359 spin_unlock_bh(&ar->data_lock);
2362 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2364 struct ath10k *ar = hw->priv;
2366 mutex_lock(&ar->conf_mutex);
2368 if (ar->cfg_tx_chainmask) {
2369 *tx_ant = ar->cfg_tx_chainmask;
2370 *rx_ant = ar->cfg_rx_chainmask;
2372 *tx_ant = ar->supp_tx_chainmask;
2373 *rx_ant = ar->supp_rx_chainmask;
2376 mutex_unlock(&ar->conf_mutex);
2381 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2385 lockdep_assert_held(&ar->conf_mutex);
2387 ar->cfg_tx_chainmask = tx_ant;
2388 ar->cfg_rx_chainmask = rx_ant;
2390 if ((ar->state != ATH10K_STATE_ON) &&
2391 (ar->state != ATH10K_STATE_RESTARTED))
2394 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2397 ath10k_warn("failed to set tx-chainmask: %d, req 0x%x\n",
2402 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2405 ath10k_warn("failed to set rx-chainmask: %d, req 0x%x\n",
2413 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2415 struct ath10k *ar = hw->priv;
2418 mutex_lock(&ar->conf_mutex);
2419 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2420 mutex_unlock(&ar->conf_mutex);
2424 static int ath10k_start(struct ieee80211_hw *hw)
2426 struct ath10k *ar = hw->priv;
2430 * This makes sense only when restarting hw. It is harmless to call
2431 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2432 * commands will be submitted while restarting.
2434 ath10k_drain_tx(ar);
2436 mutex_lock(&ar->conf_mutex);
2438 switch (ar->state) {
2439 case ATH10K_STATE_OFF:
2440 ar->state = ATH10K_STATE_ON;
2442 case ATH10K_STATE_RESTARTING:
2444 ar->state = ATH10K_STATE_RESTARTED;
2446 case ATH10K_STATE_ON:
2447 case ATH10K_STATE_RESTARTED:
2448 case ATH10K_STATE_WEDGED:
2454 ret = ath10k_hif_power_up(ar);
2456 ath10k_err("Could not init hif: %d\n", ret);
2460 ret = ath10k_core_start(ar);
2462 ath10k_err("Could not init core: %d\n", ret);
2463 goto err_power_down;
2466 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2468 ath10k_warn("failed to enable PMF QOS: %d\n", ret);
2472 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2474 ath10k_warn("failed to enable dynamic BW: %d\n", ret);
2478 if (ar->cfg_tx_chainmask)
2479 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2480 ar->cfg_rx_chainmask);
2483 * By default FW set ARP frames ac to voice (6). In that case ARP
2484 * exchange is not working properly for UAPSD enabled AP. ARP requests
2485 * which arrives with access category 0 are processed by network stack
2486 * and send back with access category 0, but FW changes access category
2487 * to 6. Set ARP frames access category to best effort (0) solves
2491 ret = ath10k_wmi_pdev_set_param(ar,
2492 ar->wmi.pdev_param->arp_ac_override, 0);
2494 ath10k_warn("failed to set arp ac override parameter: %d\n",
2499 ar->num_started_vdevs = 0;
2500 ath10k_regd_update(ar);
2502 ath10k_spectral_start(ar);
2504 mutex_unlock(&ar->conf_mutex);
2508 ath10k_core_stop(ar);
2511 ath10k_hif_power_down(ar);
2514 ar->state = ATH10K_STATE_OFF;
2517 mutex_unlock(&ar->conf_mutex);
2521 static void ath10k_stop(struct ieee80211_hw *hw)
2523 struct ath10k *ar = hw->priv;
2525 ath10k_drain_tx(ar);
2527 mutex_lock(&ar->conf_mutex);
2528 if (ar->state != ATH10K_STATE_OFF) {
2530 ar->state = ATH10K_STATE_OFF;
2532 mutex_unlock(&ar->conf_mutex);
2534 cancel_work_sync(&ar->restart_work);
2537 static int ath10k_config_ps(struct ath10k *ar)
2539 struct ath10k_vif *arvif;
2542 lockdep_assert_held(&ar->conf_mutex);
2544 list_for_each_entry(arvif, &ar->arvifs, list) {
2545 ret = ath10k_mac_vif_setup_ps(arvif);
2547 ath10k_warn("failed to setup powersave: %d\n", ret);
2555 static const char *chandef_get_width(enum nl80211_chan_width width)
2558 case NL80211_CHAN_WIDTH_20_NOHT:
2560 case NL80211_CHAN_WIDTH_20:
2562 case NL80211_CHAN_WIDTH_40:
2564 case NL80211_CHAN_WIDTH_80:
2566 case NL80211_CHAN_WIDTH_80P80:
2568 case NL80211_CHAN_WIDTH_160:
2570 case NL80211_CHAN_WIDTH_5:
2572 case NL80211_CHAN_WIDTH_10:
2578 static void ath10k_config_chan(struct ath10k *ar)
2580 struct ath10k_vif *arvif;
2583 lockdep_assert_held(&ar->conf_mutex);
2585 ath10k_dbg(ATH10K_DBG_MAC,
2586 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2587 ar->chandef.chan->center_freq,
2588 ar->chandef.center_freq1,
2589 ar->chandef.center_freq2,
2590 chandef_get_width(ar->chandef.width));
2592 /* First stop monitor interface. Some FW versions crash if there's a
2593 * lone monitor interface. */
2594 if (ar->monitor_started)
2595 ath10k_monitor_vdev_stop(ar);
2597 list_for_each_entry(arvif, &ar->arvifs, list) {
2598 if (!arvif->is_started)
2604 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2607 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2609 ath10k_warn("failed to down vdev %d: %d\n",
2610 arvif->vdev_id, ret);
2615 /* all vdevs are downed now - attempt to restart and re-up them */
2617 list_for_each_entry(arvif, &ar->arvifs, list) {
2618 if (!arvif->is_started)
2621 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2624 ret = ath10k_vdev_restart(arvif);
2626 ath10k_warn("failed to restart vdev %d: %d\n",
2627 arvif->vdev_id, ret);
2634 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2637 ath10k_warn("failed to bring vdev up %d: %d\n",
2638 arvif->vdev_id, ret);
2643 if (ath10k_monitor_is_enabled(ar))
2644 ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
2647 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2649 struct ath10k *ar = hw->priv;
2650 struct ieee80211_conf *conf = &hw->conf;
2654 mutex_lock(&ar->conf_mutex);
2656 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2657 ath10k_dbg(ATH10K_DBG_MAC,
2658 "mac config channel %dMHz flags 0x%x radar %d\n",
2659 conf->chandef.chan->center_freq,
2660 conf->chandef.chan->flags,
2661 conf->radar_enabled);
2663 spin_lock_bh(&ar->data_lock);
2664 ar->rx_channel = conf->chandef.chan;
2665 spin_unlock_bh(&ar->data_lock);
2667 ar->radar_enabled = conf->radar_enabled;
2668 ath10k_recalc_radar_detection(ar);
2670 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2671 ar->chandef = conf->chandef;
2672 ath10k_config_chan(ar);
2676 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2677 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2678 hw->conf.power_level);
2680 param = ar->wmi.pdev_param->txpower_limit2g;
2681 ret = ath10k_wmi_pdev_set_param(ar, param,
2682 hw->conf.power_level * 2);
2684 ath10k_warn("failed to set 2g txpower %d: %d\n",
2685 hw->conf.power_level, ret);
2687 param = ar->wmi.pdev_param->txpower_limit5g;
2688 ret = ath10k_wmi_pdev_set_param(ar, param,
2689 hw->conf.power_level * 2);
2691 ath10k_warn("failed to set 5g txpower %d: %d\n",
2692 hw->conf.power_level, ret);
2695 if (changed & IEEE80211_CONF_CHANGE_PS)
2696 ath10k_config_ps(ar);
2698 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2699 if (conf->flags & IEEE80211_CONF_MONITOR && !ar->monitor) {
2701 ret = ath10k_monitor_start(ar);
2703 ath10k_warn("failed to start monitor (config): %d\n",
2705 ar->monitor = false;
2707 } else if (!(conf->flags & IEEE80211_CONF_MONITOR) &&
2709 ar->monitor = false;
2710 ath10k_monitor_stop(ar);
2714 mutex_unlock(&ar->conf_mutex);
2720 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2721 * because we will send mgmt frames without CCK. This requirement
2722 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2725 static int ath10k_add_interface(struct ieee80211_hw *hw,
2726 struct ieee80211_vif *vif)
2728 struct ath10k *ar = hw->priv;
2729 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2730 enum wmi_sta_powersave_param param;
2736 mutex_lock(&ar->conf_mutex);
2738 memset(arvif, 0, sizeof(*arvif));
2743 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2744 INIT_LIST_HEAD(&arvif->list);
2746 bit = ffs(ar->free_vdev_map);
2752 arvif->vdev_id = bit - 1;
2753 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2756 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2758 switch (vif->type) {
2759 case NL80211_IFTYPE_UNSPECIFIED:
2760 case NL80211_IFTYPE_STATION:
2761 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2763 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2765 case NL80211_IFTYPE_ADHOC:
2766 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2768 case NL80211_IFTYPE_AP:
2769 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2772 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2774 case NL80211_IFTYPE_MONITOR:
2775 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2782 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2783 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2785 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2786 arvif->vdev_subtype, vif->addr);
2788 ath10k_warn("failed to create WMI vdev %i: %d\n",
2789 arvif->vdev_id, ret);
2793 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2794 list_add(&arvif->list, &ar->arvifs);
2796 vdev_param = ar->wmi.vdev_param->def_keyid;
2797 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2798 arvif->def_wep_key_idx);
2800 ath10k_warn("failed to set vdev %i default key id: %d\n",
2801 arvif->vdev_id, ret);
2802 goto err_vdev_delete;
2805 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2806 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2807 ATH10K_HW_TXRX_NATIVE_WIFI);
2808 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2809 if (ret && ret != -EOPNOTSUPP) {
2810 ath10k_warn("failed to set vdev %i TX encapsulation: %d\n",
2811 arvif->vdev_id, ret);
2812 goto err_vdev_delete;
2815 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2816 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2818 ath10k_warn("failed to create vdev %i peer for AP: %d\n",
2819 arvif->vdev_id, ret);
2820 goto err_vdev_delete;
2823 ret = ath10k_mac_set_kickout(arvif);
2825 ath10k_warn("failed to set vdev %i kickout parameters: %d\n",
2826 arvif->vdev_id, ret);
2827 goto err_peer_delete;
2831 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2832 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2833 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2834 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2837 ath10k_warn("failed to set vdev %i RX wake policy: %d\n",
2838 arvif->vdev_id, ret);
2839 goto err_peer_delete;
2842 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2843 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2844 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2847 ath10k_warn("failed to set vdev %i TX wake thresh: %d\n",
2848 arvif->vdev_id, ret);
2849 goto err_peer_delete;
2852 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2853 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2854 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2857 ath10k_warn("failed to set vdev %i PSPOLL count: %d\n",
2858 arvif->vdev_id, ret);
2859 goto err_peer_delete;
2863 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2865 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
2866 arvif->vdev_id, ret);
2867 goto err_peer_delete;
2870 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2872 ath10k_warn("failed to set frag threshold for vdev %d: %d\n",
2873 arvif->vdev_id, ret);
2874 goto err_peer_delete;
2877 mutex_unlock(&ar->conf_mutex);
2881 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2882 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2885 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2886 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2887 list_del(&arvif->list);
2890 mutex_unlock(&ar->conf_mutex);
2895 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2896 struct ieee80211_vif *vif)
2898 struct ath10k *ar = hw->priv;
2899 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2902 mutex_lock(&ar->conf_mutex);
2904 cancel_work_sync(&arvif->wep_key_work);
2906 spin_lock_bh(&ar->data_lock);
2907 if (arvif->beacon) {
2908 dma_unmap_single(arvif->ar->dev,
2909 ATH10K_SKB_CB(arvif->beacon)->paddr,
2910 arvif->beacon->len, DMA_TO_DEVICE);
2911 dev_kfree_skb_any(arvif->beacon);
2912 arvif->beacon = NULL;
2915 spin_unlock_bh(&ar->data_lock);
2917 ret = ath10k_spectral_vif_stop(arvif);
2919 ath10k_warn("failed to stop spectral for vdev %i: %d\n",
2920 arvif->vdev_id, ret);
2922 ar->free_vdev_map |= 1 << (arvif->vdev_id);
2923 list_del(&arvif->list);
2925 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2926 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2928 ath10k_warn("failed to remove peer for AP vdev %i: %d\n",
2929 arvif->vdev_id, ret);
2931 kfree(arvif->u.ap.noa_data);
2934 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
2937 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2939 ath10k_warn("failed to delete WMI vdev %i: %d\n",
2940 arvif->vdev_id, ret);
2942 ath10k_peer_cleanup(ar, arvif->vdev_id);
2944 mutex_unlock(&ar->conf_mutex);
2948 * FIXME: Has to be verified.
2950 #define SUPPORTED_FILTERS \
2951 (FIF_PROMISC_IN_BSS | \
2956 FIF_BCN_PRBRESP_PROMISC | \
2960 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2961 unsigned int changed_flags,
2962 unsigned int *total_flags,
2965 struct ath10k *ar = hw->priv;
2968 mutex_lock(&ar->conf_mutex);
2970 changed_flags &= SUPPORTED_FILTERS;
2971 *total_flags &= SUPPORTED_FILTERS;
2972 ar->filter_flags = *total_flags;
2974 if (ar->filter_flags & FIF_PROMISC_IN_BSS && !ar->promisc) {
2976 ret = ath10k_monitor_start(ar);
2978 ath10k_warn("failed to start monitor (promisc): %d\n",
2980 ar->promisc = false;
2982 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && ar->promisc) {
2983 ar->promisc = false;
2984 ath10k_monitor_stop(ar);
2987 mutex_unlock(&ar->conf_mutex);
2990 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2991 struct ieee80211_vif *vif,
2992 struct ieee80211_bss_conf *info,
2995 struct ath10k *ar = hw->priv;
2996 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2998 u32 vdev_param, pdev_param;
3000 mutex_lock(&ar->conf_mutex);
3002 if (changed & BSS_CHANGED_IBSS)
3003 ath10k_control_ibss(arvif, info, vif->addr);
3005 if (changed & BSS_CHANGED_BEACON_INT) {
3006 arvif->beacon_interval = info->beacon_int;
3007 vdev_param = ar->wmi.vdev_param->beacon_interval;
3008 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3009 arvif->beacon_interval);
3010 ath10k_dbg(ATH10K_DBG_MAC,
3011 "mac vdev %d beacon_interval %d\n",
3012 arvif->vdev_id, arvif->beacon_interval);
3015 ath10k_warn("failed to set beacon interval for vdev %d: %i\n",
3016 arvif->vdev_id, ret);
3019 if (changed & BSS_CHANGED_BEACON) {
3020 ath10k_dbg(ATH10K_DBG_MAC,
3021 "vdev %d set beacon tx mode to staggered\n",
3024 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3025 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3026 WMI_BEACON_STAGGERED_MODE);
3028 ath10k_warn("failed to set beacon mode for vdev %d: %i\n",
3029 arvif->vdev_id, ret);
3032 if (changed & BSS_CHANGED_BEACON_INFO) {
3033 arvif->dtim_period = info->dtim_period;
3035 ath10k_dbg(ATH10K_DBG_MAC,
3036 "mac vdev %d dtim_period %d\n",
3037 arvif->vdev_id, arvif->dtim_period);
3039 vdev_param = ar->wmi.vdev_param->dtim_period;
3040 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3041 arvif->dtim_period);
3043 ath10k_warn("failed to set dtim period for vdev %d: %i\n",
3044 arvif->vdev_id, ret);
3047 if (changed & BSS_CHANGED_SSID &&
3048 vif->type == NL80211_IFTYPE_AP) {
3049 arvif->u.ap.ssid_len = info->ssid_len;
3051 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3052 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3056 * Firmware manages AP self-peer internally so make sure to not create
3057 * it in driver. Otherwise AP self-peer deletion may timeout later.
3059 if (changed & BSS_CHANGED_BSSID &&
3060 vif->type != NL80211_IFTYPE_AP) {
3061 if (!is_zero_ether_addr(info->bssid)) {
3062 ath10k_dbg(ATH10K_DBG_MAC,
3063 "mac vdev %d create peer %pM\n",
3064 arvif->vdev_id, info->bssid);
3066 ret = ath10k_peer_create(ar, arvif->vdev_id,
3069 ath10k_warn("failed to add peer %pM for vdev %d when changing bssid: %i\n",
3070 info->bssid, arvif->vdev_id, ret);
3072 if (vif->type == NL80211_IFTYPE_STATION) {
3074 * this is never erased as we it for crypto key
3075 * clearing; this is FW requirement
3077 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
3079 ath10k_dbg(ATH10K_DBG_MAC,
3080 "mac vdev %d start %pM\n",
3081 arvif->vdev_id, info->bssid);
3083 ret = ath10k_vdev_start(arvif);
3085 ath10k_warn("failed to start vdev %i: %d\n",
3086 arvif->vdev_id, ret);
3090 arvif->is_started = true;
3094 * Mac80211 does not keep IBSS bssid when leaving IBSS,
3095 * so driver need to store it. It is needed when leaving
3096 * IBSS in order to remove BSSID peer.
3098 if (vif->type == NL80211_IFTYPE_ADHOC)
3099 memcpy(arvif->bssid, info->bssid,
3104 if (changed & BSS_CHANGED_BEACON_ENABLED)
3105 ath10k_control_beaconing(arvif, info);
3107 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3108 arvif->use_cts_prot = info->use_cts_prot;
3109 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3110 arvif->vdev_id, info->use_cts_prot);
3112 ret = ath10k_recalc_rtscts_prot(arvif);
3114 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
3115 arvif->vdev_id, ret);
3118 if (changed & BSS_CHANGED_ERP_SLOT) {
3120 if (info->use_short_slot)
3121 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3124 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3126 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3127 arvif->vdev_id, slottime);
3129 vdev_param = ar->wmi.vdev_param->slot_time;
3130 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3133 ath10k_warn("failed to set erp slot for vdev %d: %i\n",
3134 arvif->vdev_id, ret);
3137 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3139 if (info->use_short_preamble)
3140 preamble = WMI_VDEV_PREAMBLE_SHORT;
3142 preamble = WMI_VDEV_PREAMBLE_LONG;
3144 ath10k_dbg(ATH10K_DBG_MAC,
3145 "mac vdev %d preamble %dn",
3146 arvif->vdev_id, preamble);
3148 vdev_param = ar->wmi.vdev_param->preamble;
3149 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3152 ath10k_warn("failed to set preamble for vdev %d: %i\n",
3153 arvif->vdev_id, ret);
3156 if (changed & BSS_CHANGED_ASSOC) {
3158 ath10k_bss_assoc(hw, vif, info);
3162 mutex_unlock(&ar->conf_mutex);
3165 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3166 struct ieee80211_vif *vif,
3167 struct ieee80211_scan_request *hw_req)
3169 struct ath10k *ar = hw->priv;
3170 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3171 struct cfg80211_scan_request *req = &hw_req->req;
3172 struct wmi_start_scan_arg arg;
3176 mutex_lock(&ar->conf_mutex);
3178 spin_lock_bh(&ar->data_lock);
3179 if (ar->scan.in_progress) {
3180 spin_unlock_bh(&ar->data_lock);
3185 reinit_completion(&ar->scan.started);
3186 reinit_completion(&ar->scan.completed);
3187 ar->scan.in_progress = true;
3188 ar->scan.aborting = false;
3189 ar->scan.is_roc = false;
3190 ar->scan.vdev_id = arvif->vdev_id;
3191 spin_unlock_bh(&ar->data_lock);
3193 memset(&arg, 0, sizeof(arg));
3194 ath10k_wmi_start_scan_init(ar, &arg);
3195 arg.vdev_id = arvif->vdev_id;
3196 arg.scan_id = ATH10K_SCAN_ID;
3199 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3202 arg.ie_len = req->ie_len;
3203 memcpy(arg.ie, req->ie, arg.ie_len);
3207 arg.n_ssids = req->n_ssids;
3208 for (i = 0; i < arg.n_ssids; i++) {
3209 arg.ssids[i].len = req->ssids[i].ssid_len;
3210 arg.ssids[i].ssid = req->ssids[i].ssid;
3213 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3216 if (req->n_channels) {
3217 arg.n_channels = req->n_channels;
3218 for (i = 0; i < arg.n_channels; i++)
3219 arg.channels[i] = req->channels[i]->center_freq;
3222 ret = ath10k_start_scan(ar, &arg);
3224 ath10k_warn("failed to start hw scan: %d\n", ret);
3225 spin_lock_bh(&ar->data_lock);
3226 ar->scan.in_progress = false;
3227 spin_unlock_bh(&ar->data_lock);
3231 mutex_unlock(&ar->conf_mutex);
3235 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3236 struct ieee80211_vif *vif)
3238 struct ath10k *ar = hw->priv;
3241 mutex_lock(&ar->conf_mutex);
3242 ret = ath10k_abort_scan(ar);
3244 ath10k_warn("failed to abort scan: %d\n", ret);
3245 ieee80211_scan_completed(hw, 1 /* aborted */);
3247 mutex_unlock(&ar->conf_mutex);
3250 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3251 struct ath10k_vif *arvif,
3252 enum set_key_cmd cmd,
3253 struct ieee80211_key_conf *key)
3255 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3258 /* 10.1 firmware branch requires default key index to be set to group
3259 * key index after installing it. Otherwise FW/HW Txes corrupted
3260 * frames with multi-vif APs. This is not required for main firmware
3261 * branch (e.g. 636).
3263 * FIXME: This has been tested only in AP. It remains unknown if this
3264 * is required for multi-vif STA interfaces on 10.1 */
3266 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3269 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3272 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3275 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3281 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3284 ath10k_warn("failed to set vdev %i group key as default key: %d\n",
3285 arvif->vdev_id, ret);
3288 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3289 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3290 struct ieee80211_key_conf *key)
3292 struct ath10k *ar = hw->priv;
3293 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3294 struct ath10k_peer *peer;
3295 const u8 *peer_addr;
3296 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3297 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3300 if (key->keyidx > WMI_MAX_KEY_INDEX)
3303 mutex_lock(&ar->conf_mutex);
3306 peer_addr = sta->addr;
3307 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3308 peer_addr = vif->bss_conf.bssid;
3310 peer_addr = vif->addr;
3312 key->hw_key_idx = key->keyidx;
3314 /* the peer should not disappear in mid-way (unless FW goes awry) since
3315 * we already hold conf_mutex. we just make sure its there now. */
3316 spin_lock_bh(&ar->data_lock);
3317 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3318 spin_unlock_bh(&ar->data_lock);
3321 if (cmd == SET_KEY) {
3322 ath10k_warn("failed to install key for non-existent peer %pM\n",
3327 /* if the peer doesn't exist there is no key to disable
3335 arvif->wep_keys[key->keyidx] = key;
3337 arvif->wep_keys[key->keyidx] = NULL;
3339 if (cmd == DISABLE_KEY)
3340 ath10k_clear_vdev_key(arvif, key);
3343 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3345 ath10k_warn("failed to install key for vdev %i peer %pM: %d\n",
3346 arvif->vdev_id, peer_addr, ret);
3350 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3352 spin_lock_bh(&ar->data_lock);
3353 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3354 if (peer && cmd == SET_KEY)
3355 peer->keys[key->keyidx] = key;
3356 else if (peer && cmd == DISABLE_KEY)
3357 peer->keys[key->keyidx] = NULL;
3358 else if (peer == NULL)
3359 /* impossible unless FW goes crazy */
3360 ath10k_warn("Peer %pM disappeared!\n", peer_addr);
3361 spin_unlock_bh(&ar->data_lock);
3364 mutex_unlock(&ar->conf_mutex);
3368 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3371 struct ath10k_vif *arvif;
3372 struct ath10k_sta *arsta;
3373 struct ieee80211_sta *sta;
3374 u32 changed, bw, nss, smps;
3377 arsta = container_of(wk, struct ath10k_sta, update_wk);
3378 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3379 arvif = arsta->arvif;
3382 spin_lock_bh(&ar->data_lock);
3384 changed = arsta->changed;
3391 spin_unlock_bh(&ar->data_lock);
3393 mutex_lock(&ar->conf_mutex);
3395 if (changed & IEEE80211_RC_BW_CHANGED) {
3396 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3399 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3400 WMI_PEER_CHAN_WIDTH, bw);
3402 ath10k_warn("failed to update STA %pM peer bw %d: %d\n",
3403 sta->addr, bw, err);
3406 if (changed & IEEE80211_RC_NSS_CHANGED) {
3407 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3410 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3413 ath10k_warn("failed to update STA %pM nss %d: %d\n",
3414 sta->addr, nss, err);
3417 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3418 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3421 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3422 WMI_PEER_SMPS_STATE, smps);
3424 ath10k_warn("failed to update STA %pM smps %d: %d\n",
3425 sta->addr, smps, err);
3428 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3429 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3432 err = ath10k_station_assoc(ar, arvif, sta, true);
3434 ath10k_warn("failed to reassociate station: %pM\n",
3438 mutex_unlock(&ar->conf_mutex);
3441 static int ath10k_sta_state(struct ieee80211_hw *hw,
3442 struct ieee80211_vif *vif,
3443 struct ieee80211_sta *sta,
3444 enum ieee80211_sta_state old_state,
3445 enum ieee80211_sta_state new_state)
3447 struct ath10k *ar = hw->priv;
3448 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3449 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3453 if (old_state == IEEE80211_STA_NOTEXIST &&
3454 new_state == IEEE80211_STA_NONE) {
3455 memset(arsta, 0, sizeof(*arsta));
3456 arsta->arvif = arvif;
3457 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3460 /* cancel must be done outside the mutex to avoid deadlock */
3461 if ((old_state == IEEE80211_STA_NONE &&
3462 new_state == IEEE80211_STA_NOTEXIST))
3463 cancel_work_sync(&arsta->update_wk);
3465 mutex_lock(&ar->conf_mutex);
3467 if (old_state == IEEE80211_STA_NOTEXIST &&
3468 new_state == IEEE80211_STA_NONE &&
3469 vif->type != NL80211_IFTYPE_STATION) {
3471 * New station addition.
3473 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3474 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3476 max_num_peers = TARGET_NUM_PEERS;
3478 if (ar->num_peers >= max_num_peers) {
3479 ath10k_warn("number of peers exceeded: peers number %d (max peers %d)\n",
3480 ar->num_peers, max_num_peers);
3485 ath10k_dbg(ATH10K_DBG_MAC,
3486 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3487 arvif->vdev_id, sta->addr, ar->num_peers);
3489 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3491 ath10k_warn("failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3492 sta->addr, arvif->vdev_id, ret);
3493 } else if ((old_state == IEEE80211_STA_NONE &&
3494 new_state == IEEE80211_STA_NOTEXIST)) {
3496 * Existing station deletion.
3498 ath10k_dbg(ATH10K_DBG_MAC,
3499 "mac vdev %d peer delete %pM (sta gone)\n",
3500 arvif->vdev_id, sta->addr);
3501 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3503 ath10k_warn("failed to delete peer %pM for vdev %d: %i\n",
3504 sta->addr, arvif->vdev_id, ret);
3506 if (vif->type == NL80211_IFTYPE_STATION)
3507 ath10k_bss_disassoc(hw, vif);
3508 } else if (old_state == IEEE80211_STA_AUTH &&
3509 new_state == IEEE80211_STA_ASSOC &&
3510 (vif->type == NL80211_IFTYPE_AP ||
3511 vif->type == NL80211_IFTYPE_ADHOC)) {
3515 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
3518 ret = ath10k_station_assoc(ar, arvif, sta, false);
3520 ath10k_warn("failed to associate station %pM for vdev %i: %i\n",
3521 sta->addr, arvif->vdev_id, ret);
3522 } else if (old_state == IEEE80211_STA_ASSOC &&
3523 new_state == IEEE80211_STA_AUTH &&
3524 (vif->type == NL80211_IFTYPE_AP ||
3525 vif->type == NL80211_IFTYPE_ADHOC)) {
3529 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3532 ret = ath10k_station_disassoc(ar, arvif, sta);
3534 ath10k_warn("failed to disassociate station: %pM vdev %i: %i\n",
3535 sta->addr, arvif->vdev_id, ret);
3538 mutex_unlock(&ar->conf_mutex);
3542 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3543 u16 ac, bool enable)
3545 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3549 lockdep_assert_held(&ar->conf_mutex);
3551 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3555 case IEEE80211_AC_VO:
3556 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3557 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3559 case IEEE80211_AC_VI:
3560 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3561 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3563 case IEEE80211_AC_BE:
3564 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3565 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3567 case IEEE80211_AC_BK:
3568 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3569 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3574 arvif->u.sta.uapsd |= value;
3576 arvif->u.sta.uapsd &= ~value;
3578 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3579 WMI_STA_PS_PARAM_UAPSD,
3580 arvif->u.sta.uapsd);
3582 ath10k_warn("failed to set uapsd params: %d\n", ret);
3586 if (arvif->u.sta.uapsd)
3587 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3589 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3591 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3592 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3595 ath10k_warn("failed to set rx wake param: %d\n", ret);
3601 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3602 struct ieee80211_vif *vif, u16 ac,
3603 const struct ieee80211_tx_queue_params *params)
3605 struct ath10k *ar = hw->priv;
3606 struct wmi_wmm_params_arg *p = NULL;
3609 mutex_lock(&ar->conf_mutex);
3612 case IEEE80211_AC_VO:
3613 p = &ar->wmm_params.ac_vo;
3615 case IEEE80211_AC_VI:
3616 p = &ar->wmm_params.ac_vi;
3618 case IEEE80211_AC_BE:
3619 p = &ar->wmm_params.ac_be;
3621 case IEEE80211_AC_BK:
3622 p = &ar->wmm_params.ac_bk;
3631 p->cwmin = params->cw_min;
3632 p->cwmax = params->cw_max;
3633 p->aifs = params->aifs;
3636 * The channel time duration programmed in the HW is in absolute
3637 * microseconds, while mac80211 gives the txop in units of
3640 p->txop = params->txop * 32;
3642 /* FIXME: FW accepts wmm params per hw, not per vif */
3643 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3645 ath10k_warn("failed to set wmm params: %d\n", ret);
3649 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3651 ath10k_warn("failed to set sta uapsd: %d\n", ret);
3654 mutex_unlock(&ar->conf_mutex);
3658 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3660 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3661 struct ieee80211_vif *vif,
3662 struct ieee80211_channel *chan,
3664 enum ieee80211_roc_type type)
3666 struct ath10k *ar = hw->priv;
3667 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3668 struct wmi_start_scan_arg arg;
3671 mutex_lock(&ar->conf_mutex);
3673 spin_lock_bh(&ar->data_lock);
3674 if (ar->scan.in_progress) {
3675 spin_unlock_bh(&ar->data_lock);
3680 reinit_completion(&ar->scan.started);
3681 reinit_completion(&ar->scan.completed);
3682 reinit_completion(&ar->scan.on_channel);
3683 ar->scan.in_progress = true;
3684 ar->scan.aborting = false;
3685 ar->scan.is_roc = true;
3686 ar->scan.vdev_id = arvif->vdev_id;
3687 ar->scan.roc_freq = chan->center_freq;
3688 spin_unlock_bh(&ar->data_lock);
3690 memset(&arg, 0, sizeof(arg));
3691 ath10k_wmi_start_scan_init(ar, &arg);
3692 arg.vdev_id = arvif->vdev_id;
3693 arg.scan_id = ATH10K_SCAN_ID;
3695 arg.channels[0] = chan->center_freq;
3696 arg.dwell_time_active = duration;
3697 arg.dwell_time_passive = duration;
3698 arg.max_scan_time = 2 * duration;
3699 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3700 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3702 ret = ath10k_start_scan(ar, &arg);
3704 ath10k_warn("failed to start roc scan: %d\n", ret);
3705 spin_lock_bh(&ar->data_lock);
3706 ar->scan.in_progress = false;
3707 spin_unlock_bh(&ar->data_lock);
3711 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3713 ath10k_warn("failed to switch to channel for roc scan\n");
3714 ath10k_abort_scan(ar);
3721 mutex_unlock(&ar->conf_mutex);
3725 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3727 struct ath10k *ar = hw->priv;
3729 mutex_lock(&ar->conf_mutex);
3730 ath10k_abort_scan(ar);
3731 mutex_unlock(&ar->conf_mutex);
3737 * Both RTS and Fragmentation threshold are interface-specific
3738 * in ath10k, but device-specific in mac80211.
3741 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3743 struct ath10k *ar = hw->priv;
3744 struct ath10k_vif *arvif;
3747 mutex_lock(&ar->conf_mutex);
3748 list_for_each_entry(arvif, &ar->arvifs, list) {
3749 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3750 arvif->vdev_id, value);
3752 ret = ath10k_mac_set_rts(arvif, value);
3754 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
3755 arvif->vdev_id, ret);
3759 mutex_unlock(&ar->conf_mutex);
3764 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3766 struct ath10k *ar = hw->priv;
3767 struct ath10k_vif *arvif;
3770 mutex_lock(&ar->conf_mutex);
3771 list_for_each_entry(arvif, &ar->arvifs, list) {
3772 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3773 arvif->vdev_id, value);
3775 ret = ath10k_mac_set_rts(arvif, value);
3777 ath10k_warn("failed to set fragmentation threshold for vdev %d: %d\n",
3778 arvif->vdev_id, ret);
3782 mutex_unlock(&ar->conf_mutex);
3787 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3788 u32 queues, bool drop)
3790 struct ath10k *ar = hw->priv;
3794 /* mac80211 doesn't care if we really xmit queued frames or not
3795 * we'll collect those frames either way if we stop/delete vdevs */
3799 mutex_lock(&ar->conf_mutex);
3801 if (ar->state == ATH10K_STATE_WEDGED)
3804 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3807 spin_lock_bh(&ar->htt.tx_lock);
3808 empty = (ar->htt.num_pending_tx == 0);
3809 spin_unlock_bh(&ar->htt.tx_lock);
3811 skip = (ar->state == ATH10K_STATE_WEDGED);
3814 }), ATH10K_FLUSH_TIMEOUT_HZ);
3816 if (ret <= 0 || skip)
3817 ath10k_warn("failed to flush transmit queue (skip %i ar-state %i): %i\n",
3818 skip, ar->state, ret);
3821 mutex_unlock(&ar->conf_mutex);
3824 /* TODO: Implement this function properly
3825 * For now it is needed to reply to Probe Requests in IBSS mode.
3826 * Propably we need this information from FW.
3828 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3834 static int ath10k_suspend(struct ieee80211_hw *hw,
3835 struct cfg80211_wowlan *wowlan)
3837 struct ath10k *ar = hw->priv;
3840 mutex_lock(&ar->conf_mutex);
3842 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
3844 if (ret == -ETIMEDOUT)
3850 ret = ath10k_hif_suspend(ar);
3852 ath10k_warn("failed to suspend hif: %d\n", ret);
3859 ret = ath10k_wmi_pdev_resume_target(ar);
3861 ath10k_warn("failed to resume target: %d\n", ret);
3865 mutex_unlock(&ar->conf_mutex);
3869 static int ath10k_resume(struct ieee80211_hw *hw)
3871 struct ath10k *ar = hw->priv;
3874 mutex_lock(&ar->conf_mutex);
3876 ret = ath10k_hif_resume(ar);
3878 ath10k_warn("failed to resume hif: %d\n", ret);
3883 ret = ath10k_wmi_pdev_resume_target(ar);
3885 ath10k_warn("failed to resume target: %d\n", ret);
3892 mutex_unlock(&ar->conf_mutex);
3897 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3899 struct ath10k *ar = hw->priv;
3901 mutex_lock(&ar->conf_mutex);
3903 /* If device failed to restart it will be in a different state, e.g.
3904 * ATH10K_STATE_WEDGED */
3905 if (ar->state == ATH10K_STATE_RESTARTED) {
3906 ath10k_info("device successfully recovered\n");
3907 ar->state = ATH10K_STATE_ON;
3910 mutex_unlock(&ar->conf_mutex);
3913 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3914 struct survey_info *survey)
3916 struct ath10k *ar = hw->priv;
3917 struct ieee80211_supported_band *sband;
3918 struct survey_info *ar_survey = &ar->survey[idx];
3921 mutex_lock(&ar->conf_mutex);
3923 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3924 if (sband && idx >= sband->n_channels) {
3925 idx -= sband->n_channels;
3930 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3932 if (!sband || idx >= sband->n_channels) {
3937 spin_lock_bh(&ar->data_lock);
3938 memcpy(survey, ar_survey, sizeof(*survey));
3939 spin_unlock_bh(&ar->data_lock);
3941 survey->channel = &sband->channels[idx];
3944 mutex_unlock(&ar->conf_mutex);
3948 /* Helper table for legacy fixed_rate/bitrate_mask */
3949 static const u8 cck_ofdm_rate[] = {
3966 /* Check if only one bit set */
3967 static int ath10k_check_single_mask(u32 mask)
3975 mask &= ~BIT(bit - 1);
3983 ath10k_default_bitrate_mask(struct ath10k *ar,
3984 enum ieee80211_band band,
3985 const struct cfg80211_bitrate_mask *mask)
3987 u32 legacy = 0x00ff;
3992 case IEEE80211_BAND_2GHZ:
3996 case IEEE80211_BAND_5GHZ:
4002 if (mask->control[band].legacy != legacy)
4005 for (i = 0; i < ar->num_rf_chains; i++)
4006 if (mask->control[band].ht_mcs[i] != ht)
4009 for (i = 0; i < ar->num_rf_chains; i++)
4010 if (mask->control[band].vht_mcs[i] != vht)
4017 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4018 enum ieee80211_band band,
4021 int ht_nss = 0, vht_nss = 0, i;
4024 if (ath10k_check_single_mask(mask->control[band].legacy))
4028 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4029 if (mask->control[band].ht_mcs[i] == 0xff)
4031 else if (mask->control[band].ht_mcs[i] == 0x00)
4040 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4041 if (mask->control[band].vht_mcs[i] == 0x03ff)
4043 else if (mask->control[band].vht_mcs[i] == 0x0000)
4051 if (ht_nss > 0 && vht_nss > 0)
4055 *fixed_nss = ht_nss;
4057 *fixed_nss = vht_nss;
4065 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4066 enum ieee80211_band band,
4067 enum wmi_rate_preamble *preamble)
4069 int legacy = 0, ht = 0, vht = 0, i;
4071 *preamble = WMI_RATE_PREAMBLE_OFDM;
4074 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4079 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4080 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4085 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4086 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4090 /* Currently we support only one fixed_rate */
4091 if ((legacy + ht + vht) != 1)
4095 *preamble = WMI_RATE_PREAMBLE_HT;
4097 *preamble = WMI_RATE_PREAMBLE_VHT;
4103 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
4104 enum ieee80211_band band,
4108 u8 rate = 0, pream = 0, nss = 0, i;
4109 enum wmi_rate_preamble preamble;
4111 /* Check if single rate correct */
4112 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4118 case WMI_RATE_PREAMBLE_CCK:
4119 case WMI_RATE_PREAMBLE_OFDM:
4120 i = ffs(mask->control[band].legacy) - 1;
4122 if (band == IEEE80211_BAND_2GHZ && i < 4)
4123 pream = WMI_RATE_PREAMBLE_CCK;
4125 if (band == IEEE80211_BAND_5GHZ)
4128 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4131 rate = cck_ofdm_rate[i];
4133 case WMI_RATE_PREAMBLE_HT:
4134 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4135 if (mask->control[band].ht_mcs[i])
4138 if (i == IEEE80211_HT_MCS_MASK_LEN)
4141 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4144 case WMI_RATE_PREAMBLE_VHT:
4145 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4146 if (mask->control[band].vht_mcs[i])
4149 if (i == NL80211_VHT_NSS_MAX)
4152 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4157 *fixed_nss = nss + 1;
4161 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4164 *fixed_rate = pream | nss | rate;
4169 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
4170 enum ieee80211_band band,
4174 /* First check full NSS mask, if we can simply limit NSS */
4175 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4178 /* Next Check single rate is set */
4179 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
4182 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4187 struct ath10k *ar = arvif->ar;
4191 mutex_lock(&ar->conf_mutex);
4193 if (arvif->fixed_rate == fixed_rate &&
4194 arvif->fixed_nss == fixed_nss &&
4195 arvif->force_sgi == force_sgi)
4198 if (fixed_rate == WMI_FIXED_RATE_NONE)
4199 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4202 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n");
4204 vdev_param = ar->wmi.vdev_param->fixed_rate;
4205 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4206 vdev_param, fixed_rate);
4208 ath10k_warn("failed to set fixed rate param 0x%02x: %d\n",
4214 arvif->fixed_rate = fixed_rate;
4216 vdev_param = ar->wmi.vdev_param->nss;
4217 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4218 vdev_param, fixed_nss);
4221 ath10k_warn("failed to set fixed nss param %d: %d\n",
4227 arvif->fixed_nss = fixed_nss;
4229 vdev_param = ar->wmi.vdev_param->sgi;
4230 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4234 ath10k_warn("failed to set sgi param %d: %d\n",
4240 arvif->force_sgi = force_sgi;
4243 mutex_unlock(&ar->conf_mutex);
4247 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4248 struct ieee80211_vif *vif,
4249 const struct cfg80211_bitrate_mask *mask)
4251 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4252 struct ath10k *ar = arvif->ar;
4253 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4254 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4255 u8 fixed_nss = ar->num_rf_chains;
4258 force_sgi = mask->control[band].gi;
4259 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4262 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4263 if (!ath10k_get_fixed_rate_nss(mask, band,
4269 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4270 ath10k_warn("failed to force SGI usage for default rate settings\n");
4274 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4275 fixed_nss, force_sgi);
4278 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4279 struct ieee80211_vif *vif,
4280 struct ieee80211_sta *sta,
4283 struct ath10k *ar = hw->priv;
4284 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4287 spin_lock_bh(&ar->data_lock);
4289 ath10k_dbg(ATH10K_DBG_MAC,
4290 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4291 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4294 if (changed & IEEE80211_RC_BW_CHANGED) {
4295 bw = WMI_PEER_CHWIDTH_20MHZ;
4297 switch (sta->bandwidth) {
4298 case IEEE80211_STA_RX_BW_20:
4299 bw = WMI_PEER_CHWIDTH_20MHZ;
4301 case IEEE80211_STA_RX_BW_40:
4302 bw = WMI_PEER_CHWIDTH_40MHZ;
4304 case IEEE80211_STA_RX_BW_80:
4305 bw = WMI_PEER_CHWIDTH_80MHZ;
4307 case IEEE80211_STA_RX_BW_160:
4308 ath10k_warn("Invalid bandwith %d in rc update for %pM\n",
4309 sta->bandwidth, sta->addr);
4310 bw = WMI_PEER_CHWIDTH_20MHZ;
4317 if (changed & IEEE80211_RC_NSS_CHANGED)
4318 arsta->nss = sta->rx_nss;
4320 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4321 smps = WMI_PEER_SMPS_PS_NONE;
4323 switch (sta->smps_mode) {
4324 case IEEE80211_SMPS_AUTOMATIC:
4325 case IEEE80211_SMPS_OFF:
4326 smps = WMI_PEER_SMPS_PS_NONE;
4328 case IEEE80211_SMPS_STATIC:
4329 smps = WMI_PEER_SMPS_STATIC;
4331 case IEEE80211_SMPS_DYNAMIC:
4332 smps = WMI_PEER_SMPS_DYNAMIC;
4334 case IEEE80211_SMPS_NUM_MODES:
4335 ath10k_warn("Invalid smps %d in sta rc update for %pM\n",
4336 sta->smps_mode, sta->addr);
4337 smps = WMI_PEER_SMPS_PS_NONE;
4344 arsta->changed |= changed;
4346 spin_unlock_bh(&ar->data_lock);
4348 ieee80211_queue_work(hw, &arsta->update_wk);
4351 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4354 * FIXME: Return 0 for time being. Need to figure out whether FW
4355 * has the API to fetch 64-bit local TSF
4361 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4362 struct ieee80211_vif *vif,
4363 enum ieee80211_ampdu_mlme_action action,
4364 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4367 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4369 ath10k_dbg(ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4370 arvif->vdev_id, sta->addr, tid, action);
4373 case IEEE80211_AMPDU_RX_START:
4374 case IEEE80211_AMPDU_RX_STOP:
4375 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4376 * creation/removal. Do we need to verify this?
4379 case IEEE80211_AMPDU_TX_START:
4380 case IEEE80211_AMPDU_TX_STOP_CONT:
4381 case IEEE80211_AMPDU_TX_STOP_FLUSH:
4382 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4383 case IEEE80211_AMPDU_TX_OPERATIONAL:
4384 /* Firmware offloads Tx aggregation entirely so deny mac80211
4385 * Tx aggregation requests.
4393 static const struct ieee80211_ops ath10k_ops = {
4395 .start = ath10k_start,
4396 .stop = ath10k_stop,
4397 .config = ath10k_config,
4398 .add_interface = ath10k_add_interface,
4399 .remove_interface = ath10k_remove_interface,
4400 .configure_filter = ath10k_configure_filter,
4401 .bss_info_changed = ath10k_bss_info_changed,
4402 .hw_scan = ath10k_hw_scan,
4403 .cancel_hw_scan = ath10k_cancel_hw_scan,
4404 .set_key = ath10k_set_key,
4405 .sta_state = ath10k_sta_state,
4406 .conf_tx = ath10k_conf_tx,
4407 .remain_on_channel = ath10k_remain_on_channel,
4408 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4409 .set_rts_threshold = ath10k_set_rts_threshold,
4410 .set_frag_threshold = ath10k_set_frag_threshold,
4411 .flush = ath10k_flush,
4412 .tx_last_beacon = ath10k_tx_last_beacon,
4413 .set_antenna = ath10k_set_antenna,
4414 .get_antenna = ath10k_get_antenna,
4415 .restart_complete = ath10k_restart_complete,
4416 .get_survey = ath10k_get_survey,
4417 .set_bitrate_mask = ath10k_set_bitrate_mask,
4418 .sta_rc_update = ath10k_sta_rc_update,
4419 .get_tsf = ath10k_get_tsf,
4420 .ampdu_action = ath10k_ampdu_action,
4422 .suspend = ath10k_suspend,
4423 .resume = ath10k_resume,
4427 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4428 .bitrate = (_rate), \
4429 .flags = (_flags), \
4430 .hw_value = (_rateid), \
4433 #define CHAN2G(_channel, _freq, _flags) { \
4434 .band = IEEE80211_BAND_2GHZ, \
4435 .hw_value = (_channel), \
4436 .center_freq = (_freq), \
4437 .flags = (_flags), \
4438 .max_antenna_gain = 0, \
4442 #define CHAN5G(_channel, _freq, _flags) { \
4443 .band = IEEE80211_BAND_5GHZ, \
4444 .hw_value = (_channel), \
4445 .center_freq = (_freq), \
4446 .flags = (_flags), \
4447 .max_antenna_gain = 0, \
4451 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4461 CHAN2G(10, 2457, 0),
4462 CHAN2G(11, 2462, 0),
4463 CHAN2G(12, 2467, 0),
4464 CHAN2G(13, 2472, 0),
4465 CHAN2G(14, 2484, 0),
4468 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4469 CHAN5G(36, 5180, 0),
4470 CHAN5G(40, 5200, 0),
4471 CHAN5G(44, 5220, 0),
4472 CHAN5G(48, 5240, 0),
4473 CHAN5G(52, 5260, 0),
4474 CHAN5G(56, 5280, 0),
4475 CHAN5G(60, 5300, 0),
4476 CHAN5G(64, 5320, 0),
4477 CHAN5G(100, 5500, 0),
4478 CHAN5G(104, 5520, 0),
4479 CHAN5G(108, 5540, 0),
4480 CHAN5G(112, 5560, 0),
4481 CHAN5G(116, 5580, 0),
4482 CHAN5G(120, 5600, 0),
4483 CHAN5G(124, 5620, 0),
4484 CHAN5G(128, 5640, 0),
4485 CHAN5G(132, 5660, 0),
4486 CHAN5G(136, 5680, 0),
4487 CHAN5G(140, 5700, 0),
4488 CHAN5G(149, 5745, 0),
4489 CHAN5G(153, 5765, 0),
4490 CHAN5G(157, 5785, 0),
4491 CHAN5G(161, 5805, 0),
4492 CHAN5G(165, 5825, 0),
4495 static struct ieee80211_rate ath10k_rates[] = {
4497 RATETAB_ENT(10, 0x82, 0),
4498 RATETAB_ENT(20, 0x84, 0),
4499 RATETAB_ENT(55, 0x8b, 0),
4500 RATETAB_ENT(110, 0x96, 0),
4502 RATETAB_ENT(60, 0x0c, 0),
4503 RATETAB_ENT(90, 0x12, 0),
4504 RATETAB_ENT(120, 0x18, 0),
4505 RATETAB_ENT(180, 0x24, 0),
4506 RATETAB_ENT(240, 0x30, 0),
4507 RATETAB_ENT(360, 0x48, 0),
4508 RATETAB_ENT(480, 0x60, 0),
4509 RATETAB_ENT(540, 0x6c, 0),
4512 #define ath10k_a_rates (ath10k_rates + 4)
4513 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4514 #define ath10k_g_rates (ath10k_rates + 0)
4515 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4517 struct ath10k *ath10k_mac_create(void)
4519 struct ieee80211_hw *hw;
4522 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
4532 void ath10k_mac_destroy(struct ath10k *ar)
4534 ieee80211_free_hw(ar->hw);
4537 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4540 .types = BIT(NL80211_IFTYPE_STATION)
4541 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4545 .types = BIT(NL80211_IFTYPE_P2P_GO)
4549 .types = BIT(NL80211_IFTYPE_AP)
4553 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4556 .types = BIT(NL80211_IFTYPE_AP)
4560 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4562 .limits = ath10k_if_limits,
4563 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4564 .max_interfaces = 8,
4565 .num_different_channels = 1,
4566 .beacon_int_infra_match = true,
4570 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4572 .limits = ath10k_10x_if_limits,
4573 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4574 .max_interfaces = 8,
4575 .num_different_channels = 1,
4576 .beacon_int_infra_match = true,
4577 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4578 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4579 BIT(NL80211_CHAN_WIDTH_20) |
4580 BIT(NL80211_CHAN_WIDTH_40) |
4581 BIT(NL80211_CHAN_WIDTH_80),
4586 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4588 struct ieee80211_sta_vht_cap vht_cap = {0};
4592 vht_cap.vht_supported = 1;
4593 vht_cap.cap = ar->vht_cap_info;
4596 for (i = 0; i < 8; i++) {
4597 if (i < ar->num_rf_chains)
4598 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4600 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4603 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4604 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4609 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4612 struct ieee80211_sta_ht_cap ht_cap = {0};
4614 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4617 ht_cap.ht_supported = 1;
4618 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4619 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4620 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4621 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4622 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4624 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4625 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4627 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4628 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4630 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4633 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4634 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4639 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4640 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4642 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4645 stbc = ar->ht_cap_info;
4646 stbc &= WMI_HT_CAP_RX_STBC;
4647 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4648 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4649 stbc &= IEEE80211_HT_CAP_RX_STBC;
4654 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4655 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4657 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4658 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4660 /* max AMSDU is implicitly taken from vht_cap_info */
4661 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4662 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4664 for (i = 0; i < ar->num_rf_chains; i++)
4665 ht_cap.mcs.rx_mask[i] = 0xFF;
4667 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4673 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4674 struct ieee80211_vif *vif)
4676 struct ath10k_vif_iter *arvif_iter = data;
4677 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4679 if (arvif->vdev_id == arvif_iter->vdev_id)
4680 arvif_iter->arvif = arvif;
4683 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4685 struct ath10k_vif_iter arvif_iter;
4688 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4689 arvif_iter.vdev_id = vdev_id;
4691 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4692 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4694 ath10k_get_arvif_iter,
4696 if (!arvif_iter.arvif) {
4697 ath10k_warn("No VIF found for vdev %d\n", vdev_id);
4701 return arvif_iter.arvif;
4704 int ath10k_mac_register(struct ath10k *ar)
4706 struct ieee80211_supported_band *band;
4707 struct ieee80211_sta_vht_cap vht_cap;
4708 struct ieee80211_sta_ht_cap ht_cap;
4712 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4714 SET_IEEE80211_DEV(ar->hw, ar->dev);
4716 ht_cap = ath10k_get_ht_cap(ar);
4717 vht_cap = ath10k_create_vht_cap(ar);
4719 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4720 channels = kmemdup(ath10k_2ghz_channels,
4721 sizeof(ath10k_2ghz_channels),
4728 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4729 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4730 band->channels = channels;
4731 band->n_bitrates = ath10k_g_rates_size;
4732 band->bitrates = ath10k_g_rates;
4733 band->ht_cap = ht_cap;
4735 /* vht is not supported in 2.4 GHz */
4737 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4740 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4741 channels = kmemdup(ath10k_5ghz_channels,
4742 sizeof(ath10k_5ghz_channels),
4749 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4750 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4751 band->channels = channels;
4752 band->n_bitrates = ath10k_a_rates_size;
4753 band->bitrates = ath10k_a_rates;
4754 band->ht_cap = ht_cap;
4755 band->vht_cap = vht_cap;
4756 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4759 ar->hw->wiphy->interface_modes =
4760 BIT(NL80211_IFTYPE_STATION) |
4761 BIT(NL80211_IFTYPE_AP);
4763 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4764 /* TODO: Have to deal with 2x2 chips if/when the come out. */
4765 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK;
4766 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK;
4768 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK;
4769 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK;
4772 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4773 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4775 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4776 ar->hw->wiphy->interface_modes |=
4777 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4778 BIT(NL80211_IFTYPE_P2P_GO);
4780 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4781 IEEE80211_HW_SUPPORTS_PS |
4782 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4783 IEEE80211_HW_SUPPORTS_UAPSD |
4784 IEEE80211_HW_MFP_CAPABLE |
4785 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4786 IEEE80211_HW_HAS_RATE_CONTROL |
4787 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4788 IEEE80211_HW_AP_LINK_PS |
4789 IEEE80211_HW_SPECTRUM_MGMT;
4791 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4792 * bytes is used for padding/alignment if necessary. */
4793 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4795 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4796 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4798 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4799 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4800 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4803 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4804 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4806 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4807 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4809 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4811 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4812 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4813 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4815 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4817 * on LL hardware queues are managed entirely by the FW
4818 * so we only advertise to mac we can do the queues thing
4822 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4823 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4824 ar->hw->wiphy->n_iface_combinations =
4825 ARRAY_SIZE(ath10k_10x_if_comb);
4827 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4828 ar->hw->wiphy->n_iface_combinations =
4829 ARRAY_SIZE(ath10k_if_comb);
4831 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
4834 ar->hw->netdev_features = NETIF_F_HW_CSUM;
4836 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4837 /* Init ath dfs pattern detector */
4838 ar->ath_common.debug_mask = ATH_DBG_DFS;
4839 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4842 if (!ar->dfs_detector)
4843 ath10k_warn("failed to initialise DFS pattern detector\n");
4846 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4847 ath10k_reg_notifier);
4849 ath10k_err("failed to initialise regulatory: %i\n", ret);
4853 ret = ieee80211_register_hw(ar->hw);
4855 ath10k_err("failed to register ieee80211: %d\n", ret);
4859 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4860 ret = regulatory_hint(ar->hw->wiphy,
4861 ar->ath_common.regulatory.alpha2);
4863 goto err_unregister;
4869 ieee80211_unregister_hw(ar->hw);
4871 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4872 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4877 void ath10k_mac_unregister(struct ath10k *ar)
4879 ieee80211_unregister_hw(ar->hw);
4881 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4882 ar->dfs_detector->exit(ar->dfs_detector);
4884 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4885 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4887 SET_IEEE80211_DEV(ar->hw, NULL);