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>
35 static int ath10k_send_key(struct ath10k_vif *arvif,
36 struct ieee80211_key_conf *key,
40 struct ath10k *ar = arvif->ar;
41 struct wmi_vdev_install_key_arg arg = {
42 .vdev_id = arvif->vdev_id,
43 .key_idx = key->keyidx,
44 .key_len = key->keylen,
49 lockdep_assert_held(&arvif->ar->conf_mutex);
51 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
52 arg.key_flags = WMI_KEY_PAIRWISE;
54 arg.key_flags = WMI_KEY_GROUP;
56 switch (key->cipher) {
57 case WLAN_CIPHER_SUITE_CCMP:
58 arg.key_cipher = WMI_CIPHER_AES_CCM;
59 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
60 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
62 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
64 case WLAN_CIPHER_SUITE_TKIP:
65 arg.key_cipher = WMI_CIPHER_TKIP;
66 arg.key_txmic_len = 8;
67 arg.key_rxmic_len = 8;
69 case WLAN_CIPHER_SUITE_WEP40:
70 case WLAN_CIPHER_SUITE_WEP104:
71 arg.key_cipher = WMI_CIPHER_WEP;
72 /* AP/IBSS mode requires self-key to be groupwise
73 * Otherwise pairwise key must be set */
74 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
75 arg.key_flags = WMI_KEY_PAIRWISE;
78 ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
82 if (cmd == DISABLE_KEY) {
83 arg.key_cipher = WMI_CIPHER_NONE;
87 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
90 static int ath10k_install_key(struct ath10k_vif *arvif,
91 struct ieee80211_key_conf *key,
95 struct ath10k *ar = arvif->ar;
98 lockdep_assert_held(&ar->conf_mutex);
100 reinit_completion(&ar->install_key_done);
102 ret = ath10k_send_key(arvif, key, cmd, macaddr);
106 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
113 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
116 struct ath10k *ar = arvif->ar;
117 struct ath10k_peer *peer;
121 lockdep_assert_held(&ar->conf_mutex);
123 spin_lock_bh(&ar->data_lock);
124 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
125 spin_unlock_bh(&ar->data_lock);
130 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
131 if (arvif->wep_keys[i] == NULL)
134 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
139 peer->keys[i] = arvif->wep_keys[i];
145 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
148 struct ath10k *ar = arvif->ar;
149 struct ath10k_peer *peer;
154 lockdep_assert_held(&ar->conf_mutex);
156 spin_lock_bh(&ar->data_lock);
157 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
158 spin_unlock_bh(&ar->data_lock);
163 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
164 if (peer->keys[i] == NULL)
167 ret = ath10k_install_key(arvif, peer->keys[i],
169 if (ret && first_errno == 0)
173 ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
176 peer->keys[i] = NULL;
182 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
183 struct ieee80211_key_conf *key)
185 struct ath10k *ar = arvif->ar;
186 struct ath10k_peer *peer;
192 lockdep_assert_held(&ar->conf_mutex);
195 /* since ath10k_install_key we can't hold data_lock all the
196 * time, so we try to remove the keys incrementally */
197 spin_lock_bh(&ar->data_lock);
199 list_for_each_entry(peer, &ar->peers, list) {
200 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
201 if (peer->keys[i] == key) {
202 ether_addr_copy(addr, peer->addr);
203 peer->keys[i] = NULL;
208 if (i < ARRAY_SIZE(peer->keys))
211 spin_unlock_bh(&ar->data_lock);
213 if (i == ARRAY_SIZE(peer->keys))
216 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
217 if (ret && first_errno == 0)
221 ath10k_warn(ar, "failed to remove key for %pM: %d\n",
228 /*********************/
229 /* General utilities */
230 /*********************/
232 static inline enum wmi_phy_mode
233 chan_to_phymode(const struct cfg80211_chan_def *chandef)
235 enum wmi_phy_mode phymode = MODE_UNKNOWN;
237 switch (chandef->chan->band) {
238 case IEEE80211_BAND_2GHZ:
239 switch (chandef->width) {
240 case NL80211_CHAN_WIDTH_20_NOHT:
243 case NL80211_CHAN_WIDTH_20:
244 phymode = MODE_11NG_HT20;
246 case NL80211_CHAN_WIDTH_40:
247 phymode = MODE_11NG_HT40;
249 case NL80211_CHAN_WIDTH_5:
250 case NL80211_CHAN_WIDTH_10:
251 case NL80211_CHAN_WIDTH_80:
252 case NL80211_CHAN_WIDTH_80P80:
253 case NL80211_CHAN_WIDTH_160:
254 phymode = MODE_UNKNOWN;
258 case IEEE80211_BAND_5GHZ:
259 switch (chandef->width) {
260 case NL80211_CHAN_WIDTH_20_NOHT:
263 case NL80211_CHAN_WIDTH_20:
264 phymode = MODE_11NA_HT20;
266 case NL80211_CHAN_WIDTH_40:
267 phymode = MODE_11NA_HT40;
269 case NL80211_CHAN_WIDTH_80:
270 phymode = MODE_11AC_VHT80;
272 case NL80211_CHAN_WIDTH_5:
273 case NL80211_CHAN_WIDTH_10:
274 case NL80211_CHAN_WIDTH_80P80:
275 case NL80211_CHAN_WIDTH_160:
276 phymode = MODE_UNKNOWN;
284 WARN_ON(phymode == MODE_UNKNOWN);
288 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
291 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
292 * 0 for no restriction
301 switch (mpdudensity) {
307 /* Our lower layer calculations limit our precision to
323 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
327 lockdep_assert_held(&ar->conf_mutex);
329 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
331 ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
336 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
338 ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
342 spin_lock_bh(&ar->data_lock);
344 spin_unlock_bh(&ar->data_lock);
349 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
351 struct ath10k *ar = arvif->ar;
355 param = ar->wmi.pdev_param->sta_kickout_th;
356 ret = ath10k_wmi_pdev_set_param(ar, param,
357 ATH10K_KICKOUT_THRESHOLD);
359 ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
360 arvif->vdev_id, ret);
364 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
365 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
366 ATH10K_KEEPALIVE_MIN_IDLE);
368 ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
369 arvif->vdev_id, ret);
373 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
374 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
375 ATH10K_KEEPALIVE_MAX_IDLE);
377 ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
378 arvif->vdev_id, ret);
382 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
383 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
384 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
386 ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
387 arvif->vdev_id, ret);
394 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
396 struct ath10k *ar = arvif->ar;
399 if (value != 0xFFFFFFFF)
400 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
403 vdev_param = ar->wmi.vdev_param->rts_threshold;
404 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
407 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
409 struct ath10k *ar = arvif->ar;
412 if (value != 0xFFFFFFFF)
413 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
414 ATH10K_FRAGMT_THRESHOLD_MIN,
415 ATH10K_FRAGMT_THRESHOLD_MAX);
417 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
418 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
421 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
425 lockdep_assert_held(&ar->conf_mutex);
427 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
431 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
435 spin_lock_bh(&ar->data_lock);
437 spin_unlock_bh(&ar->data_lock);
442 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
444 struct ath10k_peer *peer, *tmp;
446 lockdep_assert_held(&ar->conf_mutex);
448 spin_lock_bh(&ar->data_lock);
449 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
450 if (peer->vdev_id != vdev_id)
453 ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
454 peer->addr, vdev_id);
456 list_del(&peer->list);
460 spin_unlock_bh(&ar->data_lock);
463 static void ath10k_peer_cleanup_all(struct ath10k *ar)
465 struct ath10k_peer *peer, *tmp;
467 lockdep_assert_held(&ar->conf_mutex);
469 spin_lock_bh(&ar->data_lock);
470 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
471 list_del(&peer->list);
475 spin_unlock_bh(&ar->data_lock);
478 /************************/
479 /* Interface management */
480 /************************/
482 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
486 lockdep_assert_held(&ar->conf_mutex);
488 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
489 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
496 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
498 struct cfg80211_chan_def *chandef = &ar->chandef;
499 struct ieee80211_channel *channel = chandef->chan;
500 struct wmi_vdev_start_request_arg arg = {};
503 lockdep_assert_held(&ar->conf_mutex);
505 arg.vdev_id = vdev_id;
506 arg.channel.freq = channel->center_freq;
507 arg.channel.band_center_freq1 = chandef->center_freq1;
509 /* TODO setup this dynamically, what in case we
510 don't have any vifs? */
511 arg.channel.mode = chan_to_phymode(chandef);
512 arg.channel.chan_radar =
513 !!(channel->flags & IEEE80211_CHAN_RADAR);
515 arg.channel.min_power = 0;
516 arg.channel.max_power = channel->max_power * 2;
517 arg.channel.max_reg_power = channel->max_reg_power * 2;
518 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
520 ret = ath10k_wmi_vdev_start(ar, &arg);
522 ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
527 ret = ath10k_vdev_setup_sync(ar);
529 ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i: %d\n",
534 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
536 ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
541 ar->monitor_vdev_id = vdev_id;
543 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
544 ar->monitor_vdev_id);
548 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
550 ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
551 ar->monitor_vdev_id, ret);
556 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
560 lockdep_assert_held(&ar->conf_mutex);
562 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
564 ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
565 ar->monitor_vdev_id, ret);
567 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
569 ath10k_warn(ar, "failed to to request monitor vdev %i stop: %d\n",
570 ar->monitor_vdev_id, ret);
572 ret = ath10k_vdev_setup_sync(ar);
574 ath10k_warn(ar, "failed to synchronise monitor vdev %i: %d\n",
575 ar->monitor_vdev_id, ret);
577 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
578 ar->monitor_vdev_id);
582 static int ath10k_monitor_vdev_create(struct ath10k *ar)
586 lockdep_assert_held(&ar->conf_mutex);
588 if (ar->free_vdev_map == 0) {
589 ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
593 bit = ffs(ar->free_vdev_map);
595 ar->monitor_vdev_id = bit - 1;
597 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
598 WMI_VDEV_TYPE_MONITOR,
601 ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
602 ar->monitor_vdev_id, ret);
606 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
607 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
608 ar->monitor_vdev_id);
613 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
617 lockdep_assert_held(&ar->conf_mutex);
619 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
621 ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
622 ar->monitor_vdev_id, ret);
626 ar->free_vdev_map |= 1 << ar->monitor_vdev_id;
628 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
629 ar->monitor_vdev_id);
633 static int ath10k_monitor_start(struct ath10k *ar)
637 lockdep_assert_held(&ar->conf_mutex);
639 ret = ath10k_monitor_vdev_create(ar);
641 ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
645 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
647 ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
648 ath10k_monitor_vdev_delete(ar);
652 ar->monitor_started = true;
653 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
658 static int ath10k_monitor_stop(struct ath10k *ar)
662 lockdep_assert_held(&ar->conf_mutex);
664 ret = ath10k_monitor_vdev_stop(ar);
666 ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
670 ret = ath10k_monitor_vdev_delete(ar);
672 ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
676 ar->monitor_started = false;
677 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
682 static int ath10k_monitor_recalc(struct ath10k *ar)
686 lockdep_assert_held(&ar->conf_mutex);
688 should_start = ar->monitor ||
689 ar->filter_flags & FIF_PROMISC_IN_BSS ||
690 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
692 ath10k_dbg(ar, ATH10K_DBG_MAC,
693 "mac monitor recalc started? %d should? %d\n",
694 ar->monitor_started, should_start);
696 if (should_start == ar->monitor_started)
700 return ath10k_monitor_start(ar);
702 return ath10k_monitor_stop(ar);
705 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
707 struct ath10k *ar = arvif->ar;
708 u32 vdev_param, rts_cts = 0;
710 lockdep_assert_held(&ar->conf_mutex);
712 vdev_param = ar->wmi.vdev_param->enable_rtscts;
714 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
715 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
717 if (arvif->num_legacy_stations > 0)
718 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
721 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
725 static int ath10k_start_cac(struct ath10k *ar)
729 lockdep_assert_held(&ar->conf_mutex);
731 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
733 ret = ath10k_monitor_recalc(ar);
735 ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
736 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
740 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
741 ar->monitor_vdev_id);
746 static int ath10k_stop_cac(struct ath10k *ar)
748 lockdep_assert_held(&ar->conf_mutex);
750 /* CAC is not running - do nothing */
751 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
754 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
755 ath10k_monitor_stop(ar);
757 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
762 static void ath10k_recalc_radar_detection(struct ath10k *ar)
766 lockdep_assert_held(&ar->conf_mutex);
770 if (!ar->radar_enabled)
773 if (ar->num_started_vdevs > 0)
776 ret = ath10k_start_cac(ar);
779 * Not possible to start CAC on current channel so starting
780 * radiation is not allowed, make this channel DFS_UNAVAILABLE
781 * by indicating that radar was detected.
783 ath10k_warn(ar, "failed to start CAC: %d\n", ret);
784 ieee80211_radar_detected(ar->hw);
788 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif, bool restart)
790 struct ath10k *ar = arvif->ar;
791 struct cfg80211_chan_def *chandef = &ar->chandef;
792 struct wmi_vdev_start_request_arg arg = {};
795 lockdep_assert_held(&ar->conf_mutex);
797 reinit_completion(&ar->vdev_setup_done);
799 arg.vdev_id = arvif->vdev_id;
800 arg.dtim_period = arvif->dtim_period;
801 arg.bcn_intval = arvif->beacon_interval;
803 arg.channel.freq = chandef->chan->center_freq;
804 arg.channel.band_center_freq1 = chandef->center_freq1;
805 arg.channel.mode = chan_to_phymode(chandef);
807 arg.channel.min_power = 0;
808 arg.channel.max_power = chandef->chan->max_power * 2;
809 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
810 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
812 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
813 arg.ssid = arvif->u.ap.ssid;
814 arg.ssid_len = arvif->u.ap.ssid_len;
815 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
817 /* For now allow DFS for AP mode */
818 arg.channel.chan_radar =
819 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
820 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
821 arg.ssid = arvif->vif->bss_conf.ssid;
822 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
825 ath10k_dbg(ar, ATH10K_DBG_MAC,
826 "mac vdev %d start center_freq %d phymode %s\n",
827 arg.vdev_id, arg.channel.freq,
828 ath10k_wmi_phymode_str(arg.channel.mode));
831 ret = ath10k_wmi_vdev_restart(ar, &arg);
833 ret = ath10k_wmi_vdev_start(ar, &arg);
836 ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
841 ret = ath10k_vdev_setup_sync(ar);
843 ath10k_warn(ar, "failed to synchronise setup for vdev %i: %d\n",
848 ar->num_started_vdevs++;
849 ath10k_recalc_radar_detection(ar);
854 static int ath10k_vdev_start(struct ath10k_vif *arvif)
856 return ath10k_vdev_start_restart(arvif, false);
859 static int ath10k_vdev_restart(struct ath10k_vif *arvif)
861 return ath10k_vdev_start_restart(arvif, true);
864 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
866 struct ath10k *ar = arvif->ar;
869 lockdep_assert_held(&ar->conf_mutex);
871 reinit_completion(&ar->vdev_setup_done);
873 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
875 ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
876 arvif->vdev_id, ret);
880 ret = ath10k_vdev_setup_sync(ar);
882 ath10k_warn(ar, "failed to syncronise setup for vdev %i: %d\n",
883 arvif->vdev_id, ret);
887 WARN_ON(ar->num_started_vdevs == 0);
889 if (ar->num_started_vdevs != 0) {
890 ar->num_started_vdevs--;
891 ath10k_recalc_radar_detection(ar);
897 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
898 struct ieee80211_bss_conf *info)
900 struct ath10k *ar = arvif->ar;
903 lockdep_assert_held(&arvif->ar->conf_mutex);
905 if (!info->enable_beacon) {
906 ath10k_vdev_stop(arvif);
908 arvif->is_started = false;
909 arvif->is_up = false;
911 spin_lock_bh(&arvif->ar->data_lock);
913 dma_unmap_single(arvif->ar->dev,
914 ATH10K_SKB_CB(arvif->beacon)->paddr,
915 arvif->beacon->len, DMA_TO_DEVICE);
916 dev_kfree_skb_any(arvif->beacon);
918 arvif->beacon = NULL;
919 arvif->beacon_sent = false;
921 spin_unlock_bh(&arvif->ar->data_lock);
926 arvif->tx_seq_no = 0x1000;
928 ret = ath10k_vdev_start(arvif);
933 ether_addr_copy(arvif->bssid, info->bssid);
935 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
938 ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
939 arvif->vdev_id, ret);
940 ath10k_vdev_stop(arvif);
944 arvif->is_started = true;
947 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
950 static void ath10k_control_ibss(struct ath10k_vif *arvif,
951 struct ieee80211_bss_conf *info,
952 const u8 self_peer[ETH_ALEN])
954 struct ath10k *ar = arvif->ar;
958 lockdep_assert_held(&arvif->ar->conf_mutex);
960 if (!info->ibss_joined) {
961 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
963 ath10k_warn(ar, "failed to delete IBSS self peer %pM for vdev %d: %d\n",
964 self_peer, arvif->vdev_id, ret);
966 if (is_zero_ether_addr(arvif->bssid))
969 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
972 ath10k_warn(ar, "failed to delete IBSS BSSID peer %pM for vdev %d: %d\n",
973 arvif->bssid, arvif->vdev_id, ret);
977 memset(arvif->bssid, 0, ETH_ALEN);
982 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
984 ath10k_warn(ar, "failed to create IBSS self peer %pM for vdev %d: %d\n",
985 self_peer, arvif->vdev_id, ret);
989 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
990 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
991 ATH10K_DEFAULT_ATIM);
993 ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
994 arvif->vdev_id, ret);
998 * Review this when mac80211 gains per-interface powersave support.
1000 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1002 struct ath10k *ar = arvif->ar;
1003 struct ieee80211_conf *conf = &ar->hw->conf;
1004 enum wmi_sta_powersave_param param;
1005 enum wmi_sta_ps_mode psmode;
1008 lockdep_assert_held(&arvif->ar->conf_mutex);
1010 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1013 if (conf->flags & IEEE80211_CONF_PS) {
1014 psmode = WMI_STA_PS_MODE_ENABLED;
1015 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1017 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1018 conf->dynamic_ps_timeout);
1020 ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1021 arvif->vdev_id, ret);
1025 psmode = WMI_STA_PS_MODE_DISABLED;
1028 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1029 arvif->vdev_id, psmode ? "enable" : "disable");
1031 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1033 ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1034 psmode, arvif->vdev_id, ret);
1041 /**********************/
1042 /* Station management */
1043 /**********************/
1045 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1046 struct ath10k_vif *arvif,
1047 struct ieee80211_sta *sta,
1048 struct ieee80211_bss_conf *bss_conf,
1049 struct wmi_peer_assoc_complete_arg *arg)
1051 lockdep_assert_held(&ar->conf_mutex);
1053 ether_addr_copy(arg->addr, sta->addr);
1054 arg->vdev_id = arvif->vdev_id;
1055 arg->peer_aid = sta->aid;
1056 arg->peer_flags |= WMI_PEER_AUTH;
1058 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
1060 * Seems FW have problems with Power Save in STA
1061 * mode when we setup this parameter to high (eg. 5).
1062 * Often we see that FW don't send NULL (with clean P flags)
1063 * frame even there is info about buffered frames in beacons.
1064 * Sometimes we have to wait more than 10 seconds before FW
1065 * will wakeup. Often sending one ping from AP to our device
1066 * just fail (more than 50%).
1068 * Seems setting this FW parameter to 1 couse FW
1069 * will check every beacon and will wakup immediately
1070 * after detection buffered data.
1072 arg->peer_listen_intval = 1;
1074 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1076 arg->peer_num_spatial_streams = 1;
1079 * The assoc capabilities are available only in managed mode.
1081 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
1082 arg->peer_caps = bss_conf->assoc_capability;
1085 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1086 struct ath10k_vif *arvif,
1087 struct wmi_peer_assoc_complete_arg *arg)
1089 struct ieee80211_vif *vif = arvif->vif;
1090 struct ieee80211_bss_conf *info = &vif->bss_conf;
1091 struct cfg80211_bss *bss;
1092 const u8 *rsnie = NULL;
1093 const u8 *wpaie = NULL;
1095 lockdep_assert_held(&ar->conf_mutex);
1097 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1098 info->bssid, NULL, 0, 0, 0);
1100 const struct cfg80211_bss_ies *ies;
1103 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1105 ies = rcu_dereference(bss->ies);
1107 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1108 WLAN_OUI_TYPE_MICROSOFT_WPA,
1112 cfg80211_put_bss(ar->hw->wiphy, bss);
1115 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1116 if (rsnie || wpaie) {
1117 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1118 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1122 ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1123 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1127 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1128 struct ieee80211_sta *sta,
1129 struct wmi_peer_assoc_complete_arg *arg)
1131 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1132 const struct ieee80211_supported_band *sband;
1133 const struct ieee80211_rate *rates;
1137 lockdep_assert_held(&ar->conf_mutex);
1139 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1140 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1141 rates = sband->bitrates;
1143 rateset->num_rates = 0;
1145 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1146 if (!(ratemask & 1))
1149 rateset->rates[rateset->num_rates] = rates->hw_value;
1150 rateset->num_rates++;
1154 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1155 struct ieee80211_sta *sta,
1156 struct wmi_peer_assoc_complete_arg *arg)
1158 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1162 lockdep_assert_held(&ar->conf_mutex);
1164 if (!ht_cap->ht_supported)
1167 arg->peer_flags |= WMI_PEER_HT;
1168 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1169 ht_cap->ampdu_factor)) - 1;
1171 arg->peer_mpdu_density =
1172 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1174 arg->peer_ht_caps = ht_cap->cap;
1175 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1177 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1178 arg->peer_flags |= WMI_PEER_LDPC;
1180 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1181 arg->peer_flags |= WMI_PEER_40MHZ;
1182 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1185 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1186 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1188 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1189 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1191 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1192 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1193 arg->peer_flags |= WMI_PEER_STBC;
1196 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1197 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1198 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1199 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1200 arg->peer_rate_caps |= stbc;
1201 arg->peer_flags |= WMI_PEER_STBC;
1204 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1205 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1206 else if (ht_cap->mcs.rx_mask[1])
1207 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1209 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1210 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1211 arg->peer_ht_rates.rates[n++] = i;
1214 * This is a workaround for HT-enabled STAs which break the spec
1215 * and have no HT capabilities RX mask (no HT RX MCS map).
1217 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1218 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1220 * Firmware asserts if such situation occurs.
1223 arg->peer_ht_rates.num_rates = 8;
1224 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1225 arg->peer_ht_rates.rates[i] = i;
1227 arg->peer_ht_rates.num_rates = n;
1228 arg->peer_num_spatial_streams = sta->rx_nss;
1231 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1233 arg->peer_ht_rates.num_rates,
1234 arg->peer_num_spatial_streams);
1237 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1238 struct ath10k_vif *arvif,
1239 struct ieee80211_sta *sta)
1245 lockdep_assert_held(&ar->conf_mutex);
1247 if (sta->wme && sta->uapsd_queues) {
1248 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1249 sta->uapsd_queues, sta->max_sp);
1251 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1252 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1253 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1254 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1255 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1256 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1257 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1258 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1259 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1260 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1261 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1262 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1264 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1265 max_sp = sta->max_sp;
1267 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1269 WMI_AP_PS_PEER_PARAM_UAPSD,
1272 ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
1273 arvif->vdev_id, ret);
1277 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1279 WMI_AP_PS_PEER_PARAM_MAX_SP,
1282 ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
1283 arvif->vdev_id, ret);
1287 /* TODO setup this based on STA listen interval and
1288 beacon interval. Currently we don't know
1289 sta->listen_interval - mac80211 patch required.
1290 Currently use 10 seconds */
1291 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1292 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1295 ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
1296 arvif->vdev_id, ret);
1304 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1305 struct ieee80211_sta *sta,
1306 struct wmi_peer_assoc_complete_arg *arg)
1308 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1311 if (!vht_cap->vht_supported)
1314 arg->peer_flags |= WMI_PEER_VHT;
1315 arg->peer_vht_caps = vht_cap->cap;
1317 ampdu_factor = (vht_cap->cap &
1318 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1319 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1321 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1322 * zero in VHT IE. Using it would result in degraded throughput.
1323 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1324 * it if VHT max_mpdu is smaller. */
1325 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1326 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1327 ampdu_factor)) - 1);
1329 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1330 arg->peer_flags |= WMI_PEER_80MHZ;
1332 arg->peer_vht_rates.rx_max_rate =
1333 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1334 arg->peer_vht_rates.rx_mcs_set =
1335 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1336 arg->peer_vht_rates.tx_max_rate =
1337 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1338 arg->peer_vht_rates.tx_mcs_set =
1339 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1341 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1342 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1345 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1346 struct ath10k_vif *arvif,
1347 struct ieee80211_sta *sta,
1348 struct ieee80211_bss_conf *bss_conf,
1349 struct wmi_peer_assoc_complete_arg *arg)
1351 switch (arvif->vdev_type) {
1352 case WMI_VDEV_TYPE_AP:
1354 arg->peer_flags |= WMI_PEER_QOS;
1356 if (sta->wme && sta->uapsd_queues) {
1357 arg->peer_flags |= WMI_PEER_APSD;
1358 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1361 case WMI_VDEV_TYPE_STA:
1363 arg->peer_flags |= WMI_PEER_QOS;
1370 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1371 struct ath10k_vif *arvif,
1372 struct ieee80211_sta *sta,
1373 struct wmi_peer_assoc_complete_arg *arg)
1375 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1377 switch (ar->hw->conf.chandef.chan->band) {
1378 case IEEE80211_BAND_2GHZ:
1379 if (sta->ht_cap.ht_supported) {
1380 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1381 phymode = MODE_11NG_HT40;
1383 phymode = MODE_11NG_HT20;
1389 case IEEE80211_BAND_5GHZ:
1393 if (sta->vht_cap.vht_supported) {
1394 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1395 phymode = MODE_11AC_VHT80;
1396 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1397 phymode = MODE_11AC_VHT40;
1398 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1399 phymode = MODE_11AC_VHT20;
1400 } else if (sta->ht_cap.ht_supported) {
1401 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1402 phymode = MODE_11NA_HT40;
1404 phymode = MODE_11NA_HT20;
1414 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1415 sta->addr, ath10k_wmi_phymode_str(phymode));
1417 arg->peer_phymode = phymode;
1418 WARN_ON(phymode == MODE_UNKNOWN);
1421 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1422 struct ath10k_vif *arvif,
1423 struct ieee80211_sta *sta,
1424 struct ieee80211_bss_conf *bss_conf,
1425 struct wmi_peer_assoc_complete_arg *arg)
1427 lockdep_assert_held(&ar->conf_mutex);
1429 memset(arg, 0, sizeof(*arg));
1431 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1432 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1433 ath10k_peer_assoc_h_rates(ar, sta, arg);
1434 ath10k_peer_assoc_h_ht(ar, sta, arg);
1435 ath10k_peer_assoc_h_vht(ar, sta, arg);
1436 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1437 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
1442 static const u32 ath10k_smps_map[] = {
1443 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1444 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1445 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1446 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1449 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1451 const struct ieee80211_sta_ht_cap *ht_cap)
1455 if (!ht_cap->ht_supported)
1458 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1459 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1461 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1464 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1465 WMI_PEER_SMPS_STATE,
1466 ath10k_smps_map[smps]);
1469 /* can be called only in mac80211 callbacks due to `key_count` usage */
1470 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1471 struct ieee80211_vif *vif,
1472 struct ieee80211_bss_conf *bss_conf)
1474 struct ath10k *ar = hw->priv;
1475 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1476 struct ieee80211_sta_ht_cap ht_cap;
1477 struct wmi_peer_assoc_complete_arg peer_arg;
1478 struct ieee80211_sta *ap_sta;
1481 lockdep_assert_held(&ar->conf_mutex);
1485 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1487 ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
1488 bss_conf->bssid, arvif->vdev_id);
1493 /* ap_sta must be accessed only within rcu section which must be left
1494 * before calling ath10k_setup_peer_smps() which might sleep. */
1495 ht_cap = ap_sta->ht_cap;
1497 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1498 bss_conf, &peer_arg);
1500 ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
1501 bss_conf->bssid, arvif->vdev_id, ret);
1508 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1510 ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
1511 bss_conf->bssid, arvif->vdev_id, ret);
1515 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1517 ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
1518 arvif->vdev_id, ret);
1522 ath10k_dbg(ar, ATH10K_DBG_MAC,
1523 "mac vdev %d up (associated) bssid %pM aid %d\n",
1524 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1526 arvif->aid = bss_conf->aid;
1527 ether_addr_copy(arvif->bssid, bss_conf->bssid);
1529 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1531 ath10k_warn(ar, "failed to set vdev %d up: %d\n",
1532 arvif->vdev_id, ret);
1536 arvif->is_up = true;
1542 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1543 struct ieee80211_vif *vif)
1545 struct ath10k *ar = hw->priv;
1546 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1549 lockdep_assert_held(&ar->conf_mutex);
1552 * For some reason, calling VDEV-DOWN before VDEV-STOP
1553 * makes the FW to send frames via HTT after disassociation.
1554 * No idea why this happens, even though VDEV-DOWN is supposed
1555 * to be analogous to link down, so just stop the VDEV.
1557 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1560 /* FIXME: check return value */
1561 ret = ath10k_vdev_stop(arvif);
1564 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1565 * report beacons from previously associated network through HTT.
1566 * This in turn would spam mac80211 WARN_ON if we bring down all
1567 * interfaces as it expects there is no rx when no interface is
1570 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1572 /* FIXME: why don't we print error if wmi call fails? */
1573 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1575 arvif->def_wep_key_idx = 0;
1577 arvif->is_started = false;
1578 arvif->is_up = false;
1581 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1582 struct ieee80211_sta *sta, bool reassoc)
1584 struct wmi_peer_assoc_complete_arg peer_arg;
1587 lockdep_assert_held(&ar->conf_mutex);
1589 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1591 ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1592 sta->addr, arvif->vdev_id, ret);
1596 peer_arg.peer_reassoc = reassoc;
1597 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1599 ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
1600 sta->addr, arvif->vdev_id, ret);
1604 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap);
1606 ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
1607 arvif->vdev_id, ret);
1611 if (!sta->wme && !reassoc) {
1612 arvif->num_legacy_stations++;
1613 ret = ath10k_recalc_rtscts_prot(arvif);
1615 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1616 arvif->vdev_id, ret);
1621 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1623 ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
1624 arvif->vdev_id, ret);
1628 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1630 ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
1631 sta->addr, arvif->vdev_id, ret);
1638 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1639 struct ieee80211_sta *sta)
1643 lockdep_assert_held(&ar->conf_mutex);
1646 arvif->num_legacy_stations--;
1647 ret = ath10k_recalc_rtscts_prot(arvif);
1649 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
1650 arvif->vdev_id, ret);
1655 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1657 ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
1658 arvif->vdev_id, ret);
1669 static int ath10k_update_channel_list(struct ath10k *ar)
1671 struct ieee80211_hw *hw = ar->hw;
1672 struct ieee80211_supported_band **bands;
1673 enum ieee80211_band band;
1674 struct ieee80211_channel *channel;
1675 struct wmi_scan_chan_list_arg arg = {0};
1676 struct wmi_channel_arg *ch;
1682 lockdep_assert_held(&ar->conf_mutex);
1684 bands = hw->wiphy->bands;
1685 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1689 for (i = 0; i < bands[band]->n_channels; i++) {
1690 if (bands[band]->channels[i].flags &
1691 IEEE80211_CHAN_DISABLED)
1698 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1699 arg.channels = kzalloc(len, GFP_KERNEL);
1704 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1708 for (i = 0; i < bands[band]->n_channels; i++) {
1709 channel = &bands[band]->channels[i];
1711 if (channel->flags & IEEE80211_CHAN_DISABLED)
1714 ch->allow_ht = true;
1716 /* FIXME: when should we really allow VHT? */
1717 ch->allow_vht = true;
1720 !(channel->flags & IEEE80211_CHAN_NO_IR);
1723 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1726 !!(channel->flags & IEEE80211_CHAN_RADAR);
1728 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1729 ch->passive = passive;
1731 ch->freq = channel->center_freq;
1733 ch->max_power = channel->max_power * 2;
1734 ch->max_reg_power = channel->max_reg_power * 2;
1735 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1736 ch->reg_class_id = 0; /* FIXME */
1738 /* FIXME: why use only legacy modes, why not any
1739 * HT/VHT modes? Would that even make any
1741 if (channel->band == IEEE80211_BAND_2GHZ)
1742 ch->mode = MODE_11G;
1744 ch->mode = MODE_11A;
1746 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1749 ath10k_dbg(ar, ATH10K_DBG_WMI,
1750 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1751 ch - arg.channels, arg.n_channels,
1752 ch->freq, ch->max_power, ch->max_reg_power,
1753 ch->max_antenna_gain, ch->mode);
1759 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1760 kfree(arg.channels);
1765 static enum wmi_dfs_region
1766 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1768 switch (dfs_region) {
1769 case NL80211_DFS_UNSET:
1770 return WMI_UNINIT_DFS_DOMAIN;
1771 case NL80211_DFS_FCC:
1772 return WMI_FCC_DFS_DOMAIN;
1773 case NL80211_DFS_ETSI:
1774 return WMI_ETSI_DFS_DOMAIN;
1775 case NL80211_DFS_JP:
1776 return WMI_MKK4_DFS_DOMAIN;
1778 return WMI_UNINIT_DFS_DOMAIN;
1781 static void ath10k_regd_update(struct ath10k *ar)
1783 struct reg_dmn_pair_mapping *regpair;
1785 enum wmi_dfs_region wmi_dfs_reg;
1786 enum nl80211_dfs_regions nl_dfs_reg;
1788 lockdep_assert_held(&ar->conf_mutex);
1790 ret = ath10k_update_channel_list(ar);
1792 ath10k_warn(ar, "failed to update channel list: %d\n", ret);
1794 regpair = ar->ath_common.regulatory.regpair;
1796 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1797 nl_dfs_reg = ar->dfs_detector->region;
1798 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1800 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1803 /* Target allows setting up per-band regdomain but ath_common provides
1804 * a combined one only */
1805 ret = ath10k_wmi_pdev_set_regdomain(ar,
1806 regpair->reg_domain,
1807 regpair->reg_domain, /* 2ghz */
1808 regpair->reg_domain, /* 5ghz */
1809 regpair->reg_2ghz_ctl,
1810 regpair->reg_5ghz_ctl,
1813 ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
1816 static void ath10k_reg_notifier(struct wiphy *wiphy,
1817 struct regulatory_request *request)
1819 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1820 struct ath10k *ar = hw->priv;
1823 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1825 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1826 ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1827 request->dfs_region);
1828 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1829 request->dfs_region);
1831 ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
1832 request->dfs_region);
1835 mutex_lock(&ar->conf_mutex);
1836 if (ar->state == ATH10K_STATE_ON)
1837 ath10k_regd_update(ar);
1838 mutex_unlock(&ar->conf_mutex);
1845 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1847 if (ieee80211_is_mgmt(hdr->frame_control))
1848 return HTT_DATA_TX_EXT_TID_MGMT;
1850 if (!ieee80211_is_data_qos(hdr->frame_control))
1851 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1853 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1854 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1856 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1859 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar, struct ieee80211_vif *vif)
1862 return ath10k_vif_to_arvif(vif)->vdev_id;
1864 if (ar->monitor_started)
1865 return ar->monitor_vdev_id;
1867 ath10k_warn(ar, "failed to resolve vdev id\n");
1871 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
1872 * Control in the header.
1874 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
1876 struct ieee80211_hdr *hdr = (void *)skb->data;
1877 struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
1880 if (!ieee80211_is_data_qos(hdr->frame_control))
1883 qos_ctl = ieee80211_get_qos_ctl(hdr);
1884 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1885 skb->data, (void *)qos_ctl - (void *)skb->data);
1886 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1888 /* Fw/Hw generates a corrupted QoS Control Field for QoS NullFunc
1889 * frames. Powersave is handled by the fw/hw so QoS NyllFunc frames are
1890 * used only for CQM purposes (e.g. hostapd station keepalive ping) so
1891 * it is safe to downgrade to NullFunc.
1893 if (ieee80211_is_qos_nullfunc(hdr->frame_control)) {
1894 hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
1895 cb->htt.tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1899 static void ath10k_tx_wep_key_work(struct work_struct *work)
1901 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1903 struct ath10k *ar = arvif->ar;
1904 int ret, keyidx = arvif->def_wep_key_newidx;
1906 mutex_lock(&arvif->ar->conf_mutex);
1908 if (arvif->ar->state != ATH10K_STATE_ON)
1911 if (arvif->def_wep_key_idx == keyidx)
1914 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1915 arvif->vdev_id, keyidx);
1917 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1919 arvif->ar->wmi.vdev_param->def_keyid,
1922 ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
1928 arvif->def_wep_key_idx = keyidx;
1931 mutex_unlock(&arvif->ar->conf_mutex);
1934 static void ath10k_tx_h_update_wep_key(struct ieee80211_vif *vif,
1935 struct ieee80211_key_conf *key,
1936 struct sk_buff *skb)
1938 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1939 struct ath10k *ar = arvif->ar;
1940 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1942 if (!ieee80211_has_protected(hdr->frame_control))
1948 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1949 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1952 if (key->keyidx == arvif->def_wep_key_idx)
1955 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1956 * queueing frames until key index is updated is not an option because
1957 * sk_buff may need more processing to be done, e.g. offchannel */
1958 arvif->def_wep_key_newidx = key->keyidx;
1959 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1962 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
1963 struct ieee80211_vif *vif,
1964 struct sk_buff *skb)
1966 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1967 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1969 /* This is case only for P2P_GO */
1970 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1971 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1974 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1975 spin_lock_bh(&ar->data_lock);
1976 if (arvif->u.ap.noa_data)
1977 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1979 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1980 arvif->u.ap.noa_data,
1981 arvif->u.ap.noa_len);
1982 spin_unlock_bh(&ar->data_lock);
1986 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1988 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1991 if (ar->htt.target_version_major >= 3) {
1992 /* Since HTT 3.0 there is no separate mgmt tx command */
1993 ret = ath10k_htt_tx(&ar->htt, skb);
1997 if (ieee80211_is_mgmt(hdr->frame_control)) {
1998 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2000 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
2001 ATH10K_MAX_NUM_MGMT_PENDING) {
2002 ath10k_warn(ar, "reached WMI management transmit queue limit\n");
2007 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
2008 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
2010 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2012 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2014 ieee80211_is_nullfunc(hdr->frame_control)) {
2015 /* FW does not report tx status properly for NullFunc frames
2016 * unless they are sent through mgmt tx path. mac80211 sends
2017 * those frames when it detects link/beacon loss and depends
2018 * on the tx status to be correct. */
2019 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2021 ret = ath10k_htt_tx(&ar->htt, skb);
2026 ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
2028 ieee80211_free_txskb(ar->hw, skb);
2032 void ath10k_offchan_tx_purge(struct ath10k *ar)
2034 struct sk_buff *skb;
2037 skb = skb_dequeue(&ar->offchan_tx_queue);
2041 ieee80211_free_txskb(ar->hw, skb);
2045 void ath10k_offchan_tx_work(struct work_struct *work)
2047 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2048 struct ath10k_peer *peer;
2049 struct ieee80211_hdr *hdr;
2050 struct sk_buff *skb;
2051 const u8 *peer_addr;
2055 /* FW requirement: We must create a peer before FW will send out
2056 * an offchannel frame. Otherwise the frame will be stuck and
2057 * never transmitted. We delete the peer upon tx completion.
2058 * It is unlikely that a peer for offchannel tx will already be
2059 * present. However it may be in some rare cases so account for that.
2060 * Otherwise we might remove a legitimate peer and break stuff. */
2063 skb = skb_dequeue(&ar->offchan_tx_queue);
2067 mutex_lock(&ar->conf_mutex);
2069 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2072 hdr = (struct ieee80211_hdr *)skb->data;
2073 peer_addr = ieee80211_get_DA(hdr);
2074 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2076 spin_lock_bh(&ar->data_lock);
2077 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2078 spin_unlock_bh(&ar->data_lock);
2081 /* FIXME: should this use ath10k_warn()? */
2082 ath10k_dbg(ar, ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2083 peer_addr, vdev_id);
2086 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2088 ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
2089 peer_addr, vdev_id, ret);
2092 spin_lock_bh(&ar->data_lock);
2093 reinit_completion(&ar->offchan_tx_completed);
2094 ar->offchan_tx_skb = skb;
2095 spin_unlock_bh(&ar->data_lock);
2097 ath10k_tx_htt(ar, skb);
2099 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2102 ath10k_warn(ar, "timed out waiting for offchannel skb %p\n",
2106 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2108 ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
2109 peer_addr, vdev_id, ret);
2112 mutex_unlock(&ar->conf_mutex);
2116 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2118 struct sk_buff *skb;
2121 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2125 ieee80211_free_txskb(ar->hw, skb);
2129 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2131 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2132 struct sk_buff *skb;
2136 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2140 ret = ath10k_wmi_mgmt_tx(ar, skb);
2142 ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
2144 ieee80211_free_txskb(ar->hw, skb);
2153 void __ath10k_scan_finish(struct ath10k *ar)
2155 lockdep_assert_held(&ar->data_lock);
2157 switch (ar->scan.state) {
2158 case ATH10K_SCAN_IDLE:
2160 case ATH10K_SCAN_RUNNING:
2161 case ATH10K_SCAN_ABORTING:
2162 if (ar->scan.is_roc)
2163 ieee80211_remain_on_channel_expired(ar->hw);
2165 ieee80211_scan_completed(ar->hw,
2167 ATH10K_SCAN_ABORTING));
2169 case ATH10K_SCAN_STARTING:
2170 ar->scan.state = ATH10K_SCAN_IDLE;
2171 ar->scan_channel = NULL;
2172 ath10k_offchan_tx_purge(ar);
2173 cancel_delayed_work(&ar->scan.timeout);
2174 complete_all(&ar->scan.completed);
2179 void ath10k_scan_finish(struct ath10k *ar)
2181 spin_lock_bh(&ar->data_lock);
2182 __ath10k_scan_finish(ar);
2183 spin_unlock_bh(&ar->data_lock);
2186 static int ath10k_scan_stop(struct ath10k *ar)
2188 struct wmi_stop_scan_arg arg = {
2189 .req_id = 1, /* FIXME */
2190 .req_type = WMI_SCAN_STOP_ONE,
2191 .u.scan_id = ATH10K_SCAN_ID,
2195 lockdep_assert_held(&ar->conf_mutex);
2197 ret = ath10k_wmi_stop_scan(ar, &arg);
2199 ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
2203 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2205 ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
2207 } else if (ret > 0) {
2212 /* Scan state should be updated upon scan completion but in case
2213 * firmware fails to deliver the event (for whatever reason) it is
2214 * desired to clean up scan state anyway. Firmware may have just
2215 * dropped the scan completion event delivery due to transport pipe
2216 * being overflown with data and/or it can recover on its own before
2217 * next scan request is submitted.
2219 spin_lock_bh(&ar->data_lock);
2220 if (ar->scan.state != ATH10K_SCAN_IDLE)
2221 __ath10k_scan_finish(ar);
2222 spin_unlock_bh(&ar->data_lock);
2227 static void ath10k_scan_abort(struct ath10k *ar)
2231 lockdep_assert_held(&ar->conf_mutex);
2233 spin_lock_bh(&ar->data_lock);
2235 switch (ar->scan.state) {
2236 case ATH10K_SCAN_IDLE:
2237 /* This can happen if timeout worker kicked in and called
2238 * abortion while scan completion was being processed.
2241 case ATH10K_SCAN_STARTING:
2242 case ATH10K_SCAN_ABORTING:
2243 ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
2244 ath10k_scan_state_str(ar->scan.state),
2247 case ATH10K_SCAN_RUNNING:
2248 ar->scan.state = ATH10K_SCAN_ABORTING;
2249 spin_unlock_bh(&ar->data_lock);
2251 ret = ath10k_scan_stop(ar);
2253 ath10k_warn(ar, "failed to abort scan: %d\n", ret);
2255 spin_lock_bh(&ar->data_lock);
2259 spin_unlock_bh(&ar->data_lock);
2262 void ath10k_scan_timeout_work(struct work_struct *work)
2264 struct ath10k *ar = container_of(work, struct ath10k,
2267 mutex_lock(&ar->conf_mutex);
2268 ath10k_scan_abort(ar);
2269 mutex_unlock(&ar->conf_mutex);
2272 static int ath10k_start_scan(struct ath10k *ar,
2273 const struct wmi_start_scan_arg *arg)
2277 lockdep_assert_held(&ar->conf_mutex);
2279 ret = ath10k_wmi_start_scan(ar, arg);
2283 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2285 ret = ath10k_scan_stop(ar);
2287 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
2292 /* Add a 200ms margin to account for event/command processing */
2293 ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
2294 msecs_to_jiffies(arg->max_scan_time+200));
2298 /**********************/
2299 /* mac80211 callbacks */
2300 /**********************/
2302 static void ath10k_tx(struct ieee80211_hw *hw,
2303 struct ieee80211_tx_control *control,
2304 struct sk_buff *skb)
2306 struct ath10k *ar = hw->priv;
2307 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2308 struct ieee80211_vif *vif = info->control.vif;
2309 struct ieee80211_key_conf *key = info->control.hw_key;
2310 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2312 /* We should disable CCK RATE due to P2P */
2313 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2314 ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2316 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2317 ATH10K_SKB_CB(skb)->htt.tid = ath10k_tx_h_get_tid(hdr);
2318 ATH10K_SKB_CB(skb)->vdev_id = ath10k_tx_h_get_vdev_id(ar, vif);
2320 /* it makes no sense to process injected frames like that */
2321 if (vif && vif->type != NL80211_IFTYPE_MONITOR) {
2322 ath10k_tx_h_nwifi(hw, skb);
2323 ath10k_tx_h_update_wep_key(vif, key, skb);
2324 ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
2325 ath10k_tx_h_seq_no(vif, skb);
2328 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2329 spin_lock_bh(&ar->data_lock);
2330 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2331 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2332 spin_unlock_bh(&ar->data_lock);
2334 ath10k_dbg(ar, ATH10K_DBG_MAC, "queued offchannel skb %p\n",
2337 skb_queue_tail(&ar->offchan_tx_queue, skb);
2338 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2342 ath10k_tx_htt(ar, skb);
2345 /* Must not be called with conf_mutex held as workers can use that also. */
2346 static void ath10k_drain_tx(struct ath10k *ar)
2348 /* make sure rcu-protected mac80211 tx path itself is drained */
2351 ath10k_offchan_tx_purge(ar);
2352 ath10k_mgmt_over_wmi_tx_purge(ar);
2354 cancel_work_sync(&ar->offchan_tx_work);
2355 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2358 void ath10k_halt(struct ath10k *ar)
2360 struct ath10k_vif *arvif;
2362 lockdep_assert_held(&ar->conf_mutex);
2364 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2365 ar->filter_flags = 0;
2366 ar->monitor = false;
2368 if (ar->monitor_started)
2369 ath10k_monitor_stop(ar);
2371 ar->monitor_started = false;
2373 ath10k_scan_finish(ar);
2374 ath10k_peer_cleanup_all(ar);
2375 ath10k_core_stop(ar);
2376 ath10k_hif_power_down(ar);
2378 spin_lock_bh(&ar->data_lock);
2379 list_for_each_entry(arvif, &ar->arvifs, list) {
2383 dma_unmap_single(arvif->ar->dev,
2384 ATH10K_SKB_CB(arvif->beacon)->paddr,
2385 arvif->beacon->len, DMA_TO_DEVICE);
2386 dev_kfree_skb_any(arvif->beacon);
2387 arvif->beacon = NULL;
2389 spin_unlock_bh(&ar->data_lock);
2392 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2394 struct ath10k *ar = hw->priv;
2396 mutex_lock(&ar->conf_mutex);
2398 if (ar->cfg_tx_chainmask) {
2399 *tx_ant = ar->cfg_tx_chainmask;
2400 *rx_ant = ar->cfg_rx_chainmask;
2402 *tx_ant = ar->supp_tx_chainmask;
2403 *rx_ant = ar->supp_rx_chainmask;
2406 mutex_unlock(&ar->conf_mutex);
2411 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2415 lockdep_assert_held(&ar->conf_mutex);
2417 ar->cfg_tx_chainmask = tx_ant;
2418 ar->cfg_rx_chainmask = rx_ant;
2420 if ((ar->state != ATH10K_STATE_ON) &&
2421 (ar->state != ATH10K_STATE_RESTARTED))
2424 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2427 ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
2432 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2435 ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
2443 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2445 struct ath10k *ar = hw->priv;
2448 mutex_lock(&ar->conf_mutex);
2449 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2450 mutex_unlock(&ar->conf_mutex);
2454 static int ath10k_start(struct ieee80211_hw *hw)
2456 struct ath10k *ar = hw->priv;
2460 * This makes sense only when restarting hw. It is harmless to call
2461 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2462 * commands will be submitted while restarting.
2464 ath10k_drain_tx(ar);
2466 mutex_lock(&ar->conf_mutex);
2468 switch (ar->state) {
2469 case ATH10K_STATE_OFF:
2470 ar->state = ATH10K_STATE_ON;
2472 case ATH10K_STATE_RESTARTING:
2474 ar->state = ATH10K_STATE_RESTARTED;
2476 case ATH10K_STATE_ON:
2477 case ATH10K_STATE_RESTARTED:
2478 case ATH10K_STATE_WEDGED:
2482 case ATH10K_STATE_UTF:
2487 ret = ath10k_hif_power_up(ar);
2489 ath10k_err(ar, "Could not init hif: %d\n", ret);
2493 ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL);
2495 ath10k_err(ar, "Could not init core: %d\n", ret);
2496 goto err_power_down;
2499 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2501 ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
2505 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2507 ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
2511 if (ar->cfg_tx_chainmask)
2512 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2513 ar->cfg_rx_chainmask);
2516 * By default FW set ARP frames ac to voice (6). In that case ARP
2517 * exchange is not working properly for UAPSD enabled AP. ARP requests
2518 * which arrives with access category 0 are processed by network stack
2519 * and send back with access category 0, but FW changes access category
2520 * to 6. Set ARP frames access category to best effort (0) solves
2524 ret = ath10k_wmi_pdev_set_param(ar,
2525 ar->wmi.pdev_param->arp_ac_override, 0);
2527 ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
2532 ar->num_started_vdevs = 0;
2533 ath10k_regd_update(ar);
2535 ath10k_spectral_start(ar);
2537 mutex_unlock(&ar->conf_mutex);
2541 ath10k_core_stop(ar);
2544 ath10k_hif_power_down(ar);
2547 ar->state = ATH10K_STATE_OFF;
2550 mutex_unlock(&ar->conf_mutex);
2554 static void ath10k_stop(struct ieee80211_hw *hw)
2556 struct ath10k *ar = hw->priv;
2558 ath10k_drain_tx(ar);
2560 mutex_lock(&ar->conf_mutex);
2561 if (ar->state != ATH10K_STATE_OFF) {
2563 ar->state = ATH10K_STATE_OFF;
2565 mutex_unlock(&ar->conf_mutex);
2567 cancel_delayed_work_sync(&ar->scan.timeout);
2568 cancel_work_sync(&ar->restart_work);
2571 static int ath10k_config_ps(struct ath10k *ar)
2573 struct ath10k_vif *arvif;
2576 lockdep_assert_held(&ar->conf_mutex);
2578 list_for_each_entry(arvif, &ar->arvifs, list) {
2579 ret = ath10k_mac_vif_setup_ps(arvif);
2581 ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
2589 static const char *chandef_get_width(enum nl80211_chan_width width)
2592 case NL80211_CHAN_WIDTH_20_NOHT:
2594 case NL80211_CHAN_WIDTH_20:
2596 case NL80211_CHAN_WIDTH_40:
2598 case NL80211_CHAN_WIDTH_80:
2600 case NL80211_CHAN_WIDTH_80P80:
2602 case NL80211_CHAN_WIDTH_160:
2604 case NL80211_CHAN_WIDTH_5:
2606 case NL80211_CHAN_WIDTH_10:
2612 static void ath10k_config_chan(struct ath10k *ar)
2614 struct ath10k_vif *arvif;
2617 lockdep_assert_held(&ar->conf_mutex);
2619 ath10k_dbg(ar, ATH10K_DBG_MAC,
2620 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2621 ar->chandef.chan->center_freq,
2622 ar->chandef.center_freq1,
2623 ar->chandef.center_freq2,
2624 chandef_get_width(ar->chandef.width));
2626 /* First stop monitor interface. Some FW versions crash if there's a
2627 * lone monitor interface. */
2628 if (ar->monitor_started)
2629 ath10k_monitor_stop(ar);
2631 list_for_each_entry(arvif, &ar->arvifs, list) {
2632 if (!arvif->is_started)
2638 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2641 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
2643 ath10k_warn(ar, "failed to down vdev %d: %d\n",
2644 arvif->vdev_id, ret);
2649 /* all vdevs are downed now - attempt to restart and re-up them */
2651 list_for_each_entry(arvif, &ar->arvifs, list) {
2652 if (!arvif->is_started)
2655 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2658 ret = ath10k_vdev_restart(arvif);
2660 ath10k_warn(ar, "failed to restart vdev %d: %d\n",
2661 arvif->vdev_id, ret);
2668 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2671 ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
2672 arvif->vdev_id, ret);
2677 ath10k_monitor_recalc(ar);
2680 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2682 struct ath10k *ar = hw->priv;
2683 struct ieee80211_conf *conf = &hw->conf;
2687 mutex_lock(&ar->conf_mutex);
2689 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2690 ath10k_dbg(ar, ATH10K_DBG_MAC,
2691 "mac config channel %dMHz flags 0x%x radar %d\n",
2692 conf->chandef.chan->center_freq,
2693 conf->chandef.chan->flags,
2694 conf->radar_enabled);
2696 spin_lock_bh(&ar->data_lock);
2697 ar->rx_channel = conf->chandef.chan;
2698 spin_unlock_bh(&ar->data_lock);
2700 ar->radar_enabled = conf->radar_enabled;
2701 ath10k_recalc_radar_detection(ar);
2703 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2704 ar->chandef = conf->chandef;
2705 ath10k_config_chan(ar);
2709 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2710 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac config power %d\n",
2711 hw->conf.power_level);
2713 param = ar->wmi.pdev_param->txpower_limit2g;
2714 ret = ath10k_wmi_pdev_set_param(ar, param,
2715 hw->conf.power_level * 2);
2717 ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2718 hw->conf.power_level, ret);
2720 param = ar->wmi.pdev_param->txpower_limit5g;
2721 ret = ath10k_wmi_pdev_set_param(ar, param,
2722 hw->conf.power_level * 2);
2724 ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2725 hw->conf.power_level, ret);
2728 if (changed & IEEE80211_CONF_CHANGE_PS)
2729 ath10k_config_ps(ar);
2731 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2732 ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
2733 ret = ath10k_monitor_recalc(ar);
2735 ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
2738 mutex_unlock(&ar->conf_mutex);
2744 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2745 * because we will send mgmt frames without CCK. This requirement
2746 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2749 static int ath10k_add_interface(struct ieee80211_hw *hw,
2750 struct ieee80211_vif *vif)
2752 struct ath10k *ar = hw->priv;
2753 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2754 enum wmi_sta_powersave_param param;
2760 mutex_lock(&ar->conf_mutex);
2762 memset(arvif, 0, sizeof(*arvif));
2767 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2768 INIT_LIST_HEAD(&arvif->list);
2770 if (ar->free_vdev_map == 0) {
2771 ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
2775 bit = ffs(ar->free_vdev_map);
2777 arvif->vdev_id = bit - 1;
2778 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2781 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2783 switch (vif->type) {
2784 case NL80211_IFTYPE_UNSPECIFIED:
2785 case NL80211_IFTYPE_STATION:
2786 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2788 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2790 case NL80211_IFTYPE_ADHOC:
2791 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2793 case NL80211_IFTYPE_AP:
2794 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2797 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2799 case NL80211_IFTYPE_MONITOR:
2800 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2807 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2808 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2810 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2811 arvif->vdev_subtype, vif->addr);
2813 ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
2814 arvif->vdev_id, ret);
2818 ar->free_vdev_map &= ~(1 << arvif->vdev_id);
2819 list_add(&arvif->list, &ar->arvifs);
2821 vdev_param = ar->wmi.vdev_param->def_keyid;
2822 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2823 arvif->def_wep_key_idx);
2825 ath10k_warn(ar, "failed to set vdev %i default key id: %d\n",
2826 arvif->vdev_id, ret);
2827 goto err_vdev_delete;
2830 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2831 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2832 ATH10K_HW_TXRX_NATIVE_WIFI);
2833 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2834 if (ret && ret != -EOPNOTSUPP) {
2835 ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
2836 arvif->vdev_id, ret);
2837 goto err_vdev_delete;
2840 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2841 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2843 ath10k_warn(ar, "failed to create vdev %i peer for AP: %d\n",
2844 arvif->vdev_id, ret);
2845 goto err_vdev_delete;
2848 ret = ath10k_mac_set_kickout(arvif);
2850 ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
2851 arvif->vdev_id, ret);
2852 goto err_peer_delete;
2856 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2857 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2858 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2859 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2862 ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
2863 arvif->vdev_id, ret);
2864 goto err_peer_delete;
2867 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2868 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2869 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2872 ath10k_warn(ar, "failed to set vdev %i TX wake thresh: %d\n",
2873 arvif->vdev_id, ret);
2874 goto err_peer_delete;
2877 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2878 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2879 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2882 ath10k_warn(ar, "failed to set vdev %i PSPOLL count: %d\n",
2883 arvif->vdev_id, ret);
2884 goto err_peer_delete;
2888 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2890 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
2891 arvif->vdev_id, ret);
2892 goto err_peer_delete;
2895 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2897 ath10k_warn(ar, "failed to set frag threshold for vdev %d: %d\n",
2898 arvif->vdev_id, ret);
2899 goto err_peer_delete;
2902 mutex_unlock(&ar->conf_mutex);
2906 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2907 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2910 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2911 ar->free_vdev_map |= 1 << arvif->vdev_id;
2912 list_del(&arvif->list);
2915 mutex_unlock(&ar->conf_mutex);
2920 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2921 struct ieee80211_vif *vif)
2923 struct ath10k *ar = hw->priv;
2924 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2927 mutex_lock(&ar->conf_mutex);
2929 cancel_work_sync(&arvif->wep_key_work);
2931 spin_lock_bh(&ar->data_lock);
2932 if (arvif->beacon) {
2933 dma_unmap_single(arvif->ar->dev,
2934 ATH10K_SKB_CB(arvif->beacon)->paddr,
2935 arvif->beacon->len, DMA_TO_DEVICE);
2936 dev_kfree_skb_any(arvif->beacon);
2937 arvif->beacon = NULL;
2940 spin_unlock_bh(&ar->data_lock);
2942 ret = ath10k_spectral_vif_stop(arvif);
2944 ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
2945 arvif->vdev_id, ret);
2947 ar->free_vdev_map |= 1 << arvif->vdev_id;
2948 list_del(&arvif->list);
2950 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2951 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2953 ath10k_warn(ar, "failed to remove peer for AP vdev %i: %d\n",
2954 arvif->vdev_id, ret);
2956 kfree(arvif->u.ap.noa_data);
2959 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
2962 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2964 ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
2965 arvif->vdev_id, ret);
2967 ath10k_peer_cleanup(ar, arvif->vdev_id);
2969 mutex_unlock(&ar->conf_mutex);
2973 * FIXME: Has to be verified.
2975 #define SUPPORTED_FILTERS \
2976 (FIF_PROMISC_IN_BSS | \
2981 FIF_BCN_PRBRESP_PROMISC | \
2985 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2986 unsigned int changed_flags,
2987 unsigned int *total_flags,
2990 struct ath10k *ar = hw->priv;
2993 mutex_lock(&ar->conf_mutex);
2995 changed_flags &= SUPPORTED_FILTERS;
2996 *total_flags &= SUPPORTED_FILTERS;
2997 ar->filter_flags = *total_flags;
2999 ret = ath10k_monitor_recalc(ar);
3001 ath10k_warn(ar, "failed to recalc montior: %d\n", ret);
3003 mutex_unlock(&ar->conf_mutex);
3006 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
3007 struct ieee80211_vif *vif,
3008 struct ieee80211_bss_conf *info,
3011 struct ath10k *ar = hw->priv;
3012 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3014 u32 vdev_param, pdev_param, slottime, preamble;
3016 mutex_lock(&ar->conf_mutex);
3018 if (changed & BSS_CHANGED_IBSS)
3019 ath10k_control_ibss(arvif, info, vif->addr);
3021 if (changed & BSS_CHANGED_BEACON_INT) {
3022 arvif->beacon_interval = info->beacon_int;
3023 vdev_param = ar->wmi.vdev_param->beacon_interval;
3024 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3025 arvif->beacon_interval);
3026 ath10k_dbg(ar, ATH10K_DBG_MAC,
3027 "mac vdev %d beacon_interval %d\n",
3028 arvif->vdev_id, arvif->beacon_interval);
3031 ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
3032 arvif->vdev_id, ret);
3035 if (changed & BSS_CHANGED_BEACON) {
3036 ath10k_dbg(ar, ATH10K_DBG_MAC,
3037 "vdev %d set beacon tx mode to staggered\n",
3040 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
3041 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
3042 WMI_BEACON_STAGGERED_MODE);
3044 ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
3045 arvif->vdev_id, ret);
3048 if (changed & BSS_CHANGED_BEACON_INFO) {
3049 arvif->dtim_period = info->dtim_period;
3051 ath10k_dbg(ar, ATH10K_DBG_MAC,
3052 "mac vdev %d dtim_period %d\n",
3053 arvif->vdev_id, arvif->dtim_period);
3055 vdev_param = ar->wmi.vdev_param->dtim_period;
3056 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3057 arvif->dtim_period);
3059 ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
3060 arvif->vdev_id, ret);
3063 if (changed & BSS_CHANGED_SSID &&
3064 vif->type == NL80211_IFTYPE_AP) {
3065 arvif->u.ap.ssid_len = info->ssid_len;
3067 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3068 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3072 * Firmware manages AP self-peer internally so make sure to not create
3073 * it in driver. Otherwise AP self-peer deletion may timeout later.
3075 if (changed & BSS_CHANGED_BSSID &&
3076 vif->type != NL80211_IFTYPE_AP) {
3077 if (!is_zero_ether_addr(info->bssid)) {
3078 ath10k_dbg(ar, ATH10K_DBG_MAC,
3079 "mac vdev %d create peer %pM\n",
3080 arvif->vdev_id, info->bssid);
3082 ret = ath10k_peer_create(ar, arvif->vdev_id,
3085 ath10k_warn(ar, "failed to add peer %pM for vdev %d when changing bssid: %i\n",
3086 info->bssid, arvif->vdev_id, ret);
3088 if (vif->type == NL80211_IFTYPE_STATION) {
3090 * this is never erased as we it for crypto key
3091 * clearing; this is FW requirement
3093 ether_addr_copy(arvif->bssid, info->bssid);
3095 ath10k_dbg(ar, ATH10K_DBG_MAC,
3096 "mac vdev %d start %pM\n",
3097 arvif->vdev_id, info->bssid);
3099 ret = ath10k_vdev_start(arvif);
3101 ath10k_warn(ar, "failed to start vdev %i: %d\n",
3102 arvif->vdev_id, ret);
3106 arvif->is_started = true;
3110 * Mac80211 does not keep IBSS bssid when leaving IBSS,
3111 * so driver need to store it. It is needed when leaving
3112 * IBSS in order to remove BSSID peer.
3114 if (vif->type == NL80211_IFTYPE_ADHOC)
3115 memcpy(arvif->bssid, info->bssid,
3120 if (changed & BSS_CHANGED_BEACON_ENABLED)
3121 ath10k_control_beaconing(arvif, info);
3123 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3124 arvif->use_cts_prot = info->use_cts_prot;
3125 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3126 arvif->vdev_id, info->use_cts_prot);
3128 ret = ath10k_recalc_rtscts_prot(arvif);
3130 ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3131 arvif->vdev_id, ret);
3134 if (changed & BSS_CHANGED_ERP_SLOT) {
3135 if (info->use_short_slot)
3136 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3139 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3141 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3142 arvif->vdev_id, slottime);
3144 vdev_param = ar->wmi.vdev_param->slot_time;
3145 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3148 ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
3149 arvif->vdev_id, ret);
3152 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3153 if (info->use_short_preamble)
3154 preamble = WMI_VDEV_PREAMBLE_SHORT;
3156 preamble = WMI_VDEV_PREAMBLE_LONG;
3158 ath10k_dbg(ar, ATH10K_DBG_MAC,
3159 "mac vdev %d preamble %dn",
3160 arvif->vdev_id, preamble);
3162 vdev_param = ar->wmi.vdev_param->preamble;
3163 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3166 ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
3167 arvif->vdev_id, ret);
3170 if (changed & BSS_CHANGED_ASSOC) {
3172 /* Workaround: Make sure monitor vdev is not running
3173 * when associating to prevent some firmware revisions
3174 * (e.g. 10.1 and 10.2) from crashing.
3176 if (ar->monitor_started)
3177 ath10k_monitor_stop(ar);
3178 ath10k_bss_assoc(hw, vif, info);
3179 ath10k_monitor_recalc(ar);
3184 mutex_unlock(&ar->conf_mutex);
3187 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3188 struct ieee80211_vif *vif,
3189 struct ieee80211_scan_request *hw_req)
3191 struct ath10k *ar = hw->priv;
3192 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3193 struct cfg80211_scan_request *req = &hw_req->req;
3194 struct wmi_start_scan_arg arg;
3198 mutex_lock(&ar->conf_mutex);
3200 spin_lock_bh(&ar->data_lock);
3201 switch (ar->scan.state) {
3202 case ATH10K_SCAN_IDLE:
3203 reinit_completion(&ar->scan.started);
3204 reinit_completion(&ar->scan.completed);
3205 ar->scan.state = ATH10K_SCAN_STARTING;
3206 ar->scan.is_roc = false;
3207 ar->scan.vdev_id = arvif->vdev_id;
3210 case ATH10K_SCAN_STARTING:
3211 case ATH10K_SCAN_RUNNING:
3212 case ATH10K_SCAN_ABORTING:
3216 spin_unlock_bh(&ar->data_lock);
3221 memset(&arg, 0, sizeof(arg));
3222 ath10k_wmi_start_scan_init(ar, &arg);
3223 arg.vdev_id = arvif->vdev_id;
3224 arg.scan_id = ATH10K_SCAN_ID;
3227 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3230 arg.ie_len = req->ie_len;
3231 memcpy(arg.ie, req->ie, arg.ie_len);
3235 arg.n_ssids = req->n_ssids;
3236 for (i = 0; i < arg.n_ssids; i++) {
3237 arg.ssids[i].len = req->ssids[i].ssid_len;
3238 arg.ssids[i].ssid = req->ssids[i].ssid;
3241 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3244 if (req->n_channels) {
3245 arg.n_channels = req->n_channels;
3246 for (i = 0; i < arg.n_channels; i++)
3247 arg.channels[i] = req->channels[i]->center_freq;
3250 ret = ath10k_start_scan(ar, &arg);
3252 ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
3253 spin_lock_bh(&ar->data_lock);
3254 ar->scan.state = ATH10K_SCAN_IDLE;
3255 spin_unlock_bh(&ar->data_lock);
3259 mutex_unlock(&ar->conf_mutex);
3263 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3264 struct ieee80211_vif *vif)
3266 struct ath10k *ar = hw->priv;
3268 mutex_lock(&ar->conf_mutex);
3269 cancel_delayed_work_sync(&ar->scan.timeout);
3270 ath10k_scan_abort(ar);
3271 mutex_unlock(&ar->conf_mutex);
3274 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3275 struct ath10k_vif *arvif,
3276 enum set_key_cmd cmd,
3277 struct ieee80211_key_conf *key)
3279 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3282 /* 10.1 firmware branch requires default key index to be set to group
3283 * key index after installing it. Otherwise FW/HW Txes corrupted
3284 * frames with multi-vif APs. This is not required for main firmware
3285 * branch (e.g. 636).
3287 * FIXME: This has been tested only in AP. It remains unknown if this
3288 * is required for multi-vif STA interfaces on 10.1 */
3290 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3293 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3296 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3299 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3305 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3308 ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
3309 arvif->vdev_id, ret);
3312 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3313 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3314 struct ieee80211_key_conf *key)
3316 struct ath10k *ar = hw->priv;
3317 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3318 struct ath10k_peer *peer;
3319 const u8 *peer_addr;
3320 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3321 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3324 if (key->keyidx > WMI_MAX_KEY_INDEX)
3327 mutex_lock(&ar->conf_mutex);
3330 peer_addr = sta->addr;
3331 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3332 peer_addr = vif->bss_conf.bssid;
3334 peer_addr = vif->addr;
3336 key->hw_key_idx = key->keyidx;
3338 /* the peer should not disappear in mid-way (unless FW goes awry) since
3339 * we already hold conf_mutex. we just make sure its there now. */
3340 spin_lock_bh(&ar->data_lock);
3341 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3342 spin_unlock_bh(&ar->data_lock);
3345 if (cmd == SET_KEY) {
3346 ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
3351 /* if the peer doesn't exist there is no key to disable
3359 arvif->wep_keys[key->keyidx] = key;
3361 arvif->wep_keys[key->keyidx] = NULL;
3363 if (cmd == DISABLE_KEY)
3364 ath10k_clear_vdev_key(arvif, key);
3367 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3369 ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
3370 arvif->vdev_id, peer_addr, ret);
3374 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3376 spin_lock_bh(&ar->data_lock);
3377 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3378 if (peer && cmd == SET_KEY)
3379 peer->keys[key->keyidx] = key;
3380 else if (peer && cmd == DISABLE_KEY)
3381 peer->keys[key->keyidx] = NULL;
3382 else if (peer == NULL)
3383 /* impossible unless FW goes crazy */
3384 ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
3385 spin_unlock_bh(&ar->data_lock);
3388 mutex_unlock(&ar->conf_mutex);
3392 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3395 struct ath10k_vif *arvif;
3396 struct ath10k_sta *arsta;
3397 struct ieee80211_sta *sta;
3398 u32 changed, bw, nss, smps;
3401 arsta = container_of(wk, struct ath10k_sta, update_wk);
3402 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3403 arvif = arsta->arvif;
3406 spin_lock_bh(&ar->data_lock);
3408 changed = arsta->changed;
3415 spin_unlock_bh(&ar->data_lock);
3417 mutex_lock(&ar->conf_mutex);
3419 if (changed & IEEE80211_RC_BW_CHANGED) {
3420 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3423 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3424 WMI_PEER_CHAN_WIDTH, bw);
3426 ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
3427 sta->addr, bw, err);
3430 if (changed & IEEE80211_RC_NSS_CHANGED) {
3431 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3434 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3437 ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
3438 sta->addr, nss, err);
3441 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3442 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3445 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3446 WMI_PEER_SMPS_STATE, smps);
3448 ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
3449 sta->addr, smps, err);
3452 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3453 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3456 err = ath10k_station_assoc(ar, arvif, sta, true);
3458 ath10k_warn(ar, "failed to reassociate station: %pM\n",
3462 mutex_unlock(&ar->conf_mutex);
3465 static int ath10k_sta_state(struct ieee80211_hw *hw,
3466 struct ieee80211_vif *vif,
3467 struct ieee80211_sta *sta,
3468 enum ieee80211_sta_state old_state,
3469 enum ieee80211_sta_state new_state)
3471 struct ath10k *ar = hw->priv;
3472 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3473 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3477 if (old_state == IEEE80211_STA_NOTEXIST &&
3478 new_state == IEEE80211_STA_NONE) {
3479 memset(arsta, 0, sizeof(*arsta));
3480 arsta->arvif = arvif;
3481 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3484 /* cancel must be done outside the mutex to avoid deadlock */
3485 if ((old_state == IEEE80211_STA_NONE &&
3486 new_state == IEEE80211_STA_NOTEXIST))
3487 cancel_work_sync(&arsta->update_wk);
3489 mutex_lock(&ar->conf_mutex);
3491 if (old_state == IEEE80211_STA_NOTEXIST &&
3492 new_state == IEEE80211_STA_NONE &&
3493 vif->type != NL80211_IFTYPE_STATION) {
3495 * New station addition.
3497 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3498 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3500 max_num_peers = TARGET_NUM_PEERS;
3502 if (ar->num_peers >= max_num_peers) {
3503 ath10k_warn(ar, "number of peers exceeded: peers number %d (max peers %d)\n",
3504 ar->num_peers, max_num_peers);
3509 ath10k_dbg(ar, ATH10K_DBG_MAC,
3510 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3511 arvif->vdev_id, sta->addr, ar->num_peers);
3513 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3515 ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3516 sta->addr, arvif->vdev_id, ret);
3517 } else if ((old_state == IEEE80211_STA_NONE &&
3518 new_state == IEEE80211_STA_NOTEXIST)) {
3520 * Existing station deletion.
3522 ath10k_dbg(ar, ATH10K_DBG_MAC,
3523 "mac vdev %d peer delete %pM (sta gone)\n",
3524 arvif->vdev_id, sta->addr);
3525 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3527 ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
3528 sta->addr, arvif->vdev_id, ret);
3530 if (vif->type == NL80211_IFTYPE_STATION)
3531 ath10k_bss_disassoc(hw, vif);
3532 } else if (old_state == IEEE80211_STA_AUTH &&
3533 new_state == IEEE80211_STA_ASSOC &&
3534 (vif->type == NL80211_IFTYPE_AP ||
3535 vif->type == NL80211_IFTYPE_ADHOC)) {
3539 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM associated\n",
3542 ret = ath10k_station_assoc(ar, arvif, sta, false);
3544 ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
3545 sta->addr, arvif->vdev_id, ret);
3546 } else if (old_state == IEEE80211_STA_ASSOC &&
3547 new_state == IEEE80211_STA_AUTH &&
3548 (vif->type == NL80211_IFTYPE_AP ||
3549 vif->type == NL80211_IFTYPE_ADHOC)) {
3553 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3556 ret = ath10k_station_disassoc(ar, arvif, sta);
3558 ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
3559 sta->addr, arvif->vdev_id, ret);
3562 mutex_unlock(&ar->conf_mutex);
3566 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3567 u16 ac, bool enable)
3569 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3573 lockdep_assert_held(&ar->conf_mutex);
3575 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3579 case IEEE80211_AC_VO:
3580 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3581 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3583 case IEEE80211_AC_VI:
3584 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3585 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3587 case IEEE80211_AC_BE:
3588 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3589 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3591 case IEEE80211_AC_BK:
3592 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3593 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3598 arvif->u.sta.uapsd |= value;
3600 arvif->u.sta.uapsd &= ~value;
3602 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3603 WMI_STA_PS_PARAM_UAPSD,
3604 arvif->u.sta.uapsd);
3606 ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
3610 if (arvif->u.sta.uapsd)
3611 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3613 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3615 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3616 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3619 ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
3625 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3626 struct ieee80211_vif *vif, u16 ac,
3627 const struct ieee80211_tx_queue_params *params)
3629 struct ath10k *ar = hw->priv;
3630 struct wmi_wmm_params_arg *p = NULL;
3633 mutex_lock(&ar->conf_mutex);
3636 case IEEE80211_AC_VO:
3637 p = &ar->wmm_params.ac_vo;
3639 case IEEE80211_AC_VI:
3640 p = &ar->wmm_params.ac_vi;
3642 case IEEE80211_AC_BE:
3643 p = &ar->wmm_params.ac_be;
3645 case IEEE80211_AC_BK:
3646 p = &ar->wmm_params.ac_bk;
3655 p->cwmin = params->cw_min;
3656 p->cwmax = params->cw_max;
3657 p->aifs = params->aifs;
3660 * The channel time duration programmed in the HW is in absolute
3661 * microseconds, while mac80211 gives the txop in units of
3664 p->txop = params->txop * 32;
3666 /* FIXME: FW accepts wmm params per hw, not per vif */
3667 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3669 ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
3673 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3675 ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
3678 mutex_unlock(&ar->conf_mutex);
3682 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3684 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3685 struct ieee80211_vif *vif,
3686 struct ieee80211_channel *chan,
3688 enum ieee80211_roc_type type)
3690 struct ath10k *ar = hw->priv;
3691 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3692 struct wmi_start_scan_arg arg;
3695 mutex_lock(&ar->conf_mutex);
3697 spin_lock_bh(&ar->data_lock);
3698 switch (ar->scan.state) {
3699 case ATH10K_SCAN_IDLE:
3700 reinit_completion(&ar->scan.started);
3701 reinit_completion(&ar->scan.completed);
3702 reinit_completion(&ar->scan.on_channel);
3703 ar->scan.state = ATH10K_SCAN_STARTING;
3704 ar->scan.is_roc = true;
3705 ar->scan.vdev_id = arvif->vdev_id;
3706 ar->scan.roc_freq = chan->center_freq;
3709 case ATH10K_SCAN_STARTING:
3710 case ATH10K_SCAN_RUNNING:
3711 case ATH10K_SCAN_ABORTING:
3715 spin_unlock_bh(&ar->data_lock);
3720 memset(&arg, 0, sizeof(arg));
3721 ath10k_wmi_start_scan_init(ar, &arg);
3722 arg.vdev_id = arvif->vdev_id;
3723 arg.scan_id = ATH10K_SCAN_ID;
3725 arg.channels[0] = chan->center_freq;
3726 arg.dwell_time_active = duration;
3727 arg.dwell_time_passive = duration;
3728 arg.max_scan_time = 2 * duration;
3729 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3730 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3732 ret = ath10k_start_scan(ar, &arg);
3734 ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
3735 spin_lock_bh(&ar->data_lock);
3736 ar->scan.state = ATH10K_SCAN_IDLE;
3737 spin_unlock_bh(&ar->data_lock);
3741 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3743 ath10k_warn(ar, "failed to switch to channel for roc scan\n");
3745 ret = ath10k_scan_stop(ar);
3747 ath10k_warn(ar, "failed to stop scan: %d\n", ret);
3755 mutex_unlock(&ar->conf_mutex);
3759 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3761 struct ath10k *ar = hw->priv;
3763 mutex_lock(&ar->conf_mutex);
3764 cancel_delayed_work_sync(&ar->scan.timeout);
3765 ath10k_scan_abort(ar);
3766 mutex_unlock(&ar->conf_mutex);
3772 * Both RTS and Fragmentation threshold are interface-specific
3773 * in ath10k, but device-specific in mac80211.
3776 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3778 struct ath10k *ar = hw->priv;
3779 struct ath10k_vif *arvif;
3782 mutex_lock(&ar->conf_mutex);
3783 list_for_each_entry(arvif, &ar->arvifs, list) {
3784 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3785 arvif->vdev_id, value);
3787 ret = ath10k_mac_set_rts(arvif, value);
3789 ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
3790 arvif->vdev_id, ret);
3794 mutex_unlock(&ar->conf_mutex);
3799 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3801 struct ath10k *ar = hw->priv;
3802 struct ath10k_vif *arvif;
3805 mutex_lock(&ar->conf_mutex);
3806 list_for_each_entry(arvif, &ar->arvifs, list) {
3807 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3808 arvif->vdev_id, value);
3810 ret = ath10k_mac_set_rts(arvif, value);
3812 ath10k_warn(ar, "failed to set fragmentation threshold for vdev %d: %d\n",
3813 arvif->vdev_id, ret);
3817 mutex_unlock(&ar->conf_mutex);
3822 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3823 u32 queues, bool drop)
3825 struct ath10k *ar = hw->priv;
3829 /* mac80211 doesn't care if we really xmit queued frames or not
3830 * we'll collect those frames either way if we stop/delete vdevs */
3834 mutex_lock(&ar->conf_mutex);
3836 if (ar->state == ATH10K_STATE_WEDGED)
3839 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3842 spin_lock_bh(&ar->htt.tx_lock);
3843 empty = (ar->htt.num_pending_tx == 0);
3844 spin_unlock_bh(&ar->htt.tx_lock);
3846 skip = (ar->state == ATH10K_STATE_WEDGED);
3849 }), ATH10K_FLUSH_TIMEOUT_HZ);
3851 if (ret <= 0 || skip)
3852 ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %i\n",
3853 skip, ar->state, ret);
3856 mutex_unlock(&ar->conf_mutex);
3859 /* TODO: Implement this function properly
3860 * For now it is needed to reply to Probe Requests in IBSS mode.
3861 * Propably we need this information from FW.
3863 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3869 static int ath10k_suspend(struct ieee80211_hw *hw,
3870 struct cfg80211_wowlan *wowlan)
3872 struct ath10k *ar = hw->priv;
3875 mutex_lock(&ar->conf_mutex);
3877 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
3879 if (ret == -ETIMEDOUT)
3885 ret = ath10k_hif_suspend(ar);
3887 ath10k_warn(ar, "failed to suspend hif: %d\n", ret);
3894 ret = ath10k_wmi_pdev_resume_target(ar);
3896 ath10k_warn(ar, "failed to resume target: %d\n", ret);
3900 mutex_unlock(&ar->conf_mutex);
3904 static int ath10k_resume(struct ieee80211_hw *hw)
3906 struct ath10k *ar = hw->priv;
3909 mutex_lock(&ar->conf_mutex);
3911 ret = ath10k_hif_resume(ar);
3913 ath10k_warn(ar, "failed to resume hif: %d\n", ret);
3918 ret = ath10k_wmi_pdev_resume_target(ar);
3920 ath10k_warn(ar, "failed to resume target: %d\n", ret);
3927 mutex_unlock(&ar->conf_mutex);
3932 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3934 struct ath10k *ar = hw->priv;
3936 mutex_lock(&ar->conf_mutex);
3938 /* If device failed to restart it will be in a different state, e.g.
3939 * ATH10K_STATE_WEDGED */
3940 if (ar->state == ATH10K_STATE_RESTARTED) {
3941 ath10k_info(ar, "device successfully recovered\n");
3942 ar->state = ATH10K_STATE_ON;
3945 mutex_unlock(&ar->conf_mutex);
3948 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3949 struct survey_info *survey)
3951 struct ath10k *ar = hw->priv;
3952 struct ieee80211_supported_band *sband;
3953 struct survey_info *ar_survey = &ar->survey[idx];
3956 mutex_lock(&ar->conf_mutex);
3958 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3959 if (sband && idx >= sband->n_channels) {
3960 idx -= sband->n_channels;
3965 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3967 if (!sband || idx >= sband->n_channels) {
3972 spin_lock_bh(&ar->data_lock);
3973 memcpy(survey, ar_survey, sizeof(*survey));
3974 spin_unlock_bh(&ar->data_lock);
3976 survey->channel = &sband->channels[idx];
3979 mutex_unlock(&ar->conf_mutex);
3983 /* Helper table for legacy fixed_rate/bitrate_mask */
3984 static const u8 cck_ofdm_rate[] = {
4001 /* Check if only one bit set */
4002 static int ath10k_check_single_mask(u32 mask)
4010 mask &= ~BIT(bit - 1);
4018 ath10k_default_bitrate_mask(struct ath10k *ar,
4019 enum ieee80211_band band,
4020 const struct cfg80211_bitrate_mask *mask)
4022 u32 legacy = 0x00ff;
4027 case IEEE80211_BAND_2GHZ:
4031 case IEEE80211_BAND_5GHZ:
4037 if (mask->control[band].legacy != legacy)
4040 for (i = 0; i < ar->num_rf_chains; i++)
4041 if (mask->control[band].ht_mcs[i] != ht)
4044 for (i = 0; i < ar->num_rf_chains; i++)
4045 if (mask->control[band].vht_mcs[i] != vht)
4052 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
4053 enum ieee80211_band band,
4056 int ht_nss = 0, vht_nss = 0, i;
4059 if (ath10k_check_single_mask(mask->control[band].legacy))
4063 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4064 if (mask->control[band].ht_mcs[i] == 0xff)
4066 else if (mask->control[band].ht_mcs[i] == 0x00)
4075 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4076 if (mask->control[band].vht_mcs[i] == 0x03ff)
4078 else if (mask->control[band].vht_mcs[i] == 0x0000)
4086 if (ht_nss > 0 && vht_nss > 0)
4090 *fixed_nss = ht_nss;
4092 *fixed_nss = vht_nss;
4100 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4101 enum ieee80211_band band,
4102 enum wmi_rate_preamble *preamble)
4104 int legacy = 0, ht = 0, vht = 0, i;
4106 *preamble = WMI_RATE_PREAMBLE_OFDM;
4109 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4114 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4115 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4120 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4121 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4125 /* Currently we support only one fixed_rate */
4126 if ((legacy + ht + vht) != 1)
4130 *preamble = WMI_RATE_PREAMBLE_HT;
4132 *preamble = WMI_RATE_PREAMBLE_VHT;
4138 ath10k_bitrate_mask_rate(struct ath10k *ar,
4139 const struct cfg80211_bitrate_mask *mask,
4140 enum ieee80211_band band,
4144 u8 rate = 0, pream = 0, nss = 0, i;
4145 enum wmi_rate_preamble preamble;
4147 /* Check if single rate correct */
4148 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4154 case WMI_RATE_PREAMBLE_CCK:
4155 case WMI_RATE_PREAMBLE_OFDM:
4156 i = ffs(mask->control[band].legacy) - 1;
4158 if (band == IEEE80211_BAND_2GHZ && i < 4)
4159 pream = WMI_RATE_PREAMBLE_CCK;
4161 if (band == IEEE80211_BAND_5GHZ)
4164 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4167 rate = cck_ofdm_rate[i];
4169 case WMI_RATE_PREAMBLE_HT:
4170 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4171 if (mask->control[band].ht_mcs[i])
4174 if (i == IEEE80211_HT_MCS_MASK_LEN)
4177 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4180 case WMI_RATE_PREAMBLE_VHT:
4181 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4182 if (mask->control[band].vht_mcs[i])
4185 if (i == NL80211_VHT_NSS_MAX)
4188 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4193 *fixed_nss = nss + 1;
4197 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4200 *fixed_rate = pream | nss | rate;
4205 static bool ath10k_get_fixed_rate_nss(struct ath10k *ar,
4206 const struct cfg80211_bitrate_mask *mask,
4207 enum ieee80211_band band,
4211 /* First check full NSS mask, if we can simply limit NSS */
4212 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4215 /* Next Check single rate is set */
4216 return ath10k_bitrate_mask_rate(ar, mask, band, fixed_rate, fixed_nss);
4219 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4224 struct ath10k *ar = arvif->ar;
4228 mutex_lock(&ar->conf_mutex);
4230 if (arvif->fixed_rate == fixed_rate &&
4231 arvif->fixed_nss == fixed_nss &&
4232 arvif->force_sgi == force_sgi)
4235 if (fixed_rate == WMI_FIXED_RATE_NONE)
4236 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4239 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac force sgi\n");
4241 vdev_param = ar->wmi.vdev_param->fixed_rate;
4242 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4243 vdev_param, fixed_rate);
4245 ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
4251 arvif->fixed_rate = fixed_rate;
4253 vdev_param = ar->wmi.vdev_param->nss;
4254 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4255 vdev_param, fixed_nss);
4258 ath10k_warn(ar, "failed to set fixed nss param %d: %d\n",
4264 arvif->fixed_nss = fixed_nss;
4266 vdev_param = ar->wmi.vdev_param->sgi;
4267 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4271 ath10k_warn(ar, "failed to set sgi param %d: %d\n",
4277 arvif->force_sgi = force_sgi;
4280 mutex_unlock(&ar->conf_mutex);
4284 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4285 struct ieee80211_vif *vif,
4286 const struct cfg80211_bitrate_mask *mask)
4288 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4289 struct ath10k *ar = arvif->ar;
4290 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4291 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4292 u8 fixed_nss = ar->num_rf_chains;
4295 force_sgi = mask->control[band].gi;
4296 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4299 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4300 if (!ath10k_get_fixed_rate_nss(ar, mask, band,
4306 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4307 ath10k_warn(ar, "failed to force SGI usage for default rate settings\n");
4311 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4312 fixed_nss, force_sgi);
4315 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4316 struct ieee80211_vif *vif,
4317 struct ieee80211_sta *sta,
4320 struct ath10k *ar = hw->priv;
4321 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4324 spin_lock_bh(&ar->data_lock);
4326 ath10k_dbg(ar, ATH10K_DBG_MAC,
4327 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4328 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4331 if (changed & IEEE80211_RC_BW_CHANGED) {
4332 bw = WMI_PEER_CHWIDTH_20MHZ;
4334 switch (sta->bandwidth) {
4335 case IEEE80211_STA_RX_BW_20:
4336 bw = WMI_PEER_CHWIDTH_20MHZ;
4338 case IEEE80211_STA_RX_BW_40:
4339 bw = WMI_PEER_CHWIDTH_40MHZ;
4341 case IEEE80211_STA_RX_BW_80:
4342 bw = WMI_PEER_CHWIDTH_80MHZ;
4344 case IEEE80211_STA_RX_BW_160:
4345 ath10k_warn(ar, "Invalid bandwith %d in rc update for %pM\n",
4346 sta->bandwidth, sta->addr);
4347 bw = WMI_PEER_CHWIDTH_20MHZ;
4354 if (changed & IEEE80211_RC_NSS_CHANGED)
4355 arsta->nss = sta->rx_nss;
4357 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4358 smps = WMI_PEER_SMPS_PS_NONE;
4360 switch (sta->smps_mode) {
4361 case IEEE80211_SMPS_AUTOMATIC:
4362 case IEEE80211_SMPS_OFF:
4363 smps = WMI_PEER_SMPS_PS_NONE;
4365 case IEEE80211_SMPS_STATIC:
4366 smps = WMI_PEER_SMPS_STATIC;
4368 case IEEE80211_SMPS_DYNAMIC:
4369 smps = WMI_PEER_SMPS_DYNAMIC;
4371 case IEEE80211_SMPS_NUM_MODES:
4372 ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
4373 sta->smps_mode, sta->addr);
4374 smps = WMI_PEER_SMPS_PS_NONE;
4381 arsta->changed |= changed;
4383 spin_unlock_bh(&ar->data_lock);
4385 ieee80211_queue_work(hw, &arsta->update_wk);
4388 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4391 * FIXME: Return 0 for time being. Need to figure out whether FW
4392 * has the API to fetch 64-bit local TSF
4398 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
4399 struct ieee80211_vif *vif,
4400 enum ieee80211_ampdu_mlme_action action,
4401 struct ieee80211_sta *sta, u16 tid, u16 *ssn,
4404 struct ath10k *ar = hw->priv;
4405 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4407 ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
4408 arvif->vdev_id, sta->addr, tid, action);
4411 case IEEE80211_AMPDU_RX_START:
4412 case IEEE80211_AMPDU_RX_STOP:
4413 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
4414 * creation/removal. Do we need to verify this?
4417 case IEEE80211_AMPDU_TX_START:
4418 case IEEE80211_AMPDU_TX_STOP_CONT:
4419 case IEEE80211_AMPDU_TX_STOP_FLUSH:
4420 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
4421 case IEEE80211_AMPDU_TX_OPERATIONAL:
4422 /* Firmware offloads Tx aggregation entirely so deny mac80211
4423 * Tx aggregation requests.
4431 static const struct ieee80211_ops ath10k_ops = {
4433 .start = ath10k_start,
4434 .stop = ath10k_stop,
4435 .config = ath10k_config,
4436 .add_interface = ath10k_add_interface,
4437 .remove_interface = ath10k_remove_interface,
4438 .configure_filter = ath10k_configure_filter,
4439 .bss_info_changed = ath10k_bss_info_changed,
4440 .hw_scan = ath10k_hw_scan,
4441 .cancel_hw_scan = ath10k_cancel_hw_scan,
4442 .set_key = ath10k_set_key,
4443 .sta_state = ath10k_sta_state,
4444 .conf_tx = ath10k_conf_tx,
4445 .remain_on_channel = ath10k_remain_on_channel,
4446 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4447 .set_rts_threshold = ath10k_set_rts_threshold,
4448 .set_frag_threshold = ath10k_set_frag_threshold,
4449 .flush = ath10k_flush,
4450 .tx_last_beacon = ath10k_tx_last_beacon,
4451 .set_antenna = ath10k_set_antenna,
4452 .get_antenna = ath10k_get_antenna,
4453 .restart_complete = ath10k_restart_complete,
4454 .get_survey = ath10k_get_survey,
4455 .set_bitrate_mask = ath10k_set_bitrate_mask,
4456 .sta_rc_update = ath10k_sta_rc_update,
4457 .get_tsf = ath10k_get_tsf,
4458 .ampdu_action = ath10k_ampdu_action,
4460 CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
4463 .suspend = ath10k_suspend,
4464 .resume = ath10k_resume,
4468 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4469 .bitrate = (_rate), \
4470 .flags = (_flags), \
4471 .hw_value = (_rateid), \
4474 #define CHAN2G(_channel, _freq, _flags) { \
4475 .band = IEEE80211_BAND_2GHZ, \
4476 .hw_value = (_channel), \
4477 .center_freq = (_freq), \
4478 .flags = (_flags), \
4479 .max_antenna_gain = 0, \
4483 #define CHAN5G(_channel, _freq, _flags) { \
4484 .band = IEEE80211_BAND_5GHZ, \
4485 .hw_value = (_channel), \
4486 .center_freq = (_freq), \
4487 .flags = (_flags), \
4488 .max_antenna_gain = 0, \
4492 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4502 CHAN2G(10, 2457, 0),
4503 CHAN2G(11, 2462, 0),
4504 CHAN2G(12, 2467, 0),
4505 CHAN2G(13, 2472, 0),
4506 CHAN2G(14, 2484, 0),
4509 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4510 CHAN5G(36, 5180, 0),
4511 CHAN5G(40, 5200, 0),
4512 CHAN5G(44, 5220, 0),
4513 CHAN5G(48, 5240, 0),
4514 CHAN5G(52, 5260, 0),
4515 CHAN5G(56, 5280, 0),
4516 CHAN5G(60, 5300, 0),
4517 CHAN5G(64, 5320, 0),
4518 CHAN5G(100, 5500, 0),
4519 CHAN5G(104, 5520, 0),
4520 CHAN5G(108, 5540, 0),
4521 CHAN5G(112, 5560, 0),
4522 CHAN5G(116, 5580, 0),
4523 CHAN5G(120, 5600, 0),
4524 CHAN5G(124, 5620, 0),
4525 CHAN5G(128, 5640, 0),
4526 CHAN5G(132, 5660, 0),
4527 CHAN5G(136, 5680, 0),
4528 CHAN5G(140, 5700, 0),
4529 CHAN5G(149, 5745, 0),
4530 CHAN5G(153, 5765, 0),
4531 CHAN5G(157, 5785, 0),
4532 CHAN5G(161, 5805, 0),
4533 CHAN5G(165, 5825, 0),
4536 static struct ieee80211_rate ath10k_rates[] = {
4538 RATETAB_ENT(10, 0x82, 0),
4539 RATETAB_ENT(20, 0x84, 0),
4540 RATETAB_ENT(55, 0x8b, 0),
4541 RATETAB_ENT(110, 0x96, 0),
4543 RATETAB_ENT(60, 0x0c, 0),
4544 RATETAB_ENT(90, 0x12, 0),
4545 RATETAB_ENT(120, 0x18, 0),
4546 RATETAB_ENT(180, 0x24, 0),
4547 RATETAB_ENT(240, 0x30, 0),
4548 RATETAB_ENT(360, 0x48, 0),
4549 RATETAB_ENT(480, 0x60, 0),
4550 RATETAB_ENT(540, 0x6c, 0),
4553 #define ath10k_a_rates (ath10k_rates + 4)
4554 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4555 #define ath10k_g_rates (ath10k_rates + 0)
4556 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4558 struct ath10k *ath10k_mac_create(size_t priv_size)
4560 struct ieee80211_hw *hw;
4563 hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, &ath10k_ops);
4573 void ath10k_mac_destroy(struct ath10k *ar)
4575 ieee80211_free_hw(ar->hw);
4578 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4581 .types = BIT(NL80211_IFTYPE_STATION)
4582 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4586 .types = BIT(NL80211_IFTYPE_P2P_GO)
4590 .types = BIT(NL80211_IFTYPE_AP)
4594 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4597 .types = BIT(NL80211_IFTYPE_AP)
4601 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4603 .limits = ath10k_if_limits,
4604 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4605 .max_interfaces = 8,
4606 .num_different_channels = 1,
4607 .beacon_int_infra_match = true,
4611 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4613 .limits = ath10k_10x_if_limits,
4614 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4615 .max_interfaces = 8,
4616 .num_different_channels = 1,
4617 .beacon_int_infra_match = true,
4618 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4619 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4620 BIT(NL80211_CHAN_WIDTH_20) |
4621 BIT(NL80211_CHAN_WIDTH_40) |
4622 BIT(NL80211_CHAN_WIDTH_80),
4627 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4629 struct ieee80211_sta_vht_cap vht_cap = {0};
4633 vht_cap.vht_supported = 1;
4634 vht_cap.cap = ar->vht_cap_info;
4637 for (i = 0; i < 8; i++) {
4638 if (i < ar->num_rf_chains)
4639 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4641 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4644 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4645 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4650 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4653 struct ieee80211_sta_ht_cap ht_cap = {0};
4655 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4658 ht_cap.ht_supported = 1;
4659 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4660 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4661 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4662 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4663 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4665 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4666 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4668 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4669 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4671 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4674 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4675 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4680 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4681 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4683 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4686 stbc = ar->ht_cap_info;
4687 stbc &= WMI_HT_CAP_RX_STBC;
4688 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4689 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4690 stbc &= IEEE80211_HT_CAP_RX_STBC;
4695 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4696 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4698 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4699 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4701 /* max AMSDU is implicitly taken from vht_cap_info */
4702 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4703 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4705 for (i = 0; i < ar->num_rf_chains; i++)
4706 ht_cap.mcs.rx_mask[i] = 0xFF;
4708 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4713 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4714 struct ieee80211_vif *vif)
4716 struct ath10k_vif_iter *arvif_iter = data;
4717 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4719 if (arvif->vdev_id == arvif_iter->vdev_id)
4720 arvif_iter->arvif = arvif;
4723 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4725 struct ath10k_vif_iter arvif_iter;
4728 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4729 arvif_iter.vdev_id = vdev_id;
4731 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4732 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4734 ath10k_get_arvif_iter,
4736 if (!arvif_iter.arvif) {
4737 ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
4741 return arvif_iter.arvif;
4744 int ath10k_mac_register(struct ath10k *ar)
4746 struct ieee80211_supported_band *band;
4747 struct ieee80211_sta_vht_cap vht_cap;
4748 struct ieee80211_sta_ht_cap ht_cap;
4752 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4754 SET_IEEE80211_DEV(ar->hw, ar->dev);
4756 ht_cap = ath10k_get_ht_cap(ar);
4757 vht_cap = ath10k_create_vht_cap(ar);
4759 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4760 channels = kmemdup(ath10k_2ghz_channels,
4761 sizeof(ath10k_2ghz_channels),
4768 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4769 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4770 band->channels = channels;
4771 band->n_bitrates = ath10k_g_rates_size;
4772 band->bitrates = ath10k_g_rates;
4773 band->ht_cap = ht_cap;
4775 /* vht is not supported in 2.4 GHz */
4777 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4780 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4781 channels = kmemdup(ath10k_5ghz_channels,
4782 sizeof(ath10k_5ghz_channels),
4789 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4790 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4791 band->channels = channels;
4792 band->n_bitrates = ath10k_a_rates_size;
4793 band->bitrates = ath10k_a_rates;
4794 band->ht_cap = ht_cap;
4795 band->vht_cap = vht_cap;
4796 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4799 ar->hw->wiphy->interface_modes =
4800 BIT(NL80211_IFTYPE_STATION) |
4801 BIT(NL80211_IFTYPE_AP);
4803 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4804 /* TODO: Have to deal with 2x2 chips if/when the come out. */
4805 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK;
4806 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK;
4808 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK;
4809 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK;
4812 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4813 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4815 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4816 ar->hw->wiphy->interface_modes |=
4817 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4818 BIT(NL80211_IFTYPE_P2P_GO);
4820 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4821 IEEE80211_HW_SUPPORTS_PS |
4822 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4823 IEEE80211_HW_SUPPORTS_UAPSD |
4824 IEEE80211_HW_MFP_CAPABLE |
4825 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4826 IEEE80211_HW_HAS_RATE_CONTROL |
4827 IEEE80211_HW_AP_LINK_PS |
4828 IEEE80211_HW_SPECTRUM_MGMT;
4830 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4831 * bytes is used for padding/alignment if necessary. */
4832 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4834 ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
4836 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4837 ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
4839 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4840 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4841 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4844 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4845 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4847 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4848 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4850 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4852 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4853 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4854 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4856 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4858 * on LL hardware queues are managed entirely by the FW
4859 * so we only advertise to mac we can do the queues thing
4863 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4864 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4865 ar->hw->wiphy->n_iface_combinations =
4866 ARRAY_SIZE(ath10k_10x_if_comb);
4868 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4869 ar->hw->wiphy->n_iface_combinations =
4870 ARRAY_SIZE(ath10k_if_comb);
4872 ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
4875 ar->hw->netdev_features = NETIF_F_HW_CSUM;
4877 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4878 /* Init ath dfs pattern detector */
4879 ar->ath_common.debug_mask = ATH_DBG_DFS;
4880 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4883 if (!ar->dfs_detector)
4884 ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
4887 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4888 ath10k_reg_notifier);
4890 ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
4894 ret = ieee80211_register_hw(ar->hw);
4896 ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
4900 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4901 ret = regulatory_hint(ar->hw->wiphy,
4902 ar->ath_common.regulatory.alpha2);
4904 goto err_unregister;
4910 ieee80211_unregister_hw(ar->hw);
4912 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4913 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4918 void ath10k_mac_unregister(struct ath10k *ar)
4920 ieee80211_unregister_hw(ar->hw);
4922 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4923 ar->dfs_detector->exit(ar->dfs_detector);
4925 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4926 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4928 SET_IEEE80211_DEV(ar->hw, NULL);