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