Debian Codegraph @

drivers/net/wireless/mediatek/mt76/mt7996/mcu.c

raw
1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (C) 2022 MediaTek Inc.
4 */
5
6 #include <linux/firmware.h>
7 #include <linux/fs.h>
8 #include "mt7996.h"
9 #include "mcu.h"
10 #include "mac.h"
11 #include "eeprom.h"
12
13 #define fw_name(_dev, name, ...) ({ \
14 char *_fw; \
15 switch (mt76_chip(&(_dev)->mt76)) { \
16 case MT7992_DEVICE_ID: \
17 switch ((_dev)->var.type) { \
18 case MT7992_VAR_TYPE_23: \
19 _fw = MT7992_##name##_23; \
20 break; \
21 default: \
22 _fw = MT7992_##name; \
23 } \
24 break; \
25 case MT7990_DEVICE_ID: \
26 _fw = MT7990_##name; \
27 break; \
28 case MT7996_DEVICE_ID: \
29 default: \
30 switch ((_dev)->var.type) { \
31 case MT7996_VAR_TYPE_233: \
32 _fw = MT7996_##name##_233; \
33 break; \
34 default: \
35 _fw = MT7996_##name; \
36 } \
37 break; \
38 } \
39 _fw; \
40 })
41
42 struct mt7996_patch_hdr {
43 char build_date[16];
44 char platform[4];
45 __be32 hw_sw_ver;
46 __be32 patch_ver;
47 __be16 checksum;
48 u16 reserved;
49 struct {
50 __be32 patch_ver;
51 __be32 subsys;
52 __be32 feature;
53 __be32 n_region;
54 __be32 crc;
55 u32 reserved[11];
56 } desc;
57 } __packed;
58
59 struct mt7996_patch_sec {
60 __be32 type;
61 __be32 offs;
62 __be32 size;
63 union {
64 __be32 spec[13];
65 struct {
66 __be32 addr;
67 __be32 len;
68 __be32 sec_key_idx;
69 __be32 align_len;
70 u32 reserved[9];
71 } info;
72 };
73 } __packed;
74
75 struct mt7996_fw_trailer {
76 u8 chip_id;
77 u8 eco_code;
78 u8 n_region;
79 u8 format_ver;
80 u8 format_flag;
81 u8 reserved[2];
82 char fw_ver[10];
83 char build_date[15];
84 u32 crc;
85 } __packed;
86
87 struct mt7996_fw_region {
88 __le32 decomp_crc;
89 __le32 decomp_len;
90 __le32 decomp_blk_sz;
91 u8 reserved[4];
92 __le32 addr;
93 __le32 len;
94 u8 feature_set;
95 u8 reserved1[15];
96 } __packed;
97
98 #define MCU_PATCH_ADDRESS 0x200000
99
100 #define HE_PHY(p, c) u8_get_bits(c, IEEE80211_HE_PHY_##p)
101 #define HE_MAC(m, c) u8_get_bits(c, IEEE80211_HE_MAC_##m)
102 #define EHT_PHY(p, c) u8_get_bits(c, IEEE80211_EHT_PHY_##p)
103
104 static bool sr_scene_detect = true;
105 module_param(sr_scene_detect, bool, 0644);
106 MODULE_PARM_DESC(sr_scene_detect, "Enable firmware scene detection algorithm");
107
108 static u8
109 mt7996_mcu_get_sta_nss(u16 mcs_map)
110 {
111 u8 nss;
112
113 for (nss = 8; nss > 0; nss--) {
114 u8 nss_mcs = (mcs_map >> (2 * (nss - 1))) & 3;
115
116 if (nss_mcs != IEEE80211_VHT_MCS_NOT_SUPPORTED)
117 break;
118 }
119
120 return nss - 1;
121 }
122
123 static void
124 mt7996_mcu_set_sta_he_mcs(struct ieee80211_link_sta *link_sta,
125 struct mt7996_vif_link *link,
126 __le16 *he_mcs, u16 mcs_map)
127 {
128 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss;
129 enum nl80211_band band = link->phy->mt76->chandef.chan->band;
130 const u16 *mask = link->bitrate_mask.control[band].he_mcs;
131
132 for (nss = 0; nss < max_nss; nss++) {
133 int mcs;
134
135 switch ((mcs_map >> (2 * nss)) & 0x3) {
136 case IEEE80211_HE_MCS_SUPPORT_0_11:
137 mcs = GENMASK(11, 0);
138 break;
139 case IEEE80211_HE_MCS_SUPPORT_0_9:
140 mcs = GENMASK(9, 0);
141 break;
142 case IEEE80211_HE_MCS_SUPPORT_0_7:
143 mcs = GENMASK(7, 0);
144 break;
145 default:
146 mcs = 0;
147 }
148
149 mcs = mcs ? fls(mcs & mask[nss]) - 1 : -1;
150
151 switch (mcs) {
152 case 0 ... 7:
153 mcs = IEEE80211_HE_MCS_SUPPORT_0_7;
154 break;
155 case 8 ... 9:
156 mcs = IEEE80211_HE_MCS_SUPPORT_0_9;
157 break;
158 case 10 ... 11:
159 mcs = IEEE80211_HE_MCS_SUPPORT_0_11;
160 break;
161 default:
162 mcs = IEEE80211_HE_MCS_NOT_SUPPORTED;
163 break;
164 }
165 mcs_map &= ~(0x3 << (nss * 2));
166 mcs_map |= mcs << (nss * 2);
167 }
168
169 *he_mcs = cpu_to_le16(mcs_map);
170 }
171
172 static void
173 mt7996_mcu_set_sta_vht_mcs(struct ieee80211_link_sta *link_sta,
174 __le16 *vht_mcs, const u16 *mask)
175 {
176 u16 mcs, mcs_map = le16_to_cpu(link_sta->vht_cap.vht_mcs.rx_mcs_map);
177 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss;
178
179 for (nss = 0; nss < max_nss; nss++, mcs_map >>= 2) {
180 switch (mcs_map & 0x3) {
181 case IEEE80211_VHT_MCS_SUPPORT_0_9:
182 mcs = GENMASK(9, 0);
183 break;
184 case IEEE80211_VHT_MCS_SUPPORT_0_8:
185 mcs = GENMASK(8, 0);
186 break;
187 case IEEE80211_VHT_MCS_SUPPORT_0_7:
188 mcs = GENMASK(7, 0);
189 break;
190 default:
191 mcs = 0;
192 }
193
194 vht_mcs[nss] = cpu_to_le16(mcs & mask[nss]);
195 }
196 }
197
198 static void
199 mt7996_mcu_set_sta_ht_mcs(struct ieee80211_link_sta *link_sta,
200 u8 *ht_mcs, const u8 *mask)
201 {
202 int nss, max_nss = link_sta->rx_nss > 3 ? 4 : link_sta->rx_nss;
203
204 for (nss = 0; nss < max_nss; nss++)
205 ht_mcs[nss] = link_sta->ht_cap.mcs.rx_mask[nss] & mask[nss];
206 }
207
208 static int
209 mt7996_mcu_parse_response(struct mt76_dev *mdev, int cmd,
210 struct sk_buff *skb, int seq)
211 {
212 struct mt7996_mcu_rxd *rxd;
213 struct mt7996_mcu_uni_event *event;
214 int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
215 int ret = 0;
216
217 if (!skb) {
218 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n",
219 cmd, seq);
220 return -ETIMEDOUT;
221 }
222
223 rxd = (struct mt7996_mcu_rxd *)skb->data;
224 if (seq != rxd->seq)
225 return -EAGAIN;
226
227 if (cmd == MCU_CMD(PATCH_SEM_CONTROL)) {
228 skb_pull(skb, sizeof(*rxd) - 4);
229 ret = *skb->data;
230 } else if ((rxd->option & MCU_UNI_CMD_EVENT) &&
231 rxd->eid == MCU_UNI_EVENT_RESULT) {
232 skb_pull(skb, sizeof(*rxd));
233 event = (struct mt7996_mcu_uni_event *)skb->data;
234 ret = le32_to_cpu(event->status);
235 /* skip invalid event */
236 if (mcu_cmd != le16_to_cpu(event->cid))
237 ret = -EAGAIN;
238 } else {
239 skb_pull(skb, sizeof(struct mt7996_mcu_rxd));
240 }
241
242 return ret;
243 }
244
245 static void
246 mt7996_mcu_set_timeout(struct mt76_dev *mdev, int cmd)
247 {
248 mdev->mcu.timeout = 5 * HZ;
249
250 if (!(cmd & __MCU_CMD_FIELD_UNI))
251 return;
252
253 switch (FIELD_GET(__MCU_CMD_FIELD_ID, cmd)) {
254 case MCU_UNI_CMD_THERMAL:
255 case MCU_UNI_CMD_TWT:
256 case MCU_UNI_CMD_GET_MIB_INFO:
257 case MCU_UNI_CMD_STA_REC_UPDATE:
258 case MCU_UNI_CMD_BSS_INFO_UPDATE:
259 mdev->mcu.timeout = 2 * HZ;
260 return;
261 case MCU_UNI_CMD_EFUSE_CTRL:
262 mdev->mcu.timeout = 20 * HZ;
263 return;
264 default:
265 break;
266 }
267 }
268
269 static int
270 mt7996_mcu_send_message(struct mt76_dev *mdev, struct sk_buff *skb,
271 int cmd, int *wait_seq)
272 {
273 struct mt7996_dev *dev = container_of(mdev, struct mt7996_dev, mt76);
274 int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
275 struct mt76_connac2_mcu_uni_txd *uni_txd;
276 struct mt76_connac2_mcu_txd *mcu_txd;
277 enum mt76_mcuq_id qid;
278 __le32 *txd;
279 u32 val;
280 u8 seq;
281
282 mt7996_mcu_set_timeout(mdev, cmd);
283
284 seq = ++dev->mt76.mcu.msg_seq & 0xf;
285 if (!seq)
286 seq = ++dev->mt76.mcu.msg_seq & 0xf;
287
288 if (cmd == MCU_CMD(FW_SCATTER)) {
289 qid = MT_MCUQ_FWDL;
290 goto exit;
291 }
292
293 txd_len = cmd & __MCU_CMD_FIELD_UNI ? sizeof(*uni_txd) : sizeof(*mcu_txd);
294 txd = (__le32 *)skb_push(skb, txd_len);
295 if (test_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state) && mt7996_has_wa(dev))
296 qid = MT_MCUQ_WA;
297 else
298 qid = MT_MCUQ_WM;
299
300 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) |
301 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) |
302 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0);
303 txd[0] = cpu_to_le32(val);
304
305 val = FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD);
306 txd[1] = cpu_to_le32(val);
307
308 if (cmd & __MCU_CMD_FIELD_UNI) {
309 uni_txd = (struct mt76_connac2_mcu_uni_txd *)txd;
310 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd));
311 uni_txd->cid = cpu_to_le16(mcu_cmd);
312 uni_txd->s2d_index = MCU_S2D_H2CN;
313 uni_txd->pkt_type = MCU_PKT_ID;
314 uni_txd->seq = seq;
315
316 if (cmd & __MCU_CMD_FIELD_QUERY)
317 uni_txd->option = MCU_CMD_UNI_QUERY_ACK;
318 else
319 uni_txd->option = MCU_CMD_UNI_EXT_ACK;
320
321 if (mcu_cmd == MCU_UNI_CMD_SDO)
322 uni_txd->option &= ~MCU_CMD_ACK;
323
324 if ((cmd & __MCU_CMD_FIELD_WA) && (cmd & __MCU_CMD_FIELD_WM))
325 uni_txd->s2d_index = MCU_S2D_H2CN;
326 else if (cmd & __MCU_CMD_FIELD_WA)
327 uni_txd->s2d_index = MCU_S2D_H2C;
328 else if (cmd & __MCU_CMD_FIELD_WM)
329 uni_txd->s2d_index = MCU_S2D_H2N;
330
331 goto exit;
332 }
333
334 mcu_txd = (struct mt76_connac2_mcu_txd *)txd;
335 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd));
336 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU,
337 MT_TX_MCU_PORT_RX_Q0));
338 mcu_txd->pkt_type = MCU_PKT_ID;
339 mcu_txd->seq = seq;
340
341 mcu_txd->cid = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
342 mcu_txd->set_query = MCU_Q_NA;
343 mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
344 if (mcu_txd->ext_cid) {
345 mcu_txd->ext_cid_ack = 1;
346
347 if (cmd & __MCU_CMD_FIELD_QUERY)
348 mcu_txd->set_query = MCU_Q_QUERY;
349 else
350 mcu_txd->set_query = MCU_Q_SET;
351 }
352
353 if (cmd & __MCU_CMD_FIELD_WA)
354 mcu_txd->s2d_index = MCU_S2D_H2C;
355 else
356 mcu_txd->s2d_index = MCU_S2D_H2N;
357
358 exit:
359 if (wait_seq)
360 *wait_seq = seq;
361
362 return mt76_tx_queue_skb_raw(dev, mdev->q_mcu[qid], skb, 0);
363 }
364
365 int mt7996_mcu_wa_cmd(struct mt7996_dev *dev, int cmd, u32 a1, u32 a2, u32 a3)
366 {
367 struct {
368 u8 _rsv[4];
369
370 __le16 tag;
371 __le16 len;
372 __le32 args[3];
373 } __packed req = {
374 .args = {
375 cpu_to_le32(a1),
376 cpu_to_le32(a2),
377 cpu_to_le32(a3),
378 },
379 };
380
381 if (mt7996_has_wa(dev))
382 return mt76_mcu_send_msg(&dev->mt76, cmd, &req.args,
383 sizeof(req.args), false);
384
385 req.tag = cpu_to_le16(cmd == MCU_WA_PARAM_CMD(QUERY) ? UNI_CMD_SDO_QUERY :
386 UNI_CMD_SDO_SET);
387 req.len = cpu_to_le16(sizeof(req) - 4);
388
389 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(SDO), &req,
390 sizeof(req), false);
391 }
392
393 static void
394 mt7996_mcu_csa_finish(void *priv, u8 *mac, struct ieee80211_vif *vif)
395 {
396 if (!vif->bss_conf.csa_active || vif->type == NL80211_IFTYPE_STATION)
397 return;
398
399 ieee80211_csa_finish(vif, 0);
400 }
401
402 static void
403 mt7996_mcu_rx_radar_detected(struct mt7996_dev *dev, struct sk_buff *skb)
404 {
405 struct mt76_phy *mphy = &dev->mt76.phy;
406 struct mt7996_mcu_rdd_report *r;
407
408 r = (struct mt7996_mcu_rdd_report *)skb->data;
409
410 switch (r->rdd_idx) {
411 case MT_RDD_IDX_BAND2:
412 mphy = dev->mt76.phys[MT_BAND2];
413 break;
414 case MT_RDD_IDX_BAND1:
415 mphy = dev->mt76.phys[MT_BAND1];
416 break;
417 case MT_RDD_IDX_BACKGROUND:
418 if (!dev->rdd2_phy)
419 goto err;
420 mphy = dev->rdd2_phy->mt76;
421 break;
422 default:
423 goto err;
424 }
425
426 if (!mphy)
427 goto err;
428
429 if (r->rdd_idx == MT_RDD_IDX_BACKGROUND) {
430 cfg80211_background_radar_event(mphy->hw->wiphy,
431 &dev->rdd2_chandef,
432 GFP_ATOMIC);
433 } else {
434 struct mt7996_phy *phy = mphy->priv;
435
436 phy->rdd_tx_paused = true;
437 ieee80211_radar_detected(mphy->hw, NULL);
438 }
439 dev->hw_pattern++;
440
441 return;
442
443 err:
444 dev_err(dev->mt76.dev, "Invalid RDD idx %d\n", r->rdd_idx);
445 }
446
447 static void
448 mt7996_mcu_rx_log_message(struct mt7996_dev *dev, struct sk_buff *skb)
449 {
450 #define UNI_EVENT_FW_LOG_FORMAT 0
451 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
452 const char *data = (char *)&rxd[1] + 4, *type;
453 struct tlv *tlv = (struct tlv *)data;
454 int len;
455
456 if (!(rxd->option & MCU_UNI_CMD_EVENT)) {
457 len = skb->len - sizeof(*rxd);
458 data = (char *)&rxd[1];
459 goto out;
460 }
461
462 if (le16_to_cpu(tlv->tag) != UNI_EVENT_FW_LOG_FORMAT)
463 return;
464
465 data += sizeof(*tlv) + 4;
466 len = le16_to_cpu(tlv->len) - sizeof(*tlv) - 4;
467
468 out:
469 switch (rxd->s2d_index) {
470 case 0:
471 if (mt7996_debugfs_rx_log(dev, data, len))
472 return;
473
474 type = "WM";
475 break;
476 case 2:
477 type = "WA";
478 break;
479 default:
480 type = "unknown";
481 break;
482 }
483
484 wiphy_info(mt76_hw(dev)->wiphy, "%s: %.*s", type, len, data);
485 }
486
487 static void
488 mt7996_mcu_cca_finish(void *priv, u8 *mac, struct ieee80211_vif *vif)
489 {
490 if (!vif->bss_conf.color_change_active || vif->type == NL80211_IFTYPE_STATION)
491 return;
492
493 ieee80211_color_change_finish(vif, 0);
494 }
495
496 static void
497 mt7996_mcu_ie_countdown(struct mt7996_dev *dev, struct sk_buff *skb)
498 {
499 #define UNI_EVENT_IE_COUNTDOWN_CSA 0
500 #define UNI_EVENT_IE_COUNTDOWN_BCC 1
501 struct header {
502 u8 band;
503 u8 rsv[3];
504 };
505 struct mt76_phy *mphy = &dev->mt76.phy;
506 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
507 const char *data = (char *)&rxd[1], *tail;
508 struct header *hdr = (struct header *)data;
509 struct tlv *tlv = (struct tlv *)(data + 4);
510
511 if (hdr->band >= ARRAY_SIZE(dev->mt76.phys))
512 return;
513
514 if (hdr->band && dev->mt76.phys[hdr->band])
515 mphy = dev->mt76.phys[hdr->band];
516
517 tail = skb->data + skb->len;
518 data += sizeof(struct header);
519 while (data + sizeof(struct tlv) < tail && le16_to_cpu(tlv->len)) {
520 switch (le16_to_cpu(tlv->tag)) {
521 case UNI_EVENT_IE_COUNTDOWN_CSA:
522 ieee80211_iterate_active_interfaces_atomic(mphy->hw,
523 IEEE80211_IFACE_ITER_RESUME_ALL,
524 mt7996_mcu_csa_finish, mphy->hw);
525 break;
526 case UNI_EVENT_IE_COUNTDOWN_BCC:
527 ieee80211_iterate_active_interfaces_atomic(mphy->hw,
528 IEEE80211_IFACE_ITER_RESUME_ALL,
529 mt7996_mcu_cca_finish, mphy->hw);
530 break;
531 }
532
533 data += le16_to_cpu(tlv->len);
534 tlv = (struct tlv *)data;
535 }
536 }
537
538 static int
539 mt7996_mcu_update_tx_gi(struct rate_info *rate, struct all_sta_trx_rate *mcu_rate)
540 {
541 switch (mcu_rate->tx_mode) {
542 case MT_PHY_TYPE_CCK:
543 case MT_PHY_TYPE_OFDM:
544 break;
545 case MT_PHY_TYPE_HT:
546 case MT_PHY_TYPE_HT_GF:
547 case MT_PHY_TYPE_VHT:
548 if (mcu_rate->tx_gi)
549 rate->flags |= RATE_INFO_FLAGS_SHORT_GI;
550 else
551 rate->flags &= ~RATE_INFO_FLAGS_SHORT_GI;
552 break;
553 case MT_PHY_TYPE_HE_SU:
554 case MT_PHY_TYPE_HE_EXT_SU:
555 case MT_PHY_TYPE_HE_TB:
556 case MT_PHY_TYPE_HE_MU:
557 if (mcu_rate->tx_gi > NL80211_RATE_INFO_HE_GI_3_2)
558 return -EINVAL;
559 rate->he_gi = mcu_rate->tx_gi;
560 break;
561 case MT_PHY_TYPE_EHT_SU:
562 case MT_PHY_TYPE_EHT_TRIG:
563 case MT_PHY_TYPE_EHT_MU:
564 if (mcu_rate->tx_gi > NL80211_RATE_INFO_EHT_GI_3_2)
565 return -EINVAL;
566 rate->eht_gi = mcu_rate->tx_gi;
567 break;
568 default:
569 return -EINVAL;
570 }
571
572 return 0;
573 }
574
575 static void
576 mt7996_mcu_rx_all_sta_info_event(struct mt7996_dev *dev, struct sk_buff *skb)
577 {
578 struct mt7996_mcu_all_sta_info_event *res;
579 u16 i;
580
581 skb_pull(skb, sizeof(struct mt7996_mcu_rxd));
582
583 res = (struct mt7996_mcu_all_sta_info_event *)skb->data;
584
585 for (i = 0; i < le16_to_cpu(res->sta_num); i++) {
586 u8 ac;
587 u16 wlan_idx;
588 struct mt76_wcid *wcid;
589
590 switch (le16_to_cpu(res->tag)) {
591 case UNI_ALL_STA_TXRX_RATE:
592 wlan_idx = le16_to_cpu(res->rate[i].wlan_idx);
593 wcid = mt76_wcid_ptr(dev, wlan_idx);
594
595 if (!wcid)
596 break;
597
598 if (mt7996_mcu_update_tx_gi(&wcid->rate, &res->rate[i]))
599 dev_err(dev->mt76.dev, "Failed to update TX GI\n");
600 break;
601 case UNI_ALL_STA_TXRX_ADM_STAT:
602 wlan_idx = le16_to_cpu(res->adm_stat[i].wlan_idx);
603 wcid = mt76_wcid_ptr(dev, wlan_idx);
604
605 if (!wcid)
606 break;
607
608 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
609 wcid->stats.tx_bytes +=
610 le32_to_cpu(res->adm_stat[i].tx_bytes[ac]);
611 wcid->stats.rx_bytes +=
612 le32_to_cpu(res->adm_stat[i].rx_bytes[ac]);
613 }
614 break;
615 case UNI_ALL_STA_TXRX_MSDU_COUNT:
616 wlan_idx = le16_to_cpu(res->msdu_cnt[i].wlan_idx);
617 wcid = mt76_wcid_ptr(dev, wlan_idx);
618
619 if (!wcid)
620 break;
621
622 wcid->stats.tx_packets +=
623 le32_to_cpu(res->msdu_cnt[i].tx_msdu_cnt);
624 wcid->stats.rx_packets +=
625 le32_to_cpu(res->msdu_cnt[i].rx_msdu_cnt);
626 break;
627 default:
628 break;
629 }
630 }
631 }
632
633 static void
634 mt7996_mcu_rx_thermal_notify(struct mt7996_dev *dev, struct sk_buff *skb)
635 {
636 #define THERMAL_NOTIFY_TAG 0x4
637 #define THERMAL_NOTIFY 0x2
638 struct mt76_phy *mphy = &dev->mt76.phy;
639 struct mt7996_mcu_thermal_notify *n;
640 struct mt7996_phy *phy;
641
642 n = (struct mt7996_mcu_thermal_notify *)skb->data;
643
644 if (le16_to_cpu(n->tag) != THERMAL_NOTIFY_TAG)
645 return;
646
647 if (n->event_id != THERMAL_NOTIFY)
648 return;
649
650 if (n->band_idx > MT_BAND2)
651 return;
652
653 mphy = dev->mt76.phys[n->band_idx];
654 if (!mphy)
655 return;
656
657 phy = (struct mt7996_phy *)mphy->priv;
658 phy->throttle_state = n->duty_percent;
659 }
660
661 static void
662 mt7996_mcu_rx_ext_event(struct mt7996_dev *dev, struct sk_buff *skb)
663 {
664 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
665
666 switch (rxd->ext_eid) {
667 case MCU_EXT_EVENT_FW_LOG_2_HOST:
668 mt7996_mcu_rx_log_message(dev, skb);
669 break;
670 default:
671 break;
672 }
673 }
674
675 static void
676 mt7996_mcu_rx_unsolicited_event(struct mt7996_dev *dev, struct sk_buff *skb)
677 {
678 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
679
680 switch (rxd->eid) {
681 case MCU_EVENT_EXT:
682 mt7996_mcu_rx_ext_event(dev, skb);
683 break;
684 case MCU_UNI_EVENT_THERMAL:
685 mt7996_mcu_rx_thermal_notify(dev, skb);
686 break;
687 default:
688 break;
689 }
690 dev_kfree_skb(skb);
691 }
692
693 static void
694 mt7996_mcu_wed_rro_event(struct mt7996_dev *dev, struct sk_buff *skb)
695 {
696 struct mt7996_mcu_wed_rro_event *event = (void *)skb->data;
697
698 if (!mt7996_has_hwrro(dev))
699 return;
700
701 skb_pull(skb, sizeof(struct mt7996_mcu_rxd) + 4);
702
703 switch (le16_to_cpu(event->tag)) {
704 case UNI_WED_RRO_BA_SESSION_STATUS: {
705 struct mt7996_mcu_wed_rro_ba_event *e;
706
707 while (skb->len >= sizeof(*e)) {
708 struct mt76_rx_tid *tid;
709 struct mt76_wcid *wcid;
710 u16 idx;
711
712 e = (void *)skb->data;
713 idx = le16_to_cpu(e->wlan_id);
714 wcid = mt76_wcid_ptr(dev, idx);
715 if (!wcid || !wcid->sta)
716 break;
717
718 if (e->tid >= ARRAY_SIZE(wcid->aggr))
719 break;
720
721 tid = rcu_dereference(wcid->aggr[e->tid]);
722 if (!tid)
723 break;
724
725 tid->id = le16_to_cpu(e->id);
726 skb_pull(skb, sizeof(*e));
727 }
728 break;
729 }
730 case UNI_WED_RRO_BA_SESSION_DELETE: {
731 struct mt7996_mcu_wed_rro_ba_delete_event *e;
732
733 while (skb->len >= sizeof(*e)) {
734 struct mt7996_wed_rro_session_id *session;
735
736 e = (void *)skb->data;
737 session = kzalloc_obj(*session, GFP_ATOMIC);
738 if (!session)
739 break;
740
741 session->id = le16_to_cpu(e->session_id);
742
743 spin_lock_bh(&dev->wed_rro.lock);
744 list_add_tail(&session->list, &dev->wed_rro.poll_list);
745 spin_unlock_bh(&dev->wed_rro.lock);
746
747 ieee80211_queue_work(mt76_hw(dev), &dev->wed_rro.work);
748 skb_pull(skb, sizeof(*e));
749 }
750 break;
751 }
752 default:
753 break;
754 }
755 }
756
757 static void
758 mt7996_mcu_uni_rx_unsolicited_event(struct mt7996_dev *dev, struct sk_buff *skb)
759 {
760 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
761
762 switch (rxd->eid) {
763 case MCU_UNI_EVENT_FW_LOG_2_HOST:
764 mt7996_mcu_rx_log_message(dev, skb);
765 break;
766 case MCU_UNI_EVENT_IE_COUNTDOWN:
767 mt7996_mcu_ie_countdown(dev, skb);
768 break;
769 case MCU_UNI_EVENT_RDD_REPORT:
770 mt7996_mcu_rx_radar_detected(dev, skb);
771 break;
772 case MCU_UNI_EVENT_ALL_STA_INFO:
773 mt7996_mcu_rx_all_sta_info_event(dev, skb);
774 break;
775 case MCU_UNI_EVENT_WED_RRO:
776 mt7996_mcu_wed_rro_event(dev, skb);
777 break;
778 default:
779 break;
780 }
781 dev_kfree_skb(skb);
782 }
783
784 void mt7996_mcu_rx_event(struct mt7996_dev *dev, struct sk_buff *skb)
785 {
786 struct mt7996_mcu_rxd *rxd = (struct mt7996_mcu_rxd *)skb->data;
787
788 if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) {
789 mt7996_mcu_uni_rx_unsolicited_event(dev, skb);
790 return;
791 }
792
793 /* WA still uses legacy event*/
794 if (rxd->ext_eid == MCU_EXT_EVENT_FW_LOG_2_HOST ||
795 !rxd->seq)
796 mt7996_mcu_rx_unsolicited_event(dev, skb);
797 else
798 mt76_mcu_rx_event(&dev->mt76, skb);
799 }
800
801 static struct tlv *
802 mt7996_mcu_add_uni_tlv(struct sk_buff *skb, u16 tag, u16 len)
803 {
804 struct tlv *ptlv = skb_put_zero(skb, len);
805
806 ptlv->tag = cpu_to_le16(tag);
807 ptlv->len = cpu_to_le16(len);
808
809 return ptlv;
810 }
811
812 static void
813 mt7996_mcu_bss_rfch_tlv(struct sk_buff *skb, struct mt7996_phy *phy)
814 {
815 static const u8 rlm_ch_band[] = {
816 [NL80211_BAND_2GHZ] = 1,
817 [NL80211_BAND_5GHZ] = 2,
818 [NL80211_BAND_6GHZ] = 3,
819 };
820 struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
821 struct bss_rlm_tlv *ch;
822 struct tlv *tlv;
823 int freq1 = chandef->center_freq1;
824
825 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RLM, sizeof(*ch));
826
827 ch = (struct bss_rlm_tlv *)tlv;
828 ch->control_channel = chandef->chan->hw_value;
829 ch->center_chan = ieee80211_frequency_to_channel(freq1);
830 ch->bw = mt76_connac_chan_bw(chandef);
831 ch->tx_streams = hweight8(phy->mt76->antenna_mask);
832 ch->rx_streams = hweight8(phy->mt76->antenna_mask);
833 ch->band = rlm_ch_band[chandef->chan->band];
834
835 if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
836 int freq2 = chandef->center_freq2;
837
838 ch->center_chan2 = ieee80211_frequency_to_channel(freq2);
839 }
840 }
841
842 static void
843 mt7996_mcu_bss_ra_tlv(struct sk_buff *skb, struct mt7996_phy *phy)
844 {
845 struct bss_ra_tlv *ra;
846 struct tlv *tlv;
847
848 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RA, sizeof(*ra));
849
850 ra = (struct bss_ra_tlv *)tlv;
851 ra->short_preamble = true;
852 }
853
854 static void
855 mt7996_mcu_bss_he_tlv(struct sk_buff *skb, struct ieee80211_vif *vif,
856 struct ieee80211_bss_conf *link_conf,
857 struct mt7996_phy *phy)
858 {
859 #define DEFAULT_HE_PE_DURATION 4
860 #define DEFAULT_HE_DURATION_RTS_THRES 1023
861 const struct ieee80211_sta_he_cap *cap;
862 struct bss_info_uni_he *he;
863 struct tlv *tlv;
864
865 cap = mt76_connac_get_he_phy_cap(phy->mt76, vif);
866
867 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_HE_BASIC, sizeof(*he));
868
869 he = (struct bss_info_uni_he *)tlv;
870 he->he_pe_duration = link_conf->htc_trig_based_pkt_ext;
871 if (!he->he_pe_duration)
872 he->he_pe_duration = DEFAULT_HE_PE_DURATION;
873
874 he->he_rts_thres = cpu_to_le16(link_conf->frame_time_rts_th);
875 if (!he->he_rts_thres)
876 he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES);
877
878 he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80;
879 he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160;
880 he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80;
881 }
882
883 static void
884 mt7996_mcu_bss_mbssid_tlv(struct sk_buff *skb, struct ieee80211_bss_conf *link_conf,
885 bool enable)
886 {
887 struct bss_info_uni_mbssid *mbssid;
888 struct tlv *tlv;
889
890 if (!link_conf->bssid_indicator && enable)
891 return;
892
893 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_11V_MBSSID, sizeof(*mbssid));
894
895 mbssid = (struct bss_info_uni_mbssid *)tlv;
896
897 if (enable) {
898 mbssid->max_indicator = link_conf->bssid_indicator;
899 mbssid->mbss_idx = link_conf->bssid_index;
900 mbssid->tx_bss_omac_idx = 0;
901 }
902 }
903
904 static void
905 mt7996_mcu_bss_bmc_tlv(struct sk_buff *skb, struct mt76_vif_link *mlink,
906 struct mt7996_phy *phy)
907 {
908 struct bss_rate_tlv *bmc;
909 struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
910 enum nl80211_band band = chandef->chan->band;
911 struct tlv *tlv;
912 u8 idx = mlink->mcast_rates_idx ?
913 mlink->mcast_rates_idx : mlink->basic_rates_idx;
914
915 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_RATE, sizeof(*bmc));
916
917 bmc = (struct bss_rate_tlv *)tlv;
918
919 bmc->short_preamble = (band == NL80211_BAND_2GHZ);
920 bmc->bc_fixed_rate = idx;
921 bmc->mc_fixed_rate = idx;
922 }
923
924 static void
925 mt7996_mcu_bss_txcmd_tlv(struct sk_buff *skb, bool en)
926 {
927 struct bss_txcmd_tlv *txcmd;
928 struct tlv *tlv;
929
930 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_TXCMD, sizeof(*txcmd));
931
932 txcmd = (struct bss_txcmd_tlv *)tlv;
933 txcmd->txcmd_mode = en;
934 }
935
936 static void
937 mt7996_mcu_bss_mld_tlv(struct sk_buff *skb,
938 struct ieee80211_bss_conf *link_conf,
939 struct mt7996_vif_link *link)
940 {
941 struct ieee80211_vif *vif = link_conf->vif;
942 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
943 struct bss_mld_tlv *mld;
944 struct tlv *tlv;
945
946 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_MLD, sizeof(*mld));
947 mld = (struct bss_mld_tlv *)tlv;
948 mld->own_mld_id = link->mld_idx;
949 mld->link_id = link_conf->link_id;
950
951 if (ieee80211_vif_is_mld(vif)) {
952 mld->group_mld_id = mvif->mld_group_idx;
953 mld->remap_idx = mvif->mld_remap_idx;
954 memcpy(mld->mac_addr, vif->addr, ETH_ALEN);
955 } else {
956 mld->group_mld_id = 0xff;
957 mld->remap_idx = 0xff;
958 }
959 }
960
961 static void
962 mt7996_mcu_bss_sec_tlv(struct sk_buff *skb, struct mt76_vif_link *mlink)
963 {
964 struct bss_sec_tlv *sec;
965 struct tlv *tlv;
966
967 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_SEC, sizeof(*sec));
968
969 sec = (struct bss_sec_tlv *)tlv;
970 sec->cipher = mlink->cipher;
971 }
972
973 static int
974 mt7996_mcu_muar_config(struct mt7996_dev *dev, struct mt76_vif_link *mlink,
975 const u8 *addr, bool bssid, bool enable)
976 {
977 #define UNI_MUAR_ENTRY 2
978 u32 idx = mlink->omac_idx - REPEATER_BSSID_START;
979 struct {
980 struct {
981 u8 band;
982 u8 __rsv[3];
983 } hdr;
984
985 __le16 tag;
986 __le16 len;
987
988 bool smesh;
989 u8 bssid;
990 u8 index;
991 u8 entry_add;
992 u8 addr[ETH_ALEN];
993 u8 __rsv[2];
994 } __packed req = {
995 .hdr.band = mlink->band_idx,
996 .tag = cpu_to_le16(UNI_MUAR_ENTRY),
997 .len = cpu_to_le16(sizeof(req) - sizeof(req.hdr)),
998 .smesh = false,
999 .index = idx * 2 + bssid,
1000 .entry_add = true,
1001 };
1002
1003 if (enable)
1004 memcpy(req.addr, addr, ETH_ALEN);
1005
1006 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(REPT_MUAR), &req,
1007 sizeof(req), true);
1008 }
1009
1010 static void
1011 mt7996_mcu_bss_ifs_timing_tlv(struct sk_buff *skb, struct mt7996_phy *phy)
1012 {
1013 struct bss_ifs_time_tlv *ifs_time;
1014 struct tlv *tlv;
1015 bool is_2ghz = phy->mt76->chandef.chan->band == NL80211_BAND_2GHZ;
1016
1017 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_IFS_TIME, sizeof(*ifs_time));
1018
1019 ifs_time = (struct bss_ifs_time_tlv *)tlv;
1020 ifs_time->slot_valid = true;
1021 ifs_time->sifs_valid = true;
1022 ifs_time->rifs_valid = true;
1023 ifs_time->eifs_valid = true;
1024
1025 ifs_time->slot_time = cpu_to_le16(phy->slottime);
1026 ifs_time->sifs_time = cpu_to_le16(10);
1027 ifs_time->rifs_time = cpu_to_le16(2);
1028 ifs_time->eifs_time = cpu_to_le16(is_2ghz ? 78 : 84);
1029
1030 if (is_2ghz) {
1031 ifs_time->eifs_cck_valid = true;
1032 ifs_time->eifs_cck_time = cpu_to_le16(314);
1033 }
1034 }
1035
1036 static int
1037 mt7996_mcu_bss_basic_tlv(struct sk_buff *skb,
1038 struct ieee80211_vif *vif,
1039 struct ieee80211_bss_conf *link_conf,
1040 struct mt76_vif_link *mvif,
1041 struct mt76_phy *phy, u16 wlan_idx,
1042 bool enable)
1043 {
1044 struct cfg80211_chan_def *chandef = &phy->chandef;
1045 struct mt76_connac_bss_basic_tlv *bss;
1046 u32 type = CONNECTION_INFRA_AP;
1047 u16 sta_wlan_idx = wlan_idx;
1048 struct tlv *tlv;
1049 int idx;
1050
1051 switch (vif->type) {
1052 case NL80211_IFTYPE_MESH_POINT:
1053 case NL80211_IFTYPE_AP:
1054 case NL80211_IFTYPE_MONITOR:
1055 break;
1056 case NL80211_IFTYPE_STATION:
1057 if (enable) {
1058 struct ieee80211_sta *sta;
1059
1060 rcu_read_lock();
1061 sta = ieee80211_find_sta(vif, link_conf->bssid);
1062 if (sta) {
1063 struct mt7996_sta *msta = (void *)sta->drv_priv;
1064 struct mt7996_sta_link *msta_link;
1065 int link_id = link_conf->link_id;
1066
1067 msta_link = rcu_dereference(msta->link[link_id]);
1068 if (msta_link)
1069 sta_wlan_idx = msta_link->wcid.idx;
1070 }
1071 rcu_read_unlock();
1072 }
1073 type = CONNECTION_INFRA_STA;
1074 break;
1075 case NL80211_IFTYPE_ADHOC:
1076 type = CONNECTION_IBSS_ADHOC;
1077 break;
1078 default:
1079 WARN_ON(1);
1080 break;
1081 }
1082
1083 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_BSS_INFO_BASIC, sizeof(*bss));
1084
1085 bss = (struct mt76_connac_bss_basic_tlv *)tlv;
1086 bss->bmc_tx_wlan_idx = cpu_to_le16(wlan_idx);
1087 bss->sta_idx = cpu_to_le16(sta_wlan_idx);
1088 bss->conn_type = cpu_to_le32(type);
1089 bss->omac_idx = mvif->omac_idx;
1090 bss->band_idx = mvif->band_idx;
1091 bss->wmm_idx = mvif->wmm_idx;
1092 bss->conn_state = !enable;
1093 bss->active = enable;
1094
1095 idx = mvif->omac_idx > EXT_BSSID_START ? HW_BSSID_0 : mvif->omac_idx;
1096 bss->hw_bss_idx = idx;
1097
1098 if (vif->type == NL80211_IFTYPE_MONITOR) {
1099 memcpy(bss->bssid, phy->macaddr, ETH_ALEN);
1100 return 0;
1101 }
1102
1103 memcpy(bss->bssid, link_conf->bssid, ETH_ALEN);
1104 bss->bcn_interval = cpu_to_le16(link_conf->beacon_int);
1105 bss->dtim_period = link_conf->dtim_period;
1106 bss->phymode = mt76_connac_get_phy_mode(phy, vif,
1107 chandef->chan->band, NULL);
1108 bss->phymode_ext = mt76_connac_get_phy_mode_ext(phy, link_conf,
1109 chandef->chan->band);
1110
1111 return 0;
1112 }
1113
1114 static struct sk_buff *
1115 __mt7996_mcu_alloc_bss_req(struct mt76_dev *dev, struct mt76_vif_link *mvif, int len)
1116 {
1117 struct bss_req_hdr hdr = {
1118 .bss_idx = mvif->idx,
1119 };
1120 struct sk_buff *skb;
1121
1122 skb = mt76_mcu_msg_alloc(dev, NULL, len);
1123 if (!skb)
1124 return ERR_PTR(-ENOMEM);
1125
1126 skb_put_data(skb, &hdr, sizeof(hdr));
1127
1128 return skb;
1129 }
1130
1131 int mt7996_mcu_add_bss_info(struct mt7996_phy *phy, struct ieee80211_vif *vif,
1132 struct ieee80211_bss_conf *link_conf,
1133 struct mt76_vif_link *mlink,
1134 struct mt7996_sta_link *msta_link, int enable)
1135 {
1136 struct mt7996_dev *dev = phy->dev;
1137 struct sk_buff *skb;
1138
1139 if (mlink->omac_idx >= REPEATER_BSSID_START) {
1140 mt7996_mcu_muar_config(dev, mlink, link_conf->addr, false, enable);
1141 mt7996_mcu_muar_config(dev, mlink, link_conf->bssid, true, enable);
1142 }
1143
1144 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink,
1145 MT7996_BSS_UPDATE_MAX_SIZE);
1146 if (IS_ERR(skb))
1147 return PTR_ERR(skb);
1148
1149 /* bss_basic must be first */
1150 mt7996_mcu_bss_basic_tlv(skb, vif, link_conf, mlink, phy->mt76,
1151 msta_link->wcid.idx, enable);
1152 mt7996_mcu_bss_sec_tlv(skb, mlink);
1153
1154 if (vif->type == NL80211_IFTYPE_MONITOR)
1155 goto out;
1156
1157 if (enable) {
1158 struct mt7996_vif_link *link;
1159
1160 mt7996_mcu_bss_rfch_tlv(skb, phy);
1161 mt7996_mcu_bss_bmc_tlv(skb, mlink, phy);
1162 mt7996_mcu_bss_ra_tlv(skb, phy);
1163 mt7996_mcu_bss_txcmd_tlv(skb, true);
1164 mt7996_mcu_bss_ifs_timing_tlv(skb, phy);
1165
1166 if (vif->bss_conf.he_support)
1167 mt7996_mcu_bss_he_tlv(skb, vif, link_conf, phy);
1168
1169 /* this tag is necessary no matter if the vif is MLD */
1170 link = container_of(mlink, struct mt7996_vif_link, mt76);
1171 mt7996_mcu_bss_mld_tlv(skb, link_conf, link);
1172 }
1173
1174 mt7996_mcu_bss_mbssid_tlv(skb, link_conf, enable);
1175
1176 out:
1177 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1178 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true);
1179 }
1180
1181 int mt7996_mcu_set_timing(struct mt7996_phy *phy, struct ieee80211_vif *vif,
1182 struct ieee80211_bss_conf *link_conf)
1183 {
1184 struct mt7996_dev *dev = phy->dev;
1185 struct mt76_vif_link *mlink = mt76_vif_conf_link(&dev->mt76, vif, link_conf);
1186 struct sk_buff *skb;
1187
1188 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink,
1189 MT7996_BSS_UPDATE_MAX_SIZE);
1190 if (IS_ERR(skb))
1191 return PTR_ERR(skb);
1192
1193 mt7996_mcu_bss_ifs_timing_tlv(skb, phy);
1194
1195 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1196 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true);
1197 }
1198
1199 static int
1200 mt7996_mcu_sta_ba(struct mt7996_dev *dev, struct mt76_vif_link *mvif,
1201 struct ieee80211_ampdu_params *params,
1202 struct mt76_wcid *wcid, bool enable, bool tx)
1203 {
1204 struct sta_rec_ba_uni *ba;
1205 struct sk_buff *skb;
1206 struct tlv *tlv;
1207
1208 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, mvif, wcid,
1209 MT7996_STA_UPDATE_MAX_SIZE);
1210 if (IS_ERR(skb))
1211 return PTR_ERR(skb);
1212
1213 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba));
1214
1215 ba = (struct sta_rec_ba_uni *)tlv;
1216 ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT;
1217 ba->winsize = cpu_to_le16(params->buf_size);
1218 ba->ssn = cpu_to_le16(params->ssn);
1219 ba->ba_en = enable << params->tid;
1220 ba->amsdu = params->amsdu;
1221 ba->tid = params->tid;
1222 ba->ba_rdd_rro = !tx && enable && mt7996_has_hwrro(dev);
1223
1224 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1225 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
1226 }
1227
1228 /** starec & wtbl **/
1229 int mt7996_mcu_add_tx_ba(struct mt7996_dev *dev,
1230 struct ieee80211_ampdu_params *params,
1231 struct ieee80211_vif *vif, bool enable)
1232 {
1233 struct ieee80211_sta *sta = params->sta;
1234 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1235 struct ieee80211_link_sta *link_sta;
1236 unsigned int link_id;
1237 int ret = 0;
1238
1239 for_each_sta_active_link(vif, sta, link_sta, link_id) {
1240 struct mt7996_sta_link *msta_link;
1241 struct mt7996_vif_link *link;
1242
1243 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
1244 if (!msta_link)
1245 continue;
1246
1247 link = mt7996_vif_link(dev, vif, link_id);
1248 if (!link)
1249 continue;
1250
1251 if (enable && !params->amsdu)
1252 msta_link->wcid.amsdu = false;
1253
1254 ret = mt7996_mcu_sta_ba(dev, &link->mt76, params,
1255 &msta_link->wcid, enable, true);
1256 if (ret)
1257 break;
1258 }
1259
1260 return ret;
1261 }
1262
1263 int mt7996_mcu_add_rx_ba(struct mt7996_dev *dev,
1264 struct ieee80211_ampdu_params *params,
1265 struct ieee80211_vif *vif, bool enable)
1266 {
1267 struct ieee80211_sta *sta = params->sta;
1268 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1269 struct ieee80211_link_sta *link_sta;
1270 unsigned int link_id;
1271 int ret = 0;
1272
1273 for_each_sta_active_link(vif, sta, link_sta, link_id) {
1274 struct mt7996_sta_link *msta_link;
1275 struct mt7996_vif_link *link;
1276
1277 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
1278 if (!msta_link)
1279 continue;
1280
1281 link = mt7996_vif_link(dev, vif, link_id);
1282 if (!link)
1283 continue;
1284
1285 ret = mt7996_mcu_sta_ba(dev, &link->mt76, params,
1286 &msta_link->wcid, enable, false);
1287 if (ret)
1288 break;
1289 }
1290
1291 return ret;
1292 }
1293
1294 static void
1295 mt7996_mcu_sta_he_tlv(struct sk_buff *skb,
1296 struct ieee80211_link_sta *link_sta,
1297 struct mt7996_vif_link *link)
1298 {
1299 struct ieee80211_he_cap_elem *elem = &link_sta->he_cap.he_cap_elem;
1300 struct ieee80211_he_mcs_nss_supp mcs_map;
1301 struct sta_rec_he_v2 *he;
1302 struct tlv *tlv;
1303 int i = 0;
1304
1305 if (!link_sta->he_cap.has_he)
1306 return;
1307
1308 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_V2, sizeof(*he));
1309
1310 he = (struct sta_rec_he_v2 *)tlv;
1311 for (i = 0; i < 11; i++) {
1312 if (i < 6)
1313 he->he_mac_cap[i] = elem->mac_cap_info[i];
1314 he->he_phy_cap[i] = elem->phy_cap_info[i];
1315 }
1316
1317 mcs_map = link_sta->he_cap.he_mcs_nss_supp;
1318 switch (link_sta->bandwidth) {
1319 case IEEE80211_STA_RX_BW_160:
1320 if (elem->phy_cap_info[0] &
1321 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
1322 mt7996_mcu_set_sta_he_mcs(link_sta, link,
1323 &he->max_nss_mcs[CMD_HE_MCS_BW8080],
1324 le16_to_cpu(mcs_map.rx_mcs_80p80));
1325
1326 mt7996_mcu_set_sta_he_mcs(link_sta, link,
1327 &he->max_nss_mcs[CMD_HE_MCS_BW160],
1328 le16_to_cpu(mcs_map.rx_mcs_160));
1329 fallthrough;
1330 default:
1331 mt7996_mcu_set_sta_he_mcs(link_sta, link,
1332 &he->max_nss_mcs[CMD_HE_MCS_BW80],
1333 le16_to_cpu(mcs_map.rx_mcs_80));
1334 break;
1335 }
1336
1337 he->pkt_ext = 2;
1338 }
1339
1340 static void
1341 mt7996_mcu_sta_he_6g_tlv(struct sk_buff *skb,
1342 struct ieee80211_link_sta *link_sta)
1343 {
1344 struct sta_rec_he_6g_capa *he_6g;
1345 struct tlv *tlv;
1346
1347 if (!link_sta->he_6ghz_capa.capa)
1348 return;
1349
1350 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_6G, sizeof(*he_6g));
1351
1352 he_6g = (struct sta_rec_he_6g_capa *)tlv;
1353 he_6g->capa = link_sta->he_6ghz_capa.capa;
1354 }
1355
1356 static void
1357 mt7996_mcu_sta_eht_tlv(struct sk_buff *skb,
1358 struct ieee80211_link_sta *link_sta)
1359 {
1360 struct mt7996_sta *msta = (struct mt7996_sta *)link_sta->sta->drv_priv;
1361 struct ieee80211_vif *vif = container_of((void *)msta->vif,
1362 struct ieee80211_vif, drv_priv);
1363 struct ieee80211_eht_mcs_nss_supp *mcs_map;
1364 struct ieee80211_eht_cap_elem_fixed *elem;
1365 struct sta_rec_eht *eht;
1366 struct tlv *tlv;
1367
1368 if (!link_sta->eht_cap.has_eht)
1369 return;
1370
1371 mcs_map = &link_sta->eht_cap.eht_mcs_nss_supp;
1372 elem = &link_sta->eht_cap.eht_cap_elem;
1373
1374 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT, sizeof(*eht));
1375
1376 eht = (struct sta_rec_eht *)tlv;
1377 eht->tid_bitmap = 0xff;
1378 eht->mac_cap = cpu_to_le16(*(u16 *)elem->mac_cap_info);
1379 eht->phy_cap = cpu_to_le64(*(u64 *)elem->phy_cap_info);
1380 eht->phy_cap_ext = cpu_to_le64(elem->phy_cap_info[8]);
1381
1382 if (vif->type != NL80211_IFTYPE_STATION &&
1383 (link_sta->he_cap.he_cap_elem.phy_cap_info[0] &
1384 (IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G |
1385 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
1386 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
1387 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)) == 0) {
1388 memcpy(eht->mcs_map_bw20, &mcs_map->only_20mhz,
1389 sizeof(eht->mcs_map_bw20));
1390 return;
1391 }
1392
1393 memcpy(eht->mcs_map_bw80, &mcs_map->bw._80, sizeof(eht->mcs_map_bw80));
1394 memcpy(eht->mcs_map_bw160, &mcs_map->bw._160, sizeof(eht->mcs_map_bw160));
1395 memcpy(eht->mcs_map_bw320, &mcs_map->bw._320, sizeof(eht->mcs_map_bw320));
1396 }
1397
1398 static void
1399 mt7996_mcu_sta_ht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1400 {
1401 struct sta_rec_ht_uni *ht;
1402 struct tlv *tlv;
1403
1404 if (!link_sta->ht_cap.ht_supported)
1405 return;
1406
1407 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht));
1408
1409 ht = (struct sta_rec_ht_uni *)tlv;
1410 ht->ht_cap = cpu_to_le16(link_sta->ht_cap.cap);
1411 ht->ampdu_param = u8_encode_bits(link_sta->ht_cap.ampdu_factor,
1412 IEEE80211_HT_AMPDU_PARM_FACTOR) |
1413 u8_encode_bits(link_sta->ht_cap.ampdu_density,
1414 IEEE80211_HT_AMPDU_PARM_DENSITY);
1415 }
1416
1417 static void
1418 mt7996_mcu_sta_vht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1419 {
1420 struct sta_rec_vht *vht;
1421 struct tlv *tlv;
1422
1423 /* For 6G band, this tlv is necessary to let hw work normally */
1424 if (!link_sta->he_6ghz_capa.capa && !link_sta->vht_cap.vht_supported)
1425 return;
1426
1427 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, sizeof(*vht));
1428
1429 vht = (struct sta_rec_vht *)tlv;
1430 vht->vht_cap = cpu_to_le32(link_sta->vht_cap.cap);
1431 vht->vht_rx_mcs_map = link_sta->vht_cap.vht_mcs.rx_mcs_map;
1432 vht->vht_tx_mcs_map = link_sta->vht_cap.vht_mcs.tx_mcs_map;
1433 }
1434
1435 static void
1436 mt7996_mcu_sta_amsdu_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
1437 struct ieee80211_vif *vif,
1438 struct ieee80211_link_sta *link_sta,
1439 struct mt7996_sta_link *msta_link)
1440 {
1441 struct sta_rec_amsdu *amsdu;
1442 struct tlv *tlv;
1443
1444 if (vif->type != NL80211_IFTYPE_STATION &&
1445 vif->type != NL80211_IFTYPE_MESH_POINT &&
1446 vif->type != NL80211_IFTYPE_AP)
1447 return;
1448
1449 if (!link_sta->agg.max_amsdu_len)
1450 return;
1451
1452 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu));
1453 amsdu = (struct sta_rec_amsdu *)tlv;
1454 amsdu->max_amsdu_num = 8;
1455 amsdu->amsdu_en = true;
1456 msta_link->wcid.amsdu = true;
1457
1458 switch (link_sta->agg.max_amsdu_len) {
1459 case IEEE80211_MAX_MPDU_LEN_VHT_11454:
1460 amsdu->max_mpdu_size =
1461 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
1462 return;
1463 case IEEE80211_MAX_MPDU_LEN_HT_7935:
1464 case IEEE80211_MAX_MPDU_LEN_VHT_7991:
1465 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
1466 return;
1467 default:
1468 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
1469 return;
1470 }
1471 }
1472
1473 static void
1474 mt7996_mcu_sta_muru_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
1475 struct ieee80211_bss_conf *link_conf,
1476 struct ieee80211_link_sta *link_sta)
1477 {
1478 struct ieee80211_he_cap_elem *elem = &link_sta->he_cap.he_cap_elem;
1479 struct sta_rec_muru *muru;
1480 struct tlv *tlv;
1481
1482 if (link_conf->vif->type != NL80211_IFTYPE_STATION &&
1483 link_conf->vif->type != NL80211_IFTYPE_AP)
1484 return;
1485
1486 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MURU, sizeof(*muru));
1487
1488 muru = (struct sta_rec_muru *)tlv;
1489 muru->cfg.mimo_dl_en = link_conf->eht_mu_beamformer ||
1490 link_conf->he_mu_beamformer ||
1491 link_conf->vht_mu_beamformer ||
1492 link_conf->vht_mu_beamformee;
1493 muru->cfg.ofdma_dl_en = true;
1494
1495 if (link_sta->vht_cap.vht_supported)
1496 muru->mimo_dl.vht_mu_bfee =
1497 !!(link_sta->vht_cap.cap & IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE);
1498
1499 if (!link_sta->he_cap.has_he)
1500 return;
1501
1502 muru->mimo_dl.partial_bw_dl_mimo =
1503 HE_PHY(CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO, elem->phy_cap_info[6]);
1504
1505 muru->mimo_ul.full_ul_mimo =
1506 HE_PHY(CAP2_UL_MU_FULL_MU_MIMO, elem->phy_cap_info[2]);
1507 muru->mimo_ul.partial_ul_mimo =
1508 HE_PHY(CAP2_UL_MU_PARTIAL_MU_MIMO, elem->phy_cap_info[2]);
1509
1510 muru->ofdma_dl.punc_pream_rx =
1511 HE_PHY(CAP1_PREAMBLE_PUNC_RX_MASK, elem->phy_cap_info[1]);
1512 muru->ofdma_dl.he_20m_in_40m_2g =
1513 HE_PHY(CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G, elem->phy_cap_info[8]);
1514 muru->ofdma_dl.he_20m_in_160m =
1515 HE_PHY(CAP8_20MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]);
1516 muru->ofdma_dl.he_80m_in_160m =
1517 HE_PHY(CAP8_80MHZ_IN_160MHZ_HE_PPDU, elem->phy_cap_info[8]);
1518
1519 muru->ofdma_ul.t_frame_dur =
1520 HE_MAC(CAP1_TF_MAC_PAD_DUR_MASK, elem->mac_cap_info[1]);
1521 muru->ofdma_ul.mu_cascading =
1522 HE_MAC(CAP2_MU_CASCADING, elem->mac_cap_info[2]);
1523 muru->ofdma_ul.uo_ra =
1524 HE_MAC(CAP3_OFDMA_RA, elem->mac_cap_info[3]);
1525 muru->ofdma_ul.rx_ctrl_frame_to_mbss =
1526 HE_MAC(CAP3_RX_CTRL_FRAME_TO_MULTIBSS, elem->mac_cap_info[3]);
1527 }
1528
1529 static inline bool
1530 mt7996_is_ebf_supported(struct mt7996_phy *phy,
1531 struct ieee80211_bss_conf *link_conf,
1532 struct ieee80211_link_sta *link_sta, bool bfee)
1533 {
1534 int sts = hweight16(phy->mt76->chainmask);
1535
1536 if (link_conf->vif->type != NL80211_IFTYPE_STATION &&
1537 link_conf->vif->type != NL80211_IFTYPE_AP)
1538 return false;
1539
1540 if (!bfee && sts < 2)
1541 return false;
1542
1543 if (link_sta->eht_cap.has_eht) {
1544 struct ieee80211_sta_eht_cap *pc = &link_sta->eht_cap;
1545 struct ieee80211_eht_cap_elem_fixed *pe = &pc->eht_cap_elem;
1546
1547 if (bfee)
1548 return link_conf->eht_su_beamformee &&
1549 EHT_PHY(CAP0_SU_BEAMFORMER, pe->phy_cap_info[0]);
1550 else
1551 return link_conf->eht_su_beamformer &&
1552 EHT_PHY(CAP0_SU_BEAMFORMEE, pe->phy_cap_info[0]);
1553 }
1554
1555 if (link_sta->he_cap.has_he) {
1556 struct ieee80211_he_cap_elem *pe = &link_sta->he_cap.he_cap_elem;
1557
1558 if (bfee)
1559 return link_conf->he_su_beamformee &&
1560 HE_PHY(CAP3_SU_BEAMFORMER, pe->phy_cap_info[3]);
1561 else
1562 return link_conf->he_su_beamformer &&
1563 HE_PHY(CAP4_SU_BEAMFORMEE, pe->phy_cap_info[4]);
1564 }
1565
1566 if (link_sta->vht_cap.vht_supported) {
1567 u32 cap = link_sta->vht_cap.cap;
1568
1569 if (bfee)
1570 return link_conf->vht_su_beamformee &&
1571 (cap & IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE);
1572 else
1573 return link_conf->vht_su_beamformer &&
1574 (cap & IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE);
1575 }
1576
1577 return false;
1578 }
1579
1580 static void
1581 mt7996_mcu_sta_sounding_rate(struct sta_rec_bf *bf, struct mt7996_phy *phy)
1582 {
1583 bf->sounding_phy = MT_PHY_TYPE_OFDM;
1584 bf->ndp_rate = 0; /* mcs0 */
1585 if (is_mt7996(phy->mt76->dev))
1586 bf->ndpa_rate = MT7996_CFEND_RATE_DEFAULT; /* ofdm 24m */
1587 else
1588 bf->ndpa_rate = MT7992_CFEND_RATE_DEFAULT; /* ofdm 6m */
1589
1590 bf->rept_poll_rate = MT7996_CFEND_RATE_DEFAULT; /* ofdm 24m */
1591 }
1592
1593 static void
1594 mt7996_mcu_sta_bfer_ht(struct ieee80211_link_sta *link_sta,
1595 struct mt7996_phy *phy, struct sta_rec_bf *bf,
1596 bool explicit)
1597 {
1598 struct ieee80211_mcs_info *mcs = &link_sta->ht_cap.mcs;
1599 u8 n = 0;
1600
1601 bf->tx_mode = MT_PHY_TYPE_HT;
1602
1603 if ((mcs->tx_params & IEEE80211_HT_MCS_TX_RX_DIFF) &&
1604 (mcs->tx_params & IEEE80211_HT_MCS_TX_DEFINED))
1605 n = FIELD_GET(IEEE80211_HT_MCS_TX_MAX_STREAMS_MASK,
1606 mcs->tx_params);
1607 else if (mcs->rx_mask[3])
1608 n = 3;
1609 else if (mcs->rx_mask[2])
1610 n = 2;
1611 else if (mcs->rx_mask[1])
1612 n = 1;
1613
1614 bf->nrow = hweight8(phy->mt76->antenna_mask) - 1;
1615 bf->ncol = min_t(u8, bf->nrow, n);
1616 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) :
1617 min_t(u8, MT7996_IBF_MAX_NC, n);
1618 }
1619
1620 static void
1621 mt7996_mcu_sta_bfer_vht(struct ieee80211_link_sta *link_sta,
1622 struct mt7996_phy *phy, struct sta_rec_bf *bf,
1623 bool explicit)
1624 {
1625 struct ieee80211_sta_vht_cap *pc = &link_sta->vht_cap;
1626 struct ieee80211_sta_vht_cap *vc = &phy->mt76->sband_5g.sband.vht_cap;
1627 u16 mcs_map = le16_to_cpu(pc->vht_mcs.rx_mcs_map);
1628 u8 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map);
1629 u8 tx_ant = hweight8(phy->mt76->antenna_mask) - 1;
1630
1631 bf->tx_mode = MT_PHY_TYPE_VHT;
1632
1633 if (explicit) {
1634 u8 sts, snd_dim;
1635
1636 mt7996_mcu_sta_sounding_rate(bf, phy);
1637
1638 sts = FIELD_GET(IEEE80211_VHT_CAP_BEAMFORMEE_STS_MASK,
1639 pc->cap);
1640 snd_dim = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK,
1641 vc->cap);
1642 bf->nrow = min_t(u8, min_t(u8, snd_dim, sts), tx_ant);
1643 bf->ncol = min_t(u8, nss_mcs, bf->nrow);
1644 bf->ibf_ncol = min_t(u8, MT7996_IBF_MAX_NC, bf->ncol);
1645
1646 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_160)
1647 bf->nrow = 1;
1648 } else {
1649 bf->nrow = tx_ant;
1650 bf->ncol = min_t(u8, nss_mcs, bf->nrow);
1651 bf->ibf_ncol = min_t(u8, MT7996_IBF_MAX_NC, nss_mcs);
1652
1653 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_160)
1654 bf->ibf_nrow = 1;
1655 }
1656 }
1657
1658 static void
1659 mt7996_mcu_sta_bfer_he(struct ieee80211_link_sta *link_sta,
1660 struct ieee80211_vif *vif, struct mt7996_phy *phy,
1661 struct sta_rec_bf *bf, bool explicit)
1662 {
1663 struct ieee80211_sta_he_cap *pc = &link_sta->he_cap;
1664 struct ieee80211_he_cap_elem *pe = &pc->he_cap_elem;
1665 const struct ieee80211_sta_he_cap *vc =
1666 mt76_connac_get_he_phy_cap(phy->mt76, vif);
1667 const struct ieee80211_he_cap_elem *ve = &vc->he_cap_elem;
1668 u16 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80);
1669 u8 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map);
1670 u8 snd_dim, sts;
1671
1672 if (!vc)
1673 return;
1674
1675 bf->tx_mode = MT_PHY_TYPE_HE_SU;
1676
1677 mt7996_mcu_sta_sounding_rate(bf, phy);
1678
1679 bf->trigger_su = HE_PHY(CAP6_TRIG_SU_BEAMFORMING_FB,
1680 pe->phy_cap_info[6]);
1681 bf->trigger_mu = HE_PHY(CAP6_TRIG_MU_BEAMFORMING_PARTIAL_BW_FB,
1682 pe->phy_cap_info[6]);
1683 snd_dim = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK,
1684 ve->phy_cap_info[5]);
1685 sts = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_MASK,
1686 pe->phy_cap_info[4]);
1687 bf->nrow = min_t(u8, snd_dim, sts);
1688 bf->ncol = min_t(u8, nss_mcs, bf->nrow);
1689 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) :
1690 min_t(u8, MT7996_IBF_MAX_NC, nss_mcs);
1691
1692 if (link_sta->bandwidth != IEEE80211_STA_RX_BW_160)
1693 return;
1694
1695 /* go over for 160MHz and 80p80 */
1696 if (pe->phy_cap_info[0] &
1697 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G) {
1698 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_160);
1699 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map);
1700
1701 bf->ncol_gt_bw80 = nss_mcs;
1702 }
1703
1704 if (pe->phy_cap_info[0] &
1705 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G) {
1706 mcs_map = le16_to_cpu(pc->he_mcs_nss_supp.rx_mcs_80p80);
1707 nss_mcs = mt7996_mcu_get_sta_nss(mcs_map);
1708
1709 if (bf->ncol_gt_bw80)
1710 bf->ncol_gt_bw80 = min_t(u8, bf->ncol_gt_bw80, nss_mcs);
1711 else
1712 bf->ncol_gt_bw80 = nss_mcs;
1713 }
1714
1715 snd_dim = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK,
1716 ve->phy_cap_info[5]);
1717 sts = HE_PHY(CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_MASK,
1718 pe->phy_cap_info[4]);
1719
1720 bf->nrow_gt_bw80 = min_t(int, snd_dim, sts);
1721 }
1722
1723 static void
1724 mt7996_mcu_sta_bfer_eht(struct ieee80211_link_sta *link_sta,
1725 struct ieee80211_vif *vif, struct mt7996_phy *phy,
1726 struct sta_rec_bf *bf, bool explicit)
1727 {
1728 struct ieee80211_sta_eht_cap *pc = &link_sta->eht_cap;
1729 struct ieee80211_eht_cap_elem_fixed *pe = &pc->eht_cap_elem;
1730 struct ieee80211_eht_mcs_nss_supp *eht_nss = &pc->eht_mcs_nss_supp;
1731 const struct ieee80211_sta_eht_cap *vc =
1732 mt76_connac_get_eht_phy_cap(phy->mt76, vif);
1733 const struct ieee80211_eht_cap_elem_fixed *ve = &vc->eht_cap_elem;
1734 u8 nss_mcs = u8_get_bits(eht_nss->bw._80.rx_tx_mcs9_max_nss,
1735 IEEE80211_EHT_MCS_NSS_RX) - 1;
1736 u8 snd_dim, sts;
1737
1738 bf->tx_mode = MT_PHY_TYPE_EHT_MU;
1739
1740 mt7996_mcu_sta_sounding_rate(bf, phy);
1741
1742 bf->trigger_su = EHT_PHY(CAP3_TRIG_SU_BF_FDBK, pe->phy_cap_info[3]);
1743 bf->trigger_mu = EHT_PHY(CAP3_TRIG_MU_BF_PART_BW_FDBK, pe->phy_cap_info[3]);
1744 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_80MHZ_MASK, ve->phy_cap_info[2]);
1745 sts = EHT_PHY(CAP0_BEAMFORMEE_SS_80MHZ_MASK, pe->phy_cap_info[0]) +
1746 (EHT_PHY(CAP1_BEAMFORMEE_SS_80MHZ_MASK, pe->phy_cap_info[1]) << 1);
1747 bf->nrow = min_t(u8, snd_dim, sts);
1748 bf->ncol = min_t(u8, nss_mcs, bf->nrow);
1749 bf->ibf_ncol = explicit ? min_t(u8, MT7996_IBF_MAX_NC, bf->ncol) :
1750 min_t(u8, MT7996_IBF_MAX_NC, nss_mcs);
1751
1752 if (link_sta->bandwidth < IEEE80211_STA_RX_BW_160)
1753 return;
1754
1755 switch (link_sta->bandwidth) {
1756 case IEEE80211_STA_RX_BW_160:
1757 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_160MHZ_MASK, ve->phy_cap_info[2]);
1758 sts = EHT_PHY(CAP1_BEAMFORMEE_SS_160MHZ_MASK, pe->phy_cap_info[1]);
1759 nss_mcs = u8_get_bits(eht_nss->bw._160.rx_tx_mcs9_max_nss,
1760 IEEE80211_EHT_MCS_NSS_RX) - 1;
1761
1762 bf->nrow_gt_bw80 = min_t(u8, snd_dim, sts);
1763 bf->ncol_gt_bw80 = nss_mcs;
1764 break;
1765 case IEEE80211_STA_RX_BW_320:
1766 snd_dim = EHT_PHY(CAP2_SOUNDING_DIM_320MHZ_MASK, ve->phy_cap_info[2]) +
1767 (EHT_PHY(CAP3_SOUNDING_DIM_320MHZ_MASK,
1768 ve->phy_cap_info[3]) << 1);
1769 sts = EHT_PHY(CAP1_BEAMFORMEE_SS_320MHZ_MASK, pe->phy_cap_info[1]);
1770 nss_mcs = u8_get_bits(eht_nss->bw._320.rx_tx_mcs9_max_nss,
1771 IEEE80211_EHT_MCS_NSS_RX) - 1;
1772
1773 bf->nrow_gt_bw80 = min_t(u8, snd_dim, sts) << 4;
1774 bf->ncol_gt_bw80 = nss_mcs << 4;
1775 break;
1776 default:
1777 break;
1778 }
1779 }
1780
1781 static void
1782 mt7996_mcu_sta_bfer_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
1783 struct ieee80211_bss_conf *link_conf,
1784 struct ieee80211_link_sta *link_sta,
1785 struct mt7996_vif_link *link)
1786 {
1787 #define EBF_MODE BIT(0)
1788 #define IBF_MODE BIT(1)
1789 #define BF_MAT_ORDER 4
1790 struct ieee80211_vif *vif = link_conf->vif;
1791 struct mt7996_phy *phy = link->phy;
1792 int tx_ant = hweight16(phy->mt76->chainmask) - 1;
1793 struct sta_rec_bf *bf;
1794 struct tlv *tlv;
1795 static const u8 matrix[BF_MAT_ORDER][BF_MAT_ORDER] = {
1796 {0, 0, 0, 0},
1797 {1, 1, 0, 0}, /* 2x1, 2x2, 2x3, 2x4 */
1798 {2, 4, 4, 0}, /* 3x1, 3x2, 3x3, 3x4 */
1799 {3, 5, 6, 0} /* 4x1, 4x2, 4x3, 4x4 */
1800 };
1801 bool ebf;
1802
1803 if (!(link_sta->ht_cap.ht_supported || link_sta->he_cap.has_he))
1804 return;
1805
1806 ebf = mt7996_is_ebf_supported(phy, link_conf, link_sta, false);
1807 if (!ebf && !dev->ibf)
1808 return;
1809
1810 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BF, sizeof(*bf));
1811 bf = (struct sta_rec_bf *)tlv;
1812
1813 /* he/eht: eBF only, except mt7992 that has 5T on 5GHz also supports iBF
1814 * vht: support eBF and iBF
1815 * ht: iBF only, since mac80211 lacks of eBF support
1816 */
1817 if (link_sta->eht_cap.has_eht)
1818 mt7996_mcu_sta_bfer_eht(link_sta, vif, link->phy, bf, ebf);
1819 else if (link_sta->he_cap.has_he)
1820 mt7996_mcu_sta_bfer_he(link_sta, vif, link->phy, bf, ebf);
1821 else if (link_sta->vht_cap.vht_supported)
1822 mt7996_mcu_sta_bfer_vht(link_sta, link->phy, bf, ebf);
1823 else if (link_sta->ht_cap.ht_supported)
1824 mt7996_mcu_sta_bfer_ht(link_sta, link->phy, bf, ebf);
1825 else
1826 return;
1827
1828 bf->bf_cap = ebf ? EBF_MODE : (dev->ibf ? IBF_MODE : 0);
1829 if (is_mt7992(&dev->mt76) && tx_ant == 4)
1830 bf->bf_cap |= IBF_MODE;
1831
1832 bf->bw = link_sta->bandwidth;
1833 bf->ibf_dbw = link_sta->bandwidth;
1834 bf->ibf_nrow = tx_ant;
1835
1836 if (link_sta->eht_cap.has_eht || link_sta->he_cap.has_he)
1837 bf->ibf_timeout = is_mt7992(&dev->mt76) ? MT7992_IBF_TIMEOUT :
1838 MT7996_IBF_TIMEOUT;
1839 else if (!ebf && link_sta->bandwidth <= IEEE80211_STA_RX_BW_40 && !bf->ncol)
1840 bf->ibf_timeout = MT7996_IBF_TIMEOUT_LEGACY;
1841 else
1842 bf->ibf_timeout = MT7996_IBF_TIMEOUT;
1843
1844 if (bf->ncol < BF_MAT_ORDER) {
1845 if (ebf)
1846 bf->mem_20m = tx_ant < BF_MAT_ORDER ?
1847 matrix[tx_ant][bf->ncol] : 0;
1848 else
1849 bf->mem_20m = bf->nrow < BF_MAT_ORDER ?
1850 matrix[bf->nrow][bf->ncol] : 0;
1851 }
1852 }
1853
1854 static void
1855 mt7996_mcu_sta_bfee_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
1856 struct ieee80211_bss_conf *link_conf,
1857 struct ieee80211_link_sta *link_sta,
1858 struct mt7996_vif_link *link)
1859 {
1860 struct mt7996_phy *phy = link->phy;
1861 int tx_ant = hweight8(phy->mt76->antenna_mask) - 1;
1862 struct sta_rec_bfee *bfee;
1863 struct tlv *tlv;
1864 u8 nrow = 0;
1865
1866 if (!(link_sta->vht_cap.vht_supported || link_sta->he_cap.has_he))
1867 return;
1868
1869 if (!mt7996_is_ebf_supported(phy, link_conf, link_sta, true))
1870 return;
1871
1872 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BFEE, sizeof(*bfee));
1873 bfee = (struct sta_rec_bfee *)tlv;
1874
1875 if (link_sta->he_cap.has_he) {
1876 struct ieee80211_he_cap_elem *pe = &link_sta->he_cap.he_cap_elem;
1877
1878 nrow = HE_PHY(CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK,
1879 pe->phy_cap_info[5]);
1880 } else if (link_sta->vht_cap.vht_supported) {
1881 struct ieee80211_sta_vht_cap *pc = &link_sta->vht_cap;
1882
1883 nrow = FIELD_GET(IEEE80211_VHT_CAP_SOUNDING_DIMENSIONS_MASK,
1884 pc->cap);
1885 }
1886
1887 /* reply with identity matrix to avoid 2x2 BF negative gain */
1888 bfee->fb_identity_matrix = (nrow == 1 && tx_ant == 2);
1889 }
1890
1891 static void
1892 mt7996_mcu_sta_tx_proc_tlv(struct sk_buff *skb)
1893 {
1894 struct sta_rec_tx_proc *tx_proc;
1895 struct tlv *tlv;
1896
1897 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_TX_PROC, sizeof(*tx_proc));
1898
1899 tx_proc = (struct sta_rec_tx_proc *)tlv;
1900 tx_proc->flag = cpu_to_le32(0);
1901 }
1902
1903 static void
1904 mt7996_mcu_sta_hdrt_tlv(struct mt7996_dev *dev, struct sk_buff *skb)
1905 {
1906 struct sta_rec_hdrt *hdrt;
1907 struct tlv *tlv;
1908
1909 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDRT, sizeof(*hdrt));
1910
1911 hdrt = (struct sta_rec_hdrt *)tlv;
1912 hdrt->hdrt_mode = 1;
1913 }
1914
1915 static void
1916 mt7996_mcu_sta_hdr_trans_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
1917 struct ieee80211_vif *vif, struct mt76_wcid *wcid)
1918 {
1919 struct sta_rec_hdr_trans *hdr_trans;
1920 struct tlv *tlv;
1921
1922 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDR_TRANS, sizeof(*hdr_trans));
1923 hdr_trans = (struct sta_rec_hdr_trans *)tlv;
1924 hdr_trans->dis_rx_hdr_tran = true;
1925
1926 if (vif->type == NL80211_IFTYPE_STATION)
1927 hdr_trans->to_ds = true;
1928 else
1929 hdr_trans->from_ds = true;
1930
1931 if (!wcid)
1932 return;
1933
1934 hdr_trans->dis_rx_hdr_tran = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags);
1935 if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags)) {
1936 hdr_trans->to_ds = true;
1937 hdr_trans->from_ds = true;
1938 }
1939
1940 if (vif->type == NL80211_IFTYPE_MESH_POINT) {
1941 hdr_trans->to_ds = true;
1942 hdr_trans->from_ds = true;
1943 hdr_trans->mesh = true;
1944 }
1945 }
1946
1947 static enum mcu_mmps_mode
1948 mt7996_mcu_get_mmps_mode(enum ieee80211_smps_mode smps)
1949 {
1950 switch (smps) {
1951 case IEEE80211_SMPS_OFF:
1952 return MCU_MMPS_DISABLE;
1953 case IEEE80211_SMPS_STATIC:
1954 return MCU_MMPS_STATIC;
1955 case IEEE80211_SMPS_DYNAMIC:
1956 return MCU_MMPS_DYNAMIC;
1957 default:
1958 return MCU_MMPS_DISABLE;
1959 }
1960 }
1961
1962 int mt7996_mcu_set_fixed_rate_ctrl(struct mt7996_dev *dev,
1963 void *data, u16 version)
1964 {
1965 struct uni_header hdr = {};
1966 struct ra_fixed_rate *req;
1967 struct sk_buff *skb;
1968 struct tlv *tlv;
1969 int len;
1970
1971 len = sizeof(hdr) + sizeof(*req);
1972
1973 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
1974 if (!skb)
1975 return -ENOMEM;
1976
1977 skb_put_data(skb, &hdr, sizeof(hdr));
1978
1979 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_RA_FIXED_RATE, sizeof(*req));
1980 req = (struct ra_fixed_rate *)tlv;
1981 req->version = cpu_to_le16(version);
1982 memcpy(&req->rate, data, sizeof(req->rate));
1983
1984 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1985 MCU_WM_UNI_CMD(RA), true);
1986 }
1987
1988 int mt7996_mcu_set_fixed_field(struct mt7996_dev *dev, struct mt7996_sta *msta,
1989 void *data, u8 link_id, u32 field)
1990 {
1991 struct mt7996_vif *mvif = msta->vif;
1992 struct mt7996_sta_link *msta_link;
1993 struct sta_rec_ra_fixed_uni *ra;
1994 struct sta_phy_uni *phy = data;
1995 struct mt76_vif_link *mlink;
1996 struct sk_buff *skb;
1997 int err = -ENODEV;
1998 struct tlv *tlv;
1999
2000 rcu_read_lock();
2001
2002 mlink = rcu_dereference(mvif->mt76.link[link_id]);
2003 if (!mlink)
2004 goto error_unlock;
2005
2006 msta_link = rcu_dereference(msta->link[link_id]);
2007 if (!msta_link)
2008 goto error_unlock;
2009
2010 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, mlink,
2011 &msta_link->wcid,
2012 MT7996_STA_UPDATE_MAX_SIZE);
2013 if (IS_ERR(skb)) {
2014 err = PTR_ERR(skb);
2015 goto error_unlock;
2016 }
2017
2018 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA_UPDATE, sizeof(*ra));
2019 ra = (struct sta_rec_ra_fixed_uni *)tlv;
2020
2021 switch (field) {
2022 case RATE_PARAM_AUTO:
2023 break;
2024 case RATE_PARAM_FIXED:
2025 case RATE_PARAM_FIXED_MCS:
2026 case RATE_PARAM_FIXED_GI:
2027 case RATE_PARAM_FIXED_HE_LTF:
2028 if (phy)
2029 ra->phy = *phy;
2030 break;
2031 case RATE_PARAM_MMPS_UPDATE: {
2032 struct ieee80211_sta *sta = wcid_to_sta(&msta_link->wcid);
2033 struct ieee80211_link_sta *link_sta;
2034
2035 link_sta = rcu_dereference(sta->link[link_id]);
2036 if (!link_sta) {
2037 dev_kfree_skb(skb);
2038 goto error_unlock;
2039 }
2040
2041 ra->mmps_mode = mt7996_mcu_get_mmps_mode(link_sta->smps_mode);
2042 break;
2043 }
2044 default:
2045 break;
2046 }
2047 ra->field = cpu_to_le32(field);
2048
2049 rcu_read_unlock();
2050
2051 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2052 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
2053 error_unlock:
2054 rcu_read_unlock();
2055
2056 return err;
2057 }
2058
2059 static int
2060 mt7996_mcu_add_rate_ctrl_fixed(struct mt7996_dev *dev, struct mt7996_sta *msta,
2061 struct ieee80211_vif *vif, u8 link_id)
2062 {
2063 struct ieee80211_link_sta *link_sta;
2064 struct cfg80211_bitrate_mask mask;
2065 struct mt7996_sta_link *msta_link;
2066 struct mt7996_vif_link *link;
2067 struct sta_phy_uni phy = {};
2068 struct ieee80211_sta *sta;
2069 int ret, nrates = 0, idx;
2070 enum nl80211_band band;
2071 bool has_he;
2072
2073 #define __sta_phy_bitrate_mask_check(_mcs, _gi, _ht, _he) \
2074 do { \
2075 u8 i, gi = mask.control[band]._gi; \
2076 gi = (_he) ? gi : gi == NL80211_TXRATE_FORCE_SGI; \
2077 phy.sgi = gi; \
2078 phy.he_ltf = mask.control[band].he_ltf; \
2079 for (i = 0; i < ARRAY_SIZE(mask.control[band]._mcs); i++) { \
2080 if (!mask.control[band]._mcs[i]) \
2081 continue; \
2082 nrates += hweight16(mask.control[band]._mcs[i]); \
2083 phy.mcs = ffs(mask.control[band]._mcs[i]) - 1; \
2084 if (_ht) \
2085 phy.mcs += 8 * i; \
2086 } \
2087 } while (0)
2088
2089 rcu_read_lock();
2090
2091 link = mt7996_vif_link(dev, vif, link_id);
2092 if (!link)
2093 goto error_unlock;
2094
2095 msta_link = rcu_dereference(msta->link[link_id]);
2096 if (!msta_link)
2097 goto error_unlock;
2098
2099 sta = wcid_to_sta(&msta_link->wcid);
2100 link_sta = rcu_dereference(sta->link[link_id]);
2101 if (!link_sta)
2102 goto error_unlock;
2103
2104 band = link->phy->mt76->chandef.chan->band;
2105 has_he = link_sta->he_cap.has_he;
2106 mask = link->bitrate_mask;
2107 idx = msta_link->wcid.idx;
2108
2109 if (has_he) {
2110 __sta_phy_bitrate_mask_check(he_mcs, he_gi, 0, 1);
2111 } else if (link_sta->vht_cap.vht_supported) {
2112 __sta_phy_bitrate_mask_check(vht_mcs, gi, 0, 0);
2113 } else if (link_sta->ht_cap.ht_supported) {
2114 __sta_phy_bitrate_mask_check(ht_mcs, gi, 1, 0);
2115 } else {
2116 nrates = hweight32(mask.control[band].legacy);
2117 phy.mcs = ffs(mask.control[band].legacy) - 1;
2118 }
2119
2120 rcu_read_unlock();
2121
2122 #undef __sta_phy_bitrate_mask_check
2123
2124 /* fall back to auto rate control */
2125 if (mask.control[band].gi == NL80211_TXRATE_DEFAULT_GI &&
2126 mask.control[band].he_gi == GENMASK(7, 0) &&
2127 mask.control[band].he_ltf == GENMASK(7, 0) &&
2128 nrates != 1)
2129 return 0;
2130
2131 /* fixed single rate */
2132 if (nrates == 1) {
2133 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id,
2134 RATE_PARAM_FIXED_MCS);
2135 if (ret)
2136 return ret;
2137 }
2138
2139 /* fixed GI */
2140 if (mask.control[band].gi != NL80211_TXRATE_DEFAULT_GI ||
2141 mask.control[band].he_gi != GENMASK(7, 0)) {
2142 u32 addr;
2143
2144 /* firmware updates only TXCMD but doesn't take WTBL into
2145 * account, so driver should update here to reflect the
2146 * actual txrate hardware sends out.
2147 */
2148 addr = mt7996_mac_wtbl_lmac_addr(dev, idx, 7);
2149 if (has_he)
2150 mt76_rmw_field(dev, addr, GENMASK(31, 24), phy.sgi);
2151 else
2152 mt76_rmw_field(dev, addr, GENMASK(15, 12), phy.sgi);
2153
2154 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id,
2155 RATE_PARAM_FIXED_GI);
2156 if (ret)
2157 return ret;
2158 }
2159
2160 /* fixed HE_LTF */
2161 if (mask.control[band].he_ltf != GENMASK(7, 0)) {
2162 ret = mt7996_mcu_set_fixed_field(dev, msta, &phy, link_id,
2163 RATE_PARAM_FIXED_HE_LTF);
2164 if (ret)
2165 return ret;
2166 }
2167
2168 return 0;
2169
2170 error_unlock:
2171 rcu_read_unlock();
2172
2173 return -ENODEV;
2174 }
2175
2176 static void
2177 mt7996_mcu_sta_rate_ctrl_tlv(struct sk_buff *skb, struct mt7996_dev *dev,
2178 struct ieee80211_vif *vif,
2179 struct ieee80211_bss_conf *link_conf,
2180 struct ieee80211_link_sta *link_sta,
2181 struct mt7996_vif_link *link)
2182 {
2183 #define INIT_RCPI 180
2184 struct mt76_phy *mphy = link->phy->mt76;
2185 struct cfg80211_chan_def *chandef = &mphy->chandef;
2186 struct cfg80211_bitrate_mask *mask = &link->bitrate_mask;
2187 u32 cap = link_sta->sta->wme ? STA_CAP_WMM : 0;
2188 enum nl80211_band band = chandef->chan->band;
2189 struct sta_rec_ra_uni *ra;
2190 struct tlv *tlv;
2191 u32 supp_rate = link_sta->supp_rates[band];
2192
2193 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra));
2194 ra = (struct sta_rec_ra_uni *)tlv;
2195
2196 ra->valid = true;
2197 ra->auto_rate = true;
2198 ra->phy_mode = mt76_connac_get_phy_mode(mphy, vif, band, link_sta);
2199 ra->channel = chandef->chan->hw_value;
2200 ra->bw = (link_sta->bandwidth == IEEE80211_STA_RX_BW_320) ?
2201 CMD_CBW_320MHZ : link_sta->bandwidth;
2202 ra->phy.bw = ra->bw;
2203 ra->mmps_mode = mt7996_mcu_get_mmps_mode(link_sta->smps_mode);
2204
2205 if (supp_rate) {
2206 supp_rate &= mask->control[band].legacy;
2207 ra->rate_len = hweight32(supp_rate);
2208
2209 if (band == NL80211_BAND_2GHZ) {
2210 ra->supp_mode = MODE_CCK;
2211 ra->supp_cck_rate = supp_rate & GENMASK(3, 0);
2212
2213 if (ra->rate_len > 4) {
2214 ra->supp_mode |= MODE_OFDM;
2215 ra->supp_ofdm_rate = supp_rate >> 4;
2216 }
2217 } else {
2218 ra->supp_mode = MODE_OFDM;
2219 ra->supp_ofdm_rate = supp_rate;
2220 }
2221 }
2222
2223 if (link_sta->ht_cap.ht_supported) {
2224 ra->supp_mode |= MODE_HT;
2225 ra->af = link_sta->ht_cap.ampdu_factor;
2226 ra->ht_gf = !!(link_sta->ht_cap.cap & IEEE80211_HT_CAP_GRN_FLD);
2227
2228 cap |= STA_CAP_HT;
2229 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_20)
2230 cap |= STA_CAP_SGI_20;
2231 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_SGI_40)
2232 cap |= STA_CAP_SGI_40;
2233 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_TX_STBC)
2234 cap |= STA_CAP_TX_STBC;
2235 if (link_sta->ht_cap.cap & IEEE80211_HT_CAP_RX_STBC)
2236 cap |= STA_CAP_RX_STBC;
2237 if (link_conf->ht_ldpc &&
2238 (link_sta->ht_cap.cap & IEEE80211_HT_CAP_LDPC_CODING))
2239 cap |= STA_CAP_LDPC;
2240
2241 mt7996_mcu_set_sta_ht_mcs(link_sta, ra->ht_mcs,
2242 mask->control[band].ht_mcs);
2243 ra->supp_ht_mcs = *(__le32 *)ra->ht_mcs;
2244 }
2245
2246 if (link_sta->vht_cap.vht_supported) {
2247 u8 af;
2248
2249 ra->supp_mode |= MODE_VHT;
2250 af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
2251 link_sta->vht_cap.cap);
2252 ra->af = max_t(u8, ra->af, af);
2253
2254 cap |= STA_CAP_VHT;
2255 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_80)
2256 cap |= STA_CAP_VHT_SGI_80;
2257 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_SHORT_GI_160)
2258 cap |= STA_CAP_VHT_SGI_160;
2259 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_TXSTBC)
2260 cap |= STA_CAP_VHT_TX_STBC;
2261 if (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_RXSTBC_1)
2262 cap |= STA_CAP_VHT_RX_STBC;
2263 if ((vif->type != NL80211_IFTYPE_AP || link_conf->vht_ldpc) &&
2264 (link_sta->vht_cap.cap & IEEE80211_VHT_CAP_RXLDPC))
2265 cap |= STA_CAP_VHT_LDPC;
2266
2267 mt7996_mcu_set_sta_vht_mcs(link_sta, ra->supp_vht_mcs,
2268 mask->control[band].vht_mcs);
2269 }
2270
2271 if (link_sta->he_cap.has_he) {
2272 ra->supp_mode |= MODE_HE;
2273 cap |= STA_CAP_HE;
2274
2275 if (link_sta->he_6ghz_capa.capa)
2276 ra->af = le16_get_bits(link_sta->he_6ghz_capa.capa,
2277 IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP);
2278 }
2279 ra->sta_cap = cpu_to_le32(cap);
2280
2281 memset(ra->rx_rcpi, INIT_RCPI, sizeof(ra->rx_rcpi));
2282 }
2283
2284 int mt7996_mcu_add_rate_ctrl(struct mt7996_dev *dev, struct mt7996_sta *msta,
2285 struct ieee80211_vif *vif, u8 link_id,
2286 bool changed)
2287 {
2288 struct ieee80211_bss_conf *link_conf;
2289 struct ieee80211_link_sta *link_sta;
2290 struct mt7996_sta_link *msta_link;
2291 struct mt7996_vif_link *link;
2292 struct ieee80211_sta *sta;
2293 struct sk_buff *skb;
2294 int ret = -ENODEV;
2295
2296 rcu_read_lock();
2297
2298 link = mt7996_vif_link(dev, vif, link_id);
2299 if (!link)
2300 goto error_unlock;
2301
2302 msta_link = rcu_dereference(msta->link[link_id]);
2303 if (!msta_link)
2304 goto error_unlock;
2305
2306 sta = wcid_to_sta(&msta_link->wcid);
2307 link_sta = rcu_dereference(sta->link[link_id]);
2308 if (!link_sta)
2309 goto error_unlock;
2310
2311 link_conf = rcu_dereference(vif->link_conf[link_id]);
2312 if (!link_conf)
2313 goto error_unlock;
2314
2315 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76,
2316 &msta_link->wcid,
2317 MT7996_STA_UPDATE_MAX_SIZE);
2318 if (IS_ERR(skb)) {
2319 ret = PTR_ERR(skb);
2320 goto error_unlock;
2321 }
2322
2323 /* firmware rc algorithm refers to sta_rec_he for HE control.
2324 * once dev->rc_work changes the settings driver should also
2325 * update sta_rec_he here.
2326 */
2327 if (changed)
2328 mt7996_mcu_sta_he_tlv(skb, link_sta, link);
2329
2330 /* sta_rec_ra accommodates BW, NSS and only MCS range format
2331 * i.e 0-{7,8,9} for VHT.
2332 */
2333 mt7996_mcu_sta_rate_ctrl_tlv(skb, dev, vif, link_conf, link_sta, link);
2334
2335 rcu_read_unlock();
2336
2337 ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
2338 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
2339 if (ret)
2340 return ret;
2341
2342 return mt7996_mcu_add_rate_ctrl_fixed(dev, msta, vif, link_id);
2343
2344 error_unlock:
2345 rcu_read_unlock();
2346
2347 return ret;
2348 }
2349
2350 static int
2351 mt7996_mcu_add_group(struct mt7996_dev *dev, struct mt7996_vif_link *link,
2352 struct mt76_wcid *wcid)
2353 {
2354 #define MT_STA_BSS_GROUP 1
2355 struct {
2356 u8 __rsv1[4];
2357
2358 __le16 tag;
2359 __le16 len;
2360 __le16 wlan_idx;
2361 u8 __rsv2[2];
2362 __le32 action;
2363 __le32 val;
2364 u8 __rsv3[8];
2365 } __packed req = {
2366 .tag = cpu_to_le16(UNI_VOW_DRR_CTRL),
2367 .len = cpu_to_le16(sizeof(req) - 4),
2368 .action = cpu_to_le32(MT_STA_BSS_GROUP),
2369 .val = cpu_to_le32(link->mt76.idx % 16),
2370 .wlan_idx = cpu_to_le16(wcid->idx),
2371 };
2372
2373 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(VOW), &req,
2374 sizeof(req), true);
2375 }
2376
2377 static void
2378 mt7996_mcu_sta_mld_setup_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
2379 struct ieee80211_vif *vif,
2380 struct ieee80211_sta *sta)
2381 {
2382 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
2383 unsigned int nlinks = hweight16(sta->valid_links);
2384 struct mld_setup_link *mld_setup_link;
2385 struct ieee80211_link_sta *link_sta;
2386 struct sta_rec_mld_setup *mld_setup;
2387 struct mt7996_sta_link *msta_link;
2388 unsigned int link_id;
2389 struct tlv *tlv;
2390
2391 msta_link = mt76_dereference(msta->link[msta->deflink_id], &dev->mt76);
2392 if (!msta_link)
2393 return;
2394
2395 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MLD,
2396 sizeof(struct sta_rec_mld_setup) +
2397 sizeof(struct mld_setup_link) * nlinks);
2398
2399 mld_setup = (struct sta_rec_mld_setup *)tlv;
2400 memcpy(mld_setup->mld_addr, sta->addr, ETH_ALEN);
2401 mld_setup->setup_wcid = cpu_to_le16(msta_link->wcid.idx);
2402 mld_setup->primary_id = cpu_to_le16(msta_link->wcid.idx);
2403
2404 if (nlinks > 1) {
2405 msta_link = mt76_dereference(msta->link[msta->seclink_id],
2406 &dev->mt76);
2407 if (!msta_link)
2408 return;
2409 }
2410 mld_setup->seconed_id = cpu_to_le16(msta_link->wcid.idx);
2411 mld_setup->link_num = nlinks;
2412
2413 mld_setup_link = (struct mld_setup_link *)mld_setup->link_info;
2414 for_each_sta_active_link(vif, sta, link_sta, link_id) {
2415 struct mt7996_vif_link *link;
2416
2417 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
2418 if (!msta_link)
2419 continue;
2420
2421 link = mt7996_vif_link(dev, vif, link_id);
2422 if (!link)
2423 continue;
2424
2425 mld_setup_link->wcid = cpu_to_le16(msta_link->wcid.idx);
2426 mld_setup_link->bss_idx = link->mt76.idx;
2427 mld_setup_link++;
2428 }
2429 }
2430
2431 static void
2432 mt7996_mcu_sta_eht_mld_tlv(struct mt7996_dev *dev, struct sk_buff *skb,
2433 struct ieee80211_sta *sta)
2434 {
2435 struct sta_rec_eht_mld *eht_mld;
2436 struct tlv *tlv;
2437 int i;
2438
2439 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT_MLD, sizeof(*eht_mld));
2440 eht_mld = (struct sta_rec_eht_mld *)tlv;
2441
2442 for (i = 0; i < ARRAY_SIZE(eht_mld->str_cap); i++)
2443 eht_mld->str_cap[i] = 0x7;
2444 }
2445
2446 int mt7996_mcu_add_sta(struct mt7996_dev *dev,
2447 struct ieee80211_bss_conf *link_conf,
2448 struct ieee80211_link_sta *link_sta,
2449 struct mt7996_vif_link *link,
2450 struct mt7996_sta_link *msta_link,
2451 int conn_state, bool newly)
2452 {
2453 struct mt76_wcid *wcid = msta_link ? &msta_link->wcid : link->mt76.wcid;
2454 struct ieee80211_sta *sta = link_sta ? link_sta->sta : NULL;
2455 struct sk_buff *skb;
2456 int ret;
2457
2458 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76, wcid,
2459 MT7996_STA_UPDATE_MAX_SIZE);
2460 if (IS_ERR(skb))
2461 return PTR_ERR(skb);
2462
2463 /* starec basic */
2464 mt76_connac_mcu_sta_basic_tlv(&dev->mt76, skb, link_conf, link_sta,
2465 conn_state, newly);
2466
2467 if (conn_state == CONN_STATE_DISCONNECT)
2468 goto out;
2469
2470 /* starec hdr trans */
2471 mt7996_mcu_sta_hdr_trans_tlv(dev, skb, link_conf->vif, wcid);
2472 /* starec tx proc */
2473 mt7996_mcu_sta_tx_proc_tlv(skb);
2474
2475 /* tag order is in accordance with firmware dependency. */
2476 if (link_sta) {
2477 /* starec hdrt mode */
2478 mt7996_mcu_sta_hdrt_tlv(dev, skb);
2479 if (conn_state == CONN_STATE_CONNECT) {
2480 /* starec bfer */
2481 mt7996_mcu_sta_bfer_tlv(dev, skb, link_conf, link_sta,
2482 link);
2483 /* starec bfee */
2484 mt7996_mcu_sta_bfee_tlv(dev, skb, link_conf, link_sta,
2485 link);
2486 }
2487 /* starec ht */
2488 mt7996_mcu_sta_ht_tlv(skb, link_sta);
2489 /* starec vht */
2490 mt7996_mcu_sta_vht_tlv(skb, link_sta);
2491 /* starec uapsd */
2492 mt76_connac_mcu_sta_uapsd(skb, link_conf->vif, sta);
2493 /* starec amsdu */
2494 mt7996_mcu_sta_amsdu_tlv(dev, skb, link_conf->vif, link_sta,
2495 msta_link);
2496 /* starec he */
2497 mt7996_mcu_sta_he_tlv(skb, link_sta, link);
2498 /* starec he 6g*/
2499 mt7996_mcu_sta_he_6g_tlv(skb, link_sta);
2500 /* starec eht */
2501 mt7996_mcu_sta_eht_tlv(skb, link_sta);
2502 /* starec muru */
2503 mt7996_mcu_sta_muru_tlv(dev, skb, link_conf, link_sta);
2504
2505 if (sta->mlo) {
2506 mt7996_mcu_sta_mld_setup_tlv(dev, skb, link_conf->vif,
2507 sta);
2508 mt7996_mcu_sta_eht_mld_tlv(dev, skb, sta);
2509 }
2510 }
2511
2512 ret = mt7996_mcu_add_group(dev, link, wcid);
2513 if (ret) {
2514 dev_kfree_skb(skb);
2515 return ret;
2516 }
2517 out:
2518 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2519 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
2520 }
2521
2522 int mt7996_mcu_teardown_mld_sta(struct mt7996_dev *dev,
2523 struct mt7996_vif_link *link,
2524 struct mt7996_sta_link *msta_link)
2525 {
2526 struct sk_buff *skb;
2527
2528 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76,
2529 &msta_link->wcid,
2530 MT7996_STA_UPDATE_MAX_SIZE);
2531 if (IS_ERR(skb))
2532 return PTR_ERR(skb);
2533
2534 mt76_connac_mcu_add_tlv(skb, STA_REC_MLD_OFF, sizeof(struct tlv));
2535
2536 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2537 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
2538 }
2539
2540 static int
2541 mt7996_mcu_sta_key_tlv(struct mt76_dev *dev, struct mt76_wcid *wcid,
2542 struct sk_buff *skb,
2543 struct ieee80211_key_conf *key,
2544 enum set_key_cmd cmd)
2545 {
2546 struct sta_rec_sec_uni *sec;
2547 struct sec_key_uni *sec_key;
2548 struct tlv *tlv;
2549 u8 cipher;
2550
2551 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec));
2552 sec = (struct sta_rec_sec_uni *)tlv;
2553 /* due to connac3 FW design, we only do remove key for BIGTK; even for
2554 * removal, the field should be filled with SET_KEY
2555 */
2556 sec->add = SET_KEY;
2557 sec->n_cipher = 1;
2558 sec_key = &sec->key[0];
2559 sec_key->wlan_idx = cpu_to_le16(wcid->idx);
2560 sec_key->key_id = key->keyidx;
2561
2562 if (cmd != SET_KEY)
2563 return 0;
2564
2565 cipher = mt76_connac_mcu_get_cipher(key->cipher);
2566 if (cipher == MCU_CIPHER_NONE)
2567 return -EOPNOTSUPP;
2568
2569 sec_key->mgmt_prot = 0;
2570 sec_key->cipher_id = cipher;
2571 sec_key->cipher_len = sizeof(*sec_key);
2572 sec_key->key_len = key->keylen;
2573 sec_key->need_resp = 0;
2574 memcpy(sec_key->key, key->key, key->keylen);
2575
2576 if (cipher == MCU_CIPHER_TKIP) {
2577 /* Rx/Tx MIC keys are swapped */
2578 memcpy(sec_key->key + 16, key->key + 24, 8);
2579 memcpy(sec_key->key + 24, key->key + 16, 8);
2580 return 0;
2581 }
2582
2583 if (sec_key->key_id != 6 && sec_key->key_id != 7)
2584 return 0;
2585
2586 switch (key->cipher) {
2587 case WLAN_CIPHER_SUITE_AES_CMAC:
2588 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_CMAC_128;
2589 break;
2590 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
2591 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_GMAC_128;
2592 break;
2593 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
2594 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_GMAC_256;
2595 break;
2596 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
2597 if (!is_mt7990(dev))
2598 return -EOPNOTSUPP;
2599 sec_key->cipher_id = MCU_CIPHER_BCN_PROT_CMAC_256;
2600 break;
2601 default:
2602 return -EOPNOTSUPP;
2603 }
2604
2605 sec_key->bcn_mode = is_mt7990(dev) ? BP_HW_MODE : BP_SW_MODE;
2606
2607 return 0;
2608 }
2609
2610 int mt7996_mcu_add_key(struct mt76_dev *dev, struct mt7996_vif_link *link,
2611 struct ieee80211_key_conf *key, int mcu_cmd,
2612 struct mt76_wcid *wcid, enum set_key_cmd cmd)
2613 {
2614 struct sk_buff *skb;
2615 int ret;
2616
2617 skb = __mt76_connac_mcu_alloc_sta_req(dev, (struct mt76_vif_link *)link,
2618 wcid, MT7996_STA_UPDATE_MAX_SIZE);
2619 if (IS_ERR(skb))
2620 return PTR_ERR(skb);
2621
2622 ret = mt7996_mcu_sta_key_tlv(dev, wcid, skb, key, cmd);
2623 if (ret) {
2624 dev_kfree_skb(skb);
2625 return ret;
2626 }
2627
2628 return mt76_mcu_skb_send_msg(dev, skb, mcu_cmd, true);
2629 }
2630
2631 int mt7996_mcu_add_dev_info(struct mt7996_phy *phy, struct ieee80211_vif *vif,
2632 struct ieee80211_bss_conf *link_conf,
2633 struct mt76_vif_link *mlink, bool enable)
2634 {
2635 struct mt7996_dev *dev = phy->dev;
2636 struct {
2637 struct req_hdr {
2638 u8 omac_idx;
2639 u8 band_idx;
2640 u8 __rsv[2];
2641 } __packed hdr;
2642 struct req_tlv {
2643 __le16 tag;
2644 __le16 len;
2645 u8 active;
2646 u8 __rsv;
2647 u8 omac_addr[ETH_ALEN];
2648 } __packed tlv;
2649 } data = {
2650 .hdr = {
2651 .omac_idx = mlink->omac_idx,
2652 .band_idx = mlink->band_idx,
2653 },
2654 .tlv = {
2655 .tag = cpu_to_le16(DEV_INFO_ACTIVE),
2656 .len = cpu_to_le16(sizeof(struct req_tlv)),
2657 .active = enable,
2658 },
2659 };
2660
2661 if (mlink->omac_idx >= REPEATER_BSSID_START)
2662 return mt7996_mcu_muar_config(dev, mlink, link_conf->addr, false, enable);
2663
2664 memcpy(data.tlv.omac_addr, link_conf->addr, ETH_ALEN);
2665 return mt76_mcu_send_msg(&dev->mt76, MCU_WMWA_UNI_CMD(DEV_INFO_UPDATE),
2666 &data, sizeof(data), true);
2667 }
2668
2669 static void
2670 mt7996_mcu_beacon_cntdwn(struct sk_buff *rskb, struct sk_buff *skb,
2671 struct ieee80211_mutable_offsets *offs,
2672 bool csa)
2673 {
2674 struct bss_bcn_cntdwn_tlv *info;
2675 struct tlv *tlv;
2676 u16 tag;
2677
2678 if (!offs->cntdwn_counter_offs[0])
2679 return;
2680
2681 tag = csa ? UNI_BSS_INFO_BCN_CSA : UNI_BSS_INFO_BCN_BCC;
2682
2683 tlv = mt7996_mcu_add_uni_tlv(rskb, tag, sizeof(*info));
2684
2685 info = (struct bss_bcn_cntdwn_tlv *)tlv;
2686 info->cnt = skb->data[offs->cntdwn_counter_offs[0]];
2687 }
2688
2689 static void
2690 mt7996_mcu_beacon_mbss(struct sk_buff *rskb, struct sk_buff *skb,
2691 struct bss_bcn_content_tlv *bcn,
2692 struct ieee80211_mutable_offsets *offs)
2693 {
2694 struct bss_bcn_mbss_tlv *mbss;
2695 const struct element *elem;
2696 struct tlv *tlv;
2697
2698 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_BCN_MBSSID, sizeof(*mbss));
2699
2700 mbss = (struct bss_bcn_mbss_tlv *)tlv;
2701 mbss->offset[0] = cpu_to_le16(offs->tim_offset);
2702 mbss->bitmap = cpu_to_le32(1);
2703
2704 for_each_element_id(elem, WLAN_EID_MULTIPLE_BSSID,
2705 &skb->data[offs->mbssid_off],
2706 skb->len - offs->mbssid_off) {
2707 const struct element *sub_elem;
2708
2709 if (elem->datalen < 2)
2710 continue;
2711
2712 for_each_element(sub_elem, elem->data + 1, elem->datalen - 1) {
2713 const struct ieee80211_bssid_index *idx;
2714 const u8 *idx_ie;
2715
2716 /* not a valid BSS profile */
2717 if (sub_elem->id || sub_elem->datalen < 4)
2718 continue;
2719
2720 /* Find WLAN_EID_MULTI_BSSID_IDX
2721 * in the merged nontransmitted profile
2722 */
2723 idx_ie = cfg80211_find_ie(WLAN_EID_MULTI_BSSID_IDX,
2724 sub_elem->data, sub_elem->datalen);
2725 if (!idx_ie || idx_ie[1] < sizeof(*idx))
2726 continue;
2727
2728 idx = (void *)(idx_ie + 2);
2729 if (!idx->bssid_index || idx->bssid_index > 31)
2730 continue;
2731
2732 mbss->offset[idx->bssid_index] = cpu_to_le16(idx_ie -
2733 skb->data);
2734 mbss->bitmap |= cpu_to_le32(BIT(idx->bssid_index));
2735 }
2736 }
2737 }
2738
2739 static void
2740 mt7996_mcu_beacon_cont(struct mt7996_dev *dev,
2741 struct ieee80211_bss_conf *link_conf,
2742 struct mt7996_vif_link *link,
2743 struct sk_buff *rskb, struct sk_buff *skb,
2744 struct bss_bcn_content_tlv *bcn,
2745 struct ieee80211_mutable_offsets *offs)
2746 {
2747 u8 *buf, keyidx = link->msta_link.wcid.hw_key_idx2;
2748 struct mt76_wcid *wcid;
2749
2750 if (is_mt7990(&dev->mt76) && (keyidx == 6 || keyidx == 7))
2751 wcid = &link->msta_link.wcid;
2752 else
2753 wcid = &dev->mt76.global_wcid;
2754
2755 bcn->pkt_len = cpu_to_le16(MT_TXD_SIZE + skb->len);
2756 bcn->tim_ie_pos = cpu_to_le16(offs->tim_offset);
2757
2758 if (offs->cntdwn_counter_offs[0]) {
2759 u16 offset = offs->cntdwn_counter_offs[0];
2760
2761 if (link_conf->csa_active)
2762 bcn->csa_ie_pos = cpu_to_le16(offset - 4);
2763 if (link_conf->color_change_active)
2764 bcn->bcc_ie_pos = cpu_to_le16(offset - 3);
2765 }
2766
2767 buf = (u8 *)bcn + sizeof(*bcn);
2768 mt7996_mac_write_txwi(dev, (__le32 *)buf, skb, wcid, NULL, 0, 0,
2769 BSS_CHANGED_BEACON);
2770
2771 memcpy(buf + MT_TXD_SIZE, skb->data, skb->len);
2772 }
2773
2774 int mt7996_mcu_add_beacon(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2775 struct ieee80211_bss_conf *link_conf, bool enabled)
2776 {
2777 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2778 struct mt7996_vif_link *link = mt7996_vif_conf_link(dev, vif, link_conf);
2779 struct mt76_vif_link *mlink = link ? &link->mt76 : NULL;
2780 struct ieee80211_mutable_offsets offs;
2781 struct ieee80211_tx_info *info;
2782 struct sk_buff *skb, *rskb;
2783 struct tlv *tlv;
2784 struct bss_bcn_content_tlv *bcn;
2785 int len, extra_len = 0;
2786
2787 if (link_conf->nontransmitted)
2788 return 0;
2789
2790 if (!mlink)
2791 return -EINVAL;
2792
2793 if (link->phy && link->phy->mt76->offchannel)
2794 enabled = false;
2795
2796 rskb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink,
2797 MT7996_MAX_BSS_OFFLOAD_SIZE);
2798 if (IS_ERR(rskb))
2799 return PTR_ERR(rskb);
2800
2801 skb = ieee80211_beacon_get_template(hw, vif, &offs, link_conf->link_id);
2802 if (enabled && !skb) {
2803 dev_kfree_skb(rskb);
2804 return -EINVAL;
2805 }
2806
2807 if (skb) {
2808 if (skb->len > MT7996_MAX_BEACON_SIZE) {
2809 dev_err(dev->mt76.dev, "Bcn size limit exceed\n");
2810 dev_kfree_skb(rskb);
2811 dev_kfree_skb(skb);
2812 return -EINVAL;
2813 }
2814
2815 extra_len = skb->len;
2816 }
2817
2818 len = ALIGN(sizeof(*bcn) + MT_TXD_SIZE + extra_len, 4);
2819 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_BCN_CONTENT, len);
2820 bcn = (struct bss_bcn_content_tlv *)tlv;
2821 bcn->enable = enabled;
2822 if (!bcn->enable)
2823 goto out;
2824
2825 info = IEEE80211_SKB_CB(skb);
2826 info->hw_queue |= FIELD_PREP(MT_TX_HW_QUEUE_PHY, mlink->band_idx);
2827
2828 mt7996_mcu_beacon_cont(dev, link_conf, link, rskb, skb, bcn, &offs);
2829 if (link_conf->bssid_indicator)
2830 mt7996_mcu_beacon_mbss(rskb, skb, bcn, &offs);
2831 mt7996_mcu_beacon_cntdwn(rskb, skb, &offs, link_conf->csa_active);
2832 out:
2833 dev_kfree_skb(skb);
2834 return mt76_mcu_skb_send_msg(&dev->mt76, rskb,
2835 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true);
2836 }
2837
2838 int mt7996_mcu_beacon_inband_discov(struct mt7996_dev *dev,
2839 struct ieee80211_bss_conf *link_conf,
2840 struct mt7996_vif_link *link, u32 changed)
2841 {
2842 #define OFFLOAD_TX_MODE_SU BIT(0)
2843 #define OFFLOAD_TX_MODE_MU BIT(1)
2844 struct ieee80211_vif *vif = link_conf->vif;
2845 struct ieee80211_hw *hw = mt76_hw(dev);
2846 struct mt7996_phy *phy = link->phy;
2847 struct mt76_wcid *wcid = &dev->mt76.global_wcid;
2848 struct bss_inband_discovery_tlv *discov;
2849 struct ieee80211_tx_info *info;
2850 struct sk_buff *rskb, *skb = NULL;
2851 struct cfg80211_chan_def *chandef;
2852 enum nl80211_band band;
2853 struct tlv *tlv;
2854 u8 *buf, interval;
2855 int len;
2856
2857 if (!phy)
2858 return -EINVAL;
2859
2860 chandef = &phy->mt76->chandef;
2861 band = chandef->chan->band;
2862
2863 if (link_conf->nontransmitted)
2864 return 0;
2865
2866 rskb = __mt7996_mcu_alloc_bss_req(&dev->mt76, &link->mt76,
2867 MT7996_MAX_BSS_OFFLOAD_SIZE);
2868 if (IS_ERR(rskb))
2869 return PTR_ERR(rskb);
2870
2871 if (changed & BSS_CHANGED_FILS_DISCOVERY &&
2872 link_conf->fils_discovery.max_interval) {
2873 interval = link_conf->fils_discovery.max_interval;
2874 skb = ieee80211_get_fils_discovery_tmpl(hw, vif);
2875 } else if (changed & BSS_CHANGED_UNSOL_BCAST_PROBE_RESP &&
2876 link_conf->unsol_bcast_probe_resp_interval) {
2877 interval = link_conf->unsol_bcast_probe_resp_interval;
2878 skb = ieee80211_get_unsol_bcast_probe_resp_tmpl(hw, vif);
2879 }
2880
2881 if (!skb) {
2882 dev_kfree_skb(rskb);
2883 return -EINVAL;
2884 }
2885
2886 if (skb->len > MT7996_MAX_BEACON_SIZE) {
2887 dev_err(dev->mt76.dev, "inband discovery size limit exceed\n");
2888 dev_kfree_skb(rskb);
2889 dev_kfree_skb(skb);
2890 return -EINVAL;
2891 }
2892
2893 info = IEEE80211_SKB_CB(skb);
2894 info->control.vif = vif;
2895 info->band = band;
2896 info->hw_queue |= FIELD_PREP(MT_TX_HW_QUEUE_PHY, phy->mt76->band_idx);
2897
2898 len = ALIGN(sizeof(*discov) + MT_TXD_SIZE + skb->len, 4);
2899 tlv = mt7996_mcu_add_uni_tlv(rskb, UNI_BSS_INFO_OFFLOAD, len);
2900
2901 discov = (struct bss_inband_discovery_tlv *)tlv;
2902 discov->tx_mode = OFFLOAD_TX_MODE_SU;
2903 /* 0: UNSOL PROBE RESP, 1: FILS DISCOV */
2904 discov->tx_type = !!(changed & BSS_CHANGED_FILS_DISCOVERY);
2905 discov->tx_interval = interval;
2906 discov->prob_rsp_len = cpu_to_le16(MT_TXD_SIZE + skb->len);
2907 discov->enable = true;
2908 discov->wcid = cpu_to_le16(MT7996_WTBL_RESERVED);
2909
2910 buf = (u8 *)tlv + sizeof(*discov);
2911
2912 mt7996_mac_write_txwi(dev, (__le32 *)buf, skb, wcid, NULL, 0, 0, changed);
2913
2914 memcpy(buf + MT_TXD_SIZE, skb->data, skb->len);
2915
2916 dev_kfree_skb(skb);
2917
2918 return mt76_mcu_skb_send_msg(&dev->mt76, rskb,
2919 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true);
2920 }
2921
2922 static int mt7996_driver_own(struct mt7996_dev *dev, u8 band)
2923 {
2924 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(band), MT_TOP_LPCR_HOST_DRV_OWN);
2925 if (!mt76_poll_msec(dev, MT_TOP_LPCR_HOST_BAND(band),
2926 MT_TOP_LPCR_HOST_FW_OWN_STAT, 0, 500)) {
2927 dev_err(dev->mt76.dev, "Timeout for driver own\n");
2928 return -EIO;
2929 }
2930
2931 /* clear irq when the driver own success */
2932 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND_IRQ_STAT(band),
2933 MT_TOP_LPCR_HOST_BAND_STAT);
2934
2935 return 0;
2936 }
2937
2938 static u32 mt7996_patch_sec_mode(u32 key_info)
2939 {
2940 u32 sec = u32_get_bits(key_info, MT7996_PATCH_SEC), key = 0;
2941
2942 if (key_info == GENMASK(31, 0) || sec == MT7996_SEC_MODE_PLAIN)
2943 return 0;
2944
2945 if (sec == MT7996_SEC_MODE_AES)
2946 key = u32_get_bits(key_info, MT7996_PATCH_AES_KEY);
2947 else
2948 key = u32_get_bits(key_info, MT7996_PATCH_SCRAMBLE_KEY);
2949
2950 return MT7996_SEC_ENCRYPT | MT7996_SEC_IV |
2951 u32_encode_bits(key, MT7996_SEC_KEY_IDX);
2952 }
2953
2954 static int mt7996_load_patch(struct mt7996_dev *dev)
2955 {
2956 const struct mt7996_patch_hdr *hdr;
2957 const struct firmware *fw = NULL;
2958 int i, ret, sem;
2959
2960 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, 1);
2961 switch (sem) {
2962 case PATCH_IS_DL:
2963 return 0;
2964 case PATCH_NOT_DL_SEM_SUCCESS:
2965 break;
2966 default:
2967 dev_err(dev->mt76.dev, "Failed to get patch semaphore\n");
2968 return -EAGAIN;
2969 }
2970
2971 ret = request_firmware(&fw, fw_name(dev, ROM_PATCH), dev->mt76.dev);
2972 if (ret)
2973 goto out;
2974
2975 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
2976 dev_err(dev->mt76.dev, "Invalid firmware\n");
2977 ret = -EINVAL;
2978 goto out;
2979 }
2980
2981 hdr = (const struct mt7996_patch_hdr *)(fw->data);
2982
2983 dev_info(dev->mt76.dev, "HW/SW Version: 0x%x, Build Time: %.16s\n",
2984 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date);
2985
2986 for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) {
2987 struct mt7996_patch_sec *sec;
2988 const u8 *dl;
2989 u32 len, addr, sec_key_idx, mode = DL_MODE_NEED_RSP;
2990
2991 sec = (struct mt7996_patch_sec *)(fw->data + sizeof(*hdr) +
2992 i * sizeof(*sec));
2993 if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) !=
2994 PATCH_SEC_TYPE_INFO) {
2995 ret = -EINVAL;
2996 goto out;
2997 }
2998
2999 addr = be32_to_cpu(sec->info.addr);
3000 len = be32_to_cpu(sec->info.len);
3001 sec_key_idx = be32_to_cpu(sec->info.sec_key_idx);
3002 dl = fw->data + be32_to_cpu(sec->offs);
3003
3004 mode |= mt7996_patch_sec_mode(sec_key_idx);
3005
3006 ret = mt76_connac_mcu_init_download(&dev->mt76, addr, len,
3007 mode);
3008 if (ret) {
3009 dev_err(dev->mt76.dev, "Download request failed\n");
3010 goto out;
3011 }
3012
3013 ret = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER),
3014 dl, len, 4096);
3015 if (ret) {
3016 dev_err(dev->mt76.dev, "Failed to send patch\n");
3017 goto out;
3018 }
3019 }
3020
3021 ret = mt76_connac_mcu_start_patch(&dev->mt76);
3022 if (ret)
3023 dev_err(dev->mt76.dev, "Failed to start patch\n");
3024
3025 out:
3026 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, 0);
3027 switch (sem) {
3028 case PATCH_REL_SEM_SUCCESS:
3029 break;
3030 default:
3031 ret = -EAGAIN;
3032 dev_err(dev->mt76.dev, "Failed to release patch semaphore\n");
3033 break;
3034 }
3035 release_firmware(fw);
3036
3037 return ret;
3038 }
3039
3040 static int
3041 mt7996_mcu_send_ram_firmware(struct mt7996_dev *dev,
3042 const struct mt7996_fw_trailer *hdr,
3043 const u8 *data, enum mt7996_ram_type type)
3044 {
3045 int i, offset = 0;
3046 u32 override = 0, option = 0;
3047
3048 for (i = 0; i < hdr->n_region; i++) {
3049 const struct mt7996_fw_region *region;
3050 int err;
3051 u32 len, addr, mode;
3052
3053 region = (const struct mt7996_fw_region *)((const u8 *)hdr -
3054 (hdr->n_region - i) * sizeof(*region));
3055 /* DSP and WA use same mode */
3056 mode = mt76_connac_mcu_gen_dl_mode(&dev->mt76,
3057 region->feature_set,
3058 type != MT7996_RAM_TYPE_WM);
3059 len = le32_to_cpu(region->len);
3060 addr = le32_to_cpu(region->addr);
3061
3062 if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR)
3063 override = addr;
3064
3065 err = mt76_connac_mcu_init_download(&dev->mt76, addr, len,
3066 mode);
3067 if (err) {
3068 dev_err(dev->mt76.dev, "Download request failed\n");
3069 return err;
3070 }
3071
3072 err = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD(FW_SCATTER),
3073 data + offset, len, 4096);
3074 if (err) {
3075 dev_err(dev->mt76.dev, "Failed to send firmware.\n");
3076 return err;
3077 }
3078
3079 offset += len;
3080 }
3081
3082 if (override)
3083 option |= FW_START_OVERRIDE;
3084
3085 if (type == MT7996_RAM_TYPE_WA)
3086 option |= FW_START_WORKING_PDA_CR4;
3087 else if (type == MT7996_RAM_TYPE_DSP)
3088 option |= FW_START_WORKING_PDA_DSP;
3089
3090 return mt76_connac_mcu_start_firmware(&dev->mt76, override, option);
3091 }
3092
3093 static int __mt7996_load_ram(struct mt7996_dev *dev, const char *fw_type,
3094 const char *fw_file, enum mt7996_ram_type ram_type)
3095 {
3096 const struct mt7996_fw_trailer *hdr;
3097 const struct firmware *fw;
3098 int ret;
3099
3100 ret = request_firmware(&fw, fw_file, dev->mt76.dev);
3101 if (ret)
3102 return ret;
3103
3104 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
3105 dev_err(dev->mt76.dev, "Invalid firmware\n");
3106 ret = -EINVAL;
3107 goto out;
3108 }
3109
3110 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr));
3111 dev_info(dev->mt76.dev, "%s Firmware Version: %.10s, Build Time: %.15s\n",
3112 fw_type, hdr->fw_ver, hdr->build_date);
3113
3114 ret = mt7996_mcu_send_ram_firmware(dev, hdr, fw->data, ram_type);
3115 if (ret) {
3116 dev_err(dev->mt76.dev, "Failed to start %s firmware\n", fw_type);
3117 goto out;
3118 }
3119
3120 snprintf(dev->mt76.hw->wiphy->fw_version,
3121 sizeof(dev->mt76.hw->wiphy->fw_version),
3122 "%.10s-%.15s", hdr->fw_ver, hdr->build_date);
3123
3124 out:
3125 release_firmware(fw);
3126
3127 return ret;
3128 }
3129
3130 static int mt7996_load_ram(struct mt7996_dev *dev)
3131 {
3132 int ret;
3133
3134 ret = __mt7996_load_ram(dev, "WM", fw_name(dev, FIRMWARE_WM),
3135 MT7996_RAM_TYPE_WM);
3136 if (ret)
3137 return ret;
3138
3139 if (!mt7996_has_wa(dev))
3140 return 0;
3141
3142 ret = __mt7996_load_ram(dev, "DSP", fw_name(dev, FIRMWARE_DSP),
3143 MT7996_RAM_TYPE_DSP);
3144 if (ret)
3145 return ret;
3146
3147 return __mt7996_load_ram(dev, "WA", fw_name(dev, FIRMWARE_WA),
3148 MT7996_RAM_TYPE_WA);
3149 }
3150
3151 static int
3152 mt7996_firmware_state(struct mt7996_dev *dev, u8 fw_state)
3153 {
3154 u32 state = FIELD_PREP(MT_TOP_MISC_FW_STATE, fw_state);
3155
3156 if (!mt76_poll_msec(dev, MT_TOP_MISC, MT_TOP_MISC_FW_STATE,
3157 state, 1000)) {
3158 dev_err(dev->mt76.dev, "Timeout for initializing firmware\n");
3159 return -EIO;
3160 }
3161 return 0;
3162 }
3163
3164 static int
3165 mt7996_mcu_restart(struct mt76_dev *dev)
3166 {
3167 struct {
3168 u8 __rsv1[4];
3169
3170 __le16 tag;
3171 __le16 len;
3172 u8 power_mode;
3173 u8 __rsv2[3];
3174 } __packed req = {
3175 .tag = cpu_to_le16(UNI_POWER_OFF),
3176 .len = cpu_to_le16(sizeof(req) - 4),
3177 .power_mode = 1,
3178 };
3179
3180 return mt76_mcu_send_msg(dev, MCU_WM_UNI_CMD(POWER_CTRL), &req,
3181 sizeof(req), false);
3182 }
3183
3184 static int mt7996_load_firmware(struct mt7996_dev *dev)
3185 {
3186 u8 fw_state;
3187 int ret;
3188
3189 /* make sure fw is download state */
3190 if (mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD)) {
3191 /* restart firmware once */
3192 mt7996_mcu_restart(&dev->mt76);
3193 ret = mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD);
3194 if (ret) {
3195 dev_err(dev->mt76.dev,
3196 "Firmware is not ready for download\n");
3197 return ret;
3198 }
3199 }
3200
3201 ret = mt7996_load_patch(dev);
3202 if (ret)
3203 return ret;
3204
3205 ret = mt7996_load_ram(dev);
3206 if (ret)
3207 return ret;
3208
3209 fw_state = mt7996_has_wa(dev) ? FW_STATE_RDY : FW_STATE_NORMAL_TRX;
3210 ret = mt7996_firmware_state(dev, fw_state);
3211 if (ret)
3212 return ret;
3213
3214 mt76_queue_tx_cleanup(dev, dev->mt76.q_mcu[MT_MCUQ_FWDL], false);
3215
3216 dev_dbg(dev->mt76.dev, "Firmware init done\n");
3217
3218 return 0;
3219 }
3220
3221 int mt7996_mcu_fw_log_2_host(struct mt7996_dev *dev, u8 type, u8 ctrl)
3222 {
3223 struct {
3224 u8 _rsv[4];
3225
3226 __le16 tag;
3227 __le16 len;
3228 u8 ctrl;
3229 u8 interval;
3230 u8 _rsv2[2];
3231 } __packed data = {
3232 .tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_LOG_CTRL),
3233 .len = cpu_to_le16(sizeof(data) - 4),
3234 .ctrl = ctrl,
3235 };
3236
3237 if (type == MCU_FW_LOG_WA)
3238 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(WSYS_CONFIG),
3239 &data, sizeof(data), true);
3240
3241 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(WSYS_CONFIG), &data,
3242 sizeof(data), true);
3243 }
3244
3245 int mt7996_mcu_fw_dbg_ctrl(struct mt7996_dev *dev, u32 module, u8 level)
3246 {
3247 struct {
3248 u8 _rsv[4];
3249
3250 __le16 tag;
3251 __le16 len;
3252 __le32 module_idx;
3253 u8 level;
3254 u8 _rsv2[3];
3255 } data = {
3256 .tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_DBG_CTRL),
3257 .len = cpu_to_le16(sizeof(data) - 4),
3258 .module_idx = cpu_to_le32(module),
3259 .level = level,
3260 };
3261
3262 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(WSYS_CONFIG), &data,
3263 sizeof(data), false);
3264 }
3265
3266 static int mt7996_mcu_set_mwds(struct mt7996_dev *dev, bool enabled)
3267 {
3268 struct {
3269 u8 enable;
3270 u8 _rsv[3];
3271 } __packed req = {
3272 .enable = enabled
3273 };
3274
3275 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_EXT_CMD(MWDS_SUPPORT), &req,
3276 sizeof(req), false);
3277 }
3278
3279 static void mt7996_add_rx_airtime_tlv(struct sk_buff *skb, u8 band_idx)
3280 {
3281 struct vow_rx_airtime *req;
3282 struct tlv *tlv;
3283
3284 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_VOW_RX_AT_AIRTIME_CLR_EN, sizeof(*req));
3285 req = (struct vow_rx_airtime *)tlv;
3286 req->enable = true;
3287 req->band = band_idx;
3288
3289 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_VOW_RX_AT_AIRTIME_EN, sizeof(*req));
3290 req = (struct vow_rx_airtime *)tlv;
3291 req->enable = true;
3292 req->band = band_idx;
3293 }
3294
3295 static int
3296 mt7996_mcu_init_rx_airtime(struct mt7996_dev *dev)
3297 {
3298 struct uni_header hdr = {};
3299 struct sk_buff *skb;
3300 int len, num, i;
3301
3302 num = 2 + 2 * (mt7996_band_valid(dev, MT_BAND1) +
3303 mt7996_band_valid(dev, MT_BAND2));
3304 len = sizeof(hdr) + num * sizeof(struct vow_rx_airtime);
3305 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
3306 if (!skb)
3307 return -ENOMEM;
3308
3309 skb_put_data(skb, &hdr, sizeof(hdr));
3310
3311 for (i = 0; i < __MT_MAX_BAND; i++) {
3312 if (mt7996_band_valid(dev, i))
3313 mt7996_add_rx_airtime_tlv(skb, i);
3314 }
3315
3316 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
3317 MCU_WM_UNI_CMD(VOW), true);
3318 }
3319
3320 int mt7996_mcu_init_firmware(struct mt7996_dev *dev)
3321 {
3322 int ret;
3323
3324 /* force firmware operation mode into normal state,
3325 * which should be set before firmware download stage.
3326 */
3327 mt76_wr(dev, MT_SWDEF_MODE, MT_SWDEF_NORMAL_MODE);
3328
3329 ret = mt7996_driver_own(dev, 0);
3330 if (ret)
3331 return ret;
3332 /* set driver own for band1 when two hif exist */
3333 if (dev->hif2) {
3334 ret = mt7996_driver_own(dev, 1);
3335 if (ret)
3336 return ret;
3337 }
3338
3339 ret = mt7996_load_firmware(dev);
3340 if (ret)
3341 return ret;
3342
3343 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
3344 ret = mt7996_mcu_fw_log_2_host(dev, MCU_FW_LOG_WM, 0);
3345 if (ret)
3346 return ret;
3347
3348 if (mt7996_has_wa(dev)) {
3349 ret = mt7996_mcu_fw_log_2_host(dev, MCU_FW_LOG_WA, 0);
3350 if (ret)
3351 return ret;
3352
3353 ret = mt7996_mcu_set_mwds(dev, 1);
3354 if (ret)
3355 return ret;
3356 }
3357
3358 ret = mt7996_mcu_init_rx_airtime(dev);
3359 if (ret)
3360 return ret;
3361
3362 return mt7996_mcu_wa_cmd(dev, MCU_WA_PARAM_CMD(SET),
3363 MCU_WA_PARAM_RED, 0, 0);
3364 }
3365
3366 int mt7996_mcu_init(struct mt7996_dev *dev)
3367 {
3368 static const struct mt76_mcu_ops mt7996_mcu_ops = {
3369 .headroom = sizeof(struct mt76_connac2_mcu_txd), /* reuse */
3370 .mcu_skb_send_msg = mt7996_mcu_send_message,
3371 .mcu_parse_response = mt7996_mcu_parse_response,
3372 };
3373
3374 dev->mt76.mcu_ops = &mt7996_mcu_ops;
3375
3376 return mt7996_mcu_init_firmware(dev);
3377 }
3378
3379 void mt7996_mcu_exit(struct mt7996_dev *dev)
3380 {
3381 mt7996_mcu_restart(&dev->mt76);
3382 if (mt7996_firmware_state(dev, FW_STATE_FW_DOWNLOAD)) {
3383 dev_err(dev->mt76.dev, "Failed to exit mcu\n");
3384 goto out;
3385 }
3386
3387 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(0), MT_TOP_LPCR_HOST_FW_OWN);
3388 if (dev->hif2)
3389 mt76_wr(dev, MT_TOP_LPCR_HOST_BAND(1),
3390 MT_TOP_LPCR_HOST_FW_OWN);
3391 out:
3392 skb_queue_purge(&dev->mt76.mcu.res_q);
3393 }
3394
3395 int mt7996_mcu_set_hdr_trans(struct mt7996_dev *dev, bool hdr_trans)
3396 {
3397 struct {
3398 u8 __rsv[4];
3399 } __packed hdr = {};
3400 struct hdr_trans_blacklist *req_blacklist;
3401 struct hdr_trans_en *req_en;
3402 struct sk_buff *skb;
3403 struct tlv *tlv;
3404 int len = MT7996_HDR_TRANS_MAX_SIZE + sizeof(hdr);
3405
3406 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
3407 if (!skb)
3408 return -ENOMEM;
3409
3410 skb_put_data(skb, &hdr, sizeof(hdr));
3411
3412 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_EN, sizeof(*req_en));
3413 req_en = (struct hdr_trans_en *)tlv;
3414 req_en->enable = hdr_trans;
3415
3416 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_VLAN,
3417 sizeof(struct hdr_trans_vlan));
3418
3419 if (hdr_trans) {
3420 tlv = mt7996_mcu_add_uni_tlv(skb, UNI_HDR_TRANS_BLACKLIST,
3421 sizeof(*req_blacklist));
3422 req_blacklist = (struct hdr_trans_blacklist *)tlv;
3423 req_blacklist->enable = 1;
3424 req_blacklist->type = cpu_to_le16(ETH_P_PAE);
3425 }
3426
3427 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
3428 MCU_WM_UNI_CMD(RX_HDR_TRANS), true);
3429 }
3430
3431 int mt7996_mcu_set_tx(struct mt7996_dev *dev, struct ieee80211_vif *vif,
3432 struct ieee80211_bss_conf *link_conf)
3433 {
3434 #define MCU_EDCA_AC_PARAM 0
3435 #define WMM_AIFS_SET BIT(0)
3436 #define WMM_CW_MIN_SET BIT(1)
3437 #define WMM_CW_MAX_SET BIT(2)
3438 #define WMM_TXOP_SET BIT(3)
3439 #define WMM_PARAM_SET (WMM_AIFS_SET | WMM_CW_MIN_SET | \
3440 WMM_CW_MAX_SET | WMM_TXOP_SET)
3441 struct mt7996_vif_link *link = mt7996_vif_conf_link(dev, vif, link_conf);
3442 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
3443 unsigned int link_id = link_conf->link_id;
3444 struct mt7996_vif_link_info *link_info = &mvif->link_info[link_id];
3445 struct {
3446 u8 bss_idx;
3447 u8 __rsv[3];
3448 } __packed hdr = {
3449 .bss_idx = link->mt76.idx,
3450 };
3451 struct sk_buff *skb;
3452 int len = sizeof(hdr) + IEEE80211_NUM_ACS * sizeof(struct edca);
3453 int ac;
3454
3455 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
3456 if (!skb)
3457 return -ENOMEM;
3458
3459 skb_put_data(skb, &hdr, sizeof(hdr));
3460
3461 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
3462 struct ieee80211_tx_queue_params *q = &link_info->queue_params[ac];
3463 struct edca *e;
3464 struct tlv *tlv;
3465
3466 tlv = mt7996_mcu_add_uni_tlv(skb, MCU_EDCA_AC_PARAM, sizeof(*e));
3467
3468 e = (struct edca *)tlv;
3469 e->set = WMM_PARAM_SET;
3470 e->queue = ac;
3471 e->aifs = q->aifs;
3472 e->txop = cpu_to_le16(q->txop);
3473
3474 if (q->cw_min)
3475 e->cw_min = fls(q->cw_min);
3476 else
3477 e->cw_min = 5;
3478
3479 if (q->cw_max)
3480 e->cw_max = fls(q->cw_max);
3481 else
3482 e->cw_max = 10;
3483 }
3484
3485 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
3486 MCU_WM_UNI_CMD(EDCA_UPDATE), true);
3487 }
3488
3489 int mt7996_mcu_set_fcc5_lpn(struct mt7996_dev *dev, int val)
3490 {
3491 struct {
3492 u8 _rsv[4];
3493
3494 __le16 tag;
3495 __le16 len;
3496
3497 __le32 ctrl;
3498 __le16 min_lpn;
3499 u8 rsv[2];
3500 } __packed req = {
3501 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH),
3502 .len = cpu_to_le16(sizeof(req) - 4),
3503
3504 .ctrl = cpu_to_le32(0x1),
3505 .min_lpn = cpu_to_le16(val),
3506 };
3507
3508 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL),
3509 &req, sizeof(req), true);
3510 }
3511
3512 int mt7996_mcu_set_pulse_th(struct mt7996_dev *dev,
3513 const struct mt7996_dfs_pulse *pulse)
3514 {
3515 struct {
3516 u8 _rsv[4];
3517
3518 __le16 tag;
3519 __le16 len;
3520
3521 __le32 ctrl;
3522
3523 __le32 max_width; /* us */
3524 __le32 max_pwr; /* dbm */
3525 __le32 min_pwr; /* dbm */
3526 __le32 min_stgr_pri; /* us */
3527 __le32 max_stgr_pri; /* us */
3528 __le32 min_cr_pri; /* us */
3529 __le32 max_cr_pri; /* us */
3530 } __packed req = {
3531 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH),
3532 .len = cpu_to_le16(sizeof(req) - 4),
3533
3534 .ctrl = cpu_to_le32(0x3),
3535
3536 #define __req_field(field) .field = cpu_to_le32(pulse->field)
3537 __req_field(max_width),
3538 __req_field(max_pwr),
3539 __req_field(min_pwr),
3540 __req_field(min_stgr_pri),
3541 __req_field(max_stgr_pri),
3542 __req_field(min_cr_pri),
3543 __req_field(max_cr_pri),
3544 #undef __req_field
3545 };
3546
3547 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL),
3548 &req, sizeof(req), true);
3549 }
3550
3551 int mt7996_mcu_set_radar_th(struct mt7996_dev *dev, int index,
3552 const struct mt7996_dfs_pattern *pattern)
3553 {
3554 struct {
3555 u8 _rsv[4];
3556
3557 __le16 tag;
3558 __le16 len;
3559
3560 __le32 ctrl;
3561 __le16 radar_type;
3562
3563 u8 enb;
3564 u8 stgr;
3565 u8 min_crpn;
3566 u8 max_crpn;
3567 u8 min_crpr;
3568 u8 min_pw;
3569 __le32 min_pri;
3570 __le32 max_pri;
3571 u8 max_pw;
3572 u8 min_crbn;
3573 u8 max_crbn;
3574 u8 min_stgpn;
3575 u8 max_stgpn;
3576 u8 min_stgpr;
3577 u8 rsv[2];
3578 __le32 min_stgpr_diff;
3579 } __packed req = {
3580 .tag = cpu_to_le16(UNI_RDD_CTRL_SET_TH),
3581 .len = cpu_to_le16(sizeof(req) - 4),
3582
3583 .ctrl = cpu_to_le32(0x2),
3584 .radar_type = cpu_to_le16(index),
3585
3586 #define __req_field_u8(field) .field = pattern->field
3587 #define __req_field_u32(field) .field = cpu_to_le32(pattern->field)
3588 __req_field_u8(enb),
3589 __req_field_u8(stgr),
3590 __req_field_u8(min_crpn),
3591 __req_field_u8(max_crpn),
3592 __req_field_u8(min_crpr),
3593 __req_field_u8(min_pw),
3594 __req_field_u32(min_pri),
3595 __req_field_u32(max_pri),
3596 __req_field_u8(max_pw),
3597 __req_field_u8(min_crbn),
3598 __req_field_u8(max_crbn),
3599 __req_field_u8(min_stgpn),
3600 __req_field_u8(max_stgpn),
3601 __req_field_u8(min_stgpr),
3602 __req_field_u32(min_stgpr_diff),
3603 #undef __req_field_u8
3604 #undef __req_field_u32
3605 };
3606
3607 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL),
3608 &req, sizeof(req), true);
3609 }
3610
3611 static int
3612 mt7996_mcu_background_chain_ctrl(struct mt7996_phy *phy,
3613 struct cfg80211_chan_def *chandef,
3614 int cmd)
3615 {
3616 struct mt7996_dev *dev = phy->dev;
3617 struct mt76_phy *mphy = phy->mt76;
3618 struct ieee80211_channel *chan = mphy->chandef.chan;
3619 int freq = mphy->chandef.center_freq1;
3620 struct mt7996_mcu_background_chain_ctrl req = {
3621 .tag = cpu_to_le16(0),
3622 .len = cpu_to_le16(sizeof(req) - 4),
3623 .monitor_scan_type = 2, /* simple rx */
3624 };
3625
3626 if (!chandef && cmd != CH_SWITCH_BACKGROUND_SCAN_STOP)
3627 return -EINVAL;
3628
3629 if (!cfg80211_chandef_valid(&mphy->chandef))
3630 return -EINVAL;
3631
3632 switch (cmd) {
3633 case CH_SWITCH_BACKGROUND_SCAN_START: {
3634 req.chan = chan->hw_value;
3635 req.central_chan = ieee80211_frequency_to_channel(freq);
3636 req.bw = mt76_connac_chan_bw(&mphy->chandef);
3637 req.monitor_chan = chandef->chan->hw_value;
3638 req.monitor_central_chan =
3639 ieee80211_frequency_to_channel(chandef->center_freq1);
3640 req.monitor_bw = mt76_connac_chan_bw(chandef);
3641 req.band_idx = phy->mt76->band_idx;
3642 req.scan_mode = 1;
3643 break;
3644 }
3645 case CH_SWITCH_BACKGROUND_SCAN_RUNNING:
3646 req.monitor_chan = chandef->chan->hw_value;
3647 req.monitor_central_chan =
3648 ieee80211_frequency_to_channel(chandef->center_freq1);
3649 req.band_idx = phy->mt76->band_idx;
3650 req.scan_mode = 2;
3651 break;
3652 case CH_SWITCH_BACKGROUND_SCAN_STOP:
3653 req.chan = chan->hw_value;
3654 req.central_chan = ieee80211_frequency_to_channel(freq);
3655 req.bw = mt76_connac_chan_bw(&mphy->chandef);
3656 req.tx_stream = hweight8(mphy->antenna_mask);
3657 req.rx_stream = mphy->antenna_mask;
3658 break;
3659 default:
3660 return -EINVAL;
3661 }
3662 req.band = chandef ? chandef->chan->band == NL80211_BAND_5GHZ : 1;
3663
3664 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(OFFCH_SCAN_CTRL),
3665 &req, sizeof(req), false);
3666 }
3667
3668 int mt7996_mcu_rdd_background_enable(struct mt7996_phy *phy,
3669 struct cfg80211_chan_def *chandef)
3670 {
3671 struct mt7996_dev *dev = phy->dev;
3672 int err, region, rdd_idx = mt7996_get_rdd_idx(phy, true);
3673
3674 if (!chandef) { /* disable offchain */
3675 err = mt7996_mcu_rdd_cmd(dev, RDD_STOP, rdd_idx, 0);
3676 if (err)
3677 return err;
3678
3679 return mt7996_mcu_background_chain_ctrl(phy, NULL,
3680 CH_SWITCH_BACKGROUND_SCAN_STOP);
3681 }
3682
3683 err = mt7996_mcu_background_chain_ctrl(phy, chandef,
3684 CH_SWITCH_BACKGROUND_SCAN_START);
3685 if (err)
3686 return err;
3687
3688 switch (dev->mt76.region) {
3689 case NL80211_DFS_ETSI:
3690 region = 0;
3691 break;
3692 case NL80211_DFS_JP:
3693 region = 2;
3694 break;
3695 case NL80211_DFS_FCC:
3696 default:
3697 region = 1;
3698 break;
3699 }
3700
3701 return mt7996_mcu_rdd_cmd(dev, RDD_START, rdd_idx, region);
3702 }
3703
3704 int mt7996_mcu_set_chan_info(struct mt7996_phy *phy, u16 tag)
3705 {
3706 static const u8 ch_band[] = {
3707 [NL80211_BAND_2GHZ] = 0,
3708 [NL80211_BAND_5GHZ] = 1,
3709 [NL80211_BAND_6GHZ] = 2,
3710 };
3711 struct mt7996_dev *dev = phy->dev;
3712 struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
3713 int freq1 = chandef->center_freq1;
3714 u8 band_idx = phy->mt76->band_idx;
3715 struct {
3716 /* fixed field */
3717 u8 __rsv[4];
3718
3719 __le16 tag;
3720 __le16 len;
3721 u8 control_ch;
3722 u8 center_ch;
3723 u8 bw;
3724 u8 tx_path_num;
3725 u8 rx_path; /* mask or num */
3726 u8 switch_reason;
3727 u8 band_idx;
3728 u8 center_ch2; /* for 80+80 only */
3729 __le16 cac_case;
3730 u8 channel_band;
3731 u8 rsv0;
3732 __le32 outband_freq;
3733 u8 txpower_drop;
3734 u8 ap_bw;
3735 u8 ap_center_ch;
3736 u8 rsv1[53];
3737 } __packed req = {
3738 .tag = cpu_to_le16(tag),
3739 .len = cpu_to_le16(sizeof(req) - 4),
3740 .control_ch = chandef->chan->hw_value,
3741 .center_ch = ieee80211_frequency_to_channel(freq1),
3742 .bw = mt76_connac_chan_bw(chandef),
3743 .tx_path_num = hweight16(phy->mt76->chainmask),
3744 .rx_path = mt7996_rx_chainmask(phy) >> dev->chainshift[band_idx],
3745 .band_idx = band_idx,
3746 .channel_band = ch_band[chandef->chan->band],
3747 };
3748
3749 if (phy->mt76->hw->conf.flags & IEEE80211_CONF_MONITOR)
3750 req.switch_reason = CH_SWITCH_NORMAL;
3751 else if (phy->mt76->offchannel ||
3752 phy->mt76->hw->conf.flags & IEEE80211_CONF_IDLE)
3753 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD;
3754 else if (!cfg80211_reg_can_beacon(phy->mt76->hw->wiphy, chandef,
3755 NL80211_IFTYPE_AP))
3756 req.switch_reason = CH_SWITCH_DFS;
3757 else
3758 req.switch_reason = CH_SWITCH_NORMAL;
3759
3760 if (tag == UNI_CHANNEL_SWITCH)
3761 req.rx_path = hweight8(req.rx_path);
3762
3763 if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
3764 int freq2 = chandef->center_freq2;
3765
3766 req.center_ch2 = ieee80211_frequency_to_channel(freq2);
3767 }
3768
3769 return mt76_mcu_send_msg(&dev->mt76, MCU_WMWA_UNI_CMD(CHANNEL_SWITCH),
3770 &req, sizeof(req), true);
3771 }
3772
3773 static int mt7996_mcu_set_eeprom_flash(struct mt7996_dev *dev)
3774 {
3775 #define MAX_PAGE_IDX_MASK GENMASK(7, 5)
3776 #define PAGE_IDX_MASK GENMASK(4, 2)
3777 #define PER_PAGE_SIZE 0x400
3778 struct mt7996_mcu_eeprom req = {
3779 .tag = cpu_to_le16(UNI_EFUSE_BUFFER_MODE),
3780 .buffer_mode = EE_MODE_BUFFER
3781 };
3782 u16 eeprom_size = MT7996_EEPROM_SIZE;
3783 u8 total = DIV_ROUND_UP(eeprom_size, PER_PAGE_SIZE);
3784 u8 *eep = (u8 *)dev->mt76.eeprom.data;
3785 int eep_len, i;
3786
3787 for (i = 0; i < total; i++, eep += eep_len) {
3788 struct sk_buff *skb;
3789 int ret, msg_len;
3790
3791 if (i == total - 1 && !!(eeprom_size % PER_PAGE_SIZE))
3792 eep_len = eeprom_size % PER_PAGE_SIZE;
3793 else
3794 eep_len = PER_PAGE_SIZE;
3795
3796 msg_len = sizeof(req) + eep_len;
3797 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, msg_len);
3798 if (!skb)
3799 return -ENOMEM;
3800
3801 req.len = cpu_to_le16(msg_len - 4);
3802 req.format = FIELD_PREP(MAX_PAGE_IDX_MASK, total - 1) |
3803 FIELD_PREP(PAGE_IDX_MASK, i) | EE_FORMAT_WHOLE;
3804 req.buf_len = cpu_to_le16(eep_len);
3805
3806 skb_put_data(skb, &req, sizeof(req));
3807 skb_put_data(skb, eep, eep_len);
3808
3809 ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
3810 MCU_WM_UNI_CMD(EFUSE_CTRL), true);
3811 if (ret)
3812 return ret;
3813 }
3814
3815 return 0;
3816 }
3817
3818 int mt7996_mcu_set_eeprom(struct mt7996_dev *dev)
3819 {
3820 struct mt7996_mcu_eeprom req = {
3821 .tag = cpu_to_le16(UNI_EFUSE_BUFFER_MODE),
3822 .len = cpu_to_le16(sizeof(req) - 4),
3823 .buffer_mode = EE_MODE_EFUSE,
3824 .format = EE_FORMAT_WHOLE
3825 };
3826
3827 if (dev->flash_mode)
3828 return mt7996_mcu_set_eeprom_flash(dev);
3829
3830 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(EFUSE_CTRL),
3831 &req, sizeof(req), true);
3832 }
3833
3834 int mt7996_mcu_get_eeprom(struct mt7996_dev *dev, u32 offset, u8 *buf, u32 buf_len)
3835 {
3836 struct {
3837 u8 _rsv[4];
3838
3839 __le16 tag;
3840 __le16 len;
3841 __le32 addr;
3842 __le32 valid;
3843 u8 data[16];
3844 } __packed req = {
3845 .tag = cpu_to_le16(UNI_EFUSE_ACCESS),
3846 .len = cpu_to_le16(sizeof(req) - 4),
3847 .addr = cpu_to_le32(round_down(offset,
3848 MT7996_EEPROM_BLOCK_SIZE)),
3849 };
3850 struct sk_buff *skb;
3851 bool valid;
3852 int ret;
3853
3854 ret = mt76_mcu_send_and_get_msg(&dev->mt76,
3855 MCU_WM_UNI_CMD_QUERY(EFUSE_CTRL),
3856 &req, sizeof(req), true, &skb);
3857 if (ret)
3858 return ret;
3859
3860 valid = le32_to_cpu(*(__le32 *)(skb->data + 16));
3861 if (valid) {
3862 u32 addr = le32_to_cpu(*(__le32 *)(skb->data + 12));
3863
3864 if (!buf)
3865 buf = (u8 *)dev->mt76.eeprom.data + addr;
3866 if (!buf_len || buf_len > MT7996_EEPROM_BLOCK_SIZE)
3867 buf_len = MT7996_EEPROM_BLOCK_SIZE;
3868
3869 skb_pull(skb, 48);
3870 memcpy(buf, skb->data, buf_len);
3871 } else {
3872 ret = -EINVAL;
3873 }
3874
3875 dev_kfree_skb(skb);
3876
3877 return ret;
3878 }
3879
3880 int mt7996_mcu_get_eeprom_free_block(struct mt7996_dev *dev, u8 *block_num)
3881 {
3882 struct {
3883 u8 _rsv[4];
3884
3885 __le16 tag;
3886 __le16 len;
3887 u8 num;
3888 u8 version;
3889 u8 die_idx;
3890 u8 _rsv2;
3891 } __packed req = {
3892 .tag = cpu_to_le16(UNI_EFUSE_FREE_BLOCK),
3893 .len = cpu_to_le16(sizeof(req) - 4),
3894 .version = 2,
3895 };
3896 struct sk_buff *skb;
3897 int ret;
3898
3899 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_WM_UNI_CMD_QUERY(EFUSE_CTRL), &req,
3900 sizeof(req), true, &skb);
3901 if (ret)
3902 return ret;
3903
3904 *block_num = *(u8 *)(skb->data + 8);
3905 dev_kfree_skb(skb);
3906
3907 return 0;
3908 }
3909
3910 int mt7996_mcu_get_chip_config(struct mt7996_dev *dev, u32 *cap)
3911 {
3912 #define NIC_CAP 3
3913 #define UNI_EVENT_CHIP_CONFIG_EFUSE_VERSION 0x21
3914 struct {
3915 u8 _rsv[4];
3916
3917 __le16 tag;
3918 __le16 len;
3919 } __packed req = {
3920 .tag = cpu_to_le16(NIC_CAP),
3921 .len = cpu_to_le16(sizeof(req) - 4),
3922 };
3923 struct sk_buff *skb;
3924 u8 *buf;
3925 int ret;
3926
3927 ret = mt76_mcu_send_and_get_msg(&dev->mt76,
3928 MCU_WM_UNI_CMD_QUERY(CHIP_CONFIG), &req,
3929 sizeof(req), true, &skb);
3930 if (ret)
3931 return ret;
3932
3933 /* fixed field */
3934 skb_pull(skb, 4);
3935
3936 buf = skb->data;
3937 while (buf - skb->data < skb->len) {
3938 struct tlv *tlv = (struct tlv *)buf;
3939
3940 switch (le16_to_cpu(tlv->tag)) {
3941 case UNI_EVENT_CHIP_CONFIG_EFUSE_VERSION:
3942 *cap = le32_to_cpu(*(__le32 *)(buf + sizeof(*tlv)));
3943 break;
3944 default:
3945 break;
3946 }
3947
3948 buf += le16_to_cpu(tlv->len);
3949 }
3950
3951 dev_kfree_skb(skb);
3952
3953 return 0;
3954 }
3955
3956 int mt7996_mcu_get_chan_mib_info(struct mt7996_phy *phy, bool chan_switch)
3957 {
3958 enum {
3959 IDX_TX_TIME,
3960 IDX_RX_TIME,
3961 IDX_OBSS_AIRTIME,
3962 IDX_NON_WIFI_TIME,
3963 IDX_NUM
3964 };
3965 struct {
3966 struct {
3967 u8 band;
3968 u8 __rsv[3];
3969 } hdr;
3970 struct {
3971 __le16 tag;
3972 __le16 len;
3973 __le32 offs;
3974 } data[IDX_NUM];
3975 } __packed req = {
3976 .hdr.band = phy->mt76->band_idx,
3977 };
3978 static const u32 offs[] = {
3979 [IDX_TX_TIME] = UNI_MIB_TX_TIME,
3980 [IDX_RX_TIME] = UNI_MIB_RX_TIME,
3981 [IDX_OBSS_AIRTIME] = UNI_MIB_OBSS_AIRTIME,
3982 [IDX_NON_WIFI_TIME] = UNI_MIB_NON_WIFI_TIME,
3983 };
3984 struct mt76_channel_state *state = phy->mt76->chan_state;
3985 struct mt76_channel_state *state_ts = &phy->state_ts;
3986 struct mt7996_dev *dev = phy->dev;
3987 struct mt7996_mcu_mib *res;
3988 struct sk_buff *skb;
3989 int i, ret;
3990
3991 for (i = 0; i < IDX_NUM; i++) {
3992 req.data[i].tag = cpu_to_le16(UNI_CMD_MIB_DATA);
3993 req.data[i].len = cpu_to_le16(sizeof(req.data[i]));
3994 req.data[i].offs = cpu_to_le32(offs[i]);
3995 }
3996
3997 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_WM_UNI_CMD_QUERY(GET_MIB_INFO),
3998 &req, sizeof(req), true, &skb);
3999 if (ret)
4000 return ret;
4001
4002 skb_pull(skb, sizeof(req.hdr));
4003
4004 res = (struct mt7996_mcu_mib *)(skb->data);
4005
4006 if (chan_switch)
4007 goto out;
4008
4009 #define __res_u64(s) le64_to_cpu(res[s].data)
4010 state->cc_tx += __res_u64(IDX_TX_TIME) - state_ts->cc_tx;
4011 state->cc_bss_rx += __res_u64(IDX_RX_TIME) - state_ts->cc_bss_rx;
4012 state->cc_rx += __res_u64(IDX_RX_TIME) +
4013 __res_u64(IDX_OBSS_AIRTIME) -
4014 state_ts->cc_rx;
4015 state->cc_busy += __res_u64(IDX_TX_TIME) +
4016 __res_u64(IDX_RX_TIME) +
4017 __res_u64(IDX_OBSS_AIRTIME) +
4018 __res_u64(IDX_NON_WIFI_TIME) -
4019 state_ts->cc_busy;
4020 out:
4021 state_ts->cc_tx = __res_u64(IDX_TX_TIME);
4022 state_ts->cc_bss_rx = __res_u64(IDX_RX_TIME);
4023 state_ts->cc_rx = __res_u64(IDX_RX_TIME) + __res_u64(IDX_OBSS_AIRTIME);
4024 state_ts->cc_busy = __res_u64(IDX_TX_TIME) +
4025 __res_u64(IDX_RX_TIME) +
4026 __res_u64(IDX_OBSS_AIRTIME) +
4027 __res_u64(IDX_NON_WIFI_TIME);
4028 #undef __res_u64
4029
4030 dev_kfree_skb(skb);
4031
4032 return 0;
4033 }
4034
4035 int mt7996_mcu_get_temperature(struct mt7996_phy *phy)
4036 {
4037 #define TEMPERATURE_QUERY 0
4038 #define GET_TEMPERATURE 0
4039 struct {
4040 u8 _rsv[4];
4041
4042 __le16 tag;
4043 __le16 len;
4044
4045 u8 rsv1;
4046 u8 action;
4047 u8 band_idx;
4048 u8 rsv2;
4049 } req = {
4050 .tag = cpu_to_le16(TEMPERATURE_QUERY),
4051 .len = cpu_to_le16(sizeof(req) - 4),
4052 .action = GET_TEMPERATURE,
4053 .band_idx = phy->mt76->band_idx,
4054 };
4055 struct mt7996_mcu_thermal {
4056 u8 _rsv[4];
4057
4058 __le16 tag;
4059 __le16 len;
4060
4061 __le32 rsv;
4062 __le32 temperature;
4063 } __packed * res;
4064 struct sk_buff *skb;
4065 int ret;
4066 u32 temp;
4067
4068 ret = mt76_mcu_send_and_get_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL),
4069 &req, sizeof(req), true, &skb);
4070 if (ret)
4071 return ret;
4072
4073 res = (void *)skb->data;
4074 temp = le32_to_cpu(res->temperature);
4075 dev_kfree_skb(skb);
4076
4077 return temp;
4078 }
4079
4080 int mt7996_mcu_set_thermal_throttling(struct mt7996_phy *phy, u8 state)
4081 {
4082 struct {
4083 u8 _rsv[4];
4084
4085 __le16 tag;
4086 __le16 len;
4087
4088 struct mt7996_mcu_thermal_ctrl ctrl;
4089 } __packed req = {
4090 .tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_DUTY_CONFIG),
4091 .len = cpu_to_le16(sizeof(req) - 4),
4092 .ctrl = {
4093 .band_idx = phy->mt76->band_idx,
4094 },
4095 };
4096 int level, ret;
4097
4098 /* set duty cycle and level */
4099 for (level = 0; level < 4; level++) {
4100 req.ctrl.duty.duty_level = level;
4101 req.ctrl.duty.duty_cycle = state;
4102 state /= 2;
4103
4104 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL),
4105 &req, sizeof(req), false);
4106 if (ret)
4107 return ret;
4108 }
4109
4110 return 0;
4111 }
4112
4113 int mt7996_mcu_set_thermal_protect(struct mt7996_phy *phy, bool enable)
4114 {
4115 #define SUSTAIN_PERIOD 10
4116 struct {
4117 u8 _rsv[4];
4118
4119 __le16 tag;
4120 __le16 len;
4121
4122 struct mt7996_mcu_thermal_ctrl ctrl;
4123 struct mt7996_mcu_thermal_enable enable;
4124 } __packed req = {
4125 .len = cpu_to_le16(sizeof(req) - 4 - sizeof(req.enable)),
4126 .ctrl = {
4127 .band_idx = phy->mt76->band_idx,
4128 .type.protect_type = 1,
4129 .type.trigger_type = 1,
4130 },
4131 };
4132 int ret;
4133
4134 req.tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_DISABLE);
4135
4136 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL),
4137 &req, sizeof(req) - sizeof(req.enable), false);
4138 if (ret || !enable)
4139 return ret;
4140
4141 /* set high-temperature trigger threshold */
4142 req.tag = cpu_to_le16(UNI_CMD_THERMAL_PROTECT_ENABLE);
4143 req.enable.restore_temp = cpu_to_le32(phy->throttle_temp[0]);
4144 req.enable.trigger_temp = cpu_to_le32(phy->throttle_temp[1]);
4145 req.enable.sustain_time = cpu_to_le16(SUSTAIN_PERIOD);
4146
4147 req.len = cpu_to_le16(sizeof(req) - 4);
4148
4149 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(THERMAL),
4150 &req, sizeof(req), false);
4151 }
4152
4153 int mt7996_mcu_set_ser(struct mt7996_dev *dev, u8 action, u8 val, u8 band)
4154 {
4155 struct {
4156 u8 rsv[4];
4157
4158 __le16 tag;
4159 __le16 len;
4160
4161 union {
4162 struct {
4163 __le32 mask;
4164 } __packed set;
4165
4166 struct {
4167 u8 method;
4168 u8 band;
4169 u8 rsv2[2];
4170 } __packed trigger;
4171 };
4172 } __packed req = {
4173 .tag = cpu_to_le16(action),
4174 .len = cpu_to_le16(sizeof(req) - 4),
4175 };
4176
4177 switch (action) {
4178 case UNI_CMD_SER_SET:
4179 req.set.mask = cpu_to_le32(val);
4180 break;
4181 case UNI_CMD_SER_TRIGGER:
4182 req.trigger.method = val;
4183 req.trigger.band = band;
4184 break;
4185 default:
4186 return -EINVAL;
4187 }
4188
4189 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SER),
4190 &req, sizeof(req), false);
4191 }
4192
4193 int mt7996_mcu_set_txbf(struct mt7996_dev *dev, u8 action)
4194 {
4195 #define MT7996_BF_MAX_SIZE sizeof(union bf_tag_tlv)
4196 #define BF_PROCESSING 4
4197 struct uni_header hdr;
4198 struct sk_buff *skb;
4199 struct tlv *tlv;
4200 int len = sizeof(hdr) + MT7996_BF_MAX_SIZE;
4201
4202 memset(&hdr, 0, sizeof(hdr));
4203
4204 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
4205 if (!skb)
4206 return -ENOMEM;
4207
4208 skb_put_data(skb, &hdr, sizeof(hdr));
4209
4210 switch (action) {
4211 case BF_SOUNDING_ON: {
4212 struct bf_sounding_on *req_snd_on;
4213
4214 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_snd_on));
4215 req_snd_on = (struct bf_sounding_on *)tlv;
4216 req_snd_on->snd_mode = BF_PROCESSING;
4217 break;
4218 }
4219 case BF_HW_EN_UPDATE: {
4220 struct bf_hw_en_status_update *req_hw_en;
4221
4222 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_hw_en));
4223 req_hw_en = (struct bf_hw_en_status_update *)tlv;
4224 req_hw_en->ebf = true;
4225 req_hw_en->ibf = dev->ibf;
4226 break;
4227 }
4228 case BF_MOD_EN_CTRL: {
4229 struct bf_mod_en_ctrl *req_mod_en;
4230
4231 tlv = mt7996_mcu_add_uni_tlv(skb, action, sizeof(*req_mod_en));
4232 req_mod_en = (struct bf_mod_en_ctrl *)tlv;
4233 req_mod_en->bf_num = mt7996_band_valid(dev, MT_BAND2) ? 3 : 2;
4234 req_mod_en->bf_bitmap = mt7996_band_valid(dev, MT_BAND2) ?
4235 GENMASK(2, 0) : GENMASK(1, 0);
4236 break;
4237 }
4238 default:
4239 return -EINVAL;
4240 }
4241
4242 return mt76_mcu_skb_send_msg(&dev->mt76, skb, MCU_WM_UNI_CMD(BF), true);
4243 }
4244
4245 static int
4246 mt7996_mcu_enable_obss_spr(struct mt7996_phy *phy, u16 action, u8 val)
4247 {
4248 struct mt7996_dev *dev = phy->dev;
4249 struct {
4250 u8 band_idx;
4251 u8 __rsv[3];
4252
4253 __le16 tag;
4254 __le16 len;
4255
4256 __le32 val;
4257 } __packed req = {
4258 .band_idx = phy->mt76->band_idx,
4259 .tag = cpu_to_le16(action),
4260 .len = cpu_to_le16(sizeof(req) - 4),
4261 .val = cpu_to_le32(val),
4262 };
4263
4264 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR),
4265 &req, sizeof(req), true);
4266 }
4267
4268 static int
4269 mt7996_mcu_set_obss_spr_pd(struct mt7996_phy *phy,
4270 struct ieee80211_he_obss_pd *he_obss_pd)
4271 {
4272 struct mt7996_dev *dev = phy->dev;
4273 u8 max_th = 82, non_srg_max_th = 62;
4274 struct {
4275 u8 band_idx;
4276 u8 __rsv[3];
4277
4278 __le16 tag;
4279 __le16 len;
4280
4281 u8 pd_th_non_srg;
4282 u8 pd_th_srg;
4283 u8 period_offs;
4284 u8 rcpi_src;
4285 __le16 obss_pd_min;
4286 __le16 obss_pd_min_srg;
4287 u8 resp_txpwr_mode;
4288 u8 txpwr_restrict_mode;
4289 u8 txpwr_ref;
4290 u8 __rsv2[3];
4291 } __packed req = {
4292 .band_idx = phy->mt76->band_idx,
4293 .tag = cpu_to_le16(UNI_CMD_SR_SET_PARAM),
4294 .len = cpu_to_le16(sizeof(req) - 4),
4295 .obss_pd_min = cpu_to_le16(max_th),
4296 .obss_pd_min_srg = cpu_to_le16(max_th),
4297 .txpwr_restrict_mode = 2,
4298 .txpwr_ref = 21
4299 };
4300 int ret;
4301
4302 /* disable firmware dynamical PD asjustment */
4303 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_DPD, false);
4304 if (ret)
4305 return ret;
4306
4307 if (he_obss_pd->sr_ctrl &
4308 IEEE80211_HE_SPR_NON_SRG_OBSS_PD_SR_DISALLOWED)
4309 req.pd_th_non_srg = max_th;
4310 else if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_NON_SRG_OFFSET_PRESENT)
4311 req.pd_th_non_srg = max_th - he_obss_pd->non_srg_max_offset;
4312 else
4313 req.pd_th_non_srg = non_srg_max_th;
4314
4315 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_SRG_INFORMATION_PRESENT)
4316 req.pd_th_srg = max_th - he_obss_pd->max_offset;
4317
4318 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR),
4319 &req, sizeof(req), true);
4320 }
4321
4322 static int
4323 mt7996_mcu_set_obss_spr_siga(struct mt7996_phy *phy,
4324 struct mt7996_vif_link *link,
4325 struct ieee80211_he_obss_pd *he_obss_pd)
4326 {
4327 struct mt7996_dev *dev = phy->dev;
4328 u8 omac = link->mt76.omac_idx;
4329 struct {
4330 u8 band_idx;
4331 u8 __rsv[3];
4332
4333 __le16 tag;
4334 __le16 len;
4335
4336 u8 omac;
4337 u8 __rsv2[3];
4338 u8 flag[20];
4339 } __packed req = {
4340 .band_idx = phy->mt76->band_idx,
4341 .tag = cpu_to_le16(UNI_CMD_SR_SET_SIGA),
4342 .len = cpu_to_le16(sizeof(req) - 4),
4343 .omac = omac > HW_BSSID_MAX ? omac - 12 : omac,
4344 };
4345 int ret;
4346
4347 if (he_obss_pd->sr_ctrl & IEEE80211_HE_SPR_HESIGA_SR_VAL15_ALLOWED)
4348 req.flag[req.omac] = 0xf;
4349 else
4350 return 0;
4351
4352 /* switch to normal AP mode */
4353 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_MODE, 0);
4354 if (ret)
4355 return ret;
4356
4357 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR),
4358 &req, sizeof(req), true);
4359 }
4360
4361 static int
4362 mt7996_mcu_set_obss_spr_bitmap(struct mt7996_phy *phy,
4363 struct ieee80211_he_obss_pd *he_obss_pd)
4364 {
4365 struct mt7996_dev *dev = phy->dev;
4366 struct {
4367 u8 band_idx;
4368 u8 __rsv[3];
4369
4370 __le16 tag;
4371 __le16 len;
4372
4373 __le32 color_l[2];
4374 __le32 color_h[2];
4375 __le32 bssid_l[2];
4376 __le32 bssid_h[2];
4377 } __packed req = {
4378 .band_idx = phy->mt76->band_idx,
4379 .tag = cpu_to_le16(UNI_CMD_SR_SET_SRG_BITMAP),
4380 .len = cpu_to_le16(sizeof(req) - 4),
4381 };
4382 u32 bitmap;
4383
4384 memcpy(&bitmap, he_obss_pd->bss_color_bitmap, sizeof(bitmap));
4385 req.color_l[req.band_idx] = cpu_to_le32(bitmap);
4386
4387 memcpy(&bitmap, he_obss_pd->bss_color_bitmap + 4, sizeof(bitmap));
4388 req.color_h[req.band_idx] = cpu_to_le32(bitmap);
4389
4390 memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap, sizeof(bitmap));
4391 req.bssid_l[req.band_idx] = cpu_to_le32(bitmap);
4392
4393 memcpy(&bitmap, he_obss_pd->partial_bssid_bitmap + 4, sizeof(bitmap));
4394 req.bssid_h[req.band_idx] = cpu_to_le32(bitmap);
4395
4396 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SR), &req,
4397 sizeof(req), true);
4398 }
4399
4400 int mt7996_mcu_add_obss_spr(struct mt7996_phy *phy,
4401 struct mt7996_vif_link *link,
4402 struct ieee80211_he_obss_pd *he_obss_pd)
4403 {
4404 int ret;
4405
4406 /* enable firmware scene detection algorithms */
4407 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_SD,
4408 sr_scene_detect);
4409 if (ret)
4410 return ret;
4411
4412 /* firmware dynamically adjusts PD threshold so skip manual control */
4413 if (sr_scene_detect && !he_obss_pd->enable)
4414 return 0;
4415
4416 /* enable spatial reuse */
4417 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE,
4418 he_obss_pd->enable);
4419 if (ret)
4420 return ret;
4421
4422 if (sr_scene_detect || !he_obss_pd->enable)
4423 return 0;
4424
4425 ret = mt7996_mcu_enable_obss_spr(phy, UNI_CMD_SR_ENABLE_TX, true);
4426 if (ret)
4427 return ret;
4428
4429 /* set SRG/non-SRG OBSS PD threshold */
4430 ret = mt7996_mcu_set_obss_spr_pd(phy, he_obss_pd);
4431 if (ret)
4432 return ret;
4433
4434 /* Set SR prohibit */
4435 ret = mt7996_mcu_set_obss_spr_siga(phy, link, he_obss_pd);
4436 if (ret)
4437 return ret;
4438
4439 /* set SRG BSS color/BSSID bitmap */
4440 return mt7996_mcu_set_obss_spr_bitmap(phy, he_obss_pd);
4441 }
4442
4443 int mt7996_mcu_update_bss_color(struct mt7996_dev *dev,
4444 struct mt76_vif_link *mlink,
4445 struct cfg80211_he_bss_color *he_bss_color)
4446 {
4447 int len = sizeof(struct bss_req_hdr) + sizeof(struct bss_color_tlv);
4448 struct bss_color_tlv *bss_color;
4449 struct sk_buff *skb;
4450 struct tlv *tlv;
4451
4452 skb = __mt7996_mcu_alloc_bss_req(&dev->mt76, mlink, len);
4453 if (IS_ERR(skb))
4454 return PTR_ERR(skb);
4455
4456 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BSS_COLOR,
4457 sizeof(*bss_color));
4458 bss_color = (struct bss_color_tlv *)tlv;
4459 bss_color->enable = he_bss_color->enabled;
4460 bss_color->color = he_bss_color->color;
4461
4462 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
4463 MCU_WMWA_UNI_CMD(BSS_INFO_UPDATE), true);
4464 }
4465
4466 #define TWT_AGRT_TRIGGER BIT(0)
4467 #define TWT_AGRT_ANNOUNCE BIT(1)
4468 #define TWT_AGRT_PROTECT BIT(2)
4469
4470 int mt7996_mcu_twt_agrt_update(struct mt7996_dev *dev,
4471 struct mt7996_vif_link *link,
4472 struct mt7996_twt_flow *flow,
4473 int cmd)
4474 {
4475 struct {
4476 /* fixed field */
4477 u8 bss;
4478 u8 _rsv[3];
4479
4480 __le16 tag;
4481 __le16 len;
4482 u8 tbl_idx;
4483 u8 cmd;
4484 u8 own_mac_idx;
4485 u8 flowid; /* 0xff for group id */
4486 __le16 peer_id; /* specify the peer_id (msb=0)
4487 * or group_id (msb=1)
4488 */
4489 u8 duration; /* 256 us */
4490 u8 bss_idx;
4491 __le64 start_tsf;
4492 __le16 mantissa;
4493 u8 exponent;
4494 u8 is_ap;
4495 u8 agrt_params;
4496 u8 __rsv2[23];
4497 } __packed req = {
4498 .tag = cpu_to_le16(UNI_CMD_TWT_ARGT_UPDATE),
4499 .len = cpu_to_le16(sizeof(req) - 4),
4500 .tbl_idx = flow->table_id,
4501 .cmd = cmd,
4502 .own_mac_idx = link->mt76.omac_idx,
4503 .flowid = flow->id,
4504 .peer_id = cpu_to_le16(flow->wcid),
4505 .duration = flow->duration,
4506 .bss = link->mt76.idx,
4507 .bss_idx = link->mt76.idx,
4508 .start_tsf = cpu_to_le64(flow->tsf),
4509 .mantissa = flow->mantissa,
4510 .exponent = flow->exp,
4511 .is_ap = true,
4512 };
4513
4514 if (flow->protection)
4515 req.agrt_params |= TWT_AGRT_PROTECT;
4516 if (!flow->flowtype)
4517 req.agrt_params |= TWT_AGRT_ANNOUNCE;
4518 if (flow->trigger)
4519 req.agrt_params |= TWT_AGRT_TRIGGER;
4520
4521 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(TWT),
4522 &req, sizeof(req), true);
4523 }
4524
4525 int mt7996_mcu_set_rts_thresh(struct mt7996_phy *phy, u32 val)
4526 {
4527 struct {
4528 u8 band_idx;
4529 u8 _rsv[3];
4530
4531 __le16 tag;
4532 __le16 len;
4533 __le32 len_thresh;
4534 __le32 pkt_thresh;
4535 } __packed req = {
4536 .band_idx = phy->mt76->band_idx,
4537 .tag = cpu_to_le16(UNI_BAND_CONFIG_RTS_THRESHOLD),
4538 .len = cpu_to_le16(sizeof(req) - 4),
4539 .len_thresh = cpu_to_le32(val),
4540 .pkt_thresh = cpu_to_le32(0x2),
4541 };
4542
4543 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG),
4544 &req, sizeof(req), true);
4545 }
4546
4547 int mt7996_mcu_set_radio_en(struct mt7996_phy *phy, bool enable)
4548 {
4549 struct {
4550 u8 band_idx;
4551 u8 _rsv[3];
4552
4553 __le16 tag;
4554 __le16 len;
4555 u8 enable;
4556 u8 _rsv2[3];
4557 } __packed req = {
4558 .band_idx = phy->mt76->band_idx,
4559 .tag = cpu_to_le16(UNI_BAND_CONFIG_RADIO_ENABLE),
4560 .len = cpu_to_le16(sizeof(req) - 4),
4561 .enable = enable,
4562 };
4563
4564 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG),
4565 &req, sizeof(req), true);
4566 }
4567
4568 int mt7996_mcu_rdd_resume_tx(struct mt7996_phy *phy)
4569 {
4570 struct {
4571 u8 band_idx;
4572 u8 _rsv[3];
4573
4574 __le16 tag;
4575 __le16 len;
4576 u8 mac_enable;
4577 u8 _rsv2[3];
4578 } __packed req = {
4579 .band_idx = phy->mt76->band_idx,
4580 .tag = cpu_to_le16(UNI_BAND_CONFIG_MAC_ENABLE_CTRL),
4581 .len = cpu_to_le16(sizeof(req) - 4),
4582 .mac_enable = 2,
4583 };
4584 int ret;
4585
4586 if (!phy->rdd_tx_paused)
4587 return 0;
4588
4589 ret = mt76_mcu_send_msg(&phy->dev->mt76, MCU_WM_UNI_CMD(BAND_CONFIG),
4590 &req, sizeof(req), true);
4591 if (!ret)
4592 phy->rdd_tx_paused = false;
4593
4594 return ret;
4595 }
4596
4597 int mt7996_mcu_rdd_cmd(struct mt7996_dev *dev, int cmd, u8 rdd_idx, u8 val)
4598 {
4599 struct {
4600 u8 _rsv[4];
4601
4602 __le16 tag;
4603 __le16 len;
4604
4605 u8 ctrl;
4606 u8 rdd_idx;
4607 u8 rdd_rx_sel;
4608 u8 val;
4609 u8 rsv[4];
4610 } __packed req = {
4611 .tag = cpu_to_le16(UNI_RDD_CTRL_PARM),
4612 .len = cpu_to_le16(sizeof(req) - 4),
4613 .ctrl = cmd,
4614 .rdd_idx = rdd_idx,
4615 .val = val,
4616 };
4617
4618 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RDD_CTRL),
4619 &req, sizeof(req), true);
4620 }
4621
4622 int mt7996_mcu_wtbl_update_hdr_trans(struct mt7996_dev *dev,
4623 struct ieee80211_vif *vif,
4624 struct mt7996_vif_link *link,
4625 struct mt7996_sta_link *msta_link)
4626 {
4627 struct sk_buff *skb;
4628
4629 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &link->mt76,
4630 &msta_link->wcid,
4631 MT7996_STA_UPDATE_MAX_SIZE);
4632 if (IS_ERR(skb))
4633 return PTR_ERR(skb);
4634
4635 /* starec hdr trans */
4636 mt7996_mcu_sta_hdr_trans_tlv(dev, skb, vif, &msta_link->wcid);
4637 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
4638 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
4639 }
4640
4641 int mt7996_mcu_set_fixed_rate_table(struct mt7996_phy *phy, u8 table_idx,
4642 u16 rate_idx, bool beacon)
4643 {
4644 #define UNI_FIXED_RATE_TABLE_SET 0
4645 #define SPE_IXD_SELECT_TXD 0
4646 #define SPE_IXD_SELECT_BMC_WTBL 1
4647 struct mt7996_dev *dev = phy->dev;
4648 struct fixed_rate_table_ctrl req = {
4649 .tag = cpu_to_le16(UNI_FIXED_RATE_TABLE_SET),
4650 .len = cpu_to_le16(sizeof(req) - 4),
4651 .table_idx = table_idx,
4652 .rate_idx = cpu_to_le16(rate_idx),
4653 .gi = 1,
4654 .he_ltf = 1,
4655 };
4656 u8 band_idx = phy->mt76->band_idx;
4657
4658 if (beacon) {
4659 req.spe_idx_sel = SPE_IXD_SELECT_TXD;
4660 req.spe_idx = 24 + band_idx;
4661 phy->beacon_rate = rate_idx;
4662 } else {
4663 req.spe_idx_sel = SPE_IXD_SELECT_BMC_WTBL;
4664 }
4665
4666 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(FIXED_RATE_TABLE),
4667 &req, sizeof(req), false);
4668 }
4669
4670 int mt7996_mcu_rf_regval(struct mt7996_dev *dev, u32 regidx, u32 *val, bool set)
4671 {
4672 struct {
4673 u8 __rsv1[4];
4674
4675 __le16 tag;
4676 __le16 len;
4677 __le16 idx;
4678 u8 __rsv2[2];
4679 __le32 ofs;
4680 __le32 data;
4681 } __packed *res, req = {
4682 .tag = cpu_to_le16(UNI_CMD_ACCESS_RF_REG_BASIC),
4683 .len = cpu_to_le16(sizeof(req) - 4),
4684
4685 .idx = cpu_to_le16(u32_get_bits(regidx, GENMASK(31, 24))),
4686 .ofs = cpu_to_le32(u32_get_bits(regidx, GENMASK(23, 0))),
4687 .data = set ? cpu_to_le32(*val) : 0,
4688 };
4689 struct sk_buff *skb;
4690 int ret;
4691
4692 if (set)
4693 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(REG_ACCESS),
4694 &req, sizeof(req), true);
4695
4696 ret = mt76_mcu_send_and_get_msg(&dev->mt76,
4697 MCU_WM_UNI_CMD_QUERY(REG_ACCESS),
4698 &req, sizeof(req), true, &skb);
4699 if (ret)
4700 return ret;
4701
4702 res = (void *)skb->data;
4703 *val = le32_to_cpu(res->data);
4704 dev_kfree_skb(skb);
4705
4706 return 0;
4707 }
4708
4709 int mt7996_mcu_trigger_assert(struct mt7996_dev *dev)
4710 {
4711 struct {
4712 __le16 tag;
4713 __le16 len;
4714 u8 enable;
4715 u8 rsv[3];
4716 } __packed req = {
4717 .len = cpu_to_le16(sizeof(req) - 4),
4718 .enable = true,
4719 };
4720
4721 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(ASSERT_DUMP),
4722 &req, sizeof(req), false);
4723 }
4724
4725 int mt7996_mcu_set_rro(struct mt7996_dev *dev, u16 tag, u16 val)
4726 {
4727 struct {
4728 u8 __rsv1[4];
4729 __le16 tag;
4730 __le16 len;
4731 union {
4732 struct {
4733 u8 type;
4734 u8 __rsv2[3];
4735 } __packed platform_type;
4736 struct {
4737 u8 type;
4738 u8 dest;
4739 u8 __rsv2[2];
4740 } __packed bypass_mode;
4741 struct {
4742 u8 path;
4743 u8 __rsv2[3];
4744 } __packed txfree_path;
4745 struct {
4746 __le16 flush_one;
4747 __le16 flush_all;
4748 u8 __rsv2[4];
4749 } __packed timeout;
4750 };
4751 } __packed req = {
4752 .tag = cpu_to_le16(tag),
4753 .len = cpu_to_le16(sizeof(req) - 4),
4754 };
4755
4756 switch (tag) {
4757 case UNI_RRO_SET_PLATFORM_TYPE:
4758 req.platform_type.type = val;
4759 break;
4760 case UNI_RRO_SET_BYPASS_MODE:
4761 req.bypass_mode.type = val;
4762 break;
4763 case UNI_RRO_SET_TXFREE_PATH:
4764 req.txfree_path.path = val;
4765 break;
4766 case UNI_RRO_SET_FLUSH_TIMEOUT:
4767 req.timeout.flush_one = cpu_to_le16(val);
4768 req.timeout.flush_all = cpu_to_le16(2 * val);
4769 break;
4770 default:
4771 return -EINVAL;
4772 }
4773
4774 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RRO), &req,
4775 sizeof(req), true);
4776 }
4777
4778 int mt7996_mcu_get_all_sta_info(struct mt7996_phy *phy, u16 tag)
4779 {
4780 struct mt7996_dev *dev = phy->dev;
4781 struct {
4782 u8 _rsv[4];
4783
4784 __le16 tag;
4785 __le16 len;
4786 } __packed req = {
4787 .tag = cpu_to_le16(tag),
4788 .len = cpu_to_le16(sizeof(req) - 4),
4789 };
4790
4791 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(ALL_STA_INFO),
4792 &req, sizeof(req), false);
4793 }
4794
4795 int mt7996_mcu_wed_rro_reset_sessions(struct mt7996_dev *dev, u16 id)
4796 {
4797 struct {
4798 u8 __rsv[4];
4799
4800 __le16 tag;
4801 __le16 len;
4802 __le16 session_id;
4803 u8 pad[4];
4804 } __packed req = {
4805 .tag = cpu_to_le16(UNI_RRO_DEL_BA_SESSION),
4806 .len = cpu_to_le16(sizeof(req) - 4),
4807 .session_id = cpu_to_le16(id),
4808 };
4809
4810 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(RRO), &req,
4811 sizeof(req), true);
4812 }
4813
4814 int mt7996_mcu_set_sniffer_mode(struct mt7996_phy *phy, bool enabled)
4815 {
4816 struct mt7996_dev *dev = phy->dev;
4817 struct {
4818 u8 band_idx;
4819 u8 _rsv[3];
4820 __le16 tag;
4821 __le16 len;
4822 u8 enable;
4823 u8 _pad[3];
4824 } __packed req = {
4825 .band_idx = phy->mt76->band_idx,
4826 .tag = 0,
4827 .len = cpu_to_le16(sizeof(req) - 4),
4828 .enable = enabled,
4829 };
4830
4831 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(SNIFFER), &req,
4832 sizeof(req), true);
4833 }
4834
4835 int mt7996_mcu_set_txpower_sku(struct mt7996_phy *phy)
4836 {
4837 #define TX_POWER_LIMIT_TABLE_RATE 0
4838 struct mt7996_dev *dev = phy->dev;
4839 struct mt76_phy *mphy = phy->mt76;
4840 struct tx_power_limit_table_ctrl {
4841 u8 __rsv1[4];
4842
4843 __le16 tag;
4844 __le16 len;
4845 u8 power_ctrl_id;
4846 u8 power_limit_type;
4847 u8 band_idx;
4848 } __packed req = {
4849 .tag = cpu_to_le16(UNI_TXPOWER_POWER_LIMIT_TABLE_CTRL),
4850 .len = cpu_to_le16(sizeof(req) + MT7996_SKU_PATH_NUM - 4),
4851 .power_ctrl_id = UNI_TXPOWER_POWER_LIMIT_TABLE_CTRL,
4852 .power_limit_type = TX_POWER_LIMIT_TABLE_RATE,
4853 .band_idx = phy->mt76->band_idx,
4854 };
4855 struct mt76_power_limits la = {};
4856 struct sk_buff *skb;
4857 int i, tx_power;
4858
4859 tx_power = mt76_get_power_bound(mphy, phy->txpower);
4860 tx_power = mt76_get_rate_power_limits(mphy, mphy->chandef.chan,
4861 &la, tx_power);
4862 mphy->txpower_cur = tx_power;
4863
4864 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL,
4865 sizeof(req) + MT7996_SKU_PATH_NUM);
4866 if (!skb)
4867 return -ENOMEM;
4868
4869 skb_put_data(skb, &req, sizeof(req));
4870 /* cck and ofdm */
4871 skb_put_data(skb, &la.cck, sizeof(la.cck));
4872 skb_put_data(skb, &la.ofdm, sizeof(la.ofdm));
4873 /* ht20 */
4874 skb_put_data(skb, &la.mcs[0], 8);
4875 /* ht40 */
4876 skb_put_data(skb, &la.mcs[1], 9);
4877
4878 /* vht */
4879 for (i = 0; i < 4; i++) {
4880 skb_put_data(skb, &la.mcs[i], sizeof(la.mcs[i]));
4881 skb_put_zero(skb, 2); /* padding */
4882 }
4883
4884 /* he */
4885 skb_put_data(skb, &la.ru[0], sizeof(la.ru));
4886 /* eht */
4887 skb_put_data(skb, &la.eht[0], sizeof(la.eht));
4888
4889 /* padding */
4890 skb_put_zero(skb, MT7996_SKU_PATH_NUM - MT7996_SKU_RATE_NUM);
4891
4892 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
4893 MCU_WM_UNI_CMD(TXPOWER), true);
4894 }
4895
4896 int mt7996_mcu_cp_support(struct mt7996_dev *dev, u8 mode)
4897 {
4898 __le32 cp_mode;
4899
4900 if (mode < mt76_connac_lmac_mapping(IEEE80211_AC_BE) ||
4901 mode > mt76_connac_lmac_mapping(IEEE80211_AC_VO))
4902 return -EINVAL;
4903
4904 if (!mt7996_has_wa(dev)) {
4905 struct {
4906 u8 _rsv[4];
4907
4908 __le16 tag;
4909 __le16 len;
4910 u8 cp_mode;
4911 u8 rsv[3];
4912 } __packed req = {
4913 .tag = cpu_to_le16(UNI_CMD_SDO_CP_MODE),
4914 .len = cpu_to_le16(sizeof(req) - 4),
4915 .cp_mode = mode,
4916 };
4917
4918 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_UNI_CMD(SDO),
4919 &req, sizeof(req), false);
4920 }
4921
4922 cp_mode = cpu_to_le32(mode);
4923
4924 return mt76_mcu_send_msg(&dev->mt76, MCU_WA_EXT_CMD(CP_SUPPORT),
4925 &cp_mode, sizeof(cp_mode), true);
4926 }