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