xref: /linux/drivers/net/wireless/intel/iwlwifi/mld/roc.c (revision 1a9239bb4253f9076b5b4b2a1a4e8d7defd77a95)

// SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause
/*
 * Copyright (C) 2024 - 2025 Intel Corporation
 */
#include <net/cfg80211.h>
#include <net/mac80211.h>

#include "mld.h"
#include "roc.h"
#include "hcmd.h"
#include "iface.h"
#include "sta.h"
#include "mlo.h"

#include "fw/api/context.h"
#include "fw/api/time-event.h"

#define AUX_ROC_MAX_DELAY MSEC_TO_TU(200)

static void
iwl_mld_vif_iter_emlsr_block_roc(void *data, u8 *mac, struct ieee80211_vif *vif)
{
	struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif);
	int *result = data;
	int ret;

	ret = iwl_mld_block_emlsr_sync(mld_vif->mld, vif,
				       IWL_MLD_EMLSR_BLOCKED_ROC,
				       iwl_mld_get_primary_link(vif));
	if (ret)
		*result = ret;
}

int iwl_mld_start_roc(struct ieee80211_hw *hw, struct ieee80211_vif *vif,
		      struct ieee80211_channel *channel, int duration,
		      enum ieee80211_roc_type type)
{
	struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw);
	struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif);
	struct iwl_mld_int_sta *aux_sta;
	struct iwl_roc_req cmd = {
		.action = cpu_to_le32(FW_CTXT_ACTION_ADD),
	};
	u8 ver = iwl_fw_lookup_cmd_ver(mld->fw,
				       WIDE_ID(MAC_CONF_GROUP, ROC_CMD), 0);
	u16 cmd_len = ver < 6 ? sizeof(struct iwl_roc_req_v5) : sizeof(cmd);
	enum iwl_roc_activity activity;
	int ret = 0;

	lockdep_assert_wiphy(mld->wiphy);

	ieee80211_iterate_active_interfaces_mtx(mld->hw,
						IEEE80211_IFACE_ITER_NORMAL,
						iwl_mld_vif_iter_emlsr_block_roc,
						&ret);
	if (ret)
		return ret;

	/* TODO: task=Hotspot 2.0 */
	if (vif->type != NL80211_IFTYPE_P2P_DEVICE) {
		IWL_ERR(mld, "NOT SUPPORTED: ROC on vif->type %d\n",
			vif->type);

		return -EOPNOTSUPP;
	}

	switch (type) {
	case IEEE80211_ROC_TYPE_NORMAL:
		activity = ROC_ACTIVITY_P2P_DISC;
		break;
	case IEEE80211_ROC_TYPE_MGMT_TX:
		activity = ROC_ACTIVITY_P2P_NEG;
		break;
	default:
		WARN_ONCE(1, "Got an invalid P2P ROC type\n");
		return -EINVAL;
	}

	if (WARN_ON(mld_vif->roc_activity != ROC_NUM_ACTIVITIES))
		return -EBUSY;

	/* No MLO on P2P device */
	aux_sta = &mld_vif->deflink.aux_sta;

	ret = iwl_mld_add_aux_sta(mld, aux_sta);
	if (ret)
		return ret;

	cmd.activity = cpu_to_le32(activity);
	cmd.sta_id = cpu_to_le32(aux_sta->sta_id);
	cmd.channel_info.channel = cpu_to_le32(channel->hw_value);
	cmd.channel_info.band = iwl_mld_nl80211_band_to_fw(channel->band);
	cmd.channel_info.width = IWL_PHY_CHANNEL_MODE20;
	/* TODO: task=Hotspot 2.0, revisit those parameters when we add an ROC
	 * on the BSS vif
	 */
	cmd.max_delay = cpu_to_le32(AUX_ROC_MAX_DELAY);
	cmd.duration = cpu_to_le32(MSEC_TO_TU(duration));

	memcpy(cmd.node_addr, vif->addr, ETH_ALEN);

	ret = iwl_mld_send_cmd_pdu(mld, WIDE_ID(MAC_CONF_GROUP, ROC_CMD),
				   &cmd, cmd_len);
	if (ret) {
		IWL_ERR(mld, "Couldn't send the ROC_CMD\n");
		return ret;
	}
	mld_vif->roc_activity = activity;

	return 0;
}

