1 // SPDX-License-Identifier: ISC
2 /*
3  * Copyright (c) 2005-2011 Atheros Communications Inc.
4  * Copyright (c) 2011-2017 Qualcomm Atheros, Inc.
5  * Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
6  */
7 
8 #include "mac.h"
9 
10 #include <net/cfg80211.h>
11 #include <net/mac80211.h>
12 #include <linux/etherdevice.h>
13 #include <linux/acpi.h>
14 #include <linux/of.h>
15 #include <linux/bitfield.h>
16 
17 #include "hif.h"
18 #include "core.h"
19 #include "debug.h"
20 #include "wmi.h"
21 #include "htt.h"
22 #include "txrx.h"
23 #include "testmode.h"
24 #include "wmi-tlv.h"
25 #include "wmi-ops.h"
26 #include "wow.h"
27 
28 /*********/
29 /* Rates */
30 /*********/
31 
32 static struct ieee80211_rate ath10k_rates[] = {
33 	{ .bitrate = 10,
34 	  .hw_value = ATH10K_HW_RATE_CCK_LP_1M },
35 	{ .bitrate = 20,
36 	  .hw_value = ATH10K_HW_RATE_CCK_LP_2M,
37 	  .hw_value_short = ATH10K_HW_RATE_CCK_SP_2M,
38 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
39 	{ .bitrate = 55,
40 	  .hw_value = ATH10K_HW_RATE_CCK_LP_5_5M,
41 	  .hw_value_short = ATH10K_HW_RATE_CCK_SP_5_5M,
42 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
43 	{ .bitrate = 110,
44 	  .hw_value = ATH10K_HW_RATE_CCK_LP_11M,
45 	  .hw_value_short = ATH10K_HW_RATE_CCK_SP_11M,
46 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
47 
48 	{ .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
49 	{ .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
50 	{ .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
51 	{ .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
52 	{ .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
53 	{ .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
54 	{ .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
55 	{ .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
56 };
57 
58 static struct ieee80211_rate ath10k_rates_rev2[] = {
59 	{ .bitrate = 10,
60 	  .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_1M },
61 	{ .bitrate = 20,
62 	  .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_2M,
63 	  .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_2M,
64 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
65 	{ .bitrate = 55,
66 	  .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_5_5M,
67 	  .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_5_5M,
68 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
69 	{ .bitrate = 110,
70 	  .hw_value = ATH10K_HW_RATE_REV2_CCK_LP_11M,
71 	  .hw_value_short = ATH10K_HW_RATE_REV2_CCK_SP_11M,
72 	  .flags = IEEE80211_RATE_SHORT_PREAMBLE },
73 
74 	{ .bitrate = 60, .hw_value = ATH10K_HW_RATE_OFDM_6M },
75 	{ .bitrate = 90, .hw_value = ATH10K_HW_RATE_OFDM_9M },
76 	{ .bitrate = 120, .hw_value = ATH10K_HW_RATE_OFDM_12M },
77 	{ .bitrate = 180, .hw_value = ATH10K_HW_RATE_OFDM_18M },
78 	{ .bitrate = 240, .hw_value = ATH10K_HW_RATE_OFDM_24M },
79 	{ .bitrate = 360, .hw_value = ATH10K_HW_RATE_OFDM_36M },
80 	{ .bitrate = 480, .hw_value = ATH10K_HW_RATE_OFDM_48M },
81 	{ .bitrate = 540, .hw_value = ATH10K_HW_RATE_OFDM_54M },
82 };
83 
84 static const struct cfg80211_sar_freq_ranges ath10k_sar_freq_ranges[] = {
85 	{.start_freq = 2402, .end_freq = 2494 },
86 	{.start_freq = 5170, .end_freq = 5875 },
87 };
88 
89 static const struct cfg80211_sar_capa ath10k_sar_capa = {
90 	.type = NL80211_SAR_TYPE_POWER,
91 	.num_freq_ranges = (ARRAY_SIZE(ath10k_sar_freq_ranges)),
92 	.freq_ranges = &ath10k_sar_freq_ranges[0],
93 };
94 
95 #define ATH10K_MAC_FIRST_OFDM_RATE_IDX 4
96 
97 #define ath10k_a_rates (ath10k_rates + ATH10K_MAC_FIRST_OFDM_RATE_IDX)
98 #define ath10k_a_rates_size (ARRAY_SIZE(ath10k_rates) - \
99 			     ATH10K_MAC_FIRST_OFDM_RATE_IDX)
100 #define ath10k_g_rates (ath10k_rates + 0)
101 #define ath10k_g_rates_size (ARRAY_SIZE(ath10k_rates))
102 
103 #define ath10k_g_rates_rev2 (ath10k_rates_rev2 + 0)
104 #define ath10k_g_rates_rev2_size (ARRAY_SIZE(ath10k_rates_rev2))
105 
106 #define ath10k_wmi_legacy_rates ath10k_rates
107 
ath10k_mac_bitrate_is_cck(int bitrate)108 static bool ath10k_mac_bitrate_is_cck(int bitrate)
109 {
110 	switch (bitrate) {
111 	case 10:
112 	case 20:
113 	case 55:
114 	case 110:
115 		return true;
116 	}
117 
118 	return false;
119 }
120 
ath10k_mac_bitrate_to_rate(int bitrate)121 static u8 ath10k_mac_bitrate_to_rate(int bitrate)
122 {
123 	return DIV_ROUND_UP(bitrate, 5) |
124 	       (ath10k_mac_bitrate_is_cck(bitrate) ? BIT(7) : 0);
125 }
126 
ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band * sband,u8 hw_rate,bool cck)127 u8 ath10k_mac_hw_rate_to_idx(const struct ieee80211_supported_band *sband,
128 			     u8 hw_rate, bool cck)
129 {
130 	const struct ieee80211_rate *rate;
131 	int i;
132 
133 	for (i = 0; i < sband->n_bitrates; i++) {
134 		rate = &sband->bitrates[i];
135 
136 		if (ath10k_mac_bitrate_is_cck(rate->bitrate) != cck)
137 			continue;
138 
139 		if (rate->hw_value == hw_rate)
140 			return i;
141 		else if (rate->flags & IEEE80211_RATE_SHORT_PREAMBLE &&
142 			 rate->hw_value_short == hw_rate)
143 			return i;
144 	}
145 
146 	return 0;
147 }
148 
ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band * sband,u32 bitrate)149 u8 ath10k_mac_bitrate_to_idx(const struct ieee80211_supported_band *sband,
150 			     u32 bitrate)
151 {
152 	int i;
153 
154 	for (i = 0; i < sband->n_bitrates; i++)
155 		if (sband->bitrates[i].bitrate == bitrate)
156 			return i;
157 
158 	return 0;
159 }
160 
ath10k_mac_get_rate_hw_value(int bitrate)161 static int ath10k_mac_get_rate_hw_value(int bitrate)
162 {
163 	int i;
164 	u8 hw_value_prefix = 0;
165 
166 	if (ath10k_mac_bitrate_is_cck(bitrate))
167 		hw_value_prefix = WMI_RATE_PREAMBLE_CCK << 6;
168 
169 	for (i = 0; i < ARRAY_SIZE(ath10k_rates); i++) {
170 		if (ath10k_rates[i].bitrate == bitrate)
171 			return hw_value_prefix | ath10k_rates[i].hw_value;
172 	}
173 
174 	return -EINVAL;
175 }
176 
ath10k_mac_get_max_vht_mcs_map(u16 mcs_map,int nss)177 static int ath10k_mac_get_max_vht_mcs_map(u16 mcs_map, int nss)
178 {
179 	switch ((mcs_map >> (2 * nss)) & 0x3) {
180 	case IEEE80211_VHT_MCS_SUPPORT_0_7: return BIT(8) - 1;
181 	case IEEE80211_VHT_MCS_SUPPORT_0_8: return BIT(9) - 1;
182 	case IEEE80211_VHT_MCS_SUPPORT_0_9: return BIT(10) - 1;
183 	}
184 	return 0;
185 }
186 
187 static u32
ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])188 ath10k_mac_max_ht_nss(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
189 {
190 	int nss;
191 
192 	for (nss = IEEE80211_HT_MCS_MASK_LEN - 1; nss >= 0; nss--)
193 		if (ht_mcs_mask[nss])
194 			return nss + 1;
195 
196 	return 1;
197 }
198 
199 static u32
ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])200 ath10k_mac_max_vht_nss(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
201 {
202 	int nss;
203 
204 	for (nss = NL80211_VHT_NSS_MAX - 1; nss >= 0; nss--)
205 		if (vht_mcs_mask[nss])
206 			return nss + 1;
207 
208 	return 1;
209 }
210 
ath10k_mac_ext_resource_config(struct ath10k * ar,u32 val)211 int ath10k_mac_ext_resource_config(struct ath10k *ar, u32 val)
212 {
213 	enum wmi_host_platform_type platform_type;
214 	int ret;
215 
216 	if (test_bit(WMI_SERVICE_TX_MODE_DYNAMIC, ar->wmi.svc_map))
217 		platform_type = WMI_HOST_PLATFORM_LOW_PERF;
218 	else
219 		platform_type = WMI_HOST_PLATFORM_HIGH_PERF;
220 
221 	ret = ath10k_wmi_ext_resource_config(ar, platform_type, val);
222 
223 	if (ret && ret != -EOPNOTSUPP) {
224 		ath10k_warn(ar, "failed to configure ext resource: %d\n", ret);
225 		return ret;
226 	}
227 
228 	return 0;
229 }
230 
231 /**********/
232 /* Crypto */
233 /**********/
234 
ath10k_send_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key,enum set_key_cmd cmd,const u8 * macaddr,u32 flags)235 static int ath10k_send_key(struct ath10k_vif *arvif,
236 			   struct ieee80211_key_conf *key,
237 			   enum set_key_cmd cmd,
238 			   const u8 *macaddr, u32 flags)
239 {
240 	struct ath10k *ar = arvif->ar;
241 	struct wmi_vdev_install_key_arg arg = {
242 		.vdev_id = arvif->vdev_id,
243 		.key_idx = key->keyidx,
244 		.key_len = key->keylen,
245 		.key_data = key->key,
246 		.key_flags = flags,
247 		.macaddr = macaddr,
248 	};
249 
250 	lockdep_assert_held(&arvif->ar->conf_mutex);
251 
252 	switch (key->cipher) {
253 	case WLAN_CIPHER_SUITE_CCMP:
254 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];
255 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
256 		break;
257 	case WLAN_CIPHER_SUITE_TKIP:
258 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_TKIP];
259 		arg.key_txmic_len = 8;
260 		arg.key_rxmic_len = 8;
261 		break;
262 	case WLAN_CIPHER_SUITE_WEP40:
263 	case WLAN_CIPHER_SUITE_WEP104:
264 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_WEP];
265 		break;
266 	case WLAN_CIPHER_SUITE_CCMP_256:
267 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_CCM];
268 		break;
269 	case WLAN_CIPHER_SUITE_GCMP:
270 	case WLAN_CIPHER_SUITE_GCMP_256:
271 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_AES_GCM];
272 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV_MGMT;
273 		break;
274 	case WLAN_CIPHER_SUITE_BIP_GMAC_128:
275 	case WLAN_CIPHER_SUITE_BIP_GMAC_256:
276 	case WLAN_CIPHER_SUITE_BIP_CMAC_256:
277 	case WLAN_CIPHER_SUITE_AES_CMAC:
278 		WARN_ON(1);
279 		return -EINVAL;
280 	default:
281 		ath10k_warn(ar, "cipher %d is not supported\n", key->cipher);
282 		return -EOPNOTSUPP;
283 	}
284 
285 	if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
286 		key->flags |= IEEE80211_KEY_FLAG_GENERATE_IV;
287 
288 	if (cmd == DISABLE_KEY) {
289 		arg.key_cipher = ar->wmi_key_cipher[WMI_CIPHER_NONE];
290 		arg.key_data = NULL;
291 	}
292 
293 	return ath10k_wmi_vdev_install_key(arvif->ar, &arg);
294 }
295 
ath10k_install_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key,enum set_key_cmd cmd,const u8 * macaddr,u32 flags)296 static int ath10k_install_key(struct ath10k_vif *arvif,
297 			      struct ieee80211_key_conf *key,
298 			      enum set_key_cmd cmd,
299 			      const u8 *macaddr, u32 flags)
300 {
301 	struct ath10k *ar = arvif->ar;
302 	int ret;
303 	unsigned long time_left;
304 
305 	lockdep_assert_held(&ar->conf_mutex);
306 
307 	reinit_completion(&ar->install_key_done);
308 
309 	if (arvif->nohwcrypt)
310 		return 1;
311 
312 	ret = ath10k_send_key(arvif, key, cmd, macaddr, flags);
313 	if (ret)
314 		return ret;
315 
316 	time_left = wait_for_completion_timeout(&ar->install_key_done, 3 * HZ);
317 	if (time_left == 0)
318 		return -ETIMEDOUT;
319 
320 	return 0;
321 }
322 
ath10k_install_peer_wep_keys(struct ath10k_vif * arvif,const u8 * addr)323 static int ath10k_install_peer_wep_keys(struct ath10k_vif *arvif,
324 					const u8 *addr)
325 {
326 	struct ath10k *ar = arvif->ar;
327 	struct ath10k_peer *peer;
328 	int ret;
329 	int i;
330 	u32 flags;
331 
332 	lockdep_assert_held(&ar->conf_mutex);
333 
334 	if (WARN_ON(arvif->vif->type != NL80211_IFTYPE_AP &&
335 		    arvif->vif->type != NL80211_IFTYPE_ADHOC &&
336 		    arvif->vif->type != NL80211_IFTYPE_MESH_POINT))
337 		return -EINVAL;
338 
339 	spin_lock_bh(&ar->data_lock);
340 	peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
341 	spin_unlock_bh(&ar->data_lock);
342 
343 	if (!peer)
344 		return -ENOENT;
345 
346 	for (i = 0; i < ARRAY_SIZE(arvif->wep_keys); i++) {
347 		if (arvif->wep_keys[i] == NULL)
348 			continue;
349 
350 		switch (arvif->vif->type) {
351 		case NL80211_IFTYPE_AP:
352 			flags = WMI_KEY_PAIRWISE;
353 
354 			if (arvif->def_wep_key_idx == i)
355 				flags |= WMI_KEY_TX_USAGE;
356 
357 			ret = ath10k_install_key(arvif, arvif->wep_keys[i],
358 						 SET_KEY, addr, flags);
359 			if (ret < 0)
360 				return ret;
361 			break;
362 		case NL80211_IFTYPE_ADHOC:
363 			ret = ath10k_install_key(arvif, arvif->wep_keys[i],
364 						 SET_KEY, addr,
365 						 WMI_KEY_PAIRWISE);
366 			if (ret < 0)
367 				return ret;
368 
369 			ret = ath10k_install_key(arvif, arvif->wep_keys[i],
370 						 SET_KEY, addr, WMI_KEY_GROUP);
371 			if (ret < 0)
372 				return ret;
373 			break;
374 		default:
375 			WARN_ON(1);
376 			return -EINVAL;
377 		}
378 
379 		spin_lock_bh(&ar->data_lock);
380 		peer->keys[i] = arvif->wep_keys[i];
381 		spin_unlock_bh(&ar->data_lock);
382 	}
383 
384 	/* In some cases (notably with static WEP IBSS with multiple keys)
385 	 * multicast Tx becomes broken. Both pairwise and groupwise keys are
386 	 * installed already. Using WMI_KEY_TX_USAGE in different combinations
387 	 * didn't seem help. Using def_keyid vdev parameter seems to be
388 	 * effective so use that.
389 	 *
390 	 * FIXME: Revisit. Perhaps this can be done in a less hacky way.
391 	 */
392 	if (arvif->vif->type != NL80211_IFTYPE_ADHOC)
393 		return 0;
394 
395 	if (arvif->def_wep_key_idx == -1)
396 		return 0;
397 
398 	ret = ath10k_wmi_vdev_set_param(arvif->ar,
399 					arvif->vdev_id,
400 					arvif->ar->wmi.vdev_param->def_keyid,
401 					arvif->def_wep_key_idx);
402 	if (ret) {
403 		ath10k_warn(ar, "failed to re-set def wpa key idxon vdev %i: %d\n",
404 			    arvif->vdev_id, ret);
405 		return ret;
406 	}
407 
408 	return 0;
409 }
410 
ath10k_clear_peer_keys(struct ath10k_vif * arvif,const u8 * addr)411 static int ath10k_clear_peer_keys(struct ath10k_vif *arvif,
412 				  const u8 *addr)
413 {
414 	struct ath10k *ar = arvif->ar;
415 	struct ath10k_peer *peer;
416 	int first_errno = 0;
417 	int ret;
418 	int i;
419 	u32 flags = 0;
420 
421 	lockdep_assert_held(&ar->conf_mutex);
422 
423 	spin_lock_bh(&ar->data_lock);
424 	peer = ath10k_peer_find(ar, arvif->vdev_id, addr);
425 	spin_unlock_bh(&ar->data_lock);
426 
427 	if (!peer)
428 		return -ENOENT;
429 
430 	for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
431 		if (peer->keys[i] == NULL)
432 			continue;
433 
434 		/* key flags are not required to delete the key */
435 		ret = ath10k_install_key(arvif, peer->keys[i],
436 					 DISABLE_KEY, addr, flags);
437 		if (ret < 0 && first_errno == 0)
438 			first_errno = ret;
439 
440 		if (ret < 0)
441 			ath10k_warn(ar, "failed to remove peer wep key %d: %d\n",
442 				    i, ret);
443 
444 		spin_lock_bh(&ar->data_lock);
445 		peer->keys[i] = NULL;
446 		spin_unlock_bh(&ar->data_lock);
447 	}
448 
449 	return first_errno;
450 }
451 
ath10k_mac_is_peer_wep_key_set(struct ath10k * ar,const u8 * addr,u8 keyidx)452 bool ath10k_mac_is_peer_wep_key_set(struct ath10k *ar, const u8 *addr,
453 				    u8 keyidx)
454 {
455 	struct ath10k_peer *peer;
456 	int i;
457 
458 	lockdep_assert_held(&ar->data_lock);
459 
460 	/* We don't know which vdev this peer belongs to,
461 	 * since WMI doesn't give us that information.
462 	 *
463 	 * FIXME: multi-bss needs to be handled.
464 	 */
465 	peer = ath10k_peer_find(ar, 0, addr);
466 	if (!peer)
467 		return false;
468 
469 	for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
470 		if (peer->keys[i] && peer->keys[i]->keyidx == keyidx)
471 			return true;
472 	}
473 
474 	return false;
475 }
476 
ath10k_clear_vdev_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key)477 static int ath10k_clear_vdev_key(struct ath10k_vif *arvif,
478 				 struct ieee80211_key_conf *key)
479 {
480 	struct ath10k *ar = arvif->ar;
481 	struct ath10k_peer *peer;
482 	u8 addr[ETH_ALEN];
483 	int first_errno = 0;
484 	int ret;
485 	int i;
486 	u32 flags = 0;
487 
488 	lockdep_assert_held(&ar->conf_mutex);
489 
490 	for (;;) {
491 		/* since ath10k_install_key we can't hold data_lock all the
492 		 * time, so we try to remove the keys incrementally
493 		 */
494 		spin_lock_bh(&ar->data_lock);
495 		i = 0;
496 		list_for_each_entry(peer, &ar->peers, list) {
497 			for (i = 0; i < ARRAY_SIZE(peer->keys); i++) {
498 				if (peer->keys[i] == key) {
499 					ether_addr_copy(addr, peer->addr);
500 					peer->keys[i] = NULL;
501 					break;
502 				}
503 			}
504 
505 			if (i < ARRAY_SIZE(peer->keys))
506 				break;
507 		}
508 		spin_unlock_bh(&ar->data_lock);
509 
510 		if (i == ARRAY_SIZE(peer->keys))
511 			break;
512 		/* key flags are not required to delete the key */
513 		ret = ath10k_install_key(arvif, key, DISABLE_KEY, addr, flags);
514 		if (ret < 0 && first_errno == 0)
515 			first_errno = ret;
516 
517 		if (ret)
518 			ath10k_warn(ar, "failed to remove key for %pM: %d\n",
519 				    addr, ret);
520 	}
521 
522 	return first_errno;
523 }
524 
ath10k_mac_vif_update_wep_key(struct ath10k_vif * arvif,struct ieee80211_key_conf * key)525 static int ath10k_mac_vif_update_wep_key(struct ath10k_vif *arvif,
526 					 struct ieee80211_key_conf *key)
527 {
528 	struct ath10k *ar = arvif->ar;
529 	struct ath10k_peer *peer;
530 	int ret;
531 
532 	lockdep_assert_held(&ar->conf_mutex);
533 
534 	list_for_each_entry(peer, &ar->peers, list) {
535 		if (ether_addr_equal(peer->addr, arvif->vif->addr))
536 			continue;
537 
538 		if (ether_addr_equal(peer->addr, arvif->bssid))
539 			continue;
540 
541 		if (peer->keys[key->keyidx] == key)
542 			continue;
543 
544 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vif vdev %i update key %i needs update\n",
545 			   arvif->vdev_id, key->keyidx);
546 
547 		ret = ath10k_install_peer_wep_keys(arvif, peer->addr);
548 		if (ret) {
549 			ath10k_warn(ar, "failed to update wep keys on vdev %i for peer %pM: %d\n",
550 				    arvif->vdev_id, peer->addr, ret);
551 			return ret;
552 		}
553 	}
554 
555 	return 0;
556 }
557 
558 /*********************/
559 /* General utilities */
560 /*********************/
561 
562 static inline enum wmi_phy_mode
chan_to_phymode(const struct cfg80211_chan_def * chandef)563 chan_to_phymode(const struct cfg80211_chan_def *chandef)
564 {
565 	enum wmi_phy_mode phymode = MODE_UNKNOWN;
566 
567 	switch (chandef->chan->band) {
568 	case NL80211_BAND_2GHZ:
569 		switch (chandef->width) {
570 		case NL80211_CHAN_WIDTH_20_NOHT:
571 			if (chandef->chan->flags & IEEE80211_CHAN_NO_OFDM)
572 				phymode = MODE_11B;
573 			else
574 				phymode = MODE_11G;
575 			break;
576 		case NL80211_CHAN_WIDTH_20:
577 			phymode = MODE_11NG_HT20;
578 			break;
579 		case NL80211_CHAN_WIDTH_40:
580 			phymode = MODE_11NG_HT40;
581 			break;
582 		default:
583 			phymode = MODE_UNKNOWN;
584 			break;
585 		}
586 		break;
587 	case NL80211_BAND_5GHZ:
588 		switch (chandef->width) {
589 		case NL80211_CHAN_WIDTH_20_NOHT:
590 			phymode = MODE_11A;
591 			break;
592 		case NL80211_CHAN_WIDTH_20:
593 			phymode = MODE_11NA_HT20;
594 			break;
595 		case NL80211_CHAN_WIDTH_40:
596 			phymode = MODE_11NA_HT40;
597 			break;
598 		case NL80211_CHAN_WIDTH_80:
599 			phymode = MODE_11AC_VHT80;
600 			break;
601 		case NL80211_CHAN_WIDTH_160:
602 			phymode = MODE_11AC_VHT160;
603 			break;
604 		case NL80211_CHAN_WIDTH_80P80:
605 			phymode = MODE_11AC_VHT80_80;
606 			break;
607 		default:
608 			phymode = MODE_UNKNOWN;
609 			break;
610 		}
611 		break;
612 	default:
613 		break;
614 	}
615 
616 	WARN_ON(phymode == MODE_UNKNOWN);
617 	return phymode;
618 }
619 
ath10k_parse_mpdudensity(u8 mpdudensity)620 static u8 ath10k_parse_mpdudensity(u8 mpdudensity)
621 {
622 /*
623  * 802.11n D2.0 defined values for "Minimum MPDU Start Spacing":
624  *   0 for no restriction
625  *   1 for 1/4 us
626  *   2 for 1/2 us
627  *   3 for 1 us
628  *   4 for 2 us
629  *   5 for 4 us
630  *   6 for 8 us
631  *   7 for 16 us
632  */
633 	switch (mpdudensity) {
634 	case 0:
635 		return 0;
636 	case 1:
637 	case 2:
638 	case 3:
639 	/* Our lower layer calculations limit our precision to
640 	 * 1 microsecond
641 	 */
642 		return 1;
643 	case 4:
644 		return 2;
645 	case 5:
646 		return 4;
647 	case 6:
648 		return 8;
649 	case 7:
650 		return 16;
651 	default:
652 		return 0;
653 	}
654 }
655 
ath10k_mac_vif_chan(struct ieee80211_vif * vif,struct cfg80211_chan_def * def)656 int ath10k_mac_vif_chan(struct ieee80211_vif *vif,
657 			struct cfg80211_chan_def *def)
658 {
659 	struct ieee80211_chanctx_conf *conf;
660 
661 	rcu_read_lock();
662 	conf = rcu_dereference(vif->bss_conf.chanctx_conf);
663 	if (!conf) {
664 		rcu_read_unlock();
665 		return -ENOENT;
666 	}
667 
668 	*def = conf->def;
669 	rcu_read_unlock();
670 
671 	return 0;
672 }
673 
ath10k_mac_num_chanctxs_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)674 static void ath10k_mac_num_chanctxs_iter(struct ieee80211_hw *hw,
675 					 struct ieee80211_chanctx_conf *conf,
676 					 void *data)
677 {
678 	int *num = data;
679 
680 	(*num)++;
681 }
682 
ath10k_mac_num_chanctxs(struct ath10k * ar)683 static int ath10k_mac_num_chanctxs(struct ath10k *ar)
684 {
685 	int num = 0;
686 
687 	ieee80211_iter_chan_contexts_atomic(ar->hw,
688 					    ath10k_mac_num_chanctxs_iter,
689 					    &num);
690 
691 	return num;
692 }
693 
694 static void
ath10k_mac_get_any_chandef_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)695 ath10k_mac_get_any_chandef_iter(struct ieee80211_hw *hw,
696 				struct ieee80211_chanctx_conf *conf,
697 				void *data)
698 {
699 	struct cfg80211_chan_def **def = data;
700 
701 	*def = &conf->def;
702 }
703 
ath10k_wait_for_peer_delete_done(struct ath10k * ar,u32 vdev_id,const u8 * addr)704 static void ath10k_wait_for_peer_delete_done(struct ath10k *ar, u32 vdev_id,
705 					     const u8 *addr)
706 {
707 	unsigned long time_left;
708 	int ret;
709 
710 	if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
711 		ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
712 		if (ret) {
713 			ath10k_warn(ar, "failed wait for peer deleted");
714 			return;
715 		}
716 
717 		time_left = wait_for_completion_timeout(&ar->peer_delete_done,
718 							5 * HZ);
719 		if (!time_left)
720 			ath10k_warn(ar, "Timeout in receiving peer delete response\n");
721 	}
722 }
723 
ath10k_peer_create(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 vdev_id,const u8 * addr,enum wmi_peer_type peer_type)724 static int ath10k_peer_create(struct ath10k *ar,
725 			      struct ieee80211_vif *vif,
726 			      struct ieee80211_sta *sta,
727 			      u32 vdev_id,
728 			      const u8 *addr,
729 			      enum wmi_peer_type peer_type)
730 {
731 	struct ath10k_vif *arvif;
732 	struct ath10k_peer *peer;
733 	int num_peers = 0;
734 	int ret;
735 
736 	lockdep_assert_held(&ar->conf_mutex);
737 
738 	num_peers = ar->num_peers;
739 
740 	/* Each vdev consumes a peer entry as well */
741 	list_for_each_entry(arvif, &ar->arvifs, list)
742 		num_peers++;
743 
744 	if (num_peers >= ar->max_num_peers)
745 		return -ENOBUFS;
746 
747 	ret = ath10k_wmi_peer_create(ar, vdev_id, addr, peer_type);
748 	if (ret) {
749 		ath10k_warn(ar, "failed to create wmi peer %pM on vdev %i: %i\n",
750 			    addr, vdev_id, ret);
751 		return ret;
752 	}
753 
754 	ret = ath10k_wait_for_peer_created(ar, vdev_id, addr);
755 	if (ret) {
756 		ath10k_warn(ar, "failed to wait for created wmi peer %pM on vdev %i: %i\n",
757 			    addr, vdev_id, ret);
758 		return ret;
759 	}
760 
761 	spin_lock_bh(&ar->data_lock);
762 
763 	peer = ath10k_peer_find(ar, vdev_id, addr);
764 	if (!peer) {
765 		spin_unlock_bh(&ar->data_lock);
766 		ath10k_warn(ar, "failed to find peer %pM on vdev %i after creation\n",
767 			    addr, vdev_id);
768 		ath10k_wait_for_peer_delete_done(ar, vdev_id, addr);
769 		return -ENOENT;
770 	}
771 
772 	peer->vif = vif;
773 	peer->sta = sta;
774 
775 	spin_unlock_bh(&ar->data_lock);
776 
777 	ar->num_peers++;
778 
779 	return 0;
780 }
781 
ath10k_mac_set_kickout(struct ath10k_vif * arvif)782 static int ath10k_mac_set_kickout(struct ath10k_vif *arvif)
783 {
784 	struct ath10k *ar = arvif->ar;
785 	u32 param;
786 	int ret;
787 
788 	param = ar->wmi.pdev_param->sta_kickout_th;
789 	ret = ath10k_wmi_pdev_set_param(ar, param,
790 					ATH10K_KICKOUT_THRESHOLD);
791 	if (ret) {
792 		ath10k_warn(ar, "failed to set kickout threshold on vdev %i: %d\n",
793 			    arvif->vdev_id, ret);
794 		return ret;
795 	}
796 
797 	param = ar->wmi.vdev_param->ap_keepalive_min_idle_inactive_time_secs;
798 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
799 					ATH10K_KEEPALIVE_MIN_IDLE);
800 	if (ret) {
801 		ath10k_warn(ar, "failed to set keepalive minimum idle time on vdev %i: %d\n",
802 			    arvif->vdev_id, ret);
803 		return ret;
804 	}
805 
806 	param = ar->wmi.vdev_param->ap_keepalive_max_idle_inactive_time_secs;
807 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
808 					ATH10K_KEEPALIVE_MAX_IDLE);
809 	if (ret) {
810 		ath10k_warn(ar, "failed to set keepalive maximum idle time on vdev %i: %d\n",
811 			    arvif->vdev_id, ret);
812 		return ret;
813 	}
814 
815 	param = ar->wmi.vdev_param->ap_keepalive_max_unresponsive_time_secs;
816 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param,
817 					ATH10K_KEEPALIVE_MAX_UNRESPONSIVE);
818 	if (ret) {
819 		ath10k_warn(ar, "failed to set keepalive maximum unresponsive time on vdev %i: %d\n",
820 			    arvif->vdev_id, ret);
821 		return ret;
822 	}
823 
824 	return 0;
825 }
826 
ath10k_mac_set_rts(struct ath10k_vif * arvif,u32 value)827 static int ath10k_mac_set_rts(struct ath10k_vif *arvif, u32 value)
828 {
829 	struct ath10k *ar = arvif->ar;
830 	u32 vdev_param;
831 
832 	vdev_param = ar->wmi.vdev_param->rts_threshold;
833 	return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, value);
834 }
835 
ath10k_peer_delete(struct ath10k * ar,u32 vdev_id,const u8 * addr)836 static int ath10k_peer_delete(struct ath10k *ar, u32 vdev_id, const u8 *addr)
837 {
838 	int ret;
839 
840 	lockdep_assert_held(&ar->conf_mutex);
841 
842 	ret = ath10k_wmi_peer_delete(ar, vdev_id, addr);
843 	if (ret)
844 		return ret;
845 
846 	ret = ath10k_wait_for_peer_deleted(ar, vdev_id, addr);
847 	if (ret)
848 		return ret;
849 
850 	if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
851 		unsigned long time_left;
852 
853 		time_left = wait_for_completion_timeout
854 			    (&ar->peer_delete_done, 5 * HZ);
855 
856 		if (!time_left) {
857 			ath10k_warn(ar, "Timeout in receiving peer delete response\n");
858 			return -ETIMEDOUT;
859 		}
860 	}
861 
862 	ar->num_peers--;
863 
864 	return 0;
865 }
866 
ath10k_peer_cleanup(struct ath10k * ar,u32 vdev_id)867 static void ath10k_peer_cleanup(struct ath10k *ar, u32 vdev_id)
868 {
869 	struct ath10k_peer *peer, *tmp;
870 	int peer_id;
871 	int i;
872 
873 	lockdep_assert_held(&ar->conf_mutex);
874 
875 	spin_lock_bh(&ar->data_lock);
876 	list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
877 		if (peer->vdev_id != vdev_id)
878 			continue;
879 
880 		ath10k_warn(ar, "removing stale peer %pM from vdev_id %d\n",
881 			    peer->addr, vdev_id);
882 
883 		for_each_set_bit(peer_id, peer->peer_ids,
884 				 ATH10K_MAX_NUM_PEER_IDS) {
885 			ar->peer_map[peer_id] = NULL;
886 		}
887 
888 		/* Double check that peer is properly un-referenced from
889 		 * the peer_map
890 		 */
891 		for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
892 			if (ar->peer_map[i] == peer) {
893 				ath10k_warn(ar, "removing stale peer_map entry for %pM (ptr %pK idx %d)\n",
894 					    peer->addr, peer, i);
895 				ar->peer_map[i] = NULL;
896 			}
897 		}
898 
899 		list_del(&peer->list);
900 		kfree(peer);
901 		ar->num_peers--;
902 	}
903 	spin_unlock_bh(&ar->data_lock);
904 }
905 
ath10k_peer_cleanup_all(struct ath10k * ar)906 static void ath10k_peer_cleanup_all(struct ath10k *ar)
907 {
908 	struct ath10k_peer *peer, *tmp;
909 	int i;
910 
911 	lockdep_assert_held(&ar->conf_mutex);
912 
913 	spin_lock_bh(&ar->data_lock);
914 	list_for_each_entry_safe(peer, tmp, &ar->peers, list) {
915 		list_del(&peer->list);
916 		kfree(peer);
917 	}
918 
919 	for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++)
920 		ar->peer_map[i] = NULL;
921 
922 	spin_unlock_bh(&ar->data_lock);
923 
924 	ar->num_peers = 0;
925 	ar->num_stations = 0;
926 }
927 
ath10k_mac_tdls_peer_update(struct ath10k * ar,u32 vdev_id,struct ieee80211_sta * sta,enum wmi_tdls_peer_state state)928 static int ath10k_mac_tdls_peer_update(struct ath10k *ar, u32 vdev_id,
929 				       struct ieee80211_sta *sta,
930 				       enum wmi_tdls_peer_state state)
931 {
932 	int ret;
933 	struct wmi_tdls_peer_update_cmd_arg arg = {};
934 	struct wmi_tdls_peer_capab_arg cap = {};
935 	struct wmi_channel_arg chan_arg = {};
936 
937 	lockdep_assert_held(&ar->conf_mutex);
938 
939 	arg.vdev_id = vdev_id;
940 	arg.peer_state = state;
941 	ether_addr_copy(arg.addr, sta->addr);
942 
943 	cap.peer_max_sp = sta->max_sp;
944 	cap.peer_uapsd_queues = sta->uapsd_queues;
945 
946 	if (state == WMI_TDLS_PEER_STATE_CONNECTED &&
947 	    !sta->tdls_initiator)
948 		cap.is_peer_responder = 1;
949 
950 	ret = ath10k_wmi_tdls_peer_update(ar, &arg, &cap, &chan_arg);
951 	if (ret) {
952 		ath10k_warn(ar, "failed to update tdls peer %pM on vdev %i: %i\n",
953 			    arg.addr, vdev_id, ret);
954 		return ret;
955 	}
956 
957 	return 0;
958 }
959 
960 /************************/
961 /* Interface management */
962 /************************/
963 
ath10k_mac_vif_beacon_free(struct ath10k_vif * arvif)964 void ath10k_mac_vif_beacon_free(struct ath10k_vif *arvif)
965 {
966 	struct ath10k *ar = arvif->ar;
967 
968 	lockdep_assert_held(&ar->data_lock);
969 
970 	if (!arvif->beacon)
971 		return;
972 
973 	if (!arvif->beacon_buf)
974 		dma_unmap_single(ar->dev, ATH10K_SKB_CB(arvif->beacon)->paddr,
975 				 arvif->beacon->len, DMA_TO_DEVICE);
976 
977 	if (WARN_ON(arvif->beacon_state != ATH10K_BEACON_SCHEDULED &&
978 		    arvif->beacon_state != ATH10K_BEACON_SENT))
979 		return;
980 
981 	dev_kfree_skb_any(arvif->beacon);
982 
983 	arvif->beacon = NULL;
984 	arvif->beacon_state = ATH10K_BEACON_SCHEDULED;
985 }
986 
ath10k_mac_vif_beacon_cleanup(struct ath10k_vif * arvif)987 static void ath10k_mac_vif_beacon_cleanup(struct ath10k_vif *arvif)
988 {
989 	struct ath10k *ar = arvif->ar;
990 
991 	lockdep_assert_held(&ar->data_lock);
992 
993 	ath10k_mac_vif_beacon_free(arvif);
994 
995 	if (arvif->beacon_buf) {
996 		if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)
997 			kfree(arvif->beacon_buf);
998 		else
999 			dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
1000 					  arvif->beacon_buf,
1001 					  arvif->beacon_paddr);
1002 		arvif->beacon_buf = NULL;
1003 	}
1004 }
1005 
ath10k_vdev_setup_sync(struct ath10k * ar)1006 static inline int ath10k_vdev_setup_sync(struct ath10k *ar)
1007 {
1008 	unsigned long time_left;
1009 
1010 	lockdep_assert_held(&ar->conf_mutex);
1011 
1012 	if (test_bit(ATH10K_FLAG_CRASH_FLUSH, &ar->dev_flags))
1013 		return -ESHUTDOWN;
1014 
1015 	time_left = wait_for_completion_timeout(&ar->vdev_setup_done,
1016 						ATH10K_VDEV_SETUP_TIMEOUT_HZ);
1017 	if (time_left == 0)
1018 		return -ETIMEDOUT;
1019 
1020 	return ar->last_wmi_vdev_start_status;
1021 }
1022 
ath10k_monitor_vdev_start(struct ath10k * ar,int vdev_id)1023 static int ath10k_monitor_vdev_start(struct ath10k *ar, int vdev_id)
1024 {
1025 	struct cfg80211_chan_def *chandef = NULL;
1026 	struct ieee80211_channel *channel = NULL;
1027 	struct wmi_vdev_start_request_arg arg = {};
1028 	int ret = 0;
1029 
1030 	lockdep_assert_held(&ar->conf_mutex);
1031 
1032 	ieee80211_iter_chan_contexts_atomic(ar->hw,
1033 					    ath10k_mac_get_any_chandef_iter,
1034 					    &chandef);
1035 	if (WARN_ON_ONCE(!chandef))
1036 		return -ENOENT;
1037 
1038 	channel = chandef->chan;
1039 
1040 	arg.vdev_id = vdev_id;
1041 	arg.channel.freq = channel->center_freq;
1042 	arg.channel.band_center_freq1 = chandef->center_freq1;
1043 	arg.channel.band_center_freq2 = chandef->center_freq2;
1044 
1045 	/* TODO setup this dynamically, what in case we
1046 	 * don't have any vifs?
1047 	 */
1048 	arg.channel.mode = chan_to_phymode(chandef);
1049 	arg.channel.chan_radar =
1050 			!!(channel->flags & IEEE80211_CHAN_RADAR);
1051 
1052 	arg.channel.min_power = 0;
1053 	arg.channel.max_power = channel->max_power * 2;
1054 	arg.channel.max_reg_power = channel->max_reg_power * 2;
1055 	arg.channel.max_antenna_gain = channel->max_antenna_gain;
1056 
1057 	reinit_completion(&ar->vdev_setup_done);
1058 	reinit_completion(&ar->vdev_delete_done);
1059 
1060 	ret = ath10k_wmi_vdev_start(ar, &arg);
1061 	if (ret) {
1062 		ath10k_warn(ar, "failed to request monitor vdev %i start: %d\n",
1063 			    vdev_id, ret);
1064 		return ret;
1065 	}
1066 
1067 	ret = ath10k_vdev_setup_sync(ar);
1068 	if (ret) {
1069 		ath10k_warn(ar, "failed to synchronize setup for monitor vdev %i start: %d\n",
1070 			    vdev_id, ret);
1071 		return ret;
1072 	}
1073 
1074 	ret = ath10k_wmi_vdev_up(ar, vdev_id, 0, ar->mac_addr);
1075 	if (ret) {
1076 		ath10k_warn(ar, "failed to put up monitor vdev %i: %d\n",
1077 			    vdev_id, ret);
1078 		goto vdev_stop;
1079 	}
1080 
1081 	ar->monitor_vdev_id = vdev_id;
1082 
1083 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i started\n",
1084 		   ar->monitor_vdev_id);
1085 	return 0;
1086 
1087 vdev_stop:
1088 	ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1089 	if (ret)
1090 		ath10k_warn(ar, "failed to stop monitor vdev %i after start failure: %d\n",
1091 			    ar->monitor_vdev_id, ret);
1092 
1093 	return ret;
1094 }
1095 
ath10k_monitor_vdev_stop(struct ath10k * ar)1096 static int ath10k_monitor_vdev_stop(struct ath10k *ar)
1097 {
1098 	int ret = 0;
1099 
1100 	lockdep_assert_held(&ar->conf_mutex);
1101 
1102 	ret = ath10k_wmi_vdev_down(ar, ar->monitor_vdev_id);
1103 	if (ret)
1104 		ath10k_warn(ar, "failed to put down monitor vdev %i: %d\n",
1105 			    ar->monitor_vdev_id, ret);
1106 
1107 	reinit_completion(&ar->vdev_setup_done);
1108 	reinit_completion(&ar->vdev_delete_done);
1109 
1110 	ret = ath10k_wmi_vdev_stop(ar, ar->monitor_vdev_id);
1111 	if (ret)
1112 		ath10k_warn(ar, "failed to request monitor vdev %i stop: %d\n",
1113 			    ar->monitor_vdev_id, ret);
1114 
1115 	ret = ath10k_vdev_setup_sync(ar);
1116 	if (ret)
1117 		ath10k_warn(ar, "failed to synchronize monitor vdev %i stop: %d\n",
1118 			    ar->monitor_vdev_id, ret);
1119 
1120 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %i stopped\n",
1121 		   ar->monitor_vdev_id);
1122 	return ret;
1123 }
1124 
ath10k_monitor_vdev_create(struct ath10k * ar)1125 static int ath10k_monitor_vdev_create(struct ath10k *ar)
1126 {
1127 	int bit, ret = 0;
1128 
1129 	lockdep_assert_held(&ar->conf_mutex);
1130 
1131 	if (ar->free_vdev_map == 0) {
1132 		ath10k_warn(ar, "failed to find free vdev id for monitor vdev\n");
1133 		return -ENOMEM;
1134 	}
1135 
1136 	bit = __ffs64(ar->free_vdev_map);
1137 
1138 	ar->monitor_vdev_id = bit;
1139 
1140 	ret = ath10k_wmi_vdev_create(ar, ar->monitor_vdev_id,
1141 				     WMI_VDEV_TYPE_MONITOR,
1142 				     0, ar->mac_addr);
1143 	if (ret) {
1144 		ath10k_warn(ar, "failed to request monitor vdev %i creation: %d\n",
1145 			    ar->monitor_vdev_id, ret);
1146 		return ret;
1147 	}
1148 
1149 	ar->free_vdev_map &= ~(1LL << ar->monitor_vdev_id);
1150 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d created\n",
1151 		   ar->monitor_vdev_id);
1152 
1153 	return 0;
1154 }
1155 
ath10k_monitor_vdev_delete(struct ath10k * ar)1156 static int ath10k_monitor_vdev_delete(struct ath10k *ar)
1157 {
1158 	int ret = 0;
1159 
1160 	lockdep_assert_held(&ar->conf_mutex);
1161 
1162 	ret = ath10k_wmi_vdev_delete(ar, ar->monitor_vdev_id);
1163 	if (ret) {
1164 		ath10k_warn(ar, "failed to request wmi monitor vdev %i removal: %d\n",
1165 			    ar->monitor_vdev_id, ret);
1166 		return ret;
1167 	}
1168 
1169 	ar->free_vdev_map |= 1LL << ar->monitor_vdev_id;
1170 
1171 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor vdev %d deleted\n",
1172 		   ar->monitor_vdev_id);
1173 	return ret;
1174 }
1175 
ath10k_monitor_start(struct ath10k * ar)1176 static int ath10k_monitor_start(struct ath10k *ar)
1177 {
1178 	int ret;
1179 
1180 	lockdep_assert_held(&ar->conf_mutex);
1181 
1182 	ret = ath10k_monitor_vdev_create(ar);
1183 	if (ret) {
1184 		ath10k_warn(ar, "failed to create monitor vdev: %d\n", ret);
1185 		return ret;
1186 	}
1187 
1188 	ret = ath10k_monitor_vdev_start(ar, ar->monitor_vdev_id);
1189 	if (ret) {
1190 		ath10k_warn(ar, "failed to start monitor vdev: %d\n", ret);
1191 		ath10k_monitor_vdev_delete(ar);
1192 		return ret;
1193 	}
1194 
1195 	ar->monitor_started = true;
1196 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor started\n");
1197 
1198 	return 0;
1199 }
1200 
ath10k_monitor_stop(struct ath10k * ar)1201 static int ath10k_monitor_stop(struct ath10k *ar)
1202 {
1203 	int ret;
1204 
1205 	lockdep_assert_held(&ar->conf_mutex);
1206 
1207 	ret = ath10k_monitor_vdev_stop(ar);
1208 	if (ret) {
1209 		ath10k_warn(ar, "failed to stop monitor vdev: %d\n", ret);
1210 		return ret;
1211 	}
1212 
1213 	ret = ath10k_monitor_vdev_delete(ar);
1214 	if (ret) {
1215 		ath10k_warn(ar, "failed to delete monitor vdev: %d\n", ret);
1216 		return ret;
1217 	}
1218 
1219 	ar->monitor_started = false;
1220 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopped\n");
1221 
1222 	return 0;
1223 }
1224 
ath10k_mac_monitor_vdev_is_needed(struct ath10k * ar)1225 static bool ath10k_mac_monitor_vdev_is_needed(struct ath10k *ar)
1226 {
1227 	int num_ctx;
1228 
1229 	/* At least one chanctx is required to derive a channel to start
1230 	 * monitor vdev on.
1231 	 */
1232 	num_ctx = ath10k_mac_num_chanctxs(ar);
1233 	if (num_ctx == 0)
1234 		return false;
1235 
1236 	/* If there's already an existing special monitor interface then don't
1237 	 * bother creating another monitor vdev.
1238 	 */
1239 	if (ar->monitor_arvif)
1240 		return false;
1241 
1242 	return ar->monitor ||
1243 	       (!test_bit(ATH10K_FW_FEATURE_ALLOWS_MESH_BCAST,
1244 			  ar->running_fw->fw_file.fw_features) &&
1245 		(ar->filter_flags & FIF_OTHER_BSS)) ||
1246 	       test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1247 }
1248 
ath10k_mac_monitor_vdev_is_allowed(struct ath10k * ar)1249 static bool ath10k_mac_monitor_vdev_is_allowed(struct ath10k *ar)
1250 {
1251 	int num_ctx;
1252 
1253 	num_ctx = ath10k_mac_num_chanctxs(ar);
1254 
1255 	/* FIXME: Current interface combinations and cfg80211/mac80211 code
1256 	 * shouldn't allow this but make sure to prevent handling the following
1257 	 * case anyway since multi-channel DFS hasn't been tested at all.
1258 	 */
1259 	if (test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags) && num_ctx > 1)
1260 		return false;
1261 
1262 	return true;
1263 }
1264 
ath10k_monitor_recalc(struct ath10k * ar)1265 static int ath10k_monitor_recalc(struct ath10k *ar)
1266 {
1267 	bool needed;
1268 	bool allowed;
1269 	int ret;
1270 
1271 	lockdep_assert_held(&ar->conf_mutex);
1272 
1273 	needed = ath10k_mac_monitor_vdev_is_needed(ar);
1274 	allowed = ath10k_mac_monitor_vdev_is_allowed(ar);
1275 
1276 	ath10k_dbg(ar, ATH10K_DBG_MAC,
1277 		   "mac monitor recalc started? %d needed? %d allowed? %d\n",
1278 		   ar->monitor_started, needed, allowed);
1279 
1280 	if (WARN_ON(needed && !allowed)) {
1281 		if (ar->monitor_started) {
1282 			ath10k_dbg(ar, ATH10K_DBG_MAC, "mac monitor stopping disallowed monitor\n");
1283 
1284 			ret = ath10k_monitor_stop(ar);
1285 			if (ret)
1286 				ath10k_warn(ar, "failed to stop disallowed monitor: %d\n",
1287 					    ret);
1288 				/* not serious */
1289 		}
1290 
1291 		return -EPERM;
1292 	}
1293 
1294 	if (needed == ar->monitor_started)
1295 		return 0;
1296 
1297 	if (needed)
1298 		return ath10k_monitor_start(ar);
1299 	else
1300 		return ath10k_monitor_stop(ar);
1301 }
1302 
ath10k_mac_can_set_cts_prot(struct ath10k_vif * arvif)1303 static bool ath10k_mac_can_set_cts_prot(struct ath10k_vif *arvif)
1304 {
1305 	struct ath10k *ar = arvif->ar;
1306 
1307 	lockdep_assert_held(&ar->conf_mutex);
1308 
1309 	if (!arvif->is_started) {
1310 		ath10k_dbg(ar, ATH10K_DBG_MAC, "defer cts setup, vdev is not ready yet\n");
1311 		return false;
1312 	}
1313 
1314 	return true;
1315 }
1316 
ath10k_mac_set_cts_prot(struct ath10k_vif * arvif)1317 static int ath10k_mac_set_cts_prot(struct ath10k_vif *arvif)
1318 {
1319 	struct ath10k *ar = arvif->ar;
1320 	u32 vdev_param;
1321 
1322 	lockdep_assert_held(&ar->conf_mutex);
1323 
1324 	vdev_param = ar->wmi.vdev_param->protection_mode;
1325 
1326 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d cts_protection %d\n",
1327 		   arvif->vdev_id, arvif->use_cts_prot);
1328 
1329 	return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1330 					 arvif->use_cts_prot ? 1 : 0);
1331 }
1332 
ath10k_recalc_rtscts_prot(struct ath10k_vif * arvif)1333 static int ath10k_recalc_rtscts_prot(struct ath10k_vif *arvif)
1334 {
1335 	struct ath10k *ar = arvif->ar;
1336 	u32 vdev_param, rts_cts = 0;
1337 
1338 	lockdep_assert_held(&ar->conf_mutex);
1339 
1340 	vdev_param = ar->wmi.vdev_param->enable_rtscts;
1341 
1342 	rts_cts |= SM(WMI_RTSCTS_ENABLED, WMI_RTSCTS_SET);
1343 
1344 	if (arvif->num_legacy_stations > 0)
1345 		rts_cts |= SM(WMI_RTSCTS_ACROSS_SW_RETRIES,
1346 			      WMI_RTSCTS_PROFILE);
1347 	else
1348 		rts_cts |= SM(WMI_RTSCTS_FOR_SECOND_RATESERIES,
1349 			      WMI_RTSCTS_PROFILE);
1350 
1351 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d recalc rts/cts prot %d\n",
1352 		   arvif->vdev_id, rts_cts);
1353 
1354 	return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
1355 					 rts_cts);
1356 }
1357 
ath10k_start_cac(struct ath10k * ar)1358 static int ath10k_start_cac(struct ath10k *ar)
1359 {
1360 	int ret;
1361 
1362 	lockdep_assert_held(&ar->conf_mutex);
1363 
1364 	set_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1365 
1366 	ret = ath10k_monitor_recalc(ar);
1367 	if (ret) {
1368 		ath10k_warn(ar, "failed to start monitor (cac): %d\n", ret);
1369 		clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1370 		return ret;
1371 	}
1372 
1373 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac start monitor vdev %d\n",
1374 		   ar->monitor_vdev_id);
1375 
1376 	return 0;
1377 }
1378 
ath10k_stop_cac(struct ath10k * ar)1379 static int ath10k_stop_cac(struct ath10k *ar)
1380 {
1381 	lockdep_assert_held(&ar->conf_mutex);
1382 
1383 	/* CAC is not running - do nothing */
1384 	if (!test_bit(ATH10K_CAC_RUNNING, &ar->dev_flags))
1385 		return 0;
1386 
1387 	clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
1388 	ath10k_monitor_stop(ar);
1389 
1390 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac cac finished\n");
1391 
1392 	return 0;
1393 }
1394 
ath10k_mac_has_radar_iter(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * conf,void * data)1395 static void ath10k_mac_has_radar_iter(struct ieee80211_hw *hw,
1396 				      struct ieee80211_chanctx_conf *conf,
1397 				      void *data)
1398 {
1399 	bool *ret = data;
1400 
1401 	if (!*ret && conf->radar_enabled)
1402 		*ret = true;
1403 }
1404 
ath10k_mac_has_radar_enabled(struct ath10k * ar)1405 static bool ath10k_mac_has_radar_enabled(struct ath10k *ar)
1406 {
1407 	bool has_radar = false;
1408 
1409 	ieee80211_iter_chan_contexts_atomic(ar->hw,
1410 					    ath10k_mac_has_radar_iter,
1411 					    &has_radar);
1412 
1413 	return has_radar;
1414 }
1415 
ath10k_recalc_radar_detection(struct ath10k * ar)1416 static void ath10k_recalc_radar_detection(struct ath10k *ar)
1417 {
1418 	int ret;
1419 
1420 	lockdep_assert_held(&ar->conf_mutex);
1421 
1422 	ath10k_stop_cac(ar);
1423 
1424 	if (!ath10k_mac_has_radar_enabled(ar))
1425 		return;
1426 
1427 	if (ar->num_started_vdevs > 0)
1428 		return;
1429 
1430 	ret = ath10k_start_cac(ar);
1431 	if (ret) {
1432 		/*
1433 		 * Not possible to start CAC on current channel so starting
1434 		 * radiation is not allowed, make this channel DFS_UNAVAILABLE
1435 		 * by indicating that radar was detected.
1436 		 */
1437 		ath10k_warn(ar, "failed to start CAC: %d\n", ret);
1438 		ieee80211_radar_detected(ar->hw);
1439 	}
1440 }
1441 
ath10k_vdev_stop(struct ath10k_vif * arvif)1442 static int ath10k_vdev_stop(struct ath10k_vif *arvif)
1443 {
1444 	struct ath10k *ar = arvif->ar;
1445 	int ret;
1446 
1447 	lockdep_assert_held(&ar->conf_mutex);
1448 
1449 	reinit_completion(&ar->vdev_setup_done);
1450 	reinit_completion(&ar->vdev_delete_done);
1451 
1452 	ret = ath10k_wmi_vdev_stop(ar, arvif->vdev_id);
1453 	if (ret) {
1454 		ath10k_warn(ar, "failed to stop WMI vdev %i: %d\n",
1455 			    arvif->vdev_id, ret);
1456 		return ret;
1457 	}
1458 
1459 	ret = ath10k_vdev_setup_sync(ar);
1460 	if (ret) {
1461 		ath10k_warn(ar, "failed to synchronize setup for vdev %i: %d\n",
1462 			    arvif->vdev_id, ret);
1463 		return ret;
1464 	}
1465 
1466 	WARN_ON(ar->num_started_vdevs == 0);
1467 
1468 	if (ar->num_started_vdevs != 0) {
1469 		ar->num_started_vdevs--;
1470 		ath10k_recalc_radar_detection(ar);
1471 	}
1472 
1473 	return ret;
1474 }
1475 
ath10k_vdev_start_restart(struct ath10k_vif * arvif,const struct cfg80211_chan_def * chandef,bool restart)1476 static int ath10k_vdev_start_restart(struct ath10k_vif *arvif,
1477 				     const struct cfg80211_chan_def *chandef,
1478 				     bool restart)
1479 {
1480 	struct ath10k *ar = arvif->ar;
1481 	struct wmi_vdev_start_request_arg arg = {};
1482 	int ret = 0;
1483 
1484 	lockdep_assert_held(&ar->conf_mutex);
1485 
1486 	reinit_completion(&ar->vdev_setup_done);
1487 	reinit_completion(&ar->vdev_delete_done);
1488 
1489 	arg.vdev_id = arvif->vdev_id;
1490 	arg.dtim_period = arvif->dtim_period;
1491 	arg.bcn_intval = arvif->beacon_interval;
1492 
1493 	arg.channel.freq = chandef->chan->center_freq;
1494 	arg.channel.band_center_freq1 = chandef->center_freq1;
1495 	arg.channel.band_center_freq2 = chandef->center_freq2;
1496 	arg.channel.mode = chan_to_phymode(chandef);
1497 
1498 	arg.channel.min_power = 0;
1499 	arg.channel.max_power = chandef->chan->max_power * 2;
1500 	arg.channel.max_reg_power = chandef->chan->max_reg_power * 2;
1501 	arg.channel.max_antenna_gain = chandef->chan->max_antenna_gain;
1502 
1503 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
1504 		arg.ssid = arvif->u.ap.ssid;
1505 		arg.ssid_len = arvif->u.ap.ssid_len;
1506 		arg.hidden_ssid = arvif->u.ap.hidden_ssid;
1507 
1508 		/* For now allow DFS for AP mode */
1509 		arg.channel.chan_radar =
1510 			!!(chandef->chan->flags & IEEE80211_CHAN_RADAR);
1511 	} else if (arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
1512 		arg.ssid = arvif->vif->bss_conf.ssid;
1513 		arg.ssid_len = arvif->vif->bss_conf.ssid_len;
1514 	}
1515 
1516 	ath10k_dbg(ar, ATH10K_DBG_MAC,
1517 		   "mac vdev %d start center_freq %d phymode %s\n",
1518 		   arg.vdev_id, arg.channel.freq,
1519 		   ath10k_wmi_phymode_str(arg.channel.mode));
1520 
1521 	if (restart)
1522 		ret = ath10k_wmi_vdev_restart(ar, &arg);
1523 	else
1524 		ret = ath10k_wmi_vdev_start(ar, &arg);
1525 
1526 	if (ret) {
1527 		ath10k_warn(ar, "failed to start WMI vdev %i: %d\n",
1528 			    arg.vdev_id, ret);
1529 		return ret;
1530 	}
1531 
1532 	ret = ath10k_vdev_setup_sync(ar);
1533 	if (ret) {
1534 		ath10k_warn(ar,
1535 			    "failed to synchronize setup for vdev %i restart %d: %d\n",
1536 			    arg.vdev_id, restart, ret);
1537 		return ret;
1538 	}
1539 
1540 	ar->num_started_vdevs++;
1541 	ath10k_recalc_radar_detection(ar);
1542 
1543 	return ret;
1544 }
1545 
ath10k_vdev_start(struct ath10k_vif * arvif,const struct cfg80211_chan_def * def)1546 static int ath10k_vdev_start(struct ath10k_vif *arvif,
1547 			     const struct cfg80211_chan_def *def)
1548 {
1549 	return ath10k_vdev_start_restart(arvif, def, false);
1550 }
1551 
ath10k_vdev_restart(struct ath10k_vif * arvif,const struct cfg80211_chan_def * def)1552 static int ath10k_vdev_restart(struct ath10k_vif *arvif,
1553 			       const struct cfg80211_chan_def *def)
1554 {
1555 	return ath10k_vdev_start_restart(arvif, def, true);
1556 }
1557 
ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif * arvif,struct sk_buff * bcn)1558 static int ath10k_mac_setup_bcn_p2p_ie(struct ath10k_vif *arvif,
1559 				       struct sk_buff *bcn)
1560 {
1561 	struct ath10k *ar = arvif->ar;
1562 	struct ieee80211_mgmt *mgmt;
1563 	const u8 *p2p_ie;
1564 	int ret;
1565 
1566 	if (arvif->vif->type != NL80211_IFTYPE_AP || !arvif->vif->p2p)
1567 		return 0;
1568 
1569 	mgmt = (void *)bcn->data;
1570 	p2p_ie = cfg80211_find_vendor_ie(WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1571 					 mgmt->u.beacon.variable,
1572 					 bcn->len - (mgmt->u.beacon.variable -
1573 						     bcn->data));
1574 	if (!p2p_ie)
1575 		return -ENOENT;
1576 
1577 	ret = ath10k_wmi_p2p_go_bcn_ie(ar, arvif->vdev_id, p2p_ie);
1578 	if (ret) {
1579 		ath10k_warn(ar, "failed to submit p2p go bcn ie for vdev %i: %d\n",
1580 			    arvif->vdev_id, ret);
1581 		return ret;
1582 	}
1583 
1584 	return 0;
1585 }
1586 
ath10k_mac_remove_vendor_ie(struct sk_buff * skb,unsigned int oui,u8 oui_type,size_t ie_offset)1587 static int ath10k_mac_remove_vendor_ie(struct sk_buff *skb, unsigned int oui,
1588 				       u8 oui_type, size_t ie_offset)
1589 {
1590 	size_t len;
1591 	const u8 *next;
1592 	const u8 *end;
1593 	u8 *ie;
1594 
1595 	if (WARN_ON(skb->len < ie_offset))
1596 		return -EINVAL;
1597 
1598 	ie = (u8 *)cfg80211_find_vendor_ie(oui, oui_type,
1599 					   skb->data + ie_offset,
1600 					   skb->len - ie_offset);
1601 	if (!ie)
1602 		return -ENOENT;
1603 
1604 	len = ie[1] + 2;
1605 	end = skb->data + skb->len;
1606 	next = ie + len;
1607 
1608 	if (WARN_ON(next > end))
1609 		return -EINVAL;
1610 
1611 	memmove(ie, next, end - next);
1612 	skb_trim(skb, skb->len - len);
1613 
1614 	return 0;
1615 }
1616 
ath10k_mac_setup_bcn_tmpl(struct ath10k_vif * arvif)1617 static int ath10k_mac_setup_bcn_tmpl(struct ath10k_vif *arvif)
1618 {
1619 	struct ath10k *ar = arvif->ar;
1620 	struct ieee80211_hw *hw = ar->hw;
1621 	struct ieee80211_vif *vif = arvif->vif;
1622 	struct ieee80211_mutable_offsets offs = {};
1623 	struct sk_buff *bcn;
1624 	int ret;
1625 
1626 	if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1627 		return 0;
1628 
1629 	if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
1630 	    arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
1631 		return 0;
1632 
1633 	bcn = ieee80211_beacon_get_template(hw, vif, &offs);
1634 	if (!bcn) {
1635 		ath10k_warn(ar, "failed to get beacon template from mac80211\n");
1636 		return -EPERM;
1637 	}
1638 
1639 	ret = ath10k_mac_setup_bcn_p2p_ie(arvif, bcn);
1640 	if (ret) {
1641 		ath10k_warn(ar, "failed to setup p2p go bcn ie: %d\n", ret);
1642 		kfree_skb(bcn);
1643 		return ret;
1644 	}
1645 
1646 	/* P2P IE is inserted by firmware automatically (as configured above)
1647 	 * so remove it from the base beacon template to avoid duplicate P2P
1648 	 * IEs in beacon frames.
1649 	 */
1650 	ath10k_mac_remove_vendor_ie(bcn, WLAN_OUI_WFA, WLAN_OUI_TYPE_WFA_P2P,
1651 				    offsetof(struct ieee80211_mgmt,
1652 					     u.beacon.variable));
1653 
1654 	ret = ath10k_wmi_bcn_tmpl(ar, arvif->vdev_id, offs.tim_offset, bcn, 0,
1655 				  0, NULL, 0);
1656 	kfree_skb(bcn);
1657 
1658 	if (ret) {
1659 		ath10k_warn(ar, "failed to submit beacon template command: %d\n",
1660 			    ret);
1661 		return ret;
1662 	}
1663 
1664 	return 0;
1665 }
1666 
ath10k_mac_setup_prb_tmpl(struct ath10k_vif * arvif)1667 static int ath10k_mac_setup_prb_tmpl(struct ath10k_vif *arvif)
1668 {
1669 	struct ath10k *ar = arvif->ar;
1670 	struct ieee80211_hw *hw = ar->hw;
1671 	struct ieee80211_vif *vif = arvif->vif;
1672 	struct sk_buff *prb;
1673 	int ret;
1674 
1675 	if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1676 		return 0;
1677 
1678 	if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
1679 		return 0;
1680 
1681 	 /* For mesh, probe response and beacon share the same template */
1682 	if (ieee80211_vif_is_mesh(vif))
1683 		return 0;
1684 
1685 	prb = ieee80211_proberesp_get(hw, vif);
1686 	if (!prb) {
1687 		ath10k_warn(ar, "failed to get probe resp template from mac80211\n");
1688 		return -EPERM;
1689 	}
1690 
1691 	ret = ath10k_wmi_prb_tmpl(ar, arvif->vdev_id, prb);
1692 	kfree_skb(prb);
1693 
1694 	if (ret) {
1695 		ath10k_warn(ar, "failed to submit probe resp template command: %d\n",
1696 			    ret);
1697 		return ret;
1698 	}
1699 
1700 	return 0;
1701 }
1702 
ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif * arvif)1703 static int ath10k_mac_vif_fix_hidden_ssid(struct ath10k_vif *arvif)
1704 {
1705 	struct ath10k *ar = arvif->ar;
1706 	struct cfg80211_chan_def def;
1707 	int ret;
1708 
1709 	/* When originally vdev is started during assign_vif_chanctx() some
1710 	 * information is missing, notably SSID. Firmware revisions with beacon
1711 	 * offloading require the SSID to be provided during vdev (re)start to
1712 	 * handle hidden SSID properly.
1713 	 *
1714 	 * Vdev restart must be done after vdev has been both started and
1715 	 * upped. Otherwise some firmware revisions (at least 10.2) fail to
1716 	 * deliver vdev restart response event causing timeouts during vdev
1717 	 * syncing in ath10k.
1718 	 *
1719 	 * Note: The vdev down/up and template reinstallation could be skipped
1720 	 * since only wmi-tlv firmware are known to have beacon offload and
1721 	 * wmi-tlv doesn't seem to misbehave like 10.2 wrt vdev restart
1722 	 * response delivery. It's probably more robust to keep it as is.
1723 	 */
1724 	if (!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map))
1725 		return 0;
1726 
1727 	if (WARN_ON(!arvif->is_started))
1728 		return -EINVAL;
1729 
1730 	if (WARN_ON(!arvif->is_up))
1731 		return -EINVAL;
1732 
1733 	if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
1734 		return -EINVAL;
1735 
1736 	ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1737 	if (ret) {
1738 		ath10k_warn(ar, "failed to bring down ap vdev %i: %d\n",
1739 			    arvif->vdev_id, ret);
1740 		return ret;
1741 	}
1742 
1743 	/* Vdev down reset beacon & presp templates. Reinstall them. Otherwise
1744 	 * firmware will crash upon vdev up.
1745 	 */
1746 
1747 	ret = ath10k_mac_setup_bcn_tmpl(arvif);
1748 	if (ret) {
1749 		ath10k_warn(ar, "failed to update beacon template: %d\n", ret);
1750 		return ret;
1751 	}
1752 
1753 	ret = ath10k_mac_setup_prb_tmpl(arvif);
1754 	if (ret) {
1755 		ath10k_warn(ar, "failed to update presp template: %d\n", ret);
1756 		return ret;
1757 	}
1758 
1759 	ret = ath10k_vdev_restart(arvif, &def);
1760 	if (ret) {
1761 		ath10k_warn(ar, "failed to restart ap vdev %i: %d\n",
1762 			    arvif->vdev_id, ret);
1763 		return ret;
1764 	}
1765 
1766 	ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1767 				 arvif->bssid);
1768 	if (ret) {
1769 		ath10k_warn(ar, "failed to bring up ap vdev %i: %d\n",
1770 			    arvif->vdev_id, ret);
1771 		return ret;
1772 	}
1773 
1774 	return 0;
1775 }
1776 
ath10k_control_beaconing(struct ath10k_vif * arvif,struct ieee80211_bss_conf * info)1777 static void ath10k_control_beaconing(struct ath10k_vif *arvif,
1778 				     struct ieee80211_bss_conf *info)
1779 {
1780 	struct ath10k *ar = arvif->ar;
1781 	int ret = 0;
1782 
1783 	lockdep_assert_held(&arvif->ar->conf_mutex);
1784 
1785 	if (!info->enable_beacon) {
1786 		ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
1787 		if (ret)
1788 			ath10k_warn(ar, "failed to down vdev_id %i: %d\n",
1789 				    arvif->vdev_id, ret);
1790 
1791 		arvif->is_up = false;
1792 
1793 		spin_lock_bh(&arvif->ar->data_lock);
1794 		ath10k_mac_vif_beacon_free(arvif);
1795 		spin_unlock_bh(&arvif->ar->data_lock);
1796 
1797 		return;
1798 	}
1799 
1800 	arvif->tx_seq_no = 0x1000;
1801 
1802 	arvif->aid = 0;
1803 	ether_addr_copy(arvif->bssid, info->bssid);
1804 
1805 	ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
1806 				 arvif->bssid);
1807 	if (ret) {
1808 		ath10k_warn(ar, "failed to bring up vdev %d: %i\n",
1809 			    arvif->vdev_id, ret);
1810 		return;
1811 	}
1812 
1813 	arvif->is_up = true;
1814 
1815 	ret = ath10k_mac_vif_fix_hidden_ssid(arvif);
1816 	if (ret) {
1817 		ath10k_warn(ar, "failed to fix hidden ssid for vdev %i, expect trouble: %d\n",
1818 			    arvif->vdev_id, ret);
1819 		return;
1820 	}
1821 
1822 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d up\n", arvif->vdev_id);
1823 }
1824 
ath10k_control_ibss(struct ath10k_vif * arvif,struct ieee80211_bss_conf * info,const u8 self_peer[ETH_ALEN])1825 static void ath10k_control_ibss(struct ath10k_vif *arvif,
1826 				struct ieee80211_bss_conf *info,
1827 				const u8 self_peer[ETH_ALEN])
1828 {
1829 	struct ath10k *ar = arvif->ar;
1830 	u32 vdev_param;
1831 	int ret = 0;
1832 
1833 	lockdep_assert_held(&arvif->ar->conf_mutex);
1834 
1835 	if (!info->ibss_joined) {
1836 		if (is_zero_ether_addr(arvif->bssid))
1837 			return;
1838 
1839 		eth_zero_addr(arvif->bssid);
1840 
1841 		return;
1842 	}
1843 
1844 	vdev_param = arvif->ar->wmi.vdev_param->atim_window;
1845 	ret = ath10k_wmi_vdev_set_param(arvif->ar, arvif->vdev_id, vdev_param,
1846 					ATH10K_DEFAULT_ATIM);
1847 	if (ret)
1848 		ath10k_warn(ar, "failed to set IBSS ATIM for vdev %d: %d\n",
1849 			    arvif->vdev_id, ret);
1850 }
1851 
ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif * arvif)1852 static int ath10k_mac_vif_recalc_ps_wake_threshold(struct ath10k_vif *arvif)
1853 {
1854 	struct ath10k *ar = arvif->ar;
1855 	u32 param;
1856 	u32 value;
1857 	int ret;
1858 
1859 	lockdep_assert_held(&arvif->ar->conf_mutex);
1860 
1861 	if (arvif->u.sta.uapsd)
1862 		value = WMI_STA_PS_TX_WAKE_THRESHOLD_NEVER;
1863 	else
1864 		value = WMI_STA_PS_TX_WAKE_THRESHOLD_ALWAYS;
1865 
1866 	param = WMI_STA_PS_PARAM_TX_WAKE_THRESHOLD;
1867 	ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param, value);
1868 	if (ret) {
1869 		ath10k_warn(ar, "failed to submit ps wake threshold %u on vdev %i: %d\n",
1870 			    value, arvif->vdev_id, ret);
1871 		return ret;
1872 	}
1873 
1874 	return 0;
1875 }
1876 
ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif * arvif)1877 static int ath10k_mac_vif_recalc_ps_poll_count(struct ath10k_vif *arvif)
1878 {
1879 	struct ath10k *ar = arvif->ar;
1880 	u32 param;
1881 	u32 value;
1882 	int ret;
1883 
1884 	lockdep_assert_held(&arvif->ar->conf_mutex);
1885 
1886 	if (arvif->u.sta.uapsd)
1887 		value = WMI_STA_PS_PSPOLL_COUNT_UAPSD;
1888 	else
1889 		value = WMI_STA_PS_PSPOLL_COUNT_NO_MAX;
1890 
1891 	param = WMI_STA_PS_PARAM_PSPOLL_COUNT;
1892 	ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
1893 					  param, value);
1894 	if (ret) {
1895 		ath10k_warn(ar, "failed to submit ps poll count %u on vdev %i: %d\n",
1896 			    value, arvif->vdev_id, ret);
1897 		return ret;
1898 	}
1899 
1900 	return 0;
1901 }
1902 
ath10k_mac_num_vifs_started(struct ath10k * ar)1903 static int ath10k_mac_num_vifs_started(struct ath10k *ar)
1904 {
1905 	struct ath10k_vif *arvif;
1906 	int num = 0;
1907 
1908 	lockdep_assert_held(&ar->conf_mutex);
1909 
1910 	list_for_each_entry(arvif, &ar->arvifs, list)
1911 		if (arvif->is_started)
1912 			num++;
1913 
1914 	return num;
1915 }
1916 
ath10k_mac_vif_setup_ps(struct ath10k_vif * arvif)1917 static int ath10k_mac_vif_setup_ps(struct ath10k_vif *arvif)
1918 {
1919 	struct ath10k *ar = arvif->ar;
1920 	struct ieee80211_vif *vif = arvif->vif;
1921 	struct ieee80211_conf *conf = &ar->hw->conf;
1922 	enum wmi_sta_powersave_param param;
1923 	enum wmi_sta_ps_mode psmode;
1924 	int ret;
1925 	int ps_timeout;
1926 	bool enable_ps;
1927 
1928 	lockdep_assert_held(&arvif->ar->conf_mutex);
1929 
1930 	if (arvif->vif->type != NL80211_IFTYPE_STATION)
1931 		return 0;
1932 
1933 	enable_ps = arvif->ps;
1934 
1935 	if (enable_ps && ath10k_mac_num_vifs_started(ar) > 1 &&
1936 	    !test_bit(ATH10K_FW_FEATURE_MULTI_VIF_PS_SUPPORT,
1937 		      ar->running_fw->fw_file.fw_features)) {
1938 		ath10k_warn(ar, "refusing to enable ps on vdev %i: not supported by fw\n",
1939 			    arvif->vdev_id);
1940 		enable_ps = false;
1941 	}
1942 
1943 	if (!arvif->is_started) {
1944 		/* mac80211 can update vif powersave state while disconnected.
1945 		 * Firmware doesn't behave nicely and consumes more power than
1946 		 * necessary if PS is disabled on a non-started vdev. Hence
1947 		 * force-enable PS for non-running vdevs.
1948 		 */
1949 		psmode = WMI_STA_PS_MODE_ENABLED;
1950 	} else if (enable_ps) {
1951 		psmode = WMI_STA_PS_MODE_ENABLED;
1952 		param = WMI_STA_PS_PARAM_INACTIVITY_TIME;
1953 
1954 		ps_timeout = conf->dynamic_ps_timeout;
1955 		if (ps_timeout == 0) {
1956 			/* Firmware doesn't like 0 */
1957 			ps_timeout = ieee80211_tu_to_usec(
1958 				vif->bss_conf.beacon_int) / 1000;
1959 		}
1960 
1961 		ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id, param,
1962 						  ps_timeout);
1963 		if (ret) {
1964 			ath10k_warn(ar, "failed to set inactivity time for vdev %d: %i\n",
1965 				    arvif->vdev_id, ret);
1966 			return ret;
1967 		}
1968 	} else {
1969 		psmode = WMI_STA_PS_MODE_DISABLED;
1970 	}
1971 
1972 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d psmode %s\n",
1973 		   arvif->vdev_id, psmode ? "enable" : "disable");
1974 
1975 	ret = ath10k_wmi_set_psmode(ar, arvif->vdev_id, psmode);
1976 	if (ret) {
1977 		ath10k_warn(ar, "failed to set PS Mode %d for vdev %d: %d\n",
1978 			    psmode, arvif->vdev_id, ret);
1979 		return ret;
1980 	}
1981 
1982 	return 0;
1983 }
1984 
ath10k_mac_vif_disable_keepalive(struct ath10k_vif * arvif)1985 static int ath10k_mac_vif_disable_keepalive(struct ath10k_vif *arvif)
1986 {
1987 	struct ath10k *ar = arvif->ar;
1988 	struct wmi_sta_keepalive_arg arg = {};
1989 	int ret;
1990 
1991 	lockdep_assert_held(&arvif->ar->conf_mutex);
1992 
1993 	if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
1994 		return 0;
1995 
1996 	if (!test_bit(WMI_SERVICE_STA_KEEP_ALIVE, ar->wmi.svc_map))
1997 		return 0;
1998 
1999 	/* Some firmware revisions have a bug and ignore the `enabled` field.
2000 	 * Instead use the interval to disable the keepalive.
2001 	 */
2002 	arg.vdev_id = arvif->vdev_id;
2003 	arg.enabled = 1;
2004 	arg.method = WMI_STA_KEEPALIVE_METHOD_NULL_FRAME;
2005 	arg.interval = WMI_STA_KEEPALIVE_INTERVAL_DISABLE;
2006 
2007 	ret = ath10k_wmi_sta_keepalive(ar, &arg);
2008 	if (ret) {
2009 		ath10k_warn(ar, "failed to submit keepalive on vdev %i: %d\n",
2010 			    arvif->vdev_id, ret);
2011 		return ret;
2012 	}
2013 
2014 	return 0;
2015 }
2016 
ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif * arvif)2017 static void ath10k_mac_vif_ap_csa_count_down(struct ath10k_vif *arvif)
2018 {
2019 	struct ath10k *ar = arvif->ar;
2020 	struct ieee80211_vif *vif = arvif->vif;
2021 	int ret;
2022 
2023 	lockdep_assert_held(&arvif->ar->conf_mutex);
2024 
2025 	if (WARN_ON(!test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)))
2026 		return;
2027 
2028 	if (arvif->vdev_type != WMI_VDEV_TYPE_AP)
2029 		return;
2030 
2031 	if (!vif->bss_conf.csa_active)
2032 		return;
2033 
2034 	if (!arvif->is_up)
2035 		return;
2036 
2037 	if (!ieee80211_beacon_cntdwn_is_complete(vif)) {
2038 		ieee80211_beacon_update_cntdwn(vif);
2039 
2040 		ret = ath10k_mac_setup_bcn_tmpl(arvif);
2041 		if (ret)
2042 			ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
2043 				    ret);
2044 
2045 		ret = ath10k_mac_setup_prb_tmpl(arvif);
2046 		if (ret)
2047 			ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
2048 				    ret);
2049 	} else {
2050 		ieee80211_csa_finish(vif);
2051 	}
2052 }
2053 
ath10k_mac_vif_ap_csa_work(struct work_struct * work)2054 static void ath10k_mac_vif_ap_csa_work(struct work_struct *work)
2055 {
2056 	struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
2057 						ap_csa_work);
2058 	struct ath10k *ar = arvif->ar;
2059 
2060 	mutex_lock(&ar->conf_mutex);
2061 	ath10k_mac_vif_ap_csa_count_down(arvif);
2062 	mutex_unlock(&ar->conf_mutex);
2063 }
2064 
ath10k_mac_handle_beacon_iter(void * data,u8 * mac,struct ieee80211_vif * vif)2065 static void ath10k_mac_handle_beacon_iter(void *data, u8 *mac,
2066 					  struct ieee80211_vif *vif)
2067 {
2068 	struct sk_buff *skb = data;
2069 	struct ieee80211_mgmt *mgmt = (void *)skb->data;
2070 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2071 
2072 	if (vif->type != NL80211_IFTYPE_STATION)
2073 		return;
2074 
2075 	if (!ether_addr_equal(mgmt->bssid, vif->bss_conf.bssid))
2076 		return;
2077 
2078 	cancel_delayed_work(&arvif->connection_loss_work);
2079 }
2080 
ath10k_mac_handle_beacon(struct ath10k * ar,struct sk_buff * skb)2081 void ath10k_mac_handle_beacon(struct ath10k *ar, struct sk_buff *skb)
2082 {
2083 	ieee80211_iterate_active_interfaces_atomic(ar->hw,
2084 						   ATH10K_ITER_NORMAL_FLAGS,
2085 						   ath10k_mac_handle_beacon_iter,
2086 						   skb);
2087 }
2088 
ath10k_mac_handle_beacon_miss_iter(void * data,u8 * mac,struct ieee80211_vif * vif)2089 static void ath10k_mac_handle_beacon_miss_iter(void *data, u8 *mac,
2090 					       struct ieee80211_vif *vif)
2091 {
2092 	u32 *vdev_id = data;
2093 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2094 	struct ath10k *ar = arvif->ar;
2095 	struct ieee80211_hw *hw = ar->hw;
2096 
2097 	if (arvif->vdev_id != *vdev_id)
2098 		return;
2099 
2100 	if (!arvif->is_up)
2101 		return;
2102 
2103 	ieee80211_beacon_loss(vif);
2104 
2105 	/* Firmware doesn't report beacon loss events repeatedly. If AP probe
2106 	 * (done by mac80211) succeeds but beacons do not resume then it
2107 	 * doesn't make sense to continue operation. Queue connection loss work
2108 	 * which can be cancelled when beacon is received.
2109 	 */
2110 	ieee80211_queue_delayed_work(hw, &arvif->connection_loss_work,
2111 				     ATH10K_CONNECTION_LOSS_HZ);
2112 }
2113 
ath10k_mac_handle_beacon_miss(struct ath10k * ar,u32 vdev_id)2114 void ath10k_mac_handle_beacon_miss(struct ath10k *ar, u32 vdev_id)
2115 {
2116 	ieee80211_iterate_active_interfaces_atomic(ar->hw,
2117 						   ATH10K_ITER_NORMAL_FLAGS,
2118 						   ath10k_mac_handle_beacon_miss_iter,
2119 						   &vdev_id);
2120 }
2121 
ath10k_mac_vif_sta_connection_loss_work(struct work_struct * work)2122 static void ath10k_mac_vif_sta_connection_loss_work(struct work_struct *work)
2123 {
2124 	struct ath10k_vif *arvif = container_of(work, struct ath10k_vif,
2125 						connection_loss_work.work);
2126 	struct ieee80211_vif *vif = arvif->vif;
2127 
2128 	if (!arvif->is_up)
2129 		return;
2130 
2131 	ieee80211_connection_loss(vif);
2132 }
2133 
2134 /**********************/
2135 /* Station management */
2136 /**********************/
2137 
ath10k_peer_assoc_h_listen_intval(struct ath10k * ar,struct ieee80211_vif * vif)2138 static u32 ath10k_peer_assoc_h_listen_intval(struct ath10k *ar,
2139 					     struct ieee80211_vif *vif)
2140 {
2141 	/* Some firmware revisions have unstable STA powersave when listen
2142 	 * interval is set too high (e.g. 5). The symptoms are firmware doesn't
2143 	 * generate NullFunc frames properly even if buffered frames have been
2144 	 * indicated in Beacon TIM. Firmware would seldom wake up to pull
2145 	 * buffered frames. Often pinging the device from AP would simply fail.
2146 	 *
2147 	 * As a workaround set it to 1.
2148 	 */
2149 	if (vif->type == NL80211_IFTYPE_STATION)
2150 		return 1;
2151 
2152 	return ar->hw->conf.listen_interval;
2153 }
2154 
ath10k_peer_assoc_h_basic(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2155 static void ath10k_peer_assoc_h_basic(struct ath10k *ar,
2156 				      struct ieee80211_vif *vif,
2157 				      struct ieee80211_sta *sta,
2158 				      struct wmi_peer_assoc_complete_arg *arg)
2159 {
2160 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2161 	u32 aid;
2162 
2163 	lockdep_assert_held(&ar->conf_mutex);
2164 
2165 	if (vif->type == NL80211_IFTYPE_STATION)
2166 		aid = vif->bss_conf.aid;
2167 	else
2168 		aid = sta->aid;
2169 
2170 	ether_addr_copy(arg->addr, sta->addr);
2171 	arg->vdev_id = arvif->vdev_id;
2172 	arg->peer_aid = aid;
2173 	arg->peer_flags |= arvif->ar->wmi.peer_flags->auth;
2174 	arg->peer_listen_intval = ath10k_peer_assoc_h_listen_intval(ar, vif);
2175 	arg->peer_num_spatial_streams = 1;
2176 	arg->peer_caps = vif->bss_conf.assoc_capability;
2177 }
2178 
ath10k_peer_assoc_h_crypto(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2179 static void ath10k_peer_assoc_h_crypto(struct ath10k *ar,
2180 				       struct ieee80211_vif *vif,
2181 				       struct ieee80211_sta *sta,
2182 				       struct wmi_peer_assoc_complete_arg *arg)
2183 {
2184 	struct ieee80211_bss_conf *info = &vif->bss_conf;
2185 	struct cfg80211_chan_def def;
2186 	struct cfg80211_bss *bss;
2187 	const u8 *rsnie = NULL;
2188 	const u8 *wpaie = NULL;
2189 
2190 	lockdep_assert_held(&ar->conf_mutex);
2191 
2192 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2193 		return;
2194 
2195 	bss = cfg80211_get_bss(ar->hw->wiphy, def.chan, info->bssid,
2196 			       info->ssid_len ? info->ssid : NULL, info->ssid_len,
2197 			       IEEE80211_BSS_TYPE_ANY, IEEE80211_PRIVACY_ANY);
2198 	if (bss) {
2199 		const struct cfg80211_bss_ies *ies;
2200 
2201 		rcu_read_lock();
2202 		rsnie = ieee80211_bss_get_ie(bss, WLAN_EID_RSN);
2203 
2204 		ies = rcu_dereference(bss->ies);
2205 
2206 		wpaie = cfg80211_find_vendor_ie(WLAN_OUI_MICROSOFT,
2207 						WLAN_OUI_TYPE_MICROSOFT_WPA,
2208 						ies->data,
2209 						ies->len);
2210 		rcu_read_unlock();
2211 		cfg80211_put_bss(ar->hw->wiphy, bss);
2212 	}
2213 
2214 	/* FIXME: base on RSN IE/WPA IE is a correct idea? */
2215 	if (rsnie || wpaie) {
2216 		ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: rsn ie found\n", __func__);
2217 		arg->peer_flags |= ar->wmi.peer_flags->need_ptk_4_way;
2218 	}
2219 
2220 	if (wpaie) {
2221 		ath10k_dbg(ar, ATH10K_DBG_WMI, "%s: wpa ie found\n", __func__);
2222 		arg->peer_flags |= ar->wmi.peer_flags->need_gtk_2_way;
2223 	}
2224 
2225 	if (sta->mfp &&
2226 	    test_bit(ATH10K_FW_FEATURE_MFP_SUPPORT,
2227 		     ar->running_fw->fw_file.fw_features)) {
2228 		arg->peer_flags |= ar->wmi.peer_flags->pmf;
2229 	}
2230 }
2231 
ath10k_peer_assoc_h_rates(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2232 static void ath10k_peer_assoc_h_rates(struct ath10k *ar,
2233 				      struct ieee80211_vif *vif,
2234 				      struct ieee80211_sta *sta,
2235 				      struct wmi_peer_assoc_complete_arg *arg)
2236 {
2237 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2238 	struct wmi_rate_set_arg *rateset = &arg->peer_legacy_rates;
2239 	struct cfg80211_chan_def def;
2240 	const struct ieee80211_supported_band *sband;
2241 	const struct ieee80211_rate *rates;
2242 	enum nl80211_band band;
2243 	u32 ratemask;
2244 	u8 rate;
2245 	int i;
2246 
2247 	lockdep_assert_held(&ar->conf_mutex);
2248 
2249 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2250 		return;
2251 
2252 	band = def.chan->band;
2253 	sband = ar->hw->wiphy->bands[band];
2254 	ratemask = sta->deflink.supp_rates[band];
2255 	ratemask &= arvif->bitrate_mask.control[band].legacy;
2256 	rates = sband->bitrates;
2257 
2258 	rateset->num_rates = 0;
2259 
2260 	for (i = 0; i < 32; i++, ratemask >>= 1, rates++) {
2261 		if (!(ratemask & 1))
2262 			continue;
2263 
2264 		rate = ath10k_mac_bitrate_to_rate(rates->bitrate);
2265 		rateset->rates[rateset->num_rates] = rate;
2266 		rateset->num_rates++;
2267 	}
2268 }
2269 
2270 static bool
ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])2271 ath10k_peer_assoc_h_ht_masked(const u8 ht_mcs_mask[IEEE80211_HT_MCS_MASK_LEN])
2272 {
2273 	int nss;
2274 
2275 	for (nss = 0; nss < IEEE80211_HT_MCS_MASK_LEN; nss++)
2276 		if (ht_mcs_mask[nss])
2277 			return false;
2278 
2279 	return true;
2280 }
2281 
2282 static bool
ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])2283 ath10k_peer_assoc_h_vht_masked(const u16 vht_mcs_mask[NL80211_VHT_NSS_MAX])
2284 {
2285 	int nss;
2286 
2287 	for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++)
2288 		if (vht_mcs_mask[nss])
2289 			return false;
2290 
2291 	return true;
2292 }
2293 
ath10k_peer_assoc_h_ht(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2294 static void ath10k_peer_assoc_h_ht(struct ath10k *ar,
2295 				   struct ieee80211_vif *vif,
2296 				   struct ieee80211_sta *sta,
2297 				   struct wmi_peer_assoc_complete_arg *arg)
2298 {
2299 	const struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
2300 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2301 	struct cfg80211_chan_def def;
2302 	enum nl80211_band band;
2303 	const u8 *ht_mcs_mask;
2304 	const u16 *vht_mcs_mask;
2305 	int i, n;
2306 	u8 max_nss;
2307 	u32 stbc;
2308 
2309 	lockdep_assert_held(&ar->conf_mutex);
2310 
2311 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2312 		return;
2313 
2314 	if (!ht_cap->ht_supported)
2315 		return;
2316 
2317 	band = def.chan->band;
2318 	ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2319 	vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2320 
2321 	if (ath10k_peer_assoc_h_ht_masked(ht_mcs_mask) &&
2322 	    ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2323 		return;
2324 
2325 	arg->peer_flags |= ar->wmi.peer_flags->ht;
2326 	arg->peer_max_mpdu = (1 << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2327 				    ht_cap->ampdu_factor)) - 1;
2328 
2329 	arg->peer_mpdu_density =
2330 		ath10k_parse_mpdudensity(ht_cap->ampdu_density);
2331 
2332 	arg->peer_ht_caps = ht_cap->cap;
2333 	arg->peer_rate_caps |= WMI_RC_HT_FLAG;
2334 
2335 	if (ht_cap->cap & IEEE80211_HT_CAP_LDPC_CODING)
2336 		arg->peer_flags |= ar->wmi.peer_flags->ldbc;
2337 
2338 	if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40) {
2339 		arg->peer_flags |= ar->wmi.peer_flags->bw40;
2340 		arg->peer_rate_caps |= WMI_RC_CW40_FLAG;
2341 	}
2342 
2343 	if (arvif->bitrate_mask.control[band].gi != NL80211_TXRATE_FORCE_LGI) {
2344 		if (ht_cap->cap & IEEE80211_HT_CAP_SGI_20)
2345 			arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2346 
2347 		if (ht_cap->cap & IEEE80211_HT_CAP_SGI_40)
2348 			arg->peer_rate_caps |= WMI_RC_SGI_FLAG;
2349 	}
2350 
2351 	if (ht_cap->cap & IEEE80211_HT_CAP_TX_STBC) {
2352 		arg->peer_rate_caps |= WMI_RC_TX_STBC_FLAG;
2353 		arg->peer_flags |= ar->wmi.peer_flags->stbc;
2354 	}
2355 
2356 	if (ht_cap->cap & IEEE80211_HT_CAP_RX_STBC) {
2357 		stbc = ht_cap->cap & IEEE80211_HT_CAP_RX_STBC;
2358 		stbc = stbc >> IEEE80211_HT_CAP_RX_STBC_SHIFT;
2359 		stbc = stbc << WMI_RC_RX_STBC_FLAG_S;
2360 		arg->peer_rate_caps |= stbc;
2361 		arg->peer_flags |= ar->wmi.peer_flags->stbc;
2362 	}
2363 
2364 	if (ht_cap->mcs.rx_mask[1] && ht_cap->mcs.rx_mask[2])
2365 		arg->peer_rate_caps |= WMI_RC_TS_FLAG;
2366 	else if (ht_cap->mcs.rx_mask[1])
2367 		arg->peer_rate_caps |= WMI_RC_DS_FLAG;
2368 
2369 	for (i = 0, n = 0, max_nss = 0; i < IEEE80211_HT_MCS_MASK_LEN * 8; i++)
2370 		if ((ht_cap->mcs.rx_mask[i / 8] & BIT(i % 8)) &&
2371 		    (ht_mcs_mask[i / 8] & BIT(i % 8))) {
2372 			max_nss = (i / 8) + 1;
2373 			arg->peer_ht_rates.rates[n++] = i;
2374 		}
2375 
2376 	/*
2377 	 * This is a workaround for HT-enabled STAs which break the spec
2378 	 * and have no HT capabilities RX mask (no HT RX MCS map).
2379 	 *
2380 	 * As per spec, in section 20.3.5 Modulation and coding scheme (MCS),
2381 	 * MCS 0 through 7 are mandatory in 20MHz with 800 ns GI at all STAs.
2382 	 *
2383 	 * Firmware asserts if such situation occurs.
2384 	 */
2385 	if (n == 0) {
2386 		arg->peer_ht_rates.num_rates = 8;
2387 		for (i = 0; i < arg->peer_ht_rates.num_rates; i++)
2388 			arg->peer_ht_rates.rates[i] = i;
2389 	} else {
2390 		arg->peer_ht_rates.num_rates = n;
2391 		arg->peer_num_spatial_streams = min(sta->deflink.rx_nss,
2392 						    max_nss);
2393 	}
2394 
2395 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ht peer %pM mcs cnt %d nss %d\n",
2396 		   arg->addr,
2397 		   arg->peer_ht_rates.num_rates,
2398 		   arg->peer_num_spatial_streams);
2399 }
2400 
ath10k_peer_assoc_qos_ap(struct ath10k * ar,struct ath10k_vif * arvif,struct ieee80211_sta * sta)2401 static int ath10k_peer_assoc_qos_ap(struct ath10k *ar,
2402 				    struct ath10k_vif *arvif,
2403 				    struct ieee80211_sta *sta)
2404 {
2405 	u32 uapsd = 0;
2406 	u32 max_sp = 0;
2407 	int ret = 0;
2408 
2409 	lockdep_assert_held(&ar->conf_mutex);
2410 
2411 	if (sta->wme && sta->uapsd_queues) {
2412 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac uapsd_queues 0x%x max_sp %d\n",
2413 			   sta->uapsd_queues, sta->max_sp);
2414 
2415 		if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO)
2416 			uapsd |= WMI_AP_PS_UAPSD_AC3_DELIVERY_EN |
2417 				 WMI_AP_PS_UAPSD_AC3_TRIGGER_EN;
2418 		if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI)
2419 			uapsd |= WMI_AP_PS_UAPSD_AC2_DELIVERY_EN |
2420 				 WMI_AP_PS_UAPSD_AC2_TRIGGER_EN;
2421 		if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK)
2422 			uapsd |= WMI_AP_PS_UAPSD_AC1_DELIVERY_EN |
2423 				 WMI_AP_PS_UAPSD_AC1_TRIGGER_EN;
2424 		if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE)
2425 			uapsd |= WMI_AP_PS_UAPSD_AC0_DELIVERY_EN |
2426 				 WMI_AP_PS_UAPSD_AC0_TRIGGER_EN;
2427 
2428 		if (sta->max_sp < MAX_WMI_AP_PS_PEER_PARAM_MAX_SP)
2429 			max_sp = sta->max_sp;
2430 
2431 		ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2432 						 sta->addr,
2433 						 WMI_AP_PS_PEER_PARAM_UAPSD,
2434 						 uapsd);
2435 		if (ret) {
2436 			ath10k_warn(ar, "failed to set ap ps peer param uapsd for vdev %i: %d\n",
2437 				    arvif->vdev_id, ret);
2438 			return ret;
2439 		}
2440 
2441 		ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id,
2442 						 sta->addr,
2443 						 WMI_AP_PS_PEER_PARAM_MAX_SP,
2444 						 max_sp);
2445 		if (ret) {
2446 			ath10k_warn(ar, "failed to set ap ps peer param max sp for vdev %i: %d\n",
2447 				    arvif->vdev_id, ret);
2448 			return ret;
2449 		}
2450 
2451 		/* TODO setup this based on STA listen interval and
2452 		 * beacon interval. Currently we don't know
2453 		 * sta->listen_interval - mac80211 patch required.
2454 		 * Currently use 10 seconds
2455 		 */
2456 		ret = ath10k_wmi_set_ap_ps_param(ar, arvif->vdev_id, sta->addr,
2457 						 WMI_AP_PS_PEER_PARAM_AGEOUT_TIME,
2458 						 10);
2459 		if (ret) {
2460 			ath10k_warn(ar, "failed to set ap ps peer param ageout time for vdev %i: %d\n",
2461 				    arvif->vdev_id, ret);
2462 			return ret;
2463 		}
2464 	}
2465 
2466 	return 0;
2467 }
2468 
2469 static u16
ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])2470 ath10k_peer_assoc_h_vht_limit(u16 tx_mcs_set,
2471 			      const u16 vht_mcs_limit[NL80211_VHT_NSS_MAX])
2472 {
2473 	int idx_limit;
2474 	int nss;
2475 	u16 mcs_map;
2476 	u16 mcs;
2477 
2478 	for (nss = 0; nss < NL80211_VHT_NSS_MAX; nss++) {
2479 		mcs_map = ath10k_mac_get_max_vht_mcs_map(tx_mcs_set, nss) &
2480 			  vht_mcs_limit[nss];
2481 
2482 		if (mcs_map)
2483 			idx_limit = fls(mcs_map) - 1;
2484 		else
2485 			idx_limit = -1;
2486 
2487 		switch (idx_limit) {
2488 		case 0:
2489 		case 1:
2490 		case 2:
2491 		case 3:
2492 		case 4:
2493 		case 5:
2494 		case 6:
2495 		default:
2496 			/* see ath10k_mac_can_set_bitrate_mask() */
2497 			WARN_ON(1);
2498 			fallthrough;
2499 		case -1:
2500 			mcs = IEEE80211_VHT_MCS_NOT_SUPPORTED;
2501 			break;
2502 		case 7:
2503 			mcs = IEEE80211_VHT_MCS_SUPPORT_0_7;
2504 			break;
2505 		case 8:
2506 			mcs = IEEE80211_VHT_MCS_SUPPORT_0_8;
2507 			break;
2508 		case 9:
2509 			mcs = IEEE80211_VHT_MCS_SUPPORT_0_9;
2510 			break;
2511 		}
2512 
2513 		tx_mcs_set &= ~(0x3 << (nss * 2));
2514 		tx_mcs_set |= mcs << (nss * 2);
2515 	}
2516 
2517 	return tx_mcs_set;
2518 }
2519 
get_160mhz_nss_from_maxrate(int rate)2520 static u32 get_160mhz_nss_from_maxrate(int rate)
2521 {
2522 	u32 nss;
2523 
2524 	switch (rate) {
2525 	case 780:
2526 		nss = 1;
2527 		break;
2528 	case 1560:
2529 		nss = 2;
2530 		break;
2531 	case 2106:
2532 		nss = 3; /* not support MCS9 from spec*/
2533 		break;
2534 	case 3120:
2535 		nss = 4;
2536 		break;
2537 	default:
2538 		 nss = 1;
2539 	}
2540 
2541 	return nss;
2542 }
2543 
ath10k_peer_assoc_h_vht(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2544 static void ath10k_peer_assoc_h_vht(struct ath10k *ar,
2545 				    struct ieee80211_vif *vif,
2546 				    struct ieee80211_sta *sta,
2547 				    struct wmi_peer_assoc_complete_arg *arg)
2548 {
2549 	const struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2550 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2551 	struct ath10k_hw_params *hw = &ar->hw_params;
2552 	struct cfg80211_chan_def def;
2553 	enum nl80211_band band;
2554 	const u16 *vht_mcs_mask;
2555 	u8 ampdu_factor;
2556 	u8 max_nss, vht_mcs;
2557 	int i;
2558 
2559 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2560 		return;
2561 
2562 	if (!vht_cap->vht_supported)
2563 		return;
2564 
2565 	band = def.chan->band;
2566 	vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2567 
2568 	if (ath10k_peer_assoc_h_vht_masked(vht_mcs_mask))
2569 		return;
2570 
2571 	arg->peer_flags |= ar->wmi.peer_flags->vht;
2572 
2573 	if (def.chan->band == NL80211_BAND_2GHZ)
2574 		arg->peer_flags |= ar->wmi.peer_flags->vht_2g;
2575 
2576 	arg->peer_vht_caps = vht_cap->cap;
2577 
2578 	ampdu_factor = (vht_cap->cap &
2579 			IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK) >>
2580 		       IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
2581 
2582 	/* Workaround: Some Netgear/Linksys 11ac APs set Rx A-MPDU factor to
2583 	 * zero in VHT IE. Using it would result in degraded throughput.
2584 	 * arg->peer_max_mpdu at this point contains HT max_mpdu so keep
2585 	 * it if VHT max_mpdu is smaller.
2586 	 */
2587 	arg->peer_max_mpdu = max(arg->peer_max_mpdu,
2588 				 (1U << (IEEE80211_HT_MAX_AMPDU_FACTOR +
2589 					ampdu_factor)) - 1);
2590 
2591 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2592 		arg->peer_flags |= ar->wmi.peer_flags->bw80;
2593 
2594 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160)
2595 		arg->peer_flags |= ar->wmi.peer_flags->bw160;
2596 
2597 	/* Calculate peer NSS capability from VHT capabilities if STA
2598 	 * supports VHT.
2599 	 */
2600 	for (i = 0, max_nss = 0, vht_mcs = 0; i < NL80211_VHT_NSS_MAX; i++) {
2601 		vht_mcs = __le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map) >>
2602 			  (2 * i) & 3;
2603 
2604 		if ((vht_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED) &&
2605 		    vht_mcs_mask[i])
2606 			max_nss = i + 1;
2607 	}
2608 	arg->peer_num_spatial_streams = min(sta->deflink.rx_nss, max_nss);
2609 	arg->peer_vht_rates.rx_max_rate =
2610 		__le16_to_cpu(vht_cap->vht_mcs.rx_highest);
2611 	arg->peer_vht_rates.rx_mcs_set =
2612 		__le16_to_cpu(vht_cap->vht_mcs.rx_mcs_map);
2613 	arg->peer_vht_rates.tx_max_rate =
2614 		__le16_to_cpu(vht_cap->vht_mcs.tx_highest);
2615 	arg->peer_vht_rates.tx_mcs_set = ath10k_peer_assoc_h_vht_limit(
2616 		__le16_to_cpu(vht_cap->vht_mcs.tx_mcs_map), vht_mcs_mask);
2617 
2618 	/* Configure bandwidth-NSS mapping to FW
2619 	 * for the chip's tx chains setting on 160Mhz bw
2620 	 */
2621 	if (arg->peer_phymode == MODE_11AC_VHT160 ||
2622 	    arg->peer_phymode == MODE_11AC_VHT80_80) {
2623 		u32 rx_nss;
2624 		u32 max_rate;
2625 
2626 		max_rate = arg->peer_vht_rates.rx_max_rate;
2627 		rx_nss = get_160mhz_nss_from_maxrate(max_rate);
2628 
2629 		if (rx_nss == 0)
2630 			rx_nss = arg->peer_num_spatial_streams;
2631 		else
2632 			rx_nss = min(arg->peer_num_spatial_streams, rx_nss);
2633 
2634 		max_rate = hw->vht160_mcs_tx_highest;
2635 		rx_nss = min(rx_nss, get_160mhz_nss_from_maxrate(max_rate));
2636 
2637 		arg->peer_bw_rxnss_override =
2638 			FIELD_PREP(WMI_PEER_NSS_MAP_ENABLE, 1) |
2639 			FIELD_PREP(WMI_PEER_NSS_160MHZ_MASK, (rx_nss - 1));
2640 
2641 		if (arg->peer_phymode == MODE_11AC_VHT80_80) {
2642 			arg->peer_bw_rxnss_override |=
2643 			FIELD_PREP(WMI_PEER_NSS_80_80MHZ_MASK, (rx_nss - 1));
2644 		}
2645 	}
2646 	ath10k_dbg(ar, ATH10K_DBG_MAC,
2647 		   "mac vht peer %pM max_mpdu %d flags 0x%x peer_rx_nss_override 0x%x\n",
2648 		   sta->addr, arg->peer_max_mpdu,
2649 		   arg->peer_flags, arg->peer_bw_rxnss_override);
2650 }
2651 
ath10k_peer_assoc_h_qos(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2652 static void ath10k_peer_assoc_h_qos(struct ath10k *ar,
2653 				    struct ieee80211_vif *vif,
2654 				    struct ieee80211_sta *sta,
2655 				    struct wmi_peer_assoc_complete_arg *arg)
2656 {
2657 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2658 
2659 	switch (arvif->vdev_type) {
2660 	case WMI_VDEV_TYPE_AP:
2661 		if (sta->wme)
2662 			arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2663 
2664 		if (sta->wme && sta->uapsd_queues) {
2665 			arg->peer_flags |= arvif->ar->wmi.peer_flags->apsd;
2666 			arg->peer_rate_caps |= WMI_RC_UAPSD_FLAG;
2667 		}
2668 		break;
2669 	case WMI_VDEV_TYPE_STA:
2670 		if (sta->wme)
2671 			arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2672 		break;
2673 	case WMI_VDEV_TYPE_IBSS:
2674 		if (sta->wme)
2675 			arg->peer_flags |= arvif->ar->wmi.peer_flags->qos;
2676 		break;
2677 	default:
2678 		break;
2679 	}
2680 
2681 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM qos %d\n",
2682 		   sta->addr, !!(arg->peer_flags &
2683 		   arvif->ar->wmi.peer_flags->qos));
2684 }
2685 
ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta * sta)2686 static bool ath10k_mac_sta_has_ofdm_only(struct ieee80211_sta *sta)
2687 {
2688 	return sta->deflink.supp_rates[NL80211_BAND_2GHZ] >>
2689 	       ATH10K_MAC_FIRST_OFDM_RATE_IDX;
2690 }
2691 
ath10k_mac_get_phymode_vht(struct ath10k * ar,struct ieee80211_sta * sta)2692 static enum wmi_phy_mode ath10k_mac_get_phymode_vht(struct ath10k *ar,
2693 						    struct ieee80211_sta *sta)
2694 {
2695 	struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
2696 
2697 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_160) {
2698 		switch (vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
2699 		case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
2700 			return MODE_11AC_VHT160;
2701 		case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ:
2702 			return MODE_11AC_VHT80_80;
2703 		default:
2704 			/* not sure if this is a valid case? */
2705 			return MODE_11AC_VHT160;
2706 		}
2707 	}
2708 
2709 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_80)
2710 		return MODE_11AC_VHT80;
2711 
2712 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2713 		return MODE_11AC_VHT40;
2714 
2715 	if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_20)
2716 		return MODE_11AC_VHT20;
2717 
2718 	return MODE_UNKNOWN;
2719 }
2720 
ath10k_peer_assoc_h_phymode(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2721 static void ath10k_peer_assoc_h_phymode(struct ath10k *ar,
2722 					struct ieee80211_vif *vif,
2723 					struct ieee80211_sta *sta,
2724 					struct wmi_peer_assoc_complete_arg *arg)
2725 {
2726 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2727 	struct cfg80211_chan_def def;
2728 	enum nl80211_band band;
2729 	const u8 *ht_mcs_mask;
2730 	const u16 *vht_mcs_mask;
2731 	enum wmi_phy_mode phymode = MODE_UNKNOWN;
2732 
2733 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
2734 		return;
2735 
2736 	band = def.chan->band;
2737 	ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
2738 	vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
2739 
2740 	switch (band) {
2741 	case NL80211_BAND_2GHZ:
2742 		if (sta->deflink.vht_cap.vht_supported &&
2743 		    !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2744 			if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2745 				phymode = MODE_11AC_VHT40;
2746 			else
2747 				phymode = MODE_11AC_VHT20;
2748 		} else if (sta->deflink.ht_cap.ht_supported &&
2749 			   !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2750 			if (sta->deflink.bandwidth == IEEE80211_STA_RX_BW_40)
2751 				phymode = MODE_11NG_HT40;
2752 			else
2753 				phymode = MODE_11NG_HT20;
2754 		} else if (ath10k_mac_sta_has_ofdm_only(sta)) {
2755 			phymode = MODE_11G;
2756 		} else {
2757 			phymode = MODE_11B;
2758 		}
2759 
2760 		break;
2761 	case NL80211_BAND_5GHZ:
2762 		/*
2763 		 * Check VHT first.
2764 		 */
2765 		if (sta->deflink.vht_cap.vht_supported &&
2766 		    !ath10k_peer_assoc_h_vht_masked(vht_mcs_mask)) {
2767 			phymode = ath10k_mac_get_phymode_vht(ar, sta);
2768 		} else if (sta->deflink.ht_cap.ht_supported &&
2769 			   !ath10k_peer_assoc_h_ht_masked(ht_mcs_mask)) {
2770 			if (sta->deflink.bandwidth >= IEEE80211_STA_RX_BW_40)
2771 				phymode = MODE_11NA_HT40;
2772 			else
2773 				phymode = MODE_11NA_HT20;
2774 		} else {
2775 			phymode = MODE_11A;
2776 		}
2777 
2778 		break;
2779 	default:
2780 		break;
2781 	}
2782 
2783 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac peer %pM phymode %s\n",
2784 		   sta->addr, ath10k_wmi_phymode_str(phymode));
2785 
2786 	arg->peer_phymode = phymode;
2787 	WARN_ON(phymode == MODE_UNKNOWN);
2788 }
2789 
ath10k_peer_assoc_prepare(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct wmi_peer_assoc_complete_arg * arg)2790 static int ath10k_peer_assoc_prepare(struct ath10k *ar,
2791 				     struct ieee80211_vif *vif,
2792 				     struct ieee80211_sta *sta,
2793 				     struct wmi_peer_assoc_complete_arg *arg)
2794 {
2795 	lockdep_assert_held(&ar->conf_mutex);
2796 
2797 	memset(arg, 0, sizeof(*arg));
2798 
2799 	ath10k_peer_assoc_h_basic(ar, vif, sta, arg);
2800 	ath10k_peer_assoc_h_crypto(ar, vif, sta, arg);
2801 	ath10k_peer_assoc_h_rates(ar, vif, sta, arg);
2802 	ath10k_peer_assoc_h_ht(ar, vif, sta, arg);
2803 	ath10k_peer_assoc_h_phymode(ar, vif, sta, arg);
2804 	ath10k_peer_assoc_h_vht(ar, vif, sta, arg);
2805 	ath10k_peer_assoc_h_qos(ar, vif, sta, arg);
2806 
2807 	return 0;
2808 }
2809 
2810 static const u32 ath10k_smps_map[] = {
2811 	[WLAN_HT_CAP_SM_PS_STATIC] = WMI_PEER_SMPS_STATIC,
2812 	[WLAN_HT_CAP_SM_PS_DYNAMIC] = WMI_PEER_SMPS_DYNAMIC,
2813 	[WLAN_HT_CAP_SM_PS_INVALID] = WMI_PEER_SMPS_PS_NONE,
2814 	[WLAN_HT_CAP_SM_PS_DISABLED] = WMI_PEER_SMPS_PS_NONE,
2815 };
2816 
ath10k_setup_peer_smps(struct ath10k * ar,struct ath10k_vif * arvif,const u8 * addr,const struct ieee80211_sta_ht_cap * ht_cap)2817 static int ath10k_setup_peer_smps(struct ath10k *ar, struct ath10k_vif *arvif,
2818 				  const u8 *addr,
2819 				  const struct ieee80211_sta_ht_cap *ht_cap)
2820 {
2821 	int smps;
2822 
2823 	if (!ht_cap->ht_supported)
2824 		return 0;
2825 
2826 	smps = ht_cap->cap & IEEE80211_HT_CAP_SM_PS;
2827 	smps >>= IEEE80211_HT_CAP_SM_PS_SHIFT;
2828 
2829 	if (smps >= ARRAY_SIZE(ath10k_smps_map))
2830 		return -EINVAL;
2831 
2832 	return ath10k_wmi_peer_set_param(ar, arvif->vdev_id, addr,
2833 					 ar->wmi.peer_param->smps_state,
2834 					 ath10k_smps_map[smps]);
2835 }
2836 
ath10k_mac_vif_recalc_txbf(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta_vht_cap vht_cap)2837 static int ath10k_mac_vif_recalc_txbf(struct ath10k *ar,
2838 				      struct ieee80211_vif *vif,
2839 				      struct ieee80211_sta_vht_cap vht_cap)
2840 {
2841 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
2842 	int ret;
2843 	u32 param;
2844 	u32 value;
2845 
2846 	if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_AFTER_ASSOC)
2847 		return 0;
2848 
2849 	if (!(ar->vht_cap_info &
2850 	      (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2851 	       IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE |
2852 	       IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2853 	       IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)))
2854 		return 0;
2855 
2856 	param = ar->wmi.vdev_param->txbf;
2857 	value = 0;
2858 
2859 	if (WARN_ON(param == WMI_VDEV_PARAM_UNSUPPORTED))
2860 		return 0;
2861 
2862 	/* The following logic is correct. If a remote STA advertises support
2863 	 * for being a beamformer then we should enable us being a beamformee.
2864 	 */
2865 
2866 	if (ar->vht_cap_info &
2867 	    (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
2868 	     IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
2869 		if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
2870 			value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2871 
2872 		if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
2873 			value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFEE;
2874 	}
2875 
2876 	if (ar->vht_cap_info &
2877 	    (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
2878 	     IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
2879 		if (vht_cap.cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
2880 			value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2881 
2882 		if (vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
2883 			value |= WMI_VDEV_PARAM_TXBF_MU_TX_BFER;
2884 	}
2885 
2886 	if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFEE)
2887 		value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
2888 
2889 	if (value & WMI_VDEV_PARAM_TXBF_MU_TX_BFER)
2890 		value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
2891 
2892 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, param, value);
2893 	if (ret) {
2894 		ath10k_warn(ar, "failed to submit vdev param txbf 0x%x: %d\n",
2895 			    value, ret);
2896 		return ret;
2897 	}
2898 
2899 	return 0;
2900 }
2901 
ath10k_mac_is_connected(struct ath10k * ar)2902 static bool ath10k_mac_is_connected(struct ath10k *ar)
2903 {
2904 	struct ath10k_vif *arvif;
2905 
2906 	list_for_each_entry(arvif, &ar->arvifs, list) {
2907 		if (arvif->is_up && arvif->vdev_type == WMI_VDEV_TYPE_STA)
2908 			return true;
2909 	}
2910 
2911 	return false;
2912 }
2913 
ath10k_mac_txpower_setup(struct ath10k * ar,int txpower)2914 static int ath10k_mac_txpower_setup(struct ath10k *ar, int txpower)
2915 {
2916 	int ret;
2917 	u32 param;
2918 	int tx_power_2g, tx_power_5g;
2919 	bool connected;
2920 
2921 	lockdep_assert_held(&ar->conf_mutex);
2922 
2923 	/* ath10k internally uses unit of 0.5 dBm so multiply by 2 */
2924 	tx_power_2g = txpower * 2;
2925 	tx_power_5g = txpower * 2;
2926 
2927 	connected = ath10k_mac_is_connected(ar);
2928 
2929 	if (connected && ar->tx_power_2g_limit)
2930 		if (tx_power_2g > ar->tx_power_2g_limit)
2931 			tx_power_2g = ar->tx_power_2g_limit;
2932 
2933 	if (connected && ar->tx_power_5g_limit)
2934 		if (tx_power_5g > ar->tx_power_5g_limit)
2935 			tx_power_5g = ar->tx_power_5g_limit;
2936 
2937 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac txpower 2g: %d, 5g: %d\n",
2938 		   tx_power_2g, tx_power_5g);
2939 
2940 	param = ar->wmi.pdev_param->txpower_limit2g;
2941 	ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_2g);
2942 	if (ret) {
2943 		ath10k_warn(ar, "failed to set 2g txpower %d: %d\n",
2944 			    tx_power_2g, ret);
2945 		return ret;
2946 	}
2947 
2948 	param = ar->wmi.pdev_param->txpower_limit5g;
2949 	ret = ath10k_wmi_pdev_set_param(ar, param, tx_power_5g);
2950 	if (ret) {
2951 		ath10k_warn(ar, "failed to set 5g txpower %d: %d\n",
2952 			    tx_power_5g, ret);
2953 		return ret;
2954 	}
2955 
2956 	return 0;
2957 }
2958 
ath10k_mac_txpower_recalc(struct ath10k * ar)2959 static int ath10k_mac_txpower_recalc(struct ath10k *ar)
2960 {
2961 	struct ath10k_vif *arvif;
2962 	int ret, txpower = -1;
2963 
2964 	lockdep_assert_held(&ar->conf_mutex);
2965 
2966 	list_for_each_entry(arvif, &ar->arvifs, list) {
2967 		/* txpower not initialized yet? */
2968 		if (arvif->txpower == INT_MIN)
2969 			continue;
2970 
2971 		if (txpower == -1)
2972 			txpower = arvif->txpower;
2973 		else
2974 			txpower = min(txpower, arvif->txpower);
2975 	}
2976 
2977 	if (txpower == -1)
2978 		return 0;
2979 
2980 	ret = ath10k_mac_txpower_setup(ar, txpower);
2981 	if (ret) {
2982 		ath10k_warn(ar, "failed to setup tx power %d: %d\n",
2983 			    txpower, ret);
2984 		return ret;
2985 	}
2986 
2987 	return 0;
2988 }
2989 
ath10k_mac_set_sar_power(struct ath10k * ar)2990 static int ath10k_mac_set_sar_power(struct ath10k *ar)
2991 {
2992 	if (!ar->hw_params.dynamic_sar_support)
2993 		return -EOPNOTSUPP;
2994 
2995 	if (!ath10k_mac_is_connected(ar))
2996 		return 0;
2997 
2998 	/* if connected, then arvif->txpower must be valid */
2999 	return ath10k_mac_txpower_recalc(ar);
3000 }
3001 
ath10k_mac_set_sar_specs(struct ieee80211_hw * hw,const struct cfg80211_sar_specs * sar)3002 static int ath10k_mac_set_sar_specs(struct ieee80211_hw *hw,
3003 				    const struct cfg80211_sar_specs *sar)
3004 {
3005 	const struct cfg80211_sar_sub_specs *sub_specs;
3006 	struct ath10k *ar = hw->priv;
3007 	u32 i;
3008 	int ret;
3009 
3010 	mutex_lock(&ar->conf_mutex);
3011 
3012 	if (!ar->hw_params.dynamic_sar_support) {
3013 		ret = -EOPNOTSUPP;
3014 		goto err;
3015 	}
3016 
3017 	if (!sar || sar->type != NL80211_SAR_TYPE_POWER ||
3018 	    sar->num_sub_specs == 0) {
3019 		ret = -EINVAL;
3020 		goto err;
3021 	}
3022 
3023 	sub_specs = sar->sub_specs;
3024 
3025 	/* 0dbm is not a practical value for ath10k, so use 0
3026 	 * as no SAR limitation on it.
3027 	 */
3028 	ar->tx_power_2g_limit = 0;
3029 	ar->tx_power_5g_limit = 0;
3030 
3031 	/* note the power is in 0.25dbm unit, while ath10k uses
3032 	 * 0.5dbm unit.
3033 	 */
3034 	for (i = 0; i < sar->num_sub_specs; i++) {
3035 		if (sub_specs->freq_range_index == 0)
3036 			ar->tx_power_2g_limit = sub_specs->power / 2;
3037 		else if (sub_specs->freq_range_index == 1)
3038 			ar->tx_power_5g_limit = sub_specs->power / 2;
3039 
3040 		sub_specs++;
3041 	}
3042 
3043 	ret = ath10k_mac_set_sar_power(ar);
3044 	if (ret) {
3045 		ath10k_warn(ar, "failed to set sar power: %d", ret);
3046 		goto err;
3047 	}
3048 
3049 err:
3050 	mutex_unlock(&ar->conf_mutex);
3051 	return ret;
3052 }
3053 
3054 /* can be called only in mac80211 callbacks due to `key_count` usage */
ath10k_bss_assoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * bss_conf)3055 static void ath10k_bss_assoc(struct ieee80211_hw *hw,
3056 			     struct ieee80211_vif *vif,
3057 			     struct ieee80211_bss_conf *bss_conf)
3058 {
3059 	struct ath10k *ar = hw->priv;
3060 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3061 	struct ieee80211_sta_ht_cap ht_cap;
3062 	struct ieee80211_sta_vht_cap vht_cap;
3063 	struct wmi_peer_assoc_complete_arg peer_arg;
3064 	struct ieee80211_sta *ap_sta;
3065 	int ret;
3066 
3067 	lockdep_assert_held(&ar->conf_mutex);
3068 
3069 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i assoc bssid %pM aid %d\n",
3070 		   arvif->vdev_id, arvif->bssid, arvif->aid);
3071 
3072 	rcu_read_lock();
3073 
3074 	ap_sta = ieee80211_find_sta(vif, bss_conf->bssid);
3075 	if (!ap_sta) {
3076 		ath10k_warn(ar, "failed to find station entry for bss %pM vdev %i\n",
3077 			    bss_conf->bssid, arvif->vdev_id);
3078 		rcu_read_unlock();
3079 		return;
3080 	}
3081 
3082 	/* ap_sta must be accessed only within rcu section which must be left
3083 	 * before calling ath10k_setup_peer_smps() which might sleep.
3084 	 */
3085 	ht_cap = ap_sta->deflink.ht_cap;
3086 	vht_cap = ap_sta->deflink.vht_cap;
3087 
3088 	ret = ath10k_peer_assoc_prepare(ar, vif, ap_sta, &peer_arg);
3089 	if (ret) {
3090 		ath10k_warn(ar, "failed to prepare peer assoc for %pM vdev %i: %d\n",
3091 			    bss_conf->bssid, arvif->vdev_id, ret);
3092 		rcu_read_unlock();
3093 		return;
3094 	}
3095 
3096 	rcu_read_unlock();
3097 
3098 	ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
3099 	if (ret) {
3100 		ath10k_warn(ar, "failed to run peer assoc for %pM vdev %i: %d\n",
3101 			    bss_conf->bssid, arvif->vdev_id, ret);
3102 		return;
3103 	}
3104 
3105 	ret = ath10k_setup_peer_smps(ar, arvif, bss_conf->bssid, &ht_cap);
3106 	if (ret) {
3107 		ath10k_warn(ar, "failed to setup peer SMPS for vdev %i: %d\n",
3108 			    arvif->vdev_id, ret);
3109 		return;
3110 	}
3111 
3112 	ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
3113 	if (ret) {
3114 		ath10k_warn(ar, "failed to recalc txbf for vdev %i on bss %pM: %d\n",
3115 			    arvif->vdev_id, bss_conf->bssid, ret);
3116 		return;
3117 	}
3118 
3119 	ath10k_dbg(ar, ATH10K_DBG_MAC,
3120 		   "mac vdev %d up (associated) bssid %pM aid %d\n",
3121 		   arvif->vdev_id, bss_conf->bssid, bss_conf->aid);
3122 
3123 	WARN_ON(arvif->is_up);
3124 
3125 	arvif->aid = bss_conf->aid;
3126 	ether_addr_copy(arvif->bssid, bss_conf->bssid);
3127 
3128 	ret = ath10k_wmi_pdev_set_param(ar,
3129 					ar->wmi.pdev_param->peer_stats_info_enable, 1);
3130 	if (ret)
3131 		ath10k_warn(ar, "failed to enable peer stats info: %d\n", ret);
3132 
3133 	ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, arvif->aid, arvif->bssid);
3134 	if (ret) {
3135 		ath10k_warn(ar, "failed to set vdev %d up: %d\n",
3136 			    arvif->vdev_id, ret);
3137 		return;
3138 	}
3139 
3140 	arvif->is_up = true;
3141 
3142 	ath10k_mac_set_sar_power(ar);
3143 
3144 	/* Workaround: Some firmware revisions (tested with qca6174
3145 	 * WLAN.RM.2.0-00073) have buggy powersave state machine and must be
3146 	 * poked with peer param command.
3147 	 */
3148 	ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, arvif->bssid,
3149 					ar->wmi.peer_param->dummy_var, 1);
3150 	if (ret) {
3151 		ath10k_warn(ar, "failed to poke peer %pM param for ps workaround on vdev %i: %d\n",
3152 			    arvif->bssid, arvif->vdev_id, ret);
3153 		return;
3154 	}
3155 }
3156 
ath10k_bss_disassoc(struct ieee80211_hw * hw,struct ieee80211_vif * vif)3157 static void ath10k_bss_disassoc(struct ieee80211_hw *hw,
3158 				struct ieee80211_vif *vif)
3159 {
3160 	struct ath10k *ar = hw->priv;
3161 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3162 	struct ieee80211_sta_vht_cap vht_cap = {};
3163 	int ret;
3164 
3165 	lockdep_assert_held(&ar->conf_mutex);
3166 
3167 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i disassoc bssid %pM\n",
3168 		   arvif->vdev_id, arvif->bssid);
3169 
3170 	ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
3171 	if (ret)
3172 		ath10k_warn(ar, "failed to down vdev %i: %d\n",
3173 			    arvif->vdev_id, ret);
3174 
3175 	arvif->def_wep_key_idx = -1;
3176 
3177 	ret = ath10k_mac_vif_recalc_txbf(ar, vif, vht_cap);
3178 	if (ret) {
3179 		ath10k_warn(ar, "failed to recalc txbf for vdev %i: %d\n",
3180 			    arvif->vdev_id, ret);
3181 		return;
3182 	}
3183 
3184 	arvif->is_up = false;
3185 
3186 	ath10k_mac_txpower_recalc(ar);
3187 
3188 	cancel_delayed_work_sync(&arvif->connection_loss_work);
3189 }
3190 
ath10k_new_peer_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ath10k_vif * arvif)3191 static int ath10k_new_peer_tid_config(struct ath10k *ar,
3192 				      struct ieee80211_sta *sta,
3193 				      struct ath10k_vif *arvif)
3194 {
3195 	struct wmi_per_peer_per_tid_cfg_arg arg = {};
3196 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
3197 	bool config_apply;
3198 	int ret, i;
3199 
3200 	for (i = 0; i < ATH10K_TID_MAX; i++) {
3201 		config_apply = false;
3202 		if (arvif->retry_long[i] || arvif->ampdu[i] ||
3203 		    arvif->rate_ctrl[i] || arvif->rtscts[i]) {
3204 			config_apply = true;
3205 			arg.tid = i;
3206 			arg.vdev_id = arvif->vdev_id;
3207 			arg.retry_count = arvif->retry_long[i];
3208 			arg.aggr_control = arvif->ampdu[i];
3209 			arg.rate_ctrl = arvif->rate_ctrl[i];
3210 			arg.rcode_flags = arvif->rate_code[i];
3211 
3212 			if (arvif->rtscts[i])
3213 				arg.ext_tid_cfg_bitmap =
3214 					WMI_EXT_TID_RTS_CTS_CONFIG;
3215 			else
3216 				arg.ext_tid_cfg_bitmap = 0;
3217 
3218 			arg.rtscts_ctrl = arvif->rtscts[i];
3219 		}
3220 
3221 		if (arvif->noack[i]) {
3222 			arg.ack_policy = arvif->noack[i];
3223 			arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;
3224 			arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
3225 			config_apply = true;
3226 		}
3227 
3228 		/* Assign default value(-1) to newly connected station.
3229 		 * This is to identify station specific tid configuration not
3230 		 * configured for the station.
3231 		 */
3232 		arsta->retry_long[i] = -1;
3233 		arsta->noack[i] = -1;
3234 		arsta->ampdu[i] = -1;
3235 
3236 		if (!config_apply)
3237 			continue;
3238 
3239 		ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
3240 
3241 		ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
3242 		if (ret) {
3243 			ath10k_warn(ar, "failed to set per tid retry/aggr config for sta %pM: %d\n",
3244 				    sta->addr, ret);
3245 			return ret;
3246 		}
3247 
3248 		memset(&arg, 0, sizeof(arg));
3249 	}
3250 
3251 	return 0;
3252 }
3253 
ath10k_station_assoc(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,bool reassoc)3254 static int ath10k_station_assoc(struct ath10k *ar,
3255 				struct ieee80211_vif *vif,
3256 				struct ieee80211_sta *sta,
3257 				bool reassoc)
3258 {
3259 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3260 	struct wmi_peer_assoc_complete_arg peer_arg;
3261 	int ret = 0;
3262 
3263 	lockdep_assert_held(&ar->conf_mutex);
3264 
3265 	ret = ath10k_peer_assoc_prepare(ar, vif, sta, &peer_arg);
3266 	if (ret) {
3267 		ath10k_warn(ar, "failed to prepare WMI peer assoc for %pM vdev %i: %i\n",
3268 			    sta->addr, arvif->vdev_id, ret);
3269 		return ret;
3270 	}
3271 
3272 	ret = ath10k_wmi_peer_assoc(ar, &peer_arg);
3273 	if (ret) {
3274 		ath10k_warn(ar, "failed to run peer assoc for STA %pM vdev %i: %d\n",
3275 			    sta->addr, arvif->vdev_id, ret);
3276 		return ret;
3277 	}
3278 
3279 	/* Re-assoc is run only to update supported rates for given station. It
3280 	 * doesn't make much sense to reconfigure the peer completely.
3281 	 */
3282 	if (!reassoc) {
3283 		ret = ath10k_setup_peer_smps(ar, arvif, sta->addr,
3284 					     &sta->deflink.ht_cap);
3285 		if (ret) {
3286 			ath10k_warn(ar, "failed to setup peer SMPS for vdev %d: %d\n",
3287 				    arvif->vdev_id, ret);
3288 			return ret;
3289 		}
3290 
3291 		ret = ath10k_peer_assoc_qos_ap(ar, arvif, sta);
3292 		if (ret) {
3293 			ath10k_warn(ar, "failed to set qos params for STA %pM for vdev %i: %d\n",
3294 				    sta->addr, arvif->vdev_id, ret);
3295 			return ret;
3296 		}
3297 
3298 		if (!sta->wme) {
3299 			arvif->num_legacy_stations++;
3300 			ret  = ath10k_recalc_rtscts_prot(arvif);
3301 			if (ret) {
3302 				ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3303 					    arvif->vdev_id, ret);
3304 				return ret;
3305 			}
3306 		}
3307 
3308 		/* Plumb cached keys only for static WEP */
3309 		if ((arvif->def_wep_key_idx != -1) && (!sta->tdls)) {
3310 			ret = ath10k_install_peer_wep_keys(arvif, sta->addr);
3311 			if (ret) {
3312 				ath10k_warn(ar, "failed to install peer wep keys for vdev %i: %d\n",
3313 					    arvif->vdev_id, ret);
3314 				return ret;
3315 			}
3316 		}
3317 	}
3318 
3319 	if (!test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map))
3320 		return ret;
3321 
3322 	return ath10k_new_peer_tid_config(ar, sta, arvif);
3323 }
3324 
ath10k_station_disassoc(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta)3325 static int ath10k_station_disassoc(struct ath10k *ar,
3326 				   struct ieee80211_vif *vif,
3327 				   struct ieee80211_sta *sta)
3328 {
3329 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3330 	int ret = 0;
3331 
3332 	lockdep_assert_held(&ar->conf_mutex);
3333 
3334 	if (!sta->wme) {
3335 		arvif->num_legacy_stations--;
3336 		ret = ath10k_recalc_rtscts_prot(arvif);
3337 		if (ret) {
3338 			ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
3339 				    arvif->vdev_id, ret);
3340 			return ret;
3341 		}
3342 	}
3343 
3344 	ret = ath10k_clear_peer_keys(arvif, sta->addr);
3345 	if (ret) {
3346 		ath10k_warn(ar, "failed to clear all peer wep keys for vdev %i: %d\n",
3347 			    arvif->vdev_id, ret);
3348 		return ret;
3349 	}
3350 
3351 	return ret;
3352 }
3353 
3354 /**************/
3355 /* Regulatory */
3356 /**************/
3357 
ath10k_update_channel_list(struct ath10k * ar)3358 static int ath10k_update_channel_list(struct ath10k *ar)
3359 {
3360 	struct ieee80211_hw *hw = ar->hw;
3361 	struct ieee80211_supported_band **bands;
3362 	enum nl80211_band band;
3363 	struct ieee80211_channel *channel;
3364 	struct wmi_scan_chan_list_arg arg = {0};
3365 	struct wmi_channel_arg *ch;
3366 	bool passive;
3367 	int len;
3368 	int ret;
3369 	int i;
3370 
3371 	lockdep_assert_held(&ar->conf_mutex);
3372 
3373 	bands = hw->wiphy->bands;
3374 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
3375 		if (!bands[band])
3376 			continue;
3377 
3378 		for (i = 0; i < bands[band]->n_channels; i++) {
3379 			if (bands[band]->channels[i].flags &
3380 			    IEEE80211_CHAN_DISABLED)
3381 				continue;
3382 
3383 			arg.n_channels++;
3384 		}
3385 	}
3386 
3387 	len = sizeof(struct wmi_channel_arg) * arg.n_channels;
3388 	arg.channels = kzalloc(len, GFP_KERNEL);
3389 	if (!arg.channels)
3390 		return -ENOMEM;
3391 
3392 	ch = arg.channels;
3393 	for (band = 0; band < NUM_NL80211_BANDS; band++) {
3394 		if (!bands[band])
3395 			continue;
3396 
3397 		for (i = 0; i < bands[band]->n_channels; i++) {
3398 			channel = &bands[band]->channels[i];
3399 
3400 			if (channel->flags & IEEE80211_CHAN_DISABLED)
3401 				continue;
3402 
3403 			ch->allow_ht = true;
3404 
3405 			/* FIXME: when should we really allow VHT? */
3406 			ch->allow_vht = true;
3407 
3408 			ch->allow_ibss =
3409 				!(channel->flags & IEEE80211_CHAN_NO_IR);
3410 
3411 			ch->ht40plus =
3412 				!(channel->flags & IEEE80211_CHAN_NO_HT40PLUS);
3413 
3414 			ch->chan_radar =
3415 				!!(channel->flags & IEEE80211_CHAN_RADAR);
3416 
3417 			passive = channel->flags & IEEE80211_CHAN_NO_IR;
3418 			ch->passive = passive;
3419 
3420 			/* the firmware is ignoring the "radar" flag of the
3421 			 * channel and is scanning actively using Probe Requests
3422 			 * on "Radar detection"/DFS channels which are not
3423 			 * marked as "available"
3424 			 */
3425 			ch->passive |= ch->chan_radar;
3426 
3427 			ch->freq = channel->center_freq;
3428 			ch->band_center_freq1 = channel->center_freq;
3429 			ch->min_power = 0;
3430 			ch->max_power = channel->max_power * 2;
3431 			ch->max_reg_power = channel->max_reg_power * 2;
3432 			ch->max_antenna_gain = channel->max_antenna_gain;
3433 			ch->reg_class_id = 0; /* FIXME */
3434 
3435 			/* FIXME: why use only legacy modes, why not any
3436 			 * HT/VHT modes? Would that even make any
3437 			 * difference?
3438 			 */
3439 			if (channel->band == NL80211_BAND_2GHZ)
3440 				ch->mode = MODE_11G;
3441 			else
3442 				ch->mode = MODE_11A;
3443 
3444 			if (WARN_ON_ONCE(ch->mode == MODE_UNKNOWN))
3445 				continue;
3446 
3447 			ath10k_dbg(ar, ATH10K_DBG_WMI,
3448 				   "mac channel [%zd/%d] freq %d maxpower %d regpower %d antenna %d mode %d\n",
3449 				    ch - arg.channels, arg.n_channels,
3450 				   ch->freq, ch->max_power, ch->max_reg_power,
3451 				   ch->max_antenna_gain, ch->mode);
3452 
3453 			ch++;
3454 		}
3455 	}
3456 
3457 	ret = ath10k_wmi_scan_chan_list(ar, &arg);
3458 	kfree(arg.channels);
3459 
3460 	return ret;
3461 }
3462 
3463 static enum wmi_dfs_region
ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)3464 ath10k_mac_get_dfs_region(enum nl80211_dfs_regions dfs_region)
3465 {
3466 	switch (dfs_region) {
3467 	case NL80211_DFS_UNSET:
3468 		return WMI_UNINIT_DFS_DOMAIN;
3469 	case NL80211_DFS_FCC:
3470 		return WMI_FCC_DFS_DOMAIN;
3471 	case NL80211_DFS_ETSI:
3472 		return WMI_ETSI_DFS_DOMAIN;
3473 	case NL80211_DFS_JP:
3474 		return WMI_MKK4_DFS_DOMAIN;
3475 	}
3476 	return WMI_UNINIT_DFS_DOMAIN;
3477 }
3478 
ath10k_regd_update(struct ath10k * ar)3479 static void ath10k_regd_update(struct ath10k *ar)
3480 {
3481 	struct reg_dmn_pair_mapping *regpair;
3482 	int ret;
3483 	enum wmi_dfs_region wmi_dfs_reg;
3484 	enum nl80211_dfs_regions nl_dfs_reg;
3485 
3486 	lockdep_assert_held(&ar->conf_mutex);
3487 
3488 	ret = ath10k_update_channel_list(ar);
3489 	if (ret)
3490 		ath10k_warn(ar, "failed to update channel list: %d\n", ret);
3491 
3492 	regpair = ar->ath_common.regulatory.regpair;
3493 
3494 	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
3495 		nl_dfs_reg = ar->dfs_detector->region;
3496 		wmi_dfs_reg = ath10k_mac_get_dfs_region(nl_dfs_reg);
3497 	} else {
3498 		wmi_dfs_reg = WMI_UNINIT_DFS_DOMAIN;
3499 	}
3500 
3501 	/* Target allows setting up per-band regdomain but ath_common provides
3502 	 * a combined one only
3503 	 */
3504 	ret = ath10k_wmi_pdev_set_regdomain(ar,
3505 					    regpair->reg_domain,
3506 					    regpair->reg_domain, /* 2ghz */
3507 					    regpair->reg_domain, /* 5ghz */
3508 					    regpair->reg_2ghz_ctl,
3509 					    regpair->reg_5ghz_ctl,
3510 					    wmi_dfs_reg);
3511 	if (ret)
3512 		ath10k_warn(ar, "failed to set pdev regdomain: %d\n", ret);
3513 }
3514 
ath10k_mac_update_channel_list(struct ath10k * ar,struct ieee80211_supported_band * band)3515 static void ath10k_mac_update_channel_list(struct ath10k *ar,
3516 					   struct ieee80211_supported_band *band)
3517 {
3518 	int i;
3519 
3520 	if (ar->low_5ghz_chan && ar->high_5ghz_chan) {
3521 		for (i = 0; i < band->n_channels; i++) {
3522 			if (band->channels[i].center_freq < ar->low_5ghz_chan ||
3523 			    band->channels[i].center_freq > ar->high_5ghz_chan)
3524 				band->channels[i].flags |=
3525 					IEEE80211_CHAN_DISABLED;
3526 		}
3527 	}
3528 }
3529 
ath10k_reg_notifier(struct wiphy * wiphy,struct regulatory_request * request)3530 static void ath10k_reg_notifier(struct wiphy *wiphy,
3531 				struct regulatory_request *request)
3532 {
3533 	struct ieee80211_hw *hw = wiphy_to_ieee80211_hw(wiphy);
3534 	struct ath10k *ar = hw->priv;
3535 	bool result;
3536 
3537 	ath_reg_notifier_apply(wiphy, request, &ar->ath_common.regulatory);
3538 
3539 	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector) {
3540 		ath10k_dbg(ar, ATH10K_DBG_REGULATORY, "dfs region 0x%x\n",
3541 			   request->dfs_region);
3542 		result = ar->dfs_detector->set_dfs_domain(ar->dfs_detector,
3543 							  request->dfs_region);
3544 		if (!result)
3545 			ath10k_warn(ar, "DFS region 0x%X not supported, will trigger radar for every pulse\n",
3546 				    request->dfs_region);
3547 	}
3548 
3549 	mutex_lock(&ar->conf_mutex);
3550 	if (ar->state == ATH10K_STATE_ON)
3551 		ath10k_regd_update(ar);
3552 	mutex_unlock(&ar->conf_mutex);
3553 
3554 	if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
3555 		ath10k_mac_update_channel_list(ar,
3556 					       ar->hw->wiphy->bands[NL80211_BAND_5GHZ]);
3557 }
3558 
ath10k_stop_radar_confirmation(struct ath10k * ar)3559 static void ath10k_stop_radar_confirmation(struct ath10k *ar)
3560 {
3561 	spin_lock_bh(&ar->data_lock);
3562 	ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_STOPPED;
3563 	spin_unlock_bh(&ar->data_lock);
3564 
3565 	cancel_work_sync(&ar->radar_confirmation_work);
3566 }
3567 
3568 /***************/
3569 /* TX handlers */
3570 /***************/
3571 
3572 enum ath10k_mac_tx_path {
3573 	ATH10K_MAC_TX_HTT,
3574 	ATH10K_MAC_TX_HTT_MGMT,
3575 	ATH10K_MAC_TX_WMI_MGMT,
3576 	ATH10K_MAC_TX_UNKNOWN,
3577 };
3578 
ath10k_mac_tx_lock(struct ath10k * ar,int reason)3579 void ath10k_mac_tx_lock(struct ath10k *ar, int reason)
3580 {
3581 	lockdep_assert_held(&ar->htt.tx_lock);
3582 
3583 	WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3584 	ar->tx_paused |= BIT(reason);
3585 	ieee80211_stop_queues(ar->hw);
3586 }
3587 
ath10k_mac_tx_unlock_iter(void * data,u8 * mac,struct ieee80211_vif * vif)3588 static void ath10k_mac_tx_unlock_iter(void *data, u8 *mac,
3589 				      struct ieee80211_vif *vif)
3590 {
3591 	struct ath10k *ar = data;
3592 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3593 
3594 	if (arvif->tx_paused)
3595 		return;
3596 
3597 	ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3598 }
3599 
ath10k_mac_tx_unlock(struct ath10k * ar,int reason)3600 void ath10k_mac_tx_unlock(struct ath10k *ar, int reason)
3601 {
3602 	lockdep_assert_held(&ar->htt.tx_lock);
3603 
3604 	WARN_ON(reason >= ATH10K_TX_PAUSE_MAX);
3605 	ar->tx_paused &= ~BIT(reason);
3606 
3607 	if (ar->tx_paused)
3608 		return;
3609 
3610 	ieee80211_iterate_active_interfaces_atomic(ar->hw,
3611 						   ATH10K_ITER_RESUME_FLAGS,
3612 						   ath10k_mac_tx_unlock_iter,
3613 						   ar);
3614 
3615 	ieee80211_wake_queue(ar->hw, ar->hw->offchannel_tx_hw_queue);
3616 }
3617 
ath10k_mac_vif_tx_lock(struct ath10k_vif * arvif,int reason)3618 void ath10k_mac_vif_tx_lock(struct ath10k_vif *arvif, int reason)
3619 {
3620 	struct ath10k *ar = arvif->ar;
3621 
3622 	lockdep_assert_held(&ar->htt.tx_lock);
3623 
3624 	WARN_ON(reason >= BITS_PER_LONG);
3625 	arvif->tx_paused |= BIT(reason);
3626 	ieee80211_stop_queue(ar->hw, arvif->vdev_id);
3627 }
3628 
ath10k_mac_vif_tx_unlock(struct ath10k_vif * arvif,int reason)3629 void ath10k_mac_vif_tx_unlock(struct ath10k_vif *arvif, int reason)
3630 {
3631 	struct ath10k *ar = arvif->ar;
3632 
3633 	lockdep_assert_held(&ar->htt.tx_lock);
3634 
3635 	WARN_ON(reason >= BITS_PER_LONG);
3636 	arvif->tx_paused &= ~BIT(reason);
3637 
3638 	if (ar->tx_paused)
3639 		return;
3640 
3641 	if (arvif->tx_paused)
3642 		return;
3643 
3644 	ieee80211_wake_queue(ar->hw, arvif->vdev_id);
3645 }
3646 
ath10k_mac_vif_handle_tx_pause(struct ath10k_vif * arvif,enum wmi_tlv_tx_pause_id pause_id,enum wmi_tlv_tx_pause_action action)3647 static void ath10k_mac_vif_handle_tx_pause(struct ath10k_vif *arvif,
3648 					   enum wmi_tlv_tx_pause_id pause_id,
3649 					   enum wmi_tlv_tx_pause_action action)
3650 {
3651 	struct ath10k *ar = arvif->ar;
3652 
3653 	lockdep_assert_held(&ar->htt.tx_lock);
3654 
3655 	switch (action) {
3656 	case WMI_TLV_TX_PAUSE_ACTION_STOP:
3657 		ath10k_mac_vif_tx_lock(arvif, pause_id);
3658 		break;
3659 	case WMI_TLV_TX_PAUSE_ACTION_WAKE:
3660 		ath10k_mac_vif_tx_unlock(arvif, pause_id);
3661 		break;
3662 	default:
3663 		ath10k_dbg(ar, ATH10K_DBG_BOOT,
3664 			   "received unknown tx pause action %d on vdev %i, ignoring\n",
3665 			    action, arvif->vdev_id);
3666 		break;
3667 	}
3668 }
3669 
3670 struct ath10k_mac_tx_pause {
3671 	u32 vdev_id;
3672 	enum wmi_tlv_tx_pause_id pause_id;
3673 	enum wmi_tlv_tx_pause_action action;
3674 };
3675 
ath10k_mac_handle_tx_pause_iter(void * data,u8 * mac,struct ieee80211_vif * vif)3676 static void ath10k_mac_handle_tx_pause_iter(void *data, u8 *mac,
3677 					    struct ieee80211_vif *vif)
3678 {
3679 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3680 	struct ath10k_mac_tx_pause *arg = data;
3681 
3682 	if (arvif->vdev_id != arg->vdev_id)
3683 		return;
3684 
3685 	ath10k_mac_vif_handle_tx_pause(arvif, arg->pause_id, arg->action);
3686 }
3687 
ath10k_mac_handle_tx_pause_vdev(struct ath10k * ar,u32 vdev_id,enum wmi_tlv_tx_pause_id pause_id,enum wmi_tlv_tx_pause_action action)3688 void ath10k_mac_handle_tx_pause_vdev(struct ath10k *ar, u32 vdev_id,
3689 				     enum wmi_tlv_tx_pause_id pause_id,
3690 				     enum wmi_tlv_tx_pause_action action)
3691 {
3692 	struct ath10k_mac_tx_pause arg = {
3693 		.vdev_id = vdev_id,
3694 		.pause_id = pause_id,
3695 		.action = action,
3696 	};
3697 
3698 	spin_lock_bh(&ar->htt.tx_lock);
3699 	ieee80211_iterate_active_interfaces_atomic(ar->hw,
3700 						   ATH10K_ITER_RESUME_FLAGS,
3701 						   ath10k_mac_handle_tx_pause_iter,
3702 						   &arg);
3703 	spin_unlock_bh(&ar->htt.tx_lock);
3704 }
3705 
3706 static enum ath10k_hw_txrx_mode
ath10k_mac_tx_h_get_txmode(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct sk_buff * skb)3707 ath10k_mac_tx_h_get_txmode(struct ath10k *ar,
3708 			   struct ieee80211_vif *vif,
3709 			   struct ieee80211_sta *sta,
3710 			   struct sk_buff *skb)
3711 {
3712 	const struct ieee80211_hdr *hdr = (void *)skb->data;
3713 	const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
3714 	__le16 fc = hdr->frame_control;
3715 
3716 	if (!vif || vif->type == NL80211_IFTYPE_MONITOR)
3717 		return ATH10K_HW_TXRX_RAW;
3718 
3719 	if (ieee80211_is_mgmt(fc))
3720 		return ATH10K_HW_TXRX_MGMT;
3721 
3722 	/* Workaround:
3723 	 *
3724 	 * NullFunc frames are mostly used to ping if a client or AP are still
3725 	 * reachable and responsive. This implies tx status reports must be
3726 	 * accurate - otherwise either mac80211 or userspace (e.g. hostapd) can
3727 	 * come to a conclusion that the other end disappeared and tear down
3728 	 * BSS connection or it can never disconnect from BSS/client (which is
3729 	 * the case).
3730 	 *
3731 	 * Firmware with HTT older than 3.0 delivers incorrect tx status for
3732 	 * NullFunc frames to driver. However there's a HTT Mgmt Tx command
3733 	 * which seems to deliver correct tx reports for NullFunc frames. The
3734 	 * downside of using it is it ignores client powersave state so it can
3735 	 * end up disconnecting sleeping clients in AP mode. It should fix STA
3736 	 * mode though because AP don't sleep.
3737 	 */
3738 	if (ar->htt.target_version_major < 3 &&
3739 	    (ieee80211_is_nullfunc(fc) || ieee80211_is_qos_nullfunc(fc)) &&
3740 	    !test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3741 		      ar->running_fw->fw_file.fw_features))
3742 		return ATH10K_HW_TXRX_MGMT;
3743 
3744 	/* Workaround:
3745 	 *
3746 	 * Some wmi-tlv firmwares for qca6174 have broken Tx key selection for
3747 	 * NativeWifi txmode - it selects AP key instead of peer key. It seems
3748 	 * to work with Ethernet txmode so use it.
3749 	 *
3750 	 * FIXME: Check if raw mode works with TDLS.
3751 	 */
3752 	if (ieee80211_is_data_present(fc) && sta && sta->tdls)
3753 		return ATH10K_HW_TXRX_ETHERNET;
3754 
3755 	if (test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) ||
3756 	    skb_cb->flags & ATH10K_SKB_F_RAW_TX)
3757 		return ATH10K_HW_TXRX_RAW;
3758 
3759 	return ATH10K_HW_TXRX_NATIVE_WIFI;
3760 }
3761 
ath10k_tx_h_use_hwcrypto(struct ieee80211_vif * vif,struct sk_buff * skb)3762 static bool ath10k_tx_h_use_hwcrypto(struct ieee80211_vif *vif,
3763 				     struct sk_buff *skb)
3764 {
3765 	const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3766 	const struct ieee80211_hdr *hdr = (void *)skb->data;
3767 	const u32 mask = IEEE80211_TX_INTFL_DONT_ENCRYPT |
3768 			 IEEE80211_TX_CTL_INJECTED;
3769 
3770 	if (!ieee80211_has_protected(hdr->frame_control))
3771 		return false;
3772 
3773 	if ((info->flags & mask) == mask)
3774 		return false;
3775 
3776 	if (vif)
3777 		return !((struct ath10k_vif *)vif->drv_priv)->nohwcrypt;
3778 
3779 	return true;
3780 }
3781 
3782 /* HTT Tx uses Native Wifi tx mode which expects 802.11 frames without QoS
3783  * Control in the header.
3784  */
ath10k_tx_h_nwifi(struct ieee80211_hw * hw,struct sk_buff * skb)3785 static void ath10k_tx_h_nwifi(struct ieee80211_hw *hw, struct sk_buff *skb)
3786 {
3787 	struct ieee80211_hdr *hdr = (void *)skb->data;
3788 	struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3789 	u8 *qos_ctl;
3790 
3791 	if (!ieee80211_is_data_qos(hdr->frame_control))
3792 		return;
3793 
3794 	qos_ctl = ieee80211_get_qos_ctl(hdr);
3795 	memmove(skb->data + IEEE80211_QOS_CTL_LEN,
3796 		skb->data, (void *)qos_ctl - (void *)skb->data);
3797 	skb_pull(skb, IEEE80211_QOS_CTL_LEN);
3798 
3799 	/* Some firmware revisions don't handle sending QoS NullFunc well.
3800 	 * These frames are mainly used for CQM purposes so it doesn't really
3801 	 * matter whether QoS NullFunc or NullFunc are sent.
3802 	 */
3803 	hdr = (void *)skb->data;
3804 	if (ieee80211_is_qos_nullfunc(hdr->frame_control))
3805 		cb->flags &= ~ATH10K_SKB_F_QOS;
3806 
3807 	hdr->frame_control &= ~__cpu_to_le16(IEEE80211_STYPE_QOS_DATA);
3808 }
3809 
ath10k_tx_h_8023(struct sk_buff * skb)3810 static void ath10k_tx_h_8023(struct sk_buff *skb)
3811 {
3812 	struct ieee80211_hdr *hdr;
3813 	struct rfc1042_hdr *rfc1042;
3814 	struct ethhdr *eth;
3815 	size_t hdrlen;
3816 	u8 da[ETH_ALEN];
3817 	u8 sa[ETH_ALEN];
3818 	__be16 type;
3819 
3820 	hdr = (void *)skb->data;
3821 	hdrlen = ieee80211_hdrlen(hdr->frame_control);
3822 	rfc1042 = (void *)skb->data + hdrlen;
3823 
3824 	ether_addr_copy(da, ieee80211_get_DA(hdr));
3825 	ether_addr_copy(sa, ieee80211_get_SA(hdr));
3826 	type = rfc1042->snap_type;
3827 
3828 	skb_pull(skb, hdrlen + sizeof(*rfc1042));
3829 	skb_push(skb, sizeof(*eth));
3830 
3831 	eth = (void *)skb->data;
3832 	ether_addr_copy(eth->h_dest, da);
3833 	ether_addr_copy(eth->h_source, sa);
3834 	eth->h_proto = type;
3835 }
3836 
ath10k_tx_h_add_p2p_noa_ie(struct ath10k * ar,struct ieee80211_vif * vif,struct sk_buff * skb)3837 static void ath10k_tx_h_add_p2p_noa_ie(struct ath10k *ar,
3838 				       struct ieee80211_vif *vif,
3839 				       struct sk_buff *skb)
3840 {
3841 	struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
3842 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3843 
3844 	/* This is case only for P2P_GO */
3845 	if (vif->type != NL80211_IFTYPE_AP || !vif->p2p)
3846 		return;
3847 
3848 	if (unlikely(ieee80211_is_probe_resp(hdr->frame_control))) {
3849 		spin_lock_bh(&ar->data_lock);
3850 		if (arvif->u.ap.noa_data)
3851 			if (!pskb_expand_head(skb, 0, arvif->u.ap.noa_len,
3852 					      GFP_ATOMIC))
3853 				skb_put_data(skb, arvif->u.ap.noa_data,
3854 					     arvif->u.ap.noa_len);
3855 		spin_unlock_bh(&ar->data_lock);
3856 	}
3857 }
3858 
ath10k_mac_tx_h_fill_cb(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_txq * txq,struct ieee80211_sta * sta,struct sk_buff * skb,u16 airtime)3859 static void ath10k_mac_tx_h_fill_cb(struct ath10k *ar,
3860 				    struct ieee80211_vif *vif,
3861 				    struct ieee80211_txq *txq,
3862 				    struct ieee80211_sta *sta,
3863 				    struct sk_buff *skb, u16 airtime)
3864 {
3865 	struct ieee80211_hdr *hdr = (void *)skb->data;
3866 	struct ath10k_skb_cb *cb = ATH10K_SKB_CB(skb);
3867 	const struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
3868 	bool is_data = ieee80211_is_data(hdr->frame_control) ||
3869 			ieee80211_is_data_qos(hdr->frame_control);
3870 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
3871 	struct ath10k_sta *arsta;
3872 	u8 tid, *qos_ctl;
3873 	bool noack = false;
3874 
3875 	cb->flags = 0;
3876 	if (!ath10k_tx_h_use_hwcrypto(vif, skb))
3877 		cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3878 
3879 	if (ieee80211_is_mgmt(hdr->frame_control))
3880 		cb->flags |= ATH10K_SKB_F_MGMT;
3881 
3882 	if (ieee80211_is_data_qos(hdr->frame_control)) {
3883 		cb->flags |= ATH10K_SKB_F_QOS;
3884 		qos_ctl = ieee80211_get_qos_ctl(hdr);
3885 		tid = (*qos_ctl) & IEEE80211_QOS_CTL_TID_MASK;
3886 
3887 		if (arvif->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)
3888 			noack = true;
3889 
3890 		if (sta) {
3891 			arsta = (struct ath10k_sta *)sta->drv_priv;
3892 
3893 			if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_NOACK)
3894 				noack = true;
3895 
3896 			if (arsta->noack[tid] == WMI_PEER_TID_CONFIG_ACK)
3897 				noack = false;
3898 		}
3899 
3900 		if (noack)
3901 			cb->flags |= ATH10K_SKB_F_NOACK_TID;
3902 	}
3903 
3904 	/* Data frames encrypted in software will be posted to firmware
3905 	 * with tx encap mode set to RAW. Ex: Multicast traffic generated
3906 	 * for a specific VLAN group will always be encrypted in software.
3907 	 */
3908 	if (is_data && ieee80211_has_protected(hdr->frame_control) &&
3909 	    !info->control.hw_key) {
3910 		cb->flags |= ATH10K_SKB_F_NO_HWCRYPT;
3911 		cb->flags |= ATH10K_SKB_F_RAW_TX;
3912 	}
3913 
3914 	cb->vif = vif;
3915 	cb->txq = txq;
3916 	cb->airtime_est = airtime;
3917 	if (sta) {
3918 		arsta = (struct ath10k_sta *)sta->drv_priv;
3919 		spin_lock_bh(&ar->data_lock);
3920 		cb->ucast_cipher = arsta->ucast_cipher;
3921 		spin_unlock_bh(&ar->data_lock);
3922 	}
3923 }
3924 
ath10k_mac_tx_frm_has_freq(struct ath10k * ar)3925 bool ath10k_mac_tx_frm_has_freq(struct ath10k *ar)
3926 {
3927 	/* FIXME: Not really sure since when the behaviour changed. At some
3928 	 * point new firmware stopped requiring creation of peer entries for
3929 	 * offchannel tx (and actually creating them causes issues with wmi-htc
3930 	 * tx credit replenishment and reliability). Assuming it's at least 3.4
3931 	 * because that's when the `freq` was introduced to TX_FRM HTT command.
3932 	 */
3933 	return (ar->htt.target_version_major >= 3 &&
3934 		ar->htt.target_version_minor >= 4 &&
3935 		ar->running_fw->fw_file.htt_op_version == ATH10K_FW_HTT_OP_VERSION_TLV);
3936 }
3937 
ath10k_mac_tx_wmi_mgmt(struct ath10k * ar,struct sk_buff * skb)3938 static int ath10k_mac_tx_wmi_mgmt(struct ath10k *ar, struct sk_buff *skb)
3939 {
3940 	struct sk_buff_head *q = &ar->wmi_mgmt_tx_queue;
3941 
3942 	if (skb_queue_len_lockless(q) >= ATH10K_MAX_NUM_MGMT_PENDING) {
3943 		ath10k_warn(ar, "wmi mgmt tx queue is full\n");
3944 		return -ENOSPC;
3945 	}
3946 
3947 	skb_queue_tail(q, skb);
3948 	ieee80211_queue_work(ar->hw, &ar->wmi_mgmt_tx_work);
3949 
3950 	return 0;
3951 }
3952 
3953 static enum ath10k_mac_tx_path
ath10k_mac_tx_h_get_txpath(struct ath10k * ar,struct sk_buff * skb,enum ath10k_hw_txrx_mode txmode)3954 ath10k_mac_tx_h_get_txpath(struct ath10k *ar,
3955 			   struct sk_buff *skb,
3956 			   enum ath10k_hw_txrx_mode txmode)
3957 {
3958 	switch (txmode) {
3959 	case ATH10K_HW_TXRX_RAW:
3960 	case ATH10K_HW_TXRX_NATIVE_WIFI:
3961 	case ATH10K_HW_TXRX_ETHERNET:
3962 		return ATH10K_MAC_TX_HTT;
3963 	case ATH10K_HW_TXRX_MGMT:
3964 		if (test_bit(ATH10K_FW_FEATURE_HAS_WMI_MGMT_TX,
3965 			     ar->running_fw->fw_file.fw_features) ||
3966 			     test_bit(WMI_SERVICE_MGMT_TX_WMI,
3967 				      ar->wmi.svc_map))
3968 			return ATH10K_MAC_TX_WMI_MGMT;
3969 		else if (ar->htt.target_version_major >= 3)
3970 			return ATH10K_MAC_TX_HTT;
3971 		else
3972 			return ATH10K_MAC_TX_HTT_MGMT;
3973 	}
3974 
3975 	return ATH10K_MAC_TX_UNKNOWN;
3976 }
3977 
ath10k_mac_tx_submit(struct ath10k * ar,enum ath10k_hw_txrx_mode txmode,enum ath10k_mac_tx_path txpath,struct sk_buff * skb)3978 static int ath10k_mac_tx_submit(struct ath10k *ar,
3979 				enum ath10k_hw_txrx_mode txmode,
3980 				enum ath10k_mac_tx_path txpath,
3981 				struct sk_buff *skb)
3982 {
3983 	struct ath10k_htt *htt = &ar->htt;
3984 	int ret = -EINVAL;
3985 
3986 	switch (txpath) {
3987 	case ATH10K_MAC_TX_HTT:
3988 		ret = ath10k_htt_tx(htt, txmode, skb);
3989 		break;
3990 	case ATH10K_MAC_TX_HTT_MGMT:
3991 		ret = ath10k_htt_mgmt_tx(htt, skb);
3992 		break;
3993 	case ATH10K_MAC_TX_WMI_MGMT:
3994 		ret = ath10k_mac_tx_wmi_mgmt(ar, skb);
3995 		break;
3996 	case ATH10K_MAC_TX_UNKNOWN:
3997 		WARN_ON_ONCE(1);
3998 		ret = -EINVAL;
3999 		break;
4000 	}
4001 
4002 	if (ret) {
4003 		ath10k_warn(ar, "failed to transmit packet, dropping: %d\n",
4004 			    ret);
4005 		ieee80211_free_txskb(ar->hw, skb);
4006 	}
4007 
4008 	return ret;
4009 }
4010 
4011 /* This function consumes the sk_buff regardless of return value as far as
4012  * caller is concerned so no freeing is necessary afterwards.
4013  */
ath10k_mac_tx(struct ath10k * ar,struct ieee80211_vif * vif,enum ath10k_hw_txrx_mode txmode,enum ath10k_mac_tx_path txpath,struct sk_buff * skb,bool noque_offchan)4014 static int ath10k_mac_tx(struct ath10k *ar,
4015 			 struct ieee80211_vif *vif,
4016 			 enum ath10k_hw_txrx_mode txmode,
4017 			 enum ath10k_mac_tx_path txpath,
4018 			 struct sk_buff *skb, bool noque_offchan)
4019 {
4020 	struct ieee80211_hw *hw = ar->hw;
4021 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4022 	const struct ath10k_skb_cb *skb_cb = ATH10K_SKB_CB(skb);
4023 	int ret;
4024 
4025 	/* We should disable CCK RATE due to P2P */
4026 	if (info->flags & IEEE80211_TX_CTL_NO_CCK_RATE)
4027 		ath10k_dbg(ar, ATH10K_DBG_MAC, "IEEE80211_TX_CTL_NO_CCK_RATE\n");
4028 
4029 	switch (txmode) {
4030 	case ATH10K_HW_TXRX_MGMT:
4031 	case ATH10K_HW_TXRX_NATIVE_WIFI:
4032 		ath10k_tx_h_nwifi(hw, skb);
4033 		ath10k_tx_h_add_p2p_noa_ie(ar, vif, skb);
4034 		ath10k_tx_h_seq_no(vif, skb);
4035 		break;
4036 	case ATH10K_HW_TXRX_ETHERNET:
4037 		ath10k_tx_h_8023(skb);
4038 		break;
4039 	case ATH10K_HW_TXRX_RAW:
4040 		if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags) &&
4041 		    !(skb_cb->flags & ATH10K_SKB_F_RAW_TX)) {
4042 			WARN_ON_ONCE(1);
4043 			ieee80211_free_txskb(hw, skb);
4044 			return -ENOTSUPP;
4045 		}
4046 	}
4047 
4048 	if (!noque_offchan && info->flags & IEEE80211_TX_CTL_TX_OFFCHAN) {
4049 		if (!ath10k_mac_tx_frm_has_freq(ar)) {
4050 			ath10k_dbg(ar, ATH10K_DBG_MAC, "mac queued offchannel skb %pK len %d\n",
4051 				   skb, skb->len);
4052 
4053 			skb_queue_tail(&ar->offchan_tx_queue, skb);
4054 			ieee80211_queue_work(hw, &ar->offchan_tx_work);
4055 			return 0;
4056 		}
4057 	}
4058 
4059 	ret = ath10k_mac_tx_submit(ar, txmode, txpath, skb);
4060 	if (ret) {
4061 		ath10k_warn(ar, "failed to submit frame: %d\n", ret);
4062 		return ret;
4063 	}
4064 
4065 	return 0;
4066 }
4067 
ath10k_offchan_tx_purge(struct ath10k * ar)4068 void ath10k_offchan_tx_purge(struct ath10k *ar)
4069 {
4070 	struct sk_buff *skb;
4071 
4072 	for (;;) {
4073 		skb = skb_dequeue(&ar->offchan_tx_queue);
4074 		if (!skb)
4075 			break;
4076 
4077 		ieee80211_free_txskb(ar->hw, skb);
4078 	}
4079 }
4080 
ath10k_offchan_tx_work(struct work_struct * work)4081 void ath10k_offchan_tx_work(struct work_struct *work)
4082 {
4083 	struct ath10k *ar = container_of(work, struct ath10k, offchan_tx_work);
4084 	struct ath10k_peer *peer;
4085 	struct ath10k_vif *arvif;
4086 	enum ath10k_hw_txrx_mode txmode;
4087 	enum ath10k_mac_tx_path txpath;
4088 	struct ieee80211_hdr *hdr;
4089 	struct ieee80211_vif *vif;
4090 	struct ieee80211_sta *sta;
4091 	struct sk_buff *skb;
4092 	const u8 *peer_addr;
4093 	int vdev_id;
4094 	int ret;
4095 	unsigned long time_left;
4096 	bool tmp_peer_created = false;
4097 
4098 	/* FW requirement: We must create a peer before FW will send out
4099 	 * an offchannel frame. Otherwise the frame will be stuck and
4100 	 * never transmitted. We delete the peer upon tx completion.
4101 	 * It is unlikely that a peer for offchannel tx will already be
4102 	 * present. However it may be in some rare cases so account for that.
4103 	 * Otherwise we might remove a legitimate peer and break stuff.
4104 	 */
4105 
4106 	for (;;) {
4107 		skb = skb_dequeue(&ar->offchan_tx_queue);
4108 		if (!skb)
4109 			break;
4110 
4111 		mutex_lock(&ar->conf_mutex);
4112 
4113 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac offchannel skb %pK len %d\n",
4114 			   skb, skb->len);
4115 
4116 		hdr = (struct ieee80211_hdr *)skb->data;
4117 		peer_addr = ieee80211_get_DA(hdr);
4118 
4119 		spin_lock_bh(&ar->data_lock);
4120 		vdev_id = ar->scan.vdev_id;
4121 		peer = ath10k_peer_find(ar, vdev_id, peer_addr);
4122 		spin_unlock_bh(&ar->data_lock);
4123 
4124 		if (peer) {
4125 			ath10k_warn(ar, "peer %pM on vdev %d already present\n",
4126 				    peer_addr, vdev_id);
4127 		} else {
4128 			ret = ath10k_peer_create(ar, NULL, NULL, vdev_id,
4129 						 peer_addr,
4130 						 WMI_PEER_TYPE_DEFAULT);
4131 			if (ret)
4132 				ath10k_warn(ar, "failed to create peer %pM on vdev %d: %d\n",
4133 					    peer_addr, vdev_id, ret);
4134 			tmp_peer_created = (ret == 0);
4135 		}
4136 
4137 		spin_lock_bh(&ar->data_lock);
4138 		reinit_completion(&ar->offchan_tx_completed);
4139 		ar->offchan_tx_skb = skb;
4140 		spin_unlock_bh(&ar->data_lock);
4141 
4142 		/* It's safe to access vif and sta - conf_mutex guarantees that
4143 		 * sta_state() and remove_interface() are locked exclusively
4144 		 * out wrt to this offchannel worker.
4145 		 */
4146 		arvif = ath10k_get_arvif(ar, vdev_id);
4147 		if (arvif) {
4148 			vif = arvif->vif;
4149 			sta = ieee80211_find_sta(vif, peer_addr);
4150 		} else {
4151 			vif = NULL;
4152 			sta = NULL;
4153 		}
4154 
4155 		txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4156 		txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4157 
4158 		ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, true);
4159 		if (ret) {
4160 			ath10k_warn(ar, "failed to transmit offchannel frame: %d\n",
4161 				    ret);
4162 			/* not serious */
4163 		}
4164 
4165 		time_left =
4166 		wait_for_completion_timeout(&ar->offchan_tx_completed, 3 * HZ);
4167 		if (time_left == 0)
4168 			ath10k_warn(ar, "timed out waiting for offchannel skb %pK, len: %d\n",
4169 				    skb, skb->len);
4170 
4171 		if (!peer && tmp_peer_created) {
4172 			ret = ath10k_peer_delete(ar, vdev_id, peer_addr);
4173 			if (ret)
4174 				ath10k_warn(ar, "failed to delete peer %pM on vdev %d: %d\n",
4175 					    peer_addr, vdev_id, ret);
4176 		}
4177 
4178 		mutex_unlock(&ar->conf_mutex);
4179 	}
4180 }
4181 
ath10k_mgmt_over_wmi_tx_purge(struct ath10k * ar)4182 void ath10k_mgmt_over_wmi_tx_purge(struct ath10k *ar)
4183 {
4184 	struct sk_buff *skb;
4185 
4186 	for (;;) {
4187 		skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
4188 		if (!skb)
4189 			break;
4190 
4191 		ieee80211_free_txskb(ar->hw, skb);
4192 	}
4193 }
4194 
ath10k_mgmt_over_wmi_tx_work(struct work_struct * work)4195 void ath10k_mgmt_over_wmi_tx_work(struct work_struct *work)
4196 {
4197 	struct ath10k *ar = container_of(work, struct ath10k, wmi_mgmt_tx_work);
4198 	struct sk_buff *skb;
4199 	dma_addr_t paddr;
4200 	int ret;
4201 
4202 	for (;;) {
4203 		skb = skb_dequeue(&ar->wmi_mgmt_tx_queue);
4204 		if (!skb)
4205 			break;
4206 
4207 		if (test_bit(ATH10K_FW_FEATURE_MGMT_TX_BY_REF,
4208 			     ar->running_fw->fw_file.fw_features)) {
4209 			paddr = dma_map_single(ar->dev, skb->data,
4210 					       skb->len, DMA_TO_DEVICE);
4211 			if (dma_mapping_error(ar->dev, paddr)) {
4212 				ieee80211_free_txskb(ar->hw, skb);
4213 				continue;
4214 			}
4215 			ret = ath10k_wmi_mgmt_tx_send(ar, skb, paddr);
4216 			if (ret) {
4217 				ath10k_warn(ar, "failed to transmit management frame by ref via WMI: %d\n",
4218 					    ret);
4219 				/* remove this msdu from idr tracking */
4220 				ath10k_wmi_cleanup_mgmt_tx_send(ar, skb);
4221 
4222 				dma_unmap_single(ar->dev, paddr, skb->len,
4223 						 DMA_TO_DEVICE);
4224 				ieee80211_free_txskb(ar->hw, skb);
4225 			}
4226 		} else {
4227 			ret = ath10k_wmi_mgmt_tx(ar, skb);
4228 			if (ret) {
4229 				ath10k_warn(ar, "failed to transmit management frame via WMI: %d\n",
4230 					    ret);
4231 				ieee80211_free_txskb(ar->hw, skb);
4232 			}
4233 		}
4234 	}
4235 }
4236 
ath10k_mac_txq_init(struct ieee80211_txq * txq)4237 static void ath10k_mac_txq_init(struct ieee80211_txq *txq)
4238 {
4239 	struct ath10k_txq *artxq;
4240 
4241 	if (!txq)
4242 		return;
4243 
4244 	artxq = (void *)txq->drv_priv;
4245 	INIT_LIST_HEAD(&artxq->list);
4246 }
4247 
ath10k_mac_txq_unref(struct ath10k * ar,struct ieee80211_txq * txq)4248 static void ath10k_mac_txq_unref(struct ath10k *ar, struct ieee80211_txq *txq)
4249 {
4250 	struct ath10k_skb_cb *cb;
4251 	struct sk_buff *msdu;
4252 	int msdu_id;
4253 
4254 	if (!txq)
4255 		return;
4256 
4257 	spin_lock_bh(&ar->htt.tx_lock);
4258 	idr_for_each_entry(&ar->htt.pending_tx, msdu, msdu_id) {
4259 		cb = ATH10K_SKB_CB(msdu);
4260 		if (cb->txq == txq)
4261 			cb->txq = NULL;
4262 	}
4263 	spin_unlock_bh(&ar->htt.tx_lock);
4264 }
4265 
ath10k_mac_txq_lookup(struct ath10k * ar,u16 peer_id,u8 tid)4266 struct ieee80211_txq *ath10k_mac_txq_lookup(struct ath10k *ar,
4267 					    u16 peer_id,
4268 					    u8 tid)
4269 {
4270 	struct ath10k_peer *peer;
4271 
4272 	lockdep_assert_held(&ar->data_lock);
4273 
4274 	peer = ar->peer_map[peer_id];
4275 	if (!peer)
4276 		return NULL;
4277 
4278 	if (peer->removed)
4279 		return NULL;
4280 
4281 	if (peer->sta)
4282 		return peer->sta->txq[tid];
4283 	else if (peer->vif)
4284 		return peer->vif->txq;
4285 	else
4286 		return NULL;
4287 }
4288 
ath10k_mac_tx_can_push(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4289 static bool ath10k_mac_tx_can_push(struct ieee80211_hw *hw,
4290 				   struct ieee80211_txq *txq)
4291 {
4292 	struct ath10k *ar = hw->priv;
4293 	struct ath10k_txq *artxq = (void *)txq->drv_priv;
4294 
4295 	/* No need to get locks */
4296 	if (ar->htt.tx_q_state.mode == HTT_TX_MODE_SWITCH_PUSH)
4297 		return true;
4298 
4299 	if (ar->htt.num_pending_tx < ar->htt.tx_q_state.num_push_allowed)
4300 		return true;
4301 
4302 	if (artxq->num_fw_queued < artxq->num_push_allowed)
4303 		return true;
4304 
4305 	return false;
4306 }
4307 
4308 /* Return estimated airtime in microsecond, which is calculated using last
4309  * reported TX rate. This is just a rough estimation because host driver has no
4310  * knowledge of the actual transmit rate, retries or aggregation. If actual
4311  * airtime can be reported by firmware, then delta between estimated and actual
4312  * airtime can be adjusted from deficit.
4313  */
4314 #define IEEE80211_ATF_OVERHEAD		100	/* IFS + some slot time */
4315 #define IEEE80211_ATF_OVERHEAD_IFS	16	/* IFS only */
ath10k_mac_update_airtime(struct ath10k * ar,struct ieee80211_txq * txq,struct sk_buff * skb)4316 static u16 ath10k_mac_update_airtime(struct ath10k *ar,
4317 				     struct ieee80211_txq *txq,
4318 				     struct sk_buff *skb)
4319 {
4320 	struct ath10k_sta *arsta;
4321 	u32 pktlen;
4322 	u16 airtime = 0;
4323 
4324 	if (!txq || !txq->sta)
4325 		return airtime;
4326 
4327 	if (test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))
4328 		return airtime;
4329 
4330 	spin_lock_bh(&ar->data_lock);
4331 	arsta = (struct ath10k_sta *)txq->sta->drv_priv;
4332 
4333 	pktlen = skb->len + 38; /* Assume MAC header 30, SNAP 8 for most case */
4334 	if (arsta->last_tx_bitrate) {
4335 		/* airtime in us, last_tx_bitrate in 100kbps */
4336 		airtime = (pktlen * 8 * (1000 / 100))
4337 				/ arsta->last_tx_bitrate;
4338 		/* overhead for media access time and IFS */
4339 		airtime += IEEE80211_ATF_OVERHEAD_IFS;
4340 	} else {
4341 		/* This is mostly for throttle excessive BC/MC frames, and the
4342 		 * airtime/rate doesn't need be exact. Airtime of BC/MC frames
4343 		 * in 2G get some discount, which helps prevent very low rate
4344 		 * frames from being blocked for too long.
4345 		 */
4346 		airtime = (pktlen * 8 * (1000 / 100)) / 60; /* 6M */
4347 		airtime += IEEE80211_ATF_OVERHEAD;
4348 	}
4349 	spin_unlock_bh(&ar->data_lock);
4350 
4351 	return airtime;
4352 }
4353 
ath10k_mac_tx_push_txq(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4354 int ath10k_mac_tx_push_txq(struct ieee80211_hw *hw,
4355 			   struct ieee80211_txq *txq)
4356 {
4357 	struct ath10k *ar = hw->priv;
4358 	struct ath10k_htt *htt = &ar->htt;
4359 	struct ath10k_txq *artxq = (void *)txq->drv_priv;
4360 	struct ieee80211_vif *vif = txq->vif;
4361 	struct ieee80211_sta *sta = txq->sta;
4362 	enum ath10k_hw_txrx_mode txmode;
4363 	enum ath10k_mac_tx_path txpath;
4364 	struct sk_buff *skb;
4365 	struct ieee80211_hdr *hdr;
4366 	size_t skb_len;
4367 	bool is_mgmt, is_presp;
4368 	int ret;
4369 	u16 airtime;
4370 
4371 	spin_lock_bh(&ar->htt.tx_lock);
4372 	ret = ath10k_htt_tx_inc_pending(htt);
4373 	spin_unlock_bh(&ar->htt.tx_lock);
4374 
4375 	if (ret)
4376 		return ret;
4377 
4378 	skb = ieee80211_tx_dequeue_ni(hw, txq);
4379 	if (!skb) {
4380 		spin_lock_bh(&ar->htt.tx_lock);
4381 		ath10k_htt_tx_dec_pending(htt);
4382 		spin_unlock_bh(&ar->htt.tx_lock);
4383 
4384 		return -ENOENT;
4385 	}
4386 
4387 	airtime = ath10k_mac_update_airtime(ar, txq, skb);
4388 	ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);
4389 
4390 	skb_len = skb->len;
4391 	txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4392 	txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4393 	is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);
4394 
4395 	if (is_mgmt) {
4396 		hdr = (struct ieee80211_hdr *)skb->data;
4397 		is_presp = ieee80211_is_probe_resp(hdr->frame_control);
4398 
4399 		spin_lock_bh(&ar->htt.tx_lock);
4400 		ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);
4401 
4402 		if (ret) {
4403 			ath10k_htt_tx_dec_pending(htt);
4404 			spin_unlock_bh(&ar->htt.tx_lock);
4405 			return ret;
4406 		}
4407 		spin_unlock_bh(&ar->htt.tx_lock);
4408 	}
4409 
4410 	ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);
4411 	if (unlikely(ret)) {
4412 		ath10k_warn(ar, "failed to push frame: %d\n", ret);
4413 
4414 		spin_lock_bh(&ar->htt.tx_lock);
4415 		ath10k_htt_tx_dec_pending(htt);
4416 		if (is_mgmt)
4417 			ath10k_htt_tx_mgmt_dec_pending(htt);
4418 		spin_unlock_bh(&ar->htt.tx_lock);
4419 
4420 		return ret;
4421 	}
4422 
4423 	spin_lock_bh(&ar->htt.tx_lock);
4424 	artxq->num_fw_queued++;
4425 	spin_unlock_bh(&ar->htt.tx_lock);
4426 
4427 	return skb_len;
4428 }
4429 
ath10k_mac_schedule_txq(struct ieee80211_hw * hw,u32 ac)4430 static int ath10k_mac_schedule_txq(struct ieee80211_hw *hw, u32 ac)
4431 {
4432 	struct ieee80211_txq *txq;
4433 	int ret = 0;
4434 
4435 	ieee80211_txq_schedule_start(hw, ac);
4436 	while ((txq = ieee80211_next_txq(hw, ac))) {
4437 		while (ath10k_mac_tx_can_push(hw, txq)) {
4438 			ret = ath10k_mac_tx_push_txq(hw, txq);
4439 			if (ret < 0)
4440 				break;
4441 		}
4442 		ieee80211_return_txq(hw, txq, false);
4443 		ath10k_htt_tx_txq_update(hw, txq);
4444 		if (ret == -EBUSY)
4445 			break;
4446 	}
4447 	ieee80211_txq_schedule_end(hw, ac);
4448 
4449 	return ret;
4450 }
4451 
ath10k_mac_tx_push_pending(struct ath10k * ar)4452 void ath10k_mac_tx_push_pending(struct ath10k *ar)
4453 {
4454 	struct ieee80211_hw *hw = ar->hw;
4455 	u32 ac;
4456 
4457 	if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)
4458 		return;
4459 
4460 	if (ar->htt.num_pending_tx >= (ar->htt.max_num_pending_tx / 2))
4461 		return;
4462 
4463 	rcu_read_lock();
4464 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
4465 		if (ath10k_mac_schedule_txq(hw, ac) == -EBUSY)
4466 			break;
4467 	}
4468 	rcu_read_unlock();
4469 }
4470 EXPORT_SYMBOL(ath10k_mac_tx_push_pending);
4471 
4472 /************/
4473 /* Scanning */
4474 /************/
4475 
__ath10k_scan_finish(struct ath10k * ar)4476 void __ath10k_scan_finish(struct ath10k *ar)
4477 {
4478 	lockdep_assert_held(&ar->data_lock);
4479 
4480 	switch (ar->scan.state) {
4481 	case ATH10K_SCAN_IDLE:
4482 		break;
4483 	case ATH10K_SCAN_RUNNING:
4484 	case ATH10K_SCAN_ABORTING:
4485 		if (!ar->scan.is_roc) {
4486 			struct cfg80211_scan_info info = {
4487 				.aborted = (ar->scan.state ==
4488 					    ATH10K_SCAN_ABORTING),
4489 			};
4490 
4491 			ieee80211_scan_completed(ar->hw, &info);
4492 		} else if (ar->scan.roc_notify) {
4493 			ieee80211_remain_on_channel_expired(ar->hw);
4494 		}
4495 		fallthrough;
4496 	case ATH10K_SCAN_STARTING:
4497 		ar->scan.state = ATH10K_SCAN_IDLE;
4498 		ar->scan_channel = NULL;
4499 		ar->scan.roc_freq = 0;
4500 		ath10k_offchan_tx_purge(ar);
4501 		cancel_delayed_work(&ar->scan.timeout);
4502 		complete(&ar->scan.completed);
4503 		break;
4504 	}
4505 }
4506 
ath10k_scan_finish(struct ath10k * ar)4507 void ath10k_scan_finish(struct ath10k *ar)
4508 {
4509 	spin_lock_bh(&ar->data_lock);
4510 	__ath10k_scan_finish(ar);
4511 	spin_unlock_bh(&ar->data_lock);
4512 }
4513 
ath10k_scan_stop(struct ath10k * ar)4514 static int ath10k_scan_stop(struct ath10k *ar)
4515 {
4516 	struct wmi_stop_scan_arg arg = {
4517 		.req_id = 1, /* FIXME */
4518 		.req_type = WMI_SCAN_STOP_ONE,
4519 		.u.scan_id = ATH10K_SCAN_ID,
4520 	};
4521 	int ret;
4522 
4523 	lockdep_assert_held(&ar->conf_mutex);
4524 
4525 	ret = ath10k_wmi_stop_scan(ar, &arg);
4526 	if (ret) {
4527 		ath10k_warn(ar, "failed to stop wmi scan: %d\n", ret);
4528 		goto out;
4529 	}
4530 
4531 	ret = wait_for_completion_timeout(&ar->scan.completed, 3 * HZ);
4532 	if (ret == 0) {
4533 		ath10k_warn(ar, "failed to receive scan abortion completion: timed out\n");
4534 		ret = -ETIMEDOUT;
4535 	} else if (ret > 0) {
4536 		ret = 0;
4537 	}
4538 
4539 out:
4540 	/* Scan state should be updated upon scan completion but in case
4541 	 * firmware fails to deliver the event (for whatever reason) it is
4542 	 * desired to clean up scan state anyway. Firmware may have just
4543 	 * dropped the scan completion event delivery due to transport pipe
4544 	 * being overflown with data and/or it can recover on its own before
4545 	 * next scan request is submitted.
4546 	 */
4547 	spin_lock_bh(&ar->data_lock);
4548 	if (ar->scan.state != ATH10K_SCAN_IDLE)
4549 		__ath10k_scan_finish(ar);
4550 	spin_unlock_bh(&ar->data_lock);
4551 
4552 	return ret;
4553 }
4554 
ath10k_scan_abort(struct ath10k * ar)4555 static void ath10k_scan_abort(struct ath10k *ar)
4556 {
4557 	int ret;
4558 
4559 	lockdep_assert_held(&ar->conf_mutex);
4560 
4561 	spin_lock_bh(&ar->data_lock);
4562 
4563 	switch (ar->scan.state) {
4564 	case ATH10K_SCAN_IDLE:
4565 		/* This can happen if timeout worker kicked in and called
4566 		 * abortion while scan completion was being processed.
4567 		 */
4568 		break;
4569 	case ATH10K_SCAN_STARTING:
4570 	case ATH10K_SCAN_ABORTING:
4571 		ath10k_warn(ar, "refusing scan abortion due to invalid scan state: %s (%d)\n",
4572 			    ath10k_scan_state_str(ar->scan.state),
4573 			    ar->scan.state);
4574 		break;
4575 	case ATH10K_SCAN_RUNNING:
4576 		ar->scan.state = ATH10K_SCAN_ABORTING;
4577 		spin_unlock_bh(&ar->data_lock);
4578 
4579 		ret = ath10k_scan_stop(ar);
4580 		if (ret)
4581 			ath10k_warn(ar, "failed to abort scan: %d\n", ret);
4582 
4583 		spin_lock_bh(&ar->data_lock);
4584 		break;
4585 	}
4586 
4587 	spin_unlock_bh(&ar->data_lock);
4588 }
4589 
ath10k_scan_timeout_work(struct work_struct * work)4590 void ath10k_scan_timeout_work(struct work_struct *work)
4591 {
4592 	struct ath10k *ar = container_of(work, struct ath10k,
4593 					 scan.timeout.work);
4594 
4595 	mutex_lock(&ar->conf_mutex);
4596 	ath10k_scan_abort(ar);
4597 	mutex_unlock(&ar->conf_mutex);
4598 }
4599 
ath10k_start_scan(struct ath10k * ar,const struct wmi_start_scan_arg * arg)4600 static int ath10k_start_scan(struct ath10k *ar,
4601 			     const struct wmi_start_scan_arg *arg)
4602 {
4603 	int ret;
4604 
4605 	lockdep_assert_held(&ar->conf_mutex);
4606 
4607 	ret = ath10k_wmi_start_scan(ar, arg);
4608 	if (ret)
4609 		return ret;
4610 
4611 	ret = wait_for_completion_timeout(&ar->scan.started, 1 * HZ);
4612 	if (ret == 0) {
4613 		ret = ath10k_scan_stop(ar);
4614 		if (ret)
4615 			ath10k_warn(ar, "failed to stop scan: %d\n", ret);
4616 
4617 		return -ETIMEDOUT;
4618 	}
4619 
4620 	/* If we failed to start the scan, return error code at
4621 	 * this point.  This is probably due to some issue in the
4622 	 * firmware, but no need to wedge the driver due to that...
4623 	 */
4624 	spin_lock_bh(&ar->data_lock);
4625 	if (ar->scan.state == ATH10K_SCAN_IDLE) {
4626 		spin_unlock_bh(&ar->data_lock);
4627 		return -EINVAL;
4628 	}
4629 	spin_unlock_bh(&ar->data_lock);
4630 
4631 	return 0;
4632 }
4633 
4634 /**********************/
4635 /* mac80211 callbacks */
4636 /**********************/
4637 
ath10k_mac_op_tx(struct ieee80211_hw * hw,struct ieee80211_tx_control * control,struct sk_buff * skb)4638 static void ath10k_mac_op_tx(struct ieee80211_hw *hw,
4639 			     struct ieee80211_tx_control *control,
4640 			     struct sk_buff *skb)
4641 {
4642 	struct ath10k *ar = hw->priv;
4643 	struct ath10k_htt *htt = &ar->htt;
4644 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
4645 	struct ieee80211_vif *vif = info->control.vif;
4646 	struct ieee80211_sta *sta = control->sta;
4647 	struct ieee80211_txq *txq = NULL;
4648 	struct ieee80211_hdr *hdr = (void *)skb->data;
4649 	enum ath10k_hw_txrx_mode txmode;
4650 	enum ath10k_mac_tx_path txpath;
4651 	bool is_htt;
4652 	bool is_mgmt;
4653 	bool is_presp;
4654 	int ret;
4655 	u16 airtime;
4656 
4657 	airtime = ath10k_mac_update_airtime(ar, txq, skb);
4658 	ath10k_mac_tx_h_fill_cb(ar, vif, txq, sta, skb, airtime);
4659 
4660 	txmode = ath10k_mac_tx_h_get_txmode(ar, vif, sta, skb);
4661 	txpath = ath10k_mac_tx_h_get_txpath(ar, skb, txmode);
4662 	is_htt = (txpath == ATH10K_MAC_TX_HTT ||
4663 		  txpath == ATH10K_MAC_TX_HTT_MGMT);
4664 	is_mgmt = (txpath == ATH10K_MAC_TX_HTT_MGMT);
4665 
4666 	if (is_htt) {
4667 		spin_lock_bh(&ar->htt.tx_lock);
4668 		is_presp = ieee80211_is_probe_resp(hdr->frame_control);
4669 
4670 		ret = ath10k_htt_tx_inc_pending(htt);
4671 		if (ret) {
4672 			ath10k_warn(ar, "failed to increase tx pending count: %d, dropping\n",
4673 				    ret);
4674 			spin_unlock_bh(&ar->htt.tx_lock);
4675 			ieee80211_free_txskb(ar->hw, skb);
4676 			return;
4677 		}
4678 
4679 		ret = ath10k_htt_tx_mgmt_inc_pending(htt, is_mgmt, is_presp);
4680 		if (ret) {
4681 			ath10k_dbg(ar, ATH10K_DBG_MAC, "failed to increase tx mgmt pending count: %d, dropping\n",
4682 				   ret);
4683 			ath10k_htt_tx_dec_pending(htt);
4684 			spin_unlock_bh(&ar->htt.tx_lock);
4685 			ieee80211_free_txskb(ar->hw, skb);
4686 			return;
4687 		}
4688 		spin_unlock_bh(&ar->htt.tx_lock);
4689 	}
4690 
4691 	ret = ath10k_mac_tx(ar, vif, txmode, txpath, skb, false);
4692 	if (ret) {
4693 		ath10k_warn(ar, "failed to transmit frame: %d\n", ret);
4694 		if (is_htt) {
4695 			spin_lock_bh(&ar->htt.tx_lock);
4696 			ath10k_htt_tx_dec_pending(htt);
4697 			if (is_mgmt)
4698 				ath10k_htt_tx_mgmt_dec_pending(htt);
4699 			spin_unlock_bh(&ar->htt.tx_lock);
4700 		}
4701 		return;
4702 	}
4703 }
4704 
ath10k_mac_op_wake_tx_queue(struct ieee80211_hw * hw,struct ieee80211_txq * txq)4705 static void ath10k_mac_op_wake_tx_queue(struct ieee80211_hw *hw,
4706 					struct ieee80211_txq *txq)
4707 {
4708 	struct ath10k *ar = hw->priv;
4709 	int ret;
4710 	u8 ac;
4711 
4712 	ath10k_htt_tx_txq_update(hw, txq);
4713 	if (ar->htt.tx_q_state.mode != HTT_TX_MODE_SWITCH_PUSH)
4714 		return;
4715 
4716 	ac = txq->ac;
4717 	ieee80211_txq_schedule_start(hw, ac);
4718 	txq = ieee80211_next_txq(hw, ac);
4719 	if (!txq)
4720 		goto out;
4721 
4722 	while (ath10k_mac_tx_can_push(hw, txq)) {
4723 		ret = ath10k_mac_tx_push_txq(hw, txq);
4724 		if (ret < 0)
4725 			break;
4726 	}
4727 	ieee80211_return_txq(hw, txq, false);
4728 	ath10k_htt_tx_txq_update(hw, txq);
4729 out:
4730 	ieee80211_txq_schedule_end(hw, ac);
4731 }
4732 
4733 /* Must not be called with conf_mutex held as workers can use that also. */
ath10k_drain_tx(struct ath10k * ar)4734 void ath10k_drain_tx(struct ath10k *ar)
4735 {
4736 	lockdep_assert_not_held(&ar->conf_mutex);
4737 
4738 	/* make sure rcu-protected mac80211 tx path itself is drained */
4739 	synchronize_net();
4740 
4741 	ath10k_offchan_tx_purge(ar);
4742 	ath10k_mgmt_over_wmi_tx_purge(ar);
4743 
4744 	cancel_work_sync(&ar->offchan_tx_work);
4745 	cancel_work_sync(&ar->wmi_mgmt_tx_work);
4746 }
4747 
ath10k_halt(struct ath10k * ar)4748 void ath10k_halt(struct ath10k *ar)
4749 {
4750 	struct ath10k_vif *arvif;
4751 
4752 	lockdep_assert_held(&ar->conf_mutex);
4753 
4754 	clear_bit(ATH10K_CAC_RUNNING, &ar->dev_flags);
4755 	ar->filter_flags = 0;
4756 	ar->monitor = false;
4757 	ar->monitor_arvif = NULL;
4758 
4759 	if (ar->monitor_started)
4760 		ath10k_monitor_stop(ar);
4761 
4762 	ar->monitor_started = false;
4763 	ar->tx_paused = 0;
4764 
4765 	ath10k_scan_finish(ar);
4766 	ath10k_peer_cleanup_all(ar);
4767 	ath10k_stop_radar_confirmation(ar);
4768 	ath10k_core_stop(ar);
4769 	ath10k_hif_power_down(ar);
4770 
4771 	spin_lock_bh(&ar->data_lock);
4772 	list_for_each_entry(arvif, &ar->arvifs, list)
4773 		ath10k_mac_vif_beacon_cleanup(arvif);
4774 	spin_unlock_bh(&ar->data_lock);
4775 }
4776 
ath10k_get_antenna(struct ieee80211_hw * hw,u32 * tx_ant,u32 * rx_ant)4777 static int ath10k_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant)
4778 {
4779 	struct ath10k *ar = hw->priv;
4780 
4781 	mutex_lock(&ar->conf_mutex);
4782 
4783 	*tx_ant = ar->cfg_tx_chainmask;
4784 	*rx_ant = ar->cfg_rx_chainmask;
4785 
4786 	mutex_unlock(&ar->conf_mutex);
4787 
4788 	return 0;
4789 }
4790 
ath10k_check_chain_mask(struct ath10k * ar,u32 cm,const char * dbg)4791 static bool ath10k_check_chain_mask(struct ath10k *ar, u32 cm, const char *dbg)
4792 {
4793 	/* It is not clear that allowing gaps in chainmask
4794 	 * is helpful.  Probably it will not do what user
4795 	 * is hoping for, so warn in that case.
4796 	 */
4797 	if (cm == 15 || cm == 7 || cm == 3 || cm == 1 || cm == 0)
4798 		return true;
4799 
4800 	ath10k_warn(ar, "mac %s antenna chainmask is invalid: 0x%x.  Suggested values: 15, 7, 3, 1 or 0.\n",
4801 		    dbg, cm);
4802 	return false;
4803 }
4804 
ath10k_mac_get_vht_cap_bf_sts(struct ath10k * ar)4805 static int ath10k_mac_get_vht_cap_bf_sts(struct ath10k *ar)
4806 {
4807 	int nsts = ar->vht_cap_info;
4808 
4809 	nsts &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4810 	nsts >>= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4811 
4812 	/* If firmware does not deliver to host number of space-time
4813 	 * streams supported, assume it support up to 4 BF STS and return
4814 	 * the value for VHT CAP: nsts-1)
4815 	 */
4816 	if (nsts == 0)
4817 		return 3;
4818 
4819 	return nsts;
4820 }
4821 
ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k * ar)4822 static int ath10k_mac_get_vht_cap_bf_sound_dim(struct ath10k *ar)
4823 {
4824 	int sound_dim = ar->vht_cap_info;
4825 
4826 	sound_dim &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4827 	sound_dim >>= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4828 
4829 	/* If the sounding dimension is not advertised by the firmware,
4830 	 * let's use a default value of 1
4831 	 */
4832 	if (sound_dim == 0)
4833 		return 1;
4834 
4835 	return sound_dim;
4836 }
4837 
ath10k_create_vht_cap(struct ath10k * ar)4838 static struct ieee80211_sta_vht_cap ath10k_create_vht_cap(struct ath10k *ar)
4839 {
4840 	struct ieee80211_sta_vht_cap vht_cap = {0};
4841 	struct ath10k_hw_params *hw = &ar->hw_params;
4842 	u16 mcs_map;
4843 	u32 val;
4844 	int i;
4845 
4846 	vht_cap.vht_supported = 1;
4847 	vht_cap.cap = ar->vht_cap_info;
4848 
4849 	if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
4850 				IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)) {
4851 		val = ath10k_mac_get_vht_cap_bf_sts(ar);
4852 		val <<= IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT;
4853 		val &= IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK;
4854 
4855 		vht_cap.cap |= val;
4856 	}
4857 
4858 	if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
4859 				IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)) {
4860 		val = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
4861 		val <<= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_SHIFT;
4862 		val &= IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK;
4863 
4864 		vht_cap.cap |= val;
4865 	}
4866 
4867 	mcs_map = 0;
4868 	for (i = 0; i < 8; i++) {
4869 		if ((i < ar->num_rf_chains) && (ar->cfg_tx_chainmask & BIT(i)))
4870 			mcs_map |= IEEE80211_VHT_MCS_SUPPORT_0_9 << (i * 2);
4871 		else
4872 			mcs_map |= IEEE80211_VHT_MCS_NOT_SUPPORTED << (i * 2);
4873 	}
4874 
4875 	if (ar->cfg_tx_chainmask <= 1)
4876 		vht_cap.cap &= ~IEEE80211_VHT_CAP_TXSTBC;
4877 
4878 	vht_cap.vht_mcs.rx_mcs_map = cpu_to_le16(mcs_map);
4879 	vht_cap.vht_mcs.tx_mcs_map = cpu_to_le16(mcs_map);
4880 
4881 	/* If we are supporting 160Mhz or 80+80, then the NIC may be able to do
4882 	 * a restricted NSS for 160 or 80+80 vs what it can do for 80Mhz.  Give
4883 	 * user-space a clue if that is the case.
4884 	 */
4885 	if ((vht_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) &&
4886 	    (hw->vht160_mcs_rx_highest != 0 ||
4887 	     hw->vht160_mcs_tx_highest != 0)) {
4888 		vht_cap.vht_mcs.rx_highest = cpu_to_le16(hw->vht160_mcs_rx_highest);
4889 		vht_cap.vht_mcs.tx_highest = cpu_to_le16(hw->vht160_mcs_tx_highest);
4890 	}
4891 
4892 	return vht_cap;
4893 }
4894 
ath10k_get_ht_cap(struct ath10k * ar)4895 static struct ieee80211_sta_ht_cap ath10k_get_ht_cap(struct ath10k *ar)
4896 {
4897 	int i;
4898 	struct ieee80211_sta_ht_cap ht_cap = {0};
4899 
4900 	if (!(ar->ht_cap_info & WMI_HT_CAP_ENABLED))
4901 		return ht_cap;
4902 
4903 	ht_cap.ht_supported = 1;
4904 	ht_cap.ampdu_factor = IEEE80211_HT_MAX_AMPDU_64K;
4905 	ht_cap.ampdu_density = IEEE80211_HT_MPDU_DENSITY_8;
4906 	ht_cap.cap |= IEEE80211_HT_CAP_SUP_WIDTH_20_40;
4907 	ht_cap.cap |= IEEE80211_HT_CAP_DSSSCCK40;
4908 	ht_cap.cap |=
4909 		WLAN_HT_CAP_SM_PS_DISABLED << IEEE80211_HT_CAP_SM_PS_SHIFT;
4910 
4911 	if (ar->ht_cap_info & WMI_HT_CAP_HT20_SGI)
4912 		ht_cap.cap |= IEEE80211_HT_CAP_SGI_20;
4913 
4914 	if (ar->ht_cap_info & WMI_HT_CAP_HT40_SGI)
4915 		ht_cap.cap |= IEEE80211_HT_CAP_SGI_40;
4916 
4917 	if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS) {
4918 		u32 smps;
4919 
4920 		smps   = WLAN_HT_CAP_SM_PS_DYNAMIC;
4921 		smps <<= IEEE80211_HT_CAP_SM_PS_SHIFT;
4922 
4923 		ht_cap.cap |= smps;
4924 	}
4925 
4926 	if (ar->ht_cap_info & WMI_HT_CAP_TX_STBC && (ar->cfg_tx_chainmask > 1))
4927 		ht_cap.cap |= IEEE80211_HT_CAP_TX_STBC;
4928 
4929 	if (ar->ht_cap_info & WMI_HT_CAP_RX_STBC) {
4930 		u32 stbc;
4931 
4932 		stbc   = ar->ht_cap_info;
4933 		stbc  &= WMI_HT_CAP_RX_STBC;
4934 		stbc >>= WMI_HT_CAP_RX_STBC_MASK_SHIFT;
4935 		stbc <<= IEEE80211_HT_CAP_RX_STBC_SHIFT;
4936 		stbc  &= IEEE80211_HT_CAP_RX_STBC;
4937 
4938 		ht_cap.cap |= stbc;
4939 	}
4940 
4941 	if (ar->ht_cap_info & WMI_HT_CAP_LDPC || (ar->ht_cap_info &
4942 	    WMI_HT_CAP_RX_LDPC && (ar->ht_cap_info & WMI_HT_CAP_TX_LDPC)))
4943 		ht_cap.cap |= IEEE80211_HT_CAP_LDPC_CODING;
4944 
4945 	if (ar->ht_cap_info & WMI_HT_CAP_L_SIG_TXOP_PROT)
4946 		ht_cap.cap |= IEEE80211_HT_CAP_LSIG_TXOP_PROT;
4947 
4948 	/* max AMSDU is implicitly taken from vht_cap_info */
4949 	if (ar->vht_cap_info & WMI_VHT_CAP_MAX_MPDU_LEN_MASK)
4950 		ht_cap.cap |= IEEE80211_HT_CAP_MAX_AMSDU;
4951 
4952 	for (i = 0; i < ar->num_rf_chains; i++) {
4953 		if (ar->cfg_rx_chainmask & BIT(i))
4954 			ht_cap.mcs.rx_mask[i] = 0xFF;
4955 	}
4956 
4957 	ht_cap.mcs.tx_params |= IEEE80211_HT_MCS_TX_DEFINED;
4958 
4959 	return ht_cap;
4960 }
4961 
ath10k_mac_setup_ht_vht_cap(struct ath10k * ar)4962 static void ath10k_mac_setup_ht_vht_cap(struct ath10k *ar)
4963 {
4964 	struct ieee80211_supported_band *band;
4965 	struct ieee80211_sta_vht_cap vht_cap;
4966 	struct ieee80211_sta_ht_cap ht_cap;
4967 
4968 	ht_cap = ath10k_get_ht_cap(ar);
4969 	vht_cap = ath10k_create_vht_cap(ar);
4970 
4971 	if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
4972 		band = &ar->mac.sbands[NL80211_BAND_2GHZ];
4973 		band->ht_cap = ht_cap;
4974 	}
4975 	if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
4976 		band = &ar->mac.sbands[NL80211_BAND_5GHZ];
4977 		band->ht_cap = ht_cap;
4978 		band->vht_cap = vht_cap;
4979 	}
4980 }
4981 
__ath10k_set_antenna(struct ath10k * ar,u32 tx_ant,u32 rx_ant)4982 static int __ath10k_set_antenna(struct ath10k *ar, u32 tx_ant, u32 rx_ant)
4983 {
4984 	int ret;
4985 	bool is_valid_tx_chain_mask, is_valid_rx_chain_mask;
4986 
4987 	lockdep_assert_held(&ar->conf_mutex);
4988 
4989 	is_valid_tx_chain_mask = ath10k_check_chain_mask(ar, tx_ant, "tx");
4990 	is_valid_rx_chain_mask = ath10k_check_chain_mask(ar, rx_ant, "rx");
4991 
4992 	if (!is_valid_tx_chain_mask || !is_valid_rx_chain_mask)
4993 		return -EINVAL;
4994 
4995 	ar->cfg_tx_chainmask = tx_ant;
4996 	ar->cfg_rx_chainmask = rx_ant;
4997 
4998 	if ((ar->state != ATH10K_STATE_ON) &&
4999 	    (ar->state != ATH10K_STATE_RESTARTED))
5000 		return 0;
5001 
5002 	ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->tx_chain_mask,
5003 					tx_ant);
5004 	if (ret) {
5005 		ath10k_warn(ar, "failed to set tx-chainmask: %d, req 0x%x\n",
5006 			    ret, tx_ant);
5007 		return ret;
5008 	}
5009 
5010 	ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rx_chain_mask,
5011 					rx_ant);
5012 	if (ret) {
5013 		ath10k_warn(ar, "failed to set rx-chainmask: %d, req 0x%x\n",
5014 			    ret, rx_ant);
5015 		return ret;
5016 	}
5017 
5018 	/* Reload HT/VHT capability */
5019 	ath10k_mac_setup_ht_vht_cap(ar);
5020 
5021 	return 0;
5022 }
5023 
ath10k_set_antenna(struct ieee80211_hw * hw,u32 tx_ant,u32 rx_ant)5024 static int ath10k_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
5025 {
5026 	struct ath10k *ar = hw->priv;
5027 	int ret;
5028 
5029 	mutex_lock(&ar->conf_mutex);
5030 	ret = __ath10k_set_antenna(ar, tx_ant, rx_ant);
5031 	mutex_unlock(&ar->conf_mutex);
5032 	return ret;
5033 }
5034 
__ath10k_fetch_bb_timing_dt(struct ath10k * ar,struct wmi_bb_timing_cfg_arg * bb_timing)5035 static int __ath10k_fetch_bb_timing_dt(struct ath10k *ar,
5036 				       struct wmi_bb_timing_cfg_arg *bb_timing)
5037 {
5038 	struct device_node *node;
5039 	const char *fem_name;
5040 	int ret;
5041 
5042 	node = ar->dev->of_node;
5043 	if (!node)
5044 		return -ENOENT;
5045 
5046 	ret = of_property_read_string_index(node, "ext-fem-name", 0, &fem_name);
5047 	if (ret)
5048 		return -ENOENT;
5049 
5050 	/*
5051 	 * If external Front End module used in hardware, then default base band timing
5052 	 * parameter cannot be used since they were fine tuned for reference hardware,
5053 	 * so choosing different value suitable for that external FEM.
5054 	 */
5055 	if (!strcmp("microsemi-lx5586", fem_name)) {
5056 		bb_timing->bb_tx_timing = 0x00;
5057 		bb_timing->bb_xpa_timing = 0x0101;
5058 	} else {
5059 		return -ENOENT;
5060 	}
5061 
5062 	ath10k_dbg(ar, ATH10K_DBG_BOOT, "boot bb_tx_timing 0x%x bb_xpa_timing 0x%x\n",
5063 		   bb_timing->bb_tx_timing, bb_timing->bb_xpa_timing);
5064 	return 0;
5065 }
5066 
ath10k_mac_rfkill_config(struct ath10k * ar)5067 static int ath10k_mac_rfkill_config(struct ath10k *ar)
5068 {
5069 	u32 param;
5070 	int ret;
5071 
5072 	if (ar->hw_values->rfkill_pin == 0) {
5073 		ath10k_warn(ar, "ath10k does not support hardware rfkill with this device\n");
5074 		return -EOPNOTSUPP;
5075 	}
5076 
5077 	ath10k_dbg(ar, ATH10K_DBG_MAC,
5078 		   "mac rfkill_pin %d rfkill_cfg %d rfkill_on_level %d",
5079 		   ar->hw_values->rfkill_pin, ar->hw_values->rfkill_cfg,
5080 		   ar->hw_values->rfkill_on_level);
5081 
5082 	param = FIELD_PREP(WMI_TLV_RFKILL_CFG_RADIO_LEVEL,
5083 			   ar->hw_values->rfkill_on_level) |
5084 		FIELD_PREP(WMI_TLV_RFKILL_CFG_GPIO_PIN_NUM,
5085 			   ar->hw_values->rfkill_pin) |
5086 		FIELD_PREP(WMI_TLV_RFKILL_CFG_PIN_AS_GPIO,
5087 			   ar->hw_values->rfkill_cfg);
5088 
5089 	ret = ath10k_wmi_pdev_set_param(ar,
5090 					ar->wmi.pdev_param->rfkill_config,
5091 					param);
5092 	if (ret) {
5093 		ath10k_warn(ar,
5094 			    "failed to set rfkill config 0x%x: %d\n",
5095 			    param, ret);
5096 		return ret;
5097 	}
5098 	return 0;
5099 }
5100 
ath10k_mac_rfkill_enable_radio(struct ath10k * ar,bool enable)5101 int ath10k_mac_rfkill_enable_radio(struct ath10k *ar, bool enable)
5102 {
5103 	enum wmi_tlv_rfkill_enable_radio param;
5104 	int ret;
5105 
5106 	if (enable)
5107 		param = WMI_TLV_RFKILL_ENABLE_RADIO_ON;
5108 	else
5109 		param = WMI_TLV_RFKILL_ENABLE_RADIO_OFF;
5110 
5111 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac rfkill enable %d", param);
5112 
5113 	ret = ath10k_wmi_pdev_set_param(ar, ar->wmi.pdev_param->rfkill_enable,
5114 					param);
5115 	if (ret) {
5116 		ath10k_warn(ar, "failed to set rfkill enable param %d: %d\n",
5117 			    param, ret);
5118 		return ret;
5119 	}
5120 
5121 	return 0;
5122 }
5123 
ath10k_start(struct ieee80211_hw * hw)5124 static int ath10k_start(struct ieee80211_hw *hw)
5125 {
5126 	struct ath10k *ar = hw->priv;
5127 	u32 param;
5128 	int ret = 0;
5129 	struct wmi_bb_timing_cfg_arg bb_timing = {0};
5130 
5131 	/*
5132 	 * This makes sense only when restarting hw. It is harmless to call
5133 	 * unconditionally. This is necessary to make sure no HTT/WMI tx
5134 	 * commands will be submitted while restarting.
5135 	 */
5136 	ath10k_drain_tx(ar);
5137 
5138 	mutex_lock(&ar->conf_mutex);
5139 
5140 	switch (ar->state) {
5141 	case ATH10K_STATE_OFF:
5142 		ar->state = ATH10K_STATE_ON;
5143 		break;
5144 	case ATH10K_STATE_RESTARTING:
5145 		ar->state = ATH10K_STATE_RESTARTED;
5146 		break;
5147 	case ATH10K_STATE_ON:
5148 	case ATH10K_STATE_RESTARTED:
5149 	case ATH10K_STATE_WEDGED:
5150 		WARN_ON(1);
5151 		ret = -EINVAL;
5152 		goto err;
5153 	case ATH10K_STATE_UTF:
5154 		ret = -EBUSY;
5155 		goto err;
5156 	}
5157 
5158 	spin_lock_bh(&ar->data_lock);
5159 
5160 	if (ar->hw_rfkill_on) {
5161 		ar->hw_rfkill_on = false;
5162 		spin_unlock_bh(&ar->data_lock);
5163 		goto err;
5164 	}
5165 
5166 	spin_unlock_bh(&ar->data_lock);
5167 
5168 	ret = ath10k_hif_power_up(ar, ATH10K_FIRMWARE_MODE_NORMAL);
5169 	if (ret) {
5170 		ath10k_err(ar, "Could not init hif: %d\n", ret);
5171 		goto err_off;
5172 	}
5173 
5174 	ret = ath10k_core_start(ar, ATH10K_FIRMWARE_MODE_NORMAL,
5175 				&ar->normal_mode_fw);
5176 	if (ret) {
5177 		ath10k_err(ar, "Could not init core: %d\n", ret);
5178 		goto err_power_down;
5179 	}
5180 
5181 	if (ar->sys_cap_info & WMI_TLV_SYS_CAP_INFO_RFKILL) {
5182 		ret = ath10k_mac_rfkill_config(ar);
5183 		if (ret && ret != -EOPNOTSUPP) {
5184 			ath10k_warn(ar, "failed to configure rfkill: %d", ret);
5185 			goto err_core_stop;
5186 		}
5187 	}
5188 
5189 	param = ar->wmi.pdev_param->pmf_qos;
5190 	ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5191 	if (ret) {
5192 		ath10k_warn(ar, "failed to enable PMF QOS: %d\n", ret);
5193 		goto err_core_stop;
5194 	}
5195 
5196 	param = ar->wmi.pdev_param->dynamic_bw;
5197 	ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5198 	if (ret) {
5199 		ath10k_warn(ar, "failed to enable dynamic BW: %d\n", ret);
5200 		goto err_core_stop;
5201 	}
5202 
5203 	if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {
5204 		ret = ath10k_wmi_scan_prob_req_oui(ar, ar->mac_addr);
5205 		if (ret) {
5206 			ath10k_err(ar, "failed to set prob req oui: %i\n", ret);
5207 			goto err_core_stop;
5208 		}
5209 	}
5210 
5211 	if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
5212 		ret = ath10k_wmi_adaptive_qcs(ar, true);
5213 		if (ret) {
5214 			ath10k_warn(ar, "failed to enable adaptive qcs: %d\n",
5215 				    ret);
5216 			goto err_core_stop;
5217 		}
5218 	}
5219 
5220 	if (test_bit(WMI_SERVICE_BURST, ar->wmi.svc_map)) {
5221 		param = ar->wmi.pdev_param->burst_enable;
5222 		ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5223 		if (ret) {
5224 			ath10k_warn(ar, "failed to disable burst: %d\n", ret);
5225 			goto err_core_stop;
5226 		}
5227 	}
5228 
5229 	param = ar->wmi.pdev_param->idle_ps_config;
5230 	ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5231 	if (ret && ret != -EOPNOTSUPP) {
5232 		ath10k_warn(ar, "failed to enable idle_ps_config: %d\n", ret);
5233 		goto err_core_stop;
5234 	}
5235 
5236 	__ath10k_set_antenna(ar, ar->cfg_tx_chainmask, ar->cfg_rx_chainmask);
5237 
5238 	/*
5239 	 * By default FW set ARP frames ac to voice (6). In that case ARP
5240 	 * exchange is not working properly for UAPSD enabled AP. ARP requests
5241 	 * which arrives with access category 0 are processed by network stack
5242 	 * and send back with access category 0, but FW changes access category
5243 	 * to 6. Set ARP frames access category to best effort (0) solves
5244 	 * this problem.
5245 	 */
5246 
5247 	param = ar->wmi.pdev_param->arp_ac_override;
5248 	ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5249 	if (ret) {
5250 		ath10k_warn(ar, "failed to set arp ac override parameter: %d\n",
5251 			    ret);
5252 		goto err_core_stop;
5253 	}
5254 
5255 	if (test_bit(ATH10K_FW_FEATURE_SUPPORTS_ADAPTIVE_CCA,
5256 		     ar->running_fw->fw_file.fw_features)) {
5257 		ret = ath10k_wmi_pdev_enable_adaptive_cca(ar, 1,
5258 							  WMI_CCA_DETECT_LEVEL_AUTO,
5259 							  WMI_CCA_DETECT_MARGIN_AUTO);
5260 		if (ret) {
5261 			ath10k_warn(ar, "failed to enable adaptive cca: %d\n",
5262 				    ret);
5263 			goto err_core_stop;
5264 		}
5265 	}
5266 
5267 	param = ar->wmi.pdev_param->ani_enable;
5268 	ret = ath10k_wmi_pdev_set_param(ar, param, 1);
5269 	if (ret) {
5270 		ath10k_warn(ar, "failed to enable ani by default: %d\n",
5271 			    ret);
5272 		goto err_core_stop;
5273 	}
5274 
5275 	ar->ani_enabled = true;
5276 
5277 	if (ath10k_peer_stats_enabled(ar)) {
5278 		param = ar->wmi.pdev_param->peer_stats_update_period;
5279 		ret = ath10k_wmi_pdev_set_param(ar, param,
5280 						PEER_DEFAULT_STATS_UPDATE_PERIOD);
5281 		if (ret) {
5282 			ath10k_warn(ar,
5283 				    "failed to set peer stats period : %d\n",
5284 				    ret);
5285 			goto err_core_stop;
5286 		}
5287 	}
5288 
5289 	param = ar->wmi.pdev_param->enable_btcoex;
5290 	if (test_bit(WMI_SERVICE_COEX_GPIO, ar->wmi.svc_map) &&
5291 	    test_bit(ATH10K_FW_FEATURE_BTCOEX_PARAM,
5292 		     ar->running_fw->fw_file.fw_features) &&
5293 	    ar->coex_support) {
5294 		ret = ath10k_wmi_pdev_set_param(ar, param, 0);
5295 		if (ret) {
5296 			ath10k_warn(ar,
5297 				    "failed to set btcoex param: %d\n", ret);
5298 			goto err_core_stop;
5299 		}
5300 		clear_bit(ATH10K_FLAG_BTCOEX, &ar->dev_flags);
5301 	}
5302 
5303 	if (test_bit(WMI_SERVICE_BB_TIMING_CONFIG_SUPPORT, ar->wmi.svc_map)) {
5304 		ret = __ath10k_fetch_bb_timing_dt(ar, &bb_timing);
5305 		if (!ret) {
5306 			ret = ath10k_wmi_pdev_bb_timing(ar, &bb_timing);
5307 			if (ret) {
5308 				ath10k_warn(ar,
5309 					    "failed to set bb timings: %d\n",
5310 					    ret);
5311 				goto err_core_stop;
5312 			}
5313 		}
5314 	}
5315 
5316 	ar->num_started_vdevs = 0;
5317 	ath10k_regd_update(ar);
5318 
5319 	ath10k_spectral_start(ar);
5320 	ath10k_thermal_set_throttling(ar);
5321 
5322 	ar->radar_conf_state = ATH10K_RADAR_CONFIRMATION_IDLE;
5323 
5324 	mutex_unlock(&ar->conf_mutex);
5325 	return 0;
5326 
5327 err_core_stop:
5328 	ath10k_core_stop(ar);
5329 
5330 err_power_down:
5331 	ath10k_hif_power_down(ar);
5332 
5333 err_off:
5334 	ar->state = ATH10K_STATE_OFF;
5335 
5336 err:
5337 	mutex_unlock(&ar->conf_mutex);
5338 	return ret;
5339 }
5340 
ath10k_stop(struct ieee80211_hw * hw)5341 static void ath10k_stop(struct ieee80211_hw *hw)
5342 {
5343 	struct ath10k *ar = hw->priv;
5344 	u32 opt;
5345 
5346 	ath10k_drain_tx(ar);
5347 
5348 	mutex_lock(&ar->conf_mutex);
5349 	if (ar->state != ATH10K_STATE_OFF) {
5350 		if (!ar->hw_rfkill_on) {
5351 			/* If the current driver state is RESTARTING but not yet
5352 			 * fully RESTARTED because of incoming suspend event,
5353 			 * then ath10k_halt() is already called via
5354 			 * ath10k_core_restart() and should not be called here.
5355 			 */
5356 			if (ar->state != ATH10K_STATE_RESTARTING) {
5357 				ath10k_halt(ar);
5358 			} else {
5359 				/* Suspending here, because when in RESTARTING
5360 				 * state, ath10k_core_stop() skips
5361 				 * ath10k_wait_for_suspend().
5362 				 */
5363 				opt = WMI_PDEV_SUSPEND_AND_DISABLE_INTR;
5364 				ath10k_wait_for_suspend(ar, opt);
5365 			}
5366 		}
5367 		ar->state = ATH10K_STATE_OFF;
5368 	}
5369 	mutex_unlock(&ar->conf_mutex);
5370 
5371 	cancel_work_sync(&ar->set_coverage_class_work);
5372 	cancel_delayed_work_sync(&ar->scan.timeout);
5373 	cancel_work_sync(&ar->restart_work);
5374 }
5375 
ath10k_config_ps(struct ath10k * ar)5376 static int ath10k_config_ps(struct ath10k *ar)
5377 {
5378 	struct ath10k_vif *arvif;
5379 	int ret = 0;
5380 
5381 	lockdep_assert_held(&ar->conf_mutex);
5382 
5383 	list_for_each_entry(arvif, &ar->arvifs, list) {
5384 		ret = ath10k_mac_vif_setup_ps(arvif);
5385 		if (ret) {
5386 			ath10k_warn(ar, "failed to setup powersave: %d\n", ret);
5387 			break;
5388 		}
5389 	}
5390 
5391 	return ret;
5392 }
5393 
ath10k_config(struct ieee80211_hw * hw,u32 changed)5394 static int ath10k_config(struct ieee80211_hw *hw, u32 changed)
5395 {
5396 	struct ath10k *ar = hw->priv;
5397 	struct ieee80211_conf *conf = &hw->conf;
5398 	int ret = 0;
5399 
5400 	mutex_lock(&ar->conf_mutex);
5401 
5402 	if (changed & IEEE80211_CONF_CHANGE_PS)
5403 		ath10k_config_ps(ar);
5404 
5405 	if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
5406 		ar->monitor = conf->flags & IEEE80211_CONF_MONITOR;
5407 		ret = ath10k_monitor_recalc(ar);
5408 		if (ret)
5409 			ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5410 	}
5411 
5412 	mutex_unlock(&ar->conf_mutex);
5413 	return ret;
5414 }
5415 
get_nss_from_chainmask(u16 chain_mask)5416 static u32 get_nss_from_chainmask(u16 chain_mask)
5417 {
5418 	if ((chain_mask & 0xf) == 0xf)
5419 		return 4;
5420 	else if ((chain_mask & 0x7) == 0x7)
5421 		return 3;
5422 	else if ((chain_mask & 0x3) == 0x3)
5423 		return 2;
5424 	return 1;
5425 }
5426 
ath10k_mac_set_txbf_conf(struct ath10k_vif * arvif)5427 static int ath10k_mac_set_txbf_conf(struct ath10k_vif *arvif)
5428 {
5429 	u32 value = 0;
5430 	struct ath10k *ar = arvif->ar;
5431 	int nsts;
5432 	int sound_dim;
5433 
5434 	if (ath10k_wmi_get_txbf_conf_scheme(ar) != WMI_TXBF_CONF_BEFORE_ASSOC)
5435 		return 0;
5436 
5437 	nsts = ath10k_mac_get_vht_cap_bf_sts(ar);
5438 	if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
5439 				IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE))
5440 		value |= SM(nsts, WMI_TXBF_STS_CAP_OFFSET);
5441 
5442 	sound_dim = ath10k_mac_get_vht_cap_bf_sound_dim(ar);
5443 	if (ar->vht_cap_info & (IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE |
5444 				IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE))
5445 		value |= SM(sound_dim, WMI_BF_SOUND_DIM_OFFSET);
5446 
5447 	if (!value)
5448 		return 0;
5449 
5450 	if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE)
5451 		value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFER;
5452 
5453 	if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMER_CAPABLE)
5454 		value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFER |
5455 			  WMI_VDEV_PARAM_TXBF_SU_TX_BFER);
5456 
5457 	if (ar->vht_cap_info & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE)
5458 		value |= WMI_VDEV_PARAM_TXBF_SU_TX_BFEE;
5459 
5460 	if (ar->vht_cap_info & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE)
5461 		value |= (WMI_VDEV_PARAM_TXBF_MU_TX_BFEE |
5462 			  WMI_VDEV_PARAM_TXBF_SU_TX_BFEE);
5463 
5464 	return ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
5465 					 ar->wmi.vdev_param->txbf, value);
5466 }
5467 
5468 /*
5469  * TODO:
5470  * Figure out how to handle WMI_VDEV_SUBTYPE_P2P_DEVICE,
5471  * because we will send mgmt frames without CCK. This requirement
5472  * for P2P_FIND/GO_NEG should be handled by checking CCK flag
5473  * in the TX packet.
5474  */
ath10k_add_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5475 static int ath10k_add_interface(struct ieee80211_hw *hw,
5476 				struct ieee80211_vif *vif)
5477 {
5478 	struct ath10k *ar = hw->priv;
5479 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
5480 	struct ath10k_peer *peer;
5481 	enum wmi_sta_powersave_param param;
5482 	int ret = 0;
5483 	u32 value;
5484 	int bit;
5485 	int i;
5486 	u32 vdev_param;
5487 
5488 	vif->driver_flags |= IEEE80211_VIF_SUPPORTS_UAPSD;
5489 
5490 	mutex_lock(&ar->conf_mutex);
5491 
5492 	memset(arvif, 0, sizeof(*arvif));
5493 	ath10k_mac_txq_init(vif->txq);
5494 
5495 	arvif->ar = ar;
5496 	arvif->vif = vif;
5497 
5498 	INIT_LIST_HEAD(&arvif->list);
5499 	INIT_WORK(&arvif->ap_csa_work, ath10k_mac_vif_ap_csa_work);
5500 	INIT_DELAYED_WORK(&arvif->connection_loss_work,
5501 			  ath10k_mac_vif_sta_connection_loss_work);
5502 
5503 	for (i = 0; i < ARRAY_SIZE(arvif->bitrate_mask.control); i++) {
5504 		arvif->bitrate_mask.control[i].legacy = 0xffffffff;
5505 		memset(arvif->bitrate_mask.control[i].ht_mcs, 0xff,
5506 		       sizeof(arvif->bitrate_mask.control[i].ht_mcs));
5507 		memset(arvif->bitrate_mask.control[i].vht_mcs, 0xff,
5508 		       sizeof(arvif->bitrate_mask.control[i].vht_mcs));
5509 	}
5510 
5511 	if (ar->num_peers >= ar->max_num_peers) {
5512 		ath10k_warn(ar, "refusing vdev creation due to insufficient peer entry resources in firmware\n");
5513 		ret = -ENOBUFS;
5514 		goto err;
5515 	}
5516 
5517 	if (ar->free_vdev_map == 0) {
5518 		ath10k_warn(ar, "Free vdev map is empty, no more interfaces allowed.\n");
5519 		ret = -EBUSY;
5520 		goto err;
5521 	}
5522 	bit = __ffs64(ar->free_vdev_map);
5523 
5524 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac create vdev %i map %llx\n",
5525 		   bit, ar->free_vdev_map);
5526 
5527 	arvif->vdev_id = bit;
5528 	arvif->vdev_subtype =
5529 		ath10k_wmi_get_vdev_subtype(ar, WMI_VDEV_SUBTYPE_NONE);
5530 
5531 	switch (vif->type) {
5532 	case NL80211_IFTYPE_P2P_DEVICE:
5533 		arvif->vdev_type = WMI_VDEV_TYPE_STA;
5534 		arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5535 					(ar, WMI_VDEV_SUBTYPE_P2P_DEVICE);
5536 		break;
5537 	case NL80211_IFTYPE_UNSPECIFIED:
5538 	case NL80211_IFTYPE_STATION:
5539 		arvif->vdev_type = WMI_VDEV_TYPE_STA;
5540 		if (vif->p2p)
5541 			arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5542 					(ar, WMI_VDEV_SUBTYPE_P2P_CLIENT);
5543 		break;
5544 	case NL80211_IFTYPE_ADHOC:
5545 		arvif->vdev_type = WMI_VDEV_TYPE_IBSS;
5546 		break;
5547 	case NL80211_IFTYPE_MESH_POINT:
5548 		if (test_bit(WMI_SERVICE_MESH_11S, ar->wmi.svc_map)) {
5549 			arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5550 						(ar, WMI_VDEV_SUBTYPE_MESH_11S);
5551 		} else if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
5552 			ret = -EINVAL;
5553 			ath10k_warn(ar, "must load driver with rawmode=1 to add mesh interfaces\n");
5554 			goto err;
5555 		}
5556 		arvif->vdev_type = WMI_VDEV_TYPE_AP;
5557 		break;
5558 	case NL80211_IFTYPE_AP:
5559 		arvif->vdev_type = WMI_VDEV_TYPE_AP;
5560 
5561 		if (vif->p2p)
5562 			arvif->vdev_subtype = ath10k_wmi_get_vdev_subtype
5563 						(ar, WMI_VDEV_SUBTYPE_P2P_GO);
5564 		break;
5565 	case NL80211_IFTYPE_MONITOR:
5566 		arvif->vdev_type = WMI_VDEV_TYPE_MONITOR;
5567 		break;
5568 	default:
5569 		WARN_ON(1);
5570 		break;
5571 	}
5572 
5573 	/* Using vdev_id as queue number will make it very easy to do per-vif
5574 	 * tx queue locking. This shouldn't wrap due to interface combinations
5575 	 * but do a modulo for correctness sake and prevent using offchannel tx
5576 	 * queues for regular vif tx.
5577 	 */
5578 	vif->cab_queue = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
5579 	for (i = 0; i < ARRAY_SIZE(vif->hw_queue); i++)
5580 		vif->hw_queue[i] = arvif->vdev_id % (IEEE80211_MAX_QUEUES - 1);
5581 
5582 	/* Some firmware revisions don't wait for beacon tx completion before
5583 	 * sending another SWBA event. This could lead to hardware using old
5584 	 * (freed) beacon data in some cases, e.g. tx credit starvation
5585 	 * combined with missed TBTT. This is very rare.
5586 	 *
5587 	 * On non-IOMMU-enabled hosts this could be a possible security issue
5588 	 * because hw could beacon some random data on the air.  On
5589 	 * IOMMU-enabled hosts DMAR faults would occur in most cases and target
5590 	 * device would crash.
5591 	 *
5592 	 * Since there are no beacon tx completions (implicit nor explicit)
5593 	 * propagated to host the only workaround for this is to allocate a
5594 	 * DMA-coherent buffer for a lifetime of a vif and use it for all
5595 	 * beacon tx commands. Worst case for this approach is some beacons may
5596 	 * become corrupted, e.g. have garbled IEs or out-of-date TIM bitmap.
5597 	 */
5598 	if (vif->type == NL80211_IFTYPE_ADHOC ||
5599 	    vif->type == NL80211_IFTYPE_MESH_POINT ||
5600 	    vif->type == NL80211_IFTYPE_AP) {
5601 		if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL) {
5602 			arvif->beacon_buf = kmalloc(IEEE80211_MAX_FRAME_LEN,
5603 						    GFP_KERNEL);
5604 
5605 			/* Using a kernel pointer in place of a dma_addr_t
5606 			 * token can lead to undefined behavior if that
5607 			 * makes it into cache management functions. Use a
5608 			 * known-invalid address token instead, which
5609 			 * avoids the warning and makes it easier to catch
5610 			 * bugs if it does end up getting used.
5611 			 */
5612 			arvif->beacon_paddr = DMA_MAPPING_ERROR;
5613 		} else {
5614 			arvif->beacon_buf =
5615 				dma_alloc_coherent(ar->dev,
5616 						   IEEE80211_MAX_FRAME_LEN,
5617 						   &arvif->beacon_paddr,
5618 						   GFP_ATOMIC);
5619 		}
5620 		if (!arvif->beacon_buf) {
5621 			ret = -ENOMEM;
5622 			ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
5623 				    ret);
5624 			goto err;
5625 		}
5626 	}
5627 	if (test_bit(ATH10K_FLAG_HW_CRYPTO_DISABLED, &ar->dev_flags))
5628 		arvif->nohwcrypt = true;
5629 
5630 	if (arvif->nohwcrypt &&
5631 	    !test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags)) {
5632 		ret = -EINVAL;
5633 		ath10k_warn(ar, "cryptmode module param needed for sw crypto\n");
5634 		goto err;
5635 	}
5636 
5637 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev create %d (add interface) type %d subtype %d bcnmode %s\n",
5638 		   arvif->vdev_id, arvif->vdev_type, arvif->vdev_subtype,
5639 		   arvif->beacon_buf ? "single-buf" : "per-skb");
5640 
5641 	ret = ath10k_wmi_vdev_create(ar, arvif->vdev_id, arvif->vdev_type,
5642 				     arvif->vdev_subtype, vif->addr);
5643 	if (ret) {
5644 		ath10k_warn(ar, "failed to create WMI vdev %i: %d\n",
5645 			    arvif->vdev_id, ret);
5646 		goto err;
5647 	}
5648 
5649 	if (test_bit(WMI_SERVICE_VDEV_DISABLE_4_ADDR_SRC_LRN_SUPPORT,
5650 		     ar->wmi.svc_map)) {
5651 		vdev_param = ar->wmi.vdev_param->disable_4addr_src_lrn;
5652 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5653 						WMI_VDEV_DISABLE_4_ADDR_SRC_LRN);
5654 		if (ret && ret != -EOPNOTSUPP) {
5655 			ath10k_warn(ar, "failed to disable 4addr src lrn vdev %i: %d\n",
5656 				    arvif->vdev_id, ret);
5657 		}
5658 	}
5659 
5660 	ar->free_vdev_map &= ~(1LL << arvif->vdev_id);
5661 	spin_lock_bh(&ar->data_lock);
5662 	list_add(&arvif->list, &ar->arvifs);
5663 	spin_unlock_bh(&ar->data_lock);
5664 
5665 	/* It makes no sense to have firmware do keepalives. mac80211 already
5666 	 * takes care of this with idle connection polling.
5667 	 */
5668 	ret = ath10k_mac_vif_disable_keepalive(arvif);
5669 	if (ret) {
5670 		ath10k_warn(ar, "failed to disable keepalive on vdev %i: %d\n",
5671 			    arvif->vdev_id, ret);
5672 		goto err_vdev_delete;
5673 	}
5674 
5675 	arvif->def_wep_key_idx = -1;
5676 
5677 	vdev_param = ar->wmi.vdev_param->tx_encap_type;
5678 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5679 					ATH10K_HW_TXRX_NATIVE_WIFI);
5680 	/* 10.X firmware does not support this VDEV parameter. Do not warn */
5681 	if (ret && ret != -EOPNOTSUPP) {
5682 		ath10k_warn(ar, "failed to set vdev %i TX encapsulation: %d\n",
5683 			    arvif->vdev_id, ret);
5684 		goto err_vdev_delete;
5685 	}
5686 
5687 	/* Configuring number of spatial stream for monitor interface is causing
5688 	 * target assert in qca9888 and qca6174.
5689 	 */
5690 	if (ar->cfg_tx_chainmask && (vif->type != NL80211_IFTYPE_MONITOR)) {
5691 		u16 nss = get_nss_from_chainmask(ar->cfg_tx_chainmask);
5692 
5693 		vdev_param = ar->wmi.vdev_param->nss;
5694 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5695 						nss);
5696 		if (ret) {
5697 			ath10k_warn(ar, "failed to set vdev %i chainmask 0x%x, nss %i: %d\n",
5698 				    arvif->vdev_id, ar->cfg_tx_chainmask, nss,
5699 				    ret);
5700 			goto err_vdev_delete;
5701 		}
5702 	}
5703 
5704 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5705 	    arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5706 		ret = ath10k_peer_create(ar, vif, NULL, arvif->vdev_id,
5707 					 vif->addr, WMI_PEER_TYPE_DEFAULT);
5708 		if (ret) {
5709 			ath10k_warn(ar, "failed to create vdev %i peer for AP/IBSS: %d\n",
5710 				    arvif->vdev_id, ret);
5711 			goto err_vdev_delete;
5712 		}
5713 
5714 		spin_lock_bh(&ar->data_lock);
5715 
5716 		peer = ath10k_peer_find(ar, arvif->vdev_id, vif->addr);
5717 		if (!peer) {
5718 			ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
5719 				    vif->addr, arvif->vdev_id);
5720 			spin_unlock_bh(&ar->data_lock);
5721 			ret = -ENOENT;
5722 			goto err_peer_delete;
5723 		}
5724 
5725 		arvif->peer_id = find_first_bit(peer->peer_ids,
5726 						ATH10K_MAX_NUM_PEER_IDS);
5727 
5728 		spin_unlock_bh(&ar->data_lock);
5729 	} else {
5730 		arvif->peer_id = HTT_INVALID_PEERID;
5731 	}
5732 
5733 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP) {
5734 		ret = ath10k_mac_set_kickout(arvif);
5735 		if (ret) {
5736 			ath10k_warn(ar, "failed to set vdev %i kickout parameters: %d\n",
5737 				    arvif->vdev_id, ret);
5738 			goto err_peer_delete;
5739 		}
5740 	}
5741 
5742 	if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
5743 		param = WMI_STA_PS_PARAM_RX_WAKE_POLICY;
5744 		value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
5745 		ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
5746 						  param, value);
5747 		if (ret) {
5748 			ath10k_warn(ar, "failed to set vdev %i RX wake policy: %d\n",
5749 				    arvif->vdev_id, ret);
5750 			goto err_peer_delete;
5751 		}
5752 
5753 		ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
5754 		if (ret) {
5755 			ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
5756 				    arvif->vdev_id, ret);
5757 			goto err_peer_delete;
5758 		}
5759 
5760 		ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
5761 		if (ret) {
5762 			ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
5763 				    arvif->vdev_id, ret);
5764 			goto err_peer_delete;
5765 		}
5766 	}
5767 
5768 	ret = ath10k_mac_set_txbf_conf(arvif);
5769 	if (ret) {
5770 		ath10k_warn(ar, "failed to set txbf for vdev %d: %d\n",
5771 			    arvif->vdev_id, ret);
5772 		goto err_peer_delete;
5773 	}
5774 
5775 	ret = ath10k_mac_set_rts(arvif, ar->hw->wiphy->rts_threshold);
5776 	if (ret) {
5777 		ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
5778 			    arvif->vdev_id, ret);
5779 		goto err_peer_delete;
5780 	}
5781 
5782 	arvif->txpower = vif->bss_conf.txpower;
5783 	ret = ath10k_mac_txpower_recalc(ar);
5784 	if (ret) {
5785 		ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
5786 		goto err_peer_delete;
5787 	}
5788 
5789 	if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {
5790 		vdev_param = ar->wmi.vdev_param->rtt_responder_role;
5791 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
5792 						arvif->ftm_responder);
5793 
5794 		/* It is harmless to not set FTM role. Do not warn */
5795 		if (ret && ret != -EOPNOTSUPP)
5796 			ath10k_warn(ar, "failed to set vdev %i FTM Responder: %d\n",
5797 				    arvif->vdev_id, ret);
5798 	}
5799 
5800 	if (vif->type == NL80211_IFTYPE_MONITOR) {
5801 		ar->monitor_arvif = arvif;
5802 		ret = ath10k_monitor_recalc(ar);
5803 		if (ret) {
5804 			ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5805 			goto err_peer_delete;
5806 		}
5807 	}
5808 
5809 	spin_lock_bh(&ar->htt.tx_lock);
5810 	if (!ar->tx_paused)
5811 		ieee80211_wake_queue(ar->hw, arvif->vdev_id);
5812 	spin_unlock_bh(&ar->htt.tx_lock);
5813 
5814 	mutex_unlock(&ar->conf_mutex);
5815 	return 0;
5816 
5817 err_peer_delete:
5818 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5819 	    arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5820 		ath10k_wmi_peer_delete(ar, arvif->vdev_id, vif->addr);
5821 		ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,
5822 						 vif->addr);
5823 	}
5824 
5825 err_vdev_delete:
5826 	ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
5827 	ar->free_vdev_map |= 1LL << arvif->vdev_id;
5828 	spin_lock_bh(&ar->data_lock);
5829 	list_del(&arvif->list);
5830 	spin_unlock_bh(&ar->data_lock);
5831 
5832 err:
5833 	if (arvif->beacon_buf) {
5834 		if (ar->bus_param.dev_type == ATH10K_DEV_TYPE_HL)
5835 			kfree(arvif->beacon_buf);
5836 		else
5837 			dma_free_coherent(ar->dev, IEEE80211_MAX_FRAME_LEN,
5838 					  arvif->beacon_buf,
5839 					  arvif->beacon_paddr);
5840 		arvif->beacon_buf = NULL;
5841 	}
5842 
5843 	mutex_unlock(&ar->conf_mutex);
5844 
5845 	return ret;
5846 }
5847 
ath10k_mac_vif_tx_unlock_all(struct ath10k_vif * arvif)5848 static void ath10k_mac_vif_tx_unlock_all(struct ath10k_vif *arvif)
5849 {
5850 	int i;
5851 
5852 	for (i = 0; i < BITS_PER_LONG; i++)
5853 		ath10k_mac_vif_tx_unlock(arvif, i);
5854 }
5855 
ath10k_remove_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)5856 static void ath10k_remove_interface(struct ieee80211_hw *hw,
5857 				    struct ieee80211_vif *vif)
5858 {
5859 	struct ath10k *ar = hw->priv;
5860 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
5861 	struct ath10k_peer *peer;
5862 	unsigned long time_left;
5863 	int ret;
5864 	int i;
5865 
5866 	cancel_work_sync(&arvif->ap_csa_work);
5867 	cancel_delayed_work_sync(&arvif->connection_loss_work);
5868 
5869 	mutex_lock(&ar->conf_mutex);
5870 
5871 	ret = ath10k_spectral_vif_stop(arvif);
5872 	if (ret)
5873 		ath10k_warn(ar, "failed to stop spectral for vdev %i: %d\n",
5874 			    arvif->vdev_id, ret);
5875 
5876 	ar->free_vdev_map |= 1LL << arvif->vdev_id;
5877 	spin_lock_bh(&ar->data_lock);
5878 	list_del(&arvif->list);
5879 	spin_unlock_bh(&ar->data_lock);
5880 
5881 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5882 	    arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5883 		ret = ath10k_wmi_peer_delete(arvif->ar, arvif->vdev_id,
5884 					     vif->addr);
5885 		if (ret)
5886 			ath10k_warn(ar, "failed to submit AP/IBSS self-peer removal on vdev %i: %d\n",
5887 				    arvif->vdev_id, ret);
5888 
5889 		ath10k_wait_for_peer_delete_done(ar, arvif->vdev_id,
5890 						 vif->addr);
5891 		kfree(arvif->u.ap.noa_data);
5892 	}
5893 
5894 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %i delete (remove interface)\n",
5895 		   arvif->vdev_id);
5896 
5897 	ret = ath10k_wmi_vdev_delete(ar, arvif->vdev_id);
5898 	if (ret)
5899 		ath10k_warn(ar, "failed to delete WMI vdev %i: %d\n",
5900 			    arvif->vdev_id, ret);
5901 
5902 	if (test_bit(WMI_SERVICE_SYNC_DELETE_CMDS, ar->wmi.svc_map)) {
5903 		time_left = wait_for_completion_timeout(&ar->vdev_delete_done,
5904 							ATH10K_VDEV_DELETE_TIMEOUT_HZ);
5905 		if (time_left == 0) {
5906 			ath10k_warn(ar, "Timeout in receiving vdev delete response\n");
5907 			goto out;
5908 		}
5909 	}
5910 
5911 	/* Some firmware revisions don't notify host about self-peer removal
5912 	 * until after associated vdev is deleted.
5913 	 */
5914 	if (arvif->vdev_type == WMI_VDEV_TYPE_AP ||
5915 	    arvif->vdev_type == WMI_VDEV_TYPE_IBSS) {
5916 		ret = ath10k_wait_for_peer_deleted(ar, arvif->vdev_id,
5917 						   vif->addr);
5918 		if (ret)
5919 			ath10k_warn(ar, "failed to remove AP self-peer on vdev %i: %d\n",
5920 				    arvif->vdev_id, ret);
5921 
5922 		spin_lock_bh(&ar->data_lock);
5923 		ar->num_peers--;
5924 		spin_unlock_bh(&ar->data_lock);
5925 	}
5926 
5927 	spin_lock_bh(&ar->data_lock);
5928 	for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
5929 		peer = ar->peer_map[i];
5930 		if (!peer)
5931 			continue;
5932 
5933 		if (peer->vif == vif) {
5934 			ath10k_warn(ar, "found vif peer %pM entry on vdev %i after it was supposedly removed\n",
5935 				    vif->addr, arvif->vdev_id);
5936 			peer->vif = NULL;
5937 		}
5938 	}
5939 
5940 	/* Clean this up late, less opportunity for firmware to access
5941 	 * DMA memory we have deleted.
5942 	 */
5943 	ath10k_mac_vif_beacon_cleanup(arvif);
5944 	spin_unlock_bh(&ar->data_lock);
5945 
5946 	ath10k_peer_cleanup(ar, arvif->vdev_id);
5947 	ath10k_mac_txq_unref(ar, vif->txq);
5948 
5949 	if (vif->type == NL80211_IFTYPE_MONITOR) {
5950 		ar->monitor_arvif = NULL;
5951 		ret = ath10k_monitor_recalc(ar);
5952 		if (ret)
5953 			ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5954 	}
5955 
5956 	ret = ath10k_mac_txpower_recalc(ar);
5957 	if (ret)
5958 		ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
5959 
5960 	spin_lock_bh(&ar->htt.tx_lock);
5961 	ath10k_mac_vif_tx_unlock_all(arvif);
5962 	spin_unlock_bh(&ar->htt.tx_lock);
5963 
5964 	ath10k_mac_txq_unref(ar, vif->txq);
5965 
5966 out:
5967 	mutex_unlock(&ar->conf_mutex);
5968 }
5969 
5970 /*
5971  * FIXME: Has to be verified.
5972  */
5973 #define SUPPORTED_FILTERS			\
5974 	(FIF_ALLMULTI |				\
5975 	FIF_CONTROL |				\
5976 	FIF_PSPOLL |				\
5977 	FIF_OTHER_BSS |				\
5978 	FIF_BCN_PRBRESP_PROMISC |		\
5979 	FIF_PROBE_REQ |				\
5980 	FIF_FCSFAIL)
5981 
ath10k_configure_filter(struct ieee80211_hw * hw,unsigned int changed_flags,unsigned int * total_flags,u64 multicast)5982 static void ath10k_configure_filter(struct ieee80211_hw *hw,
5983 				    unsigned int changed_flags,
5984 				    unsigned int *total_flags,
5985 				    u64 multicast)
5986 {
5987 	struct ath10k *ar = hw->priv;
5988 	int ret;
5989 
5990 	mutex_lock(&ar->conf_mutex);
5991 
5992 	changed_flags &= SUPPORTED_FILTERS;
5993 	*total_flags &= SUPPORTED_FILTERS;
5994 	ar->filter_flags = *total_flags;
5995 
5996 	ret = ath10k_monitor_recalc(ar);
5997 	if (ret)
5998 		ath10k_warn(ar, "failed to recalc monitor: %d\n", ret);
5999 
6000 	mutex_unlock(&ar->conf_mutex);
6001 }
6002 
ath10k_recalculate_mgmt_rate(struct ath10k * ar,struct ieee80211_vif * vif,struct cfg80211_chan_def * def)6003 static void ath10k_recalculate_mgmt_rate(struct ath10k *ar,
6004 					 struct ieee80211_vif *vif,
6005 					 struct cfg80211_chan_def *def)
6006 {
6007 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6008 	const struct ieee80211_supported_band *sband;
6009 	u8 basic_rate_idx;
6010 	int hw_rate_code;
6011 	u32 vdev_param;
6012 	u16 bitrate;
6013 	int ret;
6014 
6015 	lockdep_assert_held(&ar->conf_mutex);
6016 
6017 	sband = ar->hw->wiphy->bands[def->chan->band];
6018 	basic_rate_idx = ffs(vif->bss_conf.basic_rates) - 1;
6019 	bitrate = sband->bitrates[basic_rate_idx].bitrate;
6020 
6021 	hw_rate_code = ath10k_mac_get_rate_hw_value(bitrate);
6022 	if (hw_rate_code < 0) {
6023 		ath10k_warn(ar, "bitrate not supported %d\n", bitrate);
6024 		return;
6025 	}
6026 
6027 	vdev_param = ar->wmi.vdev_param->mgmt_rate;
6028 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6029 					hw_rate_code);
6030 	if (ret)
6031 		ath10k_warn(ar, "failed to set mgmt tx rate %d\n", ret);
6032 }
6033 
ath10k_bss_info_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * info,u32 changed)6034 static void ath10k_bss_info_changed(struct ieee80211_hw *hw,
6035 				    struct ieee80211_vif *vif,
6036 				    struct ieee80211_bss_conf *info,
6037 				    u32 changed)
6038 {
6039 	struct ath10k *ar = hw->priv;
6040 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6041 	struct cfg80211_chan_def def;
6042 	u32 vdev_param, pdev_param, slottime, preamble;
6043 	u16 bitrate, hw_value;
6044 	u8 rate, rateidx;
6045 	int ret = 0, mcast_rate;
6046 	enum nl80211_band band;
6047 
6048 	mutex_lock(&ar->conf_mutex);
6049 
6050 	if (changed & BSS_CHANGED_IBSS)
6051 		ath10k_control_ibss(arvif, info, vif->addr);
6052 
6053 	if (changed & BSS_CHANGED_BEACON_INT) {
6054 		arvif->beacon_interval = info->beacon_int;
6055 		vdev_param = ar->wmi.vdev_param->beacon_interval;
6056 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6057 						arvif->beacon_interval);
6058 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6059 			   "mac vdev %d beacon_interval %d\n",
6060 			   arvif->vdev_id, arvif->beacon_interval);
6061 
6062 		if (ret)
6063 			ath10k_warn(ar, "failed to set beacon interval for vdev %d: %i\n",
6064 				    arvif->vdev_id, ret);
6065 	}
6066 
6067 	if (changed & BSS_CHANGED_BEACON) {
6068 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6069 			   "vdev %d set beacon tx mode to staggered\n",
6070 			   arvif->vdev_id);
6071 
6072 		pdev_param = ar->wmi.pdev_param->beacon_tx_mode;
6073 		ret = ath10k_wmi_pdev_set_param(ar, pdev_param,
6074 						WMI_BEACON_STAGGERED_MODE);
6075 		if (ret)
6076 			ath10k_warn(ar, "failed to set beacon mode for vdev %d: %i\n",
6077 				    arvif->vdev_id, ret);
6078 
6079 		ret = ath10k_mac_setup_bcn_tmpl(arvif);
6080 		if (ret)
6081 			ath10k_warn(ar, "failed to update beacon template: %d\n",
6082 				    ret);
6083 
6084 		if (ieee80211_vif_is_mesh(vif)) {
6085 			/* mesh doesn't use SSID but firmware needs it */
6086 			strncpy(arvif->u.ap.ssid, "mesh",
6087 				sizeof(arvif->u.ap.ssid));
6088 			arvif->u.ap.ssid_len = 4;
6089 		}
6090 	}
6091 
6092 	if (changed & BSS_CHANGED_AP_PROBE_RESP) {
6093 		ret = ath10k_mac_setup_prb_tmpl(arvif);
6094 		if (ret)
6095 			ath10k_warn(ar, "failed to setup probe resp template on vdev %i: %d\n",
6096 				    arvif->vdev_id, ret);
6097 	}
6098 
6099 	if (changed & (BSS_CHANGED_BEACON_INFO | BSS_CHANGED_BEACON)) {
6100 		arvif->dtim_period = info->dtim_period;
6101 
6102 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6103 			   "mac vdev %d dtim_period %d\n",
6104 			   arvif->vdev_id, arvif->dtim_period);
6105 
6106 		vdev_param = ar->wmi.vdev_param->dtim_period;
6107 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6108 						arvif->dtim_period);
6109 		if (ret)
6110 			ath10k_warn(ar, "failed to set dtim period for vdev %d: %i\n",
6111 				    arvif->vdev_id, ret);
6112 	}
6113 
6114 	if (changed & BSS_CHANGED_SSID &&
6115 	    vif->type == NL80211_IFTYPE_AP) {
6116 		arvif->u.ap.ssid_len = info->ssid_len;
6117 		if (info->ssid_len)
6118 			memcpy(arvif->u.ap.ssid, info->ssid, info->ssid_len);
6119 		arvif->u.ap.hidden_ssid = info->hidden_ssid;
6120 	}
6121 
6122 	if (changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid))
6123 		ether_addr_copy(arvif->bssid, info->bssid);
6124 
6125 	if (changed & BSS_CHANGED_FTM_RESPONDER &&
6126 	    arvif->ftm_responder != info->ftm_responder &&
6127 	    test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map)) {
6128 		arvif->ftm_responder = info->ftm_responder;
6129 
6130 		vdev_param = ar->wmi.vdev_param->rtt_responder_role;
6131 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6132 						arvif->ftm_responder);
6133 
6134 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6135 			   "mac vdev %d ftm_responder %d:ret %d\n",
6136 			   arvif->vdev_id, arvif->ftm_responder, ret);
6137 	}
6138 
6139 	if (changed & BSS_CHANGED_BEACON_ENABLED)
6140 		ath10k_control_beaconing(arvif, info);
6141 
6142 	if (changed & BSS_CHANGED_ERP_CTS_PROT) {
6143 		arvif->use_cts_prot = info->use_cts_prot;
6144 
6145 		ret = ath10k_recalc_rtscts_prot(arvif);
6146 		if (ret)
6147 			ath10k_warn(ar, "failed to recalculate rts/cts prot for vdev %d: %d\n",
6148 				    arvif->vdev_id, ret);
6149 
6150 		if (ath10k_mac_can_set_cts_prot(arvif)) {
6151 			ret = ath10k_mac_set_cts_prot(arvif);
6152 			if (ret)
6153 				ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",
6154 					    arvif->vdev_id, ret);
6155 		}
6156 	}
6157 
6158 	if (changed & BSS_CHANGED_ERP_SLOT) {
6159 		if (info->use_short_slot)
6160 			slottime = WMI_VDEV_SLOT_TIME_SHORT; /* 9us */
6161 
6162 		else
6163 			slottime = WMI_VDEV_SLOT_TIME_LONG; /* 20us */
6164 
6165 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d slot_time %d\n",
6166 			   arvif->vdev_id, slottime);
6167 
6168 		vdev_param = ar->wmi.vdev_param->slot_time;
6169 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6170 						slottime);
6171 		if (ret)
6172 			ath10k_warn(ar, "failed to set erp slot for vdev %d: %i\n",
6173 				    arvif->vdev_id, ret);
6174 	}
6175 
6176 	if (changed & BSS_CHANGED_ERP_PREAMBLE) {
6177 		if (info->use_short_preamble)
6178 			preamble = WMI_VDEV_PREAMBLE_SHORT;
6179 		else
6180 			preamble = WMI_VDEV_PREAMBLE_LONG;
6181 
6182 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6183 			   "mac vdev %d preamble %dn",
6184 			   arvif->vdev_id, preamble);
6185 
6186 		vdev_param = ar->wmi.vdev_param->preamble;
6187 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6188 						preamble);
6189 		if (ret)
6190 			ath10k_warn(ar, "failed to set preamble for vdev %d: %i\n",
6191 				    arvif->vdev_id, ret);
6192 	}
6193 
6194 	if (changed & BSS_CHANGED_ASSOC) {
6195 		if (info->assoc) {
6196 			/* Workaround: Make sure monitor vdev is not running
6197 			 * when associating to prevent some firmware revisions
6198 			 * (e.g. 10.1 and 10.2) from crashing.
6199 			 */
6200 			if (ar->monitor_started)
6201 				ath10k_monitor_stop(ar);
6202 			ath10k_bss_assoc(hw, vif, info);
6203 			ath10k_monitor_recalc(ar);
6204 		} else {
6205 			ath10k_bss_disassoc(hw, vif);
6206 		}
6207 	}
6208 
6209 	if (changed & BSS_CHANGED_TXPOWER) {
6210 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev_id %i txpower %d\n",
6211 			   arvif->vdev_id, info->txpower);
6212 
6213 		arvif->txpower = info->txpower;
6214 		ret = ath10k_mac_txpower_recalc(ar);
6215 		if (ret)
6216 			ath10k_warn(ar, "failed to recalc tx power: %d\n", ret);
6217 	}
6218 
6219 	if (changed & BSS_CHANGED_PS) {
6220 		arvif->ps = vif->bss_conf.ps;
6221 
6222 		ret = ath10k_config_ps(ar);
6223 		if (ret)
6224 			ath10k_warn(ar, "failed to setup ps on vdev %i: %d\n",
6225 				    arvif->vdev_id, ret);
6226 	}
6227 
6228 	if (changed & BSS_CHANGED_MCAST_RATE &&
6229 	    !ath10k_mac_vif_chan(arvif->vif, &def)) {
6230 		band = def.chan->band;
6231 		mcast_rate = vif->bss_conf.mcast_rate[band];
6232 		if (mcast_rate > 0)
6233 			rateidx = mcast_rate - 1;
6234 		else
6235 			rateidx = ffs(vif->bss_conf.basic_rates) - 1;
6236 
6237 		if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
6238 			rateidx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;
6239 
6240 		bitrate = ath10k_wmi_legacy_rates[rateidx].bitrate;
6241 		hw_value = ath10k_wmi_legacy_rates[rateidx].hw_value;
6242 		if (ath10k_mac_bitrate_is_cck(bitrate))
6243 			preamble = WMI_RATE_PREAMBLE_CCK;
6244 		else
6245 			preamble = WMI_RATE_PREAMBLE_OFDM;
6246 
6247 		rate = ATH10K_HW_RATECODE(hw_value, 0, preamble);
6248 
6249 		ath10k_dbg(ar, ATH10K_DBG_MAC,
6250 			   "mac vdev %d mcast_rate %x\n",
6251 			   arvif->vdev_id, rate);
6252 
6253 		vdev_param = ar->wmi.vdev_param->mcast_data_rate;
6254 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
6255 						vdev_param, rate);
6256 		if (ret)
6257 			ath10k_warn(ar,
6258 				    "failed to set mcast rate on vdev %i: %d\n",
6259 				    arvif->vdev_id,  ret);
6260 
6261 		vdev_param = ar->wmi.vdev_param->bcast_data_rate;
6262 		ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
6263 						vdev_param, rate);
6264 		if (ret)
6265 			ath10k_warn(ar,
6266 				    "failed to set bcast rate on vdev %i: %d\n",
6267 				    arvif->vdev_id,  ret);
6268 	}
6269 
6270 	if (changed & BSS_CHANGED_BASIC_RATES &&
6271 	    !ath10k_mac_vif_chan(arvif->vif, &def))
6272 		ath10k_recalculate_mgmt_rate(ar, vif, &def);
6273 
6274 	mutex_unlock(&ar->conf_mutex);
6275 }
6276 
ath10k_mac_op_set_coverage_class(struct ieee80211_hw * hw,s16 value)6277 static void ath10k_mac_op_set_coverage_class(struct ieee80211_hw *hw, s16 value)
6278 {
6279 	struct ath10k *ar = hw->priv;
6280 
6281 	/* This function should never be called if setting the coverage class
6282 	 * is not supported on this hardware.
6283 	 */
6284 	if (!ar->hw_params.hw_ops->set_coverage_class) {
6285 		WARN_ON_ONCE(1);
6286 		return;
6287 	}
6288 	ar->hw_params.hw_ops->set_coverage_class(ar, value);
6289 }
6290 
6291 struct ath10k_mac_tdls_iter_data {
6292 	u32 num_tdls_stations;
6293 	struct ieee80211_vif *curr_vif;
6294 };
6295 
ath10k_mac_tdls_vif_stations_count_iter(void * data,struct ieee80211_sta * sta)6296 static void ath10k_mac_tdls_vif_stations_count_iter(void *data,
6297 						    struct ieee80211_sta *sta)
6298 {
6299 	struct ath10k_mac_tdls_iter_data *iter_data = data;
6300 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
6301 	struct ieee80211_vif *sta_vif = arsta->arvif->vif;
6302 
6303 	if (sta->tdls && sta_vif == iter_data->curr_vif)
6304 		iter_data->num_tdls_stations++;
6305 }
6306 
ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw * hw,struct ieee80211_vif * vif)6307 static int ath10k_mac_tdls_vif_stations_count(struct ieee80211_hw *hw,
6308 					      struct ieee80211_vif *vif)
6309 {
6310 	struct ath10k_mac_tdls_iter_data data = {};
6311 
6312 	data.curr_vif = vif;
6313 
6314 	ieee80211_iterate_stations_atomic(hw,
6315 					  ath10k_mac_tdls_vif_stations_count_iter,
6316 					  &data);
6317 	return data.num_tdls_stations;
6318 }
6319 
ath10k_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_scan_request * hw_req)6320 static int ath10k_hw_scan(struct ieee80211_hw *hw,
6321 			  struct ieee80211_vif *vif,
6322 			  struct ieee80211_scan_request *hw_req)
6323 {
6324 	struct ath10k *ar = hw->priv;
6325 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6326 	struct cfg80211_scan_request *req = &hw_req->req;
6327 	struct wmi_start_scan_arg arg;
6328 	int ret = 0;
6329 	int i;
6330 	u32 scan_timeout;
6331 
6332 	mutex_lock(&ar->conf_mutex);
6333 
6334 	if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {
6335 		ret = -EBUSY;
6336 		goto exit;
6337 	}
6338 
6339 	spin_lock_bh(&ar->data_lock);
6340 	switch (ar->scan.state) {
6341 	case ATH10K_SCAN_IDLE:
6342 		reinit_completion(&ar->scan.started);
6343 		reinit_completion(&ar->scan.completed);
6344 		ar->scan.state = ATH10K_SCAN_STARTING;
6345 		ar->scan.is_roc = false;
6346 		ar->scan.vdev_id = arvif->vdev_id;
6347 		ret = 0;
6348 		break;
6349 	case ATH10K_SCAN_STARTING:
6350 	case ATH10K_SCAN_RUNNING:
6351 	case ATH10K_SCAN_ABORTING:
6352 		ret = -EBUSY;
6353 		break;
6354 	}
6355 	spin_unlock_bh(&ar->data_lock);
6356 
6357 	if (ret)
6358 		goto exit;
6359 
6360 	memset(&arg, 0, sizeof(arg));
6361 	ath10k_wmi_start_scan_init(ar, &arg);
6362 	arg.vdev_id = arvif->vdev_id;
6363 	arg.scan_id = ATH10K_SCAN_ID;
6364 
6365 	if (req->ie_len) {
6366 		arg.ie_len = req->ie_len;
6367 		memcpy(arg.ie, req->ie, arg.ie_len);
6368 	}
6369 
6370 	if (req->n_ssids) {
6371 		arg.n_ssids = req->n_ssids;
6372 		for (i = 0; i < arg.n_ssids; i++) {
6373 			arg.ssids[i].len  = req->ssids[i].ssid_len;
6374 			arg.ssids[i].ssid = req->ssids[i].ssid;
6375 		}
6376 	} else {
6377 		arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
6378 	}
6379 
6380 	if (req->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
6381 		arg.scan_ctrl_flags |=  WMI_SCAN_ADD_SPOOFED_MAC_IN_PROBE_REQ;
6382 		ether_addr_copy(arg.mac_addr.addr, req->mac_addr);
6383 		ether_addr_copy(arg.mac_mask.addr, req->mac_addr_mask);
6384 	}
6385 
6386 	if (req->n_channels) {
6387 		arg.n_channels = req->n_channels;
6388 		for (i = 0; i < arg.n_channels; i++)
6389 			arg.channels[i] = req->channels[i]->center_freq;
6390 	}
6391 
6392 	/* if duration is set, default dwell times will be overwritten */
6393 	if (req->duration) {
6394 		arg.dwell_time_active = req->duration;
6395 		arg.dwell_time_passive = req->duration;
6396 		arg.burst_duration_ms = req->duration;
6397 
6398 		scan_timeout = min_t(u32, arg.max_rest_time *
6399 				(arg.n_channels - 1) + (req->duration +
6400 				ATH10K_SCAN_CHANNEL_SWITCH_WMI_EVT_OVERHEAD) *
6401 				arg.n_channels, arg.max_scan_time);
6402 	} else {
6403 		scan_timeout = arg.max_scan_time;
6404 	}
6405 
6406 	/* Add a 200ms margin to account for event/command processing */
6407 	scan_timeout += 200;
6408 
6409 	ret = ath10k_start_scan(ar, &arg);
6410 	if (ret) {
6411 		ath10k_warn(ar, "failed to start hw scan: %d\n", ret);
6412 		spin_lock_bh(&ar->data_lock);
6413 		ar->scan.state = ATH10K_SCAN_IDLE;
6414 		spin_unlock_bh(&ar->data_lock);
6415 	}
6416 
6417 	ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
6418 				     msecs_to_jiffies(scan_timeout));
6419 
6420 exit:
6421 	mutex_unlock(&ar->conf_mutex);
6422 	return ret;
6423 }
6424 
ath10k_cancel_hw_scan(struct ieee80211_hw * hw,struct ieee80211_vif * vif)6425 static void ath10k_cancel_hw_scan(struct ieee80211_hw *hw,
6426 				  struct ieee80211_vif *vif)
6427 {
6428 	struct ath10k *ar = hw->priv;
6429 
6430 	mutex_lock(&ar->conf_mutex);
6431 	ath10k_scan_abort(ar);
6432 	mutex_unlock(&ar->conf_mutex);
6433 
6434 	cancel_delayed_work_sync(&ar->scan.timeout);
6435 }
6436 
ath10k_set_key_h_def_keyidx(struct ath10k * ar,struct ath10k_vif * arvif,enum set_key_cmd cmd,struct ieee80211_key_conf * key)6437 static void ath10k_set_key_h_def_keyidx(struct ath10k *ar,
6438 					struct ath10k_vif *arvif,
6439 					enum set_key_cmd cmd,
6440 					struct ieee80211_key_conf *key)
6441 {
6442 	u32 vdev_param = arvif->ar->wmi.vdev_param->def_keyid;
6443 	int ret;
6444 
6445 	/* 10.1 firmware branch requires default key index to be set to group
6446 	 * key index after installing it. Otherwise FW/HW Txes corrupted
6447 	 * frames with multi-vif APs. This is not required for main firmware
6448 	 * branch (e.g. 636).
6449 	 *
6450 	 * This is also needed for 636 fw for IBSS-RSN to work more reliably.
6451 	 *
6452 	 * FIXME: It remains unknown if this is required for multi-vif STA
6453 	 * interfaces on 10.1.
6454 	 */
6455 
6456 	if (arvif->vdev_type != WMI_VDEV_TYPE_AP &&
6457 	    arvif->vdev_type != WMI_VDEV_TYPE_IBSS)
6458 		return;
6459 
6460 	if (key->cipher == WLAN_CIPHER_SUITE_WEP40)
6461 		return;
6462 
6463 	if (key->cipher == WLAN_CIPHER_SUITE_WEP104)
6464 		return;
6465 
6466 	if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
6467 		return;
6468 
6469 	if (cmd != SET_KEY)
6470 		return;
6471 
6472 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param,
6473 					key->keyidx);
6474 	if (ret)
6475 		ath10k_warn(ar, "failed to set vdev %i group key as default key: %d\n",
6476 			    arvif->vdev_id, ret);
6477 }
6478 
ath10k_set_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key)6479 static int ath10k_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
6480 			  struct ieee80211_vif *vif, struct ieee80211_sta *sta,
6481 			  struct ieee80211_key_conf *key)
6482 {
6483 	struct ath10k *ar = hw->priv;
6484 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6485 	struct ath10k_sta *arsta;
6486 	struct ath10k_peer *peer;
6487 	const u8 *peer_addr;
6488 	bool is_wep = key->cipher == WLAN_CIPHER_SUITE_WEP40 ||
6489 		      key->cipher == WLAN_CIPHER_SUITE_WEP104;
6490 	int ret = 0;
6491 	int ret2;
6492 	u32 flags = 0;
6493 	u32 flags2;
6494 
6495 	/* this one needs to be done in software */
6496 	if (key->cipher == WLAN_CIPHER_SUITE_AES_CMAC ||
6497 	    key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_128 ||
6498 	    key->cipher == WLAN_CIPHER_SUITE_BIP_GMAC_256 ||
6499 	    key->cipher == WLAN_CIPHER_SUITE_BIP_CMAC_256)
6500 		return 1;
6501 
6502 	if (arvif->nohwcrypt)
6503 		return 1;
6504 
6505 	if (key->keyidx > WMI_MAX_KEY_INDEX)
6506 		return -ENOSPC;
6507 
6508 	mutex_lock(&ar->conf_mutex);
6509 
6510 	if (sta) {
6511 		arsta = (struct ath10k_sta *)sta->drv_priv;
6512 		peer_addr = sta->addr;
6513 		spin_lock_bh(&ar->data_lock);
6514 		arsta->ucast_cipher = key->cipher;
6515 		spin_unlock_bh(&ar->data_lock);
6516 	} else if (arvif->vdev_type == WMI_VDEV_TYPE_STA) {
6517 		peer_addr = vif->bss_conf.bssid;
6518 	} else {
6519 		peer_addr = vif->addr;
6520 	}
6521 
6522 	key->hw_key_idx = key->keyidx;
6523 
6524 	if (is_wep) {
6525 		if (cmd == SET_KEY)
6526 			arvif->wep_keys[key->keyidx] = key;
6527 		else
6528 			arvif->wep_keys[key->keyidx] = NULL;
6529 	}
6530 
6531 	/* the peer should not disappear in mid-way (unless FW goes awry) since
6532 	 * we already hold conf_mutex. we just make sure its there now.
6533 	 */
6534 	spin_lock_bh(&ar->data_lock);
6535 	peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
6536 	spin_unlock_bh(&ar->data_lock);
6537 
6538 	if (!peer) {
6539 		if (cmd == SET_KEY) {
6540 			ath10k_warn(ar, "failed to install key for non-existent peer %pM\n",
6541 				    peer_addr);
6542 			ret = -EOPNOTSUPP;
6543 			goto exit;
6544 		} else {
6545 			/* if the peer doesn't exist there is no key to disable anymore */
6546 			goto exit;
6547 		}
6548 	}
6549 
6550 	if (key->flags & IEEE80211_KEY_FLAG_PAIRWISE)
6551 		flags |= WMI_KEY_PAIRWISE;
6552 	else
6553 		flags |= WMI_KEY_GROUP;
6554 
6555 	if (is_wep) {
6556 		if (cmd == DISABLE_KEY)
6557 			ath10k_clear_vdev_key(arvif, key);
6558 
6559 		/* When WEP keys are uploaded it's possible that there are
6560 		 * stations associated already (e.g. when merging) without any
6561 		 * keys. Static WEP needs an explicit per-peer key upload.
6562 		 */
6563 		if (vif->type == NL80211_IFTYPE_ADHOC &&
6564 		    cmd == SET_KEY)
6565 			ath10k_mac_vif_update_wep_key(arvif, key);
6566 
6567 		/* 802.1x never sets the def_wep_key_idx so each set_key()
6568 		 * call changes default tx key.
6569 		 *
6570 		 * Static WEP sets def_wep_key_idx via .set_default_unicast_key
6571 		 * after first set_key().
6572 		 */
6573 		if (cmd == SET_KEY && arvif->def_wep_key_idx == -1)
6574 			flags |= WMI_KEY_TX_USAGE;
6575 	}
6576 
6577 	ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags);
6578 	if (ret) {
6579 		WARN_ON(ret > 0);
6580 		ath10k_warn(ar, "failed to install key for vdev %i peer %pM: %d\n",
6581 			    arvif->vdev_id, peer_addr, ret);
6582 		goto exit;
6583 	}
6584 
6585 	/* mac80211 sets static WEP keys as groupwise while firmware requires
6586 	 * them to be installed twice as both pairwise and groupwise.
6587 	 */
6588 	if (is_wep && !sta && vif->type == NL80211_IFTYPE_STATION) {
6589 		flags2 = flags;
6590 		flags2 &= ~WMI_KEY_GROUP;
6591 		flags2 |= WMI_KEY_PAIRWISE;
6592 
6593 		ret = ath10k_install_key(arvif, key, cmd, peer_addr, flags2);
6594 		if (ret) {
6595 			WARN_ON(ret > 0);
6596 			ath10k_warn(ar, "failed to install (ucast) key for vdev %i peer %pM: %d\n",
6597 				    arvif->vdev_id, peer_addr, ret);
6598 			ret2 = ath10k_install_key(arvif, key, DISABLE_KEY,
6599 						  peer_addr, flags);
6600 			if (ret2) {
6601 				WARN_ON(ret2 > 0);
6602 				ath10k_warn(ar, "failed to disable (mcast) key for vdev %i peer %pM: %d\n",
6603 					    arvif->vdev_id, peer_addr, ret2);
6604 			}
6605 			goto exit;
6606 		}
6607 	}
6608 
6609 	ath10k_set_key_h_def_keyidx(ar, arvif, cmd, key);
6610 
6611 	spin_lock_bh(&ar->data_lock);
6612 	peer = ath10k_peer_find(ar, arvif->vdev_id, peer_addr);
6613 	if (peer && cmd == SET_KEY)
6614 		peer->keys[key->keyidx] = key;
6615 	else if (peer && cmd == DISABLE_KEY)
6616 		peer->keys[key->keyidx] = NULL;
6617 	else if (peer == NULL)
6618 		/* impossible unless FW goes crazy */
6619 		ath10k_warn(ar, "Peer %pM disappeared!\n", peer_addr);
6620 	spin_unlock_bh(&ar->data_lock);
6621 
6622 	if (sta && sta->tdls)
6623 		ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6624 					  ar->wmi.peer_param->authorize, 1);
6625 	else if (sta && cmd == SET_KEY && (key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
6626 		ath10k_wmi_peer_set_param(ar, arvif->vdev_id, peer_addr,
6627 					  ar->wmi.peer_param->authorize, 1);
6628 
6629 exit:
6630 	mutex_unlock(&ar->conf_mutex);
6631 	return ret;
6632 }
6633 
ath10k_set_default_unicast_key(struct ieee80211_hw * hw,struct ieee80211_vif * vif,int keyidx)6634 static void ath10k_set_default_unicast_key(struct ieee80211_hw *hw,
6635 					   struct ieee80211_vif *vif,
6636 					   int keyidx)
6637 {
6638 	struct ath10k *ar = hw->priv;
6639 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6640 	int ret;
6641 
6642 	mutex_lock(&arvif->ar->conf_mutex);
6643 
6644 	if (arvif->ar->state != ATH10K_STATE_ON)
6645 		goto unlock;
6646 
6647 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d set keyidx %d\n",
6648 		   arvif->vdev_id, keyidx);
6649 
6650 	ret = ath10k_wmi_vdev_set_param(arvif->ar,
6651 					arvif->vdev_id,
6652 					arvif->ar->wmi.vdev_param->def_keyid,
6653 					keyidx);
6654 
6655 	if (ret) {
6656 		ath10k_warn(ar, "failed to update wep key index for vdev %d: %d\n",
6657 			    arvif->vdev_id,
6658 			    ret);
6659 		goto unlock;
6660 	}
6661 
6662 	arvif->def_wep_key_idx = keyidx;
6663 
6664 unlock:
6665 	mutex_unlock(&arvif->ar->conf_mutex);
6666 }
6667 
ath10k_sta_rc_update_wk(struct work_struct * wk)6668 static void ath10k_sta_rc_update_wk(struct work_struct *wk)
6669 {
6670 	struct ath10k *ar;
6671 	struct ath10k_vif *arvif;
6672 	struct ath10k_sta *arsta;
6673 	struct ieee80211_sta *sta;
6674 	struct cfg80211_chan_def def;
6675 	enum nl80211_band band;
6676 	const u8 *ht_mcs_mask;
6677 	const u16 *vht_mcs_mask;
6678 	u32 changed, bw, nss, smps;
6679 	int err;
6680 
6681 	arsta = container_of(wk, struct ath10k_sta, update_wk);
6682 	sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
6683 	arvif = arsta->arvif;
6684 	ar = arvif->ar;
6685 
6686 	if (WARN_ON(ath10k_mac_vif_chan(arvif->vif, &def)))
6687 		return;
6688 
6689 	band = def.chan->band;
6690 	ht_mcs_mask = arvif->bitrate_mask.control[band].ht_mcs;
6691 	vht_mcs_mask = arvif->bitrate_mask.control[band].vht_mcs;
6692 
6693 	spin_lock_bh(&ar->data_lock);
6694 
6695 	changed = arsta->changed;
6696 	arsta->changed = 0;
6697 
6698 	bw = arsta->bw;
6699 	nss = arsta->nss;
6700 	smps = arsta->smps;
6701 
6702 	spin_unlock_bh(&ar->data_lock);
6703 
6704 	mutex_lock(&ar->conf_mutex);
6705 
6706 	nss = max_t(u32, 1, nss);
6707 	nss = min(nss, max(ath10k_mac_max_ht_nss(ht_mcs_mask),
6708 			   ath10k_mac_max_vht_nss(vht_mcs_mask)));
6709 
6710 	if (changed & IEEE80211_RC_BW_CHANGED) {
6711 		enum wmi_phy_mode mode;
6712 
6713 		mode = chan_to_phymode(&def);
6714 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM peer bw %d phymode %d\n",
6715 			   sta->addr, bw, mode);
6716 
6717 		err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6718 						ar->wmi.peer_param->phymode, mode);
6719 		if (err) {
6720 			ath10k_warn(ar, "failed to update STA %pM peer phymode %d: %d\n",
6721 				    sta->addr, mode, err);
6722 			goto exit;
6723 		}
6724 
6725 		err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6726 						ar->wmi.peer_param->chan_width, bw);
6727 		if (err)
6728 			ath10k_warn(ar, "failed to update STA %pM peer bw %d: %d\n",
6729 				    sta->addr, bw, err);
6730 	}
6731 
6732 	if (changed & IEEE80211_RC_NSS_CHANGED) {
6733 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM nss %d\n",
6734 			   sta->addr, nss);
6735 
6736 		err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6737 						ar->wmi.peer_param->nss, nss);
6738 		if (err)
6739 			ath10k_warn(ar, "failed to update STA %pM nss %d: %d\n",
6740 				    sta->addr, nss, err);
6741 	}
6742 
6743 	if (changed & IEEE80211_RC_SMPS_CHANGED) {
6744 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM smps %d\n",
6745 			   sta->addr, smps);
6746 
6747 		err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6748 						ar->wmi.peer_param->smps_state, smps);
6749 		if (err)
6750 			ath10k_warn(ar, "failed to update STA %pM smps %d: %d\n",
6751 				    sta->addr, smps, err);
6752 	}
6753 
6754 	if (changed & IEEE80211_RC_SUPP_RATES_CHANGED) {
6755 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac update sta %pM supp rates\n",
6756 			   sta->addr);
6757 
6758 		err = ath10k_station_assoc(ar, arvif->vif, sta, true);
6759 		if (err)
6760 			ath10k_warn(ar, "failed to reassociate station: %pM\n",
6761 				    sta->addr);
6762 	}
6763 
6764 exit:
6765 	mutex_unlock(&ar->conf_mutex);
6766 }
6767 
ath10k_mac_inc_num_stations(struct ath10k_vif * arvif,struct ieee80211_sta * sta)6768 static int ath10k_mac_inc_num_stations(struct ath10k_vif *arvif,
6769 				       struct ieee80211_sta *sta)
6770 {
6771 	struct ath10k *ar = arvif->ar;
6772 
6773 	lockdep_assert_held(&ar->conf_mutex);
6774 
6775 	if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
6776 		return 0;
6777 
6778 	if (ar->num_stations >= ar->max_num_stations)
6779 		return -ENOBUFS;
6780 
6781 	ar->num_stations++;
6782 
6783 	return 0;
6784 }
6785 
ath10k_mac_dec_num_stations(struct ath10k_vif * arvif,struct ieee80211_sta * sta)6786 static void ath10k_mac_dec_num_stations(struct ath10k_vif *arvif,
6787 					struct ieee80211_sta *sta)
6788 {
6789 	struct ath10k *ar = arvif->ar;
6790 
6791 	lockdep_assert_held(&ar->conf_mutex);
6792 
6793 	if (arvif->vdev_type == WMI_VDEV_TYPE_STA && !sta->tdls)
6794 		return;
6795 
6796 	ar->num_stations--;
6797 }
6798 
ath10k_sta_set_txpwr(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)6799 static int ath10k_sta_set_txpwr(struct ieee80211_hw *hw,
6800 				struct ieee80211_vif *vif,
6801 				struct ieee80211_sta *sta)
6802 {
6803 	struct ath10k *ar = hw->priv;
6804 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
6805 	int ret = 0;
6806 	s16 txpwr;
6807 
6808 	if (sta->deflink.txpwr.type == NL80211_TX_POWER_AUTOMATIC) {
6809 		txpwr = 0;
6810 	} else {
6811 		txpwr = sta->deflink.txpwr.power;
6812 		if (!txpwr)
6813 			return -EINVAL;
6814 	}
6815 
6816 	if (txpwr > ATH10K_TX_POWER_MAX_VAL || txpwr < ATH10K_TX_POWER_MIN_VAL)
6817 		return -EINVAL;
6818 
6819 	mutex_lock(&ar->conf_mutex);
6820 
6821 	ret = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
6822 					ar->wmi.peer_param->use_fixed_power, txpwr);
6823 	if (ret) {
6824 		ath10k_warn(ar, "failed to set tx power for station ret: %d\n",
6825 			    ret);
6826 		goto out;
6827 	}
6828 
6829 out:
6830 	mutex_unlock(&ar->conf_mutex);
6831 	return ret;
6832 }
6833 
6834 struct ath10k_mac_iter_tid_conf_data {
6835 	struct ieee80211_vif *curr_vif;
6836 	struct ath10k *ar;
6837 	bool reset_config;
6838 };
6839 
6840 static bool
ath10k_mac_bitrate_mask_has_single_rate(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,int * vht_num_rates)6841 ath10k_mac_bitrate_mask_has_single_rate(struct ath10k *ar,
6842 					enum nl80211_band band,
6843 					const struct cfg80211_bitrate_mask *mask,
6844 					int *vht_num_rates)
6845 {
6846 	int num_rates = 0;
6847 	int i, tmp;
6848 
6849 	num_rates += hweight32(mask->control[band].legacy);
6850 
6851 	for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++)
6852 		num_rates += hweight8(mask->control[band].ht_mcs[i]);
6853 
6854 	*vht_num_rates = 0;
6855 	for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6856 		tmp = hweight16(mask->control[band].vht_mcs[i]);
6857 		num_rates += tmp;
6858 		*vht_num_rates += tmp;
6859 	}
6860 
6861 	return num_rates == 1;
6862 }
6863 
6864 static int
ath10k_mac_bitrate_mask_get_single_rate(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,u8 * rate,u8 * nss,bool vht_only)6865 ath10k_mac_bitrate_mask_get_single_rate(struct ath10k *ar,
6866 					enum nl80211_band band,
6867 					const struct cfg80211_bitrate_mask *mask,
6868 					u8 *rate, u8 *nss, bool vht_only)
6869 {
6870 	int rate_idx;
6871 	int i;
6872 	u16 bitrate;
6873 	u8 preamble;
6874 	u8 hw_rate;
6875 
6876 	if (vht_only)
6877 		goto next;
6878 
6879 	if (hweight32(mask->control[band].legacy) == 1) {
6880 		rate_idx = ffs(mask->control[band].legacy) - 1;
6881 
6882 		if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY)
6883 			rate_idx += ATH10K_MAC_FIRST_OFDM_RATE_IDX;
6884 
6885 		hw_rate = ath10k_wmi_legacy_rates[rate_idx].hw_value;
6886 		bitrate = ath10k_wmi_legacy_rates[rate_idx].bitrate;
6887 
6888 		if (ath10k_mac_bitrate_is_cck(bitrate))
6889 			preamble = WMI_RATE_PREAMBLE_CCK;
6890 		else
6891 			preamble = WMI_RATE_PREAMBLE_OFDM;
6892 
6893 		*nss = 1;
6894 		*rate = preamble << 6 |
6895 			(*nss - 1) << 4 |
6896 			hw_rate << 0;
6897 
6898 		return 0;
6899 	}
6900 
6901 	for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
6902 		if (hweight8(mask->control[band].ht_mcs[i]) == 1) {
6903 			*nss = i + 1;
6904 			*rate = WMI_RATE_PREAMBLE_HT << 6 |
6905 				(*nss - 1) << 4 |
6906 				(ffs(mask->control[band].ht_mcs[i]) - 1);
6907 
6908 			return 0;
6909 		}
6910 	}
6911 
6912 next:
6913 	for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
6914 		if (hweight16(mask->control[band].vht_mcs[i]) == 1) {
6915 			*nss = i + 1;
6916 			*rate = WMI_RATE_PREAMBLE_VHT << 6 |
6917 				(*nss - 1) << 4 |
6918 				(ffs(mask->control[band].vht_mcs[i]) - 1);
6919 
6920 			return 0;
6921 		}
6922 	}
6923 
6924 	return -EINVAL;
6925 }
6926 
ath10k_mac_validate_rate_mask(struct ath10k * ar,struct ieee80211_sta * sta,u32 rate_ctrl_flag,u8 nss)6927 static int ath10k_mac_validate_rate_mask(struct ath10k *ar,
6928 					 struct ieee80211_sta *sta,
6929 					 u32 rate_ctrl_flag, u8 nss)
6930 {
6931 	struct ieee80211_sta_ht_cap *ht_cap = &sta->deflink.ht_cap;
6932 	struct ieee80211_sta_vht_cap *vht_cap = &sta->deflink.vht_cap;
6933 
6934 	if (nss > sta->deflink.rx_nss) {
6935 		ath10k_warn(ar, "Invalid nss field, configured %u limit %u\n",
6936 			    nss, sta->deflink.rx_nss);
6937 		return -EINVAL;
6938 	}
6939 
6940 	if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_VHT) {
6941 		if (!vht_cap->vht_supported) {
6942 			ath10k_warn(ar, "Invalid VHT rate for sta %pM\n",
6943 				    sta->addr);
6944 			return -EINVAL;
6945 		}
6946 	} else if (ATH10K_HW_PREAMBLE(rate_ctrl_flag) == WMI_RATE_PREAMBLE_HT) {
6947 		if (!ht_cap->ht_supported || vht_cap->vht_supported) {
6948 			ath10k_warn(ar, "Invalid HT rate for sta %pM\n",
6949 				    sta->addr);
6950 			return -EINVAL;
6951 		}
6952 	} else {
6953 		if (ht_cap->ht_supported || vht_cap->vht_supported)
6954 			return -EINVAL;
6955 	}
6956 
6957 	return 0;
6958 }
6959 
6960 static int
ath10k_mac_tid_bitrate_config(struct ath10k * ar,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 * rate_ctrl_flag,u8 * rate_ctrl,enum nl80211_tx_rate_setting txrate_type,const struct cfg80211_bitrate_mask * mask)6961 ath10k_mac_tid_bitrate_config(struct ath10k *ar,
6962 			      struct ieee80211_vif *vif,
6963 			      struct ieee80211_sta *sta,
6964 			      u32 *rate_ctrl_flag, u8 *rate_ctrl,
6965 			      enum nl80211_tx_rate_setting txrate_type,
6966 			      const struct cfg80211_bitrate_mask *mask)
6967 {
6968 	struct cfg80211_chan_def def;
6969 	enum nl80211_band band;
6970 	u8 nss, rate;
6971 	int vht_num_rates, ret;
6972 
6973 	if (WARN_ON(ath10k_mac_vif_chan(vif, &def)))
6974 		return -EINVAL;
6975 
6976 	if (txrate_type == NL80211_TX_RATE_AUTOMATIC) {
6977 		*rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;
6978 		*rate_ctrl_flag = 0;
6979 		return 0;
6980 	}
6981 
6982 	band = def.chan->band;
6983 
6984 	if (!ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,
6985 						     &vht_num_rates)) {
6986 		return -EINVAL;
6987 	}
6988 
6989 	ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
6990 						      &rate, &nss, false);
6991 	if (ret) {
6992 		ath10k_warn(ar, "failed to get single rate: %d\n",
6993 			    ret);
6994 		return ret;
6995 	}
6996 
6997 	*rate_ctrl_flag = rate;
6998 
6999 	if (sta && ath10k_mac_validate_rate_mask(ar, sta, *rate_ctrl_flag, nss))
7000 		return -EINVAL;
7001 
7002 	if (txrate_type == NL80211_TX_RATE_FIXED)
7003 		*rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_FIXED_RATE;
7004 	else if (txrate_type == NL80211_TX_RATE_LIMITED &&
7005 		 (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,
7006 			   ar->wmi.svc_map)))
7007 		*rate_ctrl = WMI_PEER_TID_CONFIG_RATE_UPPER_CAP;
7008 	else
7009 		return -EOPNOTSUPP;
7010 
7011 	return 0;
7012 }
7013 
ath10k_mac_set_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ieee80211_vif * vif,u32 changed,struct wmi_per_peer_per_tid_cfg_arg * arg)7014 static int ath10k_mac_set_tid_config(struct ath10k *ar, struct ieee80211_sta *sta,
7015 				     struct ieee80211_vif *vif, u32 changed,
7016 				     struct wmi_per_peer_per_tid_cfg_arg *arg)
7017 {
7018 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
7019 	struct ath10k_sta *arsta;
7020 	int ret;
7021 
7022 	if (sta) {
7023 		if (!sta->wme)
7024 			return -ENOTSUPP;
7025 
7026 		arsta = (struct ath10k_sta *)sta->drv_priv;
7027 
7028 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7029 			if ((arsta->retry_long[arg->tid] > 0 ||
7030 			     arsta->rate_code[arg->tid] > 0 ||
7031 			     arsta->ampdu[arg->tid] ==
7032 					WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&
7033 			     arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {
7034 				changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);
7035 				arg->ack_policy = 0;
7036 				arg->aggr_control = 0;
7037 				arg->rate_ctrl = 0;
7038 				arg->rcode_flags = 0;
7039 			}
7040 		}
7041 
7042 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7043 			if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||
7044 			    arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7045 				arg->aggr_control = 0;
7046 				changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
7047 			}
7048 		}
7049 
7050 		if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7051 		    BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7052 			if (arsta->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK ||
7053 			    arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7054 				arg->rate_ctrl = 0;
7055 				arg->rcode_flags = 0;
7056 			}
7057 		}
7058 
7059 		ether_addr_copy(arg->peer_macaddr.addr, sta->addr);
7060 
7061 		ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, arg);
7062 		if (ret)
7063 			return ret;
7064 
7065 		/* Store the configured parameters in success case */
7066 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7067 			arsta->noack[arg->tid] = arg->ack_policy;
7068 			arg->ack_policy = 0;
7069 			arg->aggr_control = 0;
7070 			arg->rate_ctrl = 0;
7071 			arg->rcode_flags = 0;
7072 		}
7073 
7074 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7075 			arsta->retry_long[arg->tid] = arg->retry_count;
7076 			arg->retry_count = 0;
7077 		}
7078 
7079 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7080 			arsta->ampdu[arg->tid] = arg->aggr_control;
7081 			arg->aggr_control = 0;
7082 		}
7083 
7084 		if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7085 		    BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7086 			arsta->rate_ctrl[arg->tid] = arg->rate_ctrl;
7087 			arg->rate_ctrl = 0;
7088 			arg->rcode_flags = 0;
7089 		}
7090 
7091 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7092 			arsta->rtscts[arg->tid] = arg->rtscts_ctrl;
7093 			arg->ext_tid_cfg_bitmap = 0;
7094 		}
7095 	} else {
7096 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7097 			if ((arvif->retry_long[arg->tid] ||
7098 			     arvif->rate_code[arg->tid] ||
7099 			     arvif->ampdu[arg->tid] ==
7100 					WMI_TID_CONFIG_AGGR_CONTROL_ENABLE) &&
7101 			     arg->ack_policy == WMI_PEER_TID_CONFIG_NOACK) {
7102 				changed &= ~BIT(NL80211_TID_CONFIG_ATTR_NOACK);
7103 			} else {
7104 				arvif->noack[arg->tid] = arg->ack_policy;
7105 				arvif->ampdu[arg->tid] = arg->aggr_control;
7106 				arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;
7107 			}
7108 		}
7109 
7110 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7111 			if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)
7112 				changed &= ~BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG);
7113 			else
7114 				arvif->retry_long[arg->tid] = arg->retry_count;
7115 		}
7116 
7117 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7118 			if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK)
7119 				changed &= ~BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL);
7120 			else
7121 				arvif->ampdu[arg->tid] = arg->aggr_control;
7122 		}
7123 
7124 		if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7125 		    BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7126 			if (arvif->noack[arg->tid] == WMI_PEER_TID_CONFIG_NOACK) {
7127 				changed &= ~(BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7128 					     BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE));
7129 			} else {
7130 				arvif->rate_ctrl[arg->tid] = arg->rate_ctrl;
7131 				arvif->rate_code[arg->tid] = arg->rcode_flags;
7132 			}
7133 		}
7134 
7135 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7136 			arvif->rtscts[arg->tid] = arg->rtscts_ctrl;
7137 			arg->ext_tid_cfg_bitmap = 0;
7138 		}
7139 
7140 		if (changed)
7141 			arvif->tid_conf_changed[arg->tid] |= changed;
7142 	}
7143 
7144 	return 0;
7145 }
7146 
7147 static int
ath10k_mac_parse_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ieee80211_vif * vif,struct cfg80211_tid_cfg * tid_conf,struct wmi_per_peer_per_tid_cfg_arg * arg)7148 ath10k_mac_parse_tid_config(struct ath10k *ar,
7149 			    struct ieee80211_sta *sta,
7150 			    struct ieee80211_vif *vif,
7151 			    struct cfg80211_tid_cfg *tid_conf,
7152 			    struct wmi_per_peer_per_tid_cfg_arg *arg)
7153 {
7154 	u32 changed = tid_conf->mask;
7155 	int ret = 0, i = 0;
7156 
7157 	if (!changed)
7158 		return -EINVAL;
7159 
7160 	while (i < ATH10K_TID_MAX) {
7161 		if (!(tid_conf->tids & BIT(i))) {
7162 			i++;
7163 			continue;
7164 		}
7165 
7166 		arg->tid = i;
7167 
7168 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7169 			if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE) {
7170 				arg->ack_policy = WMI_PEER_TID_CONFIG_NOACK;
7171 				arg->rate_ctrl =
7172 				WMI_TID_CONFIG_RATE_CONTROL_DEFAULT_LOWEST_RATE;
7173 				arg->aggr_control =
7174 					WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
7175 			} else {
7176 				arg->ack_policy =
7177 					WMI_PEER_TID_CONFIG_ACK;
7178 				arg->rate_ctrl =
7179 					WMI_TID_CONFIG_RATE_CONTROL_AUTO;
7180 				arg->aggr_control =
7181 					WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7182 			}
7183 		}
7184 
7185 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG))
7186 			arg->retry_count = tid_conf->retry_long;
7187 
7188 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7189 			if (tid_conf->noack == NL80211_TID_CONFIG_ENABLE)
7190 				arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7191 			else
7192 				arg->aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_DISABLE;
7193 		}
7194 
7195 		if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7196 		    BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7197 			ret = ath10k_mac_tid_bitrate_config(ar, vif, sta,
7198 							    &arg->rcode_flags,
7199 							    &arg->rate_ctrl,
7200 							    tid_conf->txrate_type,
7201 							&tid_conf->txrate_mask);
7202 			if (ret) {
7203 				ath10k_warn(ar, "failed to configure bitrate mask %d\n",
7204 					    ret);
7205 				arg->rcode_flags = 0;
7206 				arg->rate_ctrl = 0;
7207 			}
7208 		}
7209 
7210 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7211 			if (tid_conf->rtscts)
7212 				arg->rtscts_ctrl = tid_conf->rtscts;
7213 
7214 			arg->ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;
7215 		}
7216 
7217 		ret = ath10k_mac_set_tid_config(ar, sta, vif, changed, arg);
7218 		if (ret)
7219 			return ret;
7220 		i++;
7221 	}
7222 
7223 	return ret;
7224 }
7225 
ath10k_mac_reset_tid_config(struct ath10k * ar,struct ieee80211_sta * sta,struct ath10k_vif * arvif,u8 tids)7226 static int ath10k_mac_reset_tid_config(struct ath10k *ar,
7227 				       struct ieee80211_sta *sta,
7228 				       struct ath10k_vif *arvif,
7229 				       u8 tids)
7230 {
7231 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7232 	struct wmi_per_peer_per_tid_cfg_arg arg;
7233 	int ret = 0, i = 0;
7234 
7235 	arg.vdev_id = arvif->vdev_id;
7236 	while (i < ATH10K_TID_MAX) {
7237 		if (!(tids & BIT(i))) {
7238 			i++;
7239 			continue;
7240 		}
7241 
7242 		arg.tid = i;
7243 		arg.ack_policy = WMI_PEER_TID_CONFIG_ACK;
7244 		arg.retry_count = ATH10K_MAX_RETRY_COUNT;
7245 		arg.rate_ctrl = WMI_TID_CONFIG_RATE_CONTROL_AUTO;
7246 		arg.aggr_control = WMI_TID_CONFIG_AGGR_CONTROL_ENABLE;
7247 		arg.rtscts_ctrl = WMI_TID_CONFIG_RTSCTS_CONTROL_ENABLE;
7248 		arg.ext_tid_cfg_bitmap = WMI_EXT_TID_RTS_CTS_CONFIG;
7249 
7250 		ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
7251 
7252 		ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
7253 		if (ret)
7254 			return ret;
7255 
7256 		if (!arvif->tids_rst) {
7257 			arsta->retry_long[i] = -1;
7258 			arsta->noack[i] = -1;
7259 			arsta->ampdu[i] = -1;
7260 			arsta->rate_code[i] = -1;
7261 			arsta->rate_ctrl[i] = 0;
7262 			arsta->rtscts[i] = -1;
7263 		} else {
7264 			arvif->retry_long[i] = 0;
7265 			arvif->noack[i] = 0;
7266 			arvif->ampdu[i] = 0;
7267 			arvif->rate_code[i] = 0;
7268 			arvif->rate_ctrl[i] = 0;
7269 			arvif->rtscts[i] = 0;
7270 		}
7271 
7272 		i++;
7273 	}
7274 
7275 	return ret;
7276 }
7277 
ath10k_sta_tid_cfg_wk(struct work_struct * wk)7278 static void ath10k_sta_tid_cfg_wk(struct work_struct *wk)
7279 {
7280 	struct wmi_per_peer_per_tid_cfg_arg arg = {};
7281 	struct ieee80211_sta *sta;
7282 	struct ath10k_sta *arsta;
7283 	struct ath10k_vif *arvif;
7284 	struct ath10k *ar;
7285 	bool config_apply;
7286 	int ret, i;
7287 	u32 changed;
7288 	u8 nss;
7289 
7290 	arsta = container_of(wk, struct ath10k_sta, tid_config_wk);
7291 	sta = container_of((void *)arsta, struct ieee80211_sta, drv_priv);
7292 	arvif = arsta->arvif;
7293 	ar = arvif->ar;
7294 
7295 	mutex_lock(&ar->conf_mutex);
7296 
7297 	if (arvif->tids_rst) {
7298 		ret = ath10k_mac_reset_tid_config(ar, sta, arvif,
7299 						  arvif->tids_rst);
7300 		goto exit;
7301 	}
7302 
7303 	ether_addr_copy(arg.peer_macaddr.addr, sta->addr);
7304 
7305 	for (i = 0; i < ATH10K_TID_MAX; i++) {
7306 		config_apply = false;
7307 		changed = arvif->tid_conf_changed[i];
7308 
7309 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_NOACK)) {
7310 			if (arsta->noack[i] != -1) {
7311 				arg.ack_policy  = 0;
7312 			} else {
7313 				config_apply = true;
7314 				arg.ack_policy = arvif->noack[i];
7315 				arg.aggr_control = arvif->ampdu[i];
7316 				arg.rate_ctrl = arvif->rate_ctrl[i];
7317 			}
7318 		}
7319 
7320 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG)) {
7321 			if (arsta->retry_long[i] != -1 ||
7322 			    arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7323 			    arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7324 				arg.retry_count = 0;
7325 			} else {
7326 				arg.retry_count = arvif->retry_long[i];
7327 				config_apply = true;
7328 			}
7329 		}
7330 
7331 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL)) {
7332 			if (arsta->ampdu[i] != -1 ||
7333 			    arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7334 			    arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7335 				arg.aggr_control = 0;
7336 			} else {
7337 				arg.aggr_control = arvif->ampdu[i];
7338 				config_apply = true;
7339 			}
7340 		}
7341 
7342 		if (changed & (BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
7343 		    BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE))) {
7344 			nss = ATH10K_HW_NSS(arvif->rate_code[i]);
7345 			ret = ath10k_mac_validate_rate_mask(ar, sta,
7346 							    arvif->rate_code[i],
7347 							    nss);
7348 			if (ret &&
7349 			    arvif->rate_ctrl[i] > WMI_TID_CONFIG_RATE_CONTROL_AUTO) {
7350 				arg.rate_ctrl = 0;
7351 				arg.rcode_flags = 0;
7352 			}
7353 
7354 			if (arsta->rate_ctrl[i] >
7355 			    WMI_TID_CONFIG_RATE_CONTROL_AUTO ||
7356 			    arsta->noack[i] == WMI_PEER_TID_CONFIG_NOACK ||
7357 			    arvif->noack[i] == WMI_PEER_TID_CONFIG_NOACK) {
7358 				arg.rate_ctrl = 0;
7359 				arg.rcode_flags = 0;
7360 			} else {
7361 				arg.rate_ctrl = arvif->rate_ctrl[i];
7362 				arg.rcode_flags = arvif->rate_code[i];
7363 				config_apply = true;
7364 			}
7365 		}
7366 
7367 		if (changed & BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL)) {
7368 			if (arsta->rtscts[i]) {
7369 				arg.rtscts_ctrl = 0;
7370 				arg.ext_tid_cfg_bitmap = 0;
7371 			} else {
7372 				arg.rtscts_ctrl = arvif->rtscts[i] - 1;
7373 				arg.ext_tid_cfg_bitmap =
7374 					WMI_EXT_TID_RTS_CTS_CONFIG;
7375 				config_apply = true;
7376 			}
7377 		}
7378 
7379 		arg.tid = i;
7380 
7381 		if (config_apply) {
7382 			ret = ath10k_wmi_set_per_peer_per_tid_cfg(ar, &arg);
7383 			if (ret)
7384 				ath10k_warn(ar, "failed to set per tid config for sta %pM: %d\n",
7385 					    sta->addr, ret);
7386 		}
7387 
7388 		arg.ack_policy  = 0;
7389 		arg.retry_count  = 0;
7390 		arg.aggr_control  = 0;
7391 		arg.rate_ctrl = 0;
7392 		arg.rcode_flags = 0;
7393 	}
7394 
7395 exit:
7396 	mutex_unlock(&ar->conf_mutex);
7397 }
7398 
ath10k_mac_vif_stations_tid_conf(void * data,struct ieee80211_sta * sta)7399 static void ath10k_mac_vif_stations_tid_conf(void *data,
7400 					     struct ieee80211_sta *sta)
7401 {
7402 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7403 	struct ath10k_mac_iter_tid_conf_data *iter_data = data;
7404 	struct ieee80211_vif *sta_vif = arsta->arvif->vif;
7405 
7406 	if (sta_vif != iter_data->curr_vif || !sta->wme)
7407 		return;
7408 
7409 	ieee80211_queue_work(iter_data->ar->hw, &arsta->tid_config_wk);
7410 }
7411 
ath10k_sta_state(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,enum ieee80211_sta_state old_state,enum ieee80211_sta_state new_state)7412 static int ath10k_sta_state(struct ieee80211_hw *hw,
7413 			    struct ieee80211_vif *vif,
7414 			    struct ieee80211_sta *sta,
7415 			    enum ieee80211_sta_state old_state,
7416 			    enum ieee80211_sta_state new_state)
7417 {
7418 	struct ath10k *ar = hw->priv;
7419 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
7420 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
7421 	struct ath10k_peer *peer;
7422 	int ret = 0;
7423 	int i;
7424 
7425 	if (old_state == IEEE80211_STA_NOTEXIST &&
7426 	    new_state == IEEE80211_STA_NONE) {
7427 		memset(arsta, 0, sizeof(*arsta));
7428 		arsta->arvif = arvif;
7429 		arsta->peer_ps_state = WMI_PEER_PS_STATE_DISABLED;
7430 		INIT_WORK(&arsta->update_wk, ath10k_sta_rc_update_wk);
7431 		INIT_WORK(&arsta->tid_config_wk, ath10k_sta_tid_cfg_wk);
7432 
7433 		for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
7434 			ath10k_mac_txq_init(sta->txq[i]);
7435 	}
7436 
7437 	/* cancel must be done outside the mutex to avoid deadlock */
7438 	if ((old_state == IEEE80211_STA_NONE &&
7439 	     new_state == IEEE80211_STA_NOTEXIST)) {
7440 		cancel_work_sync(&arsta->update_wk);
7441 		cancel_work_sync(&arsta->tid_config_wk);
7442 	}
7443 
7444 	mutex_lock(&ar->conf_mutex);
7445 
7446 	if (old_state == IEEE80211_STA_NOTEXIST &&
7447 	    new_state == IEEE80211_STA_NONE) {
7448 		/*
7449 		 * New station addition.
7450 		 */
7451 		enum wmi_peer_type peer_type = WMI_PEER_TYPE_DEFAULT;
7452 		u32 num_tdls_stations;
7453 
7454 		ath10k_dbg(ar, ATH10K_DBG_STA,
7455 			   "mac vdev %d peer create %pM (new sta) sta %d / %d peer %d / %d\n",
7456 			   arvif->vdev_id, sta->addr,
7457 			   ar->num_stations + 1, ar->max_num_stations,
7458 			   ar->num_peers + 1, ar->max_num_peers);
7459 
7460 		num_tdls_stations = ath10k_mac_tdls_vif_stations_count(hw, vif);
7461 
7462 		if (sta->tdls) {
7463 			if (num_tdls_stations >= ar->max_num_tdls_vdevs) {
7464 				ath10k_warn(ar, "vdev %i exceeded maximum number of tdls vdevs %i\n",
7465 					    arvif->vdev_id,
7466 					    ar->max_num_tdls_vdevs);
7467 				ret = -ELNRNG;
7468 				goto exit;
7469 			}
7470 			peer_type = WMI_PEER_TYPE_TDLS;
7471 		}
7472 
7473 		ret = ath10k_mac_inc_num_stations(arvif, sta);
7474 		if (ret) {
7475 			ath10k_warn(ar, "refusing to associate station: too many connected already (%d)\n",
7476 				    ar->max_num_stations);
7477 			goto exit;
7478 		}
7479 
7480 		if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {
7481 			arsta->tx_stats = kzalloc(sizeof(*arsta->tx_stats),
7482 						  GFP_KERNEL);
7483 			if (!arsta->tx_stats) {
7484 				ath10k_mac_dec_num_stations(arvif, sta);
7485 				ret = -ENOMEM;
7486 				goto exit;
7487 			}
7488 		}
7489 
7490 		ret = ath10k_peer_create(ar, vif, sta, arvif->vdev_id,
7491 					 sta->addr, peer_type);
7492 		if (ret) {
7493 			ath10k_warn(ar, "failed to add peer %pM for vdev %d when adding a new sta: %i\n",
7494 				    sta->addr, arvif->vdev_id, ret);
7495 			ath10k_mac_dec_num_stations(arvif, sta);
7496 			kfree(arsta->tx_stats);
7497 			goto exit;
7498 		}
7499 
7500 		spin_lock_bh(&ar->data_lock);
7501 
7502 		peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
7503 		if (!peer) {
7504 			ath10k_warn(ar, "failed to lookup peer %pM on vdev %i\n",
7505 				    vif->addr, arvif->vdev_id);
7506 			spin_unlock_bh(&ar->data_lock);
7507 			ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7508 			ath10k_mac_dec_num_stations(arvif, sta);
7509 			kfree(arsta->tx_stats);
7510 			ret = -ENOENT;
7511 			goto exit;
7512 		}
7513 
7514 		arsta->peer_id = find_first_bit(peer->peer_ids,
7515 						ATH10K_MAX_NUM_PEER_IDS);
7516 
7517 		spin_unlock_bh(&ar->data_lock);
7518 
7519 		if (!sta->tdls)
7520 			goto exit;
7521 
7522 		ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7523 						      WMI_TDLS_ENABLE_ACTIVE);
7524 		if (ret) {
7525 			ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
7526 				    arvif->vdev_id, ret);
7527 			ath10k_peer_delete(ar, arvif->vdev_id,
7528 					   sta->addr);
7529 			ath10k_mac_dec_num_stations(arvif, sta);
7530 			kfree(arsta->tx_stats);
7531 			goto exit;
7532 		}
7533 
7534 		ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
7535 						  WMI_TDLS_PEER_STATE_PEERING);
7536 		if (ret) {
7537 			ath10k_warn(ar,
7538 				    "failed to update tdls peer %pM for vdev %d when adding a new sta: %i\n",
7539 				    sta->addr, arvif->vdev_id, ret);
7540 			ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7541 			ath10k_mac_dec_num_stations(arvif, sta);
7542 			kfree(arsta->tx_stats);
7543 
7544 			if (num_tdls_stations != 0)
7545 				goto exit;
7546 			ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7547 							WMI_TDLS_DISABLE);
7548 		}
7549 	} else if ((old_state == IEEE80211_STA_NONE &&
7550 		    new_state == IEEE80211_STA_NOTEXIST)) {
7551 		/*
7552 		 * Existing station deletion.
7553 		 */
7554 		ath10k_dbg(ar, ATH10K_DBG_STA,
7555 			   "mac vdev %d peer delete %pM sta %pK (sta gone)\n",
7556 			   arvif->vdev_id, sta->addr, sta);
7557 
7558 		if (sta->tdls) {
7559 			ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id,
7560 							  sta,
7561 							  WMI_TDLS_PEER_STATE_TEARDOWN);
7562 			if (ret)
7563 				ath10k_warn(ar, "failed to update tdls peer state for %pM state %d: %i\n",
7564 					    sta->addr,
7565 					    WMI_TDLS_PEER_STATE_TEARDOWN, ret);
7566 		}
7567 
7568 		ret = ath10k_peer_delete(ar, arvif->vdev_id, sta->addr);
7569 		if (ret)
7570 			ath10k_warn(ar, "failed to delete peer %pM for vdev %d: %i\n",
7571 				    sta->addr, arvif->vdev_id, ret);
7572 
7573 		ath10k_mac_dec_num_stations(arvif, sta);
7574 
7575 		spin_lock_bh(&ar->data_lock);
7576 		for (i = 0; i < ARRAY_SIZE(ar->peer_map); i++) {
7577 			peer = ar->peer_map[i];
7578 			if (!peer)
7579 				continue;
7580 
7581 			if (peer->sta == sta) {
7582 				ath10k_warn(ar, "found sta peer %pM (ptr %pK id %d) entry on vdev %i after it was supposedly removed\n",
7583 					    sta->addr, peer, i, arvif->vdev_id);
7584 				peer->sta = NULL;
7585 
7586 				/* Clean up the peer object as well since we
7587 				 * must have failed to do this above.
7588 				 */
7589 				list_del(&peer->list);
7590 				ar->peer_map[i] = NULL;
7591 				kfree(peer);
7592 				ar->num_peers--;
7593 			}
7594 		}
7595 		spin_unlock_bh(&ar->data_lock);
7596 
7597 		if (ath10k_debug_is_extd_tx_stats_enabled(ar)) {
7598 			kfree(arsta->tx_stats);
7599 			arsta->tx_stats = NULL;
7600 		}
7601 
7602 		for (i = 0; i < ARRAY_SIZE(sta->txq); i++)
7603 			ath10k_mac_txq_unref(ar, sta->txq[i]);
7604 
7605 		if (!sta->tdls)
7606 			goto exit;
7607 
7608 		if (ath10k_mac_tdls_vif_stations_count(hw, vif))
7609 			goto exit;
7610 
7611 		/* This was the last tdls peer in current vif */
7612 		ret = ath10k_wmi_update_fw_tdls_state(ar, arvif->vdev_id,
7613 						      WMI_TDLS_DISABLE);
7614 		if (ret) {
7615 			ath10k_warn(ar, "failed to update fw tdls state on vdev %i: %i\n",
7616 				    arvif->vdev_id, ret);
7617 		}
7618 	} else if (old_state == IEEE80211_STA_AUTH &&
7619 		   new_state == IEEE80211_STA_ASSOC &&
7620 		   (vif->type == NL80211_IFTYPE_AP ||
7621 		    vif->type == NL80211_IFTYPE_MESH_POINT ||
7622 		    vif->type == NL80211_IFTYPE_ADHOC)) {
7623 		/*
7624 		 * New association.
7625 		 */
7626 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM associated\n",
7627 			   sta->addr);
7628 
7629 		ret = ath10k_station_assoc(ar, vif, sta, false);
7630 		if (ret)
7631 			ath10k_warn(ar, "failed to associate station %pM for vdev %i: %i\n",
7632 				    sta->addr, arvif->vdev_id, ret);
7633 	} else if (old_state == IEEE80211_STA_ASSOC &&
7634 		   new_state == IEEE80211_STA_AUTHORIZED &&
7635 		   sta->tdls) {
7636 		/*
7637 		 * Tdls station authorized.
7638 		 */
7639 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac tdls sta %pM authorized\n",
7640 			   sta->addr);
7641 
7642 		ret = ath10k_station_assoc(ar, vif, sta, false);
7643 		if (ret) {
7644 			ath10k_warn(ar, "failed to associate tdls station %pM for vdev %i: %i\n",
7645 				    sta->addr, arvif->vdev_id, ret);
7646 			goto exit;
7647 		}
7648 
7649 		ret = ath10k_mac_tdls_peer_update(ar, arvif->vdev_id, sta,
7650 						  WMI_TDLS_PEER_STATE_CONNECTED);
7651 		if (ret)
7652 			ath10k_warn(ar, "failed to update tdls peer %pM for vdev %i: %i\n",
7653 				    sta->addr, arvif->vdev_id, ret);
7654 	} else if (old_state == IEEE80211_STA_ASSOC &&
7655 		    new_state == IEEE80211_STA_AUTH &&
7656 		    (vif->type == NL80211_IFTYPE_AP ||
7657 		     vif->type == NL80211_IFTYPE_MESH_POINT ||
7658 		     vif->type == NL80211_IFTYPE_ADHOC)) {
7659 		/*
7660 		 * Disassociation.
7661 		 */
7662 		ath10k_dbg(ar, ATH10K_DBG_STA, "mac sta %pM disassociated\n",
7663 			   sta->addr);
7664 
7665 		ret = ath10k_station_disassoc(ar, vif, sta);
7666 		if (ret)
7667 			ath10k_warn(ar, "failed to disassociate station: %pM vdev %i: %i\n",
7668 				    sta->addr, arvif->vdev_id, ret);
7669 	}
7670 exit:
7671 	mutex_unlock(&ar->conf_mutex);
7672 	return ret;
7673 }
7674 
ath10k_conf_tx_uapsd(struct ath10k * ar,struct ieee80211_vif * vif,u16 ac,bool enable)7675 static int ath10k_conf_tx_uapsd(struct ath10k *ar, struct ieee80211_vif *vif,
7676 				u16 ac, bool enable)
7677 {
7678 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
7679 	struct wmi_sta_uapsd_auto_trig_arg arg = {};
7680 	u32 prio = 0, acc = 0;
7681 	u32 value = 0;
7682 	int ret = 0;
7683 
7684 	lockdep_assert_held(&ar->conf_mutex);
7685 
7686 	if (arvif->vdev_type != WMI_VDEV_TYPE_STA)
7687 		return 0;
7688 
7689 	switch (ac) {
7690 	case IEEE80211_AC_VO:
7691 		value = WMI_STA_PS_UAPSD_AC3_DELIVERY_EN |
7692 			WMI_STA_PS_UAPSD_AC3_TRIGGER_EN;
7693 		prio = 7;
7694 		acc = 3;
7695 		break;
7696 	case IEEE80211_AC_VI:
7697 		value = WMI_STA_PS_UAPSD_AC2_DELIVERY_EN |
7698 			WMI_STA_PS_UAPSD_AC2_TRIGGER_EN;
7699 		prio = 5;
7700 		acc = 2;
7701 		break;
7702 	case IEEE80211_AC_BE:
7703 		value = WMI_STA_PS_UAPSD_AC1_DELIVERY_EN |
7704 			WMI_STA_PS_UAPSD_AC1_TRIGGER_EN;
7705 		prio = 2;
7706 		acc = 1;
7707 		break;
7708 	case IEEE80211_AC_BK:
7709 		value = WMI_STA_PS_UAPSD_AC0_DELIVERY_EN |
7710 			WMI_STA_PS_UAPSD_AC0_TRIGGER_EN;
7711 		prio = 0;
7712 		acc = 0;
7713 		break;
7714 	}
7715 
7716 	if (enable)
7717 		arvif->u.sta.uapsd |= value;
7718 	else
7719 		arvif->u.sta.uapsd &= ~value;
7720 
7721 	ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
7722 					  WMI_STA_PS_PARAM_UAPSD,
7723 					  arvif->u.sta.uapsd);
7724 	if (ret) {
7725 		ath10k_warn(ar, "failed to set uapsd params: %d\n", ret);
7726 		goto exit;
7727 	}
7728 
7729 	if (arvif->u.sta.uapsd)
7730 		value = WMI_STA_PS_RX_WAKE_POLICY_POLL_UAPSD;
7731 	else
7732 		value = WMI_STA_PS_RX_WAKE_POLICY_WAKE;
7733 
7734 	ret = ath10k_wmi_set_sta_ps_param(ar, arvif->vdev_id,
7735 					  WMI_STA_PS_PARAM_RX_WAKE_POLICY,
7736 					  value);
7737 	if (ret)
7738 		ath10k_warn(ar, "failed to set rx wake param: %d\n", ret);
7739 
7740 	ret = ath10k_mac_vif_recalc_ps_wake_threshold(arvif);
7741 	if (ret) {
7742 		ath10k_warn(ar, "failed to recalc ps wake threshold on vdev %i: %d\n",
7743 			    arvif->vdev_id, ret);
7744 		return ret;
7745 	}
7746 
7747 	ret = ath10k_mac_vif_recalc_ps_poll_count(arvif);
7748 	if (ret) {
7749 		ath10k_warn(ar, "failed to recalc ps poll count on vdev %i: %d\n",
7750 			    arvif->vdev_id, ret);
7751 		return ret;
7752 	}
7753 
7754 	if (test_bit(WMI_SERVICE_STA_UAPSD_BASIC_AUTO_TRIG, ar->wmi.svc_map) ||
7755 	    test_bit(WMI_SERVICE_STA_UAPSD_VAR_AUTO_TRIG, ar->wmi.svc_map)) {
7756 		/* Only userspace can make an educated decision when to send
7757 		 * trigger frame. The following effectively disables u-UAPSD
7758 		 * autotrigger in firmware (which is enabled by default
7759 		 * provided the autotrigger service is available).
7760 		 */
7761 
7762 		arg.wmm_ac = acc;
7763 		arg.user_priority = prio;
7764 		arg.service_interval = 0;
7765 		arg.suspend_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
7766 		arg.delay_interval = WMI_STA_UAPSD_MAX_INTERVAL_MSEC;
7767 
7768 		ret = ath10k_wmi_vdev_sta_uapsd(ar, arvif->vdev_id,
7769 						arvif->bssid, &arg, 1);
7770 		if (ret) {
7771 			ath10k_warn(ar, "failed to set uapsd auto trigger %d\n",
7772 				    ret);
7773 			return ret;
7774 		}
7775 	}
7776 
7777 exit:
7778 	return ret;
7779 }
7780 
ath10k_conf_tx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u16 ac,const struct ieee80211_tx_queue_params * params)7781 static int ath10k_conf_tx(struct ieee80211_hw *hw,
7782 			  struct ieee80211_vif *vif, u16 ac,
7783 			  const struct ieee80211_tx_queue_params *params)
7784 {
7785 	struct ath10k *ar = hw->priv;
7786 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
7787 	struct wmi_wmm_params_arg *p = NULL;
7788 	int ret;
7789 
7790 	mutex_lock(&ar->conf_mutex);
7791 
7792 	switch (ac) {
7793 	case IEEE80211_AC_VO:
7794 		p = &arvif->wmm_params.ac_vo;
7795 		break;
7796 	case IEEE80211_AC_VI:
7797 		p = &arvif->wmm_params.ac_vi;
7798 		break;
7799 	case IEEE80211_AC_BE:
7800 		p = &arvif->wmm_params.ac_be;
7801 		break;
7802 	case IEEE80211_AC_BK:
7803 		p = &arvif->wmm_params.ac_bk;
7804 		break;
7805 	}
7806 
7807 	if (WARN_ON(!p)) {
7808 		ret = -EINVAL;
7809 		goto exit;
7810 	}
7811 
7812 	p->cwmin = params->cw_min;
7813 	p->cwmax = params->cw_max;
7814 	p->aifs = params->aifs;
7815 
7816 	/*
7817 	 * The channel time duration programmed in the HW is in absolute
7818 	 * microseconds, while mac80211 gives the txop in units of
7819 	 * 32 microseconds.
7820 	 */
7821 	p->txop = params->txop * 32;
7822 
7823 	if (ar->wmi.ops->gen_vdev_wmm_conf) {
7824 		ret = ath10k_wmi_vdev_wmm_conf(ar, arvif->vdev_id,
7825 					       &arvif->wmm_params);
7826 		if (ret) {
7827 			ath10k_warn(ar, "failed to set vdev wmm params on vdev %i: %d\n",
7828 				    arvif->vdev_id, ret);
7829 			goto exit;
7830 		}
7831 	} else {
7832 		/* This won't work well with multi-interface cases but it's
7833 		 * better than nothing.
7834 		 */
7835 		ret = ath10k_wmi_pdev_set_wmm_params(ar, &arvif->wmm_params);
7836 		if (ret) {
7837 			ath10k_warn(ar, "failed to set wmm params: %d\n", ret);
7838 			goto exit;
7839 		}
7840 	}
7841 
7842 	ret = ath10k_conf_tx_uapsd(ar, vif, ac, params->uapsd);
7843 	if (ret)
7844 		ath10k_warn(ar, "failed to set sta uapsd: %d\n", ret);
7845 
7846 exit:
7847 	mutex_unlock(&ar->conf_mutex);
7848 	return ret;
7849 }
7850 
ath10k_remain_on_channel(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_channel * chan,int duration,enum ieee80211_roc_type type)7851 static int ath10k_remain_on_channel(struct ieee80211_hw *hw,
7852 				    struct ieee80211_vif *vif,
7853 				    struct ieee80211_channel *chan,
7854 				    int duration,
7855 				    enum ieee80211_roc_type type)
7856 {
7857 	struct ath10k *ar = hw->priv;
7858 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
7859 	struct wmi_start_scan_arg arg;
7860 	int ret = 0;
7861 	u32 scan_time_msec;
7862 
7863 	mutex_lock(&ar->conf_mutex);
7864 
7865 	if (ath10k_mac_tdls_vif_stations_count(hw, vif) > 0) {
7866 		ret = -EBUSY;
7867 		goto exit;
7868 	}
7869 
7870 	spin_lock_bh(&ar->data_lock);
7871 	switch (ar->scan.state) {
7872 	case ATH10K_SCAN_IDLE:
7873 		reinit_completion(&ar->scan.started);
7874 		reinit_completion(&ar->scan.completed);
7875 		reinit_completion(&ar->scan.on_channel);
7876 		ar->scan.state = ATH10K_SCAN_STARTING;
7877 		ar->scan.is_roc = true;
7878 		ar->scan.vdev_id = arvif->vdev_id;
7879 		ar->scan.roc_freq = chan->center_freq;
7880 		ar->scan.roc_notify = true;
7881 		ret = 0;
7882 		break;
7883 	case ATH10K_SCAN_STARTING:
7884 	case ATH10K_SCAN_RUNNING:
7885 	case ATH10K_SCAN_ABORTING:
7886 		ret = -EBUSY;
7887 		break;
7888 	}
7889 	spin_unlock_bh(&ar->data_lock);
7890 
7891 	if (ret)
7892 		goto exit;
7893 
7894 	scan_time_msec = ar->hw->wiphy->max_remain_on_channel_duration * 2;
7895 
7896 	memset(&arg, 0, sizeof(arg));
7897 	ath10k_wmi_start_scan_init(ar, &arg);
7898 	arg.vdev_id = arvif->vdev_id;
7899 	arg.scan_id = ATH10K_SCAN_ID;
7900 	arg.n_channels = 1;
7901 	arg.channels[0] = chan->center_freq;
7902 	arg.dwell_time_active = scan_time_msec;
7903 	arg.dwell_time_passive = scan_time_msec;
7904 	arg.max_scan_time = scan_time_msec;
7905 	arg.scan_ctrl_flags |= WMI_SCAN_FLAG_PASSIVE;
7906 	arg.scan_ctrl_flags |= WMI_SCAN_FILTER_PROBE_REQ;
7907 	arg.burst_duration_ms = duration;
7908 
7909 	ret = ath10k_start_scan(ar, &arg);
7910 	if (ret) {
7911 		ath10k_warn(ar, "failed to start roc scan: %d\n", ret);
7912 		spin_lock_bh(&ar->data_lock);
7913 		ar->scan.state = ATH10K_SCAN_IDLE;
7914 		spin_unlock_bh(&ar->data_lock);
7915 		goto exit;
7916 	}
7917 
7918 	ret = wait_for_completion_timeout(&ar->scan.on_channel, 3 * HZ);
7919 	if (ret == 0) {
7920 		ath10k_warn(ar, "failed to switch to channel for roc scan\n");
7921 
7922 		ret = ath10k_scan_stop(ar);
7923 		if (ret)
7924 			ath10k_warn(ar, "failed to stop scan: %d\n", ret);
7925 
7926 		ret = -ETIMEDOUT;
7927 		goto exit;
7928 	}
7929 
7930 	ieee80211_queue_delayed_work(ar->hw, &ar->scan.timeout,
7931 				     msecs_to_jiffies(duration));
7932 
7933 	ret = 0;
7934 exit:
7935 	mutex_unlock(&ar->conf_mutex);
7936 	return ret;
7937 }
7938 
ath10k_cancel_remain_on_channel(struct ieee80211_hw * hw,struct ieee80211_vif * vif)7939 static int ath10k_cancel_remain_on_channel(struct ieee80211_hw *hw,
7940 					   struct ieee80211_vif *vif)
7941 {
7942 	struct ath10k *ar = hw->priv;
7943 
7944 	mutex_lock(&ar->conf_mutex);
7945 
7946 	spin_lock_bh(&ar->data_lock);
7947 	ar->scan.roc_notify = false;
7948 	spin_unlock_bh(&ar->data_lock);
7949 
7950 	ath10k_scan_abort(ar);
7951 
7952 	mutex_unlock(&ar->conf_mutex);
7953 
7954 	cancel_delayed_work_sync(&ar->scan.timeout);
7955 
7956 	return 0;
7957 }
7958 
7959 /*
7960  * Both RTS and Fragmentation threshold are interface-specific
7961  * in ath10k, but device-specific in mac80211.
7962  */
7963 
ath10k_set_rts_threshold(struct ieee80211_hw * hw,u32 value)7964 static int ath10k_set_rts_threshold(struct ieee80211_hw *hw, u32 value)
7965 {
7966 	struct ath10k *ar = hw->priv;
7967 	struct ath10k_vif *arvif;
7968 	int ret = 0;
7969 
7970 	mutex_lock(&ar->conf_mutex);
7971 	list_for_each_entry(arvif, &ar->arvifs, list) {
7972 		ath10k_dbg(ar, ATH10K_DBG_MAC, "mac vdev %d rts threshold %d\n",
7973 			   arvif->vdev_id, value);
7974 
7975 		ret = ath10k_mac_set_rts(arvif, value);
7976 		if (ret) {
7977 			ath10k_warn(ar, "failed to set rts threshold for vdev %d: %d\n",
7978 				    arvif->vdev_id, ret);
7979 			break;
7980 		}
7981 	}
7982 	mutex_unlock(&ar->conf_mutex);
7983 
7984 	return ret;
7985 }
7986 
ath10k_mac_op_set_frag_threshold(struct ieee80211_hw * hw,u32 value)7987 static int ath10k_mac_op_set_frag_threshold(struct ieee80211_hw *hw, u32 value)
7988 {
7989 	/* Even though there's a WMI enum for fragmentation threshold no known
7990 	 * firmware actually implements it. Moreover it is not possible to rely
7991 	 * frame fragmentation to mac80211 because firmware clears the "more
7992 	 * fragments" bit in frame control making it impossible for remote
7993 	 * devices to reassemble frames.
7994 	 *
7995 	 * Hence implement a dummy callback just to say fragmentation isn't
7996 	 * supported. This effectively prevents mac80211 from doing frame
7997 	 * fragmentation in software.
7998 	 */
7999 	return -EOPNOTSUPP;
8000 }
8001 
ath10k_mac_wait_tx_complete(struct ath10k * ar)8002 void ath10k_mac_wait_tx_complete(struct ath10k *ar)
8003 {
8004 	bool skip;
8005 	long time_left;
8006 
8007 	/* mac80211 doesn't care if we really xmit queued frames or not
8008 	 * we'll collect those frames either way if we stop/delete vdevs
8009 	 */
8010 
8011 	if (ar->state == ATH10K_STATE_WEDGED)
8012 		return;
8013 
8014 	time_left = wait_event_timeout(ar->htt.empty_tx_wq, ({
8015 			bool empty;
8016 
8017 			spin_lock_bh(&ar->htt.tx_lock);
8018 			empty = (ar->htt.num_pending_tx == 0);
8019 			spin_unlock_bh(&ar->htt.tx_lock);
8020 
8021 			skip = (ar->state == ATH10K_STATE_WEDGED) ||
8022 			       test_bit(ATH10K_FLAG_CRASH_FLUSH,
8023 					&ar->dev_flags);
8024 
8025 			(empty || skip);
8026 		}), ATH10K_FLUSH_TIMEOUT_HZ);
8027 
8028 	if (time_left == 0 || skip)
8029 		ath10k_warn(ar, "failed to flush transmit queue (skip %i ar-state %i): %ld\n",
8030 			    skip, ar->state, time_left);
8031 }
8032 
ath10k_flush(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u32 queues,bool drop)8033 static void ath10k_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
8034 			 u32 queues, bool drop)
8035 {
8036 	struct ath10k *ar = hw->priv;
8037 	struct ath10k_vif *arvif;
8038 	u32 bitmap;
8039 
8040 	if (drop) {
8041 		if (vif && vif->type == NL80211_IFTYPE_STATION) {
8042 			bitmap = ~(1 << WMI_MGMT_TID);
8043 			list_for_each_entry(arvif, &ar->arvifs, list) {
8044 				if (arvif->vdev_type == WMI_VDEV_TYPE_STA)
8045 					ath10k_wmi_peer_flush(ar, arvif->vdev_id,
8046 							      arvif->bssid, bitmap);
8047 			}
8048 			ath10k_htt_flush_tx(&ar->htt);
8049 		}
8050 		return;
8051 	}
8052 
8053 	mutex_lock(&ar->conf_mutex);
8054 	ath10k_mac_wait_tx_complete(ar);
8055 	mutex_unlock(&ar->conf_mutex);
8056 }
8057 
8058 /* TODO: Implement this function properly
8059  * For now it is needed to reply to Probe Requests in IBSS mode.
8060  * Propably we need this information from FW.
8061  */
ath10k_tx_last_beacon(struct ieee80211_hw * hw)8062 static int ath10k_tx_last_beacon(struct ieee80211_hw *hw)
8063 {
8064 	return 1;
8065 }
8066 
ath10k_reconfig_complete(struct ieee80211_hw * hw,enum ieee80211_reconfig_type reconfig_type)8067 static void ath10k_reconfig_complete(struct ieee80211_hw *hw,
8068 				     enum ieee80211_reconfig_type reconfig_type)
8069 {
8070 	struct ath10k *ar = hw->priv;
8071 
8072 	if (reconfig_type != IEEE80211_RECONFIG_TYPE_RESTART)
8073 		return;
8074 
8075 	mutex_lock(&ar->conf_mutex);
8076 
8077 	/* If device failed to restart it will be in a different state, e.g.
8078 	 * ATH10K_STATE_WEDGED
8079 	 */
8080 	if (ar->state == ATH10K_STATE_RESTARTED) {
8081 		ath10k_info(ar, "device successfully recovered\n");
8082 		ar->state = ATH10K_STATE_ON;
8083 		ieee80211_wake_queues(ar->hw);
8084 		clear_bit(ATH10K_FLAG_RESTARTING, &ar->dev_flags);
8085 	}
8086 
8087 	mutex_unlock(&ar->conf_mutex);
8088 }
8089 
8090 static void
ath10k_mac_update_bss_chan_survey(struct ath10k * ar,struct ieee80211_channel * channel)8091 ath10k_mac_update_bss_chan_survey(struct ath10k *ar,
8092 				  struct ieee80211_channel *channel)
8093 {
8094 	int ret;
8095 	enum wmi_bss_survey_req_type type = WMI_BSS_SURVEY_REQ_TYPE_READ;
8096 
8097 	lockdep_assert_held(&ar->conf_mutex);
8098 
8099 	if (!test_bit(WMI_SERVICE_BSS_CHANNEL_INFO_64, ar->wmi.svc_map) ||
8100 	    (ar->rx_channel != channel))
8101 		return;
8102 
8103 	if (ar->scan.state != ATH10K_SCAN_IDLE) {
8104 		ath10k_dbg(ar, ATH10K_DBG_MAC, "ignoring bss chan info request while scanning..\n");
8105 		return;
8106 	}
8107 
8108 	reinit_completion(&ar->bss_survey_done);
8109 
8110 	ret = ath10k_wmi_pdev_bss_chan_info_request(ar, type);
8111 	if (ret) {
8112 		ath10k_warn(ar, "failed to send pdev bss chan info request\n");
8113 		return;
8114 	}
8115 
8116 	ret = wait_for_completion_timeout(&ar->bss_survey_done, 3 * HZ);
8117 	if (!ret) {
8118 		ath10k_warn(ar, "bss channel survey timed out\n");
8119 		return;
8120 	}
8121 }
8122 
ath10k_get_survey(struct ieee80211_hw * hw,int idx,struct survey_info * survey)8123 static int ath10k_get_survey(struct ieee80211_hw *hw, int idx,
8124 			     struct survey_info *survey)
8125 {
8126 	struct ath10k *ar = hw->priv;
8127 	struct ieee80211_supported_band *sband;
8128 	struct survey_info *ar_survey = &ar->survey[idx];
8129 	int ret = 0;
8130 
8131 	mutex_lock(&ar->conf_mutex);
8132 
8133 	sband = hw->wiphy->bands[NL80211_BAND_2GHZ];
8134 	if (sband && idx >= sband->n_channels) {
8135 		idx -= sband->n_channels;
8136 		sband = NULL;
8137 	}
8138 
8139 	if (!sband)
8140 		sband = hw->wiphy->bands[NL80211_BAND_5GHZ];
8141 
8142 	if (!sband || idx >= sband->n_channels) {
8143 		ret = -ENOENT;
8144 		goto exit;
8145 	}
8146 
8147 	ath10k_mac_update_bss_chan_survey(ar, &sband->channels[idx]);
8148 
8149 	spin_lock_bh(&ar->data_lock);
8150 	memcpy(survey, ar_survey, sizeof(*survey));
8151 	spin_unlock_bh(&ar->data_lock);
8152 
8153 	survey->channel = &sband->channels[idx];
8154 
8155 	if (ar->rx_channel == survey->channel)
8156 		survey->filled |= SURVEY_INFO_IN_USE;
8157 
8158 exit:
8159 	mutex_unlock(&ar->conf_mutex);
8160 	return ret;
8161 }
8162 
8163 static bool
ath10k_mac_bitrate_mask_get_single_nss(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,int * nss)8164 ath10k_mac_bitrate_mask_get_single_nss(struct ath10k *ar,
8165 				       enum nl80211_band band,
8166 				       const struct cfg80211_bitrate_mask *mask,
8167 				       int *nss)
8168 {
8169 	struct ieee80211_supported_band *sband = &ar->mac.sbands[band];
8170 	u16 vht_mcs_map = le16_to_cpu(sband->vht_cap.vht_mcs.tx_mcs_map);
8171 	u8 ht_nss_mask = 0;
8172 	u8 vht_nss_mask = 0;
8173 	int i;
8174 
8175 	if (mask->control[band].legacy)
8176 		return false;
8177 
8178 	for (i = 0; i < ARRAY_SIZE(mask->control[band].ht_mcs); i++) {
8179 		if (mask->control[band].ht_mcs[i] == 0)
8180 			continue;
8181 		else if (mask->control[band].ht_mcs[i] ==
8182 			 sband->ht_cap.mcs.rx_mask[i])
8183 			ht_nss_mask |= BIT(i);
8184 		else
8185 			return false;
8186 	}
8187 
8188 	for (i = 0; i < ARRAY_SIZE(mask->control[band].vht_mcs); i++) {
8189 		if (mask->control[band].vht_mcs[i] == 0)
8190 			continue;
8191 		else if (mask->control[band].vht_mcs[i] ==
8192 			 ath10k_mac_get_max_vht_mcs_map(vht_mcs_map, i))
8193 			vht_nss_mask |= BIT(i);
8194 		else
8195 			return false;
8196 	}
8197 
8198 	if (ht_nss_mask != vht_nss_mask)
8199 		return false;
8200 
8201 	if (ht_nss_mask == 0)
8202 		return false;
8203 
8204 	if (BIT(fls(ht_nss_mask)) - 1 != ht_nss_mask)
8205 		return false;
8206 
8207 	*nss = fls(ht_nss_mask);
8208 
8209 	return true;
8210 }
8211 
ath10k_mac_set_fixed_rate_params(struct ath10k_vif * arvif,u8 rate,u8 nss,u8 sgi,u8 ldpc)8212 static int ath10k_mac_set_fixed_rate_params(struct ath10k_vif *arvif,
8213 					    u8 rate, u8 nss, u8 sgi, u8 ldpc)
8214 {
8215 	struct ath10k *ar = arvif->ar;
8216 	u32 vdev_param;
8217 	int ret;
8218 
8219 	lockdep_assert_held(&ar->conf_mutex);
8220 
8221 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac set fixed rate params vdev %i rate 0x%02x nss %u sgi %u\n",
8222 		   arvif->vdev_id, rate, nss, sgi);
8223 
8224 	vdev_param = ar->wmi.vdev_param->fixed_rate;
8225 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, rate);
8226 	if (ret) {
8227 		ath10k_warn(ar, "failed to set fixed rate param 0x%02x: %d\n",
8228 			    rate, ret);
8229 		return ret;
8230 	}
8231 
8232 	vdev_param = ar->wmi.vdev_param->nss;
8233 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, nss);
8234 	if (ret) {
8235 		ath10k_warn(ar, "failed to set nss param %d: %d\n", nss, ret);
8236 		return ret;
8237 	}
8238 
8239 	vdev_param = ar->wmi.vdev_param->sgi;
8240 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, sgi);
8241 	if (ret) {
8242 		ath10k_warn(ar, "failed to set sgi param %d: %d\n", sgi, ret);
8243 		return ret;
8244 	}
8245 
8246 	vdev_param = ar->wmi.vdev_param->ldpc;
8247 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id, vdev_param, ldpc);
8248 	if (ret) {
8249 		ath10k_warn(ar, "failed to set ldpc param %d: %d\n", ldpc, ret);
8250 		return ret;
8251 	}
8252 
8253 	return 0;
8254 }
8255 
8256 static bool
ath10k_mac_can_set_bitrate_mask(struct ath10k * ar,enum nl80211_band band,const struct cfg80211_bitrate_mask * mask,bool allow_pfr)8257 ath10k_mac_can_set_bitrate_mask(struct ath10k *ar,
8258 				enum nl80211_band band,
8259 				const struct cfg80211_bitrate_mask *mask,
8260 				bool allow_pfr)
8261 {
8262 	int i;
8263 	u16 vht_mcs;
8264 
8265 	/* Due to firmware limitation in WMI_PEER_ASSOC_CMDID it is impossible
8266 	 * to express all VHT MCS rate masks. Effectively only the following
8267 	 * ranges can be used: none, 0-7, 0-8 and 0-9.
8268 	 */
8269 	for (i = 0; i < NL80211_VHT_NSS_MAX; i++) {
8270 		vht_mcs = mask->control[band].vht_mcs[i];
8271 
8272 		switch (vht_mcs) {
8273 		case 0:
8274 		case BIT(8) - 1:
8275 		case BIT(9) - 1:
8276 		case BIT(10) - 1:
8277 			break;
8278 		default:
8279 			if (!allow_pfr)
8280 				ath10k_warn(ar, "refusing bitrate mask with missing 0-7 VHT MCS rates\n");
8281 			return false;
8282 		}
8283 	}
8284 
8285 	return true;
8286 }
8287 
ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k * ar,struct ath10k_vif * arvif,struct ieee80211_sta * sta)8288 static bool ath10k_mac_set_vht_bitrate_mask_fixup(struct ath10k *ar,
8289 						  struct ath10k_vif *arvif,
8290 						  struct ieee80211_sta *sta)
8291 {
8292 	int err;
8293 	u8 rate = arvif->vht_pfr;
8294 
8295 	/* skip non vht and multiple rate peers */
8296 	if (!sta->deflink.vht_cap.vht_supported || arvif->vht_num_rates != 1)
8297 		return false;
8298 
8299 	err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
8300 					WMI_PEER_PARAM_FIXED_RATE, rate);
8301 	if (err)
8302 		ath10k_warn(ar, "failed to enable STA %pM peer fixed rate: %d\n",
8303 			    sta->addr, err);
8304 
8305 	return true;
8306 }
8307 
ath10k_mac_set_bitrate_mask_iter(void * data,struct ieee80211_sta * sta)8308 static void ath10k_mac_set_bitrate_mask_iter(void *data,
8309 					     struct ieee80211_sta *sta)
8310 {
8311 	struct ath10k_vif *arvif = data;
8312 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8313 	struct ath10k *ar = arvif->ar;
8314 
8315 	if (arsta->arvif != arvif)
8316 		return;
8317 
8318 	if (ath10k_mac_set_vht_bitrate_mask_fixup(ar, arvif, sta))
8319 		return;
8320 
8321 	spin_lock_bh(&ar->data_lock);
8322 	arsta->changed |= IEEE80211_RC_SUPP_RATES_CHANGED;
8323 	spin_unlock_bh(&ar->data_lock);
8324 
8325 	ieee80211_queue_work(ar->hw, &arsta->update_wk);
8326 }
8327 
ath10k_mac_clr_bitrate_mask_iter(void * data,struct ieee80211_sta * sta)8328 static void ath10k_mac_clr_bitrate_mask_iter(void *data,
8329 					     struct ieee80211_sta *sta)
8330 {
8331 	struct ath10k_vif *arvif = data;
8332 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8333 	struct ath10k *ar = arvif->ar;
8334 	int err;
8335 
8336 	/* clear vht peers only */
8337 	if (arsta->arvif != arvif || !sta->deflink.vht_cap.vht_supported)
8338 		return;
8339 
8340 	err = ath10k_wmi_peer_set_param(ar, arvif->vdev_id, sta->addr,
8341 					WMI_PEER_PARAM_FIXED_RATE,
8342 					WMI_FIXED_RATE_NONE);
8343 	if (err)
8344 		ath10k_warn(ar, "failed to clear STA %pM peer fixed rate: %d\n",
8345 			    sta->addr, err);
8346 }
8347 
ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw * hw,struct ieee80211_vif * vif,const struct cfg80211_bitrate_mask * mask)8348 static int ath10k_mac_op_set_bitrate_mask(struct ieee80211_hw *hw,
8349 					  struct ieee80211_vif *vif,
8350 					  const struct cfg80211_bitrate_mask *mask)
8351 {
8352 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8353 	struct cfg80211_chan_def def;
8354 	struct ath10k *ar = arvif->ar;
8355 	enum nl80211_band band;
8356 	const u8 *ht_mcs_mask;
8357 	const u16 *vht_mcs_mask;
8358 	u8 rate;
8359 	u8 nss;
8360 	u8 sgi;
8361 	u8 ldpc;
8362 	int single_nss;
8363 	int ret;
8364 	int vht_num_rates, allow_pfr;
8365 	u8 vht_pfr;
8366 	bool update_bitrate_mask = true;
8367 
8368 	if (ath10k_mac_vif_chan(vif, &def))
8369 		return -EPERM;
8370 
8371 	band = def.chan->band;
8372 	ht_mcs_mask = mask->control[band].ht_mcs;
8373 	vht_mcs_mask = mask->control[band].vht_mcs;
8374 	ldpc = !!(ar->ht_cap_info & WMI_HT_CAP_LDPC);
8375 
8376 	sgi = mask->control[band].gi;
8377 	if (sgi == NL80211_TXRATE_FORCE_LGI)
8378 		return -EINVAL;
8379 
8380 	allow_pfr = test_bit(ATH10K_FW_FEATURE_PEER_FIXED_RATE,
8381 			     ar->normal_mode_fw.fw_file.fw_features);
8382 	if (allow_pfr) {
8383 		mutex_lock(&ar->conf_mutex);
8384 		ieee80211_iterate_stations_atomic(ar->hw,
8385 						  ath10k_mac_clr_bitrate_mask_iter,
8386 						  arvif);
8387 		mutex_unlock(&ar->conf_mutex);
8388 	}
8389 
8390 	if (ath10k_mac_bitrate_mask_has_single_rate(ar, band, mask,
8391 						    &vht_num_rates)) {
8392 		ret = ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
8393 							      &rate, &nss,
8394 							      false);
8395 		if (ret) {
8396 			ath10k_warn(ar, "failed to get single rate for vdev %i: %d\n",
8397 				    arvif->vdev_id, ret);
8398 			return ret;
8399 		}
8400 	} else if (ath10k_mac_bitrate_mask_get_single_nss(ar, band, mask,
8401 							  &single_nss)) {
8402 		rate = WMI_FIXED_RATE_NONE;
8403 		nss = single_nss;
8404 	} else {
8405 		rate = WMI_FIXED_RATE_NONE;
8406 		nss = min(ar->num_rf_chains,
8407 			  max(ath10k_mac_max_ht_nss(ht_mcs_mask),
8408 			      ath10k_mac_max_vht_nss(vht_mcs_mask)));
8409 
8410 		if (!ath10k_mac_can_set_bitrate_mask(ar, band, mask,
8411 						     allow_pfr)) {
8412 			u8 vht_nss;
8413 
8414 			if (!allow_pfr || vht_num_rates != 1)
8415 				return -EINVAL;
8416 
8417 			/* Reach here, firmware supports peer fixed rate and has
8418 			 * single vht rate, and don't update vif birate_mask, as
8419 			 * the rate only for specific peer.
8420 			 */
8421 			ath10k_mac_bitrate_mask_get_single_rate(ar, band, mask,
8422 								&vht_pfr,
8423 								&vht_nss,
8424 								true);
8425 			update_bitrate_mask = false;
8426 		} else {
8427 			vht_pfr = 0;
8428 		}
8429 
8430 		mutex_lock(&ar->conf_mutex);
8431 
8432 		if (update_bitrate_mask)
8433 			arvif->bitrate_mask = *mask;
8434 		arvif->vht_num_rates = vht_num_rates;
8435 		arvif->vht_pfr = vht_pfr;
8436 		ieee80211_iterate_stations_atomic(ar->hw,
8437 						  ath10k_mac_set_bitrate_mask_iter,
8438 						  arvif);
8439 
8440 		mutex_unlock(&ar->conf_mutex);
8441 	}
8442 
8443 	mutex_lock(&ar->conf_mutex);
8444 
8445 	ret = ath10k_mac_set_fixed_rate_params(arvif, rate, nss, sgi, ldpc);
8446 	if (ret) {
8447 		ath10k_warn(ar, "failed to set fixed rate params on vdev %i: %d\n",
8448 			    arvif->vdev_id, ret);
8449 		goto exit;
8450 	}
8451 
8452 exit:
8453 	mutex_unlock(&ar->conf_mutex);
8454 
8455 	return ret;
8456 }
8457 
ath10k_sta_rc_update(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u32 changed)8458 static void ath10k_sta_rc_update(struct ieee80211_hw *hw,
8459 				 struct ieee80211_vif *vif,
8460 				 struct ieee80211_sta *sta,
8461 				 u32 changed)
8462 {
8463 	struct ath10k *ar = hw->priv;
8464 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
8465 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8466 	struct ath10k_peer *peer;
8467 	u32 bw, smps;
8468 
8469 	spin_lock_bh(&ar->data_lock);
8470 
8471 	peer = ath10k_peer_find(ar, arvif->vdev_id, sta->addr);
8472 	if (!peer) {
8473 		spin_unlock_bh(&ar->data_lock);
8474 		ath10k_warn(ar, "mac sta rc update failed to find peer %pM on vdev %i\n",
8475 			    sta->addr, arvif->vdev_id);
8476 		return;
8477 	}
8478 
8479 	ath10k_dbg(ar, ATH10K_DBG_STA,
8480 		   "mac sta rc update for %pM changed %08x bw %d nss %d smps %d\n",
8481 		   sta->addr, changed, sta->deflink.bandwidth,
8482 		   sta->deflink.rx_nss,
8483 		   sta->smps_mode);
8484 
8485 	if (changed & IEEE80211_RC_BW_CHANGED) {
8486 		bw = WMI_PEER_CHWIDTH_20MHZ;
8487 
8488 		switch (sta->deflink.bandwidth) {
8489 		case IEEE80211_STA_RX_BW_20:
8490 			bw = WMI_PEER_CHWIDTH_20MHZ;
8491 			break;
8492 		case IEEE80211_STA_RX_BW_40:
8493 			bw = WMI_PEER_CHWIDTH_40MHZ;
8494 			break;
8495 		case IEEE80211_STA_RX_BW_80:
8496 			bw = WMI_PEER_CHWIDTH_80MHZ;
8497 			break;
8498 		case IEEE80211_STA_RX_BW_160:
8499 			bw = WMI_PEER_CHWIDTH_160MHZ;
8500 			break;
8501 		default:
8502 			ath10k_warn(ar, "Invalid bandwidth %d in rc update for %pM\n",
8503 				    sta->deflink.bandwidth, sta->addr);
8504 			bw = WMI_PEER_CHWIDTH_20MHZ;
8505 			break;
8506 		}
8507 
8508 		arsta->bw = bw;
8509 	}
8510 
8511 	if (changed & IEEE80211_RC_NSS_CHANGED)
8512 		arsta->nss = sta->deflink.rx_nss;
8513 
8514 	if (changed & IEEE80211_RC_SMPS_CHANGED) {
8515 		smps = WMI_PEER_SMPS_PS_NONE;
8516 
8517 		switch (sta->smps_mode) {
8518 		case IEEE80211_SMPS_AUTOMATIC:
8519 		case IEEE80211_SMPS_OFF:
8520 			smps = WMI_PEER_SMPS_PS_NONE;
8521 			break;
8522 		case IEEE80211_SMPS_STATIC:
8523 			smps = WMI_PEER_SMPS_STATIC;
8524 			break;
8525 		case IEEE80211_SMPS_DYNAMIC:
8526 			smps = WMI_PEER_SMPS_DYNAMIC;
8527 			break;
8528 		case IEEE80211_SMPS_NUM_MODES:
8529 			ath10k_warn(ar, "Invalid smps %d in sta rc update for %pM\n",
8530 				    sta->smps_mode, sta->addr);
8531 			smps = WMI_PEER_SMPS_PS_NONE;
8532 			break;
8533 		}
8534 
8535 		arsta->smps = smps;
8536 	}
8537 
8538 	arsta->changed |= changed;
8539 
8540 	spin_unlock_bh(&ar->data_lock);
8541 
8542 	ieee80211_queue_work(hw, &arsta->update_wk);
8543 }
8544 
ath10k_offset_tsf(struct ieee80211_hw * hw,struct ieee80211_vif * vif,s64 tsf_offset)8545 static void ath10k_offset_tsf(struct ieee80211_hw *hw,
8546 			      struct ieee80211_vif *vif, s64 tsf_offset)
8547 {
8548 	struct ath10k *ar = hw->priv;
8549 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8550 	u32 offset, vdev_param;
8551 	int ret;
8552 
8553 	if (tsf_offset < 0) {
8554 		vdev_param = ar->wmi.vdev_param->dec_tsf;
8555 		offset = -tsf_offset;
8556 	} else {
8557 		vdev_param = ar->wmi.vdev_param->inc_tsf;
8558 		offset = tsf_offset;
8559 	}
8560 
8561 	ret = ath10k_wmi_vdev_set_param(ar, arvif->vdev_id,
8562 					vdev_param, offset);
8563 
8564 	if (ret && ret != -EOPNOTSUPP)
8565 		ath10k_warn(ar, "failed to set tsf offset %d cmd %d: %d\n",
8566 			    offset, vdev_param, ret);
8567 }
8568 
ath10k_ampdu_action(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_ampdu_params * params)8569 static int ath10k_ampdu_action(struct ieee80211_hw *hw,
8570 			       struct ieee80211_vif *vif,
8571 			       struct ieee80211_ampdu_params *params)
8572 {
8573 	struct ath10k *ar = hw->priv;
8574 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8575 	struct ieee80211_sta *sta = params->sta;
8576 	enum ieee80211_ampdu_mlme_action action = params->action;
8577 	u16 tid = params->tid;
8578 
8579 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac ampdu vdev_id %i sta %pM tid %u action %d\n",
8580 		   arvif->vdev_id, sta->addr, tid, action);
8581 
8582 	switch (action) {
8583 	case IEEE80211_AMPDU_RX_START:
8584 	case IEEE80211_AMPDU_RX_STOP:
8585 		/* HTT AddBa/DelBa events trigger mac80211 Rx BA session
8586 		 * creation/removal. Do we need to verify this?
8587 		 */
8588 		return 0;
8589 	case IEEE80211_AMPDU_TX_START:
8590 	case IEEE80211_AMPDU_TX_STOP_CONT:
8591 	case IEEE80211_AMPDU_TX_STOP_FLUSH:
8592 	case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
8593 	case IEEE80211_AMPDU_TX_OPERATIONAL:
8594 		/* Firmware offloads Tx aggregation entirely so deny mac80211
8595 		 * Tx aggregation requests.
8596 		 */
8597 		return -EOPNOTSUPP;
8598 	}
8599 
8600 	return -EINVAL;
8601 }
8602 
8603 static void
ath10k_mac_update_rx_channel(struct ath10k * ar,struct ieee80211_chanctx_conf * ctx,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs)8604 ath10k_mac_update_rx_channel(struct ath10k *ar,
8605 			     struct ieee80211_chanctx_conf *ctx,
8606 			     struct ieee80211_vif_chanctx_switch *vifs,
8607 			     int n_vifs)
8608 {
8609 	struct cfg80211_chan_def *def = NULL;
8610 
8611 	/* Both locks are required because ar->rx_channel is modified. This
8612 	 * allows readers to hold either lock.
8613 	 */
8614 	lockdep_assert_held(&ar->conf_mutex);
8615 	lockdep_assert_held(&ar->data_lock);
8616 
8617 	WARN_ON(ctx && vifs);
8618 	WARN_ON(vifs && !n_vifs);
8619 
8620 	/* FIXME: Sort of an optimization and a workaround. Peers and vifs are
8621 	 * on a linked list now. Doing a lookup peer -> vif -> chanctx for each
8622 	 * ppdu on Rx may reduce performance on low-end systems. It should be
8623 	 * possible to make tables/hashmaps to speed the lookup up (be vary of
8624 	 * cpu data cache lines though regarding sizes) but to keep the initial
8625 	 * implementation simple and less intrusive fallback to the slow lookup
8626 	 * only for multi-channel cases. Single-channel cases will remain to
8627 	 * use the old channel derival and thus performance should not be
8628 	 * affected much.
8629 	 */
8630 	rcu_read_lock();
8631 	if (!ctx && ath10k_mac_num_chanctxs(ar) == 1) {
8632 		ieee80211_iter_chan_contexts_atomic(ar->hw,
8633 						    ath10k_mac_get_any_chandef_iter,
8634 						    &def);
8635 
8636 		if (vifs)
8637 			def = &vifs[0].new_ctx->def;
8638 
8639 		ar->rx_channel = def->chan;
8640 	} else if ((ctx && ath10k_mac_num_chanctxs(ar) == 0) ||
8641 		   (ctx && (ar->state == ATH10K_STATE_RESTARTED))) {
8642 		/* During driver restart due to firmware assert, since mac80211
8643 		 * already has valid channel context for given radio, channel
8644 		 * context iteration return num_chanctx > 0. So fix rx_channel
8645 		 * when restart is in progress.
8646 		 */
8647 		ar->rx_channel = ctx->def.chan;
8648 	} else {
8649 		ar->rx_channel = NULL;
8650 	}
8651 	rcu_read_unlock();
8652 }
8653 
8654 static void
ath10k_mac_update_vif_chan(struct ath10k * ar,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs)8655 ath10k_mac_update_vif_chan(struct ath10k *ar,
8656 			   struct ieee80211_vif_chanctx_switch *vifs,
8657 			   int n_vifs)
8658 {
8659 	struct ath10k_vif *arvif;
8660 	int ret;
8661 	int i;
8662 
8663 	lockdep_assert_held(&ar->conf_mutex);
8664 
8665 	/* First stop monitor interface. Some FW versions crash if there's a
8666 	 * lone monitor interface.
8667 	 */
8668 	if (ar->monitor_started)
8669 		ath10k_monitor_stop(ar);
8670 
8671 	for (i = 0; i < n_vifs; i++) {
8672 		arvif = (void *)vifs[i].vif->drv_priv;
8673 
8674 		ath10k_dbg(ar, ATH10K_DBG_MAC,
8675 			   "mac chanctx switch vdev_id %i freq %u->%u width %d->%d\n",
8676 			   arvif->vdev_id,
8677 			   vifs[i].old_ctx->def.chan->center_freq,
8678 			   vifs[i].new_ctx->def.chan->center_freq,
8679 			   vifs[i].old_ctx->def.width,
8680 			   vifs[i].new_ctx->def.width);
8681 
8682 		if (WARN_ON(!arvif->is_started))
8683 			continue;
8684 
8685 		if (WARN_ON(!arvif->is_up))
8686 			continue;
8687 
8688 		ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
8689 		if (ret) {
8690 			ath10k_warn(ar, "failed to down vdev %d: %d\n",
8691 				    arvif->vdev_id, ret);
8692 			continue;
8693 		}
8694 	}
8695 
8696 	/* All relevant vdevs are downed and associated channel resources
8697 	 * should be available for the channel switch now.
8698 	 */
8699 
8700 	spin_lock_bh(&ar->data_lock);
8701 	ath10k_mac_update_rx_channel(ar, NULL, vifs, n_vifs);
8702 	spin_unlock_bh(&ar->data_lock);
8703 
8704 	for (i = 0; i < n_vifs; i++) {
8705 		arvif = (void *)vifs[i].vif->drv_priv;
8706 
8707 		if (WARN_ON(!arvif->is_started))
8708 			continue;
8709 
8710 		if (WARN_ON(!arvif->is_up))
8711 			continue;
8712 
8713 		ret = ath10k_mac_setup_bcn_tmpl(arvif);
8714 		if (ret)
8715 			ath10k_warn(ar, "failed to update bcn tmpl during csa: %d\n",
8716 				    ret);
8717 
8718 		ret = ath10k_mac_setup_prb_tmpl(arvif);
8719 		if (ret)
8720 			ath10k_warn(ar, "failed to update prb tmpl during csa: %d\n",
8721 				    ret);
8722 
8723 		ret = ath10k_vdev_restart(arvif, &vifs[i].new_ctx->def);
8724 		if (ret) {
8725 			ath10k_warn(ar, "failed to restart vdev %d: %d\n",
8726 				    arvif->vdev_id, ret);
8727 			continue;
8728 		}
8729 
8730 		ret = ath10k_wmi_vdev_up(arvif->ar, arvif->vdev_id, arvif->aid,
8731 					 arvif->bssid);
8732 		if (ret) {
8733 			ath10k_warn(ar, "failed to bring vdev up %d: %d\n",
8734 				    arvif->vdev_id, ret);
8735 			continue;
8736 		}
8737 	}
8738 
8739 	ath10k_monitor_recalc(ar);
8740 }
8741 
8742 static int
ath10k_mac_op_add_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)8743 ath10k_mac_op_add_chanctx(struct ieee80211_hw *hw,
8744 			  struct ieee80211_chanctx_conf *ctx)
8745 {
8746 	struct ath10k *ar = hw->priv;
8747 
8748 	ath10k_dbg(ar, ATH10K_DBG_MAC,
8749 		   "mac chanctx add freq %u width %d ptr %pK\n",
8750 		   ctx->def.chan->center_freq, ctx->def.width, ctx);
8751 
8752 	mutex_lock(&ar->conf_mutex);
8753 
8754 	spin_lock_bh(&ar->data_lock);
8755 	ath10k_mac_update_rx_channel(ar, ctx, NULL, 0);
8756 	spin_unlock_bh(&ar->data_lock);
8757 
8758 	ath10k_recalc_radar_detection(ar);
8759 	ath10k_monitor_recalc(ar);
8760 
8761 	mutex_unlock(&ar->conf_mutex);
8762 
8763 	return 0;
8764 }
8765 
8766 static void
ath10k_mac_op_remove_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx)8767 ath10k_mac_op_remove_chanctx(struct ieee80211_hw *hw,
8768 			     struct ieee80211_chanctx_conf *ctx)
8769 {
8770 	struct ath10k *ar = hw->priv;
8771 
8772 	ath10k_dbg(ar, ATH10K_DBG_MAC,
8773 		   "mac chanctx remove freq %u width %d ptr %pK\n",
8774 		   ctx->def.chan->center_freq, ctx->def.width, ctx);
8775 
8776 	mutex_lock(&ar->conf_mutex);
8777 
8778 	spin_lock_bh(&ar->data_lock);
8779 	ath10k_mac_update_rx_channel(ar, NULL, NULL, 0);
8780 	spin_unlock_bh(&ar->data_lock);
8781 
8782 	ath10k_recalc_radar_detection(ar);
8783 	ath10k_monitor_recalc(ar);
8784 
8785 	mutex_unlock(&ar->conf_mutex);
8786 }
8787 
8788 struct ath10k_mac_change_chanctx_arg {
8789 	struct ieee80211_chanctx_conf *ctx;
8790 	struct ieee80211_vif_chanctx_switch *vifs;
8791 	int n_vifs;
8792 	int next_vif;
8793 };
8794 
8795 static void
ath10k_mac_change_chanctx_cnt_iter(void * data,u8 * mac,struct ieee80211_vif * vif)8796 ath10k_mac_change_chanctx_cnt_iter(void *data, u8 *mac,
8797 				   struct ieee80211_vif *vif)
8798 {
8799 	struct ath10k_mac_change_chanctx_arg *arg = data;
8800 
8801 	if (rcu_access_pointer(vif->bss_conf.chanctx_conf) != arg->ctx)
8802 		return;
8803 
8804 	arg->n_vifs++;
8805 }
8806 
8807 static void
ath10k_mac_change_chanctx_fill_iter(void * data,u8 * mac,struct ieee80211_vif * vif)8808 ath10k_mac_change_chanctx_fill_iter(void *data, u8 *mac,
8809 				    struct ieee80211_vif *vif)
8810 {
8811 	struct ath10k_mac_change_chanctx_arg *arg = data;
8812 	struct ieee80211_chanctx_conf *ctx;
8813 
8814 	ctx = rcu_access_pointer(vif->bss_conf.chanctx_conf);
8815 	if (ctx != arg->ctx)
8816 		return;
8817 
8818 	if (WARN_ON(arg->next_vif == arg->n_vifs))
8819 		return;
8820 
8821 	arg->vifs[arg->next_vif].vif = vif;
8822 	arg->vifs[arg->next_vif].old_ctx = ctx;
8823 	arg->vifs[arg->next_vif].new_ctx = ctx;
8824 	arg->next_vif++;
8825 }
8826 
8827 static void
ath10k_mac_op_change_chanctx(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * ctx,u32 changed)8828 ath10k_mac_op_change_chanctx(struct ieee80211_hw *hw,
8829 			     struct ieee80211_chanctx_conf *ctx,
8830 			     u32 changed)
8831 {
8832 	struct ath10k *ar = hw->priv;
8833 	struct ath10k_mac_change_chanctx_arg arg = { .ctx = ctx };
8834 
8835 	mutex_lock(&ar->conf_mutex);
8836 
8837 	ath10k_dbg(ar, ATH10K_DBG_MAC,
8838 		   "mac chanctx change freq %u width %d ptr %pK changed %x\n",
8839 		   ctx->def.chan->center_freq, ctx->def.width, ctx, changed);
8840 
8841 	/* This shouldn't really happen because channel switching should use
8842 	 * switch_vif_chanctx().
8843 	 */
8844 	if (WARN_ON(changed & IEEE80211_CHANCTX_CHANGE_CHANNEL))
8845 		goto unlock;
8846 
8847 	if (changed & IEEE80211_CHANCTX_CHANGE_WIDTH) {
8848 		ieee80211_iterate_active_interfaces_atomic(
8849 					hw,
8850 					ATH10K_ITER_NORMAL_FLAGS,
8851 					ath10k_mac_change_chanctx_cnt_iter,
8852 					&arg);
8853 		if (arg.n_vifs == 0)
8854 			goto radar;
8855 
8856 		arg.vifs = kcalloc(arg.n_vifs, sizeof(arg.vifs[0]),
8857 				   GFP_KERNEL);
8858 		if (!arg.vifs)
8859 			goto radar;
8860 
8861 		ieee80211_iterate_active_interfaces_atomic(
8862 					hw,
8863 					ATH10K_ITER_NORMAL_FLAGS,
8864 					ath10k_mac_change_chanctx_fill_iter,
8865 					&arg);
8866 		ath10k_mac_update_vif_chan(ar, arg.vifs, arg.n_vifs);
8867 		kfree(arg.vifs);
8868 	}
8869 
8870 radar:
8871 	ath10k_recalc_radar_detection(ar);
8872 
8873 	/* FIXME: How to configure Rx chains properly? */
8874 
8875 	/* No other actions are actually necessary. Firmware maintains channel
8876 	 * definitions per vdev internally and there's no host-side channel
8877 	 * context abstraction to configure, e.g. channel width.
8878 	 */
8879 
8880 unlock:
8881 	mutex_unlock(&ar->conf_mutex);
8882 }
8883 
8884 static int
ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_chanctx_conf * ctx)8885 ath10k_mac_op_assign_vif_chanctx(struct ieee80211_hw *hw,
8886 				 struct ieee80211_vif *vif,
8887 				 struct ieee80211_chanctx_conf *ctx)
8888 {
8889 	struct ath10k *ar = hw->priv;
8890 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8891 	int ret;
8892 
8893 	mutex_lock(&ar->conf_mutex);
8894 
8895 	ath10k_dbg(ar, ATH10K_DBG_MAC,
8896 		   "mac chanctx assign ptr %pK vdev_id %i\n",
8897 		   ctx, arvif->vdev_id);
8898 
8899 	if (WARN_ON(arvif->is_started)) {
8900 		mutex_unlock(&ar->conf_mutex);
8901 		return -EBUSY;
8902 	}
8903 
8904 	ret = ath10k_vdev_start(arvif, &ctx->def);
8905 	if (ret) {
8906 		ath10k_warn(ar, "failed to start vdev %i addr %pM on freq %d: %d\n",
8907 			    arvif->vdev_id, vif->addr,
8908 			    ctx->def.chan->center_freq, ret);
8909 		goto err;
8910 	}
8911 
8912 	arvif->is_started = true;
8913 
8914 	ret = ath10k_mac_vif_setup_ps(arvif);
8915 	if (ret) {
8916 		ath10k_warn(ar, "failed to update vdev %i ps: %d\n",
8917 			    arvif->vdev_id, ret);
8918 		goto err_stop;
8919 	}
8920 
8921 	if (vif->type == NL80211_IFTYPE_MONITOR) {
8922 		ret = ath10k_wmi_vdev_up(ar, arvif->vdev_id, 0, vif->addr);
8923 		if (ret) {
8924 			ath10k_warn(ar, "failed to up monitor vdev %i: %d\n",
8925 				    arvif->vdev_id, ret);
8926 			goto err_stop;
8927 		}
8928 
8929 		arvif->is_up = true;
8930 	}
8931 
8932 	if (ath10k_mac_can_set_cts_prot(arvif)) {
8933 		ret = ath10k_mac_set_cts_prot(arvif);
8934 		if (ret)
8935 			ath10k_warn(ar, "failed to set cts protection for vdev %d: %d\n",
8936 				    arvif->vdev_id, ret);
8937 	}
8938 
8939 	if (ath10k_peer_stats_enabled(ar) &&
8940 	    ar->hw_params.tx_stats_over_pktlog) {
8941 		ar->pktlog_filter |= ATH10K_PKTLOG_PEER_STATS;
8942 		ret = ath10k_wmi_pdev_pktlog_enable(ar,
8943 						    ar->pktlog_filter);
8944 		if (ret) {
8945 			ath10k_warn(ar, "failed to enable pktlog %d\n", ret);
8946 			goto err_stop;
8947 		}
8948 	}
8949 
8950 	mutex_unlock(&ar->conf_mutex);
8951 	return 0;
8952 
8953 err_stop:
8954 	ath10k_vdev_stop(arvif);
8955 	arvif->is_started = false;
8956 	ath10k_mac_vif_setup_ps(arvif);
8957 
8958 err:
8959 	mutex_unlock(&ar->conf_mutex);
8960 	return ret;
8961 }
8962 
8963 static void
ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_chanctx_conf * ctx)8964 ath10k_mac_op_unassign_vif_chanctx(struct ieee80211_hw *hw,
8965 				   struct ieee80211_vif *vif,
8966 				   struct ieee80211_chanctx_conf *ctx)
8967 {
8968 	struct ath10k *ar = hw->priv;
8969 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
8970 	int ret;
8971 
8972 	mutex_lock(&ar->conf_mutex);
8973 
8974 	ath10k_dbg(ar, ATH10K_DBG_MAC,
8975 		   "mac chanctx unassign ptr %pK vdev_id %i\n",
8976 		   ctx, arvif->vdev_id);
8977 
8978 	WARN_ON(!arvif->is_started);
8979 
8980 	if (vif->type == NL80211_IFTYPE_MONITOR) {
8981 		WARN_ON(!arvif->is_up);
8982 
8983 		ret = ath10k_wmi_vdev_down(ar, arvif->vdev_id);
8984 		if (ret)
8985 			ath10k_warn(ar, "failed to down monitor vdev %i: %d\n",
8986 				    arvif->vdev_id, ret);
8987 
8988 		arvif->is_up = false;
8989 	}
8990 
8991 	ret = ath10k_vdev_stop(arvif);
8992 	if (ret)
8993 		ath10k_warn(ar, "failed to stop vdev %i: %d\n",
8994 			    arvif->vdev_id, ret);
8995 
8996 	arvif->is_started = false;
8997 
8998 	mutex_unlock(&ar->conf_mutex);
8999 }
9000 
9001 static int
ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw * hw,struct ieee80211_vif_chanctx_switch * vifs,int n_vifs,enum ieee80211_chanctx_switch_mode mode)9002 ath10k_mac_op_switch_vif_chanctx(struct ieee80211_hw *hw,
9003 				 struct ieee80211_vif_chanctx_switch *vifs,
9004 				 int n_vifs,
9005 				 enum ieee80211_chanctx_switch_mode mode)
9006 {
9007 	struct ath10k *ar = hw->priv;
9008 
9009 	mutex_lock(&ar->conf_mutex);
9010 
9011 	ath10k_dbg(ar, ATH10K_DBG_MAC,
9012 		   "mac chanctx switch n_vifs %d mode %d\n",
9013 		   n_vifs, mode);
9014 	ath10k_mac_update_vif_chan(ar, vifs, n_vifs);
9015 
9016 	mutex_unlock(&ar->conf_mutex);
9017 	return 0;
9018 }
9019 
ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta)9020 static void ath10k_mac_op_sta_pre_rcu_remove(struct ieee80211_hw *hw,
9021 					     struct ieee80211_vif *vif,
9022 					     struct ieee80211_sta *sta)
9023 {
9024 	struct ath10k *ar;
9025 	struct ath10k_peer *peer;
9026 
9027 	ar = hw->priv;
9028 
9029 	list_for_each_entry(peer, &ar->peers, list)
9030 		if (peer->sta == sta)
9031 			peer->removed = true;
9032 }
9033 
9034 /* HT MCS parameters with Nss = 1 */
9035 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss1[] = {
9036 	/* MCS  L20   L40   S20  S40 */
9037 	{0,  { 65,  135,  72,  150} },
9038 	{1,  { 130, 270,  144, 300} },
9039 	{2,  { 195, 405,  217, 450} },
9040 	{3,  { 260, 540,  289, 600} },
9041 	{4,  { 390, 810,  433, 900} },
9042 	{5,  { 520, 1080, 578, 1200} },
9043 	{6,  { 585, 1215, 650, 1350} },
9044 	{7,  { 650, 1350, 722, 1500} }
9045 };
9046 
9047 /* HT MCS parameters with Nss = 2 */
9048 static const struct ath10k_index_ht_data_rate_type supported_ht_mcs_rate_nss2[] = {
9049 	/* MCS  L20    L40   S20   S40 */
9050 	{0,  {130,  270,  144,  300} },
9051 	{1,  {260,  540,  289,  600} },
9052 	{2,  {390,  810,  433,  900} },
9053 	{3,  {520,  1080, 578,  1200} },
9054 	{4,  {780,  1620, 867,  1800} },
9055 	{5,  {1040, 2160, 1156, 2400} },
9056 	{6,  {1170, 2430, 1300, 2700} },
9057 	{7,  {1300, 2700, 1444, 3000} }
9058 };
9059 
9060 /* MCS parameters with Nss = 1 */
9061 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss1[] = {
9062 	/* MCS  L80    S80     L40   S40    L20   S20 */
9063 	{0,  {293,  325},  {135,  150},  {65,   72} },
9064 	{1,  {585,  650},  {270,  300},  {130,  144} },
9065 	{2,  {878,  975},  {405,  450},  {195,  217} },
9066 	{3,  {1170, 1300}, {540,  600},  {260,  289} },
9067 	{4,  {1755, 1950}, {810,  900},  {390,  433} },
9068 	{5,  {2340, 2600}, {1080, 1200}, {520,  578} },
9069 	{6,  {2633, 2925}, {1215, 1350}, {585,  650} },
9070 	{7,  {2925, 3250}, {1350, 1500}, {650,  722} },
9071 	{8,  {3510, 3900}, {1620, 1800}, {780,  867} },
9072 	{9,  {3900, 4333}, {1800, 2000}, {780,  867} }
9073 };
9074 
9075 /*MCS parameters with Nss = 2 */
9076 static const struct ath10k_index_vht_data_rate_type supported_vht_mcs_rate_nss2[] = {
9077 	/* MCS  L80    S80     L40   S40    L20   S20 */
9078 	{0,  {585,  650},  {270,  300},  {130,  144} },
9079 	{1,  {1170, 1300}, {540,  600},  {260,  289} },
9080 	{2,  {1755, 1950}, {810,  900},  {390,  433} },
9081 	{3,  {2340, 2600}, {1080, 1200}, {520,  578} },
9082 	{4,  {3510, 3900}, {1620, 1800}, {780,  867} },
9083 	{5,  {4680, 5200}, {2160, 2400}, {1040, 1156} },
9084 	{6,  {5265, 5850}, {2430, 2700}, {1170, 1300} },
9085 	{7,  {5850, 6500}, {2700, 3000}, {1300, 1444} },
9086 	{8,  {7020, 7800}, {3240, 3600}, {1560, 1733} },
9087 	{9,  {7800, 8667}, {3600, 4000}, {1560, 1733} }
9088 };
9089 
ath10k_mac_get_rate_flags_ht(struct ath10k * ar,u32 rate,u8 nss,u8 mcs,u8 * flags,u8 * bw)9090 static void ath10k_mac_get_rate_flags_ht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,
9091 					 u8 *flags, u8 *bw)
9092 {
9093 	struct ath10k_index_ht_data_rate_type *mcs_rate;
9094 	u8 index;
9095 	size_t len_nss1 = ARRAY_SIZE(supported_ht_mcs_rate_nss1);
9096 	size_t len_nss2 = ARRAY_SIZE(supported_ht_mcs_rate_nss2);
9097 
9098 	if (mcs >= (len_nss1 + len_nss2)) {
9099 		ath10k_warn(ar, "not supported mcs %d in current rate table", mcs);
9100 		return;
9101 	}
9102 
9103 	mcs_rate = (struct ath10k_index_ht_data_rate_type *)
9104 		   ((nss == 1) ? &supported_ht_mcs_rate_nss1 :
9105 		   &supported_ht_mcs_rate_nss2);
9106 
9107 	if (mcs >= len_nss1)
9108 		index = mcs - len_nss1;
9109 	else
9110 		index = mcs;
9111 
9112 	if (rate == mcs_rate[index].supported_rate[0]) {
9113 		*bw = RATE_INFO_BW_20;
9114 	} else if (rate == mcs_rate[index].supported_rate[1]) {
9115 		*bw |= RATE_INFO_BW_40;
9116 	} else if (rate == mcs_rate[index].supported_rate[2]) {
9117 		*bw |= RATE_INFO_BW_20;
9118 		*flags |= RATE_INFO_FLAGS_SHORT_GI;
9119 	} else if (rate == mcs_rate[index].supported_rate[3]) {
9120 		*bw |= RATE_INFO_BW_40;
9121 		*flags |= RATE_INFO_FLAGS_SHORT_GI;
9122 	} else {
9123 		ath10k_warn(ar, "invalid ht params rate %d 100kbps nss %d mcs %d",
9124 			    rate, nss, mcs);
9125 	}
9126 }
9127 
ath10k_mac_get_rate_flags_vht(struct ath10k * ar,u32 rate,u8 nss,u8 mcs,u8 * flags,u8 * bw)9128 static void ath10k_mac_get_rate_flags_vht(struct ath10k *ar, u32 rate, u8 nss, u8 mcs,
9129 					  u8 *flags, u8 *bw)
9130 {
9131 	struct ath10k_index_vht_data_rate_type *mcs_rate;
9132 
9133 	mcs_rate = (struct ath10k_index_vht_data_rate_type *)
9134 		   ((nss == 1) ? &supported_vht_mcs_rate_nss1 :
9135 		   &supported_vht_mcs_rate_nss2);
9136 
9137 	if (rate == mcs_rate[mcs].supported_VHT80_rate[0]) {
9138 		*bw = RATE_INFO_BW_80;
9139 	} else if (rate == mcs_rate[mcs].supported_VHT80_rate[1]) {
9140 		*bw = RATE_INFO_BW_80;
9141 		*flags |= RATE_INFO_FLAGS_SHORT_GI;
9142 	} else if (rate == mcs_rate[mcs].supported_VHT40_rate[0]) {
9143 		*bw = RATE_INFO_BW_40;
9144 	} else if (rate == mcs_rate[mcs].supported_VHT40_rate[1]) {
9145 		*bw = RATE_INFO_BW_40;
9146 		*flags |= RATE_INFO_FLAGS_SHORT_GI;
9147 	} else if (rate == mcs_rate[mcs].supported_VHT20_rate[0]) {
9148 		*bw = RATE_INFO_BW_20;
9149 	} else if (rate == mcs_rate[mcs].supported_VHT20_rate[1]) {
9150 		*bw = RATE_INFO_BW_20;
9151 		*flags |= RATE_INFO_FLAGS_SHORT_GI;
9152 	} else {
9153 		ath10k_warn(ar, "invalid vht params rate %d 100kbps nss %d mcs %d",
9154 			    rate, nss, mcs);
9155 	}
9156 }
9157 
ath10k_mac_get_rate_flags(struct ath10k * ar,u32 rate,enum ath10k_phy_mode mode,u8 nss,u8 mcs,u8 * flags,u8 * bw)9158 static void ath10k_mac_get_rate_flags(struct ath10k *ar, u32 rate,
9159 				      enum ath10k_phy_mode mode, u8 nss, u8 mcs,
9160 				      u8 *flags, u8 *bw)
9161 {
9162 	if (mode == ATH10K_PHY_MODE_HT) {
9163 		*flags = RATE_INFO_FLAGS_MCS;
9164 		ath10k_mac_get_rate_flags_ht(ar, rate, nss, mcs, flags, bw);
9165 	} else if (mode == ATH10K_PHY_MODE_VHT) {
9166 		*flags = RATE_INFO_FLAGS_VHT_MCS;
9167 		ath10k_mac_get_rate_flags_vht(ar, rate, nss, mcs, flags, bw);
9168 	}
9169 }
9170 
ath10k_mac_parse_bitrate(struct ath10k * ar,u32 rate_code,u32 bitrate_kbps,struct rate_info * rate)9171 static void ath10k_mac_parse_bitrate(struct ath10k *ar, u32 rate_code,
9172 				     u32 bitrate_kbps, struct rate_info *rate)
9173 {
9174 	enum ath10k_phy_mode mode = ATH10K_PHY_MODE_LEGACY;
9175 	enum wmi_rate_preamble preamble = WMI_TLV_GET_HW_RC_PREAM_V1(rate_code);
9176 	u8 nss = WMI_TLV_GET_HW_RC_NSS_V1(rate_code) + 1;
9177 	u8 mcs = WMI_TLV_GET_HW_RC_RATE_V1(rate_code);
9178 	u8 flags = 0, bw = 0;
9179 
9180 	ath10k_dbg(ar, ATH10K_DBG_MAC, "mac parse rate code 0x%x bitrate %d kbps\n",
9181 		   rate_code, bitrate_kbps);
9182 
9183 	if (preamble == WMI_RATE_PREAMBLE_HT)
9184 		mode = ATH10K_PHY_MODE_HT;
9185 	else if (preamble == WMI_RATE_PREAMBLE_VHT)
9186 		mode = ATH10K_PHY_MODE_VHT;
9187 
9188 	ath10k_mac_get_rate_flags(ar, bitrate_kbps / 100, mode, nss, mcs, &flags, &bw);
9189 
9190 	ath10k_dbg(ar, ATH10K_DBG_MAC,
9191 		   "mac parse bitrate preamble %d mode %d nss %d mcs %d flags %x bw %d\n",
9192 		   preamble, mode, nss, mcs, flags, bw);
9193 
9194 	rate->flags = flags;
9195 	rate->bw = bw;
9196 	rate->legacy = bitrate_kbps / 100;
9197 	rate->nss = nss;
9198 	rate->mcs = mcs;
9199 }
9200 
ath10k_mac_sta_get_peer_stats_info(struct ath10k * ar,struct ieee80211_sta * sta,struct station_info * sinfo)9201 static void ath10k_mac_sta_get_peer_stats_info(struct ath10k *ar,
9202 					       struct ieee80211_sta *sta,
9203 					       struct station_info *sinfo)
9204 {
9205 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
9206 	struct ath10k_peer *peer;
9207 	unsigned long time_left;
9208 	int ret;
9209 
9210 	if (!(ar->hw_params.supports_peer_stats_info &&
9211 	      arsta->arvif->vdev_type == WMI_VDEV_TYPE_STA))
9212 		return;
9213 
9214 	spin_lock_bh(&ar->data_lock);
9215 	peer = ath10k_peer_find(ar, arsta->arvif->vdev_id, sta->addr);
9216 	spin_unlock_bh(&ar->data_lock);
9217 	if (!peer)
9218 		return;
9219 
9220 	reinit_completion(&ar->peer_stats_info_complete);
9221 
9222 	ret = ath10k_wmi_request_peer_stats_info(ar,
9223 						 arsta->arvif->vdev_id,
9224 						 WMI_REQUEST_ONE_PEER_STATS_INFO,
9225 						 arsta->arvif->bssid,
9226 						 0);
9227 	if (ret && ret != -EOPNOTSUPP) {
9228 		ath10k_warn(ar, "could not request peer stats info: %d\n", ret);
9229 		return;
9230 	}
9231 
9232 	time_left = wait_for_completion_timeout(&ar->peer_stats_info_complete, 3 * HZ);
9233 	if (time_left == 0) {
9234 		ath10k_warn(ar, "timed out waiting peer stats info\n");
9235 		return;
9236 	}
9237 
9238 	if (arsta->rx_rate_code != 0 && arsta->rx_bitrate_kbps != 0) {
9239 		ath10k_mac_parse_bitrate(ar, arsta->rx_rate_code,
9240 					 arsta->rx_bitrate_kbps,
9241 					 &sinfo->rxrate);
9242 
9243 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE);
9244 		arsta->rx_rate_code = 0;
9245 		arsta->rx_bitrate_kbps = 0;
9246 	}
9247 
9248 	if (arsta->tx_rate_code != 0 && arsta->tx_bitrate_kbps != 0) {
9249 		ath10k_mac_parse_bitrate(ar, arsta->tx_rate_code,
9250 					 arsta->tx_bitrate_kbps,
9251 					 &sinfo->txrate);
9252 
9253 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
9254 		arsta->tx_rate_code = 0;
9255 		arsta->tx_bitrate_kbps = 0;
9256 	}
9257 }
9258 
ath10k_sta_statistics(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct station_info * sinfo)9259 static void ath10k_sta_statistics(struct ieee80211_hw *hw,
9260 				  struct ieee80211_vif *vif,
9261 				  struct ieee80211_sta *sta,
9262 				  struct station_info *sinfo)
9263 {
9264 	struct ath10k_sta *arsta = (struct ath10k_sta *)sta->drv_priv;
9265 	struct ath10k *ar = arsta->arvif->ar;
9266 
9267 	if (!ath10k_peer_stats_enabled(ar))
9268 		return;
9269 
9270 	mutex_lock(&ar->conf_mutex);
9271 	ath10k_debug_fw_stats_request(ar);
9272 	mutex_unlock(&ar->conf_mutex);
9273 
9274 	sinfo->rx_duration = arsta->rx_duration;
9275 	sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_DURATION);
9276 
9277 	if (arsta->txrate.legacy || arsta->txrate.nss) {
9278 		if (arsta->txrate.legacy) {
9279 			sinfo->txrate.legacy = arsta->txrate.legacy;
9280 		} else {
9281 			sinfo->txrate.mcs = arsta->txrate.mcs;
9282 			sinfo->txrate.nss = arsta->txrate.nss;
9283 			sinfo->txrate.bw = arsta->txrate.bw;
9284 		}
9285 		sinfo->txrate.flags = arsta->txrate.flags;
9286 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
9287 	}
9288 
9289 	if (ar->htt.disable_tx_comp) {
9290 		sinfo->tx_failed = arsta->tx_failed;
9291 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
9292 	}
9293 
9294 	sinfo->tx_retries = arsta->tx_retries;
9295 	sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
9296 
9297 	ath10k_mac_sta_get_peer_stats_info(ar, sta, sinfo);
9298 }
9299 
ath10k_mac_op_set_tid_config(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct cfg80211_tid_config * tid_config)9300 static int ath10k_mac_op_set_tid_config(struct ieee80211_hw *hw,
9301 					struct ieee80211_vif *vif,
9302 					struct ieee80211_sta *sta,
9303 					struct cfg80211_tid_config *tid_config)
9304 {
9305 	struct ath10k *ar = hw->priv;
9306 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
9307 	struct ath10k_mac_iter_tid_conf_data data = {};
9308 	struct wmi_per_peer_per_tid_cfg_arg arg = {};
9309 	int ret, i;
9310 
9311 	mutex_lock(&ar->conf_mutex);
9312 	arg.vdev_id = arvif->vdev_id;
9313 
9314 	arvif->tids_rst = 0;
9315 	memset(arvif->tid_conf_changed, 0, sizeof(arvif->tid_conf_changed));
9316 
9317 	for (i = 0; i < tid_config->n_tid_conf; i++) {
9318 		ret = ath10k_mac_parse_tid_config(ar, sta, vif,
9319 						  &tid_config->tid_conf[i],
9320 						  &arg);
9321 		if (ret)
9322 			goto exit;
9323 	}
9324 
9325 	ret = 0;
9326 
9327 	if (sta)
9328 		goto exit;
9329 
9330 	arvif->tids_rst = 0;
9331 	data.curr_vif = vif;
9332 	data.ar = ar;
9333 
9334 	ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,
9335 					  &data);
9336 
9337 exit:
9338 	mutex_unlock(&ar->conf_mutex);
9339 	return ret;
9340 }
9341 
ath10k_mac_op_reset_tid_config(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u8 tids)9342 static int ath10k_mac_op_reset_tid_config(struct ieee80211_hw *hw,
9343 					  struct ieee80211_vif *vif,
9344 					  struct ieee80211_sta *sta,
9345 					  u8 tids)
9346 {
9347 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
9348 	struct ath10k_mac_iter_tid_conf_data data = {};
9349 	struct ath10k *ar = hw->priv;
9350 	int ret = 0;
9351 
9352 	mutex_lock(&ar->conf_mutex);
9353 
9354 	if (sta) {
9355 		arvif->tids_rst = 0;
9356 		ret = ath10k_mac_reset_tid_config(ar, sta, arvif, tids);
9357 		goto exit;
9358 	}
9359 
9360 	arvif->tids_rst = tids;
9361 	data.curr_vif = vif;
9362 	data.ar = ar;
9363 	ieee80211_iterate_stations_atomic(hw, ath10k_mac_vif_stations_tid_conf,
9364 					  &data);
9365 
9366 exit:
9367 	mutex_unlock(&ar->conf_mutex);
9368 	return ret;
9369 }
9370 
9371 static const struct ieee80211_ops ath10k_ops = {
9372 	.tx				= ath10k_mac_op_tx,
9373 	.wake_tx_queue			= ath10k_mac_op_wake_tx_queue,
9374 	.start				= ath10k_start,
9375 	.stop				= ath10k_stop,
9376 	.config				= ath10k_config,
9377 	.add_interface			= ath10k_add_interface,
9378 	.remove_interface		= ath10k_remove_interface,
9379 	.configure_filter		= ath10k_configure_filter,
9380 	.bss_info_changed		= ath10k_bss_info_changed,
9381 	.set_coverage_class		= ath10k_mac_op_set_coverage_class,
9382 	.hw_scan			= ath10k_hw_scan,
9383 	.cancel_hw_scan			= ath10k_cancel_hw_scan,
9384 	.set_key			= ath10k_set_key,
9385 	.set_default_unicast_key        = ath10k_set_default_unicast_key,
9386 	.sta_state			= ath10k_sta_state,
9387 	.sta_set_txpwr			= ath10k_sta_set_txpwr,
9388 	.conf_tx			= ath10k_conf_tx,
9389 	.remain_on_channel		= ath10k_remain_on_channel,
9390 	.cancel_remain_on_channel	= ath10k_cancel_remain_on_channel,
9391 	.set_rts_threshold		= ath10k_set_rts_threshold,
9392 	.set_frag_threshold		= ath10k_mac_op_set_frag_threshold,
9393 	.flush				= ath10k_flush,
9394 	.tx_last_beacon			= ath10k_tx_last_beacon,
9395 	.set_antenna			= ath10k_set_antenna,
9396 	.get_antenna			= ath10k_get_antenna,
9397 	.reconfig_complete		= ath10k_reconfig_complete,
9398 	.get_survey			= ath10k_get_survey,
9399 	.set_bitrate_mask		= ath10k_mac_op_set_bitrate_mask,
9400 	.sta_rc_update			= ath10k_sta_rc_update,
9401 	.offset_tsf			= ath10k_offset_tsf,
9402 	.ampdu_action			= ath10k_ampdu_action,
9403 	.get_et_sset_count		= ath10k_debug_get_et_sset_count,
9404 	.get_et_stats			= ath10k_debug_get_et_stats,
9405 	.get_et_strings			= ath10k_debug_get_et_strings,
9406 	.add_chanctx			= ath10k_mac_op_add_chanctx,
9407 	.remove_chanctx			= ath10k_mac_op_remove_chanctx,
9408 	.change_chanctx			= ath10k_mac_op_change_chanctx,
9409 	.assign_vif_chanctx		= ath10k_mac_op_assign_vif_chanctx,
9410 	.unassign_vif_chanctx		= ath10k_mac_op_unassign_vif_chanctx,
9411 	.switch_vif_chanctx		= ath10k_mac_op_switch_vif_chanctx,
9412 	.sta_pre_rcu_remove		= ath10k_mac_op_sta_pre_rcu_remove,
9413 	.sta_statistics			= ath10k_sta_statistics,
9414 	.set_tid_config			= ath10k_mac_op_set_tid_config,
9415 	.reset_tid_config		= ath10k_mac_op_reset_tid_config,
9416 
9417 	CFG80211_TESTMODE_CMD(ath10k_tm_cmd)
9418 
9419 #ifdef CONFIG_PM
9420 	.suspend			= ath10k_wow_op_suspend,
9421 	.resume				= ath10k_wow_op_resume,
9422 	.set_wakeup			= ath10k_wow_op_set_wakeup,
9423 #endif
9424 #ifdef CONFIG_MAC80211_DEBUGFS
9425 	.sta_add_debugfs		= ath10k_sta_add_debugfs,
9426 #endif
9427 	.set_sar_specs			= ath10k_mac_set_sar_specs,
9428 };
9429 
9430 #define CHAN2G(_channel, _freq, _flags) { \
9431 	.band			= NL80211_BAND_2GHZ, \
9432 	.hw_value		= (_channel), \
9433 	.center_freq		= (_freq), \
9434 	.flags			= (_flags), \
9435 	.max_antenna_gain	= 0, \
9436 	.max_power		= 30, \
9437 }
9438 
9439 #define CHAN5G(_channel, _freq, _flags) { \
9440 	.band			= NL80211_BAND_5GHZ, \
9441 	.hw_value		= (_channel), \
9442 	.center_freq		= (_freq), \
9443 	.flags			= (_flags), \
9444 	.max_antenna_gain	= 0, \
9445 	.max_power		= 30, \
9446 }
9447 
9448 static const struct ieee80211_channel ath10k_2ghz_channels[] = {
9449 	CHAN2G(1, 2412, 0),
9450 	CHAN2G(2, 2417, 0),
9451 	CHAN2G(3, 2422, 0),
9452 	CHAN2G(4, 2427, 0),
9453 	CHAN2G(5, 2432, 0),
9454 	CHAN2G(6, 2437, 0),
9455 	CHAN2G(7, 2442, 0),
9456 	CHAN2G(8, 2447, 0),
9457 	CHAN2G(9, 2452, 0),
9458 	CHAN2G(10, 2457, 0),
9459 	CHAN2G(11, 2462, 0),
9460 	CHAN2G(12, 2467, 0),
9461 	CHAN2G(13, 2472, 0),
9462 	CHAN2G(14, 2484, 0),
9463 };
9464 
9465 static const struct ieee80211_channel ath10k_5ghz_channels[] = {
9466 	CHAN5G(36, 5180, 0),
9467 	CHAN5G(40, 5200, 0),
9468 	CHAN5G(44, 5220, 0),
9469 	CHAN5G(48, 5240, 0),
9470 	CHAN5G(52, 5260, 0),
9471 	CHAN5G(56, 5280, 0),
9472 	CHAN5G(60, 5300, 0),
9473 	CHAN5G(64, 5320, 0),
9474 	CHAN5G(100, 5500, 0),
9475 	CHAN5G(104, 5520, 0),
9476 	CHAN5G(108, 5540, 0),
9477 	CHAN5G(112, 5560, 0),
9478 	CHAN5G(116, 5580, 0),
9479 	CHAN5G(120, 5600, 0),
9480 	CHAN5G(124, 5620, 0),
9481 	CHAN5G(128, 5640, 0),
9482 	CHAN5G(132, 5660, 0),
9483 	CHAN5G(136, 5680, 0),
9484 	CHAN5G(140, 5700, 0),
9485 	CHAN5G(144, 5720, 0),
9486 	CHAN5G(149, 5745, 0),
9487 	CHAN5G(153, 5765, 0),
9488 	CHAN5G(157, 5785, 0),
9489 	CHAN5G(161, 5805, 0),
9490 	CHAN5G(165, 5825, 0),
9491 	CHAN5G(169, 5845, 0),
9492 	CHAN5G(173, 5865, 0),
9493 	/* If you add more, you may need to change ATH10K_MAX_5G_CHAN */
9494 	/* And you will definitely need to change ATH10K_NUM_CHANS in core.h */
9495 };
9496 
ath10k_mac_create(size_t priv_size)9497 struct ath10k *ath10k_mac_create(size_t priv_size)
9498 {
9499 	struct ieee80211_hw *hw;
9500 	struct ieee80211_ops *ops;
9501 	struct ath10k *ar;
9502 
9503 	ops = kmemdup(&ath10k_ops, sizeof(ath10k_ops), GFP_KERNEL);
9504 	if (!ops)
9505 		return NULL;
9506 
9507 	hw = ieee80211_alloc_hw(sizeof(struct ath10k) + priv_size, ops);
9508 	if (!hw) {
9509 		kfree(ops);
9510 		return NULL;
9511 	}
9512 
9513 	ar = hw->priv;
9514 	ar->hw = hw;
9515 	ar->ops = ops;
9516 
9517 	return ar;
9518 }
9519 
ath10k_mac_destroy(struct ath10k * ar)9520 void ath10k_mac_destroy(struct ath10k *ar)
9521 {
9522 	struct ieee80211_ops *ops = ar->ops;
9523 
9524 	ieee80211_free_hw(ar->hw);
9525 	kfree(ops);
9526 }
9527 
9528 static const struct ieee80211_iface_limit ath10k_if_limits[] = {
9529 	{
9530 		.max	= 8,
9531 		.types	= BIT(NL80211_IFTYPE_STATION)
9532 			| BIT(NL80211_IFTYPE_P2P_CLIENT)
9533 	},
9534 	{
9535 		.max	= 3,
9536 		.types	= BIT(NL80211_IFTYPE_P2P_GO)
9537 	},
9538 	{
9539 		.max	= 1,
9540 		.types	= BIT(NL80211_IFTYPE_P2P_DEVICE)
9541 	},
9542 	{
9543 		.max	= 7,
9544 		.types	= BIT(NL80211_IFTYPE_AP)
9545 #ifdef CONFIG_MAC80211_MESH
9546 			| BIT(NL80211_IFTYPE_MESH_POINT)
9547 #endif
9548 	},
9549 };
9550 
9551 static const struct ieee80211_iface_limit ath10k_10x_if_limits[] = {
9552 	{
9553 		.max	= 8,
9554 		.types	= BIT(NL80211_IFTYPE_AP)
9555 #ifdef CONFIG_MAC80211_MESH
9556 			| BIT(NL80211_IFTYPE_MESH_POINT)
9557 #endif
9558 	},
9559 	{
9560 		.max	= 1,
9561 		.types	= BIT(NL80211_IFTYPE_STATION)
9562 	},
9563 };
9564 
9565 static const struct ieee80211_iface_combination ath10k_if_comb[] = {
9566 	{
9567 		.limits = ath10k_if_limits,
9568 		.n_limits = ARRAY_SIZE(ath10k_if_limits),
9569 		.max_interfaces = 8,
9570 		.num_different_channels = 1,
9571 		.beacon_int_infra_match = true,
9572 	},
9573 };
9574 
9575 static const struct ieee80211_iface_combination ath10k_10x_if_comb[] = {
9576 	{
9577 		.limits = ath10k_10x_if_limits,
9578 		.n_limits = ARRAY_SIZE(ath10k_10x_if_limits),
9579 		.max_interfaces = 8,
9580 		.num_different_channels = 1,
9581 		.beacon_int_infra_match = true,
9582 		.beacon_int_min_gcd = 1,
9583 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9584 		.radar_detect_widths =	BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9585 					BIT(NL80211_CHAN_WIDTH_20) |
9586 					BIT(NL80211_CHAN_WIDTH_40) |
9587 					BIT(NL80211_CHAN_WIDTH_80),
9588 #endif
9589 	},
9590 };
9591 
9592 static const struct ieee80211_iface_limit ath10k_tlv_if_limit[] = {
9593 	{
9594 		.max = 2,
9595 		.types = BIT(NL80211_IFTYPE_STATION),
9596 	},
9597 	{
9598 		.max = 2,
9599 		.types = BIT(NL80211_IFTYPE_AP) |
9600 #ifdef CONFIG_MAC80211_MESH
9601 			 BIT(NL80211_IFTYPE_MESH_POINT) |
9602 #endif
9603 			 BIT(NL80211_IFTYPE_P2P_CLIENT) |
9604 			 BIT(NL80211_IFTYPE_P2P_GO),
9605 	},
9606 	{
9607 		.max = 1,
9608 		.types = BIT(NL80211_IFTYPE_P2P_DEVICE),
9609 	},
9610 };
9611 
9612 static const struct ieee80211_iface_limit ath10k_tlv_qcs_if_limit[] = {
9613 	{
9614 		.max = 2,
9615 		.types = BIT(NL80211_IFTYPE_STATION),
9616 	},
9617 	{
9618 		.max = 2,
9619 		.types = BIT(NL80211_IFTYPE_P2P_CLIENT),
9620 	},
9621 	{
9622 		.max = 1,
9623 		.types = BIT(NL80211_IFTYPE_AP) |
9624 #ifdef CONFIG_MAC80211_MESH
9625 			 BIT(NL80211_IFTYPE_MESH_POINT) |
9626 #endif
9627 			 BIT(NL80211_IFTYPE_P2P_GO),
9628 	},
9629 	{
9630 		.max = 1,
9631 		.types = BIT(NL80211_IFTYPE_P2P_DEVICE),
9632 	},
9633 };
9634 
9635 static const struct ieee80211_iface_limit ath10k_tlv_if_limit_ibss[] = {
9636 	{
9637 		.max = 1,
9638 		.types = BIT(NL80211_IFTYPE_STATION),
9639 	},
9640 	{
9641 		.max = 1,
9642 		.types = BIT(NL80211_IFTYPE_ADHOC),
9643 	},
9644 };
9645 
9646 /* FIXME: This is not thouroughly tested. These combinations may over- or
9647  * underestimate hw/fw capabilities.
9648  */
9649 static struct ieee80211_iface_combination ath10k_tlv_if_comb[] = {
9650 	{
9651 		.limits = ath10k_tlv_if_limit,
9652 		.num_different_channels = 1,
9653 		.max_interfaces = 4,
9654 		.n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
9655 	},
9656 	{
9657 		.limits = ath10k_tlv_if_limit_ibss,
9658 		.num_different_channels = 1,
9659 		.max_interfaces = 2,
9660 		.n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
9661 	},
9662 };
9663 
9664 static struct ieee80211_iface_combination ath10k_tlv_qcs_if_comb[] = {
9665 	{
9666 		.limits = ath10k_tlv_if_limit,
9667 		.num_different_channels = 1,
9668 		.max_interfaces = 4,
9669 		.n_limits = ARRAY_SIZE(ath10k_tlv_if_limit),
9670 	},
9671 	{
9672 		.limits = ath10k_tlv_qcs_if_limit,
9673 		.num_different_channels = 2,
9674 		.max_interfaces = 4,
9675 		.n_limits = ARRAY_SIZE(ath10k_tlv_qcs_if_limit),
9676 	},
9677 	{
9678 		.limits = ath10k_tlv_if_limit_ibss,
9679 		.num_different_channels = 1,
9680 		.max_interfaces = 2,
9681 		.n_limits = ARRAY_SIZE(ath10k_tlv_if_limit_ibss),
9682 	},
9683 };
9684 
9685 static const struct ieee80211_iface_limit ath10k_10_4_if_limits[] = {
9686 	{
9687 		.max = 1,
9688 		.types = BIT(NL80211_IFTYPE_STATION),
9689 	},
9690 	{
9691 		.max	= 16,
9692 		.types	= BIT(NL80211_IFTYPE_AP)
9693 #ifdef CONFIG_MAC80211_MESH
9694 			| BIT(NL80211_IFTYPE_MESH_POINT)
9695 #endif
9696 	},
9697 };
9698 
9699 static const struct ieee80211_iface_combination ath10k_10_4_if_comb[] = {
9700 	{
9701 		.limits = ath10k_10_4_if_limits,
9702 		.n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
9703 		.max_interfaces = 16,
9704 		.num_different_channels = 1,
9705 		.beacon_int_infra_match = true,
9706 		.beacon_int_min_gcd = 1,
9707 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9708 		.radar_detect_widths =	BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9709 					BIT(NL80211_CHAN_WIDTH_20) |
9710 					BIT(NL80211_CHAN_WIDTH_40) |
9711 					BIT(NL80211_CHAN_WIDTH_80) |
9712 					BIT(NL80211_CHAN_WIDTH_80P80) |
9713 					BIT(NL80211_CHAN_WIDTH_160),
9714 #endif
9715 	},
9716 };
9717 
9718 static const struct
9719 ieee80211_iface_combination ath10k_10_4_bcn_int_if_comb[] = {
9720 	{
9721 		.limits = ath10k_10_4_if_limits,
9722 		.n_limits = ARRAY_SIZE(ath10k_10_4_if_limits),
9723 		.max_interfaces = 16,
9724 		.num_different_channels = 1,
9725 		.beacon_int_infra_match = true,
9726 		.beacon_int_min_gcd = 100,
9727 #ifdef CONFIG_ATH10K_DFS_CERTIFIED
9728 		.radar_detect_widths =  BIT(NL80211_CHAN_WIDTH_20_NOHT) |
9729 					BIT(NL80211_CHAN_WIDTH_20) |
9730 					BIT(NL80211_CHAN_WIDTH_40) |
9731 					BIT(NL80211_CHAN_WIDTH_80) |
9732 					BIT(NL80211_CHAN_WIDTH_80P80) |
9733 					BIT(NL80211_CHAN_WIDTH_160),
9734 #endif
9735 	},
9736 };
9737 
ath10k_get_arvif_iter(void * data,u8 * mac,struct ieee80211_vif * vif)9738 static void ath10k_get_arvif_iter(void *data, u8 *mac,
9739 				  struct ieee80211_vif *vif)
9740 {
9741 	struct ath10k_vif_iter *arvif_iter = data;
9742 	struct ath10k_vif *arvif = (void *)vif->drv_priv;
9743 
9744 	if (arvif->vdev_id == arvif_iter->vdev_id)
9745 		arvif_iter->arvif = arvif;
9746 }
9747 
ath10k_get_arvif(struct ath10k * ar,u32 vdev_id)9748 struct ath10k_vif *ath10k_get_arvif(struct ath10k *ar, u32 vdev_id)
9749 {
9750 	struct ath10k_vif_iter arvif_iter;
9751 
9752 	memset(&arvif_iter, 0, sizeof(struct ath10k_vif_iter));
9753 	arvif_iter.vdev_id = vdev_id;
9754 
9755 	ieee80211_iterate_active_interfaces_atomic(ar->hw,
9756 						   ATH10K_ITER_RESUME_FLAGS,
9757 						   ath10k_get_arvif_iter,
9758 						   &arvif_iter);
9759 	if (!arvif_iter.arvif) {
9760 		ath10k_warn(ar, "No VIF found for vdev %d\n", vdev_id);
9761 		return NULL;
9762 	}
9763 
9764 	return arvif_iter.arvif;
9765 }
9766 
9767 #define WRD_METHOD "WRDD"
9768 #define WRDD_WIFI  (0x07)
9769 
ath10k_mac_wrdd_get_mcc(struct ath10k * ar,union acpi_object * wrdd)9770 static u32 ath10k_mac_wrdd_get_mcc(struct ath10k *ar, union acpi_object *wrdd)
9771 {
9772 	union acpi_object *mcc_pkg;
9773 	union acpi_object *domain_type;
9774 	union acpi_object *mcc_value;
9775 	u32 i;
9776 
9777 	if (wrdd->type != ACPI_TYPE_PACKAGE ||
9778 	    wrdd->package.count < 2 ||
9779 	    wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||
9780 	    wrdd->package.elements[0].integer.value != 0) {
9781 		ath10k_warn(ar, "ignoring malformed/unsupported wrdd structure\n");
9782 		return 0;
9783 	}
9784 
9785 	for (i = 1; i < wrdd->package.count; ++i) {
9786 		mcc_pkg = &wrdd->package.elements[i];
9787 
9788 		if (mcc_pkg->type != ACPI_TYPE_PACKAGE)
9789 			continue;
9790 		if (mcc_pkg->package.count < 2)
9791 			continue;
9792 		if (mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||
9793 		    mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER)
9794 			continue;
9795 
9796 		domain_type = &mcc_pkg->package.elements[0];
9797 		if (domain_type->integer.value != WRDD_WIFI)
9798 			continue;
9799 
9800 		mcc_value = &mcc_pkg->package.elements[1];
9801 		return mcc_value->integer.value;
9802 	}
9803 	return 0;
9804 }
9805 
ath10k_mac_get_wrdd_regulatory(struct ath10k * ar,u16 * rd)9806 static int ath10k_mac_get_wrdd_regulatory(struct ath10k *ar, u16 *rd)
9807 {
9808 	acpi_handle root_handle;
9809 	acpi_handle handle;
9810 	struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};
9811 	acpi_status status;
9812 	u32 alpha2_code;
9813 	char alpha2[3];
9814 
9815 	root_handle = ACPI_HANDLE(ar->dev);
9816 	if (!root_handle)
9817 		return -EOPNOTSUPP;
9818 
9819 	status = acpi_get_handle(root_handle, (acpi_string)WRD_METHOD, &handle);
9820 	if (ACPI_FAILURE(status)) {
9821 		ath10k_dbg(ar, ATH10K_DBG_BOOT,
9822 			   "failed to get wrd method %d\n", status);
9823 		return -EIO;
9824 	}
9825 
9826 	status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);
9827 	if (ACPI_FAILURE(status)) {
9828 		ath10k_dbg(ar, ATH10K_DBG_BOOT,
9829 			   "failed to call wrdc %d\n", status);
9830 		return -EIO;
9831 	}
9832 
9833 	alpha2_code = ath10k_mac_wrdd_get_mcc(ar, wrdd.pointer);
9834 	kfree(wrdd.pointer);
9835 	if (!alpha2_code)
9836 		return -EIO;
9837 
9838 	alpha2[0] = (alpha2_code >> 8) & 0xff;
9839 	alpha2[1] = (alpha2_code >> 0) & 0xff;
9840 	alpha2[2] = '\0';
9841 
9842 	ath10k_dbg(ar, ATH10K_DBG_BOOT,
9843 		   "regulatory hint from WRDD (alpha2-code): %s\n", alpha2);
9844 
9845 	*rd = ath_regd_find_country_by_name(alpha2);
9846 	if (*rd == 0xffff)
9847 		return -EIO;
9848 
9849 	*rd |= COUNTRY_ERD_FLAG;
9850 	return 0;
9851 }
9852 
ath10k_mac_init_rd(struct ath10k * ar)9853 static int ath10k_mac_init_rd(struct ath10k *ar)
9854 {
9855 	int ret;
9856 	u16 rd;
9857 
9858 	ret = ath10k_mac_get_wrdd_regulatory(ar, &rd);
9859 	if (ret) {
9860 		ath10k_dbg(ar, ATH10K_DBG_BOOT,
9861 			   "fallback to eeprom programmed regulatory settings\n");
9862 		rd = ar->hw_eeprom_rd;
9863 	}
9864 
9865 	ar->ath_common.regulatory.current_rd = rd;
9866 	return 0;
9867 }
9868 
ath10k_mac_register(struct ath10k * ar)9869 int ath10k_mac_register(struct ath10k *ar)
9870 {
9871 	static const u32 cipher_suites[] = {
9872 		WLAN_CIPHER_SUITE_WEP40,
9873 		WLAN_CIPHER_SUITE_WEP104,
9874 		WLAN_CIPHER_SUITE_TKIP,
9875 		WLAN_CIPHER_SUITE_CCMP,
9876 
9877 		/* Do not add hardware supported ciphers before this line.
9878 		 * Allow software encryption for all chips. Don't forget to
9879 		 * update n_cipher_suites below.
9880 		 */
9881 		WLAN_CIPHER_SUITE_AES_CMAC,
9882 		WLAN_CIPHER_SUITE_BIP_CMAC_256,
9883 		WLAN_CIPHER_SUITE_BIP_GMAC_128,
9884 		WLAN_CIPHER_SUITE_BIP_GMAC_256,
9885 
9886 		/* Only QCA99x0 and QCA4019 varients support GCMP-128, GCMP-256
9887 		 * and CCMP-256 in hardware.
9888 		 */
9889 		WLAN_CIPHER_SUITE_GCMP,
9890 		WLAN_CIPHER_SUITE_GCMP_256,
9891 		WLAN_CIPHER_SUITE_CCMP_256,
9892 	};
9893 	struct ieee80211_supported_band *band;
9894 	void *channels;
9895 	int ret;
9896 
9897 	if (!is_valid_ether_addr(ar->mac_addr)) {
9898 		ath10k_warn(ar, "invalid MAC address; choosing random\n");
9899 		eth_random_addr(ar->mac_addr);
9900 	}
9901 	SET_IEEE80211_PERM_ADDR(ar->hw, ar->mac_addr);
9902 
9903 	SET_IEEE80211_DEV(ar->hw, ar->dev);
9904 
9905 	BUILD_BUG_ON((ARRAY_SIZE(ath10k_2ghz_channels) +
9906 		      ARRAY_SIZE(ath10k_5ghz_channels)) !=
9907 		     ATH10K_NUM_CHANS);
9908 
9909 	if (ar->phy_capability & WHAL_WLAN_11G_CAPABILITY) {
9910 		channels = kmemdup(ath10k_2ghz_channels,
9911 				   sizeof(ath10k_2ghz_channels),
9912 				   GFP_KERNEL);
9913 		if (!channels) {
9914 			ret = -ENOMEM;
9915 			goto err_free;
9916 		}
9917 
9918 		band = &ar->mac.sbands[NL80211_BAND_2GHZ];
9919 		band->n_channels = ARRAY_SIZE(ath10k_2ghz_channels);
9920 		band->channels = channels;
9921 
9922 		if (ar->hw_params.cck_rate_map_rev2) {
9923 			band->n_bitrates = ath10k_g_rates_rev2_size;
9924 			band->bitrates = ath10k_g_rates_rev2;
9925 		} else {
9926 			band->n_bitrates = ath10k_g_rates_size;
9927 			band->bitrates = ath10k_g_rates;
9928 		}
9929 
9930 		ar->hw->wiphy->bands[NL80211_BAND_2GHZ] = band;
9931 	}
9932 
9933 	if (ar->phy_capability & WHAL_WLAN_11A_CAPABILITY) {
9934 		channels = kmemdup(ath10k_5ghz_channels,
9935 				   sizeof(ath10k_5ghz_channels),
9936 				   GFP_KERNEL);
9937 		if (!channels) {
9938 			ret = -ENOMEM;
9939 			goto err_free;
9940 		}
9941 
9942 		band = &ar->mac.sbands[NL80211_BAND_5GHZ];
9943 		band->n_channels = ARRAY_SIZE(ath10k_5ghz_channels);
9944 		band->channels = channels;
9945 		band->n_bitrates = ath10k_a_rates_size;
9946 		band->bitrates = ath10k_a_rates;
9947 		ar->hw->wiphy->bands[NL80211_BAND_5GHZ] = band;
9948 	}
9949 
9950 	wiphy_read_of_freq_limits(ar->hw->wiphy);
9951 	ath10k_mac_setup_ht_vht_cap(ar);
9952 
9953 	ar->hw->wiphy->interface_modes =
9954 		BIT(NL80211_IFTYPE_STATION) |
9955 		BIT(NL80211_IFTYPE_AP) |
9956 		BIT(NL80211_IFTYPE_MESH_POINT);
9957 
9958 	ar->hw->wiphy->available_antennas_rx = ar->cfg_rx_chainmask;
9959 	ar->hw->wiphy->available_antennas_tx = ar->cfg_tx_chainmask;
9960 
9961 	if (!test_bit(ATH10K_FW_FEATURE_NO_P2P, ar->normal_mode_fw.fw_file.fw_features))
9962 		ar->hw->wiphy->interface_modes |=
9963 			BIT(NL80211_IFTYPE_P2P_DEVICE) |
9964 			BIT(NL80211_IFTYPE_P2P_CLIENT) |
9965 			BIT(NL80211_IFTYPE_P2P_GO);
9966 
9967 	ieee80211_hw_set(ar->hw, SIGNAL_DBM);
9968 
9969 	if (!test_bit(ATH10K_FW_FEATURE_NO_PS,
9970 		      ar->running_fw->fw_file.fw_features)) {
9971 		ieee80211_hw_set(ar->hw, SUPPORTS_PS);
9972 		ieee80211_hw_set(ar->hw, SUPPORTS_DYNAMIC_PS);
9973 	}
9974 
9975 	ieee80211_hw_set(ar->hw, MFP_CAPABLE);
9976 	ieee80211_hw_set(ar->hw, REPORTS_TX_ACK_STATUS);
9977 	ieee80211_hw_set(ar->hw, HAS_RATE_CONTROL);
9978 	ieee80211_hw_set(ar->hw, AP_LINK_PS);
9979 	ieee80211_hw_set(ar->hw, SPECTRUM_MGMT);
9980 	ieee80211_hw_set(ar->hw, SUPPORT_FAST_XMIT);
9981 	ieee80211_hw_set(ar->hw, CONNECTION_MONITOR);
9982 	ieee80211_hw_set(ar->hw, SUPPORTS_PER_STA_GTK);
9983 	ieee80211_hw_set(ar->hw, WANT_MONITOR_VIF);
9984 	ieee80211_hw_set(ar->hw, CHANCTX_STA_CSA);
9985 	ieee80211_hw_set(ar->hw, QUEUE_CONTROL);
9986 	ieee80211_hw_set(ar->hw, SUPPORTS_TX_FRAG);
9987 	ieee80211_hw_set(ar->hw, REPORTS_LOW_ACK);
9988 
9989 	if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
9990 		ieee80211_hw_set(ar->hw, SW_CRYPTO_CONTROL);
9991 
9992 	ar->hw->wiphy->features |= NL80211_FEATURE_STATIC_SMPS;
9993 	ar->hw->wiphy->flags |= WIPHY_FLAG_IBSS_RSN;
9994 
9995 	if (ar->ht_cap_info & WMI_HT_CAP_DYNAMIC_SMPS)
9996 		ar->hw->wiphy->features |= NL80211_FEATURE_DYNAMIC_SMPS;
9997 
9998 	if (ar->ht_cap_info & WMI_HT_CAP_ENABLED) {
9999 		ieee80211_hw_set(ar->hw, AMPDU_AGGREGATION);
10000 		ieee80211_hw_set(ar->hw, TX_AMPDU_SETUP_IN_HW);
10001 	}
10002 
10003 	ar->hw->wiphy->max_scan_ssids = WLAN_SCAN_PARAMS_MAX_SSID;
10004 	ar->hw->wiphy->max_scan_ie_len = WLAN_SCAN_PARAMS_MAX_IE_LEN;
10005 
10006 	if (test_bit(WMI_SERVICE_NLO, ar->wmi.svc_map)) {
10007 		ar->hw->wiphy->max_sched_scan_ssids = WMI_PNO_MAX_SUPP_NETWORKS;
10008 		ar->hw->wiphy->max_match_sets = WMI_PNO_MAX_SUPP_NETWORKS;
10009 		ar->hw->wiphy->max_sched_scan_ie_len = WMI_PNO_MAX_IE_LENGTH;
10010 		ar->hw->wiphy->max_sched_scan_plans = WMI_PNO_MAX_SCHED_SCAN_PLANS;
10011 		ar->hw->wiphy->max_sched_scan_plan_interval =
10012 			WMI_PNO_MAX_SCHED_SCAN_PLAN_INT;
10013 		ar->hw->wiphy->max_sched_scan_plan_iterations =
10014 			WMI_PNO_MAX_SCHED_SCAN_PLAN_ITRNS;
10015 		ar->hw->wiphy->features |= NL80211_FEATURE_ND_RANDOM_MAC_ADDR;
10016 	}
10017 
10018 	ar->hw->vif_data_size = sizeof(struct ath10k_vif);
10019 	ar->hw->sta_data_size = sizeof(struct ath10k_sta);
10020 	ar->hw->txq_data_size = sizeof(struct ath10k_txq);
10021 
10022 	ar->hw->max_listen_interval = ATH10K_MAX_HW_LISTEN_INTERVAL;
10023 
10024 	if (test_bit(WMI_SERVICE_BEACON_OFFLOAD, ar->wmi.svc_map)) {
10025 		ar->hw->wiphy->flags |= WIPHY_FLAG_AP_PROBE_RESP_OFFLOAD;
10026 
10027 		/* Firmware delivers WPS/P2P Probe Requests frames to driver so
10028 		 * that userspace (e.g. wpa_supplicant/hostapd) can generate
10029 		 * correct Probe Responses. This is more of a hack advert..
10030 		 */
10031 		ar->hw->wiphy->probe_resp_offload |=
10032 			NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS |
10033 			NL80211_PROBE_RESP_OFFLOAD_SUPPORT_WPS2 |
10034 			NL80211_PROBE_RESP_OFFLOAD_SUPPORT_P2P;
10035 	}
10036 
10037 	if (test_bit(WMI_SERVICE_TDLS, ar->wmi.svc_map) ||
10038 	    test_bit(WMI_SERVICE_TDLS_EXPLICIT_MODE_ONLY, ar->wmi.svc_map)) {
10039 		ar->hw->wiphy->flags |= WIPHY_FLAG_SUPPORTS_TDLS;
10040 		if (test_bit(WMI_SERVICE_TDLS_WIDER_BANDWIDTH, ar->wmi.svc_map))
10041 			ieee80211_hw_set(ar->hw, TDLS_WIDER_BW);
10042 	}
10043 
10044 	if (test_bit(WMI_SERVICE_TDLS_UAPSD_BUFFER_STA, ar->wmi.svc_map))
10045 		ieee80211_hw_set(ar->hw, SUPPORTS_TDLS_BUFFER_STA);
10046 
10047 	ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL;
10048 	ar->hw->wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH;
10049 	ar->hw->wiphy->max_remain_on_channel_duration = 5000;
10050 
10051 	ar->hw->wiphy->flags |= WIPHY_FLAG_AP_UAPSD;
10052 	ar->hw->wiphy->features |= NL80211_FEATURE_AP_MODE_CHAN_WIDTH_CHANGE |
10053 				   NL80211_FEATURE_AP_SCAN;
10054 
10055 	ar->hw->wiphy->max_ap_assoc_sta = ar->max_num_stations;
10056 
10057 	ret = ath10k_wow_init(ar);
10058 	if (ret) {
10059 		ath10k_warn(ar, "failed to init wow: %d\n", ret);
10060 		goto err_free;
10061 	}
10062 
10063 	wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_VHT_IBSS);
10064 	wiphy_ext_feature_set(ar->hw->wiphy,
10065 			      NL80211_EXT_FEATURE_SET_SCAN_DWELL);
10066 	wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_AQL);
10067 
10068 	if (test_bit(WMI_SERVICE_TX_DATA_ACK_RSSI, ar->wmi.svc_map) ||
10069 	    test_bit(WMI_SERVICE_HTT_MGMT_TX_COMP_VALID_FLAGS, ar->wmi.svc_map))
10070 		wiphy_ext_feature_set(ar->hw->wiphy,
10071 				      NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT);
10072 
10073 	if (ath10k_peer_stats_enabled(ar) ||
10074 	    test_bit(WMI_SERVICE_REPORT_AIRTIME, ar->wmi.svc_map))
10075 		wiphy_ext_feature_set(ar->hw->wiphy,
10076 				      NL80211_EXT_FEATURE_AIRTIME_FAIRNESS);
10077 
10078 	if (test_bit(WMI_SERVICE_RTT_RESPONDER_ROLE, ar->wmi.svc_map))
10079 		wiphy_ext_feature_set(ar->hw->wiphy,
10080 				      NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER);
10081 
10082 	if (test_bit(WMI_SERVICE_TX_PWR_PER_PEER, ar->wmi.svc_map))
10083 		wiphy_ext_feature_set(ar->hw->wiphy,
10084 				      NL80211_EXT_FEATURE_STA_TX_PWR);
10085 
10086 	if (test_bit(WMI_SERVICE_PEER_TID_CONFIGS_SUPPORT, ar->wmi.svc_map)) {
10087 		ar->hw->wiphy->tid_config_support.vif |=
10088 				BIT(NL80211_TID_CONFIG_ATTR_NOACK) |
10089 				BIT(NL80211_TID_CONFIG_ATTR_RETRY_SHORT) |
10090 				BIT(NL80211_TID_CONFIG_ATTR_RETRY_LONG) |
10091 				BIT(NL80211_TID_CONFIG_ATTR_AMPDU_CTRL) |
10092 				BIT(NL80211_TID_CONFIG_ATTR_TX_RATE) |
10093 				BIT(NL80211_TID_CONFIG_ATTR_TX_RATE_TYPE);
10094 
10095 		if (test_bit(WMI_SERVICE_EXT_PEER_TID_CONFIGS_SUPPORT,
10096 			     ar->wmi.svc_map)) {
10097 			ar->hw->wiphy->tid_config_support.vif |=
10098 				BIT(NL80211_TID_CONFIG_ATTR_RTSCTS_CTRL);
10099 		}
10100 
10101 		ar->hw->wiphy->tid_config_support.peer =
10102 				ar->hw->wiphy->tid_config_support.vif;
10103 		ar->hw->wiphy->max_data_retry_count = ATH10K_MAX_RETRY_COUNT;
10104 	} else {
10105 		ar->ops->set_tid_config = NULL;
10106 	}
10107 	/*
10108 	 * on LL hardware queues are managed entirely by the FW
10109 	 * so we only advertise to mac we can do the queues thing
10110 	 */
10111 	ar->hw->queues = IEEE80211_MAX_QUEUES;
10112 
10113 	/* vdev_ids are used as hw queue numbers. Make sure offchan tx queue is
10114 	 * something that vdev_ids can't reach so that we don't stop the queue
10115 	 * accidentally.
10116 	 */
10117 	ar->hw->offchannel_tx_hw_queue = IEEE80211_MAX_QUEUES - 1;
10118 
10119 	switch (ar->running_fw->fw_file.wmi_op_version) {
10120 	case ATH10K_FW_WMI_OP_VERSION_MAIN:
10121 		ar->hw->wiphy->iface_combinations = ath10k_if_comb;
10122 		ar->hw->wiphy->n_iface_combinations =
10123 			ARRAY_SIZE(ath10k_if_comb);
10124 		ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
10125 		break;
10126 	case ATH10K_FW_WMI_OP_VERSION_TLV:
10127 		if (test_bit(WMI_SERVICE_ADAPTIVE_OCS, ar->wmi.svc_map)) {
10128 			ar->hw->wiphy->iface_combinations =
10129 				ath10k_tlv_qcs_if_comb;
10130 			ar->hw->wiphy->n_iface_combinations =
10131 				ARRAY_SIZE(ath10k_tlv_qcs_if_comb);
10132 		} else {
10133 			ar->hw->wiphy->iface_combinations = ath10k_tlv_if_comb;
10134 			ar->hw->wiphy->n_iface_combinations =
10135 				ARRAY_SIZE(ath10k_tlv_if_comb);
10136 		}
10137 		ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_ADHOC);
10138 		break;
10139 	case ATH10K_FW_WMI_OP_VERSION_10_1:
10140 	case ATH10K_FW_WMI_OP_VERSION_10_2:
10141 	case ATH10K_FW_WMI_OP_VERSION_10_2_4:
10142 		ar->hw->wiphy->iface_combinations = ath10k_10x_if_comb;
10143 		ar->hw->wiphy->n_iface_combinations =
10144 			ARRAY_SIZE(ath10k_10x_if_comb);
10145 		break;
10146 	case ATH10K_FW_WMI_OP_VERSION_10_4:
10147 		ar->hw->wiphy->iface_combinations = ath10k_10_4_if_comb;
10148 		ar->hw->wiphy->n_iface_combinations =
10149 			ARRAY_SIZE(ath10k_10_4_if_comb);
10150 		if (test_bit(WMI_SERVICE_VDEV_DIFFERENT_BEACON_INTERVAL_SUPPORT,
10151 			     ar->wmi.svc_map)) {
10152 			ar->hw->wiphy->iface_combinations =
10153 				ath10k_10_4_bcn_int_if_comb;
10154 			ar->hw->wiphy->n_iface_combinations =
10155 				ARRAY_SIZE(ath10k_10_4_bcn_int_if_comb);
10156 		}
10157 		break;
10158 	case ATH10K_FW_WMI_OP_VERSION_UNSET:
10159 	case ATH10K_FW_WMI_OP_VERSION_MAX:
10160 		WARN_ON(1);
10161 		ret = -EINVAL;
10162 		goto err_free;
10163 	}
10164 
10165 	if (ar->hw_params.dynamic_sar_support)
10166 		ar->hw->wiphy->sar_capa = &ath10k_sar_capa;
10167 
10168 	if (!test_bit(ATH10K_FLAG_RAW_MODE, &ar->dev_flags))
10169 		ar->hw->netdev_features = NETIF_F_HW_CSUM;
10170 
10171 	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED)) {
10172 		/* Init ath dfs pattern detector */
10173 		ar->ath_common.debug_mask = ATH_DBG_DFS;
10174 		ar->dfs_detector = dfs_pattern_detector_init(&ar->ath_common,
10175 							     NL80211_DFS_UNSET);
10176 
10177 		if (!ar->dfs_detector)
10178 			ath10k_warn(ar, "failed to initialise DFS pattern detector\n");
10179 	}
10180 
10181 	ret = ath10k_mac_init_rd(ar);
10182 	if (ret) {
10183 		ath10k_err(ar, "failed to derive regdom: %d\n", ret);
10184 		goto err_dfs_detector_exit;
10185 	}
10186 
10187 	/* Disable set_coverage_class for chipsets that do not support it. */
10188 	if (!ar->hw_params.hw_ops->set_coverage_class)
10189 		ar->ops->set_coverage_class = NULL;
10190 
10191 	ret = ath_regd_init(&ar->ath_common.regulatory, ar->hw->wiphy,
10192 			    ath10k_reg_notifier);
10193 	if (ret) {
10194 		ath10k_err(ar, "failed to initialise regulatory: %i\n", ret);
10195 		goto err_dfs_detector_exit;
10196 	}
10197 
10198 	if (test_bit(WMI_SERVICE_SPOOF_MAC_SUPPORT, ar->wmi.svc_map)) {
10199 		ar->hw->wiphy->features |=
10200 			NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR;
10201 	}
10202 
10203 	ar->hw->wiphy->cipher_suites = cipher_suites;
10204 
10205 	/* QCA988x and QCA6174 family chips do not support CCMP-256, GCMP-128
10206 	 * and GCMP-256 ciphers in hardware. Fetch number of ciphers supported
10207 	 * from chip specific hw_param table.
10208 	 */
10209 	if (!ar->hw_params.n_cipher_suites ||
10210 	    ar->hw_params.n_cipher_suites > ARRAY_SIZE(cipher_suites)) {
10211 		ath10k_err(ar, "invalid hw_params.n_cipher_suites %d\n",
10212 			   ar->hw_params.n_cipher_suites);
10213 		ar->hw_params.n_cipher_suites = 8;
10214 	}
10215 	ar->hw->wiphy->n_cipher_suites = ar->hw_params.n_cipher_suites;
10216 
10217 	wiphy_ext_feature_set(ar->hw->wiphy, NL80211_EXT_FEATURE_CQM_RSSI_LIST);
10218 
10219 	ar->hw->weight_multiplier = ATH10K_AIRTIME_WEIGHT_MULTIPLIER;
10220 
10221 	ret = ieee80211_register_hw(ar->hw);
10222 	if (ret) {
10223 		ath10k_err(ar, "failed to register ieee80211: %d\n", ret);
10224 		goto err_dfs_detector_exit;
10225 	}
10226 
10227 	if (test_bit(WMI_SERVICE_PER_PACKET_SW_ENCRYPT, ar->wmi.svc_map)) {
10228 		ar->hw->wiphy->interface_modes |= BIT(NL80211_IFTYPE_AP_VLAN);
10229 		ar->hw->wiphy->software_iftypes |= BIT(NL80211_IFTYPE_AP_VLAN);
10230 	}
10231 
10232 	if (!ath_is_world_regd(&ar->ath_common.regulatory)) {
10233 		ret = regulatory_hint(ar->hw->wiphy,
10234 				      ar->ath_common.regulatory.alpha2);
10235 		if (ret)
10236 			goto err_unregister;
10237 	}
10238 
10239 	return 0;
10240 
10241 err_unregister:
10242 	ieee80211_unregister_hw(ar->hw);
10243 
10244 err_dfs_detector_exit:
10245 	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
10246 		ar->dfs_detector->exit(ar->dfs_detector);
10247 
10248 err_free:
10249 	kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
10250 	kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
10251 
10252 	SET_IEEE80211_DEV(ar->hw, NULL);
10253 	return ret;
10254 }
10255 
ath10k_mac_unregister(struct ath10k * ar)10256 void ath10k_mac_unregister(struct ath10k *ar)
10257 {
10258 	ieee80211_unregister_hw(ar->hw);
10259 
10260 	if (IS_ENABLED(CONFIG_ATH10K_DFS_CERTIFIED) && ar->dfs_detector)
10261 		ar->dfs_detector->exit(ar->dfs_detector);
10262 
10263 	kfree(ar->mac.sbands[NL80211_BAND_2GHZ].channels);
10264 	kfree(ar->mac.sbands[NL80211_BAND_5GHZ].channels);
10265 
10266 	SET_IEEE80211_DEV(ar->hw, NULL);
10267 }
10268