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