Loading...
Note: File does not exist in v3.5.6.
1// SPDX-License-Identifier: ISC
2/* Copyright (C) 2020 MediaTek Inc. */
3
4#include <linux/fs.h>
5#include <linux/firmware.h>
6#include "mt7921.h"
7#include "mcu.h"
8#include "../mt76_connac2_mac.h"
9#include "../mt792x_trace.h"
10
11#define MT_STA_BFER BIT(0)
12#define MT_STA_BFEE BIT(1)
13
14static bool mt7921_disable_clc;
15module_param_named(disable_clc, mt7921_disable_clc, bool, 0644);
16MODULE_PARM_DESC(disable_clc, "disable CLC support");
17
18int mt7921_mcu_parse_response(struct mt76_dev *mdev, int cmd,
19 struct sk_buff *skb, int seq)
20{
21 int mcu_cmd = FIELD_GET(__MCU_CMD_FIELD_ID, cmd);
22 struct mt76_connac2_mcu_rxd *rxd;
23 int ret = 0;
24
25 if (!skb) {
26 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n",
27 cmd, seq);
28 mt792x_reset(mdev);
29
30 return -ETIMEDOUT;
31 }
32
33 rxd = (struct mt76_connac2_mcu_rxd *)skb->data;
34 if (seq != rxd->seq)
35 return -EAGAIN;
36
37 if (cmd == MCU_CMD(PATCH_SEM_CONTROL) ||
38 cmd == MCU_CMD(PATCH_FINISH_REQ)) {
39 skb_pull(skb, sizeof(*rxd) - 4);
40 ret = *skb->data;
41 } else if (cmd == MCU_EXT_CMD(THERMAL_CTRL)) {
42 skb_pull(skb, sizeof(*rxd) + 4);
43 ret = le32_to_cpu(*(__le32 *)skb->data);
44 } else if (cmd == MCU_UNI_CMD(DEV_INFO_UPDATE) ||
45 cmd == MCU_UNI_CMD(BSS_INFO_UPDATE) ||
46 cmd == MCU_UNI_CMD(STA_REC_UPDATE) ||
47 cmd == MCU_UNI_CMD(HIF_CTRL) ||
48 cmd == MCU_UNI_CMD(OFFLOAD) ||
49 cmd == MCU_UNI_CMD(SUSPEND)) {
50 struct mt76_connac_mcu_uni_event *event;
51
52 skb_pull(skb, sizeof(*rxd));
53 event = (struct mt76_connac_mcu_uni_event *)skb->data;
54 ret = le32_to_cpu(event->status);
55 /* skip invalid event */
56 if (mcu_cmd != event->cid)
57 ret = -EAGAIN;
58 } else if (cmd == MCU_CE_QUERY(REG_READ)) {
59 struct mt76_connac_mcu_reg_event *event;
60
61 skb_pull(skb, sizeof(*rxd));
62 event = (struct mt76_connac_mcu_reg_event *)skb->data;
63 ret = (int)le32_to_cpu(event->val);
64 } else {
65 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd));
66 }
67
68 return ret;
69}
70EXPORT_SYMBOL_GPL(mt7921_mcu_parse_response);
71
72static int mt7921_mcu_read_eeprom(struct mt792x_dev *dev, u32 offset, u8 *val)
73{
74 struct mt7921_mcu_eeprom_info *res, req = {
75 .addr = cpu_to_le32(round_down(offset,
76 MT7921_EEPROM_BLOCK_SIZE)),
77 };
78 struct sk_buff *skb;
79 int ret;
80
81 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_QUERY(EFUSE_ACCESS),
82 &req, sizeof(req), true, &skb);
83 if (ret)
84 return ret;
85
86 res = (struct mt7921_mcu_eeprom_info *)skb->data;
87 *val = res->data[offset % MT7921_EEPROM_BLOCK_SIZE];
88 dev_kfree_skb(skb);
89
90 return 0;
91}
92
93#ifdef CONFIG_PM
94
95static int
96mt7921_mcu_set_ipv6_ns_filter(struct mt76_dev *dev,
97 struct ieee80211_vif *vif, bool suspend)
98{
99 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
100 struct {
101 struct {
102 u8 bss_idx;
103 u8 pad[3];
104 } __packed hdr;
105 struct mt76_connac_arpns_tlv arpns;
106 } req = {
107 .hdr = {
108 .bss_idx = mvif->mt76.idx,
109 },
110 .arpns = {
111 .tag = cpu_to_le16(UNI_OFFLOAD_OFFLOAD_ND),
112 .len = cpu_to_le16(sizeof(struct mt76_connac_arpns_tlv)),
113 .mode = suspend,
114 },
115 };
116
117 return mt76_mcu_send_msg(dev, MCU_UNI_CMD_OFFLOAD, &req, sizeof(req),
118 true);
119}
120
121void mt7921_mcu_set_suspend_iter(void *priv, u8 *mac, struct ieee80211_vif *vif)
122{
123 if (IS_ENABLED(CONFIG_IPV6)) {
124 struct mt76_phy *phy = priv;
125
126 mt7921_mcu_set_ipv6_ns_filter(phy->dev, vif,
127 !test_bit(MT76_STATE_RUNNING,
128 &phy->state));
129 }
130
131 mt76_connac_mcu_set_suspend_iter(priv, mac, vif);
132}
133
134#endif /* CONFIG_PM */
135
136static void
137mt7921_mcu_uni_roc_event(struct mt792x_dev *dev, struct sk_buff *skb)
138{
139 struct mt7921_roc_grant_tlv *grant;
140 struct mt76_connac2_mcu_rxd *rxd;
141 int duration;
142
143 rxd = (struct mt76_connac2_mcu_rxd *)skb->data;
144 grant = (struct mt7921_roc_grant_tlv *)(rxd->tlv + 4);
145
146 /* should never happen */
147 WARN_ON_ONCE((le16_to_cpu(grant->tag) != UNI_EVENT_ROC_GRANT));
148
149 if (grant->reqtype == MT7921_ROC_REQ_ROC)
150 ieee80211_ready_on_channel(dev->mt76.phy.hw);
151
152 dev->phy.roc_grant = true;
153 wake_up(&dev->phy.roc_wait);
154 duration = le32_to_cpu(grant->max_interval);
155 mod_timer(&dev->phy.roc_timer,
156 jiffies + msecs_to_jiffies(duration));
157}
158
159static void
160mt7921_mcu_scan_event(struct mt792x_dev *dev, struct sk_buff *skb)
161{
162 struct mt76_phy *mphy = &dev->mt76.phy;
163 struct mt792x_phy *phy = mphy->priv;
164
165 spin_lock_bh(&dev->mt76.lock);
166 __skb_queue_tail(&phy->scan_event_list, skb);
167 spin_unlock_bh(&dev->mt76.lock);
168
169 ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work,
170 MT792x_HW_SCAN_TIMEOUT);
171}
172
173static void
174mt7921_mcu_connection_loss_iter(void *priv, u8 *mac,
175 struct ieee80211_vif *vif)
176{
177 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
178 struct mt76_connac_beacon_loss_event *event = priv;
179
180 if (mvif->idx != event->bss_idx)
181 return;
182
183 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER) ||
184 vif->type != NL80211_IFTYPE_STATION)
185 return;
186
187 ieee80211_connection_loss(vif);
188}
189
190static void
191mt7921_mcu_connection_loss_event(struct mt792x_dev *dev, struct sk_buff *skb)
192{
193 struct mt76_connac_beacon_loss_event *event;
194 struct mt76_phy *mphy = &dev->mt76.phy;
195
196 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd));
197 event = (struct mt76_connac_beacon_loss_event *)skb->data;
198
199 ieee80211_iterate_active_interfaces_atomic(mphy->hw,
200 IEEE80211_IFACE_ITER_RESUME_ALL,
201 mt7921_mcu_connection_loss_iter, event);
202}
203
204static void
205mt7921_mcu_debug_msg_event(struct mt792x_dev *dev, struct sk_buff *skb)
206{
207 struct mt7921_debug_msg {
208 __le16 id;
209 u8 type;
210 u8 flag;
211 __le32 value;
212 __le16 len;
213 u8 content[512];
214 } __packed * msg;
215
216 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd));
217 msg = (struct mt7921_debug_msg *)skb->data;
218
219 if (msg->type == 3) { /* fw log */
220 u16 len = min_t(u16, le16_to_cpu(msg->len), 512);
221 int i;
222
223 for (i = 0 ; i < len; i++) {
224 if (!msg->content[i])
225 msg->content[i] = ' ';
226 }
227 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", len, msg->content);
228 }
229}
230
231static void
232mt7921_mcu_low_power_event(struct mt792x_dev *dev, struct sk_buff *skb)
233{
234 struct mt7921_mcu_lp_event {
235 u8 state;
236 u8 reserved[3];
237 } __packed * event;
238
239 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd));
240 event = (struct mt7921_mcu_lp_event *)skb->data;
241
242 trace_lp_event(dev, event->state);
243}
244
245static void
246mt7921_mcu_tx_done_event(struct mt792x_dev *dev, struct sk_buff *skb)
247{
248 struct mt7921_mcu_tx_done_event *event;
249
250 skb_pull(skb, sizeof(struct mt76_connac2_mcu_rxd));
251 event = (struct mt7921_mcu_tx_done_event *)skb->data;
252
253 mt7921_mac_add_txs(dev, event->txs);
254}
255
256static void
257mt7921_mcu_rx_unsolicited_event(struct mt792x_dev *dev, struct sk_buff *skb)
258{
259 struct mt76_connac2_mcu_rxd *rxd;
260
261 rxd = (struct mt76_connac2_mcu_rxd *)skb->data;
262 switch (rxd->eid) {
263 case MCU_EVENT_BSS_BEACON_LOSS:
264 mt7921_mcu_connection_loss_event(dev, skb);
265 break;
266 case MCU_EVENT_SCHED_SCAN_DONE:
267 case MCU_EVENT_SCAN_DONE:
268 mt7921_mcu_scan_event(dev, skb);
269 return;
270 case MCU_EVENT_DBG_MSG:
271 mt7921_mcu_debug_msg_event(dev, skb);
272 break;
273 case MCU_EVENT_COREDUMP:
274 dev->fw_assert = true;
275 mt76_connac_mcu_coredump_event(&dev->mt76, skb,
276 &dev->coredump);
277 return;
278 case MCU_EVENT_LP_INFO:
279 mt7921_mcu_low_power_event(dev, skb);
280 break;
281 case MCU_EVENT_TX_DONE:
282 mt7921_mcu_tx_done_event(dev, skb);
283 break;
284 default:
285 break;
286 }
287 dev_kfree_skb(skb);
288}
289
290static void
291mt7921_mcu_uni_rx_unsolicited_event(struct mt792x_dev *dev,
292 struct sk_buff *skb)
293{
294 struct mt76_connac2_mcu_rxd *rxd;
295
296 rxd = (struct mt76_connac2_mcu_rxd *)skb->data;
297
298 switch (rxd->eid) {
299 case MCU_UNI_EVENT_ROC:
300 mt7921_mcu_uni_roc_event(dev, skb);
301 break;
302 default:
303 break;
304 }
305 dev_kfree_skb(skb);
306}
307
308void mt7921_mcu_rx_event(struct mt792x_dev *dev, struct sk_buff *skb)
309{
310 struct mt76_connac2_mcu_rxd *rxd;
311
312 if (skb_linearize(skb))
313 return;
314
315 rxd = (struct mt76_connac2_mcu_rxd *)skb->data;
316
317 if (rxd->option & MCU_UNI_CMD_UNSOLICITED_EVENT) {
318 mt7921_mcu_uni_rx_unsolicited_event(dev, skb);
319 return;
320 }
321
322 if (rxd->eid == 0x6) {
323 mt76_mcu_rx_event(&dev->mt76, skb);
324 return;
325 }
326
327 if (rxd->ext_eid == MCU_EXT_EVENT_RATE_REPORT ||
328 rxd->eid == MCU_EVENT_BSS_BEACON_LOSS ||
329 rxd->eid == MCU_EVENT_SCHED_SCAN_DONE ||
330 rxd->eid == MCU_EVENT_SCAN_DONE ||
331 rxd->eid == MCU_EVENT_TX_DONE ||
332 rxd->eid == MCU_EVENT_DBG_MSG ||
333 rxd->eid == MCU_EVENT_COREDUMP ||
334 rxd->eid == MCU_EVENT_LP_INFO ||
335 !rxd->seq)
336 mt7921_mcu_rx_unsolicited_event(dev, skb);
337 else
338 mt76_mcu_rx_event(&dev->mt76, skb);
339}
340
341/** starec & wtbl **/
342int mt7921_mcu_uni_tx_ba(struct mt792x_dev *dev,
343 struct ieee80211_ampdu_params *params,
344 bool enable)
345{
346 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
347
348 if (enable && !params->amsdu)
349 msta->wcid.amsdu = false;
350
351 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params,
352 MCU_UNI_CMD(STA_REC_UPDATE),
353 enable, true);
354}
355
356int mt7921_mcu_uni_rx_ba(struct mt792x_dev *dev,
357 struct ieee80211_ampdu_params *params,
358 bool enable)
359{
360 struct mt792x_sta *msta = (struct mt792x_sta *)params->sta->drv_priv;
361
362 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params,
363 MCU_UNI_CMD(STA_REC_UPDATE),
364 enable, false);
365}
366
367static int mt7921_load_clc(struct mt792x_dev *dev, const char *fw_name)
368{
369 const struct mt76_connac2_fw_trailer *hdr;
370 const struct mt76_connac2_fw_region *region;
371 const struct mt7921_clc *clc;
372 struct mt76_dev *mdev = &dev->mt76;
373 struct mt792x_phy *phy = &dev->phy;
374 const struct firmware *fw;
375 int ret, i, len, offset = 0;
376 u8 *clc_base = NULL, hw_encap = 0;
377
378 dev->phy.clc_chan_conf = 0xff;
379 if (mt7921_disable_clc ||
380 mt76_is_usb(&dev->mt76))
381 return 0;
382
383 if (mt76_is_mmio(&dev->mt76)) {
384 ret = mt7921_mcu_read_eeprom(dev, MT_EE_HW_TYPE, &hw_encap);
385 if (ret)
386 return ret;
387 hw_encap = u8_get_bits(hw_encap, MT_EE_HW_TYPE_ENCAP);
388 }
389
390 ret = request_firmware(&fw, fw_name, mdev->dev);
391 if (ret)
392 return ret;
393
394 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
395 dev_err(mdev->dev, "Invalid firmware\n");
396 ret = -EINVAL;
397 goto out;
398 }
399
400 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr));
401 for (i = 0; i < hdr->n_region; i++) {
402 region = (const void *)((const u8 *)hdr -
403 (hdr->n_region - i) * sizeof(*region));
404 len = le32_to_cpu(region->len);
405
406 /* check if we have valid buffer size */
407 if (offset + len > fw->size) {
408 dev_err(mdev->dev, "Invalid firmware region\n");
409 ret = -EINVAL;
410 goto out;
411 }
412
413 if ((region->feature_set & FW_FEATURE_NON_DL) &&
414 region->type == FW_TYPE_CLC) {
415 clc_base = (u8 *)(fw->data + offset);
416 break;
417 }
418 offset += len;
419 }
420
421 if (!clc_base)
422 goto out;
423
424 for (offset = 0; offset < len; offset += le32_to_cpu(clc->len)) {
425 clc = (const struct mt7921_clc *)(clc_base + offset);
426
427 /* do not init buf again if chip reset triggered */
428 if (phy->clc[clc->idx])
429 continue;
430
431 /* header content sanity */
432 if (clc->idx == MT7921_CLC_POWER &&
433 u8_get_bits(clc->type, MT_EE_HW_TYPE_ENCAP) != hw_encap)
434 continue;
435
436 phy->clc[clc->idx] = devm_kmemdup(mdev->dev, clc,
437 le32_to_cpu(clc->len),
438 GFP_KERNEL);
439
440 if (!phy->clc[clc->idx]) {
441 ret = -ENOMEM;
442 goto out;
443 }
444 }
445 ret = mt7921_mcu_set_clc(dev, "00", ENVIRON_INDOOR);
446out:
447 release_firmware(fw);
448
449 return ret;
450}
451
452static void mt7921_mcu_parse_tx_resource(struct mt76_dev *dev,
453 struct sk_buff *skb)
454{
455 struct mt76_sdio *sdio = &dev->sdio;
456 struct mt7921_tx_resource {
457 __le32 version;
458 __le32 pse_data_quota;
459 __le32 pse_mcu_quota;
460 __le32 ple_data_quota;
461 __le32 ple_mcu_quota;
462 __le16 pse_page_size;
463 __le16 ple_page_size;
464 u8 pp_padding;
465 u8 pad[3];
466 } __packed * tx_res;
467
468 tx_res = (struct mt7921_tx_resource *)skb->data;
469 sdio->sched.pse_data_quota = le32_to_cpu(tx_res->pse_data_quota);
470 sdio->sched.pse_mcu_quota = le32_to_cpu(tx_res->pse_mcu_quota);
471 sdio->sched.ple_data_quota = le32_to_cpu(tx_res->ple_data_quota);
472 sdio->sched.pse_page_size = le16_to_cpu(tx_res->pse_page_size);
473 sdio->sched.deficit = tx_res->pp_padding;
474}
475
476static void mt7921_mcu_parse_phy_cap(struct mt76_dev *dev,
477 struct sk_buff *skb)
478{
479 struct mt7921_phy_cap {
480 u8 ht;
481 u8 vht;
482 u8 _5g;
483 u8 max_bw;
484 u8 nss;
485 u8 dbdc;
486 u8 tx_ldpc;
487 u8 rx_ldpc;
488 u8 tx_stbc;
489 u8 rx_stbc;
490 u8 hw_path;
491 u8 he;
492 } __packed * cap;
493
494 enum {
495 WF0_24G,
496 WF0_5G
497 };
498
499 cap = (struct mt7921_phy_cap *)skb->data;
500
501 dev->phy.antenna_mask = BIT(cap->nss) - 1;
502 dev->phy.chainmask = dev->phy.antenna_mask;
503 dev->phy.cap.has_2ghz = cap->hw_path & BIT(WF0_24G);
504 dev->phy.cap.has_5ghz = cap->hw_path & BIT(WF0_5G);
505}
506
507static int mt7921_mcu_get_nic_capability(struct mt792x_phy *mphy)
508{
509 struct mt76_connac_cap_hdr {
510 __le16 n_element;
511 u8 rsv[2];
512 } __packed * hdr;
513 struct sk_buff *skb;
514 struct mt76_phy *phy = mphy->mt76;
515 int ret, i;
516
517 ret = mt76_mcu_send_and_get_msg(phy->dev, MCU_CE_CMD(GET_NIC_CAPAB),
518 NULL, 0, true, &skb);
519 if (ret)
520 return ret;
521
522 hdr = (struct mt76_connac_cap_hdr *)skb->data;
523 if (skb->len < sizeof(*hdr)) {
524 ret = -EINVAL;
525 goto out;
526 }
527
528 skb_pull(skb, sizeof(*hdr));
529
530 for (i = 0; i < le16_to_cpu(hdr->n_element); i++) {
531 struct tlv_hdr {
532 __le32 type;
533 __le32 len;
534 } __packed * tlv = (struct tlv_hdr *)skb->data;
535 int len;
536
537 if (skb->len < sizeof(*tlv))
538 break;
539
540 skb_pull(skb, sizeof(*tlv));
541
542 len = le32_to_cpu(tlv->len);
543 if (skb->len < len)
544 break;
545
546 switch (le32_to_cpu(tlv->type)) {
547 case MT_NIC_CAP_6G:
548 phy->cap.has_6ghz = skb->data[0];
549 break;
550 case MT_NIC_CAP_MAC_ADDR:
551 memcpy(phy->macaddr, (void *)skb->data, ETH_ALEN);
552 break;
553 case MT_NIC_CAP_PHY:
554 mt7921_mcu_parse_phy_cap(phy->dev, skb);
555 break;
556 case MT_NIC_CAP_TX_RESOURCE:
557 if (mt76_is_sdio(phy->dev))
558 mt7921_mcu_parse_tx_resource(phy->dev,
559 skb);
560 break;
561 case MT_NIC_CAP_CHIP_CAP:
562 memcpy(&mphy->chip_cap, (void *)skb->data, sizeof(u64));
563 break;
564 default:
565 break;
566 }
567 skb_pull(skb, len);
568 }
569out:
570 dev_kfree_skb(skb);
571
572 return ret;
573}
574
575int mt7921_mcu_fw_log_2_host(struct mt792x_dev *dev, u8 ctrl)
576{
577 struct {
578 u8 ctrl_val;
579 u8 pad[3];
580 } data = {
581 .ctrl_val = ctrl
582 };
583
584 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(FWLOG_2_HOST),
585 &data, sizeof(data), false);
586}
587
588int mt7921_run_firmware(struct mt792x_dev *dev)
589{
590 int err;
591
592 err = mt792x_load_firmware(dev);
593 if (err)
594 return err;
595
596 err = mt7921_mcu_get_nic_capability(&dev->phy);
597 if (err)
598 return err;
599
600 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
601 err = mt7921_load_clc(dev, mt792x_ram_name(dev));
602 if (err)
603 return err;
604
605 return mt7921_mcu_fw_log_2_host(dev, 1);
606}
607EXPORT_SYMBOL_GPL(mt7921_run_firmware);
608
609int mt7921_mcu_set_tx(struct mt792x_dev *dev, struct ieee80211_vif *vif)
610{
611 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
612 struct edca {
613 __le16 cw_min;
614 __le16 cw_max;
615 __le16 txop;
616 __le16 aifs;
617 u8 guardtime;
618 u8 acm;
619 } __packed;
620 struct mt7921_mcu_tx {
621 struct edca edca[IEEE80211_NUM_ACS];
622 u8 bss_idx;
623 u8 qos;
624 u8 wmm_idx;
625 u8 pad;
626 } __packed req = {
627 .bss_idx = mvif->mt76.idx,
628 .qos = vif->bss_conf.qos,
629 .wmm_idx = mvif->mt76.wmm_idx,
630 };
631 struct mu_edca {
632 u8 cw_min;
633 u8 cw_max;
634 u8 aifsn;
635 u8 acm;
636 u8 timer;
637 u8 padding[3];
638 };
639 struct mt7921_mcu_mu_tx {
640 u8 ver;
641 u8 pad0;
642 __le16 len;
643 u8 bss_idx;
644 u8 qos;
645 u8 wmm_idx;
646 u8 pad1;
647 struct mu_edca edca[IEEE80211_NUM_ACS];
648 u8 pad3[32];
649 } __packed req_mu = {
650 .bss_idx = mvif->mt76.idx,
651 .qos = vif->bss_conf.qos,
652 .wmm_idx = mvif->mt76.wmm_idx,
653 };
654 static const int to_aci[] = { 1, 0, 2, 3 };
655 int ac, ret;
656
657 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
658 struct ieee80211_tx_queue_params *q = &mvif->queue_params[ac];
659 struct edca *e = &req.edca[to_aci[ac]];
660
661 e->aifs = cpu_to_le16(q->aifs);
662 e->txop = cpu_to_le16(q->txop);
663
664 if (q->cw_min)
665 e->cw_min = cpu_to_le16(q->cw_min);
666 else
667 e->cw_min = cpu_to_le16(5);
668
669 if (q->cw_max)
670 e->cw_max = cpu_to_le16(q->cw_max);
671 else
672 e->cw_max = cpu_to_le16(10);
673 }
674
675 ret = mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_EDCA_PARMS), &req,
676 sizeof(req), false);
677 if (ret)
678 return ret;
679
680 if (!vif->bss_conf.he_support)
681 return 0;
682
683 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
684 struct ieee80211_he_mu_edca_param_ac_rec *q;
685 struct mu_edca *e;
686
687 if (!mvif->queue_params[ac].mu_edca)
688 break;
689
690 q = &mvif->queue_params[ac].mu_edca_param_rec;
691 e = &(req_mu.edca[to_aci[ac]]);
692
693 e->cw_min = q->ecw_min_max & 0xf;
694 e->cw_max = (q->ecw_min_max & 0xf0) >> 4;
695 e->aifsn = q->aifsn;
696 e->timer = q->mu_edca_timer;
697 }
698
699 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_MU_EDCA_PARMS),
700 &req_mu, sizeof(req_mu), false);
701}
702
703int mt7921_mcu_set_roc(struct mt792x_phy *phy, struct mt792x_vif *vif,
704 struct ieee80211_channel *chan, int duration,
705 enum mt7921_roc_req type, u8 token_id)
706{
707 int center_ch = ieee80211_frequency_to_channel(chan->center_freq);
708 struct mt792x_dev *dev = phy->dev;
709 struct {
710 struct {
711 u8 rsv[4];
712 } __packed hdr;
713 struct roc_acquire_tlv {
714 __le16 tag;
715 __le16 len;
716 u8 bss_idx;
717 u8 tokenid;
718 u8 control_channel;
719 u8 sco;
720 u8 band;
721 u8 bw;
722 u8 center_chan;
723 u8 center_chan2;
724 u8 bw_from_ap;
725 u8 center_chan_from_ap;
726 u8 center_chan2_from_ap;
727 u8 reqtype;
728 __le32 maxinterval;
729 u8 dbdcband;
730 u8 rsv[3];
731 } __packed roc;
732 } __packed req = {
733 .roc = {
734 .tag = cpu_to_le16(UNI_ROC_ACQUIRE),
735 .len = cpu_to_le16(sizeof(struct roc_acquire_tlv)),
736 .tokenid = token_id,
737 .reqtype = type,
738 .maxinterval = cpu_to_le32(duration),
739 .bss_idx = vif->mt76.idx,
740 .control_channel = chan->hw_value,
741 .bw = CMD_CBW_20MHZ,
742 .bw_from_ap = CMD_CBW_20MHZ,
743 .center_chan = center_ch,
744 .center_chan_from_ap = center_ch,
745 .dbdcband = 0xff, /* auto */
746 },
747 };
748
749 if (chan->hw_value < center_ch)
750 req.roc.sco = 1; /* SCA */
751 else if (chan->hw_value > center_ch)
752 req.roc.sco = 3; /* SCB */
753
754 switch (chan->band) {
755 case NL80211_BAND_6GHZ:
756 req.roc.band = 3;
757 break;
758 case NL80211_BAND_5GHZ:
759 req.roc.band = 2;
760 break;
761 default:
762 req.roc.band = 1;
763 break;
764 }
765
766 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
767 &req, sizeof(req), false);
768}
769
770int mt7921_mcu_abort_roc(struct mt792x_phy *phy, struct mt792x_vif *vif,
771 u8 token_id)
772{
773 struct mt792x_dev *dev = phy->dev;
774 struct {
775 struct {
776 u8 rsv[4];
777 } __packed hdr;
778 struct roc_abort_tlv {
779 __le16 tag;
780 __le16 len;
781 u8 bss_idx;
782 u8 tokenid;
783 u8 dbdcband;
784 u8 rsv[5];
785 } __packed abort;
786 } __packed req = {
787 .abort = {
788 .tag = cpu_to_le16(UNI_ROC_ABORT),
789 .len = cpu_to_le16(sizeof(struct roc_abort_tlv)),
790 .tokenid = token_id,
791 .bss_idx = vif->mt76.idx,
792 .dbdcband = 0xff, /* auto*/
793 },
794 };
795
796 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(ROC),
797 &req, sizeof(req), false);
798}
799
800int mt7921_mcu_set_chan_info(struct mt792x_phy *phy, int cmd)
801{
802 struct mt792x_dev *dev = phy->dev;
803 struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
804 int freq1 = chandef->center_freq1;
805 struct {
806 u8 control_ch;
807 u8 center_ch;
808 u8 bw;
809 u8 tx_streams_num;
810 u8 rx_streams; /* mask or num */
811 u8 switch_reason;
812 u8 band_idx;
813 u8 center_ch2; /* for 80+80 only */
814 __le16 cac_case;
815 u8 channel_band;
816 u8 rsv0;
817 __le32 outband_freq;
818 u8 txpower_drop;
819 u8 ap_bw;
820 u8 ap_center_ch;
821 u8 rsv1[57];
822 } __packed req = {
823 .control_ch = chandef->chan->hw_value,
824 .center_ch = ieee80211_frequency_to_channel(freq1),
825 .bw = mt76_connac_chan_bw(chandef),
826 .tx_streams_num = hweight8(phy->mt76->antenna_mask),
827 .rx_streams = phy->mt76->antenna_mask,
828 .band_idx = phy != &dev->phy,
829 };
830
831 if (chandef->chan->band == NL80211_BAND_6GHZ)
832 req.channel_band = 2;
833 else
834 req.channel_band = chandef->chan->band;
835
836 if (cmd == MCU_EXT_CMD(SET_RX_PATH) ||
837 dev->mt76.hw->conf.flags & IEEE80211_CONF_MONITOR)
838 req.switch_reason = CH_SWITCH_NORMAL;
839 else if (dev->mt76.hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
840 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD;
841 else if (!cfg80211_reg_can_beacon(dev->mt76.hw->wiphy, chandef,
842 NL80211_IFTYPE_AP))
843 req.switch_reason = CH_SWITCH_DFS;
844 else
845 req.switch_reason = CH_SWITCH_NORMAL;
846
847 if (cmd == MCU_EXT_CMD(CHANNEL_SWITCH))
848 req.rx_streams = hweight8(req.rx_streams);
849
850 if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
851 int freq2 = chandef->center_freq2;
852
853 req.center_ch2 = ieee80211_frequency_to_channel(freq2);
854 }
855
856 return mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true);
857}
858
859int mt7921_mcu_set_eeprom(struct mt792x_dev *dev)
860{
861 struct req_hdr {
862 u8 buffer_mode;
863 u8 format;
864 __le16 len;
865 } __packed req = {
866 .buffer_mode = EE_MODE_EFUSE,
867 .format = EE_FORMAT_WHOLE,
868 };
869
870 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(EFUSE_BUFFER_MODE),
871 &req, sizeof(req), true);
872}
873EXPORT_SYMBOL_GPL(mt7921_mcu_set_eeprom);
874
875int mt7921_mcu_uni_bss_ps(struct mt792x_dev *dev, struct ieee80211_vif *vif)
876{
877 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
878 struct {
879 struct {
880 u8 bss_idx;
881 u8 pad[3];
882 } __packed hdr;
883 struct ps_tlv {
884 __le16 tag;
885 __le16 len;
886 u8 ps_state; /* 0: device awake
887 * 1: static power save
888 * 2: dynamic power saving
889 * 3: enter TWT power saving
890 * 4: leave TWT power saving
891 */
892 u8 pad[3];
893 } __packed ps;
894 } __packed ps_req = {
895 .hdr = {
896 .bss_idx = mvif->mt76.idx,
897 },
898 .ps = {
899 .tag = cpu_to_le16(UNI_BSS_INFO_PS),
900 .len = cpu_to_le16(sizeof(struct ps_tlv)),
901 .ps_state = vif->cfg.ps ? 2 : 0,
902 },
903 };
904
905 if (vif->type != NL80211_IFTYPE_STATION)
906 return -EOPNOTSUPP;
907
908 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
909 &ps_req, sizeof(ps_req), true);
910}
911
912static int
913mt7921_mcu_uni_bss_bcnft(struct mt792x_dev *dev, struct ieee80211_vif *vif,
914 bool enable)
915{
916 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
917 struct {
918 struct {
919 u8 bss_idx;
920 u8 pad[3];
921 } __packed hdr;
922 struct bcnft_tlv {
923 __le16 tag;
924 __le16 len;
925 __le16 bcn_interval;
926 u8 dtim_period;
927 u8 pad;
928 } __packed bcnft;
929 } __packed bcnft_req = {
930 .hdr = {
931 .bss_idx = mvif->mt76.idx,
932 },
933 .bcnft = {
934 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
935 .len = cpu_to_le16(sizeof(struct bcnft_tlv)),
936 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
937 .dtim_period = vif->bss_conf.dtim_period,
938 },
939 };
940
941 if (vif->type != NL80211_IFTYPE_STATION)
942 return 0;
943
944 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
945 &bcnft_req, sizeof(bcnft_req), true);
946}
947
948int
949mt7921_mcu_set_bss_pm(struct mt792x_dev *dev, struct ieee80211_vif *vif,
950 bool enable)
951{
952 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
953 struct {
954 u8 bss_idx;
955 u8 dtim_period;
956 __le16 aid;
957 __le16 bcn_interval;
958 __le16 atim_window;
959 u8 uapsd;
960 u8 bmc_delivered_ac;
961 u8 bmc_triggered_ac;
962 u8 pad;
963 } req = {
964 .bss_idx = mvif->mt76.idx,
965 .aid = cpu_to_le16(vif->cfg.aid),
966 .dtim_period = vif->bss_conf.dtim_period,
967 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
968 };
969 struct {
970 u8 bss_idx;
971 u8 pad[3];
972 } req_hdr = {
973 .bss_idx = mvif->mt76.idx,
974 };
975 int err;
976
977 err = mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_BSS_ABORT),
978 &req_hdr, sizeof(req_hdr), false);
979 if (err < 0 || !enable)
980 return err;
981
982 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_BSS_CONNECTED),
983 &req, sizeof(req), false);
984}
985
986int mt7921_mcu_sta_update(struct mt792x_dev *dev, struct ieee80211_sta *sta,
987 struct ieee80211_vif *vif, bool enable,
988 enum mt76_sta_info_state state)
989{
990 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
991 int rssi = -ewma_rssi_read(&mvif->rssi);
992 struct mt76_sta_cmd_info info = {
993 .sta = sta,
994 .vif = vif,
995 .enable = enable,
996 .cmd = MCU_UNI_CMD(STA_REC_UPDATE),
997 .state = state,
998 .offload_fw = true,
999 .rcpi = to_rcpi(rssi),
1000 };
1001 struct mt792x_sta *msta;
1002
1003 msta = sta ? (struct mt792x_sta *)sta->drv_priv : NULL;
1004 info.wcid = msta ? &msta->wcid : &mvif->sta.wcid;
1005 info.newly = msta ? state != MT76_STA_INFO_STATE_ASSOC : true;
1006
1007 return mt76_connac_mcu_sta_cmd(&dev->mphy, &info);
1008}
1009
1010int mt7921_mcu_set_beacon_filter(struct mt792x_dev *dev,
1011 struct ieee80211_vif *vif,
1012 bool enable)
1013{
1014#define MT7921_FIF_BIT_CLR BIT(1)
1015#define MT7921_FIF_BIT_SET BIT(0)
1016 int err;
1017
1018 if (enable) {
1019 err = mt7921_mcu_uni_bss_bcnft(dev, vif, true);
1020 if (err)
1021 return err;
1022
1023 err = mt7921_mcu_set_rxfilter(dev, 0,
1024 MT7921_FIF_BIT_SET,
1025 MT_WF_RFCR_DROP_OTHER_BEACON);
1026 if (err)
1027 return err;
1028
1029 return 0;
1030 }
1031
1032 err = mt7921_mcu_set_bss_pm(dev, vif, false);
1033 if (err)
1034 return err;
1035
1036 err = mt7921_mcu_set_rxfilter(dev, 0,
1037 MT7921_FIF_BIT_CLR,
1038 MT_WF_RFCR_DROP_OTHER_BEACON);
1039 if (err)
1040 return err;
1041
1042 return 0;
1043}
1044
1045int mt7921_get_txpwr_info(struct mt792x_dev *dev, struct mt7921_txpwr *txpwr)
1046{
1047 struct mt7921_txpwr_event *event;
1048 struct mt7921_txpwr_req req = {
1049 .dbdc_idx = 0,
1050 };
1051 struct sk_buff *skb;
1052 int ret;
1053
1054 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_CE_CMD(GET_TXPWR),
1055 &req, sizeof(req), true, &skb);
1056 if (ret)
1057 return ret;
1058
1059 event = (struct mt7921_txpwr_event *)skb->data;
1060 WARN_ON(skb->len != le16_to_cpu(event->len));
1061 memcpy(txpwr, &event->txpwr, sizeof(event->txpwr));
1062
1063 dev_kfree_skb(skb);
1064
1065 return 0;
1066}
1067
1068int mt7921_mcu_set_sniffer(struct mt792x_dev *dev, struct ieee80211_vif *vif,
1069 bool enable)
1070{
1071 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
1072 struct {
1073 struct {
1074 u8 band_idx;
1075 u8 pad[3];
1076 } __packed hdr;
1077 struct sniffer_enable_tlv {
1078 __le16 tag;
1079 __le16 len;
1080 u8 enable;
1081 u8 pad[3];
1082 } __packed enable;
1083 } req = {
1084 .hdr = {
1085 .band_idx = mvif->band_idx,
1086 },
1087 .enable = {
1088 .tag = cpu_to_le16(0),
1089 .len = cpu_to_le16(sizeof(struct sniffer_enable_tlv)),
1090 .enable = enable,
1091 },
1092 };
1093
1094 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(SNIFFER), &req, sizeof(req),
1095 true);
1096}
1097
1098int mt7921_mcu_config_sniffer(struct mt792x_vif *vif,
1099 struct ieee80211_chanctx_conf *ctx)
1100{
1101 struct cfg80211_chan_def *chandef = &ctx->def;
1102 int freq1 = chandef->center_freq1, freq2 = chandef->center_freq2;
1103 const u8 ch_band[] = {
1104 [NL80211_BAND_2GHZ] = 1,
1105 [NL80211_BAND_5GHZ] = 2,
1106 [NL80211_BAND_6GHZ] = 3,
1107 };
1108 const u8 ch_width[] = {
1109 [NL80211_CHAN_WIDTH_20_NOHT] = 0,
1110 [NL80211_CHAN_WIDTH_20] = 0,
1111 [NL80211_CHAN_WIDTH_40] = 0,
1112 [NL80211_CHAN_WIDTH_80] = 1,
1113 [NL80211_CHAN_WIDTH_160] = 2,
1114 [NL80211_CHAN_WIDTH_80P80] = 3,
1115 [NL80211_CHAN_WIDTH_5] = 4,
1116 [NL80211_CHAN_WIDTH_10] = 5,
1117 [NL80211_CHAN_WIDTH_320] = 6,
1118 };
1119 struct {
1120 struct {
1121 u8 band_idx;
1122 u8 pad[3];
1123 } __packed hdr;
1124 struct config_tlv {
1125 __le16 tag;
1126 __le16 len;
1127 u16 aid;
1128 u8 ch_band;
1129 u8 bw;
1130 u8 control_ch;
1131 u8 sco;
1132 u8 center_ch;
1133 u8 center_ch2;
1134 u8 drop_err;
1135 u8 pad[3];
1136 } __packed tlv;
1137 } __packed req = {
1138 .hdr = {
1139 .band_idx = vif->mt76.band_idx,
1140 },
1141 .tlv = {
1142 .tag = cpu_to_le16(1),
1143 .len = cpu_to_le16(sizeof(req.tlv)),
1144 .control_ch = chandef->chan->hw_value,
1145 .center_ch = ieee80211_frequency_to_channel(freq1),
1146 .drop_err = 1,
1147 },
1148 };
1149 if (chandef->chan->band < ARRAY_SIZE(ch_band))
1150 req.tlv.ch_band = ch_band[chandef->chan->band];
1151 if (chandef->width < ARRAY_SIZE(ch_width))
1152 req.tlv.bw = ch_width[chandef->width];
1153
1154 if (freq2)
1155 req.tlv.center_ch2 = ieee80211_frequency_to_channel(freq2);
1156
1157 if (req.tlv.control_ch < req.tlv.center_ch)
1158 req.tlv.sco = 1; /* SCA */
1159 else if (req.tlv.control_ch > req.tlv.center_ch)
1160 req.tlv.sco = 3; /* SCB */
1161
1162 return mt76_mcu_send_msg(vif->phy->mt76->dev, MCU_UNI_CMD(SNIFFER),
1163 &req, sizeof(req), true);
1164}
1165
1166int
1167mt7921_mcu_uni_add_beacon_offload(struct mt792x_dev *dev,
1168 struct ieee80211_hw *hw,
1169 struct ieee80211_vif *vif,
1170 bool enable)
1171{
1172 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv;
1173 struct mt76_wcid *wcid = &dev->mt76.global_wcid;
1174 struct ieee80211_mutable_offsets offs;
1175 struct {
1176 struct req_hdr {
1177 u8 bss_idx;
1178 u8 pad[3];
1179 } __packed hdr;
1180 struct bcn_content_tlv {
1181 __le16 tag;
1182 __le16 len;
1183 __le16 tim_ie_pos;
1184 __le16 csa_ie_pos;
1185 __le16 bcc_ie_pos;
1186 /* 0: disable beacon offload
1187 * 1: enable beacon offload
1188 * 2: update probe respond offload
1189 */
1190 u8 enable;
1191 /* 0: legacy format (TXD + payload)
1192 * 1: only cap field IE
1193 */
1194 u8 type;
1195 __le16 pkt_len;
1196 u8 pkt[512];
1197 } __packed beacon_tlv;
1198 } req = {
1199 .hdr = {
1200 .bss_idx = mvif->mt76.idx,
1201 },
1202 .beacon_tlv = {
1203 .tag = cpu_to_le16(UNI_BSS_INFO_BCN_CONTENT),
1204 .len = cpu_to_le16(sizeof(struct bcn_content_tlv)),
1205 .enable = enable,
1206 },
1207 };
1208 struct sk_buff *skb;
1209
1210 /* support enable/update process only
1211 * disable flow would be handled in bss stop handler automatically
1212 */
1213 if (!enable)
1214 return -EOPNOTSUPP;
1215
1216 skb = ieee80211_beacon_get_template(mt76_hw(dev), vif, &offs, 0);
1217 if (!skb)
1218 return -EINVAL;
1219
1220 if (skb->len > 512 - MT_TXD_SIZE) {
1221 dev_err(dev->mt76.dev, "beacon size limit exceed\n");
1222 dev_kfree_skb(skb);
1223 return -EINVAL;
1224 }
1225
1226 mt76_connac2_mac_write_txwi(&dev->mt76, (__le32 *)(req.beacon_tlv.pkt),
1227 skb, wcid, NULL, 0, 0, BSS_CHANGED_BEACON);
1228 memcpy(req.beacon_tlv.pkt + MT_TXD_SIZE, skb->data, skb->len);
1229 req.beacon_tlv.pkt_len = cpu_to_le16(MT_TXD_SIZE + skb->len);
1230 req.beacon_tlv.tim_ie_pos = cpu_to_le16(MT_TXD_SIZE + offs.tim_offset);
1231
1232 if (offs.cntdwn_counter_offs[0]) {
1233 u16 csa_offs;
1234
1235 csa_offs = MT_TXD_SIZE + offs.cntdwn_counter_offs[0] - 4;
1236 req.beacon_tlv.csa_ie_pos = cpu_to_le16(csa_offs);
1237 }
1238 dev_kfree_skb(skb);
1239
1240 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD(BSS_INFO_UPDATE),
1241 &req, sizeof(req), true);
1242}
1243
1244static
1245int __mt7921_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
1246 enum environment_cap env_cap,
1247 struct mt7921_clc *clc,
1248 u8 idx)
1249{
1250#define CLC_CAP_EVT_EN BIT(0)
1251#define CLC_CAP_DTS_EN BIT(1)
1252 struct sk_buff *skb, *ret_skb = NULL;
1253 struct {
1254 u8 ver;
1255 u8 pad0;
1256 __le16 len;
1257 u8 idx;
1258 u8 env;
1259 u8 acpi_conf;
1260 u8 cap;
1261 u8 alpha2[2];
1262 u8 type[2];
1263 u8 env_6g;
1264 u8 mtcl_conf;
1265 u8 rsvd[62];
1266 } __packed req = {
1267 .ver = 1,
1268 .idx = idx,
1269 .env = env_cap,
1270 .env_6g = dev->phy.power_type,
1271 .acpi_conf = mt792x_acpi_get_flags(&dev->phy),
1272 .mtcl_conf = mt792x_acpi_get_mtcl_conf(&dev->phy, alpha2),
1273 };
1274 int ret, valid_cnt = 0;
1275 u16 buf_len = 0;
1276 u8 *pos;
1277
1278 if (!clc)
1279 return 0;
1280
1281 if (dev->phy.chip_cap & MT792x_CHIP_CAP_CLC_EVT_EN)
1282 req.cap |= CLC_CAP_EVT_EN;
1283 if (mt76_find_power_limits_node(&dev->mt76))
1284 req.cap |= CLC_CAP_DTS_EN;
1285
1286 buf_len = le16_to_cpu(clc->len) - sizeof(*clc);
1287 pos = clc->data;
1288 while (buf_len > 16) {
1289 struct mt7921_clc_rule *rule = (struct mt7921_clc_rule *)pos;
1290 u16 len = le16_to_cpu(rule->len);
1291 u16 offset = len + sizeof(*rule);
1292
1293 pos += offset;
1294 buf_len -= offset;
1295 if (rule->alpha2[0] != alpha2[0] ||
1296 rule->alpha2[1] != alpha2[1])
1297 continue;
1298
1299 memcpy(req.alpha2, rule->alpha2, 2);
1300 memcpy(req.type, rule->type, 2);
1301
1302 req.len = cpu_to_le16(sizeof(req) + len);
1303 skb = __mt76_mcu_msg_alloc(&dev->mt76, &req,
1304 le16_to_cpu(req.len),
1305 sizeof(req), GFP_KERNEL);
1306 if (!skb)
1307 return -ENOMEM;
1308 skb_put_data(skb, rule->data, len);
1309
1310 ret = mt76_mcu_skb_send_and_get_msg(&dev->mt76, skb,
1311 MCU_CE_CMD(SET_CLC),
1312 !!(req.cap & CLC_CAP_EVT_EN),
1313 &ret_skb);
1314 if (ret < 0)
1315 return ret;
1316
1317 if (ret_skb) {
1318 struct mt7921_clc_info_tlv *info;
1319
1320 info = (struct mt7921_clc_info_tlv *)(ret_skb->data + 4);
1321 dev->phy.clc_chan_conf = info->chan_conf;
1322 dev_kfree_skb(ret_skb);
1323 }
1324
1325 valid_cnt++;
1326 }
1327
1328 if (!valid_cnt)
1329 return -ENOENT;
1330
1331 return 0;
1332}
1333
1334int mt7921_mcu_set_clc(struct mt792x_dev *dev, u8 *alpha2,
1335 enum environment_cap env_cap)
1336{
1337 struct mt792x_phy *phy = (struct mt792x_phy *)&dev->phy;
1338 int i, ret;
1339
1340 /* submit all clc config */
1341 for (i = 0; i < ARRAY_SIZE(phy->clc); i++) {
1342 ret = __mt7921_mcu_set_clc(dev, alpha2, env_cap,
1343 phy->clc[i], i);
1344
1345 /* If no country found, set "00" as default */
1346 if (ret == -ENOENT)
1347 ret = __mt7921_mcu_set_clc(dev, "00",
1348 ENVIRON_INDOOR,
1349 phy->clc[i], i);
1350 if (ret < 0)
1351 return ret;
1352 }
1353 return 0;
1354}
1355
1356int mt7921_mcu_get_temperature(struct mt792x_phy *phy)
1357{
1358 struct mt792x_dev *dev = phy->dev;
1359 struct {
1360 u8 ctrl_id;
1361 u8 action;
1362 u8 band_idx;
1363 u8 rsv[5];
1364 } req = {
1365 .ctrl_id = THERMAL_SENSOR_TEMP_QUERY,
1366 .band_idx = phy->mt76->band_idx,
1367 };
1368
1369 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD(THERMAL_CTRL), &req,
1370 sizeof(req), true);
1371}
1372
1373int mt7921_mcu_set_rxfilter(struct mt792x_dev *dev, u32 fif,
1374 u8 bit_op, u32 bit_map)
1375{
1376 struct {
1377 u8 rsv[4];
1378 u8 mode;
1379 u8 rsv2[3];
1380 __le32 fif;
1381 __le32 bit_map; /* bit_* for bitmap update */
1382 u8 bit_op;
1383 u8 pad[51];
1384 } __packed data = {
1385 .mode = fif ? 1 : 2,
1386 .fif = cpu_to_le32(fif),
1387 .bit_map = cpu_to_le32(bit_map),
1388 .bit_op = bit_op,
1389 };
1390
1391 return mt76_mcu_send_msg(&dev->mt76, MCU_CE_CMD(SET_RX_FILTER),
1392 &data, sizeof(data), false);
1393}