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