1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2023 MediaTek Inc. */
3
4 #include <linux/fs.h>
5 #include <linux/firmware.h>
6 #include "mt7925.h"
7 #include "mcu.h"
8 #include "mac.h"
9
10 #define MT_STA_BFER BIT(0)
11 #define MT_STA_BFEE BIT(1)
12
13 static bool mt7925_disable_clc;
14 module_param_named(disable_clc, mt7925_disable_clc, bool, 0644);
15 MODULE_PARM_DESC(disable_clc, "disable CLC support");
16
mt7925_mcu_parse_response(struct mt76_dev * mdev,int cmd,struct sk_buff * skb,int seq)17 int mt7925_mcu_parse_response(struct mt76_dev *mdev, int cmd,
18 struct sk_buff *skb, int seq)
19 {
20 int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
21 struct mt7925_mcu_rxd *rxd;
22 int ret = 0;
23
24 if (!skb) {
25 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n", cmd, seq);
26 mt792x_reset(mdev);
27
28 return -ETIMEDOUT;
29 }
30
31 rxd = (struct mt7925_mcu_rxd *)skb->data;
32 if (seq != rxd->seq)
33 return -EAGAIN;
34
35 if (cmd == MCU_CMD(PATCH_SEM_CONTROL) ||
36 cmd == MCU_CMD(PATCH_FINISH_REQ)) {
37 skb_pull(skb, sizeof(*rxd) - 4);
38 ret = *skb->data;
39 } else if (cmd == MCU_UNI_CMD(DEV_INFO_UPDATE) ||
40 cmd == MCU_UNI_CMD(BSS_INFO_UPDATE) ||
41 cmd == MCU_UNI_CMD(STA_REC_UPDATE) ||
42 cmd == MCU_UNI_CMD(HIF_CTRL) ||
43 cmd == MCU_UNI_CMD(OFFLOAD) ||
44 cmd == MCU_UNI_CMD(SUSPEND)) {
45 struct mt7925_mcu_uni_event *event;
46
47 skb_pull(skb, sizeof(*rxd));
48 event = (struct mt7925_mcu_uni_event *)skb->data;
49 ret = le32_to_cpu(event->status);
50 /* skip invalid event */
51 if (mcu_cmd != event->cid)
52 ret = -EAGAIN;
53 } else {
54 skb_pull(skb, sizeof(*rxd));
55 }
56
57 return ret;
58 }
59 EXPORT_SYMBOL_GPL(mt7925_mcu_parse_response);
60
mt7925_mcu_regval(struct mt792x_dev * dev,u32 regidx,u32 * val,bool set)61 int mt7925_mcu_regval(struct mt792x_dev *dev, u32 regidx, u32 *val, bool set)
62 {
63 #define MT_RF_REG_HDR GENMASK(31, 24)
64 #define MT_RF_REG_ANT GENMASK(23, 16)
65 #define RF_REG_PREFIX 0x99
66 struct {
67 u8 __rsv[4];
68 union {
69 struct uni_cmd_access_reg_basic {
70 __le16 tag;
71 __le16 len;
72 __le32 idx;
73 __le32 data;
74 } __packed reg;
75 struct uni_cmd_access_rf_reg_basic {
76 __le16 tag;
77 __le16 len;
78 __le16 ant;
79 u8 __rsv[2];
80 __le32 idx;
81 __le32 data;
82 } __packed rf_reg;
83 };
84 } __packed * res, req;
85 struct sk_buff *skb;
86 int ret;
87
88 if (u32_get_bits(regidx, MT_RF_REG_HDR) == RF_REG_PREFIX) {
89 req.rf_reg.tag = cpu_to_le16(UNI_CMD_ACCESS_RF_REG_BASIC);
90 req.rf_reg.len = cpu_to_le16(sizeof(req.rf_reg));
91 req.rf_reg.ant = cpu_to_le16(u32_get_bits(regidx, MT_RF_REG_ANT));
92 req.rf_reg.idx = cpu_to_le32(regidx);
93 req.rf_reg.data = set ? cpu_to_le32(*val) : 0;
94 } else {
95 req.reg.tag = cpu_to_le16(UNI_CMD_ACCESS_REG_BASIC);
96 req.reg.len = cpu_to_le16(sizeof(req.reg));
97 req.reg.idx = cpu_to_le32(regidx);
98 req.reg.data = set ? cpu_to_le32(*val) : 0;
99 }
100
101 if (set)
102 return mt76_mcu_send_msg(&dev->mt76, MCU_WM_UNI_CMD(REG_ACCESS),
103 &req, sizeof(req), true);
104
105 ret = mt76_mcu_send_and_get_msg(&dev->mt76,
106 MCU_WM_UNI_CMD_QUERY(REG_ACCESS),
107 &req, sizeof(req), true, &skb);
108 if (ret)
109 return ret;
110
111 res = (void *)skb->data;
112 if (u32_get_bits(regidx, MT_RF_REG_HDR) == RF_REG_PREFIX)
113 *val = le32_to_cpu(res->rf_reg.data);
114 else
115 *val = le32_to_cpu(res->reg.data);
116
117 dev_kfree_skb(skb);
118
119 return 0;
120 }
121 EXPORT_SYMBOL_GPL(mt7925_mcu_regval);
122
mt7925_mcu_update_arp_filter(struct mt76_dev * dev,struct ieee80211_bss_conf * link_conf)123 int mt7925_mcu_update_arp_filter(struct mt76_dev *dev,
124 struct ieee80211_bss_conf *link_conf)
125 {
126 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
127 struct ieee80211_vif *mvif = link_conf->vif;
128 struct sk_buff *skb;
129 int i, len = min_t(int, mvif->cfg.arp_addr_cnt,
130 IEEE80211_BSS_ARP_ADDR_LIST_LEN);
131 struct {
132 struct {
133 u8 bss_idx;
134 u8 pad[3];
135 } __packed hdr;
136 struct mt7925_arpns_tlv arp;
137 } req = {
138 .hdr = {
139 .bss_idx = mconf->mt76.idx,
140 },
141 .arp = {
142 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ARP),
143 .len = cpu_to_le16(sizeof(req) - 4 + len * 2 * sizeof(__be32)),
144 .ips_num = len,
145 .enable = true,
146 },
147 };
148
149 skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(req) + len * 2 * sizeof(__be32));
150 if (!skb)
151 return -ENOMEM;
152
153 skb_put_data(skb, &req, sizeof(req));
154 for (i = 0; i < len; i++) {
155 skb_put_data(skb, &mvif->cfg.arp_addr_list[i], sizeof(__be32));
156 skb_put_zero(skb, sizeof(__be32));
157 }
158
159 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(OFFLOAD), true);
160 }
161
162 #ifdef CONFIG_PM
163 static int
mt7925_connac_mcu_set_wow_ctrl(struct mt76_phy * phy,struct ieee80211_vif * vif,bool suspend,struct cfg80211_wowlan * wowlan)164 mt7925_connac_mcu_set_wow_ctrl(struct mt76_phy *phy, struct ieee80211_vif *vif,
165 bool suspend, struct cfg80211_wowlan *wowlan)
166 {
167 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
168 struct mt76_dev *dev = phy->dev;
169 struct {
170 struct {
171 u8 bss_idx;
172 u8 pad[3];
173 } __packed hdr;
174 struct mt76_connac_wow_ctrl_tlv wow_ctrl_tlv;
175 struct mt76_connac_wow_gpio_param_tlv gpio_tlv;
176 } req = {
177 .hdr = {
178 .bss_idx = mvif->idx,
179 },
180 .wow_ctrl_tlv = {
181 .tag = cpu_to_le16(UNI_SUSPEND_WOW_CTRL),
182 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_ctrl_tlv)),
183 .cmd = suspend ? 1 : 2,
184 },
185 .gpio_tlv = {
186 .tag = cpu_to_le16(UNI_SUSPEND_WOW_GPIO_PARAM),
187 .len = cpu_to_le16(sizeof(struct mt76_connac_wow_gpio_param_tlv)),
188 .gpio_pin = 0xff, /* follow fw about GPIO pin */
189 },
190 };
191
192 if (wowlan->magic_pkt)
193 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_MAGIC;
194 if (wowlan->disconnect)
195 req.wow_ctrl_tlv.trigger |= (UNI_WOW_DETECT_TYPE_DISCONNECT |
196 UNI_WOW_DETECT_TYPE_BCN_LOST);
197 if (wowlan->nd_config) {
198 mt7925_mcu_sched_scan_req(phy, vif, wowlan->nd_config);
199 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_SCH_SCAN_HIT;
200 mt7925_mcu_sched_scan_enable(phy, vif, suspend);
201 }
202 if (wowlan->n_patterns)
203 req.wow_ctrl_tlv.trigger |= UNI_WOW_DETECT_TYPE_BITMAP;
204
205 if (mt76_is_mmio(dev))
206 req.wow_ctrl_tlv.wakeup_hif = WOW_PCIE;
207 else if (mt76_is_usb(dev))
208 req.wow_ctrl_tlv.wakeup_hif = WOW_USB;
209 else if (mt76_is_sdio(dev))
210 req.wow_ctrl_tlv.wakeup_hif = WOW_GPIO;
211
212 return mt76_mcu_send_msg(dev, MCU_UNI_CMD(SUSPEND), &req,
213 sizeof(req), true);
214 }
215
216 static int
mt7925_mcu_set_wow_pattern(struct mt76_dev * dev,struct ieee80211_vif * vif,u8 index,bool enable,struct cfg80211_pkt_pattern * pattern)217 mt7925_mcu_set_wow_pattern(struct mt76_dev *dev,
218 struct ieee80211_vif *vif,
219 u8 index, bool enable,
220 struct cfg80211_pkt_pattern *pattern)
221 {
222 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
223 struct mt7925_wow_pattern_tlv *tlv;
224 struct sk_buff *skb;
225 struct {
226 u8 bss_idx;
227 u8 pad[3];
228 } __packed hdr = {
229 .bss_idx = mvif->idx,
230 };
231
232 skb = mt76_mcu_msg_alloc(dev, NULL, sizeof(hdr) + sizeof(*tlv));
233 if (!skb)
234 return -ENOMEM;
235
236 skb_put_data(skb, &hdr, sizeof(hdr));
237 tlv = (struct mt7925_wow_pattern_tlv *)skb_put(skb, sizeof(*tlv));
238 tlv->tag = cpu_to_le16(UNI_SUSPEND_WOW_PATTERN);
239 tlv->len = cpu_to_le16(sizeof(*tlv));
240 tlv->bss_idx = 0xF;
241 tlv->data_len = pattern->pattern_len;
242 tlv->enable = enable;
243 tlv->index = index;
244 tlv->offset = 0;
245
246 memcpy(tlv->pattern, pattern->pattern, pattern->pattern_len);
247 memcpy(tlv->mask, pattern->mask, DIV_ROUND_UP(pattern->pattern_len, 8));
248
249 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(SUSPEND), true);
250 }
251
mt7925_mcu_set_suspend_iter(void * priv,u8 * mac,struct ieee80211_vif * vif)252 void mt7925_mcu_set_suspend_iter(void *priv, u8 *mac,
253 struct ieee80211_vif *vif)
254 {
255 struct mt76_phy *phy = priv;
256 bool suspend = !test_bit(MT76_STATE_RUNNING, &phy->state);
257 struct ieee80211_hw *hw = phy->hw;
258 struct cfg80211_wowlan *wowlan = hw->wiphy->wowlan_config;
259 int i;
260
261 mt76_connac_mcu_set_gtk_rekey(phy->dev, vif, suspend);
262
263 mt76_connac_mcu_set_suspend_mode(phy->dev, vif, suspend, 1, true);
264
265 for (i = 0; i < wowlan->n_patterns; i++)
266 mt7925_mcu_set_wow_pattern(phy->dev, vif, i, suspend,
267 &wowlan->patterns[i]);
268 mt7925_connac_mcu_set_wow_ctrl(phy, vif, suspend, wowlan);
269 }
270
271 #endif /* CONFIG_PM */
272
273 static void
mt7925_mcu_connection_loss_iter(void * priv,u8 * mac,struct ieee80211_vif * vif)274 mt7925_mcu_connection_loss_iter(void *priv, u8 *mac,
275 struct ieee80211_vif *vif)
276 {
277 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
278 struct mt7925_uni_beacon_loss_event *event = priv;
279
280 if (mvif->idx != event->hdr.bss_idx)
281 return;
282
283 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER) ||
284 vif->type != NL80211_IFTYPE_STATION)
285 return;
286
287 ieee80211_connection_loss(vif);
288 }
289
290 static void
mt7925_mcu_connection_loss_event(struct mt792x_dev * dev,struct sk_buff * skb)291 mt7925_mcu_connection_loss_event(struct mt792x_dev *dev, struct sk_buff *skb)
292 {
293 struct mt7925_uni_beacon_loss_event *event;
294 struct mt76_phy *mphy = &dev->mt76.phy;
295
296 skb_pull(skb, sizeof(struct mt7925_mcu_rxd));
297 event = (struct mt7925_uni_beacon_loss_event *)skb->data;
298
299 ieee80211_iterate_active_interfaces_atomic(mphy->hw,
300 IEEE80211_IFACE_ITER_RESUME_ALL,
301 mt7925_mcu_connection_loss_iter, event);
302 }
303
304 static void
mt7925_mcu_roc_iter(void * priv,u8 * mac,struct ieee80211_vif * vif)305 mt7925_mcu_roc_iter(void *priv, u8 *mac, struct ieee80211_vif *vif)
306 {
307 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
308 struct mt7925_roc_grant_tlv *grant = priv;
309
310 if (ieee80211_vif_is_mld(vif) && vif->type == NL80211_IFTYPE_STATION)
311 return;
312
313 if (mvif->idx != grant->bss_idx)
314 return;
315
316 mvif->band_idx = grant->dbdcband;
317 }
318
mt7925_mcu_roc_handle_grant(struct mt792x_dev * dev,struct tlv * tlv)319 static void mt7925_mcu_roc_handle_grant(struct mt792x_dev *dev,
320 struct tlv *tlv)
321 {
322 struct ieee80211_hw *hw = dev->mt76.hw;
323 struct mt7925_roc_grant_tlv *grant;
324 int duration;
325
326 grant = (struct mt7925_roc_grant_tlv *)tlv;
327
328 /* should never happen */
329 WARN_ON_ONCE((le16_to_cpu(grant->tag) != UNI_EVENT_ROC_GRANT));
330
331 if (grant->reqtype == MT7925_ROC_REQ_ROC)
332 ieee80211_ready_on_channel(hw);
333 else if (grant->reqtype == MT7925_ROC_REQ_JOIN)
334 ieee80211_iterate_active_interfaces_atomic(hw,
335 IEEE80211_IFACE_ITER_RESUME_ALL,
336 mt7925_mcu_roc_iter, grant);
337 dev->phy.roc_grant = true;
338 wake_up(&dev->phy.roc_wait);
339 duration = le32_to_cpu(grant->max_interval);
340 mod_timer(&dev->phy.roc_timer,
341 jiffies + msecs_to_jiffies(duration));
342 }
343
344 static void
mt7925_mcu_uni_roc_event(struct mt792x_dev * dev,struct sk_buff * skb)345 mt7925_mcu_uni_roc_event(struct mt792x_dev *dev, struct sk_buff *skb)
346 {
347 struct tlv *tlv;
348 int i = 0;
349
350 skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4);
351
352 while (i < skb->len) {
353 tlv = (struct tlv *)(skb->data + i);
354
355 switch (le16_to_cpu(tlv->tag)) {
356 case UNI_EVENT_ROC_GRANT:
357 mt7925_mcu_roc_handle_grant(dev, tlv);
358 break;
359 case UNI_EVENT_ROC_GRANT_SUB_LINK:
360 break;
361 }
362
363 i += le16_to_cpu(tlv->len);
364 }
365 }
366
367 static void
mt7925_mcu_scan_event(struct mt792x_dev * dev,struct sk_buff * skb)368 mt7925_mcu_scan_event(struct mt792x_dev *dev, struct sk_buff *skb)
369 {
370 struct mt76_phy *mphy = &dev->mt76.phy;
371 struct mt792x_phy *phy = mphy->priv;
372
373 spin_lock_bh(&dev->mt76.lock);
374 __skb_queue_tail(&phy->scan_event_list, skb);
375 spin_unlock_bh(&dev->mt76.lock);
376
377 ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work,
378 MT792x_HW_SCAN_TIMEOUT);
379 }
380
381 static void
mt7925_mcu_tx_done_event(struct mt792x_dev * dev,struct sk_buff * skb)382 mt7925_mcu_tx_done_event(struct mt792x_dev *dev, struct sk_buff *skb)
383 {
384 #define UNI_EVENT_TX_DONE_MSG 0
385 #define UNI_EVENT_TX_DONE_RAW 1
386 struct mt7925_mcu_txs_event {
387 u8 ver;
388 u8 rsv[3];
389 u8 data[0];
390 } __packed * txs;
391 struct tlv *tlv;
392 u32 tlv_len;
393
394 skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4);
395 tlv = (struct tlv *)skb->data;
396 tlv_len = skb->len;
397
398 while (tlv_len > 0 && le16_to_cpu(tlv->len) <= tlv_len) {
399 switch (le16_to_cpu(tlv->tag)) {
400 case UNI_EVENT_TX_DONE_RAW:
401 txs = (struct mt7925_mcu_txs_event *)tlv->data;
402 mt7925_mac_add_txs(dev, txs->data);
403 break;
404 default:
405 break;
406 }
407 tlv_len -= le16_to_cpu(tlv->len);
408 tlv = (struct tlv *)((char *)(tlv) + le16_to_cpu(tlv->len));
409 }
410 }
411
412 static void
mt7925_mcu_uni_debug_msg_event(struct mt792x_dev * dev,struct sk_buff * skb)413 mt7925_mcu_uni_debug_msg_event(struct mt792x_dev *dev, struct sk_buff *skb)
414 {
415 struct mt7925_uni_debug_msg {
416 __le16 tag;
417 __le16 len;
418 u8 fmt;
419 u8 rsv[3];
420 u8 id;
421 u8 type:3;
422 u8 nr_args:5;
423 union {
424 struct idxlog {
425 __le16 rsv;
426 __le32 ts;
427 __le32 idx;
428 u8 data[];
429 } __packed idx;
430 struct txtlog {
431 u8 len;
432 u8 rsv;
433 __le32 ts;
434 u8 data[];
435 } __packed txt;
436 };
437 } __packed * hdr;
438
439 skb_pull(skb, sizeof(struct mt7925_mcu_rxd) + 4);
440 hdr = (struct mt7925_uni_debug_msg *)skb->data;
441
442 if (hdr->id == 0x28) {
443 skb_pull(skb, offsetof(struct mt7925_uni_debug_msg, id));
444 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", skb->len, skb->data);
445 return;
446 } else if (hdr->id != 0xa8) {
447 return;
448 }
449
450 if (hdr->type == 0) { /* idx log */
451 int i, ret, len = PAGE_SIZE - 1, nr_val;
452 struct page *page = dev_alloc_pages(get_order(len));
453 __le32 *val;
454 char *buf, *cur;
455
456 if (!page)
457 return;
458
459 buf = page_address(page);
460 cur = buf;
461
462 nr_val = (le16_to_cpu(hdr->len) - sizeof(*hdr)) / 4;
463 val = (__le32 *)hdr->idx.data;
464 for (i = 0; i < nr_val && len > 0; i++) {
465 ret = snprintf(cur, len, "0x%x,", le32_to_cpu(val[i]));
466 if (ret <= 0)
467 break;
468
469 cur += ret;
470 len -= ret;
471 }
472 if (cur > buf)
473 wiphy_info(mt76_hw(dev)->wiphy, "idx: 0x%X,%d,%s",
474 le32_to_cpu(hdr->idx.idx), nr_val, buf);
475 put_page(page);
476 } else if (hdr->type == 2) { /* str log */
477 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", hdr->txt.len, hdr->txt.data);
478 }
479 }
480
481 static void
mt7925_mcu_uni_rx_unsolicited_event(struct mt792x_dev * dev,struct sk_buff * skb)482 mt7925_mcu_uni_rx_unsolicited_event(struct mt792x_dev *dev,
483 struct sk_buff *skb)
484 {
485 struct mt7925_mcu_rxd *rxd;
486
487 rxd = (struct mt7925_mcu_rxd *)skb->data;
488
489 switch (rxd->eid) {
490 case MCU_UNI_EVENT_FW_LOG_2_HOST:
491 mt7925_mcu_uni_debug_msg_event(dev, skb);
492 break;
493 case MCU_UNI_EVENT_ROC:
494 mt7925_mcu_uni_roc_event(dev, skb);
495 break;
496 case MCU_UNI_EVENT_SCAN_DONE:
497 mt7925_mcu_scan_event(dev, skb);
498 return;
499 case MCU_UNI_EVENT_TX_DONE:
500 mt7925_mcu_tx_done_event(dev, skb);
501 break;
502 case MCU_UNI_EVENT_BSS_BEACON_LOSS:
503 mt7925_mcu_connection_loss_event(dev, skb);
504 break;
505 case MCU_UNI_EVENT_COREDUMP:
506 dev->fw_assert = true;
507 mt76_connac_mcu_coredump_event(&dev->mt76, skb, &dev->coredump);
508 return;
509 default:
510 break;
511 }
512 dev_kfree_skb(skb);
513 }
514
mt7925_mcu_rx_event(struct mt792x_dev * dev,struct sk_buff * skb)515 void mt7925_mcu_rx_event(struct mt792x_dev *dev, struct sk_buff *skb)
516 {
517 struct mt7925_mcu_rxd *rxd = (struct mt7925_mcu_rxd *)skb->data;
518
519 if (skb_linearize(skb))
520 return;
521
522 if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) {
523 mt7925_mcu_uni_rx_unsolicited_event(dev, skb);
524 return;
525 }
526
527 mt76_mcu_rx_event(&dev->mt76, skb);
528 }
529
530 static int
mt7925_mcu_sta_ba(struct mt76_dev * dev,struct mt76_vif * mvif,struct ieee80211_ampdu_params * params,bool enable,bool tx)531 mt7925_mcu_sta_ba(struct mt76_dev *dev, struct mt76_vif *mvif,
532 struct ieee80211_ampdu_params *params,
533 bool enable, bool tx)
534 {
535 struct mt76_wcid *wcid = (struct mt76_wcid *)params->sta->drv_priv;
536 struct sta_rec_ba_uni *ba;
537 struct sk_buff *skb;
538 struct tlv *tlv;
539 int len;
540
541 len = sizeof(struct sta_req_hdr) + sizeof(*ba);
542 skb = __mt76_connac_mcu_alloc_sta_req(dev, mvif, wcid,
543 len);
544 if (IS_ERR(skb))
545 return PTR_ERR(skb);
546
547 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_BA, sizeof(*ba));
548
549 ba = (struct sta_rec_ba_uni *)tlv;
550 ba->ba_type = tx ? MT_BA_TYPE_ORIGINATOR : MT_BA_TYPE_RECIPIENT;
551 ba->winsize = cpu_to_le16(params->buf_size);
552 ba->ssn = cpu_to_le16(params->ssn);
553 ba->ba_en = enable << params->tid;
554 ba->amsdu = params->amsdu;
555 ba->tid = params->tid;
556
557 return mt76_mcu_skb_send_msg(dev, skb,
558 MCU_UNI_CMD(STA_REC_UPDATE), true);
559 }
560
561 /** starec & wtbl **/
mt7925_mcu_uni_tx_ba(struct mt792x_dev * dev,struct ieee80211_ampdu_params * params,bool enable)562 int mt7925_mcu_uni_tx_ba(struct mt792x_dev *dev,
563 struct ieee80211_ampdu_params *params,
564 bool enable)
565 {
566 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
567 struct mt792x_vif *mvif = msta->vif;
568
569 if (enable && !params->amsdu)
570 msta->deflink.wcid.amsdu = false;
571
572 return mt7925_mcu_sta_ba(&dev->mt76, &mvif->bss_conf.mt76, params,
573 enable, true);
574 }
575
mt7925_mcu_uni_rx_ba(struct mt792x_dev * dev,struct ieee80211_ampdu_params * params,bool enable)576 int mt7925_mcu_uni_rx_ba(struct mt792x_dev *dev,
577 struct ieee80211_ampdu_params *params,
578 bool enable)
579 {
580 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
581 struct mt792x_vif *mvif = msta->vif;
582
583 return mt7925_mcu_sta_ba(&dev->mt76, &mvif->bss_conf.mt76, params,
584 enable, false);
585 }
586
mt7925_mcu_read_eeprom(struct mt792x_dev * dev,u32 offset,u8 * val)587 static int mt7925_mcu_read_eeprom(struct mt792x_dev *dev, u32 offset, u8 *val)
588 {
589 struct {
590 u8 rsv[4];
591
592 __le16 tag;
593 __le16 len;
594
595 __le32 addr;
596 __le32 valid;
597 u8 data[MT7925_EEPROM_BLOCK_SIZE];
598 } __packed req = {
599 .tag = cpu_to_le16(1),
600 .len = cpu_to_le16(sizeof(req) - 4),
601 .addr = cpu_to_le32(round_down(offset,
602 MT7925_EEPROM_BLOCK_SIZE)),
603 };
604 struct evt {
605 u8 rsv[4];
606
607 __le16 tag;
608 __le16 len;
609
610 __le32 ver;
611 __le32 addr;
612 __le32 valid;
613 __le32 size;
614 __le32 magic_num;
615 __le32 type;
616 __le32 rsv1[4];
617 u8 data[32];
618 } __packed *res;
619 struct sk_buff *skb;
620 int ret;
621
622 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_WM_UNI_CMD_QUERY(EFUSE_CTRL),
623 &req, sizeof(req), true, &skb);
624 if (ret)
625 return ret;
626
627 res = (struct evt *)skb->data;
628 *val = res->data[offset % MT7925_EEPROM_BLOCK_SIZE];
629
630 dev_kfree_skb(skb);
631
632 return 0;
633 }
634
mt7925_load_clc(struct mt792x_dev * dev,const char * fw_name)635 static int mt7925_load_clc(struct mt792x_dev *dev, const char *fw_name)
636 {
637 const struct mt76_connac2_fw_trailer *hdr;
638 const struct mt76_connac2_fw_region *region;
639 const struct mt7925_clc *clc;
640 struct mt76_dev *mdev = &dev->mt76;
641 struct mt792x_phy *phy = &dev->phy;
642 const struct firmware *fw;
643 u8 *clc_base = NULL, hw_encap = 0;
644 int ret, i, len, offset = 0;
645
646 if (mt7925_disable_clc ||
647 mt76_is_usb(&dev->mt76))
648 return 0;
649
650 if (mt76_is_mmio(&dev->mt76)) {
651 ret = mt7925_mcu_read_eeprom(dev, MT_EE_HW_TYPE, &hw_encap);
652 if (ret)
653 return ret;
654 hw_encap = u8_get_bits(hw_encap, MT_EE_HW_TYPE_ENCAP);
655 }
656
657 ret = request_firmware(&fw, fw_name, mdev->dev);
658 if (ret)
659 return ret;
660
661 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
662 dev_err(mdev->dev, "Invalid firmware\n");
663 ret = -EINVAL;
664 goto out;
665 }
666
667 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr));
668 for (i = 0; i < hdr->n_region; i++) {
669 region = (const void *)((const u8 *)hdr -
670 (hdr->n_region - i) * sizeof(*region));
671 len = le32_to_cpu(region->len);
672
673 /* check if we have valid buffer size */
674 if (offset + len > fw->size) {
675 dev_err(mdev->dev, "Invalid firmware region\n");
676 ret = -EINVAL;
677 goto out;
678 }
679
680 if ((region->feature_set & FW_FEATURE_NON_DL) &&
681 region->type == FW_TYPE_CLC) {
682 clc_base = (u8 *)(fw->data + offset);
683 break;
684 }
685 offset += len;
686 }
687
688 if (!clc_base)
689 goto out;
690
691 for (offset = 0; offset < len; offset += le32_to_cpu(clc->len)) {
692 clc = (const struct mt7925_clc *)(clc_base + offset);
693
694 if (clc->idx >= ARRAY_SIZE(phy->clc))
695 break;
696
697 /* do not init buf again if chip reset triggered */
698 if (phy->clc[clc->idx])
699 continue;
700
701 /* header content sanity */
702 if (u8_get_bits(clc->type, MT_EE_HW_TYPE_ENCAP) != hw_encap)
703 continue;
704
705 phy->clc[clc->idx] = devm_kmemdup(mdev->dev, clc,
706 le32_to_cpu(clc->len),
707 GFP_KERNEL);
708
709 if (!phy->clc[clc->idx]) {
710 ret = -ENOMEM;
711 goto out;
712 }
713 }
714
715 ret = mt7925_mcu_set_clc(dev, "00", ENVIRON_INDOOR);
716 out:
717 release_firmware(fw);
718
719 return ret;
720 }
721
mt7925_mcu_fw_log_2_host(struct mt792x_dev * dev,u8 ctrl)722 int mt7925_mcu_fw_log_2_host(struct mt792x_dev *dev, u8 ctrl)
723 {
724 struct {
725 u8 _rsv[4];
726
727 __le16 tag;
728 __le16 len;
729 u8 ctrl;
730 u8 interval;
731 u8 _rsv2[2];
732 } __packed req = {
733 .tag = cpu_to_le16(UNI_WSYS_CONFIG_FW_LOG_CTRL),
734 .len = cpu_to_le16(sizeof(req) - 4),
735 .ctrl = ctrl,
736 };
737 int ret;
738
739 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(WSYS_CONFIG),
740 &req, sizeof(req), true, NULL);
741 return ret;
742 }
743
mt7925_mcu_get_temperature(struct mt792x_phy * phy)744 int mt7925_mcu_get_temperature(struct mt792x_phy *phy)
745 {
746 struct {
747 u8 _rsv[4];
748
749 __le16 tag;
750 __le16 len;
751 u8 _rsv2[4];
752 } __packed req = {
753 .tag = cpu_to_le16(0x0),
754 .len = cpu_to_le16(sizeof(req) - 4),
755 };
756 struct mt7925_thermal_evt {
757 u8 rsv[4];
758 __le32 temperature;
759 } __packed * evt;
760 struct mt792x_dev *dev = phy->dev;
761 int temperature, ret;
762 struct sk_buff *skb;
763
764 ret = mt76_mcu_send_and_get_msg(&dev->mt76,
765 MCU_WM_UNI_CMD_QUERY(THERMAL),
766 &req, sizeof(req), true, &skb);
767 if (ret)
768 return ret;
769
770 skb_pull(skb, 4 + sizeof(struct tlv));
771 evt = (struct mt7925_thermal_evt *)skb->data;
772
773 temperature = le32_to_cpu(evt->temperature);
774
775 dev_kfree_skb(skb);
776
777 return temperature;
778 }
779
780 static void
mt7925_mcu_parse_phy_cap(struct mt792x_dev * dev,char * data)781 mt7925_mcu_parse_phy_cap(struct mt792x_dev *dev, char *data)
782 {
783 struct mt76_phy *mphy = &dev->mt76.phy;
784 struct mt76_dev *mdev = mphy->dev;
785 struct mt7925_mcu_phy_cap {
786 u8 ht;
787 u8 vht;
788 u8 _5g;
789 u8 max_bw;
790 u8 nss;
791 u8 dbdc;
792 u8 tx_ldpc;
793 u8 rx_ldpc;
794 u8 tx_stbc;
795 u8 rx_stbc;
796 u8 hw_path;
797 u8 he;
798 u8 eht;
799 } __packed * cap;
800 enum {
801 WF0_24G,
802 WF0_5G
803 };
804
805 cap = (struct mt7925_mcu_phy_cap *)data;
806
807 mdev->phy.antenna_mask = BIT(cap->nss) - 1;
808 mdev->phy.chainmask = mdev->phy.antenna_mask;
809 mdev->phy.cap.has_2ghz = cap->hw_path & BIT(WF0_24G);
810 mdev->phy.cap.has_5ghz = cap->hw_path & BIT(WF0_5G);
811 dev->has_eht = cap->eht;
812 }
813
814 static void
mt7925_mcu_parse_eml_cap(struct mt792x_dev * dev,char * data)815 mt7925_mcu_parse_eml_cap(struct mt792x_dev *dev, char *data)
816 {
817 struct mt7925_mcu_eml_cap {
818 u8 rsv[4];
819 __le16 eml_cap;
820 u8 rsv2[6];
821 } __packed * cap;
822
823 cap = (struct mt7925_mcu_eml_cap *)data;
824
825 dev->phy.eml_cap = le16_to_cpu(cap->eml_cap);
826 }
827
828 static int
mt7925_mcu_get_nic_capability(struct mt792x_dev * dev)829 mt7925_mcu_get_nic_capability(struct mt792x_dev *dev)
830 {
831 struct mt76_phy *mphy = &dev->mt76.phy;
832 struct {
833 u8 _rsv[4];
834
835 __le16 tag;
836 __le16 len;
837 } __packed req = {
838 .tag = cpu_to_le16(UNI_CHIP_CONFIG_NIC_CAPA),
839 .len = cpu_to_le16(sizeof(req) - 4),
840 };
841 struct mt76_connac_cap_hdr {
842 __le16 n_element;
843 u8 rsv[2];
844 } __packed * hdr;
845 struct sk_buff *skb;
846 int ret, i;
847
848 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(CHIP_CONFIG),
849 &req, sizeof(req), true, &skb);
850 if (ret)
851 return ret;
852
853 hdr = (struct mt76_connac_cap_hdr *)skb->data;
854 if (skb->len < sizeof(*hdr)) {
855 ret = -EINVAL;
856 goto out;
857 }
858
859 skb_pull(skb, sizeof(*hdr));
860
861 for (i = 0; i < le16_to_cpu(hdr->n_element); i++) {
862 struct tlv *tlv = (struct tlv *)skb->data;
863 int len;
864
865 if (skb->len < sizeof(*tlv))
866 break;
867
868 len = le16_to_cpu(tlv->len);
869 if (skb->len < len)
870 break;
871
872 switch (le16_to_cpu(tlv->tag)) {
873 case MT_NIC_CAP_6G:
874 mphy->cap.has_6ghz = !!tlv->data[0];
875 break;
876 case MT_NIC_CAP_MAC_ADDR:
877 memcpy(mphy->macaddr, (void *)tlv->data, ETH_ALEN);
878 break;
879 case MT_NIC_CAP_PHY:
880 mt7925_mcu_parse_phy_cap(dev, tlv->data);
881 break;
882 case MT_NIC_CAP_CHIP_CAP:
883 dev->phy.chip_cap = le64_to_cpu(*(__le64 *)tlv->data);
884 break;
885 case MT_NIC_CAP_EML_CAP:
886 mt7925_mcu_parse_eml_cap(dev, tlv->data);
887 break;
888 default:
889 break;
890 }
891 skb_pull(skb, len);
892 }
893 out:
894 dev_kfree_skb(skb);
895 return ret;
896 }
897
mt7925_mcu_chip_config(struct mt792x_dev * dev,const char * cmd)898 int mt7925_mcu_chip_config(struct mt792x_dev *dev, const char *cmd)
899 {
900 u16 len = strlen(cmd) + 1;
901 struct {
902 u8 _rsv[4];
903 __le16 tag;
904 __le16 len;
905 struct mt76_connac_config config;
906 } __packed req = {
907 .tag = cpu_to_le16(UNI_CHIP_CONFIG_CHIP_CFG),
908 .len = cpu_to_le16(sizeof(req) - 4),
909 .config = {
910 .resp_type = 0,
911 .type = 0,
912 .data_size = cpu_to_le16(len),
913 },
914 };
915
916 memcpy(req.config.data, cmd, len);
917
918 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(CHIP_CONFIG),
919 &req, sizeof(req), false);
920 }
921
mt7925_mcu_set_deep_sleep(struct mt792x_dev * dev,bool enable)922 int mt7925_mcu_set_deep_sleep(struct mt792x_dev *dev, bool enable)
923 {
924 char cmd[16];
925
926 snprintf(cmd, sizeof(cmd), "KeepFullPwr %d", !enable);
927
928 return mt7925_mcu_chip_config(dev, cmd);
929 }
930 EXPORT_SYMBOL_GPL(mt7925_mcu_set_deep_sleep);
931
mt7925_mcu_set_thermal_protect(struct mt792x_dev * dev)932 int mt7925_mcu_set_thermal_protect(struct mt792x_dev *dev)
933 {
934 char cmd[64];
935 int ret = 0;
936
937 snprintf(cmd, sizeof(cmd), "ThermalProtGband %d %d %d %d %d %d %d %d %d %d",
938 0, 100, 90, 80, 30, 1, 1, 115, 105, 5);
939 ret = mt7925_mcu_chip_config(dev, cmd);
940
941 snprintf(cmd, sizeof(cmd), "ThermalProtAband %d %d %d %d %d %d %d %d %d %d",
942 1, 100, 90, 80, 30, 1, 1, 115, 105, 5);
943 ret |= mt7925_mcu_chip_config(dev, cmd);
944
945 return ret;
946 }
947 EXPORT_SYMBOL_GPL(mt7925_mcu_set_thermal_protect);
948
mt7925_run_firmware(struct mt792x_dev * dev)949 int mt7925_run_firmware(struct mt792x_dev *dev)
950 {
951 int err;
952
953 err = mt792x_load_firmware(dev);
954 if (err)
955 return err;
956
957 err = mt7925_mcu_get_nic_capability(dev);
958 if (err)
959 return err;
960
961 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
962 err = mt7925_load_clc(dev, mt792x_ram_name(dev));
963 if (err)
964 return err;
965
966 return mt7925_mcu_fw_log_2_host(dev, 1);
967 }
968 EXPORT_SYMBOL_GPL(mt7925_run_firmware);
969
970 static void
mt7925_mcu_sta_hdr_trans_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_link_sta * link_sta)971 mt7925_mcu_sta_hdr_trans_tlv(struct sk_buff *skb,
972 struct ieee80211_vif *vif,
973 struct ieee80211_link_sta *link_sta)
974 {
975 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
976 struct sta_rec_hdr_trans *hdr_trans;
977 struct mt76_wcid *wcid;
978 struct tlv *tlv;
979
980 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HDR_TRANS, sizeof(*hdr_trans));
981 hdr_trans = (struct sta_rec_hdr_trans *)tlv;
982 hdr_trans->dis_rx_hdr_tran = true;
983
984 if (vif->type == NL80211_IFTYPE_STATION)
985 hdr_trans->to_ds = true;
986 else
987 hdr_trans->from_ds = true;
988
989 if (link_sta) {
990 struct mt792x_sta *msta = (struct mt792x_sta *)link_sta->sta->drv_priv;
991 struct mt792x_link_sta *mlink;
992
993 mlink = mt792x_sta_to_link(msta, link_sta->link_id);
994 wcid = &mlink->wcid;
995 } else {
996 wcid = &mvif->sta.deflink.wcid;
997 }
998
999 if (!wcid)
1000 return;
1001
1002 hdr_trans->dis_rx_hdr_tran = !test_bit(MT_WCID_FLAG_HDR_TRANS, &wcid->flags);
1003 if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags)) {
1004 hdr_trans->to_ds = true;
1005 hdr_trans->from_ds = true;
1006 }
1007 }
1008
mt7925_mcu_wtbl_update_hdr_trans(struct mt792x_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta,int link_id)1009 int mt7925_mcu_wtbl_update_hdr_trans(struct mt792x_dev *dev,
1010 struct ieee80211_vif *vif,
1011 struct ieee80211_sta *sta,
1012 int link_id)
1013 {
1014 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1015 struct ieee80211_link_sta *link_sta = sta ? &sta->deflink : NULL;
1016 struct mt792x_link_sta *mlink;
1017 struct mt792x_bss_conf *mconf;
1018 struct mt792x_sta *msta;
1019 struct sk_buff *skb;
1020
1021 msta = sta ? (struct mt792x_sta *)sta->drv_priv : &mvif->sta;
1022
1023 mlink = mt792x_sta_to_link(msta, link_id);
1024 link_sta = mt792x_sta_to_link_sta(vif, sta, link_id);
1025 mconf = mt792x_vif_to_link(mvif, link_id);
1026
1027 skb = __mt76_connac_mcu_alloc_sta_req(&dev->mt76, &mconf->mt76,
1028 &mlink->wcid,
1029 MT7925_STA_UPDATE_MAX_SIZE);
1030 if (IS_ERR(skb))
1031 return PTR_ERR(skb);
1032
1033 /* starec hdr trans */
1034 mt7925_mcu_sta_hdr_trans_tlv(skb, vif, link_sta);
1035 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1036 MCU_WMWA_UNI_CMD(STA_REC_UPDATE), true);
1037 }
1038
mt7925_mcu_set_tx(struct mt792x_dev * dev,struct ieee80211_bss_conf * bss_conf)1039 int mt7925_mcu_set_tx(struct mt792x_dev *dev,
1040 struct ieee80211_bss_conf *bss_conf)
1041 {
1042 #define MCU_EDCA_AC_PARAM 0
1043 #define WMM_AIFS_SET BIT(0)
1044 #define WMM_CW_MIN_SET BIT(1)
1045 #define WMM_CW_MAX_SET BIT(2)
1046 #define WMM_TXOP_SET BIT(3)
1047 #define WMM_PARAM_SET (WMM_AIFS_SET | WMM_CW_MIN_SET | \
1048 WMM_CW_MAX_SET | WMM_TXOP_SET)
1049 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(bss_conf);
1050 struct {
1051 u8 bss_idx;
1052 u8 __rsv[3];
1053 } __packed hdr = {
1054 .bss_idx = mconf->mt76.idx,
1055 };
1056 struct sk_buff *skb;
1057 int len = sizeof(hdr) + IEEE80211_NUM_ACS * sizeof(struct edca);
1058 int ac;
1059
1060 skb = mt76_mcu_msg_alloc(&dev->mt76, NULL, len);
1061 if (!skb)
1062 return -ENOMEM;
1063
1064 skb_put_data(skb, &hdr, sizeof(hdr));
1065
1066 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1067 struct ieee80211_tx_queue_params *q = &mconf->queue_params[ac];
1068 struct edca *e;
1069 struct tlv *tlv;
1070
1071 tlv = mt76_connac_mcu_add_tlv(skb, MCU_EDCA_AC_PARAM, sizeof(*e));
1072
1073 e = (struct edca *)tlv;
1074 e->set = WMM_PARAM_SET;
1075 e->queue = ac;
1076 e->aifs = q->aifs;
1077 e->txop = cpu_to_le16(q->txop);
1078
1079 if (q->cw_min)
1080 e->cw_min = fls(q->cw_min);
1081 else
1082 e->cw_min = 5;
1083
1084 if (q->cw_max)
1085 e->cw_max = fls(q->cw_max);
1086 else
1087 e->cw_max = 10;
1088 }
1089
1090 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
1091 MCU_UNI_CMD(EDCA_UPDATE), true);
1092 }
1093
1094 static int
mt7925_mcu_sta_key_tlv(struct mt76_wcid * wcid,struct mt76_connac_sta_key_conf * sta_key_conf,struct sk_buff * skb,struct ieee80211_key_conf * key,enum set_key_cmd cmd,struct mt792x_sta * msta)1095 mt7925_mcu_sta_key_tlv(struct mt76_wcid *wcid,
1096 struct mt76_connac_sta_key_conf *sta_key_conf,
1097 struct sk_buff *skb,
1098 struct ieee80211_key_conf *key,
1099 enum set_key_cmd cmd,
1100 struct mt792x_sta *msta)
1101 {
1102 struct mt792x_vif *mvif = msta->vif;
1103 struct mt792x_bss_conf *mconf = mt792x_vif_to_link(mvif, wcid->link_id);
1104 struct sta_rec_sec_uni *sec;
1105 struct ieee80211_sta *sta;
1106 struct ieee80211_vif *vif;
1107 struct tlv *tlv;
1108
1109 sta = msta == &mvif->sta ?
1110 NULL :
1111 container_of((void *)msta, struct ieee80211_sta, drv_priv);
1112 vif = container_of((void *)mvif, struct ieee80211_vif, drv_priv);
1113
1114 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V3, sizeof(*sec));
1115 sec = (struct sta_rec_sec_uni *)tlv;
1116 sec->bss_idx = mconf->mt76.idx;
1117 sec->is_authenticator = 0;
1118 sec->mgmt_prot = 1; /* only used in MLO mode */
1119 sec->wlan_idx = (u8)wcid->idx;
1120
1121 if (sta) {
1122 struct ieee80211_link_sta *link_sta;
1123
1124 sec->tx_key = 1;
1125 sec->key_type = 1;
1126 link_sta = mt792x_sta_to_link_sta(vif, sta, wcid->link_id);
1127
1128 if (link_sta)
1129 memcpy(sec->peer_addr, link_sta->addr, ETH_ALEN);
1130 } else {
1131 struct ieee80211_bss_conf *link_conf;
1132
1133 link_conf = mt792x_vif_to_bss_conf(vif, wcid->link_id);
1134
1135 if (link_conf)
1136 memcpy(sec->peer_addr, link_conf->bssid, ETH_ALEN);
1137 }
1138
1139 if (cmd == SET_KEY) {
1140 u8 cipher;
1141
1142 sec->add = 1;
1143 cipher = mt7925_mcu_get_cipher(key->cipher);
1144 if (cipher == CONNAC3_CIPHER_NONE)
1145 return -EOPNOTSUPP;
1146
1147 if (cipher == CONNAC3_CIPHER_BIP_CMAC_128) {
1148 sec->cipher_id = CONNAC3_CIPHER_BIP_CMAC_128;
1149 sec->key_id = sta_key_conf->keyidx;
1150 sec->key_len = 32;
1151 memcpy(sec->key, sta_key_conf->key, 16);
1152 memcpy(sec->key + 16, key->key, 16);
1153 } else {
1154 sec->cipher_id = cipher;
1155 sec->key_id = key->keyidx;
1156 sec->key_len = key->keylen;
1157 memcpy(sec->key, key->key, key->keylen);
1158
1159 if (cipher == CONNAC3_CIPHER_TKIP) {
1160 /* Rx/Tx MIC keys are swapped */
1161 memcpy(sec->key + 16, key->key + 24, 8);
1162 memcpy(sec->key + 24, key->key + 16, 8);
1163 }
1164
1165 /* store key_conf for BIP batch update */
1166 if (cipher == CONNAC3_CIPHER_AES_CCMP) {
1167 memcpy(sta_key_conf->key, key->key, key->keylen);
1168 sta_key_conf->keyidx = key->keyidx;
1169 }
1170 }
1171 } else {
1172 sec->add = 0;
1173 }
1174
1175 return 0;
1176 }
1177
mt7925_mcu_add_key(struct mt76_dev * dev,struct ieee80211_vif * vif,struct mt76_connac_sta_key_conf * sta_key_conf,struct ieee80211_key_conf * key,int mcu_cmd,struct mt76_wcid * wcid,enum set_key_cmd cmd,struct mt792x_sta * msta)1178 int mt7925_mcu_add_key(struct mt76_dev *dev, struct ieee80211_vif *vif,
1179 struct mt76_connac_sta_key_conf *sta_key_conf,
1180 struct ieee80211_key_conf *key, int mcu_cmd,
1181 struct mt76_wcid *wcid, enum set_key_cmd cmd,
1182 struct mt792x_sta *msta)
1183 {
1184 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1185 struct mt792x_bss_conf *mconf = mt792x_vif_to_link(mvif, wcid->link_id);
1186 struct sk_buff *skb;
1187 int ret;
1188
1189 skb = __mt76_connac_mcu_alloc_sta_req(dev, &mconf->mt76, wcid,
1190 MT7925_STA_UPDATE_MAX_SIZE);
1191 if (IS_ERR(skb))
1192 return PTR_ERR(skb);
1193
1194 ret = mt7925_mcu_sta_key_tlv(wcid, sta_key_conf, skb, key, cmd, msta);
1195 if (ret)
1196 return ret;
1197
1198 return mt76_mcu_skb_send_msg(dev, skb, mcu_cmd, true);
1199 }
1200
mt7925_mcu_set_mlo_roc(struct mt792x_bss_conf * mconf,u16 sel_links,int duration,u8 token_id)1201 int mt7925_mcu_set_mlo_roc(struct mt792x_bss_conf *mconf, u16 sel_links,
1202 int duration, u8 token_id)
1203 {
1204 struct mt792x_vif *mvif = mconf->vif;
1205 struct ieee80211_vif *vif = container_of((void *)mvif,
1206 struct ieee80211_vif, drv_priv);
1207 struct ieee80211_bss_conf *link_conf;
1208 struct ieee80211_channel *chan;
1209 const u8 ch_band[] = {
1210 [NL80211_BAND_2GHZ] = 1,
1211 [NL80211_BAND_5GHZ] = 2,
1212 [NL80211_BAND_6GHZ] = 3,
1213 };
1214 enum mt7925_roc_req type;
1215 int center_ch, i = 0;
1216 bool is_AG_band = false;
1217 struct {
1218 u8 id;
1219 u8 bss_idx;
1220 u16 tag;
1221 struct mt792x_bss_conf *mconf;
1222 struct ieee80211_channel *chan;
1223 } links[2];
1224
1225 struct {
1226 struct {
1227 u8 rsv[4];
1228 } __packed hdr;
1229 struct roc_acquire_tlv roc[2];
1230 } __packed req = {
1231 .roc[0].tag = cpu_to_le16(UNI_ROC_NUM),
1232 .roc[0].len = cpu_to_le16(sizeof(struct roc_acquire_tlv)),
1233 .roc[1].tag = cpu_to_le16(UNI_ROC_NUM),
1234 .roc[1].len = cpu_to_le16(sizeof(struct roc_acquire_tlv))
1235 };
1236
1237 if (!mconf || hweight16(vif->valid_links) < 2 ||
1238 hweight16(sel_links) != 2)
1239 return -EPERM;
1240
1241 for (i = 0; i < ARRAY_SIZE(links); i++) {
1242 links[i].id = i ? __ffs(~BIT(mconf->link_id) & sel_links) :
1243 mconf->link_id;
1244 link_conf = mt792x_vif_to_bss_conf(vif, links[i].id);
1245 if (WARN_ON_ONCE(!link_conf))
1246 return -EPERM;
1247
1248 links[i].chan = link_conf->chanreq.oper.chan;
1249 if (WARN_ON_ONCE(!links[i].chan))
1250 return -EPERM;
1251
1252 links[i].mconf = mt792x_vif_to_link(mvif, links[i].id);
1253 links[i].tag = links[i].id == mconf->link_id ?
1254 UNI_ROC_ACQUIRE : UNI_ROC_SUB_LINK;
1255
1256 is_AG_band |= links[i].chan->band == NL80211_BAND_2GHZ;
1257 }
1258
1259 if (vif->cfg.eml_cap & IEEE80211_EML_CAP_EMLSR_SUPP)
1260 type = is_AG_band ? MT7925_ROC_REQ_MLSR_AG :
1261 MT7925_ROC_REQ_MLSR_AA;
1262 else
1263 type = MT7925_ROC_REQ_JOIN;
1264
1265 for (i = 0; i < ARRAY_SIZE(links) && i < hweight16(vif->active_links); i++) {
1266 if (WARN_ON_ONCE(!links[i].mconf || !links[i].chan))
1267 continue;
1268
1269 chan = links[i].chan;
1270 center_ch = ieee80211_frequency_to_channel(chan->center_freq);
1271 req.roc[i].len = cpu_to_le16(sizeof(struct roc_acquire_tlv));
1272 req.roc[i].tag = cpu_to_le16(links[i].tag);
1273 req.roc[i].tokenid = token_id;
1274 req.roc[i].reqtype = type;
1275 req.roc[i].maxinterval = cpu_to_le32(duration);
1276 req.roc[i].bss_idx = links[i].mconf->mt76.idx;
1277 req.roc[i].control_channel = chan->hw_value;
1278 req.roc[i].bw = CMD_CBW_20MHZ;
1279 req.roc[i].bw_from_ap = CMD_CBW_20MHZ;
1280 req.roc[i].center_chan = center_ch;
1281 req.roc[i].center_chan_from_ap = center_ch;
1282 req.roc[i].center_chan2 = 0;
1283 req.roc[i].center_chan2_from_ap = 0;
1284
1285 /* STR : 0xfe indicates BAND_ALL with enabling DBDC
1286 * EMLSR : 0xff indicates (BAND_AUTO) without DBDC
1287 */
1288 req.roc[i].dbdcband = type == MT7925_ROC_REQ_JOIN ? 0xfe : 0xff;
1289
1290 if (chan->hw_value < center_ch)
1291 req.roc[i].sco = 1; /* SCA */
1292 else if (chan->hw_value > center_ch)
1293 req.roc[i].sco = 3; /* SCB */
1294
1295 req.roc[i].band = ch_band[chan->band];
1296 }
1297
1298 return mt76_mcu_send_msg(&mvif->phy->dev->mt76, MCU_UNI_CMD(ROC),
1299 &req, sizeof(req), true);
1300 }
1301
mt7925_mcu_set_roc(struct mt792x_phy * phy,struct mt792x_bss_conf * mconf,struct ieee80211_channel * chan,int duration,enum mt7925_roc_req type,u8 token_id)1302 int mt7925_mcu_set_roc(struct mt792x_phy *phy, struct mt792x_bss_conf *mconf,
1303 struct ieee80211_channel *chan, int duration,
1304 enum mt7925_roc_req type, u8 token_id)
1305 {
1306 int center_ch = ieee80211_frequency_to_channel(chan->center_freq);
1307 struct mt792x_dev *dev = phy->dev;
1308 struct {
1309 struct {
1310 u8 rsv[4];
1311 } __packed hdr;
1312 struct roc_acquire_tlv roc;
1313 } __packed req = {
1314 .roc = {
1315 .tag = cpu_to_le16(UNI_ROC_ACQUIRE),
1316 .len = cpu_to_le16(sizeof(struct roc_acquire_tlv)),
1317 .tokenid = token_id,
1318 .reqtype = type,
1319 .maxinterval = cpu_to_le32(duration),
1320 .bss_idx = mconf->mt76.idx,
1321 .control_channel = chan->hw_value,
1322 .bw = CMD_CBW_20MHZ,
1323 .bw_from_ap = CMD_CBW_20MHZ,
1324 .center_chan = center_ch,
1325 .center_chan_from_ap = center_ch,
1326 .dbdcband = 0xff, /* auto */
1327 },
1328 };
1329
1330 if (chan->hw_value < center_ch)
1331 req.roc.sco = 1; /* SCA */
1332 else if (chan->hw_value > center_ch)
1333 req.roc.sco = 3; /* SCB */
1334
1335 switch (chan->band) {
1336 case NL80211_BAND_6GHZ:
1337 req.roc.band = 3;
1338 break;
1339 case NL80211_BAND_5GHZ:
1340 req.roc.band = 2;
1341 break;
1342 default:
1343 req.roc.band = 1;
1344 break;
1345 }
1346
1347 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
1348 &req, sizeof(req), true);
1349 }
1350
mt7925_mcu_abort_roc(struct mt792x_phy * phy,struct mt792x_bss_conf * mconf,u8 token_id)1351 int mt7925_mcu_abort_roc(struct mt792x_phy *phy, struct mt792x_bss_conf *mconf,
1352 u8 token_id)
1353 {
1354 struct mt792x_dev *dev = phy->dev;
1355 struct {
1356 struct {
1357 u8 rsv[4];
1358 } __packed hdr;
1359 struct roc_abort_tlv {
1360 __le16 tag;
1361 __le16 len;
1362 u8 bss_idx;
1363 u8 tokenid;
1364 u8 dbdcband;
1365 u8 rsv[5];
1366 } __packed abort;
1367 } __packed req = {
1368 .abort = {
1369 .tag = cpu_to_le16(UNI_ROC_ABORT),
1370 .len = cpu_to_le16(sizeof(struct roc_abort_tlv)),
1371 .tokenid = token_id,
1372 .bss_idx = mconf->mt76.idx,
1373 .dbdcband = 0xff, /* auto*/
1374 },
1375 };
1376
1377 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
1378 &req, sizeof(req), true);
1379 }
1380
mt7925_mcu_set_eeprom(struct mt792x_dev * dev)1381 int mt7925_mcu_set_eeprom(struct mt792x_dev *dev)
1382 {
1383 struct {
1384 u8 _rsv[4];
1385
1386 __le16 tag;
1387 __le16 len;
1388 u8 buffer_mode;
1389 u8 format;
1390 __le16 buf_len;
1391 } __packed req = {
1392 .tag = cpu_to_le16(UNI_EFUSE_BUFFER_MODE),
1393 .len = cpu_to_le16(sizeof(req) - 4),
1394 .buffer_mode = EE_MODE_EFUSE,
1395 .format = EE_FORMAT_WHOLE
1396 };
1397
1398 return mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(EFUSE_CTRL),
1399 &req, sizeof(req), true, NULL);
1400 }
1401 EXPORT_SYMBOL_GPL(mt7925_mcu_set_eeprom);
1402
mt7925_mcu_uni_bss_ps(struct mt792x_dev * dev,struct ieee80211_bss_conf * link_conf)1403 int mt7925_mcu_uni_bss_ps(struct mt792x_dev *dev,
1404 struct ieee80211_bss_conf *link_conf)
1405 {
1406 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
1407 struct {
1408 struct {
1409 u8 bss_idx;
1410 u8 pad[3];
1411 } __packed hdr;
1412 struct ps_tlv {
1413 __le16 tag;
1414 __le16 len;
1415 u8 ps_state; /* 0: device awake
1416 * 1: static power save
1417 * 2: dynamic power saving
1418 * 3: enter TWT power saving
1419 * 4: leave TWT power saving
1420 */
1421 u8 pad[3];
1422 } __packed ps;
1423 } __packed ps_req = {
1424 .hdr = {
1425 .bss_idx = mconf->mt76.idx,
1426 },
1427 .ps = {
1428 .tag = cpu_to_le16(UNI_BSS_INFO_PS),
1429 .len = cpu_to_le16(sizeof(struct ps_tlv)),
1430 .ps_state = link_conf->vif->cfg.ps ? 2 : 0,
1431 },
1432 };
1433
1434 if (link_conf->vif->type != NL80211_IFTYPE_STATION)
1435 return -EOPNOTSUPP;
1436
1437 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1438 &ps_req, sizeof(ps_req), true);
1439 }
1440
1441 int
mt7925_mcu_uni_bss_bcnft(struct mt792x_dev * dev,struct ieee80211_bss_conf * link_conf,bool enable)1442 mt7925_mcu_uni_bss_bcnft(struct mt792x_dev *dev,
1443 struct ieee80211_bss_conf *link_conf, bool enable)
1444 {
1445 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
1446 struct {
1447 struct {
1448 u8 bss_idx;
1449 u8 pad[3];
1450 } __packed hdr;
1451 struct bcnft_tlv {
1452 __le16 tag;
1453 __le16 len;
1454 __le16 bcn_interval;
1455 u8 dtim_period;
1456 u8 bmc_delivered_ac;
1457 u8 bmc_triggered_ac;
1458 u8 pad[3];
1459 } __packed bcnft;
1460 } __packed bcnft_req = {
1461 .hdr = {
1462 .bss_idx = mconf->mt76.idx,
1463 },
1464 .bcnft = {
1465 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
1466 .len = cpu_to_le16(sizeof(struct bcnft_tlv)),
1467 .bcn_interval = cpu_to_le16(link_conf->beacon_int),
1468 .dtim_period = link_conf->dtim_period,
1469 },
1470 };
1471
1472 if (link_conf->vif->type != NL80211_IFTYPE_STATION)
1473 return 0;
1474
1475 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1476 &bcnft_req, sizeof(bcnft_req), true);
1477 }
1478
1479 int
mt7925_mcu_set_bss_pm(struct mt792x_dev * dev,struct ieee80211_bss_conf * link_conf,bool enable)1480 mt7925_mcu_set_bss_pm(struct mt792x_dev *dev,
1481 struct ieee80211_bss_conf *link_conf,
1482 bool enable)
1483 {
1484 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
1485 struct {
1486 struct {
1487 u8 bss_idx;
1488 u8 pad[3];
1489 } __packed hdr;
1490 struct bcnft_tlv {
1491 __le16 tag;
1492 __le16 len;
1493 __le16 bcn_interval;
1494 u8 dtim_period;
1495 u8 bmc_delivered_ac;
1496 u8 bmc_triggered_ac;
1497 u8 pad[3];
1498 } __packed enable;
1499 } req = {
1500 .hdr = {
1501 .bss_idx = mconf->mt76.idx,
1502 },
1503 .enable = {
1504 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
1505 .len = cpu_to_le16(sizeof(struct bcnft_tlv)),
1506 .dtim_period = link_conf->dtim_period,
1507 .bcn_interval = cpu_to_le16(link_conf->beacon_int),
1508 },
1509 };
1510 struct {
1511 struct {
1512 u8 bss_idx;
1513 u8 pad[3];
1514 } __packed hdr;
1515 struct pm_disable {
1516 __le16 tag;
1517 __le16 len;
1518 } __packed disable;
1519 } req1 = {
1520 .hdr = {
1521 .bss_idx = mconf->mt76.idx,
1522 },
1523 .disable = {
1524 .tag = cpu_to_le16(UNI_BSS_INFO_PM_DISABLE),
1525 .len = cpu_to_le16(sizeof(struct pm_disable))
1526 },
1527 };
1528 int err;
1529
1530 err = mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1531 &req1, sizeof(req1), true);
1532 if (err < 0 || !enable)
1533 return err;
1534
1535 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1536 &req, sizeof(req), true);
1537 }
1538
1539 static void
mt7925_mcu_sta_he_tlv(struct sk_buff * skb,struct ieee80211_link_sta * link_sta)1540 mt7925_mcu_sta_he_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1541 {
1542 if (!link_sta->he_cap.has_he)
1543 return;
1544
1545 mt76_connac_mcu_sta_he_tlv_v2(skb, link_sta->sta);
1546 }
1547
1548 static void
mt7925_mcu_sta_he_6g_tlv(struct sk_buff * skb,struct ieee80211_link_sta * link_sta)1549 mt7925_mcu_sta_he_6g_tlv(struct sk_buff *skb,
1550 struct ieee80211_link_sta *link_sta)
1551 {
1552 struct sta_rec_he_6g_capa *he_6g;
1553 struct tlv *tlv;
1554
1555 if (!link_sta->he_6ghz_capa.capa)
1556 return;
1557
1558 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HE_6G, sizeof(*he_6g));
1559
1560 he_6g = (struct sta_rec_he_6g_capa *)tlv;
1561 he_6g->capa = link_sta->he_6ghz_capa.capa;
1562 }
1563
1564 static void
mt7925_mcu_sta_eht_tlv(struct sk_buff * skb,struct ieee80211_link_sta * link_sta)1565 mt7925_mcu_sta_eht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1566 {
1567 struct ieee80211_eht_mcs_nss_supp *mcs_map;
1568 struct ieee80211_eht_cap_elem_fixed *elem;
1569 struct sta_rec_eht *eht;
1570 struct tlv *tlv;
1571
1572 if (!link_sta->eht_cap.has_eht)
1573 return;
1574
1575 mcs_map = &link_sta->eht_cap.eht_mcs_nss_supp;
1576 elem = &link_sta->eht_cap.eht_cap_elem;
1577
1578 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT, sizeof(*eht));
1579
1580 eht = (struct sta_rec_eht *)tlv;
1581 eht->tid_bitmap = 0xff;
1582 eht->mac_cap = cpu_to_le16(*(u16 *)elem->mac_cap_info);
1583 eht->phy_cap = cpu_to_le64(*(u64 *)elem->phy_cap_info);
1584 eht->phy_cap_ext = cpu_to_le64(elem->phy_cap_info[8]);
1585
1586 if (link_sta->bandwidth == IEEE80211_STA_RX_BW_20)
1587 memcpy(eht->mcs_map_bw20, &mcs_map->only_20mhz, sizeof(eht->mcs_map_bw20));
1588 memcpy(eht->mcs_map_bw80, &mcs_map->bw._80, sizeof(eht->mcs_map_bw80));
1589 memcpy(eht->mcs_map_bw160, &mcs_map->bw._160, sizeof(eht->mcs_map_bw160));
1590 }
1591
1592 static void
mt7925_mcu_sta_ht_tlv(struct sk_buff * skb,struct ieee80211_link_sta * link_sta)1593 mt7925_mcu_sta_ht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1594 {
1595 struct sta_rec_ht *ht;
1596 struct tlv *tlv;
1597
1598 if (!link_sta->ht_cap.ht_supported)
1599 return;
1600
1601 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HT, sizeof(*ht));
1602
1603 ht = (struct sta_rec_ht *)tlv;
1604 ht->ht_cap = cpu_to_le16(link_sta->ht_cap.cap);
1605 }
1606
1607 static void
mt7925_mcu_sta_vht_tlv(struct sk_buff * skb,struct ieee80211_link_sta * link_sta)1608 mt7925_mcu_sta_vht_tlv(struct sk_buff *skb, struct ieee80211_link_sta *link_sta)
1609 {
1610 struct sta_rec_vht *vht;
1611 struct tlv *tlv;
1612
1613 /* For 6G band, this tlv is necessary to let hw work normally */
1614 if (!link_sta->he_6ghz_capa.capa && !link_sta->vht_cap.vht_supported)
1615 return;
1616
1617 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_VHT, sizeof(*vht));
1618
1619 vht = (struct sta_rec_vht *)tlv;
1620 vht->vht_cap = cpu_to_le32(link_sta->vht_cap.cap);
1621 vht->vht_rx_mcs_map = link_sta->vht_cap.vht_mcs.rx_mcs_map;
1622 vht->vht_tx_mcs_map = link_sta->vht_cap.vht_mcs.tx_mcs_map;
1623 }
1624
1625 static void
mt7925_mcu_sta_amsdu_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_link_sta * link_sta)1626 mt7925_mcu_sta_amsdu_tlv(struct sk_buff *skb,
1627 struct ieee80211_vif *vif,
1628 struct ieee80211_link_sta *link_sta)
1629 {
1630 struct mt792x_sta *msta = (struct mt792x_sta *)link_sta->sta->drv_priv;
1631 struct mt792x_link_sta *mlink;
1632 struct sta_rec_amsdu *amsdu;
1633 struct tlv *tlv;
1634
1635 if (vif->type != NL80211_IFTYPE_STATION &&
1636 vif->type != NL80211_IFTYPE_AP)
1637 return;
1638
1639 if (!link_sta->agg.max_amsdu_len)
1640 return;
1641
1642 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_HW_AMSDU, sizeof(*amsdu));
1643 amsdu = (struct sta_rec_amsdu *)tlv;
1644 amsdu->max_amsdu_num = 8;
1645 amsdu->amsdu_en = true;
1646
1647 mlink = mt792x_sta_to_link(msta, link_sta->link_id);
1648 mlink->wcid.amsdu = true;
1649
1650 switch (link_sta->agg.max_amsdu_len) {
1651 case IEEE80211_MAX_MPDU_LEN_VHT_11454:
1652 amsdu->max_mpdu_size =
1653 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
1654 return;
1655 case IEEE80211_MAX_MPDU_LEN_HT_7935:
1656 case IEEE80211_MAX_MPDU_LEN_VHT_7991:
1657 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
1658 return;
1659 default:
1660 amsdu->max_mpdu_size = IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
1661 return;
1662 }
1663 }
1664
1665 static void
mt7925_mcu_sta_phy_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_link_sta * link_sta)1666 mt7925_mcu_sta_phy_tlv(struct sk_buff *skb,
1667 struct ieee80211_vif *vif,
1668 struct ieee80211_link_sta *link_sta)
1669 {
1670 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1671 struct ieee80211_bss_conf *link_conf;
1672 struct cfg80211_chan_def *chandef;
1673 struct mt792x_bss_conf *mconf;
1674 struct sta_rec_phy *phy;
1675 struct tlv *tlv;
1676 u8 af = 0, mm = 0;
1677
1678 link_conf = mt792x_vif_to_bss_conf(vif, link_sta->link_id);
1679 mconf = mt792x_vif_to_link(mvif, link_sta->link_id);
1680 chandef = mconf->mt76.ctx ? &mconf->mt76.ctx->def :
1681 &link_conf->chanreq.oper;
1682
1683 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_PHY, sizeof(*phy));
1684 phy = (struct sta_rec_phy *)tlv;
1685 phy->phy_type = mt76_connac_get_phy_mode_v2(mvif->phy->mt76, vif,
1686 chandef->chan->band,
1687 link_sta);
1688 phy->basic_rate = cpu_to_le16((u16)link_conf->basic_rates);
1689 if (link_sta->ht_cap.ht_supported) {
1690 af = link_sta->ht_cap.ampdu_factor;
1691 mm = link_sta->ht_cap.ampdu_density;
1692 }
1693
1694 if (link_sta->vht_cap.vht_supported) {
1695 u8 vht_af = FIELD_GET(IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK,
1696 link_sta->vht_cap.cap);
1697
1698 af = max_t(u8, af, vht_af);
1699 }
1700
1701 if (link_sta->he_6ghz_capa.capa) {
1702 af = le16_get_bits(link_sta->he_6ghz_capa.capa,
1703 IEEE80211_HE_6GHZ_CAP_MAX_AMPDU_LEN_EXP);
1704 mm = le16_get_bits(link_sta->he_6ghz_capa.capa,
1705 IEEE80211_HE_6GHZ_CAP_MIN_MPDU_START);
1706 }
1707
1708 phy->ampdu = FIELD_PREP(IEEE80211_HT_AMPDU_PARM_FACTOR, af) |
1709 FIELD_PREP(IEEE80211_HT_AMPDU_PARM_DENSITY, mm);
1710 phy->max_ampdu_len = af;
1711 }
1712
1713 static void
mt7925_mcu_sta_state_v2_tlv(struct mt76_phy * mphy,struct sk_buff * skb,struct ieee80211_link_sta * link_sta,struct ieee80211_vif * vif,u8 rcpi,u8 sta_state)1714 mt7925_mcu_sta_state_v2_tlv(struct mt76_phy *mphy, struct sk_buff *skb,
1715 struct ieee80211_link_sta *link_sta,
1716 struct ieee80211_vif *vif,
1717 u8 rcpi, u8 sta_state)
1718 {
1719 struct sta_rec_state_v2 {
1720 __le16 tag;
1721 __le16 len;
1722 u8 state;
1723 u8 rsv[3];
1724 __le32 flags;
1725 u8 vht_opmode;
1726 u8 action;
1727 u8 rsv2[2];
1728 } __packed * state;
1729 struct tlv *tlv;
1730
1731 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_STATE, sizeof(*state));
1732 state = (struct sta_rec_state_v2 *)tlv;
1733 state->state = sta_state;
1734
1735 if (link_sta->vht_cap.vht_supported) {
1736 state->vht_opmode = link_sta->bandwidth;
1737 state->vht_opmode |= link_sta->rx_nss <<
1738 IEEE80211_OPMODE_NOTIF_RX_NSS_SHIFT;
1739 }
1740 }
1741
1742 static void
mt7925_mcu_sta_rate_ctrl_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_link_sta * link_sta)1743 mt7925_mcu_sta_rate_ctrl_tlv(struct sk_buff *skb,
1744 struct ieee80211_vif *vif,
1745 struct ieee80211_link_sta *link_sta)
1746 {
1747 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1748 struct ieee80211_bss_conf *link_conf;
1749 struct cfg80211_chan_def *chandef;
1750 struct sta_rec_ra_info *ra_info;
1751 struct mt792x_bss_conf *mconf;
1752 enum nl80211_band band;
1753 struct tlv *tlv;
1754 u16 supp_rates;
1755
1756 link_conf = mt792x_vif_to_bss_conf(vif, link_sta->link_id);
1757 mconf = mt792x_vif_to_link(mvif, link_sta->link_id);
1758 chandef = mconf->mt76.ctx ? &mconf->mt76.ctx->def :
1759 &link_conf->chanreq.oper;
1760 band = chandef->chan->band;
1761
1762 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_RA, sizeof(*ra_info));
1763 ra_info = (struct sta_rec_ra_info *)tlv;
1764
1765 supp_rates = link_sta->supp_rates[band];
1766 if (band == NL80211_BAND_2GHZ)
1767 supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates >> 4) |
1768 FIELD_PREP(RA_LEGACY_CCK, supp_rates & 0xf);
1769 else
1770 supp_rates = FIELD_PREP(RA_LEGACY_OFDM, supp_rates);
1771
1772 ra_info->legacy = cpu_to_le16(supp_rates);
1773
1774 if (link_sta->ht_cap.ht_supported)
1775 memcpy(ra_info->rx_mcs_bitmask,
1776 link_sta->ht_cap.mcs.rx_mask,
1777 HT_MCS_MASK_NUM);
1778 }
1779
1780 static void
mt7925_mcu_sta_eht_mld_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1781 mt7925_mcu_sta_eht_mld_tlv(struct sk_buff *skb,
1782 struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1783 {
1784 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1785 struct wiphy *wiphy = mvif->phy->mt76->hw->wiphy;
1786 const struct wiphy_iftype_ext_capab *ext_capa;
1787 struct sta_rec_eht_mld *eht_mld;
1788 struct tlv *tlv;
1789 u16 eml_cap;
1790
1791 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_EHT_MLD, sizeof(*eht_mld));
1792 eht_mld = (struct sta_rec_eht_mld *)tlv;
1793 eht_mld->mld_type = 0xff;
1794
1795 if (!ieee80211_vif_is_mld(vif))
1796 return;
1797
1798 ext_capa = cfg80211_get_iftype_ext_capa(wiphy,
1799 ieee80211_vif_type_p2p(vif));
1800 if (!ext_capa)
1801 return;
1802
1803 eml_cap = (vif->cfg.eml_cap & (IEEE80211_EML_CAP_EMLSR_SUPP |
1804 IEEE80211_EML_CAP_TRANSITION_TIMEOUT)) |
1805 (ext_capa->eml_capabilities & (IEEE80211_EML_CAP_EMLSR_PADDING_DELAY |
1806 IEEE80211_EML_CAP_EMLSR_TRANSITION_DELAY));
1807
1808 if (eml_cap & IEEE80211_EML_CAP_EMLSR_SUPP) {
1809 eht_mld->eml_cap[0] = u16_get_bits(eml_cap, GENMASK(7, 0));
1810 eht_mld->eml_cap[1] = u16_get_bits(eml_cap, GENMASK(15, 8));
1811 } else {
1812 eht_mld->str_cap[0] = BIT(1);
1813 }
1814 }
1815
1816 static void
mt7925_mcu_sta_mld_tlv(struct sk_buff * skb,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1817 mt7925_mcu_sta_mld_tlv(struct sk_buff *skb,
1818 struct ieee80211_vif *vif, struct ieee80211_sta *sta)
1819 {
1820 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1821 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv;
1822 unsigned long valid = mvif->valid_links;
1823 struct mt792x_bss_conf *mconf;
1824 struct mt792x_link_sta *mlink;
1825 struct sta_rec_mld *mld;
1826 struct tlv *tlv;
1827 int i, cnt = 0;
1828
1829 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_MLD, sizeof(*mld));
1830 mld = (struct sta_rec_mld *)tlv;
1831 memcpy(mld->mac_addr, sta->addr, ETH_ALEN);
1832 mld->primary_id = cpu_to_le16(msta->deflink.wcid.idx);
1833 mld->wlan_id = cpu_to_le16(msta->deflink.wcid.idx);
1834 mld->link_num = min_t(u8, hweight16(mvif->valid_links), 2);
1835
1836 for_each_set_bit(i, &valid, IEEE80211_MLD_MAX_NUM_LINKS) {
1837 if (cnt == mld->link_num)
1838 break;
1839
1840 mconf = mt792x_vif_to_link(mvif, i);
1841 mlink = mt792x_sta_to_link(msta, i);
1842 mld->link[cnt].wlan_id = cpu_to_le16(mlink->wcid.idx);
1843 mld->link[cnt++].bss_idx = mconf->mt76.idx;
1844
1845 if (mlink != &msta->deflink)
1846 mld->secondary_id = cpu_to_le16(mlink->wcid.idx);
1847 }
1848 }
1849
1850 static int
mt7925_mcu_sta_cmd(struct mt76_phy * phy,struct mt76_sta_cmd_info * info)1851 mt7925_mcu_sta_cmd(struct mt76_phy *phy,
1852 struct mt76_sta_cmd_info *info)
1853 {
1854 struct mt76_vif *mvif = (struct mt76_vif *)info->vif->drv_priv;
1855 struct mt76_dev *dev = phy->dev;
1856 struct sk_buff *skb;
1857 int conn_state;
1858
1859 skb = __mt76_connac_mcu_alloc_sta_req(dev, mvif, info->wcid,
1860 MT7925_STA_UPDATE_MAX_SIZE);
1861 if (IS_ERR(skb))
1862 return PTR_ERR(skb);
1863
1864 conn_state = info->enable ? CONN_STATE_PORT_SECURE :
1865 CONN_STATE_DISCONNECT;
1866 if (info->link_sta)
1867 mt76_connac_mcu_sta_basic_tlv(dev, skb, info->vif,
1868 info->link_sta,
1869 conn_state, info->newly);
1870 if (info->link_sta && info->enable) {
1871 mt7925_mcu_sta_phy_tlv(skb, info->vif, info->link_sta);
1872 mt7925_mcu_sta_ht_tlv(skb, info->link_sta);
1873 mt7925_mcu_sta_vht_tlv(skb, info->link_sta);
1874 mt76_connac_mcu_sta_uapsd(skb, info->vif, info->link_sta->sta);
1875 mt7925_mcu_sta_amsdu_tlv(skb, info->vif, info->link_sta);
1876 mt7925_mcu_sta_he_tlv(skb, info->link_sta);
1877 mt7925_mcu_sta_he_6g_tlv(skb, info->link_sta);
1878 mt7925_mcu_sta_eht_tlv(skb, info->link_sta);
1879 mt7925_mcu_sta_rate_ctrl_tlv(skb, info->vif,
1880 info->link_sta);
1881 mt7925_mcu_sta_state_v2_tlv(phy, skb, info->link_sta,
1882 info->vif, info->rcpi,
1883 info->state);
1884 mt7925_mcu_sta_mld_tlv(skb, info->vif, info->link_sta->sta);
1885 }
1886
1887 if (info->enable)
1888 mt7925_mcu_sta_hdr_trans_tlv(skb, info->vif, info->link_sta);
1889
1890 return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true);
1891 }
1892
1893 static void
mt7925_mcu_sta_remove_tlv(struct sk_buff * skb)1894 mt7925_mcu_sta_remove_tlv(struct sk_buff *skb)
1895 {
1896 struct sta_rec_remove *rem;
1897 struct tlv *tlv;
1898
1899 tlv = mt76_connac_mcu_add_tlv(skb, 0x25, sizeof(*rem));
1900 rem = (struct sta_rec_remove *)tlv;
1901 rem->action = 0;
1902 }
1903
1904 static int
mt7925_mcu_mlo_sta_cmd(struct mt76_phy * phy,struct mt76_sta_cmd_info * info)1905 mt7925_mcu_mlo_sta_cmd(struct mt76_phy *phy,
1906 struct mt76_sta_cmd_info *info)
1907 {
1908 struct mt792x_vif *mvif = (struct mt792x_vif *)info->vif->drv_priv;
1909 struct mt76_dev *dev = phy->dev;
1910 struct mt792x_bss_conf *mconf;
1911 struct sk_buff *skb;
1912
1913 mconf = mt792x_vif_to_link(mvif, info->wcid->link_id);
1914
1915 skb = __mt76_connac_mcu_alloc_sta_req(dev, &mconf->mt76, info->wcid,
1916 MT7925_STA_UPDATE_MAX_SIZE);
1917 if (IS_ERR(skb))
1918 return PTR_ERR(skb);
1919
1920 if (info->enable)
1921 mt76_connac_mcu_sta_basic_tlv(dev, skb, info->vif,
1922 info->link_sta,
1923 info->enable, info->newly);
1924
1925 if (info->enable && info->link_sta) {
1926 mt7925_mcu_sta_phy_tlv(skb, info->vif, info->link_sta);
1927 mt7925_mcu_sta_ht_tlv(skb, info->link_sta);
1928 mt7925_mcu_sta_vht_tlv(skb, info->link_sta);
1929 mt76_connac_mcu_sta_uapsd(skb, info->vif, info->link_sta->sta);
1930 mt7925_mcu_sta_amsdu_tlv(skb, info->vif, info->link_sta);
1931 mt7925_mcu_sta_he_tlv(skb, info->link_sta);
1932 mt7925_mcu_sta_he_6g_tlv(skb, info->link_sta);
1933 mt7925_mcu_sta_eht_tlv(skb, info->link_sta);
1934 mt7925_mcu_sta_rate_ctrl_tlv(skb, info->vif,
1935 info->link_sta);
1936 mt7925_mcu_sta_state_v2_tlv(phy, skb, info->link_sta,
1937 info->vif, info->rcpi,
1938 info->state);
1939
1940 if (info->state != MT76_STA_INFO_STATE_NONE) {
1941 mt7925_mcu_sta_mld_tlv(skb, info->vif, info->link_sta->sta);
1942 mt7925_mcu_sta_eht_mld_tlv(skb, info->vif, info->link_sta->sta);
1943 }
1944
1945 mt7925_mcu_sta_hdr_trans_tlv(skb, info->vif, info->link_sta);
1946 }
1947
1948 if (!info->enable) {
1949 mt7925_mcu_sta_remove_tlv(skb);
1950 mt76_connac_mcu_add_tlv(skb, STA_REC_MLD_OFF,
1951 sizeof(struct tlv));
1952 }
1953
1954 return mt76_mcu_skb_send_msg(dev, skb, info->cmd, true);
1955 }
1956
mt7925_mcu_sta_update(struct mt792x_dev * dev,struct ieee80211_link_sta * link_sta,struct ieee80211_vif * vif,bool enable,enum mt76_sta_info_state state)1957 int mt7925_mcu_sta_update(struct mt792x_dev *dev,
1958 struct ieee80211_link_sta *link_sta,
1959 struct ieee80211_vif *vif, bool enable,
1960 enum mt76_sta_info_state state)
1961 {
1962 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1963 int rssi = -ewma_rssi_read(&mvif->bss_conf.rssi);
1964 struct mt76_sta_cmd_info info = {
1965 .link_sta = link_sta,
1966 .vif = vif,
1967 .enable = enable,
1968 .cmd = MCU_UNI_CMD(STA_REC_UPDATE),
1969 .state = state,
1970 .offload_fw = true,
1971 .rcpi = to_rcpi(rssi),
1972 };
1973 struct mt792x_sta *msta;
1974 struct mt792x_link_sta *mlink;
1975 int err;
1976
1977 if (link_sta) {
1978 msta = (struct mt792x_sta *)link_sta->sta->drv_priv;
1979 mlink = mt792x_sta_to_link(msta, link_sta->link_id);
1980 }
1981 info.wcid = link_sta ? &mlink->wcid : &mvif->sta.deflink.wcid;
1982
1983 if (link_sta)
1984 info.newly = state != MT76_STA_INFO_STATE_ASSOC;
1985 else
1986 info.newly = state == MT76_STA_INFO_STATE_ASSOC ? false : true;
1987
1988 if (ieee80211_vif_is_mld(vif))
1989 err = mt7925_mcu_mlo_sta_cmd(&dev->mphy, &info);
1990 else
1991 err = mt7925_mcu_sta_cmd(&dev->mphy, &info);
1992
1993 return err;
1994 }
1995
mt7925_mcu_set_beacon_filter(struct mt792x_dev * dev,struct ieee80211_vif * vif,bool enable)1996 int mt7925_mcu_set_beacon_filter(struct mt792x_dev *dev,
1997 struct ieee80211_vif *vif,
1998 bool enable)
1999 {
2000 #define MT7925_FIF_BIT_CLR BIT(1)
2001 #define MT7925_FIF_BIT_SET BIT(0)
2002 int err = 0;
2003
2004 if (enable) {
2005 err = mt7925_mcu_uni_bss_bcnft(dev, &vif->bss_conf, true);
2006 if (err < 0)
2007 return err;
2008
2009 return mt7925_mcu_set_rxfilter(dev, 0,
2010 MT7925_FIF_BIT_SET,
2011 MT_WF_RFCR_DROP_OTHER_BEACON);
2012 }
2013
2014 err = mt7925_mcu_set_bss_pm(dev, &vif->bss_conf, false);
2015 if (err < 0)
2016 return err;
2017
2018 return mt7925_mcu_set_rxfilter(dev, 0,
2019 MT7925_FIF_BIT_CLR,
2020 MT_WF_RFCR_DROP_OTHER_BEACON);
2021 }
2022
mt7925_get_txpwr_info(struct mt792x_dev * dev,u8 band_idx,struct mt7925_txpwr * txpwr)2023 int mt7925_get_txpwr_info(struct mt792x_dev *dev, u8 band_idx, struct mt7925_txpwr *txpwr)
2024 {
2025 #define TX_POWER_SHOW_INFO 0x7
2026 #define TXPOWER_ALL_RATE_POWER_INFO 0x2
2027 struct mt7925_txpwr_event *event;
2028 struct mt7925_txpwr_req req = {
2029 .tag = cpu_to_le16(TX_POWER_SHOW_INFO),
2030 .len = cpu_to_le16(sizeof(req) - 4),
2031 .catg = TXPOWER_ALL_RATE_POWER_INFO,
2032 .band_idx = band_idx,
2033 };
2034 struct sk_buff *skb;
2035 int ret;
2036
2037 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_UNI_CMD(TXPOWER),
2038 &req, sizeof(req), true, &skb);
2039 if (ret)
2040 return ret;
2041
2042 event = (struct mt7925_txpwr_event *)skb->data;
2043 memcpy(txpwr, &event->txpwr, sizeof(event->txpwr));
2044
2045 dev_kfree_skb(skb);
2046
2047 return 0;
2048 }
2049
mt7925_mcu_set_sniffer(struct mt792x_dev * dev,struct ieee80211_vif * vif,bool enable)2050 int mt7925_mcu_set_sniffer(struct mt792x_dev *dev, struct ieee80211_vif *vif,
2051 bool enable)
2052 {
2053 struct {
2054 struct {
2055 u8 band_idx;
2056 u8 pad[3];
2057 } __packed hdr;
2058 struct sniffer_enable_tlv {
2059 __le16 tag;
2060 __le16 len;
2061 u8 enable;
2062 u8 pad[3];
2063 } __packed enable;
2064 } __packed req = {
2065 .hdr = {
2066 .band_idx = 0,
2067 },
2068 .enable = {
2069 .tag = cpu_to_le16(UNI_SNIFFER_ENABLE),
2070 .len = cpu_to_le16(sizeof(struct sniffer_enable_tlv)),
2071 .enable = enable,
2072 },
2073 };
2074
2075 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(SNIFFER), &req, sizeof(req),
2076 true);
2077 }
2078
mt7925_mcu_config_sniffer(struct mt792x_vif * vif,struct ieee80211_chanctx_conf * ctx)2079 int mt7925_mcu_config_sniffer(struct mt792x_vif *vif,
2080 struct ieee80211_chanctx_conf *ctx)
2081 {
2082 struct mt76_phy *mphy = vif->phy->mt76;
2083 struct cfg80211_chan_def *chandef = ctx ? &ctx->def : &mphy->chandef;
2084 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2;
2085
2086 static const u8 ch_band[] = {
2087 [NL80211_BAND_2GHZ] = 1,
2088 [NL80211_BAND_5GHZ] = 2,
2089 [NL80211_BAND_6GHZ] = 3,
2090 };
2091 static const u8 ch_width[] = {
2092 [NL80211_CHAN_WIDTH_20_NOHT] = 0,
2093 [NL80211_CHAN_WIDTH_20] = 0,
2094 [NL80211_CHAN_WIDTH_40] = 0,
2095 [NL80211_CHAN_WIDTH_80] = 1,
2096 [NL80211_CHAN_WIDTH_160] = 2,
2097 [NL80211_CHAN_WIDTH_80P80] = 3,
2098 [NL80211_CHAN_WIDTH_5] = 4,
2099 [NL80211_CHAN_WIDTH_10] = 5,
2100 [NL80211_CHAN_WIDTH_320] = 6,
2101 };
2102
2103 struct {
2104 struct {
2105 u8 band_idx;
2106 u8 pad[3];
2107 } __packed hdr;
2108 struct config_tlv {
2109 __le16 tag;
2110 __le16 len;
2111 u16 aid;
2112 u8 ch_band;
2113 u8 bw;
2114 u8 control_ch;
2115 u8 sco;
2116 u8 center_ch;
2117 u8 center_ch2;
2118 u8 drop_err;
2119 u8 pad[3];
2120 } __packed tlv;
2121 } __packed req = {
2122 .hdr = {
2123 .band_idx = 0,
2124 },
2125 .tlv = {
2126 .tag = cpu_to_le16(UNI_SNIFFER_CONFIG),
2127 .len = cpu_to_le16(sizeof(req.tlv)),
2128 .control_ch = chandef->chan->hw_value,
2129 .center_ch = ieee80211_frequency_to_channel(freq1),
2130 .drop_err = 1,
2131 },
2132 };
2133
2134 if (chandef->chan->band < ARRAY_SIZE(ch_band))
2135 req.tlv.ch_band = ch_band[chandef->chan->band];
2136 if (chandef->width < ARRAY_SIZE(ch_width))
2137 req.tlv.bw = ch_width[chandef->width];
2138
2139 if (freq2)
2140 req.tlv.center_ch2 = ieee80211_frequency_to_channel(freq2);
2141
2142 if (req.tlv.control_ch < req.tlv.center_ch)
2143 req.tlv.sco = 1; /* SCA */
2144 else if (req.tlv.control_ch > req.tlv.center_ch)
2145 req.tlv.sco = 3; /* SCB */
2146
2147 return mt76_mcu_send_msg(mphy->dev, MCU_UNI_CMD(SNIFFER),
2148 &req, sizeof(req), true);
2149 }
2150
2151 int
mt7925_mcu_uni_add_beacon_offload(struct mt792x_dev * dev,struct ieee80211_hw * hw,struct ieee80211_vif * vif,bool enable)2152 mt7925_mcu_uni_add_beacon_offload(struct mt792x_dev *dev,
2153 struct ieee80211_hw *hw,
2154 struct ieee80211_vif *vif,
2155 bool enable)
2156 {
2157 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
2158 struct ieee80211_mutable_offsets offs;
2159 struct {
2160 struct req_hdr {
2161 u8 bss_idx;
2162 u8 pad[3];
2163 } __packed hdr;
2164 struct bcn_content_tlv {
2165 __le16 tag;
2166 __le16 len;
2167 __le16 tim_ie_pos;
2168 __le16 csa_ie_pos;
2169 __le16 bcc_ie_pos;
2170 /* 0: disable beacon offload
2171 * 1: enable beacon offload
2172 * 2: update probe respond offload
2173 */
2174 u8 enable;
2175 /* 0: legacy format (TXD + payload)
2176 * 1: only cap field IE
2177 */
2178 u8 type;
2179 __le16 pkt_len;
2180 u8 pkt[512];
2181 } __packed beacon_tlv;
2182 } req = {
2183 .hdr = {
2184 .bss_idx = mvif->bss_conf.mt76.idx,
2185 },
2186 .beacon_tlv = {
2187 .tag = cpu_to_le16(UNI_BSS_INFO_BCN_CONTENT),
2188 .len = cpu_to_le16(sizeof(struct bcn_content_tlv)),
2189 .enable = enable,
2190 .type = 1,
2191 },
2192 };
2193 struct sk_buff *skb;
2194 u8 cap_offs;
2195
2196 /* support enable/update process only
2197 * disable flow would be handled in bss stop handler automatically
2198 */
2199 if (!enable)
2200 return -EOPNOTSUPP;
2201
2202 skb = ieee80211_beacon_get_template(mt76_hw(dev), vif, &offs, 0);
2203 if (!skb)
2204 return -EINVAL;
2205
2206 cap_offs = offsetof(struct ieee80211_mgmt, u.beacon.capab_info);
2207 if (!skb_pull(skb, cap_offs)) {
2208 dev_err(dev->mt76.dev, "beacon format err\n");
2209 dev_kfree_skb(skb);
2210 return -EINVAL;
2211 }
2212
2213 if (skb->len > 512) {
2214 dev_err(dev->mt76.dev, "beacon size limit exceed\n");
2215 dev_kfree_skb(skb);
2216 return -EINVAL;
2217 }
2218
2219 memcpy(req.beacon_tlv.pkt, skb->data, skb->len);
2220 req.beacon_tlv.pkt_len = cpu_to_le16(skb->len);
2221 offs.tim_offset -= cap_offs;
2222 req.beacon_tlv.tim_ie_pos = cpu_to_le16(offs.tim_offset);
2223
2224 if (offs.cntdwn_counter_offs[0]) {
2225 u16 csa_offs;
2226
2227 csa_offs = offs.cntdwn_counter_offs[0] - cap_offs - 4;
2228 req.beacon_tlv.csa_ie_pos = cpu_to_le16(csa_offs);
2229 }
2230 dev_kfree_skb(skb);
2231
2232 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
2233 &req, sizeof(req), true);
2234 }
2235
2236 static
mt7925_mcu_bss_rlm_tlv(struct sk_buff * skb,struct mt76_phy * phy,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)2237 void mt7925_mcu_bss_rlm_tlv(struct sk_buff *skb, struct mt76_phy *phy,
2238 struct ieee80211_bss_conf *link_conf,
2239 struct ieee80211_chanctx_conf *ctx)
2240 {
2241 struct cfg80211_chan_def *chandef = ctx ? &ctx->def :
2242 &link_conf->chanreq.oper;
2243 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2;
2244 enum nl80211_band band = chandef->chan->band;
2245 struct bss_rlm_tlv *req;
2246 struct tlv *tlv;
2247
2248 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_RLM, sizeof(*req));
2249 req = (struct bss_rlm_tlv *)tlv;
2250 req->control_channel = chandef->chan->hw_value;
2251 req->center_chan = ieee80211_frequency_to_channel(freq1);
2252 req->center_chan2 = 0;
2253 req->tx_streams = hweight8(phy->antenna_mask);
2254 req->ht_op_info = 4; /* set HT 40M allowed */
2255 req->rx_streams = hweight8(phy->antenna_mask);
2256 req->center_chan2 = 0;
2257 req->sco = 0;
2258 req->band = 1;
2259
2260 switch (band) {
2261 case NL80211_BAND_2GHZ:
2262 req->band = 1;
2263 break;
2264 case NL80211_BAND_5GHZ:
2265 req->band = 2;
2266 break;
2267 case NL80211_BAND_6GHZ:
2268 req->band = 3;
2269 break;
2270 default:
2271 break;
2272 }
2273
2274 switch (chandef->width) {
2275 case NL80211_CHAN_WIDTH_40:
2276 req->bw = CMD_CBW_40MHZ;
2277 break;
2278 case NL80211_CHAN_WIDTH_80:
2279 req->bw = CMD_CBW_80MHZ;
2280 break;
2281 case NL80211_CHAN_WIDTH_80P80:
2282 req->bw = CMD_CBW_8080MHZ;
2283 req->center_chan2 = ieee80211_frequency_to_channel(freq2);
2284 break;
2285 case NL80211_CHAN_WIDTH_160:
2286 req->bw = CMD_CBW_160MHZ;
2287 break;
2288 case NL80211_CHAN_WIDTH_5:
2289 req->bw = CMD_CBW_5MHZ;
2290 break;
2291 case NL80211_CHAN_WIDTH_10:
2292 req->bw = CMD_CBW_10MHZ;
2293 break;
2294 case NL80211_CHAN_WIDTH_20_NOHT:
2295 case NL80211_CHAN_WIDTH_20:
2296 default:
2297 req->bw = CMD_CBW_20MHZ;
2298 req->ht_op_info = 0;
2299 break;
2300 }
2301
2302 if (req->control_channel < req->center_chan)
2303 req->sco = 1; /* SCA */
2304 else if (req->control_channel > req->center_chan)
2305 req->sco = 3; /* SCB */
2306 }
2307
2308 static struct sk_buff *
__mt7925_mcu_alloc_bss_req(struct mt76_dev * dev,struct mt76_vif * mvif,int len)2309 __mt7925_mcu_alloc_bss_req(struct mt76_dev *dev, struct mt76_vif *mvif, int len)
2310 {
2311 struct bss_req_hdr hdr = {
2312 .bss_idx = mvif->idx,
2313 };
2314 struct sk_buff *skb;
2315
2316 skb = mt76_mcu_msg_alloc(dev, NULL, len);
2317 if (!skb)
2318 return ERR_PTR(-ENOMEM);
2319
2320 skb_put_data(skb, &hdr, sizeof(hdr));
2321
2322 return skb;
2323 }
2324
mt7925_mcu_set_chctx(struct mt76_phy * phy,struct mt76_vif * mvif,struct ieee80211_bss_conf * link_conf,struct ieee80211_chanctx_conf * ctx)2325 int mt7925_mcu_set_chctx(struct mt76_phy *phy, struct mt76_vif *mvif,
2326 struct ieee80211_bss_conf *link_conf,
2327 struct ieee80211_chanctx_conf *ctx)
2328 {
2329 struct sk_buff *skb;
2330
2331 skb = __mt7925_mcu_alloc_bss_req(phy->dev, mvif,
2332 MT7925_BSS_UPDATE_MAX_SIZE);
2333 if (IS_ERR(skb))
2334 return PTR_ERR(skb);
2335
2336 mt7925_mcu_bss_rlm_tlv(skb, phy, link_conf, ctx);
2337
2338 return mt76_mcu_skb_send_msg(phy->dev, skb,
2339 MCU_UNI_CMD(BSS_INFO_UPDATE), true);
2340 }
2341
2342 static u8
mt7925_get_phy_mode_ext(struct mt76_phy * phy,struct ieee80211_vif * vif,enum nl80211_band band,struct ieee80211_link_sta * link_sta)2343 mt7925_get_phy_mode_ext(struct mt76_phy *phy, struct ieee80211_vif *vif,
2344 enum nl80211_band band,
2345 struct ieee80211_link_sta *link_sta)
2346 {
2347 struct ieee80211_he_6ghz_capa *he_6ghz_capa;
2348 const struct ieee80211_sta_eht_cap *eht_cap;
2349 __le16 capa = 0;
2350 u8 mode = 0;
2351
2352 if (link_sta) {
2353 he_6ghz_capa = &link_sta->he_6ghz_capa;
2354 eht_cap = &link_sta->eht_cap;
2355 } else {
2356 struct ieee80211_supported_band *sband;
2357
2358 sband = phy->hw->wiphy->bands[band];
2359 capa = ieee80211_get_he_6ghz_capa(sband, vif->type);
2360 he_6ghz_capa = (struct ieee80211_he_6ghz_capa *)&capa;
2361
2362 eht_cap = ieee80211_get_eht_iftype_cap(sband, vif->type);
2363 }
2364
2365 switch (band) {
2366 case NL80211_BAND_2GHZ:
2367 if (eht_cap && eht_cap->has_eht)
2368 mode |= PHY_MODE_BE_24G;
2369 break;
2370 case NL80211_BAND_5GHZ:
2371 if (eht_cap && eht_cap->has_eht)
2372 mode |= PHY_MODE_BE_5G;
2373 break;
2374 case NL80211_BAND_6GHZ:
2375 if (he_6ghz_capa && he_6ghz_capa->capa)
2376 mode |= PHY_MODE_AX_6G;
2377
2378 if (eht_cap && eht_cap->has_eht)
2379 mode |= PHY_MODE_BE_6G;
2380 break;
2381 default:
2382 break;
2383 }
2384
2385 return mode;
2386 }
2387
2388 static void
mt7925_mcu_bss_basic_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf,struct ieee80211_link_sta * link_sta,struct ieee80211_chanctx_conf * ctx,struct mt76_phy * phy,u16 wlan_idx,bool enable)2389 mt7925_mcu_bss_basic_tlv(struct sk_buff *skb,
2390 struct ieee80211_bss_conf *link_conf,
2391 struct ieee80211_link_sta *link_sta,
2392 struct ieee80211_chanctx_conf *ctx,
2393 struct mt76_phy *phy, u16 wlan_idx,
2394 bool enable)
2395 {
2396 struct ieee80211_vif *vif = link_conf->vif;
2397 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2398 struct cfg80211_chan_def *chandef = ctx ? &ctx->def :
2399 &link_conf->chanreq.oper;
2400 enum nl80211_band band = chandef->chan->band;
2401 struct mt76_connac_bss_basic_tlv *basic_req;
2402 struct mt792x_link_sta *mlink;
2403 struct tlv *tlv;
2404 int conn_type;
2405 u8 idx;
2406
2407 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BASIC, sizeof(*basic_req));
2408 basic_req = (struct mt76_connac_bss_basic_tlv *)tlv;
2409
2410 idx = mconf->mt76.omac_idx > EXT_BSSID_START ? HW_BSSID_0 :
2411 mconf->mt76.omac_idx;
2412 basic_req->hw_bss_idx = idx;
2413
2414 basic_req->phymode_ext = mt7925_get_phy_mode_ext(phy, vif, band,
2415 link_sta);
2416
2417 if (band == NL80211_BAND_2GHZ)
2418 basic_req->nonht_basic_phy = cpu_to_le16(PHY_TYPE_ERP_INDEX);
2419 else
2420 basic_req->nonht_basic_phy = cpu_to_le16(PHY_TYPE_OFDM_INDEX);
2421
2422 memcpy(basic_req->bssid, link_conf->bssid, ETH_ALEN);
2423 basic_req->phymode = mt76_connac_get_phy_mode(phy, vif, band, link_sta);
2424 basic_req->bcn_interval = cpu_to_le16(link_conf->beacon_int);
2425 basic_req->dtim_period = link_conf->dtim_period;
2426 basic_req->bmc_tx_wlan_idx = cpu_to_le16(wlan_idx);
2427 basic_req->link_idx = mconf->mt76.idx;
2428
2429 if (link_sta) {
2430 struct mt792x_sta *msta;
2431
2432 msta = (struct mt792x_sta *)link_sta->sta->drv_priv;
2433 mlink = mt792x_sta_to_link(msta, link_sta->link_id);
2434
2435 } else {
2436 mlink = &mconf->vif->sta.deflink;
2437 }
2438
2439 basic_req->sta_idx = cpu_to_le16(mlink->wcid.idx);
2440 basic_req->omac_idx = mconf->mt76.omac_idx;
2441 basic_req->band_idx = mconf->mt76.band_idx;
2442 basic_req->wmm_idx = mconf->mt76.wmm_idx;
2443 basic_req->conn_state = !enable;
2444
2445 switch (vif->type) {
2446 case NL80211_IFTYPE_MESH_POINT:
2447 case NL80211_IFTYPE_AP:
2448 if (vif->p2p)
2449 conn_type = CONNECTION_P2P_GO;
2450 else
2451 conn_type = CONNECTION_INFRA_AP;
2452 basic_req->conn_type = cpu_to_le32(conn_type);
2453 basic_req->active = enable;
2454 break;
2455 case NL80211_IFTYPE_STATION:
2456 if (vif->p2p)
2457 conn_type = CONNECTION_P2P_GC;
2458 else
2459 conn_type = CONNECTION_INFRA_STA;
2460 basic_req->conn_type = cpu_to_le32(conn_type);
2461 basic_req->active = true;
2462 break;
2463 case NL80211_IFTYPE_ADHOC:
2464 basic_req->conn_type = cpu_to_le32(CONNECTION_IBSS_ADHOC);
2465 basic_req->active = true;
2466 break;
2467 default:
2468 WARN_ON(1);
2469 break;
2470 }
2471 }
2472
2473 static void
mt7925_mcu_bss_sec_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf)2474 mt7925_mcu_bss_sec_tlv(struct sk_buff *skb,
2475 struct ieee80211_bss_conf *link_conf)
2476 {
2477 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2478 struct mt76_vif *mvif = &mconf->mt76;
2479 struct bss_sec_tlv {
2480 __le16 tag;
2481 __le16 len;
2482 u8 mode;
2483 u8 status;
2484 u8 cipher;
2485 u8 __rsv;
2486 } __packed * sec;
2487 struct tlv *tlv;
2488
2489 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_SEC, sizeof(*sec));
2490 sec = (struct bss_sec_tlv *)tlv;
2491
2492 switch (mvif->cipher) {
2493 case CONNAC3_CIPHER_GCMP_256:
2494 case CONNAC3_CIPHER_GCMP:
2495 sec->mode = MODE_WPA3_SAE;
2496 sec->status = 8;
2497 break;
2498 case CONNAC3_CIPHER_AES_CCMP:
2499 sec->mode = MODE_WPA2_PSK;
2500 sec->status = 6;
2501 break;
2502 case CONNAC3_CIPHER_TKIP:
2503 sec->mode = MODE_WPA2_PSK;
2504 sec->status = 4;
2505 break;
2506 case CONNAC3_CIPHER_WEP104:
2507 case CONNAC3_CIPHER_WEP40:
2508 sec->mode = MODE_SHARED;
2509 sec->status = 0;
2510 break;
2511 default:
2512 sec->mode = MODE_OPEN;
2513 sec->status = 1;
2514 break;
2515 }
2516
2517 sec->cipher = mvif->cipher;
2518 }
2519
2520 static void
mt7925_mcu_bss_bmc_tlv(struct sk_buff * skb,struct mt792x_phy * phy,struct ieee80211_chanctx_conf * ctx,struct ieee80211_bss_conf * link_conf)2521 mt7925_mcu_bss_bmc_tlv(struct sk_buff *skb, struct mt792x_phy *phy,
2522 struct ieee80211_chanctx_conf *ctx,
2523 struct ieee80211_bss_conf *link_conf)
2524 {
2525 struct cfg80211_chan_def *chandef = ctx ? &ctx->def :
2526 &link_conf->chanreq.oper;
2527 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2528 enum nl80211_band band = chandef->chan->band;
2529 struct mt76_vif *mvif = &mconf->mt76;
2530 struct bss_rate_tlv *bmc;
2531 struct tlv *tlv;
2532 u8 idx = mvif->mcast_rates_idx ?
2533 mvif->mcast_rates_idx : mvif->basic_rates_idx;
2534
2535 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_RATE, sizeof(*bmc));
2536
2537 bmc = (struct bss_rate_tlv *)tlv;
2538
2539 if (band == NL80211_BAND_2GHZ)
2540 bmc->basic_rate = cpu_to_le16(HR_DSSS_ERP_BASIC_RATE);
2541 else
2542 bmc->basic_rate = cpu_to_le16(OFDM_BASIC_RATE);
2543
2544 bmc->short_preamble = (band == NL80211_BAND_2GHZ);
2545 bmc->bc_fixed_rate = idx;
2546 bmc->mc_fixed_rate = idx;
2547 }
2548
2549 static void
mt7925_mcu_bss_mld_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf)2550 mt7925_mcu_bss_mld_tlv(struct sk_buff *skb,
2551 struct ieee80211_bss_conf *link_conf)
2552 {
2553 struct ieee80211_vif *vif = link_conf->vif;
2554 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2555 struct mt792x_vif *mvif = (struct mt792x_vif *)link_conf->vif->drv_priv;
2556 struct bss_mld_tlv *mld;
2557 struct tlv *tlv;
2558 bool is_mld;
2559
2560 is_mld = ieee80211_vif_is_mld(link_conf->vif) ||
2561 (hweight16(mvif->valid_links) > 1);
2562
2563 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_MLD, sizeof(*mld));
2564 mld = (struct bss_mld_tlv *)tlv;
2565
2566 mld->link_id = is_mld ? link_conf->link_id : 0xff;
2567 /* apply the index of the primary link */
2568 mld->group_mld_id = is_mld ? mvif->bss_conf.mt76.idx : 0xff;
2569 mld->own_mld_id = mconf->mt76.idx + 32;
2570 mld->remap_idx = 0xff;
2571 mld->eml_enable = !!(link_conf->vif->cfg.eml_cap &
2572 IEEE80211_EML_CAP_EMLSR_SUPP);
2573
2574 memcpy(mld->mac_addr, vif->addr, ETH_ALEN);
2575 }
2576
2577 static void
mt7925_mcu_bss_qos_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf)2578 mt7925_mcu_bss_qos_tlv(struct sk_buff *skb, struct ieee80211_bss_conf *link_conf)
2579 {
2580 struct mt76_connac_bss_qos_tlv *qos;
2581 struct tlv *tlv;
2582
2583 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_QBSS, sizeof(*qos));
2584 qos = (struct mt76_connac_bss_qos_tlv *)tlv;
2585 qos->qos = link_conf->qos;
2586 }
2587
2588 static void
mt7925_mcu_bss_he_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf,struct mt792x_phy * phy)2589 mt7925_mcu_bss_he_tlv(struct sk_buff *skb, struct ieee80211_bss_conf *link_conf,
2590 struct mt792x_phy *phy)
2591 {
2592 #define DEFAULT_HE_PE_DURATION 4
2593 #define DEFAULT_HE_DURATION_RTS_THRES 1023
2594 const struct ieee80211_sta_he_cap *cap;
2595 struct bss_info_uni_he *he;
2596 struct tlv *tlv;
2597
2598 cap = mt76_connac_get_he_phy_cap(phy->mt76, link_conf->vif);
2599
2600 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_HE_BASIC, sizeof(*he));
2601
2602 he = (struct bss_info_uni_he *)tlv;
2603 he->he_pe_duration = link_conf->htc_trig_based_pkt_ext;
2604 if (!he->he_pe_duration)
2605 he->he_pe_duration = DEFAULT_HE_PE_DURATION;
2606
2607 he->he_rts_thres = cpu_to_le16(link_conf->frame_time_rts_th);
2608 if (!he->he_rts_thres)
2609 he->he_rts_thres = cpu_to_le16(DEFAULT_HE_DURATION_RTS_THRES);
2610
2611 he->max_nss_mcs[CMD_HE_MCS_BW80] = cap->he_mcs_nss_supp.tx_mcs_80;
2612 he->max_nss_mcs[CMD_HE_MCS_BW160] = cap->he_mcs_nss_supp.tx_mcs_160;
2613 he->max_nss_mcs[CMD_HE_MCS_BW8080] = cap->he_mcs_nss_supp.tx_mcs_80p80;
2614 }
2615
2616 static void
mt7925_mcu_bss_color_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf,bool enable)2617 mt7925_mcu_bss_color_tlv(struct sk_buff *skb, struct ieee80211_bss_conf *link_conf,
2618 bool enable)
2619 {
2620 struct bss_info_uni_bss_color *color;
2621 struct tlv *tlv;
2622
2623 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_BSS_COLOR, sizeof(*color));
2624 color = (struct bss_info_uni_bss_color *)tlv;
2625
2626 color->enable = enable ?
2627 link_conf->he_bss_color.enabled : 0;
2628 color->bss_color = enable ?
2629 link_conf->he_bss_color.color : 0;
2630 }
2631
2632 static void
mt7925_mcu_bss_ifs_tlv(struct sk_buff * skb,struct ieee80211_bss_conf * link_conf)2633 mt7925_mcu_bss_ifs_tlv(struct sk_buff *skb,
2634 struct ieee80211_bss_conf *link_conf)
2635 {
2636 struct mt792x_vif *mvif = (struct mt792x_vif *)link_conf->vif->drv_priv;
2637 struct mt792x_phy *phy = mvif->phy;
2638 struct bss_ifs_time_tlv *ifs_time;
2639 struct tlv *tlv;
2640
2641 tlv = mt76_connac_mcu_add_tlv(skb, UNI_BSS_INFO_IFS_TIME, sizeof(*ifs_time));
2642 ifs_time = (struct bss_ifs_time_tlv *)tlv;
2643 ifs_time->slot_valid = true;
2644 ifs_time->slot_time = cpu_to_le16(phy->slottime);
2645 }
2646
mt7925_mcu_set_timing(struct mt792x_phy * phy,struct ieee80211_bss_conf * link_conf)2647 int mt7925_mcu_set_timing(struct mt792x_phy *phy,
2648 struct ieee80211_bss_conf *link_conf)
2649 {
2650 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2651 struct mt792x_dev *dev = phy->dev;
2652 struct sk_buff *skb;
2653
2654 skb = __mt7925_mcu_alloc_bss_req(&dev->mt76, &mconf->mt76,
2655 MT7925_BSS_UPDATE_MAX_SIZE);
2656 if (IS_ERR(skb))
2657 return PTR_ERR(skb);
2658
2659 mt7925_mcu_bss_ifs_tlv(skb, link_conf);
2660
2661 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2662 MCU_UNI_CMD(BSS_INFO_UPDATE), true);
2663 }
2664
mt7925_mcu_del_dev(struct mt76_dev * mdev,struct ieee80211_vif * vif)2665 void mt7925_mcu_del_dev(struct mt76_dev *mdev,
2666 struct ieee80211_vif *vif)
2667 {
2668 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
2669 struct {
2670 struct {
2671 u8 omac_idx;
2672 u8 band_idx;
2673 __le16 pad;
2674 } __packed hdr;
2675 struct req_tlv {
2676 __le16 tag;
2677 __le16 len;
2678 u8 active;
2679 u8 link_idx; /* hw link idx */
2680 u8 omac_addr[ETH_ALEN];
2681 } __packed tlv;
2682 } dev_req = {
2683 .tlv = {
2684 .tag = cpu_to_le16(DEV_INFO_ACTIVE),
2685 .len = cpu_to_le16(sizeof(struct req_tlv)),
2686 .active = true,
2687 },
2688 };
2689 struct {
2690 struct {
2691 u8 bss_idx;
2692 u8 pad[3];
2693 } __packed hdr;
2694 struct mt76_connac_bss_basic_tlv basic;
2695 } basic_req = {
2696 .basic = {
2697 .tag = cpu_to_le16(UNI_BSS_INFO_BASIC),
2698 .len = cpu_to_le16(sizeof(struct mt76_connac_bss_basic_tlv)),
2699 .active = true,
2700 .conn_state = 1,
2701 },
2702 };
2703
2704 dev_req.hdr.omac_idx = mvif->bss_conf.mt76.omac_idx;
2705 dev_req.hdr.band_idx = mvif->bss_conf.mt76.band_idx;
2706
2707 basic_req.hdr.bss_idx = mvif->bss_conf.mt76.idx;
2708 basic_req.basic.omac_idx = mvif->bss_conf.mt76.omac_idx;
2709 basic_req.basic.band_idx = mvif->bss_conf.mt76.band_idx;
2710 basic_req.basic.link_idx = mvif->bss_conf.mt76.link_idx;
2711
2712 mt76_mcu_send_msg(mdev, MCU_UNI_CMD(BSS_INFO_UPDATE),
2713 &basic_req, sizeof(basic_req), true);
2714
2715 /* recovery omac address for the legacy interface */
2716 memcpy(dev_req.tlv.omac_addr, vif->addr, ETH_ALEN);
2717 mt76_mcu_send_msg(mdev, MCU_UNI_CMD(DEV_INFO_UPDATE),
2718 &dev_req, sizeof(dev_req), true);
2719 }
2720
mt7925_mcu_add_bss_info(struct mt792x_phy * phy,struct ieee80211_chanctx_conf * ctx,struct ieee80211_bss_conf * link_conf,struct ieee80211_link_sta * link_sta,int enable)2721 int mt7925_mcu_add_bss_info(struct mt792x_phy *phy,
2722 struct ieee80211_chanctx_conf *ctx,
2723 struct ieee80211_bss_conf *link_conf,
2724 struct ieee80211_link_sta *link_sta,
2725 int enable)
2726 {
2727 struct mt792x_vif *mvif = (struct mt792x_vif *)link_conf->vif->drv_priv;
2728 struct mt792x_bss_conf *mconf = mt792x_link_conf_to_mconf(link_conf);
2729 struct mt792x_dev *dev = phy->dev;
2730 struct mt792x_link_sta *mlink_bc;
2731 struct sk_buff *skb;
2732
2733 skb = __mt7925_mcu_alloc_bss_req(&dev->mt76, &mconf->mt76,
2734 MT7925_BSS_UPDATE_MAX_SIZE);
2735 if (IS_ERR(skb))
2736 return PTR_ERR(skb);
2737
2738 mlink_bc = mt792x_sta_to_link(&mvif->sta, mconf->link_id);
2739
2740 /* bss_basic must be first */
2741 mt7925_mcu_bss_basic_tlv(skb, link_conf, link_sta, ctx, phy->mt76,
2742 mlink_bc->wcid.idx, enable);
2743 mt7925_mcu_bss_sec_tlv(skb, link_conf);
2744 mt7925_mcu_bss_bmc_tlv(skb, phy, ctx, link_conf);
2745 mt7925_mcu_bss_qos_tlv(skb, link_conf);
2746 mt7925_mcu_bss_mld_tlv(skb, link_conf);
2747 mt7925_mcu_bss_ifs_tlv(skb, link_conf);
2748
2749 if (link_conf->he_support) {
2750 mt7925_mcu_bss_he_tlv(skb, link_conf, phy);
2751 mt7925_mcu_bss_color_tlv(skb, link_conf, enable);
2752 }
2753
2754 if (enable)
2755 mt7925_mcu_bss_rlm_tlv(skb, phy->mt76, link_conf, ctx);
2756
2757 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
2758 MCU_UNI_CMD(BSS_INFO_UPDATE), true);
2759 }
2760
mt7925_mcu_set_dbdc(struct mt76_phy * phy,bool enable)2761 int mt7925_mcu_set_dbdc(struct mt76_phy *phy, bool enable)
2762 {
2763 struct mt76_dev *mdev = phy->dev;
2764
2765 struct mbmc_conf_tlv *conf;
2766 struct mbmc_set_req *hdr;
2767 struct sk_buff *skb;
2768 struct tlv *tlv;
2769 int max_len, err;
2770
2771 max_len = sizeof(*hdr) + sizeof(*conf);
2772 skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2773 if (!skb)
2774 return -ENOMEM;
2775
2776 hdr = (struct mbmc_set_req *)skb_put(skb, sizeof(*hdr));
2777
2778 tlv = mt76_connac_mcu_add_tlv(skb, UNI_MBMC_SETTING, sizeof(*conf));
2779 conf = (struct mbmc_conf_tlv *)tlv;
2780
2781 conf->mbmc_en = enable;
2782 conf->band = 0; /* unused */
2783
2784 err = mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SET_DBDC_PARMS),
2785 true);
2786
2787 return err;
2788 }
2789
2790 #define MT76_CONNAC_SCAN_CHANNEL_TIME 60
2791
mt7925_mcu_hw_scan(struct mt76_phy * phy,struct ieee80211_vif * vif,struct ieee80211_scan_request * scan_req)2792 int mt7925_mcu_hw_scan(struct mt76_phy *phy, struct ieee80211_vif *vif,
2793 struct ieee80211_scan_request *scan_req)
2794 {
2795 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2796 struct cfg80211_scan_request *sreq = &scan_req->req;
2797 int n_ssids = 0, err, i, duration;
2798 struct ieee80211_channel **scan_list = sreq->channels;
2799 struct mt76_dev *mdev = phy->dev;
2800 struct mt76_connac_mcu_scan_channel *chan;
2801 struct sk_buff *skb;
2802
2803 struct scan_hdr_tlv *hdr;
2804 struct scan_req_tlv *req;
2805 struct scan_ssid_tlv *ssid;
2806 struct scan_bssid_tlv *bssid;
2807 struct scan_chan_info_tlv *chan_info;
2808 struct scan_ie_tlv *ie;
2809 struct scan_misc_tlv *misc;
2810 struct tlv *tlv;
2811 int max_len;
2812
2813 if (test_bit(MT76_HW_SCANNING, &phy->state))
2814 return -EBUSY;
2815
2816 max_len = sizeof(*hdr) + sizeof(*req) + sizeof(*ssid) +
2817 sizeof(*bssid) + sizeof(*chan_info) +
2818 sizeof(*misc) + sizeof(*ie);
2819
2820 skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2821 if (!skb)
2822 return -ENOMEM;
2823
2824 set_bit(MT76_HW_SCANNING, &phy->state);
2825 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f;
2826
2827 hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
2828 hdr->seq_num = mvif->scan_seq_num | mvif->band_idx << 7;
2829 hdr->bss_idx = mvif->idx;
2830
2831 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_REQ, sizeof(*req));
2832 req = (struct scan_req_tlv *)tlv;
2833 req->scan_type = sreq->n_ssids ? 1 : 0;
2834 req->probe_req_num = sreq->n_ssids ? 2 : 0;
2835
2836 duration = MT76_CONNAC_SCAN_CHANNEL_TIME;
2837 /* increase channel time for passive scan */
2838 if (!sreq->n_ssids)
2839 duration *= 2;
2840 req->timeout_value = cpu_to_le16(sreq->n_channels * duration);
2841 req->channel_min_dwell_time = cpu_to_le16(duration);
2842 req->channel_dwell_time = cpu_to_le16(duration);
2843
2844 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID, sizeof(*ssid));
2845 ssid = (struct scan_ssid_tlv *)tlv;
2846 for (i = 0; i < sreq->n_ssids; i++) {
2847 if (!sreq->ssids[i].ssid_len)
2848 continue;
2849
2850 ssid->ssids[n_ssids].ssid_len = cpu_to_le32(sreq->ssids[i].ssid_len);
2851 memcpy(ssid->ssids[n_ssids].ssid, sreq->ssids[i].ssid,
2852 sreq->ssids[i].ssid_len);
2853 n_ssids++;
2854 }
2855 ssid->ssid_type = n_ssids ? BIT(2) : BIT(0);
2856 ssid->ssids_num = n_ssids;
2857
2858 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_BSSID, sizeof(*bssid));
2859 bssid = (struct scan_bssid_tlv *)tlv;
2860
2861 memcpy(bssid->bssid, sreq->bssid, ETH_ALEN);
2862
2863 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_CHANNEL, sizeof(*chan_info));
2864 chan_info = (struct scan_chan_info_tlv *)tlv;
2865 chan_info->channels_num = min_t(u8, sreq->n_channels,
2866 ARRAY_SIZE(chan_info->channels));
2867 for (i = 0; i < chan_info->channels_num; i++) {
2868 chan = &chan_info->channels[i];
2869
2870 switch (scan_list[i]->band) {
2871 case NL80211_BAND_2GHZ:
2872 chan->band = 1;
2873 break;
2874 case NL80211_BAND_6GHZ:
2875 chan->band = 3;
2876 break;
2877 default:
2878 chan->band = 2;
2879 break;
2880 }
2881 chan->channel_num = scan_list[i]->hw_value;
2882 }
2883 chan_info->channel_type = sreq->n_channels ? 4 : 0;
2884
2885 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_IE, sizeof(*ie));
2886 ie = (struct scan_ie_tlv *)tlv;
2887 if (sreq->ie_len > 0) {
2888 memcpy(ie->ies, sreq->ie, sreq->ie_len);
2889 ie->ies_len = cpu_to_le16(sreq->ie_len);
2890 }
2891
2892 req->scan_func |= SCAN_FUNC_SPLIT_SCAN;
2893
2894 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_MISC, sizeof(*misc));
2895 misc = (struct scan_misc_tlv *)tlv;
2896 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR) {
2897 get_random_mask_addr(misc->random_mac, sreq->mac_addr,
2898 sreq->mac_addr_mask);
2899 req->scan_func |= SCAN_FUNC_RANDOM_MAC;
2900 }
2901
2902 err = mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
2903 true);
2904 if (err < 0)
2905 clear_bit(MT76_HW_SCANNING, &phy->state);
2906
2907 return err;
2908 }
2909 EXPORT_SYMBOL_GPL(mt7925_mcu_hw_scan);
2910
mt7925_mcu_sched_scan_req(struct mt76_phy * phy,struct ieee80211_vif * vif,struct cfg80211_sched_scan_request * sreq)2911 int mt7925_mcu_sched_scan_req(struct mt76_phy *phy,
2912 struct ieee80211_vif *vif,
2913 struct cfg80211_sched_scan_request *sreq)
2914 {
2915 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
2916 struct ieee80211_channel **scan_list = sreq->channels;
2917 struct mt76_connac_mcu_scan_channel *chan;
2918 struct mt76_dev *mdev = phy->dev;
2919 struct cfg80211_match_set *cfg_match;
2920 struct cfg80211_ssid *cfg_ssid;
2921
2922 struct scan_hdr_tlv *hdr;
2923 struct scan_sched_req *req;
2924 struct scan_ssid_tlv *ssid;
2925 struct scan_chan_info_tlv *chan_info;
2926 struct scan_ie_tlv *ie;
2927 struct scan_sched_ssid_match_sets *match;
2928 struct sk_buff *skb;
2929 struct tlv *tlv;
2930 int i, max_len;
2931
2932 max_len = sizeof(*hdr) + sizeof(*req) + sizeof(*ssid) +
2933 sizeof(*chan_info) + sizeof(*ie) +
2934 sizeof(*match);
2935
2936 skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
2937 if (!skb)
2938 return -ENOMEM;
2939
2940 mvif->scan_seq_num = (mvif->scan_seq_num + 1) & 0x7f;
2941
2942 hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
2943 hdr->seq_num = mvif->scan_seq_num | mvif->band_idx << 7;
2944 hdr->bss_idx = mvif->idx;
2945
2946 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SCHED_REQ, sizeof(*req));
2947 req = (struct scan_sched_req *)tlv;
2948 req->version = 1;
2949
2950 if (sreq->flags & NL80211_SCAN_FLAG_RANDOM_ADDR)
2951 req->scan_func |= SCAN_FUNC_RANDOM_MAC;
2952
2953 req->intervals_num = sreq->n_scan_plans;
2954 for (i = 0; i < req->intervals_num; i++)
2955 req->intervals[i] = cpu_to_le16(sreq->scan_plans[i].interval);
2956
2957 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID, sizeof(*ssid));
2958 ssid = (struct scan_ssid_tlv *)tlv;
2959
2960 ssid->ssids_num = sreq->n_ssids;
2961 ssid->ssid_type = BIT(2);
2962 for (i = 0; i < ssid->ssids_num; i++) {
2963 cfg_ssid = &sreq->ssids[i];
2964 memcpy(ssid->ssids[i].ssid, cfg_ssid->ssid, cfg_ssid->ssid_len);
2965 ssid->ssids[i].ssid_len = cpu_to_le32(cfg_ssid->ssid_len);
2966 }
2967
2968 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SSID_MATCH_SETS, sizeof(*match));
2969 match = (struct scan_sched_ssid_match_sets *)tlv;
2970 match->match_num = sreq->n_match_sets;
2971 for (i = 0; i < match->match_num; i++) {
2972 cfg_match = &sreq->match_sets[i];
2973 memcpy(match->match[i].ssid, cfg_match->ssid.ssid,
2974 cfg_match->ssid.ssid_len);
2975 match->match[i].rssi_th = cpu_to_le32(cfg_match->rssi_thold);
2976 match->match[i].ssid_len = cfg_match->ssid.ssid_len;
2977 }
2978
2979 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_CHANNEL, sizeof(*chan_info));
2980 chan_info = (struct scan_chan_info_tlv *)tlv;
2981 chan_info->channels_num = min_t(u8, sreq->n_channels,
2982 ARRAY_SIZE(chan_info->channels));
2983 for (i = 0; i < chan_info->channels_num; i++) {
2984 chan = &chan_info->channels[i];
2985
2986 switch (scan_list[i]->band) {
2987 case NL80211_BAND_2GHZ:
2988 chan->band = 1;
2989 break;
2990 case NL80211_BAND_6GHZ:
2991 chan->band = 3;
2992 break;
2993 default:
2994 chan->band = 2;
2995 break;
2996 }
2997 chan->channel_num = scan_list[i]->hw_value;
2998 }
2999 chan_info->channel_type = sreq->n_channels ? 4 : 0;
3000
3001 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_IE, sizeof(*ie));
3002 ie = (struct scan_ie_tlv *)tlv;
3003 if (sreq->ie_len > 0) {
3004 memcpy(ie->ies, sreq->ie, sreq->ie_len);
3005 ie->ies_len = cpu_to_le16(sreq->ie_len);
3006 }
3007
3008 return mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
3009 true);
3010 }
3011 EXPORT_SYMBOL_GPL(mt7925_mcu_sched_scan_req);
3012
3013 int
mt7925_mcu_sched_scan_enable(struct mt76_phy * phy,struct ieee80211_vif * vif,bool enable)3014 mt7925_mcu_sched_scan_enable(struct mt76_phy *phy,
3015 struct ieee80211_vif *vif,
3016 bool enable)
3017 {
3018 struct mt76_dev *mdev = phy->dev;
3019 struct scan_sched_enable *req;
3020 struct scan_hdr_tlv *hdr;
3021 struct sk_buff *skb;
3022 struct tlv *tlv;
3023 int max_len;
3024
3025 max_len = sizeof(*hdr) + sizeof(*req);
3026
3027 skb = mt76_mcu_msg_alloc(mdev, NULL, max_len);
3028 if (!skb)
3029 return -ENOMEM;
3030
3031 hdr = (struct scan_hdr_tlv *)skb_put(skb, sizeof(*hdr));
3032 hdr->seq_num = 0;
3033 hdr->bss_idx = 0;
3034
3035 tlv = mt76_connac_mcu_add_tlv(skb, UNI_SCAN_SCHED_ENABLE, sizeof(*req));
3036 req = (struct scan_sched_enable *)tlv;
3037 req->active = !enable;
3038
3039 if (enable)
3040 set_bit(MT76_HW_SCHED_SCANNING, &phy->state);
3041 else
3042 clear_bit(MT76_HW_SCHED_SCANNING, &phy->state);
3043
3044 return mt76_mcu_skb_send_msg(mdev, skb, MCU_UNI_CMD(SCAN_REQ),
3045 true);
3046 }
3047
mt7925_mcu_cancel_hw_scan(struct mt76_phy * phy,struct ieee80211_vif * vif)3048 int mt7925_mcu_cancel_hw_scan(struct mt76_phy *phy,
3049 struct ieee80211_vif *vif)
3050 {
3051 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
3052 struct {
3053 struct scan_hdr {
3054 u8 seq_num;
3055 u8 bss_idx;
3056 u8 pad[2];
3057 } __packed hdr;
3058 struct scan_cancel_tlv {
3059 __le16 tag;
3060 __le16 len;
3061 u8 is_ext_channel;
3062 u8 rsv[3];
3063 } __packed cancel;
3064 } req = {
3065 .hdr = {
3066 .seq_num = mvif->scan_seq_num,
3067 .bss_idx = mvif->idx,
3068 },
3069 .cancel = {
3070 .tag = cpu_to_le16(UNI_SCAN_CANCEL),
3071 .len = cpu_to_le16(sizeof(struct scan_cancel_tlv)),
3072 },
3073 };
3074
3075 if (test_and_clear_bit(MT76_HW_SCANNING, &phy->state)) {
3076 struct cfg80211_scan_info info = {
3077 .aborted = true,
3078 };
3079
3080 ieee80211_scan_completed(phy->hw, &info);
3081 }
3082
3083 return mt76_mcu_send_msg(phy->dev, MCU_UNI_CMD(SCAN_REQ),
3084 &req, sizeof(req), true);
3085 }
3086 EXPORT_SYMBOL_GPL(mt7925_mcu_cancel_hw_scan);
3087
mt7925_mcu_set_channel_domain(struct mt76_phy * phy)3088 int mt7925_mcu_set_channel_domain(struct mt76_phy *phy)
3089 {
3090 int len, i, n_max_channels, n_2ch = 0, n_5ch = 0, n_6ch = 0;
3091 struct {
3092 struct {
3093 u8 alpha2[4]; /* regulatory_request.alpha2 */
3094 u8 bw_2g; /* BW_20_40M 0
3095 * BW_20M 1
3096 * BW_20_40_80M 2
3097 * BW_20_40_80_160M 3
3098 * BW_20_40_80_8080M 4
3099 */
3100 u8 bw_5g;
3101 u8 bw_6g;
3102 u8 pad;
3103 } __packed hdr;
3104 struct n_chan {
3105 __le16 tag;
3106 __le16 len;
3107 u8 n_2ch;
3108 u8 n_5ch;
3109 u8 n_6ch;
3110 u8 pad;
3111 } __packed n_ch;
3112 } req = {
3113 .hdr = {
3114 .bw_2g = 0,
3115 .bw_5g = 3, /* BW_20_40_80_160M */
3116 .bw_6g = 3,
3117 },
3118 .n_ch = {
3119 .tag = cpu_to_le16(2),
3120 },
3121 };
3122 struct mt76_connac_mcu_chan {
3123 __le16 hw_value;
3124 __le16 pad;
3125 __le32 flags;
3126 } __packed channel;
3127 struct mt76_dev *dev = phy->dev;
3128 struct ieee80211_channel *chan;
3129 struct sk_buff *skb;
3130
3131 n_max_channels = phy->sband_2g.sband.n_channels +
3132 phy->sband_5g.sband.n_channels +
3133 phy->sband_6g.sband.n_channels;
3134 len = sizeof(req) + n_max_channels * sizeof(channel);
3135
3136 skb = mt76_mcu_msg_alloc(dev, NULL, len);
3137 if (!skb)
3138 return -ENOMEM;
3139
3140 skb_reserve(skb, sizeof(req));
3141
3142 for (i = 0; i < phy->sband_2g.sband.n_channels; i++) {
3143 chan = &phy->sband_2g.sband.channels[i];
3144 if (chan->flags & IEEE80211_CHAN_DISABLED)
3145 continue;
3146
3147 channel.hw_value = cpu_to_le16(chan->hw_value);
3148 channel.flags = cpu_to_le32(chan->flags);
3149 channel.pad = 0;
3150
3151 skb_put_data(skb, &channel, sizeof(channel));
3152 n_2ch++;
3153 }
3154 for (i = 0; i < phy->sband_5g.sband.n_channels; i++) {
3155 chan = &phy->sband_5g.sband.channels[i];
3156 if (chan->flags & IEEE80211_CHAN_DISABLED)
3157 continue;
3158
3159 channel.hw_value = cpu_to_le16(chan->hw_value);
3160 channel.flags = cpu_to_le32(chan->flags);
3161 channel.pad = 0;
3162
3163 skb_put_data(skb, &channel, sizeof(channel));
3164 n_5ch++;
3165 }
3166 for (i = 0; i < phy->sband_6g.sband.n_channels; i++) {
3167 chan = &phy->sband_6g.sband.channels[i];
3168 if (chan->flags & IEEE80211_CHAN_DISABLED)
3169 continue;
3170
3171 channel.hw_value = cpu_to_le16(chan->hw_value);
3172 channel.flags = cpu_to_le32(chan->flags);
3173 channel.pad = 0;
3174
3175 skb_put_data(skb, &channel, sizeof(channel));
3176 n_6ch++;
3177 }
3178
3179 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(req.hdr.alpha2));
3180 memcpy(req.hdr.alpha2, dev->alpha2, sizeof(dev->alpha2));
3181 req.n_ch.n_2ch = n_2ch;
3182 req.n_ch.n_5ch = n_5ch;
3183 req.n_ch.n_6ch = n_6ch;
3184 len = sizeof(struct n_chan) + (n_2ch + n_5ch + n_6ch) * sizeof(channel);
3185 req.n_ch.len = cpu_to_le16(len);
3186 memcpy(__skb_push(skb, sizeof(req)), &req, sizeof(req));
3187
3188 return mt76_mcu_skb_send_msg(dev, skb, MCU_UNI_CMD(SET_DOMAIN_INFO),
3189 true);
3190 }
3191 EXPORT_SYMBOL_GPL(mt7925_mcu_set_channel_domain);
3192
3193 static int
__mt7925_mcu_set_clc(struct mt792x_dev * dev,u8 * alpha2,enum environment_cap env_cap,struct mt7925_clc * clc,u8 idx)3194 __mt7925_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
3195 enum environment_cap env_cap,
3196 struct mt7925_clc *clc, u8 idx)
3197 {
3198 struct mt7925_clc_segment *seg;
3199 struct sk_buff *skb;
3200 struct {
3201 u8 rsv[4];
3202 __le16 tag;
3203 __le16 len;
3204
3205 u8 ver;
3206 u8 pad0;
3207 __le16 size;
3208 u8 idx;
3209 u8 env;
3210 u8 acpi_conf;
3211 u8 pad1;
3212 u8 alpha2[2];
3213 u8 type[2];
3214 u8 rsvd[64];
3215 } __packed req = {
3216 .tag = cpu_to_le16(0x3),
3217 .len = cpu_to_le16(sizeof(req) - 4),
3218
3219 .idx = idx,
3220 .env = env_cap,
3221 };
3222 int ret, valid_cnt = 0;
3223 u8 *pos, *last_pos;
3224
3225 if (!clc)
3226 return 0;
3227
3228 pos = clc->data + sizeof(*seg) * clc->nr_seg;
3229 last_pos = clc->data + le32_to_cpu(*(__le32 *)(clc->data + 4));
3230 while (pos < last_pos) {
3231 struct mt7925_clc_rule *rule = (struct mt7925_clc_rule *)pos;
3232
3233 pos += sizeof(*rule);
3234 if (rule->alpha2[0] != alpha2[0] ||
3235 rule->alpha2[1] != alpha2[1])
3236 continue;
3237
3238 seg = (struct mt7925_clc_segment *)clc->data
3239 + rule->seg_idx - 1;
3240
3241 memcpy(req.alpha2, rule->alpha2, 2);
3242 memcpy(req.type, rule->type, 2);
3243
3244 req.size = cpu_to_le16(seg->len);
3245 skb = __mt76_mcu_msg_alloc(&dev->mt76, &req,
3246 le16_to_cpu(req.size) + sizeof(req),
3247 sizeof(req), GFP_KERNEL);
3248 if (!skb)
3249 return -ENOMEM;
3250 skb_put_data(skb, clc->data + seg->offset, seg->len);
3251
3252 ret = mt76_mcu_skb_send_msg(&dev->mt76, skb,
3253 MCU_UNI_CMD(SET_POWER_LIMIT),
3254 true);
3255 if (ret < 0)
3256 return ret;
3257 valid_cnt++;
3258 }
3259
3260 if (!valid_cnt)
3261 return -ENOENT;
3262
3263 return 0;
3264 }
3265
mt7925_mcu_set_clc(struct mt792x_dev * dev,u8 * alpha2,enum environment_cap env_cap)3266 int mt7925_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
3267 enum environment_cap env_cap)
3268 {
3269 struct mt792x_phy *phy = (struct mt792x_phy *)&dev->phy;
3270 int i, ret;
3271
3272 /* submit all clc config */
3273 for (i = 0; i < ARRAY_SIZE(phy->clc); i++) {
3274 ret = __mt7925_mcu_set_clc(dev, alpha2, env_cap,
3275 phy->clc[i], i);
3276
3277 /* If no country found, set "00" as default */
3278 if (ret == -ENOENT)
3279 ret = __mt7925_mcu_set_clc(dev, "00",
3280 ENVIRON_INDOOR,
3281 phy->clc[i], i);
3282 if (ret < 0)
3283 return ret;
3284 }
3285 return 0;
3286 }
3287
mt7925_mcu_fill_message(struct mt76_dev * mdev,struct sk_buff * skb,int cmd,int * wait_seq)3288 int mt7925_mcu_fill_message(struct mt76_dev *mdev, struct sk_buff *skb,
3289 int cmd, int *wait_seq)
3290 {
3291 int txd_len, mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
3292 struct mt76_connac2_mcu_uni_txd *uni_txd;
3293 struct mt76_connac2_mcu_txd *mcu_txd;
3294 __le32 *txd;
3295 u32 val;
3296 u8 seq;
3297
3298 /* TODO: make dynamic based on msg type */
3299 mdev->mcu.timeout = 20 * HZ;
3300
3301 seq = ++mdev->mcu.msg_seq & 0xf;
3302 if (!seq)
3303 seq = ++mdev->mcu.msg_seq & 0xf;
3304
3305 if (cmd == MCU_CMD(FW_SCATTER))
3306 goto exit;
3307
3308 txd_len = cmd & __MCU_CMD_FIELD_UNI ? sizeof(*uni_txd) : sizeof(*mcu_txd);
3309 txd = (__le32 *)skb_push(skb, txd_len);
3310
3311 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) |
3312 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) |
3313 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0);
3314 txd[0] = cpu_to_le32(val);
3315
3316 val = FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD);
3317 txd[1] = cpu_to_le32(val);
3318
3319 if (cmd & __MCU_CMD_FIELD_UNI) {
3320 uni_txd = (struct mt76_connac2_mcu_uni_txd *)txd;
3321 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd));
3322 uni_txd->cid = cpu_to_le16(mcu_cmd);
3323 uni_txd->s2d_index = MCU_S2D_H2N;
3324 uni_txd->pkt_type = MCU_PKT_ID;
3325 uni_txd->seq = seq;
3326
3327 if (cmd & __MCU_CMD_FIELD_QUERY)
3328 uni_txd->option = MCU_CMD_UNI_QUERY_ACK;
3329 else
3330 uni_txd->option = MCU_CMD_UNI_EXT_ACK;
3331
3332 if (cmd == MCU_UNI_CMD(HIF_CTRL) ||
3333 cmd == MCU_UNI_CMD(CHIP_CONFIG))
3334 uni_txd->option &= ~MCU_CMD_ACK;
3335
3336 goto exit;
3337 }
3338
3339 mcu_txd = (struct mt76_connac2_mcu_txd *)txd;
3340 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd));
3341 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU,
3342 MT_TX_MCU_PORT_RX_Q0));
3343 mcu_txd->pkt_type = MCU_PKT_ID;
3344 mcu_txd->seq = seq;
3345 mcu_txd->cid = mcu_cmd;
3346 mcu_txd->ext_cid = FIELD_GET(__MCU_CMD_FIELD_EXT_ID, cmd);
3347
3348 if (mcu_txd->ext_cid || (cmd & __MCU_CMD_FIELD_CE)) {
3349 if (cmd & __MCU_CMD_FIELD_QUERY)
3350 mcu_txd->set_query = MCU_Q_QUERY;
3351 else
3352 mcu_txd->set_query = MCU_Q_SET;
3353 mcu_txd->ext_cid_ack = !!mcu_txd->ext_cid;
3354 } else {
3355 mcu_txd->set_query = MCU_Q_NA;
3356 }
3357
3358 if (cmd & __MCU_CMD_FIELD_WA)
3359 mcu_txd->s2d_index = MCU_S2D_H2C;
3360 else
3361 mcu_txd->s2d_index = MCU_S2D_H2N;
3362
3363 exit:
3364 if (wait_seq)
3365 *wait_seq = seq;
3366
3367 return 0;
3368 }
3369 EXPORT_SYMBOL_GPL(mt7925_mcu_fill_message);
3370
mt7925_mcu_set_rts_thresh(struct mt792x_phy * phy,u32 val)3371 int mt7925_mcu_set_rts_thresh(struct mt792x_phy *phy, u32 val)
3372 {
3373 struct {
3374 u8 band_idx;
3375 u8 _rsv[3];
3376
3377 __le16 tag;
3378 __le16 len;
3379 __le32 len_thresh;
3380 __le32 pkt_thresh;
3381 } __packed req = {
3382 .band_idx = phy->mt76->band_idx,
3383 .tag = cpu_to_le16(UNI_BAND_CONFIG_RTS_THRESHOLD),
3384 .len = cpu_to_le16(sizeof(req) - 4),
3385 .len_thresh = cpu_to_le32(val),
3386 .pkt_thresh = cpu_to_le32(0x2),
3387 };
3388
3389 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
3390 &req, sizeof(req), true);
3391 }
3392
mt7925_mcu_set_radio_en(struct mt792x_phy * phy,bool enable)3393 int mt7925_mcu_set_radio_en(struct mt792x_phy *phy, bool enable)
3394 {
3395 struct {
3396 u8 band_idx;
3397 u8 _rsv[3];
3398
3399 __le16 tag;
3400 __le16 len;
3401 u8 enable;
3402 u8 _rsv2[3];
3403 } __packed req = {
3404 .band_idx = phy->mt76->band_idx,
3405 .tag = cpu_to_le16(UNI_BAND_CONFIG_RADIO_ENABLE),
3406 .len = cpu_to_le16(sizeof(req) - 4),
3407 .enable = enable,
3408 };
3409
3410 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
3411 &req, sizeof(req), true);
3412 }
3413
3414 static void
mt7925_mcu_build_sku(struct mt76_dev * dev,s8 * sku,struct mt76_power_limits * limits,enum nl80211_band band)3415 mt7925_mcu_build_sku(struct mt76_dev *dev, s8 *sku,
3416 struct mt76_power_limits *limits,
3417 enum nl80211_band band)
3418 {
3419 int i, offset = sizeof(limits->cck);
3420
3421 memset(sku, 127, MT_CONNAC3_SKU_POWER_LIMIT);
3422
3423 if (band == NL80211_BAND_2GHZ) {
3424 /* cck */
3425 memcpy(sku, limits->cck, sizeof(limits->cck));
3426 }
3427
3428 /* ofdm */
3429 memcpy(&sku[offset], limits->ofdm, sizeof(limits->ofdm));
3430 offset += (sizeof(limits->ofdm) * 5);
3431
3432 /* ht */
3433 for (i = 0; i < 2; i++) {
3434 memcpy(&sku[offset], limits->mcs[i], 8);
3435 offset += 8;
3436 }
3437 sku[offset++] = limits->mcs[0][0];
3438
3439 /* vht */
3440 for (i = 0; i < ARRAY_SIZE(limits->mcs); i++) {
3441 memcpy(&sku[offset], limits->mcs[i],
3442 ARRAY_SIZE(limits->mcs[i]));
3443 offset += 12;
3444 }
3445
3446 /* he */
3447 for (i = 0; i < ARRAY_SIZE(limits->ru); i++) {
3448 memcpy(&sku[offset], limits->ru[i], ARRAY_SIZE(limits->ru[i]));
3449 offset += ARRAY_SIZE(limits->ru[i]);
3450 }
3451
3452 /* eht */
3453 for (i = 0; i < ARRAY_SIZE(limits->eht); i++) {
3454 memcpy(&sku[offset], limits->eht[i], ARRAY_SIZE(limits->eht[i]));
3455 offset += ARRAY_SIZE(limits->eht[i]);
3456 }
3457 }
3458
3459 static int
mt7925_mcu_rate_txpower_band(struct mt76_phy * phy,enum nl80211_band band)3460 mt7925_mcu_rate_txpower_band(struct mt76_phy *phy,
3461 enum nl80211_band band)
3462 {
3463 int tx_power, n_chan, last_ch, err = 0, idx = 0;
3464 int i, sku_len, batch_size, batch_len = 3;
3465 struct mt76_dev *dev = phy->dev;
3466 static const u8 chan_list_2ghz[] = {
3467 1, 2, 3, 4, 5, 6, 7,
3468 8, 9, 10, 11, 12, 13, 14
3469 };
3470 static const u8 chan_list_5ghz[] = {
3471 36, 38, 40, 42, 44, 46, 48,
3472 50, 52, 54, 56, 58, 60, 62,
3473 64, 100, 102, 104, 106, 108, 110,
3474 112, 114, 116, 118, 120, 122, 124,
3475 126, 128, 132, 134, 136, 138, 140,
3476 142, 144, 149, 151, 153, 155, 157,
3477 159, 161, 165, 167
3478 };
3479 static const u8 chan_list_6ghz[] = {
3480 1, 3, 5, 7, 9, 11, 13,
3481 15, 17, 19, 21, 23, 25, 27,
3482 29, 33, 35, 37, 39, 41, 43,
3483 45, 47, 49, 51, 53, 55, 57,
3484 59, 61, 65, 67, 69, 71, 73,
3485 75, 77, 79, 81, 83, 85, 87,
3486 89, 91, 93, 97, 99, 101, 103,
3487 105, 107, 109, 111, 113, 115, 117,
3488 119, 121, 123, 125, 129, 131, 133,
3489 135, 137, 139, 141, 143, 145, 147,
3490 149, 151, 153, 155, 157, 161, 163,
3491 165, 167, 169, 171, 173, 175, 177,
3492 179, 181, 183, 185, 187, 189, 193,
3493 195, 197, 199, 201, 203, 205, 207,
3494 209, 211, 213, 215, 217, 219, 221,
3495 225, 227, 229, 233
3496 };
3497 struct mt76_power_limits *limits;
3498 struct mt7925_sku_tlv *sku_tlbv;
3499 const u8 *ch_list;
3500
3501 sku_len = sizeof(*sku_tlbv);
3502 tx_power = 2 * phy->hw->conf.power_level;
3503 if (!tx_power)
3504 tx_power = 127;
3505
3506 if (band == NL80211_BAND_2GHZ) {
3507 n_chan = ARRAY_SIZE(chan_list_2ghz);
3508 ch_list = chan_list_2ghz;
3509 last_ch = chan_list_2ghz[ARRAY_SIZE(chan_list_2ghz) - 1];
3510 } else if (band == NL80211_BAND_6GHZ) {
3511 n_chan = ARRAY_SIZE(chan_list_6ghz);
3512 ch_list = chan_list_6ghz;
3513 last_ch = chan_list_6ghz[ARRAY_SIZE(chan_list_6ghz) - 1];
3514 } else {
3515 n_chan = ARRAY_SIZE(chan_list_5ghz);
3516 ch_list = chan_list_5ghz;
3517 last_ch = chan_list_5ghz[ARRAY_SIZE(chan_list_5ghz) - 1];
3518 }
3519 batch_size = DIV_ROUND_UP(n_chan, batch_len);
3520
3521 limits = devm_kmalloc(dev->dev, sizeof(*limits), GFP_KERNEL);
3522 if (!limits)
3523 return -ENOMEM;
3524
3525 sku_tlbv = devm_kmalloc(dev->dev, sku_len, GFP_KERNEL);
3526 if (!sku_tlbv) {
3527 devm_kfree(dev->dev, limits);
3528 return -ENOMEM;
3529 }
3530
3531 for (i = 0; i < batch_size; i++) {
3532 struct mt7925_tx_power_limit_tlv *tx_power_tlv;
3533 int j, msg_len, num_ch;
3534 struct sk_buff *skb;
3535
3536 num_ch = i == batch_size - 1 ? n_chan % batch_len : batch_len;
3537 msg_len = sizeof(*tx_power_tlv) + num_ch * sku_len;
3538 skb = mt76_mcu_msg_alloc(dev, NULL, msg_len);
3539 if (!skb) {
3540 err = -ENOMEM;
3541 goto out;
3542 }
3543
3544 tx_power_tlv = (struct mt7925_tx_power_limit_tlv *)
3545 skb_put(skb, sizeof(*tx_power_tlv));
3546
3547 BUILD_BUG_ON(sizeof(dev->alpha2) > sizeof(tx_power_tlv->alpha2));
3548 memcpy(tx_power_tlv->alpha2, dev->alpha2, sizeof(dev->alpha2));
3549 tx_power_tlv->n_chan = num_ch;
3550 tx_power_tlv->tag = cpu_to_le16(0x1);
3551 tx_power_tlv->len = cpu_to_le16(sizeof(*tx_power_tlv));
3552
3553 switch (band) {
3554 case NL80211_BAND_2GHZ:
3555 tx_power_tlv->band = 1;
3556 break;
3557 case NL80211_BAND_6GHZ:
3558 tx_power_tlv->band = 3;
3559 break;
3560 default:
3561 tx_power_tlv->band = 2;
3562 break;
3563 }
3564
3565 for (j = 0; j < num_ch; j++, idx++) {
3566 struct ieee80211_channel chan = {
3567 .hw_value = ch_list[idx],
3568 .band = band,
3569 };
3570 s8 reg_power, sar_power;
3571
3572 reg_power = mt76_connac_get_ch_power(phy, &chan,
3573 tx_power);
3574 sar_power = mt76_get_sar_power(phy, &chan, reg_power);
3575
3576 mt76_get_rate_power_limits(phy, &chan, limits,
3577 sar_power);
3578
3579 tx_power_tlv->last_msg = ch_list[idx] == last_ch;
3580 sku_tlbv->channel = ch_list[idx];
3581
3582 mt7925_mcu_build_sku(dev, sku_tlbv->pwr_limit,
3583 limits, band);
3584 skb_put_data(skb, sku_tlbv, sku_len);
3585 }
3586 err = mt76_mcu_skb_send_msg(dev, skb,
3587 MCU_UNI_CMD(SET_POWER_LIMIT),
3588 true);
3589 if (err < 0)
3590 goto out;
3591 }
3592
3593 out:
3594 devm_kfree(dev->dev, sku_tlbv);
3595 devm_kfree(dev->dev, limits);
3596 return err;
3597 }
3598
mt7925_mcu_set_rate_txpower(struct mt76_phy * phy)3599 int mt7925_mcu_set_rate_txpower(struct mt76_phy *phy)
3600 {
3601 int err;
3602
3603 if (phy->cap.has_2ghz) {
3604 err = mt7925_mcu_rate_txpower_band(phy,
3605 NL80211_BAND_2GHZ);
3606 if (err < 0)
3607 return err;
3608 }
3609
3610 if (phy->cap.has_5ghz) {
3611 err = mt7925_mcu_rate_txpower_band(phy,
3612 NL80211_BAND_5GHZ);
3613 if (err < 0)
3614 return err;
3615 }
3616
3617 if (phy->cap.has_6ghz) {
3618 err = mt7925_mcu_rate_txpower_band(phy,
3619 NL80211_BAND_6GHZ);
3620 if (err < 0)
3621 return err;
3622 }
3623
3624 return 0;
3625 }
3626
mt7925_mcu_set_rxfilter(struct mt792x_dev * dev,u32 fif,u8 bit_op,u32 bit_map)3627 int mt7925_mcu_set_rxfilter(struct mt792x_dev *dev, u32 fif,
3628 u8 bit_op, u32 bit_map)
3629 {
3630 struct mt792x_phy *phy = &dev->phy;
3631 struct {
3632 u8 band_idx;
3633 u8 rsv1[3];
3634
3635 __le16 tag;
3636 __le16 len;
3637 u8 mode;
3638 u8 rsv2[3];
3639 __le32 fif;
3640 __le32 bit_map; /* bit_* for bitmap update */
3641 u8 bit_op;
3642 u8 pad[51];
3643 } __packed req = {
3644 .band_idx = phy->mt76->band_idx,
3645 .tag = cpu_to_le16(UNI_BAND_CONFIG_SET_MAC80211_RX_FILTER),
3646 .len = cpu_to_le16(sizeof(req) - 4),
3647
3648 .mode = fif ? 0 : 1,
3649 .fif = cpu_to_le32(fif),
3650 .bit_map = cpu_to_le32(bit_map),
3651 .bit_op = bit_op,
3652 };
3653
3654 return mt76_mcu_send_msg(&phy->dev->mt76, MCU_UNI_CMD(BAND_CONFIG),
3655 &req, sizeof(req), true);
3656 }
3657