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