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