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