1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2020 MediaTek Inc. */ 3 4 #include <linux/etherdevice.h> 5 #include <linux/platform_device.h> 6 #include <linux/pci.h> 7 #include <linux/module.h> 8 #include "mt7915.h" 9 #include "mcu.h" 10 11 static bool mt7915_dev_running(struct mt7915_dev *dev) 12 { 13 struct mt7915_phy *phy; 14 15 if (test_bit(MT76_STATE_RUNNING, &dev->mphy.state)) 16 return true; 17 18 phy = mt7915_ext_phy(dev); 19 20 return phy && test_bit(MT76_STATE_RUNNING, &phy->mt76->state); 21 } 22 23 static int mt7915_start(struct ieee80211_hw *hw) 24 { 25 struct mt7915_dev *dev = mt7915_hw_dev(hw); 26 struct mt7915_phy *phy = mt7915_hw_phy(hw); 27 bool running; 28 int ret; 29 30 flush_work(&dev->init_work); 31 32 mutex_lock(&dev->mt76.mutex); 33 34 running = mt7915_dev_running(dev); 35 36 if (!running) { 37 ret = mt7915_mcu_set_pm(dev, 0, 0); 38 if (ret) 39 goto out; 40 41 ret = mt7915_mcu_set_mac(dev, 0, true, true); 42 if (ret) 43 goto out; 44 45 ret = mt7915_mcu_set_scs(dev, 0, true); 46 if (ret) 47 goto out; 48 49 mt7915_mac_enable_nf(dev, 0); 50 } 51 52 if (phy != &dev->phy) { 53 ret = mt7915_mcu_set_pm(dev, 1, 0); 54 if (ret) 55 goto out; 56 57 ret = mt7915_mcu_set_mac(dev, 1, true, true); 58 if (ret) 59 goto out; 60 61 ret = mt7915_mcu_set_scs(dev, 1, true); 62 if (ret) 63 goto out; 64 65 mt7915_mac_enable_nf(dev, 1); 66 } 67 68 ret = mt7915_mcu_set_rts_thresh(phy, 0x92b); 69 if (ret) 70 goto out; 71 72 ret = mt7915_mcu_set_sku_en(phy, true); 73 if (ret) 74 goto out; 75 76 ret = mt7915_mcu_set_chan_info(phy, MCU_EXT_CMD(SET_RX_PATH)); 77 if (ret) 78 goto out; 79 80 set_bit(MT76_STATE_RUNNING, &phy->mt76->state); 81 82 if (!mt76_testmode_enabled(phy->mt76)) 83 ieee80211_queue_delayed_work(hw, &phy->mt76->mac_work, 84 MT7915_WATCHDOG_TIME); 85 86 if (!running) 87 mt7915_mac_reset_counters(phy); 88 89 out: 90 mutex_unlock(&dev->mt76.mutex); 91 92 return ret; 93 } 94 95 static void mt7915_stop(struct ieee80211_hw *hw) 96 { 97 struct mt7915_dev *dev = mt7915_hw_dev(hw); 98 struct mt7915_phy *phy = mt7915_hw_phy(hw); 99 100 cancel_delayed_work_sync(&phy->mt76->mac_work); 101 102 mutex_lock(&dev->mt76.mutex); 103 104 mt76_testmode_reset(phy->mt76, true); 105 106 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state); 107 108 if (phy != &dev->phy) { 109 mt7915_mcu_set_pm(dev, 1, 1); 110 mt7915_mcu_set_mac(dev, 1, false, false); 111 } 112 113 if (!mt7915_dev_running(dev)) { 114 mt7915_mcu_set_pm(dev, 0, 1); 115 mt7915_mcu_set_mac(dev, 0, false, false); 116 } 117 118 mutex_unlock(&dev->mt76.mutex); 119 } 120 121 static inline int get_free_idx(u32 mask, u8 start, u8 end) 122 { 123 return ffs(~mask & GENMASK(end, start)); 124 } 125 126 static int get_omac_idx(enum nl80211_iftype type, u64 mask) 127 { 128 int i; 129 130 switch (type) { 131 case NL80211_IFTYPE_MESH_POINT: 132 case NL80211_IFTYPE_ADHOC: 133 case NL80211_IFTYPE_STATION: 134 /* prefer hw bssid slot 1-3 */ 135 i = get_free_idx(mask, HW_BSSID_1, HW_BSSID_3); 136 if (i) 137 return i - 1; 138 139 if (type != NL80211_IFTYPE_STATION) 140 break; 141 142 /* next, try to find a free repeater entry for the sta */ 143 i = get_free_idx(mask >> REPEATER_BSSID_START, 0, 144 REPEATER_BSSID_MAX - REPEATER_BSSID_START); 145 if (i) 146 return i + 32 - 1; 147 148 i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX); 149 if (i) 150 return i - 1; 151 152 if (~mask & BIT(HW_BSSID_0)) 153 return HW_BSSID_0; 154 155 break; 156 case NL80211_IFTYPE_MONITOR: 157 case NL80211_IFTYPE_AP: 158 /* ap uses hw bssid 0 and ext bssid */ 159 if (~mask & BIT(HW_BSSID_0)) 160 return HW_BSSID_0; 161 162 i = get_free_idx(mask, EXT_BSSID_1, EXT_BSSID_MAX); 163 if (i) 164 return i - 1; 165 166 break; 167 default: 168 WARN_ON(1); 169 break; 170 } 171 172 return -1; 173 } 174 175 static int mt7915_add_interface(struct ieee80211_hw *hw, 176 struct ieee80211_vif *vif) 177 { 178 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 179 struct mt7915_dev *dev = mt7915_hw_dev(hw); 180 struct mt7915_phy *phy = mt7915_hw_phy(hw); 181 struct mt76_txq *mtxq; 182 bool ext_phy = phy != &dev->phy; 183 int idx, ret = 0; 184 185 mutex_lock(&dev->mt76.mutex); 186 187 mt76_testmode_reset(phy->mt76, true); 188 189 if (vif->type == NL80211_IFTYPE_MONITOR && 190 is_zero_ether_addr(vif->addr)) 191 phy->monitor_vif = vif; 192 193 mvif->idx = ffs(~dev->mt76.vif_mask) - 1; 194 if (mvif->idx >= MT7915_MAX_INTERFACES) { 195 ret = -ENOSPC; 196 goto out; 197 } 198 199 idx = get_omac_idx(vif->type, phy->omac_mask); 200 if (idx < 0) { 201 ret = -ENOSPC; 202 goto out; 203 } 204 mvif->omac_idx = idx; 205 mvif->phy = phy; 206 mvif->band_idx = ext_phy; 207 208 if (ext_phy) 209 mvif->wmm_idx = ext_phy * (MT7915_MAX_WMM_SETS / 2) + 210 mvif->idx % (MT7915_MAX_WMM_SETS / 2); 211 else 212 mvif->wmm_idx = mvif->idx % MT7915_MAX_WMM_SETS; 213 214 ret = mt7915_mcu_add_dev_info(phy, vif, true); 215 if (ret) 216 goto out; 217 218 dev->mt76.vif_mask |= BIT(mvif->idx); 219 phy->omac_mask |= BIT_ULL(mvif->omac_idx); 220 221 idx = MT7915_WTBL_RESERVED - mvif->idx; 222 223 INIT_LIST_HEAD(&mvif->sta.rc_list); 224 INIT_LIST_HEAD(&mvif->sta.stats_list); 225 INIT_LIST_HEAD(&mvif->sta.poll_list); 226 mvif->sta.wcid.idx = idx; 227 mvif->sta.wcid.ext_phy = mvif->band_idx; 228 mvif->sta.wcid.hw_key_idx = -1; 229 mvif->sta.wcid.tx_info |= MT_WCID_TX_INFO_SET; 230 mt7915_mac_wtbl_update(dev, idx, 231 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 232 233 rcu_assign_pointer(dev->mt76.wcid[idx], &mvif->sta.wcid); 234 if (vif->txq) { 235 mtxq = (struct mt76_txq *)vif->txq->drv_priv; 236 mtxq->wcid = &mvif->sta.wcid; 237 } 238 239 if (vif->type != NL80211_IFTYPE_AP && 240 (!mvif->omac_idx || mvif->omac_idx > 3)) 241 vif->offload_flags = 0; 242 vif->offload_flags |= IEEE80211_OFFLOAD_ENCAP_4ADDR; 243 244 out: 245 mutex_unlock(&dev->mt76.mutex); 246 247 return ret; 248 } 249 250 static void mt7915_remove_interface(struct ieee80211_hw *hw, 251 struct ieee80211_vif *vif) 252 { 253 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 254 struct mt7915_sta *msta = &mvif->sta; 255 struct mt7915_dev *dev = mt7915_hw_dev(hw); 256 struct mt7915_phy *phy = mt7915_hw_phy(hw); 257 int idx = msta->wcid.idx; 258 259 mt7915_mcu_add_bss_info(phy, vif, false); 260 mt7915_mcu_add_sta(dev, vif, NULL, false); 261 262 mutex_lock(&dev->mt76.mutex); 263 mt76_testmode_reset(phy->mt76, true); 264 mutex_unlock(&dev->mt76.mutex); 265 266 if (vif == phy->monitor_vif) 267 phy->monitor_vif = NULL; 268 269 mt7915_mcu_add_dev_info(phy, vif, false); 270 271 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 272 273 mutex_lock(&dev->mt76.mutex); 274 dev->mt76.vif_mask &= ~BIT(mvif->idx); 275 phy->omac_mask &= ~BIT_ULL(mvif->omac_idx); 276 mutex_unlock(&dev->mt76.mutex); 277 278 spin_lock_bh(&dev->sta_poll_lock); 279 if (!list_empty(&msta->poll_list)) 280 list_del_init(&msta->poll_list); 281 spin_unlock_bh(&dev->sta_poll_lock); 282 } 283 284 static void mt7915_init_dfs_state(struct mt7915_phy *phy) 285 { 286 struct mt76_phy *mphy = phy->mt76; 287 struct ieee80211_hw *hw = mphy->hw; 288 struct cfg80211_chan_def *chandef = &hw->conf.chandef; 289 290 if (hw->conf.flags & IEEE80211_CONF_OFFCHANNEL) 291 return; 292 293 if (!(chandef->chan->flags & IEEE80211_CHAN_RADAR)) 294 return; 295 296 if (mphy->chandef.chan->center_freq == chandef->chan->center_freq && 297 mphy->chandef.width == chandef->width) 298 return; 299 300 phy->dfs_state = -1; 301 } 302 303 int mt7915_set_channel(struct mt7915_phy *phy) 304 { 305 struct mt7915_dev *dev = phy->dev; 306 int ret; 307 308 cancel_delayed_work_sync(&phy->mt76->mac_work); 309 310 mutex_lock(&dev->mt76.mutex); 311 set_bit(MT76_RESET, &phy->mt76->state); 312 313 mt7915_init_dfs_state(phy); 314 mt76_set_channel(phy->mt76); 315 316 if (dev->flash_mode) { 317 ret = mt7915_mcu_apply_tx_dpd(phy); 318 if (ret) 319 goto out; 320 } 321 322 ret = mt7915_mcu_set_chan_info(phy, MCU_EXT_CMD(CHANNEL_SWITCH)); 323 if (ret) 324 goto out; 325 326 mt7915_mac_set_timing(phy); 327 ret = mt7915_dfs_init_radar_detector(phy); 328 mt7915_mac_cca_stats_reset(phy); 329 330 mt7915_mac_reset_counters(phy); 331 phy->noise = 0; 332 333 out: 334 clear_bit(MT76_RESET, &phy->mt76->state); 335 mutex_unlock(&dev->mt76.mutex); 336 337 mt76_txq_schedule_all(phy->mt76); 338 339 if (!mt76_testmode_enabled(phy->mt76)) 340 ieee80211_queue_delayed_work(phy->mt76->hw, 341 &phy->mt76->mac_work, 342 MT7915_WATCHDOG_TIME); 343 344 return ret; 345 } 346 347 static int mt7915_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 348 struct ieee80211_vif *vif, struct ieee80211_sta *sta, 349 struct ieee80211_key_conf *key) 350 { 351 struct mt7915_dev *dev = mt7915_hw_dev(hw); 352 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 353 struct mt7915_sta *msta = sta ? (struct mt7915_sta *)sta->drv_priv : 354 &mvif->sta; 355 struct mt76_wcid *wcid = &msta->wcid; 356 u8 *wcid_keyidx = &wcid->hw_key_idx; 357 int idx = key->keyidx; 358 int err = 0; 359 360 /* The hardware does not support per-STA RX GTK, fallback 361 * to software mode for these. 362 */ 363 if ((vif->type == NL80211_IFTYPE_ADHOC || 364 vif->type == NL80211_IFTYPE_MESH_POINT) && 365 (key->cipher == WLAN_CIPHER_SUITE_TKIP || 366 key->cipher == WLAN_CIPHER_SUITE_CCMP) && 367 !(key->flags & IEEE80211_KEY_FLAG_PAIRWISE)) 368 return -EOPNOTSUPP; 369 370 /* fall back to sw encryption for unsupported ciphers */ 371 switch (key->cipher) { 372 case WLAN_CIPHER_SUITE_AES_CMAC: 373 wcid_keyidx = &wcid->hw_key_idx2; 374 key->flags |= IEEE80211_KEY_FLAG_GENERATE_MMIE; 375 break; 376 case WLAN_CIPHER_SUITE_TKIP: 377 case WLAN_CIPHER_SUITE_CCMP: 378 case WLAN_CIPHER_SUITE_CCMP_256: 379 case WLAN_CIPHER_SUITE_GCMP: 380 case WLAN_CIPHER_SUITE_GCMP_256: 381 case WLAN_CIPHER_SUITE_SMS4: 382 break; 383 case WLAN_CIPHER_SUITE_WEP40: 384 case WLAN_CIPHER_SUITE_WEP104: 385 default: 386 return -EOPNOTSUPP; 387 } 388 389 mutex_lock(&dev->mt76.mutex); 390 391 if (cmd == SET_KEY) 392 *wcid_keyidx = idx; 393 else if (idx == *wcid_keyidx) 394 *wcid_keyidx = -1; 395 else 396 goto out; 397 398 mt76_wcid_key_setup(&dev->mt76, wcid, 399 cmd == SET_KEY ? key : NULL); 400 401 err = mt7915_mcu_add_key(dev, vif, msta, key, cmd); 402 403 out: 404 mutex_unlock(&dev->mt76.mutex); 405 406 return err; 407 } 408 409 static int mt7915_config(struct ieee80211_hw *hw, u32 changed) 410 { 411 struct mt7915_dev *dev = mt7915_hw_dev(hw); 412 struct mt7915_phy *phy = mt7915_hw_phy(hw); 413 bool band = phy != &dev->phy; 414 int ret; 415 416 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 417 #ifdef CONFIG_NL80211_TESTMODE 418 if (phy->mt76->test.state != MT76_TM_STATE_OFF) { 419 mutex_lock(&dev->mt76.mutex); 420 mt76_testmode_reset(phy->mt76, false); 421 mutex_unlock(&dev->mt76.mutex); 422 } 423 #endif 424 ieee80211_stop_queues(hw); 425 ret = mt7915_set_channel(phy); 426 if (ret) 427 return ret; 428 ieee80211_wake_queues(hw); 429 } 430 431 if (changed & IEEE80211_CONF_CHANGE_POWER) { 432 ret = mt7915_mcu_set_txpower_sku(phy); 433 if (ret) 434 return ret; 435 } 436 437 mutex_lock(&dev->mt76.mutex); 438 439 if (changed & IEEE80211_CONF_CHANGE_MONITOR) { 440 bool enabled = !!(hw->conf.flags & IEEE80211_CONF_MONITOR); 441 442 if (!enabled) 443 phy->rxfilter |= MT_WF_RFCR_DROP_OTHER_UC; 444 else 445 phy->rxfilter &= ~MT_WF_RFCR_DROP_OTHER_UC; 446 447 mt76_rmw_field(dev, MT_DMA_DCR0(band), MT_DMA_DCR0_RXD_G5_EN, 448 enabled); 449 mt76_testmode_reset(phy->mt76, true); 450 mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter); 451 } 452 453 mutex_unlock(&dev->mt76.mutex); 454 455 return 0; 456 } 457 458 static int 459 mt7915_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, u16 queue, 460 const struct ieee80211_tx_queue_params *params) 461 { 462 struct mt7915_dev *dev = mt7915_hw_dev(hw); 463 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 464 465 /* no need to update right away, we'll get BSS_CHANGED_QOS */ 466 queue = mt7915_lmac_mapping(dev, queue); 467 mvif->queue_params[queue] = *params; 468 469 return 0; 470 } 471 472 static void mt7915_configure_filter(struct ieee80211_hw *hw, 473 unsigned int changed_flags, 474 unsigned int *total_flags, 475 u64 multicast) 476 { 477 struct mt7915_dev *dev = mt7915_hw_dev(hw); 478 struct mt7915_phy *phy = mt7915_hw_phy(hw); 479 bool band = phy != &dev->phy; 480 u32 ctl_flags = MT_WF_RFCR1_DROP_ACK | 481 MT_WF_RFCR1_DROP_BF_POLL | 482 MT_WF_RFCR1_DROP_BA | 483 MT_WF_RFCR1_DROP_CFEND | 484 MT_WF_RFCR1_DROP_CFACK; 485 u32 flags = 0; 486 487 #define MT76_FILTER(_flag, _hw) do { \ 488 flags |= *total_flags & FIF_##_flag; \ 489 phy->rxfilter &= ~(_hw); \ 490 phy->rxfilter |= !(flags & FIF_##_flag) * (_hw); \ 491 } while (0) 492 493 mutex_lock(&dev->mt76.mutex); 494 495 phy->rxfilter &= ~(MT_WF_RFCR_DROP_OTHER_BSS | 496 MT_WF_RFCR_DROP_OTHER_BEACON | 497 MT_WF_RFCR_DROP_FRAME_REPORT | 498 MT_WF_RFCR_DROP_PROBEREQ | 499 MT_WF_RFCR_DROP_MCAST_FILTERED | 500 MT_WF_RFCR_DROP_MCAST | 501 MT_WF_RFCR_DROP_BCAST | 502 MT_WF_RFCR_DROP_DUPLICATE | 503 MT_WF_RFCR_DROP_A2_BSSID | 504 MT_WF_RFCR_DROP_UNWANTED_CTL | 505 MT_WF_RFCR_DROP_STBC_MULTI); 506 507 MT76_FILTER(OTHER_BSS, MT_WF_RFCR_DROP_OTHER_TIM | 508 MT_WF_RFCR_DROP_A3_MAC | 509 MT_WF_RFCR_DROP_A3_BSSID); 510 511 MT76_FILTER(FCSFAIL, MT_WF_RFCR_DROP_FCSFAIL); 512 513 MT76_FILTER(CONTROL, MT_WF_RFCR_DROP_CTS | 514 MT_WF_RFCR_DROP_RTS | 515 MT_WF_RFCR_DROP_CTL_RSV | 516 MT_WF_RFCR_DROP_NDPA); 517 518 *total_flags = flags; 519 mt76_wr(dev, MT_WF_RFCR(band), phy->rxfilter); 520 521 if (*total_flags & FIF_CONTROL) 522 mt76_clear(dev, MT_WF_RFCR1(band), ctl_flags); 523 else 524 mt76_set(dev, MT_WF_RFCR1(band), ctl_flags); 525 526 mutex_unlock(&dev->mt76.mutex); 527 } 528 529 static void mt7915_bss_info_changed(struct ieee80211_hw *hw, 530 struct ieee80211_vif *vif, 531 struct ieee80211_bss_conf *info, 532 u32 changed) 533 { 534 struct mt7915_phy *phy = mt7915_hw_phy(hw); 535 struct mt7915_dev *dev = mt7915_hw_dev(hw); 536 537 mutex_lock(&dev->mt76.mutex); 538 539 /* 540 * station mode uses BSSID to map the wlan entry to a peer, 541 * and then peer references bss_info_rfch to set bandwidth cap. 542 */ 543 if (changed & BSS_CHANGED_BSSID && 544 vif->type == NL80211_IFTYPE_STATION) { 545 bool join = !is_zero_ether_addr(info->bssid); 546 547 mt7915_mcu_add_bss_info(phy, vif, join); 548 mt7915_mcu_add_sta(dev, vif, NULL, join); 549 } 550 551 if (changed & BSS_CHANGED_ASSOC) { 552 mt7915_mcu_add_bss_info(phy, vif, info->assoc); 553 mt7915_mcu_add_obss_spr(dev, vif, info->he_obss_pd.enable); 554 } 555 556 if (changed & BSS_CHANGED_ERP_SLOT) { 557 int slottime = info->use_short_slot ? 9 : 20; 558 559 if (slottime != phy->slottime) { 560 phy->slottime = slottime; 561 mt7915_mac_set_timing(phy); 562 } 563 } 564 565 if (changed & BSS_CHANGED_BEACON_ENABLED && info->enable_beacon) { 566 mt7915_mcu_add_bss_info(phy, vif, true); 567 mt7915_mcu_add_sta(dev, vif, NULL, true); 568 } 569 570 /* ensure that enable txcmd_mode after bss_info */ 571 if (changed & (BSS_CHANGED_QOS | BSS_CHANGED_BEACON_ENABLED)) 572 mt7915_mcu_set_tx(dev, vif); 573 574 if (changed & BSS_CHANGED_HE_OBSS_PD) 575 mt7915_mcu_add_obss_spr(dev, vif, info->he_obss_pd.enable); 576 577 if (changed & (BSS_CHANGED_BEACON | 578 BSS_CHANGED_BEACON_ENABLED)) 579 mt7915_mcu_add_beacon(hw, vif, info->enable_beacon); 580 581 mutex_unlock(&dev->mt76.mutex); 582 } 583 584 static void 585 mt7915_channel_switch_beacon(struct ieee80211_hw *hw, 586 struct ieee80211_vif *vif, 587 struct cfg80211_chan_def *chandef) 588 { 589 struct mt7915_dev *dev = mt7915_hw_dev(hw); 590 591 mutex_lock(&dev->mt76.mutex); 592 mt7915_mcu_add_beacon(hw, vif, true); 593 mutex_unlock(&dev->mt76.mutex); 594 } 595 596 int mt7915_mac_sta_add(struct mt76_dev *mdev, struct ieee80211_vif *vif, 597 struct ieee80211_sta *sta) 598 { 599 struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76); 600 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 601 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 602 int ret, idx; 603 604 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT7915_WTBL_STA - 1); 605 if (idx < 0) 606 return -ENOSPC; 607 608 INIT_LIST_HEAD(&msta->rc_list); 609 INIT_LIST_HEAD(&msta->stats_list); 610 INIT_LIST_HEAD(&msta->poll_list); 611 msta->vif = mvif; 612 msta->wcid.sta = 1; 613 msta->wcid.idx = idx; 614 msta->wcid.ext_phy = mvif->band_idx; 615 msta->wcid.tx_info |= MT_WCID_TX_INFO_SET; 616 msta->stats.jiffies = jiffies; 617 618 mt7915_mac_wtbl_update(dev, idx, 619 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 620 621 ret = mt7915_mcu_add_sta(dev, vif, sta, true); 622 if (ret) 623 return ret; 624 625 return mt7915_mcu_add_sta_adv(dev, vif, sta, true); 626 } 627 628 void mt7915_mac_sta_remove(struct mt76_dev *mdev, struct ieee80211_vif *vif, 629 struct ieee80211_sta *sta) 630 { 631 struct mt7915_dev *dev = container_of(mdev, struct mt7915_dev, mt76); 632 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 633 634 mt7915_mcu_add_sta_adv(dev, vif, sta, false); 635 mt7915_mcu_add_sta(dev, vif, sta, false); 636 637 mt7915_mac_wtbl_update(dev, msta->wcid.idx, 638 MT_WTBL_UPDATE_ADM_COUNT_CLEAR); 639 640 spin_lock_bh(&dev->sta_poll_lock); 641 if (!list_empty(&msta->poll_list)) 642 list_del_init(&msta->poll_list); 643 if (!list_empty(&msta->stats_list)) 644 list_del_init(&msta->stats_list); 645 if (!list_empty(&msta->rc_list)) 646 list_del_init(&msta->rc_list); 647 spin_unlock_bh(&dev->sta_poll_lock); 648 } 649 650 static void mt7915_tx(struct ieee80211_hw *hw, 651 struct ieee80211_tx_control *control, 652 struct sk_buff *skb) 653 { 654 struct mt7915_dev *dev = mt7915_hw_dev(hw); 655 struct mt76_phy *mphy = hw->priv; 656 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 657 struct ieee80211_vif *vif = info->control.vif; 658 struct mt76_wcid *wcid = &dev->mt76.global_wcid; 659 660 if (control->sta) { 661 struct mt7915_sta *sta; 662 663 sta = (struct mt7915_sta *)control->sta->drv_priv; 664 wcid = &sta->wcid; 665 } 666 667 if (vif && !control->sta) { 668 struct mt7915_vif *mvif; 669 670 mvif = (struct mt7915_vif *)vif->drv_priv; 671 wcid = &mvif->sta.wcid; 672 } 673 674 mt76_tx(mphy, control->sta, wcid, skb); 675 } 676 677 static int mt7915_set_rts_threshold(struct ieee80211_hw *hw, u32 val) 678 { 679 struct mt7915_dev *dev = mt7915_hw_dev(hw); 680 struct mt7915_phy *phy = mt7915_hw_phy(hw); 681 int ret; 682 683 mutex_lock(&dev->mt76.mutex); 684 ret = mt7915_mcu_set_rts_thresh(phy, val); 685 mutex_unlock(&dev->mt76.mutex); 686 687 return ret; 688 } 689 690 static int 691 mt7915_ampdu_action(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 692 struct ieee80211_ampdu_params *params) 693 { 694 enum ieee80211_ampdu_mlme_action action = params->action; 695 struct mt7915_dev *dev = mt7915_hw_dev(hw); 696 struct ieee80211_sta *sta = params->sta; 697 struct ieee80211_txq *txq = sta->txq[params->tid]; 698 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 699 u16 tid = params->tid; 700 u16 ssn = params->ssn; 701 struct mt76_txq *mtxq; 702 int ret = 0; 703 704 if (!txq) 705 return -EINVAL; 706 707 mtxq = (struct mt76_txq *)txq->drv_priv; 708 709 mutex_lock(&dev->mt76.mutex); 710 switch (action) { 711 case IEEE80211_AMPDU_RX_START: 712 mt76_rx_aggr_start(&dev->mt76, &msta->wcid, tid, ssn, 713 params->buf_size); 714 ret = mt7915_mcu_add_rx_ba(dev, params, true); 715 break; 716 case IEEE80211_AMPDU_RX_STOP: 717 mt76_rx_aggr_stop(&dev->mt76, &msta->wcid, tid); 718 ret = mt7915_mcu_add_rx_ba(dev, params, false); 719 break; 720 case IEEE80211_AMPDU_TX_OPERATIONAL: 721 mtxq->aggr = true; 722 mtxq->send_bar = false; 723 ret = mt7915_mcu_add_tx_ba(dev, params, true); 724 break; 725 case IEEE80211_AMPDU_TX_STOP_FLUSH: 726 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 727 mtxq->aggr = false; 728 clear_bit(tid, &msta->ampdu_state); 729 ret = mt7915_mcu_add_tx_ba(dev, params, false); 730 break; 731 case IEEE80211_AMPDU_TX_START: 732 set_bit(tid, &msta->ampdu_state); 733 ret = IEEE80211_AMPDU_TX_START_IMMEDIATE; 734 break; 735 case IEEE80211_AMPDU_TX_STOP_CONT: 736 mtxq->aggr = false; 737 clear_bit(tid, &msta->ampdu_state); 738 ret = mt7915_mcu_add_tx_ba(dev, params, false); 739 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 740 break; 741 } 742 mutex_unlock(&dev->mt76.mutex); 743 744 return ret; 745 } 746 747 static int 748 mt7915_sta_add(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 749 struct ieee80211_sta *sta) 750 { 751 return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NOTEXIST, 752 IEEE80211_STA_NONE); 753 } 754 755 static int 756 mt7915_sta_remove(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 757 struct ieee80211_sta *sta) 758 { 759 return mt76_sta_state(hw, vif, sta, IEEE80211_STA_NONE, 760 IEEE80211_STA_NOTEXIST); 761 } 762 763 static int 764 mt7915_get_stats(struct ieee80211_hw *hw, 765 struct ieee80211_low_level_stats *stats) 766 { 767 struct mt7915_phy *phy = mt7915_hw_phy(hw); 768 struct mt7915_dev *dev = mt7915_hw_dev(hw); 769 struct mib_stats *mib = &phy->mib; 770 771 mutex_lock(&dev->mt76.mutex); 772 stats->dot11RTSSuccessCount = mib->rts_cnt; 773 stats->dot11RTSFailureCount = mib->rts_retries_cnt; 774 stats->dot11FCSErrorCount = mib->fcs_err_cnt; 775 stats->dot11ACKFailureCount = mib->ack_fail_cnt; 776 777 memset(mib, 0, sizeof(*mib)); 778 779 mutex_unlock(&dev->mt76.mutex); 780 781 return 0; 782 } 783 784 static u64 785 mt7915_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 786 { 787 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 788 struct mt7915_dev *dev = mt7915_hw_dev(hw); 789 struct mt7915_phy *phy = mt7915_hw_phy(hw); 790 bool band = phy != &dev->phy; 791 union { 792 u64 t64; 793 u32 t32[2]; 794 } tsf; 795 u16 n; 796 797 mutex_lock(&dev->mt76.mutex); 798 799 n = mvif->omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : mvif->omac_idx; 800 /* TSF software read */ 801 mt76_set(dev, MT_LPON_TCR(band, n), MT_LPON_TCR_SW_MODE); 802 tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0(band)); 803 tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1(band)); 804 805 mutex_unlock(&dev->mt76.mutex); 806 807 return tsf.t64; 808 } 809 810 static void 811 mt7915_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 812 u64 timestamp) 813 { 814 struct mt7915_vif *mvif = (struct mt7915_vif *)vif->drv_priv; 815 struct mt7915_dev *dev = mt7915_hw_dev(hw); 816 struct mt7915_phy *phy = mt7915_hw_phy(hw); 817 bool band = phy != &dev->phy; 818 union { 819 u64 t64; 820 u32 t32[2]; 821 } tsf = { .t64 = timestamp, }; 822 u16 n; 823 824 mutex_lock(&dev->mt76.mutex); 825 826 n = mvif->omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : mvif->omac_idx; 827 mt76_wr(dev, MT_LPON_UTTR0(band), tsf.t32[0]); 828 mt76_wr(dev, MT_LPON_UTTR1(band), tsf.t32[1]); 829 /* TSF software overwrite */ 830 mt76_set(dev, MT_LPON_TCR(band, n), MT_LPON_TCR_SW_WRITE); 831 832 mutex_unlock(&dev->mt76.mutex); 833 } 834 835 static void 836 mt7915_set_coverage_class(struct ieee80211_hw *hw, s16 coverage_class) 837 { 838 struct mt7915_phy *phy = mt7915_hw_phy(hw); 839 struct mt7915_dev *dev = phy->dev; 840 841 mutex_lock(&dev->mt76.mutex); 842 phy->coverage_class = max_t(s16, coverage_class, 0); 843 mt7915_mac_set_timing(phy); 844 mutex_unlock(&dev->mt76.mutex); 845 } 846 847 static int 848 mt7915_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 849 { 850 struct mt7915_dev *dev = mt7915_hw_dev(hw); 851 struct mt7915_phy *phy = mt7915_hw_phy(hw); 852 int max_nss = hweight8(hw->wiphy->available_antennas_tx); 853 bool ext_phy = phy != &dev->phy; 854 855 if (!tx_ant || tx_ant != rx_ant || ffs(tx_ant) > max_nss) 856 return -EINVAL; 857 858 if ((BIT(hweight8(tx_ant)) - 1) != tx_ant) 859 tx_ant = BIT(ffs(tx_ant) - 1) - 1; 860 861 mutex_lock(&dev->mt76.mutex); 862 863 phy->mt76->antenna_mask = tx_ant; 864 865 if (ext_phy) { 866 if (dev->chainmask == 0xf) 867 tx_ant <<= 2; 868 else 869 tx_ant <<= 1; 870 } 871 phy->mt76->chainmask = tx_ant; 872 873 mt76_set_stream_caps(phy->mt76, true); 874 mt7915_set_stream_vht_txbf_caps(phy); 875 mt7915_set_stream_he_caps(phy); 876 877 mutex_unlock(&dev->mt76.mutex); 878 879 return 0; 880 } 881 882 static void mt7915_sta_statistics(struct ieee80211_hw *hw, 883 struct ieee80211_vif *vif, 884 struct ieee80211_sta *sta, 885 struct station_info *sinfo) 886 { 887 struct mt7915_phy *phy = mt7915_hw_phy(hw); 888 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 889 struct mt7915_sta_stats *stats = &msta->stats; 890 struct rate_info rxrate = {}; 891 892 if (!mt7915_mcu_get_rx_rate(phy, vif, sta, &rxrate)) { 893 sinfo->rxrate = rxrate; 894 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_RX_BITRATE); 895 } 896 897 if (!stats->tx_rate.legacy && !stats->tx_rate.flags) 898 return; 899 900 if (stats->tx_rate.legacy) { 901 sinfo->txrate.legacy = stats->tx_rate.legacy; 902 } else { 903 sinfo->txrate.mcs = stats->tx_rate.mcs; 904 sinfo->txrate.nss = stats->tx_rate.nss; 905 sinfo->txrate.bw = stats->tx_rate.bw; 906 sinfo->txrate.he_gi = stats->tx_rate.he_gi; 907 sinfo->txrate.he_dcm = stats->tx_rate.he_dcm; 908 sinfo->txrate.he_ru_alloc = stats->tx_rate.he_ru_alloc; 909 } 910 sinfo->txrate.flags = stats->tx_rate.flags; 911 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 912 } 913 914 static void 915 mt7915_sta_rc_update(struct ieee80211_hw *hw, 916 struct ieee80211_vif *vif, 917 struct ieee80211_sta *sta, 918 u32 changed) 919 { 920 struct mt7915_dev *dev = mt7915_hw_dev(hw); 921 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 922 923 spin_lock_bh(&dev->sta_poll_lock); 924 msta->stats.changed |= changed; 925 if (list_empty(&msta->rc_list)) 926 list_add_tail(&msta->rc_list, &dev->sta_rc_list); 927 spin_unlock_bh(&dev->sta_poll_lock); 928 929 ieee80211_queue_work(hw, &dev->rc_work); 930 } 931 932 static void mt7915_sta_set_4addr(struct ieee80211_hw *hw, 933 struct ieee80211_vif *vif, 934 struct ieee80211_sta *sta, 935 bool enabled) 936 { 937 struct mt7915_dev *dev = mt7915_hw_dev(hw); 938 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 939 940 if (enabled) 941 set_bit(MT_WCID_FLAG_4ADDR, &msta->wcid.flags); 942 else 943 clear_bit(MT_WCID_FLAG_4ADDR, &msta->wcid.flags); 944 945 mt7915_mcu_sta_update_hdr_trans(dev, vif, sta); 946 } 947 948 static void mt7915_sta_set_decap_offload(struct ieee80211_hw *hw, 949 struct ieee80211_vif *vif, 950 struct ieee80211_sta *sta, 951 bool enabled) 952 { 953 struct mt7915_dev *dev = mt7915_hw_dev(hw); 954 struct mt7915_sta *msta = (struct mt7915_sta *)sta->drv_priv; 955 956 if (enabled) 957 set_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags); 958 else 959 clear_bit(MT_WCID_FLAG_HDR_TRANS, &msta->wcid.flags); 960 961 mt7915_mcu_sta_update_hdr_trans(dev, vif, sta); 962 } 963 964 const struct ieee80211_ops mt7915_ops = { 965 .tx = mt7915_tx, 966 .start = mt7915_start, 967 .stop = mt7915_stop, 968 .add_interface = mt7915_add_interface, 969 .remove_interface = mt7915_remove_interface, 970 .config = mt7915_config, 971 .conf_tx = mt7915_conf_tx, 972 .configure_filter = mt7915_configure_filter, 973 .bss_info_changed = mt7915_bss_info_changed, 974 .sta_add = mt7915_sta_add, 975 .sta_remove = mt7915_sta_remove, 976 .sta_pre_rcu_remove = mt76_sta_pre_rcu_remove, 977 .sta_rc_update = mt7915_sta_rc_update, 978 .set_key = mt7915_set_key, 979 .ampdu_action = mt7915_ampdu_action, 980 .set_rts_threshold = mt7915_set_rts_threshold, 981 .wake_tx_queue = mt76_wake_tx_queue, 982 .sw_scan_start = mt76_sw_scan, 983 .sw_scan_complete = mt76_sw_scan_complete, 984 .release_buffered_frames = mt76_release_buffered_frames, 985 .get_txpower = mt76_get_txpower, 986 .channel_switch_beacon = mt7915_channel_switch_beacon, 987 .get_stats = mt7915_get_stats, 988 .get_tsf = mt7915_get_tsf, 989 .set_tsf = mt7915_set_tsf, 990 .get_survey = mt76_get_survey, 991 .get_antenna = mt76_get_antenna, 992 .set_antenna = mt7915_set_antenna, 993 .set_coverage_class = mt7915_set_coverage_class, 994 .sta_statistics = mt7915_sta_statistics, 995 .sta_set_4addr = mt7915_sta_set_4addr, 996 .sta_set_decap_offload = mt7915_sta_set_decap_offload, 997 CFG80211_TESTMODE_CMD(mt76_testmode_cmd) 998 CFG80211_TESTMODE_DUMP(mt76_testmode_dump) 999 #ifdef CONFIG_MAC80211_DEBUGFS 1000 .sta_add_debugfs = mt7915_sta_add_debugfs, 1001 #endif 1002 }; 1003