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