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