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