1
2
3
4#include <linux/etherdevice.h>
5#include <linux/platform_device.h>
6#include <linux/pci.h>
7#include <linux/module.h>
8#include "mt7921.h"
9#include "mcu.h"
10
11static void
12mt7921_gen_ppe_thresh(u8 *he_ppet, int nss)
13{
14 u8 i, ppet_bits, ppet_size, ru_bit_mask = 0x7;
15 u8 ppet16_ppet8_ru3_ru0[] = {0x1c, 0xc7, 0x71};
16
17 he_ppet[0] = FIELD_PREP(IEEE80211_PPE_THRES_NSS_MASK, nss - 1) |
18 FIELD_PREP(IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK,
19 ru_bit_mask);
20
21 ppet_bits = IEEE80211_PPE_THRES_INFO_PPET_SIZE *
22 nss * hweight8(ru_bit_mask) * 2;
23 ppet_size = DIV_ROUND_UP(ppet_bits, 8);
24
25 for (i = 0; i < ppet_size - 1; i++)
26 he_ppet[i + 1] = ppet16_ppet8_ru3_ru0[i % 3];
27
28 he_ppet[i + 1] = ppet16_ppet8_ru3_ru0[i % 3] &
29 (0xff >> (8 - (ppet_bits - 1) % 8));
30}
31
32static int
33mt7921_init_he_caps(struct mt7921_phy *phy, enum nl80211_band band,
34 struct ieee80211_sband_iftype_data *data)
35{
36 int i, idx = 0;
37 int nss = hweight8(phy->mt76->chainmask);
38 u16 mcs_map = 0;
39
40 for (i = 0; i < 8; i++) {
41 if (i < nss)
42 mcs_map |= (IEEE80211_HE_MCS_SUPPORT_0_11 << (i * 2));
43 else
44 mcs_map |= (IEEE80211_HE_MCS_NOT_SUPPORTED << (i * 2));
45 }
46
47 for (i = 0; i < NUM_NL80211_IFTYPES; i++) {
48 struct ieee80211_sta_he_cap *he_cap = &data[idx].he_cap;
49 struct ieee80211_he_cap_elem *he_cap_elem =
50 &he_cap->he_cap_elem;
51 struct ieee80211_he_mcs_nss_supp *he_mcs =
52 &he_cap->he_mcs_nss_supp;
53
54 switch (i) {
55 case NL80211_IFTYPE_STATION:
56 break;
57 default:
58 continue;
59 }
60
61 data[idx].types_mask = BIT(i);
62 he_cap->has_he = true;
63
64 he_cap_elem->mac_cap_info[0] =
65 IEEE80211_HE_MAC_CAP0_HTC_HE;
66 he_cap_elem->mac_cap_info[3] =
67 IEEE80211_HE_MAC_CAP3_OMI_CONTROL |
68 IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_EXT_3;
69 he_cap_elem->mac_cap_info[4] =
70 IEEE80211_HE_MAC_CAP4_AMSDU_IN_AMPDU;
71
72 if (band == NL80211_BAND_2GHZ)
73 he_cap_elem->phy_cap_info[0] =
74 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G;
75 else if (band == NL80211_BAND_5GHZ)
76 he_cap_elem->phy_cap_info[0] =
77 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G;
78
79 he_cap_elem->phy_cap_info[1] =
80 IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD;
81 he_cap_elem->phy_cap_info[2] =
82 IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US |
83 IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ |
84 IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ |
85 IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO |
86 IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO;
87
88 switch (i) {
89 case NL80211_IFTYPE_STATION:
90 he_cap_elem->mac_cap_info[1] |=
91 IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US;
92
93 if (band == NL80211_BAND_2GHZ)
94 he_cap_elem->phy_cap_info[0] |=
95 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G;
96 else if (band == NL80211_BAND_5GHZ)
97 he_cap_elem->phy_cap_info[0] |=
98 IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G;
99
100 he_cap_elem->phy_cap_info[1] |=
101 IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A |
102 IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US;
103 he_cap_elem->phy_cap_info[3] |=
104 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_QPSK |
105 IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_QPSK;
106 he_cap_elem->phy_cap_info[4] |=
107 IEEE80211_HE_PHY_CAP4_SU_BEAMFORMEE |
108 IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_4;
109 he_cap_elem->phy_cap_info[5] |=
110 IEEE80211_HE_PHY_CAP5_NG16_SU_FEEDBACK |
111 IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK;
112 he_cap_elem->phy_cap_info[6] |=
113 IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_42_SU |
114 IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU |
115 IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB |
116 IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE |
117 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT;
118 he_cap_elem->phy_cap_info[7] |=
119 IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_SUPP |
120 IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI;
121 he_cap_elem->phy_cap_info[8] |=
122 IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G |
123 IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_484;
124 he_cap_elem->phy_cap_info[9] |=
125 IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM |
126 IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK |
127 IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU |
128 IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU |
129 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB |
130 IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB;
131 break;
132 }
133
134 he_mcs->rx_mcs_80 = cpu_to_le16(mcs_map);
135 he_mcs->tx_mcs_80 = cpu_to_le16(mcs_map);
136
137 memset(he_cap->ppe_thres, 0, sizeof(he_cap->ppe_thres));
138 if (he_cap_elem->phy_cap_info[6] &
139 IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) {
140 mt7921_gen_ppe_thresh(he_cap->ppe_thres, nss);
141 } else {
142 he_cap_elem->phy_cap_info[9] |=
143 IEEE80211_HE_PHY_CAP9_NOMIMAL_PKT_PADDING_16US;
144 }
145 idx++;
146 }
147
148 return idx;
149}
150
151void mt7921_set_stream_he_caps(struct mt7921_phy *phy)
152{
153 struct ieee80211_sband_iftype_data *data;
154 struct ieee80211_supported_band *band;
155 int n;
156
157 if (phy->mt76->cap.has_2ghz) {
158 data = phy->iftype[NL80211_BAND_2GHZ];
159 n = mt7921_init_he_caps(phy, NL80211_BAND_2GHZ, data);
160
161 band = &phy->mt76->sband_2g.sband;
162 band->iftype_data = data;
163 band->n_iftype_data = n;
164 }
165
166 if (phy->mt76->cap.has_5ghz) {
167 data = phy->iftype[NL80211_BAND_5GHZ];
168 n = mt7921_init_he_caps(phy, NL80211_BAND_5GHZ, data);
169
170 band = &phy->mt76->sband_5g.sband;
171 band->iftype_data = data;
172 band->n_iftype_data = n;
173 }
174}
175
176int __mt7921_start(struct mt7921_phy *phy)
177{
178 struct mt76_phy *mphy = phy->mt76;
179 int err;
180
181 err = mt76_connac_mcu_set_mac_enable(mphy->dev, 0, true, false);
182 if (err)
183 return err;
184
185 err = mt76_connac_mcu_set_channel_domain(mphy);
186 if (err)
187 return err;
188
189 err = mt7921_mcu_set_chan_info(phy, MCU_EXT_CMD_SET_RX_PATH);
190 if (err)
191 return err;
192
193 err = mt76_connac_mcu_set_rate_txpower(phy->mt76);
194 if (err)
195 return err;
196
197 mt7921_mac_reset_counters(phy);
198 set_bit(MT76_STATE_RUNNING, &mphy->state);
199
200 ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
201 MT7921_WATCHDOG_TIME);
202
203 return 0;
204}
205
206static int mt7921_start(struct ieee80211_hw *hw)
207{
208 struct mt7921_phy *phy = mt7921_hw_phy(hw);
209 int err;
210
211 mt7921_mutex_acquire(phy->dev);
212 err = __mt7921_start(phy);
213 mt7921_mutex_release(phy->dev);
214
215 return err;
216}
217
218static void mt7921_stop(struct ieee80211_hw *hw)
219{
220 struct mt7921_dev *dev = mt7921_hw_dev(hw);
221 struct mt7921_phy *phy = mt7921_hw_phy(hw);
222
223 cancel_delayed_work_sync(&phy->mt76->mac_work);
224
225 cancel_delayed_work_sync(&dev->pm.ps_work);
226 cancel_work_sync(&dev->pm.wake_work);
227 mt76_connac_free_pending_tx_skbs(&dev->pm, NULL);
228
229 mt7921_mutex_acquire(dev);
230 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
231 mt76_connac_mcu_set_mac_enable(&dev->mt76, 0, false, false);
232 mt7921_mutex_release(dev);
233}
234
235static int mt7921_add_interface(struct ieee80211_hw *hw,
236 struct ieee80211_vif *vif)
237{
238 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
239 struct mt7921_dev *dev = mt7921_hw_dev(hw);
240 struct mt7921_phy *phy = mt7921_hw_phy(hw);
241 struct mt76_txq *mtxq;
242 int idx, ret = 0;
243
244 mt7921_mutex_acquire(dev);
245
246 if (vif->type == NL80211_IFTYPE_MONITOR &&
247 is_zero_ether_addr(vif->addr))
248 phy->monitor_vif = vif;
249
250 mvif->mt76.idx = ffs(~dev->mt76.vif_mask) - 1;
251 if (mvif->mt76.idx >= MT7921_MAX_INTERFACES) {
252 ret = -ENOSPC;
253 goto out;
254 }
255
256 mvif->mt76.omac_idx = mvif->mt76.idx;
257 mvif->phy = phy;
258 mvif->mt76.band_idx = 0;
259 mvif->mt76.wmm_idx = mvif->mt76.idx % MT7921_MAX_WMM_SETS;
260
261 ret = mt76_connac_mcu_uni_add_dev(&dev->mphy, vif, &mvif->sta.wcid,
262 true);
263 if (ret)
264 goto out;
265
266 dev->mt76.vif_mask |= BIT(mvif->mt76.idx);
267 phy->omac_mask |= BIT_ULL(mvif->mt76.omac_idx);
268
269 idx = MT7921_WTBL_RESERVED - mvif->mt76.idx;
270
271 INIT_LIST_HEAD(&mvif->sta.stats_list);
272 INIT_LIST_HEAD(&mvif->sta.poll_list);
273 mvif->sta.wcid.idx = idx;
274 mvif->sta.wcid.ext_phy = mvif->mt76.band_idx;
275 mvif->sta.wcid.hw_key_idx = -1;
276 mvif->sta.wcid.tx_info |= MT_WCID_TX_INFO_SET;
277 mt7921_mac_wtbl_update(dev, idx,
278 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
279
280 ewma_rssi_init(&mvif->rssi);
281
282 rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid);
283 if (vif->txq) {
284 mtxq = (struct mt76_txq *)vif->txq->drv_priv;
285 mtxq->wcid = &mvif->sta.wcid;
286 }
287
288 if (vif->type != NL80211_IFTYPE_AP &&
289 (!mvif->mt76.omac_idx || mvif->mt76.omac_idx > 3))
290 vif->offload_flags = 0;
291
292 vif->offload_flags |= IEEE80211_OFFLOAD_ENCAP_4ADDR;
293
294out:
295 mt7921_mutex_release(dev);
296
297 return ret;
298}
299
300static void mt7921_remove_interface(struct ieee80211_hw *hw,
301 struct ieee80211_vif *vif)
302{
303 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
304 struct mt7921_sta *msta = &mvif->sta;
305 struct mt7921_dev *dev = mt7921_hw_dev(hw);
306 struct mt7921_phy *phy = mt7921_hw_phy(hw);
307 int idx = msta->wcid.idx;
308
309 if (vif == phy->monitor_vif)
310 phy->monitor_vif = NULL;
311
312 mt7921_mutex_acquire(dev);
313 mt76_connac_free_pending_tx_skbs(&dev->pm, &msta->wcid);
314 mt76_connac_mcu_uni_add_dev(&dev->mphy, vif, &mvif->sta.wcid, false);
315
316 rcu_assign_pointer(dev->mt76.wcid[idx], NULL);
317
318 dev->mt76.vif_mask &= ~BIT(mvif->mt76.idx);
319 phy->omac_mask &= ~BIT_ULL(mvif->mt76.omac_idx);
320 mt7921_mutex_release(dev);
321
322 spin_lock_bh(&dev->sta_poll_lock);
323 if (!list_empty(&msta->poll_list))
324 list_del_init(&msta->poll_list);
325 spin_unlock_bh(&dev->sta_poll_lock);
326}
327
328static int mt7921_set_channel(struct mt7921_phy *phy)
329{
330 struct mt7921_dev *dev = phy->dev;
331 int ret;
332
333 cancel_delayed_work_sync(&phy->mt76->mac_work);
334
335 mt7921_mutex_acquire(dev);
336 set_bit(MT76_RESET, &phy->mt76->state);
337
338 mt76_set_channel(phy->mt76);
339
340 ret = mt7921_mcu_set_chan_info(phy, MCU_EXT_CMD_CHANNEL_SWITCH);
341 if (ret)
342 goto out;
343
344 mt7921_mac_set_timing(phy);
345
346 mt7921_mac_reset_counters(phy);
347 phy->noise = 0;
348
349out:
350 clear_bit(MT76_RESET, &phy->mt76->state);
351 mt7921_mutex_release(dev);
352
353 mt76_worker_schedule(&dev->mt76.tx_worker);
354 ieee80211_queue_delayed_work(phy->mt76->hw, &phy->mt76->mac_work,
355 MT7921_WATCHDOG_TIME);
356
357 return ret;
358}
359
360static int mt7921_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
361 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
362 struct ieee80211_key_conf *key)
363{
364 struct mt7921_dev *dev = mt7921_hw_dev(hw);
365 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
366 struct mt7921_sta *msta = sta ? (struct mt7921_sta *)sta->drv_priv :
367 &mvif->sta;
368 struct mt76_wcid *wcid = &msta->wcid;
369 u8 *wcid_keyidx = &wcid->hw_key_idx;
370 int idx = key->keyidx, err = 0;
371
372
373
374
375 if ((vif->type == NL80211_IFTYPE_ADHOC ||
376 vif->type == NL80211_IFTYPE_MESH_POINT) &&
377 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
378 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
379 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
380 return -EOPNOTSUPP;
381
382
383 switch (key->cipher) {
384 case WLAN_CIPHER_SUITE_AES_CMAC:
385 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE;
386 wcid_keyidx = &wcid->hw_key_idx2;
387 break;
388 case WLAN_CIPHER_SUITE_WEP40:
389 case WLAN_CIPHER_SUITE_WEP104:
390 if (!mvif->wep_sta)
391 return -EOPNOTSUPP;
392 break;
393 case WLAN_CIPHER_SUITE_TKIP:
394 case WLAN_CIPHER_SUITE_CCMP:
395 case WLAN_CIPHER_SUITE_CCMP_256:
396 case WLAN_CIPHER_SUITE_GCMP:
397 case WLAN_CIPHER_SUITE_GCMP_256:
398 case WLAN_CIPHER_SUITE_SMS4:
399 break;
400 default:
401 return -EOPNOTSUPP;
402 }
403
404 mt7921_mutex_acquire(dev);
405
406 if (cmd == SET_KEY)
407 *wcid_keyidx = idx;
408 else if (idx == *wcid_keyidx)
409 *wcid_keyidx = -1;
410 else
411 goto out;
412
413 mt76_wcid_key_setup(&dev->mt76, wcid,
414 cmd == SET_KEY ? key : NULL);
415
416 err = mt7921_mcu_add_key(dev, vif, msta, key, cmd);
417 if (err)
418 goto out;
419
420 if (key->cipher == WLAN_CIPHER_SUITE_WEP104 ||
421 key->cipher == WLAN_CIPHER_SUITE_WEP40)
422 err = mt7921_mcu_add_key(dev, vif, mvif->wep_sta, key, cmd);
423out:
424 mt7921_mutex_release(dev);
425
426 return err;
427}
428
429static int mt7921_config(struct ieee80211_hw *hw, u32 changed)
430{
431 struct mt7921_dev *dev = mt7921_hw_dev(hw);
432 struct mt7921_phy *phy = mt7921_hw_phy(hw);
433 int ret;
434
435 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) {
436 ieee80211_stop_queues(hw);
437 ret = mt7921_set_channel(phy);
438 if (ret)
439 return ret;
440 ieee80211_wake_queues(hw);
441 }
442
443 mt7921_mutex_acquire(dev);
444
445 if (changed & IEEE80211_CONF_CHANGE_POWER)
446 mt76_connac_mcu_set_rate_txpower(phy->mt76);
447
448 if (changed & IEEE80211_CONF_CHANGE_MONITOR) {
449 bool enabled = !!(hw->conf.flags & IEEE80211_CONF_MONITOR);
450
451 if (!enabled)
452 phy->rxfilter |= MT_WF_RFCR_DROP_OTHER_UC;
453 else
454 phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC;
455
456 mt76_rmw_field(dev, MT_DMA_DCR0(0), MT_DMA_DCR0_RXD_G5_EN,
457 enabled);
458 mt76_wr(dev, MT_WF_RFCR(0), phy->rxfilter);
459 }
460
461 mt7921_mutex_release(dev);
462
463 return 0;
464}
465
466static int
467mt7921_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue,
468 const struct ieee80211_tx_queue_params *params)
469{
470 struct mt7921_dev *dev = mt7921_hw_dev(hw);
471 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
472
473
474 queue = mt7921_lmac_mapping(dev, queue);
475 mvif->queue_params[queue] = *params;
476
477 return 0;
478}
479
480static void mt7921_configure_filter(struct ieee80211_hw *hw,
481 unsigned int changed_flags,
482 unsigned int *total_flags,
483 u64 multicast)
484{
485 struct mt7921_dev *dev = mt7921_hw_dev(hw);
486 struct mt7921_phy *phy = mt7921_hw_phy(hw);
487 u32 ctl_flags = MT_WF_RFCR1_DROP_ACK |
488 MT_WF_RFCR1_DROP_BF_POLL |
489 MT_WF_RFCR1_DROP_BA |
490 MT_WF_RFCR1_DROP_CFEND |
491 MT_WF_RFCR1_DROP_CFACK;
492 u32 flags = 0;
493
494#define MT76_FILTER(_flag, _hw) do { \
495 flags |= *total_flags & FIF_##_flag; \
496 phy->rxfilter &= ~(_hw); \
497 phy->rxfilter |= !(flags & FIF_##_flag) * (_hw); \
498 } while (0)
499
500 mt7921_mutex_acquire(dev);
501
502 phy->rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS |
503 MT_WF_RFCR_DROP_OTHER_BEACON |
504 MT_WF_RFCR_DROP_FRAME_REPORT |
505 MT_WF_RFCR_DROP_PROBEREQ |
506 MT_WF_RFCR_DROP_MCAST_FILTERED |
507 MT_WF_RFCR_DROP_MCAST |
508 MT_WF_RFCR_DROP_BCAST |
509 MT_WF_RFCR_DROP_DUPLICATE |
510 MT_WF_RFCR_DROP_A2_BSSID |
511 MT_WF_RFCR_DROP_UNWANTED_CTL |
512 MT_WF_RFCR_DROP_STBC_MULTI);
513
514 MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM |
515 MT_WF_RFCR_DROP_A3_MAC |
516 MT_WF_RFCR_DROP_A3_BSSID);
517
518 MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL);
519
520 MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS |
521 MT_WF_RFCR_DROP_RTS |
522 MT_WF_RFCR_DROP_CTL_RSV |
523 MT_WF_RFCR_DROP_NDPA);
524
525 *total_flags = flags;
526 mt76_wr(dev, MT_WF_RFCR(0), phy->rxfilter);
527
528 if (*total_flags & FIF_CONTROL)
529 mt76_clear(dev, MT_WF_RFCR1(0), ctl_flags);
530 else
531 mt76_set(dev, MT_WF_RFCR1(0), ctl_flags);
532
533 mt7921_mutex_release(dev);
534}
535
536static int
537mt7921_bss_bcnft_apply(struct mt7921_dev *dev, struct ieee80211_vif *vif,
538 bool assoc)
539{
540 int ret;
541
542 if (!dev->pm.enable)
543 return 0;
544
545 if (assoc) {
546 ret = mt7921_mcu_uni_bss_bcnft(dev, vif, true);
547 if (ret)
548 return ret;
549
550 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER;
551 mt76_set(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON);
552
553 return 0;
554 }
555
556 ret = mt7921_mcu_set_bss_pm(dev, vif, false);
557 if (ret)
558 return ret;
559
560 vif->driver_flags &= ~IEEE80211_VIF_BEACON_FILTER;
561 mt76_clear(dev, MT_WF_RFCR(0), MT_WF_RFCR_DROP_OTHER_BEACON);
562
563 return 0;
564}
565
566static void mt7921_bss_info_changed(struct ieee80211_hw *hw,
567 struct ieee80211_vif *vif,
568 struct ieee80211_bss_conf *info,
569 u32 changed)
570{
571 struct mt7921_phy *phy = mt7921_hw_phy(hw);
572 struct mt7921_dev *dev = mt7921_hw_dev(hw);
573
574 mt7921_mutex_acquire(dev);
575
576 if (changed & BSS_CHANGED_ERP_SLOT) {
577 int slottime = info->use_short_slot ? 9 : 20;
578
579 if (slottime != phy->slottime) {
580 phy->slottime = slottime;
581 mt7921_mac_set_timing(phy);
582 }
583 }
584
585
586 if (changed & (BSS_CHANGED_QOS | BSS_CHANGED_BEACON_ENABLED))
587 mt7921_mcu_set_tx(dev, vif);
588
589 if (changed & BSS_CHANGED_PS)
590 mt7921_mcu_uni_bss_ps(dev, vif);
591
592 if (changed & BSS_CHANGED_ASSOC) {
593 mt7921_mcu_sta_update(dev, NULL, vif, true,
594 MT76_STA_INFO_STATE_ASSOC);
595 mt7921_bss_bcnft_apply(dev, vif, info->assoc);
596 }
597
598 if (changed & BSS_CHANGED_ARP_FILTER) {
599 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
600
601 mt76_connac_mcu_update_arp_filter(&dev->mt76, &mvif->mt76,
602 info);
603 }
604
605 mt7921_mutex_release(dev);
606}
607
608int mt7921_mac_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif,
609 struct ieee80211_sta *sta)
610{
611 struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
612 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
613 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
614 int ret, idx;
615
616 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7921_WTBL_STA - 1);
617 if (idx < 0)
618 return -ENOSPC;
619
620 INIT_LIST_HEAD(&msta->stats_list);
621 INIT_LIST_HEAD(&msta->poll_list);
622 msta->vif = mvif;
623 msta->wcid.sta = 1;
624 msta->wcid.idx = idx;
625 msta->wcid.ext_phy = mvif->mt76.band_idx;
626 msta->wcid.tx_info |= MT_WCID_TX_INFO_SET;
627 msta->stats.jiffies = jiffies;
628
629 ret = mt76_connac_pm_wake(&dev->mphy, &dev->pm);
630 if (ret)
631 return ret;
632
633 if (vif->type == NL80211_IFTYPE_STATION)
634 mvif->wep_sta = msta;
635
636 mt7921_mac_wtbl_update(dev, idx,
637 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
638
639 ret = mt7921_mcu_sta_update(dev, sta, vif, true,
640 MT76_STA_INFO_STATE_NONE);
641 if (ret)
642 return ret;
643
644 mt76_connac_power_save_sched(&dev->mphy, &dev->pm);
645
646 return 0;
647}
648
649void mt7921_mac_sta_assoc(struct mt76_dev *mdev, struct ieee80211_vif *vif,
650 struct ieee80211_sta *sta)
651{
652 struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
653 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
654 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
655
656 mt7921_mutex_acquire(dev);
657
658 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls)
659 mt76_connac_mcu_uni_add_bss(&dev->mphy, vif, &mvif->sta.wcid,
660 true);
661
662 mt7921_mac_wtbl_update(dev, msta->wcid.idx,
663 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
664
665 mt7921_mcu_sta_update(dev, sta, vif, true, MT76_STA_INFO_STATE_ASSOC);
666
667 mt7921_mutex_release(dev);
668}
669
670void mt7921_mac_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif,
671 struct ieee80211_sta *sta)
672{
673 struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
674 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
675
676 mt76_connac_free_pending_tx_skbs(&dev->pm, &msta->wcid);
677 mt76_connac_pm_wake(&dev->mphy, &dev->pm);
678
679 mt7921_mcu_sta_update(dev, sta, vif, false, MT76_STA_INFO_STATE_NONE);
680 mt7921_mac_wtbl_update(dev, msta->wcid.idx,
681 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
682
683 if (vif->type == NL80211_IFTYPE_STATION) {
684 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
685
686 mvif->wep_sta = NULL;
687 ewma_rssi_init(&mvif->rssi);
688 if (!sta->tdls)
689 mt76_connac_mcu_uni_add_bss(&dev->mphy, vif,
690 &mvif->sta.wcid, false);
691 }
692
693 spin_lock_bh(&dev->sta_poll_lock);
694 if (!list_empty(&msta->poll_list))
695 list_del_init(&msta->poll_list);
696 if (!list_empty(&msta->stats_list))
697 list_del_init(&msta->stats_list);
698 spin_unlock_bh(&dev->sta_poll_lock);
699
700 mt76_connac_power_save_sched(&dev->mphy, &dev->pm);
701}
702
703void mt7921_tx_worker(struct mt76_worker *w)
704{
705 struct mt7921_dev *dev = container_of(w, struct mt7921_dev,
706 mt76.tx_worker);
707
708 if (!mt76_connac_pm_ref(&dev->mphy, &dev->pm)) {
709 queue_work(dev->mt76.wq, &dev->pm.wake_work);
710 return;
711 }
712
713 mt76_txq_schedule_all(&dev->mphy);
714 mt76_connac_pm_unref(&dev->mphy, &dev->pm);
715}
716
717static void mt7921_tx(struct ieee80211_hw *hw,
718 struct ieee80211_tx_control *control,
719 struct sk_buff *skb)
720{
721 struct mt7921_dev *dev = mt7921_hw_dev(hw);
722 struct mt76_phy *mphy = hw->priv;
723 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
724 struct ieee80211_vif *vif = info->control.vif;
725 struct mt76_wcid *wcid = &dev->mt76.global_wcid;
726 int qid;
727
728 if (control->sta) {
729 struct mt7921_sta *sta;
730
731 sta = (struct mt7921_sta *)control->sta->drv_priv;
732 wcid = &sta->wcid;
733 }
734
735 if (vif && !control->sta) {
736 struct mt7921_vif *mvif;
737
738 mvif = (struct mt7921_vif *)vif->drv_priv;
739 wcid = &mvif->sta.wcid;
740 }
741
742 if (mt76_connac_pm_ref(mphy, &dev->pm)) {
743 mt76_tx(mphy, control->sta, wcid, skb);
744 mt76_connac_pm_unref(mphy, &dev->pm);
745 return;
746 }
747
748 qid = skb_get_queue_mapping(skb);
749 if (qid >= MT_TXQ_PSD) {
750 qid = IEEE80211_AC_BE;
751 skb_set_queue_mapping(skb, qid);
752 }
753
754 mt76_connac_pm_queue_skb(hw, &dev->pm, wcid, skb);
755}
756
757static int mt7921_set_rts_threshold(struct ieee80211_hw *hw, u32 val)
758{
759 struct mt7921_dev *dev = mt7921_hw_dev(hw);
760
761 mt7921_mutex_acquire(dev);
762 mt76_connac_mcu_set_rts_thresh(&dev->mt76, val, 0);
763 mt7921_mutex_release(dev);
764
765 return 0;
766}
767
768static int
769mt7921_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
770 struct ieee80211_ampdu_params *params)
771{
772 enum ieee80211_ampdu_mlme_action action = params->action;
773 struct mt7921_dev *dev = mt7921_hw_dev(hw);
774 struct ieee80211_sta *sta = params->sta;
775 struct ieee80211_txq *txq = sta->txq[params->tid];
776 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
777 u16 tid = params->tid;
778 u16 ssn = params->ssn;
779 struct mt76_txq *mtxq;
780 int ret = 0;
781
782 if (!txq)
783 return -EINVAL;
784
785 mtxq = (struct mt76_txq *)txq->drv_priv;
786
787 mt7921_mutex_acquire(dev);
788 switch (action) {
789 case IEEE80211_AMPDU_RX_START:
790 mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, ssn,
791 params->buf_size);
792 mt7921_mcu_uni_rx_ba(dev, params, true);
793 break;
794 case IEEE80211_AMPDU_RX_STOP:
795 mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid);
796 mt7921_mcu_uni_rx_ba(dev, params, false);
797 break;
798 case IEEE80211_AMPDU_TX_OPERATIONAL:
799 mtxq->aggr = true;
800 mtxq->send_bar = false;
801 mt7921_mcu_uni_tx_ba(dev, params, true);
802 break;
803 case IEEE80211_AMPDU_TX_STOP_FLUSH:
804 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
805 mtxq->aggr = false;
806 clear_bit(tid, &msta->ampdu_state);
807 mt7921_mcu_uni_tx_ba(dev, params, false);
808 break;
809 case IEEE80211_AMPDU_TX_START:
810 set_bit(tid, &msta->ampdu_state);
811 ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
812 break;
813 case IEEE80211_AMPDU_TX_STOP_CONT:
814 mtxq->aggr = false;
815 clear_bit(tid, &msta->ampdu_state);
816 mt7921_mcu_uni_tx_ba(dev, params, false);
817 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
818 break;
819 }
820 mt7921_mutex_release(dev);
821
822 return ret;
823}
824
825static int mt7921_sta_state(struct ieee80211_hw *hw,
826 struct ieee80211_vif *vif,
827 struct ieee80211_sta *sta,
828 enum ieee80211_sta_state old_state,
829 enum ieee80211_sta_state new_state)
830{
831 struct mt7921_dev *dev = mt7921_hw_dev(hw);
832
833 if (dev->pm.ds_enable) {
834 mt7921_mutex_acquire(dev);
835 mt76_connac_sta_state_dp(&dev->mt76, old_state, new_state);
836 mt7921_mutex_release(dev);
837 }
838
839 return mt76_sta_state(hw, vif, sta, old_state, new_state);
840}
841
842static int
843mt7921_get_stats(struct ieee80211_hw *hw,
844 struct ieee80211_low_level_stats *stats)
845{
846 struct mt7921_phy *phy = mt7921_hw_phy(hw);
847 struct mib_stats *mib = &phy->mib;
848
849 mt7921_mutex_acquire(phy->dev);
850
851 stats->dot11RTSSuccessCount = mib->rts_cnt;
852 stats->dot11RTSFailureCount = mib->rts_retries_cnt;
853 stats->dot11FCSErrorCount = mib->fcs_err_cnt;
854 stats->dot11ACKFailureCount = mib->ack_fail_cnt;
855
856 memset(mib, 0, sizeof(*mib));
857
858 mt7921_mutex_release(phy->dev);
859
860 return 0;
861}
862
863static u64
864mt7921_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
865{
866 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
867 struct mt7921_dev *dev = mt7921_hw_dev(hw);
868 u8 omac_idx = mvif->mt76.omac_idx;
869 union {
870 u64 t64;
871 u32 t32[2];
872 } tsf;
873 u16 n;
874
875 mt7921_mutex_acquire(dev);
876
877 n = omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : omac_idx;
878
879 mt76_set(dev, MT_LPON_TCR(0, n), MT_LPON_TCR_SW_MODE);
880 tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0(0));
881 tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1(0));
882
883 mt7921_mutex_release(dev);
884
885 return tsf.t64;
886}
887
888static void
889mt7921_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
890 u64 timestamp)
891{
892 struct mt7921_vif *mvif = (struct mt7921_vif *)vif->drv_priv;
893 struct mt7921_dev *dev = mt7921_hw_dev(hw);
894 u8 omac_idx = mvif->mt76.omac_idx;
895 union {
896 u64 t64;
897 u32 t32[2];
898 } tsf = { .t64 = timestamp, };
899 u16 n;
900
901 mt7921_mutex_acquire(dev);
902
903 n = omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : omac_idx;
904 mt76_wr(dev, MT_LPON_UTTR0(0), tsf.t32[0]);
905 mt76_wr(dev, MT_LPON_UTTR1(0), tsf.t32[1]);
906
907 mt76_set(dev, MT_LPON_TCR(0, n), MT_LPON_TCR_SW_WRITE);
908
909 mt7921_mutex_release(dev);
910}
911
912static void
913mt7921_set_coverage_class(struct ieee80211_hw *hw, s16 coverage_class)
914{
915 struct mt7921_phy *phy = mt7921_hw_phy(hw);
916 struct mt7921_dev *dev = phy->dev;
917
918 mt7921_mutex_acquire(dev);
919 phy->coverage_class = max_t(s16, coverage_class, 0);
920 mt7921_mac_set_timing(phy);
921 mt7921_mutex_release(dev);
922}
923
924void mt7921_scan_work(struct work_struct *work)
925{
926 struct mt7921_phy *phy;
927
928 phy = (struct mt7921_phy *)container_of(work, struct mt7921_phy,
929 scan_work.work);
930
931 while (true) {
932 struct mt7921_mcu_rxd *rxd;
933 struct sk_buff *skb;
934
935 spin_lock_bh(&phy->dev->mt76.lock);
936 skb = __skb_dequeue(&phy->scan_event_list);
937 spin_unlock_bh(&phy->dev->mt76.lock);
938
939 if (!skb)
940 break;
941
942 rxd = (struct mt7921_mcu_rxd *)skb->data;
943 if (rxd->eid == MCU_EVENT_SCHED_SCAN_DONE) {
944 ieee80211_sched_scan_results(phy->mt76->hw);
945 } else if (test_and_clear_bit(MT76_HW_SCANNING,
946 &phy->mt76->state)) {
947 struct cfg80211_scan_info info = {
948 .aborted = false,
949 };
950
951 ieee80211_scan_completed(phy->mt76->hw, &info);
952 }
953 dev_kfree_skb(skb);
954 }
955}
956
957static int
958mt7921_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
959 struct ieee80211_scan_request *req)
960{
961 struct mt7921_dev *dev = mt7921_hw_dev(hw);
962 struct mt76_phy *mphy = hw->priv;
963 int err;
964
965 mt7921_mutex_acquire(dev);
966 err = mt76_connac_mcu_hw_scan(mphy, vif, req);
967 mt7921_mutex_release(dev);
968
969 return err;
970}
971
972static void
973mt7921_cancel_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
974{
975 struct mt7921_dev *dev = mt7921_hw_dev(hw);
976 struct mt76_phy *mphy = hw->priv;
977
978 mt7921_mutex_acquire(dev);
979 mt76_connac_mcu_cancel_hw_scan(mphy, vif);
980 mt7921_mutex_release(dev);
981}
982
983static int
984mt7921_start_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
985 struct cfg80211_sched_scan_request *req,
986 struct ieee80211_scan_ies *ies)
987{
988 struct mt7921_dev *dev = mt7921_hw_dev(hw);
989 struct mt76_phy *mphy = hw->priv;
990 int err;
991
992 mt7921_mutex_acquire(dev);
993
994 err = mt76_connac_mcu_sched_scan_req(mphy, vif, req);
995 if (err < 0)
996 goto out;
997
998 err = mt76_connac_mcu_sched_scan_enable(mphy, vif, true);
999out:
1000 mt7921_mutex_release(dev);
1001
1002 return err;
1003}
1004
1005static int
1006mt7921_stop_sched_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1007{
1008 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1009 struct mt76_phy *mphy = hw->priv;
1010 int err;
1011
1012 mt7921_mutex_acquire(dev);
1013 err = mt76_connac_mcu_sched_scan_enable(mphy, vif, false);
1014 mt7921_mutex_release(dev);
1015
1016 return err;
1017}
1018
1019static int
1020mt7921_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant)
1021{
1022 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1023 struct mt7921_phy *phy = mt7921_hw_phy(hw);
1024 int max_nss = hweight8(hw->wiphy->available_antennas_tx);
1025
1026 if (!tx_ant || tx_ant != rx_ant || ffs(tx_ant) > max_nss)
1027 return -EINVAL;
1028
1029 if ((BIT(hweight8(tx_ant)) - 1) != tx_ant)
1030 tx_ant = BIT(ffs(tx_ant) - 1) - 1;
1031
1032 mt7921_mutex_acquire(dev);
1033
1034 phy->mt76->antenna_mask = tx_ant;
1035 phy->mt76->chainmask = tx_ant;
1036
1037 mt76_set_stream_caps(phy->mt76, true);
1038 mt7921_set_stream_he_caps(phy);
1039
1040 mt7921_mutex_release(dev);
1041
1042 return 0;
1043}
1044
1045static void mt7921_sta_statistics(struct ieee80211_hw *hw,
1046 struct ieee80211_vif *vif,
1047 struct ieee80211_sta *sta,
1048 struct station_info *sinfo)
1049{
1050 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
1051 struct mt7921_sta_stats *stats = &msta->stats;
1052
1053 if (!stats->tx_rate.legacy && !stats->tx_rate.flags)
1054 return;
1055
1056 if (stats->tx_rate.legacy) {
1057 sinfo->txrate.legacy = stats->tx_rate.legacy;
1058 } else {
1059 sinfo->txrate.mcs = stats->tx_rate.mcs;
1060 sinfo->txrate.nss = stats->tx_rate.nss;
1061 sinfo->txrate.bw = stats->tx_rate.bw;
1062 sinfo->txrate.he_gi = stats->tx_rate.he_gi;
1063 sinfo->txrate.he_dcm = stats->tx_rate.he_dcm;
1064 sinfo->txrate.he_ru_alloc = stats->tx_rate.he_ru_alloc;
1065 }
1066 sinfo->txrate.flags = stats->tx_rate.flags;
1067 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
1068}
1069
1070#ifdef CONFIG_PM
1071static int mt7921_suspend(struct ieee80211_hw *hw,
1072 struct cfg80211_wowlan *wowlan)
1073{
1074 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1075 struct mt7921_phy *phy = mt7921_hw_phy(hw);
1076 int err;
1077
1078 cancel_delayed_work_sync(&phy->scan_work);
1079 cancel_delayed_work_sync(&phy->mt76->mac_work);
1080
1081 cancel_delayed_work_sync(&dev->pm.ps_work);
1082 mt76_connac_free_pending_tx_skbs(&dev->pm, NULL);
1083
1084 mt7921_mutex_acquire(dev);
1085
1086 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
1087
1088 set_bit(MT76_STATE_SUSPEND, &phy->mt76->state);
1089 ieee80211_iterate_active_interfaces(hw,
1090 IEEE80211_IFACE_ITER_RESUME_ALL,
1091 mt76_connac_mcu_set_suspend_iter,
1092 &dev->mphy);
1093
1094 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, true);
1095
1096 mt7921_mutex_release(dev);
1097
1098 return err;
1099}
1100
1101static int mt7921_resume(struct ieee80211_hw *hw)
1102{
1103 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1104 struct mt7921_phy *phy = mt7921_hw_phy(hw);
1105 int err;
1106
1107 mt7921_mutex_acquire(dev);
1108
1109 err = mt76_connac_mcu_set_hif_suspend(&dev->mt76, false);
1110 if (err < 0)
1111 goto out;
1112
1113 set_bit(MT76_STATE_RUNNING, &phy->mt76->state);
1114 clear_bit(MT76_STATE_SUSPEND, &phy->mt76->state);
1115 ieee80211_iterate_active_interfaces(hw,
1116 IEEE80211_IFACE_ITER_RESUME_ALL,
1117 mt76_connac_mcu_set_suspend_iter,
1118 &dev->mphy);
1119
1120 ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work,
1121 MT7921_WATCHDOG_TIME);
1122out:
1123
1124 mt7921_mutex_release(dev);
1125
1126 return err;
1127}
1128
1129static void mt7921_set_wakeup(struct ieee80211_hw *hw, bool enabled)
1130{
1131 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1132 struct mt76_dev *mdev = &dev->mt76;
1133
1134 device_set_wakeup_enable(mdev->dev, enabled);
1135}
1136
1137static void mt7921_set_rekey_data(struct ieee80211_hw *hw,
1138 struct ieee80211_vif *vif,
1139 struct cfg80211_gtk_rekey_data *data)
1140{
1141 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1142
1143 mt7921_mutex_acquire(dev);
1144 mt76_connac_mcu_update_gtk_rekey(hw, vif, data);
1145 mt7921_mutex_release(dev);
1146}
1147#endif
1148
1149static void mt7921_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1150 u32 queues, bool drop)
1151{
1152 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1153
1154 wait_event_timeout(dev->mt76.tx_wait, !mt76_has_tx_pending(&dev->mphy),
1155 HZ / 2);
1156}
1157
1158static void mt7921_sta_set_decap_offload(struct ieee80211_hw *hw,
1159 struct ieee80211_vif *vif,
1160 struct ieee80211_sta *sta,
1161 bool enabled)
1162{
1163 struct mt7921_sta *msta = (struct mt7921_sta *)sta->drv_priv;
1164 struct mt7921_dev *dev = mt7921_hw_dev(hw);
1165
1166 if (enabled)
1167 set_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags);
1168 else
1169 clear_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags);
1170
1171 mt76_connac_mcu_sta_update_hdr_trans(&dev->mt76, vif, &msta->wcid,
1172 MCU_UNI_CMD_STA_REC_UPDATE);
1173}
1174
1175const struct ieee80211_ops mt7921_ops = {
1176 .tx = mt7921_tx,
1177 .start = mt7921_start,
1178 .stop = mt7921_stop,
1179 .add_interface = mt7921_add_interface,
1180 .remove_interface = mt7921_remove_interface,
1181 .config = mt7921_config,
1182 .conf_tx = mt7921_conf_tx,
1183 .configure_filter = mt7921_configure_filter,
1184 .bss_info_changed = mt7921_bss_info_changed,
1185 .sta_state = mt7921_sta_state,
1186 .sta_pre_rcu_remove = mt76_sta_pre_rcu_remove,
1187 .set_key = mt7921_set_key,
1188 .sta_set_decap_offload = mt7921_sta_set_decap_offload,
1189 .ampdu_action = mt7921_ampdu_action,
1190 .set_rts_threshold = mt7921_set_rts_threshold,
1191 .wake_tx_queue = mt76_wake_tx_queue,
1192 .release_buffered_frames = mt76_release_buffered_frames,
1193 .get_txpower = mt76_get_txpower,
1194 .get_stats = mt7921_get_stats,
1195 .get_tsf = mt7921_get_tsf,
1196 .set_tsf = mt7921_set_tsf,
1197 .get_survey = mt76_get_survey,
1198 .get_antenna = mt76_get_antenna,
1199 .set_antenna = mt7921_set_antenna,
1200 .set_coverage_class = mt7921_set_coverage_class,
1201 .hw_scan = mt7921_hw_scan,
1202 .cancel_hw_scan = mt7921_cancel_hw_scan,
1203 .sta_statistics = mt7921_sta_statistics,
1204 .sched_scan_start = mt7921_start_sched_scan,
1205 .sched_scan_stop = mt7921_stop_sched_scan,
1206#ifdef CONFIG_PM
1207 .suspend = mt7921_suspend,
1208 .resume = mt7921_resume,
1209 .set_wakeup = mt7921_set_wakeup,
1210 .set_rekey_data = mt7921_set_rekey_data,
1211#endif
1212 .flush = mt7921_flush,
1213};
1214
