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 131 rcu_read_lock(); 132 133 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 134 ether_addr_copy(rtwvif_link->mac_addr, bss_conf->addr); 135 136 rcu_read_unlock(); 137 138 ret = rtw89_mac_add_vif(rtwdev, rtwvif_link); 139 if (ret) 140 return ret; 141 142 rtw89_btc_ntfy_role_info(rtwdev, rtwvif_link, NULL, BTC_ROLE_START); 143 return 0; 144 } 145 146 static void __rtw89_ops_remove_iface_link(struct rtw89_dev *rtwdev, 147 struct rtw89_vif_link *rtwvif_link) 148 { 149 lockdep_assert_wiphy(rtwdev->hw->wiphy); 150 151 wiphy_work_cancel(rtwdev->hw->wiphy, &rtwvif_link->update_beacon_work); 152 wiphy_delayed_work_cancel(rtwdev->hw->wiphy, &rtwvif_link->csa_beacon_work); 153 wiphy_delayed_work_cancel(rtwdev->hw->wiphy, 154 &rtwvif_link->mcc_gc_detect_beacon_work); 155 156 rtw89_p2p_noa_once_deinit(rtwvif_link); 157 158 rtw89_leave_ps_mode(rtwdev); 159 160 rtw89_btc_ntfy_role_info(rtwdev, rtwvif_link, NULL, BTC_ROLE_STOP); 161 162 rtw89_mac_remove_vif(rtwdev, rtwvif_link); 163 } 164 165 static int rtw89_ops_add_interface(struct ieee80211_hw *hw, 166 struct ieee80211_vif *vif) 167 { 168 struct rtw89_dev *rtwdev = hw->priv; 169 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 170 struct rtw89_vif_link *rtwvif_link; 171 u8 mac_id, port; 172 int ret = 0; 173 174 lockdep_assert_wiphy(hw->wiphy); 175 176 rtw89_debug(rtwdev, RTW89_DBG_STATE, "add vif %pM type %d, p2p %d\n", 177 vif->addr, vif->type, vif->p2p); 178 179 rtw89_leave_ips_by_hwflags(rtwdev); 180 181 if (RTW89_CHK_FW_FEATURE(BEACON_FILTER, &rtwdev->fw)) 182 vif->driver_flags |= IEEE80211_VIF_BEACON_FILTER | 183 IEEE80211_VIF_SUPPORTS_CQM_RSSI; 184 185 mac_id = rtw89_acquire_mac_id(rtwdev); 186 if (mac_id == RTW89_MAX_MAC_ID_NUM) 187 return -ENOSPC; 188 189 port = rtw89_core_acquire_bit_map(rtwdev->hw_port, RTW89_PORT_NUM); 190 if (port == RTW89_PORT_NUM) { 191 ret = -ENOSPC; 192 goto release_macid; 193 } 194 195 rtw89_init_vif(rtwdev, rtwvif, mac_id, port); 196 197 rtw89_core_txq_init(rtwdev, vif->txq); 198 199 if (!rtw89_rtwvif_in_list(rtwdev, rtwvif)) { 200 list_add_tail(&rtwvif->list, &rtwdev->rtwvifs_list); 201 INIT_LIST_HEAD(&rtwvif->mgnt_entry); 202 INIT_LIST_HEAD(&rtwvif->dlink_pool); 203 } 204 205 ether_addr_copy(rtwvif->mac_addr, vif->addr); 206 207 rtwvif->offchan = false; 208 rtwvif->roc.state = RTW89_ROC_IDLE; 209 wiphy_delayed_work_init(&rtwvif->roc.roc_work, rtw89_roc_work); 210 211 rtw89_traffic_stats_init(rtwdev, &rtwvif->stats); 212 213 rtwvif_link = rtw89_vif_set_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 214 if (!rtwvif_link) { 215 ret = -EINVAL; 216 goto release_port; 217 } 218 219 ret = __rtw89_ops_add_iface_link(rtwdev, rtwvif_link); 220 if (ret) 221 goto unset_link; 222 223 rtw89_recalc_lps(rtwdev); 224 return 0; 225 226 unset_link: 227 rtw89_vif_unset_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 228 release_port: 229 list_del_init(&rtwvif->list); 230 rtw89_core_release_bit_map(rtwdev->hw_port, port); 231 release_macid: 232 rtw89_release_mac_id(rtwdev, mac_id); 233 234 return ret; 235 } 236 237 static void rtw89_ops_remove_interface(struct ieee80211_hw *hw, 238 struct ieee80211_vif *vif) 239 { 240 struct rtw89_dev *rtwdev = hw->priv; 241 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 242 u8 macid = rtw89_vif_get_main_macid(rtwvif); 243 u8 port = rtw89_vif_get_main_port(rtwvif); 244 struct rtw89_vif_link *rtwvif_link; 245 246 lockdep_assert_wiphy(hw->wiphy); 247 248 rtw89_debug(rtwdev, RTW89_DBG_STATE, "remove vif %pM type %d p2p %d\n", 249 vif->addr, vif->type, vif->p2p); 250 251 wiphy_delayed_work_cancel(hw->wiphy, &rtwvif->roc.roc_work); 252 253 rtwvif_link = rtwvif->links[RTW89_VIF_IDLE_LINK_ID]; 254 if (unlikely(!rtwvif_link)) { 255 rtw89_err(rtwdev, 256 "%s: rtwvif link (link_id %u) is not active\n", 257 __func__, RTW89_VIF_IDLE_LINK_ID); 258 goto bottom; 259 } 260 261 __rtw89_ops_remove_iface_link(rtwdev, rtwvif_link); 262 263 rtw89_vif_unset_link(rtwvif, RTW89_VIF_IDLE_LINK_ID); 264 265 bottom: 266 list_del_init(&rtwvif->list); 267 rtw89_core_release_bit_map(rtwdev->hw_port, port); 268 rtw89_release_mac_id(rtwdev, macid); 269 270 rtw89_recalc_lps(rtwdev); 271 rtw89_enter_ips_by_hwflags(rtwdev); 272 } 273 274 static int rtw89_ops_change_interface(struct ieee80211_hw *hw, 275 struct ieee80211_vif *vif, 276 enum nl80211_iftype type, bool p2p) 277 { 278 struct rtw89_dev *rtwdev = hw->priv; 279 int ret; 280 281 set_bit(RTW89_FLAG_CHANGING_INTERFACE, rtwdev->flags); 282 283 rtw89_debug(rtwdev, RTW89_DBG_STATE, "change vif %pM (%d)->(%d), p2p (%d)->(%d)\n", 284 vif->addr, vif->type, type, vif->p2p, p2p); 285 286 rtw89_ops_remove_interface(hw, vif); 287 288 vif->type = type; 289 vif->p2p = p2p; 290 291 ret = rtw89_ops_add_interface(hw, vif); 292 if (ret) 293 rtw89_warn(rtwdev, "failed to change interface %d\n", ret); 294 295 clear_bit(RTW89_FLAG_CHANGING_INTERFACE, rtwdev->flags); 296 297 return ret; 298 } 299 300 static void rtw89_ops_configure_filter(struct ieee80211_hw *hw, 301 unsigned int changed_flags, 302 unsigned int *new_flags, 303 u64 multicast) 304 { 305 struct rtw89_dev *rtwdev = hw->priv; 306 const struct rtw89_mac_gen_def *mac = rtwdev->chip->mac_def; 307 u32 rx_fltr; 308 309 lockdep_assert_wiphy(hw->wiphy); 310 311 rtw89_leave_ps_mode(rtwdev); 312 313 *new_flags &= FIF_ALLMULTI | FIF_OTHER_BSS | FIF_FCSFAIL | 314 FIF_BCN_PRBRESP_PROMISC | FIF_PROBE_REQ; 315 316 if (changed_flags & FIF_ALLMULTI) { 317 if (*new_flags & FIF_ALLMULTI) 318 rtwdev->hal.rx_fltr &= ~B_AX_A_MC; 319 else 320 rtwdev->hal.rx_fltr |= B_AX_A_MC; 321 } 322 if (changed_flags & FIF_FCSFAIL) { 323 if (*new_flags & FIF_FCSFAIL) 324 rtwdev->hal.rx_fltr |= B_AX_A_CRC32_ERR; 325 else 326 rtwdev->hal.rx_fltr &= ~B_AX_A_CRC32_ERR; 327 } 328 if (changed_flags & FIF_OTHER_BSS) { 329 if (*new_flags & FIF_OTHER_BSS) 330 rtwdev->hal.rx_fltr &= ~B_AX_A_A1_MATCH; 331 else 332 rtwdev->hal.rx_fltr |= B_AX_A_A1_MATCH; 333 } 334 if (changed_flags & FIF_BCN_PRBRESP_PROMISC) { 335 if (*new_flags & FIF_BCN_PRBRESP_PROMISC) { 336 rtwdev->hal.rx_fltr &= ~B_AX_A_BCN_CHK_EN; 337 rtwdev->hal.rx_fltr &= ~B_AX_A_BC; 338 rtwdev->hal.rx_fltr &= ~B_AX_A_A1_MATCH; 339 } else { 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 } 344 } 345 if (changed_flags & FIF_PROBE_REQ) { 346 if (*new_flags & FIF_PROBE_REQ) { 347 rtwdev->hal.rx_fltr &= ~B_AX_A_BC_CAM_MATCH; 348 rtwdev->hal.rx_fltr &= ~B_AX_A_UC_CAM_MATCH; 349 } else { 350 rtwdev->hal.rx_fltr |= B_AX_A_BC_CAM_MATCH; 351 rtwdev->hal.rx_fltr |= B_AX_A_UC_CAM_MATCH; 352 } 353 } 354 355 rx_fltr = rtwdev->hal.rx_fltr; 356 357 /* mac80211 doesn't configure filter when HW scan, driver need to 358 * set by itself. However, during P2P scan might have configure 359 * filter to overwrite filter that HW scan needed, so we need to 360 * check scan and append related filter 361 */ 362 if (rtwdev->scanning) { 363 rx_fltr &= ~B_AX_A_BCN_CHK_EN; 364 rx_fltr &= ~B_AX_A_BC; 365 rx_fltr &= ~B_AX_A_A1_MATCH; 366 } 367 368 rtw89_write32_mask(rtwdev, 369 rtw89_mac_reg_by_idx(rtwdev, mac->rx_fltr, RTW89_MAC_0), 370 B_AX_RX_FLTR_CFG_MASK, 371 rx_fltr); 372 if (!rtwdev->dbcc_en) 373 return; 374 rtw89_write32_mask(rtwdev, 375 rtw89_mac_reg_by_idx(rtwdev, mac->rx_fltr, RTW89_MAC_1), 376 B_AX_RX_FLTR_CFG_MASK, 377 rx_fltr); 378 } 379 380 static const u8 ac_to_fw_idx[IEEE80211_NUM_ACS] = { 381 [IEEE80211_AC_VO] = 3, 382 [IEEE80211_AC_VI] = 2, 383 [IEEE80211_AC_BE] = 0, 384 [IEEE80211_AC_BK] = 1, 385 }; 386 387 static u8 rtw89_aifsn_to_aifs(struct rtw89_dev *rtwdev, 388 struct rtw89_vif_link *rtwvif_link, u8 aifsn) 389 { 390 const struct rtw89_chan *chan = rtw89_chan_get(rtwdev, 391 rtwvif_link->chanctx_idx); 392 struct ieee80211_bss_conf *bss_conf; 393 u8 slot_time; 394 u8 sifs; 395 396 rcu_read_lock(); 397 398 bss_conf = rtw89_vif_rcu_dereference_link(rtwvif_link, true); 399 slot_time = bss_conf->use_short_slot ? 9 : 20; 400 401 rcu_read_unlock(); 402 403 sifs = chan->band_type == RTW89_BAND_2G ? 10 : 16; 404 405 return aifsn * slot_time + sifs; 406 } 407 408 static void ____rtw89_conf_tx_edca(struct rtw89_dev *rtwdev, 409 struct rtw89_vif_link *rtwvif_link, u16 ac) 410 { 411 struct ieee80211_tx_queue_params *params = &rtwvif_link->tx_params[ac]; 412 u32 val; 413 u8 ecw_max, ecw_min; 414 u8 aifs; 415 416 /* 2^ecw - 1 = cw; ecw = log2(cw + 1) */ 417 ecw_max = ilog2(params->cw_max + 1); 418 ecw_min = ilog2(params->cw_min + 1); 419 aifs = rtw89_aifsn_to_aifs(rtwdev, rtwvif_link, params->aifs); 420 val = FIELD_PREP(FW_EDCA_PARAM_TXOPLMT_MSK, params->txop) | 421 FIELD_PREP(FW_EDCA_PARAM_CWMAX_MSK, ecw_max) | 422 FIELD_PREP(FW_EDCA_PARAM_CWMIN_MSK, ecw_min) | 423 FIELD_PREP(FW_EDCA_PARAM_AIFS_MSK, aifs); 424 rtw89_fw_h2c_set_edca(rtwdev, rtwvif_link, ac_to_fw_idx[ac], val); 425 } 426 427 #define R_MUEDCA_ACS_PARAM(acs) {R_AX_MUEDCA_ ## acs ## _PARAM_0, \ 428 R_BE_MUEDCA_ ## acs ## _PARAM_0} 429 430 static const u32 ac_to_mu_edca_param[IEEE80211_NUM_ACS][RTW89_CHIP_GEN_NUM] = { 431 [IEEE80211_AC_VO] = R_MUEDCA_ACS_PARAM(VO), 432 [IEEE80211_AC_VI] = R_MUEDCA_ACS_PARAM(VI), 433 [IEEE80211_AC_BE] = R_MUEDCA_ACS_PARAM(BE), 434 [IEEE80211_AC_BK] = R_MUEDCA_ACS_PARAM(BK), 435 }; 436 437 static void ____rtw89_conf_tx_mu_edca(struct rtw89_dev *rtwdev, 438 struct rtw89_vif_link *rtwvif_link, u16 ac) 439 { 440 struct ieee80211_tx_queue_params *params = &rtwvif_link->tx_params[ac]; 441 struct ieee80211_he_mu_edca_param_ac_rec *mu_edca; 442 int gen = rtwdev->chip->chip_gen; 443 u8 aifs, aifsn; 444 u16 timer_32us; 445 u32 reg; 446 u32 val; 447 448 if (!params->mu_edca) 449 return; 450 451 mu_edca = ¶ms->mu_edca_param_rec; 452 aifsn = FIELD_GET(GENMASK(3, 0), mu_edca->aifsn); 453 aifs = aifsn ? rtw89_aifsn_to_aifs(rtwdev, rtwvif_link, aifsn) : 0; 454 timer_32us = mu_edca->mu_edca_timer << 8; 455 456 val = FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_TIMER_MASK, timer_32us) | 457 FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_CW_MASK, mu_edca->ecw_min_max) | 458 FIELD_PREP(B_AX_MUEDCA_BE_PARAM_0_AIFS_MASK, aifs); 459 reg = rtw89_mac_reg_by_idx(rtwdev, ac_to_mu_edca_param[ac][gen], 460 rtwvif_link->mac_idx); 461 rtw89_write32(rtwdev, reg, val); 462 463 rtw89_mac_set_hw_muedca_ctrl(rtwdev, rtwvif_link, true); 464 } 465 466 static void __rtw89_conf_tx(struct rtw89_dev *rtwdev, 467 struct rtw89_vif_link *rtwvif_link, u16 ac) 468 { 469 ____rtw89_conf_tx_edca(rtwdev, rtwvif_link, ac); 470 ____rtw89_conf_tx_mu_edca(rtwdev, rtwvif_link, ac); 471 } 472 473 static void rtw89_conf_tx(struct rtw89_dev *rtwdev, 474 struct rtw89_vif_link *rtwvif_link) 475 { 476 u16 ac; 477 478 for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) 479 __rtw89_conf_tx(rtwdev, rtwvif_link, ac); 480 } 481 482 static int __rtw89_ops_sta_add(struct rtw89_dev *rtwdev, 483 struct ieee80211_vif *vif, 484 struct ieee80211_sta *sta) 485 { 486 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 487 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 488 struct rtw89_vif_link *rtwvif_link; 489 struct rtw89_sta_link *rtwsta_link; 490 bool acquire_macid = false; 491 u8 macid; 492 int ret; 493 int i; 494 495 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) { 496 rtwvif->mlo_mode = RTW89_MLO_MODE_MLSR; 497 498 /* for station mode, assign the mac_id from itself */ 499 macid = rtw89_vif_get_main_macid(rtwvif); 500 } else { 501 macid = rtw89_acquire_mac_id(rtwdev); 502 if (macid == RTW89_MAX_MAC_ID_NUM) 503 return -ENOSPC; 504 505 acquire_macid = true; 506 } 507 508 rtw89_init_sta(rtwdev, rtwvif, rtwsta, macid); 509 510 for (i = 0; i < ARRAY_SIZE(sta->txq); i++) 511 rtw89_core_txq_init(rtwdev, sta->txq[i]); 512 513 INIT_LIST_HEAD(&rtwsta->dlink_pool); 514 515 skb_queue_head_init(&rtwsta->roc_queue); 516 bitmap_zero(rtwsta->pairwise_sec_cam_map, RTW89_MAX_SEC_CAM_NUM); 517 518 rtwsta_link = rtw89_sta_set_link(rtwsta, sta->deflink.link_id); 519 if (!rtwsta_link) { 520 ret = -EINVAL; 521 goto err; 522 } 523 524 rtwvif_link = rtwsta_link->rtwvif_link; 525 526 ret = rtw89_core_sta_link_add(rtwdev, rtwvif_link, rtwsta_link); 527 if (ret) 528 goto unset_link; 529 530 if (vif->type == NL80211_IFTYPE_AP || sta->tdls) 531 rtw89_queue_chanctx_change(rtwdev, RTW89_CHANCTX_REMOTE_STA_CHANGE); 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 723 static void rtw89_ops_link_info_changed(struct ieee80211_hw *hw, 724 struct ieee80211_vif *vif, 725 struct ieee80211_bss_conf *conf, 726 u64 changed) 727 { 728 struct rtw89_dev *rtwdev = hw->priv; 729 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 730 struct rtw89_vif_link *rtwvif_link; 731 732 lockdep_assert_wiphy(hw->wiphy); 733 734 rtw89_leave_ps_mode(rtwdev); 735 736 rtwvif_link = rtwvif->links[conf->link_id]; 737 if (unlikely(!rtwvif_link)) { 738 rtw89_err(rtwdev, 739 "%s: rtwvif link (link_id %u) is not active\n", 740 __func__, conf->link_id); 741 return; 742 } 743 744 if (changed & BSS_CHANGED_BSSID) { 745 ether_addr_copy(rtwvif_link->bssid, conf->bssid); 746 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 747 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL); 748 WRITE_ONCE(rtwvif_link->sync_bcn_tsf, 0); 749 } 750 751 if (changed & BSS_CHANGED_BEACON) 752 rtw89_chip_h2c_update_beacon(rtwdev, rtwvif_link); 753 754 if (changed & BSS_CHANGED_ERP_SLOT) 755 rtw89_conf_tx(rtwdev, rtwvif_link); 756 757 if (changed & BSS_CHANGED_HE_BSS_COLOR) 758 rtw89_phy_set_bss_color(rtwdev, rtwvif_link); 759 760 if (changed & BSS_CHANGED_MU_GROUPS) 761 rtw89_mac_bf_set_gid_table(rtwdev, vif, conf); 762 763 if (changed & BSS_CHANGED_P2P_PS) 764 rtw89_core_update_p2p_ps(rtwdev, rtwvif_link, conf); 765 766 if (changed & BSS_CHANGED_CQM) 767 rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true); 768 769 if (changed & BSS_CHANGED_TPE) 770 rtw89_reg_6ghz_recalc(rtwdev, rtwvif_link, true); 771 } 772 773 static int rtw89_ops_start_ap(struct ieee80211_hw *hw, 774 struct ieee80211_vif *vif, 775 struct ieee80211_bss_conf *link_conf) 776 { 777 struct rtw89_dev *rtwdev = hw->priv; 778 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 779 struct rtw89_vif_link *rtwvif_link; 780 const struct rtw89_chan *chan; 781 int ret = 0; 782 783 lockdep_assert_wiphy(hw->wiphy); 784 785 rtwvif_link = rtwvif->links[link_conf->link_id]; 786 if (unlikely(!rtwvif_link)) { 787 rtw89_err(rtwdev, 788 "%s: rtwvif link (link_id %u) is not active\n", 789 __func__, link_conf->link_id); 790 return -ENOLINK; 791 } 792 793 chan = rtw89_chan_get(rtwdev, rtwvif_link->chanctx_idx); 794 if (chan->band_type == RTW89_BAND_6G) 795 return -EOPNOTSUPP; 796 797 if (rtwdev->scanning) 798 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 799 800 ether_addr_copy(rtwvif_link->bssid, link_conf->bssid); 801 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 802 rtw89_mac_port_update(rtwdev, rtwvif_link); 803 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 804 rtw89_fw_h2c_role_maintain(rtwdev, rtwvif_link, NULL, RTW89_ROLE_TYPE_CHANGE); 805 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 806 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL); 807 rtw89_chip_rfk_channel(rtwdev, rtwvif_link); 808 809 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) { 810 ret = rtw89_fw_h2c_ap_info_refcount(rtwdev, true); 811 if (ret) 812 return ret; 813 } 814 815 rtw89_queue_chanctx_work(rtwdev); 816 817 return 0; 818 } 819 820 static 821 void rtw89_ops_stop_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 822 struct ieee80211_bss_conf *link_conf) 823 { 824 struct rtw89_dev *rtwdev = hw->priv; 825 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 826 struct rtw89_vif_link *rtwvif_link; 827 828 lockdep_assert_wiphy(hw->wiphy); 829 830 rtwvif_link = rtwvif->links[link_conf->link_id]; 831 if (unlikely(!rtwvif_link)) { 832 rtw89_err(rtwdev, 833 "%s: rtwvif link (link_id %u) is not active\n", 834 __func__, link_conf->link_id); 835 return; 836 } 837 838 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) 839 rtw89_fw_h2c_ap_info_refcount(rtwdev, false); 840 841 rtw89_mac_stop_ap(rtwdev, rtwvif_link); 842 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 843 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 844 } 845 846 static int rtw89_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 847 bool set) 848 { 849 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 850 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 851 struct rtw89_vif_link *rtwvif_link; 852 unsigned int link_id; 853 854 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 855 wiphy_work_queue(hw->wiphy, &rtwvif_link->update_beacon_work); 856 857 return 0; 858 } 859 860 static int rtw89_ops_conf_tx(struct ieee80211_hw *hw, 861 struct ieee80211_vif *vif, 862 unsigned int link_id, u16 ac, 863 const struct ieee80211_tx_queue_params *params) 864 { 865 struct rtw89_dev *rtwdev = hw->priv; 866 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 867 struct rtw89_vif_link *rtwvif_link; 868 869 lockdep_assert_wiphy(hw->wiphy); 870 871 rtw89_leave_ps_mode(rtwdev); 872 873 rtwvif_link = rtwvif->links[link_id]; 874 if (unlikely(!rtwvif_link)) { 875 rtw89_err(rtwdev, 876 "%s: rtwvif link (link_id %u) is not active\n", 877 __func__, link_id); 878 return -ENOLINK; 879 } 880 881 rtwvif_link->tx_params[ac] = *params; 882 __rtw89_conf_tx(rtwdev, rtwvif_link, ac); 883 884 return 0; 885 } 886 887 static int __rtw89_ops_sta_state(struct ieee80211_hw *hw, 888 struct ieee80211_vif *vif, 889 struct ieee80211_sta *sta, 890 enum ieee80211_sta_state old_state, 891 enum ieee80211_sta_state new_state) 892 { 893 struct rtw89_dev *rtwdev = hw->priv; 894 895 if (old_state == IEEE80211_STA_NOTEXIST && 896 new_state == IEEE80211_STA_NONE) 897 return __rtw89_ops_sta_add(rtwdev, vif, sta); 898 899 if (old_state == IEEE80211_STA_AUTH && 900 new_state == IEEE80211_STA_ASSOC) { 901 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) 902 return 0; /* defer to bss_info_changed to have vif info */ 903 return __rtw89_ops_sta_assoc(rtwdev, vif, sta, false); 904 } 905 906 if (old_state == IEEE80211_STA_ASSOC && 907 new_state == IEEE80211_STA_AUTH) 908 return __rtw89_ops_sta_disassoc(rtwdev, vif, sta); 909 910 if (old_state == IEEE80211_STA_AUTH && 911 new_state == IEEE80211_STA_NONE) 912 return __rtw89_ops_sta_disconnect(rtwdev, vif, sta); 913 914 if (old_state == IEEE80211_STA_NONE && 915 new_state == IEEE80211_STA_NOTEXIST) 916 return __rtw89_ops_sta_remove(rtwdev, vif, sta); 917 918 return 0; 919 } 920 921 static int rtw89_ops_sta_state(struct ieee80211_hw *hw, 922 struct ieee80211_vif *vif, 923 struct ieee80211_sta *sta, 924 enum ieee80211_sta_state old_state, 925 enum ieee80211_sta_state new_state) 926 { 927 struct rtw89_dev *rtwdev = hw->priv; 928 929 lockdep_assert_wiphy(hw->wiphy); 930 931 rtw89_leave_ps_mode(rtwdev); 932 return __rtw89_ops_sta_state(hw, vif, sta, old_state, new_state); 933 } 934 935 static int rtw89_ops_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 936 struct ieee80211_vif *vif, 937 struct ieee80211_sta *sta, 938 struct ieee80211_key_conf *key) 939 { 940 struct rtw89_dev *rtwdev = hw->priv; 941 int ret; 942 943 lockdep_assert_wiphy(hw->wiphy); 944 945 rtw89_leave_ps_mode(rtwdev); 946 947 switch (cmd) { 948 case SET_KEY: 949 rtw89_btc_ntfy_specific_packet(rtwdev, PACKET_EAPOL_END); 950 ret = rtw89_cam_sec_key_add(rtwdev, vif, sta, key); 951 if (ret && ret != -EOPNOTSUPP) { 952 rtw89_err(rtwdev, "failed to add key to sec cam\n"); 953 return ret; 954 } 955 break; 956 case DISABLE_KEY: 957 rtw89_hci_flush_queues(rtwdev, BIT(rtwdev->hw->queues) - 1, 958 false); 959 rtw89_mac_flush_txq(rtwdev, BIT(rtwdev->hw->queues) - 1, false); 960 ret = rtw89_cam_sec_key_del(rtwdev, vif, sta, key, true); 961 if (ret) { 962 rtw89_err(rtwdev, "failed to remove key from sec cam\n"); 963 return ret; 964 } 965 break; 966 } 967 968 return ret; 969 } 970 971 static int rtw89_ops_ampdu_action(struct ieee80211_hw *hw, 972 struct ieee80211_vif *vif, 973 struct ieee80211_ampdu_params *params) 974 { 975 struct rtw89_dev *rtwdev = hw->priv; 976 struct ieee80211_sta *sta = params->sta; 977 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 978 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 979 u16 tid = params->tid; 980 struct ieee80211_txq *txq = sta->txq[tid]; 981 struct rtw89_txq *rtwtxq = (struct rtw89_txq *)txq->drv_priv; 982 983 lockdep_assert_wiphy(rtwdev->hw->wiphy); 984 985 switch (params->action) { 986 case IEEE80211_AMPDU_TX_START: 987 return IEEE80211_AMPDU_TX_START_IMMEDIATE; 988 case IEEE80211_AMPDU_TX_STOP_CONT: 989 case IEEE80211_AMPDU_TX_STOP_FLUSH: 990 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 991 clear_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 992 clear_bit(tid, rtwsta->ampdu_map); 993 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 994 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 995 break; 996 case IEEE80211_AMPDU_TX_OPERATIONAL: 997 set_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 998 rtwsta->ampdu_params[tid].agg_num = params->buf_size; 999 rtwsta->ampdu_params[tid].amsdu = params->amsdu; 1000 set_bit(tid, rtwsta->ampdu_map); 1001 rtw89_leave_ps_mode(rtwdev); 1002 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 1003 break; 1004 case IEEE80211_AMPDU_RX_START: 1005 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, true, params); 1006 break; 1007 case IEEE80211_AMPDU_RX_STOP: 1008 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, false, params); 1009 break; 1010 default: 1011 WARN_ON(1); 1012 return -ENOTSUPP; 1013 } 1014 1015 return 0; 1016 } 1017 1018 static int rtw89_ops_set_rts_threshold(struct ieee80211_hw *hw, int radio_idx, 1019 u32 value) 1020 { 1021 struct rtw89_dev *rtwdev = hw->priv; 1022 1023 lockdep_assert_wiphy(hw->wiphy); 1024 1025 rtw89_leave_ps_mode(rtwdev); 1026 if (test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) 1027 rtw89_mac_update_rts_threshold(rtwdev); 1028 1029 return 0; 1030 } 1031 1032 static void rtw89_ops_sta_statistics(struct ieee80211_hw *hw, 1033 struct ieee80211_vif *vif, 1034 struct ieee80211_sta *sta, 1035 struct station_info *sinfo) 1036 { 1037 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1038 struct rtw89_sta_link *rtwsta_link; 1039 1040 rtwsta_link = rtw89_get_designated_link(rtwsta); 1041 if (unlikely(!rtwsta_link)) 1042 return; 1043 1044 sinfo->txrate = rtwsta_link->ra_report.txrate; 1045 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 1046 } 1047 1048 static 1049 void __rtw89_drop_packets(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif) 1050 { 1051 struct rtw89_vif *rtwvif; 1052 1053 if (vif) { 1054 rtwvif = vif_to_rtwvif(vif); 1055 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1056 } else { 1057 rtw89_for_each_rtwvif(rtwdev, rtwvif) 1058 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1059 } 1060 } 1061 1062 static void rtw89_ops_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1063 u32 queues, bool drop) 1064 { 1065 struct rtw89_dev *rtwdev = hw->priv; 1066 1067 lockdep_assert_wiphy(hw->wiphy); 1068 1069 rtw89_leave_lps(rtwdev); 1070 rtw89_hci_flush_queues(rtwdev, queues, drop); 1071 1072 if (drop && !RTW89_CHK_FW_FEATURE(NO_PACKET_DROP, &rtwdev->fw)) 1073 __rtw89_drop_packets(rtwdev, vif); 1074 else 1075 rtw89_mac_flush_txq(rtwdev, queues, drop); 1076 } 1077 1078 struct rtw89_iter_bitrate_mask_data { 1079 struct rtw89_dev *rtwdev; 1080 struct ieee80211_vif *vif; 1081 const struct cfg80211_bitrate_mask *mask; 1082 }; 1083 1084 static void rtw89_ra_mask_info_update_iter(void *data, struct ieee80211_sta *sta) 1085 { 1086 struct rtw89_iter_bitrate_mask_data *br_data = data; 1087 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1088 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 1089 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif); 1090 struct rtw89_sta_link *rtwsta_link; 1091 unsigned int link_id; 1092 1093 if (vif != br_data->vif || vif->p2p) 1094 return; 1095 1096 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 1097 rtwsta_link->use_cfg_mask = true; 1098 rtwsta_link->mask = *br_data->mask; 1099 } 1100 1101 rtw89_phy_ra_update_sta(br_data->rtwdev, sta, IEEE80211_RC_SUPP_RATES_CHANGED); 1102 } 1103 1104 static void rtw89_ra_mask_info_update(struct rtw89_dev *rtwdev, 1105 struct ieee80211_vif *vif, 1106 const struct cfg80211_bitrate_mask *mask) 1107 { 1108 struct rtw89_iter_bitrate_mask_data br_data = { .rtwdev = rtwdev, 1109 .vif = vif, 1110 .mask = mask}; 1111 1112 ieee80211_iterate_stations_atomic(rtwdev->hw, rtw89_ra_mask_info_update_iter, 1113 &br_data); 1114 } 1115 1116 static int rtw89_ops_set_bitrate_mask(struct ieee80211_hw *hw, 1117 struct ieee80211_vif *vif, 1118 const struct cfg80211_bitrate_mask *mask) 1119 { 1120 struct rtw89_dev *rtwdev = hw->priv; 1121 1122 lockdep_assert_wiphy(hw->wiphy); 1123 1124 rtw89_phy_rate_pattern_vif(rtwdev, vif, mask); 1125 rtw89_ra_mask_info_update(rtwdev, vif, mask); 1126 1127 return 0; 1128 } 1129 1130 static 1131 int rtw89_ops_set_antenna(struct ieee80211_hw *hw, int radio_idx, u32 tx_ant, u32 rx_ant) 1132 { 1133 struct rtw89_dev *rtwdev = hw->priv; 1134 struct rtw89_hal *hal = &rtwdev->hal; 1135 1136 lockdep_assert_wiphy(hw->wiphy); 1137 1138 if (hal->ant_diversity) { 1139 if (tx_ant != rx_ant || hweight32(tx_ant) != 1) 1140 return -EINVAL; 1141 } else if (rx_ant != hw->wiphy->available_antennas_rx && rx_ant != hal->antenna_rx) { 1142 return -EINVAL; 1143 } 1144 1145 hal->antenna_tx = tx_ant; 1146 hal->antenna_rx = rx_ant; 1147 hal->tx_path_diversity = false; 1148 hal->ant_diversity_fixed = true; 1149 1150 return 0; 1151 } 1152 1153 static 1154 int rtw89_ops_get_antenna(struct ieee80211_hw *hw, int radio_idx, u32 *tx_ant, 1155 u32 *rx_ant) 1156 { 1157 struct rtw89_dev *rtwdev = hw->priv; 1158 struct rtw89_hal *hal = &rtwdev->hal; 1159 1160 *tx_ant = hal->antenna_tx; 1161 *rx_ant = hal->antenna_rx; 1162 1163 return 0; 1164 } 1165 1166 static void rtw89_ops_sw_scan_start(struct ieee80211_hw *hw, 1167 struct ieee80211_vif *vif, 1168 const u8 *mac_addr) 1169 { 1170 struct rtw89_dev *rtwdev = hw->priv; 1171 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1172 struct rtw89_vif_link *rtwvif_link; 1173 1174 lockdep_assert_wiphy(hw->wiphy); 1175 1176 rtwvif_link = rtw89_get_designated_link(rtwvif); 1177 if (unlikely(!rtwvif_link)) { 1178 rtw89_err(rtwdev, "sw scan start: find no designated link\n"); 1179 return; 1180 } 1181 1182 rtw89_leave_lps(rtwdev); 1183 1184 rtw89_core_scan_start(rtwdev, rtwvif_link, mac_addr, false); 1185 } 1186 1187 static void rtw89_ops_sw_scan_complete(struct ieee80211_hw *hw, 1188 struct ieee80211_vif *vif) 1189 { 1190 struct rtw89_dev *rtwdev = hw->priv; 1191 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1192 struct rtw89_vif_link *rtwvif_link; 1193 1194 lockdep_assert_wiphy(hw->wiphy); 1195 1196 rtwvif_link = rtw89_get_designated_link(rtwvif); 1197 if (unlikely(!rtwvif_link)) { 1198 rtw89_err(rtwdev, "sw scan complete: find no designated link\n"); 1199 return; 1200 } 1201 1202 rtw89_core_scan_complete(rtwdev, rtwvif_link, false); 1203 } 1204 1205 static void rtw89_ops_reconfig_complete(struct ieee80211_hw *hw, 1206 enum ieee80211_reconfig_type reconfig_type) 1207 { 1208 struct rtw89_dev *rtwdev = hw->priv; 1209 1210 if (reconfig_type == IEEE80211_RECONFIG_TYPE_RESTART) 1211 rtw89_ser_recfg_done(rtwdev); 1212 } 1213 1214 static int rtw89_ops_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1215 struct ieee80211_scan_request *req) 1216 { 1217 struct rtw89_dev *rtwdev = hw->priv; 1218 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1219 struct rtw89_vif_link *rtwvif_link; 1220 int ret; 1221 1222 lockdep_assert_wiphy(hw->wiphy); 1223 1224 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1225 return 1; 1226 1227 if (rtwdev->scanning || rtwvif->offchan) 1228 return -EBUSY; 1229 1230 rtwvif_link = rtw89_get_designated_link(rtwvif); 1231 if (unlikely(!rtwvif_link)) { 1232 rtw89_err(rtwdev, "hw scan: find no designated link\n"); 1233 return -ENOLINK; 1234 } 1235 1236 rtw89_leave_lps(rtwdev); 1237 rtw89_leave_ips_by_hwflags(rtwdev); 1238 1239 ret = rtw89_hw_scan_start(rtwdev, rtwvif_link, req); 1240 if (ret) 1241 return ret; 1242 1243 ret = rtw89_hw_scan_offload(rtwdev, rtwvif_link, true); 1244 if (ret) { 1245 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1246 rtw89_err(rtwdev, "HW scan failed with status: %d\n", ret); 1247 } 1248 1249 return ret; 1250 } 1251 1252 static void rtw89_ops_cancel_hw_scan(struct ieee80211_hw *hw, 1253 struct ieee80211_vif *vif) 1254 { 1255 struct rtw89_dev *rtwdev = hw->priv; 1256 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1257 struct rtw89_vif_link *rtwvif_link; 1258 1259 lockdep_assert_wiphy(hw->wiphy); 1260 1261 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1262 return; 1263 1264 if (!rtwdev->scanning) 1265 return; 1266 1267 rtwvif_link = rtw89_get_designated_link(rtwvif); 1268 if (unlikely(!rtwvif_link)) { 1269 rtw89_err(rtwdev, "cancel hw scan: find no designated link\n"); 1270 return; 1271 } 1272 1273 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1274 } 1275 1276 static void rtw89_ops_sta_rc_update(struct ieee80211_hw *hw, 1277 struct ieee80211_vif *vif, 1278 struct ieee80211_link_sta *link_sta, 1279 u32 changed) 1280 { 1281 struct rtw89_sta *rtwsta = sta_to_rtwsta(link_sta->sta); 1282 struct rtw89_dev *rtwdev = hw->priv; 1283 struct rtw89_sta_link *rtwsta_link; 1284 1285 rtwsta_link = rtwsta->links[link_sta->link_id]; 1286 if (unlikely(!rtwsta_link)) 1287 return; 1288 1289 rtw89_phy_ra_update_sta_link(rtwdev, rtwsta_link, changed); 1290 } 1291 1292 static int rtw89_ops_add_chanctx(struct ieee80211_hw *hw, 1293 struct ieee80211_chanctx_conf *ctx) 1294 { 1295 struct rtw89_dev *rtwdev = hw->priv; 1296 1297 lockdep_assert_wiphy(hw->wiphy); 1298 1299 return rtw89_chanctx_ops_add(rtwdev, ctx); 1300 } 1301 1302 static void rtw89_ops_remove_chanctx(struct ieee80211_hw *hw, 1303 struct ieee80211_chanctx_conf *ctx) 1304 { 1305 struct rtw89_dev *rtwdev = hw->priv; 1306 1307 lockdep_assert_wiphy(hw->wiphy); 1308 1309 rtw89_chanctx_ops_remove(rtwdev, ctx); 1310 } 1311 1312 static void rtw89_ops_change_chanctx(struct ieee80211_hw *hw, 1313 struct ieee80211_chanctx_conf *ctx, 1314 u32 changed) 1315 { 1316 struct rtw89_dev *rtwdev = hw->priv; 1317 1318 lockdep_assert_wiphy(hw->wiphy); 1319 1320 rtw89_chanctx_ops_change(rtwdev, ctx, changed); 1321 } 1322 1323 static int rtw89_ops_assign_vif_chanctx(struct ieee80211_hw *hw, 1324 struct ieee80211_vif *vif, 1325 struct ieee80211_bss_conf *link_conf, 1326 struct ieee80211_chanctx_conf *ctx) 1327 { 1328 struct rtw89_dev *rtwdev = hw->priv; 1329 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1330 struct rtw89_vif_link *rtwvif_link; 1331 1332 lockdep_assert_wiphy(hw->wiphy); 1333 1334 rtwvif_link = rtwvif->links[link_conf->link_id]; 1335 if (unlikely(!rtwvif_link)) { 1336 rtw89_err(rtwdev, 1337 "%s: rtwvif link (link_id %u) is not active\n", 1338 __func__, link_conf->link_id); 1339 return -ENOLINK; 1340 } 1341 1342 return rtw89_chanctx_ops_assign_vif(rtwdev, rtwvif_link, ctx); 1343 } 1344 1345 static void rtw89_ops_unassign_vif_chanctx(struct ieee80211_hw *hw, 1346 struct ieee80211_vif *vif, 1347 struct ieee80211_bss_conf *link_conf, 1348 struct ieee80211_chanctx_conf *ctx) 1349 { 1350 struct rtw89_dev *rtwdev = hw->priv; 1351 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1352 struct rtw89_vif_link *rtwvif_link; 1353 1354 lockdep_assert_wiphy(hw->wiphy); 1355 1356 rtwvif_link = rtwvif->links[link_conf->link_id]; 1357 if (unlikely(!rtwvif_link)) { 1358 rtw89_err(rtwdev, 1359 "%s: rtwvif link (link_id %u) is not active\n", 1360 __func__, link_conf->link_id); 1361 return; 1362 } 1363 1364 rtw89_chanctx_ops_unassign_vif(rtwdev, rtwvif_link, ctx); 1365 } 1366 1367 static 1368 int rtw89_ops_switch_vif_chanctx(struct ieee80211_hw *hw, 1369 struct ieee80211_vif_chanctx_switch *vifs, 1370 int n_vifs, 1371 enum ieee80211_chanctx_switch_mode mode) 1372 { 1373 struct rtw89_dev *rtwdev = hw->priv; 1374 bool replace; 1375 int ret; 1376 int i; 1377 1378 lockdep_assert_wiphy(hw->wiphy); 1379 1380 switch (mode) { 1381 case CHANCTX_SWMODE_REASSIGN_VIF: 1382 replace = false; 1383 break; 1384 case CHANCTX_SWMODE_SWAP_CONTEXTS: 1385 replace = true; 1386 break; 1387 default: 1388 return -EOPNOTSUPP; 1389 } 1390 1391 for (i = 0; i < n_vifs; i++) { 1392 struct ieee80211_vif_chanctx_switch *p = &vifs[i]; 1393 struct ieee80211_bss_conf *link_conf = p->link_conf; 1394 struct rtw89_vif *rtwvif = vif_to_rtwvif(p->vif); 1395 struct rtw89_vif_link *rtwvif_link; 1396 1397 rtwvif_link = rtwvif->links[link_conf->link_id]; 1398 if (unlikely(!rtwvif_link)) { 1399 rtw89_err(rtwdev, 1400 "%s: rtwvif link (link_id %u) is not active\n", 1401 __func__, link_conf->link_id); 1402 return -ENOLINK; 1403 } 1404 1405 ret = rtw89_chanctx_ops_reassign_vif(rtwdev, rtwvif_link, 1406 p->old_ctx, p->new_ctx, 1407 replace); 1408 if (ret) 1409 return ret; 1410 } 1411 1412 return 0; 1413 } 1414 1415 static void rtw89_ops_channel_switch_beacon(struct ieee80211_hw *hw, 1416 struct ieee80211_vif *vif, 1417 struct cfg80211_chan_def *chandef) 1418 { 1419 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1420 struct rtw89_dev *rtwdev = hw->priv; 1421 struct rtw89_vif_link *rtwvif_link; 1422 1423 BUILD_BUG_ON(RTW89_MLD_NON_STA_LINK_NUM != 1); 1424 1425 rtwvif_link = rtw89_vif_get_link_inst(rtwvif, 0); 1426 if (unlikely(!rtwvif_link)) { 1427 rtw89_err(rtwdev, "chsw bcn: find no link on HW-0\n"); 1428 return; 1429 } 1430 1431 wiphy_delayed_work_queue(hw->wiphy, &rtwvif_link->csa_beacon_work, 0); 1432 } 1433 1434 static int rtw89_ops_remain_on_channel(struct ieee80211_hw *hw, 1435 struct ieee80211_vif *vif, 1436 struct ieee80211_channel *chan, 1437 int duration, 1438 enum ieee80211_roc_type type) 1439 { 1440 struct rtw89_dev *rtwdev = hw->priv; 1441 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1442 struct rtw89_roc *roc = &rtwvif->roc; 1443 1444 lockdep_assert_wiphy(hw->wiphy); 1445 1446 if (!rtwvif) 1447 return -EINVAL; 1448 1449 if (roc->state != RTW89_ROC_IDLE) { 1450 return -EBUSY; 1451 } 1452 1453 if (rtwdev->scanning) 1454 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1455 1456 if (type == IEEE80211_ROC_TYPE_MGMT_TX) 1457 roc->state = RTW89_ROC_MGMT; 1458 else 1459 roc->state = RTW89_ROC_NORMAL; 1460 1461 roc->duration = duration; 1462 roc->chan = *chan; 1463 roc->type = type; 1464 1465 rtw89_roc_start(rtwdev, rtwvif); 1466 1467 return 0; 1468 } 1469 1470 static int rtw89_ops_cancel_remain_on_channel(struct ieee80211_hw *hw, 1471 struct ieee80211_vif *vif) 1472 { 1473 struct rtw89_dev *rtwdev = hw->priv; 1474 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1475 1476 lockdep_assert_wiphy(hw->wiphy); 1477 1478 if (!rtwvif) 1479 return -EINVAL; 1480 1481 wiphy_delayed_work_cancel(hw->wiphy, &rtwvif->roc.roc_work); 1482 1483 rtw89_roc_end(rtwdev, rtwvif); 1484 1485 return 0; 1486 } 1487 1488 static void rtw89_set_tid_config_iter(void *data, struct ieee80211_sta *sta) 1489 { 1490 struct cfg80211_tid_config *tid_config = data; 1491 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1492 struct rtw89_dev *rtwdev = rtwsta->rtwdev; 1493 1494 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1495 } 1496 1497 static int rtw89_ops_set_tid_config(struct ieee80211_hw *hw, 1498 struct ieee80211_vif *vif, 1499 struct ieee80211_sta *sta, 1500 struct cfg80211_tid_config *tid_config) 1501 { 1502 struct rtw89_dev *rtwdev = hw->priv; 1503 1504 lockdep_assert_wiphy(hw->wiphy); 1505 1506 if (sta) 1507 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1508 else 1509 ieee80211_iterate_stations_atomic(rtwdev->hw, 1510 rtw89_set_tid_config_iter, 1511 tid_config); 1512 1513 return 0; 1514 } 1515 1516 static bool rtw89_can_work_on_links(struct rtw89_dev *rtwdev, 1517 struct ieee80211_vif *vif, u16 links) 1518 { 1519 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1520 u8 w = hweight16(links); 1521 1522 if (vif->type != NL80211_IFTYPE_STATION && 1523 w > RTW89_MLD_NON_STA_LINK_NUM) 1524 return false; 1525 1526 return w <= rtwvif->links_inst_valid_num; 1527 } 1528 1529 static bool rtw89_ops_can_activate_links(struct ieee80211_hw *hw, 1530 struct ieee80211_vif *vif, 1531 u16 active_links) 1532 { 1533 struct rtw89_dev *rtwdev = hw->priv; 1534 1535 lockdep_assert_wiphy(hw->wiphy); 1536 1537 return rtw89_can_work_on_links(rtwdev, vif, active_links); 1538 } 1539 1540 static void __rtw89_ops_clr_vif_links(struct rtw89_dev *rtwdev, 1541 struct rtw89_vif *rtwvif, 1542 unsigned long clr_links) 1543 { 1544 struct rtw89_vif_link *rtwvif_link; 1545 unsigned int link_id; 1546 1547 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1548 rtwvif_link = rtwvif->links[link_id]; 1549 if (unlikely(!rtwvif_link)) 1550 continue; 1551 1552 __rtw89_ops_remove_iface_link(rtwdev, rtwvif_link); 1553 1554 rtw89_vif_unset_link(rtwvif, link_id); 1555 } 1556 } 1557 1558 static int __rtw89_ops_set_vif_links(struct rtw89_dev *rtwdev, 1559 struct rtw89_vif *rtwvif, 1560 unsigned long set_links) 1561 { 1562 struct rtw89_vif_link *rtwvif_link; 1563 unsigned int link_id; 1564 int ret; 1565 1566 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1567 rtwvif_link = rtw89_vif_set_link(rtwvif, link_id); 1568 if (!rtwvif_link) 1569 return -EINVAL; 1570 1571 ret = __rtw89_ops_add_iface_link(rtwdev, rtwvif_link); 1572 if (ret) { 1573 rtw89_err(rtwdev, "%s: failed to add iface (link id %u)\n", 1574 __func__, link_id); 1575 return ret; 1576 } 1577 } 1578 1579 return 0; 1580 } 1581 1582 static 1583 int rtw89_ops_change_vif_links(struct ieee80211_hw *hw, 1584 struct ieee80211_vif *vif, 1585 u16 old_links, u16 new_links, 1586 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 1587 { 1588 struct rtw89_dev *rtwdev = hw->priv; 1589 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1590 unsigned long clr_links = old_links & ~new_links; 1591 unsigned long set_links = new_links & ~old_links; 1592 bool removing_links = !old_links || clr_links; 1593 struct rtw89_link_conf_container *snap; 1594 int ret = 0; 1595 int i; 1596 1597 lockdep_assert_wiphy(hw->wiphy); 1598 1599 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1600 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1601 __func__, old_links, new_links); 1602 1603 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1604 return -EOPNOTSUPP; 1605 1606 if (removing_links) { 1607 snap = kzalloc(sizeof(*snap), GFP_KERNEL); 1608 if (!snap) 1609 return -ENOMEM; 1610 1611 for (i = 0; i < ARRAY_SIZE(snap->link_conf); i++) 1612 snap->link_conf[i] = old[i]; 1613 1614 rcu_assign_pointer(rtwvif->snap_link_confs, snap); 1615 } 1616 1617 /* might depend on @snap; don't change order */ 1618 rtw89_leave_ips_by_hwflags(rtwdev); 1619 1620 if (rtwdev->scanning) 1621 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1622 1623 if (!old_links) 1624 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1625 BIT(RTW89_VIF_IDLE_LINK_ID)); 1626 else if (clr_links) 1627 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, clr_links); 1628 1629 if (removing_links) { 1630 /* @snap is required if and only if during removing links. 1631 * However, it's done here. So, cleanup @snap immediately. 1632 */ 1633 rcu_assign_pointer(rtwvif->snap_link_confs, NULL); 1634 1635 /* The pointers in @old will free after this function return, 1636 * so synchronously wait for all readers of snap to be done. 1637 */ 1638 synchronize_rcu(); 1639 kfree(snap); 1640 } 1641 1642 if (set_links) { 1643 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, set_links); 1644 if (ret) 1645 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, set_links); 1646 } else if (!new_links) { 1647 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, 1648 BIT(RTW89_VIF_IDLE_LINK_ID)); 1649 if (ret) 1650 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1651 BIT(RTW89_VIF_IDLE_LINK_ID)); 1652 } 1653 1654 rtw89_enter_ips_by_hwflags(rtwdev); 1655 return ret; 1656 } 1657 1658 static void __rtw89_ops_clr_sta_links(struct rtw89_dev *rtwdev, 1659 struct rtw89_sta *rtwsta, 1660 unsigned long clr_links) 1661 { 1662 struct rtw89_vif_link *rtwvif_link; 1663 struct rtw89_sta_link *rtwsta_link; 1664 unsigned int link_id; 1665 1666 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1667 rtwsta_link = rtwsta->links[link_id]; 1668 if (unlikely(!rtwsta_link)) 1669 continue; 1670 1671 rtwvif_link = rtwsta_link->rtwvif_link; 1672 1673 rtw89_core_sta_link_disassoc(rtwdev, rtwvif_link, rtwsta_link); 1674 rtw89_core_sta_link_disconnect(rtwdev, rtwvif_link, rtwsta_link); 1675 rtw89_core_sta_link_remove(rtwdev, rtwvif_link, rtwsta_link); 1676 1677 rtw89_sta_unset_link(rtwsta, link_id); 1678 } 1679 } 1680 1681 static int __rtw89_ops_set_sta_links(struct rtw89_dev *rtwdev, 1682 struct rtw89_sta *rtwsta, 1683 unsigned long set_links) 1684 { 1685 struct rtw89_vif_link *rtwvif_link; 1686 struct rtw89_sta_link *rtwsta_link; 1687 unsigned int link_id; 1688 u8 sec_cam_idx; 1689 int ret; 1690 1691 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1692 rtwsta_link = rtw89_sta_set_link(rtwsta, link_id); 1693 if (!rtwsta_link) 1694 return -EINVAL; 1695 1696 rtwvif_link = rtwsta_link->rtwvif_link; 1697 1698 ret = rtw89_core_sta_link_add(rtwdev, rtwvif_link, rtwsta_link); 1699 if (ret) { 1700 rtw89_err(rtwdev, "%s: failed to add sta (link id %u)\n", 1701 __func__, link_id); 1702 return ret; 1703 } 1704 1705 rtw89_vif_type_mapping(rtwvif_link, true); 1706 1707 ret = rtw89_core_sta_link_assoc(rtwdev, rtwvif_link, rtwsta_link); 1708 if (ret) { 1709 rtw89_err(rtwdev, "%s: failed to assoc sta (link id %u)\n", 1710 __func__, link_id); 1711 return ret; 1712 } 1713 1714 __rtw89_ops_bss_link_assoc(rtwdev, rtwvif_link); 1715 1716 for_each_set_bit(sec_cam_idx, rtwsta->pairwise_sec_cam_map, 1717 RTW89_MAX_SEC_CAM_NUM) { 1718 ret = rtw89_cam_attach_link_sec_cam(rtwdev, 1719 rtwvif_link, 1720 rtwsta_link, 1721 sec_cam_idx); 1722 if (ret) { 1723 rtw89_err(rtwdev, 1724 "%s: failed to apply pairwise key (link id %u)\n", 1725 __func__, link_id); 1726 return ret; 1727 } 1728 } 1729 } 1730 1731 return 0; 1732 } 1733 1734 static 1735 int rtw89_ops_change_sta_links(struct ieee80211_hw *hw, 1736 struct ieee80211_vif *vif, 1737 struct ieee80211_sta *sta, 1738 u16 old_links, u16 new_links) 1739 { 1740 struct rtw89_dev *rtwdev = hw->priv; 1741 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1742 unsigned long clr_links = old_links & ~new_links; 1743 unsigned long set_links = new_links & ~old_links; 1744 int ret = 0; 1745 1746 lockdep_assert_wiphy(hw->wiphy); 1747 1748 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1749 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1750 __func__, old_links, new_links); 1751 1752 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1753 return -EOPNOTSUPP; 1754 1755 rtw89_leave_ps_mode(rtwdev); 1756 1757 if (clr_links) 1758 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, clr_links); 1759 1760 if (set_links) { 1761 ret = __rtw89_ops_set_sta_links(rtwdev, rtwsta, set_links); 1762 if (ret) 1763 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, set_links); 1764 } 1765 1766 return ret; 1767 } 1768 1769 #ifdef CONFIG_PM 1770 static int rtw89_ops_suspend(struct ieee80211_hw *hw, 1771 struct cfg80211_wowlan *wowlan) 1772 { 1773 struct rtw89_dev *rtwdev = hw->priv; 1774 int ret; 1775 1776 lockdep_assert_wiphy(hw->wiphy); 1777 1778 set_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1779 wiphy_delayed_work_cancel(hw->wiphy, &rtwdev->track_work); 1780 wiphy_delayed_work_cancel(hw->wiphy, &rtwdev->track_ps_work); 1781 1782 ret = rtw89_wow_suspend(rtwdev, wowlan); 1783 if (ret) { 1784 rtw89_warn(rtwdev, "failed to suspend for wow %d\n", ret); 1785 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1786 return 1; 1787 } 1788 1789 return 0; 1790 } 1791 1792 static int rtw89_ops_resume(struct ieee80211_hw *hw) 1793 { 1794 struct rtw89_dev *rtwdev = hw->priv; 1795 int ret; 1796 1797 lockdep_assert_wiphy(hw->wiphy); 1798 1799 ret = rtw89_wow_resume(rtwdev); 1800 if (ret) 1801 rtw89_warn(rtwdev, "failed to resume for wow %d\n", ret); 1802 1803 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WORK, rtwdev->flags); 1804 wiphy_delayed_work_queue(hw->wiphy, &rtwdev->track_work, 1805 RTW89_TRACK_WORK_PERIOD); 1806 wiphy_delayed_work_queue(hw->wiphy, &rtwdev->track_ps_work, 1807 RTW89_TRACK_PS_WORK_PERIOD); 1808 1809 return ret ? 1 : 0; 1810 } 1811 1812 static void rtw89_ops_set_wakeup(struct ieee80211_hw *hw, bool enabled) 1813 { 1814 struct rtw89_dev *rtwdev = hw->priv; 1815 1816 device_set_wakeup_enable(rtwdev->dev, enabled); 1817 } 1818 1819 static void rtw89_set_rekey_data(struct ieee80211_hw *hw, 1820 struct ieee80211_vif *vif, 1821 struct cfg80211_gtk_rekey_data *data) 1822 { 1823 struct rtw89_dev *rtwdev = hw->priv; 1824 struct rtw89_wow_param *rtw_wow = &rtwdev->wow; 1825 struct rtw89_wow_gtk_info *gtk_info = &rtw_wow->gtk_info; 1826 1827 lockdep_assert_wiphy(hw->wiphy); 1828 1829 if (data->kek_len > sizeof(gtk_info->kek) || 1830 data->kck_len > sizeof(gtk_info->kck)) { 1831 rtw89_warn(rtwdev, "kek or kck length over fw limit\n"); 1832 return; 1833 } 1834 1835 memcpy(gtk_info->kek, data->kek, data->kek_len); 1836 memcpy(gtk_info->kck, data->kck, data->kck_len); 1837 } 1838 #endif 1839 1840 static void rtw89_ops_rfkill_poll(struct ieee80211_hw *hw) 1841 { 1842 struct rtw89_dev *rtwdev = hw->priv; 1843 1844 lockdep_assert_wiphy(hw->wiphy); 1845 1846 /* wl_disable GPIO get floating when entering LPS */ 1847 if (test_bit(RTW89_FLAG_RUNNING, rtwdev->flags)) 1848 return; 1849 1850 rtw89_core_rfkill_poll(rtwdev, false); 1851 } 1852 1853 const struct ieee80211_ops rtw89_ops = { 1854 .tx = rtw89_ops_tx, 1855 .wake_tx_queue = rtw89_ops_wake_tx_queue, 1856 .start = rtw89_ops_start, 1857 .stop = rtw89_ops_stop, 1858 .config = rtw89_ops_config, 1859 .add_interface = rtw89_ops_add_interface, 1860 .change_interface = rtw89_ops_change_interface, 1861 .remove_interface = rtw89_ops_remove_interface, 1862 .configure_filter = rtw89_ops_configure_filter, 1863 .vif_cfg_changed = rtw89_ops_vif_cfg_changed, 1864 .link_info_changed = rtw89_ops_link_info_changed, 1865 .start_ap = rtw89_ops_start_ap, 1866 .stop_ap = rtw89_ops_stop_ap, 1867 .set_tim = rtw89_ops_set_tim, 1868 .conf_tx = rtw89_ops_conf_tx, 1869 .sta_state = rtw89_ops_sta_state, 1870 .set_key = rtw89_ops_set_key, 1871 .ampdu_action = rtw89_ops_ampdu_action, 1872 .set_rts_threshold = rtw89_ops_set_rts_threshold, 1873 .sta_statistics = rtw89_ops_sta_statistics, 1874 .flush = rtw89_ops_flush, 1875 .set_bitrate_mask = rtw89_ops_set_bitrate_mask, 1876 .set_antenna = rtw89_ops_set_antenna, 1877 .get_antenna = rtw89_ops_get_antenna, 1878 .sw_scan_start = rtw89_ops_sw_scan_start, 1879 .sw_scan_complete = rtw89_ops_sw_scan_complete, 1880 .reconfig_complete = rtw89_ops_reconfig_complete, 1881 .hw_scan = rtw89_ops_hw_scan, 1882 .cancel_hw_scan = rtw89_ops_cancel_hw_scan, 1883 .add_chanctx = rtw89_ops_add_chanctx, 1884 .remove_chanctx = rtw89_ops_remove_chanctx, 1885 .change_chanctx = rtw89_ops_change_chanctx, 1886 .assign_vif_chanctx = rtw89_ops_assign_vif_chanctx, 1887 .unassign_vif_chanctx = rtw89_ops_unassign_vif_chanctx, 1888 .switch_vif_chanctx = rtw89_ops_switch_vif_chanctx, 1889 .channel_switch_beacon = rtw89_ops_channel_switch_beacon, 1890 .remain_on_channel = rtw89_ops_remain_on_channel, 1891 .cancel_remain_on_channel = rtw89_ops_cancel_remain_on_channel, 1892 .set_sar_specs = rtw89_ops_set_sar_specs, 1893 .link_sta_rc_update = rtw89_ops_sta_rc_update, 1894 .set_tid_config = rtw89_ops_set_tid_config, 1895 .can_activate_links = rtw89_ops_can_activate_links, 1896 .change_vif_links = rtw89_ops_change_vif_links, 1897 .change_sta_links = rtw89_ops_change_sta_links, 1898 #ifdef CONFIG_PM 1899 .suspend = rtw89_ops_suspend, 1900 .resume = rtw89_ops_resume, 1901 .set_wakeup = rtw89_ops_set_wakeup, 1902 .set_rekey_data = rtw89_set_rekey_data, 1903 #endif 1904 .rfkill_poll = rtw89_ops_rfkill_poll, 1905 }; 1906 EXPORT_SYMBOL(rtw89_ops); 1907