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