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