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