2 * Copyright (c) 2005-2011 Atheros Communications Inc.
3 * Copyright (c) 2011-2013 Qualcomm Atheros, Inc.
5 * Permission to use, copy, modify, and/or distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 #include <net/mac80211.h>
21 #include <linux/etherdevice.h>
34 static int ath10k_send_key(struct ath10k_vif *arvif,
35 struct ieee80211_key_conf *key,
39 struct wmi_vdev_install_key_arg arg = {
40 .vdev_id = arvif->vdev_id,
41 .key_idx = key->keyidx,
42 .key_len = key->keylen,
47 lockdep_assert_held(&arvif->ar->conf_mutex);
49 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
50 arg.key_flags = WMI_KEY_PAIRWISE;
52 arg.key_flags = WMI_KEY_GROUP;
54 switch (key->cipher) {
55 case WLAN_CIPHER_SUITE_CCMP:
56 arg.key_cipher = WMI_CIPHER_AES_CCM;
57 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
58 key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
60 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
62 case WLAN_CIPHER_SUITE_TKIP:
63 arg.key_cipher = WMI_CIPHER_TKIP;
64 arg.key_txmic_len = 8;
65 arg.key_rxmic_len = 8;
67 case WLAN_CIPHER_SUITE_WEP40:
68 case WLAN_CIPHER_SUITE_WEP104:
69 arg.key_cipher = WMI_CIPHER_WEP;
70 /* AP/IBSS mode requires self-key to be groupwise
71 * Otherwise pairwise key must be set */
72 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
73 arg.key_flags = WMI_KEY_PAIRWISE;
76 ath10k_warn("cipher %d is not supported\n", key->cipher);
80 if (cmd == DISABLE_KEY) {
81 arg.key_cipher = WMI_CIPHER_NONE;
85 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
88 static int ath10k_install_key(struct ath10k_vif *arvif,
89 struct ieee80211_key_conf *key,
93 struct ath10k *ar = arvif->ar;
96 lockdep_assert_held(&ar->conf_mutex);
98 reinit_completion(&ar->install_key_done);
100 ret = ath10k_send_key(arvif, key, cmd, macaddr);
104 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
111 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
114 struct ath10k *ar = arvif->ar;
115 struct ath10k_peer *peer;
119 lockdep_assert_held(&ar->conf_mutex);
121 spin_lock_bh(&ar->data_lock);
122 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
123 spin_unlock_bh(&ar->data_lock);
128 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
129 if (arvif->wep_keys[i] == NULL)
132 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
137 peer->keys[i] = arvif->wep_keys[i];
143 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
146 struct ath10k *ar = arvif->ar;
147 struct ath10k_peer *peer;
152 lockdep_assert_held(&ar->conf_mutex);
154 spin_lock_bh(&ar->data_lock);
155 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
156 spin_unlock_bh(&ar->data_lock);
161 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
162 if (peer->keys[i] == NULL)
165 ret = ath10k_install_key(arvif, peer->keys[i],
167 if (ret && first_errno == 0)
171 ath10k_warn("failed to remove peer wep key %d: %d\n",
174 peer->keys[i] = NULL;
180 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
181 struct ieee80211_key_conf *key)
183 struct ath10k *ar = arvif->ar;
184 struct ath10k_peer *peer;
190 lockdep_assert_held(&ar->conf_mutex);
193 /* since ath10k_install_key we can't hold data_lock all the
194 * time, so we try to remove the keys incrementally */
195 spin_lock_bh(&ar->data_lock);
197 list_for_each_entry(peer, &ar->peers, list) {
198 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
199 if (peer->keys[i] == key) {
200 memcpy(addr, peer->addr, ETH_ALEN);
201 peer->keys[i] = NULL;
206 if (i < ARRAY_SIZE(peer->keys))
209 spin_unlock_bh(&ar->data_lock);
211 if (i == ARRAY_SIZE(peer->keys))
214 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
215 if (ret && first_errno == 0)
219 ath10k_warn("failed to remove key for %pM: %d\n",
227 /*********************/
228 /* General utilities */
229 /*********************/
231 static inline enum wmi_phy_mode
232 chan_to_phymode(const struct cfg80211_chan_def *chandef)
234 enum wmi_phy_mode phymode = MODE_UNKNOWN;
236 switch (chandef->chan->band) {
237 case IEEE80211_BAND_2GHZ:
238 switch (chandef->width) {
239 case NL80211_CHAN_WIDTH_20_NOHT:
242 case NL80211_CHAN_WIDTH_20:
243 phymode = MODE_11NG_HT20;
245 case NL80211_CHAN_WIDTH_40:
246 phymode = MODE_11NG_HT40;
248 case NL80211_CHAN_WIDTH_5:
249 case NL80211_CHAN_WIDTH_10:
250 case NL80211_CHAN_WIDTH_80:
251 case NL80211_CHAN_WIDTH_80P80:
252 case NL80211_CHAN_WIDTH_160:
253 phymode = MODE_UNKNOWN;
257 case IEEE80211_BAND_5GHZ:
258 switch (chandef->width) {
259 case NL80211_CHAN_WIDTH_20_NOHT:
262 case NL80211_CHAN_WIDTH_20:
263 phymode = MODE_11NA_HT20;
265 case NL80211_CHAN_WIDTH_40:
266 phymode = MODE_11NA_HT40;
268 case NL80211_CHAN_WIDTH_80:
269 phymode = MODE_11AC_VHT80;
271 case NL80211_CHAN_WIDTH_5:
272 case NL80211_CHAN_WIDTH_10:
273 case NL80211_CHAN_WIDTH_80P80:
274 case NL80211_CHAN_WIDTH_160:
275 phymode = MODE_UNKNOWN;
283 WARN_ON(phymode == MODE_UNKNOWN);
287 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
290 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
291 * 0 for no restriction
300 switch (mpdudensity) {
306 /* Our lower layer calculations limit our precision to
322 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
326 lockdep_assert_held(&ar->conf_mutex);
328 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
330 ath10k_warn("failed to create wmi peer %pM on vdev %i: %i\n",
335 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
337 ath10k_warn("failed to wait for created wmi peer %pM on vdev %i: %i\n",
341 spin_lock_bh(&ar->data_lock);
343 spin_unlock_bh(&ar->data_lock);
348 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
350 struct ath10k *ar = arvif->ar;
354 param = ar->wmi.pdev_param->sta_kickout_th;
355 ret = ath10k_wmi_pdev_set_param(ar, param,
356 ATH10K_KICKOUT_THRESHOLD);
358 ath10k_warn("failed to set kickout threshold on vdev %i: %d\n",
359 arvif->vdev_id, ret);
363 param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
364 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
365 ATH10K_KEEPALIVE_MIN_IDLE);
367 ath10k_warn("failed to set keepalive minimum idle time on vdev %i: %d\n",
368 arvif->vdev_id, ret);
372 param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
373 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
374 ATH10K_KEEPALIVE_MAX_IDLE);
376 ath10k_warn("failed to set keepalive maximum idle time on vdev %i: %d\n",
377 arvif->vdev_id, ret);
381 param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
382 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
383 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
385 ath10k_warn("failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
386 arvif->vdev_id, ret);
393 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
395 struct ath10k *ar = arvif->ar;
398 if (value != 0xFFFFFFFF)
399 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
402 vdev_param = ar->wmi.vdev_param->rts_threshold;
403 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
406 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
408 struct ath10k *ar = arvif->ar;
411 if (value != 0xFFFFFFFF)
412 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
413 ATH10K_FRAGMT_THRESHOLD_MIN,
414 ATH10K_FRAGMT_THRESHOLD_MAX);
416 vdev_param = ar->wmi.vdev_param->fragmentation_threshold;
417 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
420 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
424 lockdep_assert_held(&ar->conf_mutex);
426 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
430 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
434 spin_lock_bh(&ar->data_lock);
436 spin_unlock_bh(&ar->data_lock);
441 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
443 struct ath10k_peer *peer, *tmp;
445 lockdep_assert_held(&ar->conf_mutex);
447 spin_lock_bh(&ar->data_lock);
448 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
449 if (peer->vdev_id != vdev_id)
452 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
453 peer->addr, vdev_id);
455 list_del(&peer->list);
459 spin_unlock_bh(&ar->data_lock);
462 static void ath10k_peer_cleanup_all(struct ath10k *ar)
464 struct ath10k_peer *peer, *tmp;
466 lockdep_assert_held(&ar->conf_mutex);
468 spin_lock_bh(&ar->data_lock);
469 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
470 list_del(&peer->list);
474 spin_unlock_bh(&ar->data_lock);
477 /************************/
478 /* Interface management */
479 /************************/
481 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
485 lockdep_assert_held(&ar->conf_mutex);
487 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
488 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
495 static bool ath10k_monitor_is_enabled(struct ath10k *ar)
497 lockdep_assert_held(&ar->conf_mutex);
499 ath10k_dbg(ATH10K_DBG_MAC,
500 "mac monitor refs: promisc %d monitor %d cac %d\n",
501 ar->promisc, ar->monitor,
502 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags));
504 return ar->promisc || ar->monitor ||
505 test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
508 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
510 struct cfg80211_chan_def *chandef = &ar->chandef;
511 struct ieee80211_channel *channel = chandef->chan;
512 struct wmi_vdev_start_request_arg arg = {};
515 lockdep_assert_held(&ar->conf_mutex);
517 arg.vdev_id = vdev_id;
518 arg.channel.freq = channel->center_freq;
519 arg.channel.band_center_freq1 = chandef->center_freq1;
521 /* TODO setup this dynamically, what in case we
522 don't have any vifs? */
523 arg.channel.mode = chan_to_phymode(chandef);
524 arg.channel.chan_radar =
525 !!(channel->flags & IEEE80211_CHAN_RADAR);
527 arg.channel.min_power = 0;
528 arg.channel.max_power = channel->max_power * 2;
529 arg.channel.max_reg_power = channel->max_reg_power * 2;
530 arg.channel.max_antenna_gain = channel->max_antenna_gain * 2;
532 ret = ath10k_wmi_vdev_start(ar, &arg);
534 ath10k_warn("failed to request monitor vdev %i start: %d\n",
539 ret = ath10k_vdev_setup_sync(ar);
541 ath10k_warn("failed to synchronize setup for monitor vdev %i: %d\n",
546 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
548 ath10k_warn("failed to put up monitor vdev %i: %d\n",
553 ar->monitor_vdev_id = vdev_id;
555 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
556 ar->monitor_vdev_id);
560 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
562 ath10k_warn("failed to stop monitor vdev %i after start failure: %d\n",
563 ar->monitor_vdev_id, ret);
568 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
572 lockdep_assert_held(&ar->conf_mutex);
574 ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
576 ath10k_warn("failed to put down monitor vdev %i: %d\n",
577 ar->monitor_vdev_id, ret);
579 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
581 ath10k_warn("failed to to request monitor vdev %i stop: %d\n",
582 ar->monitor_vdev_id, ret);
584 ret = ath10k_vdev_setup_sync(ar);
586 ath10k_warn("failed to synchronise monitor vdev %i: %d\n",
587 ar->monitor_vdev_id, ret);
589 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
590 ar->monitor_vdev_id);
594 static int ath10k_monitor_vdev_create(struct ath10k *ar)
598 lockdep_assert_held(&ar->conf_mutex);
600 bit = ffs(ar->free_vdev_map);
602 ath10k_warn("failed to find free vdev id for monitor vdev\n");
606 ar->monitor_vdev_id = bit - 1;
607 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
609 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
610 WMI_VDEV_TYPE_MONITOR,
613 ath10k_warn("failed to request monitor vdev %i creation: %d\n",
614 ar->monitor_vdev_id, ret);
618 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
619 ar->monitor_vdev_id);
625 * Restore the ID to the global map.
627 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
631 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
635 lockdep_assert_held(&ar->conf_mutex);
637 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
639 ath10k_warn("failed to request wmi monitor vdev %i removal: %d\n",
640 ar->monitor_vdev_id, ret);
644 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
646 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
647 ar->monitor_vdev_id);
651 static int ath10k_monitor_start(struct ath10k *ar)
655 lockdep_assert_held(&ar->conf_mutex);
657 if (!ath10k_monitor_is_enabled(ar)) {
658 ath10k_warn("trying to start monitor with no references\n");
662 if (ar->monitor_started) {
663 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor already started\n");
667 ret = ath10k_monitor_vdev_create(ar);
669 ath10k_warn("failed to create monitor vdev: %d\n", ret);
673 ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
675 ath10k_warn("failed to start monitor vdev: %d\n", ret);
676 ath10k_monitor_vdev_delete(ar);
680 ar->monitor_started = true;
681 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor started\n");
686 static void ath10k_monitor_stop(struct ath10k *ar)
690 lockdep_assert_held(&ar->conf_mutex);
692 if (ath10k_monitor_is_enabled(ar)) {
693 ath10k_dbg(ATH10K_DBG_MAC,
694 "mac monitor will be stopped later\n");
698 if (!ar->monitor_started) {
699 ath10k_dbg(ATH10K_DBG_MAC,
700 "mac monitor probably failed to start earlier\n");
704 ret = ath10k_monitor_vdev_stop(ar);
706 ath10k_warn("failed to stop monitor vdev: %d\n", ret);
708 ret = ath10k_monitor_vdev_delete(ar);
710 ath10k_warn("failed to delete monitor vdev: %d\n", ret);
712 ar->monitor_started = false;
713 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor stopped\n");
716 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
718 struct ath10k *ar = arvif->ar;
719 u32 vdev_param, rts_cts = 0;
721 lockdep_assert_held(&ar->conf_mutex);
723 vdev_param = ar->wmi.vdev_param->enable_rtscts;
725 if (arvif->use_cts_prot || arvif->num_legacy_stations > 0)
726 rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
728 if (arvif->num_legacy_stations > 0)
729 rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
732 return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
736 static int ath10k_start_cac(struct ath10k *ar)
740 lockdep_assert_held(&ar->conf_mutex);
742 set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
744 ret = ath10k_monitor_start(ar);
746 ath10k_warn("failed to start monitor (cac): %d\n", ret);
747 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
751 ath10k_dbg(ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
752 ar->monitor_vdev_id);
757 static int ath10k_stop_cac(struct ath10k *ar)
759 lockdep_assert_held(&ar->conf_mutex);
761 /* CAC is not running - do nothing */
762 if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
765 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
766 ath10k_monitor_stop(ar);
768 ath10k_dbg(ATH10K_DBG_MAC, "mac cac finished\n");
773 static void ath10k_recalc_radar_detection(struct ath10k *ar)
777 lockdep_assert_held(&ar->conf_mutex);
781 if (!ar->radar_enabled)
784 if (ar->num_started_vdevs > 0)
787 ret = ath10k_start_cac(ar);
790 * Not possible to start CAC on current channel so starting
791 * radiation is not allowed, make this channel DFS_UNAVAILABLE
792 * by indicating that radar was detected.
794 ath10k_warn("failed to start CAC: %d\n", ret);
795 ieee80211_radar_detected(ar->hw);
799 static int ath10k_vdev_start(struct ath10k_vif *arvif)
801 struct ath10k *ar = arvif->ar;
802 struct cfg80211_chan_def *chandef = &ar->chandef;
803 struct wmi_vdev_start_request_arg arg = {};
806 lockdep_assert_held(&ar->conf_mutex);
808 reinit_completion(&ar->vdev_setup_done);
810 arg.vdev_id = arvif->vdev_id;
811 arg.dtim_period = arvif->dtim_period;
812 arg.bcn_intval = arvif->beacon_interval;
814 arg.channel.freq = chandef->chan->center_freq;
815 arg.channel.band_center_freq1 = chandef->center_freq1;
816 arg.channel.mode = chan_to_phymode(chandef);
818 arg.channel.min_power = 0;
819 arg.channel.max_power = chandef->chan->max_power * 2;
820 arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
821 arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain * 2;
823 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
824 arg.ssid = arvif->u.ap.ssid;
825 arg.ssid_len = arvif->u.ap.ssid_len;
826 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
828 /* For now allow DFS for AP mode */
829 arg.channel.chan_radar =
830 !!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
831 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
832 arg.ssid = arvif->vif->bss_conf.ssid;
833 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
836 ath10k_dbg(ATH10K_DBG_MAC,
837 "mac vdev %d start center_freq %d phymode %s\n",
838 arg.vdev_id, arg.channel.freq,
839 ath10k_wmi_phymode_str(arg.channel.mode));
841 ret = ath10k_wmi_vdev_start(ar, &arg);
843 ath10k_warn("failed to start WMI vdev %i: %d\n",
848 ret = ath10k_vdev_setup_sync(ar);
850 ath10k_warn("failed to synchronise setup for vdev %i: %d\n",
855 ar->num_started_vdevs++;
856 ath10k_recalc_radar_detection(ar);
861 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
863 struct ath10k *ar = arvif->ar;
866 lockdep_assert_held(&ar->conf_mutex);
868 reinit_completion(&ar->vdev_setup_done);
870 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
872 ath10k_warn("failed to stop WMI vdev %i: %d\n",
873 arvif->vdev_id, ret);
877 ret = ath10k_vdev_setup_sync(ar);
879 ath10k_warn("failed to syncronise setup for vdev %i: %d\n",
880 arvif->vdev_id, ret);
884 WARN_ON(ar->num_started_vdevs == 0);
886 if (ar->num_started_vdevs != 0) {
887 ar->num_started_vdevs--;
888 ath10k_recalc_radar_detection(ar);
894 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
895 struct ieee80211_bss_conf *info)
899 lockdep_assert_held(&arvif->ar->conf_mutex);
901 if (!info->enable_beacon) {
902 ath10k_vdev_stop(arvif);
904 arvif->is_started = false;
905 arvif->is_up = false;
907 spin_lock_bh(&arvif->ar->data_lock);
909 dma_unmap_single(arvif->ar->dev,
910 ATH10K_SKB_CB(arvif->beacon)->paddr,
911 arvif->beacon->len, DMA_TO_DEVICE);
912 dev_kfree_skb_any(arvif->beacon);
914 arvif->beacon = NULL;
915 arvif->beacon_sent = false;
917 spin_unlock_bh(&arvif->ar->data_lock);
922 arvif->tx_seq_no = 0x1000;
924 ret = ath10k_vdev_start(arvif);
929 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
931 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
934 ath10k_warn("failed to bring up vdev %d: %i\n",
935 arvif->vdev_id, ret);
936 ath10k_vdev_stop(arvif);
940 arvif->is_started = true;
943 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
946 static void ath10k_control_ibss(struct ath10k_vif *arvif,
947 struct ieee80211_bss_conf *info,
948 const u8 self_peer[ETH_ALEN])
953 lockdep_assert_held(&arvif->ar->conf_mutex);
955 if (!info->ibss_joined) {
956 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
958 ath10k_warn("failed to delete IBSS self peer %pM for vdev %d: %d\n",
959 self_peer, arvif->vdev_id, ret);
961 if (is_zero_ether_addr(arvif->bssid))
964 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
967 ath10k_warn("failed to delete IBSS BSSID peer %pM for vdev %d: %d\n",
968 arvif->bssid, arvif->vdev_id, ret);
972 memset(arvif->bssid, 0, ETH_ALEN);
977 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
979 ath10k_warn("failed to create IBSS self peer %pM for vdev %d: %d\n",
980 self_peer, arvif->vdev_id, ret);
984 vdev_param = arvif->ar->wmi.vdev_param->atim_window;
985 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
986 ATH10K_DEFAULT_ATIM);
988 ath10k_warn("failed to set IBSS ATIM for vdev %d: %d\n",
989 arvif->vdev_id, ret);
993 * Review this when mac80211 gains per-interface powersave support.
995 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
997 struct ath10k *ar = arvif->ar;
998 struct ieee80211_conf *conf = &ar->hw->conf;
999 enum wmi_sta_powersave_param param;
1000 enum wmi_sta_ps_mode psmode;
1003 lockdep_assert_held(&arvif->ar->conf_mutex);
1005 if (arvif->vif->type != NL80211_IFTYPE_STATION)
1008 if (conf->flags & IEEE80211_CONF_PS) {
1009 psmode = WMI_STA_PS_MODE_ENABLED;
1010 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1012 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1013 conf->dynamic_ps_timeout);
1015 ath10k_warn("failed to set inactivity time for vdev %d: %i\n",
1016 arvif->vdev_id, ret);
1020 psmode = WMI_STA_PS_MODE_DISABLED;
1023 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1024 arvif->vdev_id, psmode ? "enable" : "disable");
1026 ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1028 ath10k_warn("failed to set PS Mode %d for vdev %d: %d\n",
1029 psmode, arvif->vdev_id, ret);
1036 /**********************/
1037 /* Station management */
1038 /**********************/
1040 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
1041 struct ath10k_vif *arvif,
1042 struct ieee80211_sta *sta,
1043 struct ieee80211_bss_conf *bss_conf,
1044 struct wmi_peer_assoc_complete_arg *arg)
1046 lockdep_assert_held(&ar->conf_mutex);
1048 memcpy(arg->addr, sta->addr, ETH_ALEN);
1049 arg->vdev_id = arvif->vdev_id;
1050 arg->peer_aid = sta->aid;
1051 arg->peer_flags |= WMI_PEER_AUTH;
1053 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
1055 * Seems FW have problems with Power Save in STA
1056 * mode when we setup this parameter to high (eg. 5).
1057 * Often we see that FW don't send NULL (with clean P flags)
1058 * frame even there is info about buffered frames in beacons.
1059 * Sometimes we have to wait more than 10 seconds before FW
1060 * will wakeup. Often sending one ping from AP to our device
1061 * just fail (more than 50%).
1063 * Seems setting this FW parameter to 1 couse FW
1064 * will check every beacon and will wakup immediately
1065 * after detection buffered data.
1067 arg->peer_listen_intval = 1;
1069 arg->peer_listen_intval = ar->hw->conf.listen_interval;
1071 arg->peer_num_spatial_streams = 1;
1074 * The assoc capabilities are available only in managed mode.
1076 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
1077 arg->peer_caps = bss_conf->assoc_capability;
1080 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
1081 struct ath10k_vif *arvif,
1082 struct wmi_peer_assoc_complete_arg *arg)
1084 struct ieee80211_vif *vif = arvif->vif;
1085 struct ieee80211_bss_conf *info = &vif->bss_conf;
1086 struct cfg80211_bss *bss;
1087 const u8 *rsnie = NULL;
1088 const u8 *wpaie = NULL;
1090 lockdep_assert_held(&ar->conf_mutex);
1092 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
1093 info->bssid, NULL, 0, 0, 0);
1095 const struct cfg80211_bss_ies *ies;
1098 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
1100 ies = rcu_dereference(bss->ies);
1102 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
1103 WLAN_OUI_TYPE_MICROSOFT_WPA,
1107 cfg80211_put_bss(ar->hw->wiphy, bss);
1110 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
1111 if (rsnie || wpaie) {
1112 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
1113 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
1117 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
1118 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
1122 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
1123 struct ieee80211_sta *sta,
1124 struct wmi_peer_assoc_complete_arg *arg)
1126 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
1127 const struct ieee80211_supported_band *sband;
1128 const struct ieee80211_rate *rates;
1132 lockdep_assert_held(&ar->conf_mutex);
1134 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
1135 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
1136 rates = sband->bitrates;
1138 rateset->num_rates = 0;
1140 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
1141 if (!(ratemask & 1))
1144 rateset->rates[rateset->num_rates] = rates->hw_value;
1145 rateset->num_rates++;
1149 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
1150 struct ieee80211_sta *sta,
1151 struct wmi_peer_assoc_complete_arg *arg)
1153 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
1156 lockdep_assert_held(&ar->conf_mutex);
1158 if (!ht_cap->ht_supported)
1161 arg->peer_flags |= WMI_PEER_HT;
1162 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1163 ht_cap->ampdu_factor)) - 1;
1165 arg->peer_mpdu_density =
1166 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
1168 arg->peer_ht_caps = ht_cap->cap;
1169 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
1171 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
1172 arg->peer_flags |= WMI_PEER_LDPC;
1174 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
1175 arg->peer_flags |= WMI_PEER_40MHZ;
1176 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
1179 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
1180 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1182 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
1183 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
1185 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
1186 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
1187 arg->peer_flags |= WMI_PEER_STBC;
1190 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
1192 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
1193 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
1194 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
1195 arg->peer_rate_caps |= stbc;
1196 arg->peer_flags |= WMI_PEER_STBC;
1199 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
1200 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
1201 else if (ht_cap->mcs.rx_mask[1])
1202 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
1204 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
1205 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
1206 arg->peer_ht_rates.rates[n++] = i;
1209 * This is a workaround for HT-enabled STAs which break the spec
1210 * and have no HT capabilities RX mask (no HT RX MCS map).
1212 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
1213 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
1215 * Firmware asserts if such situation occurs.
1218 arg->peer_ht_rates.num_rates = 8;
1219 for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
1220 arg->peer_ht_rates.rates[i] = i;
1222 arg->peer_ht_rates.num_rates = n;
1223 arg->peer_num_spatial_streams = sta->rx_nss;
1226 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
1228 arg->peer_ht_rates.num_rates,
1229 arg->peer_num_spatial_streams);
1232 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
1233 struct ath10k_vif *arvif,
1234 struct ieee80211_sta *sta)
1240 lockdep_assert_held(&ar->conf_mutex);
1242 if (sta->wme && sta->uapsd_queues) {
1243 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
1244 sta->uapsd_queues, sta->max_sp);
1246 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
1247 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
1248 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
1249 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
1250 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
1251 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
1252 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
1253 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
1254 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
1255 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
1256 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
1257 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
1260 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
1261 max_sp = sta->max_sp;
1263 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1265 WMI_AP_PS_PEER_PARAM_UAPSD,
1268 ath10k_warn("failed to set ap ps peer param uapsd for vdev %i: %d\n",
1269 arvif->vdev_id, ret);
1273 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1275 WMI_AP_PS_PEER_PARAM_MAX_SP,
1278 ath10k_warn("failed to set ap ps peer param max sp for vdev %i: %d\n",
1279 arvif->vdev_id, ret);
1283 /* TODO setup this based on STA listen interval and
1284 beacon interval. Currently we don't know
1285 sta->listen_interval - mac80211 patch required.
1286 Currently use 10 seconds */
1287 ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
1288 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME, 10);
1290 ath10k_warn("failed to set ap ps peer param ageout time for vdev %i: %d\n",
1291 arvif->vdev_id, ret);
1299 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1300 struct ieee80211_sta *sta,
1301 struct wmi_peer_assoc_complete_arg *arg)
1303 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1306 if (!vht_cap->vht_supported)
1309 arg->peer_flags |= WMI_PEER_VHT;
1310 arg->peer_vht_caps = vht_cap->cap;
1313 ampdu_factor = (vht_cap->cap &
1314 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
1315 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
1317 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
1318 * zero in VHT IE. Using it would result in degraded throughput.
1319 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
1320 * it if VHT max_mpdu is smaller. */
1321 arg->peer_max_mpdu = max(arg->peer_max_mpdu,
1322 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
1323 ampdu_factor)) - 1);
1325 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1326 arg->peer_flags |= WMI_PEER_80MHZ;
1328 arg->peer_vht_rates.rx_max_rate =
1329 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1330 arg->peer_vht_rates.rx_mcs_set =
1331 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1332 arg->peer_vht_rates.tx_max_rate =
1333 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1334 arg->peer_vht_rates.tx_mcs_set =
1335 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1337 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1338 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1341 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1342 struct ath10k_vif *arvif,
1343 struct ieee80211_sta *sta,
1344 struct ieee80211_bss_conf *bss_conf,
1345 struct wmi_peer_assoc_complete_arg *arg)
1347 switch (arvif->vdev_type) {
1348 case WMI_VDEV_TYPE_AP:
1350 arg->peer_flags |= WMI_PEER_QOS;
1352 if (sta->wme && sta->uapsd_queues) {
1353 arg->peer_flags |= WMI_PEER_APSD;
1354 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
1357 case WMI_VDEV_TYPE_STA:
1359 arg->peer_flags |= WMI_PEER_QOS;
1366 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1367 struct ath10k_vif *arvif,
1368 struct ieee80211_sta *sta,
1369 struct wmi_peer_assoc_complete_arg *arg)
1371 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1373 switch (ar->hw->conf.chandef.chan->band) {
1374 case IEEE80211_BAND_2GHZ:
1375 if (sta->ht_cap.ht_supported) {
1376 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1377 phymode = MODE_11NG_HT40;
1379 phymode = MODE_11NG_HT20;
1385 case IEEE80211_BAND_5GHZ:
1389 if (sta->vht_cap.vht_supported) {
1390 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1391 phymode = MODE_11AC_VHT80;
1392 else if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1393 phymode = MODE_11AC_VHT40;
1394 else if (sta->bandwidth == IEEE80211_STA_RX_BW_20)
1395 phymode = MODE_11AC_VHT20;
1396 } else if (sta->ht_cap.ht_supported) {
1397 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1398 phymode = MODE_11NA_HT40;
1400 phymode = MODE_11NA_HT20;
1410 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1411 sta->addr, ath10k_wmi_phymode_str(phymode));
1413 arg->peer_phymode = phymode;
1414 WARN_ON(phymode == MODE_UNKNOWN);
1417 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
1418 struct ath10k_vif *arvif,
1419 struct ieee80211_sta *sta,
1420 struct ieee80211_bss_conf *bss_conf,
1421 struct wmi_peer_assoc_complete_arg *arg)
1423 lockdep_assert_held(&ar->conf_mutex);
1425 memset(arg, 0, sizeof(*arg));
1427 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, arg);
1428 ath10k_peer_assoc_h_crypto(ar, arvif, arg);
1429 ath10k_peer_assoc_h_rates(ar, sta, arg);
1430 ath10k_peer_assoc_h_ht(ar, sta, arg);
1431 ath10k_peer_assoc_h_vht(ar, sta, arg);
1432 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, arg);
1433 ath10k_peer_assoc_h_phymode(ar, arvif, sta, arg);
1438 static const u32 ath10k_smps_map[] = {
1439 [WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
1440 [WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
1441 [WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
1442 [WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
1445 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
1447 const struct ieee80211_sta_ht_cap *ht_cap)
1451 if (!ht_cap->ht_supported)
1454 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
1455 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
1457 if (smps >= ARRAY_SIZE(ath10k_smps_map))
1460 return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
1461 WMI_PEER_SMPS_STATE,
1462 ath10k_smps_map[smps]);
1465 /* can be called only in mac80211 callbacks due to `key_count` usage */
1466 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1467 struct ieee80211_vif *vif,
1468 struct ieee80211_bss_conf *bss_conf)
1470 struct ath10k *ar = hw->priv;
1471 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1472 struct ieee80211_sta_ht_cap ht_cap;
1473 struct wmi_peer_assoc_complete_arg peer_arg;
1474 struct ieee80211_sta *ap_sta;
1477 lockdep_assert_held(&ar->conf_mutex);
1481 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1483 ath10k_warn("failed to find station entry for bss %pM vdev %i\n",
1484 bss_conf->bssid, arvif->vdev_id);
1489 /* ap_sta must be accessed only within rcu section which must be left
1490 * before calling ath10k_setup_peer_smps() which might sleep. */
1491 ht_cap = ap_sta->ht_cap;
1493 ret = ath10k_peer_assoc_prepare(ar, arvif, ap_sta,
1494 bss_conf, &peer_arg);
1496 ath10k_warn("failed to prepare peer assoc for %pM vdev %i: %d\n",
1497 bss_conf->bssid, arvif->vdev_id, ret);
1504 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1506 ath10k_warn("failed to run peer assoc for %pM vdev %i: %d\n",
1507 bss_conf->bssid, arvif->vdev_id, ret);
1511 ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
1513 ath10k_warn("failed to setup peer SMPS for vdev %i: %d\n",
1514 arvif->vdev_id, ret);
1518 ath10k_dbg(ATH10K_DBG_MAC,
1519 "mac vdev %d up (associated) bssid %pM aid %d\n",
1520 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1522 arvif->aid = bss_conf->aid;
1523 memcpy(arvif->bssid, bss_conf->bssid, ETH_ALEN);
1525 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
1527 ath10k_warn("failed to set vdev %d up: %d\n",
1528 arvif->vdev_id, ret);
1532 arvif->is_up = true;
1538 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1539 struct ieee80211_vif *vif)
1541 struct ath10k *ar = hw->priv;
1542 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1545 lockdep_assert_held(&ar->conf_mutex);
1548 * For some reason, calling VDEV-DOWN before VDEV-STOP
1549 * makes the FW to send frames via HTT after disassociation.
1550 * No idea why this happens, even though VDEV-DOWN is supposed
1551 * to be analogous to link down, so just stop the VDEV.
1553 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1556 /* FIXME: check return value */
1557 ret = ath10k_vdev_stop(arvif);
1560 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1561 * report beacons from previously associated network through HTT.
1562 * This in turn would spam mac80211 WARN_ON if we bring down all
1563 * interfaces as it expects there is no rx when no interface is
1566 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1568 /* FIXME: why don't we print error if wmi call fails? */
1569 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1571 arvif->def_wep_key_idx = 0;
1573 arvif->is_started = false;
1574 arvif->is_up = false;
1577 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1578 struct ieee80211_sta *sta, bool reassoc)
1580 struct wmi_peer_assoc_complete_arg peer_arg;
1583 lockdep_assert_held(&ar->conf_mutex);
1585 ret = ath10k_peer_assoc_prepare(ar, arvif, sta, NULL, &peer_arg);
1587 ath10k_warn("failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
1588 sta->addr, arvif->vdev_id, ret);
1592 peer_arg.peer_reassoc = reassoc;
1593 ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
1595 ath10k_warn("failed to run peer assoc for STA %pM vdev %i: %d\n",
1596 sta->addr, arvif->vdev_id, ret);
1600 ret = ath10k_setup_peer_smps(ar, arvif, sta->addr, &sta->ht_cap);
1602 ath10k_warn("failed to setup peer SMPS for vdev %d: %d\n",
1603 arvif->vdev_id, ret);
1608 arvif->num_legacy_stations++;
1609 ret = ath10k_recalc_rtscts_prot(arvif);
1611 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1612 arvif->vdev_id, ret);
1617 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1619 ath10k_warn("failed to install peer wep keys for vdev %i: %d\n",
1620 arvif->vdev_id, ret);
1624 ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
1626 ath10k_warn("failed to set qos params for STA %pM for vdev %i: %d\n",
1627 sta->addr, arvif->vdev_id, ret);
1634 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1635 struct ieee80211_sta *sta)
1639 lockdep_assert_held(&ar->conf_mutex);
1642 arvif->num_legacy_stations--;
1643 ret = ath10k_recalc_rtscts_prot(arvif);
1645 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
1646 arvif->vdev_id, ret);
1651 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1653 ath10k_warn("failed to clear all peer wep keys for vdev %i: %d\n",
1654 arvif->vdev_id, ret);
1665 static int ath10k_update_channel_list(struct ath10k *ar)
1667 struct ieee80211_hw *hw = ar->hw;
1668 struct ieee80211_supported_band **bands;
1669 enum ieee80211_band band;
1670 struct ieee80211_channel *channel;
1671 struct wmi_scan_chan_list_arg arg = {0};
1672 struct wmi_channel_arg *ch;
1678 lockdep_assert_held(&ar->conf_mutex);
1680 bands = hw->wiphy->bands;
1681 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1685 for (i = 0; i < bands[band]->n_channels; i++) {
1686 if (bands[band]->channels[i].flags &
1687 IEEE80211_CHAN_DISABLED)
1694 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1695 arg.channels = kzalloc(len, GFP_KERNEL);
1700 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1704 for (i = 0; i < bands[band]->n_channels; i++) {
1705 channel = &bands[band]->channels[i];
1707 if (channel->flags & IEEE80211_CHAN_DISABLED)
1710 ch->allow_ht = true;
1712 /* FIXME: when should we really allow VHT? */
1713 ch->allow_vht = true;
1716 !(channel->flags & IEEE80211_CHAN_NO_IR);
1719 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1722 !!(channel->flags & IEEE80211_CHAN_RADAR);
1724 passive = channel->flags & IEEE80211_CHAN_NO_IR;
1725 ch->passive = passive;
1727 ch->freq = channel->center_freq;
1729 ch->max_power = channel->max_power * 2;
1730 ch->max_reg_power = channel->max_reg_power * 2;
1731 ch->max_antenna_gain = channel->max_antenna_gain * 2;
1732 ch->reg_class_id = 0; /* FIXME */
1734 /* FIXME: why use only legacy modes, why not any
1735 * HT/VHT modes? Would that even make any
1737 if (channel->band == IEEE80211_BAND_2GHZ)
1738 ch->mode = MODE_11G;
1740 ch->mode = MODE_11A;
1742 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1745 ath10k_dbg(ATH10K_DBG_WMI,
1746 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1747 ch - arg.channels, arg.n_channels,
1748 ch->freq, ch->max_power, ch->max_reg_power,
1749 ch->max_antenna_gain, ch->mode);
1755 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1756 kfree(arg.channels);
1761 static enum wmi_dfs_region
1762 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
1764 switch (dfs_region) {
1765 case NL80211_DFS_UNSET:
1766 return WMI_UNINIT_DFS_DOMAIN;
1767 case NL80211_DFS_FCC:
1768 return WMI_FCC_DFS_DOMAIN;
1769 case NL80211_DFS_ETSI:
1770 return WMI_ETSI_DFS_DOMAIN;
1771 case NL80211_DFS_JP:
1772 return WMI_MKK4_DFS_DOMAIN;
1774 return WMI_UNINIT_DFS_DOMAIN;
1777 static void ath10k_regd_update(struct ath10k *ar)
1779 struct reg_dmn_pair_mapping *regpair;
1781 enum wmi_dfs_region wmi_dfs_reg;
1782 enum nl80211_dfs_regions nl_dfs_reg;
1784 lockdep_assert_held(&ar->conf_mutex);
1786 ret = ath10k_update_channel_list(ar);
1788 ath10k_warn("failed to update channel list: %d\n", ret);
1790 regpair = ar->ath_common.regulatory.regpair;
1792 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1793 nl_dfs_reg = ar->dfs_detector->region;
1794 wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
1796 wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
1799 /* Target allows setting up per-band regdomain but ath_common provides
1800 * a combined one only */
1801 ret = ath10k_wmi_pdev_set_regdomain(ar,
1802 regpair->reg_domain,
1803 regpair->reg_domain, /* 2ghz */
1804 regpair->reg_domain, /* 5ghz */
1805 regpair->reg_2ghz_ctl,
1806 regpair->reg_5ghz_ctl,
1809 ath10k_warn("failed to set pdev regdomain: %d\n", ret);
1812 static void ath10k_reg_notifier(struct wiphy *wiphy,
1813 struct regulatory_request *request)
1815 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1816 struct ath10k *ar = hw->priv;
1819 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1821 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
1822 ath10k_dbg(ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
1823 request->dfs_region);
1824 result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
1825 request->dfs_region);
1827 ath10k_warn("DFS region 0x%X not supported, will trigger radar for every pulse\n",
1828 request->dfs_region);
1831 mutex_lock(&ar->conf_mutex);
1832 if (ar->state == ATH10K_STATE_ON)
1833 ath10k_regd_update(ar);
1834 mutex_unlock(&ar->conf_mutex);
1841 static u8 ath10k_tx_h_get_tid(struct ieee80211_hdr *hdr)
1843 if (ieee80211_is_mgmt(hdr->frame_control))
1844 return HTT_DATA_TX_EXT_TID_MGMT;
1846 if (!ieee80211_is_data_qos(hdr->frame_control))
1847 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1849 if (!is_unicast_ether_addr(ieee80211_get_DA(hdr)))
1850 return HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1852 return ieee80211_get_qos_ctl(hdr)[0] & IEEE80211_QOS_CTL_TID_MASK;
1855 static u8 ath10k_tx_h_get_vdev_id(struct ath10k *ar,
1856 struct ieee80211_tx_info *info)
1858 if (info->control.vif)
1859 return ath10k_vif_to_arvif(info->control.vif)->vdev_id;
1861 if (ar->monitor_started)
1862 return ar->monitor_vdev_id;
1864 ath10k_warn("failed to resolve vdev id\n");
1869 * Frames sent to the FW have to be in "Native Wifi" format.
1870 * Strip the QoS field from the 802.11 header.
1872 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1873 struct ieee80211_tx_control *control,
1874 struct sk_buff *skb)
1876 struct ieee80211_hdr *hdr = (void *)skb->data;
1879 if (!ieee80211_is_data_qos(hdr->frame_control))
1882 qos_ctl = ieee80211_get_qos_ctl(hdr);
1883 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1884 skb->data, (void *)qos_ctl - (void *)skb->data);
1885 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1888 static void ath10k_tx_wep_key_work(struct work_struct *work)
1890 struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
1892 int ret, keyidx = arvif->def_wep_key_newidx;
1894 mutex_lock(&arvif->ar->conf_mutex);
1896 if (arvif->ar->state != ATH10K_STATE_ON)
1899 if (arvif->def_wep_key_idx == keyidx)
1902 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
1903 arvif->vdev_id, keyidx);
1905 ret = ath10k_wmi_vdev_set_param(arvif->ar,
1907 arvif->ar->wmi.vdev_param->def_keyid,
1910 ath10k_warn("failed to update wep key index for vdev %d: %d\n",
1916 arvif->def_wep_key_idx = keyidx;
1919 mutex_unlock(&arvif->ar->conf_mutex);
1922 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1924 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1925 struct ieee80211_vif *vif = info->control.vif;
1926 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1927 struct ath10k *ar = arvif->ar;
1928 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1929 struct ieee80211_key_conf *key = info->control.hw_key;
1931 if (!ieee80211_has_protected(hdr->frame_control))
1937 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1938 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1941 if (key->keyidx == arvif->def_wep_key_idx)
1944 /* FIXME: Most likely a few frames will be TXed with an old key. Simply
1945 * queueing frames until key index is updated is not an option because
1946 * sk_buff may need more processing to be done, e.g. offchannel */
1947 arvif->def_wep_key_newidx = key->keyidx;
1948 ieee80211_queue_work(ar->hw, &arvif->wep_key_work);
1951 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1953 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1954 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1955 struct ieee80211_vif *vif = info->control.vif;
1956 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1958 /* This is case only for P2P_GO */
1959 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1960 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1963 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1964 spin_lock_bh(&ar->data_lock);
1965 if (arvif->u.ap.noa_data)
1966 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1968 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1969 arvif->u.ap.noa_data,
1970 arvif->u.ap.noa_len);
1971 spin_unlock_bh(&ar->data_lock);
1975 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1977 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1980 if (ar->htt.target_version_major >= 3) {
1981 /* Since HTT 3.0 there is no separate mgmt tx command */
1982 ret = ath10k_htt_tx(&ar->htt, skb);
1986 if (ieee80211_is_mgmt(hdr->frame_control)) {
1987 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
1989 if (skb_queue_len(&ar->wmi_mgmt_tx_queue) >=
1990 ATH10K_MAX_NUM_MGMT_PENDING) {
1991 ath10k_warn("reached WMI management tranmist queue limit\n");
1996 skb_queue_tail(&ar->wmi_mgmt_tx_queue, skb);
1997 ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
1999 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2001 } else if (!test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
2003 ieee80211_is_nullfunc(hdr->frame_control)) {
2004 /* FW does not report tx status properly for NullFunc frames
2005 * unless they are sent through mgmt tx path. mac80211 sends
2006 * those frames when it detects link/beacon loss and depends
2007 * on the tx status to be correct. */
2008 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
2010 ret = ath10k_htt_tx(&ar->htt, skb);
2015 ath10k_warn("failed to transmit packet, dropping: %d\n", ret);
2016 ieee80211_free_txskb(ar->hw, skb);
2020 void ath10k_offchan_tx_purge(struct ath10k *ar)
2022 struct sk_buff *skb;
2025 skb = skb_dequeue(&ar->offchan_tx_queue);
2029 ieee80211_free_txskb(ar->hw, skb);
2033 void ath10k_offchan_tx_work(struct work_struct *work)
2035 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
2036 struct ath10k_peer *peer;
2037 struct ieee80211_hdr *hdr;
2038 struct sk_buff *skb;
2039 const u8 *peer_addr;
2043 /* FW requirement: We must create a peer before FW will send out
2044 * an offchannel frame. Otherwise the frame will be stuck and
2045 * never transmitted. We delete the peer upon tx completion.
2046 * It is unlikely that a peer for offchannel tx will already be
2047 * present. However it may be in some rare cases so account for that.
2048 * Otherwise we might remove a legitimate peer and break stuff. */
2051 skb = skb_dequeue(&ar->offchan_tx_queue);
2055 mutex_lock(&ar->conf_mutex);
2057 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
2060 hdr = (struct ieee80211_hdr *)skb->data;
2061 peer_addr = ieee80211_get_DA(hdr);
2062 vdev_id = ATH10K_SKB_CB(skb)->vdev_id;
2064 spin_lock_bh(&ar->data_lock);
2065 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
2066 spin_unlock_bh(&ar->data_lock);
2069 /* FIXME: should this use ath10k_warn()? */
2070 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
2071 peer_addr, vdev_id);
2074 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
2076 ath10k_warn("failed to create peer %pM on vdev %d: %d\n",
2077 peer_addr, vdev_id, ret);
2080 spin_lock_bh(&ar->data_lock);
2081 reinit_completion(&ar->offchan_tx_completed);
2082 ar->offchan_tx_skb = skb;
2083 spin_unlock_bh(&ar->data_lock);
2085 ath10k_tx_htt(ar, skb);
2087 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
2090 ath10k_warn("timed out waiting for offchannel skb %p\n",
2094 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
2096 ath10k_warn("failed to delete peer %pM on vdev %d: %d\n",
2097 peer_addr, vdev_id, ret);
2100 mutex_unlock(&ar->conf_mutex);
2104 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
2106 struct sk_buff *skb;
2109 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2113 ieee80211_free_txskb(ar->hw, skb);
2117 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
2119 struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
2120 struct sk_buff *skb;
2124 skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
2128 ret = ath10k_wmi_mgmt_tx(ar, skb);
2130 ath10k_warn("failed to transmit management frame via WMI: %d\n",
2132 ieee80211_free_txskb(ar->hw, skb);
2142 * This gets called if we dont get a heart-beat during scan.
2143 * This may indicate the FW has hung and we need to abort the
2144 * scan manually to prevent cancel_hw_scan() from deadlocking
2146 void ath10k_reset_scan(unsigned long ptr)
2148 struct ath10k *ar = (struct ath10k *)ptr;
2150 spin_lock_bh(&ar->data_lock);
2151 if (!ar->scan.in_progress) {
2152 spin_unlock_bh(&ar->data_lock);
2156 ath10k_warn("scan timed out, firmware problem?\n");
2158 if (ar->scan.is_roc)
2159 ieee80211_remain_on_channel_expired(ar->hw);
2161 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
2163 ar->scan.in_progress = false;
2164 complete_all(&ar->scan.completed);
2165 spin_unlock_bh(&ar->data_lock);
2168 static int ath10k_abort_scan(struct ath10k *ar)
2170 struct wmi_stop_scan_arg arg = {
2171 .req_id = 1, /* FIXME */
2172 .req_type = WMI_SCAN_STOP_ONE,
2173 .u.scan_id = ATH10K_SCAN_ID,
2177 lockdep_assert_held(&ar->conf_mutex);
2179 del_timer_sync(&ar->scan.timeout);
2181 spin_lock_bh(&ar->data_lock);
2182 if (!ar->scan.in_progress) {
2183 spin_unlock_bh(&ar->data_lock);
2187 ar->scan.aborting = true;
2188 spin_unlock_bh(&ar->data_lock);
2190 ret = ath10k_wmi_stop_scan(ar, &arg);
2192 ath10k_warn("failed to stop wmi scan: %d\n", ret);
2193 spin_lock_bh(&ar->data_lock);
2194 ar->scan.in_progress = false;
2195 ath10k_offchan_tx_purge(ar);
2196 spin_unlock_bh(&ar->data_lock);
2200 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
2202 ath10k_warn("timed out while waiting for scan to stop\n");
2204 /* scan completion may be done right after we timeout here, so let's
2205 * check the in_progress and tell mac80211 scan is completed. if we
2206 * don't do that and FW fails to send us scan completion indication
2207 * then userspace won't be able to scan anymore */
2210 spin_lock_bh(&ar->data_lock);
2211 if (ar->scan.in_progress) {
2212 ath10k_warn("failed to stop scan, it's still in progress\n");
2213 ar->scan.in_progress = false;
2214 ath10k_offchan_tx_purge(ar);
2217 spin_unlock_bh(&ar->data_lock);
2222 static int ath10k_start_scan(struct ath10k *ar,
2223 const struct wmi_start_scan_arg *arg)
2227 lockdep_assert_held(&ar->conf_mutex);
2229 ret = ath10k_wmi_start_scan(ar, arg);
2233 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
2235 ath10k_abort_scan(ar);
2239 /* the scan can complete earlier, before we even
2240 * start the timer. in that case the timer handler
2241 * checks ar->scan.in_progress and bails out if its
2242 * false. Add a 200ms margin to account event/command
2244 mod_timer(&ar->scan.timeout, jiffies +
2245 msecs_to_jiffies(arg->max_scan_time+200));
2249 /**********************/
2250 /* mac80211 callbacks */
2251 /**********************/
2253 static void ath10k_tx(struct ieee80211_hw *hw,
2254 struct ieee80211_tx_control *control,
2255 struct sk_buff *skb)
2257 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
2258 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
2259 struct ath10k *ar = hw->priv;
2262 /* We should disable CCK RATE due to P2P */
2263 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
2264 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
2266 /* we must calculate tid before we apply qos workaround
2267 * as we'd lose the qos control field */
2268 tid = ath10k_tx_h_get_tid(hdr);
2269 vdev_id = ath10k_tx_h_get_vdev_id(ar, info);
2271 /* it makes no sense to process injected frames like that */
2272 if (info->control.vif &&
2273 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
2274 ath10k_tx_h_qos_workaround(hw, control, skb);
2275 ath10k_tx_h_update_wep_key(skb);
2276 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
2277 ath10k_tx_h_seq_no(skb);
2280 ATH10K_SKB_CB(skb)->vdev_id = vdev_id;
2281 ATH10K_SKB_CB(skb)->htt.is_offchan = false;
2282 ATH10K_SKB_CB(skb)->htt.tid = tid;
2284 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
2285 spin_lock_bh(&ar->data_lock);
2286 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
2287 ATH10K_SKB_CB(skb)->vdev_id = ar->scan.vdev_id;
2288 spin_unlock_bh(&ar->data_lock);
2290 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
2292 skb_queue_tail(&ar->offchan_tx_queue, skb);
2293 ieee80211_queue_work(hw, &ar->offchan_tx_work);
2297 ath10k_tx_htt(ar, skb);
2300 /* Must not be called with conf_mutex held as workers can use that also. */
2301 static void ath10k_drain_tx(struct ath10k *ar)
2303 /* make sure rcu-protected mac80211 tx path itself is drained */
2306 ath10k_offchan_tx_purge(ar);
2307 ath10k_mgmt_over_wmi_tx_purge(ar);
2309 cancel_work_sync(&ar->offchan_tx_work);
2310 cancel_work_sync(&ar->wmi_mgmt_tx_work);
2313 void ath10k_halt(struct ath10k *ar)
2315 struct ath10k_vif *arvif;
2317 lockdep_assert_held(&ar->conf_mutex);
2319 if (ath10k_monitor_is_enabled(ar)) {
2320 clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
2321 ar->promisc = false;
2322 ar->monitor = false;
2323 ath10k_monitor_stop(ar);
2326 del_timer_sync(&ar->scan.timeout);
2327 ath10k_reset_scan((unsigned long)ar);
2328 ath10k_peer_cleanup_all(ar);
2329 ath10k_core_stop(ar);
2330 ath10k_hif_power_down(ar);
2332 spin_lock_bh(&ar->data_lock);
2333 list_for_each_entry(arvif, &ar->arvifs, list) {
2337 dma_unmap_single(arvif->ar->dev,
2338 ATH10K_SKB_CB(arvif->beacon)->paddr,
2339 arvif->beacon->len, DMA_TO_DEVICE);
2340 dev_kfree_skb_any(arvif->beacon);
2341 arvif->beacon = NULL;
2343 spin_unlock_bh(&ar->data_lock);
2346 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
2348 struct ath10k *ar = hw->priv;
2350 mutex_lock(&ar->conf_mutex);
2352 if (ar->cfg_tx_chainmask) {
2353 *tx_ant = ar->cfg_tx_chainmask;
2354 *rx_ant = ar->cfg_rx_chainmask;
2356 *tx_ant = ar->supp_tx_chainmask;
2357 *rx_ant = ar->supp_rx_chainmask;
2360 mutex_unlock(&ar->conf_mutex);
2365 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
2369 lockdep_assert_held(&ar->conf_mutex);
2371 ar->cfg_tx_chainmask = tx_ant;
2372 ar->cfg_rx_chainmask = rx_ant;
2374 if ((ar->state != ATH10K_STATE_ON) &&
2375 (ar->state != ATH10K_STATE_RESTARTED))
2378 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
2381 ath10k_warn("failed to set tx-chainmask: %d, req 0x%x\n",
2386 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
2389 ath10k_warn("failed to set rx-chainmask: %d, req 0x%x\n",
2397 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
2399 struct ath10k *ar = hw->priv;
2402 mutex_lock(&ar->conf_mutex);
2403 ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
2404 mutex_unlock(&ar->conf_mutex);
2408 static int ath10k_start(struct ieee80211_hw *hw)
2410 struct ath10k *ar = hw->priv;
2414 * This makes sense only when restarting hw. It is harmless to call
2415 * uncoditionally. This is necessary to make sure no HTT/WMI tx
2416 * commands will be submitted while restarting.
2418 ath10k_drain_tx(ar);
2420 mutex_lock(&ar->conf_mutex);
2422 switch (ar->state) {
2423 case ATH10K_STATE_OFF:
2424 ar->state = ATH10K_STATE_ON;
2426 case ATH10K_STATE_RESTARTING:
2428 ar->state = ATH10K_STATE_RESTARTED;
2430 case ATH10K_STATE_ON:
2431 case ATH10K_STATE_RESTARTED:
2432 case ATH10K_STATE_WEDGED:
2438 ret = ath10k_hif_power_up(ar);
2440 ath10k_err("Could not init hif: %d\n", ret);
2444 ret = ath10k_core_start(ar);
2446 ath10k_err("Could not init core: %d\n", ret);
2447 goto err_power_down;
2450 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->pmf_qos, 1);
2452 ath10k_warn("failed to enable PMF QOS: %d\n", ret);
2456 ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->dynamic_bw, 1);
2458 ath10k_warn("failed to enable dynamic BW: %d\n", ret);
2462 if (ar->cfg_tx_chainmask)
2463 __ath10k_set_antenna(ar, ar->cfg_tx_chainmask,
2464 ar->cfg_rx_chainmask);
2467 * By default FW set ARP frames ac to voice (6). In that case ARP
2468 * exchange is not working properly for UAPSD enabled AP. ARP requests
2469 * which arrives with access category 0 are processed by network stack
2470 * and send back with access category 0, but FW changes access category
2471 * to 6. Set ARP frames access category to best effort (0) solves
2475 ret = ath10k_wmi_pdev_set_param(ar,
2476 ar->wmi.pdev_param->arp_ac_override, 0);
2478 ath10k_warn("failed to set arp ac override parameter: %d\n",
2483 ar->num_started_vdevs = 0;
2484 ath10k_regd_update(ar);
2486 mutex_unlock(&ar->conf_mutex);
2490 ath10k_core_stop(ar);
2493 ath10k_hif_power_down(ar);
2496 ar->state = ATH10K_STATE_OFF;
2499 mutex_unlock(&ar->conf_mutex);
2503 static void ath10k_stop(struct ieee80211_hw *hw)
2505 struct ath10k *ar = hw->priv;
2507 ath10k_drain_tx(ar);
2509 mutex_lock(&ar->conf_mutex);
2510 if (ar->state != ATH10K_STATE_OFF) {
2512 ar->state = ATH10K_STATE_OFF;
2514 mutex_unlock(&ar->conf_mutex);
2516 cancel_work_sync(&ar->restart_work);
2519 static int ath10k_config_ps(struct ath10k *ar)
2521 struct ath10k_vif *arvif;
2524 lockdep_assert_held(&ar->conf_mutex);
2526 list_for_each_entry(arvif, &ar->arvifs, list) {
2527 ret = ath10k_mac_vif_setup_ps(arvif);
2529 ath10k_warn("failed to setup powersave: %d\n", ret);
2537 static const char *chandef_get_width(enum nl80211_chan_width width)
2540 case NL80211_CHAN_WIDTH_20_NOHT:
2542 case NL80211_CHAN_WIDTH_20:
2544 case NL80211_CHAN_WIDTH_40:
2546 case NL80211_CHAN_WIDTH_80:
2548 case NL80211_CHAN_WIDTH_80P80:
2550 case NL80211_CHAN_WIDTH_160:
2552 case NL80211_CHAN_WIDTH_5:
2554 case NL80211_CHAN_WIDTH_10:
2560 static void ath10k_config_chan(struct ath10k *ar)
2562 struct ath10k_vif *arvif;
2565 lockdep_assert_held(&ar->conf_mutex);
2567 ath10k_dbg(ATH10K_DBG_MAC,
2568 "mac config channel to %dMHz (cf1 %dMHz cf2 %dMHz width %s)\n",
2569 ar->chandef.chan->center_freq,
2570 ar->chandef.center_freq1,
2571 ar->chandef.center_freq2,
2572 chandef_get_width(ar->chandef.width));
2574 /* First stop monitor interface. Some FW versions crash if there's a
2575 * lone monitor interface. */
2576 if (ar->monitor_started)
2577 ath10k_monitor_vdev_stop(ar);
2579 list_for_each_entry(arvif, &ar->arvifs, list) {
2580 if (!arvif->is_started)
2583 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2586 ret = ath10k_vdev_stop(arvif);
2588 ath10k_warn("failed to stop vdev %d: %d\n",
2589 arvif->vdev_id, ret);
2594 /* all vdevs are now stopped - now attempt to restart them */
2596 list_for_each_entry(arvif, &ar->arvifs, list) {
2597 if (!arvif->is_started)
2600 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2603 ret = ath10k_vdev_start(arvif);
2605 ath10k_warn("failed to start vdev %d: %d\n",
2606 arvif->vdev_id, ret);
2613 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
2616 ath10k_warn("failed to bring vdev up %d: %d\n",
2617 arvif->vdev_id, ret);
2622 if (ath10k_monitor_is_enabled(ar))
2623 ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
2626 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
2628 struct ath10k *ar = hw->priv;
2629 struct ieee80211_conf *conf = &hw->conf;
2633 mutex_lock(&ar->conf_mutex);
2635 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
2636 ath10k_dbg(ATH10K_DBG_MAC,
2637 "mac config channel %dMHz flags 0x%x radar %d\n",
2638 conf->chandef.chan->center_freq,
2639 conf->chandef.chan->flags,
2640 conf->radar_enabled);
2642 spin_lock_bh(&ar->data_lock);
2643 ar->rx_channel = conf->chandef.chan;
2644 spin_unlock_bh(&ar->data_lock);
2646 ar->radar_enabled = conf->radar_enabled;
2647 ath10k_recalc_radar_detection(ar);
2649 if (!cfg80211_chandef_identical(&ar->chandef, &conf->chandef)) {
2650 ar->chandef = conf->chandef;
2651 ath10k_config_chan(ar);
2655 if (changed & IEEE80211_CONF_CHANGE_POWER) {
2656 ath10k_dbg(ATH10K_DBG_MAC, "mac config power %d\n",
2657 hw->conf.power_level);
2659 param = ar->wmi.pdev_param->txpower_limit2g;
2660 ret = ath10k_wmi_pdev_set_param(ar, param,
2661 hw->conf.power_level * 2);
2663 ath10k_warn("failed to set 2g txpower %d: %d\n",
2664 hw->conf.power_level, ret);
2666 param = ar->wmi.pdev_param->txpower_limit5g;
2667 ret = ath10k_wmi_pdev_set_param(ar, param,
2668 hw->conf.power_level * 2);
2670 ath10k_warn("failed to set 5g txpower %d: %d\n",
2671 hw->conf.power_level, ret);
2674 if (changed & IEEE80211_CONF_CHANGE_PS)
2675 ath10k_config_ps(ar);
2677 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
2678 if (conf->flags & IEEE80211_CONF_MONITOR && !ar->monitor) {
2680 ret = ath10k_monitor_start(ar);
2682 ath10k_warn("failed to start monitor (config): %d\n",
2684 ar->monitor = false;
2686 } else if (!(conf->flags & IEEE80211_CONF_MONITOR) &&
2688 ar->monitor = false;
2689 ath10k_monitor_stop(ar);
2693 mutex_unlock(&ar->conf_mutex);
2699 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
2700 * because we will send mgmt frames without CCK. This requirement
2701 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
2704 static int ath10k_add_interface(struct ieee80211_hw *hw,
2705 struct ieee80211_vif *vif)
2707 struct ath10k *ar = hw->priv;
2708 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2709 enum wmi_sta_powersave_param param;
2715 mutex_lock(&ar->conf_mutex);
2717 memset(arvif, 0, sizeof(*arvif));
2722 INIT_WORK(&arvif->wep_key_work, ath10k_tx_wep_key_work);
2723 INIT_LIST_HEAD(&arvif->list);
2725 bit = ffs(ar->free_vdev_map);
2731 arvif->vdev_id = bit - 1;
2732 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
2735 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
2737 switch (vif->type) {
2738 case NL80211_IFTYPE_UNSPECIFIED:
2739 case NL80211_IFTYPE_STATION:
2740 arvif->vdev_type = WMI_VDEV_TYPE_STA;
2742 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
2744 case NL80211_IFTYPE_ADHOC:
2745 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
2747 case NL80211_IFTYPE_AP:
2748 arvif->vdev_type = WMI_VDEV_TYPE_AP;
2751 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
2753 case NL80211_IFTYPE_MONITOR:
2754 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
2761 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
2762 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
2764 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
2765 arvif->vdev_subtype, vif->addr);
2767 ath10k_warn("failed to create WMI vdev %i: %d\n",
2768 arvif->vdev_id, ret);
2772 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2773 list_add(&arvif->list, &ar->arvifs);
2775 vdev_param = ar->wmi.vdev_param->def_keyid;
2776 ret = ath10k_wmi_vdev_set_param(ar, 0, vdev_param,
2777 arvif->def_wep_key_idx);
2779 ath10k_warn("failed to set vdev %i default key id: %d\n",
2780 arvif->vdev_id, ret);
2781 goto err_vdev_delete;
2784 vdev_param = ar->wmi.vdev_param->tx_encap_type;
2785 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2786 ATH10K_HW_TXRX_NATIVE_WIFI);
2787 /* 10.X firmware does not support this VDEV parameter. Do not warn */
2788 if (ret && ret != -EOPNOTSUPP) {
2789 ath10k_warn("failed to set vdev %i TX encapsulation: %d\n",
2790 arvif->vdev_id, ret);
2791 goto err_vdev_delete;
2794 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2795 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2797 ath10k_warn("failed to create vdev %i peer for AP: %d\n",
2798 arvif->vdev_id, ret);
2799 goto err_vdev_delete;
2802 ret = ath10k_mac_set_kickout(arvif);
2804 ath10k_warn("failed to set vdev %i kickout parameters: %d\n",
2805 arvif->vdev_id, ret);
2806 goto err_peer_delete;
2810 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2811 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2812 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2813 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2816 ath10k_warn("failed to set vdev %i RX wake policy: %d\n",
2817 arvif->vdev_id, ret);
2818 goto err_peer_delete;
2821 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2822 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2823 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2826 ath10k_warn("failed to set vdev %i TX wake thresh: %d\n",
2827 arvif->vdev_id, ret);
2828 goto err_peer_delete;
2831 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2832 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2833 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2836 ath10k_warn("failed to set vdev %i PSPOLL count: %d\n",
2837 arvif->vdev_id, ret);
2838 goto err_peer_delete;
2842 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2844 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
2845 arvif->vdev_id, ret);
2846 goto err_peer_delete;
2849 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2851 ath10k_warn("failed to set frag threshold for vdev %d: %d\n",
2852 arvif->vdev_id, ret);
2853 goto err_peer_delete;
2856 mutex_unlock(&ar->conf_mutex);
2860 if (arvif->vdev_type == WMI_VDEV_TYPE_AP)
2861 ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
2864 ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2865 ar->free_vdev_map &= ~BIT(arvif->vdev_id);
2866 list_del(&arvif->list);
2869 mutex_unlock(&ar->conf_mutex);
2874 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2875 struct ieee80211_vif *vif)
2877 struct ath10k *ar = hw->priv;
2878 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2881 mutex_lock(&ar->conf_mutex);
2883 cancel_work_sync(&arvif->wep_key_work);
2885 spin_lock_bh(&ar->data_lock);
2886 if (arvif->beacon) {
2887 dma_unmap_single(arvif->ar->dev,
2888 ATH10K_SKB_CB(arvif->beacon)->paddr,
2889 arvif->beacon->len, DMA_TO_DEVICE);
2890 dev_kfree_skb_any(arvif->beacon);
2891 arvif->beacon = NULL;
2893 spin_unlock_bh(&ar->data_lock);
2895 ar->free_vdev_map |= 1 << (arvif->vdev_id);
2896 list_del(&arvif->list);
2898 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2899 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2901 ath10k_warn("failed to remove peer for AP vdev %i: %d\n",
2902 arvif->vdev_id, ret);
2904 kfree(arvif->u.ap.noa_data);
2907 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
2910 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2912 ath10k_warn("failed to delete WMI vdev %i: %d\n",
2913 arvif->vdev_id, ret);
2915 ath10k_peer_cleanup(ar, arvif->vdev_id);
2917 mutex_unlock(&ar->conf_mutex);
2921 * FIXME: Has to be verified.
2923 #define SUPPORTED_FILTERS \
2924 (FIF_PROMISC_IN_BSS | \
2929 FIF_BCN_PRBRESP_PROMISC | \
2933 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2934 unsigned int changed_flags,
2935 unsigned int *total_flags,
2938 struct ath10k *ar = hw->priv;
2941 mutex_lock(&ar->conf_mutex);
2943 changed_flags &= SUPPORTED_FILTERS;
2944 *total_flags &= SUPPORTED_FILTERS;
2945 ar->filter_flags = *total_flags;
2947 if (ar->filter_flags & FIF_PROMISC_IN_BSS && !ar->promisc) {
2949 ret = ath10k_monitor_start(ar);
2951 ath10k_warn("failed to start monitor (promisc): %d\n",
2953 ar->promisc = false;
2955 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) && ar->promisc) {
2956 ar->promisc = false;
2957 ath10k_monitor_stop(ar);
2960 mutex_unlock(&ar->conf_mutex);
2963 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2964 struct ieee80211_vif *vif,
2965 struct ieee80211_bss_conf *info,
2968 struct ath10k *ar = hw->priv;
2969 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2971 u32 vdev_param, pdev_param;
2973 mutex_lock(&ar->conf_mutex);
2975 if (changed & BSS_CHANGED_IBSS)
2976 ath10k_control_ibss(arvif, info, vif->addr);
2978 if (changed & BSS_CHANGED_BEACON_INT) {
2979 arvif->beacon_interval = info->beacon_int;
2980 vdev_param = ar->wmi.vdev_param->beacon_interval;
2981 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
2982 arvif->beacon_interval);
2983 ath10k_dbg(ATH10K_DBG_MAC,
2984 "mac vdev %d beacon_interval %d\n",
2985 arvif->vdev_id, arvif->beacon_interval);
2988 ath10k_warn("failed to set beacon interval for vdev %d: %i\n",
2989 arvif->vdev_id, ret);
2992 if (changed & BSS_CHANGED_BEACON) {
2993 ath10k_dbg(ATH10K_DBG_MAC,
2994 "vdev %d set beacon tx mode to staggered\n",
2997 pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
2998 ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
2999 WMI_BEACON_STAGGERED_MODE);
3001 ath10k_warn("failed to set beacon mode for vdev %d: %i\n",
3002 arvif->vdev_id, ret);
3005 if (changed & BSS_CHANGED_BEACON_INFO) {
3006 arvif->dtim_period = info->dtim_period;
3008 ath10k_dbg(ATH10K_DBG_MAC,
3009 "mac vdev %d dtim_period %d\n",
3010 arvif->vdev_id, arvif->dtim_period);
3012 vdev_param = ar->wmi.vdev_param->dtim_period;
3013 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3014 arvif->dtim_period);
3016 ath10k_warn("failed to set dtim period for vdev %d: %i\n",
3017 arvif->vdev_id, ret);
3020 if (changed & BSS_CHANGED_SSID &&
3021 vif->type == NL80211_IFTYPE_AP) {
3022 arvif->u.ap.ssid_len = info->ssid_len;
3024 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
3025 arvif->u.ap.hidden_ssid = info->hidden_ssid;
3029 * Firmware manages AP self-peer internally so make sure to not create
3030 * it in driver. Otherwise AP self-peer deletion may timeout later.
3032 if (changed & BSS_CHANGED_BSSID &&
3033 vif->type != NL80211_IFTYPE_AP) {
3034 if (!is_zero_ether_addr(info->bssid)) {
3035 ath10k_dbg(ATH10K_DBG_MAC,
3036 "mac vdev %d create peer %pM\n",
3037 arvif->vdev_id, info->bssid);
3039 ret = ath10k_peer_create(ar, arvif->vdev_id,
3042 ath10k_warn("failed to add peer %pM for vdev %d when changing bssid: %i\n",
3043 info->bssid, arvif->vdev_id, ret);
3045 if (vif->type == NL80211_IFTYPE_STATION) {
3047 * this is never erased as we it for crypto key
3048 * clearing; this is FW requirement
3050 memcpy(arvif->bssid, info->bssid, ETH_ALEN);
3052 ath10k_dbg(ATH10K_DBG_MAC,
3053 "mac vdev %d start %pM\n",
3054 arvif->vdev_id, info->bssid);
3056 ret = ath10k_vdev_start(arvif);
3058 ath10k_warn("failed to start vdev %i: %d\n",
3059 arvif->vdev_id, ret);
3063 arvif->is_started = true;
3067 * Mac80211 does not keep IBSS bssid when leaving IBSS,
3068 * so driver need to store it. It is needed when leaving
3069 * IBSS in order to remove BSSID peer.
3071 if (vif->type == NL80211_IFTYPE_ADHOC)
3072 memcpy(arvif->bssid, info->bssid,
3077 if (changed & BSS_CHANGED_BEACON_ENABLED)
3078 ath10k_control_beaconing(arvif, info);
3080 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
3081 arvif->use_cts_prot = info->use_cts_prot;
3082 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
3083 arvif->vdev_id, info->use_cts_prot);
3085 ret = ath10k_recalc_rtscts_prot(arvif);
3087 ath10k_warn("failed to recalculate rts/cts prot for vdev %d: %d\n",
3088 arvif->vdev_id, ret);
3091 if (changed & BSS_CHANGED_ERP_SLOT) {
3093 if (info->use_short_slot)
3094 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
3097 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
3099 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
3100 arvif->vdev_id, slottime);
3102 vdev_param = ar->wmi.vdev_param->slot_time;
3103 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3106 ath10k_warn("failed to set erp slot for vdev %d: %i\n",
3107 arvif->vdev_id, ret);
3110 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
3112 if (info->use_short_preamble)
3113 preamble = WMI_VDEV_PREAMBLE_SHORT;
3115 preamble = WMI_VDEV_PREAMBLE_LONG;
3117 ath10k_dbg(ATH10K_DBG_MAC,
3118 "mac vdev %d preamble %dn",
3119 arvif->vdev_id, preamble);
3121 vdev_param = ar->wmi.vdev_param->preamble;
3122 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3125 ath10k_warn("failed to set preamble for vdev %d: %i\n",
3126 arvif->vdev_id, ret);
3129 if (changed & BSS_CHANGED_ASSOC) {
3131 ath10k_bss_assoc(hw, vif, info);
3135 mutex_unlock(&ar->conf_mutex);
3138 static int ath10k_hw_scan(struct ieee80211_hw *hw,
3139 struct ieee80211_vif *vif,
3140 struct cfg80211_scan_request *req)
3142 struct ath10k *ar = hw->priv;
3143 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3144 struct wmi_start_scan_arg arg;
3148 mutex_lock(&ar->conf_mutex);
3150 spin_lock_bh(&ar->data_lock);
3151 if (ar->scan.in_progress) {
3152 spin_unlock_bh(&ar->data_lock);
3157 reinit_completion(&ar->scan.started);
3158 reinit_completion(&ar->scan.completed);
3159 ar->scan.in_progress = true;
3160 ar->scan.aborting = false;
3161 ar->scan.is_roc = false;
3162 ar->scan.vdev_id = arvif->vdev_id;
3163 spin_unlock_bh(&ar->data_lock);
3165 memset(&arg, 0, sizeof(arg));
3166 ath10k_wmi_start_scan_init(ar, &arg);
3167 arg.vdev_id = arvif->vdev_id;
3168 arg.scan_id = ATH10K_SCAN_ID;
3171 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
3174 arg.ie_len = req->ie_len;
3175 memcpy(arg.ie, req->ie, arg.ie_len);
3179 arg.n_ssids = req->n_ssids;
3180 for (i = 0; i < arg.n_ssids; i++) {
3181 arg.ssids[i].len = req->ssids[i].ssid_len;
3182 arg.ssids[i].ssid = req->ssids[i].ssid;
3185 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3188 if (req->n_channels) {
3189 arg.n_channels = req->n_channels;
3190 for (i = 0; i < arg.n_channels; i++)
3191 arg.channels[i] = req->channels[i]->center_freq;
3194 ret = ath10k_start_scan(ar, &arg);
3196 ath10k_warn("failed to start hw scan: %d\n", ret);
3197 spin_lock_bh(&ar->data_lock);
3198 ar->scan.in_progress = false;
3199 spin_unlock_bh(&ar->data_lock);
3203 mutex_unlock(&ar->conf_mutex);
3207 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
3208 struct ieee80211_vif *vif)
3210 struct ath10k *ar = hw->priv;
3213 mutex_lock(&ar->conf_mutex);
3214 ret = ath10k_abort_scan(ar);
3216 ath10k_warn("failed to abort scan: %d\n", ret);
3217 ieee80211_scan_completed(hw, 1 /* aborted */);
3219 mutex_unlock(&ar->conf_mutex);
3222 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
3223 struct ath10k_vif *arvif,
3224 enum set_key_cmd cmd,
3225 struct ieee80211_key_conf *key)
3227 u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
3230 /* 10.1 firmware branch requires default key index to be set to group
3231 * key index after installing it. Otherwise FW/HW Txes corrupted
3232 * frames with multi-vif APs. This is not required for main firmware
3233 * branch (e.g. 636).
3235 * FIXME: This has been tested only in AP. It remains unknown if this
3236 * is required for multi-vif STA interfaces on 10.1 */
3238 if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
3241 if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
3244 if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
3247 if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
3253 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
3256 ath10k_warn("failed to set vdev %i group key as default key: %d\n",
3257 arvif->vdev_id, ret);
3260 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
3261 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
3262 struct ieee80211_key_conf *key)
3264 struct ath10k *ar = hw->priv;
3265 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3266 struct ath10k_peer *peer;
3267 const u8 *peer_addr;
3268 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
3269 key->cipher == WLAN_CIPHER_SUITE_WEP104;
3272 if (key->keyidx > WMI_MAX_KEY_INDEX)
3275 mutex_lock(&ar->conf_mutex);
3278 peer_addr = sta->addr;
3279 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
3280 peer_addr = vif->bss_conf.bssid;
3282 peer_addr = vif->addr;
3284 key->hw_key_idx = key->keyidx;
3286 /* the peer should not disappear in mid-way (unless FW goes awry) since
3287 * we already hold conf_mutex. we just make sure its there now. */
3288 spin_lock_bh(&ar->data_lock);
3289 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3290 spin_unlock_bh(&ar->data_lock);
3293 if (cmd == SET_KEY) {
3294 ath10k_warn("failed to install key for non-existent peer %pM\n",
3299 /* if the peer doesn't exist there is no key to disable
3307 arvif->wep_keys[key->keyidx] = key;
3309 arvif->wep_keys[key->keyidx] = NULL;
3311 if (cmd == DISABLE_KEY)
3312 ath10k_clear_vdev_key(arvif, key);
3315 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
3317 ath10k_warn("failed to install key for vdev %i peer %pM: %d\n",
3318 arvif->vdev_id, peer_addr, ret);
3322 ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
3324 spin_lock_bh(&ar->data_lock);
3325 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
3326 if (peer && cmd == SET_KEY)
3327 peer->keys[key->keyidx] = key;
3328 else if (peer && cmd == DISABLE_KEY)
3329 peer->keys[key->keyidx] = NULL;
3330 else if (peer == NULL)
3331 /* impossible unless FW goes crazy */
3332 ath10k_warn("Peer %pM disappeared!\n", peer_addr);
3333 spin_unlock_bh(&ar->data_lock);
3336 mutex_unlock(&ar->conf_mutex);
3340 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
3343 struct ath10k_vif *arvif;
3344 struct ath10k_sta *arsta;
3345 struct ieee80211_sta *sta;
3346 u32 changed, bw, nss, smps;
3349 arsta = container_of(wk, struct ath10k_sta, update_wk);
3350 sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
3351 arvif = arsta->arvif;
3354 spin_lock_bh(&ar->data_lock);
3356 changed = arsta->changed;
3363 spin_unlock_bh(&ar->data_lock);
3365 mutex_lock(&ar->conf_mutex);
3367 if (changed & IEEE80211_RC_BW_CHANGED) {
3368 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM peer bw %d\n",
3371 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3372 WMI_PEER_CHAN_WIDTH, bw);
3374 ath10k_warn("failed to update STA %pM peer bw %d: %d\n",
3375 sta->addr, bw, err);
3378 if (changed & IEEE80211_RC_NSS_CHANGED) {
3379 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM nss %d\n",
3382 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3385 ath10k_warn("failed to update STA %pM nss %d: %d\n",
3386 sta->addr, nss, err);
3389 if (changed & IEEE80211_RC_SMPS_CHANGED) {
3390 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM smps %d\n",
3393 err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
3394 WMI_PEER_SMPS_STATE, smps);
3396 ath10k_warn("failed to update STA %pM smps %d: %d\n",
3397 sta->addr, smps, err);
3400 if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
3401 ath10k_dbg(ATH10K_DBG_MAC, "mac update sta %pM supp rates\n",
3404 err = ath10k_station_assoc(ar, arvif, sta, true);
3406 ath10k_warn("failed to reassociate station: %pM\n",
3410 mutex_unlock(&ar->conf_mutex);
3413 static int ath10k_sta_state(struct ieee80211_hw *hw,
3414 struct ieee80211_vif *vif,
3415 struct ieee80211_sta *sta,
3416 enum ieee80211_sta_state old_state,
3417 enum ieee80211_sta_state new_state)
3419 struct ath10k *ar = hw->priv;
3420 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3421 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3425 if (old_state == IEEE80211_STA_NOTEXIST &&
3426 new_state == IEEE80211_STA_NONE) {
3427 memset(arsta, 0, sizeof(*arsta));
3428 arsta->arvif = arvif;
3429 INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
3432 /* cancel must be done outside the mutex to avoid deadlock */
3433 if ((old_state == IEEE80211_STA_NONE &&
3434 new_state == IEEE80211_STA_NOTEXIST))
3435 cancel_work_sync(&arsta->update_wk);
3437 mutex_lock(&ar->conf_mutex);
3439 if (old_state == IEEE80211_STA_NOTEXIST &&
3440 new_state == IEEE80211_STA_NONE &&
3441 vif->type != NL80211_IFTYPE_STATION) {
3443 * New station addition.
3445 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features))
3446 max_num_peers = TARGET_10X_NUM_PEERS_MAX - 1;
3448 max_num_peers = TARGET_NUM_PEERS;
3450 if (ar->num_peers >= max_num_peers) {
3451 ath10k_warn("number of peers exceeded: peers number %d (max peers %d)\n",
3452 ar->num_peers, max_num_peers);
3457 ath10k_dbg(ATH10K_DBG_MAC,
3458 "mac vdev %d peer create %pM (new sta) num_peers %d\n",
3459 arvif->vdev_id, sta->addr, ar->num_peers);
3461 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
3463 ath10k_warn("failed to add peer %pM for vdev %d when adding a new sta: %i\n",
3464 sta->addr, arvif->vdev_id, ret);
3465 } else if ((old_state == IEEE80211_STA_NONE &&
3466 new_state == IEEE80211_STA_NOTEXIST)) {
3468 * Existing station deletion.
3470 ath10k_dbg(ATH10K_DBG_MAC,
3471 "mac vdev %d peer delete %pM (sta gone)\n",
3472 arvif->vdev_id, sta->addr);
3473 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
3475 ath10k_warn("failed to delete peer %pM for vdev %d: %i\n",
3476 sta->addr, arvif->vdev_id, ret);
3478 if (vif->type == NL80211_IFTYPE_STATION)
3479 ath10k_bss_disassoc(hw, vif);
3480 } else if (old_state == IEEE80211_STA_AUTH &&
3481 new_state == IEEE80211_STA_ASSOC &&
3482 (vif->type == NL80211_IFTYPE_AP ||
3483 vif->type == NL80211_IFTYPE_ADHOC)) {
3487 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
3490 ret = ath10k_station_assoc(ar, arvif, sta, false);
3492 ath10k_warn("failed to associate station %pM for vdev %i: %i\n",
3493 sta->addr, arvif->vdev_id, ret);
3494 } else if (old_state == IEEE80211_STA_ASSOC &&
3495 new_state == IEEE80211_STA_AUTH &&
3496 (vif->type == NL80211_IFTYPE_AP ||
3497 vif->type == NL80211_IFTYPE_ADHOC)) {
3501 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
3504 ret = ath10k_station_disassoc(ar, arvif, sta);
3506 ath10k_warn("failed to disassociate station: %pM vdev %i: %i\n",
3507 sta->addr, arvif->vdev_id, ret);
3510 mutex_unlock(&ar->conf_mutex);
3514 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
3515 u16 ac, bool enable)
3517 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3521 lockdep_assert_held(&ar->conf_mutex);
3523 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
3527 case IEEE80211_AC_VO:
3528 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
3529 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
3531 case IEEE80211_AC_VI:
3532 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
3533 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
3535 case IEEE80211_AC_BE:
3536 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
3537 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
3539 case IEEE80211_AC_BK:
3540 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
3541 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
3546 arvif->u.sta.uapsd |= value;
3548 arvif->u.sta.uapsd &= ~value;
3550 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3551 WMI_STA_PS_PARAM_UAPSD,
3552 arvif->u.sta.uapsd);
3554 ath10k_warn("failed to set uapsd params: %d\n", ret);
3558 if (arvif->u.sta.uapsd)
3559 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
3561 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
3563 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
3564 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
3567 ath10k_warn("failed to set rx wake param: %d\n", ret);
3573 static int ath10k_conf_tx(struct ieee80211_hw *hw,
3574 struct ieee80211_vif *vif, u16 ac,
3575 const struct ieee80211_tx_queue_params *params)
3577 struct ath10k *ar = hw->priv;
3578 struct wmi_wmm_params_arg *p = NULL;
3581 mutex_lock(&ar->conf_mutex);
3584 case IEEE80211_AC_VO:
3585 p = &ar->wmm_params.ac_vo;
3587 case IEEE80211_AC_VI:
3588 p = &ar->wmm_params.ac_vi;
3590 case IEEE80211_AC_BE:
3591 p = &ar->wmm_params.ac_be;
3593 case IEEE80211_AC_BK:
3594 p = &ar->wmm_params.ac_bk;
3603 p->cwmin = params->cw_min;
3604 p->cwmax = params->cw_max;
3605 p->aifs = params->aifs;
3608 * The channel time duration programmed in the HW is in absolute
3609 * microseconds, while mac80211 gives the txop in units of
3612 p->txop = params->txop * 32;
3614 /* FIXME: FW accepts wmm params per hw, not per vif */
3615 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
3617 ath10k_warn("failed to set wmm params: %d\n", ret);
3621 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
3623 ath10k_warn("failed to set sta uapsd: %d\n", ret);
3626 mutex_unlock(&ar->conf_mutex);
3630 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
3632 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
3633 struct ieee80211_vif *vif,
3634 struct ieee80211_channel *chan,
3636 enum ieee80211_roc_type type)
3638 struct ath10k *ar = hw->priv;
3639 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3640 struct wmi_start_scan_arg arg;
3643 mutex_lock(&ar->conf_mutex);
3645 spin_lock_bh(&ar->data_lock);
3646 if (ar->scan.in_progress) {
3647 spin_unlock_bh(&ar->data_lock);
3652 reinit_completion(&ar->scan.started);
3653 reinit_completion(&ar->scan.completed);
3654 reinit_completion(&ar->scan.on_channel);
3655 ar->scan.in_progress = true;
3656 ar->scan.aborting = false;
3657 ar->scan.is_roc = true;
3658 ar->scan.vdev_id = arvif->vdev_id;
3659 ar->scan.roc_freq = chan->center_freq;
3660 spin_unlock_bh(&ar->data_lock);
3662 memset(&arg, 0, sizeof(arg));
3663 ath10k_wmi_start_scan_init(ar, &arg);
3664 arg.vdev_id = arvif->vdev_id;
3665 arg.scan_id = ATH10K_SCAN_ID;
3667 arg.channels[0] = chan->center_freq;
3668 arg.dwell_time_active = duration;
3669 arg.dwell_time_passive = duration;
3670 arg.max_scan_time = 2 * duration;
3671 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
3672 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
3674 ret = ath10k_start_scan(ar, &arg);
3676 ath10k_warn("failed to start roc scan: %d\n", ret);
3677 spin_lock_bh(&ar->data_lock);
3678 ar->scan.in_progress = false;
3679 spin_unlock_bh(&ar->data_lock);
3683 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
3685 ath10k_warn("failed to switch to channel for roc scan\n");
3686 ath10k_abort_scan(ar);
3693 mutex_unlock(&ar->conf_mutex);
3697 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
3699 struct ath10k *ar = hw->priv;
3701 mutex_lock(&ar->conf_mutex);
3702 ath10k_abort_scan(ar);
3703 mutex_unlock(&ar->conf_mutex);
3709 * Both RTS and Fragmentation threshold are interface-specific
3710 * in ath10k, but device-specific in mac80211.
3713 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
3715 struct ath10k *ar = hw->priv;
3716 struct ath10k_vif *arvif;
3719 mutex_lock(&ar->conf_mutex);
3720 list_for_each_entry(arvif, &ar->arvifs, list) {
3721 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
3722 arvif->vdev_id, value);
3724 ret = ath10k_mac_set_rts(arvif, value);
3726 ath10k_warn("failed to set rts threshold for vdev %d: %d\n",
3727 arvif->vdev_id, ret);
3731 mutex_unlock(&ar->conf_mutex);
3736 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
3738 struct ath10k *ar = hw->priv;
3739 struct ath10k_vif *arvif;
3742 mutex_lock(&ar->conf_mutex);
3743 list_for_each_entry(arvif, &ar->arvifs, list) {
3744 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation threshold %d\n",
3745 arvif->vdev_id, value);
3747 ret = ath10k_mac_set_rts(arvif, value);
3749 ath10k_warn("failed to set fragmentation threshold for vdev %d: %d\n",
3750 arvif->vdev_id, ret);
3754 mutex_unlock(&ar->conf_mutex);
3759 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
3760 u32 queues, bool drop)
3762 struct ath10k *ar = hw->priv;
3766 /* mac80211 doesn't care if we really xmit queued frames or not
3767 * we'll collect those frames either way if we stop/delete vdevs */
3771 mutex_lock(&ar->conf_mutex);
3773 if (ar->state == ATH10K_STATE_WEDGED)
3776 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
3779 spin_lock_bh(&ar->htt.tx_lock);
3780 empty = (ar->htt.num_pending_tx == 0);
3781 spin_unlock_bh(&ar->htt.tx_lock);
3783 skip = (ar->state == ATH10K_STATE_WEDGED);
3786 }), ATH10K_FLUSH_TIMEOUT_HZ);
3788 if (ret <= 0 || skip)
3789 ath10k_warn("failed to flush transmit queue (skip %i ar-state %i): %i\n",
3790 skip, ar->state, ret);
3793 mutex_unlock(&ar->conf_mutex);
3796 /* TODO: Implement this function properly
3797 * For now it is needed to reply to Probe Requests in IBSS mode.
3798 * Propably we need this information from FW.
3800 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
3806 static int ath10k_suspend(struct ieee80211_hw *hw,
3807 struct cfg80211_wowlan *wowlan)
3809 struct ath10k *ar = hw->priv;
3812 mutex_lock(&ar->conf_mutex);
3814 ret = ath10k_wait_for_suspend(ar, WMI_PDEV_SUSPEND);
3816 if (ret == -ETIMEDOUT)
3822 ret = ath10k_hif_suspend(ar);
3824 ath10k_warn("failed to suspend hif: %d\n", ret);
3831 ret = ath10k_wmi_pdev_resume_target(ar);
3833 ath10k_warn("failed to resume target: %d\n", ret);
3837 mutex_unlock(&ar->conf_mutex);
3841 static int ath10k_resume(struct ieee80211_hw *hw)
3843 struct ath10k *ar = hw->priv;
3846 mutex_lock(&ar->conf_mutex);
3848 ret = ath10k_hif_resume(ar);
3850 ath10k_warn("failed to resume hif: %d\n", ret);
3855 ret = ath10k_wmi_pdev_resume_target(ar);
3857 ath10k_warn("failed to resume target: %d\n", ret);
3864 mutex_unlock(&ar->conf_mutex);
3869 static void ath10k_restart_complete(struct ieee80211_hw *hw)
3871 struct ath10k *ar = hw->priv;
3873 mutex_lock(&ar->conf_mutex);
3875 /* If device failed to restart it will be in a different state, e.g.
3876 * ATH10K_STATE_WEDGED */
3877 if (ar->state == ATH10K_STATE_RESTARTED) {
3878 ath10k_info("device successfully recovered\n");
3879 ar->state = ATH10K_STATE_ON;
3882 mutex_unlock(&ar->conf_mutex);
3885 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
3886 struct survey_info *survey)
3888 struct ath10k *ar = hw->priv;
3889 struct ieee80211_supported_band *sband;
3890 struct survey_info *ar_survey = &ar->survey[idx];
3893 mutex_lock(&ar->conf_mutex);
3895 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
3896 if (sband && idx >= sband->n_channels) {
3897 idx -= sband->n_channels;
3902 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
3904 if (!sband || idx >= sband->n_channels) {
3909 spin_lock_bh(&ar->data_lock);
3910 memcpy(survey, ar_survey, sizeof(*survey));
3911 spin_unlock_bh(&ar->data_lock);
3913 survey->channel = &sband->channels[idx];
3916 mutex_unlock(&ar->conf_mutex);
3920 /* Helper table for legacy fixed_rate/bitrate_mask */
3921 static const u8 cck_ofdm_rate[] = {
3938 /* Check if only one bit set */
3939 static int ath10k_check_single_mask(u32 mask)
3947 mask &= ~BIT(bit - 1);
3955 ath10k_default_bitrate_mask(struct ath10k *ar,
3956 enum ieee80211_band band,
3957 const struct cfg80211_bitrate_mask *mask)
3959 u32 legacy = 0x00ff;
3964 case IEEE80211_BAND_2GHZ:
3968 case IEEE80211_BAND_5GHZ:
3974 if (mask->control[band].legacy != legacy)
3977 for (i = 0; i < ar->num_rf_chains; i++)
3978 if (mask->control[band].ht_mcs[i] != ht)
3981 for (i = 0; i < ar->num_rf_chains; i++)
3982 if (mask->control[band].vht_mcs[i] != vht)
3989 ath10k_bitrate_mask_nss(const struct cfg80211_bitrate_mask *mask,
3990 enum ieee80211_band band,
3993 int ht_nss = 0, vht_nss = 0, i;
3996 if (ath10k_check_single_mask(mask->control[band].legacy))
4000 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++) {
4001 if (mask->control[band].ht_mcs[i] == 0xff)
4003 else if (mask->control[band].ht_mcs[i] == 0x00)
4012 for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
4013 if (mask->control[band].vht_mcs[i] == 0x03ff)
4015 else if (mask->control[band].vht_mcs[i] == 0x0000)
4023 if (ht_nss > 0 && vht_nss > 0)
4027 *fixed_nss = ht_nss;
4029 *fixed_nss = vht_nss;
4037 ath10k_bitrate_mask_correct(const struct cfg80211_bitrate_mask *mask,
4038 enum ieee80211_band band,
4039 enum wmi_rate_preamble *preamble)
4041 int legacy = 0, ht = 0, vht = 0, i;
4043 *preamble = WMI_RATE_PREAMBLE_OFDM;
4046 legacy = ath10k_check_single_mask(mask->control[band].legacy);
4051 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4052 ht += ath10k_check_single_mask(mask->control[band].ht_mcs[i]);
4057 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4058 vht += ath10k_check_single_mask(mask->control[band].vht_mcs[i]);
4062 /* Currently we support only one fixed_rate */
4063 if ((legacy + ht + vht) != 1)
4067 *preamble = WMI_RATE_PREAMBLE_HT;
4069 *preamble = WMI_RATE_PREAMBLE_VHT;
4075 ath10k_bitrate_mask_rate(const struct cfg80211_bitrate_mask *mask,
4076 enum ieee80211_band band,
4080 u8 rate = 0, pream = 0, nss = 0, i;
4081 enum wmi_rate_preamble preamble;
4083 /* Check if single rate correct */
4084 if (!ath10k_bitrate_mask_correct(mask, band, &preamble))
4090 case WMI_RATE_PREAMBLE_CCK:
4091 case WMI_RATE_PREAMBLE_OFDM:
4092 i = ffs(mask->control[band].legacy) - 1;
4094 if (band == IEEE80211_BAND_2GHZ && i < 4)
4095 pream = WMI_RATE_PREAMBLE_CCK;
4097 if (band == IEEE80211_BAND_5GHZ)
4100 if (i >= ARRAY_SIZE(cck_ofdm_rate))
4103 rate = cck_ofdm_rate[i];
4105 case WMI_RATE_PREAMBLE_HT:
4106 for (i = 0; i < IEEE80211_HT_MCS_MASK_LEN; i++)
4107 if (mask->control[band].ht_mcs[i])
4110 if (i == IEEE80211_HT_MCS_MASK_LEN)
4113 rate = ffs(mask->control[band].ht_mcs[i]) - 1;
4116 case WMI_RATE_PREAMBLE_VHT:
4117 for (i = 0; i < NL80211_VHT_NSS_MAX; i++)
4118 if (mask->control[band].vht_mcs[i])
4121 if (i == NL80211_VHT_NSS_MAX)
4124 rate = ffs(mask->control[band].vht_mcs[i]) - 1;
4129 *fixed_nss = nss + 1;
4133 ath10k_dbg(ATH10K_DBG_MAC, "mac fixed rate pream 0x%02x nss 0x%02x rate 0x%02x\n",
4136 *fixed_rate = pream | nss | rate;
4141 static bool ath10k_get_fixed_rate_nss(const struct cfg80211_bitrate_mask *mask,
4142 enum ieee80211_band band,
4146 /* First check full NSS mask, if we can simply limit NSS */
4147 if (ath10k_bitrate_mask_nss(mask, band, fixed_nss))
4150 /* Next Check single rate is set */
4151 return ath10k_bitrate_mask_rate(mask, band, fixed_rate, fixed_nss);
4154 static int ath10k_set_fixed_rate_param(struct ath10k_vif *arvif,
4159 struct ath10k *ar = arvif->ar;
4163 mutex_lock(&ar->conf_mutex);
4165 if (arvif->fixed_rate == fixed_rate &&
4166 arvif->fixed_nss == fixed_nss &&
4167 arvif->force_sgi == force_sgi)
4170 if (fixed_rate == WMI_FIXED_RATE_NONE)
4171 ath10k_dbg(ATH10K_DBG_MAC, "mac disable fixed bitrate mask\n");
4174 ath10k_dbg(ATH10K_DBG_MAC, "mac force sgi\n");
4176 vdev_param = ar->wmi.vdev_param->fixed_rate;
4177 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4178 vdev_param, fixed_rate);
4180 ath10k_warn("failed to set fixed rate param 0x%02x: %d\n",
4186 arvif->fixed_rate = fixed_rate;
4188 vdev_param = ar->wmi.vdev_param->nss;
4189 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
4190 vdev_param, fixed_nss);
4193 ath10k_warn("failed to set fixed nss param %d: %d\n",
4199 arvif->fixed_nss = fixed_nss;
4201 vdev_param = ar->wmi.vdev_param->sgi;
4202 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
4206 ath10k_warn("failed to set sgi param %d: %d\n",
4212 arvif->force_sgi = force_sgi;
4215 mutex_unlock(&ar->conf_mutex);
4219 static int ath10k_set_bitrate_mask(struct ieee80211_hw *hw,
4220 struct ieee80211_vif *vif,
4221 const struct cfg80211_bitrate_mask *mask)
4223 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4224 struct ath10k *ar = arvif->ar;
4225 enum ieee80211_band band = ar->hw->conf.chandef.chan->band;
4226 u8 fixed_rate = WMI_FIXED_RATE_NONE;
4227 u8 fixed_nss = ar->num_rf_chains;
4230 force_sgi = mask->control[band].gi;
4231 if (force_sgi == NL80211_TXRATE_FORCE_LGI)
4234 if (!ath10k_default_bitrate_mask(ar, band, mask)) {
4235 if (!ath10k_get_fixed_rate_nss(mask, band,
4241 if (fixed_rate == WMI_FIXED_RATE_NONE && force_sgi) {
4242 ath10k_warn("failed to force SGI usage for default rate settings\n");
4246 return ath10k_set_fixed_rate_param(arvif, fixed_rate,
4247 fixed_nss, force_sgi);
4250 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
4251 struct ieee80211_vif *vif,
4252 struct ieee80211_sta *sta,
4255 struct ath10k *ar = hw->priv;
4256 struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
4259 spin_lock_bh(&ar->data_lock);
4261 ath10k_dbg(ATH10K_DBG_MAC,
4262 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
4263 sta->addr, changed, sta->bandwidth, sta->rx_nss,
4266 if (changed & IEEE80211_RC_BW_CHANGED) {
4267 bw = WMI_PEER_CHWIDTH_20MHZ;
4269 switch (sta->bandwidth) {
4270 case IEEE80211_STA_RX_BW_20:
4271 bw = WMI_PEER_CHWIDTH_20MHZ;
4273 case IEEE80211_STA_RX_BW_40:
4274 bw = WMI_PEER_CHWIDTH_40MHZ;
4276 case IEEE80211_STA_RX_BW_80:
4277 bw = WMI_PEER_CHWIDTH_80MHZ;
4279 case IEEE80211_STA_RX_BW_160:
4280 ath10k_warn("Invalid bandwith %d in rc update for %pM\n",
4281 sta->bandwidth, sta->addr);
4282 bw = WMI_PEER_CHWIDTH_20MHZ;
4289 if (changed & IEEE80211_RC_NSS_CHANGED)
4290 arsta->nss = sta->rx_nss;
4292 if (changed & IEEE80211_RC_SMPS_CHANGED) {
4293 smps = WMI_PEER_SMPS_PS_NONE;
4295 switch (sta->smps_mode) {
4296 case IEEE80211_SMPS_AUTOMATIC:
4297 case IEEE80211_SMPS_OFF:
4298 smps = WMI_PEER_SMPS_PS_NONE;
4300 case IEEE80211_SMPS_STATIC:
4301 smps = WMI_PEER_SMPS_STATIC;
4303 case IEEE80211_SMPS_DYNAMIC:
4304 smps = WMI_PEER_SMPS_DYNAMIC;
4306 case IEEE80211_SMPS_NUM_MODES:
4307 ath10k_warn("Invalid smps %d in sta rc update for %pM\n",
4308 sta->smps_mode, sta->addr);
4309 smps = WMI_PEER_SMPS_PS_NONE;
4316 arsta->changed |= changed;
4318 spin_unlock_bh(&ar->data_lock);
4320 ieee80211_queue_work(hw, &arsta->update_wk);
4323 static u64 ath10k_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
4326 * FIXME: Return 0 for time being. Need to figure out whether FW
4327 * has the API to fetch 64-bit local TSF
4333 static const struct ieee80211_ops ath10k_ops = {
4335 .start = ath10k_start,
4336 .stop = ath10k_stop,
4337 .config = ath10k_config,
4338 .add_interface = ath10k_add_interface,
4339 .remove_interface = ath10k_remove_interface,
4340 .configure_filter = ath10k_configure_filter,
4341 .bss_info_changed = ath10k_bss_info_changed,
4342 .hw_scan = ath10k_hw_scan,
4343 .cancel_hw_scan = ath10k_cancel_hw_scan,
4344 .set_key = ath10k_set_key,
4345 .sta_state = ath10k_sta_state,
4346 .conf_tx = ath10k_conf_tx,
4347 .remain_on_channel = ath10k_remain_on_channel,
4348 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
4349 .set_rts_threshold = ath10k_set_rts_threshold,
4350 .set_frag_threshold = ath10k_set_frag_threshold,
4351 .flush = ath10k_flush,
4352 .tx_last_beacon = ath10k_tx_last_beacon,
4353 .set_antenna = ath10k_set_antenna,
4354 .get_antenna = ath10k_get_antenna,
4355 .restart_complete = ath10k_restart_complete,
4356 .get_survey = ath10k_get_survey,
4357 .set_bitrate_mask = ath10k_set_bitrate_mask,
4358 .sta_rc_update = ath10k_sta_rc_update,
4359 .get_tsf = ath10k_get_tsf,
4361 .suspend = ath10k_suspend,
4362 .resume = ath10k_resume,
4366 #define RATETAB_ENT(_rate, _rateid, _flags) { \
4367 .bitrate = (_rate), \
4368 .flags = (_flags), \
4369 .hw_value = (_rateid), \
4372 #define CHAN2G(_channel, _freq, _flags) { \
4373 .band = IEEE80211_BAND_2GHZ, \
4374 .hw_value = (_channel), \
4375 .center_freq = (_freq), \
4376 .flags = (_flags), \
4377 .max_antenna_gain = 0, \
4381 #define CHAN5G(_channel, _freq, _flags) { \
4382 .band = IEEE80211_BAND_5GHZ, \
4383 .hw_value = (_channel), \
4384 .center_freq = (_freq), \
4385 .flags = (_flags), \
4386 .max_antenna_gain = 0, \
4390 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
4400 CHAN2G(10, 2457, 0),
4401 CHAN2G(11, 2462, 0),
4402 CHAN2G(12, 2467, 0),
4403 CHAN2G(13, 2472, 0),
4404 CHAN2G(14, 2484, 0),
4407 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
4408 CHAN5G(36, 5180, 0),
4409 CHAN5G(40, 5200, 0),
4410 CHAN5G(44, 5220, 0),
4411 CHAN5G(48, 5240, 0),
4412 CHAN5G(52, 5260, 0),
4413 CHAN5G(56, 5280, 0),
4414 CHAN5G(60, 5300, 0),
4415 CHAN5G(64, 5320, 0),
4416 CHAN5G(100, 5500, 0),
4417 CHAN5G(104, 5520, 0),
4418 CHAN5G(108, 5540, 0),
4419 CHAN5G(112, 5560, 0),
4420 CHAN5G(116, 5580, 0),
4421 CHAN5G(120, 5600, 0),
4422 CHAN5G(124, 5620, 0),
4423 CHAN5G(128, 5640, 0),
4424 CHAN5G(132, 5660, 0),
4425 CHAN5G(136, 5680, 0),
4426 CHAN5G(140, 5700, 0),
4427 CHAN5G(149, 5745, 0),
4428 CHAN5G(153, 5765, 0),
4429 CHAN5G(157, 5785, 0),
4430 CHAN5G(161, 5805, 0),
4431 CHAN5G(165, 5825, 0),
4434 static struct ieee80211_rate ath10k_rates[] = {
4436 RATETAB_ENT(10, 0x82, 0),
4437 RATETAB_ENT(20, 0x84, 0),
4438 RATETAB_ENT(55, 0x8b, 0),
4439 RATETAB_ENT(110, 0x96, 0),
4441 RATETAB_ENT(60, 0x0c, 0),
4442 RATETAB_ENT(90, 0x12, 0),
4443 RATETAB_ENT(120, 0x18, 0),
4444 RATETAB_ENT(180, 0x24, 0),
4445 RATETAB_ENT(240, 0x30, 0),
4446 RATETAB_ENT(360, 0x48, 0),
4447 RATETAB_ENT(480, 0x60, 0),
4448 RATETAB_ENT(540, 0x6c, 0),
4451 #define ath10k_a_rates (ath10k_rates + 4)
4452 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
4453 #define ath10k_g_rates (ath10k_rates + 0)
4454 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
4456 struct ath10k *ath10k_mac_create(void)
4458 struct ieee80211_hw *hw;
4461 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
4471 void ath10k_mac_destroy(struct ath10k *ar)
4473 ieee80211_free_hw(ar->hw);
4476 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
4479 .types = BIT(NL80211_IFTYPE_STATION)
4480 | BIT(NL80211_IFTYPE_P2P_CLIENT)
4484 .types = BIT(NL80211_IFTYPE_P2P_GO)
4488 .types = BIT(NL80211_IFTYPE_AP)
4492 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
4495 .types = BIT(NL80211_IFTYPE_AP)
4499 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
4501 .limits = ath10k_if_limits,
4502 .n_limits = ARRAY_SIZE(ath10k_if_limits),
4503 .max_interfaces = 8,
4504 .num_different_channels = 1,
4505 .beacon_int_infra_match = true,
4509 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
4511 .limits = ath10k_10x_if_limits,
4512 .n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
4513 .max_interfaces = 8,
4514 .num_different_channels = 1,
4515 .beacon_int_infra_match = true,
4516 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
4517 .radar_detect_widths = BIT(NL80211_CHAN_WIDTH_20_NOHT) |
4518 BIT(NL80211_CHAN_WIDTH_20) |
4519 BIT(NL80211_CHAN_WIDTH_40) |
4520 BIT(NL80211_CHAN_WIDTH_80),
4525 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4527 struct ieee80211_sta_vht_cap vht_cap = {0};
4531 vht_cap.vht_supported = 1;
4532 vht_cap.cap = ar->vht_cap_info;
4535 for (i = 0; i < 8; i++) {
4536 if (i < ar->num_rf_chains)
4537 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
4539 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
4542 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4543 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4548 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4551 struct ieee80211_sta_ht_cap ht_cap = {0};
4553 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4556 ht_cap.ht_supported = 1;
4557 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4558 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4559 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4560 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4561 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
4563 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4564 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4566 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4567 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4569 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4572 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
4573 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4578 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
4579 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4581 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4584 stbc = ar->ht_cap_info;
4585 stbc &= WMI_HT_CAP_RX_STBC;
4586 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4587 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4588 stbc &= IEEE80211_HT_CAP_RX_STBC;
4593 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
4594 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4596 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4597 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4599 /* max AMSDU is implicitly taken from vht_cap_info */
4600 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4601 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4603 for (i = 0; i < ar->num_rf_chains; i++)
4604 ht_cap.mcs.rx_mask[i] = 0xFF;
4606 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4612 static void ath10k_get_arvif_iter(void *data, u8 *mac,
4613 struct ieee80211_vif *vif)
4615 struct ath10k_vif_iter *arvif_iter = data;
4616 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
4618 if (arvif->vdev_id == arvif_iter->vdev_id)
4619 arvif_iter->arvif = arvif;
4622 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
4624 struct ath10k_vif_iter arvif_iter;
4627 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
4628 arvif_iter.vdev_id = vdev_id;
4630 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
4631 ieee80211_iterate_active_interfaces_atomic(ar->hw,
4633 ath10k_get_arvif_iter,
4635 if (!arvif_iter.arvif) {
4636 ath10k_warn("No VIF found for vdev %d\n", vdev_id);
4640 return arvif_iter.arvif;
4643 int ath10k_mac_register(struct ath10k *ar)
4645 struct ieee80211_supported_band *band;
4646 struct ieee80211_sta_vht_cap vht_cap;
4647 struct ieee80211_sta_ht_cap ht_cap;
4651 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
4653 SET_IEEE80211_DEV(ar->hw, ar->dev);
4655 ht_cap = ath10k_get_ht_cap(ar);
4656 vht_cap = ath10k_create_vht_cap(ar);
4658 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4659 channels = kmemdup(ath10k_2ghz_channels,
4660 sizeof(ath10k_2ghz_channels),
4667 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
4668 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
4669 band->channels = channels;
4670 band->n_bitrates = ath10k_g_rates_size;
4671 band->bitrates = ath10k_g_rates;
4672 band->ht_cap = ht_cap;
4674 /* vht is not supported in 2.4 GHz */
4676 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
4679 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4680 channels = kmemdup(ath10k_5ghz_channels,
4681 sizeof(ath10k_5ghz_channels),
4688 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
4689 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
4690 band->channels = channels;
4691 band->n_bitrates = ath10k_a_rates_size;
4692 band->bitrates = ath10k_a_rates;
4693 band->ht_cap = ht_cap;
4694 band->vht_cap = vht_cap;
4695 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
4698 ar->hw->wiphy->interface_modes =
4699 BIT(NL80211_IFTYPE_STATION) |
4700 BIT(NL80211_IFTYPE_ADHOC) |
4701 BIT(NL80211_IFTYPE_AP);
4703 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4704 /* TODO: Have to deal with 2x2 chips if/when the come out. */
4705 ar->supp_tx_chainmask = TARGET_10X_TX_CHAIN_MASK;
4706 ar->supp_rx_chainmask = TARGET_10X_RX_CHAIN_MASK;
4708 ar->supp_tx_chainmask = TARGET_TX_CHAIN_MASK;
4709 ar->supp_rx_chainmask = TARGET_RX_CHAIN_MASK;
4712 ar->hw->wiphy->available_antennas_rx = ar->supp_rx_chainmask;
4713 ar->hw->wiphy->available_antennas_tx = ar->supp_tx_chainmask;
4715 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->fw_features))
4716 ar->hw->wiphy->interface_modes |=
4717 BIT(NL80211_IFTYPE_P2P_CLIENT) |
4718 BIT(NL80211_IFTYPE_P2P_GO);
4720 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
4721 IEEE80211_HW_SUPPORTS_PS |
4722 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
4723 IEEE80211_HW_SUPPORTS_UAPSD |
4724 IEEE80211_HW_MFP_CAPABLE |
4725 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
4726 IEEE80211_HW_HAS_RATE_CONTROL |
4727 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
4728 IEEE80211_HW_AP_LINK_PS |
4729 IEEE80211_HW_SPECTRUM_MGMT;
4731 /* MSDU can have HTT TX fragment pushed in front. The additional 4
4732 * bytes is used for padding/alignment if necessary. */
4733 ar->hw->extra_tx_headroom += sizeof(struct htt_data_tx_desc_frag)*2 + 4;
4735 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
4736 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
4738 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
4739 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
4740 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
4743 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
4744 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
4746 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
4747 ar->hw->sta_data_size = sizeof(struct ath10k_sta);
4749 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
4751 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
4752 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
4753 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
4755 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
4757 * on LL hardware queues are managed entirely by the FW
4758 * so we only advertise to mac we can do the queues thing
4762 if (test_bit(ATH10K_FW_FEATURE_WMI_10X, ar->fw_features)) {
4763 ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
4764 ar->hw->wiphy->n_iface_combinations =
4765 ARRAY_SIZE(ath10k_10x_if_comb);
4767 ar->hw->wiphy->iface_combinations = ath10k_if_comb;
4768 ar->hw->wiphy->n_iface_combinations =
4769 ARRAY_SIZE(ath10k_if_comb);
4772 ar->hw->netdev_features = NETIF_F_HW_CSUM;
4774 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED)) {
4775 /* Init ath dfs pattern detector */
4776 ar->ath_common.debug_mask = ATH_DBG_DFS;
4777 ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
4780 if (!ar->dfs_detector)
4781 ath10k_warn("failed to initialise DFS pattern detector\n");
4784 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
4785 ath10k_reg_notifier);
4787 ath10k_err("failed to initialise regulatory: %i\n", ret);
4791 ret = ieee80211_register_hw(ar->hw);
4793 ath10k_err("failed to register ieee80211: %d\n", ret);
4797 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
4798 ret = regulatory_hint(ar->hw->wiphy,
4799 ar->ath_common.regulatory.alpha2);
4801 goto err_unregister;
4807 ieee80211_unregister_hw(ar->hw);
4809 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4810 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4815 void ath10k_mac_unregister(struct ath10k *ar)
4817 ieee80211_unregister_hw(ar->hw);
4819 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
4820 ar->dfs_detector->exit(ar->dfs_detector);
4822 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
4823 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
4825 SET_IEEE80211_DEV(ar->hw, NULL);