1 // SPDX-License-Identifier: ISC
2 /* Copyright (C) 2020 MediaTek Inc. */
3
4 #include <linux/firmware.h>
5 #include <linux/fs.h>
6 #include "mt7921.h"
7 #include "mt7921_trace.h"
8 #include "mcu.h"
9 #include "mac.h"
10
11 struct mt7921_patch_hdr {
12 char build_date[16];
13 char platform[4];
14 __be32 hw_sw_ver;
15 __be32 patch_ver;
16 __be16 checksum;
17 u16 reserved;
18 struct {
19 __be32 patch_ver;
20 __be32 subsys;
21 __be32 feature;
22 __be32 n_region;
23 __be32 crc;
24 u32 reserved[11];
25 } desc;
26 } __packed;
27
28 struct mt7921_patch_sec {
29 __be32 type;
30 __be32 offs;
31 __be32 size;
32 union {
33 __be32 spec[13];
34 struct {
35 __be32 addr;
36 __be32 len;
37 __be32 sec_key_idx;
38 __be32 align_len;
39 u32 reserved[9];
40 } info;
41 };
42 } __packed;
43
44 struct mt7921_fw_trailer {
45 u8 chip_id;
46 u8 eco_code;
47 u8 n_region;
48 u8 format_ver;
49 u8 format_flag;
50 u8 reserved[2];
51 char fw_ver[10];
52 char build_date[15];
53 u32 crc;
54 } __packed;
55
56 struct mt7921_fw_region {
57 __le32 decomp_crc;
58 __le32 decomp_len;
59 __le32 decomp_blk_sz;
60 u8 reserved[4];
61 __le32 addr;
62 __le32 len;
63 u8 feature_set;
64 u8 reserved1[15];
65 } __packed;
66
67 #define MT_STA_BFER BIT(0)
68 #define MT_STA_BFEE BIT(1)
69
70 #define FW_FEATURE_SET_ENCRYPT BIT(0)
71 #define FW_FEATURE_SET_KEY_IDX GENMASK(2, 1)
72 #define FW_FEATURE_ENCRY_MODE BIT(4)
73 #define FW_FEATURE_OVERRIDE_ADDR BIT(5)
74
75 #define DL_MODE_ENCRYPT BIT(0)
76 #define DL_MODE_KEY_IDX GENMASK(2, 1)
77 #define DL_MODE_RESET_SEC_IV BIT(3)
78 #define DL_MODE_WORKING_PDA_CR4 BIT(4)
79 #define DL_CONFIG_ENCRY_MODE_SEL BIT(6)
80 #define DL_MODE_NEED_RSP BIT(31)
81
82 #define FW_START_OVERRIDE BIT(0)
83 #define FW_START_WORKING_PDA_CR4 BIT(2)
84
85 #define PATCH_SEC_NOT_SUPPORT GENMASK(31, 0)
86 #define PATCH_SEC_TYPE_MASK GENMASK(15, 0)
87 #define PATCH_SEC_TYPE_INFO 0x2
88
89 #define PATCH_SEC_ENC_TYPE_MASK GENMASK(31, 24)
90 #define PATCH_SEC_ENC_TYPE_PLAIN 0x00
91 #define PATCH_SEC_ENC_TYPE_AES 0x01
92 #define PATCH_SEC_ENC_TYPE_SCRAMBLE 0x02
93 #define PATCH_SEC_ENC_SCRAMBLE_INFO_MASK GENMASK(15, 0)
94 #define PATCH_SEC_ENC_AES_KEY_MASK GENMASK(7, 0)
95
96 #define to_wcid_lo(id) FIELD_GET(GENMASK(7, 0), (u16)id)
97 #define to_wcid_hi(id) FIELD_GET(GENMASK(9, 8), (u16)id)
98
99 static enum mcu_cipher_type
mt7921_mcu_get_cipher(int cipher)100 mt7921_mcu_get_cipher(int cipher)
101 {
102 switch (cipher) {
103 case WLAN_CIPHER_SUITE_WEP40:
104 return MCU_CIPHER_WEP40;
105 case WLAN_CIPHER_SUITE_WEP104:
106 return MCU_CIPHER_WEP104;
107 case WLAN_CIPHER_SUITE_TKIP:
108 return MCU_CIPHER_TKIP;
109 case WLAN_CIPHER_SUITE_AES_CMAC:
110 return MCU_CIPHER_BIP_CMAC_128;
111 case WLAN_CIPHER_SUITE_CCMP:
112 return MCU_CIPHER_AES_CCMP;
113 case WLAN_CIPHER_SUITE_CCMP_256:
114 return MCU_CIPHER_CCMP_256;
115 case WLAN_CIPHER_SUITE_GCMP:
116 return MCU_CIPHER_GCMP;
117 case WLAN_CIPHER_SUITE_GCMP_256:
118 return MCU_CIPHER_GCMP_256;
119 case WLAN_CIPHER_SUITE_SMS4:
120 return MCU_CIPHER_WAPI;
121 default:
122 return MCU_CIPHER_NONE;
123 }
124 }
125
mt7921_mcu_chan_bw(struct cfg80211_chan_def * chandef)126 static u8 mt7921_mcu_chan_bw(struct cfg80211_chan_def *chandef)
127 {
128 static const u8 width_to_bw[] = {
129 [NL80211_CHAN_WIDTH_40] = CMD_CBW_40MHZ,
130 [NL80211_CHAN_WIDTH_80] = CMD_CBW_80MHZ,
131 [NL80211_CHAN_WIDTH_80P80] = CMD_CBW_8080MHZ,
132 [NL80211_CHAN_WIDTH_160] = CMD_CBW_160MHZ,
133 [NL80211_CHAN_WIDTH_5] = CMD_CBW_5MHZ,
134 [NL80211_CHAN_WIDTH_10] = CMD_CBW_10MHZ,
135 [NL80211_CHAN_WIDTH_20] = CMD_CBW_20MHZ,
136 [NL80211_CHAN_WIDTH_20_NOHT] = CMD_CBW_20MHZ,
137 };
138
139 if (chandef->width >= ARRAY_SIZE(width_to_bw))
140 return 0;
141
142 return width_to_bw[chandef->width];
143 }
144
145 static int
mt7921_mcu_parse_eeprom(struct mt76_dev * dev,struct sk_buff * skb)146 mt7921_mcu_parse_eeprom(struct mt76_dev *dev, struct sk_buff *skb)
147 {
148 struct mt7921_mcu_eeprom_info *res;
149 u8 *buf;
150
151 if (!skb)
152 return -EINVAL;
153
154 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
155
156 res = (struct mt7921_mcu_eeprom_info *)skb->data;
157 buf = dev->eeprom.data + le32_to_cpu(res->addr);
158 memcpy(buf, res->data, 16);
159
160 return 0;
161 }
162
mt7921_mcu_parse_response(struct mt76_dev * mdev,int cmd,struct sk_buff * skb,int seq)163 int mt7921_mcu_parse_response(struct mt76_dev *mdev, int cmd,
164 struct sk_buff *skb, int seq)
165 {
166 struct mt7921_mcu_rxd *rxd;
167 int mcu_cmd = cmd & MCU_CMD_MASK;
168 int ret = 0;
169
170 if (!skb) {
171 dev_err(mdev->dev, "Message %08x (seq %d) timeout\n",
172 cmd, seq);
173 mt7921_reset(mdev);
174
175 return -ETIMEDOUT;
176 }
177
178 rxd = (struct mt7921_mcu_rxd *)skb->data;
179 if (seq != rxd->seq)
180 return -EAGAIN;
181
182 switch (cmd) {
183 case MCU_CMD_PATCH_SEM_CONTROL:
184 skb_pull(skb, sizeof(*rxd) - 4);
185 ret = *skb->data;
186 break;
187 case MCU_EXT_CMD_GET_TEMP:
188 skb_pull(skb, sizeof(*rxd) + 4);
189 ret = le32_to_cpu(*(__le32 *)skb->data);
190 break;
191 case MCU_EXT_CMD_EFUSE_ACCESS:
192 ret = mt7921_mcu_parse_eeprom(mdev, skb);
193 break;
194 case MCU_UNI_CMD_DEV_INFO_UPDATE:
195 case MCU_UNI_CMD_BSS_INFO_UPDATE:
196 case MCU_UNI_CMD_STA_REC_UPDATE:
197 case MCU_UNI_CMD_HIF_CTRL:
198 case MCU_UNI_CMD_OFFLOAD:
199 case MCU_UNI_CMD_SUSPEND: {
200 struct mt7921_mcu_uni_event *event;
201
202 skb_pull(skb, sizeof(*rxd));
203 event = (struct mt7921_mcu_uni_event *)skb->data;
204 ret = le32_to_cpu(event->status);
205 /* skip invalid event */
206 if (mcu_cmd != event->cid)
207 ret = -EAGAIN;
208 break;
209 }
210 case MCU_CMD_REG_READ: {
211 struct mt7921_mcu_reg_event *event;
212
213 skb_pull(skb, sizeof(*rxd));
214 event = (struct mt7921_mcu_reg_event *)skb->data;
215 ret = (int)le32_to_cpu(event->val);
216 break;
217 }
218 default:
219 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
220 break;
221 }
222
223 return ret;
224 }
225 EXPORT_SYMBOL_GPL(mt7921_mcu_parse_response);
226
mt7921_mcu_fill_message(struct mt76_dev * mdev,struct sk_buff * skb,int cmd,int * wait_seq)227 int mt7921_mcu_fill_message(struct mt76_dev *mdev, struct sk_buff *skb,
228 int cmd, int *wait_seq)
229 {
230 struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
231 int txd_len, mcu_cmd = cmd & MCU_CMD_MASK;
232 struct mt7921_uni_txd *uni_txd;
233 struct mt7921_mcu_txd *mcu_txd;
234 __le32 *txd;
235 u32 val;
236 u8 seq;
237
238 switch (cmd) {
239 case MCU_UNI_CMD_HIF_CTRL:
240 case MCU_UNI_CMD_SUSPEND:
241 case MCU_UNI_CMD_OFFLOAD:
242 mdev->mcu.timeout = HZ / 3;
243 break;
244 default:
245 mdev->mcu.timeout = 3 * HZ;
246 break;
247 }
248
249 seq = ++dev->mt76.mcu.msg_seq & 0xf;
250 if (!seq)
251 seq = ++dev->mt76.mcu.msg_seq & 0xf;
252
253 if (cmd == MCU_CMD_FW_SCATTER)
254 goto exit;
255
256 txd_len = cmd & MCU_UNI_PREFIX ? sizeof(*uni_txd) : sizeof(*mcu_txd);
257 txd = (__le32 *)skb_push(skb, txd_len);
258
259 val = FIELD_PREP(MT_TXD0_TX_BYTES, skb->len) |
260 FIELD_PREP(MT_TXD0_PKT_FMT, MT_TX_TYPE_CMD) |
261 FIELD_PREP(MT_TXD0_Q_IDX, MT_TX_MCU_PORT_RX_Q0);
262 txd[0] = cpu_to_le32(val);
263
264 val = MT_TXD1_LONG_FORMAT |
265 FIELD_PREP(MT_TXD1_HDR_FORMAT, MT_HDR_FORMAT_CMD);
266 txd[1] = cpu_to_le32(val);
267
268 if (cmd & MCU_UNI_PREFIX) {
269 uni_txd = (struct mt7921_uni_txd *)txd;
270 uni_txd->len = cpu_to_le16(skb->len - sizeof(uni_txd->txd));
271 uni_txd->option = MCU_CMD_UNI_EXT_ACK;
272 uni_txd->cid = cpu_to_le16(mcu_cmd);
273 uni_txd->s2d_index = MCU_S2D_H2N;
274 uni_txd->pkt_type = MCU_PKT_ID;
275 uni_txd->seq = seq;
276
277 goto exit;
278 }
279
280 mcu_txd = (struct mt7921_mcu_txd *)txd;
281 mcu_txd->len = cpu_to_le16(skb->len - sizeof(mcu_txd->txd));
282 mcu_txd->pq_id = cpu_to_le16(MCU_PQ_ID(MT_TX_PORT_IDX_MCU,
283 MT_TX_MCU_PORT_RX_Q0));
284 mcu_txd->pkt_type = MCU_PKT_ID;
285 mcu_txd->seq = seq;
286
287 switch (cmd & ~MCU_CMD_MASK) {
288 case MCU_FW_PREFIX:
289 mcu_txd->set_query = MCU_Q_NA;
290 mcu_txd->cid = mcu_cmd;
291 break;
292 case MCU_CE_PREFIX:
293 if (cmd & MCU_QUERY_MASK)
294 mcu_txd->set_query = MCU_Q_QUERY;
295 else
296 mcu_txd->set_query = MCU_Q_SET;
297 mcu_txd->cid = mcu_cmd;
298 break;
299 default:
300 mcu_txd->cid = MCU_CMD_EXT_CID;
301 if (cmd & MCU_QUERY_PREFIX || cmd == MCU_EXT_CMD_EFUSE_ACCESS)
302 mcu_txd->set_query = MCU_Q_QUERY;
303 else
304 mcu_txd->set_query = MCU_Q_SET;
305 mcu_txd->ext_cid = mcu_cmd;
306 mcu_txd->ext_cid_ack = 1;
307 break;
308 }
309
310 mcu_txd->s2d_index = MCU_S2D_H2N;
311 WARN_ON(cmd == MCU_EXT_CMD_EFUSE_ACCESS &&
312 mcu_txd->set_query != MCU_Q_QUERY);
313
314 exit:
315 if (wait_seq)
316 *wait_seq = seq;
317
318 return 0;
319 }
320 EXPORT_SYMBOL_GPL(mt7921_mcu_fill_message);
321
322 static void
mt7921_mcu_scan_event(struct mt7921_dev * dev,struct sk_buff * skb)323 mt7921_mcu_scan_event(struct mt7921_dev *dev, struct sk_buff *skb)
324 {
325 struct mt76_phy *mphy = &dev->mt76.phy;
326 struct mt7921_phy *phy = (struct mt7921_phy *)mphy->priv;
327
328 spin_lock_bh(&dev->mt76.lock);
329 __skb_queue_tail(&phy->scan_event_list, skb);
330 spin_unlock_bh(&dev->mt76.lock);
331
332 ieee80211_queue_delayed_work(mphy->hw, &phy->scan_work,
333 MT7921_HW_SCAN_TIMEOUT);
334 }
335
336 static void
mt7921_mcu_connection_loss_iter(void * priv,u8 * mac,struct ieee80211_vif * vif)337 mt7921_mcu_connection_loss_iter(void *priv, u8 *mac,
338 struct ieee80211_vif *vif)
339 {
340 struct mt76_vif *mvif = (struct mt76_vif *)vif->drv_priv;
341 struct mt76_connac_beacon_loss_event *event = priv;
342
343 if (mvif->idx != event->bss_idx)
344 return;
345
346 if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
347 return;
348
349 ieee80211_connection_loss(vif);
350 }
351
352 static void
mt7921_mcu_connection_loss_event(struct mt7921_dev * dev,struct sk_buff * skb)353 mt7921_mcu_connection_loss_event(struct mt7921_dev *dev, struct sk_buff *skb)
354 {
355 struct mt76_connac_beacon_loss_event *event;
356 struct mt76_phy *mphy = &dev->mt76.phy;
357
358 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
359 event = (struct mt76_connac_beacon_loss_event *)skb->data;
360
361 ieee80211_iterate_active_interfaces_atomic(mphy->hw,
362 IEEE80211_IFACE_ITER_RESUME_ALL,
363 mt7921_mcu_connection_loss_iter, event);
364 }
365
366 static void
mt7921_mcu_bss_event(struct mt7921_dev * dev,struct sk_buff * skb)367 mt7921_mcu_bss_event(struct mt7921_dev *dev, struct sk_buff *skb)
368 {
369 struct mt76_phy *mphy = &dev->mt76.phy;
370 struct mt76_connac_mcu_bss_event *event;
371
372 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
373 event = (struct mt76_connac_mcu_bss_event *)skb->data;
374 if (event->is_absent)
375 ieee80211_stop_queues(mphy->hw);
376 else
377 ieee80211_wake_queues(mphy->hw);
378 }
379
380 static void
mt7921_mcu_debug_msg_event(struct mt7921_dev * dev,struct sk_buff * skb)381 mt7921_mcu_debug_msg_event(struct mt7921_dev *dev, struct sk_buff *skb)
382 {
383 struct mt7921_debug_msg {
384 __le16 id;
385 u8 type;
386 u8 flag;
387 __le32 value;
388 __le16 len;
389 u8 content[512];
390 } __packed * msg;
391
392 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
393 msg = (struct mt7921_debug_msg *)skb->data;
394
395 if (msg->type == 3) { /* fw log */
396 u16 len = min_t(u16, le16_to_cpu(msg->len), 512);
397 int i;
398
399 for (i = 0 ; i < len; i++) {
400 if (!msg->content[i])
401 msg->content[i] = ' ';
402 }
403 wiphy_info(mt76_hw(dev)->wiphy, "%.*s", len, msg->content);
404 }
405 }
406
407 static void
mt7921_mcu_low_power_event(struct mt7921_dev * dev,struct sk_buff * skb)408 mt7921_mcu_low_power_event(struct mt7921_dev *dev, struct sk_buff *skb)
409 {
410 struct mt7921_mcu_lp_event {
411 u8 state;
412 u8 reserved[3];
413 } __packed * event;
414
415 skb_pull(skb, sizeof(struct mt7921_mcu_rxd));
416 event = (struct mt7921_mcu_lp_event *)skb->data;
417
418 trace_lp_event(dev, event->state);
419 }
420
421 static void
mt7921_mcu_rx_unsolicited_event(struct mt7921_dev * dev,struct sk_buff * skb)422 mt7921_mcu_rx_unsolicited_event(struct mt7921_dev *dev, struct sk_buff *skb)
423 {
424 struct mt7921_mcu_rxd *rxd = (struct mt7921_mcu_rxd *)skb->data;
425
426 switch (rxd->eid) {
427 case MCU_EVENT_BSS_BEACON_LOSS:
428 mt7921_mcu_connection_loss_event(dev, skb);
429 break;
430 case MCU_EVENT_SCHED_SCAN_DONE:
431 case MCU_EVENT_SCAN_DONE:
432 mt7921_mcu_scan_event(dev, skb);
433 return;
434 case MCU_EVENT_BSS_ABSENCE:
435 mt7921_mcu_bss_event(dev, skb);
436 break;
437 case MCU_EVENT_DBG_MSG:
438 mt7921_mcu_debug_msg_event(dev, skb);
439 break;
440 case MCU_EVENT_COREDUMP:
441 dev->fw_assert = true;
442 mt76_connac_mcu_coredump_event(&dev->mt76, skb,
443 &dev->coredump);
444 return;
445 case MCU_EVENT_LP_INFO:
446 mt7921_mcu_low_power_event(dev, skb);
447 break;
448 default:
449 break;
450 }
451 dev_kfree_skb(skb);
452 }
453
mt7921_mcu_rx_event(struct mt7921_dev * dev,struct sk_buff * skb)454 void mt7921_mcu_rx_event(struct mt7921_dev *dev, struct sk_buff *skb)
455 {
456 struct mt7921_mcu_rxd *rxd;
457
458 if (skb_linearize(skb))
459 return;
460
461 rxd = (struct mt7921_mcu_rxd *)skb->data;
462
463 if (rxd->eid == 0x6) {
464 mt76_mcu_rx_event(&dev->mt76, skb);
465 return;
466 }
467
468 if (rxd->ext_eid == MCU_EXT_EVENT_RATE_REPORT ||
469 rxd->eid == MCU_EVENT_BSS_BEACON_LOSS ||
470 rxd->eid == MCU_EVENT_SCHED_SCAN_DONE ||
471 rxd->eid == MCU_EVENT_BSS_ABSENCE ||
472 rxd->eid == MCU_EVENT_SCAN_DONE ||
473 rxd->eid == MCU_EVENT_TX_DONE ||
474 rxd->eid == MCU_EVENT_DBG_MSG ||
475 rxd->eid == MCU_EVENT_COREDUMP ||
476 rxd->eid == MCU_EVENT_LP_INFO ||
477 !rxd->seq)
478 mt7921_mcu_rx_unsolicited_event(dev, skb);
479 else
480 mt76_mcu_rx_event(&dev->mt76, skb);
481 }
482
483 /** starec & wtbl **/
484 static int
mt7921_mcu_sta_key_tlv(struct mt7921_sta * msta,struct sk_buff * skb,struct ieee80211_key_conf * key,enum set_key_cmd cmd)485 mt7921_mcu_sta_key_tlv(struct mt7921_sta *msta, struct sk_buff *skb,
486 struct ieee80211_key_conf *key, enum set_key_cmd cmd)
487 {
488 struct mt7921_sta_key_conf *bip = &msta->bip;
489 struct sta_rec_sec *sec;
490 struct tlv *tlv;
491 u32 len = sizeof(*sec);
492
493 tlv = mt76_connac_mcu_add_tlv(skb, STA_REC_KEY_V2, sizeof(*sec));
494
495 sec = (struct sta_rec_sec *)tlv;
496 sec->add = cmd;
497
498 if (cmd == SET_KEY) {
499 struct sec_key *sec_key;
500 u8 cipher;
501
502 cipher = mt7921_mcu_get_cipher(key->cipher);
503 if (cipher == MCU_CIPHER_NONE)
504 return -EOPNOTSUPP;
505
506 sec_key = &sec->key[0];
507 sec_key->cipher_len = sizeof(*sec_key);
508
509 if (cipher == MCU_CIPHER_BIP_CMAC_128) {
510 sec_key->cipher_id = MCU_CIPHER_AES_CCMP;
511 sec_key->key_id = bip->keyidx;
512 sec_key->key_len = 16;
513 memcpy(sec_key->key, bip->key, 16);
514
515 sec_key = &sec->key[1];
516 sec_key->cipher_id = MCU_CIPHER_BIP_CMAC_128;
517 sec_key->cipher_len = sizeof(*sec_key);
518 sec_key->key_len = 16;
519 memcpy(sec_key->key, key->key, 16);
520
521 sec->n_cipher = 2;
522 } else {
523 sec_key->cipher_id = cipher;
524 sec_key->key_id = key->keyidx;
525 sec_key->key_len = key->keylen;
526 memcpy(sec_key->key, key->key, key->keylen);
527
528 if (cipher == MCU_CIPHER_TKIP) {
529 /* Rx/Tx MIC keys are swapped */
530 memcpy(sec_key->key + 16, key->key + 24, 8);
531 memcpy(sec_key->key + 24, key->key + 16, 8);
532 }
533
534 /* store key_conf for BIP batch update */
535 if (cipher == MCU_CIPHER_AES_CCMP) {
536 memcpy(bip->key, key->key, key->keylen);
537 bip->keyidx = key->keyidx;
538 }
539
540 len -= sizeof(*sec_key);
541 sec->n_cipher = 1;
542 }
543 } else {
544 len -= sizeof(sec->key);
545 sec->n_cipher = 0;
546 }
547 sec->len = cpu_to_le16(len);
548
549 return 0;
550 }
551
mt7921_mcu_add_key(struct mt7921_dev * dev,struct ieee80211_vif * vif,struct mt7921_sta * msta,struct ieee80211_key_conf * key,enum set_key_cmd cmd)552 int mt7921_mcu_add_key(struct mt7921_dev *dev, struct ieee80211_vif *vif,
553 struct mt7921_sta *msta, struct ieee80211_key_conf *key,
554 enum set_key_cmd cmd)
555 {
556 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
557 struct sk_buff *skb;
558 int ret;
559
560 skb = mt76_connac_mcu_alloc_sta_req(&dev->mt76, &mvif->mt76,
561 &msta->wcid);
562 if (IS_ERR(skb))
563 return PTR_ERR(skb);
564
565 ret = mt7921_mcu_sta_key_tlv(msta, skb, key, cmd);
566 if (ret)
567 return ret;
568
569 return mt76_mcu_skb_send_msg(&dev->mt76, skb,
570 MCU_UNI_CMD_STA_REC_UPDATE, true);
571 }
572
mt7921_mcu_uni_tx_ba(struct mt7921_dev * dev,struct ieee80211_ampdu_params * params,bool enable)573 int mt7921_mcu_uni_tx_ba(struct mt7921_dev *dev,
574 struct ieee80211_ampdu_params *params,
575 bool enable)
576 {
577 struct mt7921_sta *msta = (struct mt7921_sta *)params->sta->drv_priv;
578
579 if (enable && !params->amsdu)
580 msta->wcid.amsdu = false;
581
582 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params,
583 enable, true);
584 }
585
mt7921_mcu_uni_rx_ba(struct mt7921_dev * dev,struct ieee80211_ampdu_params * params,bool enable)586 int mt7921_mcu_uni_rx_ba(struct mt7921_dev *dev,
587 struct ieee80211_ampdu_params *params,
588 bool enable)
589 {
590 struct mt7921_sta *msta = (struct mt7921_sta *)params->sta->drv_priv;
591
592 return mt76_connac_mcu_sta_ba(&dev->mt76, &msta->vif->mt76, params,
593 enable, false);
594 }
595
mt7921_mcu_restart(struct mt76_dev * dev)596 int mt7921_mcu_restart(struct mt76_dev *dev)
597 {
598 struct {
599 u8 power_mode;
600 u8 rsv[3];
601 } req = {
602 .power_mode = 1,
603 };
604
605 return mt76_mcu_send_msg(dev, MCU_CMD_NIC_POWER_CTRL, &req,
606 sizeof(req), false);
607 }
608 EXPORT_SYMBOL_GPL(mt7921_mcu_restart);
609
mt7921_get_data_mode(struct mt7921_dev * dev,u32 info)610 static u32 mt7921_get_data_mode(struct mt7921_dev *dev, u32 info)
611 {
612 u32 mode = DL_MODE_NEED_RSP;
613
614 if (info == PATCH_SEC_NOT_SUPPORT)
615 return mode;
616
617 switch (FIELD_GET(PATCH_SEC_ENC_TYPE_MASK, info)) {
618 case PATCH_SEC_ENC_TYPE_PLAIN:
619 break;
620 case PATCH_SEC_ENC_TYPE_AES:
621 mode |= DL_MODE_ENCRYPT;
622 mode |= FIELD_PREP(DL_MODE_KEY_IDX,
623 (info & PATCH_SEC_ENC_AES_KEY_MASK)) & DL_MODE_KEY_IDX;
624 mode |= DL_MODE_RESET_SEC_IV;
625 break;
626 case PATCH_SEC_ENC_TYPE_SCRAMBLE:
627 mode |= DL_MODE_ENCRYPT;
628 mode |= DL_CONFIG_ENCRY_MODE_SEL;
629 mode |= DL_MODE_RESET_SEC_IV;
630 break;
631 default:
632 dev_err(dev->mt76.dev, "Encryption type not support!\n");
633 }
634
635 return mode;
636 }
637
mt7921_patch_name(struct mt7921_dev * dev)638 static char *mt7921_patch_name(struct mt7921_dev *dev)
639 {
640 char *ret;
641
642 if (is_mt7922(&dev->mt76))
643 ret = MT7922_ROM_PATCH;
644 else
645 ret = MT7921_ROM_PATCH;
646
647 return ret;
648 }
649
mt7921_load_patch(struct mt7921_dev * dev)650 static int mt7921_load_patch(struct mt7921_dev *dev)
651 {
652 const struct mt7921_patch_hdr *hdr;
653 const struct firmware *fw = NULL;
654 int i, ret, sem, max_len;
655
656 max_len = mt76_is_sdio(&dev->mt76) ? 2048 : 4096;
657
658 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, true);
659 switch (sem) {
660 case PATCH_IS_DL:
661 return 0;
662 case PATCH_NOT_DL_SEM_SUCCESS:
663 break;
664 default:
665 dev_err(dev->mt76.dev, "Failed to get patch semaphore\n");
666 return -EAGAIN;
667 }
668
669 ret = request_firmware(&fw, mt7921_patch_name(dev), dev->mt76.dev);
670 if (ret)
671 goto out;
672
673 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
674 dev_err(dev->mt76.dev, "Invalid firmware\n");
675 ret = -EINVAL;
676 goto out;
677 }
678
679 hdr = (const struct mt7921_patch_hdr *)(fw->data);
680
681 dev_info(dev->mt76.dev, "HW/SW Version: 0x%x, Build Time: %.16s\n",
682 be32_to_cpu(hdr->hw_sw_ver), hdr->build_date);
683
684 for (i = 0; i < be32_to_cpu(hdr->desc.n_region); i++) {
685 struct mt7921_patch_sec *sec;
686 const u8 *dl;
687 u32 len, addr, mode;
688 u32 sec_info = 0;
689
690 sec = (struct mt7921_patch_sec *)(fw->data + sizeof(*hdr) +
691 i * sizeof(*sec));
692 if ((be32_to_cpu(sec->type) & PATCH_SEC_TYPE_MASK) !=
693 PATCH_SEC_TYPE_INFO) {
694 ret = -EINVAL;
695 goto out;
696 }
697
698 addr = be32_to_cpu(sec->info.addr);
699 len = be32_to_cpu(sec->info.len);
700 dl = fw->data + be32_to_cpu(sec->offs);
701 sec_info = be32_to_cpu(sec->info.sec_key_idx);
702 mode = mt7921_get_data_mode(dev, sec_info);
703
704 ret = mt76_connac_mcu_init_download(&dev->mt76, addr, len,
705 mode);
706 if (ret) {
707 dev_err(dev->mt76.dev, "Download request failed\n");
708 goto out;
709 }
710
711 ret = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD_FW_SCATTER,
712 dl, len, max_len);
713 if (ret) {
714 dev_err(dev->mt76.dev, "Failed to send patch\n");
715 goto out;
716 }
717 }
718
719 ret = mt76_connac_mcu_start_patch(&dev->mt76);
720 if (ret)
721 dev_err(dev->mt76.dev, "Failed to start patch\n");
722
723 out:
724 sem = mt76_connac_mcu_patch_sem_ctrl(&dev->mt76, false);
725 switch (sem) {
726 case PATCH_REL_SEM_SUCCESS:
727 break;
728 default:
729 ret = -EAGAIN;
730 dev_err(dev->mt76.dev, "Failed to release patch semaphore\n");
731 break;
732 }
733 release_firmware(fw);
734
735 return ret;
736 }
737
mt7921_mcu_gen_dl_mode(u8 feature_set,bool is_wa)738 static u32 mt7921_mcu_gen_dl_mode(u8 feature_set, bool is_wa)
739 {
740 u32 ret = 0;
741
742 ret |= (feature_set & FW_FEATURE_SET_ENCRYPT) ?
743 (DL_MODE_ENCRYPT | DL_MODE_RESET_SEC_IV) : 0;
744 ret |= (feature_set & FW_FEATURE_ENCRY_MODE) ?
745 DL_CONFIG_ENCRY_MODE_SEL : 0;
746 ret |= FIELD_PREP(DL_MODE_KEY_IDX,
747 FIELD_GET(FW_FEATURE_SET_KEY_IDX, feature_set));
748 ret |= DL_MODE_NEED_RSP;
749 ret |= is_wa ? DL_MODE_WORKING_PDA_CR4 : 0;
750
751 return ret;
752 }
753
754 static int
mt7921_mcu_send_ram_firmware(struct mt7921_dev * dev,const struct mt7921_fw_trailer * hdr,const u8 * data,bool is_wa)755 mt7921_mcu_send_ram_firmware(struct mt7921_dev *dev,
756 const struct mt7921_fw_trailer *hdr,
757 const u8 *data, bool is_wa)
758 {
759 int i, offset = 0, max_len;
760 u32 override = 0, option = 0;
761
762 max_len = mt76_is_sdio(&dev->mt76) ? 2048 : 4096;
763
764 for (i = 0; i < hdr->n_region; i++) {
765 const struct mt7921_fw_region *region;
766 int err;
767 u32 len, addr, mode;
768
769 region = (const struct mt7921_fw_region *)((const u8 *)hdr -
770 (hdr->n_region - i) * sizeof(*region));
771 mode = mt7921_mcu_gen_dl_mode(region->feature_set, is_wa);
772 len = le32_to_cpu(region->len);
773 addr = le32_to_cpu(region->addr);
774
775 if (region->feature_set & FW_FEATURE_OVERRIDE_ADDR)
776 override = addr;
777
778 err = mt76_connac_mcu_init_download(&dev->mt76, addr, len,
779 mode);
780 if (err) {
781 dev_err(dev->mt76.dev, "Download request failed\n");
782 return err;
783 }
784
785 err = __mt76_mcu_send_firmware(&dev->mt76, MCU_CMD_FW_SCATTER,
786 data + offset, len, max_len);
787 if (err) {
788 dev_err(dev->mt76.dev, "Failed to send firmware.\n");
789 return err;
790 }
791
792 offset += len;
793 }
794
795 if (override)
796 option |= FW_START_OVERRIDE;
797
798 if (is_wa)
799 option |= FW_START_WORKING_PDA_CR4;
800
801 return mt76_connac_mcu_start_firmware(&dev->mt76, override, option);
802 }
803
mt7921_ram_name(struct mt7921_dev * dev)804 static char *mt7921_ram_name(struct mt7921_dev *dev)
805 {
806 char *ret;
807
808 if (is_mt7922(&dev->mt76))
809 ret = MT7922_FIRMWARE_WM;
810 else
811 ret = MT7921_FIRMWARE_WM;
812
813 return ret;
814 }
815
mt7921_load_ram(struct mt7921_dev * dev)816 static int mt7921_load_ram(struct mt7921_dev *dev)
817 {
818 const struct mt7921_fw_trailer *hdr;
819 const struct firmware *fw;
820 int ret;
821
822 ret = request_firmware(&fw, mt7921_ram_name(dev), dev->mt76.dev);
823 if (ret)
824 return ret;
825
826 if (!fw || !fw->data || fw->size < sizeof(*hdr)) {
827 dev_err(dev->mt76.dev, "Invalid firmware\n");
828 ret = -EINVAL;
829 goto out;
830 }
831
832 hdr = (const struct mt7921_fw_trailer *)(fw->data + fw->size -
833 sizeof(*hdr));
834
835 dev_info(dev->mt76.dev, "WM Firmware Version: %.10s, Build Time: %.15s\n",
836 hdr->fw_ver, hdr->build_date);
837
838 ret = mt7921_mcu_send_ram_firmware(dev, hdr, fw->data, false);
839 if (ret) {
840 dev_err(dev->mt76.dev, "Failed to start WM firmware\n");
841 goto out;
842 }
843
844 snprintf(dev->mt76.hw->wiphy->fw_version,
845 sizeof(dev->mt76.hw->wiphy->fw_version),
846 "%.10s-%.15s", hdr->fw_ver, hdr->build_date);
847
848 out:
849 release_firmware(fw);
850
851 return ret;
852 }
853
mt7921_load_firmware(struct mt7921_dev * dev)854 static int mt7921_load_firmware(struct mt7921_dev *dev)
855 {
856 int ret;
857
858 ret = mt76_get_field(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY);
859 if (ret && mt76_is_mmio(&dev->mt76)) {
860 dev_dbg(dev->mt76.dev, "Firmware is already download\n");
861 goto fw_loaded;
862 }
863
864 ret = mt7921_load_patch(dev);
865 if (ret)
866 return ret;
867
868 ret = mt7921_load_ram(dev);
869 if (ret)
870 return ret;
871
872 if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY,
873 MT_TOP_MISC2_FW_N9_RDY, 1500)) {
874 dev_err(dev->mt76.dev, "Timeout for initializing firmware\n");
875
876 return -EIO;
877 }
878
879 fw_loaded:
880
881 #ifdef CONFIG_PM
882 dev->mt76.hw->wiphy->wowlan = &mt76_connac_wowlan_support;
883 #endif /* CONFIG_PM */
884
885 dev_err(dev->mt76.dev, "Firmware init done\n");
886
887 return 0;
888 }
889
mt7921_mcu_fw_log_2_host(struct mt7921_dev * dev,u8 ctrl)890 int mt7921_mcu_fw_log_2_host(struct mt7921_dev *dev, u8 ctrl)
891 {
892 struct {
893 u8 ctrl_val;
894 u8 pad[3];
895 } data = {
896 .ctrl_val = ctrl
897 };
898
899 return mt76_mcu_send_msg(&dev->mt76, MCU_CMD_FWLOG_2_HOST, &data,
900 sizeof(data), false);
901 }
902
mt7921_run_firmware(struct mt7921_dev * dev)903 int mt7921_run_firmware(struct mt7921_dev *dev)
904 {
905 int err;
906
907 err = mt7921_load_firmware(dev);
908 if (err)
909 return err;
910
911 err = mt76_connac_mcu_get_nic_capability(&dev->mphy);
912 if (err)
913 return err;
914
915 set_bit(MT76_STATE_MCU_RUNNING, &dev->mphy.state);
916 return mt7921_mcu_fw_log_2_host(dev, 1);
917 }
918 EXPORT_SYMBOL_GPL(mt7921_run_firmware);
919
mt7921_mcu_exit(struct mt7921_dev * dev)920 void mt7921_mcu_exit(struct mt7921_dev *dev)
921 {
922 skb_queue_purge(&dev->mt76.mcu.res_q);
923 }
924 EXPORT_SYMBOL_GPL(mt7921_mcu_exit);
925
mt7921_mcu_set_tx(struct mt7921_dev * dev,struct ieee80211_vif * vif)926 int mt7921_mcu_set_tx(struct mt7921_dev *dev, struct ieee80211_vif *vif)
927 {
928 #define WMM_AIFS_SET BIT(0)
929 #define WMM_CW_MIN_SET BIT(1)
930 #define WMM_CW_MAX_SET BIT(2)
931 #define WMM_TXOP_SET BIT(3)
932 #define WMM_PARAM_SET GENMASK(3, 0)
933 #define TX_CMD_MODE 1
934 struct edca {
935 u8 queue;
936 u8 set;
937 u8 aifs;
938 u8 cw_min;
939 __le16 cw_max;
940 __le16 txop;
941 };
942 struct mt7921_mcu_tx {
943 u8 total;
944 u8 action;
945 u8 valid;
946 u8 mode;
947
948 struct edca edca[IEEE80211_NUM_ACS];
949 } __packed req = {
950 .valid = true,
951 .mode = TX_CMD_MODE,
952 .total = IEEE80211_NUM_ACS,
953 };
954 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
955 struct mu_edca {
956 u8 cw_min;
957 u8 cw_max;
958 u8 aifsn;
959 u8 acm;
960 u8 timer;
961 u8 padding[3];
962 };
963 struct mt7921_mcu_mu_tx {
964 u8 ver;
965 u8 pad0;
966 __le16 len;
967 u8 bss_idx;
968 u8 qos;
969 u8 wmm_idx;
970 u8 pad1;
971 struct mu_edca edca[IEEE80211_NUM_ACS];
972 u8 pad3[32];
973 } __packed req_mu = {
974 .bss_idx = mvif->mt76.idx,
975 .qos = vif->bss_conf.qos,
976 .wmm_idx = mvif->mt76.wmm_idx,
977 };
978 int ac, ret;
979
980 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
981 struct ieee80211_tx_queue_params *q = &mvif->queue_params[ac];
982 struct edca *e = &req.edca[ac];
983
984 e->set = WMM_PARAM_SET;
985 e->queue = ac + mvif->mt76.wmm_idx * MT7921_MAX_WMM_SETS;
986 e->aifs = q->aifs;
987 e->txop = cpu_to_le16(q->txop);
988
989 if (q->cw_min)
990 e->cw_min = fls(q->cw_min);
991 else
992 e->cw_min = 5;
993
994 if (q->cw_max)
995 e->cw_max = cpu_to_le16(fls(q->cw_max));
996 else
997 e->cw_max = cpu_to_le16(10);
998 }
999
1000 ret = mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EDCA_UPDATE, &req,
1001 sizeof(req), true);
1002 if (ret)
1003 return ret;
1004
1005 if (!vif->bss_conf.he_support)
1006 return 0;
1007
1008 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1009 struct ieee80211_he_mu_edca_param_ac_rec *q;
1010 struct mu_edca *e;
1011 int to_aci[] = {1, 0, 2, 3};
1012
1013 if (!mvif->queue_params[ac].mu_edca)
1014 break;
1015
1016 q = &mvif->queue_params[ac].mu_edca_param_rec;
1017 e = &(req_mu.edca[to_aci[ac]]);
1018
1019 e->cw_min = q->ecw_min_max & 0xf;
1020 e->cw_max = (q->ecw_min_max & 0xf0) >> 4;
1021 e->aifsn = q->aifsn;
1022 e->timer = q->mu_edca_timer;
1023 }
1024
1025 return mt76_mcu_send_msg(&dev->mt76, MCU_CMD_SET_MU_EDCA_PARMS, &req_mu,
1026 sizeof(req_mu), false);
1027 }
1028
mt7921_mcu_set_chan_info(struct mt7921_phy * phy,int cmd)1029 int mt7921_mcu_set_chan_info(struct mt7921_phy *phy, int cmd)
1030 {
1031 struct mt7921_dev *dev = phy->dev;
1032 struct cfg80211_chan_def *chandef = &phy->mt76->chandef;
1033 int freq1 = chandef->center_freq1;
1034 struct {
1035 u8 control_ch;
1036 u8 center_ch;
1037 u8 bw;
1038 u8 tx_streams_num;
1039 u8 rx_streams; /* mask or num */
1040 u8 switch_reason;
1041 u8 band_idx;
1042 u8 center_ch2; /* for 80+80 only */
1043 __le16 cac_case;
1044 u8 channel_band;
1045 u8 rsv0;
1046 __le32 outband_freq;
1047 u8 txpower_drop;
1048 u8 ap_bw;
1049 u8 ap_center_ch;
1050 u8 rsv1[57];
1051 } __packed req = {
1052 .control_ch = chandef->chan->hw_value,
1053 .center_ch = ieee80211_frequency_to_channel(freq1),
1054 .bw = mt7921_mcu_chan_bw(chandef),
1055 .tx_streams_num = hweight8(phy->mt76->antenna_mask),
1056 .rx_streams = phy->mt76->antenna_mask,
1057 .band_idx = phy != &dev->phy,
1058 };
1059
1060 if (chandef->chan->band == NL80211_BAND_6GHZ)
1061 req.channel_band = 2;
1062 else
1063 req.channel_band = chandef->chan->band;
1064
1065 if (dev->mt76.hw->conf.flags & IEEE80211_CONF_OFFCHANNEL)
1066 req.switch_reason = CH_SWITCH_SCAN_BYPASS_DPD;
1067 else if ((chandef->chan->flags & IEEE80211_CHAN_RADAR) &&
1068 chandef->chan->dfs_state != NL80211_DFS_AVAILABLE)
1069 req.switch_reason = CH_SWITCH_DFS;
1070 else
1071 req.switch_reason = CH_SWITCH_NORMAL;
1072
1073 if (cmd == MCU_EXT_CMD_CHANNEL_SWITCH)
1074 req.rx_streams = hweight8(req.rx_streams);
1075
1076 if (chandef->width == NL80211_CHAN_WIDTH_80P80) {
1077 int freq2 = chandef->center_freq2;
1078
1079 req.center_ch2 = ieee80211_frequency_to_channel(freq2);
1080 }
1081
1082 return mt76_mcu_send_msg(&dev->mt76, cmd, &req, sizeof(req), true);
1083 }
1084
mt7921_mcu_set_eeprom(struct mt7921_dev * dev)1085 int mt7921_mcu_set_eeprom(struct mt7921_dev *dev)
1086 {
1087 struct req_hdr {
1088 u8 buffer_mode;
1089 u8 format;
1090 __le16 len;
1091 } __packed req = {
1092 .buffer_mode = EE_MODE_EFUSE,
1093 .format = EE_FORMAT_WHOLE,
1094 };
1095
1096 return mt76_mcu_send_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_BUFFER_MODE,
1097 &req, sizeof(req), true);
1098 }
1099 EXPORT_SYMBOL_GPL(mt7921_mcu_set_eeprom);
1100
mt7921_mcu_get_eeprom(struct mt7921_dev * dev,u32 offset)1101 int mt7921_mcu_get_eeprom(struct mt7921_dev *dev, u32 offset)
1102 {
1103 struct mt7921_mcu_eeprom_info req = {
1104 .addr = cpu_to_le32(round_down(offset, 16)),
1105 };
1106 struct mt7921_mcu_eeprom_info *res;
1107 struct sk_buff *skb;
1108 int ret;
1109 u8 *buf;
1110
1111 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_EXT_CMD_EFUSE_ACCESS, &req,
1112 sizeof(req), true, &skb);
1113 if (ret)
1114 return ret;
1115
1116 res = (struct mt7921_mcu_eeprom_info *)skb->data;
1117 buf = dev->mt76.eeprom.data + le32_to_cpu(res->addr);
1118 memcpy(buf, res->data, 16);
1119 dev_kfree_skb(skb);
1120
1121 return 0;
1122 }
1123
mt7921_mcu_uni_bss_ps(struct mt7921_dev * dev,struct ieee80211_vif * vif)1124 int mt7921_mcu_uni_bss_ps(struct mt7921_dev *dev, struct ieee80211_vif *vif)
1125 {
1126 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
1127 struct {
1128 struct {
1129 u8 bss_idx;
1130 u8 pad[3];
1131 } __packed hdr;
1132 struct ps_tlv {
1133 __le16 tag;
1134 __le16 len;
1135 u8 ps_state; /* 0: device awake
1136 * 1: static power save
1137 * 2: dynamic power saving
1138 * 3: enter TWT power saving
1139 * 4: leave TWT power saving
1140 */
1141 u8 pad[3];
1142 } __packed ps;
1143 } __packed ps_req = {
1144 .hdr = {
1145 .bss_idx = mvif->mt76.idx,
1146 },
1147 .ps = {
1148 .tag = cpu_to_le16(UNI_BSS_INFO_PS),
1149 .len = cpu_to_le16(sizeof(struct ps_tlv)),
1150 .ps_state = vif->bss_conf.ps ? 2 : 0,
1151 },
1152 };
1153
1154 if (vif->type != NL80211_IFTYPE_STATION)
1155 return -EOPNOTSUPP;
1156
1157 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD_BSS_INFO_UPDATE,
1158 &ps_req, sizeof(ps_req), true);
1159 }
1160
1161 static int
mt7921_mcu_uni_bss_bcnft(struct mt7921_dev * dev,struct ieee80211_vif * vif,bool enable)1162 mt7921_mcu_uni_bss_bcnft(struct mt7921_dev *dev, struct ieee80211_vif *vif,
1163 bool enable)
1164 {
1165 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
1166 struct {
1167 struct {
1168 u8 bss_idx;
1169 u8 pad[3];
1170 } __packed hdr;
1171 struct bcnft_tlv {
1172 __le16 tag;
1173 __le16 len;
1174 __le16 bcn_interval;
1175 u8 dtim_period;
1176 u8 pad;
1177 } __packed bcnft;
1178 } __packed bcnft_req = {
1179 .hdr = {
1180 .bss_idx = mvif->mt76.idx,
1181 },
1182 .bcnft = {
1183 .tag = cpu_to_le16(UNI_BSS_INFO_BCNFT),
1184 .len = cpu_to_le16(sizeof(struct bcnft_tlv)),
1185 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
1186 .dtim_period = vif->bss_conf.dtim_period,
1187 },
1188 };
1189
1190 if (vif->type != NL80211_IFTYPE_STATION)
1191 return 0;
1192
1193 return mt76_mcu_send_msg(&dev->mt76, MCU_UNI_CMD_BSS_INFO_UPDATE,
1194 &bcnft_req, sizeof(bcnft_req), true);
1195 }
1196
1197 static int
mt7921_mcu_set_bss_pm(struct mt7921_dev * dev,struct ieee80211_vif * vif,bool enable)1198 mt7921_mcu_set_bss_pm(struct mt7921_dev *dev, struct ieee80211_vif *vif,
1199 bool enable)
1200 {
1201 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
1202 struct {
1203 u8 bss_idx;
1204 u8 dtim_period;
1205 __le16 aid;
1206 __le16 bcn_interval;
1207 __le16 atim_window;
1208 u8 uapsd;
1209 u8 bmc_delivered_ac;
1210 u8 bmc_triggered_ac;
1211 u8 pad;
1212 } req = {
1213 .bss_idx = mvif->mt76.idx,
1214 .aid = cpu_to_le16(vif->bss_conf.aid),
1215 .dtim_period = vif->bss_conf.dtim_period,
1216 .bcn_interval = cpu_to_le16(vif->bss_conf.beacon_int),
1217 };
1218 struct {
1219 u8 bss_idx;
1220 u8 pad[3];
1221 } req_hdr = {
1222 .bss_idx = mvif->mt76.idx,
1223 };
1224 int err;
1225
1226 if (vif->type != NL80211_IFTYPE_STATION)
1227 return 0;
1228
1229 err = mt76_mcu_send_msg(&dev->mt76, MCU_CMD_SET_BSS_ABORT, &req_hdr,
1230 sizeof(req_hdr), false);
1231 if (err < 0 || !enable)
1232 return err;
1233
1234 return mt76_mcu_send_msg(&dev->mt76, MCU_CMD_SET_BSS_CONNECTED, &req,
1235 sizeof(req), false);
1236 }
1237
mt7921_mcu_sta_update(struct mt7921_dev * dev,struct ieee80211_sta * sta,struct ieee80211_vif * vif,bool enable,enum mt76_sta_info_state state)1238 int mt7921_mcu_sta_update(struct mt7921_dev *dev, struct ieee80211_sta *sta,
1239 struct ieee80211_vif *vif, bool enable,
1240 enum mt76_sta_info_state state)
1241 {
1242 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
1243 int rssi = -ewma_rssi_read(&mvif->rssi);
1244 struct mt76_sta_cmd_info info = {
1245 .sta = sta,
1246 .vif = vif,
1247 .enable = enable,
1248 .cmd = MCU_UNI_CMD_STA_REC_UPDATE,
1249 .state = state,
1250 .offload_fw = true,
1251 .rcpi = to_rcpi(rssi),
1252 };
1253 struct mt7921_sta *msta;
1254
1255 msta = sta ? (struct mt7921_sta *)sta->drv_priv : NULL;
1256 info.wcid = msta ? &msta->wcid : &mvif->sta.wcid;
1257 info.newly = msta ? state != MT76_STA_INFO_STATE_ASSOC : true;
1258
1259 return mt76_connac_mcu_sta_cmd(&dev->mphy, &info);
1260 }
1261
mt7921_mcu_drv_pmctrl(struct mt7921_dev * dev)1262 int mt7921_mcu_drv_pmctrl(struct mt7921_dev *dev)
1263 {
1264 struct mt76_phy *mphy = &dev->mt76.phy;
1265 struct mt76_connac_pm *pm = &dev->pm;
1266 int err = 0;
1267
1268 mutex_lock(&pm->mutex);
1269
1270 if (!test_bit(MT76_STATE_PM, &mphy->state))
1271 goto out;
1272
1273 err = __mt7921_mcu_drv_pmctrl(dev);
1274 out:
1275 mutex_unlock(&pm->mutex);
1276
1277 if (err)
1278 mt7921_reset(&dev->mt76);
1279
1280 return err;
1281 }
1282 EXPORT_SYMBOL_GPL(mt7921_mcu_drv_pmctrl);
1283
mt7921_mcu_fw_pmctrl(struct mt7921_dev * dev)1284 int mt7921_mcu_fw_pmctrl(struct mt7921_dev *dev)
1285 {
1286 struct mt76_phy *mphy = &dev->mt76.phy;
1287 struct mt76_connac_pm *pm = &dev->pm;
1288 int err = 0;
1289
1290 mutex_lock(&pm->mutex);
1291
1292 if (mt76_connac_skip_fw_pmctrl(mphy, pm))
1293 goto out;
1294
1295 err = __mt7921_mcu_fw_pmctrl(dev);
1296 out:
1297 mutex_unlock(&pm->mutex);
1298
1299 if (err)
1300 mt7921_reset(&dev->mt76);
1301
1302 return err;
1303 }
1304 EXPORT_SYMBOL_GPL(mt7921_mcu_fw_pmctrl);
1305
mt7921_mcu_set_beacon_filter(struct mt7921_dev * dev,struct ieee80211_vif * vif,bool enable)1306 int mt7921_mcu_set_beacon_filter(struct mt7921_dev *dev,
1307 struct ieee80211_vif *vif,
1308 bool enable)
1309 {
1310 struct ieee80211_hw *hw = mt76_hw(dev);
1311 int err;
1312
1313 if (enable) {
1314 err = mt7921_mcu_uni_bss_bcnft(dev, vif, true);
1315 if (err)
1316 return err;
1317
1318 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER;
1319 ieee80211_hw_set(hw, CONNECTION_MONITOR);
1320 mt76_set(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON);
1321
1322 return 0;
1323 }
1324
1325 err = mt7921_mcu_set_bss_pm(dev, vif, false);
1326 if (err)
1327 return err;
1328
1329 vif->driver_flags &= ~IEEE80211_VIF_BEACON_FILTER;
1330 __clear_bit(IEEE80211_HW_CONNECTION_MONITOR, hw->flags);
1331 mt76_clear(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON);
1332
1333 return 0;
1334 }
1335
mt7921_get_txpwr_info(struct mt7921_dev * dev,struct mt7921_txpwr * txpwr)1336 int mt7921_get_txpwr_info(struct mt7921_dev *dev, struct mt7921_txpwr *txpwr)
1337 {
1338 struct mt7921_txpwr_event *event;
1339 struct mt7921_txpwr_req req = {
1340 .dbdc_idx = 0,
1341 };
1342 struct sk_buff *skb;
1343 int ret;
1344
1345 ret = mt76_mcu_send_and_get_msg(&dev->mt76, MCU_CMD_GET_TXPWR,
1346 &req, sizeof(req), true, &skb);
1347 if (ret)
1348 return ret;
1349
1350 event = (struct mt7921_txpwr_event *)skb->data;
1351 WARN_ON(skb->len != le16_to_cpu(event->len));
1352 memcpy(txpwr, &event->txpwr, sizeof(event->txpwr));
1353
1354 dev_kfree_skb(skb);
1355
1356 return 0;
1357 }
1358