1 // SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause 2 /* Copyright(c) 2019-2020 Realtek Corporation 3 */ 4 5 #include "cam.h" 6 #include "chan.h" 7 #include "coex.h" 8 #include "debug.h" 9 #include "fw.h" 10 #include "mac.h" 11 #include "phy.h" 12 #include "ps.h" 13 #include "reg.h" 14 #include "sar.h" 15 #include "ser.h" 16 #include "util.h" 17 #include "wow.h" 18 19 static void rtw89_ops_tx(struct ieee80211_hw *hw, 20 struct ieee80211_tx_control *control, 21 struct sk_buff *skb) 22 { 23 struct rtw89_dev *rtwdev = hw->priv; 24 struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb); 25 struct ieee80211_vif *vif = info->control.vif; 26 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 27 struct ieee80211_sta *sta = control->sta; 28 u32 flags = IEEE80211_SKB_CB(skb)->flags; 29 int ret, qsel; 30 31 if (rtwvif->offchan && !(flags & IEEE80211_TX_CTL_TX_OFFCHAN) && sta) { 32 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 33 34 rtw89_debug(rtwdev, RTW89_DBG_TXRX, "ops_tx during offchan\n"); 35 skb_queue_tail(&rtwsta->roc_queue, skb); 36 return; 37 } 38 39 ret = rtw89_core_tx_write(rtwdev, vif, sta, skb, &qsel); 40 if (ret) { 41 rtw89_err(rtwdev, "failed to transmit skb: %d\n", ret); 42 ieee80211_free_txskb(hw, skb); 43 return; 44 } 45 rtw89_core_tx_kick_off(rtwdev, qsel); 46 } 47 48 static void rtw89_ops_wake_tx_queue(struct ieee80211_hw *hw, 49 struct ieee80211_txq *txq) 50 { 51 struct rtw89_dev *rtwdev = hw->priv; 52 53 ieee80211_schedule_txq(hw, txq); 54 queue_work(rtwdev->txq_wq, &rtwdev->txq_work); 55 } 56 57 static int rtw89_ops_start(struct ieee80211_hw *hw) 58 { 59 struct rtw89_dev *rtwdev = hw->priv; 60 61 lockdep_assert_wiphy(hw->wiphy); 62 63 return rtw89_core_start(rtwdev); 64 } 65 66 static void rtw89_ops_stop(struct ieee80211_hw *hw, bool suspend) 67 { 68 struct rtw89_dev *rtwdev = hw->priv; 69 70 lockdep_assert_wiphy(hw->wiphy); 71 72 rtw89_core_stop(rtwdev); 73 } 74 75 static int rtw89_ops_config(struct ieee80211_hw *hw, int radio_idx, u32 changed) 76 { 77 struct rtw89_dev *rtwdev = hw->priv; 78 79 lockdep_assert_wiphy(hw->wiphy); 80 81 /* let previous ips work finish to ensure we don't leave ips twice */ 82 wiphy_work_cancel(hw->wiphy, &rtwdev->ips_work); 83 84 rtw89_leave_ps_mode(rtwdev); 85 86 if ((changed & IEEE80211_CONF_CHANGE_IDLE) && 87 !(hw->conf.flags & IEEE80211_CONF_IDLE)) 88 rtw89_leave_ips(rtwdev); 89 90 if (changed & IEEE80211_CONF_CHANGE_CHANNEL) { 91 rtw89_config_entity_chandef(rtwdev, RTW89_CHANCTX_0, 92 &hw->conf.chandef); 93 rtw89_set_channel(rtwdev); 94 } 95 96 if ((changed & IEEE80211_CONF_CHANGE_IDLE) && 97 (hw->conf.flags & IEEE80211_CONF_IDLE) && 98 !rtwdev->scanning) 99 rtw89_enter_ips(rtwdev); 100 101 return 0; 102 } 103 104 static int __rtw89_ops_add_iface_link(struct rtw89_dev *rtwdev, 105 struct rtw89_vif_link *rtwvif_link) 106 { 107 struct ieee80211_bss_conf *bss_conf; 108 int ret; 109 110 rtw89_leave_ps_mode(rtwdev); 111 112 rtw89_vif_type_mapping(rtwvif_link, false); 113 114 wiphy_work_init(&rtwvif_link->update_beacon_work, rtw89_core_update_beacon_work); 115 wiphy_delayed_work_init(&rtwvif_link->csa_beacon_work, rtw89_core_csa_beacon_work); 116 wiphy_delayed_work_init(&rtwvif_link->mcc_gc_detect_beacon_work, 117 rtw89_mcc_gc_detect_beacon_work); 118 119 INIT_LIST_HEAD(&rtwvif_link->general_pkt_list); 120 121 rtw89_p2p_noa_once_init(rtwvif_link); 122 123 rtwvif_link->hit_rule = 0; 124 rtwvif_link->bcn_hit_cond = 0; 125 rtwvif_link->chanctx_assigned = false; 126 rtwvif_link->chanctx_idx = RTW89_CHANCTX_0; 127 rtwvif_link->reg_6ghz_power = RTW89_REG_6GHZ_POWER_DFLT; 128 rtwvif_link->rand_tsf_done = false; 129 rtwvif_link->detect_bcn_count = 0; 130 rtwvif_link->last_sync_bcn_tsf = 0; 131 132 rcu_read_lock(); 133 134 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 135 ether_addr_copy(rtwvif_link->mac_addr, bss_conf->addr); 136 137 rcu_read_unlock(); 138 139 ret = rtw89_mac_add_vif(rtwdev, rtwvif_link); 140 if (ret) 141 return ret; 142 143 rtw89_btc_ntfy_role_info(rtwdev, rtwvif_link, NULL, BTC_ROLE_START); 144 return 0; 145 } 146 147 static void __rtw89_ops_remove_iface_link(struct rtw89_dev *rtwdev, 148 struct rtw89_vif_link *rtwvif_link) 149 { 150 lockdep_assert_wiphy(rtwdev->hw->wiphy); 151 152 wiphy_work_cancel(rtwdev->hw->wiphy, &rtwvif_link->update_beacon_work); 153 wiphy_delayed_work_cancel(rtwdev->hw->wiphy, &rtwvif_link->csa_beacon_work); 154 wiphy_delayed_work_cancel(rtwdev->hw->wiphy, 155 &rtwvif_link->mcc_gc_detect_beacon_work); 156 157 rtw89_p2p_noa_once_deinit(rtwvif_link); 158 159 rtw89_leave_ps_mode(rtwdev); 160 161 rtw89_btc_ntfy_role_info(rtwdev, rtwvif_link, NULL, BTC_ROLE_STOP); 162 163 rtw89_mac_remove_vif(rtwdev, rtwvif_link); 164 } 165 166 static int rtw89_ops_add_interface(struct ieee80211_hw *hw, 167 struct ieee80211_vif *vif) 168 { 169 struct rtw89_dev *rtwdev = hw->priv; 170 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 171 struct rtw89_vif_link *rtwvif_link; 172 u8 mac_id, port; 173 int ret = 0; 174 175 lockdep_assert_wiphy(hw->wiphy); 176 177 rtw89_debug(rtwdev, RTW89_DBG_STATE, "add vif %pM type %d, p2p %d\n", 178 vif->addr, vif->type, vif->p2p); 179 180 rtw89_leave_ips_by_hwflags(rtwdev); 181 182 if (RTW89_CHK_FW_FEATURE(BEACON_FILTER, &rtwdev->fw)) 183 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 184 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 185 186 mac_id = rtw89_acquire_mac_id(rtwdev); 187 if (mac_id == RTW89_MAX_MAC_ID_NUM) 188 return -ENOSPC; 189 190 port = rtw89_core_acquire_bit_map(rtwdev->hw_port, RTW89_PORT_NUM); 191 if (port == RTW89_PORT_NUM) { 192 ret = -ENOSPC; 193 goto release_macid; 194 } 195 196 rtw89_init_vif(rtwdev, rtwvif, mac_id, port); 197 198 rtw89_core_txq_init(rtwdev, vif->txq); 199 200 if (!rtw89_rtwvif_in_list(rtwdev, rtwvif)) { 201 list_add_tail(&rtwvif->list, &rtwdev->rtwvifs_list); 202 INIT_LIST_HEAD(&rtwvif->mgnt_entry); 203 INIT_LIST_HEAD(&rtwvif->dlink_pool); 204 } 205 206 ether_addr_copy(rtwvif->mac_addr, vif->addr); 207 208 rtwvif->offchan = false; 209 rtwvif->roc.state = RTW89_ROC_IDLE; 210 wiphy_delayed_work_init(&rtwvif->roc.roc_work, rtw89_roc_work); 211 212 rtw89_traffic_stats_init(rtwdev, &rtwvif->stats); 213 214 rtwvif_link = rtw89_vif_set_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 215 if (!rtwvif_link) { 216 ret = -EINVAL; 217 goto release_port; 218 } 219 220 ret = __rtw89_ops_add_iface_link(rtwdev, rtwvif_link); 221 if (ret) 222 goto unset_link; 223 224 rtwdev->pure_monitor_mode_vif = vif->type == NL80211_IFTYPE_MONITOR ? 225 rtwvif : NULL; 226 rtw89_recalc_lps(rtwdev); 227 return 0; 228 229 unset_link: 230 rtw89_vif_unset_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 231 release_port: 232 list_del_init(&rtwvif->list); 233 rtw89_core_release_bit_map(rtwdev->hw_port, port); 234 release_macid: 235 rtw89_release_mac_id(rtwdev, mac_id); 236 237 return ret; 238 } 239 240 static void rtw89_ops_remove_interface(struct ieee80211_hw *hw, 241 struct ieee80211_vif *vif) 242 { 243 struct rtw89_dev *rtwdev = hw->priv; 244 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 245 u8 macid = rtw89_vif_get_main_macid(rtwvif); 246 u8 port = rtw89_vif_get_main_port(rtwvif); 247 struct rtw89_vif_link *rtwvif_link; 248 249 lockdep_assert_wiphy(hw->wiphy); 250 251 rtw89_debug(rtwdev, RTW89_DBG_STATE, "remove vif %pM type %d p2p %d\n", 252 vif->addr, vif->type, vif->p2p); 253 254 wiphy_delayed_work_cancel(hw->wiphy, &rtwvif->roc.roc_work); 255 256 rtwvif_link = rtwvif->links[RTW89_VIF_IDLE_LINK_ID]; 257 if (unlikely(!rtwvif_link)) { 258 rtw89_err(rtwdev, 259 "%s: rtwvif link (link_id %u) is not active\n", 260 __func__, RTW89_VIF_IDLE_LINK_ID); 261 goto bottom; 262 } 263 264 __rtw89_ops_remove_iface_link(rtwdev, rtwvif_link); 265 266 rtw89_vif_unset_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 267 268 bottom: 269 list_del_init(&rtwvif->list); 270 rtw89_core_release_bit_map(rtwdev->hw_port, port); 271 rtw89_release_mac_id(rtwdev, macid); 272 273 rtwdev->pure_monitor_mode_vif = NULL; 274 275 rtw89_recalc_lps(rtwdev); 276 rtw89_enter_ips_by_hwflags(rtwdev); 277 } 278 279 static int rtw89_ops_change_interface(struct ieee80211_hw *hw, 280 struct ieee80211_vif *vif, 281 enum nl80211_iftype type, bool p2p) 282 { 283 struct rtw89_dev *rtwdev = hw->priv; 284 int ret; 285 286 set_bit(RTW89_FLAG_CHANGING_INTERFACE, rtwdev->flags); 287 288 rtw89_debug(rtwdev, RTW89_DBG_STATE, "change vif %pM (%d)->(%d), p2p (%d)->(%d)\n", 289 vif->addr, vif->type, type, vif->p2p, p2p); 290 291 rtw89_ops_remove_interface(hw, vif); 292 293 vif->type = type; 294 vif->p2p = p2p; 295 296 ret = rtw89_ops_add_interface(hw, vif); 297 if (ret) 298 rtw89_warn(rtwdev, "failed to change interface %d\n", ret); 299 300 clear_bit(RTW89_FLAG_CHANGING_INTERFACE, rtwdev->flags); 301 302 return ret; 303 } 304 305 static void rtw89_ops_configure_filter(struct ieee80211_hw *hw, 306 unsigned int changed_flags, 307 unsigned int *new_flags, 308 u64 multicast) 309 { 310 struct rtw89_dev *rtwdev = hw->priv; 311 u32 rx_fltr; 312 313 lockdep_assert_wiphy(hw->wiphy); 314 315 rtw89_leave_ps_mode(rtwdev); 316 317 *new_flags &= FIF_ALLMULTI | FIF_OTHER_BSS | FIF_FCSFAIL | 318 FIF_BCN_PRBRESP_PROMISC | FIF_PROBE_REQ; 319 320 if (changed_flags & FIF_ALLMULTI) { 321 if (*new_flags & FIF_ALLMULTI) 322 rtwdev->hal.rx_fltr &= ~B_AX_A_MC; 323 else 324 rtwdev->hal.rx_fltr |= B_AX_A_MC; 325 } 326 if (changed_flags & FIF_FCSFAIL) { 327 if (*new_flags & FIF_FCSFAIL) 328 rtwdev->hal.rx_fltr |= B_AX_A_CRC32_ERR; 329 else 330 rtwdev->hal.rx_fltr &= ~B_AX_A_CRC32_ERR; 331 } 332 if (changed_flags & FIF_OTHER_BSS) { 333 if (*new_flags & FIF_OTHER_BSS) 334 rtwdev->hal.rx_fltr &= ~B_AX_A_A1_MATCH; 335 else 336 rtwdev->hal.rx_fltr |= B_AX_A_A1_MATCH; 337 } 338 if (changed_flags & FIF_BCN_PRBRESP_PROMISC) { 339 if (*new_flags & FIF_BCN_PRBRESP_PROMISC) { 340 rtwdev->hal.rx_fltr &= ~B_AX_A_BCN_CHK_EN; 341 rtwdev->hal.rx_fltr &= ~B_AX_A_BC; 342 rtwdev->hal.rx_fltr &= ~B_AX_A_A1_MATCH; 343 } else { 344 rtwdev->hal.rx_fltr |= B_AX_A_BCN_CHK_EN; 345 rtwdev->hal.rx_fltr |= B_AX_A_BC; 346 rtwdev->hal.rx_fltr |= B_AX_A_A1_MATCH; 347 } 348 } 349 if (changed_flags & FIF_PROBE_REQ) { 350 if (*new_flags & FIF_PROBE_REQ) { 351 rtwdev->hal.rx_fltr &= ~B_AX_A_BC_CAM_MATCH; 352 rtwdev->hal.rx_fltr &= ~B_AX_A_UC_CAM_MATCH; 353 } else { 354 rtwdev->hal.rx_fltr |= B_AX_A_BC_CAM_MATCH; 355 rtwdev->hal.rx_fltr |= B_AX_A_UC_CAM_MATCH; 356 } 357 } 358 359 rx_fltr = rtwdev->hal.rx_fltr; 360 361 /* mac80211 doesn't configure filter when HW scan, driver need to 362 * set by itself. However, during P2P scan might have configure 363 * filter to overwrite filter that HW scan needed, so we need to 364 * check scan and append related filter 365 */ 366 if (rtwdev->scanning) { 367 rx_fltr &= ~B_AX_A_BCN_CHK_EN; 368 rx_fltr &= ~B_AX_A_BC; 369 rx_fltr &= ~B_AX_A_A1_MATCH; 370 } 371 372 rtw89_mac_set_rx_fltr(rtwdev, RTW89_MAC_0, rx_fltr); 373 if (!rtwdev->dbcc_en) 374 return; 375 rtw89_mac_set_rx_fltr(rtwdev, RTW89_MAC_1, rx_fltr); 376 } 377 378 static const u8 ac_to_fw_idx[IEEE80211_NUM_ACS] = { 379 [IEEE80211_AC_VO] = 3, 380 [IEEE80211_AC_VI] = 2, 381 [IEEE80211_AC_BE] = 0, 382 [IEEE80211_AC_BK] = 1, 383 }; 384 385 static u8 rtw89_aifsn_to_aifs(struct rtw89_dev *rtwdev, 386 struct rtw89_vif_link *rtwvif_link, u8 aifsn) 387 { 388 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, 389 rtwvif_link->chanctx_idx); 390 struct ieee80211_bss_conf *bss_conf; 391 u8 slot_time; 392 u8 sifs; 393 394 rcu_read_lock(); 395 396 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 397 slot_time = bss_conf->use_short_slot ? 9 : 20; 398 399 rcu_read_unlock(); 400 401 sifs = chan->band_type == RTW89_BAND_2G ? 10 : 16; 402 403 return aifsn * slot_time + sifs; 404 } 405 406 static void ____rtw89_conf_tx_edca(struct rtw89_dev *rtwdev, 407 struct rtw89_vif_link *rtwvif_link, u16 ac) 408 { 409 struct ieee80211_tx_queue_params *params = &rtwvif_link->tx_params[ac]; 410 u32 val; 411 u8 ecw_max, ecw_min; 412 u8 aifs; 413 414 /* 2^ecw - 1 = cw; ecw = log2(cw + 1) */ 415 ecw_max = ilog2(params->cw_max + 1); 416 ecw_min = ilog2(params->cw_min + 1); 417 aifs = rtw89_aifsn_to_aifs(rtwdev, rtwvif_link, params->aifs); 418 val = FIELD_PREP(FW_EDCA_PARAM_TXOPLMT_MSK, params->txop) | 419 FIELD_PREP(FW_EDCA_PARAM_CWMAX_MSK, ecw_max) | 420 FIELD_PREP(FW_EDCA_PARAM_CWMIN_MSK, ecw_min) | 421 FIELD_PREP(FW_EDCA_PARAM_AIFS_MSK, aifs); 422 rtw89_fw_h2c_set_edca(rtwdev, rtwvif_link, ac_to_fw_idx[ac], val); 423 } 424 425 #define R_MUEDCA_ACS_PARAM(acs) {R_AX_MUEDCA_ ## acs ## _PARAM_0, \ 426 R_BE_MUEDCA_ ## acs ## _PARAM_0} 427 428 static const u32 ac_to_mu_edca_param[IEEE80211_NUM_ACS][RTW89_CHIP_GEN_NUM] = { 429 [IEEE80211_AC_VO] = R_MUEDCA_ACS_PARAM(VO), 430 [IEEE80211_AC_VI] = R_MUEDCA_ACS_PARAM(VI), 431 [IEEE80211_AC_BE] = R_MUEDCA_ACS_PARAM(BE), 432 [IEEE80211_AC_BK] = R_MUEDCA_ACS_PARAM(BK), 433 }; 434 435 static void ____rtw89_conf_tx_mu_edca(struct rtw89_dev *rtwdev, 436 struct rtw89_vif_link *rtwvif_link, u16 ac) 437 { 438 struct ieee80211_tx_queue_params *params = &rtwvif_link->tx_params[ac]; 439 struct ieee80211_he_mu_edca_param_ac_rec *mu_edca; 440 int gen = rtwdev->chip->chip_gen; 441 u8 aifs, aifsn; 442 u16 timer_32us; 443 u32 reg; 444 u32 val; 445 446 if (!params->mu_edca) 447 return; 448 449 mu_edca = ¶ms->mu_edca_param_rec; 450 aifsn = FIELD_GET(GENMASK(3, 0), mu_edca->aifsn); 451 aifs = aifsn ? rtw89_aifsn_to_aifs(rtwdev, rtwvif_link, aifsn) : 0; 452 timer_32us = mu_edca->mu_edca_timer << 8; 453 454 val = FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_TIMER_MASK, timer_32us) | 455 FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_CW_MASK, mu_edca->ecw_min_max) | 456 FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_AIFS_MASK, aifs); 457 reg = rtw89_mac_reg_by_idx(rtwdev, ac_to_mu_edca_param[ac][gen], 458 rtwvif_link->mac_idx); 459 rtw89_write32(rtwdev, reg, val); 460 461 rtw89_mac_set_hw_muedca_ctrl(rtwdev, rtwvif_link, true); 462 } 463 464 static void __rtw89_conf_tx(struct rtw89_dev *rtwdev, 465 struct rtw89_vif_link *rtwvif_link, u16 ac) 466 { 467 ____rtw89_conf_tx_edca(rtwdev, rtwvif_link, ac); 468 ____rtw89_conf_tx_mu_edca(rtwdev, rtwvif_link, ac); 469 } 470 471 static void rtw89_conf_tx(struct rtw89_dev *rtwdev, 472 struct rtw89_vif_link *rtwvif_link) 473 { 474 u16 ac; 475 476 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 477 __rtw89_conf_tx(rtwdev, rtwvif_link, ac); 478 } 479 480 static int __rtw89_ops_sta_add(struct rtw89_dev *rtwdev, 481 struct ieee80211_vif *vif, 482 struct ieee80211_sta *sta) 483 { 484 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 485 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 486 struct rtw89_vif_link *rtwvif_link; 487 struct rtw89_sta_link *rtwsta_link; 488 bool acquire_macid = false; 489 u8 macid; 490 int ret; 491 int i; 492 493 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) { 494 rtwvif->mlo_mode = RTW89_MLO_MODE_MLSR; 495 496 /* for station mode, assign the mac_id from itself */ 497 macid = rtw89_vif_get_main_macid(rtwvif); 498 } else { 499 macid = rtw89_acquire_mac_id(rtwdev); 500 if (macid == RTW89_MAX_MAC_ID_NUM) 501 return -ENOSPC; 502 503 acquire_macid = true; 504 } 505 506 rtw89_init_sta(rtwdev, rtwvif, rtwsta, macid); 507 508 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 509 rtw89_core_txq_init(rtwdev, sta->txq[i]); 510 511 INIT_LIST_HEAD(&rtwsta->dlink_pool); 512 513 skb_queue_head_init(&rtwsta->roc_queue); 514 bitmap_zero(rtwsta->pairwise_sec_cam_map, RTW89_MAX_SEC_CAM_NUM); 515 516 rtwsta_link = rtw89_sta_set_link(rtwsta, sta->deflink.link_id); 517 if (!rtwsta_link) { 518 ret = -EINVAL; 519 goto err; 520 } 521 522 rtwvif_link = rtwsta_link->rtwvif_link; 523 524 ret = rtw89_core_sta_link_add(rtwdev, rtwvif_link, rtwsta_link); 525 if (ret) 526 goto unset_link; 527 528 if (vif->type == NL80211_IFTYPE_AP || sta->tdls) 529 rtw89_queue_chanctx_change(rtwdev, RTW89_CHANCTX_REMOTE_STA_CHANGE); 530 531 rtw89_fw_h2c_init_trx_protect(rtwdev); 532 533 return 0; 534 535 unset_link: 536 rtw89_sta_unset_link(rtwsta, sta->deflink.link_id); 537 err: 538 if (acquire_macid) 539 rtw89_release_mac_id(rtwdev, macid); 540 541 return ret; 542 } 543 544 static int __rtw89_ops_sta_assoc(struct rtw89_dev *rtwdev, 545 struct ieee80211_vif *vif, 546 struct ieee80211_sta *sta, 547 bool station_mode) 548 { 549 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 550 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 551 struct rtw89_vif_link *rtwvif_link; 552 struct rtw89_sta_link *rtwsta_link; 553 unsigned int link_id; 554 int ret; 555 556 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 557 rtwvif_link = rtwsta_link->rtwvif_link; 558 559 if (station_mode) 560 rtw89_vif_type_mapping(rtwvif_link, true); 561 562 ret = rtw89_core_sta_link_assoc(rtwdev, rtwvif_link, rtwsta_link); 563 if (ret) 564 return ret; 565 } 566 567 rtwdev->total_sta_assoc++; 568 if (sta->tdls) 569 rtwvif->tdls_peer++; 570 571 return 0; 572 } 573 574 static int __rtw89_ops_sta_disassoc(struct rtw89_dev *rtwdev, 575 struct ieee80211_vif *vif, 576 struct ieee80211_sta *sta) 577 { 578 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 579 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 580 struct rtw89_vif_link *rtwvif_link; 581 struct rtw89_sta_link *rtwsta_link; 582 unsigned int link_id; 583 int ret; 584 585 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 586 rtwvif_link = rtwsta_link->rtwvif_link; 587 ret = rtw89_core_sta_link_disassoc(rtwdev, rtwvif_link, rtwsta_link); 588 if (ret) 589 return ret; 590 } 591 592 rtwsta->disassoc = true; 593 594 rtwdev->total_sta_assoc--; 595 if (sta->tdls) 596 rtwvif->tdls_peer--; 597 598 return 0; 599 } 600 601 static int __rtw89_ops_sta_disconnect(struct rtw89_dev *rtwdev, 602 struct ieee80211_vif *vif, 603 struct ieee80211_sta *sta) 604 { 605 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 606 struct rtw89_vif_link *rtwvif_link; 607 struct rtw89_sta_link *rtwsta_link; 608 unsigned int link_id; 609 int ret; 610 611 rtw89_core_free_sta_pending_ba(rtwdev, sta); 612 rtw89_core_free_sta_pending_forbid_ba(rtwdev, sta); 613 rtw89_core_free_sta_pending_roc_tx(rtwdev, sta); 614 615 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 616 rtwvif_link = rtwsta_link->rtwvif_link; 617 ret = rtw89_core_sta_link_disconnect(rtwdev, rtwvif_link, rtwsta_link); 618 if (ret) 619 return ret; 620 } 621 622 return 0; 623 } 624 625 static int __rtw89_ops_sta_remove(struct rtw89_dev *rtwdev, 626 struct ieee80211_vif *vif, 627 struct ieee80211_sta *sta) 628 { 629 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 630 u8 macid = rtw89_sta_get_main_macid(rtwsta); 631 struct rtw89_vif_link *rtwvif_link; 632 struct rtw89_sta_link *rtwsta_link; 633 unsigned int link_id; 634 int ret; 635 636 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 637 rtwvif_link = rtwsta_link->rtwvif_link; 638 ret = rtw89_core_sta_link_remove(rtwdev, rtwvif_link, rtwsta_link); 639 if (ret) 640 return ret; 641 642 rtw89_sta_unset_link(rtwsta, link_id); 643 } 644 645 if (vif->type == NL80211_IFTYPE_AP || sta->tdls) { 646 rtw89_release_mac_id(rtwdev, macid); 647 rtw89_queue_chanctx_change(rtwdev, RTW89_CHANCTX_REMOTE_STA_CHANGE); 648 } 649 650 return 0; 651 } 652 653 static void rtw89_station_mode_sta_assoc(struct rtw89_dev *rtwdev, 654 struct ieee80211_vif *vif) 655 { 656 struct ieee80211_sta *sta; 657 658 if (vif->type != NL80211_IFTYPE_STATION) 659 return; 660 661 sta = ieee80211_find_sta(vif, vif->cfg.ap_addr); 662 if (!sta) { 663 rtw89_err(rtwdev, "can't find sta to set sta_assoc state\n"); 664 return; 665 } 666 667 __rtw89_ops_sta_assoc(rtwdev, vif, sta, true); 668 } 669 670 static void __rtw89_ops_bss_link_assoc(struct rtw89_dev *rtwdev, 671 struct rtw89_vif_link *rtwvif_link) 672 { 673 rtw89_phy_set_bss_color(rtwdev, rtwvif_link); 674 rtw89_chip_cfg_txpwr_ul_tb_offset(rtwdev, rtwvif_link); 675 rtw89_mac_port_update(rtwdev, rtwvif_link); 676 rtw89_mac_set_he_obss_narrow_bw_ru(rtwdev, rtwvif_link); 677 rtw89_mac_set_he_tb(rtwdev, rtwvif_link); 678 } 679 680 static void __rtw89_ops_bss_assoc(struct rtw89_dev *rtwdev, 681 struct ieee80211_vif *vif) 682 { 683 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 684 struct rtw89_vif_link *rtwvif_link; 685 unsigned int link_id; 686 687 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 688 __rtw89_ops_bss_link_assoc(rtwdev, rtwvif_link); 689 } 690 691 static void rtw89_ops_vif_cfg_changed(struct ieee80211_hw *hw, 692 struct ieee80211_vif *vif, u64 changed) 693 { 694 struct rtw89_dev *rtwdev = hw->priv; 695 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 696 697 lockdep_assert_wiphy(hw->wiphy); 698 699 rtw89_leave_ps_mode(rtwdev); 700 701 if (changed & BSS_CHANGED_ASSOC) { 702 if (vif->cfg.assoc) { 703 rtw89_station_mode_sta_assoc(rtwdev, vif); 704 __rtw89_ops_bss_assoc(rtwdev, vif); 705 706 rtw89_queue_chanctx_work(rtwdev); 707 } else { 708 /* Abort ongoing scan if cancel_scan isn't issued 709 * when disconnected by peer 710 */ 711 if (rtwdev->scanning) 712 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 713 } 714 } 715 716 if (changed & BSS_CHANGED_PS) 717 rtw89_recalc_lps(rtwdev); 718 719 if (changed & BSS_CHANGED_ARP_FILTER) 720 rtwvif->ip_addr = vif->cfg.arp_addr_list[0]; 721 722 if (changed & BSS_CHANGED_MLD_VALID_LINKS) { 723 struct rtw89_vif_link *cur = rtw89_get_designated_link(rtwvif); 724 725 if (RTW89_CHK_FW_FEATURE_GROUP(WITH_RFK_PRE_NOTIFY, &rtwdev->fw)) 726 rtw89_chip_rfk_channel(rtwdev, cur); 727 728 if (hweight16(vif->active_links) == 1) 729 rtwvif->mlo_mode = RTW89_MLO_MODE_MLSR; 730 else 731 rtwvif->mlo_mode = RTW89_MLO_MODE_EMLSR; 732 } 733 } 734 735 static void rtw89_ops_link_info_changed(struct ieee80211_hw *hw, 736 struct ieee80211_vif *vif, 737 struct ieee80211_bss_conf *conf, 738 u64 changed) 739 { 740 struct rtw89_dev *rtwdev = hw->priv; 741 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 742 struct rtw89_vif_link *rtwvif_link; 743 744 lockdep_assert_wiphy(hw->wiphy); 745 746 rtw89_leave_ps_mode(rtwdev); 747 748 rtwvif_link = rtwvif->links[conf->link_id]; 749 if (unlikely(!rtwvif_link)) { 750 rtw89_err(rtwdev, 751 "%s: rtwvif link (link_id %u) is not active\n", 752 __func__, conf->link_id); 753 return; 754 } 755 756 if (changed & BSS_CHANGED_BSSID) { 757 ether_addr_copy(rtwvif_link->bssid, conf->bssid); 758 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 759 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL, RTW89_ROLE_INFO_CHANGE); 760 WRITE_ONCE(rtwvif_link->sync_bcn_tsf, 0); 761 } 762 763 if (changed & BSS_CHANGED_BEACON) 764 rtw89_chip_h2c_update_beacon(rtwdev, rtwvif_link); 765 766 if (changed & BSS_CHANGED_ERP_SLOT) 767 rtw89_conf_tx(rtwdev, rtwvif_link); 768 769 if (changed & BSS_CHANGED_HE_BSS_COLOR) 770 rtw89_phy_set_bss_color(rtwdev, rtwvif_link); 771 772 if (changed & BSS_CHANGED_MU_GROUPS) 773 rtw89_mac_bf_set_gid_table(rtwdev, vif, conf); 774 775 if (changed & BSS_CHANGED_P2P_PS) 776 rtw89_core_update_p2p_ps(rtwdev, rtwvif_link, conf); 777 778 if (changed & BSS_CHANGED_CQM) 779 rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true); 780 781 if (changed & BSS_CHANGED_TPE) 782 rtw89_reg_6ghz_recalc(rtwdev, rtwvif_link, true); 783 } 784 785 static int rtw89_ops_start_ap(struct ieee80211_hw *hw, 786 struct ieee80211_vif *vif, 787 struct ieee80211_bss_conf *link_conf) 788 { 789 struct rtw89_dev *rtwdev = hw->priv; 790 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 791 struct rtw89_vif_link *rtwvif_link; 792 const struct rtw89_chan *chan; 793 int ret = 0; 794 795 lockdep_assert_wiphy(hw->wiphy); 796 797 rtwvif_link = rtwvif->links[link_conf->link_id]; 798 if (unlikely(!rtwvif_link)) { 799 rtw89_err(rtwdev, 800 "%s: rtwvif link (link_id %u) is not active\n", 801 __func__, link_conf->link_id); 802 return -ENOLINK; 803 } 804 805 chan = rtw89_chan_get(rtwdev, rtwvif_link->chanctx_idx); 806 if (chan->band_type == RTW89_BAND_6G) 807 return -EOPNOTSUPP; 808 809 if (rtwdev->scanning) 810 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 811 812 ether_addr_copy(rtwvif_link->bssid, link_conf->bssid); 813 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 814 rtw89_mac_port_update(rtwdev, rtwvif_link); 815 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 816 rtw89_fw_h2c_role_maintain(rtwdev, rtwvif_link, NULL, RTW89_ROLE_TYPE_CHANGE); 817 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 818 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL, RTW89_ROLE_TYPE_CHANGE); 819 rtw89_chip_rfk_channel(rtwdev, rtwvif_link); 820 821 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) { 822 ret = rtw89_fw_h2c_ap_info_refcount(rtwdev, true); 823 if (ret) 824 return ret; 825 } 826 827 rtw89_queue_chanctx_work(rtwdev); 828 829 return 0; 830 } 831 832 static 833 void rtw89_ops_stop_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 834 struct ieee80211_bss_conf *link_conf) 835 { 836 struct rtw89_dev *rtwdev = hw->priv; 837 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 838 struct rtw89_vif_link *rtwvif_link; 839 840 lockdep_assert_wiphy(hw->wiphy); 841 842 rtwvif_link = rtwvif->links[link_conf->link_id]; 843 if (unlikely(!rtwvif_link)) { 844 rtw89_err(rtwdev, 845 "%s: rtwvif link (link_id %u) is not active\n", 846 __func__, link_conf->link_id); 847 return; 848 } 849 850 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) 851 rtw89_fw_h2c_ap_info_refcount(rtwdev, false); 852 853 rtw89_mac_stop_ap(rtwdev, rtwvif_link); 854 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 855 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 856 } 857 858 static int rtw89_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 859 bool set) 860 { 861 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 862 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 863 struct rtw89_vif_link *rtwvif_link; 864 unsigned int link_id; 865 866 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 867 wiphy_work_queue(hw->wiphy, &rtwvif_link->update_beacon_work); 868 869 return 0; 870 } 871 872 static int rtw89_ops_conf_tx(struct ieee80211_hw *hw, 873 struct ieee80211_vif *vif, 874 unsigned int link_id, u16 ac, 875 const struct ieee80211_tx_queue_params *params) 876 { 877 struct rtw89_dev *rtwdev = hw->priv; 878 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 879 struct rtw89_vif_link *rtwvif_link; 880 881 lockdep_assert_wiphy(hw->wiphy); 882 883 rtw89_leave_ps_mode(rtwdev); 884 885 rtwvif_link = rtwvif->links[link_id]; 886 if (unlikely(!rtwvif_link)) { 887 rtw89_err(rtwdev, 888 "%s: rtwvif link (link_id %u) is not active\n", 889 __func__, link_id); 890 return -ENOLINK; 891 } 892 893 rtwvif_link->tx_params[ac] = *params; 894 __rtw89_conf_tx(rtwdev, rtwvif_link, ac); 895 896 return 0; 897 } 898 899 static int __rtw89_ops_sta_state(struct ieee80211_hw *hw, 900 struct ieee80211_vif *vif, 901 struct ieee80211_sta *sta, 902 enum ieee80211_sta_state old_state, 903 enum ieee80211_sta_state new_state) 904 { 905 struct rtw89_dev *rtwdev = hw->priv; 906 907 if (old_state == IEEE80211_STA_NOTEXIST && 908 new_state == IEEE80211_STA_NONE) 909 return __rtw89_ops_sta_add(rtwdev, vif, sta); 910 911 if (old_state == IEEE80211_STA_AUTH && 912 new_state == IEEE80211_STA_ASSOC) { 913 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) 914 return 0; /* defer to bss_info_changed to have vif info */ 915 return __rtw89_ops_sta_assoc(rtwdev, vif, sta, false); 916 } 917 918 if (old_state == IEEE80211_STA_ASSOC && 919 new_state == IEEE80211_STA_AUTH) 920 return __rtw89_ops_sta_disassoc(rtwdev, vif, sta); 921 922 if (old_state == IEEE80211_STA_AUTH && 923 new_state == IEEE80211_STA_NONE) 924 return __rtw89_ops_sta_disconnect(rtwdev, vif, sta); 925 926 if (old_state == IEEE80211_STA_NONE && 927 new_state == IEEE80211_STA_NOTEXIST) 928 return __rtw89_ops_sta_remove(rtwdev, vif, sta); 929 930 return 0; 931 } 932 933 static int rtw89_ops_sta_state(struct ieee80211_hw *hw, 934 struct ieee80211_vif *vif, 935 struct ieee80211_sta *sta, 936 enum ieee80211_sta_state old_state, 937 enum ieee80211_sta_state new_state) 938 { 939 struct rtw89_dev *rtwdev = hw->priv; 940 941 lockdep_assert_wiphy(hw->wiphy); 942 943 rtw89_leave_ps_mode(rtwdev); 944 return __rtw89_ops_sta_state(hw, vif, sta, old_state, new_state); 945 } 946 947 static int rtw89_ops_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 948 struct ieee80211_vif *vif, 949 struct ieee80211_sta *sta, 950 struct ieee80211_key_conf *key) 951 { 952 struct rtw89_dev *rtwdev = hw->priv; 953 int ret; 954 955 lockdep_assert_wiphy(hw->wiphy); 956 957 rtw89_leave_ps_mode(rtwdev); 958 959 switch (cmd) { 960 case SET_KEY: 961 rtw89_btc_ntfy_specific_packet(rtwdev, PACKET_EAPOL_END); 962 ret = rtw89_cam_sec_key_add(rtwdev, vif, sta, key); 963 if (ret && ret != -EOPNOTSUPP) { 964 rtw89_err(rtwdev, "failed to add key to sec cam\n"); 965 return ret; 966 } 967 rtw89_core_tid_rx_stats_reset(rtwdev); 968 break; 969 case DISABLE_KEY: 970 flush_work(&rtwdev->txq_work); 971 rtw89_hci_flush_queues(rtwdev, BIT(rtwdev->hw->queues) - 1, 972 false); 973 rtw89_mac_flush_txq(rtwdev, BIT(rtwdev->hw->queues) - 1, false); 974 ret = rtw89_cam_sec_key_del(rtwdev, vif, sta, key, true); 975 if (ret) { 976 rtw89_err(rtwdev, "failed to remove key from sec cam\n"); 977 return ret; 978 } 979 break; 980 } 981 982 return ret; 983 } 984 985 static int rtw89_ops_ampdu_action(struct ieee80211_hw *hw, 986 struct ieee80211_vif *vif, 987 struct ieee80211_ampdu_params *params) 988 { 989 struct rtw89_dev *rtwdev = hw->priv; 990 struct ieee80211_sta *sta = params->sta; 991 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 992 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 993 u16 tid = params->tid; 994 struct ieee80211_txq *txq = sta->txq[tid]; 995 struct rtw89_txq *rtwtxq = (struct rtw89_txq *)txq->drv_priv; 996 997 lockdep_assert_wiphy(rtwdev->hw->wiphy); 998 999 switch (params->action) { 1000 case IEEE80211_AMPDU_TX_START: 1001 return IEEE80211_AMPDU_TX_START_IMMEDIATE; 1002 case IEEE80211_AMPDU_TX_STOP_CONT: 1003 case IEEE80211_AMPDU_TX_STOP_FLUSH: 1004 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 1005 clear_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 1006 clear_bit(tid, rtwsta->ampdu_map); 1007 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 1008 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 1009 rtw89_leave_ps_mode(rtwdev); 1010 rtw89_phy_ra_recalc_agg_limit(rtwdev); 1011 break; 1012 case IEEE80211_AMPDU_TX_OPERATIONAL: 1013 set_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 1014 rtwsta->ampdu_params[tid].agg_num = params->buf_size; 1015 rtwsta->ampdu_params[tid].amsdu = params->amsdu; 1016 set_bit(tid, rtwsta->ampdu_map); 1017 rtw89_leave_ps_mode(rtwdev); 1018 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 1019 rtw89_phy_ra_recalc_agg_limit(rtwdev); 1020 break; 1021 case IEEE80211_AMPDU_RX_START: 1022 rtw89_core_tid_rx_stats_ctrl(rtwdev, rtwsta, params, true); 1023 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, true, params); 1024 break; 1025 case IEEE80211_AMPDU_RX_STOP: 1026 rtw89_core_tid_rx_stats_ctrl(rtwdev, rtwsta, params, false); 1027 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, false, params); 1028 break; 1029 default: 1030 WARN_ON(1); 1031 return -ENOTSUPP; 1032 } 1033 1034 return 0; 1035 } 1036 1037 static int rtw89_ops_set_rts_threshold(struct ieee80211_hw *hw, int radio_idx, 1038 u32 value) 1039 { 1040 struct rtw89_dev *rtwdev = hw->priv; 1041 1042 lockdep_assert_wiphy(hw->wiphy); 1043 1044 rtw89_leave_ps_mode(rtwdev); 1045 if (test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) 1046 rtw89_mac_update_rts_threshold(rtwdev); 1047 1048 return 0; 1049 } 1050 1051 static void rtw89_ops_sta_statistics(struct ieee80211_hw *hw, 1052 struct ieee80211_vif *vif, 1053 struct ieee80211_sta *sta, 1054 struct station_info *sinfo) 1055 { 1056 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1057 struct rtw89_sta_link *rtwsta_link; 1058 1059 rtwsta_link = rtw89_get_designated_link(rtwsta); 1060 if (unlikely(!rtwsta_link)) 1061 return; 1062 1063 sinfo->txrate = rtwsta_link->ra_report.txrate; 1064 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 1065 } 1066 1067 static 1068 void __rtw89_drop_packets(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif) 1069 { 1070 struct rtw89_vif *rtwvif; 1071 1072 if (vif) { 1073 rtwvif = vif_to_rtwvif(vif); 1074 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1075 } else { 1076 rtw89_for_each_rtwvif(rtwdev, rtwvif) 1077 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1078 } 1079 } 1080 1081 static void rtw89_ops_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1082 u32 queues, bool drop) 1083 { 1084 struct rtw89_dev *rtwdev = hw->priv; 1085 1086 lockdep_assert_wiphy(hw->wiphy); 1087 1088 rtw89_leave_lps(rtwdev); 1089 rtw89_hci_flush_queues(rtwdev, queues, drop); 1090 1091 if (drop && !RTW89_CHK_FW_FEATURE(NO_PACKET_DROP, &rtwdev->fw)) 1092 __rtw89_drop_packets(rtwdev, vif); 1093 else 1094 rtw89_mac_flush_txq(rtwdev, queues, drop); 1095 } 1096 1097 struct rtw89_iter_bitrate_mask_data { 1098 struct rtw89_dev *rtwdev; 1099 struct ieee80211_vif *vif; 1100 const struct cfg80211_bitrate_mask *mask; 1101 }; 1102 1103 static void rtw89_ra_mask_info_update_iter(void *data, struct ieee80211_sta *sta) 1104 { 1105 struct rtw89_iter_bitrate_mask_data *br_data = data; 1106 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1107 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 1108 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif); 1109 struct rtw89_sta_link *rtwsta_link; 1110 unsigned int link_id; 1111 1112 if (vif != br_data->vif || vif->p2p) 1113 return; 1114 1115 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 1116 rtwsta_link->use_cfg_mask = true; 1117 rtwsta_link->mask = *br_data->mask; 1118 } 1119 1120 rtw89_phy_ra_update_sta(br_data->rtwdev, sta, IEEE80211_RC_SUPP_RATES_CHANGED); 1121 } 1122 1123 static void rtw89_ra_mask_info_update(struct rtw89_dev *rtwdev, 1124 struct ieee80211_vif *vif, 1125 const struct cfg80211_bitrate_mask *mask) 1126 { 1127 struct rtw89_iter_bitrate_mask_data br_data = { .rtwdev = rtwdev, 1128 .vif = vif, 1129 .mask = mask}; 1130 1131 ieee80211_iterate_stations_atomic(rtwdev->hw, rtw89_ra_mask_info_update_iter, 1132 &br_data); 1133 } 1134 1135 static int rtw89_ops_set_bitrate_mask(struct ieee80211_hw *hw, 1136 struct ieee80211_vif *vif, 1137 const struct cfg80211_bitrate_mask *mask) 1138 { 1139 struct rtw89_dev *rtwdev = hw->priv; 1140 1141 lockdep_assert_wiphy(hw->wiphy); 1142 1143 rtw89_phy_rate_pattern_vif(rtwdev, vif, mask); 1144 rtw89_ra_mask_info_update(rtwdev, vif, mask); 1145 1146 return 0; 1147 } 1148 1149 static 1150 int rtw89_ops_set_antenna(struct ieee80211_hw *hw, int radio_idx, u32 tx_ant, u32 rx_ant) 1151 { 1152 struct rtw89_dev *rtwdev = hw->priv; 1153 struct rtw89_hal *hal = &rtwdev->hal; 1154 const struct rtw89_chip_info *chip; 1155 1156 lockdep_assert_wiphy(hw->wiphy); 1157 1158 chip = rtwdev->chip; 1159 1160 if (hal->ant_diversity) { 1161 if (tx_ant != rx_ant || hweight32(tx_ant) != 1) 1162 return -EINVAL; 1163 } else if (chip->ops->cfg_txrx_path) { 1164 /* With cfg_txrx_path ops, chips can configure rx_ant */ 1165 } else if (rx_ant != hw->wiphy->available_antennas_rx && rx_ant != hal->antenna_rx) { 1166 return -EINVAL; 1167 } 1168 1169 hal->antenna_tx = tx_ant; 1170 hal->antenna_rx = rx_ant; 1171 hal->tx_path_diversity = false; 1172 hal->ant_diversity_fixed = true; 1173 1174 return 0; 1175 } 1176 1177 static 1178 int rtw89_ops_get_antenna(struct ieee80211_hw *hw, int radio_idx, u32 *tx_ant, 1179 u32 *rx_ant) 1180 { 1181 struct rtw89_dev *rtwdev = hw->priv; 1182 struct rtw89_hal *hal = &rtwdev->hal; 1183 1184 *tx_ant = hal->antenna_tx; 1185 *rx_ant = hal->antenna_rx; 1186 1187 return 0; 1188 } 1189 1190 static void rtw89_ops_sw_scan_start(struct ieee80211_hw *hw, 1191 struct ieee80211_vif *vif, 1192 const u8 *mac_addr) 1193 { 1194 struct rtw89_dev *rtwdev = hw->priv; 1195 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1196 struct rtw89_vif_link *rtwvif_link; 1197 1198 lockdep_assert_wiphy(hw->wiphy); 1199 1200 rtwvif_link = rtw89_get_designated_link(rtwvif); 1201 if (unlikely(!rtwvif_link)) { 1202 rtw89_err(rtwdev, "sw scan start: find no designated link\n"); 1203 return; 1204 } 1205 1206 rtw89_leave_lps(rtwdev); 1207 1208 rtw89_core_scan_start(rtwdev, rtwvif_link, mac_addr, false); 1209 } 1210 1211 static void rtw89_ops_sw_scan_complete(struct ieee80211_hw *hw, 1212 struct ieee80211_vif *vif) 1213 { 1214 struct rtw89_dev *rtwdev = hw->priv; 1215 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1216 struct rtw89_vif_link *rtwvif_link; 1217 1218 lockdep_assert_wiphy(hw->wiphy); 1219 1220 rtwvif_link = rtw89_get_designated_link(rtwvif); 1221 if (unlikely(!rtwvif_link)) { 1222 rtw89_err(rtwdev, "sw scan complete: find no designated link\n"); 1223 return; 1224 } 1225 1226 rtw89_core_scan_complete(rtwdev, rtwvif_link, false); 1227 } 1228 1229 static void rtw89_ops_reconfig_complete(struct ieee80211_hw *hw, 1230 enum ieee80211_reconfig_type reconfig_type) 1231 { 1232 struct rtw89_dev *rtwdev = hw->priv; 1233 1234 if (reconfig_type == IEEE80211_RECONFIG_TYPE_RESTART) 1235 rtw89_ser_recfg_done(rtwdev); 1236 } 1237 1238 static int rtw89_ops_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1239 struct ieee80211_scan_request *req) 1240 { 1241 struct rtw89_dev *rtwdev = hw->priv; 1242 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1243 struct rtw89_vif_link *rtwvif_link; 1244 int ret; 1245 1246 lockdep_assert_wiphy(hw->wiphy); 1247 1248 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1249 return 1; 1250 1251 if (rtwdev->scanning || rtwvif->offchan) 1252 return -EBUSY; 1253 1254 rtwvif_link = rtw89_get_designated_link(rtwvif); 1255 if (unlikely(!rtwvif_link)) { 1256 rtw89_err(rtwdev, "hw scan: find no designated link\n"); 1257 return -ENOLINK; 1258 } 1259 1260 rtw89_leave_lps(rtwdev); 1261 rtw89_leave_ips_by_hwflags(rtwdev); 1262 1263 ret = rtw89_hw_scan_start(rtwdev, rtwvif_link, req); 1264 if (ret) 1265 return ret; 1266 1267 ret = rtw89_hw_scan_offload(rtwdev, rtwvif_link, true); 1268 if (ret) { 1269 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1270 rtw89_err(rtwdev, "HW scan failed with status: %d\n", ret); 1271 } 1272 1273 return ret; 1274 } 1275 1276 static void rtw89_ops_cancel_hw_scan(struct ieee80211_hw *hw, 1277 struct ieee80211_vif *vif) 1278 { 1279 struct rtw89_dev *rtwdev = hw->priv; 1280 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1281 struct rtw89_vif_link *rtwvif_link; 1282 1283 lockdep_assert_wiphy(hw->wiphy); 1284 1285 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1286 return; 1287 1288 if (!rtwdev->scanning) 1289 return; 1290 1291 rtwvif_link = rtw89_get_designated_link(rtwvif); 1292 if (unlikely(!rtwvif_link)) { 1293 rtw89_err(rtwdev, "cancel hw scan: find no designated link\n"); 1294 return; 1295 } 1296 1297 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1298 } 1299 1300 static void rtw89_ops_sta_rc_update(struct ieee80211_hw *hw, 1301 struct ieee80211_vif *vif, 1302 struct ieee80211_link_sta *link_sta, 1303 u32 changed) 1304 { 1305 struct rtw89_sta *rtwsta = sta_to_rtwsta(link_sta->sta); 1306 struct rtw89_dev *rtwdev = hw->priv; 1307 struct rtw89_sta_link *rtwsta_link; 1308 1309 rtwsta_link = rtwsta->links[link_sta->link_id]; 1310 if (unlikely(!rtwsta_link)) 1311 return; 1312 1313 rtw89_phy_ra_update_sta_link(rtwdev, rtwsta_link, changed); 1314 } 1315 1316 static int rtw89_ops_add_chanctx(struct ieee80211_hw *hw, 1317 struct ieee80211_chanctx_conf *ctx) 1318 { 1319 struct rtw89_dev *rtwdev = hw->priv; 1320 1321 lockdep_assert_wiphy(hw->wiphy); 1322 1323 return rtw89_chanctx_ops_add(rtwdev, ctx); 1324 } 1325 1326 static void rtw89_ops_remove_chanctx(struct ieee80211_hw *hw, 1327 struct ieee80211_chanctx_conf *ctx) 1328 { 1329 struct rtw89_dev *rtwdev = hw->priv; 1330 1331 lockdep_assert_wiphy(hw->wiphy); 1332 1333 rtw89_chanctx_ops_remove(rtwdev, ctx); 1334 } 1335 1336 static void rtw89_ops_change_chanctx(struct ieee80211_hw *hw, 1337 struct ieee80211_chanctx_conf *ctx, 1338 u32 changed) 1339 { 1340 struct rtw89_dev *rtwdev = hw->priv; 1341 1342 lockdep_assert_wiphy(hw->wiphy); 1343 1344 rtw89_chanctx_ops_change(rtwdev, ctx, changed); 1345 } 1346 1347 static int rtw89_ops_assign_vif_chanctx(struct ieee80211_hw *hw, 1348 struct ieee80211_vif *vif, 1349 struct ieee80211_bss_conf *link_conf, 1350 struct ieee80211_chanctx_conf *ctx) 1351 { 1352 struct rtw89_dev *rtwdev = hw->priv; 1353 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1354 struct rtw89_vif_link *rtwvif_link; 1355 1356 lockdep_assert_wiphy(hw->wiphy); 1357 1358 rtwvif_link = rtwvif->links[link_conf->link_id]; 1359 if (unlikely(!rtwvif_link)) { 1360 rtw89_err(rtwdev, 1361 "%s: rtwvif link (link_id %u) is not active\n", 1362 __func__, link_conf->link_id); 1363 return -ENOLINK; 1364 } 1365 1366 return rtw89_chanctx_ops_assign_vif(rtwdev, rtwvif_link, ctx); 1367 } 1368 1369 static void rtw89_ops_unassign_vif_chanctx(struct ieee80211_hw *hw, 1370 struct ieee80211_vif *vif, 1371 struct ieee80211_bss_conf *link_conf, 1372 struct ieee80211_chanctx_conf *ctx) 1373 { 1374 struct rtw89_dev *rtwdev = hw->priv; 1375 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1376 struct rtw89_vif_link *rtwvif_link; 1377 1378 lockdep_assert_wiphy(hw->wiphy); 1379 1380 rtwvif_link = rtwvif->links[link_conf->link_id]; 1381 if (unlikely(!rtwvif_link)) { 1382 rtw89_err(rtwdev, 1383 "%s: rtwvif link (link_id %u) is not active\n", 1384 __func__, link_conf->link_id); 1385 return; 1386 } 1387 1388 rtw89_chanctx_ops_unassign_vif(rtwdev, rtwvif_link, ctx); 1389 } 1390 1391 static 1392 int rtw89_ops_switch_vif_chanctx(struct ieee80211_hw *hw, 1393 struct ieee80211_vif_chanctx_switch *vifs, 1394 int n_vifs, 1395 enum ieee80211_chanctx_switch_mode mode) 1396 { 1397 struct rtw89_dev *rtwdev = hw->priv; 1398 bool replace; 1399 int ret; 1400 int i; 1401 1402 lockdep_assert_wiphy(hw->wiphy); 1403 1404 switch (mode) { 1405 case CHANCTX_SWMODE_REASSIGN_VIF: 1406 replace = false; 1407 break; 1408 case CHANCTX_SWMODE_SWAP_CONTEXTS: 1409 replace = true; 1410 break; 1411 default: 1412 return -EOPNOTSUPP; 1413 } 1414 1415 for (i = 0; i < n_vifs; i++) { 1416 struct ieee80211_vif_chanctx_switch *p = &vifs[i]; 1417 struct ieee80211_bss_conf *link_conf = p->link_conf; 1418 struct rtw89_vif *rtwvif = vif_to_rtwvif(p->vif); 1419 struct rtw89_vif_link *rtwvif_link; 1420 1421 rtwvif_link = rtwvif->links[link_conf->link_id]; 1422 if (unlikely(!rtwvif_link)) { 1423 rtw89_err(rtwdev, 1424 "%s: rtwvif link (link_id %u) is not active\n", 1425 __func__, link_conf->link_id); 1426 return -ENOLINK; 1427 } 1428 1429 ret = rtw89_chanctx_ops_reassign_vif(rtwdev, rtwvif_link, 1430 p->old_ctx, p->new_ctx, 1431 replace); 1432 if (ret) 1433 return ret; 1434 } 1435 1436 return 0; 1437 } 1438 1439 static void rtw89_ops_channel_switch_beacon(struct ieee80211_hw *hw, 1440 struct ieee80211_vif *vif, 1441 struct cfg80211_chan_def *chandef) 1442 { 1443 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1444 struct rtw89_dev *rtwdev = hw->priv; 1445 struct rtw89_vif_link *rtwvif_link; 1446 1447 BUILD_BUG_ON(RTW89_MLD_NON_STA_LINK_NUM != 1); 1448 1449 rtwvif_link = rtw89_get_designated_link(rtwvif); 1450 if (unlikely(!rtwvif_link)) { 1451 rtw89_err(rtwdev, "chsw bcn: find no designated link\n"); 1452 return; 1453 } 1454 1455 wiphy_delayed_work_queue(hw->wiphy, &rtwvif_link->csa_beacon_work, 0); 1456 } 1457 1458 static int rtw89_ops_remain_on_channel(struct ieee80211_hw *hw, 1459 struct ieee80211_vif *vif, 1460 struct ieee80211_channel *chan, 1461 int duration, 1462 enum ieee80211_roc_type type) 1463 { 1464 struct rtw89_dev *rtwdev = hw->priv; 1465 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1466 struct rtw89_roc *roc = &rtwvif->roc; 1467 1468 lockdep_assert_wiphy(hw->wiphy); 1469 1470 if (!rtwvif) 1471 return -EINVAL; 1472 1473 if (roc->state != RTW89_ROC_IDLE) { 1474 return -EBUSY; 1475 } 1476 1477 if (rtwdev->scanning) 1478 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1479 1480 if (type == IEEE80211_ROC_TYPE_MGMT_TX) 1481 roc->state = RTW89_ROC_MGMT; 1482 else 1483 roc->state = RTW89_ROC_NORMAL; 1484 1485 roc->duration = duration; 1486 roc->chan = *chan; 1487 roc->type = type; 1488 1489 rtw89_roc_start(rtwdev, rtwvif); 1490 1491 return 0; 1492 } 1493 1494 static int rtw89_ops_cancel_remain_on_channel(struct ieee80211_hw *hw, 1495 struct ieee80211_vif *vif) 1496 { 1497 struct rtw89_dev *rtwdev = hw->priv; 1498 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1499 1500 lockdep_assert_wiphy(hw->wiphy); 1501 1502 if (!rtwvif) 1503 return -EINVAL; 1504 1505 wiphy_delayed_work_cancel(hw->wiphy, &rtwvif->roc.roc_work); 1506 1507 rtw89_roc_end(rtwdev, rtwvif); 1508 1509 return 0; 1510 } 1511 1512 static void rtw89_set_tid_config_iter(void *data, struct ieee80211_sta *sta) 1513 { 1514 struct cfg80211_tid_config *tid_config = data; 1515 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1516 struct rtw89_dev *rtwdev = rtwsta->rtwdev; 1517 1518 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1519 } 1520 1521 static int rtw89_ops_set_tid_config(struct ieee80211_hw *hw, 1522 struct ieee80211_vif *vif, 1523 struct ieee80211_sta *sta, 1524 struct cfg80211_tid_config *tid_config) 1525 { 1526 struct rtw89_dev *rtwdev = hw->priv; 1527 1528 lockdep_assert_wiphy(hw->wiphy); 1529 1530 if (sta) 1531 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1532 else 1533 ieee80211_iterate_stations_atomic(rtwdev->hw, 1534 rtw89_set_tid_config_iter, 1535 tid_config); 1536 1537 return 0; 1538 } 1539 1540 static bool rtw89_can_work_on_links(struct rtw89_dev *rtwdev, 1541 struct ieee80211_vif *vif, u16 links) 1542 { 1543 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1544 u8 w = hweight16(links); 1545 1546 if (vif->type != NL80211_IFTYPE_STATION && 1547 w > RTW89_MLD_NON_STA_LINK_NUM) 1548 return false; 1549 1550 return w <= rtwvif->links_inst_valid_num; 1551 } 1552 1553 static bool rtw89_ops_can_activate_links(struct ieee80211_hw *hw, 1554 struct ieee80211_vif *vif, 1555 u16 active_links) 1556 { 1557 struct rtw89_dev *rtwdev = hw->priv; 1558 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1559 u16 current_links = vif->active_links; 1560 struct rtw89_vif_ml_trans trans = { 1561 .mediate_links = current_links | active_links, 1562 .links_to_del = current_links & ~active_links, 1563 .links_to_add = active_links & ~current_links, 1564 }; 1565 1566 lockdep_assert_wiphy(hw->wiphy); 1567 1568 if (!rtw89_can_work_on_links(rtwdev, vif, active_links)) 1569 return false; 1570 1571 /* 1572 * Leave LPS at the beginning of ieee80211_set_active_links(). 1573 * Because the entire process takes the same lock as our track 1574 * work, LPS will not enter during ieee80211_set_active_links(). 1575 */ 1576 rtw89_leave_lps(rtwdev); 1577 1578 rtwvif->ml_trans = trans; 1579 1580 return true; 1581 } 1582 1583 static void __rtw89_ops_clr_vif_links(struct rtw89_dev *rtwdev, 1584 struct rtw89_vif *rtwvif, 1585 unsigned long clr_links) 1586 { 1587 struct rtw89_vif_link *rtwvif_link; 1588 unsigned int link_id; 1589 1590 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1591 rtwvif_link = rtwvif->links[link_id]; 1592 if (unlikely(!rtwvif_link)) 1593 continue; 1594 1595 rtw89_fw_h2c_trx_protect(rtwdev, rtwvif_link->phy_idx, false); 1596 1597 __rtw89_ops_remove_iface_link(rtwdev, rtwvif_link); 1598 1599 rtw89_vif_unset_link(rtwvif, link_id); 1600 } 1601 } 1602 1603 static int __rtw89_ops_set_vif_links(struct rtw89_dev *rtwdev, 1604 struct rtw89_vif *rtwvif, 1605 unsigned long set_links) 1606 { 1607 struct rtw89_vif_link *rtwvif_link; 1608 unsigned int link_id; 1609 int ret; 1610 1611 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1612 rtwvif_link = rtw89_vif_set_link(rtwvif, link_id); 1613 if (!rtwvif_link) 1614 return -EINVAL; 1615 1616 ret = __rtw89_ops_add_iface_link(rtwdev, rtwvif_link); 1617 if (ret) { 1618 rtw89_err(rtwdev, "%s: failed to add iface (link id %u)\n", 1619 __func__, link_id); 1620 return ret; 1621 } 1622 rtw89_fw_h2c_trx_protect(rtwdev, rtwvif_link->phy_idx, true); 1623 } 1624 1625 return 0; 1626 } 1627 1628 static void rtw89_vif_update_fw_links(struct rtw89_dev *rtwdev, 1629 struct rtw89_vif *rtwvif, 1630 u16 current_links, bool en) 1631 { 1632 struct rtw89_vif_ml_trans *trans = &rtwvif->ml_trans; 1633 struct rtw89_vif_link *rtwvif_link; 1634 unsigned int link_id; 1635 unsigned long links; 1636 1637 /* Do follow-up when all updating links exist. */ 1638 if (current_links != trans->mediate_links) 1639 return; 1640 1641 if (en) 1642 links = trans->links_to_add; 1643 else 1644 links = trans->links_to_del; 1645 1646 for_each_set_bit(link_id, &links, IEEE80211_MLD_MAX_NUM_LINKS) { 1647 rtwvif_link = rtwvif->links[link_id]; 1648 if (unlikely(!rtwvif_link)) 1649 continue; 1650 1651 rtw89_fw_h2c_mlo_link_cfg(rtwdev, rtwvif_link, en); 1652 } 1653 } 1654 1655 static 1656 int rtw89_ops_change_vif_links(struct ieee80211_hw *hw, 1657 struct ieee80211_vif *vif, 1658 u16 old_links, u16 new_links, 1659 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 1660 { 1661 struct rtw89_dev *rtwdev = hw->priv; 1662 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1663 unsigned long clr_links = old_links & ~new_links; 1664 unsigned long set_links = new_links & ~old_links; 1665 bool removing_links = !old_links || clr_links; 1666 struct rtw89_link_conf_container *snap; 1667 int ret = 0; 1668 int i; 1669 1670 lockdep_assert_wiphy(hw->wiphy); 1671 1672 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1673 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1674 __func__, old_links, new_links); 1675 1676 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1677 return -EOPNOTSUPP; 1678 1679 if (removing_links) { 1680 snap = kzalloc_obj(*snap); 1681 if (!snap) 1682 return -ENOMEM; 1683 1684 for (i = 0; i < ARRAY_SIZE(snap->link_conf); i++) 1685 snap->link_conf[i] = old[i]; 1686 1687 rcu_assign_pointer(rtwvif->snap_link_confs, snap); 1688 } 1689 1690 /* might depend on @snap; don't change order */ 1691 rtw89_leave_ips_by_hwflags(rtwdev); 1692 1693 if (rtwdev->scanning) 1694 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1695 1696 rtw89_vif_update_fw_links(rtwdev, rtwvif, old_links, true); 1697 1698 if (!old_links) 1699 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1700 BIT(RTW89_VIF_IDLE_LINK_ID)); 1701 else if (clr_links) 1702 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, clr_links); 1703 1704 if (removing_links) { 1705 /* @snap is required if and only if during removing links. 1706 * However, it's done here. So, cleanup @snap immediately. 1707 */ 1708 rcu_assign_pointer(rtwvif->snap_link_confs, NULL); 1709 1710 /* The pointers in @old will free after this function return, 1711 * so synchronously wait for all readers of snap to be done. 1712 */ 1713 synchronize_rcu(); 1714 kfree(snap); 1715 } 1716 1717 if (set_links) { 1718 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, set_links); 1719 if (ret) 1720 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, set_links); 1721 } else if (!new_links) { 1722 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, 1723 BIT(RTW89_VIF_IDLE_LINK_ID)); 1724 if (ret) 1725 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1726 BIT(RTW89_VIF_IDLE_LINK_ID)); 1727 } 1728 1729 if (!ret) 1730 rtw89_vif_update_fw_links(rtwdev, rtwvif, new_links, false); 1731 1732 rtw89_enter_ips_by_hwflags(rtwdev); 1733 return ret; 1734 } 1735 1736 static void __rtw89_ops_clr_sta_links(struct rtw89_dev *rtwdev, 1737 struct rtw89_sta *rtwsta, 1738 unsigned long clr_links) 1739 { 1740 struct rtw89_vif_link *rtwvif_link; 1741 struct rtw89_sta_link *rtwsta_link; 1742 unsigned int link_id; 1743 1744 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1745 rtwsta_link = rtwsta->links[link_id]; 1746 if (unlikely(!rtwsta_link)) 1747 continue; 1748 1749 rtwvif_link = rtwsta_link->rtwvif_link; 1750 1751 rtw89_core_sta_link_disassoc(rtwdev, rtwvif_link, rtwsta_link); 1752 rtw89_core_sta_link_disconnect(rtwdev, rtwvif_link, rtwsta_link); 1753 rtw89_core_sta_link_remove(rtwdev, rtwvif_link, rtwsta_link); 1754 1755 rtw89_sta_unset_link(rtwsta, link_id); 1756 } 1757 } 1758 1759 static int __rtw89_ops_set_sta_links(struct rtw89_dev *rtwdev, 1760 struct rtw89_sta *rtwsta, 1761 unsigned long set_links) 1762 { 1763 struct rtw89_vif_link *rtwvif_link; 1764 struct rtw89_sta_link *rtwsta_link; 1765 unsigned int link_id; 1766 u8 sec_cam_idx; 1767 int ret; 1768 1769 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1770 rtwsta_link = rtw89_sta_set_link(rtwsta, link_id); 1771 if (!rtwsta_link) 1772 return -EINVAL; 1773 1774 rtwvif_link = rtwsta_link->rtwvif_link; 1775 1776 ret = rtw89_core_sta_link_add(rtwdev, rtwvif_link, rtwsta_link); 1777 if (ret) { 1778 rtw89_err(rtwdev, "%s: failed to add sta (link id %u)\n", 1779 __func__, link_id); 1780 return ret; 1781 } 1782 1783 rtw89_vif_type_mapping(rtwvif_link, true); 1784 1785 ret = rtw89_core_sta_link_assoc(rtwdev, rtwvif_link, rtwsta_link); 1786 if (ret) { 1787 rtw89_err(rtwdev, "%s: failed to assoc sta (link id %u)\n", 1788 __func__, link_id); 1789 return ret; 1790 } 1791 1792 __rtw89_ops_bss_link_assoc(rtwdev, rtwvif_link); 1793 1794 for_each_set_bit(sec_cam_idx, rtwsta->pairwise_sec_cam_map, 1795 RTW89_MAX_SEC_CAM_NUM) { 1796 ret = rtw89_cam_attach_link_sec_cam(rtwdev, 1797 rtwvif_link, 1798 rtwsta_link, 1799 sec_cam_idx); 1800 if (ret) { 1801 rtw89_err(rtwdev, 1802 "%s: failed to apply pairwise key (link id %u)\n", 1803 __func__, link_id); 1804 return ret; 1805 } 1806 } 1807 } 1808 1809 return 0; 1810 } 1811 1812 static 1813 int rtw89_ops_change_sta_links(struct ieee80211_hw *hw, 1814 struct ieee80211_vif *vif, 1815 struct ieee80211_sta *sta, 1816 u16 old_links, u16 new_links) 1817 { 1818 struct rtw89_dev *rtwdev = hw->priv; 1819 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1820 unsigned long clr_links = old_links & ~new_links; 1821 unsigned long set_links = new_links & ~old_links; 1822 int ret = 0; 1823 1824 lockdep_assert_wiphy(hw->wiphy); 1825 1826 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1827 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1828 __func__, old_links, new_links); 1829 1830 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1831 return -EOPNOTSUPP; 1832 1833 rtw89_leave_ps_mode(rtwdev); 1834 1835 if (clr_links) 1836 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, clr_links); 1837 1838 if (set_links) { 1839 ret = __rtw89_ops_set_sta_links(rtwdev, rtwsta, set_links); 1840 if (ret) 1841 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, set_links); 1842 } 1843 1844 return ret; 1845 } 1846 1847 #ifdef CONFIG_PM 1848 static int rtw89_ops_suspend(struct ieee80211_hw *hw, 1849 struct cfg80211_wowlan *wowlan) 1850 { 1851 struct rtw89_dev *rtwdev = hw->priv; 1852 int ret; 1853 1854 lockdep_assert_wiphy(hw->wiphy); 1855 1856 set_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1857 wiphy_delayed_work_cancel(hw->wiphy, &rtwdev->track_work); 1858 wiphy_delayed_work_cancel(hw->wiphy, &rtwdev->track_ps_work); 1859 1860 ret = rtw89_wow_suspend(rtwdev, wowlan); 1861 if (ret) { 1862 rtw89_warn(rtwdev, "failed to suspend for wow %d\n", ret); 1863 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1864 return 1; 1865 } 1866 1867 return 0; 1868 } 1869 1870 static int rtw89_ops_resume(struct ieee80211_hw *hw) 1871 { 1872 struct rtw89_dev *rtwdev = hw->priv; 1873 int ret; 1874 1875 lockdep_assert_wiphy(hw->wiphy); 1876 1877 ret = rtw89_wow_resume(rtwdev); 1878 if (ret) 1879 rtw89_warn(rtwdev, "failed to resume for wow %d\n", ret); 1880 1881 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1882 wiphy_delayed_work_queue(hw->wiphy, &rtwdev->track_work, 1883 RTW89_TRACK_WORK_PERIOD); 1884 wiphy_delayed_work_queue(hw->wiphy, &rtwdev->track_ps_work, 1885 RTW89_TRACK_PS_WORK_PERIOD); 1886 1887 return ret ? 1 : 0; 1888 } 1889 1890 static void rtw89_ops_set_wakeup(struct ieee80211_hw *hw, bool enabled) 1891 { 1892 struct rtw89_dev *rtwdev = hw->priv; 1893 1894 device_set_wakeup_enable(rtwdev->dev, enabled); 1895 } 1896 1897 static void rtw89_set_rekey_data(struct ieee80211_hw *hw, 1898 struct ieee80211_vif *vif, 1899 struct cfg80211_gtk_rekey_data *data) 1900 { 1901 struct rtw89_dev *rtwdev = hw->priv; 1902 struct rtw89_wow_param *rtw_wow = &rtwdev->wow; 1903 struct rtw89_wow_gtk_info *gtk_info = &rtw_wow->gtk_info; 1904 1905 lockdep_assert_wiphy(hw->wiphy); 1906 1907 if (data->kek_len > sizeof(gtk_info->kek) || 1908 data->kck_len > sizeof(gtk_info->kck)) { 1909 rtw89_warn(rtwdev, "kek or kck length over fw limit\n"); 1910 return; 1911 } 1912 1913 memcpy(gtk_info->kek, data->kek, data->kek_len); 1914 memcpy(gtk_info->kck, data->kck, data->kck_len); 1915 } 1916 #endif 1917 1918 static int rtw89_ops_get_survey(struct ieee80211_hw *hw, int idx, 1919 struct survey_info *survey) 1920 { 1921 struct ieee80211_conf *conf = &hw->conf; 1922 struct rtw89_dev *rtwdev = hw->priv; 1923 struct rtw89_bb_ctx *bb; 1924 1925 if (idx == 0) { 1926 survey->channel = conf->chandef.chan; 1927 survey->filled = SURVEY_INFO_NOISE_DBM; 1928 survey->noise = RTW89_NOISE_DEFAULT; 1929 1930 return 0; 1931 } 1932 1933 rtw89_for_each_active_bb(rtwdev, bb) { 1934 struct rtw89_env_monitor_info *env = &bb->env_monitor; 1935 struct rtw89_nhm_report *rpt; 1936 1937 rpt = list_first_entry_or_null(&env->nhm_rpt_list, typeof(*rpt), list); 1938 if (!rpt) 1939 continue; 1940 1941 survey->filled = SURVEY_INFO_NOISE_DBM; 1942 survey->noise = rpt->noise - MAX_RSSI; 1943 survey->channel = rpt->channel; 1944 list_del_init(&rpt->list); 1945 1946 return 0; 1947 } 1948 1949 return -EINVAL; 1950 } 1951 1952 static void rtw89_ops_rfkill_poll(struct ieee80211_hw *hw) 1953 { 1954 struct rtw89_dev *rtwdev = hw->priv; 1955 1956 lockdep_assert_wiphy(hw->wiphy); 1957 1958 /* wl_disable GPIO get floating when entering LPS */ 1959 if (test_bit(RTW89_FLAG_RUNNING, rtwdev->flags)) 1960 return; 1961 1962 rtw89_core_rfkill_poll(rtwdev, false); 1963 } 1964 1965 const struct ieee80211_ops rtw89_ops = { 1966 .tx = rtw89_ops_tx, 1967 .wake_tx_queue = rtw89_ops_wake_tx_queue, 1968 .start = rtw89_ops_start, 1969 .stop = rtw89_ops_stop, 1970 .config = rtw89_ops_config, 1971 .add_interface = rtw89_ops_add_interface, 1972 .change_interface = rtw89_ops_change_interface, 1973 .remove_interface = rtw89_ops_remove_interface, 1974 .configure_filter = rtw89_ops_configure_filter, 1975 .vif_cfg_changed = rtw89_ops_vif_cfg_changed, 1976 .link_info_changed = rtw89_ops_link_info_changed, 1977 .start_ap = rtw89_ops_start_ap, 1978 .stop_ap = rtw89_ops_stop_ap, 1979 .set_tim = rtw89_ops_set_tim, 1980 .conf_tx = rtw89_ops_conf_tx, 1981 .sta_state = rtw89_ops_sta_state, 1982 .set_key = rtw89_ops_set_key, 1983 .ampdu_action = rtw89_ops_ampdu_action, 1984 .get_survey = rtw89_ops_get_survey, 1985 .set_rts_threshold = rtw89_ops_set_rts_threshold, 1986 .sta_statistics = rtw89_ops_sta_statistics, 1987 .flush = rtw89_ops_flush, 1988 .set_bitrate_mask = rtw89_ops_set_bitrate_mask, 1989 .set_antenna = rtw89_ops_set_antenna, 1990 .get_antenna = rtw89_ops_get_antenna, 1991 .sw_scan_start = rtw89_ops_sw_scan_start, 1992 .sw_scan_complete = rtw89_ops_sw_scan_complete, 1993 .reconfig_complete = rtw89_ops_reconfig_complete, 1994 .hw_scan = rtw89_ops_hw_scan, 1995 .cancel_hw_scan = rtw89_ops_cancel_hw_scan, 1996 .add_chanctx = rtw89_ops_add_chanctx, 1997 .remove_chanctx = rtw89_ops_remove_chanctx, 1998 .change_chanctx = rtw89_ops_change_chanctx, 1999 .assign_vif_chanctx = rtw89_ops_assign_vif_chanctx, 2000 .unassign_vif_chanctx = rtw89_ops_unassign_vif_chanctx, 2001 .switch_vif_chanctx = rtw89_ops_switch_vif_chanctx, 2002 .channel_switch_beacon = rtw89_ops_channel_switch_beacon, 2003 .remain_on_channel = rtw89_ops_remain_on_channel, 2004 .cancel_remain_on_channel = rtw89_ops_cancel_remain_on_channel, 2005 .set_sar_specs = rtw89_ops_set_sar_specs, 2006 .link_sta_rc_update = rtw89_ops_sta_rc_update, 2007 .set_tid_config = rtw89_ops_set_tid_config, 2008 .can_activate_links = rtw89_ops_can_activate_links, 2009 .change_vif_links = rtw89_ops_change_vif_links, 2010 .change_sta_links = rtw89_ops_change_sta_links, 2011 #ifdef CONFIG_PM 2012 .suspend = rtw89_ops_suspend, 2013 .resume = rtw89_ops_resume, 2014 .set_wakeup = rtw89_ops_set_wakeup, 2015 .set_rekey_data = rtw89_set_rekey_data, 2016 #endif 2017 .rfkill_poll = rtw89_ops_rfkill_poll, 2018 }; 2019 EXPORT_SYMBOL(rtw89_ops); 2020