1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2020 MediaTek Inc. */
3 
4 #include <linux/firmware.h>
5 #include <linux/fs.h>
6 #include "mt7915.h"
7 #include "mcu.h"
8 #include "mac.h"
9 #include "eeprom.h"
10 
11 struct mt7915_patch_hdr {
12 	char build_date[16];
13 	char platform[4];
14 	__be32 hw_sw_ver;
15 	__be32 patch_ver;
16 	__be16 checksum;
17 	u16 reserved;
18 	struct {
19 		__be32 patch_ver;
20 		__be32 subsys;
21 		__be32 feature;
22 		__be32 n_region;
23 		__be32 crc;
24 		u32 reserved[11];
25 	} desc;
26 } __packed;
27 
28 struct mt7915_patch_sec {
29 	__be32 type;
30 	__be32 offs;
31 	__be32 size;
32 	union {
33 		__be32 spec[13];
34 		struct {
35 			__be32 addr;
36 			__be32 len;
37 			__be32 sec_key_idx;
38 			__be32 align_len;
39 			u32 reserved[9];
40 		} info;
41 	};
42 } __packed;
43 
44 struct mt7915_fw_trailer {
45 	u8 chip_id;
46 	u8 eco_code;
47 	u8 n_region;
48 	u8 format_ver;
49 	u8 format_flag;
50 	u8 reserved[2];
51 	char fw_ver[10];
52 	char build_date[15];
53 	u32 crc;
54 } __packed;
55 
56 struct mt7915_fw_region {
57 	__le32 decomp_crc;
58 	__le32 decomp_len;
59 	__le32 decomp_blk_sz;
60 	u8 reserved[4];
61 	__le32 addr;
62 	__le32 len;
63 	u8 feature_set;
64 	u8 reserved1[15];
65 } __packed;
66 
67 #define MCU_PATCH_ADDRESS		0x200000
68 
69 #define FW_FEATURE_SET_ENCRYPT		BIT(0)
70 #define FW_FEATURE_SET_KEY_IDX		GENMASK(2, 1)
71 #define FW_FEATURE_OVERRIDE_ADDR	BIT(5)
72 
73 #define DL_MODE_ENCRYPT			BIT(0)
74 #define DL_MODE_KEY_IDX			GENMASK(2, 1)
75 #define DL_MODE_RESET_SEC_IV		BIT(3)
76 #define DL_MODE_WORKING_PDA_CR4		BIT(4)
77 #define DL_MODE_NEED_RSP		BIT(31)
78 
79 #define FW_START_OVERRIDE		BIT(0)
80 #define FW_START_WORKING_PDA_CR4	BIT(2)
81 
82 #define PATCH_SEC_TYPE_MASK		GENMASK(15, 0)
83 #define PATCH_SEC_TYPE_INFO		0x2
84 
85 #define to_wcid_lo(id)			FIELD_GET(GENMASK(7, 0), (u16)id)
86 #define to_wcid_hi(id)			FIELD_GET(GENMASK(9, 8), (u16)id)
87 
88 #define HE_PHY(p, c)			u8_get_bits(c, IEEE80211_HE_PHY_##p)
89 #define HE_MAC(m, c)			u8_get_bits(c, IEEE80211_HE_MAC_##m)
90 
91 static enum mcu_cipher_type
92 mt7915_mcu_get_cipher(int cipher)
93 {
94 	switch (cipher) {
95 	case WLAN_CIPHER_SUITE_WEP40:
96 		return MCU_CIPHER_WEP40;
97 	case WLAN_CIPHER_SUITE_WEP104:
98 		return MCU_CIPHER_WEP104;
99 	case WLAN_CIPHER_SUITE_TKIP:
100 		return MCU_CIPHER_TKIP;
101 	case WLAN_CIPHER_SUITE_AES_CMAC:
102 		return MCU_CIPHER_BIP_CMAC_128;
103 	case WLAN_CIPHER_SUITE_CCMP:
104 		return MCU_CIPHER_AES_CCMP;
105 	case WLAN_CIPHER_SUITE_CCMP_256:
106 		return MCU_CIPHER_CCMP_256;
107 	case WLAN_CIPHER_SUITE_GCMP:
108 		return MCU_CIPHER_GCMP;
109 	case WLAN_CIPHER_SUITE_GCMP_256:
110 		return MCU_CIPHER_GCMP_256;
111 	case WLAN_CIPHER_SUITE_SMS4:
112 		return MCU_CIPHER_WAPI;
113 	default:
114 		return MCU_CIPHER_NONE;
115 	}
116 }
117 
118 static u8 mt7915_mcu_chan_bw(struct cfg80211_chan_def *chandef)
119 {
120 	static const u8 width_to_bw[] = {
121 		[NL80211_CHAN_WIDTH_40] = CMD_CBW_40MHZ,
122 		[NL80211_CHAN_WIDTH_80] = CMD_CBW_80MHZ,
123 		[NL80211_CHAN_WIDTH_80P80] = CMD_CBW_8080MHZ,
124 		[NL80211_CHAN_WIDTH_160] = CMD_CBW_160MHZ,
125 		[NL80211_CHAN_WIDTH_5] = CMD_CBW_5MHZ,
126 		[NL80211_CHAN_WIDTH_10] = CMD_CBW_10MHZ,
127 		[NL80211_CHAN_WIDTH_20] = CMD_CBW_20MHZ,
128 		[NL80211_CHAN_WIDTH_20_NOHT] = CMD_CBW_20MHZ,
129 	};
130 
131 	if (chandef->width >= ARRAY_SIZE(width_to_bw))
132 		return 0;
133 
134 	return width_to_bw[chandef->width];
135 }
136 
137 static const struct ieee80211_sta_he_cap *
138 mt7915_get_he_phy_cap(struct mt7915_phy *phy, struct ieee80211_vif *vif)
139 {
140 	struct ieee80211_supported_band *sband;
141 	enum nl80211_band band;
142 
143 	band = phy->mt76->chandef.chan->band;
144 	sband = phy->mt76->hw->wiphy->bands[band];
145 
146 	return ieee80211_get_he_iftype_cap(sband, vif->type);
147 }
148 
149 static u8
150 mt7915_get_phy_mode(struct ieee80211_vif *vif, struct ieee80211_sta *sta)
151 {
152 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
153 	enum nl80211_band band = mvif->phy->mt76->chandef.chan->band;
154 	struct ieee80211_sta_ht_cap *ht_cap;
155 	struct ieee80211_sta_vht_cap *vht_cap;
156 	const struct ieee80211_sta_he_cap *he_cap;
157 	u8 mode = 0;
158 
159 	if (sta) {
160 		ht_cap = &sta->ht_cap;
161 		vht_cap = &sta->vht_cap;
162 		he_cap = &sta->he_cap;
163 	} else {
164 		struct ieee80211_supported_band *sband;
165 
166 		sband = mvif->phy->mt76->hw->wiphy->bands[band];
167 
168 		ht_cap = &sband->ht_cap;
169 		vht_cap = &sband->vht_cap;
170 		he_cap = ieee80211_get_he_iftype_cap(sband, vif->type);
171 	}
172 
173 	if (band == NL80211_BAND_2GHZ) {
174 		mode |= PHY_MODE_B | PHY_MODE_G;
175 
176 		if (ht_cap->ht_supported)
177 			mode |= PHY_MODE_GN;
178 
179 		if (he_cap->has_he)
180 			mode |= PHY_MODE_AX_24G;
181 	} else if (band == NL80211_BAND_5GHZ) {
182 		mode |= PHY_MODE_A;
183 
184 		if (ht_cap->ht_supported)
185 			mode |= PHY_MODE_AN;
186 
187 		if (vht_cap->vht_supported)
188 			mode |= PHY_MODE_AC;
189 
190 		if (he_cap->has_he)
191 			mode |= PHY_MODE_AX_5G;
192 	}
193 
194 	return mode;
195 }
196 
197 static u8
198 mt7915_mcu_get_sta_nss(u16 mcs_map)
199 {
200 	u8 nss;
201 
202 	for (nss = 8; nss > 0; nss--) {
203 		u8 nss_mcs = (mcs_map >> (2 * (nss - 1))) & 3;
204 
205 		if (nss_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED)
206 			break;
207 	}
208 
209 	return nss - 1;
210 }
211 
212 static void
213 mt7915_mcu_set_sta_he_mcs(struct ieee80211_sta *sta, __le16 *he_mcs,
214 			  const u16 *mask)
215 {
216 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
217 	struct cfg80211_chan_def *chandef = &msta->vif->phy->mt76->chandef;
218 	int nss, max_nss = sta->rx_nss > 3 ? 4 : sta->rx_nss;
219 	u16 mcs_map;
220 
221 	switch (chandef->width) {
222 	case NL80211_CHAN_WIDTH_80P80:
223 		mcs_map = le16_to_cpu(sta->he_cap.he_mcs_nss_supp.rx_mcs_80p80);
224 		break;
225 	case NL80211_CHAN_WIDTH_160:
226 		mcs_map = le16_to_cpu(sta->he_cap.he_mcs_nss_supp.rx_mcs_160);
227 		break;
228 	default:
229 		mcs_map = le16_to_cpu(sta->he_cap.he_mcs_nss_supp.rx_mcs_80);
230 		break;
231 	}
232 
233 	for (nss = 0; nss < max_nss; nss++) {
234 		int mcs;
235 
236 		switch ((mcs_map >> (2 * nss)) & 0x3) {
237 		case IEEE80211_HE_MCS_SUPPORT_0_11:
238 			mcs = GENMASK(11, 0);
239 			break;
240 		case IEEE80211_HE_MCS_SUPPORT_0_9:
241 			mcs = GENMASK(9, 0);
242 			break;
243 		case IEEE80211_HE_MCS_SUPPORT_0_7:
244 			mcs = GENMASK(7, 0);
245 			break;
246 		default:
247 			mcs = 0;
248 		}
249 
250 		mcs = mcs ? fls(mcs & mask[nss]) - 1 : -1;
251 
252 		switch (mcs) {
253 		case 0 ... 7:
254 			mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
255 			break;
256 		case 8 ... 9:
257 			mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
258 			break;
259 		case 10 ... 11:
260 			mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
261 			break;
262 		default:
263 			mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
264 			break;
265 		}
266 		mcs_map &= ~(0x3 << (nss * 2));
267 		mcs_map |= mcs << (nss * 2);
268 
269 		/* only support 2ss on 160MHz */
270 		if (nss > 1 && (sta->bandwidth == IEEE80211_STA_RX_BW_160))
271 			break;
272 	}
273 
274 	*he_mcs = cpu_to_le16(mcs_map);
275 }
276 
277 static void
278 mt7915_mcu_set_sta_vht_mcs(struct ieee80211_sta *sta, __le16 *vht_mcs,
279 			   const u16 *mask)
280 {
281 	u16 mcs_map = le16_to_cpu(sta->vht_cap.vht_mcs.rx_mcs_map);
282 	int nss, max_nss = sta->rx_nss > 3 ? 4 : sta->rx_nss;
283 	u16 mcs;
284 
285 	for (nss = 0; nss < max_nss; nss++, mcs_map >>= 2) {
286 		switch (mcs_map & 0x3) {
287 		case IEEE80211_VHT_MCS_SUPPORT_0_9:
288 			mcs = GENMASK(9, 0);
289 			break;
290 		case IEEE80211_VHT_MCS_SUPPORT_0_8:
291 			mcs = GENMASK(8, 0);
292 			break;
293 		case IEEE80211_VHT_MCS_SUPPORT_0_7:
294 			mcs = GENMASK(7, 0);
295 			break;
296 		default:
297 			mcs = 0;
298 		}
299 
300 		vht_mcs[nss] = cpu_to_le16(mcs & mask[nss]);
301 
302 		/* only support 2ss on 160MHz */
303 		if (nss > 1 && (sta->bandwidth == IEEE80211_STA_RX_BW_160))
304 			break;
305 	}
306 }
307 
308 static void
309 mt7915_mcu_set_sta_ht_mcs(struct ieee80211_sta *sta, u8 *ht_mcs,
310 			  const u8 *mask)
311 {
312 	int nss, max_nss = sta->rx_nss > 3 ? 4 : sta->rx_nss;
313 
314 	for (nss = 0; nss < max_nss; nss++)
315 		ht_mcs[nss] = sta->ht_cap.mcs.rx_mask[nss] & mask[nss];
316 }
317 
318 static int
319 mt7915_mcu_parse_response(struct mt76_dev *mdev, int cmd,
320 			  struct sk_buff *skb, int seq)
321 {
322 	struct mt7915_mcu_rxd *rxd;
323 	int ret = 0;
324 
325 	if (!skb) {
326 		dev_err(mdev->dev, "Message %08x (seq %d) timeout\n",
327 			cmd, seq);
328 		return -ETIMEDOUT;
329 	}
330 
331 	rxd = (struct mt7915_mcu_rxd *)skb->data;
332 	if (seq != rxd->seq)
333 		return -EAGAIN;
334 
335 	if (cmd == MCU_CMD(PATCH_SEM_CONTROL)) {
336 		skb_pull(skb, sizeof(*rxd) - 4);
337 		ret = *skb->data;
338 	} else if (cmd == MCU_EXT_CMD(THERMAL_CTRL)) {
339 		skb_pull(skb, sizeof(*rxd) + 4);
340 		ret = le32_to_cpu(*(__le32 *)skb->data);
341 	} else {
342 		skb_pull(skb, sizeof(struct mt7915_mcu_rxd));
343 	}
344 
345 	return ret;
346 }
347 
348 static int
349 mt7915_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb,
350 			int cmd, int *wait_seq)
351 {
352 	struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76);
353 	struct mt7915_mcu_txd *mcu_txd;
354 	enum mt76_mcuq_id qid;
355 	__le32 *txd;
356 	u32 val;
357 	u8 seq;
358 
359 	/* TODO: make dynamic based on msg type */
360 	mdev->mcu.timeout = 20 * HZ;
361 
362 	seq = ++dev->mt76.mcu.msg_seq & 0xf;
363 	if (!seq)
364 		seq = ++dev->mt76.mcu.msg_seq & 0xf;
365 
366 	if (cmd == MCU_CMD(FW_SCATTER)) {
367 		qid = MT_MCUQ_FWDL;
368 		goto exit;
369 	}
370 
371 	mcu_txd = (struct mt7915_mcu_txd *)skb_push(skb, sizeof(*mcu_txd));
372 	if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state))
373 		qid = MT_MCUQ_WA;
374 	else
375 		qid = MT_MCUQ_WM;
376 
377 	txd = mcu_txd->txd;
378 
379 	val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) |
380 	      FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) |
381 	      FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0);
382 	txd[0] = cpu_to_le32(val);
383 
384 	val = MT_TXD1_LONG_FORMAT |
385 	      FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD);
386 	txd[1] = cpu_to_le32(val);
387 
388 	mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd));
389 	mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU,
390 					       MT_TX_MCU_PORT_RX_Q0));
391 	mcu_txd->pkt_type = MCU_PKT_ID;
392 	mcu_txd->seq = seq;
393 
394 	mcu_txd->cid = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
395 	mcu_txd->set_query = MCU_Q_NA;
396 	mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
397 	if (mcu_txd->ext_cid) {
398 		mcu_txd->ext_cid_ack = 1;
399 
400 		/* do not use Q_SET for efuse */
401 		if (cmd & __MCU_CMD_FIELD_QUERY)
402 			mcu_txd->set_query = MCU_Q_QUERY;
403 		else
404 			mcu_txd->set_query = MCU_Q_SET;
405 	}
406 
407 	if (cmd & __MCU_CMD_FIELD_WA)
408 		mcu_txd->s2d_index = MCU_S2D_H2C;
409 	else
410 		mcu_txd->s2d_index = MCU_S2D_H2N;
411 
412 exit:
413 	if (wait_seq)
414 		*wait_seq = seq;
415 
416 	return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[qid], skb, 0);
417 }
418 
419 static void
420 mt7915_mcu_wa_cmd(struct mt7915_dev *dev, int cmd, u32 a1, u32 a2, u32 a3)
421 {
422 	struct {
423 		__le32 args[3];
424 	} req = {
425 		.args = {
426 			cpu_to_le32(a1),
427 			cpu_to_le32(a2),
428 			cpu_to_le32(a3),
429 		},
430 	};
431 
432 	mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true);
433 }
434 
435 static void
436 mt7915_mcu_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif)
437 {
438 	if (vif->csa_active)
439 		ieee80211_csa_finish(vif);
440 }
441 
442 static void
443 mt7915_mcu_rx_csa_notify(struct mt7915_dev *dev, struct sk_buff *skb)
444 {
445 	struct mt76_phy *mphy = &dev->mt76.phy;
446 	struct mt7915_mcu_csa_notify *c;
447 
448 	c = (struct mt7915_mcu_csa_notify *)skb->data;
449 
450 	if (c->band_idx && dev->mt76.phy2)
451 		mphy = dev->mt76.phy2;
452 
453 	ieee80211_iterate_active_interfaces_atomic(mphy->hw,
454 			IEEE80211_IFACE_ITER_RESUME_ALL,
455 			mt7915_mcu_csa_finish, mphy->hw);
456 }
457 
458 static void
459 mt7915_mcu_rx_thermal_notify(struct mt7915_dev *dev, struct sk_buff *skb)
460 {
461 	struct mt76_phy *mphy = &dev->mt76.phy;
462 	struct mt7915_mcu_thermal_notify *t;
463 	struct mt7915_phy *phy;
464 
465 	t = (struct mt7915_mcu_thermal_notify *)skb->data;
466 	if (t->ctrl.ctrl_id != THERMAL_PROTECT_ENABLE)
467 		return;
468 
469 	if (t->ctrl.band_idx && dev->mt76.phy2)
470 		mphy = dev->mt76.phy2;
471 
472 	phy = (struct mt7915_phy *)mphy->priv;
473 	phy->throttle_state = t->ctrl.duty.duty_cycle;
474 }
475 
476 static void
477 mt7915_mcu_rx_radar_detected(struct mt7915_dev *dev, struct sk_buff *skb)
478 {
479 	struct mt76_phy *mphy = &dev->mt76.phy;
480 	struct mt7915_mcu_rdd_report *r;
481 
482 	r = (struct mt7915_mcu_rdd_report *)skb->data;
483 
484 	if (r->band_idx && dev->mt76.phy2)
485 		mphy = dev->mt76.phy2;
486 
487 	ieee80211_radar_detected(mphy->hw);
488 	dev->hw_pattern++;
489 }
490 
491 static int
492 mt7915_mcu_tx_rate_parse(struct mt76_phy *mphy, struct mt7915_mcu_ra_info *ra,
493 			 struct rate_info *rate, u16 r)
494 {
495 	struct ieee80211_supported_band *sband;
496 	u16 ru_idx = le16_to_cpu(ra->ru_idx);
497 	bool cck = false;
498 
499 	rate->mcs = FIELD_GET(MT_RA_RATE_MCS, r);
500 	rate->nss = FIELD_GET(MT_RA_RATE_NSS, r) + 1;
501 
502 	switch (FIELD_GET(MT_RA_RATE_TX_MODE, r)) {
503 	case MT_PHY_TYPE_CCK:
504 		cck = true;
505 		fallthrough;
506 	case MT_PHY_TYPE_OFDM:
507 		if (mphy->chandef.chan->band == NL80211_BAND_5GHZ)
508 			sband = &mphy->sband_5g.sband;
509 		else
510 			sband = &mphy->sband_2g.sband;
511 
512 		rate->mcs = mt76_get_rate(mphy->dev, sband, rate->mcs, cck);
513 		rate->legacy = sband->bitrates[rate->mcs].bitrate;
514 		break;
515 	case MT_PHY_TYPE_HT:
516 	case MT_PHY_TYPE_HT_GF:
517 		rate->mcs += (rate->nss - 1) * 8;
518 		if (rate->mcs > 31)
519 			return -EINVAL;
520 
521 		rate->flags = RATE_INFO_FLAGS_MCS;
522 		if (ra->gi)
523 			rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
524 		break;
525 	case MT_PHY_TYPE_VHT:
526 		if (rate->mcs > 9)
527 			return -EINVAL;
528 
529 		rate->flags = RATE_INFO_FLAGS_VHT_MCS;
530 		if (ra->gi)
531 			rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
532 		break;
533 	case MT_PHY_TYPE_HE_SU:
534 	case MT_PHY_TYPE_HE_EXT_SU:
535 	case MT_PHY_TYPE_HE_TB:
536 	case MT_PHY_TYPE_HE_MU:
537 		if (ra->gi > NL80211_RATE_INFO_HE_GI_3_2 || rate->mcs > 11)
538 			return -EINVAL;
539 
540 		rate->he_gi = ra->gi;
541 		rate->he_dcm = FIELD_GET(MT_RA_RATE_DCM_EN, r);
542 		rate->flags = RATE_INFO_FLAGS_HE_MCS;
543 		break;
544 	default:
545 		return -EINVAL;
546 	}
547 
548 	if (ru_idx) {
549 		switch (ru_idx) {
550 		case 1 ... 2:
551 			rate->he_ru_alloc = NL80211_RATE_INFO_HE_RU_ALLOC_996;
552 			break;
553 		case 3 ... 6:
554 			rate->he_ru_alloc = NL80211_RATE_INFO_HE_RU_ALLOC_484;
555 			break;
556 		case 7 ... 14:
557 			rate->he_ru_alloc = NL80211_RATE_INFO_HE_RU_ALLOC_242;
558 			break;
559 		default:
560 			rate->he_ru_alloc = NL80211_RATE_INFO_HE_RU_ALLOC_106;
561 			break;
562 		}
563 		rate->bw = RATE_INFO_BW_HE_RU;
564 	} else {
565 		u8 bw = mt7915_mcu_chan_bw(&mphy->chandef) -
566 			FIELD_GET(MT_RA_RATE_BW, r);
567 
568 		switch (bw) {
569 		case IEEE80211_STA_RX_BW_160:
570 			rate->bw = RATE_INFO_BW_160;
571 			break;
572 		case IEEE80211_STA_RX_BW_80:
573 			rate->bw = RATE_INFO_BW_80;
574 			break;
575 		case IEEE80211_STA_RX_BW_40:
576 			rate->bw = RATE_INFO_BW_40;
577 			break;
578 		default:
579 			rate->bw = RATE_INFO_BW_20;
580 			break;
581 		}
582 	}
583 
584 	return 0;
585 }
586 
587 static void
588 mt7915_mcu_tx_rate_report(struct mt7915_dev *dev, struct sk_buff *skb)
589 {
590 	struct mt7915_mcu_ra_info *ra = (struct mt7915_mcu_ra_info *)skb->data;
591 	struct rate_info rate = {}, prob_rate = {};
592 	u16 probe = le16_to_cpu(ra->prob_up_rate);
593 	u16 attempts = le16_to_cpu(ra->attempts);
594 	u16 curr = le16_to_cpu(ra->curr_rate);
595 	u16 wcidx = le16_to_cpu(ra->wlan_idx);
596 	struct ieee80211_tx_status status = {};
597 	struct mt76_phy *mphy = &dev->mphy;
598 	struct mt7915_sta_stats *stats;
599 	struct mt7915_sta *msta;
600 	struct mt76_wcid *wcid;
601 
602 	if (wcidx >= MT76_N_WCIDS)
603 		return;
604 
605 	wcid = rcu_dereference(dev->mt76.wcid[wcidx]);
606 	if (!wcid)
607 		return;
608 
609 	msta = container_of(wcid, struct mt7915_sta, wcid);
610 	stats = &msta->stats;
611 
612 	if (msta->wcid.ext_phy && dev->mt76.phy2)
613 		mphy = dev->mt76.phy2;
614 
615 	/* current rate */
616 	if (!mt7915_mcu_tx_rate_parse(mphy, ra, &rate, curr))
617 		stats->tx_rate = rate;
618 
619 	/* probing rate */
620 	if (!mt7915_mcu_tx_rate_parse(mphy, ra, &prob_rate, probe))
621 		stats->prob_rate = prob_rate;
622 
623 	if (attempts) {
624 		u16 success = le16_to_cpu(ra->success);
625 
626 		stats->per = 1000 * (attempts - success) / attempts;
627 	}
628 
629 	status.sta = wcid_to_sta(wcid);
630 	if (!status.sta)
631 		return;
632 
633 	status.rate = &stats->tx_rate;
634 	ieee80211_tx_status_ext(mphy->hw, &status);
635 }
636 
637 static void
638 mt7915_mcu_rx_log_message(struct mt7915_dev *dev, struct sk_buff *skb)
639 {
640 	struct mt7915_mcu_rxd *rxd = (struct mt7915_mcu_rxd *)skb->data;
641 	const char *data = (char *)&rxd[1];
642 	const char *type;
643 
644 	switch (rxd->s2d_index) {
645 	case 0:
646 		type = "WM";
647 		break;
648 	case 2:
649 		type = "WA";
650 		break;
651 	default:
652 		type = "unknown";
653 		break;
654 	}
655 
656 	wiphy_info(mt76_hw(dev)->wiphy, "%s: %.*s", type,
657 		   (int)(skb->len - sizeof(*rxd)), data);
658 }
659 
660 static void
661 mt7915_mcu_rx_ext_event(struct mt7915_dev *dev, struct sk_buff *skb)
662 {
663 	struct mt7915_mcu_rxd *rxd = (struct mt7915_mcu_rxd *)skb->data;
664 
665 	switch (rxd->ext_eid) {
666 	case MCU_EXT_EVENT_THERMAL_PROTECT:
667 		mt7915_mcu_rx_thermal_notify(dev, skb);
668 		break;
669 	case MCU_EXT_EVENT_RDD_REPORT:
670 		mt7915_mcu_rx_radar_detected(dev, skb);
671 		break;
672 	case MCU_EXT_EVENT_CSA_NOTIFY:
673 		mt7915_mcu_rx_csa_notify(dev, skb);
674 		break;
675 	case MCU_EXT_EVENT_RATE_REPORT:
676 		mt7915_mcu_tx_rate_report(dev, skb);
677 		break;
678 	case MCU_EXT_EVENT_FW_LOG_2_HOST:
679 		mt7915_mcu_rx_log_message(dev, skb);
680 		break;
681 	default:
682 		break;
683 	}
684 }
685 
686 static void
687 mt7915_mcu_rx_unsolicited_event(struct mt7915_dev *dev, struct sk_buff *skb)
688 {
689 	struct mt7915_mcu_rxd *rxd = (struct mt7915_mcu_rxd *)skb->data;
690 
691 	switch (rxd->eid) {
692 	case MCU_EVENT_EXT:
693 		mt7915_mcu_rx_ext_event(dev, skb);
694 		break;
695 	default:
696 		break;
697 	}
698 	dev_kfree_skb(skb);
699 }
700 
701 void mt7915_mcu_rx_event(struct mt7915_dev *dev, struct sk_buff *skb)
702 {
703 	struct mt7915_mcu_rxd *rxd = (struct mt7915_mcu_rxd *)skb->data;
704 
705 	if (rxd->ext_eid == MCU_EXT_EVENT_THERMAL_PROTECT ||
706 	    rxd->ext_eid == MCU_EXT_EVENT_FW_LOG_2_HOST ||
707 	    rxd->ext_eid == MCU_EXT_EVENT_ASSERT_DUMP ||
708 	    rxd->ext_eid == MCU_EXT_EVENT_PS_SYNC ||
709 	    rxd->ext_eid == MCU_EXT_EVENT_RATE_REPORT ||
710 	    !rxd->seq)
711 		mt7915_mcu_rx_unsolicited_event(dev, skb);
712 	else
713 		mt76_mcu_rx_event(&dev->mt76, skb);
714 }
715 
716 static struct sk_buff *
717 mt7915_mcu_alloc_sta_req(struct mt7915_dev *dev, struct mt7915_vif *mvif,
718 			 struct mt7915_sta *msta, int len)
719 {
720 	struct sta_req_hdr hdr = {
721 		.bss_idx = mvif->idx,
722 		.wlan_idx_lo = msta ? to_wcid_lo(msta->wcid.idx) : 0,
723 		.wlan_idx_hi = msta ? to_wcid_hi(msta->wcid.idx) : 0,
724 		.muar_idx = msta ? mvif->omac_idx : 0,
725 		.is_tlv_append = 1,
726 	};
727 	struct sk_buff *skb;
728 
729 	skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
730 	if (!skb)
731 		return ERR_PTR(-ENOMEM);
732 
733 	skb_put_data(skb, &hdr, sizeof(hdr));
734 
735 	return skb;
736 }
737 
738 static struct wtbl_req_hdr *
739 mt7915_mcu_alloc_wtbl_req(struct mt7915_dev *dev, struct mt7915_sta *msta,
740 			  int cmd, void *sta_wtbl, struct sk_buff **skb)
741 {
742 	struct tlv *sta_hdr = sta_wtbl;
743 	struct wtbl_req_hdr hdr = {
744 		.wlan_idx_lo = to_wcid_lo(msta->wcid.idx),
745 		.wlan_idx_hi = to_wcid_hi(msta->wcid.idx),
746 		.operation = cmd,
747 	};
748 	struct sk_buff *nskb = *skb;
749 
750 	if (!nskb) {
751 		nskb = mt76_mcu_msg_alloc(&dev->mt76, NULL,
752 					  MT7915_WTBL_UPDATE_MAX_SIZE);
753 		if (!nskb)
754 			return ERR_PTR(-ENOMEM);
755 
756 		*skb = nskb;
757 	}
758 
759 	if (sta_hdr)
760 		sta_hdr->len = cpu_to_le16(sizeof(hdr));
761 
762 	return skb_put_data(nskb, &hdr, sizeof(hdr));
763 }
764 
765 static struct tlv *
766 mt7915_mcu_add_nested_tlv(struct sk_buff *skb, int tag, int len,
767 			  void *sta_ntlv, void *sta_wtbl)
768 {
769 	struct sta_ntlv_hdr *ntlv_hdr = sta_ntlv;
770 	struct tlv *sta_hdr = sta_wtbl;
771 	struct tlv *ptlv, tlv = {
772 		.tag = cpu_to_le16(tag),
773 		.len = cpu_to_le16(len),
774 	};
775 	u16 ntlv;
776 
777 	ptlv = skb_put(skb, len);
778 	memcpy(ptlv, &tlv, sizeof(tlv));
779 
780 	ntlv = le16_to_cpu(ntlv_hdr->tlv_num);
781 	ntlv_hdr->tlv_num = cpu_to_le16(ntlv + 1);
782 
783 	if (sta_hdr) {
784 		u16 size = le16_to_cpu(sta_hdr->len);
785 
786 		sta_hdr->len = cpu_to_le16(size + len);
787 	}
788 
789 	return ptlv;
790 }
791 
792 static struct tlv *
793 mt7915_mcu_add_tlv(struct sk_buff *skb, int tag, int len)
794 {
795 	return mt7915_mcu_add_nested_tlv(skb, tag, len, skb->data, NULL);
796 }
797 
798 static struct tlv *
799 mt7915_mcu_add_nested_subtlv(struct sk_buff *skb, int sub_tag, int sub_len,
800 			     __le16 *sub_ntlv, __le16 *len)
801 {
802 	struct tlv *ptlv, tlv = {
803 		.tag = cpu_to_le16(sub_tag),
804 		.len = cpu_to_le16(sub_len),
805 	};
806 
807 	ptlv = skb_put(skb, sub_len);
808 	memcpy(ptlv, &tlv, sizeof(tlv));
809 
810 	le16_add_cpu(sub_ntlv, 1);
811 	le16_add_cpu(len, sub_len);
812 
813 	return ptlv;
814 }
815 
816 /** bss info **/
817 static int
818 mt7915_mcu_bss_basic_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
819 			 struct mt7915_phy *phy, bool enable)
820 {
821 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
822 	struct bss_info_basic *bss;
823 	u16 wlan_idx = mvif->sta.wcid.idx;
824 	u32 type = NETWORK_INFRA;
825 	struct tlv *tlv;
826 
827 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_BASIC, sizeof(*bss));
828 
829 	switch (vif->type) {
830 	case NL80211_IFTYPE_MESH_POINT:
831 	case NL80211_IFTYPE_AP:
832 	case NL80211_IFTYPE_MONITOR:
833 		break;
834 	case NL80211_IFTYPE_STATION:
835 		/* TODO: enable BSS_INFO_UAPSD & BSS_INFO_PM */
836 		if (enable) {
837 			struct ieee80211_sta *sta;
838 			struct mt7915_sta *msta;
839 
840 			rcu_read_lock();
841 			sta = ieee80211_find_sta(vif, vif->bss_conf.bssid);
842 			if (!sta) {
843 				rcu_read_unlock();
844 				return -EINVAL;
845 			}
846 
847 			msta = (struct mt7915_sta *)sta->drv_priv;
848 			wlan_idx = msta->wcid.idx;
849 			rcu_read_unlock();
850 		}
851 		break;
852 	case NL80211_IFTYPE_ADHOC:
853 		type = NETWORK_IBSS;
854 		break;
855 	default:
856 		WARN_ON(1);
857 		break;
858 	}
859 
860 	bss = (struct bss_info_basic *)tlv;
861 	bss->network_type = cpu_to_le32(type);
862 	bss->bmc_wcid_lo = to_wcid_lo(wlan_idx);
863 	bss->bmc_wcid_hi = to_wcid_hi(wlan_idx);
864 	bss->wmm_idx = mvif->wmm_idx;
865 	bss->active = enable;
866 
867 	if (vif->type != NL80211_IFTYPE_MONITOR) {
868 		memcpy(bss->bssid, vif->bss_conf.bssid, ETH_ALEN);
869 		bss->bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int);
870 		bss->dtim_period = vif->bss_conf.dtim_period;
871 		bss->phy_mode = mt7915_get_phy_mode(vif, NULL);
872 	} else {
873 		memcpy(bss->bssid, phy->mt76->macaddr, ETH_ALEN);
874 	}
875 
876 	return 0;
877 }
878 
879 static void
880 mt7915_mcu_bss_omac_tlv(struct sk_buff *skb, struct ieee80211_vif *vif)
881 {
882 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
883 	struct bss_info_omac *omac;
884 	struct tlv *tlv;
885 	u32 type = 0;
886 	u8 idx;
887 
888 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_OMAC, sizeof(*omac));
889 
890 	switch (vif->type) {
891 	case NL80211_IFTYPE_MONITOR:
892 	case NL80211_IFTYPE_MESH_POINT:
893 	case NL80211_IFTYPE_AP:
894 		type = CONNECTION_INFRA_AP;
895 		break;
896 	case NL80211_IFTYPE_STATION:
897 		type = CONNECTION_INFRA_STA;
898 		break;
899 	case NL80211_IFTYPE_ADHOC:
900 		type = CONNECTION_IBSS_ADHOC;
901 		break;
902 	default:
903 		WARN_ON(1);
904 		break;
905 	}
906 
907 	omac = (struct bss_info_omac *)tlv;
908 	idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx;
909 	omac->conn_type = cpu_to_le32(type);
910 	omac->omac_idx = mvif->omac_idx;
911 	omac->band_idx = mvif->band_idx;
912 	omac->hw_bss_idx = idx;
913 }
914 
915 struct mt7915_he_obss_narrow_bw_ru_data {
916 	bool tolerated;
917 };
918 
919 static void mt7915_check_he_obss_narrow_bw_ru_iter(struct wiphy *wiphy,
920 						   struct cfg80211_bss *bss,
921 						   void *_data)
922 {
923 	struct mt7915_he_obss_narrow_bw_ru_data *data = _data;
924 	const struct element *elem;
925 
926 	elem = ieee80211_bss_get_elem(bss, WLAN_EID_EXT_CAPABILITY);
927 
928 	if (!elem || elem->datalen < 10 ||
929 	    !(elem->data[10] &
930 	      WLAN_EXT_CAPA10_OBSS_NARROW_BW_RU_TOLERANCE_SUPPORT))
931 		data->tolerated = false;
932 }
933 
934 static bool mt7915_check_he_obss_narrow_bw_ru(struct ieee80211_hw *hw,
935 					      struct ieee80211_vif *vif)
936 {
937 	struct mt7915_he_obss_narrow_bw_ru_data iter_data = {
938 		.tolerated = true,
939 	};
940 
941 	if (!(vif->bss_conf.chandef.chan->flags & IEEE80211_CHAN_RADAR))
942 		return false;
943 
944 	cfg80211_bss_iter(hw->wiphy, &vif->bss_conf.chandef,
945 			  mt7915_check_he_obss_narrow_bw_ru_iter,
946 			  &iter_data);
947 
948 	/*
949 	 * If there is at least one AP on radar channel that cannot
950 	 * tolerate 26-tone RU UL OFDMA transmissions using HE TB PPDU.
951 	 */
952 	return !iter_data.tolerated;
953 }
954 
955 static void
956 mt7915_mcu_bss_rfch_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
957 			struct mt7915_phy *phy)
958 {
959 	struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
960 	struct bss_info_rf_ch *ch;
961 	struct tlv *tlv;
962 	int freq1 = chandef->center_freq1;
963 
964 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_RF_CH, sizeof(*ch));
965 
966 	ch = (struct bss_info_rf_ch *)tlv;
967 	ch->pri_ch = chandef->chan->hw_value;
968 	ch->center_ch0 = ieee80211_frequency_to_channel(freq1);
969 	ch->bw = mt7915_mcu_chan_bw(chandef);
970 
971 	if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
972 		int freq2 = chandef->center_freq2;
973 
974 		ch->center_ch1 = ieee80211_frequency_to_channel(freq2);
975 	}
976 
977 	if (vif->bss_conf.he_support && vif->type == NL80211_IFTYPE_STATION) {
978 		struct mt7915_dev *dev = phy->dev;
979 		struct mt76_phy *mphy = &dev->mt76.phy;
980 		bool ext_phy = phy != &dev->phy;
981 
982 		if (ext_phy && dev->mt76.phy2)
983 			mphy = dev->mt76.phy2;
984 
985 		ch->he_ru26_block =
986 			mt7915_check_he_obss_narrow_bw_ru(mphy->hw, vif);
987 		ch->he_all_disable = false;
988 	} else {
989 		ch->he_all_disable = true;
990 	}
991 }
992 
993 static void
994 mt7915_mcu_bss_ra_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
995 		      struct mt7915_phy *phy)
996 {
997 	int max_nss = hweight8(phy->mt76->chainmask);
998 	struct bss_info_ra *ra;
999 	struct tlv *tlv;
1000 
1001 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_RA, sizeof(*ra));
1002 
1003 	ra = (struct bss_info_ra *)tlv;
1004 	ra->op_mode = vif->type == NL80211_IFTYPE_AP;
1005 	ra->adhoc_en = vif->type == NL80211_IFTYPE_ADHOC;
1006 	ra->short_preamble = true;
1007 	ra->tx_streams = max_nss;
1008 	ra->rx_streams = max_nss;
1009 	ra->algo = 4;
1010 	ra->train_up_rule = 2;
1011 	ra->train_up_high_thres = 110;
1012 	ra->train_up_rule_rssi = -70;
1013 	ra->low_traffic_thres = 2;
1014 	ra->phy_cap = cpu_to_le32(0xfdf);
1015 	ra->interval = cpu_to_le32(500);
1016 	ra->fast_interval = cpu_to_le32(100);
1017 }
1018 
1019 static void
1020 mt7915_mcu_bss_he_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
1021 		      struct mt7915_phy *phy)
1022 {
1023 #define DEFAULT_HE_PE_DURATION		4
1024 #define DEFAULT_HE_DURATION_RTS_THRES	1023
1025 	const struct ieee80211_sta_he_cap *cap;
1026 	struct bss_info_he *he;
1027 	struct tlv *tlv;
1028 
1029 	cap = mt7915_get_he_phy_cap(phy, vif);
1030 
1031 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_HE_BASIC, sizeof(*he));
1032 
1033 	he = (struct bss_info_he *)tlv;
1034 	he->he_pe_duration = vif->bss_conf.htc_trig_based_pkt_ext;
1035 	if (!he->he_pe_duration)
1036 		he->he_pe_duration = DEFAULT_HE_PE_DURATION;
1037 
1038 	he->he_rts_thres = cpu_to_le16(vif->bss_conf.frame_time_rts_th);
1039 	if (!he->he_rts_thres)
1040 		he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES);
1041 
1042 	he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80;
1043 	he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160;
1044 	he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80;
1045 }
1046 
1047 static void
1048 mt7915_mcu_bss_hw_amsdu_tlv(struct sk_buff *skb)
1049 {
1050 #define TXD_CMP_MAP1		GENMASK(15, 0)
1051 #define TXD_CMP_MAP2		(GENMASK(31, 0) & ~BIT(23))
1052 	struct bss_info_hw_amsdu *amsdu;
1053 	struct tlv *tlv;
1054 
1055 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_HW_AMSDU, sizeof(*amsdu));
1056 
1057 	amsdu = (struct bss_info_hw_amsdu *)tlv;
1058 	amsdu->cmp_bitmap_0 = cpu_to_le32(TXD_CMP_MAP1);
1059 	amsdu->cmp_bitmap_1 = cpu_to_le32(TXD_CMP_MAP2);
1060 	amsdu->trig_thres = cpu_to_le16(2);
1061 	amsdu->enable = true;
1062 }
1063 
1064 static void
1065 mt7915_mcu_bss_ext_tlv(struct sk_buff *skb, struct mt7915_vif *mvif)
1066 {
1067 /* SIFS 20us + 512 byte beacon tranmitted by 1Mbps (3906us) */
1068 #define BCN_TX_ESTIMATE_TIME	(4096 + 20)
1069 	struct bss_info_ext_bss *ext;
1070 	int ext_bss_idx, tsf_offset;
1071 	struct tlv *tlv;
1072 
1073 	ext_bss_idx = mvif->omac_idx - EXT_BSSID_START;
1074 	if (ext_bss_idx < 0)
1075 		return;
1076 
1077 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_EXT_BSS, sizeof(*ext));
1078 
1079 	ext = (struct bss_info_ext_bss *)tlv;
1080 	tsf_offset = ext_bss_idx * BCN_TX_ESTIMATE_TIME;
1081 	ext->mbss_tsf_offset = cpu_to_le32(tsf_offset);
1082 }
1083 
1084 static void
1085 mt7915_mcu_bss_bmc_tlv(struct sk_buff *skb, struct mt7915_phy *phy)
1086 {
1087 	struct bss_info_bmc_rate *bmc;
1088 	struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
1089 	enum nl80211_band band = chandef->chan->band;
1090 	struct tlv *tlv;
1091 
1092 	tlv = mt7915_mcu_add_tlv(skb, BSS_INFO_BMC_RATE, sizeof(*bmc));
1093 
1094 	bmc = (struct bss_info_bmc_rate *)tlv;
1095 	if (band == NL80211_BAND_2GHZ) {
1096 		bmc->short_preamble = true;
1097 	} else {
1098 		bmc->bc_trans = cpu_to_le16(0x2000);
1099 		bmc->mc_trans = cpu_to_le16(0x2080);
1100 	}
1101 }
1102 
1103 static int
1104 mt7915_mcu_muar_config(struct mt7915_phy *phy, struct ieee80211_vif *vif,
1105 		       bool bssid, bool enable)
1106 {
1107 	struct mt7915_dev *dev = phy->dev;
1108 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
1109 	u32 idx = mvif->omac_idx - REPEATER_BSSID_START;
1110 	u32 mask = phy->omac_mask >> 32 & ~BIT(idx);
1111 	const u8 *addr = vif->addr;
1112 	struct {
1113 		u8 mode;
1114 		u8 force_clear;
1115 		u8 clear_bitmap[8];
1116 		u8 entry_count;
1117 		u8 write;
1118 		u8 band;
1119 
1120 		u8 index;
1121 		u8 bssid;
1122 		u8 addr[ETH_ALEN];
1123 	} __packed req = {
1124 		.mode = !!mask || enable,
1125 		.entry_count = 1,
1126 		.write = 1,
1127 		.band = phy != &dev->phy,
1128 		.index = idx * 2 + bssid,
1129 	};
1130 
1131 	if (bssid)
1132 		addr = vif->bss_conf.bssid;
1133 
1134 	if (enable)
1135 		ether_addr_copy(req.addr, addr);
1136 
1137 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(MUAR_UPDATE), &req,
1138 				 sizeof(req), true);
1139 }
1140 
1141 int mt7915_mcu_add_bss_info(struct mt7915_phy *phy,
1142 			    struct ieee80211_vif *vif, int enable)
1143 {
1144 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
1145 	struct sk_buff *skb;
1146 
1147 	if (mvif->omac_idx >= REPEATER_BSSID_START) {
1148 		mt7915_mcu_muar_config(phy, vif, false, enable);
1149 		mt7915_mcu_muar_config(phy, vif, true, enable);
1150 	}
1151 
1152 	skb = mt7915_mcu_alloc_sta_req(phy->dev, mvif, NULL,
1153 				       MT7915_BSS_UPDATE_MAX_SIZE);
1154 	if (IS_ERR(skb))
1155 		return PTR_ERR(skb);
1156 
1157 	/* bss_omac must be first */
1158 	if (enable)
1159 		mt7915_mcu_bss_omac_tlv(skb, vif);
1160 
1161 	mt7915_mcu_bss_basic_tlv(skb, vif, phy, enable);
1162 
1163 	if (vif->type == NL80211_IFTYPE_MONITOR)
1164 		goto out;
1165 
1166 	if (enable) {
1167 		mt7915_mcu_bss_rfch_tlv(skb, vif, phy);
1168 		mt7915_mcu_bss_bmc_tlv(skb, phy);
1169 		mt7915_mcu_bss_ra_tlv(skb, vif, phy);
1170 		mt7915_mcu_bss_hw_amsdu_tlv(skb);
1171 
1172 		if (vif->bss_conf.he_support)
1173 			mt7915_mcu_bss_he_tlv(skb, vif, phy);
1174 
1175 		if (mvif->omac_idx >= EXT_BSSID_START &&
1176 		    mvif->omac_idx < REPEATER_BSSID_START)
1177 			mt7915_mcu_bss_ext_tlv(skb, mvif);
1178 	}
1179 out:
1180 	return mt76_mcu_skb_send_msg(&phy->dev->mt76, skb,
1181 				     MCU_EXT_CMD(BSS_INFO_UPDATE), true);
1182 }
1183 
1184 /** starec & wtbl **/
1185 static int
1186 mt7915_mcu_sta_key_tlv(struct mt7915_sta *msta, struct sk_buff *skb,
1187 		       struct ieee80211_key_conf *key, enum set_key_cmd cmd)
1188 {
1189 	struct mt7915_sta_key_conf *bip = &msta->bip;
1190 	struct sta_rec_sec *sec;
1191 	struct tlv *tlv;
1192 	u32 len = sizeof(*sec);
1193 
1194 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec));
1195 
1196 	sec = (struct sta_rec_sec *)tlv;
1197 	sec->add = cmd;
1198 
1199 	if (cmd == SET_KEY) {
1200 		struct sec_key *sec_key;
1201 		u8 cipher;
1202 
1203 		cipher = mt7915_mcu_get_cipher(key->cipher);
1204 		if (cipher == MT_CIPHER_NONE)
1205 			return -EOPNOTSUPP;
1206 
1207 		sec_key = &sec->key[0];
1208 		sec_key->cipher_len = sizeof(*sec_key);
1209 
1210 		if (cipher == MCU_CIPHER_BIP_CMAC_128) {
1211 			sec_key->cipher_id = MCU_CIPHER_AES_CCMP;
1212 			sec_key->key_id = bip->keyidx;
1213 			sec_key->key_len = 16;
1214 			memcpy(sec_key->key, bip->key, 16);
1215 
1216 			sec_key = &sec->key[1];
1217 			sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128;
1218 			sec_key->cipher_len = sizeof(*sec_key);
1219 			sec_key->key_len = 16;
1220 			memcpy(sec_key->key, key->key, 16);
1221 
1222 			sec->n_cipher = 2;
1223 		} else {
1224 			sec_key->cipher_id = cipher;
1225 			sec_key->key_id = key->keyidx;
1226 			sec_key->key_len = key->keylen;
1227 			memcpy(sec_key->key, key->key, key->keylen);
1228 
1229 			if (cipher == MCU_CIPHER_TKIP) {
1230 				/* Rx/Tx MIC keys are swapped */
1231 				memcpy(sec_key->key + 16, key->key + 24, 8);
1232 				memcpy(sec_key->key + 24, key->key + 16, 8);
1233 			}
1234 
1235 			/* store key_conf for BIP batch update */
1236 			if (cipher == MCU_CIPHER_AES_CCMP) {
1237 				memcpy(bip->key, key->key, key->keylen);
1238 				bip->keyidx = key->keyidx;
1239 			}
1240 
1241 			len -= sizeof(*sec_key);
1242 			sec->n_cipher = 1;
1243 		}
1244 	} else {
1245 		len -= sizeof(sec->key);
1246 		sec->n_cipher = 0;
1247 	}
1248 	sec->len = cpu_to_le16(len);
1249 
1250 	return 0;
1251 }
1252 
1253 int mt7915_mcu_add_key(struct mt7915_dev *dev, struct ieee80211_vif *vif,
1254 		       struct mt7915_sta *msta, struct ieee80211_key_conf *key,
1255 		       enum set_key_cmd cmd)
1256 {
1257 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
1258 	struct sk_buff *skb;
1259 	int len = sizeof(struct sta_req_hdr) + sizeof(struct sta_rec_sec);
1260 	int ret;
1261 
1262 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
1263 	if (IS_ERR(skb))
1264 		return PTR_ERR(skb);
1265 
1266 	ret = mt7915_mcu_sta_key_tlv(msta, skb, key, cmd);
1267 	if (ret)
1268 		return ret;
1269 
1270 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1271 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
1272 }
1273 
1274 static void
1275 mt7915_mcu_sta_ba_tlv(struct sk_buff *skb,
1276 		      struct ieee80211_ampdu_params *params,
1277 		      bool enable, bool tx)
1278 {
1279 	struct sta_rec_ba *ba;
1280 	struct tlv *tlv;
1281 
1282 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba));
1283 
1284 	ba = (struct sta_rec_ba *)tlv;
1285 	ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT;
1286 	ba->winsize = cpu_to_le16(params->buf_size);
1287 	ba->ssn = cpu_to_le16(params->ssn);
1288 	ba->ba_en = enable << params->tid;
1289 	ba->amsdu = params->amsdu;
1290 	ba->tid = params->tid;
1291 }
1292 
1293 static void
1294 mt7915_mcu_wtbl_ba_tlv(struct sk_buff *skb,
1295 		       struct ieee80211_ampdu_params *params,
1296 		       bool enable, bool tx, void *sta_wtbl,
1297 		       void *wtbl_tlv)
1298 {
1299 	struct wtbl_ba *ba;
1300 	struct tlv *tlv;
1301 
1302 	tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_BA, sizeof(*ba),
1303 					wtbl_tlv, sta_wtbl);
1304 
1305 	ba = (struct wtbl_ba *)tlv;
1306 	ba->tid = params->tid;
1307 
1308 	if (tx) {
1309 		ba->ba_type = MT_BA_TYPE_ORIGINATOR;
1310 		ba->sn = enable ? cpu_to_le16(params->ssn) : 0;
1311 		ba->ba_en = enable;
1312 	} else {
1313 		memcpy(ba->peer_addr, params->sta->addr, ETH_ALEN);
1314 		ba->ba_type = MT_BA_TYPE_RECIPIENT;
1315 		ba->rst_ba_tid = params->tid;
1316 		ba->rst_ba_sel = RST_BA_MAC_TID_MATCH;
1317 		ba->rst_ba_sb = 1;
1318 	}
1319 
1320 	if (enable && tx)
1321 		ba->ba_winsize = cpu_to_le16(params->buf_size);
1322 }
1323 
1324 static int
1325 mt7915_mcu_sta_ba(struct mt7915_dev *dev,
1326 		  struct ieee80211_ampdu_params *params,
1327 		  bool enable, bool tx)
1328 {
1329 	struct mt7915_sta *msta = (struct mt7915_sta *)params->sta->drv_priv;
1330 	struct mt7915_vif *mvif = msta->vif;
1331 	struct wtbl_req_hdr *wtbl_hdr;
1332 	struct tlv *sta_wtbl;
1333 	struct sk_buff *skb;
1334 	int ret;
1335 
1336 	if (enable && tx && !params->amsdu)
1337 		msta->wcid.amsdu = false;
1338 
1339 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta,
1340 				       MT7915_STA_UPDATE_MAX_SIZE);
1341 	if (IS_ERR(skb))
1342 		return PTR_ERR(skb);
1343 
1344 	sta_wtbl = mt7915_mcu_add_tlv(skb, STA_REC_WTBL, sizeof(struct tlv));
1345 
1346 	wtbl_hdr = mt7915_mcu_alloc_wtbl_req(dev, msta, WTBL_SET, sta_wtbl,
1347 					     &skb);
1348 	if (IS_ERR(wtbl_hdr))
1349 		return PTR_ERR(wtbl_hdr);
1350 
1351 	mt7915_mcu_wtbl_ba_tlv(skb, params, enable, tx, sta_wtbl, wtbl_hdr);
1352 
1353 	ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
1354 				    MCU_EXT_CMD(STA_REC_UPDATE), true);
1355 	if (ret)
1356 		return ret;
1357 
1358 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta,
1359 				       MT7915_STA_UPDATE_MAX_SIZE);
1360 	if (IS_ERR(skb))
1361 		return PTR_ERR(skb);
1362 
1363 	mt7915_mcu_sta_ba_tlv(skb, params, enable, tx);
1364 
1365 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1366 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
1367 }
1368 
1369 int mt7915_mcu_add_tx_ba(struct mt7915_dev *dev,
1370 			 struct ieee80211_ampdu_params *params,
1371 			 bool enable)
1372 {
1373 	return mt7915_mcu_sta_ba(dev, params, enable, true);
1374 }
1375 
1376 int mt7915_mcu_add_rx_ba(struct mt7915_dev *dev,
1377 			 struct ieee80211_ampdu_params *params,
1378 			 bool enable)
1379 {
1380 	return mt7915_mcu_sta_ba(dev, params, enable, false);
1381 }
1382 
1383 static void
1384 mt7915_mcu_wtbl_generic_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
1385 			    struct ieee80211_sta *sta, void *sta_wtbl,
1386 			    void *wtbl_tlv)
1387 {
1388 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
1389 	struct wtbl_generic *generic;
1390 	struct wtbl_rx *rx;
1391 	struct tlv *tlv;
1392 
1393 	tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_GENERIC, sizeof(*generic),
1394 					wtbl_tlv, sta_wtbl);
1395 
1396 	generic = (struct wtbl_generic *)tlv;
1397 
1398 	if (sta) {
1399 		memcpy(generic->peer_addr, sta->addr, ETH_ALEN);
1400 		generic->partial_aid = cpu_to_le16(sta->aid);
1401 		generic->muar_idx = mvif->omac_idx;
1402 		generic->qos = sta->wme;
1403 	} else {
1404 		/* use BSSID in station mode */
1405 		if (vif->type == NL80211_IFTYPE_STATION)
1406 			memcpy(generic->peer_addr, vif->bss_conf.bssid,
1407 			       ETH_ALEN);
1408 		else
1409 			eth_broadcast_addr(generic->peer_addr);
1410 
1411 		generic->muar_idx = 0xe;
1412 	}
1413 
1414 	tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_RX, sizeof(*rx),
1415 					wtbl_tlv, sta_wtbl);
1416 
1417 	rx = (struct wtbl_rx *)tlv;
1418 	rx->rca1 = sta ? vif->type != NL80211_IFTYPE_AP : 1;
1419 	rx->rca2 = 1;
1420 	rx->rv = 1;
1421 }
1422 
1423 static void
1424 mt7915_mcu_sta_basic_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
1425 			 struct ieee80211_sta *sta, bool enable)
1426 {
1427 #define EXTRA_INFO_VER          BIT(0)
1428 #define EXTRA_INFO_NEW          BIT(1)
1429 	struct sta_rec_basic *basic;
1430 	struct tlv *tlv;
1431 
1432 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_BASIC, sizeof(*basic));
1433 
1434 	basic = (struct sta_rec_basic *)tlv;
1435 	basic->extra_info = cpu_to_le16(EXTRA_INFO_VER);
1436 
1437 	if (enable) {
1438 		basic->extra_info |= cpu_to_le16(EXTRA_INFO_NEW);
1439 		basic->conn_state = CONN_STATE_PORT_SECURE;
1440 	} else {
1441 		basic->conn_state = CONN_STATE_DISCONNECT;
1442 	}
1443 
1444 	if (!sta) {
1445 		basic->conn_type = cpu_to_le32(CONNECTION_INFRA_BC);
1446 		eth_broadcast_addr(basic->peer_addr);
1447 		return;
1448 	}
1449 
1450 	switch (vif->type) {
1451 	case NL80211_IFTYPE_MESH_POINT:
1452 	case NL80211_IFTYPE_AP:
1453 		basic->conn_type = cpu_to_le32(CONNECTION_INFRA_STA);
1454 		break;
1455 	case NL80211_IFTYPE_STATION:
1456 		basic->conn_type = cpu_to_le32(CONNECTION_INFRA_AP);
1457 		break;
1458 	case NL80211_IFTYPE_ADHOC:
1459 		basic->conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC);
1460 		break;
1461 	default:
1462 		WARN_ON(1);
1463 		break;
1464 	}
1465 
1466 	memcpy(basic->peer_addr, sta->addr, ETH_ALEN);
1467 	basic->aid = cpu_to_le16(sta->aid);
1468 	basic->qos = sta->wme;
1469 }
1470 
1471 static void
1472 mt7915_mcu_sta_he_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1473 {
1474 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
1475 	struct ieee80211_sta_he_cap *he_cap = &sta->he_cap;
1476 	struct ieee80211_he_cap_elem *elem = &he_cap->he_cap_elem;
1477 	enum nl80211_band band = msta->vif->phy->mt76->chandef.chan->band;
1478 	const u16 *mcs_mask = msta->vif->bitrate_mask.control[band].he_mcs;
1479 	struct sta_rec_he *he;
1480 	struct tlv *tlv;
1481 	u32 cap = 0;
1482 
1483 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_HE, sizeof(*he));
1484 
1485 	he = (struct sta_rec_he *)tlv;
1486 
1487 	if (elem->mac_cap_info[0] & IEEE80211_HE_MAC_CAP0_HTC_HE)
1488 		cap |= STA_REC_HE_CAP_HTC;
1489 
1490 	if (elem->mac_cap_info[2] & IEEE80211_HE_MAC_CAP2_BSR)
1491 		cap |= STA_REC_HE_CAP_BSR;
1492 
1493 	if (elem->mac_cap_info[3] & IEEE80211_HE_MAC_CAP3_OMI_CONTROL)
1494 		cap |= STA_REC_HE_CAP_OM;
1495 
1496 	if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_AMSDU_IN_AMPDU)
1497 		cap |= STA_REC_HE_CAP_AMSDU_IN_AMPDU;
1498 
1499 	if (elem->mac_cap_info[4] & IEEE80211_HE_MAC_CAP4_BQR)
1500 		cap |= STA_REC_HE_CAP_BQR;
1501 
1502 	if (elem->phy_cap_info[0] &
1503 	    (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G |
1504 	     IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G))
1505 		cap |= STA_REC_HE_CAP_BW20_RU242_SUPPORT;
1506 
1507 	if (elem->phy_cap_info[1] &
1508 	    IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD)
1509 		cap |= STA_REC_HE_CAP_LDPC;
1510 
1511 	if (elem->phy_cap_info[1] &
1512 	    IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US)
1513 		cap |= STA_REC_HE_CAP_SU_PPDU_1LTF_8US_GI;
1514 
1515 	if (elem->phy_cap_info[2] &
1516 	    IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US)
1517 		cap |= STA_REC_HE_CAP_NDP_4LTF_3DOT2MS_GI;
1518 
1519 	if (elem->phy_cap_info[2] &
1520 	    IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ)
1521 		cap |= STA_REC_HE_CAP_LE_EQ_80M_TX_STBC;
1522 
1523 	if (elem->phy_cap_info[2] &
1524 	    IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ)
1525 		cap |= STA_REC_HE_CAP_LE_EQ_80M_RX_STBC;
1526 
1527 	if (elem->phy_cap_info[6] &
1528 	    IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE)
1529 		cap |= STA_REC_HE_CAP_PARTIAL_BW_EXT_RANGE;
1530 
1531 	if (elem->phy_cap_info[7] &
1532 	    IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI)
1533 		cap |= STA_REC_HE_CAP_SU_MU_PPDU_4LTF_8US_GI;
1534 
1535 	if (elem->phy_cap_info[7] &
1536 	    IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ)
1537 		cap |= STA_REC_HE_CAP_GT_80M_TX_STBC;
1538 
1539 	if (elem->phy_cap_info[7] &
1540 	    IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ)
1541 		cap |= STA_REC_HE_CAP_GT_80M_RX_STBC;
1542 
1543 	if (elem->phy_cap_info[8] &
1544 	    IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI)
1545 		cap |= STA_REC_HE_CAP_ER_SU_PPDU_4LTF_8US_GI;
1546 
1547 	if (elem->phy_cap_info[8] &
1548 	    IEEE80211_HE_PHY_CAP8_HE_ER_SU_1XLTF_AND_08_US_GI)
1549 		cap |= STA_REC_HE_CAP_ER_SU_PPDU_1LTF_8US_GI;
1550 
1551 	if (elem->phy_cap_info[9] &
1552 	    IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK)
1553 		cap |= STA_REC_HE_CAP_TRIG_CQI_FK;
1554 
1555 	if (elem->phy_cap_info[9] &
1556 	    IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU)
1557 		cap |= STA_REC_HE_CAP_TX_1024QAM_UNDER_RU242;
1558 
1559 	if (elem->phy_cap_info[9] &
1560 	    IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU)
1561 		cap |= STA_REC_HE_CAP_RX_1024QAM_UNDER_RU242;
1562 
1563 	he->he_cap = cpu_to_le32(cap);
1564 
1565 	switch (sta->bandwidth) {
1566 	case IEEE80211_STA_RX_BW_160:
1567 		if (elem->phy_cap_info[0] &
1568 		    IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
1569 			mt7915_mcu_set_sta_he_mcs(sta,
1570 						  &he->max_nss_mcs[CMD_HE_MCS_BW8080],
1571 						  mcs_mask);
1572 
1573 		mt7915_mcu_set_sta_he_mcs(sta,
1574 					  &he->max_nss_mcs[CMD_HE_MCS_BW160],
1575 					  mcs_mask);
1576 		fallthrough;
1577 	default:
1578 		mt7915_mcu_set_sta_he_mcs(sta,
1579 					  &he->max_nss_mcs[CMD_HE_MCS_BW80],
1580 					  mcs_mask);
1581 		break;
1582 	}
1583 
1584 	he->t_frame_dur =
1585 		HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]);
1586 	he->max_ampdu_exp =
1587 		HE_MAC(CAP3_MAX_AMPDU_LEN_EXP_MASK, elem->mac_cap_info[3]);
1588 
1589 	he->bw_set =
1590 		HE_PHY(CAP0_CHANNEL_WIDTH_SET_MASK, elem->phy_cap_info[0]);
1591 	he->device_class =
1592 		HE_PHY(CAP1_DEVICE_CLASS_A, elem->phy_cap_info[1]);
1593 	he->punc_pream_rx =
1594 		HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]);
1595 
1596 	he->dcm_tx_mode =
1597 		HE_PHY(CAP3_DCM_MAX_CONST_TX_MASK, elem->phy_cap_info[3]);
1598 	he->dcm_tx_max_nss =
1599 		HE_PHY(CAP3_DCM_MAX_TX_NSS_2, elem->phy_cap_info[3]);
1600 	he->dcm_rx_mode =
1601 		HE_PHY(CAP3_DCM_MAX_CONST_RX_MASK, elem->phy_cap_info[3]);
1602 	he->dcm_rx_max_nss =
1603 		HE_PHY(CAP3_DCM_MAX_RX_NSS_2, elem->phy_cap_info[3]);
1604 	he->dcm_rx_max_nss =
1605 		HE_PHY(CAP8_DCM_MAX_RU_MASK, elem->phy_cap_info[8]);
1606 
1607 	he->pkt_ext = 2;
1608 }
1609 
1610 static void
1611 mt7915_mcu_sta_uapsd_tlv(struct sk_buff *skb, struct ieee80211_sta *sta,
1612 		     struct ieee80211_vif *vif)
1613 {
1614 	struct sta_rec_uapsd *uapsd;
1615 	struct tlv *tlv;
1616 
1617 	if (vif->type != NL80211_IFTYPE_AP || !sta->wme)
1618 		return;
1619 
1620 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_APPS, sizeof(*uapsd));
1621 	uapsd = (struct sta_rec_uapsd *)tlv;
1622 
1623 	if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VO) {
1624 		uapsd->dac_map |= BIT(3);
1625 		uapsd->tac_map |= BIT(3);
1626 	}
1627 	if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_VI) {
1628 		uapsd->dac_map |= BIT(2);
1629 		uapsd->tac_map |= BIT(2);
1630 	}
1631 	if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BE) {
1632 		uapsd->dac_map |= BIT(1);
1633 		uapsd->tac_map |= BIT(1);
1634 	}
1635 	if (sta->uapsd_queues & IEEE80211_WMM_IE_STA_QOSINFO_AC_BK) {
1636 		uapsd->dac_map |= BIT(0);
1637 		uapsd->tac_map |= BIT(0);
1638 	}
1639 	uapsd->max_sp = sta->max_sp;
1640 }
1641 
1642 static void
1643 mt7915_mcu_sta_muru_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1644 {
1645 	struct ieee80211_sta_he_cap *he_cap = &sta->he_cap;
1646 	struct ieee80211_he_cap_elem *elem = &he_cap->he_cap_elem;
1647 	struct sta_rec_muru *muru;
1648 	struct tlv *tlv;
1649 
1650 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_MURU, sizeof(*muru));
1651 
1652 	muru = (struct sta_rec_muru *)tlv;
1653 	muru->cfg.ofdma_dl_en = true;
1654 	muru->cfg.mimo_dl_en = true;
1655 
1656 	muru->ofdma_dl.punc_pream_rx =
1657 		HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]);
1658 	muru->ofdma_dl.he_20m_in_40m_2g =
1659 		HE_PHY(CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G, elem->phy_cap_info[8]);
1660 	muru->ofdma_dl.he_20m_in_160m =
1661 		HE_PHY(CAP8_20MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]);
1662 	muru->ofdma_dl.he_80m_in_160m =
1663 		HE_PHY(CAP8_80MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]);
1664 	muru->ofdma_dl.lt16_sigb = 0;
1665 	muru->ofdma_dl.rx_su_comp_sigb = 0;
1666 	muru->ofdma_dl.rx_su_non_comp_sigb = 0;
1667 
1668 	muru->ofdma_ul.t_frame_dur =
1669 		HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]);
1670 	muru->ofdma_ul.mu_cascading =
1671 		HE_MAC(CAP2_MU_CASCADING, elem->mac_cap_info[2]);
1672 	muru->ofdma_ul.uo_ra =
1673 		HE_MAC(CAP3_OFDMA_RA, elem->mac_cap_info[3]);
1674 	muru->ofdma_ul.he_2x996_tone = 0;
1675 	muru->ofdma_ul.rx_t_frame_11ac = 0;
1676 
1677 	muru->mimo_dl.vht_mu_bfee =
1678 		!!(sta->vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
1679 	muru->mimo_dl.partial_bw_dl_mimo =
1680 		HE_PHY(CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO, elem->phy_cap_info[6]);
1681 
1682 	muru->mimo_ul.full_ul_mimo =
1683 		HE_PHY(CAP2_UL_MU_FULL_MU_MIMO, elem->phy_cap_info[2]);
1684 	muru->mimo_ul.partial_ul_mimo =
1685 		HE_PHY(CAP2_UL_MU_PARTIAL_MU_MIMO, elem->phy_cap_info[2]);
1686 }
1687 
1688 static void
1689 mt7915_mcu_sta_vht_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1690 {
1691 	struct sta_rec_vht *vht;
1692 	struct tlv *tlv;
1693 
1694 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_VHT, sizeof(*vht));
1695 
1696 	vht = (struct sta_rec_vht *)tlv;
1697 	vht->vht_cap = cpu_to_le32(sta->vht_cap.cap);
1698 	vht->vht_rx_mcs_map = sta->vht_cap.vht_mcs.rx_mcs_map;
1699 	vht->vht_tx_mcs_map = sta->vht_cap.vht_mcs.tx_mcs_map;
1700 }
1701 
1702 static void
1703 mt7915_mcu_sta_amsdu_tlv(struct sk_buff *skb, struct ieee80211_sta *sta)
1704 {
1705 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
1706 	struct sta_rec_amsdu *amsdu;
1707 	struct tlv *tlv;
1708 
1709 	if (!sta->max_amsdu_len)
1710 	    return;
1711 
1712 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu));
1713 	amsdu = (struct sta_rec_amsdu *)tlv;
1714 	amsdu->max_amsdu_num = 8;
1715 	amsdu->amsdu_en = true;
1716 	amsdu->max_mpdu_size = sta->max_amsdu_len >=
1717 			       IEEE80211_MAX_MPDU_LEN_VHT_7991;
1718 	msta->wcid.amsdu = true;
1719 }
1720 
1721 static bool
1722 mt7915_hw_amsdu_supported(struct ieee80211_vif *vif)
1723 {
1724 	switch (vif->type) {
1725 	case NL80211_IFTYPE_AP:
1726 	case NL80211_IFTYPE_STATION:
1727 		return true;
1728 	default:
1729 		return false;
1730 	}
1731 }
1732 
1733 static void
1734 mt7915_mcu_sta_tlv(struct mt7915_dev *dev, struct sk_buff *skb,
1735 		   struct ieee80211_sta *sta, struct ieee80211_vif *vif)
1736 {
1737 	struct tlv *tlv;
1738 
1739 	/* starec ht */
1740 	if (sta->ht_cap.ht_supported) {
1741 		struct sta_rec_ht *ht;
1742 
1743 		tlv = mt7915_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht));
1744 		ht = (struct sta_rec_ht *)tlv;
1745 		ht->ht_cap = cpu_to_le16(sta->ht_cap.cap);
1746 
1747 		if (mt7915_hw_amsdu_supported(vif))
1748 			mt7915_mcu_sta_amsdu_tlv(skb, sta);
1749 	}
1750 
1751 	/* starec he */
1752 	if (sta->he_cap.has_he)
1753 		mt7915_mcu_sta_he_tlv(skb, sta);
1754 
1755 	/* starec uapsd */
1756 	mt7915_mcu_sta_uapsd_tlv(skb, sta, vif);
1757 }
1758 
1759 static void
1760 mt7915_mcu_wtbl_smps_tlv(struct sk_buff *skb, struct ieee80211_sta *sta,
1761 			 void *sta_wtbl, void *wtbl_tlv)
1762 {
1763 	struct wtbl_smps *smps;
1764 	struct tlv *tlv;
1765 
1766 	tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_SMPS, sizeof(*smps),
1767 					wtbl_tlv, sta_wtbl);
1768 	smps = (struct wtbl_smps *)tlv;
1769 
1770 	if (sta->smps_mode == IEEE80211_SMPS_DYNAMIC)
1771 		smps->smps = true;
1772 }
1773 
1774 static void
1775 mt7915_mcu_wtbl_ht_tlv(struct sk_buff *skb, struct ieee80211_sta *sta,
1776 		       void *sta_wtbl, void *wtbl_tlv)
1777 {
1778 	struct wtbl_ht *ht = NULL;
1779 	struct tlv *tlv;
1780 
1781 	/* wtbl ht */
1782 	if (sta->ht_cap.ht_supported) {
1783 		tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_HT, sizeof(*ht),
1784 						wtbl_tlv, sta_wtbl);
1785 		ht = (struct wtbl_ht *)tlv;
1786 		ht->ldpc = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING);
1787 		ht->af = sta->ht_cap.ampdu_factor;
1788 		ht->mm = sta->ht_cap.ampdu_density;
1789 		ht->ht = true;
1790 	}
1791 
1792 	/* wtbl vht */
1793 	if (sta->vht_cap.vht_supported) {
1794 		struct wtbl_vht *vht;
1795 		u8 af;
1796 
1797 		tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_VHT, sizeof(*vht),
1798 						wtbl_tlv, sta_wtbl);
1799 		vht = (struct wtbl_vht *)tlv;
1800 		vht->ldpc = !!(sta->vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC);
1801 		vht->vht = true;
1802 
1803 		af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
1804 			       sta->vht_cap.cap);
1805 		if (ht)
1806 			ht->af = max_t(u8, ht->af, af);
1807 	}
1808 
1809 	mt7915_mcu_wtbl_smps_tlv(skb, sta, sta_wtbl, wtbl_tlv);
1810 }
1811 
1812 static void
1813 mt7915_mcu_wtbl_hdr_trans_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
1814 			      struct ieee80211_sta *sta,
1815 			      void *sta_wtbl, void *wtbl_tlv)
1816 {
1817 	struct mt7915_sta *msta;
1818 	struct wtbl_hdr_trans *htr = NULL;
1819 	struct tlv *tlv;
1820 
1821 	tlv = mt7915_mcu_add_nested_tlv(skb, WTBL_HDR_TRANS, sizeof(*htr),
1822 					wtbl_tlv, sta_wtbl);
1823 	htr = (struct wtbl_hdr_trans *)tlv;
1824 	htr->no_rx_trans = true;
1825 	if (vif->type == NL80211_IFTYPE_STATION)
1826 		htr->to_ds = true;
1827 	else
1828 		htr->from_ds = true;
1829 
1830 	if (!sta)
1831 		return;
1832 
1833 	msta = (struct mt7915_sta *)sta->drv_priv;
1834 	htr->no_rx_trans = !test_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags);
1835 	if (test_bit(MT_WCID_FLAG_4ADDR, &msta->wcid.flags)) {
1836 		htr->to_ds = true;
1837 		htr->from_ds = true;
1838 	}
1839 }
1840 
1841 int mt7915_mcu_sta_update_hdr_trans(struct mt7915_dev *dev,
1842 				    struct ieee80211_vif *vif,
1843 				    struct ieee80211_sta *sta)
1844 {
1845 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
1846 	struct wtbl_req_hdr *wtbl_hdr;
1847 	struct sk_buff *skb;
1848 
1849 	skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, MT7915_WTBL_UPDATE_MAX_SIZE);
1850 	if (!skb)
1851 		return -ENOMEM;
1852 
1853 	wtbl_hdr = mt7915_mcu_alloc_wtbl_req(dev, msta, WTBL_SET, NULL, &skb);
1854 	if (IS_ERR(wtbl_hdr))
1855 		return PTR_ERR(wtbl_hdr);
1856 
1857 	mt7915_mcu_wtbl_hdr_trans_tlv(skb, vif, sta, NULL, wtbl_hdr);
1858 
1859 	return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_EXT_CMD(WTBL_UPDATE),
1860 				     true);
1861 }
1862 
1863 int mt7915_mcu_add_smps(struct mt7915_dev *dev, struct ieee80211_vif *vif,
1864 			struct ieee80211_sta *sta)
1865 {
1866 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
1867 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
1868 	struct wtbl_req_hdr *wtbl_hdr;
1869 	struct tlv *sta_wtbl;
1870 	struct sk_buff *skb;
1871 
1872 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta,
1873 				       MT7915_STA_UPDATE_MAX_SIZE);
1874 	if (IS_ERR(skb))
1875 		return PTR_ERR(skb);
1876 
1877 	sta_wtbl = mt7915_mcu_add_tlv(skb, STA_REC_WTBL, sizeof(struct tlv));
1878 
1879 	wtbl_hdr = mt7915_mcu_alloc_wtbl_req(dev, msta, WTBL_SET, sta_wtbl,
1880 					     &skb);
1881 	if (IS_ERR(wtbl_hdr))
1882 		return PTR_ERR(wtbl_hdr);
1883 
1884 	mt7915_mcu_wtbl_smps_tlv(skb, sta, sta_wtbl, wtbl_hdr);
1885 
1886 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1887 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
1888 }
1889 
1890 static void
1891 mt7915_mcu_sta_sounding_rate(struct sta_rec_bf *bf)
1892 {
1893 	bf->bf_cap = MT_EBF;
1894 	bf->sounding_phy = MT_PHY_TYPE_OFDM;
1895 	bf->ndp_rate = 0;				/* mcs0 */
1896 	bf->ndpa_rate = MT7915_CFEND_RATE_DEFAULT;	/* ofdm 24m */
1897 	bf->rept_poll_rate = MT7915_CFEND_RATE_DEFAULT;	/* ofdm 24m */
1898 }
1899 
1900 static void
1901 mt7915_mcu_sta_bfer_ht(struct ieee80211_sta *sta, struct mt7915_phy *phy,
1902 		       struct sta_rec_bf *bf)
1903 {
1904 	struct ieee80211_mcs_info *mcs = &sta->ht_cap.mcs;
1905 	u8 n = 0;
1906 
1907 	bf->tx_mode = MT_PHY_TYPE_HT;
1908 	bf->bf_cap = MT_IBF;
1909 
1910 	if (mcs->tx_params & IEEE80211_HT_MCS_TX_RX_DIFF &&
1911 	    (mcs->tx_params & IEEE80211_HT_MCS_TX_DEFINED))
1912 		n = FIELD_GET(IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK,
1913 			      mcs->tx_params);
1914 	else if (mcs->rx_mask[3])
1915 		n = 3;
1916 	else if (mcs->rx_mask[2])
1917 		n = 2;
1918 	else if (mcs->rx_mask[1])
1919 		n = 1;
1920 
1921 	bf->nr = hweight8(phy->mt76->chainmask) - 1;
1922 	bf->nc = min_t(u8, bf->nr, n);
1923 	bf->ibf_ncol = n;
1924 }
1925 
1926 static void
1927 mt7915_mcu_sta_bfer_vht(struct ieee80211_sta *sta, struct mt7915_phy *phy,
1928 			struct sta_rec_bf *bf, bool explicit)
1929 {
1930 	struct ieee80211_sta_vht_cap *pc = &sta->vht_cap;
1931 	struct ieee80211_sta_vht_cap *vc = &phy->mt76->sband_5g.sband.vht_cap;
1932 	u16 mcs_map = le16_to_cpu(pc->vht_mcs.rx_mcs_map);
1933 	u8 nss_mcs = mt7915_mcu_get_sta_nss(mcs_map);
1934 	u8 tx_ant = hweight8(phy->mt76->chainmask) - 1;
1935 
1936 	bf->tx_mode = MT_PHY_TYPE_VHT;
1937 
1938 	if (explicit) {
1939 		u8 bfee_nr, bfer_nr;
1940 
1941 		mt7915_mcu_sta_sounding_rate(bf);
1942 		bfee_nr = FIELD_GET(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK,
1943 				    pc->cap);
1944 		bfer_nr = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK,
1945 				    vc->cap);
1946 		bf->nr = min_t(u8, min_t(u8, bfer_nr, bfee_nr), tx_ant);
1947 		bf->nc = min_t(u8, nss_mcs, bf->nr);
1948 		bf->ibf_ncol = bf->nc;
1949 
1950 		if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
1951 			bf->nr = 1;
1952 	} else {
1953 		bf->bf_cap = MT_IBF;
1954 		bf->nr = tx_ant;
1955 		bf->nc = min_t(u8, nss_mcs, bf->nr);
1956 		bf->ibf_ncol = nss_mcs;
1957 
1958 		if (sta->bandwidth == IEEE80211_STA_RX_BW_160)
1959 			bf->ibf_nrow = 1;
1960 	}
1961 }
1962 
1963 static void
1964 mt7915_mcu_sta_bfer_he(struct ieee80211_sta *sta, struct ieee80211_vif *vif,
1965 		       struct mt7915_phy *phy, struct sta_rec_bf *bf)
1966 {
1967 	struct ieee80211_sta_he_cap *pc = &sta->he_cap;
1968 	struct ieee80211_he_cap_elem *pe = &pc->he_cap_elem;
1969 	const struct ieee80211_sta_he_cap *vc = mt7915_get_he_phy_cap(phy, vif);
1970 	const struct ieee80211_he_cap_elem *ve = &vc->he_cap_elem;
1971 	u16 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80);
1972 	u8 nss_mcs = mt7915_mcu_get_sta_nss(mcs_map);
1973 	u8 bfee_nr, bfer_nr;
1974 
1975 	bf->tx_mode = MT_PHY_TYPE_HE_SU;
1976 	mt7915_mcu_sta_sounding_rate(bf);
1977 	bf->trigger_su = HE_PHY(CAP6_TRIG_SU_BEAMFORMING_FB,
1978 				pe->phy_cap_info[6]);
1979 	bf->trigger_mu = HE_PHY(CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB,
1980 				pe->phy_cap_info[6]);
1981 	bfer_nr = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK,
1982 			 ve->phy_cap_info[5]);
1983 	bfee_nr = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_MASK,
1984 			 pe->phy_cap_info[4]);
1985 	bf->nr = min_t(u8, bfer_nr, bfee_nr);
1986 	bf->nc = min_t(u8, nss_mcs, bf->nr);
1987 	bf->ibf_ncol = bf->nc;
1988 
1989 	if (sta->bandwidth != IEEE80211_STA_RX_BW_160)
1990 		return;
1991 
1992 	/* go over for 160MHz and 80p80 */
1993 	if (pe->phy_cap_info[0] &
1994 	    IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) {
1995 		mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_160);
1996 		nss_mcs = mt7915_mcu_get_sta_nss(mcs_map);
1997 
1998 		bf->nc_bw160 = nss_mcs;
1999 	}
2000 
2001 	if (pe->phy_cap_info[0] &
2002 	    IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
2003 		mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80p80);
2004 		nss_mcs = mt7915_mcu_get_sta_nss(mcs_map);
2005 
2006 		if (bf->nc_bw160)
2007 			bf->nc_bw160 = min_t(u8, bf->nc_bw160, nss_mcs);
2008 		else
2009 			bf->nc_bw160 = nss_mcs;
2010 	}
2011 
2012 	bfer_nr = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK,
2013 			 ve->phy_cap_info[5]);
2014 	bfee_nr = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_MASK,
2015 			 pe->phy_cap_info[4]);
2016 
2017 	bf->nr_bw160 = min_t(int, bfer_nr, bfee_nr);
2018 }
2019 
2020 static void
2021 mt7915_mcu_sta_bfer_tlv(struct sk_buff *skb, struct ieee80211_sta *sta,
2022 			struct ieee80211_vif *vif, struct mt7915_phy *phy,
2023 			bool enable, bool explicit)
2024 {
2025 	int tx_ant = hweight8(phy->mt76->chainmask) - 1;
2026 	struct sta_rec_bf *bf;
2027 	struct tlv *tlv;
2028 	const u8 matrix[4][4] = {
2029 		{0, 0, 0, 0},
2030 		{1, 1, 0, 0},	/* 2x1, 2x2, 2x3, 2x4 */
2031 		{2, 4, 4, 0},	/* 3x1, 3x2, 3x3, 3x4 */
2032 		{3, 5, 6, 0}	/* 4x1, 4x2, 4x3, 4x4 */
2033 	};
2034 
2035 #define MT_BFER_FREE		cpu_to_le16(GENMASK(15, 0))
2036 
2037 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_BF, sizeof(*bf));
2038 	bf = (struct sta_rec_bf *)tlv;
2039 
2040 	if (!enable) {
2041 		bf->pfmu = MT_BFER_FREE;
2042 		return;
2043 	}
2044 
2045 	/* he: eBF only, in accordance with spec
2046 	 * vht: support eBF and iBF
2047 	 * ht: iBF only, since mac80211 lacks of eBF support
2048 	 */
2049 	if (sta->he_cap.has_he && explicit)
2050 		mt7915_mcu_sta_bfer_he(sta, vif, phy, bf);
2051 	else if (sta->vht_cap.vht_supported)
2052 		mt7915_mcu_sta_bfer_vht(sta, phy, bf, explicit);
2053 	else if (sta->ht_cap.ht_supported)
2054 		mt7915_mcu_sta_bfer_ht(sta, phy, bf);
2055 	else
2056 		return;
2057 
2058 	bf->bw = sta->bandwidth;
2059 	bf->ibf_dbw = sta->bandwidth;
2060 	bf->ibf_nrow = tx_ant;
2061 
2062 	if (!explicit && sta->bandwidth <= IEEE80211_STA_RX_BW_40 && !bf->nc)
2063 		bf->ibf_timeout = 0x48;
2064 	else
2065 		bf->ibf_timeout = 0x18;
2066 
2067 	if (explicit && bf->nr != tx_ant)
2068 		bf->mem_20m = matrix[tx_ant][bf->nc];
2069 	else
2070 		bf->mem_20m = matrix[bf->nr][bf->nc];
2071 
2072 	switch (sta->bandwidth) {
2073 	case IEEE80211_STA_RX_BW_160:
2074 	case IEEE80211_STA_RX_BW_80:
2075 		bf->mem_total = bf->mem_20m * 2;
2076 		break;
2077 	case IEEE80211_STA_RX_BW_40:
2078 		bf->mem_total = bf->mem_20m;
2079 		break;
2080 	case IEEE80211_STA_RX_BW_20:
2081 	default:
2082 		break;
2083 	}
2084 }
2085 
2086 static void
2087 mt7915_mcu_sta_bfee_tlv(struct sk_buff *skb, struct ieee80211_sta *sta,
2088 			struct mt7915_phy *phy)
2089 {
2090 	int tx_ant = hweight8(phy->mt76->chainmask) - 1;
2091 	struct sta_rec_bfee *bfee;
2092 	struct tlv *tlv;
2093 	u8 nr = 0;
2094 
2095 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_BFEE, sizeof(*bfee));
2096 	bfee = (struct sta_rec_bfee *)tlv;
2097 
2098 	if (sta->he_cap.has_he) {
2099 		struct ieee80211_he_cap_elem *pe = &sta->he_cap.he_cap_elem;
2100 
2101 		nr = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK,
2102 			    pe->phy_cap_info[5]);
2103 	} else if (sta->vht_cap.vht_supported) {
2104 		struct ieee80211_sta_vht_cap *pc = &sta->vht_cap;
2105 
2106 		nr = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK,
2107 			       pc->cap);
2108 	}
2109 
2110 	/* reply with identity matrix to avoid 2x2 BF negative gain */
2111 	bfee->fb_identity_matrix = !!(nr == 1 && tx_ant == 2);
2112 }
2113 
2114 static int
2115 mt7915_mcu_add_txbf(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2116 		    struct ieee80211_sta *sta, bool enable)
2117 {
2118 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2119 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2120 	struct mt7915_phy *phy;
2121 	struct sk_buff *skb;
2122 	int r, len;
2123 	bool ebfee = 0, ebf = 0;
2124 
2125 	if (vif->type != NL80211_IFTYPE_STATION &&
2126 	    vif->type != NL80211_IFTYPE_AP)
2127 		return 0;
2128 
2129 	phy = mvif->band_idx ? mt7915_ext_phy(dev) : &dev->phy;
2130 
2131 	if (sta->he_cap.has_he) {
2132 		struct ieee80211_he_cap_elem *pe;
2133 		const struct ieee80211_he_cap_elem *ve;
2134 		const struct ieee80211_sta_he_cap *vc;
2135 
2136 		pe = &sta->he_cap.he_cap_elem;
2137 		vc = mt7915_get_he_phy_cap(phy, vif);
2138 		ve = &vc->he_cap_elem;
2139 
2140 		ebfee = !!(HE_PHY(CAP3_SU_BEAMFORMER, pe->phy_cap_info[3]) &&
2141 			   HE_PHY(CAP4_SU_BEAMFORMEE, ve->phy_cap_info[4]));
2142 		ebf = !!(HE_PHY(CAP3_SU_BEAMFORMER, ve->phy_cap_info[3]) &&
2143 			 HE_PHY(CAP4_SU_BEAMFORMEE, pe->phy_cap_info[4]));
2144 	} else if (sta->vht_cap.vht_supported) {
2145 		struct ieee80211_sta_vht_cap *pc;
2146 		struct ieee80211_sta_vht_cap *vc;
2147 
2148 		pc = &sta->vht_cap;
2149 		vc = &phy->mt76->sband_5g.sband.vht_cap;
2150 
2151 		ebfee = !!((pc->cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) &&
2152 			   (vc->cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
2153 		ebf = !!((vc->cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE) &&
2154 			 (pc->cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE));
2155 	}
2156 
2157 	/* must keep each tag independent */
2158 
2159 	/* starec bf */
2160 	if (ebf || dev->ibf) {
2161 		len = sizeof(struct sta_req_hdr) + sizeof(struct sta_rec_bf);
2162 
2163 		skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
2164 		if (IS_ERR(skb))
2165 			return PTR_ERR(skb);
2166 
2167 		mt7915_mcu_sta_bfer_tlv(skb, sta, vif, phy, enable, ebf);
2168 
2169 		r = mt76_mcu_skb_send_msg(&dev->mt76, skb,
2170 					  MCU_EXT_CMD(STA_REC_UPDATE), true);
2171 		if (r)
2172 			return r;
2173 	}
2174 
2175 	/* starec bfee */
2176 	if (ebfee) {
2177 		len = sizeof(struct sta_req_hdr) + sizeof(struct sta_rec_bfee);
2178 
2179 		skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
2180 		if (IS_ERR(skb))
2181 			return PTR_ERR(skb);
2182 
2183 		mt7915_mcu_sta_bfee_tlv(skb, sta, phy);
2184 
2185 		r = mt76_mcu_skb_send_msg(&dev->mt76, skb,
2186 					  MCU_EXT_CMD(STA_REC_UPDATE), true);
2187 		if (r)
2188 			return r;
2189 	}
2190 
2191 	return 0;
2192 }
2193 
2194 static void
2195 mt7915_mcu_sta_rate_ctrl_tlv(struct sk_buff *skb, struct mt7915_dev *dev,
2196 			     struct ieee80211_vif *vif, struct ieee80211_sta *sta)
2197 {
2198 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2199 	struct cfg80211_chan_def *chandef = &mvif->phy->mt76->chandef;
2200 	struct cfg80211_bitrate_mask *mask = &mvif->bitrate_mask;
2201 	enum nl80211_band band = chandef->chan->band;
2202 	struct sta_rec_ra *ra;
2203 	struct tlv *tlv;
2204 	u32 supp_rate = sta->supp_rates[band];
2205 	u32 cap = sta->wme ? STA_CAP_WMM : 0;
2206 
2207 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra));
2208 	ra = (struct sta_rec_ra *)tlv;
2209 
2210 	ra->valid = true;
2211 	ra->auto_rate = true;
2212 	ra->phy_mode = mt7915_get_phy_mode(vif, sta);
2213 	ra->channel = chandef->chan->hw_value;
2214 	ra->bw = sta->bandwidth;
2215 	ra->phy.bw = sta->bandwidth;
2216 
2217 	if (supp_rate) {
2218 		supp_rate &= mask->control[band].legacy;
2219 		ra->rate_len = hweight32(supp_rate);
2220 
2221 		if (band == NL80211_BAND_2GHZ) {
2222 			ra->supp_mode = MODE_CCK;
2223 			ra->supp_cck_rate = supp_rate & GENMASK(3, 0);
2224 
2225 			if (ra->rate_len > 4) {
2226 				ra->supp_mode |= MODE_OFDM;
2227 				ra->supp_ofdm_rate = supp_rate >> 4;
2228 			}
2229 		} else {
2230 			ra->supp_mode = MODE_OFDM;
2231 			ra->supp_ofdm_rate = supp_rate;
2232 		}
2233 	}
2234 
2235 	if (sta->ht_cap.ht_supported) {
2236 		const u8 *mcs_mask = mask->control[band].ht_mcs;
2237 
2238 		ra->supp_mode |= MODE_HT;
2239 		ra->af = sta->ht_cap.ampdu_factor;
2240 		ra->ht_gf = !!(sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD);
2241 
2242 		cap |= STA_CAP_HT;
2243 		if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20)
2244 			cap |= STA_CAP_SGI_20;
2245 		if (sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)
2246 			cap |= STA_CAP_SGI_40;
2247 		if (sta->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC)
2248 			cap |= STA_CAP_TX_STBC;
2249 		if (sta->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)
2250 			cap |= STA_CAP_RX_STBC;
2251 		if (sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING)
2252 			cap |= STA_CAP_LDPC;
2253 
2254 		mt7915_mcu_set_sta_ht_mcs(sta, ra->ht_mcs, mcs_mask);
2255 		ra->supp_ht_mcs = *(__le32 *)ra->ht_mcs;
2256 	}
2257 
2258 	if (sta->vht_cap.vht_supported) {
2259 		const u16 *mcs_mask = mask->control[band].vht_mcs;
2260 		u8 af;
2261 
2262 		ra->supp_mode |= MODE_VHT;
2263 		af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
2264 			       sta->vht_cap.cap);
2265 		ra->af = max_t(u8, ra->af, af);
2266 
2267 		cap |= STA_CAP_VHT;
2268 		if (sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80)
2269 			cap |= STA_CAP_VHT_SGI_80;
2270 		if (sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_160)
2271 			cap |= STA_CAP_VHT_SGI_160;
2272 		if (sta->vht_cap.cap & IEEE80211_VHT_CAP_TXSTBC)
2273 			cap |= STA_CAP_VHT_TX_STBC;
2274 		if (sta->vht_cap.cap & IEEE80211_VHT_CAP_RXSTBC_1)
2275 			cap |= STA_CAP_VHT_RX_STBC;
2276 		if (sta->vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC)
2277 			cap |= STA_CAP_VHT_LDPC;
2278 
2279 		mt7915_mcu_set_sta_vht_mcs(sta, ra->supp_vht_mcs, mcs_mask);
2280 	}
2281 
2282 	if (sta->he_cap.has_he) {
2283 		ra->supp_mode |= MODE_HE;
2284 		cap |= STA_CAP_HE;
2285 	}
2286 
2287 	ra->sta_cap = cpu_to_le32(cap);
2288 }
2289 
2290 int mt7915_mcu_add_rate_ctrl(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2291 			     struct ieee80211_sta *sta)
2292 {
2293 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2294 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2295 	struct sk_buff *skb;
2296 	int len = sizeof(struct sta_req_hdr) + sizeof(struct sta_rec_ra);
2297 
2298 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
2299 	if (IS_ERR(skb))
2300 		return PTR_ERR(skb);
2301 
2302 	mt7915_mcu_sta_rate_ctrl_tlv(skb, dev, vif, sta);
2303 
2304 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2305 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
2306 }
2307 
2308 int mt7915_mcu_add_he(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2309 		      struct ieee80211_sta *sta)
2310 {
2311 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2312 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2313 	struct sk_buff *skb;
2314 	int len;
2315 
2316 	if (!sta->he_cap.has_he)
2317 		return 0;
2318 
2319 	len = sizeof(struct sta_req_hdr) + sizeof(struct sta_rec_he);
2320 
2321 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
2322 	if (IS_ERR(skb))
2323 		return PTR_ERR(skb);
2324 
2325 	mt7915_mcu_sta_he_tlv(skb, sta);
2326 
2327 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2328 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
2329 }
2330 
2331 static int
2332 mt7915_mcu_add_group(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2333 		     struct ieee80211_sta *sta)
2334 {
2335 #define MT_STA_BSS_GROUP		1
2336 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2337 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2338 	struct {
2339 		__le32 action;
2340 		u8 wlan_idx_lo;
2341 		u8 status;
2342 		u8 wlan_idx_hi;
2343 		u8 rsv0[5];
2344 		__le32 val;
2345 		u8 rsv1[8];
2346 	} __packed req = {
2347 		.action = cpu_to_le32(MT_STA_BSS_GROUP),
2348 		.wlan_idx_lo = to_wcid_lo(msta->wcid.idx),
2349 		.wlan_idx_hi = to_wcid_hi(msta->wcid.idx),
2350 		.val = cpu_to_le32(mvif->idx % 16),
2351 	};
2352 
2353 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_DRR_CTRL), &req,
2354 				 sizeof(req), true);
2355 }
2356 
2357 static int
2358 mt7915_mcu_add_mu(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2359 		  struct ieee80211_sta *sta)
2360 {
2361 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2362 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2363 	struct sk_buff *skb;
2364 	int ret;
2365 
2366 	if (!sta->vht_cap.vht_supported && !sta->he_cap.has_he)
2367 		return 0;
2368 
2369 	ret = mt7915_mcu_add_group(dev, vif, sta);
2370 	if (ret)
2371 		return ret;
2372 
2373 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta,
2374 				       MT7915_STA_UPDATE_MAX_SIZE);
2375 	if (IS_ERR(skb))
2376 		return PTR_ERR(skb);
2377 
2378 	/* wait until TxBF and MU ready to update stare vht */
2379 
2380 	/* starec muru */
2381 	mt7915_mcu_sta_muru_tlv(skb, sta);
2382 	/* starec vht */
2383 	mt7915_mcu_sta_vht_tlv(skb, sta);
2384 
2385 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2386 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
2387 }
2388 
2389 int mt7915_mcu_add_sta_adv(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2390 			   struct ieee80211_sta *sta, bool enable)
2391 {
2392 	int ret;
2393 
2394 	if (!sta)
2395 		return 0;
2396 
2397 	/* must keep the order */
2398 	ret = mt7915_mcu_add_txbf(dev, vif, sta, enable);
2399 	if (ret || !enable)
2400 		return ret;
2401 
2402 	ret = mt7915_mcu_add_mu(dev, vif, sta);
2403 	if (ret)
2404 		return ret;
2405 
2406 	return mt7915_mcu_add_rate_ctrl(dev, vif, sta);
2407 }
2408 
2409 int mt7915_mcu_add_sta(struct mt7915_dev *dev, struct ieee80211_vif *vif,
2410 		       struct ieee80211_sta *sta, bool enable)
2411 {
2412 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2413 	struct wtbl_req_hdr *wtbl_hdr;
2414 	struct mt7915_sta *msta;
2415 	struct tlv *sta_wtbl;
2416 	struct sk_buff *skb;
2417 
2418 	msta = sta ? (struct mt7915_sta *)sta->drv_priv : &mvif->sta;
2419 
2420 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta,
2421 				       MT7915_STA_UPDATE_MAX_SIZE);
2422 	if (IS_ERR(skb))
2423 		return PTR_ERR(skb);
2424 
2425 	mt7915_mcu_sta_basic_tlv(skb, vif, sta, enable);
2426 	if (enable && sta)
2427 		mt7915_mcu_sta_tlv(dev, skb, sta, vif);
2428 
2429 	sta_wtbl = mt7915_mcu_add_tlv(skb, STA_REC_WTBL, sizeof(struct tlv));
2430 
2431 	wtbl_hdr = mt7915_mcu_alloc_wtbl_req(dev, msta, WTBL_RESET_AND_SET,
2432 					     sta_wtbl, &skb);
2433 	if (IS_ERR(wtbl_hdr))
2434 		return PTR_ERR(wtbl_hdr);
2435 
2436 	if (enable) {
2437 		mt7915_mcu_wtbl_generic_tlv(skb, vif, sta, sta_wtbl, wtbl_hdr);
2438 		mt7915_mcu_wtbl_hdr_trans_tlv(skb, vif, sta, sta_wtbl, wtbl_hdr);
2439 		if (sta)
2440 			mt7915_mcu_wtbl_ht_tlv(skb, sta, sta_wtbl, wtbl_hdr);
2441 	}
2442 
2443 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2444 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
2445 }
2446 
2447 int mt7915_mcu_set_fixed_rate(struct mt7915_dev *dev,
2448 			      struct ieee80211_sta *sta, u32 rate)
2449 {
2450 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
2451 	struct mt7915_vif *mvif = msta->vif;
2452 	struct sta_rec_ra_fixed *ra;
2453 	struct sk_buff *skb;
2454 	struct tlv *tlv;
2455 	int len = sizeof(struct sta_req_hdr) + sizeof(*ra);
2456 
2457 	skb = mt7915_mcu_alloc_sta_req(dev, mvif, msta, len);
2458 	if (IS_ERR(skb))
2459 		return PTR_ERR(skb);
2460 
2461 	tlv = mt7915_mcu_add_tlv(skb, STA_REC_RA_UPDATE, sizeof(*ra));
2462 	ra = (struct sta_rec_ra_fixed *)tlv;
2463 
2464 	if (!rate) {
2465 		ra->field = cpu_to_le32(RATE_PARAM_AUTO);
2466 		goto out;
2467 	} else {
2468 		ra->field = cpu_to_le32(RATE_PARAM_FIXED);
2469 	}
2470 
2471 	ra->phy.type = FIELD_GET(RATE_CFG_PHY_TYPE, rate);
2472 	ra->phy.bw = FIELD_GET(RATE_CFG_BW, rate);
2473 	ra->phy.nss = FIELD_GET(RATE_CFG_NSS, rate);
2474 	ra->phy.mcs = FIELD_GET(RATE_CFG_MCS, rate);
2475 	ra->phy.stbc = FIELD_GET(RATE_CFG_STBC, rate);
2476 
2477 	if (ra->phy.bw)
2478 		ra->phy.ldpc = 7;
2479 	else
2480 		ra->phy.ldpc = FIELD_GET(RATE_CFG_LDPC, rate) * 7;
2481 
2482 	/* HT/VHT - SGI: 1, LGI: 0; HE - SGI: 0, MGI: 1, LGI: 2 */
2483 	if (ra->phy.type > MT_PHY_TYPE_VHT)
2484 		ra->phy.sgi = ra->phy.mcs * 85;
2485 	else
2486 		ra->phy.sgi = ra->phy.mcs * 15;
2487 
2488 out:
2489 	return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2490 				     MCU_EXT_CMD(STA_REC_UPDATE), true);
2491 }
2492 
2493 int mt7915_mcu_add_dev_info(struct mt7915_phy *phy,
2494 			    struct ieee80211_vif *vif, bool enable)
2495 {
2496 	struct mt7915_dev *dev = phy->dev;
2497 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2498 	struct {
2499 		struct req_hdr {
2500 			u8 omac_idx;
2501 			u8 dbdc_idx;
2502 			__le16 tlv_num;
2503 			u8 is_tlv_append;
2504 			u8 rsv[3];
2505 		} __packed hdr;
2506 		struct req_tlv {
2507 			__le16 tag;
2508 			__le16 len;
2509 			u8 active;
2510 			u8 dbdc_idx;
2511 			u8 omac_addr[ETH_ALEN];
2512 		} __packed tlv;
2513 	} data = {
2514 		.hdr = {
2515 			.omac_idx = mvif->omac_idx,
2516 			.dbdc_idx = mvif->band_idx,
2517 			.tlv_num = cpu_to_le16(1),
2518 			.is_tlv_append = 1,
2519 		},
2520 		.tlv = {
2521 			.tag = cpu_to_le16(DEV_INFO_ACTIVE),
2522 			.len = cpu_to_le16(sizeof(struct req_tlv)),
2523 			.active = enable,
2524 			.dbdc_idx = mvif->band_idx,
2525 		},
2526 	};
2527 
2528 	if (mvif->omac_idx >= REPEATER_BSSID_START)
2529 		return mt7915_mcu_muar_config(phy, vif, false, enable);
2530 
2531 	memcpy(data.tlv.omac_addr, vif->addr, ETH_ALEN);
2532 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(DEV_INFO_UPDATE),
2533 				 &data, sizeof(data), true);
2534 }
2535 
2536 static void
2537 mt7915_mcu_beacon_csa(struct sk_buff *rskb, struct sk_buff *skb,
2538 		      struct bss_info_bcn *bcn,
2539 		      struct ieee80211_mutable_offsets *offs)
2540 {
2541 	if (offs->cntdwn_counter_offs[0]) {
2542 		struct tlv *tlv;
2543 		struct bss_info_bcn_csa *csa;
2544 
2545 		tlv = mt7915_mcu_add_nested_subtlv(rskb, BSS_INFO_BCN_CSA,
2546 						   sizeof(*csa), &bcn->sub_ntlv,
2547 						   &bcn->len);
2548 		csa = (struct bss_info_bcn_csa *)tlv;
2549 		csa->cnt = skb->data[offs->cntdwn_counter_offs[0]];
2550 	}
2551 }
2552 
2553 static void
2554 mt7915_mcu_beacon_cont(struct mt7915_dev *dev, struct sk_buff *rskb,
2555 		       struct sk_buff *skb, struct bss_info_bcn *bcn,
2556 		       struct ieee80211_mutable_offsets *offs)
2557 {
2558 	struct mt76_wcid *wcid = &dev->mt76.global_wcid;
2559 	struct bss_info_bcn_cont *cont;
2560 	struct tlv *tlv;
2561 	u8 *buf;
2562 	int len = sizeof(*cont) + MT_TXD_SIZE + skb->len;
2563 
2564 	tlv = mt7915_mcu_add_nested_subtlv(rskb, BSS_INFO_BCN_CONTENT,
2565 					   len, &bcn->sub_ntlv, &bcn->len);
2566 
2567 	cont = (struct bss_info_bcn_cont *)tlv;
2568 	cont->pkt_len = cpu_to_le16(MT_TXD_SIZE + skb->len);
2569 	cont->tim_ofs = cpu_to_le16(offs->tim_offset);
2570 
2571 	if (offs->cntdwn_counter_offs[0])
2572 		cont->csa_ofs = cpu_to_le16(offs->cntdwn_counter_offs[0] - 4);
2573 
2574 	buf = (u8 *)tlv + sizeof(*cont);
2575 	mt7915_mac_write_txwi(dev, (__le32 *)buf, skb, wcid, 0, NULL,
2576 			      true);
2577 	memcpy(buf + MT_TXD_SIZE, skb->data, skb->len);
2578 }
2579 
2580 int mt7915_mcu_add_beacon(struct ieee80211_hw *hw,
2581 			  struct ieee80211_vif *vif, int en)
2582 {
2583 #define MAX_BEACON_SIZE 512
2584 	struct mt7915_dev *dev = mt7915_hw_dev(hw);
2585 	struct mt7915_phy *phy = mt7915_hw_phy(hw);
2586 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
2587 	struct ieee80211_mutable_offsets offs;
2588 	struct ieee80211_tx_info *info;
2589 	struct sk_buff *skb, *rskb;
2590 	struct tlv *tlv;
2591 	struct bss_info_bcn *bcn;
2592 	int len = MT7915_BEACON_UPDATE_SIZE + MAX_BEACON_SIZE;
2593 
2594 	rskb = mt7915_mcu_alloc_sta_req(dev, mvif, NULL, len);
2595 	if (IS_ERR(rskb))
2596 		return PTR_ERR(rskb);
2597 
2598 	tlv = mt7915_mcu_add_tlv(rskb, BSS_INFO_OFFLOAD, sizeof(*bcn));
2599 	bcn = (struct bss_info_bcn *)tlv;
2600 	bcn->enable = en;
2601 
2602 	if (!en)
2603 		goto out;
2604 
2605 	skb = ieee80211_beacon_get_template(hw, vif, &offs);
2606 	if (!skb)
2607 		return -EINVAL;
2608 
2609 	if (skb->len > MAX_BEACON_SIZE - MT_TXD_SIZE) {
2610 		dev_err(dev->mt76.dev, "Bcn size limit exceed\n");
2611 		dev_kfree_skb(skb);
2612 		return -EINVAL;
2613 	}
2614 
2615 	if (mvif->band_idx) {
2616 		info = IEEE80211_SKB_CB(skb);
2617 		info->hw_queue |= MT_TX_HW_QUEUE_EXT_PHY;
2618 	}
2619 
2620 	/* TODO: subtag - bss color count & 11v MBSSID */
2621 	mt7915_mcu_beacon_csa(rskb, skb, bcn, &offs);
2622 	mt7915_mcu_beacon_cont(dev, rskb, skb, bcn, &offs);
2623 	dev_kfree_skb(skb);
2624 
2625 out:
2626 	return mt76_mcu_skb_send_msg(&phy->dev->mt76, rskb,
2627 				     MCU_EXT_CMD(BSS_INFO_UPDATE), true);
2628 }
2629 
2630 static int mt7915_mcu_start_firmware(struct mt7915_dev *dev, u32 addr,
2631 				     u32 option)
2632 {
2633 	struct {
2634 		__le32 option;
2635 		__le32 addr;
2636 	} req = {
2637 		.option = cpu_to_le32(option),
2638 		.addr = cpu_to_le32(addr),
2639 	};
2640 
2641 	return mt76_mcu_send_msg(&dev->mt76, MCU_CMD(FW_START_REQ), &req,
2642 				 sizeof(req), true);
2643 }
2644 
2645 static int mt7915_mcu_restart(struct mt76_dev *dev)
2646 {
2647 	struct {
2648 		u8 power_mode;
2649 		u8 rsv[3];
2650 	} req = {
2651 		.power_mode = 1,
2652 	};
2653 
2654 	return mt76_mcu_send_msg(dev, MCU_CMD(NIC_POWER_CTRL), &req,
2655 				 sizeof(req), false);
2656 }
2657 
2658 static int mt7915_mcu_patch_sem_ctrl(struct mt7915_dev *dev, bool get)
2659 {
2660 	struct {
2661 		__le32 op;
2662 	} req = {
2663 		.op = cpu_to_le32(get ? PATCH_SEM_GET : PATCH_SEM_RELEASE),
2664 	};
2665 
2666 	return mt76_mcu_send_msg(&dev->mt76, MCU_CMD(PATCH_SEM_CONTROL), &req,
2667 				 sizeof(req), true);
2668 }
2669 
2670 static int mt7915_mcu_start_patch(struct mt7915_dev *dev)
2671 {
2672 	struct {
2673 		u8 check_crc;
2674 		u8 reserved[3];
2675 	} req = {
2676 		.check_crc = 0,
2677 	};
2678 
2679 	return mt76_mcu_send_msg(&dev->mt76, MCU_CMD(PATCH_FINISH_REQ), &req,
2680 				 sizeof(req), true);
2681 }
2682 
2683 static int mt7915_driver_own(struct mt7915_dev *dev)
2684 {
2685 	mt76_wr(dev, MT_TOP_LPCR_HOST_BAND0, MT_TOP_LPCR_HOST_DRV_OWN);
2686 	if (!mt76_poll_msec(dev, MT_TOP_LPCR_HOST_BAND0,
2687 			    MT_TOP_LPCR_HOST_FW_OWN, 0, 500)) {
2688 		dev_err(dev->mt76.dev, "Timeout for driver own\n");
2689 		return -EIO;
2690 	}
2691 
2692 	return 0;
2693 }
2694 
2695 static int mt7915_mcu_init_download(struct mt7915_dev *dev, u32 addr,
2696 				    u32 len, u32 mode)
2697 {
2698 	struct {
2699 		__le32 addr;
2700 		__le32 len;
2701 		__le32 mode;
2702 	} req = {
2703 		.addr = cpu_to_le32(addr),
2704 		.len = cpu_to_le32(len),
2705 		.mode = cpu_to_le32(mode),
2706 	};
2707 	int attr;
2708 
2709 	if (req.addr == cpu_to_le32(MCU_PATCH_ADDRESS))
2710 		attr = MCU_CMD(PATCH_START_REQ);
2711 	else
2712 		attr = MCU_CMD(TARGET_ADDRESS_LEN_REQ);
2713 
2714 	return mt76_mcu_send_msg(&dev->mt76, attr, &req, sizeof(req), true);
2715 }
2716 
2717 static int mt7915_load_patch(struct mt7915_dev *dev)
2718 {
2719 	const struct mt7915_patch_hdr *hdr;
2720 	const struct firmware *fw = NULL;
2721 	int i, ret, sem;
2722 
2723 	sem = mt7915_mcu_patch_sem_ctrl(dev, 1);
2724 	switch (sem) {
2725 	case PATCH_IS_DL:
2726 		return 0;
2727 	case PATCH_NOT_DL_SEM_SUCCESS:
2728 		break;
2729 	default:
2730 		dev_err(dev->mt76.dev, "Failed to get patch semaphore\n");
2731 		return -EAGAIN;
2732 	}
2733 
2734 	ret = request_firmware(&fw, MT7915_ROM_PATCH, dev->mt76.dev);
2735 	if (ret)
2736 		goto out;
2737 
2738 	if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
2739 		dev_err(dev->mt76.dev, "Invalid firmware\n");
2740 		ret = -EINVAL;
2741 		goto out;
2742 	}
2743 
2744 	hdr = (const struct mt7915_patch_hdr *)(fw->data);
2745 
2746 	dev_info(dev->mt76.dev, "HW/SW Version: 0x%x, Build Time: %.16s\n",
2747 		 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date);
2748 
2749 	for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) {
2750 		struct mt7915_patch_sec *sec;
2751 		const u8 *dl;
2752 		u32 len, addr;
2753 
2754 		sec = (struct mt7915_patch_sec *)(fw->data + sizeof(*hdr) +
2755 						  i * sizeof(*sec));
2756 		if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) !=
2757 		    PATCH_SEC_TYPE_INFO) {
2758 			ret = -EINVAL;
2759 			goto out;
2760 		}
2761 
2762 		addr = be32_to_cpu(sec->info.addr);
2763 		len = be32_to_cpu(sec->info.len);
2764 		dl = fw->data + be32_to_cpu(sec->offs);
2765 
2766 		ret = mt7915_mcu_init_download(dev, addr, len,
2767 					       DL_MODE_NEED_RSP);
2768 		if (ret) {
2769 			dev_err(dev->mt76.dev, "Download request failed\n");
2770 			goto out;
2771 		}
2772 
2773 		ret = mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER),
2774 					     dl, len);
2775 		if (ret) {
2776 			dev_err(dev->mt76.dev, "Failed to send patch\n");
2777 			goto out;
2778 		}
2779 	}
2780 
2781 	ret = mt7915_mcu_start_patch(dev);
2782 	if (ret)
2783 		dev_err(dev->mt76.dev, "Failed to start patch\n");
2784 
2785 out:
2786 	sem = mt7915_mcu_patch_sem_ctrl(dev, 0);
2787 	switch (sem) {
2788 	case PATCH_REL_SEM_SUCCESS:
2789 		break;
2790 	default:
2791 		ret = -EAGAIN;
2792 		dev_err(dev->mt76.dev, "Failed to release patch semaphore\n");
2793 		goto out;
2794 	}
2795 	release_firmware(fw);
2796 
2797 	return ret;
2798 }
2799 
2800 static u32 mt7915_mcu_gen_dl_mode(u8 feature_set, bool is_wa)
2801 {
2802 	u32 ret = 0;
2803 
2804 	ret |= (feature_set & FW_FEATURE_SET_ENCRYPT) ?
2805 	       (DL_MODE_ENCRYPT | DL_MODE_RESET_SEC_IV) : 0;
2806 	ret |= FIELD_PREP(DL_MODE_KEY_IDX,
2807 			  FIELD_GET(FW_FEATURE_SET_KEY_IDX, feature_set));
2808 	ret |= DL_MODE_NEED_RSP;
2809 	ret |= is_wa ? DL_MODE_WORKING_PDA_CR4 : 0;
2810 
2811 	return ret;
2812 }
2813 
2814 static int
2815 mt7915_mcu_send_ram_firmware(struct mt7915_dev *dev,
2816 			     const struct mt7915_fw_trailer *hdr,
2817 			     const u8 *data, bool is_wa)
2818 {
2819 	int i, offset = 0;
2820 	u32 override = 0, option = 0;
2821 
2822 	for (i = 0; i < hdr->n_region; i++) {
2823 		const struct mt7915_fw_region *region;
2824 		int err;
2825 		u32 len, addr, mode;
2826 
2827 		region = (const struct mt7915_fw_region *)((const u8 *)hdr -
2828 			 (hdr->n_region - i) * sizeof(*region));
2829 		mode = mt7915_mcu_gen_dl_mode(region->feature_set, is_wa);
2830 		len = le32_to_cpu(region->len);
2831 		addr = le32_to_cpu(region->addr);
2832 
2833 		if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR)
2834 			override = addr;
2835 
2836 		err = mt7915_mcu_init_download(dev, addr, len, mode);
2837 		if (err) {
2838 			dev_err(dev->mt76.dev, "Download request failed\n");
2839 			return err;
2840 		}
2841 
2842 		err = mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER),
2843 					     data + offset, len);
2844 		if (err) {
2845 			dev_err(dev->mt76.dev, "Failed to send firmware.\n");
2846 			return err;
2847 		}
2848 
2849 		offset += len;
2850 	}
2851 
2852 	if (override)
2853 		option |= FW_START_OVERRIDE;
2854 
2855 	if (is_wa)
2856 		option |= FW_START_WORKING_PDA_CR4;
2857 
2858 	return mt7915_mcu_start_firmware(dev, override, option);
2859 }
2860 
2861 static int mt7915_load_ram(struct mt7915_dev *dev)
2862 {
2863 	const struct mt7915_fw_trailer *hdr;
2864 	const struct firmware *fw;
2865 	int ret;
2866 
2867 	ret = request_firmware(&fw, MT7915_FIRMWARE_WM, dev->mt76.dev);
2868 	if (ret)
2869 		return ret;
2870 
2871 	if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
2872 		dev_err(dev->mt76.dev, "Invalid firmware\n");
2873 		ret = -EINVAL;
2874 		goto out;
2875 	}
2876 
2877 	hdr = (const struct mt7915_fw_trailer *)(fw->data + fw->size -
2878 					sizeof(*hdr));
2879 
2880 	dev_info(dev->mt76.dev, "WM Firmware Version: %.10s, Build Time: %.15s\n",
2881 		 hdr->fw_ver, hdr->build_date);
2882 
2883 	ret = mt7915_mcu_send_ram_firmware(dev, hdr, fw->data, false);
2884 	if (ret) {
2885 		dev_err(dev->mt76.dev, "Failed to start WM firmware\n");
2886 		goto out;
2887 	}
2888 
2889 	release_firmware(fw);
2890 
2891 	ret = request_firmware(&fw, MT7915_FIRMWARE_WA, dev->mt76.dev);
2892 	if (ret)
2893 		return ret;
2894 
2895 	if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
2896 		dev_err(dev->mt76.dev, "Invalid firmware\n");
2897 		ret = -EINVAL;
2898 		goto out;
2899 	}
2900 
2901 	hdr = (const struct mt7915_fw_trailer *)(fw->data + fw->size -
2902 					sizeof(*hdr));
2903 
2904 	dev_info(dev->mt76.dev, "WA Firmware Version: %.10s, Build Time: %.15s\n",
2905 		 hdr->fw_ver, hdr->build_date);
2906 
2907 	ret = mt7915_mcu_send_ram_firmware(dev, hdr, fw->data, true);
2908 	if (ret) {
2909 		dev_err(dev->mt76.dev, "Failed to start WA firmware\n");
2910 		goto out;
2911 	}
2912 
2913 	snprintf(dev->mt76.hw->wiphy->fw_version,
2914 		 sizeof(dev->mt76.hw->wiphy->fw_version),
2915 		 "%.10s-%.15s", hdr->fw_ver, hdr->build_date);
2916 
2917 out:
2918 	release_firmware(fw);
2919 
2920 	return ret;
2921 }
2922 
2923 static int mt7915_load_firmware(struct mt7915_dev *dev)
2924 {
2925 	int ret;
2926 
2927 	ret = mt7915_load_patch(dev);
2928 	if (ret)
2929 		return ret;
2930 
2931 	ret = mt7915_load_ram(dev);
2932 	if (ret)
2933 		return ret;
2934 
2935 	if (!mt76_poll_msec(dev, MT_TOP_MISC, MT_TOP_MISC_FW_STATE,
2936 			    FIELD_PREP(MT_TOP_MISC_FW_STATE,
2937 				       FW_STATE_WACPU_RDY), 1000)) {
2938 		dev_err(dev->mt76.dev, "Timeout for initializing firmware\n");
2939 		return -EIO;
2940 	}
2941 
2942 	mt76_queue_tx_cleanup(dev, dev->mt76.q_mcu[MT_MCUQ_FWDL], false);
2943 
2944 	dev_dbg(dev->mt76.dev, "Firmware init done\n");
2945 
2946 	return 0;
2947 }
2948 
2949 int mt7915_mcu_fw_log_2_host(struct mt7915_dev *dev, u8 ctrl)
2950 {
2951 	struct {
2952 		u8 ctrl_val;
2953 		u8 pad[3];
2954 	} data = {
2955 		.ctrl_val = ctrl
2956 	};
2957 
2958 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(FW_LOG_2_HOST), &data,
2959 				 sizeof(data), true);
2960 }
2961 
2962 int mt7915_mcu_fw_dbg_ctrl(struct mt7915_dev *dev, u32 module, u8 level)
2963 {
2964 	struct {
2965 		u8 ver;
2966 		u8 pad;
2967 		__le16 len;
2968 		u8 level;
2969 		u8 rsv[3];
2970 		__le32 module_idx;
2971 	} data = {
2972 		.module_idx = cpu_to_le32(module),
2973 		.level = level,
2974 	};
2975 
2976 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(FW_DBG_CTRL), &data,
2977 				 sizeof(data), false);
2978 }
2979 
2980 static int mt7915_mcu_set_mwds(struct mt7915_dev *dev, bool enabled)
2981 {
2982 	struct {
2983 		u8 enable;
2984 		u8 _rsv[3];
2985 	} __packed req = {
2986 		.enable = enabled
2987 	};
2988 
2989 	return mt76_mcu_send_msg(&dev->mt76, MCU_WA_EXT_CMD(MWDS_SUPPORT), &req,
2990 				 sizeof(req), false);
2991 }
2992 
2993 int mt7915_mcu_init(struct mt7915_dev *dev)
2994 {
2995 	static const struct mt76_mcu_ops mt7915_mcu_ops = {
2996 		.headroom = sizeof(struct mt7915_mcu_txd),
2997 		.mcu_skb_send_msg = mt7915_mcu_send_message,
2998 		.mcu_parse_response = mt7915_mcu_parse_response,
2999 		.mcu_restart = mt7915_mcu_restart,
3000 	};
3001 	int ret;
3002 
3003 	dev->mt76.mcu_ops = &mt7915_mcu_ops;
3004 
3005 	ret = mt7915_driver_own(dev);
3006 	if (ret)
3007 		return ret;
3008 
3009 	ret = mt7915_load_firmware(dev);
3010 	if (ret)
3011 		return ret;
3012 
3013 	set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
3014 	mt7915_mcu_fw_log_2_host(dev, 0);
3015 	mt7915_mcu_set_mwds(dev, 1);
3016 	mt7915_mcu_wa_cmd(dev, MCU_WA_PARAM_CMD(SET), MCU_WA_PARAM_RED, 0, 0);
3017 
3018 	return 0;
3019 }
3020 
3021 void mt7915_mcu_exit(struct mt7915_dev *dev)
3022 {
3023 	__mt76_mcu_restart(&dev->mt76);
3024 	if (!mt76_poll_msec(dev, MT_TOP_MISC, MT_TOP_MISC_FW_STATE,
3025 			    FIELD_PREP(MT_TOP_MISC_FW_STATE,
3026 				       FW_STATE_FW_DOWNLOAD), 1000)) {
3027 		dev_err(dev->mt76.dev, "Failed to exit mcu\n");
3028 		return;
3029 	}
3030 
3031 	mt76_wr(dev, MT_TOP_LPCR_HOST_BAND0, MT_TOP_LPCR_HOST_FW_OWN);
3032 	skb_queue_purge(&dev->mt76.mcu.res_q);
3033 }
3034 
3035 static int
3036 mt7915_mcu_set_rx_hdr_trans_blacklist(struct mt7915_dev *dev, int band)
3037 {
3038 	struct {
3039 		u8 operation;
3040 		u8 count;
3041 		u8 _rsv[2];
3042 		u8 index;
3043 		u8 enable;
3044 		__le16 etype;
3045 	} req = {
3046 		.operation = 1,
3047 		.count = 1,
3048 		.enable = 1,
3049 		.etype = cpu_to_le16(ETH_P_PAE),
3050 	};
3051 
3052 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RX_HDR_TRANS),
3053 				 &req, sizeof(req), false);
3054 }
3055 
3056 int mt7915_mcu_set_mac(struct mt7915_dev *dev, int band,
3057 		       bool enable, bool hdr_trans)
3058 {
3059 	struct {
3060 		u8 operation;
3061 		u8 enable;
3062 		u8 check_bssid;
3063 		u8 insert_vlan;
3064 		u8 remove_vlan;
3065 		u8 tid;
3066 		u8 mode;
3067 		u8 rsv;
3068 	} __packed req_trans = {
3069 		.enable = hdr_trans,
3070 	};
3071 	struct {
3072 		u8 enable;
3073 		u8 band;
3074 		u8 rsv[2];
3075 	} __packed req_mac = {
3076 		.enable = enable,
3077 		.band = band,
3078 	};
3079 	int ret;
3080 
3081 	ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RX_HDR_TRANS),
3082 				&req_trans, sizeof(req_trans), false);
3083 	if (ret)
3084 		return ret;
3085 
3086 	if (hdr_trans)
3087 		mt7915_mcu_set_rx_hdr_trans_blacklist(dev, band);
3088 
3089 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(MAC_INIT_CTRL),
3090 				 &req_mac, sizeof(req_mac), true);
3091 }
3092 
3093 int mt7915_mcu_set_scs(struct mt7915_dev *dev, u8 band, bool enable)
3094 {
3095 	struct {
3096 		__le32 cmd;
3097 		u8 band;
3098 		u8 enable;
3099 	} __packed req = {
3100 		.cmd = cpu_to_le32(SCS_ENABLE),
3101 		.band = band,
3102 		.enable = enable + 1,
3103 	};
3104 
3105 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SCS_CTRL), &req,
3106 				 sizeof(req), false);
3107 }
3108 
3109 int mt7915_mcu_set_rts_thresh(struct mt7915_phy *phy, u32 val)
3110 {
3111 	struct mt7915_dev *dev = phy->dev;
3112 	struct {
3113 		u8 prot_idx;
3114 		u8 band;
3115 		u8 rsv[2];
3116 		__le32 len_thresh;
3117 		__le32 pkt_thresh;
3118 	} __packed req = {
3119 		.prot_idx = 1,
3120 		.band = phy != &dev->phy,
3121 		.len_thresh = cpu_to_le32(val),
3122 		.pkt_thresh = cpu_to_le32(0x2),
3123 	};
3124 
3125 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(PROTECT_CTRL), &req,
3126 				 sizeof(req), true);
3127 }
3128 
3129 int mt7915_mcu_update_edca(struct mt7915_dev *dev, void *param)
3130 {
3131 	struct mt7915_mcu_tx *req = (struct mt7915_mcu_tx *)param;
3132 	u8 num = req->total;
3133 	size_t len = sizeof(*req) -
3134 		     (IEEE80211_NUM_ACS - num) * sizeof(struct edca);
3135 
3136 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EDCA_UPDATE), req,
3137 				 len, true);
3138 }
3139 
3140 int mt7915_mcu_set_tx(struct mt7915_dev *dev, struct ieee80211_vif *vif)
3141 {
3142 #define TX_CMD_MODE		1
3143 	struct mt7915_mcu_tx req = {
3144 		.valid = true,
3145 		.mode = TX_CMD_MODE,
3146 		.total = IEEE80211_NUM_ACS,
3147 	};
3148 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
3149 	int ac;
3150 
3151 	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
3152 		struct ieee80211_tx_queue_params *q = &mvif->queue_params[ac];
3153 		struct edca *e = &req.edca[ac];
3154 
3155 		e->set = WMM_PARAM_SET;
3156 		e->queue = ac + mvif->wmm_idx * MT7915_MAX_WMM_SETS;
3157 		e->aifs = q->aifs;
3158 		e->txop = cpu_to_le16(q->txop);
3159 
3160 		if (q->cw_min)
3161 			e->cw_min = fls(q->cw_min);
3162 		else
3163 			e->cw_min = 5;
3164 
3165 		if (q->cw_max)
3166 			e->cw_max = cpu_to_le16(fls(q->cw_max));
3167 		else
3168 			e->cw_max = cpu_to_le16(10);
3169 	}
3170 
3171 	return mt7915_mcu_update_edca(dev, &req);
3172 }
3173 
3174 int mt7915_mcu_set_pm(struct mt7915_dev *dev, int band, int enter)
3175 {
3176 #define ENTER_PM_STATE		1
3177 #define EXIT_PM_STATE		2
3178 	struct {
3179 		u8 pm_number;
3180 		u8 pm_state;
3181 		u8 bssid[ETH_ALEN];
3182 		u8 dtim_period;
3183 		u8 wlan_idx_lo;
3184 		__le16 bcn_interval;
3185 		__le32 aid;
3186 		__le32 rx_filter;
3187 		u8 band_idx;
3188 		u8 wlan_idx_hi;
3189 		u8 rsv[2];
3190 		__le32 feature;
3191 		u8 omac_idx;
3192 		u8 wmm_idx;
3193 		u8 bcn_loss_cnt;
3194 		u8 bcn_sp_duration;
3195 	} __packed req = {
3196 		.pm_number = 5,
3197 		.pm_state = (enter) ? ENTER_PM_STATE : EXIT_PM_STATE,
3198 		.band_idx = band,
3199 	};
3200 
3201 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(PM_STATE_CTRL), &req,
3202 				 sizeof(req), true);
3203 }
3204 
3205 int mt7915_mcu_rdd_cmd(struct mt7915_dev *dev,
3206 		       enum mt7915_rdd_cmd cmd, u8 index,
3207 		       u8 rx_sel, u8 val)
3208 {
3209 	struct {
3210 		u8 ctrl;
3211 		u8 rdd_idx;
3212 		u8 rdd_rx_sel;
3213 		u8 val;
3214 		u8 rsv[4];
3215 	} __packed req = {
3216 		.ctrl = cmd,
3217 		.rdd_idx = index,
3218 		.rdd_rx_sel = rx_sel,
3219 		.val = val,
3220 	};
3221 
3222 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_CTRL), &req,
3223 				 sizeof(req), true);
3224 }
3225 
3226 int mt7915_mcu_set_fcc5_lpn(struct mt7915_dev *dev, int val)
3227 {
3228 	struct {
3229 		__le32 tag;
3230 		__le16 min_lpn;
3231 		u8 rsv[2];
3232 	} __packed req = {
3233 		.tag = cpu_to_le32(0x1),
3234 		.min_lpn = cpu_to_le16(val),
3235 	};
3236 
3237 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
3238 				 sizeof(req), true);
3239 }
3240 
3241 int mt7915_mcu_set_pulse_th(struct mt7915_dev *dev,
3242 			    const struct mt7915_dfs_pulse *pulse)
3243 {
3244 	struct {
3245 		__le32 tag;
3246 
3247 		__le32 max_width;		/* us */
3248 		__le32 max_pwr;			/* dbm */
3249 		__le32 min_pwr;			/* dbm */
3250 		__le32 min_stgr_pri;		/* us */
3251 		__le32 max_stgr_pri;		/* us */
3252 		__le32 min_cr_pri;		/* us */
3253 		__le32 max_cr_pri;		/* us */
3254 	} __packed req = {
3255 		.tag = cpu_to_le32(0x3),
3256 
3257 #define __req_field(field) .field = cpu_to_le32(pulse->field)
3258 		__req_field(max_width),
3259 		__req_field(max_pwr),
3260 		__req_field(min_pwr),
3261 		__req_field(min_stgr_pri),
3262 		__req_field(max_stgr_pri),
3263 		__req_field(min_cr_pri),
3264 		__req_field(max_cr_pri),
3265 #undef __req_field
3266 	};
3267 
3268 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
3269 				 sizeof(req), true);
3270 }
3271 
3272 int mt7915_mcu_set_radar_th(struct mt7915_dev *dev, int index,
3273 			    const struct mt7915_dfs_pattern *pattern)
3274 {
3275 	struct {
3276 		__le32 tag;
3277 		__le16 radar_type;
3278 
3279 		u8 enb;
3280 		u8 stgr;
3281 		u8 min_crpn;
3282 		u8 max_crpn;
3283 		u8 min_crpr;
3284 		u8 min_pw;
3285 		__le32 min_pri;
3286 		__le32 max_pri;
3287 		u8 max_pw;
3288 		u8 min_crbn;
3289 		u8 max_crbn;
3290 		u8 min_stgpn;
3291 		u8 max_stgpn;
3292 		u8 min_stgpr;
3293 		u8 rsv[2];
3294 		__le32 min_stgpr_diff;
3295 	} __packed req = {
3296 		.tag = cpu_to_le32(0x2),
3297 		.radar_type = cpu_to_le16(index),
3298 
3299 #define __req_field_u8(field) .field = pattern->field
3300 #define __req_field_u32(field) .field = cpu_to_le32(pattern->field)
3301 		__req_field_u8(enb),
3302 		__req_field_u8(stgr),
3303 		__req_field_u8(min_crpn),
3304 		__req_field_u8(max_crpn),
3305 		__req_field_u8(min_crpr),
3306 		__req_field_u8(min_pw),
3307 		__req_field_u32(min_pri),
3308 		__req_field_u32(max_pri),
3309 		__req_field_u8(max_pw),
3310 		__req_field_u8(min_crbn),
3311 		__req_field_u8(max_crbn),
3312 		__req_field_u8(min_stgpn),
3313 		__req_field_u8(max_stgpn),
3314 		__req_field_u8(min_stgpr),
3315 		__req_field_u32(min_stgpr_diff),
3316 #undef __req_field_u8
3317 #undef __req_field_u32
3318 	};
3319 
3320 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_RDD_TH), &req,
3321 				 sizeof(req), true);
3322 }
3323 
3324 int mt7915_mcu_set_chan_info(struct mt7915_phy *phy, int cmd)
3325 {
3326 	struct mt7915_dev *dev = phy->dev;
3327 	struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
3328 	int freq1 = chandef->center_freq1;
3329 	bool ext_phy = phy != &dev->phy;
3330 	struct {
3331 		u8 control_ch;
3332 		u8 center_ch;
3333 		u8 bw;
3334 		u8 tx_streams_num;
3335 		u8 rx_streams;	/* mask or num */
3336 		u8 switch_reason;
3337 		u8 band_idx;
3338 		u8 center_ch2;	/* for 80+80 only */
3339 		__le16 cac_case;
3340 		u8 channel_band;
3341 		u8 rsv0;
3342 		__le32 outband_freq;
3343 		u8 txpower_drop;
3344 		u8 ap_bw;
3345 		u8 ap_center_ch;
3346 		u8 rsv1[57];
3347 	} __packed req = {
3348 		.control_ch = chandef->chan->hw_value,
3349 		.center_ch = ieee80211_frequency_to_channel(freq1),
3350 		.bw = mt7915_mcu_chan_bw(chandef),
3351 		.tx_streams_num = hweight8(phy->mt76->antenna_mask),
3352 		.rx_streams = phy->mt76->antenna_mask,
3353 		.band_idx = ext_phy,
3354 		.channel_band = chandef->chan->band,
3355 	};
3356 
3357 #ifdef CONFIG_NL80211_TESTMODE
3358 	if (phy->mt76->test.tx_antenna_mask &&
3359 	    (phy->mt76->test.state == MT76_TM_STATE_TX_FRAMES ||
3360 	     phy->mt76->test.state == MT76_TM_STATE_RX_FRAMES ||
3361 	     phy->mt76->test.state == MT76_TM_STATE_TX_CONT)) {
3362 		req.tx_streams_num = fls(phy->mt76->test.tx_antenna_mask);
3363 		req.rx_streams = phy->mt76->test.tx_antenna_mask;
3364 
3365 		if (ext_phy) {
3366 			req.tx_streams_num = 2;
3367 			req.rx_streams >>= 2;
3368 		}
3369 	}
3370 #endif
3371 
3372 	if (phy->mt76->hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
3373 		req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD;
3374 	else if ((chandef->chan->flags & IEEE80211_CHAN_RADAR) &&
3375 		 chandef->chan->dfs_state != NL80211_DFS_AVAILABLE)
3376 		req.switch_reason = CH_SWITCH_DFS;
3377 	else
3378 		req.switch_reason = CH_SWITCH_NORMAL;
3379 
3380 	if (cmd == MCU_EXT_CMD(CHANNEL_SWITCH))
3381 		req.rx_streams = hweight8(req.rx_streams);
3382 
3383 	if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
3384 		int freq2 = chandef->center_freq2;
3385 
3386 		req.center_ch2 = ieee80211_frequency_to_channel(freq2);
3387 	}
3388 
3389 	return mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true);
3390 }
3391 
3392 static int mt7915_mcu_set_eeprom_flash(struct mt7915_dev *dev)
3393 {
3394 #define TOTAL_PAGE_MASK		GENMASK(7, 5)
3395 #define PAGE_IDX_MASK		GENMASK(4, 2)
3396 #define PER_PAGE_SIZE		0x400
3397 	struct mt7915_mcu_eeprom req = { .buffer_mode = EE_MODE_BUFFER };
3398 	u8 total = MT7915_EEPROM_SIZE / PER_PAGE_SIZE;
3399 	u8 *eep = (u8 *)dev->mt76.eeprom.data;
3400 	int eep_len;
3401 	int i;
3402 
3403 	for (i = 0; i <= total; i++, eep += eep_len) {
3404 		struct sk_buff *skb;
3405 		int ret;
3406 
3407 		if (i == total)
3408 			eep_len = MT7915_EEPROM_SIZE % PER_PAGE_SIZE;
3409 		else
3410 			eep_len = PER_PAGE_SIZE;
3411 
3412 		skb = mt76_mcu_msg_alloc(&dev->mt76, NULL,
3413 					 sizeof(req) + eep_len);
3414 		if (!skb)
3415 			return -ENOMEM;
3416 
3417 		req.format = FIELD_PREP(TOTAL_PAGE_MASK, total) |
3418 			     FIELD_PREP(PAGE_IDX_MASK, i) | EE_FORMAT_WHOLE;
3419 		req.len = cpu_to_le16(eep_len);
3420 
3421 		skb_put_data(skb, &req, sizeof(req));
3422 		skb_put_data(skb, eep, eep_len);
3423 
3424 		ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
3425 					    MCU_EXT_CMD(EFUSE_BUFFER_MODE), true);
3426 		if (ret)
3427 			return ret;
3428 	}
3429 
3430 	return 0;
3431 }
3432 
3433 int mt7915_mcu_set_eeprom(struct mt7915_dev *dev)
3434 {
3435 	struct mt7915_mcu_eeprom req = {
3436 		.buffer_mode = EE_MODE_EFUSE,
3437 		.format = EE_FORMAT_WHOLE,
3438 	};
3439 
3440 	if (dev->flash_mode)
3441 		return mt7915_mcu_set_eeprom_flash(dev);
3442 
3443 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EFUSE_BUFFER_MODE),
3444 				 &req, sizeof(req), true);
3445 }
3446 
3447 int mt7915_mcu_get_eeprom(struct mt7915_dev *dev, u32 offset)
3448 {
3449 	struct mt7915_mcu_eeprom_info req = {
3450 		.addr = cpu_to_le32(round_down(offset,
3451 				    MT7915_EEPROM_BLOCK_SIZE)),
3452 	};
3453 	struct mt7915_mcu_eeprom_info *res;
3454 	struct sk_buff *skb;
3455 	int ret;
3456 	u8 *buf;
3457 
3458 	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_QUERY(EFUSE_ACCESS), &req,
3459 				sizeof(req), true, &skb);
3460 	if (ret)
3461 		return ret;
3462 
3463 	res = (struct mt7915_mcu_eeprom_info *)skb->data;
3464 	buf = dev->mt76.eeprom.data + le32_to_cpu(res->addr);
3465 	memcpy(buf, res->data, MT7915_EEPROM_BLOCK_SIZE);
3466 	dev_kfree_skb(skb);
3467 
3468 	return 0;
3469 }
3470 
3471 static int mt7915_mcu_set_pre_cal(struct mt7915_dev *dev, u8 idx,
3472 				  u8 *data, u32 len, int cmd)
3473 {
3474 	struct {
3475 		u8 dir;
3476 		u8 valid;
3477 		__le16 bitmap;
3478 		s8 precal;
3479 		u8 action;
3480 		u8 band;
3481 		u8 idx;
3482 		u8 rsv[4];
3483 		__le32 len;
3484 	} req;
3485 	struct sk_buff *skb;
3486 
3487 	skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, sizeof(req) + len);
3488 	if (!skb)
3489 		return -ENOMEM;
3490 
3491 	req.idx = idx;
3492 	req.len = cpu_to_le32(len);
3493 	skb_put_data(skb, &req, sizeof(req));
3494 	skb_put_data(skb, data, len);
3495 
3496 	return mt76_mcu_skb_send_msg(&dev->mt76, skb, cmd, false);
3497 }
3498 
3499 int mt7915_mcu_apply_group_cal(struct mt7915_dev *dev)
3500 {
3501 	u8 idx = 0, *cal = dev->cal, *eep = dev->mt76.eeprom.data;
3502 	u32 total = MT_EE_CAL_GROUP_SIZE;
3503 
3504 	if (!(eep[MT_EE_DO_PRE_CAL] & MT_EE_WIFI_CAL_GROUP))
3505 		return 0;
3506 
3507 	/*
3508 	 * Items: Rx DCOC, RSSI DCOC, Tx TSSI DCOC, Tx LPFG
3509 	 * Tx FDIQ, Tx DCIQ, Rx FDIQ, Rx FIIQ, ADCDCOC
3510 	 */
3511 	while (total > 0) {
3512 		int ret, len;
3513 
3514 		len = min_t(u32, total, MT_EE_CAL_UNIT);
3515 
3516 		ret = mt7915_mcu_set_pre_cal(dev, idx, cal, len,
3517 					     MCU_EXT_CMD(GROUP_PRE_CAL_INFO));
3518 		if (ret)
3519 			return ret;
3520 
3521 		total -= len;
3522 		cal += len;
3523 		idx++;
3524 	}
3525 
3526 	return 0;
3527 }
3528 
3529 static int mt7915_find_freq_idx(const u16 *freqs, int n_freqs, u16 cur)
3530 {
3531 	int i;
3532 
3533 	for (i = 0; i < n_freqs; i++)
3534 		if (cur == freqs[i])
3535 			return i;
3536 
3537 	return -1;
3538 }
3539 
3540 static int mt7915_dpd_freq_idx(u16 freq, u8 bw)
3541 {
3542 	static const u16 freq_list[] = {
3543 		5180, 5200, 5220, 5240,
3544 		5260, 5280, 5300, 5320,
3545 		5500, 5520, 5540, 5560,
3546 		5580, 5600, 5620, 5640,
3547 		5660, 5680, 5700, 5745,
3548 		5765, 5785, 5805, 5825
3549 	};
3550 	int offset_2g = ARRAY_SIZE(freq_list);
3551 	int idx;
3552 
3553 	if (freq < 4000) {
3554 		if (freq < 2432)
3555 			return offset_2g;
3556 		if (freq < 2457)
3557 			return offset_2g + 1;
3558 
3559 		return offset_2g + 2;
3560 	}
3561 
3562 	if (bw == NL80211_CHAN_WIDTH_80P80 || bw == NL80211_CHAN_WIDTH_160)
3563 		return -1;
3564 
3565 	if (bw != NL80211_CHAN_WIDTH_20) {
3566 		idx = mt7915_find_freq_idx(freq_list, ARRAY_SIZE(freq_list),
3567 					   freq + 10);
3568 		if (idx >= 0)
3569 			return idx;
3570 
3571 		idx = mt7915_find_freq_idx(freq_list, ARRAY_SIZE(freq_list),
3572 					   freq - 10);
3573 		if (idx >= 0)
3574 			return idx;
3575 	}
3576 
3577 	return mt7915_find_freq_idx(freq_list, ARRAY_SIZE(freq_list), freq);
3578 }
3579 
3580 int mt7915_mcu_apply_tx_dpd(struct mt7915_phy *phy)
3581 {
3582 	struct mt7915_dev *dev = phy->dev;
3583 	struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
3584 	u16 total = 2, center_freq = chandef->center_freq1;
3585 	u8 *cal = dev->cal, *eep = dev->mt76.eeprom.data;
3586 	int idx;
3587 
3588 	if (!(eep[MT_EE_DO_PRE_CAL] & MT_EE_WIFI_CAL_DPD))
3589 		return 0;
3590 
3591 	idx = mt7915_dpd_freq_idx(center_freq, chandef->width);
3592 	if (idx < 0)
3593 		return -EINVAL;
3594 
3595 	/* Items: Tx DPD, Tx Flatness */
3596 	idx = idx * 2;
3597 	cal += MT_EE_CAL_GROUP_SIZE;
3598 
3599 	while (total--) {
3600 		int ret;
3601 
3602 		cal += (idx * MT_EE_CAL_UNIT);
3603 		ret = mt7915_mcu_set_pre_cal(dev, idx, cal, MT_EE_CAL_UNIT,
3604 					     MCU_EXT_CMD(DPD_PRE_CAL_INFO));
3605 		if (ret)
3606 			return ret;
3607 
3608 		idx++;
3609 	}
3610 
3611 	return 0;
3612 }
3613 
3614 int mt7915_mcu_get_chan_mib_info(struct mt7915_phy *phy, bool chan_switch)
3615 {
3616 	/* strict order */
3617 	static const enum mt7915_chan_mib_offs offs[] = {
3618 		MIB_BUSY_TIME, MIB_TX_TIME, MIB_RX_TIME, MIB_OBSS_AIRTIME
3619 	};
3620 	struct mt76_channel_state *state = phy->mt76->chan_state;
3621 	struct mt76_channel_state *state_ts = &phy->state_ts;
3622 	struct mt7915_dev *dev = phy->dev;
3623 	struct mt7915_mcu_mib *res, req[4];
3624 	struct sk_buff *skb;
3625 	int i, ret;
3626 
3627 	for (i = 0; i < 4; i++) {
3628 		req[i].band = cpu_to_le32(phy != &dev->phy);
3629 		req[i].offs = cpu_to_le32(offs[i]);
3630 	}
3631 
3632 	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_CMD(GET_MIB_INFO),
3633 					req, sizeof(req), true, &skb);
3634 	if (ret)
3635 		return ret;
3636 
3637 	res = (struct mt7915_mcu_mib *)(skb->data + 20);
3638 
3639 	if (chan_switch)
3640 		goto out;
3641 
3642 #define __res_u64(s) le64_to_cpu(res[s].data)
3643 	state->cc_busy += __res_u64(0) - state_ts->cc_busy;
3644 	state->cc_tx += __res_u64(1) - state_ts->cc_tx;
3645 	state->cc_bss_rx += __res_u64(2) - state_ts->cc_bss_rx;
3646 	state->cc_rx += __res_u64(2) + __res_u64(3) - state_ts->cc_rx;
3647 
3648 out:
3649 	state_ts->cc_busy = __res_u64(0);
3650 	state_ts->cc_tx = __res_u64(1);
3651 	state_ts->cc_bss_rx = __res_u64(2);
3652 	state_ts->cc_rx = __res_u64(2) + __res_u64(3);
3653 #undef __res_u64
3654 
3655 	dev_kfree_skb(skb);
3656 
3657 	return 0;
3658 }
3659 
3660 int mt7915_mcu_get_temperature(struct mt7915_phy *phy)
3661 {
3662 	struct mt7915_dev *dev = phy->dev;
3663 	struct {
3664 		u8 ctrl_id;
3665 		u8 action;
3666 		u8 dbdc_idx;
3667 		u8 rsv[5];
3668 	} req = {
3669 		.ctrl_id = THERMAL_SENSOR_TEMP_QUERY,
3670 		.dbdc_idx = phy != &dev->phy,
3671 	};
3672 
3673 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(THERMAL_CTRL), &req,
3674 				 sizeof(req), true);
3675 }
3676 
3677 int mt7915_mcu_set_thermal_throttling(struct mt7915_phy *phy, u8 state)
3678 {
3679 	struct mt7915_dev *dev = phy->dev;
3680 	struct {
3681 		struct mt7915_mcu_thermal_ctrl ctrl;
3682 
3683 		__le32 trigger_temp;
3684 		__le32 restore_temp;
3685 		__le16 sustain_time;
3686 		u8 rsv[2];
3687 	} __packed req = {
3688 		.ctrl = {
3689 			.band_idx = phy != &dev->phy,
3690 		},
3691 	};
3692 	int level;
3693 
3694 #define TRIGGER_TEMPERATURE	122
3695 #define RESTORE_TEMPERATURE	116
3696 #define SUSTAIN_PERIOD		10
3697 
3698 	if (!state) {
3699 		req.ctrl.ctrl_id = THERMAL_PROTECT_DISABLE;
3700 		goto out;
3701 	}
3702 
3703 	/* set duty cycle and level */
3704 	for (level = 0; level < 4; level++) {
3705 		int ret;
3706 
3707 		req.ctrl.ctrl_id = THERMAL_PROTECT_DUTY_CONFIG;
3708 		req.ctrl.duty.duty_level = level;
3709 		req.ctrl.duty.duty_cycle = state;
3710 		state = state * 4 / 5;
3711 
3712 		ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(THERMAL_PROT),
3713 					&req, sizeof(req.ctrl), false);
3714 		if (ret)
3715 			return ret;
3716 	}
3717 
3718 	/* currently use fixed values for throttling, and would be better
3719 	 * to implement thermal zone for dynamic trip in the long run.
3720 	 */
3721 
3722 	/* set high-temperature trigger threshold */
3723 	req.ctrl.ctrl_id = THERMAL_PROTECT_ENABLE;
3724 	req.trigger_temp = cpu_to_le32(TRIGGER_TEMPERATURE);
3725 	req.restore_temp = cpu_to_le32(RESTORE_TEMPERATURE);
3726 	req.sustain_time = cpu_to_le16(SUSTAIN_PERIOD);
3727 
3728 out:
3729 	req.ctrl.type.protect_type = 1;
3730 	req.ctrl.type.trigger_type = 1;
3731 
3732 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(THERMAL_PROT),
3733 				 &req, sizeof(req), false);
3734 }
3735 
3736 int mt7915_mcu_get_tx_rate(struct mt7915_dev *dev, u32 cmd, u16 wlan_idx)
3737 {
3738 	struct {
3739 		__le32 cmd;
3740 		__le16 wlan_idx;
3741 		__le16 ru_idx;
3742 		__le16 direction;
3743 		__le16 dump_group;
3744 	} req = {
3745 		.cmd = cpu_to_le32(cmd),
3746 		.wlan_idx = cpu_to_le16(wlan_idx),
3747 		.dump_group = cpu_to_le16(1),
3748 	};
3749 
3750 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(RATE_CTRL), &req,
3751 				 sizeof(req), false);
3752 }
3753 
3754 int mt7915_mcu_set_txpower_sku(struct mt7915_phy *phy)
3755 {
3756 	struct mt7915_dev *dev = phy->dev;
3757 	struct mt76_phy *mphy = phy->mt76;
3758 	struct ieee80211_hw *hw = mphy->hw;
3759 	struct mt7915_sku_val {
3760 		u8 format_id;
3761 		u8 limit_type;
3762 		u8 dbdc_idx;
3763 		s8 val[MT7915_SKU_RATE_NUM];
3764 	} __packed req = {
3765 		.format_id = 4,
3766 		.dbdc_idx = phy != &dev->phy,
3767 	};
3768 	struct mt76_power_limits limits_array;
3769 	s8 *la = (s8 *)&limits_array;
3770 	int i, idx, n_chains = hweight8(mphy->antenna_mask);
3771 	int tx_power;
3772 
3773 	tx_power = hw->conf.power_level * 2 -
3774 		   mt76_tx_power_nss_delta(n_chains);
3775 
3776 	tx_power = mt76_get_rate_power_limits(mphy, mphy->chandef.chan,
3777 					      &limits_array, tx_power);
3778 	mphy->txpower_cur = tx_power;
3779 
3780 	for (i = 0, idx = 0; i < ARRAY_SIZE(mt7915_sku_group_len); i++) {
3781 		u8 mcs_num, len = mt7915_sku_group_len[i];
3782 		int j;
3783 
3784 		if (i >= SKU_HT_BW20 && i <= SKU_VHT_BW160) {
3785 			mcs_num = 10;
3786 
3787 			if (i == SKU_HT_BW20 || i == SKU_VHT_BW20)
3788 				la = (s8 *)&limits_array + 12;
3789 		} else {
3790 			mcs_num = len;
3791 		}
3792 
3793 		for (j = 0; j < min_t(u8, mcs_num, len); j++)
3794 			req.val[idx + j] = la[j];
3795 
3796 		la += mcs_num;
3797 		idx += len;
3798 	}
3799 
3800 	return mt76_mcu_send_msg(&dev->mt76,
3801 				 MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), &req,
3802 				 sizeof(req), true);
3803 }
3804 
3805 int mt7915_mcu_get_txpower_sku(struct mt7915_phy *phy, s8 *txpower, int len)
3806 {
3807 #define RATE_POWER_INFO	2
3808 	struct mt7915_dev *dev = phy->dev;
3809 	struct {
3810 		u8 format_id;
3811 		u8 category;
3812 		u8 band;
3813 		u8 _rsv;
3814 	} __packed req = {
3815 		.format_id = 7,
3816 		.category = RATE_POWER_INFO,
3817 		.band = phy != &dev->phy,
3818 	};
3819 	s8 res[MT7915_SKU_RATE_NUM][2];
3820 	struct sk_buff *skb;
3821 	int ret, i;
3822 
3823 	ret = mt76_mcu_send_and_get_msg(&dev->mt76,
3824 					MCU_EXT_CMD(TX_POWER_FEATURE_CTRL),
3825 					&req, sizeof(req), true, &skb);
3826 	if (ret)
3827 		return ret;
3828 
3829 	memcpy(res, skb->data + 4, sizeof(res));
3830 	for (i = 0; i < len; i++)
3831 		txpower[i] = res[i][req.band];
3832 
3833 	dev_kfree_skb(skb);
3834 
3835 	return 0;
3836 }
3837 
3838 int mt7915_mcu_set_test_param(struct mt7915_dev *dev, u8 param, bool test_mode,
3839 			      u8 en)
3840 {
3841 	struct {
3842 		u8 test_mode_en;
3843 		u8 param_idx;
3844 		u8 _rsv[2];
3845 
3846 		u8 enable;
3847 		u8 _rsv2[3];
3848 
3849 		u8 pad[8];
3850 	} __packed req = {
3851 		.test_mode_en = test_mode,
3852 		.param_idx = param,
3853 		.enable = en,
3854 	};
3855 
3856 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(ATE_CTRL), &req,
3857 				 sizeof(req), false);
3858 }
3859 
3860 int mt7915_mcu_set_sku_en(struct mt7915_phy *phy, bool enable)
3861 {
3862 	struct mt7915_dev *dev = phy->dev;
3863 	struct mt7915_sku {
3864 		u8 format_id;
3865 		u8 sku_enable;
3866 		u8 dbdc_idx;
3867 		u8 rsv;
3868 	} __packed req = {
3869 		.format_id = 0,
3870 		.dbdc_idx = phy != &dev->phy,
3871 		.sku_enable = enable,
3872 	};
3873 
3874 	return mt76_mcu_send_msg(&dev->mt76,
3875 				 MCU_EXT_CMD(TX_POWER_FEATURE_CTRL), &req,
3876 				 sizeof(req), true);
3877 }
3878 
3879 int mt7915_mcu_set_ser(struct mt7915_dev *dev, u8 action, u8 set, u8 band)
3880 {
3881 	struct {
3882 		u8 action;
3883 		u8 set;
3884 		u8 band;
3885 		u8 rsv;
3886 	} req = {
3887 		.action = action,
3888 		.set = set,
3889 		.band = band,
3890 	};
3891 
3892 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_SER_TRIGGER),
3893 				 &req, sizeof(req), false);
3894 }
3895 
3896 int mt7915_mcu_set_txbf(struct mt7915_dev *dev, u8 action)
3897 {
3898 	struct {
3899 		u8 action;
3900 		union {
3901 			struct {
3902 				u8 snd_mode;
3903 				u8 sta_num;
3904 				u8 rsv;
3905 				u8 wlan_idx[4];
3906 				__le32 snd_period;	/* ms */
3907 			} __packed snd;
3908 			struct {
3909 				bool ebf;
3910 				bool ibf;
3911 				u8 rsv;
3912 			} __packed type;
3913 			struct {
3914 				u8 bf_num;
3915 				u8 bf_bitmap;
3916 				u8 bf_sel[8];
3917 				u8 rsv[5];
3918 			} __packed mod;
3919 		};
3920 	} __packed req = {
3921 		.action = action,
3922 	};
3923 
3924 #define MT_BF_PROCESSING	4
3925 	switch (action) {
3926 	case MT_BF_SOUNDING_ON:
3927 		req.snd.snd_mode = MT_BF_PROCESSING;
3928 		break;
3929 	case MT_BF_TYPE_UPDATE:
3930 		req.type.ebf = true;
3931 		req.type.ibf = dev->ibf;
3932 		break;
3933 	case MT_BF_MODULE_UPDATE:
3934 		req.mod.bf_num = 2;
3935 		req.mod.bf_bitmap = GENMASK(1, 0);
3936 		break;
3937 	default:
3938 		return -EINVAL;
3939 	}
3940 
3941 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(TXBF_ACTION), &req,
3942 				 sizeof(req), true);
3943 }
3944 
3945 int mt7915_mcu_add_obss_spr(struct mt7915_dev *dev, struct ieee80211_vif *vif,
3946 			    bool enable)
3947 {
3948 #define MT_SPR_ENABLE		1
3949 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
3950 	struct {
3951 		u8 action;
3952 		u8 arg_num;
3953 		u8 band_idx;
3954 		u8 status;
3955 		u8 drop_tx_idx;
3956 		u8 sta_idx;	/* 256 sta */
3957 		u8 rsv[2];
3958 		__le32 val;
3959 	} __packed req = {
3960 		.action = MT_SPR_ENABLE,
3961 		.arg_num = 1,
3962 		.band_idx = mvif->band_idx,
3963 		.val = cpu_to_le32(enable),
3964 	};
3965 
3966 	return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(SET_SPR), &req,
3967 				 sizeof(req), true);
3968 }
3969 
3970 int mt7915_mcu_get_rx_rate(struct mt7915_phy *phy, struct ieee80211_vif *vif,
3971 			   struct ieee80211_sta *sta, struct rate_info *rate)
3972 {
3973 	struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv;
3974 	struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv;
3975 	struct mt7915_dev *dev = phy->dev;
3976 	struct mt76_phy *mphy = phy->mt76;
3977 	struct {
3978 		u8 category;
3979 		u8 band;
3980 		__le16 wcid;
3981 	} __packed req = {
3982 		.category = MCU_PHY_STATE_CONTENTION_RX_RATE,
3983 		.band = mvif->band_idx,
3984 		.wcid = cpu_to_le16(msta->wcid.idx),
3985 	};
3986 	struct ieee80211_supported_band *sband;
3987 	struct mt7915_mcu_phy_rx_info *res;
3988 	struct sk_buff *skb;
3989 	int ret;
3990 	bool cck = false;
3991 
3992 	ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_CMD(PHY_STAT_INFO),
3993 					&req, sizeof(req), true, &skb);
3994 	if (ret)
3995 		return ret;
3996 
3997 	res = (struct mt7915_mcu_phy_rx_info *)skb->data;
3998 
3999 	rate->mcs = res->rate;
4000 	rate->nss = res->nsts + 1;
4001 
4002 	switch (res->mode) {
4003 	case MT_PHY_TYPE_CCK:
4004 		cck = true;
4005 		fallthrough;
4006 	case MT_PHY_TYPE_OFDM:
4007 		if (mphy->chandef.chan->band == NL80211_BAND_5GHZ)
4008 			sband = &mphy->sband_5g.sband;
4009 		else
4010 			sband = &mphy->sband_2g.sband;
4011 
4012 		rate->mcs = mt76_get_rate(&dev->mt76, sband, rate->mcs, cck);
4013 		rate->legacy = sband->bitrates[rate->mcs].bitrate;
4014 		break;
4015 	case MT_PHY_TYPE_HT:
4016 	case MT_PHY_TYPE_HT_GF:
4017 		if (rate->mcs > 31) {
4018 			ret = -EINVAL;
4019 			goto out;
4020 		}
4021 
4022 		rate->flags = RATE_INFO_FLAGS_MCS;
4023 		if (res->gi)
4024 			rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
4025 		break;
4026 	case MT_PHY_TYPE_VHT:
4027 		if (rate->mcs > 9) {
4028 			ret = -EINVAL;
4029 			goto out;
4030 		}
4031 
4032 		rate->flags = RATE_INFO_FLAGS_VHT_MCS;
4033 		if (res->gi)
4034 			rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
4035 		break;
4036 	case MT_PHY_TYPE_HE_SU:
4037 	case MT_PHY_TYPE_HE_EXT_SU:
4038 	case MT_PHY_TYPE_HE_TB:
4039 	case MT_PHY_TYPE_HE_MU:
4040 		if (res->gi > NL80211_RATE_INFO_HE_GI_3_2 || rate->mcs > 11) {
4041 			ret = -EINVAL;
4042 			goto out;
4043 		}
4044 		rate->he_gi = res->gi;
4045 		rate->flags = RATE_INFO_FLAGS_HE_MCS;
4046 		break;
4047 	default:
4048 		ret = -EINVAL;
4049 		goto out;
4050 	}
4051 
4052 	switch (res->bw) {
4053 	case IEEE80211_STA_RX_BW_160:
4054 		rate->bw = RATE_INFO_BW_160;
4055 		break;
4056 	case IEEE80211_STA_RX_BW_80:
4057 		rate->bw = RATE_INFO_BW_80;
4058 		break;
4059 	case IEEE80211_STA_RX_BW_40:
4060 		rate->bw = RATE_INFO_BW_40;
4061 		break;
4062 	default:
4063 		rate->bw = RATE_INFO_BW_20;
4064 		break;
4065 	}
4066 
4067 out:
4068 	dev_kfree_skb(skb);
4069 
4070 	return ret;
4071 }
4072