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 key->flags |= IEEE80211_KEY_FLAG_SW_MGMT_TX;
59 case WLAN_CIPHER_SUITE_TKIP:
60 arg.key_cipher = WMI_CIPHER_TKIP;
61 arg.key_txmic_len = 8;
62 arg.key_rxmic_len = 8;
64 case WLAN_CIPHER_SUITE_WEP40:
65 case WLAN_CIPHER_SUITE_WEP104:
66 arg.key_cipher = WMI_CIPHER_WEP;
67 /* AP/IBSS mode requires self-key to be groupwise
68 * Otherwise pairwise key must be set */
69 if (memcmp(macaddr, arvif->vif->addr, ETH_ALEN))
70 arg.key_flags = WMI_KEY_PAIRWISE;
73 ath10k_warn("cipher %d is not supported\n", key->cipher);
77 if (cmd == DISABLE_KEY) {
78 arg.key_cipher = WMI_CIPHER_NONE;
82 return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
85 static int ath10k_install_key(struct ath10k_vif *arvif,
86 struct ieee80211_key_conf *key,
90 struct ath10k *ar = arvif->ar;
93 lockdep_assert_held(&ar->conf_mutex);
95 INIT_COMPLETION(ar->install_key_done);
97 ret = ath10k_send_key(arvif, key, cmd, macaddr);
101 ret = wait_for_completion_timeout(&ar->install_key_done, 3*HZ);
108 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
111 struct ath10k *ar = arvif->ar;
112 struct ath10k_peer *peer;
116 lockdep_assert_held(&ar->conf_mutex);
118 spin_lock_bh(&ar->data_lock);
119 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
120 spin_unlock_bh(&ar->data_lock);
125 for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
126 if (arvif->wep_keys[i] == NULL)
129 ret = ath10k_install_key(arvif, arvif->wep_keys[i], SET_KEY,
134 peer->keys[i] = arvif->wep_keys[i];
140 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
143 struct ath10k *ar = arvif->ar;
144 struct ath10k_peer *peer;
149 lockdep_assert_held(&ar->conf_mutex);
151 spin_lock_bh(&ar->data_lock);
152 peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
153 spin_unlock_bh(&ar->data_lock);
158 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
159 if (peer->keys[i] == NULL)
162 ret = ath10k_install_key(arvif, peer->keys[i],
164 if (ret && first_errno == 0)
168 ath10k_warn("could not remove peer wep key %d (%d)\n",
171 peer->keys[i] = NULL;
177 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
178 struct ieee80211_key_conf *key)
180 struct ath10k *ar = arvif->ar;
181 struct ath10k_peer *peer;
187 lockdep_assert_held(&ar->conf_mutex);
190 /* since ath10k_install_key we can't hold data_lock all the
191 * time, so we try to remove the keys incrementally */
192 spin_lock_bh(&ar->data_lock);
194 list_for_each_entry(peer, &ar->peers, list) {
195 for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
196 if (peer->keys[i] == key) {
197 memcpy(addr, peer->addr, ETH_ALEN);
198 peer->keys[i] = NULL;
203 if (i < ARRAY_SIZE(peer->keys))
206 spin_unlock_bh(&ar->data_lock);
208 if (i == ARRAY_SIZE(peer->keys))
211 ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr);
212 if (ret && first_errno == 0)
216 ath10k_warn("could not remove key for %pM\n", addr);
223 /*********************/
224 /* General utilities */
225 /*********************/
227 static inline enum wmi_phy_mode
228 chan_to_phymode(const struct cfg80211_chan_def *chandef)
230 enum wmi_phy_mode phymode = MODE_UNKNOWN;
232 switch (chandef->chan->band) {
233 case IEEE80211_BAND_2GHZ:
234 switch (chandef->width) {
235 case NL80211_CHAN_WIDTH_20_NOHT:
238 case NL80211_CHAN_WIDTH_20:
239 phymode = MODE_11NG_HT20;
241 case NL80211_CHAN_WIDTH_40:
242 phymode = MODE_11NG_HT40;
244 case NL80211_CHAN_WIDTH_5:
245 case NL80211_CHAN_WIDTH_10:
246 case NL80211_CHAN_WIDTH_80:
247 case NL80211_CHAN_WIDTH_80P80:
248 case NL80211_CHAN_WIDTH_160:
249 phymode = MODE_UNKNOWN;
253 case IEEE80211_BAND_5GHZ:
254 switch (chandef->width) {
255 case NL80211_CHAN_WIDTH_20_NOHT:
258 case NL80211_CHAN_WIDTH_20:
259 phymode = MODE_11NA_HT20;
261 case NL80211_CHAN_WIDTH_40:
262 phymode = MODE_11NA_HT40;
264 case NL80211_CHAN_WIDTH_80:
265 phymode = MODE_11AC_VHT80;
267 case NL80211_CHAN_WIDTH_5:
268 case NL80211_CHAN_WIDTH_10:
269 case NL80211_CHAN_WIDTH_80P80:
270 case NL80211_CHAN_WIDTH_160:
271 phymode = MODE_UNKNOWN;
279 WARN_ON(phymode == MODE_UNKNOWN);
283 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
286 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
287 * 0 for no restriction
296 switch (mpdudensity) {
302 /* Our lower layer calculations limit our precision to
318 static int ath10k_peer_create(struct ath10k *ar, u32 vdev_id, const u8 *addr)
322 lockdep_assert_held(&ar->conf_mutex);
324 ret = ath10k_wmi_peer_create(ar, vdev_id, addr);
328 ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
335 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
337 if (value != 0xFFFFFFFF)
338 value = min_t(u32, arvif->ar->hw->wiphy->rts_threshold,
341 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
342 WMI_VDEV_PARAM_RTS_THRESHOLD,
346 static int ath10k_mac_set_frag(struct ath10k_vif *arvif, u32 value)
348 if (value != 0xFFFFFFFF)
349 value = clamp_t(u32, arvif->ar->hw->wiphy->frag_threshold,
350 ATH10K_FRAGMT_THRESHOLD_MIN,
351 ATH10K_FRAGMT_THRESHOLD_MAX);
353 return ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
354 WMI_VDEV_PARAM_FRAGMENTATION_THRESHOLD,
358 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
362 lockdep_assert_held(&ar->conf_mutex);
364 ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
368 ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
375 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
377 struct ath10k_peer *peer, *tmp;
379 lockdep_assert_held(&ar->conf_mutex);
381 spin_lock_bh(&ar->data_lock);
382 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
383 if (peer->vdev_id != vdev_id)
386 ath10k_warn("removing stale peer %pM from vdev_id %d\n",
387 peer->addr, vdev_id);
389 list_del(&peer->list);
392 spin_unlock_bh(&ar->data_lock);
395 static void ath10k_peer_cleanup_all(struct ath10k *ar)
397 struct ath10k_peer *peer, *tmp;
399 lockdep_assert_held(&ar->conf_mutex);
401 spin_lock_bh(&ar->data_lock);
402 list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
403 list_del(&peer->list);
406 spin_unlock_bh(&ar->data_lock);
409 /************************/
410 /* Interface management */
411 /************************/
413 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
417 lockdep_assert_held(&ar->conf_mutex);
419 ret = wait_for_completion_timeout(&ar->vdev_setup_done,
420 ATH10K_VDEV_SETUP_TIMEOUT_HZ);
427 static int ath10k_vdev_start(struct ath10k_vif *arvif)
429 struct ath10k *ar = arvif->ar;
430 struct ieee80211_conf *conf = &ar->hw->conf;
431 struct ieee80211_channel *channel = conf->chandef.chan;
432 struct wmi_vdev_start_request_arg arg = {};
435 lockdep_assert_held(&ar->conf_mutex);
437 INIT_COMPLETION(ar->vdev_setup_done);
439 arg.vdev_id = arvif->vdev_id;
440 arg.dtim_period = arvif->dtim_period;
441 arg.bcn_intval = arvif->beacon_interval;
443 arg.channel.freq = channel->center_freq;
445 arg.channel.band_center_freq1 = conf->chandef.center_freq1;
447 arg.channel.mode = chan_to_phymode(&conf->chandef);
449 arg.channel.min_power = channel->max_power * 3;
450 arg.channel.max_power = channel->max_power * 4;
451 arg.channel.max_reg_power = channel->max_reg_power * 4;
452 arg.channel.max_antenna_gain = channel->max_antenna_gain;
454 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
455 arg.ssid = arvif->u.ap.ssid;
456 arg.ssid_len = arvif->u.ap.ssid_len;
457 arg.hidden_ssid = arvif->u.ap.hidden_ssid;
458 } else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
459 arg.ssid = arvif->vif->bss_conf.ssid;
460 arg.ssid_len = arvif->vif->bss_conf.ssid_len;
463 ath10k_dbg(ATH10K_DBG_MAC,
464 "mac vdev %d start center_freq %d phymode %s\n",
465 arg.vdev_id, arg.channel.freq,
466 ath10k_wmi_phymode_str(arg.channel.mode));
468 ret = ath10k_wmi_vdev_start(ar, &arg);
470 ath10k_warn("WMI vdev start failed: ret %d\n", ret);
474 ret = ath10k_vdev_setup_sync(ar);
476 ath10k_warn("vdev setup failed %d\n", ret);
483 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
485 struct ath10k *ar = arvif->ar;
488 lockdep_assert_held(&ar->conf_mutex);
490 INIT_COMPLETION(ar->vdev_setup_done);
492 ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
494 ath10k_warn("WMI vdev stop failed: ret %d\n", ret);
498 ret = ath10k_vdev_setup_sync(ar);
500 ath10k_warn("vdev setup failed %d\n", ret);
507 static int ath10k_monitor_start(struct ath10k *ar, int vdev_id)
509 struct ieee80211_channel *channel = ar->hw->conf.chandef.chan;
510 struct wmi_vdev_start_request_arg arg = {};
513 lockdep_assert_held(&ar->conf_mutex);
515 arg.vdev_id = vdev_id;
516 arg.channel.freq = channel->center_freq;
517 arg.channel.band_center_freq1 = ar->hw->conf.chandef.center_freq1;
519 /* TODO setup this dynamically, what in case we
520 don't have any vifs? */
521 arg.channel.mode = chan_to_phymode(&ar->hw->conf.chandef);
523 arg.channel.min_power = channel->max_power * 3;
524 arg.channel.max_power = channel->max_power * 4;
525 arg.channel.max_reg_power = channel->max_reg_power * 4;
526 arg.channel.max_antenna_gain = channel->max_antenna_gain;
528 ret = ath10k_wmi_vdev_start(ar, &arg);
530 ath10k_warn("Monitor vdev start failed: ret %d\n", ret);
534 ret = ath10k_vdev_setup_sync(ar);
536 ath10k_warn("Monitor vdev setup failed %d\n", ret);
540 ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
542 ath10k_warn("Monitor vdev up failed: %d\n", ret);
546 ar->monitor_vdev_id = vdev_id;
547 ar->monitor_enabled = true;
552 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
554 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
559 static int ath10k_monitor_stop(struct ath10k *ar)
563 lockdep_assert_held(&ar->conf_mutex);
565 /* For some reasons, ath10k_wmi_vdev_down() here couse
566 * often ath10k_wmi_vdev_stop() to fail. Next we could
567 * not run monitor vdev and driver reload
568 * required. Don't see such problems we skip
569 * ath10k_wmi_vdev_down() here.
572 ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
574 ath10k_warn("Monitor vdev stop failed: %d\n", ret);
576 ret = ath10k_vdev_setup_sync(ar);
578 ath10k_warn("Monitor_down sync failed: %d\n", ret);
580 ar->monitor_enabled = false;
584 static int ath10k_monitor_create(struct ath10k *ar)
588 lockdep_assert_held(&ar->conf_mutex);
590 if (ar->monitor_present) {
591 ath10k_warn("Monitor mode already enabled\n");
595 bit = ffs(ar->free_vdev_map);
597 ath10k_warn("No free VDEV slots\n");
601 ar->monitor_vdev_id = bit - 1;
602 ar->free_vdev_map &= ~(1 << ar->monitor_vdev_id);
604 ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
605 WMI_VDEV_TYPE_MONITOR,
608 ath10k_warn("WMI vdev monitor create failed: ret %d\n", ret);
612 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
613 ar->monitor_vdev_id);
615 ar->monitor_present = true;
620 * Restore the ID to the global map.
622 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
626 static int ath10k_monitor_destroy(struct ath10k *ar)
630 lockdep_assert_held(&ar->conf_mutex);
632 if (!ar->monitor_present)
635 ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
637 ath10k_warn("WMI vdev monitor delete failed: %d\n", ret);
641 ar->free_vdev_map |= 1 << (ar->monitor_vdev_id);
642 ar->monitor_present = false;
644 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
645 ar->monitor_vdev_id);
649 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
650 struct ieee80211_bss_conf *info)
654 lockdep_assert_held(&arvif->ar->conf_mutex);
656 if (!info->enable_beacon) {
657 ath10k_vdev_stop(arvif);
661 arvif->tx_seq_no = 0x1000;
663 ret = ath10k_vdev_start(arvif);
667 ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, 0, info->bssid);
669 ath10k_warn("Failed to bring up VDEV: %d\n",
673 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
676 static void ath10k_control_ibss(struct ath10k_vif *arvif,
677 struct ieee80211_bss_conf *info,
678 const u8 self_peer[ETH_ALEN])
682 lockdep_assert_held(&arvif->ar->conf_mutex);
684 if (!info->ibss_joined) {
685 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, self_peer);
687 ath10k_warn("Failed to delete IBSS self peer:%pM for VDEV:%d ret:%d\n",
688 self_peer, arvif->vdev_id, ret);
690 if (is_zero_ether_addr(arvif->u.ibss.bssid))
693 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id,
694 arvif->u.ibss.bssid);
696 ath10k_warn("Failed to delete IBSS BSSID peer:%pM for VDEV:%d ret:%d\n",
697 arvif->u.ibss.bssid, arvif->vdev_id, ret);
701 memset(arvif->u.ibss.bssid, 0, ETH_ALEN);
706 ret = ath10k_peer_create(arvif->ar, arvif->vdev_id, self_peer);
708 ath10k_warn("Failed to create IBSS self peer:%pM for VDEV:%d ret:%d\n",
709 self_peer, arvif->vdev_id, ret);
713 ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id,
714 WMI_VDEV_PARAM_ATIM_WINDOW,
715 ATH10K_DEFAULT_ATIM);
717 ath10k_warn("Failed to set IBSS ATIM for VDEV:%d ret:%d\n",
718 arvif->vdev_id, ret);
722 * Review this when mac80211 gains per-interface powersave support.
724 static void ath10k_ps_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
726 struct ath10k_generic_iter *ar_iter = data;
727 struct ieee80211_conf *conf = &ar_iter->ar->hw->conf;
728 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
729 enum wmi_sta_powersave_param param;
730 enum wmi_sta_ps_mode psmode;
733 lockdep_assert_held(&arvif->ar->conf_mutex);
735 if (vif->type != NL80211_IFTYPE_STATION)
738 if (conf->flags & IEEE80211_CONF_PS) {
739 psmode = WMI_STA_PS_MODE_ENABLED;
740 param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
742 ret = ath10k_wmi_set_sta_ps_param(ar_iter->ar,
745 conf->dynamic_ps_timeout);
747 ath10k_warn("Failed to set inactivity time for VDEV: %d\n",
754 psmode = WMI_STA_PS_MODE_DISABLED;
757 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
758 arvif->vdev_id, psmode ? "enable" : "disable");
760 ar_iter->ret = ath10k_wmi_set_psmode(ar_iter->ar, arvif->vdev_id,
763 ath10k_warn("Failed to set PS Mode: %d for VDEV: %d\n",
764 psmode, arvif->vdev_id);
767 /**********************/
768 /* Station management */
769 /**********************/
771 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
772 struct ath10k_vif *arvif,
773 struct ieee80211_sta *sta,
774 struct ieee80211_bss_conf *bss_conf,
775 struct wmi_peer_assoc_complete_arg *arg)
777 lockdep_assert_held(&ar->conf_mutex);
779 memcpy(arg->addr, sta->addr, ETH_ALEN);
780 arg->vdev_id = arvif->vdev_id;
781 arg->peer_aid = sta->aid;
782 arg->peer_flags |= WMI_PEER_AUTH;
784 if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
786 * Seems FW have problems with Power Save in STA
787 * mode when we setup this parameter to high (eg. 5).
788 * Often we see that FW don't send NULL (with clean P flags)
789 * frame even there is info about buffered frames in beacons.
790 * Sometimes we have to wait more than 10 seconds before FW
791 * will wakeup. Often sending one ping from AP to our device
792 * just fail (more than 50%).
794 * Seems setting this FW parameter to 1 couse FW
795 * will check every beacon and will wakup immediately
796 * after detection buffered data.
798 arg->peer_listen_intval = 1;
800 arg->peer_listen_intval = ar->hw->conf.listen_interval;
802 arg->peer_num_spatial_streams = 1;
805 * The assoc capabilities are available only in managed mode.
807 if (arvif->vdev_type == WMI_VDEV_TYPE_STA && bss_conf)
808 arg->peer_caps = bss_conf->assoc_capability;
811 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
812 struct ath10k_vif *arvif,
813 struct wmi_peer_assoc_complete_arg *arg)
815 struct ieee80211_vif *vif = arvif->vif;
816 struct ieee80211_bss_conf *info = &vif->bss_conf;
817 struct cfg80211_bss *bss;
818 const u8 *rsnie = NULL;
819 const u8 *wpaie = NULL;
821 lockdep_assert_held(&ar->conf_mutex);
823 bss = cfg80211_get_bss(ar->hw->wiphy, ar->hw->conf.chandef.chan,
824 info->bssid, NULL, 0, 0, 0);
826 const struct cfg80211_bss_ies *ies;
829 rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
831 ies = rcu_dereference(bss->ies);
833 wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
834 WLAN_OUI_TYPE_MICROSOFT_WPA,
838 cfg80211_put_bss(ar->hw->wiphy, bss);
841 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
842 if (rsnie || wpaie) {
843 ath10k_dbg(ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
844 arg->peer_flags |= WMI_PEER_NEED_PTK_4_WAY;
848 ath10k_dbg(ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
849 arg->peer_flags |= WMI_PEER_NEED_GTK_2_WAY;
853 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
854 struct ieee80211_sta *sta,
855 struct wmi_peer_assoc_complete_arg *arg)
857 struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
858 const struct ieee80211_supported_band *sband;
859 const struct ieee80211_rate *rates;
863 lockdep_assert_held(&ar->conf_mutex);
865 sband = ar->hw->wiphy->bands[ar->hw->conf.chandef.chan->band];
866 ratemask = sta->supp_rates[ar->hw->conf.chandef.chan->band];
867 rates = sband->bitrates;
869 rateset->num_rates = 0;
871 for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
875 rateset->rates[rateset->num_rates] = rates->hw_value;
876 rateset->num_rates++;
880 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
881 struct ieee80211_sta *sta,
882 struct wmi_peer_assoc_complete_arg *arg)
884 const struct ieee80211_sta_ht_cap *ht_cap = &sta->ht_cap;
888 lockdep_assert_held(&ar->conf_mutex);
890 if (!ht_cap->ht_supported)
893 arg->peer_flags |= WMI_PEER_HT;
894 arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
895 ht_cap->ampdu_factor)) - 1;
897 arg->peer_mpdu_density =
898 ath10k_parse_mpdudensity(ht_cap->ampdu_density);
900 arg->peer_ht_caps = ht_cap->cap;
901 arg->peer_rate_caps |= WMI_RC_HT_FLAG;
903 if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
904 arg->peer_flags |= WMI_PEER_LDPC;
906 if (sta->bandwidth >= IEEE80211_STA_RX_BW_40) {
907 arg->peer_flags |= WMI_PEER_40MHZ;
908 arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
911 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
912 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
914 if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
915 arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
917 if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
918 arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
919 arg->peer_flags |= WMI_PEER_STBC;
922 if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
924 stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
925 stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
926 stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
927 arg->peer_rate_caps |= stbc;
928 arg->peer_flags |= WMI_PEER_STBC;
931 smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
932 smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
934 if (smps == WLAN_HT_CAP_SM_PS_STATIC) {
935 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
936 arg->peer_flags |= WMI_PEER_STATIC_MIMOPS;
937 } else if (smps == WLAN_HT_CAP_SM_PS_DYNAMIC) {
938 arg->peer_flags |= WMI_PEER_SPATIAL_MUX;
939 arg->peer_flags |= WMI_PEER_DYN_MIMOPS;
942 if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
943 arg->peer_rate_caps |= WMI_RC_TS_FLAG;
944 else if (ht_cap->mcs.rx_mask[1])
945 arg->peer_rate_caps |= WMI_RC_DS_FLAG;
947 for (i = 0, n = 0; i < IEEE80211_HT_MCS_MASK_LEN*8; i++)
948 if (ht_cap->mcs.rx_mask[i/8] & (1 << i%8))
949 arg->peer_ht_rates.rates[n++] = i;
951 arg->peer_ht_rates.num_rates = n;
952 arg->peer_num_spatial_streams = max((n+7) / 8, 1);
954 ath10k_dbg(ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
956 arg->peer_ht_rates.num_rates,
957 arg->peer_num_spatial_streams);
960 static void ath10k_peer_assoc_h_qos_ap(struct ath10k *ar,
961 struct ath10k_vif *arvif,
962 struct ieee80211_sta *sta,
963 struct ieee80211_bss_conf *bss_conf,
964 struct wmi_peer_assoc_complete_arg *arg)
969 lockdep_assert_held(&ar->conf_mutex);
972 arg->peer_flags |= WMI_PEER_QOS;
974 if (sta->wme && sta->uapsd_queues) {
975 ath10k_dbg(ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
976 sta->uapsd_queues, sta->max_sp);
978 arg->peer_flags |= WMI_PEER_APSD;
979 arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
981 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
982 uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
983 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
984 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
985 uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
986 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
987 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
988 uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
989 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
990 if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
991 uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
992 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
995 if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
996 max_sp = sta->max_sp;
998 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1000 WMI_AP_PS_PEER_PARAM_UAPSD,
1003 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1005 WMI_AP_PS_PEER_PARAM_MAX_SP,
1008 /* TODO setup this based on STA listen interval and
1009 beacon interval. Currently we don't know
1010 sta->listen_interval - mac80211 patch required.
1011 Currently use 10 seconds */
1012 ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
1014 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
1019 static void ath10k_peer_assoc_h_qos_sta(struct ath10k *ar,
1020 struct ath10k_vif *arvif,
1021 struct ieee80211_sta *sta,
1022 struct ieee80211_bss_conf *bss_conf,
1023 struct wmi_peer_assoc_complete_arg *arg)
1026 arg->peer_flags |= WMI_PEER_QOS;
1029 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
1030 struct ieee80211_sta *sta,
1031 struct wmi_peer_assoc_complete_arg *arg)
1033 const struct ieee80211_sta_vht_cap *vht_cap = &sta->vht_cap;
1035 if (!vht_cap->vht_supported)
1038 arg->peer_flags |= WMI_PEER_VHT;
1040 arg->peer_vht_caps = vht_cap->cap;
1042 if (sta->bandwidth == IEEE80211_STA_RX_BW_80)
1043 arg->peer_flags |= WMI_PEER_80MHZ;
1045 arg->peer_vht_rates.rx_max_rate =
1046 __le16_to_cpu(vht_cap->vht_mcs.rx_highest);
1047 arg->peer_vht_rates.rx_mcs_set =
1048 __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
1049 arg->peer_vht_rates.tx_max_rate =
1050 __le16_to_cpu(vht_cap->vht_mcs.tx_highest);
1051 arg->peer_vht_rates.tx_mcs_set =
1052 __le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map);
1054 ath10k_dbg(ATH10K_DBG_MAC, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
1055 sta->addr, arg->peer_max_mpdu, arg->peer_flags);
1058 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
1059 struct ath10k_vif *arvif,
1060 struct ieee80211_sta *sta,
1061 struct ieee80211_bss_conf *bss_conf,
1062 struct wmi_peer_assoc_complete_arg *arg)
1064 switch (arvif->vdev_type) {
1065 case WMI_VDEV_TYPE_AP:
1066 ath10k_peer_assoc_h_qos_ap(ar, arvif, sta, bss_conf, arg);
1068 case WMI_VDEV_TYPE_STA:
1069 ath10k_peer_assoc_h_qos_sta(ar, arvif, sta, bss_conf, arg);
1076 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
1077 struct ath10k_vif *arvif,
1078 struct ieee80211_sta *sta,
1079 struct wmi_peer_assoc_complete_arg *arg)
1081 enum wmi_phy_mode phymode = MODE_UNKNOWN;
1083 /* FIXME: add VHT */
1085 switch (ar->hw->conf.chandef.chan->band) {
1086 case IEEE80211_BAND_2GHZ:
1087 if (sta->ht_cap.ht_supported) {
1088 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1089 phymode = MODE_11NG_HT40;
1091 phymode = MODE_11NG_HT20;
1097 case IEEE80211_BAND_5GHZ:
1098 if (sta->ht_cap.ht_supported) {
1099 if (sta->bandwidth == IEEE80211_STA_RX_BW_40)
1100 phymode = MODE_11NA_HT40;
1102 phymode = MODE_11NA_HT20;
1112 ath10k_dbg(ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
1113 sta->addr, ath10k_wmi_phymode_str(phymode));
1115 arg->peer_phymode = phymode;
1116 WARN_ON(phymode == MODE_UNKNOWN);
1119 static int ath10k_peer_assoc(struct ath10k *ar,
1120 struct ath10k_vif *arvif,
1121 struct ieee80211_sta *sta,
1122 struct ieee80211_bss_conf *bss_conf)
1124 struct wmi_peer_assoc_complete_arg arg;
1126 lockdep_assert_held(&ar->conf_mutex);
1128 memset(&arg, 0, sizeof(struct wmi_peer_assoc_complete_arg));
1130 ath10k_peer_assoc_h_basic(ar, arvif, sta, bss_conf, &arg);
1131 ath10k_peer_assoc_h_crypto(ar, arvif, &arg);
1132 ath10k_peer_assoc_h_rates(ar, sta, &arg);
1133 ath10k_peer_assoc_h_ht(ar, sta, &arg);
1134 ath10k_peer_assoc_h_vht(ar, sta, &arg);
1135 ath10k_peer_assoc_h_qos(ar, arvif, sta, bss_conf, &arg);
1136 ath10k_peer_assoc_h_phymode(ar, arvif, sta, &arg);
1138 return ath10k_wmi_peer_assoc(ar, &arg);
1141 /* can be called only in mac80211 callbacks due to `key_count` usage */
1142 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
1143 struct ieee80211_vif *vif,
1144 struct ieee80211_bss_conf *bss_conf)
1146 struct ath10k *ar = hw->priv;
1147 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1148 struct ieee80211_sta *ap_sta;
1151 lockdep_assert_held(&ar->conf_mutex);
1155 ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
1157 ath10k_warn("Failed to find station entry for %pM\n",
1163 ret = ath10k_peer_assoc(ar, arvif, ap_sta, bss_conf);
1165 ath10k_warn("Peer assoc failed for %pM\n", bss_conf->bssid);
1172 ath10k_dbg(ATH10K_DBG_MAC,
1173 "mac vdev %d up (associated) bssid %pM aid %d\n",
1174 arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
1176 ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, bss_conf->aid,
1179 ath10k_warn("VDEV: %d up failed: ret %d\n",
1180 arvif->vdev_id, ret);
1186 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
1187 struct ieee80211_vif *vif)
1189 struct ath10k *ar = hw->priv;
1190 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1193 lockdep_assert_held(&ar->conf_mutex);
1196 * For some reason, calling VDEV-DOWN before VDEV-STOP
1197 * makes the FW to send frames via HTT after disassociation.
1198 * No idea why this happens, even though VDEV-DOWN is supposed
1199 * to be analogous to link down, so just stop the VDEV.
1201 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d stop (disassociated\n",
1204 /* FIXME: check return value */
1205 ret = ath10k_vdev_stop(arvif);
1208 * If we don't call VDEV-DOWN after VDEV-STOP FW will remain active and
1209 * report beacons from previously associated network through HTT.
1210 * This in turn would spam mac80211 WARN_ON if we bring down all
1211 * interfaces as it expects there is no rx when no interface is
1214 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d down\n", arvif->vdev_id);
1216 /* FIXME: why don't we print error if wmi call fails? */
1217 ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1219 ath10k_wmi_flush_tx(ar);
1221 arvif->def_wep_key_index = 0;
1224 static int ath10k_station_assoc(struct ath10k *ar, struct ath10k_vif *arvif,
1225 struct ieee80211_sta *sta)
1229 lockdep_assert_held(&ar->conf_mutex);
1231 ret = ath10k_peer_assoc(ar, arvif, sta, NULL);
1233 ath10k_warn("WMI peer assoc failed for %pM\n", sta->addr);
1237 ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
1239 ath10k_warn("could not install peer wep keys (%d)\n", ret);
1246 static int ath10k_station_disassoc(struct ath10k *ar, struct ath10k_vif *arvif,
1247 struct ieee80211_sta *sta)
1251 lockdep_assert_held(&ar->conf_mutex);
1253 ret = ath10k_clear_peer_keys(arvif, sta->addr);
1255 ath10k_warn("could not clear all peer wep keys (%d)\n", ret);
1266 static int ath10k_update_channel_list(struct ath10k *ar)
1268 struct ieee80211_hw *hw = ar->hw;
1269 struct ieee80211_supported_band **bands;
1270 enum ieee80211_band band;
1271 struct ieee80211_channel *channel;
1272 struct wmi_scan_chan_list_arg arg = {0};
1273 struct wmi_channel_arg *ch;
1279 lockdep_assert_held(&ar->conf_mutex);
1281 bands = hw->wiphy->bands;
1282 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1286 for (i = 0; i < bands[band]->n_channels; i++) {
1287 if (bands[band]->channels[i].flags &
1288 IEEE80211_CHAN_DISABLED)
1295 len = sizeof(struct wmi_channel_arg) * arg.n_channels;
1296 arg.channels = kzalloc(len, GFP_KERNEL);
1301 for (band = 0; band < IEEE80211_NUM_BANDS; band++) {
1305 for (i = 0; i < bands[band]->n_channels; i++) {
1306 channel = &bands[band]->channels[i];
1308 if (channel->flags & IEEE80211_CHAN_DISABLED)
1311 ch->allow_ht = true;
1313 /* FIXME: when should we really allow VHT? */
1314 ch->allow_vht = true;
1317 !(channel->flags & IEEE80211_CHAN_NO_IBSS);
1320 !(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
1322 passive = channel->flags & IEEE80211_CHAN_PASSIVE_SCAN;
1323 ch->passive = passive;
1325 ch->freq = channel->center_freq;
1326 ch->min_power = channel->max_power * 3;
1327 ch->max_power = channel->max_power * 4;
1328 ch->max_reg_power = channel->max_reg_power * 4;
1329 ch->max_antenna_gain = channel->max_antenna_gain;
1330 ch->reg_class_id = 0; /* FIXME */
1332 /* FIXME: why use only legacy modes, why not any
1333 * HT/VHT modes? Would that even make any
1335 if (channel->band == IEEE80211_BAND_2GHZ)
1336 ch->mode = MODE_11G;
1338 ch->mode = MODE_11A;
1340 if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
1343 ath10k_dbg(ATH10K_DBG_WMI,
1344 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
1345 ch - arg.channels, arg.n_channels,
1346 ch->freq, ch->max_power, ch->max_reg_power,
1347 ch->max_antenna_gain, ch->mode);
1353 ret = ath10k_wmi_scan_chan_list(ar, &arg);
1354 kfree(arg.channels);
1359 static void ath10k_regd_update(struct ath10k *ar)
1361 struct reg_dmn_pair_mapping *regpair;
1364 lockdep_assert_held(&ar->conf_mutex);
1366 ret = ath10k_update_channel_list(ar);
1368 ath10k_warn("could not update channel list (%d)\n", ret);
1370 regpair = ar->ath_common.regulatory.regpair;
1372 /* Target allows setting up per-band regdomain but ath_common provides
1373 * a combined one only */
1374 ret = ath10k_wmi_pdev_set_regdomain(ar,
1375 regpair->regDmnEnum,
1376 regpair->regDmnEnum, /* 2ghz */
1377 regpair->regDmnEnum, /* 5ghz */
1378 regpair->reg_2ghz_ctl,
1379 regpair->reg_5ghz_ctl);
1381 ath10k_warn("could not set pdev regdomain (%d)\n", ret);
1384 static void ath10k_reg_notifier(struct wiphy *wiphy,
1385 struct regulatory_request *request)
1387 struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
1388 struct ath10k *ar = hw->priv;
1390 ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
1392 mutex_lock(&ar->conf_mutex);
1393 if (ar->state == ATH10K_STATE_ON)
1394 ath10k_regd_update(ar);
1395 mutex_unlock(&ar->conf_mutex);
1403 * Frames sent to the FW have to be in "Native Wifi" format.
1404 * Strip the QoS field from the 802.11 header.
1406 static void ath10k_tx_h_qos_workaround(struct ieee80211_hw *hw,
1407 struct ieee80211_tx_control *control,
1408 struct sk_buff *skb)
1410 struct ieee80211_hdr *hdr = (void *)skb->data;
1413 if (!ieee80211_is_data_qos(hdr->frame_control))
1416 qos_ctl = ieee80211_get_qos_ctl(hdr);
1417 memmove(skb->data + IEEE80211_QOS_CTL_LEN,
1418 skb->data, (void *)qos_ctl - (void *)skb->data);
1419 skb_pull(skb, IEEE80211_QOS_CTL_LEN);
1422 static void ath10k_tx_h_update_wep_key(struct sk_buff *skb)
1424 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1425 struct ieee80211_vif *vif = info->control.vif;
1426 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1427 struct ath10k *ar = arvif->ar;
1428 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1429 struct ieee80211_key_conf *key = info->control.hw_key;
1432 if (!ieee80211_has_protected(hdr->frame_control))
1438 if (key->cipher != WLAN_CIPHER_SUITE_WEP40 &&
1439 key->cipher != WLAN_CIPHER_SUITE_WEP104)
1442 if (key->keyidx == arvif->def_wep_key_index)
1445 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d keyidx %d\n",
1446 arvif->vdev_id, key->keyidx);
1448 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
1449 WMI_VDEV_PARAM_DEF_KEYID,
1452 ath10k_warn("could not update wep keyidx (%d)\n", ret);
1456 arvif->def_wep_key_index = key->keyidx;
1459 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar, struct sk_buff *skb)
1461 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1462 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1463 struct ieee80211_vif *vif = info->control.vif;
1464 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1466 /* This is case only for P2P_GO */
1467 if (arvif->vdev_type != WMI_VDEV_TYPE_AP ||
1468 arvif->vdev_subtype != WMI_VDEV_SUBTYPE_P2P_GO)
1471 if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
1472 spin_lock_bh(&ar->data_lock);
1473 if (arvif->u.ap.noa_data)
1474 if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
1476 memcpy(skb_put(skb, arvif->u.ap.noa_len),
1477 arvif->u.ap.noa_data,
1478 arvif->u.ap.noa_len);
1479 spin_unlock_bh(&ar->data_lock);
1483 static void ath10k_tx_htt(struct ath10k *ar, struct sk_buff *skb)
1485 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1488 if (ar->htt.target_version_major >= 3) {
1489 /* Since HTT 3.0 there is no separate mgmt tx command */
1490 ret = ath10k_htt_tx(&ar->htt, skb);
1494 if (ieee80211_is_mgmt(hdr->frame_control))
1495 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1496 else if (ieee80211_is_nullfunc(hdr->frame_control))
1497 /* FW does not report tx status properly for NullFunc frames
1498 * unless they are sent through mgmt tx path. mac80211 sends
1499 * those frames when it detects link/beacon loss and depends on
1500 * the tx status to be correct. */
1501 ret = ath10k_htt_mgmt_tx(&ar->htt, skb);
1503 ret = ath10k_htt_tx(&ar->htt, skb);
1507 ath10k_warn("tx failed (%d). dropping packet.\n", ret);
1508 ieee80211_free_txskb(ar->hw, skb);
1512 void ath10k_offchan_tx_purge(struct ath10k *ar)
1514 struct sk_buff *skb;
1517 skb = skb_dequeue(&ar->offchan_tx_queue);
1521 ieee80211_free_txskb(ar->hw, skb);
1525 void ath10k_offchan_tx_work(struct work_struct *work)
1527 struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
1528 struct ath10k_peer *peer;
1529 struct ieee80211_hdr *hdr;
1530 struct sk_buff *skb;
1531 const u8 *peer_addr;
1535 /* FW requirement: We must create a peer before FW will send out
1536 * an offchannel frame. Otherwise the frame will be stuck and
1537 * never transmitted. We delete the peer upon tx completion.
1538 * It is unlikely that a peer for offchannel tx will already be
1539 * present. However it may be in some rare cases so account for that.
1540 * Otherwise we might remove a legitimate peer and break stuff. */
1543 skb = skb_dequeue(&ar->offchan_tx_queue);
1547 mutex_lock(&ar->conf_mutex);
1549 ath10k_dbg(ATH10K_DBG_MAC, "mac offchannel skb %p\n",
1552 hdr = (struct ieee80211_hdr *)skb->data;
1553 peer_addr = ieee80211_get_DA(hdr);
1554 vdev_id = ATH10K_SKB_CB(skb)->htt.vdev_id;
1556 spin_lock_bh(&ar->data_lock);
1557 peer = ath10k_peer_find(ar, vdev_id, peer_addr);
1558 spin_unlock_bh(&ar->data_lock);
1561 /* FIXME: should this use ath10k_warn()? */
1562 ath10k_dbg(ATH10K_DBG_MAC, "peer %pM on vdev %d already present\n",
1563 peer_addr, vdev_id);
1566 ret = ath10k_peer_create(ar, vdev_id, peer_addr);
1568 ath10k_warn("peer %pM on vdev %d not created (%d)\n",
1569 peer_addr, vdev_id, ret);
1572 spin_lock_bh(&ar->data_lock);
1573 INIT_COMPLETION(ar->offchan_tx_completed);
1574 ar->offchan_tx_skb = skb;
1575 spin_unlock_bh(&ar->data_lock);
1577 ath10k_tx_htt(ar, skb);
1579 ret = wait_for_completion_timeout(&ar->offchan_tx_completed,
1582 ath10k_warn("timed out waiting for offchannel skb %p\n",
1586 ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
1588 ath10k_warn("peer %pM on vdev %d not deleted (%d)\n",
1589 peer_addr, vdev_id, ret);
1592 mutex_unlock(&ar->conf_mutex);
1601 * This gets called if we dont get a heart-beat during scan.
1602 * This may indicate the FW has hung and we need to abort the
1603 * scan manually to prevent cancel_hw_scan() from deadlocking
1605 void ath10k_reset_scan(unsigned long ptr)
1607 struct ath10k *ar = (struct ath10k *)ptr;
1609 spin_lock_bh(&ar->data_lock);
1610 if (!ar->scan.in_progress) {
1611 spin_unlock_bh(&ar->data_lock);
1615 ath10k_warn("scan timeout. resetting. fw issue?\n");
1617 if (ar->scan.is_roc)
1618 ieee80211_remain_on_channel_expired(ar->hw);
1620 ieee80211_scan_completed(ar->hw, 1 /* aborted */);
1622 ar->scan.in_progress = false;
1623 complete_all(&ar->scan.completed);
1624 spin_unlock_bh(&ar->data_lock);
1627 static int ath10k_abort_scan(struct ath10k *ar)
1629 struct wmi_stop_scan_arg arg = {
1630 .req_id = 1, /* FIXME */
1631 .req_type = WMI_SCAN_STOP_ONE,
1632 .u.scan_id = ATH10K_SCAN_ID,
1636 lockdep_assert_held(&ar->conf_mutex);
1638 del_timer_sync(&ar->scan.timeout);
1640 spin_lock_bh(&ar->data_lock);
1641 if (!ar->scan.in_progress) {
1642 spin_unlock_bh(&ar->data_lock);
1646 ar->scan.aborting = true;
1647 spin_unlock_bh(&ar->data_lock);
1649 ret = ath10k_wmi_stop_scan(ar, &arg);
1651 ath10k_warn("could not submit wmi stop scan (%d)\n", ret);
1652 spin_lock_bh(&ar->data_lock);
1653 ar->scan.in_progress = false;
1654 ath10k_offchan_tx_purge(ar);
1655 spin_unlock_bh(&ar->data_lock);
1659 ath10k_wmi_flush_tx(ar);
1661 ret = wait_for_completion_timeout(&ar->scan.completed, 3*HZ);
1663 ath10k_warn("timed out while waiting for scan to stop\n");
1665 /* scan completion may be done right after we timeout here, so let's
1666 * check the in_progress and tell mac80211 scan is completed. if we
1667 * don't do that and FW fails to send us scan completion indication
1668 * then userspace won't be able to scan anymore */
1671 spin_lock_bh(&ar->data_lock);
1672 if (ar->scan.in_progress) {
1673 ath10k_warn("could not stop scan. its still in progress\n");
1674 ar->scan.in_progress = false;
1675 ath10k_offchan_tx_purge(ar);
1678 spin_unlock_bh(&ar->data_lock);
1683 static int ath10k_start_scan(struct ath10k *ar,
1684 const struct wmi_start_scan_arg *arg)
1688 lockdep_assert_held(&ar->conf_mutex);
1690 ret = ath10k_wmi_start_scan(ar, arg);
1694 /* make sure we submit the command so the completion
1695 * timeout makes sense */
1696 ath10k_wmi_flush_tx(ar);
1698 ret = wait_for_completion_timeout(&ar->scan.started, 1*HZ);
1700 ath10k_abort_scan(ar);
1704 /* the scan can complete earlier, before we even
1705 * start the timer. in that case the timer handler
1706 * checks ar->scan.in_progress and bails out if its
1707 * false. Add a 200ms margin to account event/command
1709 mod_timer(&ar->scan.timeout, jiffies +
1710 msecs_to_jiffies(arg->max_scan_time+200));
1714 /**********************/
1715 /* mac80211 callbacks */
1716 /**********************/
1718 static void ath10k_tx(struct ieee80211_hw *hw,
1719 struct ieee80211_tx_control *control,
1720 struct sk_buff *skb)
1722 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1723 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1724 struct ath10k *ar = hw->priv;
1725 struct ath10k_vif *arvif = NULL;
1729 if (info->control.vif) {
1730 arvif = ath10k_vif_to_arvif(info->control.vif);
1731 vdev_id = arvif->vdev_id;
1732 } else if (ar->monitor_enabled) {
1733 vdev_id = ar->monitor_vdev_id;
1736 /* We should disable CCK RATE due to P2P */
1737 if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
1738 ath10k_dbg(ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
1740 /* we must calculate tid before we apply qos workaround
1741 * as we'd lose the qos control field */
1742 tid = HTT_DATA_TX_EXT_TID_NON_QOS_MCAST_BCAST;
1743 if (ieee80211_is_mgmt(hdr->frame_control)) {
1744 tid = HTT_DATA_TX_EXT_TID_MGMT;
1745 } else if (ieee80211_is_data_qos(hdr->frame_control) &&
1746 is_unicast_ether_addr(ieee80211_get_DA(hdr))) {
1747 u8 *qc = ieee80211_get_qos_ctl(hdr);
1748 tid = qc[0] & IEEE80211_QOS_CTL_TID_MASK;
1751 /* it makes no sense to process injected frames like that */
1752 if (info->control.vif &&
1753 info->control.vif->type != NL80211_IFTYPE_MONITOR) {
1754 ath10k_tx_h_qos_workaround(hw, control, skb);
1755 ath10k_tx_h_update_wep_key(skb);
1756 ath10k_tx_h_add_p2p_noa_ie(ar, skb);
1757 ath10k_tx_h_seq_no(skb);
1760 memset(ATH10K_SKB_CB(skb), 0, sizeof(*ATH10K_SKB_CB(skb)));
1761 ATH10K_SKB_CB(skb)->htt.vdev_id = vdev_id;
1762 ATH10K_SKB_CB(skb)->htt.tid = tid;
1764 if (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
1765 spin_lock_bh(&ar->data_lock);
1766 ATH10K_SKB_CB(skb)->htt.is_offchan = true;
1767 ATH10K_SKB_CB(skb)->htt.vdev_id = ar->scan.vdev_id;
1768 spin_unlock_bh(&ar->data_lock);
1770 ath10k_dbg(ATH10K_DBG_MAC, "queued offchannel skb %p\n", skb);
1772 skb_queue_tail(&ar->offchan_tx_queue, skb);
1773 ieee80211_queue_work(hw, &ar->offchan_tx_work);
1777 ath10k_tx_htt(ar, skb);
1781 * Initialize various parameters with default vaules.
1783 void ath10k_halt(struct ath10k *ar)
1785 lockdep_assert_held(&ar->conf_mutex);
1787 del_timer_sync(&ar->scan.timeout);
1788 ath10k_offchan_tx_purge(ar);
1789 ath10k_peer_cleanup_all(ar);
1790 ath10k_core_stop(ar);
1791 ath10k_hif_power_down(ar);
1793 spin_lock_bh(&ar->data_lock);
1794 if (ar->scan.in_progress) {
1795 del_timer(&ar->scan.timeout);
1796 ar->scan.in_progress = false;
1797 ieee80211_scan_completed(ar->hw, true);
1799 spin_unlock_bh(&ar->data_lock);
1802 static int ath10k_start(struct ieee80211_hw *hw)
1804 struct ath10k *ar = hw->priv;
1807 mutex_lock(&ar->conf_mutex);
1809 if (ar->state != ATH10K_STATE_OFF &&
1810 ar->state != ATH10K_STATE_RESTARTING) {
1815 ret = ath10k_hif_power_up(ar);
1817 ath10k_err("could not init hif (%d)\n", ret);
1818 ar->state = ATH10K_STATE_OFF;
1822 ret = ath10k_core_start(ar);
1824 ath10k_err("could not init core (%d)\n", ret);
1825 ath10k_hif_power_down(ar);
1826 ar->state = ATH10K_STATE_OFF;
1830 if (ar->state == ATH10K_STATE_OFF)
1831 ar->state = ATH10K_STATE_ON;
1832 else if (ar->state == ATH10K_STATE_RESTARTING)
1833 ar->state = ATH10K_STATE_RESTARTED;
1835 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_PMF_QOS, 1);
1837 ath10k_warn("could not enable WMI_PDEV_PARAM_PMF_QOS (%d)\n",
1840 ret = ath10k_wmi_pdev_set_param(ar, WMI_PDEV_PARAM_DYNAMIC_BW, 0);
1842 ath10k_warn("could not init WMI_PDEV_PARAM_DYNAMIC_BW (%d)\n",
1845 ath10k_regd_update(ar);
1848 mutex_unlock(&ar->conf_mutex);
1852 static void ath10k_stop(struct ieee80211_hw *hw)
1854 struct ath10k *ar = hw->priv;
1856 mutex_lock(&ar->conf_mutex);
1857 if (ar->state == ATH10K_STATE_ON ||
1858 ar->state == ATH10K_STATE_RESTARTED ||
1859 ar->state == ATH10K_STATE_WEDGED)
1862 ar->state = ATH10K_STATE_OFF;
1863 mutex_unlock(&ar->conf_mutex);
1865 cancel_work_sync(&ar->offchan_tx_work);
1866 cancel_work_sync(&ar->restart_work);
1869 static void ath10k_config_ps(struct ath10k *ar)
1871 struct ath10k_generic_iter ar_iter;
1873 lockdep_assert_held(&ar->conf_mutex);
1875 /* During HW reconfiguration mac80211 reports all interfaces that were
1876 * running until reconfiguration was started. Since FW doesn't have any
1877 * vdevs at this point we must not iterate over this interface list.
1878 * This setting will be updated upon add_interface(). */
1879 if (ar->state == ATH10K_STATE_RESTARTED)
1882 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
1885 ieee80211_iterate_active_interfaces_atomic(
1886 ar->hw, IEEE80211_IFACE_ITER_NORMAL,
1887 ath10k_ps_iter, &ar_iter);
1890 ath10k_warn("failed to set ps config (%d)\n", ar_iter.ret);
1893 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
1895 struct ath10k *ar = hw->priv;
1896 struct ieee80211_conf *conf = &hw->conf;
1899 mutex_lock(&ar->conf_mutex);
1901 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
1902 ath10k_dbg(ATH10K_DBG_MAC, "mac config channel %d mhz\n",
1903 conf->chandef.chan->center_freq);
1904 spin_lock_bh(&ar->data_lock);
1905 ar->rx_channel = conf->chandef.chan;
1906 spin_unlock_bh(&ar->data_lock);
1909 if (changed & IEEE80211_CONF_CHANGE_PS)
1910 ath10k_config_ps(ar);
1912 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
1913 if (conf->flags & IEEE80211_CONF_MONITOR)
1914 ret = ath10k_monitor_create(ar);
1916 ret = ath10k_monitor_destroy(ar);
1919 ath10k_wmi_flush_tx(ar);
1920 mutex_unlock(&ar->conf_mutex);
1926 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
1927 * because we will send mgmt frames without CCK. This requirement
1928 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
1931 static int ath10k_add_interface(struct ieee80211_hw *hw,
1932 struct ieee80211_vif *vif)
1934 struct ath10k *ar = hw->priv;
1935 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
1936 enum wmi_sta_powersave_param param;
1941 mutex_lock(&ar->conf_mutex);
1943 memset(arvif, 0, sizeof(*arvif));
1948 if ((vif->type == NL80211_IFTYPE_MONITOR) && ar->monitor_present) {
1949 ath10k_warn("Only one monitor interface allowed\n");
1954 bit = ffs(ar->free_vdev_map);
1960 arvif->vdev_id = bit - 1;
1961 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_NONE;
1962 ar->free_vdev_map &= ~(1 << arvif->vdev_id);
1965 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_DEVICE;
1967 switch (vif->type) {
1968 case NL80211_IFTYPE_UNSPECIFIED:
1969 case NL80211_IFTYPE_STATION:
1970 arvif->vdev_type = WMI_VDEV_TYPE_STA;
1972 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_CLIENT;
1974 case NL80211_IFTYPE_ADHOC:
1975 arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
1977 case NL80211_IFTYPE_AP:
1978 arvif->vdev_type = WMI_VDEV_TYPE_AP;
1981 arvif->vdev_subtype = WMI_VDEV_SUBTYPE_P2P_GO;
1983 case NL80211_IFTYPE_MONITOR:
1984 arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
1991 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d\n",
1992 arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype);
1994 ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
1995 arvif->vdev_subtype, vif->addr);
1997 ath10k_warn("WMI vdev create failed: ret %d\n", ret);
2001 ret = ath10k_wmi_vdev_set_param(ar, 0, WMI_VDEV_PARAM_DEF_KEYID,
2002 arvif->def_wep_key_index);
2004 ath10k_warn("Failed to set default keyid: %d\n", ret);
2006 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2007 WMI_VDEV_PARAM_TX_ENCAP_TYPE,
2008 ATH10K_HW_TXRX_NATIVE_WIFI);
2010 ath10k_warn("Failed to set TX encap: %d\n", ret);
2012 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2013 ret = ath10k_peer_create(ar, arvif->vdev_id, vif->addr);
2015 ath10k_warn("Failed to create peer for AP: %d\n", ret);
2020 if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
2021 param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
2022 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2023 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2026 ath10k_warn("Failed to set RX wake policy: %d\n", ret);
2028 param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
2029 value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
2030 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2033 ath10k_warn("Failed to set TX wake thresh: %d\n", ret);
2035 param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
2036 value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
2037 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2040 ath10k_warn("Failed to set PSPOLL count: %d\n", ret);
2043 ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
2045 ath10k_warn("failed to set rts threshold for vdev %d (%d)\n",
2046 arvif->vdev_id, ret);
2048 ret = ath10k_mac_set_frag(arvif, ar->hw->wiphy->frag_threshold);
2050 ath10k_warn("failed to set frag threshold for vdev %d (%d)\n",
2051 arvif->vdev_id, ret);
2053 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2054 ar->monitor_present = true;
2057 mutex_unlock(&ar->conf_mutex);
2061 static void ath10k_remove_interface(struct ieee80211_hw *hw,
2062 struct ieee80211_vif *vif)
2064 struct ath10k *ar = hw->priv;
2065 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2068 mutex_lock(&ar->conf_mutex);
2070 ar->free_vdev_map |= 1 << (arvif->vdev_id);
2072 if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
2073 ret = ath10k_peer_delete(arvif->ar, arvif->vdev_id, vif->addr);
2075 ath10k_warn("Failed to remove peer for AP: %d\n", ret);
2077 kfree(arvif->u.ap.noa_data);
2080 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev delete %d (remove interface)\n",
2083 ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
2085 ath10k_warn("WMI vdev delete failed: %d\n", ret);
2087 if (arvif->vdev_type == WMI_VDEV_TYPE_MONITOR)
2088 ar->monitor_present = false;
2090 ath10k_peer_cleanup(ar, arvif->vdev_id);
2092 mutex_unlock(&ar->conf_mutex);
2096 * FIXME: Has to be verified.
2098 #define SUPPORTED_FILTERS \
2099 (FIF_PROMISC_IN_BSS | \
2104 FIF_BCN_PRBRESP_PROMISC | \
2108 static void ath10k_configure_filter(struct ieee80211_hw *hw,
2109 unsigned int changed_flags,
2110 unsigned int *total_flags,
2113 struct ath10k *ar = hw->priv;
2116 mutex_lock(&ar->conf_mutex);
2118 changed_flags &= SUPPORTED_FILTERS;
2119 *total_flags &= SUPPORTED_FILTERS;
2120 ar->filter_flags = *total_flags;
2122 if ((ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2123 !ar->monitor_enabled) {
2124 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d start\n",
2125 ar->monitor_vdev_id);
2127 ret = ath10k_monitor_start(ar, ar->monitor_vdev_id);
2129 ath10k_warn("Unable to start monitor mode\n");
2130 } else if (!(ar->filter_flags & FIF_PROMISC_IN_BSS) &&
2131 ar->monitor_enabled) {
2132 ath10k_dbg(ATH10K_DBG_MAC, "mac monitor %d stop\n",
2133 ar->monitor_vdev_id);
2135 ret = ath10k_monitor_stop(ar);
2137 ath10k_warn("Unable to stop monitor mode\n");
2140 mutex_unlock(&ar->conf_mutex);
2143 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
2144 struct ieee80211_vif *vif,
2145 struct ieee80211_bss_conf *info,
2148 struct ath10k *ar = hw->priv;
2149 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2152 mutex_lock(&ar->conf_mutex);
2154 if (changed & BSS_CHANGED_IBSS)
2155 ath10k_control_ibss(arvif, info, vif->addr);
2157 if (changed & BSS_CHANGED_BEACON_INT) {
2158 arvif->beacon_interval = info->beacon_int;
2159 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2160 WMI_VDEV_PARAM_BEACON_INTERVAL,
2161 arvif->beacon_interval);
2162 ath10k_dbg(ATH10K_DBG_MAC,
2163 "mac vdev %d beacon_interval %d\n",
2164 arvif->vdev_id, arvif->beacon_interval);
2167 ath10k_warn("Failed to set beacon interval for VDEV: %d\n",
2171 if (changed & BSS_CHANGED_BEACON) {
2172 ath10k_dbg(ATH10K_DBG_MAC,
2173 "vdev %d set beacon tx mode to staggered\n",
2176 ret = ath10k_wmi_pdev_set_param(ar,
2177 WMI_PDEV_PARAM_BEACON_TX_MODE,
2178 WMI_BEACON_STAGGERED_MODE);
2180 ath10k_warn("Failed to set beacon mode for VDEV: %d\n",
2184 if (changed & BSS_CHANGED_BEACON_INFO) {
2185 arvif->dtim_period = info->dtim_period;
2187 ath10k_dbg(ATH10K_DBG_MAC,
2188 "mac vdev %d dtim_period %d\n",
2189 arvif->vdev_id, arvif->dtim_period);
2191 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2192 WMI_VDEV_PARAM_DTIM_PERIOD,
2193 arvif->dtim_period);
2195 ath10k_warn("Failed to set dtim period for VDEV: %d\n",
2199 if (changed & BSS_CHANGED_SSID &&
2200 vif->type == NL80211_IFTYPE_AP) {
2201 arvif->u.ap.ssid_len = info->ssid_len;
2203 memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
2204 arvif->u.ap.hidden_ssid = info->hidden_ssid;
2207 if (changed & BSS_CHANGED_BSSID) {
2208 if (!is_zero_ether_addr(info->bssid)) {
2209 ath10k_dbg(ATH10K_DBG_MAC,
2210 "mac vdev %d create peer %pM\n",
2211 arvif->vdev_id, info->bssid);
2213 ret = ath10k_peer_create(ar, arvif->vdev_id,
2216 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2217 info->bssid, arvif->vdev_id);
2219 if (vif->type == NL80211_IFTYPE_STATION) {
2221 * this is never erased as we it for crypto key
2222 * clearing; this is FW requirement
2224 memcpy(arvif->u.sta.bssid, info->bssid,
2227 ath10k_dbg(ATH10K_DBG_MAC,
2228 "mac vdev %d start %pM\n",
2229 arvif->vdev_id, info->bssid);
2231 /* FIXME: check return value */
2232 ret = ath10k_vdev_start(arvif);
2236 * Mac80211 does not keep IBSS bssid when leaving IBSS,
2237 * so driver need to store it. It is needed when leaving
2238 * IBSS in order to remove BSSID peer.
2240 if (vif->type == NL80211_IFTYPE_ADHOC)
2241 memcpy(arvif->u.ibss.bssid, info->bssid,
2246 if (changed & BSS_CHANGED_BEACON_ENABLED)
2247 ath10k_control_beaconing(arvif, info);
2249 if (changed & BSS_CHANGED_ERP_CTS_PROT) {
2251 if (info->use_cts_prot)
2256 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d cts_prot %d\n",
2257 arvif->vdev_id, cts_prot);
2259 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2260 WMI_VDEV_PARAM_ENABLE_RTSCTS,
2263 ath10k_warn("Failed to set CTS prot for VDEV: %d\n",
2267 if (changed & BSS_CHANGED_ERP_SLOT) {
2269 if (info->use_short_slot)
2270 slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
2273 slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
2275 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
2276 arvif->vdev_id, slottime);
2278 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2279 WMI_VDEV_PARAM_SLOT_TIME,
2282 ath10k_warn("Failed to set erp slot for VDEV: %d\n",
2286 if (changed & BSS_CHANGED_ERP_PREAMBLE) {
2288 if (info->use_short_preamble)
2289 preamble = WMI_VDEV_PREAMBLE_SHORT;
2291 preamble = WMI_VDEV_PREAMBLE_LONG;
2293 ath10k_dbg(ATH10K_DBG_MAC,
2294 "mac vdev %d preamble %dn",
2295 arvif->vdev_id, preamble);
2297 ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
2298 WMI_VDEV_PARAM_PREAMBLE,
2301 ath10k_warn("Failed to set preamble for VDEV: %d\n",
2305 if (changed & BSS_CHANGED_ASSOC) {
2307 ath10k_bss_assoc(hw, vif, info);
2310 mutex_unlock(&ar->conf_mutex);
2313 static int ath10k_hw_scan(struct ieee80211_hw *hw,
2314 struct ieee80211_vif *vif,
2315 struct cfg80211_scan_request *req)
2317 struct ath10k *ar = hw->priv;
2318 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2319 struct wmi_start_scan_arg arg;
2323 mutex_lock(&ar->conf_mutex);
2325 spin_lock_bh(&ar->data_lock);
2326 if (ar->scan.in_progress) {
2327 spin_unlock_bh(&ar->data_lock);
2332 INIT_COMPLETION(ar->scan.started);
2333 INIT_COMPLETION(ar->scan.completed);
2334 ar->scan.in_progress = true;
2335 ar->scan.aborting = false;
2336 ar->scan.is_roc = false;
2337 ar->scan.vdev_id = arvif->vdev_id;
2338 spin_unlock_bh(&ar->data_lock);
2340 memset(&arg, 0, sizeof(arg));
2341 ath10k_wmi_start_scan_init(ar, &arg);
2342 arg.vdev_id = arvif->vdev_id;
2343 arg.scan_id = ATH10K_SCAN_ID;
2346 arg.scan_ctrl_flags |= WMI_SCAN_ADD_CCK_RATES;
2349 arg.ie_len = req->ie_len;
2350 memcpy(arg.ie, req->ie, arg.ie_len);
2354 arg.n_ssids = req->n_ssids;
2355 for (i = 0; i < arg.n_ssids; i++) {
2356 arg.ssids[i].len = req->ssids[i].ssid_len;
2357 arg.ssids[i].ssid = req->ssids[i].ssid;
2360 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2363 if (req->n_channels) {
2364 arg.n_channels = req->n_channels;
2365 for (i = 0; i < arg.n_channels; i++)
2366 arg.channels[i] = req->channels[i]->center_freq;
2369 ret = ath10k_start_scan(ar, &arg);
2371 ath10k_warn("could not start hw scan (%d)\n", ret);
2372 spin_lock_bh(&ar->data_lock);
2373 ar->scan.in_progress = false;
2374 spin_unlock_bh(&ar->data_lock);
2378 mutex_unlock(&ar->conf_mutex);
2382 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
2383 struct ieee80211_vif *vif)
2385 struct ath10k *ar = hw->priv;
2388 mutex_lock(&ar->conf_mutex);
2389 ret = ath10k_abort_scan(ar);
2391 ath10k_warn("couldn't abort scan (%d). forcefully sending scan completion to mac80211\n",
2393 ieee80211_scan_completed(hw, 1 /* aborted */);
2395 mutex_unlock(&ar->conf_mutex);
2398 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
2399 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
2400 struct ieee80211_key_conf *key)
2402 struct ath10k *ar = hw->priv;
2403 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2404 struct ath10k_peer *peer;
2405 const u8 *peer_addr;
2406 bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
2407 key->cipher == WLAN_CIPHER_SUITE_WEP104;
2410 if (key->keyidx > WMI_MAX_KEY_INDEX)
2413 mutex_lock(&ar->conf_mutex);
2416 peer_addr = sta->addr;
2417 else if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
2418 peer_addr = vif->bss_conf.bssid;
2420 peer_addr = vif->addr;
2422 key->hw_key_idx = key->keyidx;
2424 /* the peer should not disappear in mid-way (unless FW goes awry) since
2425 * we already hold conf_mutex. we just make sure its there now. */
2426 spin_lock_bh(&ar->data_lock);
2427 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2428 spin_unlock_bh(&ar->data_lock);
2431 if (cmd == SET_KEY) {
2432 ath10k_warn("cannot install key for non-existent peer %pM\n",
2437 /* if the peer doesn't exist there is no key to disable
2445 arvif->wep_keys[key->keyidx] = key;
2447 arvif->wep_keys[key->keyidx] = NULL;
2449 if (cmd == DISABLE_KEY)
2450 ath10k_clear_vdev_key(arvif, key);
2453 ret = ath10k_install_key(arvif, key, cmd, peer_addr);
2455 ath10k_warn("ath10k_install_key failed (%d)\n", ret);
2459 spin_lock_bh(&ar->data_lock);
2460 peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
2461 if (peer && cmd == SET_KEY)
2462 peer->keys[key->keyidx] = key;
2463 else if (peer && cmd == DISABLE_KEY)
2464 peer->keys[key->keyidx] = NULL;
2465 else if (peer == NULL)
2466 /* impossible unless FW goes crazy */
2467 ath10k_warn("peer %pM disappeared!\n", peer_addr);
2468 spin_unlock_bh(&ar->data_lock);
2471 mutex_unlock(&ar->conf_mutex);
2475 static int ath10k_sta_state(struct ieee80211_hw *hw,
2476 struct ieee80211_vif *vif,
2477 struct ieee80211_sta *sta,
2478 enum ieee80211_sta_state old_state,
2479 enum ieee80211_sta_state new_state)
2481 struct ath10k *ar = hw->priv;
2482 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2485 mutex_lock(&ar->conf_mutex);
2487 if (old_state == IEEE80211_STA_NOTEXIST &&
2488 new_state == IEEE80211_STA_NONE &&
2489 vif->type != NL80211_IFTYPE_STATION) {
2491 * New station addition.
2493 ath10k_dbg(ATH10K_DBG_MAC,
2494 "mac vdev %d peer create %pM (new sta)\n",
2495 arvif->vdev_id, sta->addr);
2497 ret = ath10k_peer_create(ar, arvif->vdev_id, sta->addr);
2499 ath10k_warn("Failed to add peer: %pM for VDEV: %d\n",
2500 sta->addr, arvif->vdev_id);
2501 } else if ((old_state == IEEE80211_STA_NONE &&
2502 new_state == IEEE80211_STA_NOTEXIST)) {
2504 * Existing station deletion.
2506 ath10k_dbg(ATH10K_DBG_MAC,
2507 "mac vdev %d peer delete %pM (sta gone)\n",
2508 arvif->vdev_id, sta->addr);
2509 ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
2511 ath10k_warn("Failed to delete peer: %pM for VDEV: %d\n",
2512 sta->addr, arvif->vdev_id);
2514 if (vif->type == NL80211_IFTYPE_STATION)
2515 ath10k_bss_disassoc(hw, vif);
2516 } else if (old_state == IEEE80211_STA_AUTH &&
2517 new_state == IEEE80211_STA_ASSOC &&
2518 (vif->type == NL80211_IFTYPE_AP ||
2519 vif->type == NL80211_IFTYPE_ADHOC)) {
2523 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM associated\n",
2526 ret = ath10k_station_assoc(ar, arvif, sta);
2528 ath10k_warn("Failed to associate station: %pM\n",
2530 } else if (old_state == IEEE80211_STA_ASSOC &&
2531 new_state == IEEE80211_STA_AUTH &&
2532 (vif->type == NL80211_IFTYPE_AP ||
2533 vif->type == NL80211_IFTYPE_ADHOC)) {
2537 ath10k_dbg(ATH10K_DBG_MAC, "mac sta %pM disassociated\n",
2540 ret = ath10k_station_disassoc(ar, arvif, sta);
2542 ath10k_warn("Failed to disassociate station: %pM\n",
2546 mutex_unlock(&ar->conf_mutex);
2550 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
2551 u16 ac, bool enable)
2553 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2557 lockdep_assert_held(&ar->conf_mutex);
2559 if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
2563 case IEEE80211_AC_VO:
2564 value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
2565 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
2567 case IEEE80211_AC_VI:
2568 value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
2569 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
2571 case IEEE80211_AC_BE:
2572 value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
2573 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
2575 case IEEE80211_AC_BK:
2576 value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
2577 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
2582 arvif->u.sta.uapsd |= value;
2584 arvif->u.sta.uapsd &= ~value;
2586 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2587 WMI_STA_PS_PARAM_UAPSD,
2588 arvif->u.sta.uapsd);
2590 ath10k_warn("could not set uapsd params %d\n", ret);
2594 if (arvif->u.sta.uapsd)
2595 value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
2597 value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
2599 ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
2600 WMI_STA_PS_PARAM_RX_WAKE_POLICY,
2603 ath10k_warn("could not set rx wake param %d\n", ret);
2609 static int ath10k_conf_tx(struct ieee80211_hw *hw,
2610 struct ieee80211_vif *vif, u16 ac,
2611 const struct ieee80211_tx_queue_params *params)
2613 struct ath10k *ar = hw->priv;
2614 struct wmi_wmm_params_arg *p = NULL;
2617 mutex_lock(&ar->conf_mutex);
2620 case IEEE80211_AC_VO:
2621 p = &ar->wmm_params.ac_vo;
2623 case IEEE80211_AC_VI:
2624 p = &ar->wmm_params.ac_vi;
2626 case IEEE80211_AC_BE:
2627 p = &ar->wmm_params.ac_be;
2629 case IEEE80211_AC_BK:
2630 p = &ar->wmm_params.ac_bk;
2639 p->cwmin = params->cw_min;
2640 p->cwmax = params->cw_max;
2641 p->aifs = params->aifs;
2644 * The channel time duration programmed in the HW is in absolute
2645 * microseconds, while mac80211 gives the txop in units of
2648 p->txop = params->txop * 32;
2650 /* FIXME: FW accepts wmm params per hw, not per vif */
2651 ret = ath10k_wmi_pdev_set_wmm_params(ar, &ar->wmm_params);
2653 ath10k_warn("could not set wmm params %d\n", ret);
2657 ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
2659 ath10k_warn("could not set sta uapsd %d\n", ret);
2662 mutex_unlock(&ar->conf_mutex);
2666 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
2668 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
2669 struct ieee80211_vif *vif,
2670 struct ieee80211_channel *chan,
2672 enum ieee80211_roc_type type)
2674 struct ath10k *ar = hw->priv;
2675 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2676 struct wmi_start_scan_arg arg;
2679 mutex_lock(&ar->conf_mutex);
2681 spin_lock_bh(&ar->data_lock);
2682 if (ar->scan.in_progress) {
2683 spin_unlock_bh(&ar->data_lock);
2688 INIT_COMPLETION(ar->scan.started);
2689 INIT_COMPLETION(ar->scan.completed);
2690 INIT_COMPLETION(ar->scan.on_channel);
2691 ar->scan.in_progress = true;
2692 ar->scan.aborting = false;
2693 ar->scan.is_roc = true;
2694 ar->scan.vdev_id = arvif->vdev_id;
2695 ar->scan.roc_freq = chan->center_freq;
2696 spin_unlock_bh(&ar->data_lock);
2698 memset(&arg, 0, sizeof(arg));
2699 ath10k_wmi_start_scan_init(ar, &arg);
2700 arg.vdev_id = arvif->vdev_id;
2701 arg.scan_id = ATH10K_SCAN_ID;
2703 arg.channels[0] = chan->center_freq;
2704 arg.dwell_time_active = duration;
2705 arg.dwell_time_passive = duration;
2706 arg.max_scan_time = 2 * duration;
2707 arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
2708 arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
2710 ret = ath10k_start_scan(ar, &arg);
2712 ath10k_warn("could not start roc scan (%d)\n", ret);
2713 spin_lock_bh(&ar->data_lock);
2714 ar->scan.in_progress = false;
2715 spin_unlock_bh(&ar->data_lock);
2719 ret = wait_for_completion_timeout(&ar->scan.on_channel, 3*HZ);
2721 ath10k_warn("could not switch to channel for roc scan\n");
2722 ath10k_abort_scan(ar);
2729 mutex_unlock(&ar->conf_mutex);
2733 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw)
2735 struct ath10k *ar = hw->priv;
2737 mutex_lock(&ar->conf_mutex);
2738 ath10k_abort_scan(ar);
2739 mutex_unlock(&ar->conf_mutex);
2745 * Both RTS and Fragmentation threshold are interface-specific
2746 * in ath10k, but device-specific in mac80211.
2748 static void ath10k_set_rts_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2750 struct ath10k_generic_iter *ar_iter = data;
2751 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2752 u32 rts = ar_iter->ar->hw->wiphy->rts_threshold;
2754 lockdep_assert_held(&arvif->ar->conf_mutex);
2756 /* During HW reconfiguration mac80211 reports all interfaces that were
2757 * running until reconfiguration was started. Since FW doesn't have any
2758 * vdevs at this point we must not iterate over this interface list.
2759 * This setting will be updated upon add_interface(). */
2760 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2763 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d rts_threshold %d\n",
2764 arvif->vdev_id, rts);
2766 ar_iter->ret = ath10k_mac_set_rts(arvif, rts);
2768 ath10k_warn("Failed to set RTS threshold for VDEV: %d\n",
2772 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
2774 struct ath10k_generic_iter ar_iter;
2775 struct ath10k *ar = hw->priv;
2777 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2780 mutex_lock(&ar->conf_mutex);
2781 ieee80211_iterate_active_interfaces_atomic(
2782 hw, IEEE80211_IFACE_ITER_NORMAL,
2783 ath10k_set_rts_iter, &ar_iter);
2784 mutex_unlock(&ar->conf_mutex);
2789 static void ath10k_set_frag_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
2791 struct ath10k_generic_iter *ar_iter = data;
2792 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
2793 u32 frag = ar_iter->ar->hw->wiphy->frag_threshold;
2795 lockdep_assert_held(&arvif->ar->conf_mutex);
2797 /* During HW reconfiguration mac80211 reports all interfaces that were
2798 * running until reconfiguration was started. Since FW doesn't have any
2799 * vdevs at this point we must not iterate over this interface list.
2800 * This setting will be updated upon add_interface(). */
2801 if (ar_iter->ar->state == ATH10K_STATE_RESTARTED)
2804 ath10k_dbg(ATH10K_DBG_MAC, "mac vdev %d fragmentation_threshold %d\n",
2805 arvif->vdev_id, frag);
2807 ar_iter->ret = ath10k_mac_set_frag(arvif, frag);
2809 ath10k_warn("Failed to set frag threshold for VDEV: %d\n",
2813 static int ath10k_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
2815 struct ath10k_generic_iter ar_iter;
2816 struct ath10k *ar = hw->priv;
2818 memset(&ar_iter, 0, sizeof(struct ath10k_generic_iter));
2821 mutex_lock(&ar->conf_mutex);
2822 ieee80211_iterate_active_interfaces_atomic(
2823 hw, IEEE80211_IFACE_ITER_NORMAL,
2824 ath10k_set_frag_iter, &ar_iter);
2825 mutex_unlock(&ar->conf_mutex);
2830 static void ath10k_flush(struct ieee80211_hw *hw, u32 queues, bool drop)
2832 struct ath10k *ar = hw->priv;
2836 /* mac80211 doesn't care if we really xmit queued frames or not
2837 * we'll collect those frames either way if we stop/delete vdevs */
2841 mutex_lock(&ar->conf_mutex);
2843 if (ar->state == ATH10K_STATE_WEDGED)
2846 ret = wait_event_timeout(ar->htt.empty_tx_wq, ({
2849 spin_lock_bh(&ar->htt.tx_lock);
2850 empty = bitmap_empty(ar->htt.used_msdu_ids,
2851 ar->htt.max_num_pending_tx);
2852 spin_unlock_bh(&ar->htt.tx_lock);
2854 skip = (ar->state == ATH10K_STATE_WEDGED);
2857 }), ATH10K_FLUSH_TIMEOUT_HZ);
2859 if (ret <= 0 || skip)
2860 ath10k_warn("tx not flushed\n");
2863 mutex_unlock(&ar->conf_mutex);
2866 /* TODO: Implement this function properly
2867 * For now it is needed to reply to Probe Requests in IBSS mode.
2868 * Propably we need this information from FW.
2870 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
2876 static int ath10k_suspend(struct ieee80211_hw *hw,
2877 struct cfg80211_wowlan *wowlan)
2879 struct ath10k *ar = hw->priv;
2882 ar->is_target_paused = false;
2884 ret = ath10k_wmi_pdev_suspend_target(ar);
2886 ath10k_warn("could not suspend target (%d)\n", ret);
2890 ret = wait_event_interruptible_timeout(ar->event_queue,
2891 ar->is_target_paused == true,
2894 ath10k_warn("suspend interrupted (%d)\n", ret);
2896 } else if (ret == 0) {
2897 ath10k_warn("suspend timed out - target pause event never came\n");
2901 ret = ath10k_hif_suspend(ar);
2903 ath10k_warn("could not suspend hif (%d)\n", ret);
2909 ret = ath10k_wmi_pdev_resume_target(ar);
2911 ath10k_warn("could not resume target (%d)\n", ret);
2915 static int ath10k_resume(struct ieee80211_hw *hw)
2917 struct ath10k *ar = hw->priv;
2920 ret = ath10k_hif_resume(ar);
2922 ath10k_warn("could not resume hif (%d)\n", ret);
2926 ret = ath10k_wmi_pdev_resume_target(ar);
2928 ath10k_warn("could not resume target (%d)\n", ret);
2936 static void ath10k_restart_complete(struct ieee80211_hw *hw)
2938 struct ath10k *ar = hw->priv;
2940 mutex_lock(&ar->conf_mutex);
2942 /* If device failed to restart it will be in a different state, e.g.
2943 * ATH10K_STATE_WEDGED */
2944 if (ar->state == ATH10K_STATE_RESTARTED) {
2945 ath10k_info("device successfully recovered\n");
2946 ar->state = ATH10K_STATE_ON;
2949 mutex_unlock(&ar->conf_mutex);
2952 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
2953 struct survey_info *survey)
2955 struct ath10k *ar = hw->priv;
2956 struct ieee80211_supported_band *sband;
2957 struct survey_info *ar_survey = &ar->survey[idx];
2960 mutex_lock(&ar->conf_mutex);
2962 sband = hw->wiphy->bands[IEEE80211_BAND_2GHZ];
2963 if (sband && idx >= sband->n_channels) {
2964 idx -= sband->n_channels;
2969 sband = hw->wiphy->bands[IEEE80211_BAND_5GHZ];
2971 if (!sband || idx >= sband->n_channels) {
2976 spin_lock_bh(&ar->data_lock);
2977 memcpy(survey, ar_survey, sizeof(*survey));
2978 spin_unlock_bh(&ar->data_lock);
2980 survey->channel = &sband->channels[idx];
2983 mutex_unlock(&ar->conf_mutex);
2987 static const struct ieee80211_ops ath10k_ops = {
2989 .start = ath10k_start,
2990 .stop = ath10k_stop,
2991 .config = ath10k_config,
2992 .add_interface = ath10k_add_interface,
2993 .remove_interface = ath10k_remove_interface,
2994 .configure_filter = ath10k_configure_filter,
2995 .bss_info_changed = ath10k_bss_info_changed,
2996 .hw_scan = ath10k_hw_scan,
2997 .cancel_hw_scan = ath10k_cancel_hw_scan,
2998 .set_key = ath10k_set_key,
2999 .sta_state = ath10k_sta_state,
3000 .conf_tx = ath10k_conf_tx,
3001 .remain_on_channel = ath10k_remain_on_channel,
3002 .cancel_remain_on_channel = ath10k_cancel_remain_on_channel,
3003 .set_rts_threshold = ath10k_set_rts_threshold,
3004 .set_frag_threshold = ath10k_set_frag_threshold,
3005 .flush = ath10k_flush,
3006 .tx_last_beacon = ath10k_tx_last_beacon,
3007 .restart_complete = ath10k_restart_complete,
3008 .get_survey = ath10k_get_survey,
3010 .suspend = ath10k_suspend,
3011 .resume = ath10k_resume,
3015 #define RATETAB_ENT(_rate, _rateid, _flags) { \
3016 .bitrate = (_rate), \
3017 .flags = (_flags), \
3018 .hw_value = (_rateid), \
3021 #define CHAN2G(_channel, _freq, _flags) { \
3022 .band = IEEE80211_BAND_2GHZ, \
3023 .hw_value = (_channel), \
3024 .center_freq = (_freq), \
3025 .flags = (_flags), \
3026 .max_antenna_gain = 0, \
3030 #define CHAN5G(_channel, _freq, _flags) { \
3031 .band = IEEE80211_BAND_5GHZ, \
3032 .hw_value = (_channel), \
3033 .center_freq = (_freq), \
3034 .flags = (_flags), \
3035 .max_antenna_gain = 0, \
3039 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
3049 CHAN2G(10, 2457, 0),
3050 CHAN2G(11, 2462, 0),
3051 CHAN2G(12, 2467, 0),
3052 CHAN2G(13, 2472, 0),
3053 CHAN2G(14, 2484, 0),
3056 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
3057 CHAN5G(36, 5180, 0),
3058 CHAN5G(40, 5200, 0),
3059 CHAN5G(44, 5220, 0),
3060 CHAN5G(48, 5240, 0),
3061 CHAN5G(52, 5260, 0),
3062 CHAN5G(56, 5280, 0),
3063 CHAN5G(60, 5300, 0),
3064 CHAN5G(64, 5320, 0),
3065 CHAN5G(100, 5500, 0),
3066 CHAN5G(104, 5520, 0),
3067 CHAN5G(108, 5540, 0),
3068 CHAN5G(112, 5560, 0),
3069 CHAN5G(116, 5580, 0),
3070 CHAN5G(120, 5600, 0),
3071 CHAN5G(124, 5620, 0),
3072 CHAN5G(128, 5640, 0),
3073 CHAN5G(132, 5660, 0),
3074 CHAN5G(136, 5680, 0),
3075 CHAN5G(140, 5700, 0),
3076 CHAN5G(149, 5745, 0),
3077 CHAN5G(153, 5765, 0),
3078 CHAN5G(157, 5785, 0),
3079 CHAN5G(161, 5805, 0),
3080 CHAN5G(165, 5825, 0),
3083 static struct ieee80211_rate ath10k_rates[] = {
3085 RATETAB_ENT(10, 0x82, 0),
3086 RATETAB_ENT(20, 0x84, 0),
3087 RATETAB_ENT(55, 0x8b, 0),
3088 RATETAB_ENT(110, 0x96, 0),
3090 RATETAB_ENT(60, 0x0c, 0),
3091 RATETAB_ENT(90, 0x12, 0),
3092 RATETAB_ENT(120, 0x18, 0),
3093 RATETAB_ENT(180, 0x24, 0),
3094 RATETAB_ENT(240, 0x30, 0),
3095 RATETAB_ENT(360, 0x48, 0),
3096 RATETAB_ENT(480, 0x60, 0),
3097 RATETAB_ENT(540, 0x6c, 0),
3100 #define ath10k_a_rates (ath10k_rates + 4)
3101 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - 4)
3102 #define ath10k_g_rates (ath10k_rates + 0)
3103 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
3105 struct ath10k *ath10k_mac_create(void)
3107 struct ieee80211_hw *hw;
3110 hw = ieee80211_alloc_hw(sizeof(struct ath10k), &ath10k_ops);
3120 void ath10k_mac_destroy(struct ath10k *ar)
3122 ieee80211_free_hw(ar->hw);
3125 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
3128 .types = BIT(NL80211_IFTYPE_STATION)
3129 | BIT(NL80211_IFTYPE_P2P_CLIENT)
3133 .types = BIT(NL80211_IFTYPE_P2P_GO)
3137 .types = BIT(NL80211_IFTYPE_AP)
3141 static const struct ieee80211_iface_combination ath10k_if_comb = {
3142 .limits = ath10k_if_limits,
3143 .n_limits = ARRAY_SIZE(ath10k_if_limits),
3144 .max_interfaces = 8,
3145 .num_different_channels = 1,
3146 .beacon_int_infra_match = true,
3149 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
3151 struct ieee80211_sta_vht_cap vht_cap = {0};
3155 vht_cap.vht_supported = 1;
3156 vht_cap.cap = ar->vht_cap_info;
3159 for (i = 0; i < 8; i++) {
3160 if (i < ar->num_rf_chains)
3161 mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i*2);
3163 mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i*2);
3166 vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
3167 vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
3172 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
3175 struct ieee80211_sta_ht_cap ht_cap = {0};
3177 if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
3180 ht_cap.ht_supported = 1;
3181 ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
3182 ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
3183 ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
3184 ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
3185 ht_cap.cap |= WLAN_HT_CAP_SM_PS_STATIC << IEEE80211_HT_CAP_SM_PS_SHIFT;
3187 if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
3188 ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
3190 if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
3191 ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
3193 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
3196 smps = WLAN_HT_CAP_SM_PS_DYNAMIC;
3197 smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
3202 if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC)
3203 ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
3205 if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
3208 stbc = ar->ht_cap_info;
3209 stbc &= WMI_HT_CAP_RX_STBC;
3210 stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
3211 stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
3212 stbc &= IEEE80211_HT_CAP_RX_STBC;
3217 if (ar->ht_cap_info & WMI_HT_CAP_LDPC)
3218 ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
3220 if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
3221 ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
3223 /* max AMSDU is implicitly taken from vht_cap_info */
3224 if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
3225 ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
3227 for (i = 0; i < ar->num_rf_chains; i++)
3228 ht_cap.mcs.rx_mask[i] = 0xFF;
3230 ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
3236 static void ath10k_get_arvif_iter(void *data, u8 *mac,
3237 struct ieee80211_vif *vif)
3239 struct ath10k_vif_iter *arvif_iter = data;
3240 struct ath10k_vif *arvif = ath10k_vif_to_arvif(vif);
3242 if (arvif->vdev_id == arvif_iter->vdev_id)
3243 arvif_iter->arvif = arvif;
3246 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
3248 struct ath10k_vif_iter arvif_iter;
3251 memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
3252 arvif_iter.vdev_id = vdev_id;
3254 flags = IEEE80211_IFACE_ITER_RESUME_ALL;
3255 ieee80211_iterate_active_interfaces_atomic(ar->hw,
3257 ath10k_get_arvif_iter,
3259 if (!arvif_iter.arvif) {
3260 ath10k_warn("No VIF found for VDEV: %d\n", vdev_id);
3264 return arvif_iter.arvif;
3267 int ath10k_mac_register(struct ath10k *ar)
3269 struct ieee80211_supported_band *band;
3270 struct ieee80211_sta_vht_cap vht_cap;
3271 struct ieee80211_sta_ht_cap ht_cap;
3275 SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
3277 SET_IEEE80211_DEV(ar->hw, ar->dev);
3279 ht_cap = ath10k_get_ht_cap(ar);
3280 vht_cap = ath10k_create_vht_cap(ar);
3282 if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
3283 channels = kmemdup(ath10k_2ghz_channels,
3284 sizeof(ath10k_2ghz_channels),
3291 band = &ar->mac.sbands[IEEE80211_BAND_2GHZ];
3292 band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
3293 band->channels = channels;
3294 band->n_bitrates = ath10k_g_rates_size;
3295 band->bitrates = ath10k_g_rates;
3296 band->ht_cap = ht_cap;
3298 /* vht is not supported in 2.4 GHz */
3300 ar->hw->wiphy->bands[IEEE80211_BAND_2GHZ] = band;
3303 if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
3304 channels = kmemdup(ath10k_5ghz_channels,
3305 sizeof(ath10k_5ghz_channels),
3312 band = &ar->mac.sbands[IEEE80211_BAND_5GHZ];
3313 band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
3314 band->channels = channels;
3315 band->n_bitrates = ath10k_a_rates_size;
3316 band->bitrates = ath10k_a_rates;
3317 band->ht_cap = ht_cap;
3318 band->vht_cap = vht_cap;
3319 ar->hw->wiphy->bands[IEEE80211_BAND_5GHZ] = band;
3322 ar->hw->wiphy->interface_modes =
3323 BIT(NL80211_IFTYPE_STATION) |
3324 BIT(NL80211_IFTYPE_ADHOC) |
3325 BIT(NL80211_IFTYPE_AP) |
3326 BIT(NL80211_IFTYPE_P2P_CLIENT) |
3327 BIT(NL80211_IFTYPE_P2P_GO);
3329 ar->hw->flags = IEEE80211_HW_SIGNAL_DBM |
3330 IEEE80211_HW_SUPPORTS_PS |
3331 IEEE80211_HW_SUPPORTS_DYNAMIC_PS |
3332 IEEE80211_HW_SUPPORTS_UAPSD |
3333 IEEE80211_HW_MFP_CAPABLE |
3334 IEEE80211_HW_REPORTS_TX_ACK_STATUS |
3335 IEEE80211_HW_HAS_RATE_CONTROL |
3336 IEEE80211_HW_SUPPORTS_STATIC_SMPS |
3337 IEEE80211_HW_WANT_MONITOR_VIF |
3338 IEEE80211_HW_AP_LINK_PS;
3340 if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
3341 ar->hw->flags |= IEEE80211_HW_SUPPORTS_DYNAMIC_SMPS;
3343 if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
3344 ar->hw->flags |= IEEE80211_HW_AMPDU_AGGREGATION;
3345 ar->hw->flags |= IEEE80211_HW_TX_AMPDU_SETUP_IN_HW;
3348 ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
3349 ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
3351 ar->hw->vif_data_size = sizeof(struct ath10k_vif);
3353 ar->hw->channel_change_time = 5000;
3354 ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
3356 ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
3357 ar->hw->wiphy->max_remain_on_channel_duration = 5000;
3359 ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
3361 * on LL hardware queues are managed entirely by the FW
3362 * so we only advertise to mac we can do the queues thing
3366 ar->hw->wiphy->iface_combinations = &ath10k_if_comb;
3367 ar->hw->wiphy->n_iface_combinations = 1;
3369 ar->hw->netdev_features = NETIF_F_HW_CSUM;
3371 ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
3372 ath10k_reg_notifier);
3374 ath10k_err("Regulatory initialization failed\n");
3378 ret = ieee80211_register_hw(ar->hw);
3380 ath10k_err("ieee80211 registration failed: %d\n", ret);
3384 if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
3385 ret = regulatory_hint(ar->hw->wiphy,
3386 ar->ath_common.regulatory.alpha2);
3388 goto err_unregister;
3394 ieee80211_unregister_hw(ar->hw);
3396 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3397 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3402 void ath10k_mac_unregister(struct ath10k *ar)
3404 ieee80211_unregister_hw(ar->hw);
3406 kfree(ar->mac.sbands[IEEE80211_BAND_2GHZ].channels);
3407 kfree(ar->mac.sbands[IEEE80211_BAND_5GHZ].channels);
3409 SET_IEEE80211_DEV(ar->hw, NULL);