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 rtw89_mac_set_he_tb(rtwdev, rtwvif_link); 660 } 661 662 static void __rtw89_ops_bss_assoc(struct rtw89_dev *rtwdev, 663 struct ieee80211_vif *vif) 664 { 665 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 666 struct rtw89_vif_link *rtwvif_link; 667 unsigned int link_id; 668 669 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 670 __rtw89_ops_bss_link_assoc(rtwdev, rtwvif_link); 671 } 672 673 static void rtw89_ops_vif_cfg_changed(struct ieee80211_hw *hw, 674 struct ieee80211_vif *vif, u64 changed) 675 { 676 struct rtw89_dev *rtwdev = hw->priv; 677 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 678 679 lockdep_assert_wiphy(hw->wiphy); 680 681 rtw89_leave_ps_mode(rtwdev); 682 683 if (changed & BSS_CHANGED_ASSOC) { 684 if (vif->cfg.assoc) { 685 rtw89_station_mode_sta_assoc(rtwdev, vif); 686 __rtw89_ops_bss_assoc(rtwdev, vif); 687 688 rtw89_queue_chanctx_work(rtwdev); 689 } else { 690 /* Abort ongoing scan if cancel_scan isn't issued 691 * when disconnected by peer 692 */ 693 if (rtwdev->scanning) 694 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 695 } 696 } 697 698 if (changed & BSS_CHANGED_PS) 699 rtw89_recalc_lps(rtwdev); 700 701 if (changed & BSS_CHANGED_ARP_FILTER) 702 rtwvif->ip_addr = vif->cfg.arp_addr_list[0]; 703 } 704 705 static void rtw89_ops_link_info_changed(struct ieee80211_hw *hw, 706 struct ieee80211_vif *vif, 707 struct ieee80211_bss_conf *conf, 708 u64 changed) 709 { 710 struct rtw89_dev *rtwdev = hw->priv; 711 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 712 struct rtw89_vif_link *rtwvif_link; 713 714 lockdep_assert_wiphy(hw->wiphy); 715 716 rtw89_leave_ps_mode(rtwdev); 717 718 rtwvif_link = rtwvif->links[conf->link_id]; 719 if (unlikely(!rtwvif_link)) { 720 rtw89_err(rtwdev, 721 "%s: rtwvif link (link_id %u) is not active\n", 722 __func__, conf->link_id); 723 return; 724 } 725 726 if (changed & BSS_CHANGED_BSSID) { 727 ether_addr_copy(rtwvif_link->bssid, conf->bssid); 728 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 729 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL); 730 WRITE_ONCE(rtwvif_link->sync_bcn_tsf, 0); 731 } 732 733 if (changed & BSS_CHANGED_BEACON) 734 rtw89_chip_h2c_update_beacon(rtwdev, rtwvif_link); 735 736 if (changed & BSS_CHANGED_ERP_SLOT) 737 rtw89_conf_tx(rtwdev, rtwvif_link); 738 739 if (changed & BSS_CHANGED_HE_BSS_COLOR) 740 rtw89_phy_set_bss_color(rtwdev, rtwvif_link); 741 742 if (changed & BSS_CHANGED_MU_GROUPS) 743 rtw89_mac_bf_set_gid_table(rtwdev, vif, conf); 744 745 if (changed & BSS_CHANGED_P2P_PS) 746 rtw89_core_update_p2p_ps(rtwdev, rtwvif_link, conf); 747 748 if (changed & BSS_CHANGED_CQM) 749 rtw89_fw_h2c_set_bcn_fltr_cfg(rtwdev, rtwvif_link, true); 750 751 if (changed & BSS_CHANGED_TPE) 752 rtw89_reg_6ghz_recalc(rtwdev, rtwvif_link, true); 753 } 754 755 static int rtw89_ops_start_ap(struct ieee80211_hw *hw, 756 struct ieee80211_vif *vif, 757 struct ieee80211_bss_conf *link_conf) 758 { 759 struct rtw89_dev *rtwdev = hw->priv; 760 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 761 struct rtw89_vif_link *rtwvif_link; 762 const struct rtw89_chan *chan; 763 int ret = 0; 764 765 lockdep_assert_wiphy(hw->wiphy); 766 767 rtwvif_link = rtwvif->links[link_conf->link_id]; 768 if (unlikely(!rtwvif_link)) { 769 rtw89_err(rtwdev, 770 "%s: rtwvif link (link_id %u) is not active\n", 771 __func__, link_conf->link_id); 772 return -ENOLINK; 773 } 774 775 chan = rtw89_chan_get(rtwdev, rtwvif_link->chanctx_idx); 776 if (chan->band_type == RTW89_BAND_6G) 777 return -EOPNOTSUPP; 778 779 if (rtwdev->scanning) 780 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 781 782 ether_addr_copy(rtwvif_link->bssid, link_conf->bssid); 783 rtw89_cam_bssid_changed(rtwdev, rtwvif_link); 784 rtw89_mac_port_update(rtwdev, rtwvif_link); 785 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 786 rtw89_fw_h2c_role_maintain(rtwdev, rtwvif_link, NULL, RTW89_ROLE_TYPE_CHANGE); 787 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 788 rtw89_fw_h2c_cam(rtwdev, rtwvif_link, NULL, NULL); 789 rtw89_chip_rfk_channel(rtwdev, rtwvif_link); 790 791 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) { 792 ret = rtw89_fw_h2c_ap_info_refcount(rtwdev, true); 793 if (ret) 794 return ret; 795 } 796 797 rtw89_queue_chanctx_work(rtwdev); 798 799 return 0; 800 } 801 802 static 803 void rtw89_ops_stop_ap(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 804 struct ieee80211_bss_conf *link_conf) 805 { 806 struct rtw89_dev *rtwdev = hw->priv; 807 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 808 struct rtw89_vif_link *rtwvif_link; 809 810 lockdep_assert_wiphy(hw->wiphy); 811 812 rtwvif_link = rtwvif->links[link_conf->link_id]; 813 if (unlikely(!rtwvif_link)) { 814 rtw89_err(rtwdev, 815 "%s: rtwvif link (link_id %u) is not active\n", 816 __func__, link_conf->link_id); 817 return; 818 } 819 820 if (RTW89_CHK_FW_FEATURE(NOTIFY_AP_INFO, &rtwdev->fw)) 821 rtw89_fw_h2c_ap_info_refcount(rtwdev, false); 822 823 rtw89_mac_stop_ap(rtwdev, rtwvif_link); 824 rtw89_chip_h2c_assoc_cmac_tbl(rtwdev, rtwvif_link, NULL); 825 rtw89_fw_h2c_join_info(rtwdev, rtwvif_link, NULL, true); 826 } 827 828 static int rtw89_ops_set_tim(struct ieee80211_hw *hw, struct ieee80211_sta *sta, 829 bool set) 830 { 831 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 832 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 833 struct rtw89_vif_link *rtwvif_link; 834 unsigned int link_id; 835 836 rtw89_vif_for_each_link(rtwvif, rtwvif_link, link_id) 837 wiphy_work_queue(hw->wiphy, &rtwvif_link->update_beacon_work); 838 839 return 0; 840 } 841 842 static int rtw89_ops_conf_tx(struct ieee80211_hw *hw, 843 struct ieee80211_vif *vif, 844 unsigned int link_id, u16 ac, 845 const struct ieee80211_tx_queue_params *params) 846 { 847 struct rtw89_dev *rtwdev = hw->priv; 848 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 849 struct rtw89_vif_link *rtwvif_link; 850 851 lockdep_assert_wiphy(hw->wiphy); 852 853 rtw89_leave_ps_mode(rtwdev); 854 855 rtwvif_link = rtwvif->links[link_id]; 856 if (unlikely(!rtwvif_link)) { 857 rtw89_err(rtwdev, 858 "%s: rtwvif link (link_id %u) is not active\n", 859 __func__, link_id); 860 return -ENOLINK; 861 } 862 863 rtwvif_link->tx_params[ac] = *params; 864 __rtw89_conf_tx(rtwdev, rtwvif_link, ac); 865 866 return 0; 867 } 868 869 static int __rtw89_ops_sta_state(struct ieee80211_hw *hw, 870 struct ieee80211_vif *vif, 871 struct ieee80211_sta *sta, 872 enum ieee80211_sta_state old_state, 873 enum ieee80211_sta_state new_state) 874 { 875 struct rtw89_dev *rtwdev = hw->priv; 876 877 if (old_state == IEEE80211_STA_NOTEXIST && 878 new_state == IEEE80211_STA_NONE) 879 return __rtw89_ops_sta_add(rtwdev, vif, sta); 880 881 if (old_state == IEEE80211_STA_AUTH && 882 new_state == IEEE80211_STA_ASSOC) { 883 if (vif->type == NL80211_IFTYPE_STATION && !sta->tdls) 884 return 0; /* defer to bss_info_changed to have vif info */ 885 return __rtw89_ops_sta_assoc(rtwdev, vif, sta, false); 886 } 887 888 if (old_state == IEEE80211_STA_ASSOC && 889 new_state == IEEE80211_STA_AUTH) 890 return __rtw89_ops_sta_disassoc(rtwdev, vif, sta); 891 892 if (old_state == IEEE80211_STA_AUTH && 893 new_state == IEEE80211_STA_NONE) 894 return __rtw89_ops_sta_disconnect(rtwdev, vif, sta); 895 896 if (old_state == IEEE80211_STA_NONE && 897 new_state == IEEE80211_STA_NOTEXIST) 898 return __rtw89_ops_sta_remove(rtwdev, vif, sta); 899 900 return 0; 901 } 902 903 static int rtw89_ops_sta_state(struct ieee80211_hw *hw, 904 struct ieee80211_vif *vif, 905 struct ieee80211_sta *sta, 906 enum ieee80211_sta_state old_state, 907 enum ieee80211_sta_state new_state) 908 { 909 struct rtw89_dev *rtwdev = hw->priv; 910 911 lockdep_assert_wiphy(hw->wiphy); 912 913 rtw89_leave_ps_mode(rtwdev); 914 return __rtw89_ops_sta_state(hw, vif, sta, old_state, new_state); 915 } 916 917 static int rtw89_ops_set_key(struct ieee80211_hw *hw, enum set_key_cmd cmd, 918 struct ieee80211_vif *vif, 919 struct ieee80211_sta *sta, 920 struct ieee80211_key_conf *key) 921 { 922 struct rtw89_dev *rtwdev = hw->priv; 923 int ret; 924 925 lockdep_assert_wiphy(hw->wiphy); 926 927 rtw89_leave_ps_mode(rtwdev); 928 929 switch (cmd) { 930 case SET_KEY: 931 rtw89_btc_ntfy_specific_packet(rtwdev, PACKET_EAPOL_END); 932 ret = rtw89_cam_sec_key_add(rtwdev, vif, sta, key); 933 if (ret && ret != -EOPNOTSUPP) { 934 rtw89_err(rtwdev, "failed to add key to sec cam\n"); 935 return ret; 936 } 937 break; 938 case DISABLE_KEY: 939 rtw89_hci_flush_queues(rtwdev, BIT(rtwdev->hw->queues) - 1, 940 false); 941 rtw89_mac_flush_txq(rtwdev, BIT(rtwdev->hw->queues) - 1, false); 942 ret = rtw89_cam_sec_key_del(rtwdev, vif, sta, key, true); 943 if (ret) { 944 rtw89_err(rtwdev, "failed to remove key from sec cam\n"); 945 return ret; 946 } 947 break; 948 } 949 950 return ret; 951 } 952 953 static int rtw89_ops_ampdu_action(struct ieee80211_hw *hw, 954 struct ieee80211_vif *vif, 955 struct ieee80211_ampdu_params *params) 956 { 957 struct rtw89_dev *rtwdev = hw->priv; 958 struct ieee80211_sta *sta = params->sta; 959 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 960 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 961 u16 tid = params->tid; 962 struct ieee80211_txq *txq = sta->txq[tid]; 963 struct rtw89_txq *rtwtxq = (struct rtw89_txq *)txq->drv_priv; 964 965 lockdep_assert_wiphy(rtwdev->hw->wiphy); 966 967 switch (params->action) { 968 case IEEE80211_AMPDU_TX_START: 969 return IEEE80211_AMPDU_TX_START_IMMEDIATE; 970 case IEEE80211_AMPDU_TX_STOP_CONT: 971 case IEEE80211_AMPDU_TX_STOP_FLUSH: 972 case IEEE80211_AMPDU_TX_STOP_FLUSH_CONT: 973 clear_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 974 clear_bit(tid, rtwsta->ampdu_map); 975 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 976 ieee80211_stop_tx_ba_cb_irqsafe(vif, sta->addr, tid); 977 break; 978 case IEEE80211_AMPDU_TX_OPERATIONAL: 979 set_bit(RTW89_TXQ_F_AMPDU, &rtwtxq->flags); 980 rtwsta->ampdu_params[tid].agg_num = params->buf_size; 981 rtwsta->ampdu_params[tid].amsdu = params->amsdu; 982 set_bit(tid, rtwsta->ampdu_map); 983 rtw89_leave_ps_mode(rtwdev); 984 rtw89_chip_h2c_ampdu_cmac_tbl(rtwdev, rtwvif, rtwsta); 985 break; 986 case IEEE80211_AMPDU_RX_START: 987 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, true, params); 988 break; 989 case IEEE80211_AMPDU_RX_STOP: 990 rtw89_chip_h2c_ba_cam(rtwdev, rtwsta, false, params); 991 break; 992 default: 993 WARN_ON(1); 994 return -ENOTSUPP; 995 } 996 997 return 0; 998 } 999 1000 static int rtw89_ops_set_rts_threshold(struct ieee80211_hw *hw, u32 value) 1001 { 1002 struct rtw89_dev *rtwdev = hw->priv; 1003 1004 lockdep_assert_wiphy(hw->wiphy); 1005 1006 rtw89_leave_ps_mode(rtwdev); 1007 if (test_bit(RTW89_FLAG_POWERON, rtwdev->flags)) 1008 rtw89_mac_update_rts_threshold(rtwdev); 1009 1010 return 0; 1011 } 1012 1013 static void rtw89_ops_sta_statistics(struct ieee80211_hw *hw, 1014 struct ieee80211_vif *vif, 1015 struct ieee80211_sta *sta, 1016 struct station_info *sinfo) 1017 { 1018 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1019 struct rtw89_sta_link *rtwsta_link; 1020 1021 rtwsta_link = rtw89_sta_get_link_inst(rtwsta, 0); 1022 if (unlikely(!rtwsta_link)) 1023 return; 1024 1025 sinfo->txrate = rtwsta_link->ra_report.txrate; 1026 sinfo->filled |= BIT_ULL(NL80211_STA_INFO_TX_BITRATE); 1027 } 1028 1029 static 1030 void __rtw89_drop_packets(struct rtw89_dev *rtwdev, struct ieee80211_vif *vif) 1031 { 1032 struct rtw89_vif *rtwvif; 1033 1034 if (vif) { 1035 rtwvif = vif_to_rtwvif(vif); 1036 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1037 } else { 1038 rtw89_for_each_rtwvif(rtwdev, rtwvif) 1039 rtw89_mac_pkt_drop_vif(rtwdev, rtwvif); 1040 } 1041 } 1042 1043 static void rtw89_ops_flush(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1044 u32 queues, bool drop) 1045 { 1046 struct rtw89_dev *rtwdev = hw->priv; 1047 1048 lockdep_assert_wiphy(hw->wiphy); 1049 1050 rtw89_leave_lps(rtwdev); 1051 rtw89_hci_flush_queues(rtwdev, queues, drop); 1052 1053 if (drop && !RTW89_CHK_FW_FEATURE(NO_PACKET_DROP, &rtwdev->fw)) 1054 __rtw89_drop_packets(rtwdev, vif); 1055 else 1056 rtw89_mac_flush_txq(rtwdev, queues, drop); 1057 } 1058 1059 struct rtw89_iter_bitrate_mask_data { 1060 struct rtw89_dev *rtwdev; 1061 struct ieee80211_vif *vif; 1062 const struct cfg80211_bitrate_mask *mask; 1063 }; 1064 1065 static void rtw89_ra_mask_info_update_iter(void *data, struct ieee80211_sta *sta) 1066 { 1067 struct rtw89_iter_bitrate_mask_data *br_data = data; 1068 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1069 struct rtw89_vif *rtwvif = rtwsta->rtwvif; 1070 struct ieee80211_vif *vif = rtwvif_to_vif(rtwvif); 1071 struct rtw89_sta_link *rtwsta_link; 1072 unsigned int link_id; 1073 1074 if (vif != br_data->vif || vif->p2p) 1075 return; 1076 1077 rtw89_sta_for_each_link(rtwsta, rtwsta_link, link_id) { 1078 rtwsta_link->use_cfg_mask = true; 1079 rtwsta_link->mask = *br_data->mask; 1080 } 1081 1082 rtw89_phy_ra_update_sta(br_data->rtwdev, sta, IEEE80211_RC_SUPP_RATES_CHANGED); 1083 } 1084 1085 static void rtw89_ra_mask_info_update(struct rtw89_dev *rtwdev, 1086 struct ieee80211_vif *vif, 1087 const struct cfg80211_bitrate_mask *mask) 1088 { 1089 struct rtw89_iter_bitrate_mask_data br_data = { .rtwdev = rtwdev, 1090 .vif = vif, 1091 .mask = mask}; 1092 1093 ieee80211_iterate_stations_atomic(rtwdev->hw, rtw89_ra_mask_info_update_iter, 1094 &br_data); 1095 } 1096 1097 static int rtw89_ops_set_bitrate_mask(struct ieee80211_hw *hw, 1098 struct ieee80211_vif *vif, 1099 const struct cfg80211_bitrate_mask *mask) 1100 { 1101 struct rtw89_dev *rtwdev = hw->priv; 1102 1103 lockdep_assert_wiphy(hw->wiphy); 1104 1105 rtw89_phy_rate_pattern_vif(rtwdev, vif, mask); 1106 rtw89_ra_mask_info_update(rtwdev, vif, mask); 1107 1108 return 0; 1109 } 1110 1111 static 1112 int rtw89_ops_set_antenna(struct ieee80211_hw *hw, u32 tx_ant, u32 rx_ant) 1113 { 1114 struct rtw89_dev *rtwdev = hw->priv; 1115 struct rtw89_hal *hal = &rtwdev->hal; 1116 1117 lockdep_assert_wiphy(hw->wiphy); 1118 1119 if (hal->ant_diversity) { 1120 if (tx_ant != rx_ant || hweight32(tx_ant) != 1) 1121 return -EINVAL; 1122 } else if (rx_ant != hw->wiphy->available_antennas_rx && rx_ant != hal->antenna_rx) { 1123 return -EINVAL; 1124 } 1125 1126 hal->antenna_tx = tx_ant; 1127 hal->antenna_rx = rx_ant; 1128 hal->tx_path_diversity = false; 1129 hal->ant_diversity_fixed = true; 1130 1131 return 0; 1132 } 1133 1134 static 1135 int rtw89_ops_get_antenna(struct ieee80211_hw *hw, u32 *tx_ant, u32 *rx_ant) 1136 { 1137 struct rtw89_dev *rtwdev = hw->priv; 1138 struct rtw89_hal *hal = &rtwdev->hal; 1139 1140 *tx_ant = hal->antenna_tx; 1141 *rx_ant = hal->antenna_rx; 1142 1143 return 0; 1144 } 1145 1146 static void rtw89_ops_sw_scan_start(struct ieee80211_hw *hw, 1147 struct ieee80211_vif *vif, 1148 const u8 *mac_addr) 1149 { 1150 struct rtw89_dev *rtwdev = hw->priv; 1151 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1152 struct rtw89_vif_link *rtwvif_link; 1153 1154 lockdep_assert_wiphy(hw->wiphy); 1155 1156 rtwvif_link = rtw89_vif_get_link_inst(rtwvif, 0); 1157 if (unlikely(!rtwvif_link)) { 1158 rtw89_err(rtwdev, "sw scan start: find no link on HW-0\n"); 1159 return; 1160 } 1161 1162 rtw89_core_scan_start(rtwdev, rtwvif_link, mac_addr, false); 1163 } 1164 1165 static void rtw89_ops_sw_scan_complete(struct ieee80211_hw *hw, 1166 struct ieee80211_vif *vif) 1167 { 1168 struct rtw89_dev *rtwdev = hw->priv; 1169 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1170 struct rtw89_vif_link *rtwvif_link; 1171 1172 lockdep_assert_wiphy(hw->wiphy); 1173 1174 rtwvif_link = rtw89_vif_get_link_inst(rtwvif, 0); 1175 if (unlikely(!rtwvif_link)) { 1176 rtw89_err(rtwdev, "sw scan complete: find no link on HW-0\n"); 1177 return; 1178 } 1179 1180 rtw89_core_scan_complete(rtwdev, rtwvif_link, false); 1181 } 1182 1183 static void rtw89_ops_reconfig_complete(struct ieee80211_hw *hw, 1184 enum ieee80211_reconfig_type reconfig_type) 1185 { 1186 struct rtw89_dev *rtwdev = hw->priv; 1187 1188 if (reconfig_type == IEEE80211_RECONFIG_TYPE_RESTART) 1189 rtw89_ser_recfg_done(rtwdev); 1190 } 1191 1192 static int rtw89_ops_hw_scan(struct ieee80211_hw *hw, struct ieee80211_vif *vif, 1193 struct ieee80211_scan_request *req) 1194 { 1195 struct rtw89_dev *rtwdev = hw->priv; 1196 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1197 struct rtw89_vif_link *rtwvif_link; 1198 int ret; 1199 1200 lockdep_assert_wiphy(hw->wiphy); 1201 1202 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1203 return 1; 1204 1205 if (rtwdev->scanning || rtwvif->offchan) 1206 return -EBUSY; 1207 1208 rtwvif_link = rtw89_vif_get_link_inst(rtwvif, 0); 1209 if (unlikely(!rtwvif_link)) { 1210 rtw89_err(rtwdev, "hw scan: find no link on HW-0\n"); 1211 return -ENOLINK; 1212 } 1213 1214 rtw89_hw_scan_start(rtwdev, rtwvif_link, req); 1215 ret = rtw89_hw_scan_offload(rtwdev, rtwvif_link, true); 1216 if (ret) { 1217 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1218 rtw89_err(rtwdev, "HW scan failed with status: %d\n", ret); 1219 } 1220 1221 return ret; 1222 } 1223 1224 static void rtw89_ops_cancel_hw_scan(struct ieee80211_hw *hw, 1225 struct ieee80211_vif *vif) 1226 { 1227 struct rtw89_dev *rtwdev = hw->priv; 1228 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1229 struct rtw89_vif_link *rtwvif_link; 1230 1231 lockdep_assert_wiphy(hw->wiphy); 1232 1233 if (!RTW89_CHK_FW_FEATURE(SCAN_OFFLOAD, &rtwdev->fw)) 1234 return; 1235 1236 if (!rtwdev->scanning) 1237 return; 1238 1239 rtwvif_link = rtw89_vif_get_link_inst(rtwvif, 0); 1240 if (unlikely(!rtwvif_link)) { 1241 rtw89_err(rtwdev, "cancel hw scan: find no link on HW-0\n"); 1242 return; 1243 } 1244 1245 rtw89_hw_scan_abort(rtwdev, rtwvif_link); 1246 } 1247 1248 static void rtw89_ops_sta_rc_update(struct ieee80211_hw *hw, 1249 struct ieee80211_vif *vif, 1250 struct ieee80211_link_sta *link_sta, 1251 u32 changed) 1252 { 1253 struct rtw89_sta *rtwsta = sta_to_rtwsta(link_sta->sta); 1254 struct rtw89_dev *rtwdev = hw->priv; 1255 struct rtw89_sta_link *rtwsta_link; 1256 1257 rtwsta_link = rtwsta->links[link_sta->link_id]; 1258 if (unlikely(!rtwsta_link)) 1259 return; 1260 1261 rtw89_phy_ra_update_sta_link(rtwdev, rtwsta_link, changed); 1262 } 1263 1264 static int rtw89_ops_add_chanctx(struct ieee80211_hw *hw, 1265 struct ieee80211_chanctx_conf *ctx) 1266 { 1267 struct rtw89_dev *rtwdev = hw->priv; 1268 1269 lockdep_assert_wiphy(hw->wiphy); 1270 1271 return rtw89_chanctx_ops_add(rtwdev, ctx); 1272 } 1273 1274 static void rtw89_ops_remove_chanctx(struct ieee80211_hw *hw, 1275 struct ieee80211_chanctx_conf *ctx) 1276 { 1277 struct rtw89_dev *rtwdev = hw->priv; 1278 1279 lockdep_assert_wiphy(hw->wiphy); 1280 1281 rtw89_chanctx_ops_remove(rtwdev, ctx); 1282 } 1283 1284 static void rtw89_ops_change_chanctx(struct ieee80211_hw *hw, 1285 struct ieee80211_chanctx_conf *ctx, 1286 u32 changed) 1287 { 1288 struct rtw89_dev *rtwdev = hw->priv; 1289 1290 lockdep_assert_wiphy(hw->wiphy); 1291 1292 rtw89_chanctx_ops_change(rtwdev, ctx, changed); 1293 } 1294 1295 static int rtw89_ops_assign_vif_chanctx(struct ieee80211_hw *hw, 1296 struct ieee80211_vif *vif, 1297 struct ieee80211_bss_conf *link_conf, 1298 struct ieee80211_chanctx_conf *ctx) 1299 { 1300 struct rtw89_dev *rtwdev = hw->priv; 1301 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1302 struct rtw89_vif_link *rtwvif_link; 1303 1304 lockdep_assert_wiphy(hw->wiphy); 1305 1306 rtwvif_link = rtwvif->links[link_conf->link_id]; 1307 if (unlikely(!rtwvif_link)) { 1308 rtw89_err(rtwdev, 1309 "%s: rtwvif link (link_id %u) is not active\n", 1310 __func__, link_conf->link_id); 1311 return -ENOLINK; 1312 } 1313 1314 return rtw89_chanctx_ops_assign_vif(rtwdev, rtwvif_link, ctx); 1315 } 1316 1317 static void rtw89_ops_unassign_vif_chanctx(struct ieee80211_hw *hw, 1318 struct ieee80211_vif *vif, 1319 struct ieee80211_bss_conf *link_conf, 1320 struct ieee80211_chanctx_conf *ctx) 1321 { 1322 struct rtw89_dev *rtwdev = hw->priv; 1323 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1324 struct rtw89_vif_link *rtwvif_link; 1325 1326 lockdep_assert_wiphy(hw->wiphy); 1327 1328 rtwvif_link = rtwvif->links[link_conf->link_id]; 1329 if (unlikely(!rtwvif_link)) { 1330 rtw89_err(rtwdev, 1331 "%s: rtwvif link (link_id %u) is not active\n", 1332 __func__, link_conf->link_id); 1333 return; 1334 } 1335 1336 rtw89_chanctx_ops_unassign_vif(rtwdev, rtwvif_link, ctx); 1337 } 1338 1339 static int rtw89_ops_remain_on_channel(struct ieee80211_hw *hw, 1340 struct ieee80211_vif *vif, 1341 struct ieee80211_channel *chan, 1342 int duration, 1343 enum ieee80211_roc_type type) 1344 { 1345 struct rtw89_dev *rtwdev = hw->priv; 1346 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1347 struct rtw89_roc *roc = &rtwvif->roc; 1348 1349 lockdep_assert_wiphy(hw->wiphy); 1350 1351 if (!rtwvif) 1352 return -EINVAL; 1353 1354 if (roc->state != RTW89_ROC_IDLE) { 1355 return -EBUSY; 1356 } 1357 1358 if (rtwdev->scanning) 1359 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1360 1361 if (type == IEEE80211_ROC_TYPE_MGMT_TX) 1362 roc->state = RTW89_ROC_MGMT; 1363 else 1364 roc->state = RTW89_ROC_NORMAL; 1365 1366 roc->duration = duration; 1367 roc->chan = *chan; 1368 roc->type = type; 1369 1370 rtw89_roc_start(rtwdev, rtwvif); 1371 1372 return 0; 1373 } 1374 1375 static int rtw89_ops_cancel_remain_on_channel(struct ieee80211_hw *hw, 1376 struct ieee80211_vif *vif) 1377 { 1378 struct rtw89_dev *rtwdev = hw->priv; 1379 struct rtw89_vif *rtwvif = vif_to_rtwvif_safe(vif); 1380 1381 lockdep_assert_wiphy(hw->wiphy); 1382 1383 if (!rtwvif) 1384 return -EINVAL; 1385 1386 wiphy_delayed_work_cancel(hw->wiphy, &rtwvif->roc.roc_work); 1387 1388 rtw89_roc_end(rtwdev, rtwvif); 1389 1390 return 0; 1391 } 1392 1393 static void rtw89_set_tid_config_iter(void *data, struct ieee80211_sta *sta) 1394 { 1395 struct cfg80211_tid_config *tid_config = data; 1396 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1397 struct rtw89_dev *rtwdev = rtwsta->rtwdev; 1398 1399 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1400 } 1401 1402 static int rtw89_ops_set_tid_config(struct ieee80211_hw *hw, 1403 struct ieee80211_vif *vif, 1404 struct ieee80211_sta *sta, 1405 struct cfg80211_tid_config *tid_config) 1406 { 1407 struct rtw89_dev *rtwdev = hw->priv; 1408 1409 lockdep_assert_wiphy(hw->wiphy); 1410 1411 if (sta) 1412 rtw89_core_set_tid_config(rtwdev, sta, tid_config); 1413 else 1414 ieee80211_iterate_stations_atomic(rtwdev->hw, 1415 rtw89_set_tid_config_iter, 1416 tid_config); 1417 1418 return 0; 1419 } 1420 1421 static bool rtw89_can_work_on_links(struct rtw89_dev *rtwdev, 1422 struct ieee80211_vif *vif, u16 links) 1423 { 1424 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1425 u8 w = hweight16(links); 1426 1427 if (vif->type != NL80211_IFTYPE_STATION && 1428 w > RTW89_MLD_NON_STA_LINK_NUM) 1429 return false; 1430 1431 return w <= rtwvif->links_inst_valid_num; 1432 } 1433 1434 static bool rtw89_ops_can_activate_links(struct ieee80211_hw *hw, 1435 struct ieee80211_vif *vif, 1436 u16 active_links) 1437 { 1438 struct rtw89_dev *rtwdev = hw->priv; 1439 1440 lockdep_assert_wiphy(hw->wiphy); 1441 1442 return rtw89_can_work_on_links(rtwdev, vif, active_links); 1443 } 1444 1445 static void __rtw89_ops_clr_vif_links(struct rtw89_dev *rtwdev, 1446 struct rtw89_vif *rtwvif, 1447 unsigned long clr_links) 1448 { 1449 struct rtw89_vif_link *rtwvif_link; 1450 unsigned int link_id; 1451 1452 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1453 rtwvif_link = rtwvif->links[link_id]; 1454 if (unlikely(!rtwvif_link)) 1455 continue; 1456 1457 __rtw89_ops_remove_iface_link(rtwdev, rtwvif_link); 1458 1459 rtw89_vif_unset_link(rtwvif, link_id); 1460 } 1461 } 1462 1463 static int __rtw89_ops_set_vif_links(struct rtw89_dev *rtwdev, 1464 struct rtw89_vif *rtwvif, 1465 unsigned long set_links) 1466 { 1467 struct rtw89_vif_link *rtwvif_link; 1468 unsigned int link_id; 1469 int ret; 1470 1471 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1472 rtwvif_link = rtw89_vif_set_link(rtwvif, link_id); 1473 if (!rtwvif_link) 1474 return -EINVAL; 1475 1476 ret = __rtw89_ops_add_iface_link(rtwdev, rtwvif_link); 1477 if (ret) { 1478 rtw89_err(rtwdev, "%s: failed to add iface (link id %u)\n", 1479 __func__, link_id); 1480 return ret; 1481 } 1482 } 1483 1484 return 0; 1485 } 1486 1487 static 1488 int rtw89_ops_change_vif_links(struct ieee80211_hw *hw, 1489 struct ieee80211_vif *vif, 1490 u16 old_links, u16 new_links, 1491 struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS]) 1492 { 1493 struct rtw89_dev *rtwdev = hw->priv; 1494 struct rtw89_vif *rtwvif = vif_to_rtwvif(vif); 1495 unsigned long clr_links = old_links & ~new_links; 1496 unsigned long set_links = new_links & ~old_links; 1497 bool removing_links = !old_links || clr_links; 1498 struct rtw89_link_conf_container *snap; 1499 int ret = 0; 1500 int i; 1501 1502 lockdep_assert_wiphy(hw->wiphy); 1503 1504 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1505 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1506 __func__, old_links, new_links); 1507 1508 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1509 return -EOPNOTSUPP; 1510 1511 if (removing_links) { 1512 snap = kzalloc(sizeof(*snap), GFP_KERNEL); 1513 if (!snap) 1514 return -ENOMEM; 1515 1516 for (i = 0; i < ARRAY_SIZE(snap->link_conf); i++) 1517 snap->link_conf[i] = old[i]; 1518 1519 rcu_assign_pointer(rtwvif->snap_link_confs, snap); 1520 } 1521 1522 /* might depend on @snap; don't change order */ 1523 rtw89_leave_ips_by_hwflags(rtwdev); 1524 1525 if (rtwdev->scanning) 1526 rtw89_hw_scan_abort(rtwdev, rtwdev->scan_info.scanning_vif); 1527 1528 if (!old_links) 1529 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1530 BIT(RTW89_VIF_IDLE_LINK_ID)); 1531 else if (clr_links) 1532 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, clr_links); 1533 1534 if (removing_links) { 1535 /* @snap is required if and only if during removing links. 1536 * However, it's done here. So, cleanup @snap immediately. 1537 */ 1538 rcu_assign_pointer(rtwvif->snap_link_confs, NULL); 1539 1540 /* The pointers in @old will free after this function return, 1541 * so synchronously wait for all readers of snap to be done. 1542 */ 1543 synchronize_rcu(); 1544 kfree(snap); 1545 } 1546 1547 if (set_links) { 1548 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, set_links); 1549 if (ret) 1550 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, set_links); 1551 } else if (!new_links) { 1552 ret = __rtw89_ops_set_vif_links(rtwdev, rtwvif, 1553 BIT(RTW89_VIF_IDLE_LINK_ID)); 1554 if (ret) 1555 __rtw89_ops_clr_vif_links(rtwdev, rtwvif, 1556 BIT(RTW89_VIF_IDLE_LINK_ID)); 1557 } 1558 1559 rtw89_enter_ips_by_hwflags(rtwdev); 1560 return ret; 1561 } 1562 1563 static void __rtw89_ops_clr_sta_links(struct rtw89_dev *rtwdev, 1564 struct rtw89_sta *rtwsta, 1565 unsigned long clr_links) 1566 { 1567 struct rtw89_vif_link *rtwvif_link; 1568 struct rtw89_sta_link *rtwsta_link; 1569 unsigned int link_id; 1570 1571 for_each_set_bit(link_id, &clr_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1572 rtwsta_link = rtwsta->links[link_id]; 1573 if (unlikely(!rtwsta_link)) 1574 continue; 1575 1576 rtwvif_link = rtwsta_link->rtwvif_link; 1577 1578 rtw89_core_sta_link_disassoc(rtwdev, rtwvif_link, rtwsta_link); 1579 rtw89_core_sta_link_disconnect(rtwdev, rtwvif_link, rtwsta_link); 1580 rtw89_core_sta_link_remove(rtwdev, rtwvif_link, rtwsta_link); 1581 1582 rtw89_sta_unset_link(rtwsta, link_id); 1583 } 1584 } 1585 1586 static int __rtw89_ops_set_sta_links(struct rtw89_dev *rtwdev, 1587 struct rtw89_sta *rtwsta, 1588 unsigned long set_links) 1589 { 1590 struct rtw89_vif_link *rtwvif_link; 1591 struct rtw89_sta_link *rtwsta_link; 1592 unsigned int link_id; 1593 u8 sec_cam_idx; 1594 int ret; 1595 1596 for_each_set_bit(link_id, &set_links, IEEE80211_MLD_MAX_NUM_LINKS) { 1597 rtwsta_link = rtw89_sta_set_link(rtwsta, link_id); 1598 if (!rtwsta_link) 1599 return -EINVAL; 1600 1601 rtwvif_link = rtwsta_link->rtwvif_link; 1602 1603 ret = rtw89_core_sta_link_add(rtwdev, rtwvif_link, rtwsta_link); 1604 if (ret) { 1605 rtw89_err(rtwdev, "%s: failed to add sta (link id %u)\n", 1606 __func__, link_id); 1607 return ret; 1608 } 1609 1610 rtw89_vif_type_mapping(rtwvif_link, true); 1611 1612 ret = rtw89_core_sta_link_assoc(rtwdev, rtwvif_link, rtwsta_link); 1613 if (ret) { 1614 rtw89_err(rtwdev, "%s: failed to assoc sta (link id %u)\n", 1615 __func__, link_id); 1616 return ret; 1617 } 1618 1619 __rtw89_ops_bss_link_assoc(rtwdev, rtwvif_link); 1620 1621 for_each_set_bit(sec_cam_idx, rtwsta->pairwise_sec_cam_map, 1622 RTW89_MAX_SEC_CAM_NUM) { 1623 ret = rtw89_cam_attach_link_sec_cam(rtwdev, 1624 rtwvif_link, 1625 rtwsta_link, 1626 sec_cam_idx); 1627 if (ret) { 1628 rtw89_err(rtwdev, 1629 "%s: failed to apply pairwise key (link id %u)\n", 1630 __func__, link_id); 1631 return ret; 1632 } 1633 } 1634 } 1635 1636 return 0; 1637 } 1638 1639 static 1640 int rtw89_ops_change_sta_links(struct ieee80211_hw *hw, 1641 struct ieee80211_vif *vif, 1642 struct ieee80211_sta *sta, 1643 u16 old_links, u16 new_links) 1644 { 1645 struct rtw89_dev *rtwdev = hw->priv; 1646 struct rtw89_sta *rtwsta = sta_to_rtwsta(sta); 1647 unsigned long clr_links = old_links & ~new_links; 1648 unsigned long set_links = new_links & ~old_links; 1649 int ret = 0; 1650 1651 lockdep_assert_wiphy(hw->wiphy); 1652 1653 rtw89_debug(rtwdev, RTW89_DBG_STATE, 1654 "%s: old_links (0x%08x) -> new_links (0x%08x)\n", 1655 __func__, old_links, new_links); 1656 1657 if (!rtw89_can_work_on_links(rtwdev, vif, new_links)) 1658 return -EOPNOTSUPP; 1659 1660 rtw89_leave_ps_mode(rtwdev); 1661 1662 if (clr_links) 1663 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, clr_links); 1664 1665 if (set_links) { 1666 ret = __rtw89_ops_set_sta_links(rtwdev, rtwsta, set_links); 1667 if (ret) 1668 __rtw89_ops_clr_sta_links(rtwdev, rtwsta, set_links); 1669 } 1670 1671 return ret; 1672 } 1673 1674 #ifdef CONFIG_PM 1675 static int rtw89_ops_suspend(struct ieee80211_hw *hw, 1676 struct cfg80211_wowlan *wowlan) 1677 { 1678 struct rtw89_dev *rtwdev = hw->priv; 1679 int ret; 1680 1681 lockdep_assert_wiphy(hw->wiphy); 1682 1683 set_bit(RTW89_FLAG_FORBIDDEN_TRACK_WROK, rtwdev->flags); 1684 wiphy_delayed_work_cancel(hw->wiphy, &rtwdev->track_work); 1685 1686 ret = rtw89_wow_suspend(rtwdev, wowlan); 1687 if (ret) { 1688 rtw89_warn(rtwdev, "failed to suspend for wow %d\n", ret); 1689 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WROK, rtwdev->flags); 1690 return 1; 1691 } 1692 1693 return 0; 1694 } 1695 1696 static int rtw89_ops_resume(struct ieee80211_hw *hw) 1697 { 1698 struct rtw89_dev *rtwdev = hw->priv; 1699 int ret; 1700 1701 lockdep_assert_wiphy(hw->wiphy); 1702 1703 ret = rtw89_wow_resume(rtwdev); 1704 if (ret) 1705 rtw89_warn(rtwdev, "failed to resume for wow %d\n", ret); 1706 1707 clear_bit(RTW89_FLAG_FORBIDDEN_TRACK_WROK, rtwdev->flags); 1708 wiphy_delayed_work_queue(hw->wiphy, &rtwdev->track_work, 1709 RTW89_TRACK_WORK_PERIOD); 1710 1711 return ret ? 1 : 0; 1712 } 1713 1714 static void rtw89_ops_set_wakeup(struct ieee80211_hw *hw, bool enabled) 1715 { 1716 struct rtw89_dev *rtwdev = hw->priv; 1717 1718 device_set_wakeup_enable(rtwdev->dev, enabled); 1719 } 1720 1721 static void rtw89_set_rekey_data(struct ieee80211_hw *hw, 1722 struct ieee80211_vif *vif, 1723 struct cfg80211_gtk_rekey_data *data) 1724 { 1725 struct rtw89_dev *rtwdev = hw->priv; 1726 struct rtw89_wow_param *rtw_wow = &rtwdev->wow; 1727 struct rtw89_wow_gtk_info *gtk_info = &rtw_wow->gtk_info; 1728 1729 lockdep_assert_wiphy(hw->wiphy); 1730 1731 if (data->kek_len > sizeof(gtk_info->kek) || 1732 data->kck_len > sizeof(gtk_info->kck)) { 1733 rtw89_warn(rtwdev, "kek or kck length over fw limit\n"); 1734 return; 1735 } 1736 1737 memcpy(gtk_info->kek, data->kek, data->kek_len); 1738 memcpy(gtk_info->kck, data->kck, data->kck_len); 1739 } 1740 #endif 1741 1742 static void rtw89_ops_rfkill_poll(struct ieee80211_hw *hw) 1743 { 1744 struct rtw89_dev *rtwdev = hw->priv; 1745 1746 lockdep_assert_wiphy(hw->wiphy); 1747 1748 /* wl_disable GPIO get floating when entering LPS */ 1749 if (test_bit(RTW89_FLAG_RUNNING, rtwdev->flags)) 1750 return; 1751 1752 rtw89_core_rfkill_poll(rtwdev, false); 1753 } 1754 1755 const struct ieee80211_ops rtw89_ops = { 1756 .tx = rtw89_ops_tx, 1757 .wake_tx_queue = rtw89_ops_wake_tx_queue, 1758 .start = rtw89_ops_start, 1759 .stop = rtw89_ops_stop, 1760 .config = rtw89_ops_config, 1761 .add_interface = rtw89_ops_add_interface, 1762 .change_interface = rtw89_ops_change_interface, 1763 .remove_interface = rtw89_ops_remove_interface, 1764 .configure_filter = rtw89_ops_configure_filter, 1765 .vif_cfg_changed = rtw89_ops_vif_cfg_changed, 1766 .link_info_changed = rtw89_ops_link_info_changed, 1767 .start_ap = rtw89_ops_start_ap, 1768 .stop_ap = rtw89_ops_stop_ap, 1769 .set_tim = rtw89_ops_set_tim, 1770 .conf_tx = rtw89_ops_conf_tx, 1771 .sta_state = rtw89_ops_sta_state, 1772 .set_key = rtw89_ops_set_key, 1773 .ampdu_action = rtw89_ops_ampdu_action, 1774 .set_rts_threshold = rtw89_ops_set_rts_threshold, 1775 .sta_statistics = rtw89_ops_sta_statistics, 1776 .flush = rtw89_ops_flush, 1777 .set_bitrate_mask = rtw89_ops_set_bitrate_mask, 1778 .set_antenna = rtw89_ops_set_antenna, 1779 .get_antenna = rtw89_ops_get_antenna, 1780 .sw_scan_start = rtw89_ops_sw_scan_start, 1781 .sw_scan_complete = rtw89_ops_sw_scan_complete, 1782 .reconfig_complete = rtw89_ops_reconfig_complete, 1783 .hw_scan = rtw89_ops_hw_scan, 1784 .cancel_hw_scan = rtw89_ops_cancel_hw_scan, 1785 .add_chanctx = rtw89_ops_add_chanctx, 1786 .remove_chanctx = rtw89_ops_remove_chanctx, 1787 .change_chanctx = rtw89_ops_change_chanctx, 1788 .assign_vif_chanctx = rtw89_ops_assign_vif_chanctx, 1789 .unassign_vif_chanctx = rtw89_ops_unassign_vif_chanctx, 1790 .remain_on_channel = rtw89_ops_remain_on_channel, 1791 .cancel_remain_on_channel = rtw89_ops_cancel_remain_on_channel, 1792 .set_sar_specs = rtw89_ops_set_sar_specs, 1793 .link_sta_rc_update = rtw89_ops_sta_rc_update, 1794 .set_tid_config = rtw89_ops_set_tid_config, 1795 .can_activate_links = rtw89_ops_can_activate_links, 1796 .change_vif_links = rtw89_ops_change_vif_links, 1797 .change_sta_links = rtw89_ops_change_sta_links, 1798 #ifdef CONFIG_PM 1799 .suspend = rtw89_ops_suspend, 1800 .resume = rtw89_ops_resume, 1801 .set_wakeup = rtw89_ops_set_wakeup, 1802 .set_rekey_data = rtw89_set_rekey_data, 1803 #endif 1804 .rfkill_poll = rtw89_ops_rfkill_poll, 1805 }; 1806 EXPORT_SYMBOL(rtw89_ops); 1807