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