static void
iwl_mld_vif_iter_emlsr_unblock_roc(void *data, u8 *mac,
				   struct ieee80211_vif *vif)
{
	struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif);

	iwl_mld_unblock_emlsr(mld_vif->mld, vif, IWL_MLD_EMLSR_BLOCKED_ROC);
}

static void iwl_mld_destroy_roc(struct iwl_mld *mld,
				struct ieee80211_vif *vif,
				struct iwl_mld_vif *mld_vif)
{
	mld_vif->roc_activity = ROC_NUM_ACTIVITIES;

	ieee80211_iterate_active_interfaces_mtx(mld->hw,
						IEEE80211_IFACE_ITER_NORMAL,
						iwl_mld_vif_iter_emlsr_unblock_roc,
						NULL);

	/* wait until every tx has seen that roc_activity has been reset */
	synchronize_net();
	/* from here, no new tx will be added
	 * we can flush the Tx on the queues
	 */

	iwl_mld_flush_link_sta_txqs(mld, mld_vif->deflink.aux_sta.sta_id);

	iwl_mld_remove_aux_sta(mld, vif, &vif->bss_conf);
}

int iwl_mld_cancel_roc(struct ieee80211_hw *hw,
		       struct ieee80211_vif *vif)
{
	struct iwl_mld *mld = IWL_MAC80211_GET_MLD(hw);
	struct iwl_mld_vif *mld_vif = iwl_mld_vif_from_mac80211(vif);
	struct iwl_roc_req cmd = {
		.action = cpu_to_le32(FW_CTXT_ACTION_REMOVE),
	};
	u8 ver = iwl_fw_lookup_cmd_ver(mld->fw,
				       WIDE_ID(MAC_CONF_GROUP, ROC_CMD), 0);
	u16 cmd_len = ver < 6 ? sizeof(struct iwl_roc_req_v5) : sizeof(cmd);
	int ret;

	lockdep_assert_wiphy(mld->wiphy);

	/* TODO: task=Hotspot 2.0 */
	if (WARN_ON(vif->type != NL80211_IFTYPE_P2P_DEVICE))
		return -EOPNOTSUPP;

	/* No roc activity running it's probably already done */
	if (mld_vif->roc_activity == ROC_NUM_ACTIVITIES)
		return 0;

	cmd.activity = cpu_to_le32(mld_vif->roc_activity);

	ret = iwl_mld_send_cmd_pdu(mld, WIDE_ID(MAC_CONF_GROUP, ROC_CMD),
				   &cmd, cmd_len);
	if (ret)
		IWL_ERR(mld, "Couldn't send the command to cancel the ROC\n");

	/* We may have raced with the firmware expiring the ROC instance at
	 * this very moment. In that case, we can have a notification in the
	 * async processing queue. However, none can arrive _after_ this as
	 * ROC_CMD was sent synchronously, i.e. we waited for a response and
	 * the firmware cannot refer to this ROC after the response. Thus,
	 * if we just cancel the notification (if there's one) we'll be at a
	 * clean state for any possible next ROC.
	 */
	iwl_mld_cancel_notifications_of_object(mld, IWL_MLD_OBJECT_TYPE_ROC,
					       mld_vif->roc_activity);

	iwl_mld_destroy_roc(mld, vif, mld_vif);

	return 0;
}

void iwl_mld_handle_roc_notif(struct iwl_mld *mld,
			      struct iwl_rx_packet *pkt)
{
	const struct iwl_roc_notif *notif = (void *)pkt->data;
	u32 activity = le32_to_cpu(notif->activity);
	/* TODO: task=Hotspot 2.0 - roc can run on BSS */
	struct ieee80211_vif *vif = mld->p2p_device_vif;
	struct iwl_mld_vif *mld_vif;

	if (WARN_ON(!vif))
		return;

	mld_vif = iwl_mld_vif_from_mac80211(vif);
	/* It is possible that the ROC was canceled
	 * but the notification was already fired.
	 */
	if (mld_vif->roc_activity != activity)
		return;

	if (le32_to_cpu(notif->success) &&
	    le32_to_cpu(notif->started)) {
		/* We had a successful start */
		ieee80211_ready_on_channel(mld->hw);
	} else {
		/* ROC was not successful, tell the firmware to remove it */
		if (le32_to_cpu(notif->started))
			iwl_mld_cancel_roc(mld->hw, vif);
		else
			iwl_mld_destroy_roc(mld, vif, mld_vif);
		/* we need to let know mac80211 about end OR
		 * an unsuccessful start
		 */
		ieee80211_remain_on_channel_expired(mld->hw);
	}
}