mac80211.c

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