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>
39 static struct ieee80211_rate ath10k_rates
[] = {
41 .hw_value
= ATH10K_HW_RATE_CCK_LP_1M
},
43 .hw_value
= ATH10K_HW_RATE_CCK_LP_2M
,
44 .hw_value_short
= ATH10K_HW_RATE_CCK_SP_2M
,
45 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
47 .hw_value
= ATH10K_HW_RATE_CCK_LP_5_5M
,
48 .hw_value_short
= ATH10K_HW_RATE_CCK_SP_5_5M
,
49 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
51 .hw_value
= ATH10K_HW_RATE_CCK_LP_11M
,
52 .hw_value_short
= ATH10K_HW_RATE_CCK_SP_11M
,
53 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
},
55 { .bitrate
= 60, .hw_value
= ATH10K_HW_RATE_OFDM_6M
},
56 { .bitrate
= 90, .hw_value
= ATH10K_HW_RATE_OFDM_9M
},
57 { .bitrate
= 120, .hw_value
= ATH10K_HW_RATE_OFDM_12M
},
58 { .bitrate
= 180, .hw_value
= ATH10K_HW_RATE_OFDM_18M
},
59 { .bitrate
= 240, .hw_value
= ATH10K_HW_RATE_OFDM_24M
},
60 { .bitrate
= 360, .hw_value
= ATH10K_HW_RATE_OFDM_36M
},
61 { .bitrate
= 480, .hw_value
= ATH10K_HW_RATE_OFDM_48M
},
62 { .bitrate
= 540, .hw_value
= ATH10K_HW_RATE_OFDM_54M
},
65 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
67 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
68 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
69 ATH10K_MAC_FIRST_OFDM_RATE_IDX)
70 #define ath10k_g_rates (ath10k_rates + 0)
71 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
73 static bool ath10k_mac_bitrate_is_cck(int bitrate
)
86 static u8
ath10k_mac_bitrate_to_rate(int bitrate
)
88 return DIV_ROUND_UP(bitrate
, 5) |
89 (ath10k_mac_bitrate_is_cck(bitrate
) ? BIT(7) : 0);
92 u8
ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band
*sband
,
95 const struct ieee80211_rate
*rate
;
98 for (i
= 0; i
< sband
->n_bitrates
; i
++) {
99 rate
= &sband
->bitrates
[i
];
101 if (ath10k_mac_bitrate_is_cck(rate
->bitrate
) != cck
)
104 if (rate
->hw_value
== hw_rate
)
106 else if (rate
->flags
& IEEE80211_RATE_SHORT_PREAMBLE
&&
107 rate
->hw_value_short
== hw_rate
)
114 u8
ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band
*sband
,
119 for (i
= 0; i
< sband
->n_bitrates
; i
++)
120 if (sband
->bitrates
[i
].bitrate
== bitrate
)
126 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map
, int nss
)
128 switch ((mcs_map
>> (2 * nss
)) & 0x3) {
129 case IEEE80211_VHT_MCS_SUPPORT_0_7
: return BIT(8) - 1;
130 case IEEE80211_VHT_MCS_SUPPORT_0_8
: return BIT(9) - 1;
131 case IEEE80211_VHT_MCS_SUPPORT_0_9
: return BIT(10) - 1;
137 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask
[IEEE80211_HT_MCS_MASK_LEN
])
141 for (nss
= IEEE80211_HT_MCS_MASK_LEN
- 1; nss
>= 0; nss
--)
142 if (ht_mcs_mask
[nss
])
149 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask
[NL80211_VHT_NSS_MAX
])
153 for (nss
= NL80211_VHT_NSS_MAX
- 1; nss
>= 0; nss
--)
154 if (vht_mcs_mask
[nss
])
164 static int ath10k_send_key(struct ath10k_vif
*arvif
,
165 struct ieee80211_key_conf
*key
,
166 enum set_key_cmd cmd
,
167 const u8
*macaddr
, u32 flags
)
169 struct ath10k
*ar
= arvif
->ar
;
170 struct wmi_vdev_install_key_arg arg
= {
171 .vdev_id
= arvif
->vdev_id
,
172 .key_idx
= key
->keyidx
,
173 .key_len
= key
->keylen
,
174 .key_data
= key
->key
,
179 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
181 switch (key
->cipher
) {
182 case WLAN_CIPHER_SUITE_CCMP
:
183 arg
.key_cipher
= WMI_CIPHER_AES_CCM
;
184 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT
;
186 case WLAN_CIPHER_SUITE_TKIP
:
187 arg
.key_cipher
= WMI_CIPHER_TKIP
;
188 arg
.key_txmic_len
= 8;
189 arg
.key_rxmic_len
= 8;
191 case WLAN_CIPHER_SUITE_WEP40
:
192 case WLAN_CIPHER_SUITE_WEP104
:
193 arg
.key_cipher
= WMI_CIPHER_WEP
;
195 case WLAN_CIPHER_SUITE_AES_CMAC
:
199 ath10k_warn(ar
, "cipher %d is not supported\n", key
->cipher
);
203 if (test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
))
204 key
->flags
|= IEEE80211_KEY_FLAG_GENERATE_IV
;
206 if (cmd
== DISABLE_KEY
) {
207 arg
.key_cipher
= WMI_CIPHER_NONE
;
211 return ath10k_wmi_vdev_install_key(arvif
->ar
, &arg
);
214 static int ath10k_install_key(struct ath10k_vif
*arvif
,
215 struct ieee80211_key_conf
*key
,
216 enum set_key_cmd cmd
,
217 const u8
*macaddr
, u32 flags
)
219 struct ath10k
*ar
= arvif
->ar
;
221 unsigned long time_left
;
223 lockdep_assert_held(&ar
->conf_mutex
);
225 reinit_completion(&ar
->install_key_done
);
227 if (arvif
->nohwcrypt
)
230 ret
= ath10k_send_key(arvif
, key
, cmd
, macaddr
, flags
);
234 time_left
= wait_for_completion_timeout(&ar
->install_key_done
, 3 * HZ
);
241 static int ath10k_install_peer_wep_keys(struct ath10k_vif
*arvif
,
244 struct ath10k
*ar
= arvif
->ar
;
245 struct ath10k_peer
*peer
;
250 lockdep_assert_held(&ar
->conf_mutex
);
252 if (WARN_ON(arvif
->vif
->type
!= NL80211_IFTYPE_AP
&&
253 arvif
->vif
->type
!= NL80211_IFTYPE_ADHOC
))
256 spin_lock_bh(&ar
->data_lock
);
257 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, addr
);
258 spin_unlock_bh(&ar
->data_lock
);
263 for (i
= 0; i
< ARRAY_SIZE(arvif
->wep_keys
); i
++) {
264 if (arvif
->wep_keys
[i
] == NULL
)
267 switch (arvif
->vif
->type
) {
268 case NL80211_IFTYPE_AP
:
269 flags
= WMI_KEY_PAIRWISE
;
271 if (arvif
->def_wep_key_idx
== i
)
272 flags
|= WMI_KEY_TX_USAGE
;
274 ret
= ath10k_install_key(arvif
, arvif
->wep_keys
[i
],
275 SET_KEY
, addr
, flags
);
279 case NL80211_IFTYPE_ADHOC
:
280 ret
= ath10k_install_key(arvif
, arvif
->wep_keys
[i
],
286 ret
= ath10k_install_key(arvif
, arvif
->wep_keys
[i
],
287 SET_KEY
, addr
, WMI_KEY_GROUP
);
296 spin_lock_bh(&ar
->data_lock
);
297 peer
->keys
[i
] = arvif
->wep_keys
[i
];
298 spin_unlock_bh(&ar
->data_lock
);
301 /* In some cases (notably with static WEP IBSS with multiple keys)
302 * multicast Tx becomes broken. Both pairwise and groupwise keys are
303 * installed already. Using WMI_KEY_TX_USAGE in different combinations
304 * didn't seem help. Using def_keyid vdev parameter seems to be
305 * effective so use that.
307 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
309 if (arvif
->vif
->type
!= NL80211_IFTYPE_ADHOC
)
312 if (arvif
->def_wep_key_idx
== -1)
315 ret
= ath10k_wmi_vdev_set_param(arvif
->ar
,
317 arvif
->ar
->wmi
.vdev_param
->def_keyid
,
318 arvif
->def_wep_key_idx
);
320 ath10k_warn(ar
, "failed to re-set def wpa key idxon vdev %i: %d\n",
321 arvif
->vdev_id
, ret
);
328 static int ath10k_clear_peer_keys(struct ath10k_vif
*arvif
,
331 struct ath10k
*ar
= arvif
->ar
;
332 struct ath10k_peer
*peer
;
338 lockdep_assert_held(&ar
->conf_mutex
);
340 spin_lock_bh(&ar
->data_lock
);
341 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, addr
);
342 spin_unlock_bh(&ar
->data_lock
);
347 for (i
= 0; i
< ARRAY_SIZE(peer
->keys
); i
++) {
348 if (peer
->keys
[i
] == NULL
)
351 /* key flags are not required to delete the key */
352 ret
= ath10k_install_key(arvif
, peer
->keys
[i
],
353 DISABLE_KEY
, addr
, flags
);
354 if (ret
< 0 && first_errno
== 0)
358 ath10k_warn(ar
, "failed to remove peer wep key %d: %d\n",
361 spin_lock_bh(&ar
->data_lock
);
362 peer
->keys
[i
] = NULL
;
363 spin_unlock_bh(&ar
->data_lock
);
369 bool ath10k_mac_is_peer_wep_key_set(struct ath10k
*ar
, const u8
*addr
,
372 struct ath10k_peer
*peer
;
375 lockdep_assert_held(&ar
->data_lock
);
377 /* We don't know which vdev this peer belongs to,
378 * since WMI doesn't give us that information.
380 * FIXME: multi-bss needs to be handled.
382 peer
= ath10k_peer_find(ar
, 0, addr
);
386 for (i
= 0; i
< ARRAY_SIZE(peer
->keys
); i
++) {
387 if (peer
->keys
[i
] && peer
->keys
[i
]->keyidx
== keyidx
)
394 static int ath10k_clear_vdev_key(struct ath10k_vif
*arvif
,
395 struct ieee80211_key_conf
*key
)
397 struct ath10k
*ar
= arvif
->ar
;
398 struct ath10k_peer
*peer
;
405 lockdep_assert_held(&ar
->conf_mutex
);
408 /* since ath10k_install_key we can't hold data_lock all the
409 * time, so we try to remove the keys incrementally */
410 spin_lock_bh(&ar
->data_lock
);
412 list_for_each_entry(peer
, &ar
->peers
, list
) {
413 for (i
= 0; i
< ARRAY_SIZE(peer
->keys
); i
++) {
414 if (peer
->keys
[i
] == key
) {
415 ether_addr_copy(addr
, peer
->addr
);
416 peer
->keys
[i
] = NULL
;
421 if (i
< ARRAY_SIZE(peer
->keys
))
424 spin_unlock_bh(&ar
->data_lock
);
426 if (i
== ARRAY_SIZE(peer
->keys
))
428 /* key flags are not required to delete the key */
429 ret
= ath10k_install_key(arvif
, key
, DISABLE_KEY
, addr
, flags
);
430 if (ret
< 0 && first_errno
== 0)
434 ath10k_warn(ar
, "failed to remove key for %pM: %d\n",
441 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif
*arvif
,
442 struct ieee80211_key_conf
*key
)
444 struct ath10k
*ar
= arvif
->ar
;
445 struct ath10k_peer
*peer
;
448 lockdep_assert_held(&ar
->conf_mutex
);
450 list_for_each_entry(peer
, &ar
->peers
, list
) {
451 if (!memcmp(peer
->addr
, arvif
->vif
->addr
, ETH_ALEN
))
454 if (!memcmp(peer
->addr
, arvif
->bssid
, ETH_ALEN
))
457 if (peer
->keys
[key
->keyidx
] == key
)
460 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vif vdev %i update key %i needs update\n",
461 arvif
->vdev_id
, key
->keyidx
);
463 ret
= ath10k_install_peer_wep_keys(arvif
, peer
->addr
);
465 ath10k_warn(ar
, "failed to update wep keys on vdev %i for peer %pM: %d\n",
466 arvif
->vdev_id
, peer
->addr
, ret
);
474 /*********************/
475 /* General utilities */
476 /*********************/
478 static inline enum wmi_phy_mode
479 chan_to_phymode(const struct cfg80211_chan_def
*chandef
)
481 enum wmi_phy_mode phymode
= MODE_UNKNOWN
;
483 switch (chandef
->chan
->band
) {
484 case IEEE80211_BAND_2GHZ
:
485 switch (chandef
->width
) {
486 case NL80211_CHAN_WIDTH_20_NOHT
:
487 if (chandef
->chan
->flags
& IEEE80211_CHAN_NO_OFDM
)
492 case NL80211_CHAN_WIDTH_20
:
493 phymode
= MODE_11NG_HT20
;
495 case NL80211_CHAN_WIDTH_40
:
496 phymode
= MODE_11NG_HT40
;
498 case NL80211_CHAN_WIDTH_5
:
499 case NL80211_CHAN_WIDTH_10
:
500 case NL80211_CHAN_WIDTH_80
:
501 case NL80211_CHAN_WIDTH_80P80
:
502 case NL80211_CHAN_WIDTH_160
:
503 phymode
= MODE_UNKNOWN
;
507 case IEEE80211_BAND_5GHZ
:
508 switch (chandef
->width
) {
509 case NL80211_CHAN_WIDTH_20_NOHT
:
512 case NL80211_CHAN_WIDTH_20
:
513 phymode
= MODE_11NA_HT20
;
515 case NL80211_CHAN_WIDTH_40
:
516 phymode
= MODE_11NA_HT40
;
518 case NL80211_CHAN_WIDTH_80
:
519 phymode
= MODE_11AC_VHT80
;
521 case NL80211_CHAN_WIDTH_5
:
522 case NL80211_CHAN_WIDTH_10
:
523 case NL80211_CHAN_WIDTH_80P80
:
524 case NL80211_CHAN_WIDTH_160
:
525 phymode
= MODE_UNKNOWN
;
533 WARN_ON(phymode
== MODE_UNKNOWN
);
537 static u8
ath10k_parse_mpdudensity(u8 mpdudensity
)
540 * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
541 * 0 for no restriction
550 switch (mpdudensity
) {
556 /* Our lower layer calculations limit our precision to
572 int ath10k_mac_vif_chan(struct ieee80211_vif
*vif
,
573 struct cfg80211_chan_def
*def
)
575 struct ieee80211_chanctx_conf
*conf
;
578 conf
= rcu_dereference(vif
->chanctx_conf
);
590 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw
*hw
,
591 struct ieee80211_chanctx_conf
*conf
,
599 static int ath10k_mac_num_chanctxs(struct ath10k
*ar
)
603 ieee80211_iter_chan_contexts_atomic(ar
->hw
,
604 ath10k_mac_num_chanctxs_iter
,
611 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw
*hw
,
612 struct ieee80211_chanctx_conf
*conf
,
615 struct cfg80211_chan_def
**def
= data
;
620 static int ath10k_peer_create(struct ath10k
*ar
, u32 vdev_id
, const u8
*addr
,
621 enum wmi_peer_type peer_type
)
623 struct ath10k_vif
*arvif
;
627 lockdep_assert_held(&ar
->conf_mutex
);
629 num_peers
= ar
->num_peers
;
631 /* Each vdev consumes a peer entry as well */
632 list_for_each_entry(arvif
, &ar
->arvifs
, list
)
635 if (num_peers
>= ar
->max_num_peers
)
638 ret
= ath10k_wmi_peer_create(ar
, vdev_id
, addr
, peer_type
);
640 ath10k_warn(ar
, "failed to create wmi peer %pM on vdev %i: %i\n",
645 ret
= ath10k_wait_for_peer_created(ar
, vdev_id
, addr
);
647 ath10k_warn(ar
, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
657 static int ath10k_mac_set_kickout(struct ath10k_vif
*arvif
)
659 struct ath10k
*ar
= arvif
->ar
;
663 param
= ar
->wmi
.pdev_param
->sta_kickout_th
;
664 ret
= ath10k_wmi_pdev_set_param(ar
, param
,
665 ATH10K_KICKOUT_THRESHOLD
);
667 ath10k_warn(ar
, "failed to set kickout threshold on vdev %i: %d\n",
668 arvif
->vdev_id
, ret
);
672 param
= ar
->wmi
.vdev_param
->ap_keepalive_min_idle_inactive_time_secs
;
673 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
674 ATH10K_KEEPALIVE_MIN_IDLE
);
676 ath10k_warn(ar
, "failed to set keepalive minimum idle time on vdev %i: %d\n",
677 arvif
->vdev_id
, ret
);
681 param
= ar
->wmi
.vdev_param
->ap_keepalive_max_idle_inactive_time_secs
;
682 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
683 ATH10K_KEEPALIVE_MAX_IDLE
);
685 ath10k_warn(ar
, "failed to set keepalive maximum idle time on vdev %i: %d\n",
686 arvif
->vdev_id
, ret
);
690 param
= ar
->wmi
.vdev_param
->ap_keepalive_max_unresponsive_time_secs
;
691 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
,
692 ATH10K_KEEPALIVE_MAX_UNRESPONSIVE
);
694 ath10k_warn(ar
, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
695 arvif
->vdev_id
, ret
);
702 static int ath10k_mac_set_rts(struct ath10k_vif
*arvif
, u32 value
)
704 struct ath10k
*ar
= arvif
->ar
;
707 vdev_param
= ar
->wmi
.vdev_param
->rts_threshold
;
708 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, value
);
711 static int ath10k_peer_delete(struct ath10k
*ar
, u32 vdev_id
, const u8
*addr
)
715 lockdep_assert_held(&ar
->conf_mutex
);
717 ret
= ath10k_wmi_peer_delete(ar
, vdev_id
, addr
);
721 ret
= ath10k_wait_for_peer_deleted(ar
, vdev_id
, addr
);
730 static void ath10k_peer_cleanup(struct ath10k
*ar
, u32 vdev_id
)
732 struct ath10k_peer
*peer
, *tmp
;
734 lockdep_assert_held(&ar
->conf_mutex
);
736 spin_lock_bh(&ar
->data_lock
);
737 list_for_each_entry_safe(peer
, tmp
, &ar
->peers
, list
) {
738 if (peer
->vdev_id
!= vdev_id
)
741 ath10k_warn(ar
, "removing stale peer %pM from vdev_id %d\n",
742 peer
->addr
, vdev_id
);
744 list_del(&peer
->list
);
748 spin_unlock_bh(&ar
->data_lock
);
751 static void ath10k_peer_cleanup_all(struct ath10k
*ar
)
753 struct ath10k_peer
*peer
, *tmp
;
755 lockdep_assert_held(&ar
->conf_mutex
);
757 spin_lock_bh(&ar
->data_lock
);
758 list_for_each_entry_safe(peer
, tmp
, &ar
->peers
, list
) {
759 list_del(&peer
->list
);
762 spin_unlock_bh(&ar
->data_lock
);
765 ar
->num_stations
= 0;
768 static int ath10k_mac_tdls_peer_update(struct ath10k
*ar
, u32 vdev_id
,
769 struct ieee80211_sta
*sta
,
770 enum wmi_tdls_peer_state state
)
773 struct wmi_tdls_peer_update_cmd_arg arg
= {};
774 struct wmi_tdls_peer_capab_arg cap
= {};
775 struct wmi_channel_arg chan_arg
= {};
777 lockdep_assert_held(&ar
->conf_mutex
);
779 arg
.vdev_id
= vdev_id
;
780 arg
.peer_state
= state
;
781 ether_addr_copy(arg
.addr
, sta
->addr
);
783 cap
.peer_max_sp
= sta
->max_sp
;
784 cap
.peer_uapsd_queues
= sta
->uapsd_queues
;
786 if (state
== WMI_TDLS_PEER_STATE_CONNECTED
&&
787 !sta
->tdls_initiator
)
788 cap
.is_peer_responder
= 1;
790 ret
= ath10k_wmi_tdls_peer_update(ar
, &arg
, &cap
, &chan_arg
);
792 ath10k_warn(ar
, "failed to update tdls peer %pM on vdev %i: %i\n",
793 arg
.addr
, vdev_id
, ret
);
800 /************************/
801 /* Interface management */
802 /************************/
804 void ath10k_mac_vif_beacon_free(struct ath10k_vif
*arvif
)
806 struct ath10k
*ar
= arvif
->ar
;
808 lockdep_assert_held(&ar
->data_lock
);
813 if (!arvif
->beacon_buf
)
814 dma_unmap_single(ar
->dev
, ATH10K_SKB_CB(arvif
->beacon
)->paddr
,
815 arvif
->beacon
->len
, DMA_TO_DEVICE
);
817 if (WARN_ON(arvif
->beacon_state
!= ATH10K_BEACON_SCHEDULED
&&
818 arvif
->beacon_state
!= ATH10K_BEACON_SENT
))
821 dev_kfree_skb_any(arvif
->beacon
);
823 arvif
->beacon
= NULL
;
824 arvif
->beacon_state
= ATH10K_BEACON_SCHEDULED
;
827 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif
*arvif
)
829 struct ath10k
*ar
= arvif
->ar
;
831 lockdep_assert_held(&ar
->data_lock
);
833 ath10k_mac_vif_beacon_free(arvif
);
835 if (arvif
->beacon_buf
) {
836 dma_free_coherent(ar
->dev
, IEEE80211_MAX_FRAME_LEN
,
837 arvif
->beacon_buf
, arvif
->beacon_paddr
);
838 arvif
->beacon_buf
= NULL
;
842 static inline int ath10k_vdev_setup_sync(struct ath10k
*ar
)
844 unsigned long time_left
;
846 lockdep_assert_held(&ar
->conf_mutex
);
848 if (test_bit(ATH10K_FLAG_CRASH_FLUSH
, &ar
->dev_flags
))
851 time_left
= wait_for_completion_timeout(&ar
->vdev_setup_done
,
852 ATH10K_VDEV_SETUP_TIMEOUT_HZ
);
859 static int ath10k_monitor_vdev_start(struct ath10k
*ar
, int vdev_id
)
861 struct cfg80211_chan_def
*chandef
= NULL
;
862 struct ieee80211_channel
*channel
= NULL
;
863 struct wmi_vdev_start_request_arg arg
= {};
866 lockdep_assert_held(&ar
->conf_mutex
);
868 ieee80211_iter_chan_contexts_atomic(ar
->hw
,
869 ath10k_mac_get_any_chandef_iter
,
871 if (WARN_ON_ONCE(!chandef
))
874 channel
= chandef
->chan
;
876 arg
.vdev_id
= vdev_id
;
877 arg
.channel
.freq
= channel
->center_freq
;
878 arg
.channel
.band_center_freq1
= chandef
->center_freq1
;
880 /* TODO setup this dynamically, what in case we
881 don't have any vifs? */
882 arg
.channel
.mode
= chan_to_phymode(chandef
);
883 arg
.channel
.chan_radar
=
884 !!(channel
->flags
& IEEE80211_CHAN_RADAR
);
886 arg
.channel
.min_power
= 0;
887 arg
.channel
.max_power
= channel
->max_power
* 2;
888 arg
.channel
.max_reg_power
= channel
->max_reg_power
* 2;
889 arg
.channel
.max_antenna_gain
= channel
->max_antenna_gain
* 2;
891 reinit_completion(&ar
->vdev_setup_done
);
893 ret
= ath10k_wmi_vdev_start(ar
, &arg
);
895 ath10k_warn(ar
, "failed to request monitor vdev %i start: %d\n",
900 ret
= ath10k_vdev_setup_sync(ar
);
902 ath10k_warn(ar
, "failed to synchronize setup for monitor vdev %i start: %d\n",
907 ret
= ath10k_wmi_vdev_up(ar
, vdev_id
, 0, ar
->mac_addr
);
909 ath10k_warn(ar
, "failed to put up monitor vdev %i: %d\n",
914 ar
->monitor_vdev_id
= vdev_id
;
916 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %i started\n",
917 ar
->monitor_vdev_id
);
921 ret
= ath10k_wmi_vdev_stop(ar
, ar
->monitor_vdev_id
);
923 ath10k_warn(ar
, "failed to stop monitor vdev %i after start failure: %d\n",
924 ar
->monitor_vdev_id
, ret
);
929 static int ath10k_monitor_vdev_stop(struct ath10k
*ar
)
933 lockdep_assert_held(&ar
->conf_mutex
);
935 ret
= ath10k_wmi_vdev_down(ar
, ar
->monitor_vdev_id
);
937 ath10k_warn(ar
, "failed to put down monitor vdev %i: %d\n",
938 ar
->monitor_vdev_id
, ret
);
940 reinit_completion(&ar
->vdev_setup_done
);
942 ret
= ath10k_wmi_vdev_stop(ar
, ar
->monitor_vdev_id
);
944 ath10k_warn(ar
, "failed to to request monitor vdev %i stop: %d\n",
945 ar
->monitor_vdev_id
, ret
);
947 ret
= ath10k_vdev_setup_sync(ar
);
949 ath10k_warn(ar
, "failed to synchronize monitor vdev %i stop: %d\n",
950 ar
->monitor_vdev_id
, ret
);
952 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %i stopped\n",
953 ar
->monitor_vdev_id
);
957 static int ath10k_monitor_vdev_create(struct ath10k
*ar
)
961 lockdep_assert_held(&ar
->conf_mutex
);
963 if (ar
->free_vdev_map
== 0) {
964 ath10k_warn(ar
, "failed to find free vdev id for monitor vdev\n");
968 bit
= __ffs64(ar
->free_vdev_map
);
970 ar
->monitor_vdev_id
= bit
;
972 ret
= ath10k_wmi_vdev_create(ar
, ar
->monitor_vdev_id
,
973 WMI_VDEV_TYPE_MONITOR
,
976 ath10k_warn(ar
, "failed to request monitor vdev %i creation: %d\n",
977 ar
->monitor_vdev_id
, ret
);
981 ar
->free_vdev_map
&= ~(1LL << ar
->monitor_vdev_id
);
982 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %d created\n",
983 ar
->monitor_vdev_id
);
988 static int ath10k_monitor_vdev_delete(struct ath10k
*ar
)
992 lockdep_assert_held(&ar
->conf_mutex
);
994 ret
= ath10k_wmi_vdev_delete(ar
, ar
->monitor_vdev_id
);
996 ath10k_warn(ar
, "failed to request wmi monitor vdev %i removal: %d\n",
997 ar
->monitor_vdev_id
, ret
);
1001 ar
->free_vdev_map
|= 1LL << ar
->monitor_vdev_id
;
1003 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor vdev %d deleted\n",
1004 ar
->monitor_vdev_id
);
1008 static int ath10k_monitor_start(struct ath10k
*ar
)
1012 lockdep_assert_held(&ar
->conf_mutex
);
1014 ret
= ath10k_monitor_vdev_create(ar
);
1016 ath10k_warn(ar
, "failed to create monitor vdev: %d\n", ret
);
1020 ret
= ath10k_monitor_vdev_start(ar
, ar
->monitor_vdev_id
);
1022 ath10k_warn(ar
, "failed to start monitor vdev: %d\n", ret
);
1023 ath10k_monitor_vdev_delete(ar
);
1027 ar
->monitor_started
= true;
1028 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor started\n");
1033 static int ath10k_monitor_stop(struct ath10k
*ar
)
1037 lockdep_assert_held(&ar
->conf_mutex
);
1039 ret
= ath10k_monitor_vdev_stop(ar
);
1041 ath10k_warn(ar
, "failed to stop monitor vdev: %d\n", ret
);
1045 ret
= ath10k_monitor_vdev_delete(ar
);
1047 ath10k_warn(ar
, "failed to delete monitor vdev: %d\n", ret
);
1051 ar
->monitor_started
= false;
1052 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor stopped\n");
1057 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k
*ar
)
1061 /* At least one chanctx is required to derive a channel to start
1064 num_ctx
= ath10k_mac_num_chanctxs(ar
);
1068 /* If there's already an existing special monitor interface then don't
1069 * bother creating another monitor vdev.
1071 if (ar
->monitor_arvif
)
1074 return ar
->monitor
||
1075 ar
->filter_flags
& FIF_OTHER_BSS
||
1076 test_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
1079 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k
*ar
)
1083 num_ctx
= ath10k_mac_num_chanctxs(ar
);
1085 /* FIXME: Current interface combinations and cfg80211/mac80211 code
1086 * shouldn't allow this but make sure to prevent handling the following
1087 * case anyway since multi-channel DFS hasn't been tested at all.
1089 if (test_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
) && num_ctx
> 1)
1095 static int ath10k_monitor_recalc(struct ath10k
*ar
)
1101 lockdep_assert_held(&ar
->conf_mutex
);
1103 needed
= ath10k_mac_monitor_vdev_is_needed(ar
);
1104 allowed
= ath10k_mac_monitor_vdev_is_allowed(ar
);
1106 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
1107 "mac monitor recalc started? %d needed? %d allowed? %d\n",
1108 ar
->monitor_started
, needed
, allowed
);
1110 if (WARN_ON(needed
&& !allowed
)) {
1111 if (ar
->monitor_started
) {
1112 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac monitor stopping disallowed monitor\n");
1114 ret
= ath10k_monitor_stop(ar
);
1116 ath10k_warn(ar
, "failed to stop disallowed monitor: %d\n",
1124 if (needed
== ar
->monitor_started
)
1128 return ath10k_monitor_start(ar
);
1130 return ath10k_monitor_stop(ar
);
1133 static int ath10k_recalc_rtscts_prot(struct ath10k_vif
*arvif
)
1135 struct ath10k
*ar
= arvif
->ar
;
1136 u32 vdev_param
, rts_cts
= 0;
1138 lockdep_assert_held(&ar
->conf_mutex
);
1140 vdev_param
= ar
->wmi
.vdev_param
->enable_rtscts
;
1142 rts_cts
|= SM(WMI_RTSCTS_ENABLED
, WMI_RTSCTS_SET
);
1144 if (arvif
->num_legacy_stations
> 0)
1145 rts_cts
|= SM(WMI_RTSCTS_ACROSS_SW_RETRIES
,
1146 WMI_RTSCTS_PROFILE
);
1148 rts_cts
|= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES
,
1149 WMI_RTSCTS_PROFILE
);
1151 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
1155 static int ath10k_start_cac(struct ath10k
*ar
)
1159 lockdep_assert_held(&ar
->conf_mutex
);
1161 set_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
1163 ret
= ath10k_monitor_recalc(ar
);
1165 ath10k_warn(ar
, "failed to start monitor (cac): %d\n", ret
);
1166 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
1170 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac cac start monitor vdev %d\n",
1171 ar
->monitor_vdev_id
);
1176 static int ath10k_stop_cac(struct ath10k
*ar
)
1178 lockdep_assert_held(&ar
->conf_mutex
);
1180 /* CAC is not running - do nothing */
1181 if (!test_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
))
1184 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
1185 ath10k_monitor_stop(ar
);
1187 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac cac finished\n");
1192 static void ath10k_mac_has_radar_iter(struct ieee80211_hw
*hw
,
1193 struct ieee80211_chanctx_conf
*conf
,
1198 if (!*ret
&& conf
->radar_enabled
)
1202 static bool ath10k_mac_has_radar_enabled(struct ath10k
*ar
)
1204 bool has_radar
= false;
1206 ieee80211_iter_chan_contexts_atomic(ar
->hw
,
1207 ath10k_mac_has_radar_iter
,
1213 static void ath10k_recalc_radar_detection(struct ath10k
*ar
)
1217 lockdep_assert_held(&ar
->conf_mutex
);
1219 ath10k_stop_cac(ar
);
1221 if (!ath10k_mac_has_radar_enabled(ar
))
1224 if (ar
->num_started_vdevs
> 0)
1227 ret
= ath10k_start_cac(ar
);
1230 * Not possible to start CAC on current channel so starting
1231 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1232 * by indicating that radar was detected.
1234 ath10k_warn(ar
, "failed to start CAC: %d\n", ret
);
1235 ieee80211_radar_detected(ar
->hw
);
1239 static int ath10k_vdev_stop(struct ath10k_vif
*arvif
)
1241 struct ath10k
*ar
= arvif
->ar
;
1244 lockdep_assert_held(&ar
->conf_mutex
);
1246 reinit_completion(&ar
->vdev_setup_done
);
1248 ret
= ath10k_wmi_vdev_stop(ar
, arvif
->vdev_id
);
1250 ath10k_warn(ar
, "failed to stop WMI vdev %i: %d\n",
1251 arvif
->vdev_id
, ret
);
1255 ret
= ath10k_vdev_setup_sync(ar
);
1257 ath10k_warn(ar
, "failed to syncronise setup for vdev %i: %d\n",
1258 arvif
->vdev_id
, ret
);
1262 WARN_ON(ar
->num_started_vdevs
== 0);
1264 if (ar
->num_started_vdevs
!= 0) {
1265 ar
->num_started_vdevs
--;
1266 ath10k_recalc_radar_detection(ar
);
1272 static int ath10k_vdev_start_restart(struct ath10k_vif
*arvif
,
1273 const struct cfg80211_chan_def
*chandef
,
1276 struct ath10k
*ar
= arvif
->ar
;
1277 struct wmi_vdev_start_request_arg arg
= {};
1280 lockdep_assert_held(&ar
->conf_mutex
);
1282 reinit_completion(&ar
->vdev_setup_done
);
1284 arg
.vdev_id
= arvif
->vdev_id
;
1285 arg
.dtim_period
= arvif
->dtim_period
;
1286 arg
.bcn_intval
= arvif
->beacon_interval
;
1288 arg
.channel
.freq
= chandef
->chan
->center_freq
;
1289 arg
.channel
.band_center_freq1
= chandef
->center_freq1
;
1290 arg
.channel
.mode
= chan_to_phymode(chandef
);
1292 arg
.channel
.min_power
= 0;
1293 arg
.channel
.max_power
= chandef
->chan
->max_power
* 2;
1294 arg
.channel
.max_reg_power
= chandef
->chan
->max_reg_power
* 2;
1295 arg
.channel
.max_antenna_gain
= chandef
->chan
->max_antenna_gain
* 2;
1297 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
) {
1298 arg
.ssid
= arvif
->u
.ap
.ssid
;
1299 arg
.ssid_len
= arvif
->u
.ap
.ssid_len
;
1300 arg
.hidden_ssid
= arvif
->u
.ap
.hidden_ssid
;
1302 /* For now allow DFS for AP mode */
1303 arg
.channel
.chan_radar
=
1304 !!(chandef
->chan
->flags
& IEEE80211_CHAN_RADAR
);
1305 } else if (arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
) {
1306 arg
.ssid
= arvif
->vif
->bss_conf
.ssid
;
1307 arg
.ssid_len
= arvif
->vif
->bss_conf
.ssid_len
;
1310 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
1311 "mac vdev %d start center_freq %d phymode %s\n",
1312 arg
.vdev_id
, arg
.channel
.freq
,
1313 ath10k_wmi_phymode_str(arg
.channel
.mode
));
1316 ret
= ath10k_wmi_vdev_restart(ar
, &arg
);
1318 ret
= ath10k_wmi_vdev_start(ar
, &arg
);
1321 ath10k_warn(ar
, "failed to start WMI vdev %i: %d\n",
1326 ret
= ath10k_vdev_setup_sync(ar
);
1329 "failed to synchronize setup for vdev %i restart %d: %d\n",
1330 arg
.vdev_id
, restart
, ret
);
1334 ar
->num_started_vdevs
++;
1335 ath10k_recalc_radar_detection(ar
);
1340 static int ath10k_vdev_start(struct ath10k_vif
*arvif
,
1341 const struct cfg80211_chan_def
*def
)
1343 return ath10k_vdev_start_restart(arvif
, def
, false);
1346 static int ath10k_vdev_restart(struct ath10k_vif
*arvif
,
1347 const struct cfg80211_chan_def
*def
)
1349 return ath10k_vdev_start_restart(arvif
, def
, true);
1352 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif
*arvif
,
1353 struct sk_buff
*bcn
)
1355 struct ath10k
*ar
= arvif
->ar
;
1356 struct ieee80211_mgmt
*mgmt
;
1360 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
)
1363 if (arvif
->vdev_subtype
!= WMI_VDEV_SUBTYPE_P2P_GO
)
1366 mgmt
= (void *)bcn
->data
;
1367 p2p_ie
= cfg80211_find_vendor_ie(WLAN_OUI_WFA
, WLAN_OUI_TYPE_WFA_P2P
,
1368 mgmt
->u
.beacon
.variable
,
1369 bcn
->len
- (mgmt
->u
.beacon
.variable
-
1374 ret
= ath10k_wmi_p2p_go_bcn_ie(ar
, arvif
->vdev_id
, p2p_ie
);
1376 ath10k_warn(ar
, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1377 arvif
->vdev_id
, ret
);
1384 static int ath10k_mac_remove_vendor_ie(struct sk_buff
*skb
, unsigned int oui
,
1385 u8 oui_type
, size_t ie_offset
)
1392 if (WARN_ON(skb
->len
< ie_offset
))
1395 ie
= (u8
*)cfg80211_find_vendor_ie(oui
, oui_type
,
1396 skb
->data
+ ie_offset
,
1397 skb
->len
- ie_offset
);
1402 end
= skb
->data
+ skb
->len
;
1405 if (WARN_ON(next
> end
))
1408 memmove(ie
, next
, end
- next
);
1409 skb_trim(skb
, skb
->len
- len
);
1414 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif
*arvif
)
1416 struct ath10k
*ar
= arvif
->ar
;
1417 struct ieee80211_hw
*hw
= ar
->hw
;
1418 struct ieee80211_vif
*vif
= arvif
->vif
;
1419 struct ieee80211_mutable_offsets offs
= {};
1420 struct sk_buff
*bcn
;
1423 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD
, ar
->wmi
.svc_map
))
1426 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
&&
1427 arvif
->vdev_type
!= WMI_VDEV_TYPE_IBSS
)
1430 bcn
= ieee80211_beacon_get_template(hw
, vif
, &offs
);
1432 ath10k_warn(ar
, "failed to get beacon template from mac80211\n");
1436 ret
= ath10k_mac_setup_bcn_p2p_ie(arvif
, bcn
);
1438 ath10k_warn(ar
, "failed to setup p2p go bcn ie: %d\n", ret
);
1443 /* P2P IE is inserted by firmware automatically (as configured above)
1444 * so remove it from the base beacon template to avoid duplicate P2P
1445 * IEs in beacon frames.
1447 ath10k_mac_remove_vendor_ie(bcn
, WLAN_OUI_WFA
, WLAN_OUI_TYPE_WFA_P2P
,
1448 offsetof(struct ieee80211_mgmt
,
1449 u
.beacon
.variable
));
1451 ret
= ath10k_wmi_bcn_tmpl(ar
, arvif
->vdev_id
, offs
.tim_offset
, bcn
, 0,
1456 ath10k_warn(ar
, "failed to submit beacon template command: %d\n",
1464 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif
*arvif
)
1466 struct ath10k
*ar
= arvif
->ar
;
1467 struct ieee80211_hw
*hw
= ar
->hw
;
1468 struct ieee80211_vif
*vif
= arvif
->vif
;
1469 struct sk_buff
*prb
;
1472 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD
, ar
->wmi
.svc_map
))
1475 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
)
1478 prb
= ieee80211_proberesp_get(hw
, vif
);
1480 ath10k_warn(ar
, "failed to get probe resp template from mac80211\n");
1484 ret
= ath10k_wmi_prb_tmpl(ar
, arvif
->vdev_id
, prb
);
1488 ath10k_warn(ar
, "failed to submit probe resp template command: %d\n",
1496 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif
*arvif
)
1498 struct ath10k
*ar
= arvif
->ar
;
1499 struct cfg80211_chan_def def
;
1502 /* When originally vdev is started during assign_vif_chanctx() some
1503 * information is missing, notably SSID. Firmware revisions with beacon
1504 * offloading require the SSID to be provided during vdev (re)start to
1505 * handle hidden SSID properly.
1507 * Vdev restart must be done after vdev has been both started and
1508 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1509 * deliver vdev restart response event causing timeouts during vdev
1510 * syncing in ath10k.
1512 * Note: The vdev down/up and template reinstallation could be skipped
1513 * since only wmi-tlv firmware are known to have beacon offload and
1514 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1515 * response delivery. It's probably more robust to keep it as is.
1517 if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD
, ar
->wmi
.svc_map
))
1520 if (WARN_ON(!arvif
->is_started
))
1523 if (WARN_ON(!arvif
->is_up
))
1526 if (WARN_ON(ath10k_mac_vif_chan(arvif
->vif
, &def
)))
1529 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
1531 ath10k_warn(ar
, "failed to bring down ap vdev %i: %d\n",
1532 arvif
->vdev_id
, ret
);
1536 /* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1537 * firmware will crash upon vdev up.
1540 ret
= ath10k_mac_setup_bcn_tmpl(arvif
);
1542 ath10k_warn(ar
, "failed to update beacon template: %d\n", ret
);
1546 ret
= ath10k_mac_setup_prb_tmpl(arvif
);
1548 ath10k_warn(ar
, "failed to update presp template: %d\n", ret
);
1552 ret
= ath10k_vdev_restart(arvif
, &def
);
1554 ath10k_warn(ar
, "failed to restart ap vdev %i: %d\n",
1555 arvif
->vdev_id
, ret
);
1559 ret
= ath10k_wmi_vdev_up(arvif
->ar
, arvif
->vdev_id
, arvif
->aid
,
1562 ath10k_warn(ar
, "failed to bring up ap vdev %i: %d\n",
1563 arvif
->vdev_id
, ret
);
1570 static void ath10k_control_beaconing(struct ath10k_vif
*arvif
,
1571 struct ieee80211_bss_conf
*info
)
1573 struct ath10k
*ar
= arvif
->ar
;
1576 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1578 if (!info
->enable_beacon
) {
1579 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
1581 ath10k_warn(ar
, "failed to down vdev_id %i: %d\n",
1582 arvif
->vdev_id
, ret
);
1584 arvif
->is_up
= false;
1586 spin_lock_bh(&arvif
->ar
->data_lock
);
1587 ath10k_mac_vif_beacon_free(arvif
);
1588 spin_unlock_bh(&arvif
->ar
->data_lock
);
1593 arvif
->tx_seq_no
= 0x1000;
1596 ether_addr_copy(arvif
->bssid
, info
->bssid
);
1598 ret
= ath10k_wmi_vdev_up(arvif
->ar
, arvif
->vdev_id
, arvif
->aid
,
1601 ath10k_warn(ar
, "failed to bring up vdev %d: %i\n",
1602 arvif
->vdev_id
, ret
);
1606 arvif
->is_up
= true;
1608 ret
= ath10k_mac_vif_fix_hidden_ssid(arvif
);
1610 ath10k_warn(ar
, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1611 arvif
->vdev_id
, ret
);
1615 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d up\n", arvif
->vdev_id
);
1618 static void ath10k_control_ibss(struct ath10k_vif
*arvif
,
1619 struct ieee80211_bss_conf
*info
,
1620 const u8 self_peer
[ETH_ALEN
])
1622 struct ath10k
*ar
= arvif
->ar
;
1626 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1628 if (!info
->ibss_joined
) {
1629 if (is_zero_ether_addr(arvif
->bssid
))
1632 eth_zero_addr(arvif
->bssid
);
1637 vdev_param
= arvif
->ar
->wmi
.vdev_param
->atim_window
;
1638 ret
= ath10k_wmi_vdev_set_param(arvif
->ar
, arvif
->vdev_id
, vdev_param
,
1639 ATH10K_DEFAULT_ATIM
);
1641 ath10k_warn(ar
, "failed to set IBSS ATIM for vdev %d: %d\n",
1642 arvif
->vdev_id
, ret
);
1645 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif
*arvif
)
1647 struct ath10k
*ar
= arvif
->ar
;
1652 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1654 if (arvif
->u
.sta
.uapsd
)
1655 value
= WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER
;
1657 value
= WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS
;
1659 param
= WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD
;
1660 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
, param
, value
);
1662 ath10k_warn(ar
, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1663 value
, arvif
->vdev_id
, ret
);
1670 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif
*arvif
)
1672 struct ath10k
*ar
= arvif
->ar
;
1677 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1679 if (arvif
->u
.sta
.uapsd
)
1680 value
= WMI_STA_PS_PSPOLL_COUNT_UAPSD
;
1682 value
= WMI_STA_PS_PSPOLL_COUNT_NO_MAX
;
1684 param
= WMI_STA_PS_PARAM_PSPOLL_COUNT
;
1685 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
1688 ath10k_warn(ar
, "failed to submit ps poll count %u on vdev %i: %d\n",
1689 value
, arvif
->vdev_id
, ret
);
1696 static int ath10k_mac_num_vifs_started(struct ath10k
*ar
)
1698 struct ath10k_vif
*arvif
;
1701 lockdep_assert_held(&ar
->conf_mutex
);
1703 list_for_each_entry(arvif
, &ar
->arvifs
, list
)
1704 if (arvif
->is_started
)
1710 static int ath10k_mac_vif_setup_ps(struct ath10k_vif
*arvif
)
1712 struct ath10k
*ar
= arvif
->ar
;
1713 struct ieee80211_vif
*vif
= arvif
->vif
;
1714 struct ieee80211_conf
*conf
= &ar
->hw
->conf
;
1715 enum wmi_sta_powersave_param param
;
1716 enum wmi_sta_ps_mode psmode
;
1721 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1723 if (arvif
->vif
->type
!= NL80211_IFTYPE_STATION
)
1726 enable_ps
= arvif
->ps
;
1728 if (enable_ps
&& ath10k_mac_num_vifs_started(ar
) > 1 &&
1729 !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT
,
1731 ath10k_warn(ar
, "refusing to enable ps on vdev %i: not supported by fw\n",
1736 if (!arvif
->is_started
) {
1737 /* mac80211 can update vif powersave state while disconnected.
1738 * Firmware doesn't behave nicely and consumes more power than
1739 * necessary if PS is disabled on a non-started vdev. Hence
1740 * force-enable PS for non-running vdevs.
1742 psmode
= WMI_STA_PS_MODE_ENABLED
;
1743 } else if (enable_ps
) {
1744 psmode
= WMI_STA_PS_MODE_ENABLED
;
1745 param
= WMI_STA_PS_PARAM_INACTIVITY_TIME
;
1747 ps_timeout
= conf
->dynamic_ps_timeout
;
1748 if (ps_timeout
== 0) {
1749 /* Firmware doesn't like 0 */
1750 ps_timeout
= ieee80211_tu_to_usec(
1751 vif
->bss_conf
.beacon_int
) / 1000;
1754 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
, param
,
1757 ath10k_warn(ar
, "failed to set inactivity time for vdev %d: %i\n",
1758 arvif
->vdev_id
, ret
);
1762 psmode
= WMI_STA_PS_MODE_DISABLED
;
1765 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d psmode %s\n",
1766 arvif
->vdev_id
, psmode
? "enable" : "disable");
1768 ret
= ath10k_wmi_set_psmode(ar
, arvif
->vdev_id
, psmode
);
1770 ath10k_warn(ar
, "failed to set PS Mode %d for vdev %d: %d\n",
1771 psmode
, arvif
->vdev_id
, ret
);
1778 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif
*arvif
)
1780 struct ath10k
*ar
= arvif
->ar
;
1781 struct wmi_sta_keepalive_arg arg
= {};
1784 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1786 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_STA
)
1789 if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE
, ar
->wmi
.svc_map
))
1792 /* Some firmware revisions have a bug and ignore the `enabled` field.
1793 * Instead use the interval to disable the keepalive.
1795 arg
.vdev_id
= arvif
->vdev_id
;
1797 arg
.method
= WMI_STA_KEEPALIVE_METHOD_NULL_FRAME
;
1798 arg
.interval
= WMI_STA_KEEPALIVE_INTERVAL_DISABLE
;
1800 ret
= ath10k_wmi_sta_keepalive(ar
, &arg
);
1802 ath10k_warn(ar
, "failed to submit keepalive on vdev %i: %d\n",
1803 arvif
->vdev_id
, ret
);
1810 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif
*arvif
)
1812 struct ath10k
*ar
= arvif
->ar
;
1813 struct ieee80211_vif
*vif
= arvif
->vif
;
1816 lockdep_assert_held(&arvif
->ar
->conf_mutex
);
1818 if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD
, ar
->wmi
.svc_map
)))
1821 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
)
1824 if (!vif
->csa_active
)
1830 if (!ieee80211_csa_is_complete(vif
)) {
1831 ieee80211_csa_update_counter(vif
);
1833 ret
= ath10k_mac_setup_bcn_tmpl(arvif
);
1835 ath10k_warn(ar
, "failed to update bcn tmpl during csa: %d\n",
1838 ret
= ath10k_mac_setup_prb_tmpl(arvif
);
1840 ath10k_warn(ar
, "failed to update prb tmpl during csa: %d\n",
1843 ieee80211_csa_finish(vif
);
1847 static void ath10k_mac_vif_ap_csa_work(struct work_struct
*work
)
1849 struct ath10k_vif
*arvif
= container_of(work
, struct ath10k_vif
,
1851 struct ath10k
*ar
= arvif
->ar
;
1853 mutex_lock(&ar
->conf_mutex
);
1854 ath10k_mac_vif_ap_csa_count_down(arvif
);
1855 mutex_unlock(&ar
->conf_mutex
);
1858 static void ath10k_mac_handle_beacon_iter(void *data
, u8
*mac
,
1859 struct ieee80211_vif
*vif
)
1861 struct sk_buff
*skb
= data
;
1862 struct ieee80211_mgmt
*mgmt
= (void *)skb
->data
;
1863 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1865 if (vif
->type
!= NL80211_IFTYPE_STATION
)
1868 if (!ether_addr_equal(mgmt
->bssid
, vif
->bss_conf
.bssid
))
1871 cancel_delayed_work(&arvif
->connection_loss_work
);
1874 void ath10k_mac_handle_beacon(struct ath10k
*ar
, struct sk_buff
*skb
)
1876 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
1877 IEEE80211_IFACE_ITER_NORMAL
,
1878 ath10k_mac_handle_beacon_iter
,
1882 static void ath10k_mac_handle_beacon_miss_iter(void *data
, u8
*mac
,
1883 struct ieee80211_vif
*vif
)
1885 u32
*vdev_id
= data
;
1886 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1887 struct ath10k
*ar
= arvif
->ar
;
1888 struct ieee80211_hw
*hw
= ar
->hw
;
1890 if (arvif
->vdev_id
!= *vdev_id
)
1896 ieee80211_beacon_loss(vif
);
1898 /* Firmware doesn't report beacon loss events repeatedly. If AP probe
1899 * (done by mac80211) succeeds but beacons do not resume then it
1900 * doesn't make sense to continue operation. Queue connection loss work
1901 * which can be cancelled when beacon is received.
1903 ieee80211_queue_delayed_work(hw
, &arvif
->connection_loss_work
,
1904 ATH10K_CONNECTION_LOSS_HZ
);
1907 void ath10k_mac_handle_beacon_miss(struct ath10k
*ar
, u32 vdev_id
)
1909 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
1910 IEEE80211_IFACE_ITER_NORMAL
,
1911 ath10k_mac_handle_beacon_miss_iter
,
1915 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct
*work
)
1917 struct ath10k_vif
*arvif
= container_of(work
, struct ath10k_vif
,
1918 connection_loss_work
.work
);
1919 struct ieee80211_vif
*vif
= arvif
->vif
;
1924 ieee80211_connection_loss(vif
);
1927 /**********************/
1928 /* Station management */
1929 /**********************/
1931 static u32
ath10k_peer_assoc_h_listen_intval(struct ath10k
*ar
,
1932 struct ieee80211_vif
*vif
)
1934 /* Some firmware revisions have unstable STA powersave when listen
1935 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
1936 * generate NullFunc frames properly even if buffered frames have been
1937 * indicated in Beacon TIM. Firmware would seldom wake up to pull
1938 * buffered frames. Often pinging the device from AP would simply fail.
1940 * As a workaround set it to 1.
1942 if (vif
->type
== NL80211_IFTYPE_STATION
)
1945 return ar
->hw
->conf
.listen_interval
;
1948 static void ath10k_peer_assoc_h_basic(struct ath10k
*ar
,
1949 struct ieee80211_vif
*vif
,
1950 struct ieee80211_sta
*sta
,
1951 struct wmi_peer_assoc_complete_arg
*arg
)
1953 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
1956 lockdep_assert_held(&ar
->conf_mutex
);
1958 if (vif
->type
== NL80211_IFTYPE_STATION
)
1959 aid
= vif
->bss_conf
.aid
;
1963 ether_addr_copy(arg
->addr
, sta
->addr
);
1964 arg
->vdev_id
= arvif
->vdev_id
;
1965 arg
->peer_aid
= aid
;
1966 arg
->peer_flags
|= arvif
->ar
->wmi
.peer_flags
->auth
;
1967 arg
->peer_listen_intval
= ath10k_peer_assoc_h_listen_intval(ar
, vif
);
1968 arg
->peer_num_spatial_streams
= 1;
1969 arg
->peer_caps
= vif
->bss_conf
.assoc_capability
;
1972 static void ath10k_peer_assoc_h_crypto(struct ath10k
*ar
,
1973 struct ieee80211_vif
*vif
,
1974 struct ieee80211_sta
*sta
,
1975 struct wmi_peer_assoc_complete_arg
*arg
)
1977 struct ieee80211_bss_conf
*info
= &vif
->bss_conf
;
1978 struct cfg80211_chan_def def
;
1979 struct cfg80211_bss
*bss
;
1980 const u8
*rsnie
= NULL
;
1981 const u8
*wpaie
= NULL
;
1983 lockdep_assert_held(&ar
->conf_mutex
);
1985 if (WARN_ON(ath10k_mac_vif_chan(vif
, &def
)))
1988 bss
= cfg80211_get_bss(ar
->hw
->wiphy
, def
.chan
, info
->bssid
, NULL
, 0,
1989 IEEE80211_BSS_TYPE_ANY
, IEEE80211_PRIVACY_ANY
);
1991 const struct cfg80211_bss_ies
*ies
;
1994 rsnie
= ieee80211_bss_get_ie(bss
, WLAN_EID_RSN
);
1996 ies
= rcu_dereference(bss
->ies
);
1998 wpaie
= cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT
,
1999 WLAN_OUI_TYPE_MICROSOFT_WPA
,
2003 cfg80211_put_bss(ar
->hw
->wiphy
, bss
);
2006 /* FIXME: base on RSN IE/WPA IE is a correct idea? */
2007 if (rsnie
|| wpaie
) {
2008 ath10k_dbg(ar
, ATH10K_DBG_WMI
, "%s: rsn ie found\n", __func__
);
2009 arg
->peer_flags
|= ar
->wmi
.peer_flags
->need_ptk_4_way
;
2013 ath10k_dbg(ar
, ATH10K_DBG_WMI
, "%s: wpa ie found\n", __func__
);
2014 arg
->peer_flags
|= ar
->wmi
.peer_flags
->need_gtk_2_way
;
2018 test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT
, ar
->fw_features
)) {
2019 arg
->peer_flags
|= ar
->wmi
.peer_flags
->pmf
;
2023 static void ath10k_peer_assoc_h_rates(struct ath10k
*ar
,
2024 struct ieee80211_vif
*vif
,
2025 struct ieee80211_sta
*sta
,
2026 struct wmi_peer_assoc_complete_arg
*arg
)
2028 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2029 struct wmi_rate_set_arg
*rateset
= &arg
->peer_legacy_rates
;
2030 struct cfg80211_chan_def def
;
2031 const struct ieee80211_supported_band
*sband
;
2032 const struct ieee80211_rate
*rates
;
2033 enum ieee80211_band band
;
2038 lockdep_assert_held(&ar
->conf_mutex
);
2040 if (WARN_ON(ath10k_mac_vif_chan(vif
, &def
)))
2043 band
= def
.chan
->band
;
2044 sband
= ar
->hw
->wiphy
->bands
[band
];
2045 ratemask
= sta
->supp_rates
[band
];
2046 ratemask
&= arvif
->bitrate_mask
.control
[band
].legacy
;
2047 rates
= sband
->bitrates
;
2049 rateset
->num_rates
= 0;
2051 for (i
= 0; i
< 32; i
++, ratemask
>>= 1, rates
++) {
2052 if (!(ratemask
& 1))
2055 rate
= ath10k_mac_bitrate_to_rate(rates
->bitrate
);
2056 rateset
->rates
[rateset
->num_rates
] = rate
;
2057 rateset
->num_rates
++;
2062 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask
[IEEE80211_HT_MCS_MASK_LEN
])
2066 for (nss
= 0; nss
< IEEE80211_HT_MCS_MASK_LEN
; nss
++)
2067 if (ht_mcs_mask
[nss
])
2074 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask
[NL80211_VHT_NSS_MAX
])
2078 for (nss
= 0; nss
< NL80211_VHT_NSS_MAX
; nss
++)
2079 if (vht_mcs_mask
[nss
])
2085 static void ath10k_peer_assoc_h_ht(struct ath10k
*ar
,
2086 struct ieee80211_vif
*vif
,
2087 struct ieee80211_sta
*sta
,
2088 struct wmi_peer_assoc_complete_arg
*arg
)
2090 const struct ieee80211_sta_ht_cap
*ht_cap
= &sta
->ht_cap
;
2091 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2092 struct cfg80211_chan_def def
;
2093 enum ieee80211_band band
;
2094 const u8
*ht_mcs_mask
;
2095 const u16
*vht_mcs_mask
;
2100 lockdep_assert_held(&ar
->conf_mutex
);
2102 if (WARN_ON(ath10k_mac_vif_chan(vif
, &def
)))
2105 if (!ht_cap
->ht_supported
)
2108 band
= def
.chan
->band
;
2109 ht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].ht_mcs
;
2110 vht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].vht_mcs
;
2112 if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask
) &&
2113 ath10k_peer_assoc_h_vht_masked(vht_mcs_mask
))
2116 arg
->peer_flags
|= ar
->wmi
.peer_flags
->ht
;
2117 arg
->peer_max_mpdu
= (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR
+
2118 ht_cap
->ampdu_factor
)) - 1;
2120 arg
->peer_mpdu_density
=
2121 ath10k_parse_mpdudensity(ht_cap
->ampdu_density
);
2123 arg
->peer_ht_caps
= ht_cap
->cap
;
2124 arg
->peer_rate_caps
|= WMI_RC_HT_FLAG
;
2126 if (ht_cap
->cap
& IEEE80211_HT_CAP_LDPC_CODING
)
2127 arg
->peer_flags
|= ar
->wmi
.peer_flags
->ldbc
;
2129 if (sta
->bandwidth
>= IEEE80211_STA_RX_BW_40
) {
2130 arg
->peer_flags
|= ar
->wmi
.peer_flags
->bw40
;
2131 arg
->peer_rate_caps
|= WMI_RC_CW40_FLAG
;
2134 if (arvif
->bitrate_mask
.control
[band
].gi
!= NL80211_TXRATE_FORCE_LGI
) {
2135 if (ht_cap
->cap
& IEEE80211_HT_CAP_SGI_20
)
2136 arg
->peer_rate_caps
|= WMI_RC_SGI_FLAG
;
2138 if (ht_cap
->cap
& IEEE80211_HT_CAP_SGI_40
)
2139 arg
->peer_rate_caps
|= WMI_RC_SGI_FLAG
;
2142 if (ht_cap
->cap
& IEEE80211_HT_CAP_TX_STBC
) {
2143 arg
->peer_rate_caps
|= WMI_RC_TX_STBC_FLAG
;
2144 arg
->peer_flags
|= ar
->wmi
.peer_flags
->stbc
;
2147 if (ht_cap
->cap
& IEEE80211_HT_CAP_RX_STBC
) {
2148 stbc
= ht_cap
->cap
& IEEE80211_HT_CAP_RX_STBC
;
2149 stbc
= stbc
>> IEEE80211_HT_CAP_RX_STBC_SHIFT
;
2150 stbc
= stbc
<< WMI_RC_RX_STBC_FLAG_S
;
2151 arg
->peer_rate_caps
|= stbc
;
2152 arg
->peer_flags
|= ar
->wmi
.peer_flags
->stbc
;
2155 if (ht_cap
->mcs
.rx_mask
[1] && ht_cap
->mcs
.rx_mask
[2])
2156 arg
->peer_rate_caps
|= WMI_RC_TS_FLAG
;
2157 else if (ht_cap
->mcs
.rx_mask
[1])
2158 arg
->peer_rate_caps
|= WMI_RC_DS_FLAG
;
2160 for (i
= 0, n
= 0, max_nss
= 0; i
< IEEE80211_HT_MCS_MASK_LEN
* 8; i
++)
2161 if ((ht_cap
->mcs
.rx_mask
[i
/ 8] & BIT(i
% 8)) &&
2162 (ht_mcs_mask
[i
/ 8] & BIT(i
% 8))) {
2163 max_nss
= (i
/ 8) + 1;
2164 arg
->peer_ht_rates
.rates
[n
++] = i
;
2168 * This is a workaround for HT-enabled STAs which break the spec
2169 * and have no HT capabilities RX mask (no HT RX MCS map).
2171 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2172 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2174 * Firmware asserts if such situation occurs.
2177 arg
->peer_ht_rates
.num_rates
= 8;
2178 for (i
= 0; i
< arg
->peer_ht_rates
.num_rates
; i
++)
2179 arg
->peer_ht_rates
.rates
[i
] = i
;
2181 arg
->peer_ht_rates
.num_rates
= n
;
2182 arg
->peer_num_spatial_streams
= min(sta
->rx_nss
, max_nss
);
2185 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac ht peer %pM mcs cnt %d nss %d\n",
2187 arg
->peer_ht_rates
.num_rates
,
2188 arg
->peer_num_spatial_streams
);
2191 static int ath10k_peer_assoc_qos_ap(struct ath10k
*ar
,
2192 struct ath10k_vif
*arvif
,
2193 struct ieee80211_sta
*sta
)
2199 lockdep_assert_held(&ar
->conf_mutex
);
2201 if (sta
->wme
&& sta
->uapsd_queues
) {
2202 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac uapsd_queues 0x%x max_sp %d\n",
2203 sta
->uapsd_queues
, sta
->max_sp
);
2205 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_VO
)
2206 uapsd
|= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN
|
2207 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN
;
2208 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_VI
)
2209 uapsd
|= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN
|
2210 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN
;
2211 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
)
2212 uapsd
|= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN
|
2213 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN
;
2214 if (sta
->uapsd_queues
& IEEE80211_WMM_IE_STA_QOSINFO_AC_BE
)
2215 uapsd
|= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN
|
2216 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN
;
2218 if (sta
->max_sp
< MAX_WMI_AP_PS_PEER_PARAM_MAX_SP
)
2219 max_sp
= sta
->max_sp
;
2221 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
,
2223 WMI_AP_PS_PEER_PARAM_UAPSD
,
2226 ath10k_warn(ar
, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2227 arvif
->vdev_id
, ret
);
2231 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
,
2233 WMI_AP_PS_PEER_PARAM_MAX_SP
,
2236 ath10k_warn(ar
, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2237 arvif
->vdev_id
, ret
);
2241 /* TODO setup this based on STA listen interval and
2242 beacon interval. Currently we don't know
2243 sta->listen_interval - mac80211 patch required.
2244 Currently use 10 seconds */
2245 ret
= ath10k_wmi_set_ap_ps_param(ar
, arvif
->vdev_id
, sta
->addr
,
2246 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME
,
2249 ath10k_warn(ar
, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2250 arvif
->vdev_id
, ret
);
2259 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set
,
2260 const u16 vht_mcs_limit
[NL80211_VHT_NSS_MAX
])
2267 for (nss
= 0; nss
< NL80211_VHT_NSS_MAX
; nss
++) {
2268 mcs_map
= ath10k_mac_get_max_vht_mcs_map(tx_mcs_set
, nss
) &
2272 idx_limit
= fls(mcs_map
) - 1;
2276 switch (idx_limit
) {
2277 case 0: /* fall through */
2278 case 1: /* fall through */
2279 case 2: /* fall through */
2280 case 3: /* fall through */
2281 case 4: /* fall through */
2282 case 5: /* fall through */
2283 case 6: /* fall through */
2285 /* see ath10k_mac_can_set_bitrate_mask() */
2289 mcs
= IEEE80211_VHT_MCS_NOT_SUPPORTED
;
2292 mcs
= IEEE80211_VHT_MCS_SUPPORT_0_7
;
2295 mcs
= IEEE80211_VHT_MCS_SUPPORT_0_8
;
2298 mcs
= IEEE80211_VHT_MCS_SUPPORT_0_9
;
2302 tx_mcs_set
&= ~(0x3 << (nss
* 2));
2303 tx_mcs_set
|= mcs
<< (nss
* 2);
2309 static void ath10k_peer_assoc_h_vht(struct ath10k
*ar
,
2310 struct ieee80211_vif
*vif
,
2311 struct ieee80211_sta
*sta
,
2312 struct wmi_peer_assoc_complete_arg
*arg
)
2314 const struct ieee80211_sta_vht_cap
*vht_cap
= &sta
->vht_cap
;
2315 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2316 struct cfg80211_chan_def def
;
2317 enum ieee80211_band band
;
2318 const u16
*vht_mcs_mask
;
2321 if (WARN_ON(ath10k_mac_vif_chan(vif
, &def
)))
2324 if (!vht_cap
->vht_supported
)
2327 band
= def
.chan
->band
;
2328 vht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].vht_mcs
;
2330 if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask
))
2333 arg
->peer_flags
|= ar
->wmi
.peer_flags
->vht
;
2335 if (def
.chan
->band
== IEEE80211_BAND_2GHZ
)
2336 arg
->peer_flags
|= ar
->wmi
.peer_flags
->vht_2g
;
2338 arg
->peer_vht_caps
= vht_cap
->cap
;
2340 ampdu_factor
= (vht_cap
->cap
&
2341 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK
) >>
2342 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT
;
2344 /* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2345 * zero in VHT IE. Using it would result in degraded throughput.
2346 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2347 * it if VHT max_mpdu is smaller. */
2348 arg
->peer_max_mpdu
= max(arg
->peer_max_mpdu
,
2349 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR
+
2350 ampdu_factor
)) - 1);
2352 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_80
)
2353 arg
->peer_flags
|= ar
->wmi
.peer_flags
->bw80
;
2355 arg
->peer_vht_rates
.rx_max_rate
=
2356 __le16_to_cpu(vht_cap
->vht_mcs
.rx_highest
);
2357 arg
->peer_vht_rates
.rx_mcs_set
=
2358 __le16_to_cpu(vht_cap
->vht_mcs
.rx_mcs_map
);
2359 arg
->peer_vht_rates
.tx_max_rate
=
2360 __le16_to_cpu(vht_cap
->vht_mcs
.tx_highest
);
2361 arg
->peer_vht_rates
.tx_mcs_set
= ath10k_peer_assoc_h_vht_limit(
2362 __le16_to_cpu(vht_cap
->vht_mcs
.tx_mcs_map
), vht_mcs_mask
);
2364 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vht peer %pM max_mpdu %d flags 0x%x\n",
2365 sta
->addr
, arg
->peer_max_mpdu
, arg
->peer_flags
);
2368 static void ath10k_peer_assoc_h_qos(struct ath10k
*ar
,
2369 struct ieee80211_vif
*vif
,
2370 struct ieee80211_sta
*sta
,
2371 struct wmi_peer_assoc_complete_arg
*arg
)
2373 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2375 switch (arvif
->vdev_type
) {
2376 case WMI_VDEV_TYPE_AP
:
2378 arg
->peer_flags
|= arvif
->ar
->wmi
.peer_flags
->qos
;
2380 if (sta
->wme
&& sta
->uapsd_queues
) {
2381 arg
->peer_flags
|= arvif
->ar
->wmi
.peer_flags
->apsd
;
2382 arg
->peer_rate_caps
|= WMI_RC_UAPSD_FLAG
;
2385 case WMI_VDEV_TYPE_STA
:
2386 if (vif
->bss_conf
.qos
)
2387 arg
->peer_flags
|= arvif
->ar
->wmi
.peer_flags
->qos
;
2389 case WMI_VDEV_TYPE_IBSS
:
2391 arg
->peer_flags
|= arvif
->ar
->wmi
.peer_flags
->qos
;
2397 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac peer %pM qos %d\n",
2398 sta
->addr
, !!(arg
->peer_flags
&
2399 arvif
->ar
->wmi
.peer_flags
->qos
));
2402 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta
*sta
)
2404 return sta
->supp_rates
[IEEE80211_BAND_2GHZ
] >>
2405 ATH10K_MAC_FIRST_OFDM_RATE_IDX
;
2408 static void ath10k_peer_assoc_h_phymode(struct ath10k
*ar
,
2409 struct ieee80211_vif
*vif
,
2410 struct ieee80211_sta
*sta
,
2411 struct wmi_peer_assoc_complete_arg
*arg
)
2413 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2414 struct cfg80211_chan_def def
;
2415 enum ieee80211_band band
;
2416 const u8
*ht_mcs_mask
;
2417 const u16
*vht_mcs_mask
;
2418 enum wmi_phy_mode phymode
= MODE_UNKNOWN
;
2420 if (WARN_ON(ath10k_mac_vif_chan(vif
, &def
)))
2423 band
= def
.chan
->band
;
2424 ht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].ht_mcs
;
2425 vht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].vht_mcs
;
2428 case IEEE80211_BAND_2GHZ
:
2429 if (sta
->vht_cap
.vht_supported
&&
2430 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask
)) {
2431 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
2432 phymode
= MODE_11AC_VHT40
;
2434 phymode
= MODE_11AC_VHT20
;
2435 } else if (sta
->ht_cap
.ht_supported
&&
2436 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask
)) {
2437 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
2438 phymode
= MODE_11NG_HT40
;
2440 phymode
= MODE_11NG_HT20
;
2441 } else if (ath10k_mac_sta_has_ofdm_only(sta
)) {
2448 case IEEE80211_BAND_5GHZ
:
2452 if (sta
->vht_cap
.vht_supported
&&
2453 !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask
)) {
2454 if (sta
->bandwidth
== IEEE80211_STA_RX_BW_80
)
2455 phymode
= MODE_11AC_VHT80
;
2456 else if (sta
->bandwidth
== IEEE80211_STA_RX_BW_40
)
2457 phymode
= MODE_11AC_VHT40
;
2458 else if (sta
->bandwidth
== IEEE80211_STA_RX_BW_20
)
2459 phymode
= MODE_11AC_VHT20
;
2460 } else if (sta
->ht_cap
.ht_supported
&&
2461 !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask
)) {
2462 if (sta
->bandwidth
>= IEEE80211_STA_RX_BW_40
)
2463 phymode
= MODE_11NA_HT40
;
2465 phymode
= MODE_11NA_HT20
;
2475 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac peer %pM phymode %s\n",
2476 sta
->addr
, ath10k_wmi_phymode_str(phymode
));
2478 arg
->peer_phymode
= phymode
;
2479 WARN_ON(phymode
== MODE_UNKNOWN
);
2482 static int ath10k_peer_assoc_prepare(struct ath10k
*ar
,
2483 struct ieee80211_vif
*vif
,
2484 struct ieee80211_sta
*sta
,
2485 struct wmi_peer_assoc_complete_arg
*arg
)
2487 lockdep_assert_held(&ar
->conf_mutex
);
2489 memset(arg
, 0, sizeof(*arg
));
2491 ath10k_peer_assoc_h_basic(ar
, vif
, sta
, arg
);
2492 ath10k_peer_assoc_h_crypto(ar
, vif
, sta
, arg
);
2493 ath10k_peer_assoc_h_rates(ar
, vif
, sta
, arg
);
2494 ath10k_peer_assoc_h_ht(ar
, vif
, sta
, arg
);
2495 ath10k_peer_assoc_h_vht(ar
, vif
, sta
, arg
);
2496 ath10k_peer_assoc_h_qos(ar
, vif
, sta
, arg
);
2497 ath10k_peer_assoc_h_phymode(ar
, vif
, sta
, arg
);
2502 static const u32 ath10k_smps_map
[] = {
2503 [WLAN_HT_CAP_SM_PS_STATIC
] = WMI_PEER_SMPS_STATIC
,
2504 [WLAN_HT_CAP_SM_PS_DYNAMIC
] = WMI_PEER_SMPS_DYNAMIC
,
2505 [WLAN_HT_CAP_SM_PS_INVALID
] = WMI_PEER_SMPS_PS_NONE
,
2506 [WLAN_HT_CAP_SM_PS_DISABLED
] = WMI_PEER_SMPS_PS_NONE
,
2509 static int ath10k_setup_peer_smps(struct ath10k
*ar
, struct ath10k_vif
*arvif
,
2511 const struct ieee80211_sta_ht_cap
*ht_cap
)
2515 if (!ht_cap
->ht_supported
)
2518 smps
= ht_cap
->cap
& IEEE80211_HT_CAP_SM_PS
;
2519 smps
>>= IEEE80211_HT_CAP_SM_PS_SHIFT
;
2521 if (smps
>= ARRAY_SIZE(ath10k_smps_map
))
2524 return ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, addr
,
2525 WMI_PEER_SMPS_STATE
,
2526 ath10k_smps_map
[smps
]);
2529 static int ath10k_mac_vif_recalc_txbf(struct ath10k
*ar
,
2530 struct ieee80211_vif
*vif
,
2531 struct ieee80211_sta_vht_cap vht_cap
)
2533 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2538 if (ath10k_wmi_get_txbf_conf_scheme(ar
) != WMI_TXBF_CONF_AFTER_ASSOC
)
2541 if (!(ar
->vht_cap_info
&
2542 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
|
2543 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
|
2544 IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
|
2545 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
)))
2548 param
= ar
->wmi
.vdev_param
->txbf
;
2551 if (WARN_ON(param
== WMI_VDEV_PARAM_UNSUPPORTED
))
2554 /* The following logic is correct. If a remote STA advertises support
2555 * for being a beamformer then we should enable us being a beamformee.
2558 if (ar
->vht_cap_info
&
2559 (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
|
2560 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
)) {
2561 if (vht_cap
.cap
& IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
)
2562 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE
;
2564 if (vht_cap
.cap
& IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
)
2565 value
|= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE
;
2568 if (ar
->vht_cap_info
&
2569 (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
|
2570 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
)) {
2571 if (vht_cap
.cap
& IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
)
2572 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFER
;
2574 if (vht_cap
.cap
& IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
)
2575 value
|= WMI_VDEV_PARAM_TXBF_MU_TX_BFER
;
2578 if (value
& WMI_VDEV_PARAM_TXBF_MU_TX_BFEE
)
2579 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE
;
2581 if (value
& WMI_VDEV_PARAM_TXBF_MU_TX_BFER
)
2582 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFER
;
2584 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, param
, value
);
2586 ath10k_warn(ar
, "failed to submit vdev param txbf 0x%x: %d\n",
2594 /* can be called only in mac80211 callbacks due to `key_count` usage */
2595 static void ath10k_bss_assoc(struct ieee80211_hw
*hw
,
2596 struct ieee80211_vif
*vif
,
2597 struct ieee80211_bss_conf
*bss_conf
)
2599 struct ath10k
*ar
= hw
->priv
;
2600 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2601 struct ieee80211_sta_ht_cap ht_cap
;
2602 struct ieee80211_sta_vht_cap vht_cap
;
2603 struct wmi_peer_assoc_complete_arg peer_arg
;
2604 struct ieee80211_sta
*ap_sta
;
2607 lockdep_assert_held(&ar
->conf_mutex
);
2609 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %i assoc bssid %pM aid %d\n",
2610 arvif
->vdev_id
, arvif
->bssid
, arvif
->aid
);
2614 ap_sta
= ieee80211_find_sta(vif
, bss_conf
->bssid
);
2616 ath10k_warn(ar
, "failed to find station entry for bss %pM vdev %i\n",
2617 bss_conf
->bssid
, arvif
->vdev_id
);
2622 /* ap_sta must be accessed only within rcu section which must be left
2623 * before calling ath10k_setup_peer_smps() which might sleep. */
2624 ht_cap
= ap_sta
->ht_cap
;
2625 vht_cap
= ap_sta
->vht_cap
;
2627 ret
= ath10k_peer_assoc_prepare(ar
, vif
, ap_sta
, &peer_arg
);
2629 ath10k_warn(ar
, "failed to prepare peer assoc for %pM vdev %i: %d\n",
2630 bss_conf
->bssid
, arvif
->vdev_id
, ret
);
2637 ret
= ath10k_wmi_peer_assoc(ar
, &peer_arg
);
2639 ath10k_warn(ar
, "failed to run peer assoc for %pM vdev %i: %d\n",
2640 bss_conf
->bssid
, arvif
->vdev_id
, ret
);
2644 ret
= ath10k_setup_peer_smps(ar
, arvif
, bss_conf
->bssid
, &ht_cap
);
2646 ath10k_warn(ar
, "failed to setup peer SMPS for vdev %i: %d\n",
2647 arvif
->vdev_id
, ret
);
2651 ret
= ath10k_mac_vif_recalc_txbf(ar
, vif
, vht_cap
);
2653 ath10k_warn(ar
, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
2654 arvif
->vdev_id
, bss_conf
->bssid
, ret
);
2658 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
2659 "mac vdev %d up (associated) bssid %pM aid %d\n",
2660 arvif
->vdev_id
, bss_conf
->bssid
, bss_conf
->aid
);
2662 WARN_ON(arvif
->is_up
);
2664 arvif
->aid
= bss_conf
->aid
;
2665 ether_addr_copy(arvif
->bssid
, bss_conf
->bssid
);
2667 ret
= ath10k_wmi_vdev_up(ar
, arvif
->vdev_id
, arvif
->aid
, arvif
->bssid
);
2669 ath10k_warn(ar
, "failed to set vdev %d up: %d\n",
2670 arvif
->vdev_id
, ret
);
2674 arvif
->is_up
= true;
2676 /* Workaround: Some firmware revisions (tested with qca6174
2677 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
2678 * poked with peer param command.
2680 ret
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, arvif
->bssid
,
2681 WMI_PEER_DUMMY_VAR
, 1);
2683 ath10k_warn(ar
, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
2684 arvif
->bssid
, arvif
->vdev_id
, ret
);
2689 static void ath10k_bss_disassoc(struct ieee80211_hw
*hw
,
2690 struct ieee80211_vif
*vif
)
2692 struct ath10k
*ar
= hw
->priv
;
2693 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2694 struct ieee80211_sta_vht_cap vht_cap
= {};
2697 lockdep_assert_held(&ar
->conf_mutex
);
2699 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %i disassoc bssid %pM\n",
2700 arvif
->vdev_id
, arvif
->bssid
);
2702 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
2704 ath10k_warn(ar
, "faield to down vdev %i: %d\n",
2705 arvif
->vdev_id
, ret
);
2707 arvif
->def_wep_key_idx
= -1;
2709 ret
= ath10k_mac_vif_recalc_txbf(ar
, vif
, vht_cap
);
2711 ath10k_warn(ar
, "failed to recalc txbf for vdev %i: %d\n",
2712 arvif
->vdev_id
, ret
);
2716 arvif
->is_up
= false;
2718 cancel_delayed_work_sync(&arvif
->connection_loss_work
);
2721 static int ath10k_station_assoc(struct ath10k
*ar
,
2722 struct ieee80211_vif
*vif
,
2723 struct ieee80211_sta
*sta
,
2726 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2727 struct wmi_peer_assoc_complete_arg peer_arg
;
2730 lockdep_assert_held(&ar
->conf_mutex
);
2732 ret
= ath10k_peer_assoc_prepare(ar
, vif
, sta
, &peer_arg
);
2734 ath10k_warn(ar
, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
2735 sta
->addr
, arvif
->vdev_id
, ret
);
2739 ret
= ath10k_wmi_peer_assoc(ar
, &peer_arg
);
2741 ath10k_warn(ar
, "failed to run peer assoc for STA %pM vdev %i: %d\n",
2742 sta
->addr
, arvif
->vdev_id
, ret
);
2746 /* Re-assoc is run only to update supported rates for given station. It
2747 * doesn't make much sense to reconfigure the peer completely.
2750 ret
= ath10k_setup_peer_smps(ar
, arvif
, sta
->addr
,
2753 ath10k_warn(ar
, "failed to setup peer SMPS for vdev %d: %d\n",
2754 arvif
->vdev_id
, ret
);
2758 ret
= ath10k_peer_assoc_qos_ap(ar
, arvif
, sta
);
2760 ath10k_warn(ar
, "failed to set qos params for STA %pM for vdev %i: %d\n",
2761 sta
->addr
, arvif
->vdev_id
, ret
);
2766 arvif
->num_legacy_stations
++;
2767 ret
= ath10k_recalc_rtscts_prot(arvif
);
2769 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2770 arvif
->vdev_id
, ret
);
2775 /* Plumb cached keys only for static WEP */
2776 if (arvif
->def_wep_key_idx
!= -1) {
2777 ret
= ath10k_install_peer_wep_keys(arvif
, sta
->addr
);
2779 ath10k_warn(ar
, "failed to install peer wep keys for vdev %i: %d\n",
2780 arvif
->vdev_id
, ret
);
2789 static int ath10k_station_disassoc(struct ath10k
*ar
,
2790 struct ieee80211_vif
*vif
,
2791 struct ieee80211_sta
*sta
)
2793 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
2796 lockdep_assert_held(&ar
->conf_mutex
);
2799 arvif
->num_legacy_stations
--;
2800 ret
= ath10k_recalc_rtscts_prot(arvif
);
2802 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
2803 arvif
->vdev_id
, ret
);
2808 ret
= ath10k_clear_peer_keys(arvif
, sta
->addr
);
2810 ath10k_warn(ar
, "failed to clear all peer wep keys for vdev %i: %d\n",
2811 arvif
->vdev_id
, ret
);
2822 static int ath10k_update_channel_list(struct ath10k
*ar
)
2824 struct ieee80211_hw
*hw
= ar
->hw
;
2825 struct ieee80211_supported_band
**bands
;
2826 enum ieee80211_band band
;
2827 struct ieee80211_channel
*channel
;
2828 struct wmi_scan_chan_list_arg arg
= {0};
2829 struct wmi_channel_arg
*ch
;
2835 lockdep_assert_held(&ar
->conf_mutex
);
2837 bands
= hw
->wiphy
->bands
;
2838 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
2842 for (i
= 0; i
< bands
[band
]->n_channels
; i
++) {
2843 if (bands
[band
]->channels
[i
].flags
&
2844 IEEE80211_CHAN_DISABLED
)
2851 len
= sizeof(struct wmi_channel_arg
) * arg
.n_channels
;
2852 arg
.channels
= kzalloc(len
, GFP_KERNEL
);
2857 for (band
= 0; band
< IEEE80211_NUM_BANDS
; band
++) {
2861 for (i
= 0; i
< bands
[band
]->n_channels
; i
++) {
2862 channel
= &bands
[band
]->channels
[i
];
2864 if (channel
->flags
& IEEE80211_CHAN_DISABLED
)
2867 ch
->allow_ht
= true;
2869 /* FIXME: when should we really allow VHT? */
2870 ch
->allow_vht
= true;
2873 !(channel
->flags
& IEEE80211_CHAN_NO_IR
);
2876 !(channel
->flags
& IEEE80211_CHAN_NO_HT40PLUS
);
2879 !!(channel
->flags
& IEEE80211_CHAN_RADAR
);
2881 passive
= channel
->flags
& IEEE80211_CHAN_NO_IR
;
2882 ch
->passive
= passive
;
2884 ch
->freq
= channel
->center_freq
;
2885 ch
->band_center_freq1
= channel
->center_freq
;
2887 ch
->max_power
= channel
->max_power
* 2;
2888 ch
->max_reg_power
= channel
->max_reg_power
* 2;
2889 ch
->max_antenna_gain
= channel
->max_antenna_gain
* 2;
2890 ch
->reg_class_id
= 0; /* FIXME */
2892 /* FIXME: why use only legacy modes, why not any
2893 * HT/VHT modes? Would that even make any
2895 if (channel
->band
== IEEE80211_BAND_2GHZ
)
2896 ch
->mode
= MODE_11G
;
2898 ch
->mode
= MODE_11A
;
2900 if (WARN_ON_ONCE(ch
->mode
== MODE_UNKNOWN
))
2903 ath10k_dbg(ar
, ATH10K_DBG_WMI
,
2904 "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
2905 ch
- arg
.channels
, arg
.n_channels
,
2906 ch
->freq
, ch
->max_power
, ch
->max_reg_power
,
2907 ch
->max_antenna_gain
, ch
->mode
);
2913 ret
= ath10k_wmi_scan_chan_list(ar
, &arg
);
2914 kfree(arg
.channels
);
2919 static enum wmi_dfs_region
2920 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region
)
2922 switch (dfs_region
) {
2923 case NL80211_DFS_UNSET
:
2924 return WMI_UNINIT_DFS_DOMAIN
;
2925 case NL80211_DFS_FCC
:
2926 return WMI_FCC_DFS_DOMAIN
;
2927 case NL80211_DFS_ETSI
:
2928 return WMI_ETSI_DFS_DOMAIN
;
2929 case NL80211_DFS_JP
:
2930 return WMI_MKK4_DFS_DOMAIN
;
2932 return WMI_UNINIT_DFS_DOMAIN
;
2935 static void ath10k_regd_update(struct ath10k
*ar
)
2937 struct reg_dmn_pair_mapping
*regpair
;
2939 enum wmi_dfs_region wmi_dfs_reg
;
2940 enum nl80211_dfs_regions nl_dfs_reg
;
2942 lockdep_assert_held(&ar
->conf_mutex
);
2944 ret
= ath10k_update_channel_list(ar
);
2946 ath10k_warn(ar
, "failed to update channel list: %d\n", ret
);
2948 regpair
= ar
->ath_common
.regulatory
.regpair
;
2950 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
) {
2951 nl_dfs_reg
= ar
->dfs_detector
->region
;
2952 wmi_dfs_reg
= ath10k_mac_get_dfs_region(nl_dfs_reg
);
2954 wmi_dfs_reg
= WMI_UNINIT_DFS_DOMAIN
;
2957 /* Target allows setting up per-band regdomain but ath_common provides
2958 * a combined one only */
2959 ret
= ath10k_wmi_pdev_set_regdomain(ar
,
2960 regpair
->reg_domain
,
2961 regpair
->reg_domain
, /* 2ghz */
2962 regpair
->reg_domain
, /* 5ghz */
2963 regpair
->reg_2ghz_ctl
,
2964 regpair
->reg_5ghz_ctl
,
2967 ath10k_warn(ar
, "failed to set pdev regdomain: %d\n", ret
);
2970 static void ath10k_reg_notifier(struct wiphy
*wiphy
,
2971 struct regulatory_request
*request
)
2973 struct ieee80211_hw
*hw
= wiphy_to_ieee80211_hw(wiphy
);
2974 struct ath10k
*ar
= hw
->priv
;
2977 ath_reg_notifier_apply(wiphy
, request
, &ar
->ath_common
.regulatory
);
2979 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
) {
2980 ath10k_dbg(ar
, ATH10K_DBG_REGULATORY
, "dfs region 0x%x\n",
2981 request
->dfs_region
);
2982 result
= ar
->dfs_detector
->set_dfs_domain(ar
->dfs_detector
,
2983 request
->dfs_region
);
2985 ath10k_warn(ar
, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
2986 request
->dfs_region
);
2989 mutex_lock(&ar
->conf_mutex
);
2990 if (ar
->state
== ATH10K_STATE_ON
)
2991 ath10k_regd_update(ar
);
2992 mutex_unlock(&ar
->conf_mutex
);
2999 void ath10k_mac_tx_lock(struct ath10k
*ar
, int reason
)
3001 lockdep_assert_held(&ar
->htt
.tx_lock
);
3003 WARN_ON(reason
>= ATH10K_TX_PAUSE_MAX
);
3004 ar
->tx_paused
|= BIT(reason
);
3005 ieee80211_stop_queues(ar
->hw
);
3008 static void ath10k_mac_tx_unlock_iter(void *data
, u8
*mac
,
3009 struct ieee80211_vif
*vif
)
3011 struct ath10k
*ar
= data
;
3012 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3014 if (arvif
->tx_paused
)
3017 ieee80211_wake_queue(ar
->hw
, arvif
->vdev_id
);
3020 void ath10k_mac_tx_unlock(struct ath10k
*ar
, int reason
)
3022 lockdep_assert_held(&ar
->htt
.tx_lock
);
3024 WARN_ON(reason
>= ATH10K_TX_PAUSE_MAX
);
3025 ar
->tx_paused
&= ~BIT(reason
);
3030 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
3031 IEEE80211_IFACE_ITER_RESUME_ALL
,
3032 ath10k_mac_tx_unlock_iter
,
3035 ieee80211_wake_queue(ar
->hw
, ar
->hw
->offchannel_tx_hw_queue
);
3038 void ath10k_mac_vif_tx_lock(struct ath10k_vif
*arvif
, int reason
)
3040 struct ath10k
*ar
= arvif
->ar
;
3042 lockdep_assert_held(&ar
->htt
.tx_lock
);
3044 WARN_ON(reason
>= BITS_PER_LONG
);
3045 arvif
->tx_paused
|= BIT(reason
);
3046 ieee80211_stop_queue(ar
->hw
, arvif
->vdev_id
);
3049 void ath10k_mac_vif_tx_unlock(struct ath10k_vif
*arvif
, int reason
)
3051 struct ath10k
*ar
= arvif
->ar
;
3053 lockdep_assert_held(&ar
->htt
.tx_lock
);
3055 WARN_ON(reason
>= BITS_PER_LONG
);
3056 arvif
->tx_paused
&= ~BIT(reason
);
3061 if (arvif
->tx_paused
)
3064 ieee80211_wake_queue(ar
->hw
, arvif
->vdev_id
);
3067 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif
*arvif
,
3068 enum wmi_tlv_tx_pause_id pause_id
,
3069 enum wmi_tlv_tx_pause_action action
)
3071 struct ath10k
*ar
= arvif
->ar
;
3073 lockdep_assert_held(&ar
->htt
.tx_lock
);
3076 case WMI_TLV_TX_PAUSE_ACTION_STOP
:
3077 ath10k_mac_vif_tx_lock(arvif
, pause_id
);
3079 case WMI_TLV_TX_PAUSE_ACTION_WAKE
:
3080 ath10k_mac_vif_tx_unlock(arvif
, pause_id
);
3083 ath10k_warn(ar
, "received unknown tx pause action %d on vdev %i, ignoring\n",
3084 action
, arvif
->vdev_id
);
3089 struct ath10k_mac_tx_pause
{
3091 enum wmi_tlv_tx_pause_id pause_id
;
3092 enum wmi_tlv_tx_pause_action action
;
3095 static void ath10k_mac_handle_tx_pause_iter(void *data
, u8
*mac
,
3096 struct ieee80211_vif
*vif
)
3098 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3099 struct ath10k_mac_tx_pause
*arg
= data
;
3101 if (arvif
->vdev_id
!= arg
->vdev_id
)
3104 ath10k_mac_vif_handle_tx_pause(arvif
, arg
->pause_id
, arg
->action
);
3107 void ath10k_mac_handle_tx_pause_vdev(struct ath10k
*ar
, u32 vdev_id
,
3108 enum wmi_tlv_tx_pause_id pause_id
,
3109 enum wmi_tlv_tx_pause_action action
)
3111 struct ath10k_mac_tx_pause arg
= {
3113 .pause_id
= pause_id
,
3117 spin_lock_bh(&ar
->htt
.tx_lock
);
3118 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
3119 IEEE80211_IFACE_ITER_RESUME_ALL
,
3120 ath10k_mac_handle_tx_pause_iter
,
3122 spin_unlock_bh(&ar
->htt
.tx_lock
);
3125 static enum ath10k_hw_txrx_mode
3126 ath10k_mac_tx_h_get_txmode(struct ath10k
*ar
,
3127 struct ieee80211_vif
*vif
,
3128 struct ieee80211_sta
*sta
,
3129 struct sk_buff
*skb
)
3131 const struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
3132 __le16 fc
= hdr
->frame_control
;
3134 if (!vif
|| vif
->type
== NL80211_IFTYPE_MONITOR
)
3135 return ATH10K_HW_TXRX_RAW
;
3137 if (ieee80211_is_mgmt(fc
))
3138 return ATH10K_HW_TXRX_MGMT
;
3142 * NullFunc frames are mostly used to ping if a client or AP are still
3143 * reachable and responsive. This implies tx status reports must be
3144 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3145 * come to a conclusion that the other end disappeared and tear down
3146 * BSS connection or it can never disconnect from BSS/client (which is
3149 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3150 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3151 * which seems to deliver correct tx reports for NullFunc frames. The
3152 * downside of using it is it ignores client powersave state so it can
3153 * end up disconnecting sleeping clients in AP mode. It should fix STA
3154 * mode though because AP don't sleep.
3156 if (ar
->htt
.target_version_major
< 3 &&
3157 (ieee80211_is_nullfunc(fc
) || ieee80211_is_qos_nullfunc(fc
)) &&
3158 !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX
, ar
->fw_features
))
3159 return ATH10K_HW_TXRX_MGMT
;
3163 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3164 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3165 * to work with Ethernet txmode so use it.
3167 * FIXME: Check if raw mode works with TDLS.
3169 if (ieee80211_is_data_present(fc
) && sta
&& sta
->tdls
)
3170 return ATH10K_HW_TXRX_ETHERNET
;
3172 if (test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
))
3173 return ATH10K_HW_TXRX_RAW
;
3175 return ATH10K_HW_TXRX_NATIVE_WIFI
;
3178 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif
*vif
,
3179 struct sk_buff
*skb
)
3181 const struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
3182 const struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
3183 const u32 mask
= IEEE80211_TX_INTFL_DONT_ENCRYPT
|
3184 IEEE80211_TX_CTL_INJECTED
;
3186 if (!ieee80211_has_protected(hdr
->frame_control
))
3189 if ((info
->flags
& mask
) == mask
)
3193 return !ath10k_vif_to_arvif(vif
)->nohwcrypt
;
3198 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3199 * Control in the header.
3201 static void ath10k_tx_h_nwifi(struct ieee80211_hw
*hw
, struct sk_buff
*skb
)
3203 struct ieee80211_hdr
*hdr
= (void *)skb
->data
;
3204 struct ath10k_skb_cb
*cb
= ATH10K_SKB_CB(skb
);
3207 if (!ieee80211_is_data_qos(hdr
->frame_control
))
3210 qos_ctl
= ieee80211_get_qos_ctl(hdr
);
3211 memmove(skb
->data
+ IEEE80211_QOS_CTL_LEN
,
3212 skb
->data
, (void *)qos_ctl
- (void *)skb
->data
);
3213 skb_pull(skb
, IEEE80211_QOS_CTL_LEN
);
3215 /* Some firmware revisions don't handle sending QoS NullFunc well.
3216 * These frames are mainly used for CQM purposes so it doesn't really
3217 * matter whether QoS NullFunc or NullFunc are sent.
3219 hdr
= (void *)skb
->data
;
3220 if (ieee80211_is_qos_nullfunc(hdr
->frame_control
))
3221 cb
->flags
&= ~ATH10K_SKB_F_QOS
;
3223 hdr
->frame_control
&= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA
);
3226 static void ath10k_tx_h_8023(struct sk_buff
*skb
)
3228 struct ieee80211_hdr
*hdr
;
3229 struct rfc1042_hdr
*rfc1042
;
3236 hdr
= (void *)skb
->data
;
3237 hdrlen
= ieee80211_hdrlen(hdr
->frame_control
);
3238 rfc1042
= (void *)skb
->data
+ hdrlen
;
3240 ether_addr_copy(da
, ieee80211_get_DA(hdr
));
3241 ether_addr_copy(sa
, ieee80211_get_SA(hdr
));
3242 type
= rfc1042
->snap_type
;
3244 skb_pull(skb
, hdrlen
+ sizeof(*rfc1042
));
3245 skb_push(skb
, sizeof(*eth
));
3247 eth
= (void *)skb
->data
;
3248 ether_addr_copy(eth
->h_dest
, da
);
3249 ether_addr_copy(eth
->h_source
, sa
);
3250 eth
->h_proto
= type
;
3253 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k
*ar
,
3254 struct ieee80211_vif
*vif
,
3255 struct sk_buff
*skb
)
3257 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
3258 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
3260 /* This is case only for P2P_GO */
3261 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
||
3262 arvif
->vdev_subtype
!= WMI_VDEV_SUBTYPE_P2P_GO
)
3265 if (unlikely(ieee80211_is_probe_resp(hdr
->frame_control
))) {
3266 spin_lock_bh(&ar
->data_lock
);
3267 if (arvif
->u
.ap
.noa_data
)
3268 if (!pskb_expand_head(skb
, 0, arvif
->u
.ap
.noa_len
,
3270 memcpy(skb_put(skb
, arvif
->u
.ap
.noa_len
),
3271 arvif
->u
.ap
.noa_data
,
3272 arvif
->u
.ap
.noa_len
);
3273 spin_unlock_bh(&ar
->data_lock
);
3277 bool ath10k_mac_tx_frm_has_freq(struct ath10k
*ar
)
3279 /* FIXME: Not really sure since when the behaviour changed. At some
3280 * point new firmware stopped requiring creation of peer entries for
3281 * offchannel tx (and actually creating them causes issues with wmi-htc
3282 * tx credit replenishment and reliability). Assuming it's at least 3.4
3283 * because that's when the `freq` was introduced to TX_FRM HTT command.
3285 return (ar
->htt
.target_version_major
>= 3 &&
3286 ar
->htt
.target_version_minor
>= 4 &&
3287 ar
->htt
.op_version
== ATH10K_FW_HTT_OP_VERSION_TLV
);
3290 static int ath10k_mac_tx_wmi_mgmt(struct ath10k
*ar
, struct sk_buff
*skb
)
3292 struct sk_buff_head
*q
= &ar
->wmi_mgmt_tx_queue
;
3295 spin_lock_bh(&ar
->data_lock
);
3297 if (skb_queue_len(q
) == ATH10K_MAX_NUM_MGMT_PENDING
) {
3298 ath10k_warn(ar
, "wmi mgmt tx queue is full\n");
3303 __skb_queue_tail(q
, skb
);
3304 ieee80211_queue_work(ar
->hw
, &ar
->wmi_mgmt_tx_work
);
3307 spin_unlock_bh(&ar
->data_lock
);
3312 static void ath10k_mac_tx(struct ath10k
*ar
, enum ath10k_hw_txrx_mode txmode
,
3313 struct sk_buff
*skb
)
3315 struct ath10k_htt
*htt
= &ar
->htt
;
3319 case ATH10K_HW_TXRX_RAW
:
3320 case ATH10K_HW_TXRX_NATIVE_WIFI
:
3321 case ATH10K_HW_TXRX_ETHERNET
:
3322 ret
= ath10k_htt_tx(htt
, txmode
, skb
);
3324 case ATH10K_HW_TXRX_MGMT
:
3325 if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX
,
3327 ret
= ath10k_mac_tx_wmi_mgmt(ar
, skb
);
3328 else if (ar
->htt
.target_version_major
>= 3)
3329 ret
= ath10k_htt_tx(htt
, txmode
, skb
);
3331 ret
= ath10k_htt_mgmt_tx(htt
, skb
);
3336 ath10k_warn(ar
, "failed to transmit packet, dropping: %d\n",
3338 ieee80211_free_txskb(ar
->hw
, skb
);
3342 void ath10k_offchan_tx_purge(struct ath10k
*ar
)
3344 struct sk_buff
*skb
;
3347 skb
= skb_dequeue(&ar
->offchan_tx_queue
);
3351 ieee80211_free_txskb(ar
->hw
, skb
);
3355 void ath10k_offchan_tx_work(struct work_struct
*work
)
3357 struct ath10k
*ar
= container_of(work
, struct ath10k
, offchan_tx_work
);
3358 struct ath10k_peer
*peer
;
3359 struct ath10k_vif
*arvif
;
3360 struct ieee80211_hdr
*hdr
;
3361 struct ieee80211_vif
*vif
;
3362 struct ieee80211_sta
*sta
;
3363 struct sk_buff
*skb
;
3364 const u8
*peer_addr
;
3365 enum ath10k_hw_txrx_mode txmode
;
3368 unsigned long time_left
;
3369 bool tmp_peer_created
= false;
3371 /* FW requirement: We must create a peer before FW will send out
3372 * an offchannel frame. Otherwise the frame will be stuck and
3373 * never transmitted. We delete the peer upon tx completion.
3374 * It is unlikely that a peer for offchannel tx will already be
3375 * present. However it may be in some rare cases so account for that.
3376 * Otherwise we might remove a legitimate peer and break stuff. */
3379 skb
= skb_dequeue(&ar
->offchan_tx_queue
);
3383 mutex_lock(&ar
->conf_mutex
);
3385 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac offchannel skb %p\n",
3388 hdr
= (struct ieee80211_hdr
*)skb
->data
;
3389 peer_addr
= ieee80211_get_DA(hdr
);
3391 spin_lock_bh(&ar
->data_lock
);
3392 vdev_id
= ar
->scan
.vdev_id
;
3393 peer
= ath10k_peer_find(ar
, vdev_id
, peer_addr
);
3394 spin_unlock_bh(&ar
->data_lock
);
3397 /* FIXME: should this use ath10k_warn()? */
3398 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "peer %pM on vdev %d already present\n",
3399 peer_addr
, vdev_id
);
3402 ret
= ath10k_peer_create(ar
, vdev_id
, peer_addr
,
3403 WMI_PEER_TYPE_DEFAULT
);
3405 ath10k_warn(ar
, "failed to create peer %pM on vdev %d: %d\n",
3406 peer_addr
, vdev_id
, ret
);
3407 tmp_peer_created
= (ret
== 0);
3410 spin_lock_bh(&ar
->data_lock
);
3411 reinit_completion(&ar
->offchan_tx_completed
);
3412 ar
->offchan_tx_skb
= skb
;
3413 spin_unlock_bh(&ar
->data_lock
);
3415 /* It's safe to access vif and sta - conf_mutex guarantees that
3416 * sta_state() and remove_interface() are locked exclusively
3417 * out wrt to this offchannel worker.
3419 arvif
= ath10k_get_arvif(ar
, vdev_id
);
3422 sta
= ieee80211_find_sta(vif
, peer_addr
);
3428 txmode
= ath10k_mac_tx_h_get_txmode(ar
, vif
, sta
, skb
);
3430 ath10k_mac_tx(ar
, txmode
, skb
);
3433 wait_for_completion_timeout(&ar
->offchan_tx_completed
, 3 * HZ
);
3435 ath10k_warn(ar
, "timed out waiting for offchannel skb %p\n",
3438 if (!peer
&& tmp_peer_created
) {
3439 ret
= ath10k_peer_delete(ar
, vdev_id
, peer_addr
);
3441 ath10k_warn(ar
, "failed to delete peer %pM on vdev %d: %d\n",
3442 peer_addr
, vdev_id
, ret
);
3445 mutex_unlock(&ar
->conf_mutex
);
3449 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k
*ar
)
3451 struct sk_buff
*skb
;
3454 skb
= skb_dequeue(&ar
->wmi_mgmt_tx_queue
);
3458 ieee80211_free_txskb(ar
->hw
, skb
);
3462 void ath10k_mgmt_over_wmi_tx_work(struct work_struct
*work
)
3464 struct ath10k
*ar
= container_of(work
, struct ath10k
, wmi_mgmt_tx_work
);
3465 struct sk_buff
*skb
;
3469 skb
= skb_dequeue(&ar
->wmi_mgmt_tx_queue
);
3473 ret
= ath10k_wmi_mgmt_tx(ar
, skb
);
3475 ath10k_warn(ar
, "failed to transmit management frame via WMI: %d\n",
3477 ieee80211_free_txskb(ar
->hw
, skb
);
3486 void __ath10k_scan_finish(struct ath10k
*ar
)
3488 lockdep_assert_held(&ar
->data_lock
);
3490 switch (ar
->scan
.state
) {
3491 case ATH10K_SCAN_IDLE
:
3493 case ATH10K_SCAN_RUNNING
:
3494 case ATH10K_SCAN_ABORTING
:
3495 if (!ar
->scan
.is_roc
)
3496 ieee80211_scan_completed(ar
->hw
,
3498 ATH10K_SCAN_ABORTING
));
3499 else if (ar
->scan
.roc_notify
)
3500 ieee80211_remain_on_channel_expired(ar
->hw
);
3502 case ATH10K_SCAN_STARTING
:
3503 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
3504 ar
->scan_channel
= NULL
;
3505 ar
->scan
.roc_freq
= 0;
3506 ath10k_offchan_tx_purge(ar
);
3507 cancel_delayed_work(&ar
->scan
.timeout
);
3508 complete_all(&ar
->scan
.completed
);
3513 void ath10k_scan_finish(struct ath10k
*ar
)
3515 spin_lock_bh(&ar
->data_lock
);
3516 __ath10k_scan_finish(ar
);
3517 spin_unlock_bh(&ar
->data_lock
);
3520 static int ath10k_scan_stop(struct ath10k
*ar
)
3522 struct wmi_stop_scan_arg arg
= {
3523 .req_id
= 1, /* FIXME */
3524 .req_type
= WMI_SCAN_STOP_ONE
,
3525 .u
.scan_id
= ATH10K_SCAN_ID
,
3529 lockdep_assert_held(&ar
->conf_mutex
);
3531 ret
= ath10k_wmi_stop_scan(ar
, &arg
);
3533 ath10k_warn(ar
, "failed to stop wmi scan: %d\n", ret
);
3537 ret
= wait_for_completion_timeout(&ar
->scan
.completed
, 3*HZ
);
3539 ath10k_warn(ar
, "failed to receive scan abortion completion: timed out\n");
3541 } else if (ret
> 0) {
3546 /* Scan state should be updated upon scan completion but in case
3547 * firmware fails to deliver the event (for whatever reason) it is
3548 * desired to clean up scan state anyway. Firmware may have just
3549 * dropped the scan completion event delivery due to transport pipe
3550 * being overflown with data and/or it can recover on its own before
3551 * next scan request is submitted.
3553 spin_lock_bh(&ar
->data_lock
);
3554 if (ar
->scan
.state
!= ATH10K_SCAN_IDLE
)
3555 __ath10k_scan_finish(ar
);
3556 spin_unlock_bh(&ar
->data_lock
);
3561 static void ath10k_scan_abort(struct ath10k
*ar
)
3565 lockdep_assert_held(&ar
->conf_mutex
);
3567 spin_lock_bh(&ar
->data_lock
);
3569 switch (ar
->scan
.state
) {
3570 case ATH10K_SCAN_IDLE
:
3571 /* This can happen if timeout worker kicked in and called
3572 * abortion while scan completion was being processed.
3575 case ATH10K_SCAN_STARTING
:
3576 case ATH10K_SCAN_ABORTING
:
3577 ath10k_warn(ar
, "refusing scan abortion due to invalid scan state: %s (%d)\n",
3578 ath10k_scan_state_str(ar
->scan
.state
),
3581 case ATH10K_SCAN_RUNNING
:
3582 ar
->scan
.state
= ATH10K_SCAN_ABORTING
;
3583 spin_unlock_bh(&ar
->data_lock
);
3585 ret
= ath10k_scan_stop(ar
);
3587 ath10k_warn(ar
, "failed to abort scan: %d\n", ret
);
3589 spin_lock_bh(&ar
->data_lock
);
3593 spin_unlock_bh(&ar
->data_lock
);
3596 void ath10k_scan_timeout_work(struct work_struct
*work
)
3598 struct ath10k
*ar
= container_of(work
, struct ath10k
,
3601 mutex_lock(&ar
->conf_mutex
);
3602 ath10k_scan_abort(ar
);
3603 mutex_unlock(&ar
->conf_mutex
);
3606 static int ath10k_start_scan(struct ath10k
*ar
,
3607 const struct wmi_start_scan_arg
*arg
)
3611 lockdep_assert_held(&ar
->conf_mutex
);
3613 ret
= ath10k_wmi_start_scan(ar
, arg
);
3617 ret
= wait_for_completion_timeout(&ar
->scan
.started
, 1*HZ
);
3619 ret
= ath10k_scan_stop(ar
);
3621 ath10k_warn(ar
, "failed to stop scan: %d\n", ret
);
3626 /* If we failed to start the scan, return error code at
3627 * this point. This is probably due to some issue in the
3628 * firmware, but no need to wedge the driver due to that...
3630 spin_lock_bh(&ar
->data_lock
);
3631 if (ar
->scan
.state
== ATH10K_SCAN_IDLE
) {
3632 spin_unlock_bh(&ar
->data_lock
);
3635 spin_unlock_bh(&ar
->data_lock
);
3640 /**********************/
3641 /* mac80211 callbacks */
3642 /**********************/
3644 static void ath10k_tx(struct ieee80211_hw
*hw
,
3645 struct ieee80211_tx_control
*control
,
3646 struct sk_buff
*skb
)
3648 struct ath10k
*ar
= hw
->priv
;
3649 struct ath10k_skb_cb
*skb_cb
= ATH10K_SKB_CB(skb
);
3650 struct ieee80211_tx_info
*info
= IEEE80211_SKB_CB(skb
);
3651 struct ieee80211_vif
*vif
= info
->control
.vif
;
3652 struct ieee80211_sta
*sta
= control
->sta
;
3653 struct ieee80211_hdr
*hdr
= (struct ieee80211_hdr
*)skb
->data
;
3654 enum ath10k_hw_txrx_mode txmode
;
3656 /* We should disable CCK RATE due to P2P */
3657 if (info
->flags
& IEEE80211_TX_CTL_NO_CCK_RATE
)
3658 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
3660 txmode
= ath10k_mac_tx_h_get_txmode(ar
, vif
, sta
, skb
);
3663 if (!ath10k_tx_h_use_hwcrypto(vif
, skb
))
3664 skb_cb
->flags
|= ATH10K_SKB_F_NO_HWCRYPT
;
3666 if (ieee80211_is_mgmt(hdr
->frame_control
))
3667 skb_cb
->flags
|= ATH10K_SKB_F_MGMT
;
3669 if (ieee80211_is_data_qos(hdr
->frame_control
))
3670 skb_cb
->flags
|= ATH10K_SKB_F_QOS
;
3675 case ATH10K_HW_TXRX_MGMT
:
3676 case ATH10K_HW_TXRX_NATIVE_WIFI
:
3677 ath10k_tx_h_nwifi(hw
, skb
);
3678 ath10k_tx_h_add_p2p_noa_ie(ar
, vif
, skb
);
3679 ath10k_tx_h_seq_no(vif
, skb
);
3681 case ATH10K_HW_TXRX_ETHERNET
:
3682 ath10k_tx_h_8023(skb
);
3684 case ATH10K_HW_TXRX_RAW
:
3685 if (!test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
)) {
3687 ieee80211_free_txskb(hw
, skb
);
3692 if (info
->flags
& IEEE80211_TX_CTL_TX_OFFCHAN
) {
3693 if (!ath10k_mac_tx_frm_has_freq(ar
)) {
3694 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "queued offchannel skb %p\n",
3697 skb_queue_tail(&ar
->offchan_tx_queue
, skb
);
3698 ieee80211_queue_work(hw
, &ar
->offchan_tx_work
);
3703 ath10k_mac_tx(ar
, txmode
, skb
);
3706 /* Must not be called with conf_mutex held as workers can use that also. */
3707 void ath10k_drain_tx(struct ath10k
*ar
)
3709 /* make sure rcu-protected mac80211 tx path itself is drained */
3712 ath10k_offchan_tx_purge(ar
);
3713 ath10k_mgmt_over_wmi_tx_purge(ar
);
3715 cancel_work_sync(&ar
->offchan_tx_work
);
3716 cancel_work_sync(&ar
->wmi_mgmt_tx_work
);
3719 void ath10k_halt(struct ath10k
*ar
)
3721 struct ath10k_vif
*arvif
;
3723 lockdep_assert_held(&ar
->conf_mutex
);
3725 clear_bit(ATH10K_CAC_RUNNING
, &ar
->dev_flags
);
3726 ar
->filter_flags
= 0;
3727 ar
->monitor
= false;
3728 ar
->monitor_arvif
= NULL
;
3730 if (ar
->monitor_started
)
3731 ath10k_monitor_stop(ar
);
3733 ar
->monitor_started
= false;
3736 ath10k_scan_finish(ar
);
3737 ath10k_peer_cleanup_all(ar
);
3738 ath10k_core_stop(ar
);
3739 ath10k_hif_power_down(ar
);
3741 spin_lock_bh(&ar
->data_lock
);
3742 list_for_each_entry(arvif
, &ar
->arvifs
, list
)
3743 ath10k_mac_vif_beacon_cleanup(arvif
);
3744 spin_unlock_bh(&ar
->data_lock
);
3747 static int ath10k_get_antenna(struct ieee80211_hw
*hw
, u32
*tx_ant
, u32
*rx_ant
)
3749 struct ath10k
*ar
= hw
->priv
;
3751 mutex_lock(&ar
->conf_mutex
);
3753 *tx_ant
= ar
->cfg_tx_chainmask
;
3754 *rx_ant
= ar
->cfg_rx_chainmask
;
3756 mutex_unlock(&ar
->conf_mutex
);
3761 static void ath10k_check_chain_mask(struct ath10k
*ar
, u32 cm
, const char *dbg
)
3763 /* It is not clear that allowing gaps in chainmask
3764 * is helpful. Probably it will not do what user
3765 * is hoping for, so warn in that case.
3767 if (cm
== 15 || cm
== 7 || cm
== 3 || cm
== 1 || cm
== 0)
3770 ath10k_warn(ar
, "mac %s antenna chainmask may be invalid: 0x%x. Suggested values: 15, 7, 3, 1 or 0.\n",
3774 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k
*ar
)
3776 int nsts
= ar
->vht_cap_info
;
3778 nsts
&= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK
;
3779 nsts
>>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT
;
3781 /* If firmware does not deliver to host number of space-time
3782 * streams supported, assume it support up to 4 BF STS and return
3783 * the value for VHT CAP: nsts-1)
3791 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k
*ar
)
3793 int sound_dim
= ar
->vht_cap_info
;
3795 sound_dim
&= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK
;
3796 sound_dim
>>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT
;
3798 /* If the sounding dimension is not advertised by the firmware,
3799 * let's use a default value of 1
3807 static struct ieee80211_sta_vht_cap
ath10k_create_vht_cap(struct ath10k
*ar
)
3809 struct ieee80211_sta_vht_cap vht_cap
= {0};
3814 vht_cap
.vht_supported
= 1;
3815 vht_cap
.cap
= ar
->vht_cap_info
;
3817 if (ar
->vht_cap_info
& (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
|
3818 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
)) {
3819 val
= ath10k_mac_get_vht_cap_bf_sts(ar
);
3820 val
<<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT
;
3821 val
&= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK
;
3826 if (ar
->vht_cap_info
& (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
|
3827 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
)) {
3828 val
= ath10k_mac_get_vht_cap_bf_sound_dim(ar
);
3829 val
<<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT
;
3830 val
&= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK
;
3836 for (i
= 0; i
< 8; i
++) {
3837 if ((i
< ar
->num_rf_chains
) && (ar
->cfg_tx_chainmask
& BIT(i
)))
3838 mcs_map
|= IEEE80211_VHT_MCS_SUPPORT_0_9
<< (i
* 2);
3840 mcs_map
|= IEEE80211_VHT_MCS_NOT_SUPPORTED
<< (i
* 2);
3843 vht_cap
.vht_mcs
.rx_mcs_map
= cpu_to_le16(mcs_map
);
3844 vht_cap
.vht_mcs
.tx_mcs_map
= cpu_to_le16(mcs_map
);
3849 static struct ieee80211_sta_ht_cap
ath10k_get_ht_cap(struct ath10k
*ar
)
3852 struct ieee80211_sta_ht_cap ht_cap
= {0};
3854 if (!(ar
->ht_cap_info
& WMI_HT_CAP_ENABLED
))
3857 ht_cap
.ht_supported
= 1;
3858 ht_cap
.ampdu_factor
= IEEE80211_HT_MAX_AMPDU_64K
;
3859 ht_cap
.ampdu_density
= IEEE80211_HT_MPDU_DENSITY_8
;
3860 ht_cap
.cap
|= IEEE80211_HT_CAP_SUP_WIDTH_20_40
;
3861 ht_cap
.cap
|= IEEE80211_HT_CAP_DSSSCCK40
;
3862 ht_cap
.cap
|= WLAN_HT_CAP_SM_PS_STATIC
<< IEEE80211_HT_CAP_SM_PS_SHIFT
;
3864 if (ar
->ht_cap_info
& WMI_HT_CAP_HT20_SGI
)
3865 ht_cap
.cap
|= IEEE80211_HT_CAP_SGI_20
;
3867 if (ar
->ht_cap_info
& WMI_HT_CAP_HT40_SGI
)
3868 ht_cap
.cap
|= IEEE80211_HT_CAP_SGI_40
;
3870 if (ar
->ht_cap_info
& WMI_HT_CAP_DYNAMIC_SMPS
) {
3873 smps
= WLAN_HT_CAP_SM_PS_DYNAMIC
;
3874 smps
<<= IEEE80211_HT_CAP_SM_PS_SHIFT
;
3879 if (ar
->ht_cap_info
& WMI_HT_CAP_TX_STBC
)
3880 ht_cap
.cap
|= IEEE80211_HT_CAP_TX_STBC
;
3882 if (ar
->ht_cap_info
& WMI_HT_CAP_RX_STBC
) {
3885 stbc
= ar
->ht_cap_info
;
3886 stbc
&= WMI_HT_CAP_RX_STBC
;
3887 stbc
>>= WMI_HT_CAP_RX_STBC_MASK_SHIFT
;
3888 stbc
<<= IEEE80211_HT_CAP_RX_STBC_SHIFT
;
3889 stbc
&= IEEE80211_HT_CAP_RX_STBC
;
3894 if (ar
->ht_cap_info
& WMI_HT_CAP_LDPC
)
3895 ht_cap
.cap
|= IEEE80211_HT_CAP_LDPC_CODING
;
3897 if (ar
->ht_cap_info
& WMI_HT_CAP_L_SIG_TXOP_PROT
)
3898 ht_cap
.cap
|= IEEE80211_HT_CAP_LSIG_TXOP_PROT
;
3900 /* max AMSDU is implicitly taken from vht_cap_info */
3901 if (ar
->vht_cap_info
& WMI_VHT_CAP_MAX_MPDU_LEN_MASK
)
3902 ht_cap
.cap
|= IEEE80211_HT_CAP_MAX_AMSDU
;
3904 for (i
= 0; i
< ar
->num_rf_chains
; i
++) {
3905 if (ar
->cfg_rx_chainmask
& BIT(i
))
3906 ht_cap
.mcs
.rx_mask
[i
] = 0xFF;
3909 ht_cap
.mcs
.tx_params
|= IEEE80211_HT_MCS_TX_DEFINED
;
3914 static void ath10k_mac_setup_ht_vht_cap(struct ath10k
*ar
)
3916 struct ieee80211_supported_band
*band
;
3917 struct ieee80211_sta_vht_cap vht_cap
;
3918 struct ieee80211_sta_ht_cap ht_cap
;
3920 ht_cap
= ath10k_get_ht_cap(ar
);
3921 vht_cap
= ath10k_create_vht_cap(ar
);
3923 if (ar
->phy_capability
& WHAL_WLAN_11G_CAPABILITY
) {
3924 band
= &ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
];
3925 band
->ht_cap
= ht_cap
;
3927 /* Enable the VHT support at 2.4 GHz */
3928 band
->vht_cap
= vht_cap
;
3930 if (ar
->phy_capability
& WHAL_WLAN_11A_CAPABILITY
) {
3931 band
= &ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
];
3932 band
->ht_cap
= ht_cap
;
3933 band
->vht_cap
= vht_cap
;
3937 static int __ath10k_set_antenna(struct ath10k
*ar
, u32 tx_ant
, u32 rx_ant
)
3941 lockdep_assert_held(&ar
->conf_mutex
);
3943 ath10k_check_chain_mask(ar
, tx_ant
, "tx");
3944 ath10k_check_chain_mask(ar
, rx_ant
, "rx");
3946 ar
->cfg_tx_chainmask
= tx_ant
;
3947 ar
->cfg_rx_chainmask
= rx_ant
;
3949 if ((ar
->state
!= ATH10K_STATE_ON
) &&
3950 (ar
->state
!= ATH10K_STATE_RESTARTED
))
3953 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->tx_chain_mask
,
3956 ath10k_warn(ar
, "failed to set tx-chainmask: %d, req 0x%x\n",
3961 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->rx_chain_mask
,
3964 ath10k_warn(ar
, "failed to set rx-chainmask: %d, req 0x%x\n",
3969 /* Reload HT/VHT capability */
3970 ath10k_mac_setup_ht_vht_cap(ar
);
3975 static int ath10k_set_antenna(struct ieee80211_hw
*hw
, u32 tx_ant
, u32 rx_ant
)
3977 struct ath10k
*ar
= hw
->priv
;
3980 mutex_lock(&ar
->conf_mutex
);
3981 ret
= __ath10k_set_antenna(ar
, tx_ant
, rx_ant
);
3982 mutex_unlock(&ar
->conf_mutex
);
3986 static int ath10k_start(struct ieee80211_hw
*hw
)
3988 struct ath10k
*ar
= hw
->priv
;
3993 * This makes sense only when restarting hw. It is harmless to call
3994 * uncoditionally. This is necessary to make sure no HTT/WMI tx
3995 * commands will be submitted while restarting.
3997 ath10k_drain_tx(ar
);
3999 mutex_lock(&ar
->conf_mutex
);
4001 switch (ar
->state
) {
4002 case ATH10K_STATE_OFF
:
4003 ar
->state
= ATH10K_STATE_ON
;
4005 case ATH10K_STATE_RESTARTING
:
4007 ar
->state
= ATH10K_STATE_RESTARTED
;
4009 case ATH10K_STATE_ON
:
4010 case ATH10K_STATE_RESTARTED
:
4011 case ATH10K_STATE_WEDGED
:
4015 case ATH10K_STATE_UTF
:
4020 ret
= ath10k_hif_power_up(ar
);
4022 ath10k_err(ar
, "Could not init hif: %d\n", ret
);
4026 ret
= ath10k_core_start(ar
, ATH10K_FIRMWARE_MODE_NORMAL
);
4028 ath10k_err(ar
, "Could not init core: %d\n", ret
);
4029 goto err_power_down
;
4032 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->pmf_qos
, 1);
4034 ath10k_warn(ar
, "failed to enable PMF QOS: %d\n", ret
);
4038 ret
= ath10k_wmi_pdev_set_param(ar
, ar
->wmi
.pdev_param
->dynamic_bw
, 1);
4040 ath10k_warn(ar
, "failed to enable dynamic BW: %d\n", ret
);
4044 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS
, ar
->wmi
.svc_map
)) {
4045 ret
= ath10k_wmi_adaptive_qcs(ar
, true);
4047 ath10k_warn(ar
, "failed to enable adaptive qcs: %d\n",
4053 if (test_bit(WMI_SERVICE_BURST
, ar
->wmi
.svc_map
)) {
4054 burst_enable
= ar
->wmi
.pdev_param
->burst_enable
;
4055 ret
= ath10k_wmi_pdev_set_param(ar
, burst_enable
, 0);
4057 ath10k_warn(ar
, "failed to disable burst: %d\n", ret
);
4062 __ath10k_set_antenna(ar
, ar
->cfg_tx_chainmask
, ar
->cfg_rx_chainmask
);
4065 * By default FW set ARP frames ac to voice (6). In that case ARP
4066 * exchange is not working properly for UAPSD enabled AP. ARP requests
4067 * which arrives with access category 0 are processed by network stack
4068 * and send back with access category 0, but FW changes access category
4069 * to 6. Set ARP frames access category to best effort (0) solves
4073 ret
= ath10k_wmi_pdev_set_param(ar
,
4074 ar
->wmi
.pdev_param
->arp_ac_override
, 0);
4076 ath10k_warn(ar
, "failed to set arp ac override parameter: %d\n",
4081 if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA
,
4083 ret
= ath10k_wmi_pdev_enable_adaptive_cca(ar
, 1,
4084 WMI_CCA_DETECT_LEVEL_AUTO
,
4085 WMI_CCA_DETECT_MARGIN_AUTO
);
4087 ath10k_warn(ar
, "failed to enable adaptive cca: %d\n",
4093 ret
= ath10k_wmi_pdev_set_param(ar
,
4094 ar
->wmi
.pdev_param
->ani_enable
, 1);
4096 ath10k_warn(ar
, "failed to enable ani by default: %d\n",
4101 ar
->ani_enabled
= true;
4103 ar
->num_started_vdevs
= 0;
4104 ath10k_regd_update(ar
);
4106 ath10k_spectral_start(ar
);
4107 ath10k_thermal_set_throttling(ar
);
4109 mutex_unlock(&ar
->conf_mutex
);
4113 ath10k_core_stop(ar
);
4116 ath10k_hif_power_down(ar
);
4119 ar
->state
= ATH10K_STATE_OFF
;
4122 mutex_unlock(&ar
->conf_mutex
);
4126 static void ath10k_stop(struct ieee80211_hw
*hw
)
4128 struct ath10k
*ar
= hw
->priv
;
4130 ath10k_drain_tx(ar
);
4132 mutex_lock(&ar
->conf_mutex
);
4133 if (ar
->state
!= ATH10K_STATE_OFF
) {
4135 ar
->state
= ATH10K_STATE_OFF
;
4137 mutex_unlock(&ar
->conf_mutex
);
4139 cancel_delayed_work_sync(&ar
->scan
.timeout
);
4140 cancel_work_sync(&ar
->restart_work
);
4143 static int ath10k_config_ps(struct ath10k
*ar
)
4145 struct ath10k_vif
*arvif
;
4148 lockdep_assert_held(&ar
->conf_mutex
);
4150 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
4151 ret
= ath10k_mac_vif_setup_ps(arvif
);
4153 ath10k_warn(ar
, "failed to setup powersave: %d\n", ret
);
4161 static int ath10k_mac_txpower_setup(struct ath10k
*ar
, int txpower
)
4166 lockdep_assert_held(&ar
->conf_mutex
);
4168 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac txpower %d\n", txpower
);
4170 param
= ar
->wmi
.pdev_param
->txpower_limit2g
;
4171 ret
= ath10k_wmi_pdev_set_param(ar
, param
, txpower
* 2);
4173 ath10k_warn(ar
, "failed to set 2g txpower %d: %d\n",
4178 param
= ar
->wmi
.pdev_param
->txpower_limit5g
;
4179 ret
= ath10k_wmi_pdev_set_param(ar
, param
, txpower
* 2);
4181 ath10k_warn(ar
, "failed to set 5g txpower %d: %d\n",
4189 static int ath10k_mac_txpower_recalc(struct ath10k
*ar
)
4191 struct ath10k_vif
*arvif
;
4192 int ret
, txpower
= -1;
4194 lockdep_assert_held(&ar
->conf_mutex
);
4196 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
4197 WARN_ON(arvif
->txpower
< 0);
4200 txpower
= arvif
->txpower
;
4202 txpower
= min(txpower
, arvif
->txpower
);
4205 if (WARN_ON(txpower
== -1))
4208 ret
= ath10k_mac_txpower_setup(ar
, txpower
);
4210 ath10k_warn(ar
, "failed to setup tx power %d: %d\n",
4218 static int ath10k_config(struct ieee80211_hw
*hw
, u32 changed
)
4220 struct ath10k
*ar
= hw
->priv
;
4221 struct ieee80211_conf
*conf
= &hw
->conf
;
4224 mutex_lock(&ar
->conf_mutex
);
4226 if (changed
& IEEE80211_CONF_CHANGE_PS
)
4227 ath10k_config_ps(ar
);
4229 if (changed
& IEEE80211_CONF_CHANGE_MONITOR
) {
4230 ar
->monitor
= conf
->flags
& IEEE80211_CONF_MONITOR
;
4231 ret
= ath10k_monitor_recalc(ar
);
4233 ath10k_warn(ar
, "failed to recalc monitor: %d\n", ret
);
4236 mutex_unlock(&ar
->conf_mutex
);
4240 static u32
get_nss_from_chainmask(u16 chain_mask
)
4242 if ((chain_mask
& 0xf) == 0xf)
4244 else if ((chain_mask
& 0x7) == 0x7)
4246 else if ((chain_mask
& 0x3) == 0x3)
4251 static int ath10k_mac_set_txbf_conf(struct ath10k_vif
*arvif
)
4254 struct ath10k
*ar
= arvif
->ar
;
4258 if (ath10k_wmi_get_txbf_conf_scheme(ar
) != WMI_TXBF_CONF_BEFORE_ASSOC
)
4261 nsts
= ath10k_mac_get_vht_cap_bf_sts(ar
);
4262 if (ar
->vht_cap_info
& (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
|
4263 IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
))
4264 value
|= SM(nsts
, WMI_TXBF_STS_CAP_OFFSET
);
4266 sound_dim
= ath10k_mac_get_vht_cap_bf_sound_dim(ar
);
4267 if (ar
->vht_cap_info
& (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
|
4268 IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
))
4269 value
|= SM(sound_dim
, WMI_BF_SOUND_DIM_OFFSET
);
4274 if (ar
->vht_cap_info
& IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE
)
4275 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFER
;
4277 if (ar
->vht_cap_info
& IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE
)
4278 value
|= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER
|
4279 WMI_VDEV_PARAM_TXBF_SU_TX_BFER
);
4281 if (ar
->vht_cap_info
& IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
)
4282 value
|= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE
;
4284 if (ar
->vht_cap_info
& IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
)
4285 value
|= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE
|
4286 WMI_VDEV_PARAM_TXBF_SU_TX_BFEE
);
4288 return ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
,
4289 ar
->wmi
.vdev_param
->txbf
, value
);
4294 * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
4295 * because we will send mgmt frames without CCK. This requirement
4296 * for P2P_FIND/GO_NEG should be handled by checking CCK flag
4299 static int ath10k_add_interface(struct ieee80211_hw
*hw
,
4300 struct ieee80211_vif
*vif
)
4302 struct ath10k
*ar
= hw
->priv
;
4303 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4304 enum wmi_sta_powersave_param param
;
4311 vif
->driver_flags
|= IEEE80211_VIF_SUPPORTS_UAPSD
;
4313 mutex_lock(&ar
->conf_mutex
);
4315 memset(arvif
, 0, sizeof(*arvif
));
4320 INIT_LIST_HEAD(&arvif
->list
);
4321 INIT_WORK(&arvif
->ap_csa_work
, ath10k_mac_vif_ap_csa_work
);
4322 INIT_DELAYED_WORK(&arvif
->connection_loss_work
,
4323 ath10k_mac_vif_sta_connection_loss_work
);
4325 for (i
= 0; i
< ARRAY_SIZE(arvif
->bitrate_mask
.control
); i
++) {
4326 arvif
->bitrate_mask
.control
[i
].legacy
= 0xffffffff;
4327 memset(arvif
->bitrate_mask
.control
[i
].ht_mcs
, 0xff,
4328 sizeof(arvif
->bitrate_mask
.control
[i
].ht_mcs
));
4329 memset(arvif
->bitrate_mask
.control
[i
].vht_mcs
, 0xff,
4330 sizeof(arvif
->bitrate_mask
.control
[i
].vht_mcs
));
4333 if (ar
->num_peers
>= ar
->max_num_peers
) {
4334 ath10k_warn(ar
, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
4339 if (ar
->free_vdev_map
== 0) {
4340 ath10k_warn(ar
, "Free vdev map is empty, no more interfaces allowed.\n");
4344 bit
= __ffs64(ar
->free_vdev_map
);
4346 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac create vdev %i map %llx\n",
4347 bit
, ar
->free_vdev_map
);
4349 arvif
->vdev_id
= bit
;
4350 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_NONE
;
4352 switch (vif
->type
) {
4353 case NL80211_IFTYPE_P2P_DEVICE
:
4354 arvif
->vdev_type
= WMI_VDEV_TYPE_STA
;
4355 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_DEVICE
;
4357 case NL80211_IFTYPE_UNSPECIFIED
:
4358 case NL80211_IFTYPE_STATION
:
4359 arvif
->vdev_type
= WMI_VDEV_TYPE_STA
;
4361 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_CLIENT
;
4363 case NL80211_IFTYPE_ADHOC
:
4364 arvif
->vdev_type
= WMI_VDEV_TYPE_IBSS
;
4366 case NL80211_IFTYPE_MESH_POINT
:
4367 if (test_bit(WMI_SERVICE_MESH
, ar
->wmi
.svc_map
)) {
4368 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_MESH
;
4369 } else if (!test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
)) {
4371 ath10k_warn(ar
, "must load driver with rawmode=1 to add mesh interfaces\n");
4374 arvif
->vdev_type
= WMI_VDEV_TYPE_AP
;
4376 case NL80211_IFTYPE_AP
:
4377 arvif
->vdev_type
= WMI_VDEV_TYPE_AP
;
4380 arvif
->vdev_subtype
= WMI_VDEV_SUBTYPE_P2P_GO
;
4382 case NL80211_IFTYPE_MONITOR
:
4383 arvif
->vdev_type
= WMI_VDEV_TYPE_MONITOR
;
4390 /* Using vdev_id as queue number will make it very easy to do per-vif
4391 * tx queue locking. This shouldn't wrap due to interface combinations
4392 * but do a modulo for correctness sake and prevent using offchannel tx
4393 * queues for regular vif tx.
4395 vif
->cab_queue
= arvif
->vdev_id
% (IEEE80211_MAX_QUEUES
- 1);
4396 for (i
= 0; i
< ARRAY_SIZE(vif
->hw_queue
); i
++)
4397 vif
->hw_queue
[i
] = arvif
->vdev_id
% (IEEE80211_MAX_QUEUES
- 1);
4399 /* Some firmware revisions don't wait for beacon tx completion before
4400 * sending another SWBA event. This could lead to hardware using old
4401 * (freed) beacon data in some cases, e.g. tx credit starvation
4402 * combined with missed TBTT. This is very very rare.
4404 * On non-IOMMU-enabled hosts this could be a possible security issue
4405 * because hw could beacon some random data on the air. On
4406 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
4407 * device would crash.
4409 * Since there are no beacon tx completions (implicit nor explicit)
4410 * propagated to host the only workaround for this is to allocate a
4411 * DMA-coherent buffer for a lifetime of a vif and use it for all
4412 * beacon tx commands. Worst case for this approach is some beacons may
4413 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
4415 if (vif
->type
== NL80211_IFTYPE_ADHOC
||
4416 vif
->type
== NL80211_IFTYPE_MESH_POINT
||
4417 vif
->type
== NL80211_IFTYPE_AP
) {
4418 arvif
->beacon_buf
= dma_zalloc_coherent(ar
->dev
,
4419 IEEE80211_MAX_FRAME_LEN
,
4420 &arvif
->beacon_paddr
,
4422 if (!arvif
->beacon_buf
) {
4424 ath10k_warn(ar
, "failed to allocate beacon buffer: %d\n",
4429 if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED
, &ar
->dev_flags
))
4430 arvif
->nohwcrypt
= true;
4432 if (arvif
->nohwcrypt
&&
4433 !test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
)) {
4434 ath10k_warn(ar
, "cryptmode module param needed for sw crypto\n");
4438 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
4439 arvif
->vdev_id
, arvif
->vdev_type
, arvif
->vdev_subtype
,
4440 arvif
->beacon_buf
? "single-buf" : "per-skb");
4442 ret
= ath10k_wmi_vdev_create(ar
, arvif
->vdev_id
, arvif
->vdev_type
,
4443 arvif
->vdev_subtype
, vif
->addr
);
4445 ath10k_warn(ar
, "failed to create WMI vdev %i: %d\n",
4446 arvif
->vdev_id
, ret
);
4450 ar
->free_vdev_map
&= ~(1LL << arvif
->vdev_id
);
4451 list_add(&arvif
->list
, &ar
->arvifs
);
4453 /* It makes no sense to have firmware do keepalives. mac80211 already
4454 * takes care of this with idle connection polling.
4456 ret
= ath10k_mac_vif_disable_keepalive(arvif
);
4458 ath10k_warn(ar
, "failed to disable keepalive on vdev %i: %d\n",
4459 arvif
->vdev_id
, ret
);
4460 goto err_vdev_delete
;
4463 arvif
->def_wep_key_idx
= -1;
4465 vdev_param
= ar
->wmi
.vdev_param
->tx_encap_type
;
4466 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4467 ATH10K_HW_TXRX_NATIVE_WIFI
);
4468 /* 10.X firmware does not support this VDEV parameter. Do not warn */
4469 if (ret
&& ret
!= -EOPNOTSUPP
) {
4470 ath10k_warn(ar
, "failed to set vdev %i TX encapsulation: %d\n",
4471 arvif
->vdev_id
, ret
);
4472 goto err_vdev_delete
;
4475 if (ar
->cfg_tx_chainmask
) {
4476 u16 nss
= get_nss_from_chainmask(ar
->cfg_tx_chainmask
);
4478 vdev_param
= ar
->wmi
.vdev_param
->nss
;
4479 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4482 ath10k_warn(ar
, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
4483 arvif
->vdev_id
, ar
->cfg_tx_chainmask
, nss
,
4485 goto err_vdev_delete
;
4489 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
||
4490 arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
) {
4491 ret
= ath10k_peer_create(ar
, arvif
->vdev_id
, vif
->addr
,
4492 WMI_PEER_TYPE_DEFAULT
);
4494 ath10k_warn(ar
, "failed to create vdev %i peer for AP/IBSS: %d\n",
4495 arvif
->vdev_id
, ret
);
4496 goto err_vdev_delete
;
4500 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
) {
4501 ret
= ath10k_mac_set_kickout(arvif
);
4503 ath10k_warn(ar
, "failed to set vdev %i kickout parameters: %d\n",
4504 arvif
->vdev_id
, ret
);
4505 goto err_peer_delete
;
4509 if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
) {
4510 param
= WMI_STA_PS_PARAM_RX_WAKE_POLICY
;
4511 value
= WMI_STA_PS_RX_WAKE_POLICY_WAKE
;
4512 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
4515 ath10k_warn(ar
, "failed to set vdev %i RX wake policy: %d\n",
4516 arvif
->vdev_id
, ret
);
4517 goto err_peer_delete
;
4520 ret
= ath10k_mac_vif_recalc_ps_wake_threshold(arvif
);
4522 ath10k_warn(ar
, "failed to recalc ps wake threshold on vdev %i: %d\n",
4523 arvif
->vdev_id
, ret
);
4524 goto err_peer_delete
;
4527 ret
= ath10k_mac_vif_recalc_ps_poll_count(arvif
);
4529 ath10k_warn(ar
, "failed to recalc ps poll count on vdev %i: %d\n",
4530 arvif
->vdev_id
, ret
);
4531 goto err_peer_delete
;
4535 ret
= ath10k_mac_set_txbf_conf(arvif
);
4537 ath10k_warn(ar
, "failed to set txbf for vdev %d: %d\n",
4538 arvif
->vdev_id
, ret
);
4539 goto err_peer_delete
;
4542 ret
= ath10k_mac_set_rts(arvif
, ar
->hw
->wiphy
->rts_threshold
);
4544 ath10k_warn(ar
, "failed to set rts threshold for vdev %d: %d\n",
4545 arvif
->vdev_id
, ret
);
4546 goto err_peer_delete
;
4549 arvif
->txpower
= vif
->bss_conf
.txpower
;
4550 ret
= ath10k_mac_txpower_recalc(ar
);
4552 ath10k_warn(ar
, "failed to recalc tx power: %d\n", ret
);
4553 goto err_peer_delete
;
4556 if (vif
->type
== NL80211_IFTYPE_MONITOR
) {
4557 ar
->monitor_arvif
= arvif
;
4558 ret
= ath10k_monitor_recalc(ar
);
4560 ath10k_warn(ar
, "failed to recalc monitor: %d\n", ret
);
4561 goto err_peer_delete
;
4565 spin_lock_bh(&ar
->htt
.tx_lock
);
4567 ieee80211_wake_queue(ar
->hw
, arvif
->vdev_id
);
4568 spin_unlock_bh(&ar
->htt
.tx_lock
);
4570 mutex_unlock(&ar
->conf_mutex
);
4574 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
||
4575 arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
)
4576 ath10k_wmi_peer_delete(ar
, arvif
->vdev_id
, vif
->addr
);
4579 ath10k_wmi_vdev_delete(ar
, arvif
->vdev_id
);
4580 ar
->free_vdev_map
|= 1LL << arvif
->vdev_id
;
4581 list_del(&arvif
->list
);
4584 if (arvif
->beacon_buf
) {
4585 dma_free_coherent(ar
->dev
, IEEE80211_MAX_FRAME_LEN
,
4586 arvif
->beacon_buf
, arvif
->beacon_paddr
);
4587 arvif
->beacon_buf
= NULL
;
4590 mutex_unlock(&ar
->conf_mutex
);
4595 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif
*arvif
)
4599 for (i
= 0; i
< BITS_PER_LONG
; i
++)
4600 ath10k_mac_vif_tx_unlock(arvif
, i
);
4603 static void ath10k_remove_interface(struct ieee80211_hw
*hw
,
4604 struct ieee80211_vif
*vif
)
4606 struct ath10k
*ar
= hw
->priv
;
4607 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4610 cancel_work_sync(&arvif
->ap_csa_work
);
4611 cancel_delayed_work_sync(&arvif
->connection_loss_work
);
4613 mutex_lock(&ar
->conf_mutex
);
4615 spin_lock_bh(&ar
->data_lock
);
4616 ath10k_mac_vif_beacon_cleanup(arvif
);
4617 spin_unlock_bh(&ar
->data_lock
);
4619 ret
= ath10k_spectral_vif_stop(arvif
);
4621 ath10k_warn(ar
, "failed to stop spectral for vdev %i: %d\n",
4622 arvif
->vdev_id
, ret
);
4624 ar
->free_vdev_map
|= 1LL << arvif
->vdev_id
;
4625 list_del(&arvif
->list
);
4627 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
||
4628 arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
) {
4629 ret
= ath10k_wmi_peer_delete(arvif
->ar
, arvif
->vdev_id
,
4632 ath10k_warn(ar
, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
4633 arvif
->vdev_id
, ret
);
4635 kfree(arvif
->u
.ap
.noa_data
);
4638 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %i delete (remove interface)\n",
4641 ret
= ath10k_wmi_vdev_delete(ar
, arvif
->vdev_id
);
4643 ath10k_warn(ar
, "failed to delete WMI vdev %i: %d\n",
4644 arvif
->vdev_id
, ret
);
4646 /* Some firmware revisions don't notify host about self-peer removal
4647 * until after associated vdev is deleted.
4649 if (arvif
->vdev_type
== WMI_VDEV_TYPE_AP
||
4650 arvif
->vdev_type
== WMI_VDEV_TYPE_IBSS
) {
4651 ret
= ath10k_wait_for_peer_deleted(ar
, arvif
->vdev_id
,
4654 ath10k_warn(ar
, "failed to remove AP self-peer on vdev %i: %d\n",
4655 arvif
->vdev_id
, ret
);
4657 spin_lock_bh(&ar
->data_lock
);
4659 spin_unlock_bh(&ar
->data_lock
);
4662 ath10k_peer_cleanup(ar
, arvif
->vdev_id
);
4664 if (vif
->type
== NL80211_IFTYPE_MONITOR
) {
4665 ar
->monitor_arvif
= NULL
;
4666 ret
= ath10k_monitor_recalc(ar
);
4668 ath10k_warn(ar
, "failed to recalc monitor: %d\n", ret
);
4671 spin_lock_bh(&ar
->htt
.tx_lock
);
4672 ath10k_mac_vif_tx_unlock_all(arvif
);
4673 spin_unlock_bh(&ar
->htt
.tx_lock
);
4675 mutex_unlock(&ar
->conf_mutex
);
4679 * FIXME: Has to be verified.
4681 #define SUPPORTED_FILTERS \
4686 FIF_BCN_PRBRESP_PROMISC | \
4690 static void ath10k_configure_filter(struct ieee80211_hw
*hw
,
4691 unsigned int changed_flags
,
4692 unsigned int *total_flags
,
4695 struct ath10k
*ar
= hw
->priv
;
4698 mutex_lock(&ar
->conf_mutex
);
4700 changed_flags
&= SUPPORTED_FILTERS
;
4701 *total_flags
&= SUPPORTED_FILTERS
;
4702 ar
->filter_flags
= *total_flags
;
4704 ret
= ath10k_monitor_recalc(ar
);
4706 ath10k_warn(ar
, "failed to recalc montior: %d\n", ret
);
4708 mutex_unlock(&ar
->conf_mutex
);
4711 static void ath10k_bss_info_changed(struct ieee80211_hw
*hw
,
4712 struct ieee80211_vif
*vif
,
4713 struct ieee80211_bss_conf
*info
,
4716 struct ath10k
*ar
= hw
->priv
;
4717 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4719 u32 vdev_param
, pdev_param
, slottime
, preamble
;
4721 mutex_lock(&ar
->conf_mutex
);
4723 if (changed
& BSS_CHANGED_IBSS
)
4724 ath10k_control_ibss(arvif
, info
, vif
->addr
);
4726 if (changed
& BSS_CHANGED_BEACON_INT
) {
4727 arvif
->beacon_interval
= info
->beacon_int
;
4728 vdev_param
= ar
->wmi
.vdev_param
->beacon_interval
;
4729 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4730 arvif
->beacon_interval
);
4731 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
4732 "mac vdev %d beacon_interval %d\n",
4733 arvif
->vdev_id
, arvif
->beacon_interval
);
4736 ath10k_warn(ar
, "failed to set beacon interval for vdev %d: %i\n",
4737 arvif
->vdev_id
, ret
);
4740 if (changed
& BSS_CHANGED_BEACON
) {
4741 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
4742 "vdev %d set beacon tx mode to staggered\n",
4745 pdev_param
= ar
->wmi
.pdev_param
->beacon_tx_mode
;
4746 ret
= ath10k_wmi_pdev_set_param(ar
, pdev_param
,
4747 WMI_BEACON_STAGGERED_MODE
);
4749 ath10k_warn(ar
, "failed to set beacon mode for vdev %d: %i\n",
4750 arvif
->vdev_id
, ret
);
4752 ret
= ath10k_mac_setup_bcn_tmpl(arvif
);
4754 ath10k_warn(ar
, "failed to update beacon template: %d\n",
4757 if (ieee80211_vif_is_mesh(vif
)) {
4758 /* mesh doesn't use SSID but firmware needs it */
4759 strncpy(arvif
->u
.ap
.ssid
, "mesh",
4760 sizeof(arvif
->u
.ap
.ssid
));
4761 arvif
->u
.ap
.ssid_len
= 4;
4765 if (changed
& BSS_CHANGED_AP_PROBE_RESP
) {
4766 ret
= ath10k_mac_setup_prb_tmpl(arvif
);
4768 ath10k_warn(ar
, "failed to setup probe resp template on vdev %i: %d\n",
4769 arvif
->vdev_id
, ret
);
4772 if (changed
& (BSS_CHANGED_BEACON_INFO
| BSS_CHANGED_BEACON
)) {
4773 arvif
->dtim_period
= info
->dtim_period
;
4775 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
4776 "mac vdev %d dtim_period %d\n",
4777 arvif
->vdev_id
, arvif
->dtim_period
);
4779 vdev_param
= ar
->wmi
.vdev_param
->dtim_period
;
4780 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4781 arvif
->dtim_period
);
4783 ath10k_warn(ar
, "failed to set dtim period for vdev %d: %i\n",
4784 arvif
->vdev_id
, ret
);
4787 if (changed
& BSS_CHANGED_SSID
&&
4788 vif
->type
== NL80211_IFTYPE_AP
) {
4789 arvif
->u
.ap
.ssid_len
= info
->ssid_len
;
4791 memcpy(arvif
->u
.ap
.ssid
, info
->ssid
, info
->ssid_len
);
4792 arvif
->u
.ap
.hidden_ssid
= info
->hidden_ssid
;
4795 if (changed
& BSS_CHANGED_BSSID
&& !is_zero_ether_addr(info
->bssid
))
4796 ether_addr_copy(arvif
->bssid
, info
->bssid
);
4798 if (changed
& BSS_CHANGED_BEACON_ENABLED
)
4799 ath10k_control_beaconing(arvif
, info
);
4801 if (changed
& BSS_CHANGED_ERP_CTS_PROT
) {
4802 arvif
->use_cts_prot
= info
->use_cts_prot
;
4803 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d cts_prot %d\n",
4804 arvif
->vdev_id
, info
->use_cts_prot
);
4806 ret
= ath10k_recalc_rtscts_prot(arvif
);
4808 ath10k_warn(ar
, "failed to recalculate rts/cts prot for vdev %d: %d\n",
4809 arvif
->vdev_id
, ret
);
4811 vdev_param
= ar
->wmi
.vdev_param
->protection_mode
;
4812 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4813 info
->use_cts_prot
? 1 : 0);
4815 ath10k_warn(ar
, "failed to set protection mode %d on vdev %i: %d\n",
4816 info
->use_cts_prot
, arvif
->vdev_id
, ret
);
4819 if (changed
& BSS_CHANGED_ERP_SLOT
) {
4820 if (info
->use_short_slot
)
4821 slottime
= WMI_VDEV_SLOT_TIME_SHORT
; /* 9us */
4824 slottime
= WMI_VDEV_SLOT_TIME_LONG
; /* 20us */
4826 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d slot_time %d\n",
4827 arvif
->vdev_id
, slottime
);
4829 vdev_param
= ar
->wmi
.vdev_param
->slot_time
;
4830 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4833 ath10k_warn(ar
, "failed to set erp slot for vdev %d: %i\n",
4834 arvif
->vdev_id
, ret
);
4837 if (changed
& BSS_CHANGED_ERP_PREAMBLE
) {
4838 if (info
->use_short_preamble
)
4839 preamble
= WMI_VDEV_PREAMBLE_SHORT
;
4841 preamble
= WMI_VDEV_PREAMBLE_LONG
;
4843 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
4844 "mac vdev %d preamble %dn",
4845 arvif
->vdev_id
, preamble
);
4847 vdev_param
= ar
->wmi
.vdev_param
->preamble
;
4848 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
4851 ath10k_warn(ar
, "failed to set preamble for vdev %d: %i\n",
4852 arvif
->vdev_id
, ret
);
4855 if (changed
& BSS_CHANGED_ASSOC
) {
4857 /* Workaround: Make sure monitor vdev is not running
4858 * when associating to prevent some firmware revisions
4859 * (e.g. 10.1 and 10.2) from crashing.
4861 if (ar
->monitor_started
)
4862 ath10k_monitor_stop(ar
);
4863 ath10k_bss_assoc(hw
, vif
, info
);
4864 ath10k_monitor_recalc(ar
);
4866 ath10k_bss_disassoc(hw
, vif
);
4870 if (changed
& BSS_CHANGED_TXPOWER
) {
4871 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev_id %i txpower %d\n",
4872 arvif
->vdev_id
, info
->txpower
);
4874 arvif
->txpower
= info
->txpower
;
4875 ret
= ath10k_mac_txpower_recalc(ar
);
4877 ath10k_warn(ar
, "failed to recalc tx power: %d\n", ret
);
4880 if (changed
& BSS_CHANGED_PS
) {
4881 arvif
->ps
= vif
->bss_conf
.ps
;
4883 ret
= ath10k_config_ps(ar
);
4885 ath10k_warn(ar
, "failed to setup ps on vdev %i: %d\n",
4886 arvif
->vdev_id
, ret
);
4889 mutex_unlock(&ar
->conf_mutex
);
4892 static int ath10k_hw_scan(struct ieee80211_hw
*hw
,
4893 struct ieee80211_vif
*vif
,
4894 struct ieee80211_scan_request
*hw_req
)
4896 struct ath10k
*ar
= hw
->priv
;
4897 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
4898 struct cfg80211_scan_request
*req
= &hw_req
->req
;
4899 struct wmi_start_scan_arg arg
;
4903 mutex_lock(&ar
->conf_mutex
);
4905 spin_lock_bh(&ar
->data_lock
);
4906 switch (ar
->scan
.state
) {
4907 case ATH10K_SCAN_IDLE
:
4908 reinit_completion(&ar
->scan
.started
);
4909 reinit_completion(&ar
->scan
.completed
);
4910 ar
->scan
.state
= ATH10K_SCAN_STARTING
;
4911 ar
->scan
.is_roc
= false;
4912 ar
->scan
.vdev_id
= arvif
->vdev_id
;
4915 case ATH10K_SCAN_STARTING
:
4916 case ATH10K_SCAN_RUNNING
:
4917 case ATH10K_SCAN_ABORTING
:
4921 spin_unlock_bh(&ar
->data_lock
);
4926 memset(&arg
, 0, sizeof(arg
));
4927 ath10k_wmi_start_scan_init(ar
, &arg
);
4928 arg
.vdev_id
= arvif
->vdev_id
;
4929 arg
.scan_id
= ATH10K_SCAN_ID
;
4932 arg
.ie_len
= req
->ie_len
;
4933 memcpy(arg
.ie
, req
->ie
, arg
.ie_len
);
4937 arg
.n_ssids
= req
->n_ssids
;
4938 for (i
= 0; i
< arg
.n_ssids
; i
++) {
4939 arg
.ssids
[i
].len
= req
->ssids
[i
].ssid_len
;
4940 arg
.ssids
[i
].ssid
= req
->ssids
[i
].ssid
;
4943 arg
.scan_ctrl_flags
|= WMI_SCAN_FLAG_PASSIVE
;
4946 if (req
->n_channels
) {
4947 arg
.n_channels
= req
->n_channels
;
4948 for (i
= 0; i
< arg
.n_channels
; i
++)
4949 arg
.channels
[i
] = req
->channels
[i
]->center_freq
;
4952 ret
= ath10k_start_scan(ar
, &arg
);
4954 ath10k_warn(ar
, "failed to start hw scan: %d\n", ret
);
4955 spin_lock_bh(&ar
->data_lock
);
4956 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
4957 spin_unlock_bh(&ar
->data_lock
);
4960 /* Add a 200ms margin to account for event/command processing */
4961 ieee80211_queue_delayed_work(ar
->hw
, &ar
->scan
.timeout
,
4962 msecs_to_jiffies(arg
.max_scan_time
+
4966 mutex_unlock(&ar
->conf_mutex
);
4970 static void ath10k_cancel_hw_scan(struct ieee80211_hw
*hw
,
4971 struct ieee80211_vif
*vif
)
4973 struct ath10k
*ar
= hw
->priv
;
4975 mutex_lock(&ar
->conf_mutex
);
4976 ath10k_scan_abort(ar
);
4977 mutex_unlock(&ar
->conf_mutex
);
4979 cancel_delayed_work_sync(&ar
->scan
.timeout
);
4982 static void ath10k_set_key_h_def_keyidx(struct ath10k
*ar
,
4983 struct ath10k_vif
*arvif
,
4984 enum set_key_cmd cmd
,
4985 struct ieee80211_key_conf
*key
)
4987 u32 vdev_param
= arvif
->ar
->wmi
.vdev_param
->def_keyid
;
4990 /* 10.1 firmware branch requires default key index to be set to group
4991 * key index after installing it. Otherwise FW/HW Txes corrupted
4992 * frames with multi-vif APs. This is not required for main firmware
4993 * branch (e.g. 636).
4995 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
4997 * FIXME: It remains unknown if this is required for multi-vif STA
4998 * interfaces on 10.1.
5001 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_AP
&&
5002 arvif
->vdev_type
!= WMI_VDEV_TYPE_IBSS
)
5005 if (key
->cipher
== WLAN_CIPHER_SUITE_WEP40
)
5008 if (key
->cipher
== WLAN_CIPHER_SUITE_WEP104
)
5011 if (key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
)
5017 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
,
5020 ath10k_warn(ar
, "failed to set vdev %i group key as default key: %d\n",
5021 arvif
->vdev_id
, ret
);
5024 static int ath10k_set_key(struct ieee80211_hw
*hw
, enum set_key_cmd cmd
,
5025 struct ieee80211_vif
*vif
, struct ieee80211_sta
*sta
,
5026 struct ieee80211_key_conf
*key
)
5028 struct ath10k
*ar
= hw
->priv
;
5029 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5030 struct ath10k_peer
*peer
;
5031 const u8
*peer_addr
;
5032 bool is_wep
= key
->cipher
== WLAN_CIPHER_SUITE_WEP40
||
5033 key
->cipher
== WLAN_CIPHER_SUITE_WEP104
;
5039 /* this one needs to be done in software */
5040 if (key
->cipher
== WLAN_CIPHER_SUITE_AES_CMAC
)
5043 if (arvif
->nohwcrypt
)
5046 if (key
->keyidx
> WMI_MAX_KEY_INDEX
)
5049 mutex_lock(&ar
->conf_mutex
);
5052 peer_addr
= sta
->addr
;
5053 else if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
)
5054 peer_addr
= vif
->bss_conf
.bssid
;
5056 peer_addr
= vif
->addr
;
5058 key
->hw_key_idx
= key
->keyidx
;
5062 arvif
->wep_keys
[key
->keyidx
] = key
;
5064 arvif
->wep_keys
[key
->keyidx
] = NULL
;
5067 /* the peer should not disappear in mid-way (unless FW goes awry) since
5068 * we already hold conf_mutex. we just make sure its there now. */
5069 spin_lock_bh(&ar
->data_lock
);
5070 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, peer_addr
);
5071 spin_unlock_bh(&ar
->data_lock
);
5074 if (cmd
== SET_KEY
) {
5075 ath10k_warn(ar
, "failed to install key for non-existent peer %pM\n",
5080 /* if the peer doesn't exist there is no key to disable
5086 if (key
->flags
& IEEE80211_KEY_FLAG_PAIRWISE
)
5087 flags
|= WMI_KEY_PAIRWISE
;
5089 flags
|= WMI_KEY_GROUP
;
5092 if (cmd
== DISABLE_KEY
)
5093 ath10k_clear_vdev_key(arvif
, key
);
5095 /* When WEP keys are uploaded it's possible that there are
5096 * stations associated already (e.g. when merging) without any
5097 * keys. Static WEP needs an explicit per-peer key upload.
5099 if (vif
->type
== NL80211_IFTYPE_ADHOC
&&
5101 ath10k_mac_vif_update_wep_key(arvif
, key
);
5103 /* 802.1x never sets the def_wep_key_idx so each set_key()
5104 * call changes default tx key.
5106 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
5107 * after first set_key().
5109 if (cmd
== SET_KEY
&& arvif
->def_wep_key_idx
== -1)
5110 flags
|= WMI_KEY_TX_USAGE
;
5113 ret
= ath10k_install_key(arvif
, key
, cmd
, peer_addr
, flags
);
5116 ath10k_warn(ar
, "failed to install key for vdev %i peer %pM: %d\n",
5117 arvif
->vdev_id
, peer_addr
, ret
);
5121 /* mac80211 sets static WEP keys as groupwise while firmware requires
5122 * them to be installed twice as both pairwise and groupwise.
5124 if (is_wep
&& !sta
&& vif
->type
== NL80211_IFTYPE_STATION
) {
5126 flags2
&= ~WMI_KEY_GROUP
;
5127 flags2
|= WMI_KEY_PAIRWISE
;
5129 ret
= ath10k_install_key(arvif
, key
, cmd
, peer_addr
, flags2
);
5132 ath10k_warn(ar
, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
5133 arvif
->vdev_id
, peer_addr
, ret
);
5134 ret2
= ath10k_install_key(arvif
, key
, DISABLE_KEY
,
5138 ath10k_warn(ar
, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
5139 arvif
->vdev_id
, peer_addr
, ret2
);
5145 ath10k_set_key_h_def_keyidx(ar
, arvif
, cmd
, key
);
5147 spin_lock_bh(&ar
->data_lock
);
5148 peer
= ath10k_peer_find(ar
, arvif
->vdev_id
, peer_addr
);
5149 if (peer
&& cmd
== SET_KEY
)
5150 peer
->keys
[key
->keyidx
] = key
;
5151 else if (peer
&& cmd
== DISABLE_KEY
)
5152 peer
->keys
[key
->keyidx
] = NULL
;
5153 else if (peer
== NULL
)
5154 /* impossible unless FW goes crazy */
5155 ath10k_warn(ar
, "Peer %pM disappeared!\n", peer_addr
);
5156 spin_unlock_bh(&ar
->data_lock
);
5159 mutex_unlock(&ar
->conf_mutex
);
5163 static void ath10k_set_default_unicast_key(struct ieee80211_hw
*hw
,
5164 struct ieee80211_vif
*vif
,
5167 struct ath10k
*ar
= hw
->priv
;
5168 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5171 mutex_lock(&arvif
->ar
->conf_mutex
);
5173 if (arvif
->ar
->state
!= ATH10K_STATE_ON
)
5176 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d set keyidx %d\n",
5177 arvif
->vdev_id
, keyidx
);
5179 ret
= ath10k_wmi_vdev_set_param(arvif
->ar
,
5181 arvif
->ar
->wmi
.vdev_param
->def_keyid
,
5185 ath10k_warn(ar
, "failed to update wep key index for vdev %d: %d\n",
5191 arvif
->def_wep_key_idx
= keyidx
;
5194 mutex_unlock(&arvif
->ar
->conf_mutex
);
5197 static void ath10k_sta_rc_update_wk(struct work_struct
*wk
)
5200 struct ath10k_vif
*arvif
;
5201 struct ath10k_sta
*arsta
;
5202 struct ieee80211_sta
*sta
;
5203 struct cfg80211_chan_def def
;
5204 enum ieee80211_band band
;
5205 const u8
*ht_mcs_mask
;
5206 const u16
*vht_mcs_mask
;
5207 u32 changed
, bw
, nss
, smps
;
5210 arsta
= container_of(wk
, struct ath10k_sta
, update_wk
);
5211 sta
= container_of((void *)arsta
, struct ieee80211_sta
, drv_priv
);
5212 arvif
= arsta
->arvif
;
5215 if (WARN_ON(ath10k_mac_vif_chan(arvif
->vif
, &def
)))
5218 band
= def
.chan
->band
;
5219 ht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].ht_mcs
;
5220 vht_mcs_mask
= arvif
->bitrate_mask
.control
[band
].vht_mcs
;
5222 spin_lock_bh(&ar
->data_lock
);
5224 changed
= arsta
->changed
;
5231 spin_unlock_bh(&ar
->data_lock
);
5233 mutex_lock(&ar
->conf_mutex
);
5235 nss
= max_t(u32
, 1, nss
);
5236 nss
= min(nss
, max(ath10k_mac_max_ht_nss(ht_mcs_mask
),
5237 ath10k_mac_max_vht_nss(vht_mcs_mask
)));
5239 if (changed
& IEEE80211_RC_BW_CHANGED
) {
5240 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM peer bw %d\n",
5243 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
5244 WMI_PEER_CHAN_WIDTH
, bw
);
5246 ath10k_warn(ar
, "failed to update STA %pM peer bw %d: %d\n",
5247 sta
->addr
, bw
, err
);
5250 if (changed
& IEEE80211_RC_NSS_CHANGED
) {
5251 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM nss %d\n",
5254 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
5257 ath10k_warn(ar
, "failed to update STA %pM nss %d: %d\n",
5258 sta
->addr
, nss
, err
);
5261 if (changed
& IEEE80211_RC_SMPS_CHANGED
) {
5262 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM smps %d\n",
5265 err
= ath10k_wmi_peer_set_param(ar
, arvif
->vdev_id
, sta
->addr
,
5266 WMI_PEER_SMPS_STATE
, smps
);
5268 ath10k_warn(ar
, "failed to update STA %pM smps %d: %d\n",
5269 sta
->addr
, smps
, err
);
5272 if (changed
& IEEE80211_RC_SUPP_RATES_CHANGED
||
5273 changed
& IEEE80211_RC_NSS_CHANGED
) {
5274 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac update sta %pM supp rates/nss\n",
5277 err
= ath10k_station_assoc(ar
, arvif
->vif
, sta
, true);
5279 ath10k_warn(ar
, "failed to reassociate station: %pM\n",
5283 mutex_unlock(&ar
->conf_mutex
);
5286 static int ath10k_mac_inc_num_stations(struct ath10k_vif
*arvif
,
5287 struct ieee80211_sta
*sta
)
5289 struct ath10k
*ar
= arvif
->ar
;
5291 lockdep_assert_held(&ar
->conf_mutex
);
5293 if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
&& !sta
->tdls
)
5296 if (ar
->num_stations
>= ar
->max_num_stations
)
5304 static void ath10k_mac_dec_num_stations(struct ath10k_vif
*arvif
,
5305 struct ieee80211_sta
*sta
)
5307 struct ath10k
*ar
= arvif
->ar
;
5309 lockdep_assert_held(&ar
->conf_mutex
);
5311 if (arvif
->vdev_type
== WMI_VDEV_TYPE_STA
&& !sta
->tdls
)
5317 struct ath10k_mac_tdls_iter_data
{
5318 u32 num_tdls_stations
;
5319 struct ieee80211_vif
*curr_vif
;
5322 static void ath10k_mac_tdls_vif_stations_count_iter(void *data
,
5323 struct ieee80211_sta
*sta
)
5325 struct ath10k_mac_tdls_iter_data
*iter_data
= data
;
5326 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
5327 struct ieee80211_vif
*sta_vif
= arsta
->arvif
->vif
;
5329 if (sta
->tdls
&& sta_vif
== iter_data
->curr_vif
)
5330 iter_data
->num_tdls_stations
++;
5333 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw
*hw
,
5334 struct ieee80211_vif
*vif
)
5336 struct ath10k_mac_tdls_iter_data data
= {};
5338 data
.curr_vif
= vif
;
5340 ieee80211_iterate_stations_atomic(hw
,
5341 ath10k_mac_tdls_vif_stations_count_iter
,
5343 return data
.num_tdls_stations
;
5346 static void ath10k_mac_tdls_vifs_count_iter(void *data
, u8
*mac
,
5347 struct ieee80211_vif
*vif
)
5349 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5350 int *num_tdls_vifs
= data
;
5352 if (vif
->type
!= NL80211_IFTYPE_STATION
)
5355 if (ath10k_mac_tdls_vif_stations_count(arvif
->ar
->hw
, vif
) > 0)
5359 static int ath10k_mac_tdls_vifs_count(struct ieee80211_hw
*hw
)
5361 int num_tdls_vifs
= 0;
5363 ieee80211_iterate_active_interfaces_atomic(hw
,
5364 IEEE80211_IFACE_ITER_NORMAL
,
5365 ath10k_mac_tdls_vifs_count_iter
,
5367 return num_tdls_vifs
;
5370 static int ath10k_sta_state(struct ieee80211_hw
*hw
,
5371 struct ieee80211_vif
*vif
,
5372 struct ieee80211_sta
*sta
,
5373 enum ieee80211_sta_state old_state
,
5374 enum ieee80211_sta_state new_state
)
5376 struct ath10k
*ar
= hw
->priv
;
5377 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5378 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
5381 if (old_state
== IEEE80211_STA_NOTEXIST
&&
5382 new_state
== IEEE80211_STA_NONE
) {
5383 memset(arsta
, 0, sizeof(*arsta
));
5384 arsta
->arvif
= arvif
;
5385 INIT_WORK(&arsta
->update_wk
, ath10k_sta_rc_update_wk
);
5388 /* cancel must be done outside the mutex to avoid deadlock */
5389 if ((old_state
== IEEE80211_STA_NONE
&&
5390 new_state
== IEEE80211_STA_NOTEXIST
))
5391 cancel_work_sync(&arsta
->update_wk
);
5393 mutex_lock(&ar
->conf_mutex
);
5395 if (old_state
== IEEE80211_STA_NOTEXIST
&&
5396 new_state
== IEEE80211_STA_NONE
) {
5398 * New station addition.
5400 enum wmi_peer_type peer_type
= WMI_PEER_TYPE_DEFAULT
;
5401 u32 num_tdls_stations
;
5404 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
5405 "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
5406 arvif
->vdev_id
, sta
->addr
,
5407 ar
->num_stations
+ 1, ar
->max_num_stations
,
5408 ar
->num_peers
+ 1, ar
->max_num_peers
);
5410 ret
= ath10k_mac_inc_num_stations(arvif
, sta
);
5412 ath10k_warn(ar
, "refusing to associate station: too many connected already (%d)\n",
5413 ar
->max_num_stations
);
5418 peer_type
= WMI_PEER_TYPE_TDLS
;
5420 ret
= ath10k_peer_create(ar
, arvif
->vdev_id
, sta
->addr
,
5423 ath10k_warn(ar
, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
5424 sta
->addr
, arvif
->vdev_id
, ret
);
5425 ath10k_mac_dec_num_stations(arvif
, sta
);
5432 num_tdls_stations
= ath10k_mac_tdls_vif_stations_count(hw
, vif
);
5433 num_tdls_vifs
= ath10k_mac_tdls_vifs_count(hw
);
5435 if (num_tdls_vifs
>= ar
->max_num_tdls_vdevs
&&
5436 num_tdls_stations
== 0) {
5437 ath10k_warn(ar
, "vdev %i exceeded maximum number of tdls vdevs %i\n",
5438 arvif
->vdev_id
, ar
->max_num_tdls_vdevs
);
5439 ath10k_peer_delete(ar
, arvif
->vdev_id
, sta
->addr
);
5440 ath10k_mac_dec_num_stations(arvif
, sta
);
5445 if (num_tdls_stations
== 0) {
5446 /* This is the first tdls peer in current vif */
5447 enum wmi_tdls_state state
= WMI_TDLS_ENABLE_ACTIVE
;
5449 ret
= ath10k_wmi_update_fw_tdls_state(ar
, arvif
->vdev_id
,
5452 ath10k_warn(ar
, "failed to update fw tdls state on vdev %i: %i\n",
5453 arvif
->vdev_id
, ret
);
5454 ath10k_peer_delete(ar
, arvif
->vdev_id
,
5456 ath10k_mac_dec_num_stations(arvif
, sta
);
5461 ret
= ath10k_mac_tdls_peer_update(ar
, arvif
->vdev_id
, sta
,
5462 WMI_TDLS_PEER_STATE_PEERING
);
5465 "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
5466 sta
->addr
, arvif
->vdev_id
, ret
);
5467 ath10k_peer_delete(ar
, arvif
->vdev_id
, sta
->addr
);
5468 ath10k_mac_dec_num_stations(arvif
, sta
);
5470 if (num_tdls_stations
!= 0)
5472 ath10k_wmi_update_fw_tdls_state(ar
, arvif
->vdev_id
,
5475 } else if ((old_state
== IEEE80211_STA_NONE
&&
5476 new_state
== IEEE80211_STA_NOTEXIST
)) {
5478 * Existing station deletion.
5480 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
5481 "mac vdev %d peer delete %pM (sta gone)\n",
5482 arvif
->vdev_id
, sta
->addr
);
5484 ret
= ath10k_peer_delete(ar
, arvif
->vdev_id
, sta
->addr
);
5486 ath10k_warn(ar
, "failed to delete peer %pM for vdev %d: %i\n",
5487 sta
->addr
, arvif
->vdev_id
, ret
);
5489 ath10k_mac_dec_num_stations(arvif
, sta
);
5494 if (ath10k_mac_tdls_vif_stations_count(hw
, vif
))
5497 /* This was the last tdls peer in current vif */
5498 ret
= ath10k_wmi_update_fw_tdls_state(ar
, arvif
->vdev_id
,
5501 ath10k_warn(ar
, "failed to update fw tdls state on vdev %i: %i\n",
5502 arvif
->vdev_id
, ret
);
5504 } else if (old_state
== IEEE80211_STA_AUTH
&&
5505 new_state
== IEEE80211_STA_ASSOC
&&
5506 (vif
->type
== NL80211_IFTYPE_AP
||
5507 vif
->type
== NL80211_IFTYPE_MESH_POINT
||
5508 vif
->type
== NL80211_IFTYPE_ADHOC
)) {
5512 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac sta %pM associated\n",
5515 ret
= ath10k_station_assoc(ar
, vif
, sta
, false);
5517 ath10k_warn(ar
, "failed to associate station %pM for vdev %i: %i\n",
5518 sta
->addr
, arvif
->vdev_id
, ret
);
5519 } else if (old_state
== IEEE80211_STA_ASSOC
&&
5520 new_state
== IEEE80211_STA_AUTHORIZED
&&
5523 * Tdls station authorized.
5525 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac tdls sta %pM authorized\n",
5528 ret
= ath10k_station_assoc(ar
, vif
, sta
, false);
5530 ath10k_warn(ar
, "failed to associate tdls station %pM for vdev %i: %i\n",
5531 sta
->addr
, arvif
->vdev_id
, ret
);
5535 ret
= ath10k_mac_tdls_peer_update(ar
, arvif
->vdev_id
, sta
,
5536 WMI_TDLS_PEER_STATE_CONNECTED
);
5538 ath10k_warn(ar
, "failed to update tdls peer %pM for vdev %i: %i\n",
5539 sta
->addr
, arvif
->vdev_id
, ret
);
5540 } else if (old_state
== IEEE80211_STA_ASSOC
&&
5541 new_state
== IEEE80211_STA_AUTH
&&
5542 (vif
->type
== NL80211_IFTYPE_AP
||
5543 vif
->type
== NL80211_IFTYPE_MESH_POINT
||
5544 vif
->type
== NL80211_IFTYPE_ADHOC
)) {
5548 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac sta %pM disassociated\n",
5551 ret
= ath10k_station_disassoc(ar
, vif
, sta
);
5553 ath10k_warn(ar
, "failed to disassociate station: %pM vdev %i: %i\n",
5554 sta
->addr
, arvif
->vdev_id
, ret
);
5557 mutex_unlock(&ar
->conf_mutex
);
5561 static int ath10k_conf_tx_uapsd(struct ath10k
*ar
, struct ieee80211_vif
*vif
,
5562 u16 ac
, bool enable
)
5564 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5565 struct wmi_sta_uapsd_auto_trig_arg arg
= {};
5566 u32 prio
= 0, acc
= 0;
5570 lockdep_assert_held(&ar
->conf_mutex
);
5572 if (arvif
->vdev_type
!= WMI_VDEV_TYPE_STA
)
5576 case IEEE80211_AC_VO
:
5577 value
= WMI_STA_PS_UAPSD_AC3_DELIVERY_EN
|
5578 WMI_STA_PS_UAPSD_AC3_TRIGGER_EN
;
5582 case IEEE80211_AC_VI
:
5583 value
= WMI_STA_PS_UAPSD_AC2_DELIVERY_EN
|
5584 WMI_STA_PS_UAPSD_AC2_TRIGGER_EN
;
5588 case IEEE80211_AC_BE
:
5589 value
= WMI_STA_PS_UAPSD_AC1_DELIVERY_EN
|
5590 WMI_STA_PS_UAPSD_AC1_TRIGGER_EN
;
5594 case IEEE80211_AC_BK
:
5595 value
= WMI_STA_PS_UAPSD_AC0_DELIVERY_EN
|
5596 WMI_STA_PS_UAPSD_AC0_TRIGGER_EN
;
5603 arvif
->u
.sta
.uapsd
|= value
;
5605 arvif
->u
.sta
.uapsd
&= ~value
;
5607 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
5608 WMI_STA_PS_PARAM_UAPSD
,
5609 arvif
->u
.sta
.uapsd
);
5611 ath10k_warn(ar
, "failed to set uapsd params: %d\n", ret
);
5615 if (arvif
->u
.sta
.uapsd
)
5616 value
= WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD
;
5618 value
= WMI_STA_PS_RX_WAKE_POLICY_WAKE
;
5620 ret
= ath10k_wmi_set_sta_ps_param(ar
, arvif
->vdev_id
,
5621 WMI_STA_PS_PARAM_RX_WAKE_POLICY
,
5624 ath10k_warn(ar
, "failed to set rx wake param: %d\n", ret
);
5626 ret
= ath10k_mac_vif_recalc_ps_wake_threshold(arvif
);
5628 ath10k_warn(ar
, "failed to recalc ps wake threshold on vdev %i: %d\n",
5629 arvif
->vdev_id
, ret
);
5633 ret
= ath10k_mac_vif_recalc_ps_poll_count(arvif
);
5635 ath10k_warn(ar
, "failed to recalc ps poll count on vdev %i: %d\n",
5636 arvif
->vdev_id
, ret
);
5640 if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG
, ar
->wmi
.svc_map
) ||
5641 test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG
, ar
->wmi
.svc_map
)) {
5642 /* Only userspace can make an educated decision when to send
5643 * trigger frame. The following effectively disables u-UAPSD
5644 * autotrigger in firmware (which is enabled by default
5645 * provided the autotrigger service is available).
5649 arg
.user_priority
= prio
;
5650 arg
.service_interval
= 0;
5651 arg
.suspend_interval
= WMI_STA_UAPSD_MAX_INTERVAL_MSEC
;
5652 arg
.delay_interval
= WMI_STA_UAPSD_MAX_INTERVAL_MSEC
;
5654 ret
= ath10k_wmi_vdev_sta_uapsd(ar
, arvif
->vdev_id
,
5655 arvif
->bssid
, &arg
, 1);
5657 ath10k_warn(ar
, "failed to set uapsd auto trigger %d\n",
5667 static int ath10k_conf_tx(struct ieee80211_hw
*hw
,
5668 struct ieee80211_vif
*vif
, u16 ac
,
5669 const struct ieee80211_tx_queue_params
*params
)
5671 struct ath10k
*ar
= hw
->priv
;
5672 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5673 struct wmi_wmm_params_arg
*p
= NULL
;
5676 mutex_lock(&ar
->conf_mutex
);
5679 case IEEE80211_AC_VO
:
5680 p
= &arvif
->wmm_params
.ac_vo
;
5682 case IEEE80211_AC_VI
:
5683 p
= &arvif
->wmm_params
.ac_vi
;
5685 case IEEE80211_AC_BE
:
5686 p
= &arvif
->wmm_params
.ac_be
;
5688 case IEEE80211_AC_BK
:
5689 p
= &arvif
->wmm_params
.ac_bk
;
5698 p
->cwmin
= params
->cw_min
;
5699 p
->cwmax
= params
->cw_max
;
5700 p
->aifs
= params
->aifs
;
5703 * The channel time duration programmed in the HW is in absolute
5704 * microseconds, while mac80211 gives the txop in units of
5707 p
->txop
= params
->txop
* 32;
5709 if (ar
->wmi
.ops
->gen_vdev_wmm_conf
) {
5710 ret
= ath10k_wmi_vdev_wmm_conf(ar
, arvif
->vdev_id
,
5711 &arvif
->wmm_params
);
5713 ath10k_warn(ar
, "failed to set vdev wmm params on vdev %i: %d\n",
5714 arvif
->vdev_id
, ret
);
5718 /* This won't work well with multi-interface cases but it's
5719 * better than nothing.
5721 ret
= ath10k_wmi_pdev_set_wmm_params(ar
, &arvif
->wmm_params
);
5723 ath10k_warn(ar
, "failed to set wmm params: %d\n", ret
);
5728 ret
= ath10k_conf_tx_uapsd(ar
, vif
, ac
, params
->uapsd
);
5730 ath10k_warn(ar
, "failed to set sta uapsd: %d\n", ret
);
5733 mutex_unlock(&ar
->conf_mutex
);
5737 #define ATH10K_ROC_TIMEOUT_HZ (2*HZ)
5739 static int ath10k_remain_on_channel(struct ieee80211_hw
*hw
,
5740 struct ieee80211_vif
*vif
,
5741 struct ieee80211_channel
*chan
,
5743 enum ieee80211_roc_type type
)
5745 struct ath10k
*ar
= hw
->priv
;
5746 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
5747 struct wmi_start_scan_arg arg
;
5751 mutex_lock(&ar
->conf_mutex
);
5753 spin_lock_bh(&ar
->data_lock
);
5754 switch (ar
->scan
.state
) {
5755 case ATH10K_SCAN_IDLE
:
5756 reinit_completion(&ar
->scan
.started
);
5757 reinit_completion(&ar
->scan
.completed
);
5758 reinit_completion(&ar
->scan
.on_channel
);
5759 ar
->scan
.state
= ATH10K_SCAN_STARTING
;
5760 ar
->scan
.is_roc
= true;
5761 ar
->scan
.vdev_id
= arvif
->vdev_id
;
5762 ar
->scan
.roc_freq
= chan
->center_freq
;
5763 ar
->scan
.roc_notify
= true;
5766 case ATH10K_SCAN_STARTING
:
5767 case ATH10K_SCAN_RUNNING
:
5768 case ATH10K_SCAN_ABORTING
:
5772 spin_unlock_bh(&ar
->data_lock
);
5777 scan_time_msec
= ar
->hw
->wiphy
->max_remain_on_channel_duration
* 2;
5779 memset(&arg
, 0, sizeof(arg
));
5780 ath10k_wmi_start_scan_init(ar
, &arg
);
5781 arg
.vdev_id
= arvif
->vdev_id
;
5782 arg
.scan_id
= ATH10K_SCAN_ID
;
5784 arg
.channels
[0] = chan
->center_freq
;
5785 arg
.dwell_time_active
= scan_time_msec
;
5786 arg
.dwell_time_passive
= scan_time_msec
;
5787 arg
.max_scan_time
= scan_time_msec
;
5788 arg
.scan_ctrl_flags
|= WMI_SCAN_FLAG_PASSIVE
;
5789 arg
.scan_ctrl_flags
|= WMI_SCAN_FILTER_PROBE_REQ
;
5790 arg
.burst_duration_ms
= duration
;
5792 ret
= ath10k_start_scan(ar
, &arg
);
5794 ath10k_warn(ar
, "failed to start roc scan: %d\n", ret
);
5795 spin_lock_bh(&ar
->data_lock
);
5796 ar
->scan
.state
= ATH10K_SCAN_IDLE
;
5797 spin_unlock_bh(&ar
->data_lock
);
5801 ret
= wait_for_completion_timeout(&ar
->scan
.on_channel
, 3*HZ
);
5803 ath10k_warn(ar
, "failed to switch to channel for roc scan\n");
5805 ret
= ath10k_scan_stop(ar
);
5807 ath10k_warn(ar
, "failed to stop scan: %d\n", ret
);
5813 ieee80211_queue_delayed_work(ar
->hw
, &ar
->scan
.timeout
,
5814 msecs_to_jiffies(duration
));
5818 mutex_unlock(&ar
->conf_mutex
);
5822 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw
*hw
)
5824 struct ath10k
*ar
= hw
->priv
;
5826 mutex_lock(&ar
->conf_mutex
);
5828 spin_lock_bh(&ar
->data_lock
);
5829 ar
->scan
.roc_notify
= false;
5830 spin_unlock_bh(&ar
->data_lock
);
5832 ath10k_scan_abort(ar
);
5834 mutex_unlock(&ar
->conf_mutex
);
5836 cancel_delayed_work_sync(&ar
->scan
.timeout
);
5842 * Both RTS and Fragmentation threshold are interface-specific
5843 * in ath10k, but device-specific in mac80211.
5846 static int ath10k_set_rts_threshold(struct ieee80211_hw
*hw
, u32 value
)
5848 struct ath10k
*ar
= hw
->priv
;
5849 struct ath10k_vif
*arvif
;
5852 mutex_lock(&ar
->conf_mutex
);
5853 list_for_each_entry(arvif
, &ar
->arvifs
, list
) {
5854 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac vdev %d rts threshold %d\n",
5855 arvif
->vdev_id
, value
);
5857 ret
= ath10k_mac_set_rts(arvif
, value
);
5859 ath10k_warn(ar
, "failed to set rts threshold for vdev %d: %d\n",
5860 arvif
->vdev_id
, ret
);
5864 mutex_unlock(&ar
->conf_mutex
);
5869 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw
*hw
, u32 value
)
5871 /* Even though there's a WMI enum for fragmentation threshold no known
5872 * firmware actually implements it. Moreover it is not possible to rely
5873 * frame fragmentation to mac80211 because firmware clears the "more
5874 * fragments" bit in frame control making it impossible for remote
5875 * devices to reassemble frames.
5877 * Hence implement a dummy callback just to say fragmentation isn't
5878 * supported. This effectively prevents mac80211 from doing frame
5879 * fragmentation in software.
5884 static void ath10k_flush(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
,
5885 u32 queues
, bool drop
)
5887 struct ath10k
*ar
= hw
->priv
;
5891 /* mac80211 doesn't care if we really xmit queued frames or not
5892 * we'll collect those frames either way if we stop/delete vdevs */
5896 mutex_lock(&ar
->conf_mutex
);
5898 if (ar
->state
== ATH10K_STATE_WEDGED
)
5901 time_left
= wait_event_timeout(ar
->htt
.empty_tx_wq
, ({
5904 spin_lock_bh(&ar
->htt
.tx_lock
);
5905 empty
= (ar
->htt
.num_pending_tx
== 0);
5906 spin_unlock_bh(&ar
->htt
.tx_lock
);
5908 skip
= (ar
->state
== ATH10K_STATE_WEDGED
) ||
5909 test_bit(ATH10K_FLAG_CRASH_FLUSH
,
5913 }), ATH10K_FLUSH_TIMEOUT_HZ
);
5915 if (time_left
== 0 || skip
)
5916 ath10k_warn(ar
, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
5917 skip
, ar
->state
, time_left
);
5920 mutex_unlock(&ar
->conf_mutex
);
5923 /* TODO: Implement this function properly
5924 * For now it is needed to reply to Probe Requests in IBSS mode.
5925 * Propably we need this information from FW.
5927 static int ath10k_tx_last_beacon(struct ieee80211_hw
*hw
)
5932 static void ath10k_reconfig_complete(struct ieee80211_hw
*hw
,
5933 enum ieee80211_reconfig_type reconfig_type
)
5935 struct ath10k
*ar
= hw
->priv
;
5937 if (reconfig_type
!= IEEE80211_RECONFIG_TYPE_RESTART
)
5940 mutex_lock(&ar
->conf_mutex
);
5942 /* If device failed to restart it will be in a different state, e.g.
5943 * ATH10K_STATE_WEDGED */
5944 if (ar
->state
== ATH10K_STATE_RESTARTED
) {
5945 ath10k_info(ar
, "device successfully recovered\n");
5946 ar
->state
= ATH10K_STATE_ON
;
5947 ieee80211_wake_queues(ar
->hw
);
5950 mutex_unlock(&ar
->conf_mutex
);
5953 static int ath10k_get_survey(struct ieee80211_hw
*hw
, int idx
,
5954 struct survey_info
*survey
)
5956 struct ath10k
*ar
= hw
->priv
;
5957 struct ieee80211_supported_band
*sband
;
5958 struct survey_info
*ar_survey
= &ar
->survey
[idx
];
5961 mutex_lock(&ar
->conf_mutex
);
5963 sband
= hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
];
5964 if (sband
&& idx
>= sband
->n_channels
) {
5965 idx
-= sband
->n_channels
;
5970 sband
= hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
];
5972 if (!sband
|| idx
>= sband
->n_channels
) {
5977 spin_lock_bh(&ar
->data_lock
);
5978 memcpy(survey
, ar_survey
, sizeof(*survey
));
5979 spin_unlock_bh(&ar
->data_lock
);
5981 survey
->channel
= &sband
->channels
[idx
];
5983 if (ar
->rx_channel
== survey
->channel
)
5984 survey
->filled
|= SURVEY_INFO_IN_USE
;
5987 mutex_unlock(&ar
->conf_mutex
);
5992 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k
*ar
,
5993 enum ieee80211_band band
,
5994 const struct cfg80211_bitrate_mask
*mask
)
5999 num_rates
+= hweight32(mask
->control
[band
].legacy
);
6001 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].ht_mcs
); i
++)
6002 num_rates
+= hweight8(mask
->control
[band
].ht_mcs
[i
]);
6004 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].vht_mcs
); i
++)
6005 num_rates
+= hweight16(mask
->control
[band
].vht_mcs
[i
]);
6007 return num_rates
== 1;
6011 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k
*ar
,
6012 enum ieee80211_band band
,
6013 const struct cfg80211_bitrate_mask
*mask
,
6016 struct ieee80211_supported_band
*sband
= &ar
->mac
.sbands
[band
];
6017 u16 vht_mcs_map
= le16_to_cpu(sband
->vht_cap
.vht_mcs
.tx_mcs_map
);
6019 u8 vht_nss_mask
= 0;
6022 if (mask
->control
[band
].legacy
)
6025 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].ht_mcs
); i
++) {
6026 if (mask
->control
[band
].ht_mcs
[i
] == 0)
6028 else if (mask
->control
[band
].ht_mcs
[i
] ==
6029 sband
->ht_cap
.mcs
.rx_mask
[i
])
6030 ht_nss_mask
|= BIT(i
);
6035 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].vht_mcs
); i
++) {
6036 if (mask
->control
[band
].vht_mcs
[i
] == 0)
6038 else if (mask
->control
[band
].vht_mcs
[i
] ==
6039 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map
, i
))
6040 vht_nss_mask
|= BIT(i
);
6045 if (ht_nss_mask
!= vht_nss_mask
)
6048 if (ht_nss_mask
== 0)
6051 if (BIT(fls(ht_nss_mask
)) - 1 != ht_nss_mask
)
6054 *nss
= fls(ht_nss_mask
);
6060 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k
*ar
,
6061 enum ieee80211_band band
,
6062 const struct cfg80211_bitrate_mask
*mask
,
6065 struct ieee80211_supported_band
*sband
= &ar
->mac
.sbands
[band
];
6072 if (hweight32(mask
->control
[band
].legacy
) == 1) {
6073 rate_idx
= ffs(mask
->control
[band
].legacy
) - 1;
6075 hw_rate
= sband
->bitrates
[rate_idx
].hw_value
;
6076 bitrate
= sband
->bitrates
[rate_idx
].bitrate
;
6078 if (ath10k_mac_bitrate_is_cck(bitrate
))
6079 preamble
= WMI_RATE_PREAMBLE_CCK
;
6081 preamble
= WMI_RATE_PREAMBLE_OFDM
;
6084 *rate
= preamble
<< 6 |
6091 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].ht_mcs
); i
++) {
6092 if (hweight8(mask
->control
[band
].ht_mcs
[i
]) == 1) {
6094 *rate
= WMI_RATE_PREAMBLE_HT
<< 6 |
6096 (ffs(mask
->control
[band
].ht_mcs
[i
]) - 1);
6102 for (i
= 0; i
< ARRAY_SIZE(mask
->control
[band
].vht_mcs
); i
++) {
6103 if (hweight16(mask
->control
[band
].vht_mcs
[i
]) == 1) {
6105 *rate
= WMI_RATE_PREAMBLE_VHT
<< 6 |
6107 (ffs(mask
->control
[band
].vht_mcs
[i
]) - 1);
6116 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif
*arvif
,
6117 u8 rate
, u8 nss
, u8 sgi
, u8 ldpc
)
6119 struct ath10k
*ar
= arvif
->ar
;
6123 lockdep_assert_held(&ar
->conf_mutex
);
6125 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac set fixed rate params vdev %i rate 0x%02hhx nss %hhu sgi %hhu\n",
6126 arvif
->vdev_id
, rate
, nss
, sgi
);
6128 vdev_param
= ar
->wmi
.vdev_param
->fixed_rate
;
6129 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, rate
);
6131 ath10k_warn(ar
, "failed to set fixed rate param 0x%02x: %d\n",
6136 vdev_param
= ar
->wmi
.vdev_param
->nss
;
6137 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, nss
);
6139 ath10k_warn(ar
, "failed to set nss param %d: %d\n", nss
, ret
);
6143 vdev_param
= ar
->wmi
.vdev_param
->sgi
;
6144 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, sgi
);
6146 ath10k_warn(ar
, "failed to set sgi param %d: %d\n", sgi
, ret
);
6150 vdev_param
= ar
->wmi
.vdev_param
->ldpc
;
6151 ret
= ath10k_wmi_vdev_set_param(ar
, arvif
->vdev_id
, vdev_param
, ldpc
);
6153 ath10k_warn(ar
, "failed to set ldpc param %d: %d\n", ldpc
, ret
);
6161 ath10k_mac_can_set_bitrate_mask(struct ath10k
*ar
,
6162 enum ieee80211_band band
,
6163 const struct cfg80211_bitrate_mask
*mask
)
6168 /* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
6169 * to express all VHT MCS rate masks. Effectively only the following
6170 * ranges can be used: none, 0-7, 0-8 and 0-9.
6172 for (i
= 0; i
< NL80211_VHT_NSS_MAX
; i
++) {
6173 vht_mcs
= mask
->control
[band
].vht_mcs
[i
];
6182 ath10k_warn(ar
, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
6190 static void ath10k_mac_set_bitrate_mask_iter(void *data
,
6191 struct ieee80211_sta
*sta
)
6193 struct ath10k_vif
*arvif
= data
;
6194 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
6195 struct ath10k
*ar
= arvif
->ar
;
6197 if (arsta
->arvif
!= arvif
)
6200 spin_lock_bh(&ar
->data_lock
);
6201 arsta
->changed
|= IEEE80211_RC_SUPP_RATES_CHANGED
;
6202 spin_unlock_bh(&ar
->data_lock
);
6204 ieee80211_queue_work(ar
->hw
, &arsta
->update_wk
);
6207 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw
*hw
,
6208 struct ieee80211_vif
*vif
,
6209 const struct cfg80211_bitrate_mask
*mask
)
6211 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
6212 struct cfg80211_chan_def def
;
6213 struct ath10k
*ar
= arvif
->ar
;
6214 enum ieee80211_band band
;
6215 const u8
*ht_mcs_mask
;
6216 const u16
*vht_mcs_mask
;
6224 if (ath10k_mac_vif_chan(vif
, &def
))
6227 band
= def
.chan
->band
;
6228 ht_mcs_mask
= mask
->control
[band
].ht_mcs
;
6229 vht_mcs_mask
= mask
->control
[band
].vht_mcs
;
6230 ldpc
= !!(ar
->ht_cap_info
& WMI_HT_CAP_LDPC
);
6232 sgi
= mask
->control
[band
].gi
;
6233 if (sgi
== NL80211_TXRATE_FORCE_LGI
)
6236 if (ath10k_mac_bitrate_mask_has_single_rate(ar
, band
, mask
)) {
6237 ret
= ath10k_mac_bitrate_mask_get_single_rate(ar
, band
, mask
,
6240 ath10k_warn(ar
, "failed to get single rate for vdev %i: %d\n",
6241 arvif
->vdev_id
, ret
);
6244 } else if (ath10k_mac_bitrate_mask_get_single_nss(ar
, band
, mask
,
6246 rate
= WMI_FIXED_RATE_NONE
;
6249 rate
= WMI_FIXED_RATE_NONE
;
6250 nss
= min(ar
->num_rf_chains
,
6251 max(ath10k_mac_max_ht_nss(ht_mcs_mask
),
6252 ath10k_mac_max_vht_nss(vht_mcs_mask
)));
6254 if (!ath10k_mac_can_set_bitrate_mask(ar
, band
, mask
))
6257 mutex_lock(&ar
->conf_mutex
);
6259 arvif
->bitrate_mask
= *mask
;
6260 ieee80211_iterate_stations_atomic(ar
->hw
,
6261 ath10k_mac_set_bitrate_mask_iter
,
6264 mutex_unlock(&ar
->conf_mutex
);
6267 mutex_lock(&ar
->conf_mutex
);
6269 ret
= ath10k_mac_set_fixed_rate_params(arvif
, rate
, nss
, sgi
, ldpc
);
6271 ath10k_warn(ar
, "failed to set fixed rate params on vdev %i: %d\n",
6272 arvif
->vdev_id
, ret
);
6277 mutex_unlock(&ar
->conf_mutex
);
6282 static void ath10k_sta_rc_update(struct ieee80211_hw
*hw
,
6283 struct ieee80211_vif
*vif
,
6284 struct ieee80211_sta
*sta
,
6287 struct ath10k
*ar
= hw
->priv
;
6288 struct ath10k_sta
*arsta
= (struct ath10k_sta
*)sta
->drv_priv
;
6291 spin_lock_bh(&ar
->data_lock
);
6293 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6294 "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
6295 sta
->addr
, changed
, sta
->bandwidth
, sta
->rx_nss
,
6298 if (changed
& IEEE80211_RC_BW_CHANGED
) {
6299 bw
= WMI_PEER_CHWIDTH_20MHZ
;
6301 switch (sta
->bandwidth
) {
6302 case IEEE80211_STA_RX_BW_20
:
6303 bw
= WMI_PEER_CHWIDTH_20MHZ
;
6305 case IEEE80211_STA_RX_BW_40
:
6306 bw
= WMI_PEER_CHWIDTH_40MHZ
;
6308 case IEEE80211_STA_RX_BW_80
:
6309 bw
= WMI_PEER_CHWIDTH_80MHZ
;
6311 case IEEE80211_STA_RX_BW_160
:
6312 ath10k_warn(ar
, "Invalid bandwidth %d in rc update for %pM\n",
6313 sta
->bandwidth
, sta
->addr
);
6314 bw
= WMI_PEER_CHWIDTH_20MHZ
;
6321 if (changed
& IEEE80211_RC_NSS_CHANGED
)
6322 arsta
->nss
= sta
->rx_nss
;
6324 if (changed
& IEEE80211_RC_SMPS_CHANGED
) {
6325 smps
= WMI_PEER_SMPS_PS_NONE
;
6327 switch (sta
->smps_mode
) {
6328 case IEEE80211_SMPS_AUTOMATIC
:
6329 case IEEE80211_SMPS_OFF
:
6330 smps
= WMI_PEER_SMPS_PS_NONE
;
6332 case IEEE80211_SMPS_STATIC
:
6333 smps
= WMI_PEER_SMPS_STATIC
;
6335 case IEEE80211_SMPS_DYNAMIC
:
6336 smps
= WMI_PEER_SMPS_DYNAMIC
;
6338 case IEEE80211_SMPS_NUM_MODES
:
6339 ath10k_warn(ar
, "Invalid smps %d in sta rc update for %pM\n",
6340 sta
->smps_mode
, sta
->addr
);
6341 smps
= WMI_PEER_SMPS_PS_NONE
;
6348 arsta
->changed
|= changed
;
6350 spin_unlock_bh(&ar
->data_lock
);
6352 ieee80211_queue_work(hw
, &arsta
->update_wk
);
6355 static u64
ath10k_get_tsf(struct ieee80211_hw
*hw
, struct ieee80211_vif
*vif
)
6358 * FIXME: Return 0 for time being. Need to figure out whether FW
6359 * has the API to fetch 64-bit local TSF
6365 static int ath10k_ampdu_action(struct ieee80211_hw
*hw
,
6366 struct ieee80211_vif
*vif
,
6367 enum ieee80211_ampdu_mlme_action action
,
6368 struct ieee80211_sta
*sta
, u16 tid
, u16
*ssn
,
6369 u8 buf_size
, bool amsdu
)
6371 struct ath10k
*ar
= hw
->priv
;
6372 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
6374 ath10k_dbg(ar
, ATH10K_DBG_MAC
, "mac ampdu vdev_id %i sta %pM tid %hu action %d\n",
6375 arvif
->vdev_id
, sta
->addr
, tid
, action
);
6378 case IEEE80211_AMPDU_RX_START
:
6379 case IEEE80211_AMPDU_RX_STOP
:
6380 /* HTT AddBa/DelBa events trigger mac80211 Rx BA session
6381 * creation/removal. Do we need to verify this?
6384 case IEEE80211_AMPDU_TX_START
:
6385 case IEEE80211_AMPDU_TX_STOP_CONT
:
6386 case IEEE80211_AMPDU_TX_STOP_FLUSH
:
6387 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT
:
6388 case IEEE80211_AMPDU_TX_OPERATIONAL
:
6389 /* Firmware offloads Tx aggregation entirely so deny mac80211
6390 * Tx aggregation requests.
6399 ath10k_mac_update_rx_channel(struct ath10k
*ar
,
6400 struct ieee80211_chanctx_conf
*ctx
,
6401 struct ieee80211_vif_chanctx_switch
*vifs
,
6404 struct cfg80211_chan_def
*def
= NULL
;
6406 /* Both locks are required because ar->rx_channel is modified. This
6407 * allows readers to hold either lock.
6409 lockdep_assert_held(&ar
->conf_mutex
);
6410 lockdep_assert_held(&ar
->data_lock
);
6412 WARN_ON(ctx
&& vifs
);
6413 WARN_ON(vifs
&& n_vifs
!= 1);
6415 /* FIXME: Sort of an optimization and a workaround. Peers and vifs are
6416 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
6417 * ppdu on Rx may reduce performance on low-end systems. It should be
6418 * possible to make tables/hashmaps to speed the lookup up (be vary of
6419 * cpu data cache lines though regarding sizes) but to keep the initial
6420 * implementation simple and less intrusive fallback to the slow lookup
6421 * only for multi-channel cases. Single-channel cases will remain to
6422 * use the old channel derival and thus performance should not be
6426 if (!ctx
&& ath10k_mac_num_chanctxs(ar
) == 1) {
6427 ieee80211_iter_chan_contexts_atomic(ar
->hw
,
6428 ath10k_mac_get_any_chandef_iter
,
6432 def
= &vifs
[0].new_ctx
->def
;
6434 ar
->rx_channel
= def
->chan
;
6435 } else if (ctx
&& ath10k_mac_num_chanctxs(ar
) == 0) {
6436 ar
->rx_channel
= ctx
->def
.chan
;
6438 ar
->rx_channel
= NULL
;
6444 ath10k_mac_update_vif_chan(struct ath10k
*ar
,
6445 struct ieee80211_vif_chanctx_switch
*vifs
,
6448 struct ath10k_vif
*arvif
;
6452 lockdep_assert_held(&ar
->conf_mutex
);
6454 /* First stop monitor interface. Some FW versions crash if there's a
6455 * lone monitor interface.
6457 if (ar
->monitor_started
)
6458 ath10k_monitor_stop(ar
);
6460 for (i
= 0; i
< n_vifs
; i
++) {
6461 arvif
= ath10k_vif_to_arvif(vifs
[i
].vif
);
6463 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6464 "mac chanctx switch vdev_id %i freq %hu->%hu width %d->%d\n",
6466 vifs
[i
].old_ctx
->def
.chan
->center_freq
,
6467 vifs
[i
].new_ctx
->def
.chan
->center_freq
,
6468 vifs
[i
].old_ctx
->def
.width
,
6469 vifs
[i
].new_ctx
->def
.width
);
6471 if (WARN_ON(!arvif
->is_started
))
6474 if (WARN_ON(!arvif
->is_up
))
6477 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
6479 ath10k_warn(ar
, "failed to down vdev %d: %d\n",
6480 arvif
->vdev_id
, ret
);
6485 /* All relevant vdevs are downed and associated channel resources
6486 * should be available for the channel switch now.
6489 spin_lock_bh(&ar
->data_lock
);
6490 ath10k_mac_update_rx_channel(ar
, NULL
, vifs
, n_vifs
);
6491 spin_unlock_bh(&ar
->data_lock
);
6493 for (i
= 0; i
< n_vifs
; i
++) {
6494 arvif
= ath10k_vif_to_arvif(vifs
[i
].vif
);
6496 if (WARN_ON(!arvif
->is_started
))
6499 if (WARN_ON(!arvif
->is_up
))
6502 ret
= ath10k_mac_setup_bcn_tmpl(arvif
);
6504 ath10k_warn(ar
, "failed to update bcn tmpl during csa: %d\n",
6507 ret
= ath10k_mac_setup_prb_tmpl(arvif
);
6509 ath10k_warn(ar
, "failed to update prb tmpl during csa: %d\n",
6512 ret
= ath10k_vdev_restart(arvif
, &vifs
[i
].new_ctx
->def
);
6514 ath10k_warn(ar
, "failed to restart vdev %d: %d\n",
6515 arvif
->vdev_id
, ret
);
6519 ret
= ath10k_wmi_vdev_up(arvif
->ar
, arvif
->vdev_id
, arvif
->aid
,
6522 ath10k_warn(ar
, "failed to bring vdev up %d: %d\n",
6523 arvif
->vdev_id
, ret
);
6528 ath10k_monitor_recalc(ar
);
6532 ath10k_mac_op_add_chanctx(struct ieee80211_hw
*hw
,
6533 struct ieee80211_chanctx_conf
*ctx
)
6535 struct ath10k
*ar
= hw
->priv
;
6537 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6538 "mac chanctx add freq %hu width %d ptr %p\n",
6539 ctx
->def
.chan
->center_freq
, ctx
->def
.width
, ctx
);
6541 mutex_lock(&ar
->conf_mutex
);
6543 spin_lock_bh(&ar
->data_lock
);
6544 ath10k_mac_update_rx_channel(ar
, ctx
, NULL
, 0);
6545 spin_unlock_bh(&ar
->data_lock
);
6547 ath10k_recalc_radar_detection(ar
);
6548 ath10k_monitor_recalc(ar
);
6550 mutex_unlock(&ar
->conf_mutex
);
6556 ath10k_mac_op_remove_chanctx(struct ieee80211_hw
*hw
,
6557 struct ieee80211_chanctx_conf
*ctx
)
6559 struct ath10k
*ar
= hw
->priv
;
6561 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6562 "mac chanctx remove freq %hu width %d ptr %p\n",
6563 ctx
->def
.chan
->center_freq
, ctx
->def
.width
, ctx
);
6565 mutex_lock(&ar
->conf_mutex
);
6567 spin_lock_bh(&ar
->data_lock
);
6568 ath10k_mac_update_rx_channel(ar
, NULL
, NULL
, 0);
6569 spin_unlock_bh(&ar
->data_lock
);
6571 ath10k_recalc_radar_detection(ar
);
6572 ath10k_monitor_recalc(ar
);
6574 mutex_unlock(&ar
->conf_mutex
);
6577 struct ath10k_mac_change_chanctx_arg
{
6578 struct ieee80211_chanctx_conf
*ctx
;
6579 struct ieee80211_vif_chanctx_switch
*vifs
;
6585 ath10k_mac_change_chanctx_cnt_iter(void *data
, u8
*mac
,
6586 struct ieee80211_vif
*vif
)
6588 struct ath10k_mac_change_chanctx_arg
*arg
= data
;
6590 if (rcu_access_pointer(vif
->chanctx_conf
) != arg
->ctx
)
6597 ath10k_mac_change_chanctx_fill_iter(void *data
, u8
*mac
,
6598 struct ieee80211_vif
*vif
)
6600 struct ath10k_mac_change_chanctx_arg
*arg
= data
;
6601 struct ieee80211_chanctx_conf
*ctx
;
6603 ctx
= rcu_access_pointer(vif
->chanctx_conf
);
6604 if (ctx
!= arg
->ctx
)
6607 if (WARN_ON(arg
->next_vif
== arg
->n_vifs
))
6610 arg
->vifs
[arg
->next_vif
].vif
= vif
;
6611 arg
->vifs
[arg
->next_vif
].old_ctx
= ctx
;
6612 arg
->vifs
[arg
->next_vif
].new_ctx
= ctx
;
6617 ath10k_mac_op_change_chanctx(struct ieee80211_hw
*hw
,
6618 struct ieee80211_chanctx_conf
*ctx
,
6621 struct ath10k
*ar
= hw
->priv
;
6622 struct ath10k_mac_change_chanctx_arg arg
= { .ctx
= ctx
};
6624 mutex_lock(&ar
->conf_mutex
);
6626 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6627 "mac chanctx change freq %hu width %d ptr %p changed %x\n",
6628 ctx
->def
.chan
->center_freq
, ctx
->def
.width
, ctx
, changed
);
6630 /* This shouldn't really happen because channel switching should use
6631 * switch_vif_chanctx().
6633 if (WARN_ON(changed
& IEEE80211_CHANCTX_CHANGE_CHANNEL
))
6636 if (changed
& IEEE80211_CHANCTX_CHANGE_WIDTH
) {
6637 ieee80211_iterate_active_interfaces_atomic(
6639 IEEE80211_IFACE_ITER_NORMAL
,
6640 ath10k_mac_change_chanctx_cnt_iter
,
6642 if (arg
.n_vifs
== 0)
6645 arg
.vifs
= kcalloc(arg
.n_vifs
, sizeof(arg
.vifs
[0]),
6650 ieee80211_iterate_active_interfaces_atomic(
6652 IEEE80211_IFACE_ITER_NORMAL
,
6653 ath10k_mac_change_chanctx_fill_iter
,
6655 ath10k_mac_update_vif_chan(ar
, arg
.vifs
, arg
.n_vifs
);
6660 ath10k_recalc_radar_detection(ar
);
6662 /* FIXME: How to configure Rx chains properly? */
6664 /* No other actions are actually necessary. Firmware maintains channel
6665 * definitions per vdev internally and there's no host-side channel
6666 * context abstraction to configure, e.g. channel width.
6670 mutex_unlock(&ar
->conf_mutex
);
6674 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw
*hw
,
6675 struct ieee80211_vif
*vif
,
6676 struct ieee80211_chanctx_conf
*ctx
)
6678 struct ath10k
*ar
= hw
->priv
;
6679 struct ath10k_vif
*arvif
= (void *)vif
->drv_priv
;
6682 mutex_lock(&ar
->conf_mutex
);
6684 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6685 "mac chanctx assign ptr %p vdev_id %i\n",
6686 ctx
, arvif
->vdev_id
);
6688 if (WARN_ON(arvif
->is_started
)) {
6689 mutex_unlock(&ar
->conf_mutex
);
6693 ret
= ath10k_vdev_start(arvif
, &ctx
->def
);
6695 ath10k_warn(ar
, "failed to start vdev %i addr %pM on freq %d: %d\n",
6696 arvif
->vdev_id
, vif
->addr
,
6697 ctx
->def
.chan
->center_freq
, ret
);
6701 arvif
->is_started
= true;
6703 ret
= ath10k_mac_vif_setup_ps(arvif
);
6705 ath10k_warn(ar
, "failed to update vdev %i ps: %d\n",
6706 arvif
->vdev_id
, ret
);
6710 if (vif
->type
== NL80211_IFTYPE_MONITOR
) {
6711 ret
= ath10k_wmi_vdev_up(ar
, arvif
->vdev_id
, 0, vif
->addr
);
6713 ath10k_warn(ar
, "failed to up monitor vdev %i: %d\n",
6714 arvif
->vdev_id
, ret
);
6718 arvif
->is_up
= true;
6721 mutex_unlock(&ar
->conf_mutex
);
6725 ath10k_vdev_stop(arvif
);
6726 arvif
->is_started
= false;
6727 ath10k_mac_vif_setup_ps(arvif
);
6730 mutex_unlock(&ar
->conf_mutex
);
6735 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw
*hw
,
6736 struct ieee80211_vif
*vif
,
6737 struct ieee80211_chanctx_conf
*ctx
)
6739 struct ath10k
*ar
= hw
->priv
;
6740 struct ath10k_vif
*arvif
= (void *)vif
->drv_priv
;
6743 mutex_lock(&ar
->conf_mutex
);
6745 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6746 "mac chanctx unassign ptr %p vdev_id %i\n",
6747 ctx
, arvif
->vdev_id
);
6749 WARN_ON(!arvif
->is_started
);
6751 if (vif
->type
== NL80211_IFTYPE_MONITOR
) {
6752 WARN_ON(!arvif
->is_up
);
6754 ret
= ath10k_wmi_vdev_down(ar
, arvif
->vdev_id
);
6756 ath10k_warn(ar
, "failed to down monitor vdev %i: %d\n",
6757 arvif
->vdev_id
, ret
);
6759 arvif
->is_up
= false;
6762 ret
= ath10k_vdev_stop(arvif
);
6764 ath10k_warn(ar
, "failed to stop vdev %i: %d\n",
6765 arvif
->vdev_id
, ret
);
6767 arvif
->is_started
= false;
6769 mutex_unlock(&ar
->conf_mutex
);
6773 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw
*hw
,
6774 struct ieee80211_vif_chanctx_switch
*vifs
,
6776 enum ieee80211_chanctx_switch_mode mode
)
6778 struct ath10k
*ar
= hw
->priv
;
6780 mutex_lock(&ar
->conf_mutex
);
6782 ath10k_dbg(ar
, ATH10K_DBG_MAC
,
6783 "mac chanctx switch n_vifs %d mode %d\n",
6785 ath10k_mac_update_vif_chan(ar
, vifs
, n_vifs
);
6787 mutex_unlock(&ar
->conf_mutex
);
6791 static const struct ieee80211_ops ath10k_ops
= {
6793 .start
= ath10k_start
,
6794 .stop
= ath10k_stop
,
6795 .config
= ath10k_config
,
6796 .add_interface
= ath10k_add_interface
,
6797 .remove_interface
= ath10k_remove_interface
,
6798 .configure_filter
= ath10k_configure_filter
,
6799 .bss_info_changed
= ath10k_bss_info_changed
,
6800 .hw_scan
= ath10k_hw_scan
,
6801 .cancel_hw_scan
= ath10k_cancel_hw_scan
,
6802 .set_key
= ath10k_set_key
,
6803 .set_default_unicast_key
= ath10k_set_default_unicast_key
,
6804 .sta_state
= ath10k_sta_state
,
6805 .conf_tx
= ath10k_conf_tx
,
6806 .remain_on_channel
= ath10k_remain_on_channel
,
6807 .cancel_remain_on_channel
= ath10k_cancel_remain_on_channel
,
6808 .set_rts_threshold
= ath10k_set_rts_threshold
,
6809 .set_frag_threshold
= ath10k_mac_op_set_frag_threshold
,
6810 .flush
= ath10k_flush
,
6811 .tx_last_beacon
= ath10k_tx_last_beacon
,
6812 .set_antenna
= ath10k_set_antenna
,
6813 .get_antenna
= ath10k_get_antenna
,
6814 .reconfig_complete
= ath10k_reconfig_complete
,
6815 .get_survey
= ath10k_get_survey
,
6816 .set_bitrate_mask
= ath10k_mac_op_set_bitrate_mask
,
6817 .sta_rc_update
= ath10k_sta_rc_update
,
6818 .get_tsf
= ath10k_get_tsf
,
6819 .ampdu_action
= ath10k_ampdu_action
,
6820 .get_et_sset_count
= ath10k_debug_get_et_sset_count
,
6821 .get_et_stats
= ath10k_debug_get_et_stats
,
6822 .get_et_strings
= ath10k_debug_get_et_strings
,
6823 .add_chanctx
= ath10k_mac_op_add_chanctx
,
6824 .remove_chanctx
= ath10k_mac_op_remove_chanctx
,
6825 .change_chanctx
= ath10k_mac_op_change_chanctx
,
6826 .assign_vif_chanctx
= ath10k_mac_op_assign_vif_chanctx
,
6827 .unassign_vif_chanctx
= ath10k_mac_op_unassign_vif_chanctx
,
6828 .switch_vif_chanctx
= ath10k_mac_op_switch_vif_chanctx
,
6830 CFG80211_TESTMODE_CMD(ath10k_tm_cmd
)
6833 .suspend
= ath10k_wow_op_suspend
,
6834 .resume
= ath10k_wow_op_resume
,
6836 #ifdef CONFIG_MAC80211_DEBUGFS
6837 .sta_add_debugfs
= ath10k_sta_add_debugfs
,
6841 #define CHAN2G(_channel, _freq, _flags) { \
6842 .band = IEEE80211_BAND_2GHZ, \
6843 .hw_value = (_channel), \
6844 .center_freq = (_freq), \
6845 .flags = (_flags), \
6846 .max_antenna_gain = 0, \
6850 #define CHAN5G(_channel, _freq, _flags) { \
6851 .band = IEEE80211_BAND_5GHZ, \
6852 .hw_value = (_channel), \
6853 .center_freq = (_freq), \
6854 .flags = (_flags), \
6855 .max_antenna_gain = 0, \
6859 static const struct ieee80211_channel ath10k_2ghz_channels
[] = {
6869 CHAN2G(10, 2457, 0),
6870 CHAN2G(11, 2462, 0),
6871 CHAN2G(12, 2467, 0),
6872 CHAN2G(13, 2472, 0),
6873 CHAN2G(14, 2484, 0),
6876 static const struct ieee80211_channel ath10k_5ghz_channels
[] = {
6877 CHAN5G(36, 5180, 0),
6878 CHAN5G(40, 5200, 0),
6879 CHAN5G(44, 5220, 0),
6880 CHAN5G(48, 5240, 0),
6881 CHAN5G(52, 5260, 0),
6882 CHAN5G(56, 5280, 0),
6883 CHAN5G(60, 5300, 0),
6884 CHAN5G(64, 5320, 0),
6885 CHAN5G(100, 5500, 0),
6886 CHAN5G(104, 5520, 0),
6887 CHAN5G(108, 5540, 0),
6888 CHAN5G(112, 5560, 0),
6889 CHAN5G(116, 5580, 0),
6890 CHAN5G(120, 5600, 0),
6891 CHAN5G(124, 5620, 0),
6892 CHAN5G(128, 5640, 0),
6893 CHAN5G(132, 5660, 0),
6894 CHAN5G(136, 5680, 0),
6895 CHAN5G(140, 5700, 0),
6896 CHAN5G(144, 5720, 0),
6897 CHAN5G(149, 5745, 0),
6898 CHAN5G(153, 5765, 0),
6899 CHAN5G(157, 5785, 0),
6900 CHAN5G(161, 5805, 0),
6901 CHAN5G(165, 5825, 0),
6904 struct ath10k
*ath10k_mac_create(size_t priv_size
)
6906 struct ieee80211_hw
*hw
;
6909 hw
= ieee80211_alloc_hw(sizeof(struct ath10k
) + priv_size
, &ath10k_ops
);
6919 void ath10k_mac_destroy(struct ath10k
*ar
)
6921 ieee80211_free_hw(ar
->hw
);
6924 static const struct ieee80211_iface_limit ath10k_if_limits
[] = {
6927 .types
= BIT(NL80211_IFTYPE_STATION
)
6928 | BIT(NL80211_IFTYPE_P2P_CLIENT
)
6932 .types
= BIT(NL80211_IFTYPE_P2P_GO
)
6936 .types
= BIT(NL80211_IFTYPE_P2P_DEVICE
)
6940 .types
= BIT(NL80211_IFTYPE_AP
)
6941 #ifdef CONFIG_MAC80211_MESH
6942 | BIT(NL80211_IFTYPE_MESH_POINT
)
6947 static const struct ieee80211_iface_limit ath10k_10x_if_limits
[] = {
6950 .types
= BIT(NL80211_IFTYPE_AP
)
6951 #ifdef CONFIG_MAC80211_MESH
6952 | BIT(NL80211_IFTYPE_MESH_POINT
)
6957 .types
= BIT(NL80211_IFTYPE_STATION
)
6961 static const struct ieee80211_iface_combination ath10k_if_comb
[] = {
6963 .limits
= ath10k_if_limits
,
6964 .n_limits
= ARRAY_SIZE(ath10k_if_limits
),
6965 .max_interfaces
= 8,
6966 .num_different_channels
= 1,
6967 .beacon_int_infra_match
= true,
6971 static const struct ieee80211_iface_combination ath10k_10x_if_comb
[] = {
6973 .limits
= ath10k_10x_if_limits
,
6974 .n_limits
= ARRAY_SIZE(ath10k_10x_if_limits
),
6975 .max_interfaces
= 8,
6976 .num_different_channels
= 1,
6977 .beacon_int_infra_match
= true,
6978 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
6979 .radar_detect_widths
= BIT(NL80211_CHAN_WIDTH_20_NOHT
) |
6980 BIT(NL80211_CHAN_WIDTH_20
) |
6981 BIT(NL80211_CHAN_WIDTH_40
) |
6982 BIT(NL80211_CHAN_WIDTH_80
),
6987 static const struct ieee80211_iface_limit ath10k_tlv_if_limit
[] = {
6990 .types
= BIT(NL80211_IFTYPE_STATION
),
6994 .types
= BIT(NL80211_IFTYPE_AP
) |
6995 #ifdef CONFIG_MAC80211_MESH
6996 BIT(NL80211_IFTYPE_MESH_POINT
) |
6998 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
6999 BIT(NL80211_IFTYPE_P2P_GO
),
7003 .types
= BIT(NL80211_IFTYPE_P2P_DEVICE
),
7007 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit
[] = {
7010 .types
= BIT(NL80211_IFTYPE_STATION
),
7014 .types
= BIT(NL80211_IFTYPE_P2P_CLIENT
),
7018 .types
= BIT(NL80211_IFTYPE_AP
) |
7019 #ifdef CONFIG_MAC80211_MESH
7020 BIT(NL80211_IFTYPE_MESH_POINT
) |
7022 BIT(NL80211_IFTYPE_P2P_GO
),
7026 .types
= BIT(NL80211_IFTYPE_P2P_DEVICE
),
7030 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss
[] = {
7033 .types
= BIT(NL80211_IFTYPE_STATION
),
7037 .types
= BIT(NL80211_IFTYPE_ADHOC
),
7041 /* FIXME: This is not thouroughly tested. These combinations may over- or
7042 * underestimate hw/fw capabilities.
7044 static struct ieee80211_iface_combination ath10k_tlv_if_comb
[] = {
7046 .limits
= ath10k_tlv_if_limit
,
7047 .num_different_channels
= 1,
7048 .max_interfaces
= 4,
7049 .n_limits
= ARRAY_SIZE(ath10k_tlv_if_limit
),
7052 .limits
= ath10k_tlv_if_limit_ibss
,
7053 .num_different_channels
= 1,
7054 .max_interfaces
= 2,
7055 .n_limits
= ARRAY_SIZE(ath10k_tlv_if_limit_ibss
),
7059 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb
[] = {
7061 .limits
= ath10k_tlv_if_limit
,
7062 .num_different_channels
= 1,
7063 .max_interfaces
= 4,
7064 .n_limits
= ARRAY_SIZE(ath10k_tlv_if_limit
),
7067 .limits
= ath10k_tlv_qcs_if_limit
,
7068 .num_different_channels
= 2,
7069 .max_interfaces
= 4,
7070 .n_limits
= ARRAY_SIZE(ath10k_tlv_qcs_if_limit
),
7073 .limits
= ath10k_tlv_if_limit_ibss
,
7074 .num_different_channels
= 1,
7075 .max_interfaces
= 2,
7076 .n_limits
= ARRAY_SIZE(ath10k_tlv_if_limit_ibss
),
7080 static const struct ieee80211_iface_limit ath10k_10_4_if_limits
[] = {
7083 .types
= BIT(NL80211_IFTYPE_STATION
),
7087 .types
= BIT(NL80211_IFTYPE_AP
)
7088 #ifdef CONFIG_MAC80211_MESH
7089 | BIT(NL80211_IFTYPE_MESH_POINT
)
7094 static const struct ieee80211_iface_combination ath10k_10_4_if_comb
[] = {
7096 .limits
= ath10k_10_4_if_limits
,
7097 .n_limits
= ARRAY_SIZE(ath10k_10_4_if_limits
),
7098 .max_interfaces
= 16,
7099 .num_different_channels
= 1,
7100 .beacon_int_infra_match
= true,
7101 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
7102 .radar_detect_widths
= BIT(NL80211_CHAN_WIDTH_20_NOHT
) |
7103 BIT(NL80211_CHAN_WIDTH_20
) |
7104 BIT(NL80211_CHAN_WIDTH_40
) |
7105 BIT(NL80211_CHAN_WIDTH_80
),
7110 static void ath10k_get_arvif_iter(void *data
, u8
*mac
,
7111 struct ieee80211_vif
*vif
)
7113 struct ath10k_vif_iter
*arvif_iter
= data
;
7114 struct ath10k_vif
*arvif
= ath10k_vif_to_arvif(vif
);
7116 if (arvif
->vdev_id
== arvif_iter
->vdev_id
)
7117 arvif_iter
->arvif
= arvif
;
7120 struct ath10k_vif
*ath10k_get_arvif(struct ath10k
*ar
, u32 vdev_id
)
7122 struct ath10k_vif_iter arvif_iter
;
7125 memset(&arvif_iter
, 0, sizeof(struct ath10k_vif_iter
));
7126 arvif_iter
.vdev_id
= vdev_id
;
7128 flags
= IEEE80211_IFACE_ITER_RESUME_ALL
;
7129 ieee80211_iterate_active_interfaces_atomic(ar
->hw
,
7131 ath10k_get_arvif_iter
,
7133 if (!arvif_iter
.arvif
) {
7134 ath10k_warn(ar
, "No VIF found for vdev %d\n", vdev_id
);
7138 return arvif_iter
.arvif
;
7141 int ath10k_mac_register(struct ath10k
*ar
)
7143 static const u32 cipher_suites
[] = {
7144 WLAN_CIPHER_SUITE_WEP40
,
7145 WLAN_CIPHER_SUITE_WEP104
,
7146 WLAN_CIPHER_SUITE_TKIP
,
7147 WLAN_CIPHER_SUITE_CCMP
,
7148 WLAN_CIPHER_SUITE_AES_CMAC
,
7150 struct ieee80211_supported_band
*band
;
7154 SET_IEEE80211_PERM_ADDR(ar
->hw
, ar
->mac_addr
);
7156 SET_IEEE80211_DEV(ar
->hw
, ar
->dev
);
7158 BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels
) +
7159 ARRAY_SIZE(ath10k_5ghz_channels
)) !=
7162 if (ar
->phy_capability
& WHAL_WLAN_11G_CAPABILITY
) {
7163 channels
= kmemdup(ath10k_2ghz_channels
,
7164 sizeof(ath10k_2ghz_channels
),
7171 band
= &ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
];
7172 band
->n_channels
= ARRAY_SIZE(ath10k_2ghz_channels
);
7173 band
->channels
= channels
;
7174 band
->n_bitrates
= ath10k_g_rates_size
;
7175 band
->bitrates
= ath10k_g_rates
;
7177 ar
->hw
->wiphy
->bands
[IEEE80211_BAND_2GHZ
] = band
;
7180 if (ar
->phy_capability
& WHAL_WLAN_11A_CAPABILITY
) {
7181 channels
= kmemdup(ath10k_5ghz_channels
,
7182 sizeof(ath10k_5ghz_channels
),
7189 band
= &ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
];
7190 band
->n_channels
= ARRAY_SIZE(ath10k_5ghz_channels
);
7191 band
->channels
= channels
;
7192 band
->n_bitrates
= ath10k_a_rates_size
;
7193 band
->bitrates
= ath10k_a_rates
;
7194 ar
->hw
->wiphy
->bands
[IEEE80211_BAND_5GHZ
] = band
;
7197 ath10k_mac_setup_ht_vht_cap(ar
);
7199 ar
->hw
->wiphy
->interface_modes
=
7200 BIT(NL80211_IFTYPE_STATION
) |
7201 BIT(NL80211_IFTYPE_AP
) |
7202 BIT(NL80211_IFTYPE_MESH_POINT
);
7204 ar
->hw
->wiphy
->available_antennas_rx
= ar
->cfg_rx_chainmask
;
7205 ar
->hw
->wiphy
->available_antennas_tx
= ar
->cfg_tx_chainmask
;
7207 if (!test_bit(ATH10K_FW_FEATURE_NO_P2P
, ar
->fw_features
))
7208 ar
->hw
->wiphy
->interface_modes
|=
7209 BIT(NL80211_IFTYPE_P2P_DEVICE
) |
7210 BIT(NL80211_IFTYPE_P2P_CLIENT
) |
7211 BIT(NL80211_IFTYPE_P2P_GO
);
7213 ieee80211_hw_set(ar
->hw
, SIGNAL_DBM
);
7214 ieee80211_hw_set(ar
->hw
, SUPPORTS_PS
);
7215 ieee80211_hw_set(ar
->hw
, SUPPORTS_DYNAMIC_PS
);
7216 ieee80211_hw_set(ar
->hw
, MFP_CAPABLE
);
7217 ieee80211_hw_set(ar
->hw
, REPORTS_TX_ACK_STATUS
);
7218 ieee80211_hw_set(ar
->hw
, HAS_RATE_CONTROL
);
7219 ieee80211_hw_set(ar
->hw
, AP_LINK_PS
);
7220 ieee80211_hw_set(ar
->hw
, SPECTRUM_MGMT
);
7221 ieee80211_hw_set(ar
->hw
, SUPPORT_FAST_XMIT
);
7222 ieee80211_hw_set(ar
->hw
, CONNECTION_MONITOR
);
7223 ieee80211_hw_set(ar
->hw
, SUPPORTS_PER_STA_GTK
);
7224 ieee80211_hw_set(ar
->hw
, WANT_MONITOR_VIF
);
7225 ieee80211_hw_set(ar
->hw
, CHANCTX_STA_CSA
);
7226 ieee80211_hw_set(ar
->hw
, QUEUE_CONTROL
);
7228 if (!test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
))
7229 ieee80211_hw_set(ar
->hw
, SW_CRYPTO_CONTROL
);
7231 ar
->hw
->wiphy
->features
|= NL80211_FEATURE_STATIC_SMPS
;
7232 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_IBSS_RSN
;
7234 if (ar
->ht_cap_info
& WMI_HT_CAP_DYNAMIC_SMPS
)
7235 ar
->hw
->wiphy
->features
|= NL80211_FEATURE_DYNAMIC_SMPS
;
7237 if (ar
->ht_cap_info
& WMI_HT_CAP_ENABLED
) {
7238 ieee80211_hw_set(ar
->hw
, AMPDU_AGGREGATION
);
7239 ieee80211_hw_set(ar
->hw
, TX_AMPDU_SETUP_IN_HW
);
7242 ar
->hw
->wiphy
->max_scan_ssids
= WLAN_SCAN_PARAMS_MAX_SSID
;
7243 ar
->hw
->wiphy
->max_scan_ie_len
= WLAN_SCAN_PARAMS_MAX_IE_LEN
;
7245 ar
->hw
->vif_data_size
= sizeof(struct ath10k_vif
);
7246 ar
->hw
->sta_data_size
= sizeof(struct ath10k_sta
);
7248 ar
->hw
->max_listen_interval
= ATH10K_MAX_HW_LISTEN_INTERVAL
;
7250 if (test_bit(WMI_SERVICE_BEACON_OFFLOAD
, ar
->wmi
.svc_map
)) {
7251 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD
;
7253 /* Firmware delivers WPS/P2P Probe Requests frames to driver so
7254 * that userspace (e.g. wpa_supplicant/hostapd) can generate
7255 * correct Probe Responses. This is more of a hack advert..
7257 ar
->hw
->wiphy
->probe_resp_offload
|=
7258 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS
|
7259 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2
|
7260 NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P
;
7263 if (test_bit(WMI_SERVICE_TDLS
, ar
->wmi
.svc_map
))
7264 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_SUPPORTS_TDLS
;
7266 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL
;
7267 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_HAS_CHANNEL_SWITCH
;
7268 ar
->hw
->wiphy
->max_remain_on_channel_duration
= 5000;
7270 ar
->hw
->wiphy
->flags
|= WIPHY_FLAG_AP_UAPSD
;
7271 ar
->hw
->wiphy
->features
|= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE
;
7273 ar
->hw
->wiphy
->max_ap_assoc_sta
= ar
->max_num_stations
;
7275 ret
= ath10k_wow_init(ar
);
7277 ath10k_warn(ar
, "failed to init wow: %d\n", ret
);
7281 wiphy_ext_feature_set(ar
->hw
->wiphy
, NL80211_EXT_FEATURE_VHT_IBSS
);
7284 * on LL hardware queues are managed entirely by the FW
7285 * so we only advertise to mac we can do the queues thing
7287 ar
->hw
->queues
= IEEE80211_MAX_QUEUES
;
7289 /* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
7290 * something that vdev_ids can't reach so that we don't stop the queue
7293 ar
->hw
->offchannel_tx_hw_queue
= IEEE80211_MAX_QUEUES
- 1;
7295 switch (ar
->wmi
.op_version
) {
7296 case ATH10K_FW_WMI_OP_VERSION_MAIN
:
7297 ar
->hw
->wiphy
->iface_combinations
= ath10k_if_comb
;
7298 ar
->hw
->wiphy
->n_iface_combinations
=
7299 ARRAY_SIZE(ath10k_if_comb
);
7300 ar
->hw
->wiphy
->interface_modes
|= BIT(NL80211_IFTYPE_ADHOC
);
7302 case ATH10K_FW_WMI_OP_VERSION_TLV
:
7303 if (test_bit(WMI_SERVICE_ADAPTIVE_OCS
, ar
->wmi
.svc_map
)) {
7304 ar
->hw
->wiphy
->iface_combinations
=
7305 ath10k_tlv_qcs_if_comb
;
7306 ar
->hw
->wiphy
->n_iface_combinations
=
7307 ARRAY_SIZE(ath10k_tlv_qcs_if_comb
);
7309 ar
->hw
->wiphy
->iface_combinations
= ath10k_tlv_if_comb
;
7310 ar
->hw
->wiphy
->n_iface_combinations
=
7311 ARRAY_SIZE(ath10k_tlv_if_comb
);
7313 ar
->hw
->wiphy
->interface_modes
|= BIT(NL80211_IFTYPE_ADHOC
);
7315 case ATH10K_FW_WMI_OP_VERSION_10_1
:
7316 case ATH10K_FW_WMI_OP_VERSION_10_2
:
7317 case ATH10K_FW_WMI_OP_VERSION_10_2_4
:
7318 ar
->hw
->wiphy
->iface_combinations
= ath10k_10x_if_comb
;
7319 ar
->hw
->wiphy
->n_iface_combinations
=
7320 ARRAY_SIZE(ath10k_10x_if_comb
);
7322 case ATH10K_FW_WMI_OP_VERSION_10_4
:
7323 ar
->hw
->wiphy
->iface_combinations
= ath10k_10_4_if_comb
;
7324 ar
->hw
->wiphy
->n_iface_combinations
=
7325 ARRAY_SIZE(ath10k_10_4_if_comb
);
7327 case ATH10K_FW_WMI_OP_VERSION_UNSET
:
7328 case ATH10K_FW_WMI_OP_VERSION_MAX
:
7334 if (!test_bit(ATH10K_FLAG_RAW_MODE
, &ar
->dev_flags
))
7335 ar
->hw
->netdev_features
= NETIF_F_HW_CSUM
;
7337 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
)) {
7338 /* Init ath dfs pattern detector */
7339 ar
->ath_common
.debug_mask
= ATH_DBG_DFS
;
7340 ar
->dfs_detector
= dfs_pattern_detector_init(&ar
->ath_common
,
7343 if (!ar
->dfs_detector
)
7344 ath10k_warn(ar
, "failed to initialise DFS pattern detector\n");
7347 ret
= ath_regd_init(&ar
->ath_common
.regulatory
, ar
->hw
->wiphy
,
7348 ath10k_reg_notifier
);
7350 ath10k_err(ar
, "failed to initialise regulatory: %i\n", ret
);
7351 goto err_dfs_detector_exit
;
7354 ar
->hw
->wiphy
->cipher_suites
= cipher_suites
;
7355 ar
->hw
->wiphy
->n_cipher_suites
= ARRAY_SIZE(cipher_suites
);
7357 ret
= ieee80211_register_hw(ar
->hw
);
7359 ath10k_err(ar
, "failed to register ieee80211: %d\n", ret
);
7360 goto err_dfs_detector_exit
;
7363 if (!ath_is_world_regd(&ar
->ath_common
.regulatory
)) {
7364 ret
= regulatory_hint(ar
->hw
->wiphy
,
7365 ar
->ath_common
.regulatory
.alpha2
);
7367 goto err_unregister
;
7373 ieee80211_unregister_hw(ar
->hw
);
7375 err_dfs_detector_exit
:
7376 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
)
7377 ar
->dfs_detector
->exit(ar
->dfs_detector
);
7380 kfree(ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
].channels
);
7381 kfree(ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
].channels
);
7383 SET_IEEE80211_DEV(ar
->hw
, NULL
);
7387 void ath10k_mac_unregister(struct ath10k
*ar
)
7389 ieee80211_unregister_hw(ar
->hw
);
7391 if (config_enabled(CONFIG_ATH10K_DFS_CERTIFIED
) && ar
->dfs_detector
)
7392 ar
->dfs_detector
->exit(ar
->dfs_detector
);
7394 kfree(ar
->mac
.sbands
[IEEE80211_BAND_2GHZ
].channels
);
7395 kfree(ar
->mac
.sbands
[IEEE80211_BAND_5GHZ
].channels
);
7397 SET_IEEE80211_DEV(ar
->hw
, NULL
);