1 // SPDX-License-Identifier: ISC 2 /* Copyright (C) 2023 MediaTek Inc. */ 3 4 #include <linux/module.h> 5 #include <linux/firmware.h> 6 7 #include "mt792x.h" 8 #include "dma.h" 9 10 static const struct ieee80211_iface_limit if_limits[] = { 11 { 12 .max = MT792x_MAX_INTERFACES, 13 .types = BIT(NL80211_IFTYPE_STATION) 14 }, 15 { 16 .max = 1, 17 .types = BIT(NL80211_IFTYPE_AP) 18 } 19 }; 20 21 static const struct ieee80211_iface_combination if_comb[] = { 22 { 23 .limits = if_limits, 24 .n_limits = ARRAY_SIZE(if_limits), 25 .max_interfaces = MT792x_MAX_INTERFACES, 26 .num_different_channels = 1, 27 .beacon_int_infra_match = true, 28 }, 29 }; 30 31 static const struct ieee80211_iface_limit if_limits_chanctx[] = { 32 { 33 .max = 2, 34 .types = BIT(NL80211_IFTYPE_STATION) | 35 BIT(NL80211_IFTYPE_P2P_CLIENT) 36 }, 37 { 38 .max = 1, 39 .types = BIT(NL80211_IFTYPE_AP) | 40 BIT(NL80211_IFTYPE_P2P_GO) 41 } 42 }; 43 44 static const struct ieee80211_iface_combination if_comb_chanctx[] = { 45 { 46 .limits = if_limits_chanctx, 47 .n_limits = ARRAY_SIZE(if_limits_chanctx), 48 .max_interfaces = 2, 49 .num_different_channels = 2, 50 .beacon_int_infra_match = false, 51 } 52 }; 53 54 void mt792x_tx(struct ieee80211_hw *hw, struct ieee80211_tx_control *control, 55 struct sk_buff *skb) 56 { 57 struct mt792x_dev *dev = mt792x_hw_dev(hw); 58 struct mt76_phy *mphy = hw->priv; 59 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 60 struct ieee80211_vif *vif = info->control.vif; 61 struct mt76_wcid *wcid = &dev->mt76.global_wcid; 62 int qid; 63 64 if (control->sta) { 65 struct mt792x_sta *sta; 66 67 sta = (struct mt792x_sta *)control->sta->drv_priv; 68 wcid = &sta->wcid; 69 } 70 71 if (vif && !control->sta) { 72 struct mt792x_vif *mvif; 73 74 mvif = (struct mt792x_vif *)vif->drv_priv; 75 wcid = &mvif->sta.wcid; 76 } 77 78 if (mt76_connac_pm_ref(mphy, &dev->pm)) { 79 mt76_tx(mphy, control->sta, wcid, skb); 80 mt76_connac_pm_unref(mphy, &dev->pm); 81 return; 82 } 83 84 qid = skb_get_queue_mapping(skb); 85 if (qid >= MT_TXQ_PSD) { 86 qid = IEEE80211_AC_BE; 87 skb_set_queue_mapping(skb, qid); 88 } 89 90 mt76_connac_pm_queue_skb(hw, &dev->pm, wcid, skb); 91 } 92 EXPORT_SYMBOL_GPL(mt792x_tx); 93 94 void mt792x_stop(struct ieee80211_hw *hw) 95 { 96 struct mt792x_dev *dev = mt792x_hw_dev(hw); 97 struct mt792x_phy *phy = mt792x_hw_phy(hw); 98 99 cancel_delayed_work_sync(&phy->mt76->mac_work); 100 101 cancel_delayed_work_sync(&dev->pm.ps_work); 102 cancel_work_sync(&dev->pm.wake_work); 103 cancel_work_sync(&dev->reset_work); 104 mt76_connac_free_pending_tx_skbs(&dev->pm, NULL); 105 106 if (is_mt7921(&dev->mt76)) { 107 mt792x_mutex_acquire(dev); 108 mt76_connac_mcu_set_mac_enable(&dev->mt76, 0, false, false); 109 mt792x_mutex_release(dev); 110 } 111 112 clear_bit(MT76_STATE_RUNNING, &phy->mt76->state); 113 } 114 EXPORT_SYMBOL_GPL(mt792x_stop); 115 116 void mt792x_remove_interface(struct ieee80211_hw *hw, 117 struct ieee80211_vif *vif) 118 { 119 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 120 struct mt792x_sta *msta = &mvif->sta; 121 struct mt792x_dev *dev = mt792x_hw_dev(hw); 122 struct mt792x_phy *phy = mt792x_hw_phy(hw); 123 int idx = msta->wcid.idx; 124 125 mt792x_mutex_acquire(dev); 126 mt76_connac_free_pending_tx_skbs(&dev->pm, &msta->wcid); 127 mt76_connac_mcu_uni_add_dev(&dev->mphy, vif, &mvif->sta.wcid, false); 128 129 rcu_assign_pointer(dev->mt76.wcid[idx], NULL); 130 131 dev->mt76.vif_mask &= ~BIT_ULL(mvif->mt76.idx); 132 phy->omac_mask &= ~BIT_ULL(mvif->mt76.omac_idx); 133 mt792x_mutex_release(dev); 134 135 spin_lock_bh(&dev->mt76.sta_poll_lock); 136 if (!list_empty(&msta->wcid.poll_list)) 137 list_del_init(&msta->wcid.poll_list); 138 spin_unlock_bh(&dev->mt76.sta_poll_lock); 139 140 mt76_wcid_cleanup(&dev->mt76, &msta->wcid); 141 } 142 EXPORT_SYMBOL_GPL(mt792x_remove_interface); 143 144 int mt792x_conf_tx(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 145 unsigned int link_id, u16 queue, 146 const struct ieee80211_tx_queue_params *params) 147 { 148 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 149 150 /* no need to update right away, we'll get BSS_CHANGED_QOS */ 151 queue = mt76_connac_lmac_mapping(queue); 152 mvif->queue_params[queue] = *params; 153 154 return 0; 155 } 156 EXPORT_SYMBOL_GPL(mt792x_conf_tx); 157 158 int mt792x_get_stats(struct ieee80211_hw *hw, 159 struct ieee80211_low_level_stats *stats) 160 { 161 struct mt792x_phy *phy = mt792x_hw_phy(hw); 162 struct mt76_mib_stats *mib = &phy->mib; 163 164 mt792x_mutex_acquire(phy->dev); 165 166 stats->dot11RTSSuccessCount = mib->rts_cnt; 167 stats->dot11RTSFailureCount = mib->rts_retries_cnt; 168 stats->dot11FCSErrorCount = mib->fcs_err_cnt; 169 stats->dot11ACKFailureCount = mib->ack_fail_cnt; 170 171 mt792x_mutex_release(phy->dev); 172 173 return 0; 174 } 175 EXPORT_SYMBOL_GPL(mt792x_get_stats); 176 177 u64 mt792x_get_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif) 178 { 179 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 180 struct mt792x_dev *dev = mt792x_hw_dev(hw); 181 u8 omac_idx = mvif->mt76.omac_idx; 182 union { 183 u64 t64; 184 u32 t32[2]; 185 } tsf; 186 u16 n; 187 188 mt792x_mutex_acquire(dev); 189 190 n = omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : omac_idx; 191 /* TSF software read */ 192 mt76_set(dev, MT_LPON_TCR(0, n), MT_LPON_TCR_SW_MODE); 193 tsf.t32[0] = mt76_rr(dev, MT_LPON_UTTR0(0)); 194 tsf.t32[1] = mt76_rr(dev, MT_LPON_UTTR1(0)); 195 196 mt792x_mutex_release(dev); 197 198 return tsf.t64; 199 } 200 EXPORT_SYMBOL_GPL(mt792x_get_tsf); 201 202 void mt792x_set_tsf(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 203 u64 timestamp) 204 { 205 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 206 struct mt792x_dev *dev = mt792x_hw_dev(hw); 207 u8 omac_idx = mvif->mt76.omac_idx; 208 union { 209 u64 t64; 210 u32 t32[2]; 211 } tsf = { .t64 = timestamp, }; 212 u16 n; 213 214 mt792x_mutex_acquire(dev); 215 216 n = omac_idx > HW_BSSID_MAX ? HW_BSSID_0 : omac_idx; 217 mt76_wr(dev, MT_LPON_UTTR0(0), tsf.t32[0]); 218 mt76_wr(dev, MT_LPON_UTTR1(0), tsf.t32[1]); 219 /* TSF software overwrite */ 220 mt76_set(dev, MT_LPON_TCR(0, n), MT_LPON_TCR_SW_WRITE); 221 222 mt792x_mutex_release(dev); 223 } 224 EXPORT_SYMBOL_GPL(mt792x_set_tsf); 225 226 void mt792x_tx_worker(struct mt76_worker *w) 227 { 228 struct mt792x_dev *dev = container_of(w, struct mt792x_dev, 229 mt76.tx_worker); 230 231 if (!mt76_connac_pm_ref(&dev->mphy, &dev->pm)) { 232 queue_work(dev->mt76.wq, &dev->pm.wake_work); 233 return; 234 } 235 236 mt76_txq_schedule_all(&dev->mphy); 237 mt76_connac_pm_unref(&dev->mphy, &dev->pm); 238 } 239 EXPORT_SYMBOL_GPL(mt792x_tx_worker); 240 241 void mt792x_roc_timer(struct timer_list *timer) 242 { 243 struct mt792x_phy *phy = from_timer(phy, timer, roc_timer); 244 245 ieee80211_queue_work(phy->mt76->hw, &phy->roc_work); 246 } 247 EXPORT_SYMBOL_GPL(mt792x_roc_timer); 248 249 void mt792x_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 250 u32 queues, bool drop) 251 { 252 struct mt792x_dev *dev = mt792x_hw_dev(hw); 253 254 wait_event_timeout(dev->mt76.tx_wait, 255 !mt76_has_tx_pending(&dev->mphy), HZ / 2); 256 } 257 EXPORT_SYMBOL_GPL(mt792x_flush); 258 259 int mt792x_assign_vif_chanctx(struct ieee80211_hw *hw, 260 struct ieee80211_vif *vif, 261 struct ieee80211_bss_conf *link_conf, 262 struct ieee80211_chanctx_conf *ctx) 263 { 264 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 265 struct mt792x_dev *dev = mt792x_hw_dev(hw); 266 267 mutex_lock(&dev->mt76.mutex); 268 mvif->mt76.ctx = ctx; 269 mutex_unlock(&dev->mt76.mutex); 270 271 return 0; 272 } 273 EXPORT_SYMBOL_GPL(mt792x_assign_vif_chanctx); 274 275 void mt792x_unassign_vif_chanctx(struct ieee80211_hw *hw, 276 struct ieee80211_vif *vif, 277 struct ieee80211_bss_conf *link_conf, 278 struct ieee80211_chanctx_conf *ctx) 279 { 280 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 281 struct mt792x_dev *dev = mt792x_hw_dev(hw); 282 283 mutex_lock(&dev->mt76.mutex); 284 mvif->mt76.ctx = NULL; 285 mutex_unlock(&dev->mt76.mutex); 286 } 287 EXPORT_SYMBOL_GPL(mt792x_unassign_vif_chanctx); 288 289 void mt792x_set_wakeup(struct ieee80211_hw *hw, bool enabled) 290 { 291 struct mt792x_dev *dev = mt792x_hw_dev(hw); 292 struct mt76_dev *mdev = &dev->mt76; 293 294 device_set_wakeup_enable(mdev->dev, enabled); 295 } 296 EXPORT_SYMBOL_GPL(mt792x_set_wakeup); 297 298 static const char mt792x_gstrings_stats[][ETH_GSTRING_LEN] = { 299 /* tx counters */ 300 "tx_ampdu_cnt", 301 "tx_mpdu_attempts", 302 "tx_mpdu_success", 303 "tx_pkt_ebf_cnt", 304 "tx_pkt_ibf_cnt", 305 "tx_ampdu_len:0-1", 306 "tx_ampdu_len:2-10", 307 "tx_ampdu_len:11-19", 308 "tx_ampdu_len:20-28", 309 "tx_ampdu_len:29-37", 310 "tx_ampdu_len:38-46", 311 "tx_ampdu_len:47-55", 312 "tx_ampdu_len:56-79", 313 "tx_ampdu_len:80-103", 314 "tx_ampdu_len:104-127", 315 "tx_ampdu_len:128-151", 316 "tx_ampdu_len:152-175", 317 "tx_ampdu_len:176-199", 318 "tx_ampdu_len:200-223", 319 "tx_ampdu_len:224-247", 320 "ba_miss_count", 321 "tx_beamformer_ppdu_iBF", 322 "tx_beamformer_ppdu_eBF", 323 "tx_beamformer_rx_feedback_all", 324 "tx_beamformer_rx_feedback_he", 325 "tx_beamformer_rx_feedback_vht", 326 "tx_beamformer_rx_feedback_ht", 327 "tx_msdu_pack_1", 328 "tx_msdu_pack_2", 329 "tx_msdu_pack_3", 330 "tx_msdu_pack_4", 331 "tx_msdu_pack_5", 332 "tx_msdu_pack_6", 333 "tx_msdu_pack_7", 334 "tx_msdu_pack_8", 335 /* rx counters */ 336 "rx_mpdu_cnt", 337 "rx_ampdu_cnt", 338 "rx_ampdu_bytes_cnt", 339 "rx_ba_cnt", 340 /* per vif counters */ 341 "v_tx_mode_cck", 342 "v_tx_mode_ofdm", 343 "v_tx_mode_ht", 344 "v_tx_mode_ht_gf", 345 "v_tx_mode_vht", 346 "v_tx_mode_he_su", 347 "v_tx_mode_he_ext_su", 348 "v_tx_mode_he_tb", 349 "v_tx_mode_he_mu", 350 "v_tx_mode_eht_su", 351 "v_tx_mode_eht_trig", 352 "v_tx_mode_eht_mu", 353 "v_tx_bw_20", 354 "v_tx_bw_40", 355 "v_tx_bw_80", 356 "v_tx_bw_160", 357 "v_tx_mcs_0", 358 "v_tx_mcs_1", 359 "v_tx_mcs_2", 360 "v_tx_mcs_3", 361 "v_tx_mcs_4", 362 "v_tx_mcs_5", 363 "v_tx_mcs_6", 364 "v_tx_mcs_7", 365 "v_tx_mcs_8", 366 "v_tx_mcs_9", 367 "v_tx_mcs_10", 368 "v_tx_mcs_11", 369 "v_tx_mcs_12", 370 "v_tx_mcs_13", 371 "v_tx_nss_1", 372 "v_tx_nss_2", 373 "v_tx_nss_3", 374 "v_tx_nss_4", 375 }; 376 377 void mt792x_get_et_strings(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 378 u32 sset, u8 *data) 379 { 380 if (sset != ETH_SS_STATS) 381 return; 382 383 memcpy(data, mt792x_gstrings_stats, sizeof(mt792x_gstrings_stats)); 384 385 data += sizeof(mt792x_gstrings_stats); 386 page_pool_ethtool_stats_get_strings(data); 387 } 388 EXPORT_SYMBOL_GPL(mt792x_get_et_strings); 389 390 int mt792x_get_et_sset_count(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 391 int sset) 392 { 393 if (sset != ETH_SS_STATS) 394 return 0; 395 396 return ARRAY_SIZE(mt792x_gstrings_stats) + 397 page_pool_ethtool_stats_get_count(); 398 } 399 EXPORT_SYMBOL_GPL(mt792x_get_et_sset_count); 400 401 static void 402 mt792x_ethtool_worker(void *wi_data, struct ieee80211_sta *sta) 403 { 404 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 405 struct mt76_ethtool_worker_info *wi = wi_data; 406 407 if (msta->vif->mt76.idx != wi->idx) 408 return; 409 410 mt76_ethtool_worker(wi, &msta->wcid.stats, true); 411 } 412 413 void mt792x_get_et_stats(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 414 struct ethtool_stats *stats, u64 *data) 415 { 416 struct mt792x_vif *mvif = (struct mt792x_vif *)vif->drv_priv; 417 int stats_size = ARRAY_SIZE(mt792x_gstrings_stats); 418 struct mt792x_phy *phy = mt792x_hw_phy(hw); 419 struct mt792x_dev *dev = phy->dev; 420 struct mt76_mib_stats *mib = &phy->mib; 421 struct mt76_ethtool_worker_info wi = { 422 .data = data, 423 .idx = mvif->mt76.idx, 424 }; 425 int i, ei = 0; 426 427 mt792x_mutex_acquire(dev); 428 429 mt792x_mac_update_mib_stats(phy); 430 431 data[ei++] = mib->tx_ampdu_cnt; 432 data[ei++] = mib->tx_mpdu_attempts_cnt; 433 data[ei++] = mib->tx_mpdu_success_cnt; 434 data[ei++] = mib->tx_pkt_ebf_cnt; 435 data[ei++] = mib->tx_pkt_ibf_cnt; 436 437 /* Tx ampdu stat */ 438 for (i = 0; i < 15; i++) 439 data[ei++] = phy->mt76->aggr_stats[i]; 440 441 data[ei++] = phy->mib.ba_miss_cnt; 442 443 /* Tx Beamformer monitor */ 444 data[ei++] = mib->tx_bf_ibf_ppdu_cnt; 445 data[ei++] = mib->tx_bf_ebf_ppdu_cnt; 446 447 /* Tx Beamformer Rx feedback monitor */ 448 data[ei++] = mib->tx_bf_rx_fb_all_cnt; 449 data[ei++] = mib->tx_bf_rx_fb_he_cnt; 450 data[ei++] = mib->tx_bf_rx_fb_vht_cnt; 451 data[ei++] = mib->tx_bf_rx_fb_ht_cnt; 452 453 /* Tx amsdu info (pack-count histogram) */ 454 for (i = 0; i < ARRAY_SIZE(mib->tx_amsdu); i++) 455 data[ei++] = mib->tx_amsdu[i]; 456 457 /* rx counters */ 458 data[ei++] = mib->rx_mpdu_cnt; 459 data[ei++] = mib->rx_ampdu_cnt; 460 data[ei++] = mib->rx_ampdu_bytes_cnt; 461 data[ei++] = mib->rx_ba_cnt; 462 463 /* Add values for all stations owned by this vif */ 464 wi.initial_stat_idx = ei; 465 ieee80211_iterate_stations_atomic(hw, mt792x_ethtool_worker, &wi); 466 467 mt792x_mutex_release(dev); 468 469 if (!wi.sta_count) 470 return; 471 472 ei += wi.worker_stat_count; 473 474 mt76_ethtool_page_pool_stats(&dev->mt76, &data[ei], &ei); 475 stats_size += page_pool_ethtool_stats_get_count(); 476 477 if (ei != stats_size) 478 dev_err(dev->mt76.dev, "ei: %d SSTATS_LEN: %d", ei, 479 stats_size); 480 } 481 EXPORT_SYMBOL_GPL(mt792x_get_et_stats); 482 483 void mt792x_sta_statistics(struct ieee80211_hw *hw, 484 struct ieee80211_vif *vif, 485 struct ieee80211_sta *sta, 486 struct station_info *sinfo) 487 { 488 struct mt792x_sta *msta = (struct mt792x_sta *)sta->drv_priv; 489 struct rate_info *txrate = &msta->wcid.rate; 490 491 if (!txrate->legacy && !txrate->flags) 492 return; 493 494 if (txrate->legacy) { 495 sinfo->txrate.legacy = txrate->legacy; 496 } else { 497 sinfo->txrate.mcs = txrate->mcs; 498 sinfo->txrate.nss = txrate->nss; 499 sinfo->txrate.bw = txrate->bw; 500 sinfo->txrate.he_gi = txrate->he_gi; 501 sinfo->txrate.he_dcm = txrate->he_dcm; 502 sinfo->txrate.he_ru_alloc = txrate->he_ru_alloc; 503 } 504 sinfo->tx_failed = msta->wcid.stats.tx_failed; 505 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_FAILED); 506 507 sinfo->tx_retries = msta->wcid.stats.tx_retries; 508 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_RETRIES); 509 510 sinfo->txrate.flags = txrate->flags; 511 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 512 513 sinfo->ack_signal = (s8)msta->ack_signal; 514 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL); 515 516 sinfo->avg_ack_signal = -(s8)ewma_avg_signal_read(&msta->avg_ack_signal); 517 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_ACK_SIGNAL_AVG); 518 } 519 EXPORT_SYMBOL_GPL(mt792x_sta_statistics); 520 521 void mt792x_set_coverage_class(struct ieee80211_hw *hw, s16 coverage_class) 522 { 523 struct mt792x_phy *phy = mt792x_hw_phy(hw); 524 struct mt792x_dev *dev = phy->dev; 525 526 mt792x_mutex_acquire(dev); 527 528 phy->coverage_class = max_t(s16, coverage_class, 0); 529 mt792x_mac_set_timeing(phy); 530 531 mt792x_mutex_release(dev); 532 } 533 EXPORT_SYMBOL_GPL(mt792x_set_coverage_class); 534 535 int mt792x_init_wiphy(struct ieee80211_hw *hw) 536 { 537 struct mt792x_phy *phy = mt792x_hw_phy(hw); 538 struct mt792x_dev *dev = phy->dev; 539 struct wiphy *wiphy = hw->wiphy; 540 541 hw->queues = 4; 542 if (dev->has_eht) { 543 hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_EHT; 544 hw->max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_EHT; 545 } else { 546 hw->max_rx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 547 hw->max_tx_aggregation_subframes = IEEE80211_MAX_AMPDU_BUF_HE; 548 } 549 hw->netdev_features = NETIF_F_RXCSUM; 550 551 hw->radiotap_timestamp.units_pos = 552 IEEE80211_RADIOTAP_TIMESTAMP_UNIT_US; 553 554 phy->slottime = 9; 555 556 hw->sta_data_size = sizeof(struct mt792x_sta); 557 hw->vif_data_size = sizeof(struct mt792x_vif); 558 559 if (dev->fw_features & MT792x_FW_CAP_CNM) { 560 wiphy->flags |= WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 561 wiphy->iface_combinations = if_comb_chanctx; 562 wiphy->n_iface_combinations = ARRAY_SIZE(if_comb_chanctx); 563 } else { 564 wiphy->flags &= ~WIPHY_FLAG_HAS_REMAIN_ON_CHANNEL; 565 wiphy->iface_combinations = if_comb; 566 wiphy->n_iface_combinations = ARRAY_SIZE(if_comb); 567 } 568 wiphy->flags &= ~(WIPHY_FLAG_IBSS_RSN | WIPHY_FLAG_4ADDR_AP | 569 WIPHY_FLAG_4ADDR_STATION); 570 wiphy->interface_modes = BIT(NL80211_IFTYPE_STATION) | 571 BIT(NL80211_IFTYPE_AP) | 572 BIT(NL80211_IFTYPE_P2P_CLIENT) | 573 BIT(NL80211_IFTYPE_P2P_GO); 574 wiphy->max_remain_on_channel_duration = 5000; 575 wiphy->max_scan_ie_len = MT76_CONNAC_SCAN_IE_LEN; 576 wiphy->max_scan_ssids = 4; 577 wiphy->max_sched_scan_plan_interval = 578 MT76_CONNAC_MAX_TIME_SCHED_SCAN_INTERVAL; 579 wiphy->max_sched_scan_ie_len = IEEE80211_MAX_DATA_LEN; 580 wiphy->max_sched_scan_ssids = MT76_CONNAC_MAX_SCHED_SCAN_SSID; 581 wiphy->max_match_sets = MT76_CONNAC_MAX_SCAN_MATCH; 582 wiphy->max_sched_scan_reqs = 1; 583 wiphy->flags |= WIPHY_FLAG_HAS_CHANNEL_SWITCH | 584 WIPHY_FLAG_SPLIT_SCAN_6GHZ; 585 586 wiphy->features |= NL80211_FEATURE_SCHED_SCAN_RANDOM_MAC_ADDR | 587 NL80211_FEATURE_SCAN_RANDOM_MAC_ADDR; 588 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_SET_SCAN_DWELL); 589 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_LEGACY); 590 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_HT); 591 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_VHT); 592 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_BEACON_RATE_HE); 593 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_ACK_SIGNAL_SUPPORT); 594 wiphy_ext_feature_set(wiphy, NL80211_EXT_FEATURE_CAN_REPLACE_PTK0); 595 596 ieee80211_hw_set(hw, SINGLE_SCAN_ON_ALL_BANDS); 597 ieee80211_hw_set(hw, HAS_RATE_CONTROL); 598 ieee80211_hw_set(hw, SUPPORTS_TX_ENCAP_OFFLOAD); 599 ieee80211_hw_set(hw, SUPPORTS_RX_DECAP_OFFLOAD); 600 ieee80211_hw_set(hw, WANT_MONITOR_VIF); 601 ieee80211_hw_set(hw, SUPPORTS_PS); 602 ieee80211_hw_set(hw, SUPPORTS_DYNAMIC_PS); 603 ieee80211_hw_set(hw, SUPPORTS_VHT_EXT_NSS_BW); 604 ieee80211_hw_set(hw, CONNECTION_MONITOR); 605 606 if (dev->pm.enable) 607 ieee80211_hw_set(hw, CONNECTION_MONITOR); 608 609 hw->max_tx_fragments = 4; 610 611 return 0; 612 } 613 EXPORT_SYMBOL_GPL(mt792x_init_wiphy); 614 615 static u8 616 mt792x_get_offload_capability(struct device *dev, const char *fw_wm) 617 { 618 const struct mt76_connac2_fw_trailer *hdr; 619 struct mt792x_realease_info *rel_info; 620 const struct firmware *fw; 621 int ret, i, offset = 0; 622 const u8 *data, *end; 623 u8 offload_caps = 0; 624 625 ret = request_firmware(&fw, fw_wm, dev); 626 if (ret) 627 return ret; 628 629 if (!fw || !fw->data || fw->size < sizeof(*hdr)) { 630 dev_err(dev, "Invalid firmware\n"); 631 goto out; 632 } 633 634 data = fw->data; 635 hdr = (const void *)(fw->data + fw->size - sizeof(*hdr)); 636 637 for (i = 0; i < hdr->n_region; i++) { 638 const struct mt76_connac2_fw_region *region; 639 640 region = (const void *)((const u8 *)hdr - 641 (hdr->n_region - i) * sizeof(*region)); 642 offset += le32_to_cpu(region->len); 643 } 644 645 data += offset + 16; 646 rel_info = (struct mt792x_realease_info *)data; 647 data += sizeof(*rel_info); 648 end = data + le16_to_cpu(rel_info->len); 649 650 while (data < end) { 651 rel_info = (struct mt792x_realease_info *)data; 652 data += sizeof(*rel_info); 653 654 if (rel_info->tag == MT792x_FW_TAG_FEATURE) { 655 struct mt792x_fw_features *features; 656 657 features = (struct mt792x_fw_features *)data; 658 offload_caps = features->data; 659 break; 660 } 661 662 data += le16_to_cpu(rel_info->len) + rel_info->pad_len; 663 } 664 665 out: 666 release_firmware(fw); 667 668 return offload_caps; 669 } 670 671 struct ieee80211_ops * 672 mt792x_get_mac80211_ops(struct device *dev, 673 const struct ieee80211_ops *mac80211_ops, 674 void *drv_data, u8 *fw_features) 675 { 676 struct ieee80211_ops *ops; 677 678 ops = devm_kmemdup(dev, mac80211_ops, sizeof(struct ieee80211_ops), 679 GFP_KERNEL); 680 if (!ops) 681 return NULL; 682 683 *fw_features = mt792x_get_offload_capability(dev, drv_data); 684 if (!(*fw_features & MT792x_FW_CAP_CNM)) { 685 ops->remain_on_channel = NULL; 686 ops->cancel_remain_on_channel = NULL; 687 ops->add_chanctx = NULL; 688 ops->remove_chanctx = NULL; 689 ops->change_chanctx = NULL; 690 ops->assign_vif_chanctx = NULL; 691 ops->unassign_vif_chanctx = NULL; 692 ops->mgd_prepare_tx = NULL; 693 ops->mgd_complete_tx = NULL; 694 } 695 return ops; 696 } 697 EXPORT_SYMBOL_GPL(mt792x_get_mac80211_ops); 698 699 int mt792x_init_wcid(struct mt792x_dev *dev) 700 { 701 int idx; 702 703 /* Beacon and mgmt frames should occupy wcid 0 */ 704 idx = mt76_wcid_alloc(dev->mt76.wcid_mask, MT792x_WTBL_STA - 1); 705 if (idx) 706 return -ENOSPC; 707 708 dev->mt76.global_wcid.idx = idx; 709 dev->mt76.global_wcid.hw_key_idx = -1; 710 dev->mt76.global_wcid.tx_info |= MT_WCID_TX_INFO_SET; 711 rcu_assign_pointer(dev->mt76.wcid[idx], &dev->mt76.global_wcid); 712 713 return 0; 714 } 715 EXPORT_SYMBOL_GPL(mt792x_init_wcid); 716 717 int mt792x_mcu_drv_pmctrl(struct mt792x_dev *dev) 718 { 719 struct mt76_phy *mphy = &dev->mt76.phy; 720 struct mt76_connac_pm *pm = &dev->pm; 721 int err = 0; 722 723 mutex_lock(&pm->mutex); 724 725 if (!test_bit(MT76_STATE_PM, &mphy->state)) 726 goto out; 727 728 err = __mt792x_mcu_drv_pmctrl(dev); 729 out: 730 mutex_unlock(&pm->mutex); 731 732 if (err) 733 mt792x_reset(&dev->mt76); 734 735 return err; 736 } 737 EXPORT_SYMBOL_GPL(mt792x_mcu_drv_pmctrl); 738 739 int mt792x_mcu_fw_pmctrl(struct mt792x_dev *dev) 740 { 741 struct mt76_phy *mphy = &dev->mt76.phy; 742 struct mt76_connac_pm *pm = &dev->pm; 743 int err = 0; 744 745 mutex_lock(&pm->mutex); 746 747 if (mt76_connac_skip_fw_pmctrl(mphy, pm)) 748 goto out; 749 750 err = __mt792x_mcu_fw_pmctrl(dev); 751 out: 752 mutex_unlock(&pm->mutex); 753 754 if (err) 755 mt792x_reset(&dev->mt76); 756 757 return err; 758 } 759 EXPORT_SYMBOL_GPL(mt792x_mcu_fw_pmctrl); 760 761 int __mt792xe_mcu_drv_pmctrl(struct mt792x_dev *dev) 762 { 763 int i, err = 0; 764 765 for (i = 0; i < MT792x_DRV_OWN_RETRY_COUNT; i++) { 766 mt76_wr(dev, MT_CONN_ON_LPCTL, PCIE_LPCR_HOST_CLR_OWN); 767 if (mt76_poll_msec_tick(dev, MT_CONN_ON_LPCTL, 768 PCIE_LPCR_HOST_OWN_SYNC, 0, 50, 1)) 769 break; 770 } 771 772 if (i == MT792x_DRV_OWN_RETRY_COUNT) { 773 dev_err(dev->mt76.dev, "driver own failed\n"); 774 err = -EIO; 775 } 776 777 return err; 778 } 779 EXPORT_SYMBOL_GPL(__mt792xe_mcu_drv_pmctrl); 780 781 int mt792xe_mcu_drv_pmctrl(struct mt792x_dev *dev) 782 { 783 struct mt76_phy *mphy = &dev->mt76.phy; 784 struct mt76_connac_pm *pm = &dev->pm; 785 int err; 786 787 err = __mt792xe_mcu_drv_pmctrl(dev); 788 if (err < 0) 789 goto out; 790 791 mt792x_wpdma_reinit_cond(dev); 792 clear_bit(MT76_STATE_PM, &mphy->state); 793 794 pm->stats.last_wake_event = jiffies; 795 pm->stats.doze_time += pm->stats.last_wake_event - 796 pm->stats.last_doze_event; 797 out: 798 return err; 799 } 800 EXPORT_SYMBOL_GPL(mt792xe_mcu_drv_pmctrl); 801 802 int mt792xe_mcu_fw_pmctrl(struct mt792x_dev *dev) 803 { 804 struct mt76_phy *mphy = &dev->mt76.phy; 805 struct mt76_connac_pm *pm = &dev->pm; 806 int i; 807 808 for (i = 0; i < MT792x_DRV_OWN_RETRY_COUNT; i++) { 809 mt76_wr(dev, MT_CONN_ON_LPCTL, PCIE_LPCR_HOST_SET_OWN); 810 if (mt76_poll_msec_tick(dev, MT_CONN_ON_LPCTL, 811 PCIE_LPCR_HOST_OWN_SYNC, 4, 50, 1)) 812 break; 813 } 814 815 if (i == MT792x_DRV_OWN_RETRY_COUNT) { 816 dev_err(dev->mt76.dev, "firmware own failed\n"); 817 clear_bit(MT76_STATE_PM, &mphy->state); 818 return -EIO; 819 } 820 821 pm->stats.last_doze_event = jiffies; 822 pm->stats.awake_time += pm->stats.last_doze_event - 823 pm->stats.last_wake_event; 824 825 return 0; 826 } 827 EXPORT_SYMBOL_GPL(mt792xe_mcu_fw_pmctrl); 828 829 int mt792x_load_firmware(struct mt792x_dev *dev) 830 { 831 int ret; 832 833 ret = mt76_connac2_load_patch(&dev->mt76, mt792x_patch_name(dev)); 834 if (ret) 835 return ret; 836 837 if (mt76_is_sdio(&dev->mt76)) { 838 /* activate again */ 839 ret = __mt792x_mcu_fw_pmctrl(dev); 840 if (!ret) 841 ret = __mt792x_mcu_drv_pmctrl(dev); 842 } 843 844 ret = mt76_connac2_load_ram(&dev->mt76, mt792x_ram_name(dev), NULL); 845 if (ret) 846 return ret; 847 848 if (!mt76_poll_msec(dev, MT_CONN_ON_MISC, MT_TOP_MISC2_FW_N9_RDY, 849 MT_TOP_MISC2_FW_N9_RDY, 1500)) { 850 dev_err(dev->mt76.dev, "Timeout for initializing firmware\n"); 851 852 return -EIO; 853 } 854 855 #ifdef CONFIG_PM 856 dev->mt76.hw->wiphy->wowlan = &mt76_connac_wowlan_support; 857 #endif /* CONFIG_PM */ 858 859 dev_dbg(dev->mt76.dev, "Firmware init done\n"); 860 861 return 0; 862 } 863 EXPORT_SYMBOL_GPL(mt792x_load_firmware); 864 865 MODULE_LICENSE("Dual BSD/GPL"); 866 MODULE_AUTHOR("Lorenzo Bianconi <lorenzo@kernel.org>"); 867