1 // SPDX-License-Identifier: BSD-3-Clause-Clear
2 /*
3 * Copyright (C) 2022 MediaTek Inc.
4 */
5
6 #include "mt7996.h"
7 #include "mcu.h"
8 #include "mac.h"
9
mt7996_run(struct mt7996_phy * phy)10 int mt7996_run(struct mt7996_phy *phy)
11 {
12 struct mt7996_dev *dev = phy->dev;
13 int ret;
14
15 mt7996_mac_enable_nf(dev, phy->mt76->band_idx);
16
17 ret = mt7996_mcu_set_rts_thresh(phy, 0x92b);
18 if (ret)
19 return ret;
20
21 ret = mt7996_mcu_set_radio_en(phy, true);
22 if (ret)
23 return ret;
24
25 ret = mt7996_mcu_set_chan_info(phy, UNI_CHANNEL_RX_PATH);
26 if (ret)
27 return ret;
28
29 ret = mt7996_mcu_set_thermal_throttling(phy, MT7996_THERMAL_THROTTLE_MAX);
30 if (ret)
31 return ret;
32
33 ret = mt7996_mcu_set_thermal_protect(phy, true);
34 if (ret)
35 return ret;
36
37 set_bit(MT76_STATE_RUNNING, &phy->mt76->state);
38
39 ieee80211_queue_delayed_work(dev->mphy.hw, &phy->mt76->mac_work,
40 MT7996_WATCHDOG_TIME);
41
42 if (!phy->counter_reset) {
43 mt7996_mac_reset_counters(phy);
44 phy->counter_reset = true;
45 }
46
47 return 0;
48 }
49
mt7996_start(struct ieee80211_hw * hw)50 static int mt7996_start(struct ieee80211_hw *hw)
51 {
52 struct mt7996_dev *dev = mt7996_hw_dev(hw);
53 int ret;
54
55 flush_work(&dev->init_work);
56
57 mutex_lock(&dev->mt76.mutex);
58 ret = mt7996_mcu_set_hdr_trans(dev, true);
59 if (!ret && is_mt7992(&dev->mt76)) {
60 u8 queue = mt76_connac_lmac_mapping(IEEE80211_AC_VI);
61
62 ret = mt7996_mcu_cp_support(dev, queue);
63 }
64 mutex_unlock(&dev->mt76.mutex);
65
66 return ret;
67 }
68
mt7996_stop_phy(struct mt7996_phy * phy)69 static void mt7996_stop_phy(struct mt7996_phy *phy)
70 {
71 struct mt7996_dev *dev;
72
73 if (!phy || !test_bit(MT76_STATE_RUNNING, &phy->mt76->state))
74 return;
75
76 dev = phy->dev;
77
78 cancel_delayed_work_sync(&phy->mt76->mac_work);
79
80 mutex_lock(&dev->mt76.mutex);
81
82 mt7996_mcu_set_radio_en(phy, false);
83
84 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state);
85
86 mutex_unlock(&dev->mt76.mutex);
87 }
88
mt7996_stop(struct ieee80211_hw * hw,bool suspend)89 static void mt7996_stop(struct ieee80211_hw *hw, bool suspend)
90 {
91 }
92
get_free_idx(u64 mask,u8 start,u8 end)93 static inline int get_free_idx(u64 mask, u8 start, u8 end)
94 {
95 if (~mask & GENMASK_ULL(end, start))
96 return __ffs64(~mask & GENMASK_ULL(end, start)) + 1;
97 return 0;
98 }
99
get_omac_idx(enum nl80211_iftype type,u64 mask)100 static int get_omac_idx(enum nl80211_iftype type, u64 mask)
101 {
102 int i;
103
104 switch (type) {
105 case NL80211_IFTYPE_MESH_POINT:
106 case NL80211_IFTYPE_ADHOC:
107 case NL80211_IFTYPE_STATION:
108 /* prefer hw bssid slot 1-3 */
109 i = get_free_idx(mask, HW_BSSID_1, HW_BSSID_3);
110 if (i)
111 return i - 1;
112
113 if (type != NL80211_IFTYPE_STATION)
114 break;
115
116 i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX);
117 if (i)
118 return i - 1;
119
120 if (~mask & BIT(HW_BSSID_0))
121 return HW_BSSID_0;
122
123 break;
124 case NL80211_IFTYPE_MONITOR:
125 case NL80211_IFTYPE_AP:
126 /* ap uses hw bssid 0 and ext bssid */
127 if (~mask & BIT(HW_BSSID_0))
128 return HW_BSSID_0;
129
130 i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX);
131 if (i)
132 return i - 1;
133
134 break;
135 default:
136 WARN_ON(1);
137 break;
138 }
139
140 return -1;
141 }
142
get_own_mld_idx(u64 mask,bool group_mld)143 static int get_own_mld_idx(u64 mask, bool group_mld)
144 {
145 u8 start = group_mld ? 0 : 16;
146 u8 end = group_mld ? 15 : 63;
147 int idx;
148
149 idx = get_free_idx(mask, start, end);
150 if (idx)
151 return idx - 1;
152
153 /* If the 16-63 range is not available, perform another lookup in the
154 * range 0-15
155 */
156 if (!group_mld) {
157 idx = get_free_idx(mask, 0, 15);
158 if (idx)
159 return idx - 1;
160 }
161
162 return -EINVAL;
163 }
164
165 static void
mt7996_init_bitrate_mask(struct ieee80211_vif * vif,struct mt7996_vif_link * mlink)166 mt7996_init_bitrate_mask(struct ieee80211_vif *vif, struct mt7996_vif_link *mlink)
167 {
168 int i;
169
170 for (i = 0; i < ARRAY_SIZE(mlink->bitrate_mask.control); i++) {
171 mlink->bitrate_mask.control[i].gi = NL80211_TXRATE_DEFAULT_GI;
172 mlink->bitrate_mask.control[i].he_gi = 0xff;
173 mlink->bitrate_mask.control[i].he_ltf = 0xff;
174 mlink->bitrate_mask.control[i].legacy = GENMASK(31, 0);
175 memset(mlink->bitrate_mask.control[i].ht_mcs, 0xff,
176 sizeof(mlink->bitrate_mask.control[i].ht_mcs));
177 memset(mlink->bitrate_mask.control[i].vht_mcs, 0xff,
178 sizeof(mlink->bitrate_mask.control[i].vht_mcs));
179 memset(mlink->bitrate_mask.control[i].he_mcs, 0xff,
180 sizeof(mlink->bitrate_mask.control[i].he_mcs));
181 }
182 }
183
184 static int
mt7996_set_hw_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,unsigned int link_id,struct ieee80211_key_conf * key)185 mt7996_set_hw_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
186 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
187 unsigned int link_id, struct ieee80211_key_conf *key)
188 {
189 struct mt7996_dev *dev = mt7996_hw_dev(hw);
190 struct ieee80211_bss_conf *link_conf;
191 struct mt7996_sta_link *msta_link;
192 struct mt7996_vif_link *link;
193 int idx = key->keyidx;
194 u8 *wcid_keyidx;
195 bool is_bigtk;
196 int err;
197
198 link = mt7996_vif_link(dev, vif, link_id);
199 if (!link)
200 return 0;
201
202 if (!mt7996_vif_link_phy(link))
203 return 0;
204
205 if (sta) {
206 struct mt7996_sta *msta;
207
208 msta = (struct mt7996_sta *)sta->drv_priv;
209 msta_link = mt76_dereference(msta->link[link_id],
210 &dev->mt76);
211 if (!msta_link)
212 return 0;
213
214 if (!msta_link->wcid.sta)
215 return -EOPNOTSUPP;
216 } else {
217 msta_link = &link->msta_link;
218 }
219 wcid_keyidx = &msta_link->wcid.hw_key_idx;
220
221 is_bigtk = key->keyidx == 6 || key->keyidx == 7;
222 switch (key->cipher) {
223 case WLAN_CIPHER_SUITE_AES_CMAC:
224 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
225 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
226 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
227 if (is_bigtk) {
228 wcid_keyidx = &msta_link->wcid.hw_key_idx2;
229 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE;
230 }
231 break;
232 default:
233 break;
234 }
235
236 link_conf = link_conf_dereference_protected(vif, link_id);
237 if (!link_conf)
238 link_conf = &vif->bss_conf;
239
240 if (cmd == SET_KEY && !sta && !link->mt76.cipher) {
241 link->mt76.cipher =
242 mt76_connac_mcu_get_cipher(key->cipher);
243 mt7996_mcu_add_bss_info(link->phy, vif, link_conf,
244 &link->mt76, msta_link, true);
245 }
246
247 if (cmd == SET_KEY)
248 *wcid_keyidx = idx;
249 else if (idx == *wcid_keyidx)
250 *wcid_keyidx = -1;
251
252 /* only do remove key for BIGTK */
253 if (cmd != SET_KEY && !is_bigtk)
254 return 0;
255
256 mt76_wcid_key_setup(&dev->mt76, &msta_link->wcid, key);
257
258 err = mt7996_mcu_add_key(&dev->mt76, link, key,
259 MCU_WMWA_UNI_CMD(STA_REC_UPDATE),
260 &msta_link->wcid, cmd);
261
262 /* remove and add beacon in order to enable beacon protection */
263 if (cmd == SET_KEY && is_bigtk && link_conf->enable_beacon) {
264 mt7996_mcu_add_beacon(hw, vif, link_conf, false);
265 mt7996_mcu_add_beacon(hw, vif, link_conf, true);
266 }
267
268 return err;
269 }
270
271 struct mt7996_key_iter_data {
272 enum set_key_cmd cmd;
273 unsigned int link_id;
274 };
275
276 static void
mt7996_key_iter(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key,void * data)277 mt7996_key_iter(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
278 struct ieee80211_sta *sta, struct ieee80211_key_conf *key,
279 void *data)
280 {
281 struct mt7996_key_iter_data *it = data;
282
283 if (sta)
284 return;
285
286 WARN_ON(mt7996_set_hw_key(hw, it->cmd, vif, NULL, it->link_id, key));
287 }
288
mt7996_vif_link_add(struct mt76_phy * mphy,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct mt76_vif_link * mlink)289 int mt7996_vif_link_add(struct mt76_phy *mphy, struct ieee80211_vif *vif,
290 struct ieee80211_bss_conf *link_conf,
291 struct mt76_vif_link *mlink)
292 {
293 struct mt7996_vif_link *link = container_of(mlink, struct mt7996_vif_link, mt76);
294 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
295 struct mt7996_sta_link *msta_link = &link->msta_link;
296 struct mt7996_phy *phy = mphy->priv;
297 struct mt7996_dev *dev = phy->dev;
298 u8 band_idx = phy->mt76->band_idx;
299 struct mt7996_key_iter_data it = {
300 .cmd = SET_KEY,
301 .link_id = link_conf->link_id,
302 };
303 struct mt76_txq *mtxq;
304 int mld_idx, idx, ret;
305
306 mlink->idx = __ffs64(~dev->mt76.vif_mask);
307 if (mlink->idx >= mt7996_max_interface_num(dev))
308 return -ENOSPC;
309
310 idx = get_omac_idx(vif->type, phy->omac_mask);
311 if (idx < 0)
312 return -ENOSPC;
313
314 mld_idx = get_own_mld_idx(dev->mld_idx_mask, false);
315 if (mld_idx < 0)
316 return -ENOSPC;
317
318 link->mld_idx = mld_idx;
319 link->phy = phy;
320 mlink->omac_idx = idx;
321 mlink->band_idx = band_idx;
322 mlink->wmm_idx = vif->type == NL80211_IFTYPE_AP ? 0 : 3;
323 mlink->wcid = &msta_link->wcid;
324 mlink->wcid->offchannel = mlink->offchannel;
325
326 ret = mt7996_mcu_add_dev_info(phy, vif, link_conf, mlink, true);
327 if (ret)
328 return ret;
329
330 dev->mt76.vif_mask |= BIT_ULL(mlink->idx);
331 dev->mld_idx_mask |= BIT_ULL(link->mld_idx);
332 phy->omac_mask |= BIT_ULL(mlink->omac_idx);
333
334 idx = MT7996_WTBL_RESERVED - mlink->idx;
335
336 INIT_LIST_HEAD(&msta_link->rc_list);
337 msta_link->wcid.idx = idx;
338 msta_link->wcid.link_id = link_conf->link_id;
339 msta_link->wcid.link_valid = ieee80211_vif_is_mld(vif);
340 msta_link->wcid.tx_info |= MT_WCID_TX_INFO_SET;
341 mt76_wcid_init(&msta_link->wcid, band_idx);
342
343 mt7996_mac_wtbl_update(dev, idx,
344 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
345
346 if (vif->txq) {
347 mtxq = (struct mt76_txq *)vif->txq->drv_priv;
348 mtxq->wcid = idx;
349 }
350
351 if (vif->type != NL80211_IFTYPE_AP &&
352 (!mlink->omac_idx || mlink->omac_idx > 3))
353 vif->offload_flags = 0;
354
355 if (phy->mt76->chandef.chan->band != NL80211_BAND_2GHZ)
356 mlink->basic_rates_idx = MT7996_BASIC_RATES_TBL + 4;
357 else
358 mlink->basic_rates_idx = MT7996_BASIC_RATES_TBL;
359
360 mt7996_init_bitrate_mask(vif, link);
361
362 mt7996_mcu_add_bss_info(phy, vif, link_conf, mlink, msta_link, true);
363 /* defer the first STA_REC of BMC entry to BSS_CHANGED_BSSID for STA
364 * interface, since firmware only records BSSID when the entry is new
365 */
366 if (vif->type != NL80211_IFTYPE_STATION)
367 mt7996_mcu_add_sta(dev, link_conf, NULL, link, NULL,
368 CONN_STATE_PORT_SECURE, true);
369 rcu_assign_pointer(dev->mt76.wcid[idx], &msta_link->wcid);
370
371 ieee80211_iter_keys(mphy->hw, vif, mt7996_key_iter, &it);
372
373 if (!mlink->wcid->offchannel &&
374 mvif->mt76.deflink_id == IEEE80211_LINK_UNSPECIFIED)
375 mvif->mt76.deflink_id = link_conf->link_id;
376
377 return 0;
378 }
379
mt7996_vif_link_remove(struct mt76_phy * mphy,struct ieee80211_vif * vif,struct ieee80211_bss_conf * link_conf,struct mt76_vif_link * mlink)380 void mt7996_vif_link_remove(struct mt76_phy *mphy, struct ieee80211_vif *vif,
381 struct ieee80211_bss_conf *link_conf,
382 struct mt76_vif_link *mlink)
383 {
384 struct mt7996_vif_link *link = container_of(mlink, struct mt7996_vif_link, mt76);
385 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
386 struct mt7996_sta_link *msta_link = &link->msta_link;
387 struct mt7996_phy *phy = mphy->priv;
388 struct mt7996_dev *dev = phy->dev;
389 struct mt7996_key_iter_data it = {
390 .cmd = SET_KEY,
391 .link_id = link_conf->link_id,
392 };
393 int idx = msta_link->wcid.idx;
394
395 if (!mlink->wcid->offchannel)
396 ieee80211_iter_keys(mphy->hw, vif, mt7996_key_iter, &it);
397
398 mt7996_mcu_add_sta(dev, link_conf, NULL, link, NULL,
399 CONN_STATE_DISCONNECT, false);
400 mt7996_mcu_add_bss_info(phy, vif, link_conf, mlink, msta_link, false);
401
402 mt7996_mcu_add_dev_info(phy, vif, link_conf, mlink, false);
403
404 rcu_assign_pointer(dev->mt76.wcid[idx], NULL);
405
406 if (!mlink->wcid->offchannel &&
407 mvif->mt76.deflink_id == link_conf->link_id) {
408 struct ieee80211_bss_conf *iter;
409 unsigned int link_id;
410
411 mvif->mt76.deflink_id = IEEE80211_LINK_UNSPECIFIED;
412 for_each_vif_active_link(vif, iter, link_id) {
413 if (link_id != IEEE80211_LINK_UNSPECIFIED) {
414 mvif->mt76.deflink_id = link_id;
415 break;
416 }
417 }
418 }
419
420 dev->mt76.vif_mask &= ~BIT_ULL(mlink->idx);
421 dev->mld_idx_mask &= ~BIT_ULL(link->mld_idx);
422 phy->omac_mask &= ~BIT_ULL(mlink->omac_idx);
423
424 spin_lock_bh(&dev->mt76.sta_poll_lock);
425 if (!list_empty(&msta_link->wcid.poll_list))
426 list_del_init(&msta_link->wcid.poll_list);
427 spin_unlock_bh(&dev->mt76.sta_poll_lock);
428
429 mt76_wcid_cleanup(&dev->mt76, &msta_link->wcid);
430 }
431
mt7996_phy_set_rxfilter(struct mt7996_phy * phy)432 static void mt7996_phy_set_rxfilter(struct mt7996_phy *phy)
433 {
434 struct mt7996_dev *dev = phy->dev;
435 u32 ctl_flags = MT_WF_RFCR1_DROP_ACK |
436 MT_WF_RFCR1_DROP_BF_POLL |
437 MT_WF_RFCR1_DROP_BA |
438 MT_WF_RFCR1_DROP_CFEND |
439 MT_WF_RFCR1_DROP_CFACK;
440 u32 filter = phy->rxfilter;
441
442 if (filter & MT_WF_RFCR_DROP_OTHER_UC) {
443 filter |= MT_WF_RFCR_DROP_CTS |
444 MT_WF_RFCR_DROP_RTS |
445 MT_WF_RFCR_DROP_CTL_RSV |
446 MT_WF_RFCR_DROP_FCSFAIL;
447 }
448
449 mt76_wr(dev, MT_WF_RFCR(phy->mt76->band_idx), filter);
450 if (filter & MT_WF_RFCR_DROP_CTL_RSV)
451 mt76_set(dev, MT_WF_RFCR1(phy->mt76->band_idx), ctl_flags);
452 else
453 mt76_clear(dev, MT_WF_RFCR1(phy->mt76->band_idx), ctl_flags);
454 }
455
mt7996_set_monitor(struct mt7996_phy * phy,bool enabled)456 static void mt7996_set_monitor(struct mt7996_phy *phy, bool enabled)
457 {
458 struct mt7996_dev *dev;
459
460 if (!phy)
461 return;
462
463 dev = phy->dev;
464
465 if (enabled == !(phy->rxfilter & MT_WF_RFCR_DROP_OTHER_UC))
466 return;
467
468 if (!enabled)
469 phy->rxfilter |= MT_WF_RFCR_DROP_OTHER_UC;
470 else
471 phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC;
472
473 mt76_rmw_field(dev, MT_DMA_DCR0(phy->mt76->band_idx),
474 MT_DMA_DCR0_RXD_G5_EN, enabled);
475 mt7996_phy_set_rxfilter(phy);
476 mt7996_mcu_set_sniffer_mode(phy, enabled);
477 }
478
mt7996_add_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)479 static int mt7996_add_interface(struct ieee80211_hw *hw,
480 struct ieee80211_vif *vif)
481 {
482 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
483 struct wireless_dev *wdev = ieee80211_vif_to_wdev(vif);
484 struct mt7996_dev *dev = mt7996_hw_dev(hw);
485 int i, err = 0;
486
487 mutex_lock(&dev->mt76.mutex);
488
489 for (i = 0; i < MT7996_MAX_RADIOS; i++) {
490 struct mt7996_phy *phy = dev->radio_phy[i];
491
492 if (!phy || !(wdev->radio_mask & BIT(i)) ||
493 test_bit(MT76_STATE_RUNNING, &phy->mt76->state))
494 continue;
495
496 err = mt7996_run(phy);
497 if (err)
498 goto out;
499
500 if (vif->type == NL80211_IFTYPE_MONITOR)
501 mt7996_set_monitor(phy, true);
502 }
503
504 mt76_vif_init(vif, &mvif->mt76);
505
506 vif->offload_flags |= IEEE80211_OFFLOAD_ENCAP_4ADDR;
507 mvif->mt76.deflink_id = IEEE80211_LINK_UNSPECIFIED;
508
509 out:
510 mutex_unlock(&dev->mt76.mutex);
511
512 return err;
513 }
514
515 struct mt7996_radio_data {
516 u32 active_mask;
517 u32 monitor_mask;
518 };
519
mt7996_remove_iter(void * data,u8 * mac,struct ieee80211_vif * vif)520 static void mt7996_remove_iter(void *data, u8 *mac, struct ieee80211_vif *vif)
521 {
522 struct wireless_dev *wdev = ieee80211_vif_to_wdev(vif);
523 struct mt7996_radio_data *rdata = data;
524
525 rdata->active_mask |= wdev->radio_mask;
526 if (vif->type == NL80211_IFTYPE_MONITOR)
527 rdata->monitor_mask |= wdev->radio_mask;
528 }
529
mt7996_remove_interface(struct ieee80211_hw * hw,struct ieee80211_vif * vif)530 static void mt7996_remove_interface(struct ieee80211_hw *hw,
531 struct ieee80211_vif *vif)
532 {
533 struct mt7996_dev *dev = mt7996_hw_dev(hw);
534 struct mt7996_radio_data rdata = {};
535 int i;
536
537 ieee80211_iterate_active_interfaces_mtx(hw, 0, mt7996_remove_iter,
538 &rdata);
539 mt76_vif_cleanup(&dev->mt76, vif);
540
541 for (i = 0; i < MT7996_MAX_RADIOS; i++) {
542 struct mt7996_phy *phy = dev->radio_phy[i];
543
544 if (!phy)
545 continue;
546 if (!(rdata.monitor_mask & BIT(i)))
547 mt7996_set_monitor(phy, false);
548 if (!(rdata.active_mask & BIT(i)))
549 mt7996_stop_phy(phy);
550 }
551 }
552
mt7996_set_channel(struct mt76_phy * mphy)553 int mt7996_set_channel(struct mt76_phy *mphy)
554 {
555 struct mt7996_phy *phy = mphy->priv;
556 int ret;
557
558 if (mphy->offchannel)
559 mt7996_mac_update_beacons(phy);
560
561 ret = mt7996_mcu_set_chan_info(phy, UNI_CHANNEL_SWITCH);
562 if (ret)
563 goto out;
564
565 ret = mt7996_mcu_set_chan_info(phy, UNI_CHANNEL_RX_PATH);
566 if (ret)
567 goto out;
568
569 ret = mt7996_mcu_set_txpower_sku(phy);
570 if (ret)
571 goto out;
572
573 ret = mt7996_dfs_init_radar_detector(phy);
574 mt7996_mac_cca_stats_reset(phy);
575
576 mt7996_mac_reset_counters(phy);
577 phy->noise = 0;
578 if (!mphy->offchannel)
579 mt7996_mac_update_beacons(phy);
580
581 out:
582 ieee80211_queue_delayed_work(mphy->hw, &mphy->mac_work,
583 MT7996_WATCHDOG_TIME);
584
585 return ret;
586 }
587
mt7996_set_key(struct ieee80211_hw * hw,enum set_key_cmd cmd,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct ieee80211_key_conf * key)588 static int mt7996_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd,
589 struct ieee80211_vif *vif, struct ieee80211_sta *sta,
590 struct ieee80211_key_conf *key)
591 {
592 struct mt7996_dev *dev = mt7996_hw_dev(hw);
593 unsigned int link_id;
594 unsigned long links;
595 int err = 0;
596
597 /* The hardware does not support per-STA RX GTK, fallback
598 * to software mode for these.
599 */
600 if ((vif->type == NL80211_IFTYPE_ADHOC ||
601 vif->type == NL80211_IFTYPE_MESH_POINT) &&
602 (key->cipher == WLAN_CIPHER_SUITE_TKIP ||
603 key->cipher == WLAN_CIPHER_SUITE_CCMP) &&
604 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE))
605 return -EOPNOTSUPP;
606
607 /* fall back to sw encryption for unsupported ciphers */
608 switch (key->cipher) {
609 case WLAN_CIPHER_SUITE_TKIP:
610 case WLAN_CIPHER_SUITE_CCMP:
611 case WLAN_CIPHER_SUITE_CCMP_256:
612 case WLAN_CIPHER_SUITE_GCMP:
613 case WLAN_CIPHER_SUITE_GCMP_256:
614 case WLAN_CIPHER_SUITE_SMS4:
615 break;
616 case WLAN_CIPHER_SUITE_AES_CMAC:
617 case WLAN_CIPHER_SUITE_BIP_CMAC_256:
618 case WLAN_CIPHER_SUITE_BIP_GMAC_128:
619 case WLAN_CIPHER_SUITE_BIP_GMAC_256:
620 if (key->keyidx == 6 || key->keyidx == 7)
621 break;
622 fallthrough;
623 case WLAN_CIPHER_SUITE_WEP40:
624 case WLAN_CIPHER_SUITE_WEP104:
625 default:
626 return -EOPNOTSUPP;
627 }
628
629 mutex_lock(&dev->mt76.mutex);
630
631 if (key->link_id >= 0)
632 links = BIT(key->link_id);
633 else if (sta && sta->valid_links)
634 links = sta->valid_links;
635 else if (vif->valid_links)
636 links = vif->valid_links;
637 else
638 links = BIT(0);
639
640 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) {
641 err = mt7996_set_hw_key(hw, cmd, vif, sta, link_id, key);
642 if (err)
643 break;
644 }
645 mutex_unlock(&dev->mt76.mutex);
646
647 return err;
648 }
649
mt7996_config(struct ieee80211_hw * hw,int radio_idx,u32 changed)650 static int mt7996_config(struct ieee80211_hw *hw, int radio_idx, u32 changed)
651 {
652 return 0;
653 }
654
655 static int
mt7996_conf_tx(struct ieee80211_hw * hw,struct ieee80211_vif * vif,unsigned int link_id,u16 queue,const struct ieee80211_tx_queue_params * params)656 mt7996_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
657 unsigned int link_id, u16 queue,
658 const struct ieee80211_tx_queue_params *params)
659 {
660 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
661 struct mt7996_vif_link_info *link_info = &mvif->link_info[link_id];
662 static const u8 mq_to_aci[] = {
663 [IEEE80211_AC_VO] = 3,
664 [IEEE80211_AC_VI] = 2,
665 [IEEE80211_AC_BE] = 0,
666 [IEEE80211_AC_BK] = 1,
667 };
668
669 /* firmware uses access class index */
670 link_info->queue_params[mq_to_aci[queue]] = *params;
671 /* no need to update right away, we'll get BSS_CHANGED_QOS */
672
673 return 0;
674 }
675
mt7996_configure_filter(struct ieee80211_hw * hw,unsigned int changed_flags,unsigned int * total_flags,u64 multicast)676 static void mt7996_configure_filter(struct ieee80211_hw *hw,
677 unsigned int changed_flags,
678 unsigned int *total_flags,
679 u64 multicast)
680 {
681 struct mt7996_dev *dev = mt7996_hw_dev(hw);
682 struct mt7996_phy *phy;
683 u32 filter_mask = 0, filter_set = 0;
684 u32 flags = 0;
685
686 #define MT76_FILTER(_flag, _hw) do { \
687 flags |= *total_flags & FIF_##_flag; \
688 filter_mask |= (_hw); \
689 filter_set |= !(flags & FIF_##_flag) * (_hw); \
690 } while (0)
691
692 mutex_lock(&dev->mt76.mutex);
693
694 MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM |
695 MT_WF_RFCR_DROP_A3_MAC |
696 MT_WF_RFCR_DROP_A3_BSSID);
697
698 MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL);
699
700 MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS |
701 MT_WF_RFCR_DROP_RTS |
702 MT_WF_RFCR_DROP_CTL_RSV);
703
704 *total_flags = flags;
705
706 mt7996_for_each_phy(dev, phy) {
707 phy->rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS |
708 MT_WF_RFCR_DROP_OTHER_BEACON |
709 MT_WF_RFCR_DROP_FRAME_REPORT |
710 MT_WF_RFCR_DROP_PROBEREQ |
711 MT_WF_RFCR_DROP_MCAST_FILTERED |
712 MT_WF_RFCR_DROP_MCAST |
713 MT_WF_RFCR_DROP_BCAST |
714 MT_WF_RFCR_DROP_DUPLICATE |
715 MT_WF_RFCR_DROP_A2_BSSID |
716 MT_WF_RFCR_DROP_UNWANTED_CTL |
717 MT_WF_RFCR_DROP_STBC_MULTI |
718 filter_mask);
719 phy->rxfilter |= filter_set;
720 mt7996_phy_set_rxfilter(phy);
721 }
722
723 mutex_unlock(&dev->mt76.mutex);
724 }
725
726 static int
mt7996_get_txpower(struct ieee80211_hw * hw,struct ieee80211_vif * vif,unsigned int link_id,int * dbm)727 mt7996_get_txpower(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
728 unsigned int link_id, int *dbm)
729 {
730 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
731 struct mt7996_phy *phy = mt7996_vif_link_phy(&mvif->deflink);
732 struct mt7996_dev *dev = mt7996_hw_dev(hw);
733 struct wireless_dev *wdev;
734 int n_chains, delta, i;
735
736 if (!phy) {
737 wdev = ieee80211_vif_to_wdev(vif);
738 for (i = 0; i < hw->wiphy->n_radio; i++)
739 if (wdev->radio_mask & BIT(i))
740 phy = dev->radio_phy[i];
741
742 if (!phy)
743 return -EINVAL;
744 }
745
746 n_chains = hweight16(phy->mt76->chainmask);
747 delta = mt76_tx_power_path_delta(n_chains);
748 *dbm = DIV_ROUND_UP(phy->mt76->txpower_cur + delta, 2);
749
750 return 0;
751 }
752
753 static u8
mt7996_get_rates_table(struct mt7996_phy * phy,struct ieee80211_bss_conf * conf,bool beacon,bool mcast)754 mt7996_get_rates_table(struct mt7996_phy *phy, struct ieee80211_bss_conf *conf,
755 bool beacon, bool mcast)
756 {
757 struct mt7996_dev *dev = phy->dev;
758 struct mt76_vif_link *mvif = mt76_vif_conf_link(&dev->mt76, conf->vif, conf);
759 u16 rate;
760 u8 i, idx;
761
762 rate = mt76_connac2_mac_tx_rate_val(phy->mt76, conf, beacon, mcast);
763
764 if (beacon) {
765 /* odd index for driver, even index for firmware */
766 idx = MT7996_BEACON_RATES_TBL + 2 * phy->mt76->band_idx;
767 if (phy->beacon_rate != rate)
768 mt7996_mcu_set_fixed_rate_table(phy, idx, rate, beacon);
769
770 return idx;
771 }
772
773 idx = FIELD_GET(MT_TX_RATE_IDX, rate);
774 for (i = 0; i < ARRAY_SIZE(mt76_rates); i++)
775 if ((mt76_rates[i].hw_value & GENMASK(7, 0)) == idx)
776 return MT7996_BASIC_RATES_TBL + 2 * i;
777
778 return mvif->basic_rates_idx;
779 }
780
781 static void
mt7996_update_mu_group(struct ieee80211_hw * hw,struct mt7996_vif_link * link,struct ieee80211_bss_conf * info)782 mt7996_update_mu_group(struct ieee80211_hw *hw, struct mt7996_vif_link *link,
783 struct ieee80211_bss_conf *info)
784 {
785 struct mt7996_dev *dev = mt7996_hw_dev(hw);
786 u8 band = link->mt76.band_idx;
787 u32 *mu;
788
789 mu = (u32 *)info->mu_group.membership;
790 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_VLD0(band), mu[0]);
791 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_VLD1(band), mu[1]);
792
793 mu = (u32 *)info->mu_group.position;
794 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_POS0(band), mu[0]);
795 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_POS1(band), mu[1]);
796 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_POS2(band), mu[2]);
797 mt76_wr(dev, MT_WF_PHYRX_BAND_GID_TAB_POS3(band), mu[3]);
798 }
799
800 static void
mt7996_vif_cfg_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u64 changed)801 mt7996_vif_cfg_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
802 u64 changed)
803 {
804 struct mt7996_dev *dev = mt7996_hw_dev(hw);
805
806 mutex_lock(&dev->mt76.mutex);
807
808 if ((changed & BSS_CHANGED_ASSOC) && vif->cfg.assoc) {
809 struct ieee80211_bss_conf *link_conf;
810 unsigned long link_id;
811
812 for_each_vif_active_link(vif, link_conf, link_id) {
813 struct mt7996_vif_link *link;
814
815 link = mt7996_vif_link(dev, vif, link_id);
816 if (!link)
817 continue;
818
819 if (!link->phy)
820 continue;
821
822 mt7996_mcu_add_bss_info(link->phy, vif, link_conf,
823 &link->mt76, &link->msta_link,
824 true);
825 mt7996_mcu_add_sta(dev, link_conf, NULL, link, NULL,
826 CONN_STATE_PORT_SECURE,
827 !!(changed & BSS_CHANGED_BSSID));
828 }
829 }
830
831 mutex_unlock(&dev->mt76.mutex);
832 }
833
834 static void
mt7996_link_info_changed(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_bss_conf * info,u64 changed)835 mt7996_link_info_changed(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
836 struct ieee80211_bss_conf *info, u64 changed)
837 {
838 struct mt7996_dev *dev = mt7996_hw_dev(hw);
839 struct mt7996_vif_link *link;
840 struct mt7996_phy *phy;
841 struct mt76_phy *mphy;
842
843 mutex_lock(&dev->mt76.mutex);
844
845 link = mt7996_vif_conf_link(dev, vif, info);
846 if (!link)
847 goto out;
848
849 mphy = mt76_vif_link_phy(&link->mt76);
850 if (!mphy)
851 goto out;
852
853 phy = mphy->priv;
854
855 /* station mode uses BSSID to map the wlan entry to a peer,
856 * and then peer references bss_info_rfch to set bandwidth cap.
857 */
858 if ((changed & BSS_CHANGED_BSSID && !is_zero_ether_addr(info->bssid)) ||
859 (changed & BSS_CHANGED_BEACON_ENABLED && info->enable_beacon)) {
860 mt7996_mcu_add_bss_info(phy, vif, info, &link->mt76,
861 &link->msta_link, true);
862 mt7996_mcu_add_sta(dev, info, NULL, link, NULL,
863 CONN_STATE_PORT_SECURE,
864 !!(changed & BSS_CHANGED_BSSID));
865 }
866
867 if (changed & BSS_CHANGED_ERP_SLOT) {
868 int slottime = info->use_short_slot ? 9 : 20;
869
870 if (slottime != phy->slottime) {
871 phy->slottime = slottime;
872 mt7996_mcu_set_timing(phy, vif, info);
873 }
874 }
875
876 if (changed & BSS_CHANGED_MCAST_RATE)
877 link->mt76.mcast_rates_idx =
878 mt7996_get_rates_table(phy, info, false, true);
879
880 if (changed & BSS_CHANGED_BASIC_RATES)
881 link->mt76.basic_rates_idx =
882 mt7996_get_rates_table(phy, info, false, false);
883
884 /* ensure that enable txcmd_mode after bss_info */
885 if (changed & (BSS_CHANGED_QOS | BSS_CHANGED_BEACON_ENABLED))
886 mt7996_mcu_set_tx(dev, vif, info);
887
888 if (changed & BSS_CHANGED_HE_OBSS_PD)
889 mt7996_mcu_add_obss_spr(phy, link, &info->he_obss_pd);
890
891 if (changed & BSS_CHANGED_HE_BSS_COLOR) {
892 if ((vif->type == NL80211_IFTYPE_AP &&
893 link->mt76.omac_idx <= HW_BSSID_MAX) ||
894 vif->type == NL80211_IFTYPE_STATION)
895 mt7996_mcu_update_bss_color(dev, &link->mt76,
896 &info->he_bss_color);
897 }
898
899 if (changed & (BSS_CHANGED_BEACON |
900 BSS_CHANGED_BEACON_ENABLED)) {
901 link->mt76.beacon_rates_idx =
902 mt7996_get_rates_table(phy, info, true, false);
903
904 mt7996_mcu_add_beacon(hw, vif, info, info->enable_beacon);
905 }
906
907 if (changed & (BSS_CHANGED_UNSOL_BCAST_PROBE_RESP |
908 BSS_CHANGED_FILS_DISCOVERY))
909 mt7996_mcu_beacon_inband_discov(dev, info, link, changed);
910
911 if (changed & BSS_CHANGED_MU_GROUPS)
912 mt7996_update_mu_group(hw, link, info);
913
914 if (changed & BSS_CHANGED_TXPOWER &&
915 info->txpower != phy->txpower) {
916 phy->txpower = info->txpower;
917 mt7996_mcu_set_txpower_sku(phy);
918 }
919
920 out:
921 mutex_unlock(&dev->mt76.mutex);
922 }
923
924 static void
mt7996_channel_switch_beacon(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct cfg80211_chan_def * chandef)925 mt7996_channel_switch_beacon(struct ieee80211_hw *hw,
926 struct ieee80211_vif *vif,
927 struct cfg80211_chan_def *chandef)
928 {
929 struct mt7996_dev *dev = mt7996_hw_dev(hw);
930
931 mutex_lock(&dev->mt76.mutex);
932 mt7996_mcu_add_beacon(hw, vif, &vif->bss_conf, vif->bss_conf.enable_beacon);
933 mutex_unlock(&dev->mt76.mutex);
934 }
935
936 static int
mt7996_mac_sta_init_link(struct mt7996_dev * dev,struct ieee80211_bss_conf * link_conf,struct ieee80211_link_sta * link_sta,struct mt7996_vif_link * link,unsigned int link_id)937 mt7996_mac_sta_init_link(struct mt7996_dev *dev,
938 struct ieee80211_bss_conf *link_conf,
939 struct ieee80211_link_sta *link_sta,
940 struct mt7996_vif_link *link, unsigned int link_id)
941 {
942 struct ieee80211_sta *sta = link_sta->sta;
943 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
944 struct mt7996_phy *phy = link->phy;
945 struct mt7996_sta_link *msta_link;
946 int idx;
947
948 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7996_WTBL_STA);
949 if (idx < 0)
950 return -ENOSPC;
951
952 if (msta->deflink_id == IEEE80211_LINK_UNSPECIFIED) {
953 int i;
954
955 msta_link = &msta->deflink;
956 msta->deflink_id = link_id;
957 msta->seclink_id = msta->deflink_id;
958
959 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) {
960 struct mt76_txq *mtxq;
961
962 if (!sta->txq[i])
963 continue;
964
965 mtxq = (struct mt76_txq *)sta->txq[i]->drv_priv;
966 mtxq->wcid = idx;
967 }
968 } else {
969 msta_link = kzalloc_obj(*msta_link);
970 if (!msta_link)
971 return -ENOMEM;
972
973 if (msta->seclink_id == msta->deflink_id &&
974 (sta->valid_links & ~BIT(msta->deflink_id)))
975 msta->seclink_id = __ffs(sta->valid_links &
976 ~BIT(msta->deflink_id));
977 }
978
979 INIT_LIST_HEAD(&msta_link->rc_list);
980 INIT_LIST_HEAD(&msta_link->wcid.poll_list);
981 msta_link->sta = msta;
982 msta_link->wcid.sta = 1;
983 msta_link->wcid.idx = idx;
984 msta_link->wcid.link_id = link_id;
985 msta_link->wcid.link_valid = !!sta->valid_links;
986 msta_link->wcid.def_wcid = &msta->deflink.wcid;
987
988 ewma_avg_signal_init(&msta_link->avg_ack_signal);
989 ewma_signal_init(&msta_link->wcid.rssi);
990
991 rcu_assign_pointer(msta->link[link_id], msta_link);
992
993 mt7996_mac_wtbl_update(dev, idx, MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
994 mt7996_mcu_add_sta(dev, link_conf, link_sta, link, msta_link,
995 CONN_STATE_DISCONNECT, true);
996
997 rcu_assign_pointer(dev->mt76.wcid[idx], &msta_link->wcid);
998 mt76_wcid_init(&msta_link->wcid, phy->mt76->band_idx);
999
1000 return 0;
1001 }
1002
mt7996_mac_sta_deinit_link(struct mt7996_dev * dev,struct mt7996_sta_link * msta_link)1003 void mt7996_mac_sta_deinit_link(struct mt7996_dev *dev,
1004 struct mt7996_sta_link *msta_link)
1005 {
1006 spin_lock_bh(&dev->mt76.sta_poll_lock);
1007 if (!list_empty(&msta_link->wcid.poll_list))
1008 list_del_init(&msta_link->wcid.poll_list);
1009 if (!list_empty(&msta_link->rc_list))
1010 list_del_init(&msta_link->rc_list);
1011 spin_unlock_bh(&dev->mt76.sta_poll_lock);
1012
1013 mt76_wcid_cleanup(&dev->mt76, &msta_link->wcid);
1014 mt76_wcid_mask_clear(dev->mt76.wcid_mask, msta_link->wcid.idx);
1015 }
1016
1017 static void
mt7996_mac_sta_remove_links(struct mt7996_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta,unsigned long links)1018 mt7996_mac_sta_remove_links(struct mt7996_dev *dev, struct ieee80211_vif *vif,
1019 struct ieee80211_sta *sta, unsigned long links)
1020 {
1021 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1022 struct mt76_dev *mdev = &dev->mt76;
1023 unsigned int link_id;
1024
1025 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) {
1026 struct mt7996_sta_link *msta_link = NULL;
1027 struct mt7996_vif_link *link;
1028 struct mt76_phy *mphy;
1029
1030 msta_link = rcu_replace_pointer(msta->link[link_id], msta_link,
1031 lockdep_is_held(&mdev->mutex));
1032 if (!msta_link)
1033 continue;
1034
1035 mt7996_mac_wtbl_update(dev, msta_link->wcid.idx,
1036 MT_WTBL_UPDATE_ADM_COUNT_CLEAR);
1037
1038 mt7996_mac_sta_deinit_link(dev, msta_link);
1039 link = mt7996_vif_link(dev, vif, link_id);
1040 if (!link)
1041 continue;
1042
1043 mphy = mt76_vif_link_phy(&link->mt76);
1044 if (!mphy)
1045 continue;
1046
1047 mphy->num_sta--;
1048 if (msta->deflink_id == link_id) {
1049 msta->deflink_id = IEEE80211_LINK_UNSPECIFIED;
1050 continue;
1051 } else if (msta->seclink_id == link_id) {
1052 msta->seclink_id = IEEE80211_LINK_UNSPECIFIED;
1053 }
1054
1055 kfree_rcu(msta_link, rcu_head);
1056 }
1057 }
1058
1059 static int
mt7996_mac_sta_add_links(struct mt7996_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta,unsigned long new_links)1060 mt7996_mac_sta_add_links(struct mt7996_dev *dev, struct ieee80211_vif *vif,
1061 struct ieee80211_sta *sta, unsigned long new_links)
1062 {
1063 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1064 unsigned int link_id;
1065 int err = 0;
1066
1067 for_each_set_bit(link_id, &new_links, IEEE80211_MLD_MAX_NUM_LINKS) {
1068 struct ieee80211_bss_conf *link_conf;
1069 struct ieee80211_link_sta *link_sta;
1070 struct mt7996_vif_link *link;
1071 struct mt76_phy *mphy;
1072
1073 if (rcu_access_pointer(msta->link[link_id]))
1074 continue;
1075
1076 link_conf = link_conf_dereference_protected(vif, link_id);
1077 if (!link_conf) {
1078 err = -EINVAL;
1079 goto error_unlink;
1080 }
1081
1082 link = mt7996_vif_link(dev, vif, link_id);
1083 if (!link) {
1084 err = -EINVAL;
1085 goto error_unlink;
1086 }
1087
1088 link_sta = link_sta_dereference_protected(sta, link_id);
1089 if (!link_sta) {
1090 err = -EINVAL;
1091 goto error_unlink;
1092 }
1093
1094 mphy = mt76_vif_link_phy(&link->mt76);
1095 if (!mphy) {
1096 err = -EINVAL;
1097 goto error_unlink;
1098 }
1099
1100 err = mt7996_mac_sta_init_link(dev, link_conf, link_sta, link,
1101 link_id);
1102 if (err)
1103 goto error_unlink;
1104
1105 mphy->num_sta++;
1106 }
1107
1108 return 0;
1109
1110 error_unlink:
1111 mt7996_mac_sta_remove_links(dev, vif, sta, new_links);
1112
1113 return err;
1114 }
1115
1116 static int
mt7996_mac_sta_change_links(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,u16 old_links,u16 new_links)1117 mt7996_mac_sta_change_links(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1118 struct ieee80211_sta *sta, u16 old_links,
1119 u16 new_links)
1120 {
1121 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1122 unsigned long add = new_links & ~old_links;
1123 unsigned long rem = old_links & ~new_links;
1124 int ret;
1125
1126 mutex_lock(&dev->mt76.mutex);
1127
1128 mt7996_mac_sta_remove_links(dev, vif, sta, rem);
1129 ret = mt7996_mac_sta_add_links(dev, vif, sta, add);
1130
1131 mutex_unlock(&dev->mt76.mutex);
1132
1133 return ret;
1134 }
1135
1136 static int
mt7996_mac_sta_add(struct mt7996_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1137 mt7996_mac_sta_add(struct mt7996_dev *dev, struct ieee80211_vif *vif,
1138 struct ieee80211_sta *sta)
1139 {
1140 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1141 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
1142 unsigned long links = sta->valid_links ? sta->valid_links : BIT(0);
1143 int err;
1144
1145 mutex_lock(&dev->mt76.mutex);
1146
1147 msta->deflink_id = IEEE80211_LINK_UNSPECIFIED;
1148 msta->seclink_id = IEEE80211_LINK_UNSPECIFIED;
1149 msta->vif = mvif;
1150 err = mt7996_mac_sta_add_links(dev, vif, sta, links);
1151
1152 mutex_unlock(&dev->mt76.mutex);
1153
1154 return err;
1155 }
1156
1157 static int
mt7996_mac_sta_event(struct mt7996_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta,enum mt76_sta_event ev)1158 mt7996_mac_sta_event(struct mt7996_dev *dev, struct ieee80211_vif *vif,
1159 struct ieee80211_sta *sta, enum mt76_sta_event ev)
1160 {
1161 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1162 unsigned long links = sta->valid_links;
1163 struct ieee80211_link_sta *link_sta;
1164 unsigned int link_id;
1165 int err = 0;
1166
1167 mutex_lock(&dev->mt76.mutex);
1168
1169 for_each_sta_active_link(vif, sta, link_sta, link_id) {
1170 struct ieee80211_bss_conf *link_conf;
1171 struct mt7996_sta_link *msta_link;
1172 struct mt7996_vif_link *link;
1173 int i;
1174
1175 link_conf = link_conf_dereference_protected(vif, link_id);
1176 if (!link_conf)
1177 continue;
1178
1179 link = mt7996_vif_link(dev, vif, link_id);
1180 if (!link)
1181 continue;
1182
1183 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
1184 if (!msta_link)
1185 continue;
1186
1187 switch (ev) {
1188 case MT76_STA_EVENT_ASSOC:
1189 err = mt7996_mcu_add_sta(dev, link_conf, link_sta,
1190 link, msta_link,
1191 CONN_STATE_CONNECT, true);
1192 if (err)
1193 goto unlock;
1194
1195 err = mt7996_mcu_add_rate_ctrl(dev, msta_link->sta, vif,
1196 link_id, false);
1197 if (err)
1198 goto unlock;
1199
1200 msta_link->wcid.tx_info |= MT_WCID_TX_INFO_SET;
1201 break;
1202 case MT76_STA_EVENT_AUTHORIZE:
1203 err = mt7996_mcu_add_sta(dev, link_conf, link_sta,
1204 link, msta_link,
1205 CONN_STATE_PORT_SECURE, false);
1206 if (err)
1207 goto unlock;
1208 break;
1209 case MT76_STA_EVENT_DISASSOC:
1210 for (i = 0; i < ARRAY_SIZE(msta_link->twt.flow); i++)
1211 mt7996_mac_twt_teardown_flow(dev, link,
1212 msta_link, i);
1213
1214 if (!sta->mlo)
1215 mt7996_mcu_add_sta(dev, link_conf, link_sta,
1216 link, msta_link,
1217 CONN_STATE_DISCONNECT, false);
1218 else if (sta->mlo && links == BIT(link_id)) /* last link */
1219 mt7996_mcu_teardown_mld_sta(dev, link,
1220 msta_link);
1221 msta_link->wcid.sta_disabled = 1;
1222 msta_link->wcid.sta = 0;
1223 links = links & ~BIT(link_id);
1224 break;
1225 }
1226 }
1227 unlock:
1228 mutex_unlock(&dev->mt76.mutex);
1229
1230 return err;
1231 }
1232
1233 static void
mt7996_mac_sta_remove(struct mt7996_dev * dev,struct ieee80211_vif * vif,struct ieee80211_sta * sta)1234 mt7996_mac_sta_remove(struct mt7996_dev *dev, struct ieee80211_vif *vif,
1235 struct ieee80211_sta *sta)
1236 {
1237 unsigned long links = sta->valid_links ? sta->valid_links : BIT(0);
1238
1239 mutex_lock(&dev->mt76.mutex);
1240 mt7996_mac_sta_remove_links(dev, vif, sta, links);
1241 mutex_unlock(&dev->mt76.mutex);
1242 }
1243
1244 static void
mt7996_set_active_links(struct ieee80211_vif * vif)1245 mt7996_set_active_links(struct ieee80211_vif *vif)
1246 {
1247 u16 active_links;
1248
1249 if (vif->type != NL80211_IFTYPE_STATION)
1250 return;
1251
1252 if (!ieee80211_vif_is_mld(vif))
1253 return;
1254
1255 active_links = mt76_select_links(vif, MT7996_MAX_RADIOS);
1256 if (hweight16(active_links) < 2)
1257 return;
1258
1259 ieee80211_set_active_links_async(vif, active_links);
1260 }
1261
1262 static int
mt7996_sta_state(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,enum ieee80211_sta_state old_state,enum ieee80211_sta_state new_state)1263 mt7996_sta_state(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1264 struct ieee80211_sta *sta, enum ieee80211_sta_state old_state,
1265 enum ieee80211_sta_state new_state)
1266 {
1267 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1268 enum mt76_sta_event ev;
1269
1270 if (old_state == IEEE80211_STA_NOTEXIST &&
1271 new_state == IEEE80211_STA_NONE)
1272 return mt7996_mac_sta_add(dev, vif, sta);
1273
1274 if (old_state == IEEE80211_STA_NONE &&
1275 new_state == IEEE80211_STA_NOTEXIST)
1276 mt7996_mac_sta_remove(dev, vif, sta);
1277
1278 if (old_state == IEEE80211_STA_AUTH &&
1279 new_state == IEEE80211_STA_ASSOC) {
1280 mt7996_set_active_links(vif);
1281 ev = MT76_STA_EVENT_ASSOC;
1282 } else if (old_state == IEEE80211_STA_ASSOC &&
1283 new_state == IEEE80211_STA_AUTHORIZED) {
1284 ev = MT76_STA_EVENT_AUTHORIZE;
1285 } else if (old_state == IEEE80211_STA_ASSOC &&
1286 new_state == IEEE80211_STA_AUTH) {
1287 ev = MT76_STA_EVENT_DISASSOC;
1288 } else {
1289 return 0;
1290 }
1291
1292 return mt7996_mac_sta_event(dev, vif, sta, ev);
1293 }
1294
mt7996_tx(struct ieee80211_hw * hw,struct ieee80211_tx_control * control,struct sk_buff * skb)1295 static void mt7996_tx(struct ieee80211_hw *hw,
1296 struct ieee80211_tx_control *control,
1297 struct sk_buff *skb)
1298 {
1299 struct ieee80211_hdr *hdr = (struct ieee80211_hdr *)skb->data;
1300 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1301 struct ieee80211_sta *sta = control->sta;
1302 struct mt7996_sta *msta = sta ? (void *)sta->drv_priv : NULL;
1303 struct mt76_phy *mphy = hw->priv;
1304 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
1305 struct ieee80211_vif *vif = info->control.vif;
1306 struct mt7996_vif *mvif = vif ? (void *)vif->drv_priv : NULL;
1307 struct mt76_wcid *wcid = &dev->mt76.global_wcid;
1308 u8 link_id = u32_get_bits(info->control.flags,
1309 IEEE80211_TX_CTRL_MLO_LINK);
1310
1311 rcu_read_lock();
1312
1313 /* Use primary link_id if the value from mac80211 is set to
1314 * IEEE80211_LINK_UNSPECIFIED.
1315 */
1316 if (link_id == IEEE80211_LINK_UNSPECIFIED) {
1317 if (msta)
1318 link_id = msta->deflink_id;
1319 else if (mvif)
1320 link_id = mvif->mt76.deflink_id;
1321 }
1322
1323 if (vif && ieee80211_vif_is_mld(vif)) {
1324 struct ieee80211_bss_conf *link_conf;
1325
1326 if (msta) {
1327 struct ieee80211_link_sta *link_sta;
1328
1329 link_sta = rcu_dereference(sta->link[link_id]);
1330 if (!link_sta)
1331 link_sta = rcu_dereference(sta->link[msta->deflink_id]);
1332
1333 if (link_sta) {
1334 memcpy(hdr->addr1, link_sta->addr, ETH_ALEN);
1335 if (ether_addr_equal(sta->addr, hdr->addr3))
1336 memcpy(hdr->addr3, link_sta->addr, ETH_ALEN);
1337 }
1338 }
1339
1340 link_conf = rcu_dereference(vif->link_conf[link_id]);
1341 if (link_conf) {
1342 memcpy(hdr->addr2, link_conf->addr, ETH_ALEN);
1343 if (ether_addr_equal(vif->addr, hdr->addr3))
1344 memcpy(hdr->addr3, link_conf->addr, ETH_ALEN);
1345 }
1346 }
1347
1348 if (mvif) {
1349 struct mt76_vif_link *mlink;
1350
1351 mlink = rcu_dereference(mvif->mt76.link[link_id]);
1352 if (mlink && mlink->wcid)
1353 wcid = mlink->wcid;
1354
1355 if (mvif->mt76.roc_phy &&
1356 (info->flags & IEEE80211_TX_CTL_TX_OFFCHAN)) {
1357 mphy = mvif->mt76.roc_phy;
1358 if (mphy->roc_link)
1359 wcid = mphy->roc_link->wcid;
1360 } else if (mlink) {
1361 mphy = mt76_vif_link_phy(mlink);
1362 }
1363 }
1364
1365 if (!mphy) {
1366 ieee80211_free_txskb(hw, skb);
1367 goto unlock;
1368 }
1369
1370 if (msta) {
1371 struct mt7996_sta_link *msta_link;
1372
1373 msta_link = rcu_dereference(msta->link[link_id]);
1374 if (msta_link)
1375 wcid = &msta_link->wcid;
1376 }
1377 mt76_tx(mphy, control->sta, wcid, skb);
1378 unlock:
1379 rcu_read_unlock();
1380 }
1381
mt7996_set_rts_threshold(struct ieee80211_hw * hw,int radio_idx,u32 val)1382 static int mt7996_set_rts_threshold(struct ieee80211_hw *hw, int radio_idx,
1383 u32 val)
1384 {
1385 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1386 int i, ret = 0;
1387
1388 mutex_lock(&dev->mt76.mutex);
1389
1390 for (i = 0; i < hw->wiphy->n_radio; i++) {
1391 struct mt7996_phy *phy = dev->radio_phy[i];
1392
1393 ret = mt7996_mcu_set_rts_thresh(phy, val);
1394 if (ret)
1395 break;
1396 }
1397
1398 mutex_unlock(&dev->mt76.mutex);
1399
1400 return ret;
1401 }
1402
1403 static int
mt7996_ampdu_action(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_ampdu_params * params)1404 mt7996_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1405 struct ieee80211_ampdu_params *params)
1406 {
1407 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1408 struct ieee80211_sta *sta = params->sta;
1409 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1410 struct ieee80211_txq *txq = sta->txq[params->tid];
1411 u16 tid = params->tid;
1412 u16 ssn = params->ssn;
1413 struct mt76_txq *mtxq;
1414 int ret = 0;
1415
1416 if (!txq)
1417 return -EINVAL;
1418
1419 mtxq = (struct mt76_txq *)txq->drv_priv;
1420
1421 mutex_lock(&dev->mt76.mutex);
1422
1423 switch (params->action) {
1424 case IEEE80211_AMPDU_RX_START:
1425 /* Since packets belonging to the same TID can be split over
1426 * multiple links, store the AMPDU state for reordering in the
1427 * primary link
1428 */
1429 mt76_rx_aggr_start(&dev->mt76, &msta->deflink.wcid, tid,
1430 ssn, params->buf_size);
1431 ret = mt7996_mcu_add_rx_ba(dev, params, vif, true);
1432 break;
1433 case IEEE80211_AMPDU_RX_STOP:
1434 mt76_rx_aggr_stop(&dev->mt76, &msta->deflink.wcid, tid);
1435 ret = mt7996_mcu_add_rx_ba(dev, params, vif, false);
1436 break;
1437 case IEEE80211_AMPDU_TX_OPERATIONAL:
1438 mtxq->aggr = true;
1439 mtxq->send_bar = false;
1440 ret = mt7996_mcu_add_tx_ba(dev, params, vif, true);
1441 break;
1442 case IEEE80211_AMPDU_TX_STOP_FLUSH:
1443 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT:
1444 mtxq->aggr = false;
1445 clear_bit(tid, &msta->deflink.wcid.ampdu_state);
1446 ret = mt7996_mcu_add_tx_ba(dev, params, vif, false);
1447 break;
1448 case IEEE80211_AMPDU_TX_START:
1449 set_bit(tid, &msta->deflink.wcid.ampdu_state);
1450 ret = IEEE80211_AMPDU_TX_START_IMMEDIATE;
1451 break;
1452 case IEEE80211_AMPDU_TX_STOP_CONT:
1453 mtxq->aggr = false;
1454 clear_bit(tid, &msta->deflink.wcid.ampdu_state);
1455 ret = mt7996_mcu_add_tx_ba(dev, params, vif, false);
1456 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid);
1457 break;
1458 }
1459
1460 mutex_unlock(&dev->mt76.mutex);
1461
1462 return ret;
1463 }
1464
1465 static int
mt7996_get_stats(struct ieee80211_hw * hw,struct ieee80211_low_level_stats * stats)1466 mt7996_get_stats(struct ieee80211_hw *hw,
1467 struct ieee80211_low_level_stats *stats)
1468 {
1469 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1470 int i;
1471
1472 mutex_lock(&dev->mt76.mutex);
1473
1474 memset(stats, 0, sizeof(*stats));
1475 for (i = 0; i < hw->wiphy->n_radio; i++) {
1476 struct mt7996_phy *phy = dev->radio_phy[i];
1477 struct mt76_mib_stats *mib = &phy->mib;
1478
1479 stats->dot11RTSSuccessCount += mib->rts_cnt;
1480 stats->dot11RTSFailureCount += mib->rts_retries_cnt;
1481 stats->dot11FCSErrorCount += mib->fcs_err_cnt;
1482 stats->dot11ACKFailureCount += mib->ack_fail_cnt;
1483 }
1484
1485 mutex_unlock(&dev->mt76.mutex);
1486
1487 return 0;
1488 }
1489
__mt7996_get_tsf(struct ieee80211_hw * hw,struct mt7996_vif_link * link)1490 u64 __mt7996_get_tsf(struct ieee80211_hw *hw, struct mt7996_vif_link *link)
1491 {
1492 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1493 struct mt7996_phy *phy = link->phy;
1494 union {
1495 u64 t64;
1496 u32 t32[2];
1497 } tsf;
1498 u16 n;
1499
1500 if (!phy)
1501 return 0;
1502
1503 lockdep_assert_held(&dev->mt76.mutex);
1504
1505 n = link->mt76.omac_idx > HW_BSSID_MAX ? HW_BSSID_0
1506 : link->mt76.omac_idx;
1507 /* TSF software read */
1508 mt76_rmw(dev, MT_LPON_TCR(phy->mt76->band_idx, n), MT_LPON_TCR_SW_MODE,
1509 MT_LPON_TCR_SW_READ);
1510 tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0(phy->mt76->band_idx));
1511 tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1(phy->mt76->band_idx));
1512
1513 return tsf.t64;
1514 }
1515
1516 static u64
mt7996_get_tsf(struct ieee80211_hw * hw,struct ieee80211_vif * vif)1517 mt7996_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif)
1518 {
1519 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
1520 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1521 u64 ret;
1522
1523 mutex_lock(&dev->mt76.mutex);
1524 ret = __mt7996_get_tsf(hw, &mvif->deflink);
1525 mutex_unlock(&dev->mt76.mutex);
1526
1527 return ret;
1528 }
1529
1530 static void
mt7996_set_tsf(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u64 timestamp)1531 mt7996_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1532 u64 timestamp)
1533 {
1534 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
1535 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1536 struct mt7996_vif_link *link;
1537 struct mt7996_phy *phy;
1538 union {
1539 u64 t64;
1540 u32 t32[2];
1541 } tsf = { .t64 = timestamp, };
1542 u16 n;
1543
1544 mutex_lock(&dev->mt76.mutex);
1545
1546 link = mt7996_vif_link(dev, vif, mvif->mt76.deflink_id);
1547 if (!link)
1548 goto unlock;
1549
1550 n = link->mt76.omac_idx > HW_BSSID_MAX ? HW_BSSID_0
1551 : link->mt76.omac_idx;
1552 phy = link->phy;
1553 if (!phy)
1554 goto unlock;
1555
1556 mt76_wr(dev, MT_LPON_UTTR0(phy->mt76->band_idx), tsf.t32[0]);
1557 mt76_wr(dev, MT_LPON_UTTR1(phy->mt76->band_idx), tsf.t32[1]);
1558 /* TSF software overwrite */
1559 mt76_rmw(dev, MT_LPON_TCR(phy->mt76->band_idx, n), MT_LPON_TCR_SW_MODE,
1560 MT_LPON_TCR_SW_WRITE);
1561
1562 unlock:
1563 mutex_unlock(&dev->mt76.mutex);
1564 }
1565
1566 static void
mt7996_offset_tsf(struct ieee80211_hw * hw,struct ieee80211_vif * vif,s64 timestamp)1567 mt7996_offset_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1568 s64 timestamp)
1569 {
1570 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
1571 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1572 struct mt7996_vif_link *link;
1573 struct mt7996_phy *phy;
1574 union {
1575 u64 t64;
1576 u32 t32[2];
1577 } tsf = { .t64 = timestamp, };
1578 u16 n;
1579
1580 mutex_lock(&dev->mt76.mutex);
1581
1582 link = mt7996_vif_link(dev, vif, mvif->mt76.deflink_id);
1583 if (!link)
1584 goto unlock;
1585
1586 phy = link->phy;
1587 if (!phy)
1588 goto unlock;
1589
1590 n = link->mt76.omac_idx > HW_BSSID_MAX ? HW_BSSID_0
1591 : link->mt76.omac_idx;
1592 mt76_wr(dev, MT_LPON_UTTR0(phy->mt76->band_idx), tsf.t32[0]);
1593 mt76_wr(dev, MT_LPON_UTTR1(phy->mt76->band_idx), tsf.t32[1]);
1594 /* TSF software adjust*/
1595 mt76_rmw(dev, MT_LPON_TCR(phy->mt76->band_idx, n), MT_LPON_TCR_SW_MODE,
1596 MT_LPON_TCR_SW_ADJUST);
1597
1598 unlock:
1599 mutex_unlock(&dev->mt76.mutex);
1600 }
1601
1602 static void
mt7996_set_coverage_class(struct ieee80211_hw * hw,int radio_idx,s16 coverage_class)1603 mt7996_set_coverage_class(struct ieee80211_hw *hw, int radio_idx,
1604 s16 coverage_class)
1605 {
1606 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1607 struct mt7996_phy *phy;
1608
1609 mutex_lock(&dev->mt76.mutex);
1610 mt7996_for_each_phy(dev, phy) {
1611 phy->coverage_class = max_t(s16, coverage_class, 0);
1612 mt7996_mac_set_coverage_class(phy);
1613 }
1614 mutex_unlock(&dev->mt76.mutex);
1615 }
1616
1617 static int
mt7996_set_antenna(struct ieee80211_hw * hw,int radio_idx,u32 tx_ant,u32 rx_ant)1618 mt7996_set_antenna(struct ieee80211_hw *hw, int radio_idx,
1619 u32 tx_ant, u32 rx_ant)
1620 {
1621 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1622 int i;
1623
1624 if (tx_ant != rx_ant)
1625 return -EINVAL;
1626
1627 for (i = 0; i < hw->wiphy->n_radio; i++) {
1628 struct mt7996_phy *phy = dev->radio_phy[i];
1629
1630 if (!(tx_ant & phy->orig_chainmask))
1631 return -EINVAL;
1632 }
1633
1634 mutex_lock(&dev->mt76.mutex);
1635
1636 for (i = 0; i < hw->wiphy->n_radio; i++) {
1637 struct mt7996_phy *phy = dev->radio_phy[i];
1638 u8 band_idx = phy->mt76->band_idx;
1639 u8 shift = dev->chainshift[band_idx];
1640
1641 phy->mt76->chainmask = tx_ant & phy->orig_chainmask;
1642 phy->mt76->antenna_mask = (phy->mt76->chainmask >> shift) &
1643 phy->orig_antenna_mask;
1644
1645 mt76_set_stream_caps(phy->mt76, true);
1646 mt7996_set_stream_vht_txbf_caps(phy);
1647 mt7996_set_stream_he_eht_caps(phy);
1648 mt7996_mcu_set_txpower_sku(phy);
1649 }
1650
1651 mutex_unlock(&dev->mt76.mutex);
1652
1653 return 0;
1654 }
1655
mt7996_sta_statistics(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct station_info * sinfo)1656 static void mt7996_sta_statistics(struct ieee80211_hw *hw,
1657 struct ieee80211_vif *vif,
1658 struct ieee80211_sta *sta,
1659 struct station_info *sinfo)
1660 {
1661 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1662 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1663 struct mt7996_sta_link *msta_link = &msta->deflink;
1664 struct rate_info *txrate = &msta_link->wcid.rate;
1665
1666 if (txrate->legacy || txrate->flags) {
1667 if (txrate->legacy) {
1668 sinfo->txrate.legacy = txrate->legacy;
1669 } else {
1670 sinfo->txrate.mcs = txrate->mcs;
1671 sinfo->txrate.nss = txrate->nss;
1672 sinfo->txrate.bw = txrate->bw;
1673 sinfo->txrate.he_gi = txrate->he_gi;
1674 sinfo->txrate.he_dcm = txrate->he_dcm;
1675 sinfo->txrate.he_ru_alloc = txrate->he_ru_alloc;
1676 sinfo->txrate.eht_gi = txrate->eht_gi;
1677 }
1678 sinfo->txrate.flags = txrate->flags;
1679 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
1680 }
1681 sinfo->txrate.flags = txrate->flags;
1682 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE);
1683
1684 sinfo->tx_failed = msta_link->wcid.stats.tx_failed;
1685 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED);
1686
1687 sinfo->tx_retries = msta_link->wcid.stats.tx_retries;
1688 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES);
1689
1690 sinfo->ack_signal = (s8)msta_link->ack_signal;
1691 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL);
1692
1693 sinfo->avg_ack_signal =
1694 -(s8)ewma_avg_signal_read(&msta_link->avg_ack_signal);
1695 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG);
1696
1697 if (mtk_wed_device_active(&dev->mt76.mmio.wed)) {
1698 sinfo->tx_bytes = msta_link->wcid.stats.tx_bytes;
1699 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BYTES64);
1700
1701 sinfo->rx_bytes = msta_link->wcid.stats.rx_bytes;
1702 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BYTES64);
1703
1704 sinfo->tx_packets = msta_link->wcid.stats.tx_packets;
1705 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_PACKETS);
1706
1707 sinfo->rx_packets = msta_link->wcid.stats.rx_packets;
1708 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_PACKETS);
1709 }
1710 }
1711
mt7996_link_rate_ctrl_update(void * data,struct mt7996_sta_link * msta_link)1712 static void mt7996_link_rate_ctrl_update(void *data,
1713 struct mt7996_sta_link *msta_link)
1714 {
1715 struct mt7996_sta *msta = msta_link->sta;
1716 struct mt7996_dev *dev = msta->vif->deflink.phy->dev;
1717 u32 *changed = data;
1718
1719 spin_lock_bh(&dev->mt76.sta_poll_lock);
1720
1721 msta_link->changed |= *changed;
1722 if (list_empty(&msta_link->rc_list))
1723 list_add_tail(&msta_link->rc_list, &dev->sta_rc_list);
1724
1725 spin_unlock_bh(&dev->mt76.sta_poll_lock);
1726 }
1727
mt7996_link_sta_rc_update(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_link_sta * link_sta,u32 changed)1728 static void mt7996_link_sta_rc_update(struct ieee80211_hw *hw,
1729 struct ieee80211_vif *vif,
1730 struct ieee80211_link_sta *link_sta,
1731 u32 changed)
1732 {
1733 struct ieee80211_sta *sta = link_sta->sta;
1734 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1735 struct mt7996_sta_link *msta_link;
1736
1737 rcu_read_lock();
1738
1739 msta_link = rcu_dereference(msta->link[link_sta->link_id]);
1740 if (msta_link) {
1741 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1742
1743 mt7996_link_rate_ctrl_update(&changed, msta_link);
1744 ieee80211_queue_work(hw, &dev->rc_work);
1745 }
1746
1747 rcu_read_unlock();
1748 }
1749
mt7996_sta_rate_ctrl_update(void * data,struct ieee80211_sta * sta)1750 static void mt7996_sta_rate_ctrl_update(void *data, struct ieee80211_sta *sta)
1751 {
1752 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1753 struct mt7996_sta_link *msta_link;
1754 u32 *changed = data;
1755
1756 msta_link = rcu_dereference(msta->link[msta->deflink_id]);
1757 if (msta_link)
1758 mt7996_link_rate_ctrl_update(&changed, msta_link);
1759 }
1760
1761 static int
mt7996_set_bitrate_mask(struct ieee80211_hw * hw,struct ieee80211_vif * vif,const struct cfg80211_bitrate_mask * mask)1762 mt7996_set_bitrate_mask(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
1763 const struct cfg80211_bitrate_mask *mask)
1764 {
1765 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1766 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
1767 u32 changed = IEEE80211_RC_SUPP_RATES_CHANGED;
1768
1769 mvif->deflink.bitrate_mask = *mask;
1770
1771 /* if multiple rates across different preambles are given we can
1772 * reconfigure this info with all peers using sta_rec command with
1773 * the below exception cases.
1774 * - single rate : if a rate is passed along with different preambles,
1775 * we select the highest one as fixed rate. i.e VHT MCS for VHT peers.
1776 * - multiple rates: if it's not in range format i.e 0-{7,8,9} for VHT
1777 * then multiple MCS setting (MCS 4,5,6) is not supported.
1778 */
1779 ieee80211_iterate_stations_atomic(hw, mt7996_sta_rate_ctrl_update,
1780 &changed);
1781 ieee80211_queue_work(hw, &dev->rc_work);
1782
1783 return 0;
1784 }
1785
mt7996_sta_set_4addr(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,bool enabled)1786 static void mt7996_sta_set_4addr(struct ieee80211_hw *hw,
1787 struct ieee80211_vif *vif,
1788 struct ieee80211_sta *sta,
1789 bool enabled)
1790 {
1791 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1792 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1793 struct ieee80211_link_sta *link_sta;
1794 unsigned int link_id;
1795
1796 mutex_lock(&dev->mt76.mutex);
1797
1798 for_each_sta_active_link(vif, sta, link_sta, link_id) {
1799 struct mt7996_sta_link *msta_link;
1800 struct mt7996_vif_link *link;
1801
1802 link = mt7996_vif_link(dev, vif, link_id);
1803 if (!link)
1804 continue;
1805
1806 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
1807 if (!msta_link)
1808 continue;
1809
1810 if (enabled)
1811 set_bit(MT_WCID_FLAG_4ADDR, &msta_link->wcid.flags);
1812 else
1813 clear_bit(MT_WCID_FLAG_4ADDR, &msta_link->wcid.flags);
1814
1815 if (!msta_link->wcid.sta)
1816 continue;
1817
1818 mt7996_mcu_wtbl_update_hdr_trans(dev, vif, link, msta_link);
1819 }
1820
1821 mutex_unlock(&dev->mt76.mutex);
1822 }
1823
mt7996_sta_set_decap_offload(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,bool enabled)1824 static void mt7996_sta_set_decap_offload(struct ieee80211_hw *hw,
1825 struct ieee80211_vif *vif,
1826 struct ieee80211_sta *sta,
1827 bool enabled)
1828 {
1829 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1830 struct mt7996_dev *dev = mt7996_hw_dev(hw);
1831 struct ieee80211_link_sta *link_sta;
1832 unsigned int link_id;
1833
1834 mutex_lock(&dev->mt76.mutex);
1835
1836 for_each_sta_active_link(vif, sta, link_sta, link_id) {
1837 struct mt7996_sta_link *msta_link;
1838 struct mt7996_vif_link *link;
1839
1840 link = mt7996_vif_link(dev, vif, link_id);
1841 if (!link)
1842 continue;
1843
1844 msta_link = mt76_dereference(msta->link[link_id], &dev->mt76);
1845 if (!msta_link)
1846 continue;
1847
1848 if (enabled)
1849 set_bit(MT_WCID_FLAG_HDR_TRANS,
1850 &msta_link->wcid.flags);
1851 else
1852 clear_bit(MT_WCID_FLAG_HDR_TRANS,
1853 &msta_link->wcid.flags);
1854
1855 if (!msta_link->wcid.sta)
1856 continue;
1857
1858 mt7996_mcu_wtbl_update_hdr_trans(dev, vif, link, msta_link);
1859 }
1860
1861 mutex_unlock(&dev->mt76.mutex);
1862 }
1863
1864 static const char mt7996_gstrings_stats[][ETH_GSTRING_LEN] = {
1865 "tx_ampdu_cnt",
1866 "tx_stop_q_empty_cnt",
1867 "tx_mpdu_attempts",
1868 "tx_mpdu_success",
1869 "tx_rwp_fail_cnt",
1870 "tx_rwp_need_cnt",
1871 "tx_pkt_ebf_cnt",
1872 "tx_pkt_ibf_cnt",
1873 "tx_ampdu_len:0-1",
1874 "tx_ampdu_len:2-10",
1875 "tx_ampdu_len:11-19",
1876 "tx_ampdu_len:20-28",
1877 "tx_ampdu_len:29-37",
1878 "tx_ampdu_len:38-46",
1879 "tx_ampdu_len:47-55",
1880 "tx_ampdu_len:56-79",
1881 "tx_ampdu_len:80-103",
1882 "tx_ampdu_len:104-127",
1883 "tx_ampdu_len:128-151",
1884 "tx_ampdu_len:152-175",
1885 "tx_ampdu_len:176-199",
1886 "tx_ampdu_len:200-223",
1887 "tx_ampdu_len:224-247",
1888 "ba_miss_count",
1889 "tx_beamformer_ppdu_iBF",
1890 "tx_beamformer_ppdu_eBF",
1891 "tx_beamformer_rx_feedback_all",
1892 "tx_beamformer_rx_feedback_he",
1893 "tx_beamformer_rx_feedback_vht",
1894 "tx_beamformer_rx_feedback_ht",
1895 "tx_beamformer_rx_feedback_bw", /* zero based idx: 20, 40, 80, 160 */
1896 "tx_beamformer_rx_feedback_nc",
1897 "tx_beamformer_rx_feedback_nr",
1898 "tx_beamformee_ok_feedback_pkts",
1899 "tx_beamformee_feedback_trig",
1900 "tx_mu_beamforming",
1901 "tx_mu_mpdu",
1902 "tx_mu_successful_mpdu",
1903 "tx_su_successful_mpdu",
1904 "tx_msdu_pack_1",
1905 "tx_msdu_pack_2",
1906 "tx_msdu_pack_3",
1907 "tx_msdu_pack_4",
1908 "tx_msdu_pack_5",
1909 "tx_msdu_pack_6",
1910 "tx_msdu_pack_7",
1911 "tx_msdu_pack_8",
1912
1913 /* rx counters */
1914 "rx_fifo_full_cnt",
1915 "rx_mpdu_cnt",
1916 "channel_idle_cnt",
1917 "rx_vector_mismatch_cnt",
1918 "rx_delimiter_fail_cnt",
1919 "rx_len_mismatch_cnt",
1920 "rx_ampdu_cnt",
1921 "rx_ampdu_bytes_cnt",
1922 "rx_ampdu_valid_subframe_cnt",
1923 "rx_ampdu_valid_subframe_b_cnt",
1924 "rx_pfdrop_cnt",
1925 "rx_vec_queue_overflow_drop_cnt",
1926 "rx_ba_cnt",
1927
1928 /* per vif counters */
1929 "v_tx_mode_cck",
1930 "v_tx_mode_ofdm",
1931 "v_tx_mode_ht",
1932 "v_tx_mode_ht_gf",
1933 "v_tx_mode_vht",
1934 "v_tx_mode_he_su",
1935 "v_tx_mode_he_ext_su",
1936 "v_tx_mode_he_tb",
1937 "v_tx_mode_he_mu",
1938 "v_tx_mode_eht_su",
1939 "v_tx_mode_eht_trig",
1940 "v_tx_mode_eht_mu",
1941 "v_tx_bw_20",
1942 "v_tx_bw_40",
1943 "v_tx_bw_80",
1944 "v_tx_bw_160",
1945 "v_tx_bw_320",
1946 "v_tx_mcs_0",
1947 "v_tx_mcs_1",
1948 "v_tx_mcs_2",
1949 "v_tx_mcs_3",
1950 "v_tx_mcs_4",
1951 "v_tx_mcs_5",
1952 "v_tx_mcs_6",
1953 "v_tx_mcs_7",
1954 "v_tx_mcs_8",
1955 "v_tx_mcs_9",
1956 "v_tx_mcs_10",
1957 "v_tx_mcs_11",
1958 "v_tx_mcs_12",
1959 "v_tx_mcs_13",
1960 "v_tx_nss_1",
1961 "v_tx_nss_2",
1962 "v_tx_nss_3",
1963 "v_tx_nss_4",
1964 };
1965
1966 #define MT7996_SSTATS_LEN ARRAY_SIZE(mt7996_gstrings_stats)
1967
1968 /* Ethtool related API */
1969 static
mt7996_get_et_strings(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u32 sset,u8 * data)1970 void mt7996_get_et_strings(struct ieee80211_hw *hw,
1971 struct ieee80211_vif *vif,
1972 u32 sset, u8 *data)
1973 {
1974 if (sset == ETH_SS_STATS)
1975 memcpy(data, mt7996_gstrings_stats,
1976 sizeof(mt7996_gstrings_stats));
1977 }
1978
1979 static
mt7996_get_et_sset_count(struct ieee80211_hw * hw,struct ieee80211_vif * vif,int sset)1980 int mt7996_get_et_sset_count(struct ieee80211_hw *hw,
1981 struct ieee80211_vif *vif, int sset)
1982 {
1983 if (sset == ETH_SS_STATS)
1984 return MT7996_SSTATS_LEN;
1985
1986 return 0;
1987 }
1988
mt7996_ethtool_worker(void * wi_data,struct ieee80211_sta * sta)1989 static void mt7996_ethtool_worker(void *wi_data, struct ieee80211_sta *sta)
1990 {
1991 struct mt76_ethtool_worker_info *wi = wi_data;
1992 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
1993 struct mt7996_sta_link *msta_link = &msta->deflink;
1994
1995 if (msta->vif->deflink.mt76.idx != wi->idx)
1996 return;
1997
1998 mt76_ethtool_worker(wi, &msta_link->wcid.stats, true);
1999 }
2000
2001 static
mt7996_get_et_stats(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ethtool_stats * stats,u64 * data)2002 void mt7996_get_et_stats(struct ieee80211_hw *hw,
2003 struct ieee80211_vif *vif,
2004 struct ethtool_stats *stats, u64 *data)
2005 {
2006 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2007 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
2008 struct mt7996_phy *phy = mt7996_vif_link_phy(&mvif->deflink);
2009 struct mt76_mib_stats *mib = &phy->mib;
2010 struct mt76_ethtool_worker_info wi = {
2011 .data = data,
2012 .idx = mvif->deflink.mt76.idx,
2013 };
2014 /* See mt7996_ampdu_stat_read_phy, etc */
2015 int i, ei = 0;
2016
2017 if (!phy)
2018 return;
2019
2020 mutex_lock(&dev->mt76.mutex);
2021
2022 mt7996_mac_update_stats(phy);
2023
2024 data[ei++] = mib->tx_ampdu_cnt;
2025 data[ei++] = mib->tx_stop_q_empty_cnt;
2026 data[ei++] = mib->tx_mpdu_attempts_cnt;
2027 data[ei++] = mib->tx_mpdu_success_cnt;
2028 data[ei++] = mib->tx_rwp_fail_cnt;
2029 data[ei++] = mib->tx_rwp_need_cnt;
2030 data[ei++] = mib->tx_bf_ebf_ppdu_cnt;
2031 data[ei++] = mib->tx_bf_ibf_ppdu_cnt;
2032
2033 /* Tx ampdu stat */
2034 for (i = 0; i < 15 /*ARRAY_SIZE(bound)*/; i++)
2035 data[ei++] = phy->mt76->aggr_stats[i];
2036 data[ei++] = phy->mib.ba_miss_cnt;
2037
2038 /* Tx Beamformer monitor */
2039 data[ei++] = mib->tx_bf_ibf_ppdu_cnt;
2040 data[ei++] = mib->tx_bf_ebf_ppdu_cnt;
2041
2042 /* Tx Beamformer Rx feedback monitor */
2043 data[ei++] = mib->tx_bf_rx_fb_all_cnt;
2044 data[ei++] = mib->tx_bf_rx_fb_he_cnt;
2045 data[ei++] = mib->tx_bf_rx_fb_vht_cnt;
2046 data[ei++] = mib->tx_bf_rx_fb_ht_cnt;
2047
2048 data[ei++] = mib->tx_bf_rx_fb_bw;
2049 data[ei++] = mib->tx_bf_rx_fb_nc_cnt;
2050 data[ei++] = mib->tx_bf_rx_fb_nr_cnt;
2051
2052 /* Tx Beamformee Rx NDPA & Tx feedback report */
2053 data[ei++] = mib->tx_bf_fb_cpl_cnt;
2054 data[ei++] = mib->tx_bf_fb_trig_cnt;
2055
2056 /* Tx SU & MU counters */
2057 data[ei++] = mib->tx_mu_bf_cnt;
2058 data[ei++] = mib->tx_mu_mpdu_cnt;
2059 data[ei++] = mib->tx_mu_acked_mpdu_cnt;
2060 data[ei++] = mib->tx_su_acked_mpdu_cnt;
2061
2062 /* Tx amsdu info (pack-count histogram) */
2063 for (i = 0; i < ARRAY_SIZE(mib->tx_amsdu); i++)
2064 data[ei++] = mib->tx_amsdu[i];
2065
2066 /* rx counters */
2067 data[ei++] = mib->rx_fifo_full_cnt;
2068 data[ei++] = mib->rx_mpdu_cnt;
2069 data[ei++] = mib->channel_idle_cnt;
2070 data[ei++] = mib->rx_vector_mismatch_cnt;
2071 data[ei++] = mib->rx_delimiter_fail_cnt;
2072 data[ei++] = mib->rx_len_mismatch_cnt;
2073 data[ei++] = mib->rx_ampdu_cnt;
2074 data[ei++] = mib->rx_ampdu_bytes_cnt;
2075 data[ei++] = mib->rx_ampdu_valid_subframe_cnt;
2076 data[ei++] = mib->rx_ampdu_valid_subframe_bytes_cnt;
2077 data[ei++] = mib->rx_pfdrop_cnt;
2078 data[ei++] = mib->rx_vec_queue_overflow_drop_cnt;
2079 data[ei++] = mib->rx_ba_cnt;
2080
2081 /* Add values for all stations owned by this vif */
2082 wi.initial_stat_idx = ei;
2083 ieee80211_iterate_stations_atomic(hw, mt7996_ethtool_worker, &wi);
2084
2085 mutex_unlock(&dev->mt76.mutex);
2086
2087 if (wi.sta_count == 0)
2088 return;
2089
2090 ei += wi.worker_stat_count;
2091 if (ei != MT7996_SSTATS_LEN)
2092 dev_err(dev->mt76.dev, "ei: %d MT7996_SSTATS_LEN: %d",
2093 ei, (int)MT7996_SSTATS_LEN);
2094 }
2095
2096 static void
mt7996_twt_teardown_request(struct ieee80211_hw * hw,struct ieee80211_sta * sta,u8 flowid)2097 mt7996_twt_teardown_request(struct ieee80211_hw *hw,
2098 struct ieee80211_sta *sta,
2099 u8 flowid)
2100 {
2101 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
2102 struct mt7996_sta_link *msta_link = &msta->deflink;
2103 struct mt7996_vif_link *link = &msta->vif->deflink;
2104 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2105
2106 mutex_lock(&dev->mt76.mutex);
2107 mt7996_mac_twt_teardown_flow(dev, link, msta_link, flowid);
2108 mutex_unlock(&dev->mt76.mutex);
2109 }
2110
2111 static int
mt7996_set_radar_background(struct ieee80211_hw * hw,struct cfg80211_chan_def * chandef)2112 mt7996_set_radar_background(struct ieee80211_hw *hw,
2113 struct cfg80211_chan_def *chandef)
2114 {
2115 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2116 struct mt7996_phy *phy;
2117 int ret = -EINVAL;
2118 bool running;
2119
2120 if (chandef)
2121 phy = mt7996_band_phy(dev, chandef->chan->band);
2122 else
2123 phy = dev->rdd2_phy;
2124 if (!phy)
2125 return -EINVAL;
2126
2127 mutex_lock(&dev->mt76.mutex);
2128
2129 if (dev->mt76.region == NL80211_DFS_UNSET)
2130 goto out;
2131
2132 if (dev->rdd2_phy && dev->rdd2_phy != phy) {
2133 /* rdd2 is already locked */
2134 ret = -EBUSY;
2135 goto out;
2136 }
2137
2138 /* rdd2 already configured on a radar channel */
2139 running = dev->rdd2_phy &&
2140 cfg80211_chandef_valid(&dev->rdd2_chandef) &&
2141 !!(dev->rdd2_chandef.chan->flags & IEEE80211_CHAN_RADAR);
2142
2143 if (!chandef || running ||
2144 !(chandef->chan->flags & IEEE80211_CHAN_RADAR)) {
2145 ret = mt7996_mcu_rdd_background_enable(phy, NULL);
2146 if (ret)
2147 goto out;
2148
2149 if (!running)
2150 goto update_phy;
2151 }
2152
2153 ret = mt7996_mcu_rdd_background_enable(phy, chandef);
2154 if (ret)
2155 goto out;
2156
2157 update_phy:
2158 dev->rdd2_phy = chandef ? phy : NULL;
2159 if (chandef)
2160 dev->rdd2_chandef = *chandef;
2161 out:
2162 mutex_unlock(&dev->mt76.mutex);
2163
2164 return ret;
2165 }
2166
2167 static int
mt7996_net_fill_forward_path(struct ieee80211_hw * hw,struct ieee80211_vif * vif,struct ieee80211_sta * sta,struct net_device_path_ctx * ctx,struct net_device_path * path)2168 mt7996_net_fill_forward_path(struct ieee80211_hw *hw,
2169 struct ieee80211_vif *vif,
2170 struct ieee80211_sta *sta,
2171 struct net_device_path_ctx *ctx,
2172 struct net_device_path *path)
2173 {
2174 struct mt7996_sta *msta = (struct mt7996_sta *)sta->drv_priv;
2175 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2176 struct mtk_wed_device *wed = &dev->mt76.mmio.wed;
2177 struct mt7996_sta_link *msta_link;
2178 struct mt7996_vif_link *link;
2179
2180 link = mt7996_vif_link(dev, vif, msta->deflink_id);
2181 if (!link)
2182 return -EIO;
2183
2184 msta_link = rcu_dereference(msta->link[msta->deflink_id]);
2185 if (!msta_link)
2186 return -EIO;
2187
2188 if (!msta_link->wcid.sta || msta_link->wcid.idx > MT7996_WTBL_STA)
2189 return -EIO;
2190
2191 if (dev->hif2 &&
2192 ((is_mt7996(&dev->mt76) && msta_link->wcid.phy_idx == MT_BAND2) ||
2193 (is_mt7992(&dev->mt76) && msta_link->wcid.phy_idx == MT_BAND1)))
2194 wed = &dev->mt76.mmio.wed_hif2;
2195
2196 if (!mtk_wed_device_active(wed) &&
2197 !mt76_npu_device_active(&dev->mt76))
2198 return -ENODEV;
2199
2200 path->type = DEV_PATH_MTK_WDMA;
2201 path->dev = ctx->dev;
2202 #ifdef CONFIG_NET_MEDIATEK_SOC_WED
2203 if (mtk_wed_device_active(wed))
2204 path->mtk_wdma.wdma_idx = wed->wdma_idx;
2205 else
2206 #endif
2207 path->mtk_wdma.wdma_idx = link->mt76.band_idx;
2208 path->mtk_wdma.bss = link->mt76.idx;
2209 path->mtk_wdma.queue = 0;
2210 path->mtk_wdma.wcid = msta_link->wcid.idx;
2211
2212 if (ieee80211_hw_check(hw, SUPPORTS_AMSDU_IN_AMPDU) &&
2213 mtk_wed_is_amsdu_supported(wed))
2214 path->mtk_wdma.amsdu = msta_link->wcid.amsdu;
2215 else
2216 path->mtk_wdma.amsdu = 0;
2217 ctx->dev = NULL;
2218
2219 return 0;
2220 }
2221
2222 static int
mt7996_change_vif_links(struct ieee80211_hw * hw,struct ieee80211_vif * vif,u16 old_links,u16 new_links,struct ieee80211_bss_conf * old[IEEE80211_MLD_MAX_NUM_LINKS])2223 mt7996_change_vif_links(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
2224 u16 old_links, u16 new_links,
2225 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS])
2226 {
2227 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2228 struct mt7996_vif *mvif = (struct mt7996_vif *)vif->drv_priv;
2229 int ret = 0;
2230
2231 mutex_lock(&dev->mt76.mutex);
2232
2233 if (!old_links) {
2234 int idx;
2235
2236 idx = get_own_mld_idx(dev->mld_idx_mask, true);
2237 if (idx < 0) {
2238 ret = -ENOSPC;
2239 goto out;
2240 }
2241 mvif->mld_group_idx = idx;
2242 dev->mld_idx_mask |= BIT_ULL(mvif->mld_group_idx);
2243
2244 idx = get_free_idx(dev->mld_remap_idx_mask, 0, 15) - 1;
2245 if (idx < 0) {
2246 ret = -ENOSPC;
2247 goto out;
2248 }
2249 mvif->mld_remap_idx = idx;
2250 dev->mld_remap_idx_mask |= BIT_ULL(mvif->mld_remap_idx);
2251 }
2252
2253 if (new_links)
2254 goto out;
2255
2256 dev->mld_idx_mask &= ~BIT_ULL(mvif->mld_group_idx);
2257 dev->mld_remap_idx_mask &= ~BIT_ULL(mvif->mld_remap_idx);
2258
2259 out:
2260 mutex_unlock(&dev->mt76.mutex);
2261
2262 return ret;
2263 }
2264
2265 static void
mt7996_reconfig_complete(struct ieee80211_hw * hw,enum ieee80211_reconfig_type reconfig_type)2266 mt7996_reconfig_complete(struct ieee80211_hw *hw,
2267 enum ieee80211_reconfig_type reconfig_type)
2268 {
2269 struct mt7996_dev *dev = mt7996_hw_dev(hw);
2270 struct mt7996_phy *phy;
2271
2272 ieee80211_wake_queues(hw);
2273 mt7996_for_each_phy(dev, phy)
2274 ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work,
2275 MT7996_WATCHDOG_TIME);
2276 }
2277
2278 const struct ieee80211_ops mt7996_ops = {
2279 .add_chanctx = mt76_add_chanctx,
2280 .remove_chanctx = mt76_remove_chanctx,
2281 .change_chanctx = mt76_change_chanctx,
2282 .assign_vif_chanctx = mt76_assign_vif_chanctx,
2283 .unassign_vif_chanctx = mt76_unassign_vif_chanctx,
2284 .switch_vif_chanctx = mt76_switch_vif_chanctx,
2285 .tx = mt7996_tx,
2286 .start = mt7996_start,
2287 .stop = mt7996_stop,
2288 .add_interface = mt7996_add_interface,
2289 .remove_interface = mt7996_remove_interface,
2290 .config = mt7996_config,
2291 .conf_tx = mt7996_conf_tx,
2292 .configure_filter = mt7996_configure_filter,
2293 .vif_cfg_changed = mt7996_vif_cfg_changed,
2294 .link_info_changed = mt7996_link_info_changed,
2295 .sta_state = mt7996_sta_state,
2296 .sta_pre_rcu_remove = mt76_sta_pre_rcu_remove,
2297 .link_sta_rc_update = mt7996_link_sta_rc_update,
2298 .set_key = mt7996_set_key,
2299 .ampdu_action = mt7996_ampdu_action,
2300 .set_rts_threshold = mt7996_set_rts_threshold,
2301 .wake_tx_queue = mt76_wake_tx_queue,
2302 .hw_scan = mt76_hw_scan,
2303 .cancel_hw_scan = mt76_cancel_hw_scan,
2304 .remain_on_channel = mt76_remain_on_channel,
2305 .cancel_remain_on_channel = mt76_cancel_remain_on_channel,
2306 .release_buffered_frames = mt76_release_buffered_frames,
2307 .get_txpower = mt7996_get_txpower,
2308 .channel_switch_beacon = mt7996_channel_switch_beacon,
2309 .get_stats = mt7996_get_stats,
2310 .get_et_sset_count = mt7996_get_et_sset_count,
2311 .get_et_stats = mt7996_get_et_stats,
2312 .get_et_strings = mt7996_get_et_strings,
2313 .get_tsf = mt7996_get_tsf,
2314 .set_tsf = mt7996_set_tsf,
2315 .offset_tsf = mt7996_offset_tsf,
2316 .get_survey = mt76_get_survey,
2317 .get_antenna = mt76_get_antenna,
2318 .set_antenna = mt7996_set_antenna,
2319 .set_bitrate_mask = mt7996_set_bitrate_mask,
2320 .set_coverage_class = mt7996_set_coverage_class,
2321 .sta_statistics = mt7996_sta_statistics,
2322 .sta_set_4addr = mt7996_sta_set_4addr,
2323 .sta_set_decap_offload = mt7996_sta_set_decap_offload,
2324 .add_twt_setup = mt7996_mac_add_twt_setup,
2325 .twt_teardown_request = mt7996_twt_teardown_request,
2326 #ifdef CONFIG_MAC80211_DEBUGFS
2327 .sta_add_debugfs = mt7996_sta_add_debugfs,
2328 .link_sta_add_debugfs = mt7996_link_sta_add_debugfs,
2329 #endif
2330 .set_radar_background = mt7996_set_radar_background,
2331 .net_fill_forward_path = mt7996_net_fill_forward_path,
2332 #ifdef CONFIG_NET_MEDIATEK_SOC_WED
2333 .net_setup_tc = mt76_wed_net_setup_tc,
2334 #elif defined(CONFIG_MT7996_NPU)
2335 .net_setup_tc = mt76_npu_net_setup_tc,
2336 #endif
2337 .change_vif_links = mt7996_change_vif_links,
2338 .change_sta_links = mt7996_mac_sta_change_links,
2339 .reconfig_complete = mt7996_reconfig_complete,
2340 };
2341