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