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 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 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 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 89 static void mt7996_stop(struct ieee80211_hw *hw, bool suspend) 90 { 91 } 92 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 650 static int mt7996_config(struct ieee80211_hw *hw, int radio_idx, u32 changed) 651 { 652 return 0; 653 } 654 655 static int 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 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 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 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 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 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 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 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 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(sizeof(*msta_link), GFP_KERNEL); 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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