xref: /linux/drivers/net/wireless/virtual/mac80211_hwsim_nan.c (revision 0eaed89c18aeedf0898baf2dbf5ff027c6795152)

// SPDX-License-Identifier: GPL-2.0-only
/*
 * mac80211_hwsim_nan - NAN software simulation for mac80211_hwsim
 * Copyright (C) 2025-2026 Intel Corporation
 */

#include <net/cfg80211.h>
#include "mac80211_hwsim_i.h"

/* Defined as the lower 23 bits being zero */
#define DW0_TSF_MASK		GENMASK(22, 0)

/* DWs are repeated every 512 TUs */
#define DWST_TU			512
#define DWST_TSF_MASK		(ieee80211_tu_to_usec(DWST_TU) - 1)

#define SLOT_TU			16
#define SLOT_TSF_MASK		(ieee80211_tu_to_usec(DWST_TU) - 1)

/* The 2.4 GHz DW is at the start, the 5 GHz is in slot 8 (after 128 TUs) */
#define DW_5G_OFFSET_TU		128

#define SLOT_24GHZ_DW		0
#define SLOT_5GHZ_DW		(DW_5G_OFFSET_TU / SLOT_TU)

/* The special DW0 happens every 16 DWSTs (8192 TUs) */
static_assert(16 * DWST_TU * 1024 == 8192 * 1024);
static_assert(DW0_TSF_MASK + 1 == 8192 * 1024);

/* warmup phase should be 120 seconds, which is approximately 225 DWSTs */
#define NAN_WARMUP_DWST		225

#define NAN_RSSI_CLOSE (-60)
#define NAN_RSSI_MIDDLE (-75)

/* Quiet time at the end of each slot where TX is suppressed */
#define NAN_CHAN_SWITCH_TIME_US		256

struct hwsim_nan_sta_iter_ctx {
	struct ieee80211_hw *hw;
	bool can_tx;
};

struct hwsim_nan_mcast_data_iter_ctx {
	struct ieee80211_hw *hw;
	struct ieee80211_vif *vif;
	size_t n_vif_sta;
	size_t n_sta_can_tx;
};

static void mac80211_hwsim_nan_resume_txqs(struct mac80211_hwsim_data *data);

static u64 hwsim_nan_get_timer_tsf(struct mac80211_hwsim_data *data)
{
	ktime_t expires = hrtimer_get_expires(&data->nan.slot_timer);

	return mac80211_hwsim_boottime_to_tsf(data, expires);
}

static u8 hwsim_nan_slot_from_tsf(u64 tsf)
{
	return (tsf & DWST_TSF_MASK) / ieee80211_tu_to_usec(SLOT_TU);
}

static u64 hwsim_nan_encode_master_rank(u8 master_pref, u8 random_factor,
					const u8 *addr)
{
	return ((u64)master_pref << 56) +
		((u64)random_factor << 48) +
		((u64)addr[5] << 40) +
		((u64)addr[4] << 32) +
		((u64)addr[3] << 24) +
		((u64)addr[2] << 16) +
		((u64)addr[1] << 8) +
		((u64)addr[0] << 0);
}

static u64 hwsim_nan_get_master_rank(struct mac80211_hwsim_data *data)
{
	u8 master_pref = 0;
	u8 random_factor = 0;

	if (data->nan.phase == MAC80211_HWSIM_NAN_PHASE_UP) {
		master_pref = data->nan.master_pref;
		random_factor = data->nan.random_factor;
	}

	return hwsim_nan_encode_master_rank(master_pref, random_factor,
					    data->nan.device_vif->addr);
}

static bool mac80211_hwsim_nan_is_dw_slot(struct mac80211_hwsim_data *data,
					  u8 slot)
{
	return slot == SLOT_24GHZ_DW ||
		(slot == SLOT_5GHZ_DW &&
		 (data->nan.bands & BIT(NL80211_BAND_5GHZ)));
}

static bool
hwsim_nan_rx_chandef_compatible(struct mac80211_hwsim_data *data, u8 slot,
				struct ieee80211_channel *rx_chan, u8 rx_bw)
{
	static const int bw_to_mhz[] = {
		[RATE_INFO_BW_20] = 20, [RATE_INFO_BW_40] = 40,
		[RATE_INFO_BW_80] = 80, [RATE_INFO_BW_160] = 160,
	};
	struct cfg80211_chan_def sched_chandef;
	int rx_mhz, sched_mhz;

	scoped_guard(spinlock_bh, &data->nan.state_lock)
		sched_chandef = data->nan.local_sched[slot];

	if (!sched_chandef.chan ||
	    sched_chandef.chan->center_freq != rx_chan->center_freq)
		return false;

	if (rx_bw >= ARRAY_SIZE(bw_to_mhz) || !bw_to_mhz[rx_bw])
		return false;

	rx_mhz = bw_to_mhz[rx_bw];
	sched_mhz = cfg80211_chandef_get_width(&sched_chandef);

	/* Accept RX at narrower or equal bandwidth */
	return rx_mhz <= sched_mhz;
}

static bool hwsim_nan_peer_present_in_dw(struct hwsim_sta_priv *sp, u64 tsf)
{
	u8 slot = hwsim_nan_slot_from_tsf(tsf);
	u8 cdw = 0;
	u8 dw_index, wake_interval;
	u16 committed_dw;

	scoped_guard(spinlock_bh, &sp->nan_sched.lock)
		committed_dw = sp->nan_sched.committed_dw;

	/* If peer doesn't advertise committed DW, assume presence in
	 * all 2.4 GHz DW slots
	 */
	if (!committed_dw)
		return slot == SLOT_24GHZ_DW;

	/* Get DW index (0-15) within the 16-DWST DW0 cycle */
	dw_index = (tsf / ieee80211_tu_to_usec(DWST_TU)) & 0xf;

	/* Extract CDW for the appropriate band (spec Table 80) */
	if (slot == SLOT_24GHZ_DW)
		cdw = committed_dw & 0x7;
	else if (slot == SLOT_5GHZ_DW)
		cdw = (committed_dw >> 3) & 0x7;

	if (cdw == 0)
		return false;

	/* Peer wakes every 2^(cdw-1) DWs: 1, 2, 4, 8, or 16 */
	wake_interval = 1 << (cdw - 1);

	return (dw_index % wake_interval) == 0;
}

static bool
hwsim_nan_peer_present_in_faw(struct hwsim_sta_priv *sp,
			      struct mac80211_hwsim_data *data, u8 slot)
{
	struct cfg80211_chan_def local_chandef;

	scoped_guard(spinlock_bh, &data->nan.state_lock)
		local_chandef = data->nan.local_sched[slot];

	if (!local_chandef.chan)
		return false;

	scoped_guard(spinlock_bh, &sp->nan_sched.lock) {
		for (int i = 0; i < CFG80211_NAN_MAX_PEER_MAPS; i++) {
			struct cfg80211_chan_def *peer_chandef;

			if (sp->nan_sched.maps[i].map_id ==
			    CFG80211_NAN_INVALID_MAP_ID)
				continue;

			peer_chandef = &sp->nan_sched.maps[i].chans[slot];
			if (!peer_chandef->chan)
				continue;

			if (cfg80211_chandef_compatible(&local_chandef,
							peer_chandef))
				return true;
		}
	}

	return false;
}

static void
mac80211_hwsim_nan_schedule_slot(struct mac80211_hwsim_data *data, u8 slot,
				 bool discontinuity)
{
	u64 tsf;

	if (!discontinuity)
		tsf = hwsim_nan_get_timer_tsf(data);
	else
		tsf = mac80211_hwsim_get_tsf(data->hw, data->nan.device_vif);

	/* Only called by mac80211_hwsim_nan_dw_timer from softirq context */
	lockdep_assert_in_softirq();

	tsf &= ~DWST_TSF_MASK;
	tsf += ieee80211_tu_to_usec(slot * SLOT_TU);

	hrtimer_set_expires(&data->nan.slot_timer,
			    mac80211_hwsim_tsf_to_boottime(data, tsf));
}

void mac80211_hwsim_nan_rx(struct ieee80211_hw *hw,
			   struct sk_buff *skb)
{
	struct mac80211_hwsim_data *data = hw->priv;
	const struct ieee80211_mgmt *mgmt = (void *)skb->data;
	struct element *nan_elem = (void *)mgmt->u.beacon.variable;
	struct ieee80211_nan_anchor_master_info *ami = NULL;
	const struct ieee80211_nan_attr *nan_attr;
	struct ieee80211_rx_status rx_status;
	bool joined_cluster = false;
	bool adopt_tsf = false;
	bool is_sync_beacon;
	bool is_same_cluster;
	u64 master_rank = 0;
	ssize_t data_len;
	u8 slot;

	/* Need a NAN vendor element at the start */
	if (skb->len < (offsetofend(struct ieee80211_mgmt, u.beacon) + 6) ||
	    !ieee80211_is_beacon(mgmt->frame_control))
		return;

	data_len = skb->len - offsetofend(struct ieee80211_mgmt, u.beacon);

	/* Copy the RX status to add a MAC timestamp if needed */
	memcpy(&rx_status, IEEE80211_SKB_RXCB(skb),
	       sizeof(struct ieee80211_rx_status));

	/* And deal with the lack of mac time stamp */
	if ((rx_status.flag & RX_FLAG_MACTIME) != RX_FLAG_MACTIME_START) {
		u64 tsf = mac80211_hwsim_get_tsf(hw, data->nan.device_vif);;

		/* In that case there should be no timestamp */
		WARN_ON_ONCE(rx_status.flag & RX_FLAG_MACTIME);

		/* No mac timestamp, set current TSF for the frame end */
		rx_status.flag |= RX_FLAG_MACTIME_END;
		rx_status.mactime = tsf;

		/* And translate to the start for the rest of the code */
		rx_status.mactime =
			ieee80211_calculate_rx_timestamp(hw, &rx_status,
							 skb->len, 0);
		rx_status.flag &= ~RX_FLAG_MACTIME;
		rx_status.flag |= RX_FLAG_MACTIME_START;

		/* Match mac80211_hwsim_nan_receive, see comment there */
		slot = hwsim_nan_slot_from_tsf(tsf + 128);
	} else {
		slot = hwsim_nan_slot_from_tsf(rx_status.mactime);
	}

	/*
	 * (overly) simplify things, only track 2.4 GHz here. Also, ignore
	 * frames outside of the 2.4 GHz DW slot, unless in the initial SCAN
	 * phase.
	 */
	if ((slot != SLOT_24GHZ_DW &&
	     data->nan.phase != MAC80211_HWSIM_NAN_PHASE_SCAN) ||
	    rx_status.freq != 2437)
		return;

	/* Just ignore low RSSI beacons that we cannot sync to */
	if (rx_status.signal < NAN_RSSI_MIDDLE)
		return;

	/* Needs to be a valid NAN cluster ID in A3 */
	if (get_unaligned_be32(mgmt->bssid) != ((WLAN_OUI_WFA << 8) | 0x01))
		return;

	/* We are only interested in NAN beacons */
	if (nan_elem->id != WLAN_EID_VENDOR_SPECIFIC ||
	    nan_elem->datalen < 4 ||
	    get_unaligned_be32(nan_elem->data) !=
	    (WLAN_OUI_WFA << 8 | WLAN_OUI_TYPE_WFA_NAN))
		return;

	u8 *nan_defragmented __free(kfree) = kzalloc(data_len, GFP_ATOMIC);
	if (!nan_defragmented)
		return;

	data_len = cfg80211_defragment_element(nan_elem,
					       mgmt->u.beacon.variable,
					       data_len,
					       nan_defragmented, data_len,
					       WLAN_EID_FRAGMENT);

	if (data_len < 0)
		return;

	/* Assume it is a synchronization beacon if beacon_int is 512 TUs */
	is_sync_beacon = le16_to_cpu(mgmt->u.beacon.beacon_int) == DWST_TU;
	is_same_cluster = ether_addr_equal(mgmt->bssid, data->nan.cluster_id);

	for_each_nan_attr(nan_attr, nan_defragmented + 4, data_len - 4) {
		if (nan_attr->attr == NAN_ATTR_MASTER_INDICATION &&
		    le16_to_cpu(nan_attr->length) >=
		    sizeof(struct ieee80211_nan_master_indication)) {
			struct ieee80211_nan_master_indication *mi =
				(void *)nan_attr->data;

			master_rank =
				hwsim_nan_encode_master_rank(mi->master_pref,
							     mi->random_factor,
							     mgmt->sa);
		}

		if (nan_attr->attr == NAN_ATTR_CLUSTER_INFO &&
		    le16_to_cpu(nan_attr->length) >=
		    sizeof(struct ieee80211_nan_anchor_master_info)) {
			ami = (void *)nan_attr->data;

			/*
			 * The AMBTT should be set to the beacon timestamp when
			 * the sender is the anchor master. We can simply
			 * modify the structure because we created a copy when
			 * defragmenting the NAN element.
			 */
			if (ami->hop_count == 0)
				ami->ambtt = cpu_to_le32(
					le64_to_cpu(mgmt->u.beacon.timestamp));
		}
	}

	/* Do the rest of the processing under lock */
	spin_lock_bh(&data->nan.state_lock);

	/*
	 * sync beacon should be discarded if the master rank is the same
	 * and the AMBTT is older than 16 * 512 TUs compared to our own TSF.
	 *
	 * Subtract the AMBTT from the lowered TSF. If the AMBTT is older
	 * (smaller) then the calculation will not underflow.
	 */
	if (is_sync_beacon && ami &&
	    ami->master_rank == data->nan.current_ami.master_rank &&
	    (((u32)rx_status.mactime -
	      ieee80211_tu_to_usec(16 * 512)) -
	     le32_to_cpu(ami->ambtt)) < 0x8000000) {
		wiphy_dbg(hw->wiphy,
			  "NAN: ignoring sync beacon with old AMBTT\n");
		is_sync_beacon = false;
	}

	if (is_same_cluster && is_sync_beacon &&
	    master_rank > hwsim_nan_get_master_rank(data)) {
		if (rx_status.signal > NAN_RSSI_CLOSE)
			data->nan.master_transition_score += 3;
		else
			data->nan.master_transition_score += 1;
	}

	if (is_same_cluster && is_sync_beacon && ami &&
	    ((ami->master_rank == data->nan.current_ami.master_rank &&
	      ami->hop_count < data->nan.current_ami.hop_count) ||
	     (master_rank > hwsim_nan_get_master_rank(data) &&
	      ami->hop_count == data->nan.current_ami.hop_count))) {
		if (rx_status.signal > NAN_RSSI_CLOSE)
			data->nan.sync_transition_score += 3;
		else
			data->nan.sync_transition_score += 1;
	}

	/*
	 * Decide on TSF adjustments before updating any other state
	 */
	if (is_same_cluster && is_sync_beacon && ami &&
	    data->nan.current_ami.hop_count != 0) {
		if (le64_to_cpu(ami->master_rank) >
		    le64_to_cpu(data->nan.current_ami.master_rank) &&
		    ami->master_rank != data->nan.last_ami.master_rank)
			adopt_tsf = true;

		if (le64_to_cpu(ami->master_rank) >
		    le64_to_cpu(data->nan.current_ami.master_rank) &&
		    ami->master_rank == data->nan.last_ami.master_rank &&
		    le32_to_cpu(ami->ambtt) >
		    le32_to_cpu(data->nan.last_ami.ambtt))
			adopt_tsf = true;

		if (le64_to_cpu(ami->master_rank) <
		    le64_to_cpu(data->nan.current_ami.master_rank) &&
		    le64_to_cpu(ami->master_rank) >
		    hwsim_nan_get_master_rank(data) &&
		    ether_addr_equal(ami->master_addr,
				     data->nan.current_ami.master_addr))
			adopt_tsf = true;

		if (ami->master_rank == data->nan.current_ami.master_rank &&
		    le32_to_cpu(ami->ambtt) >
		    le32_to_cpu(data->nan.current_ami.ambtt))
			adopt_tsf = true;

		/* Anchor Master case is handled below */
	}

	/*
	 * NAN Cluster merging
	 */
	if (!is_same_cluster && ami) {
		u64 curr_amr;
		u64 own_cg;
		u64 frame_amr;
		u64 cg;

		/* Shifted down by 19 bits compared to spec */
		frame_amr = le64_to_cpu(ami->master_rank);
		cg = (u64)ami->master_pref << (64 - 19);
		cg += le64_to_cpu(mgmt->u.beacon.timestamp) >> 19;

		curr_amr = le64_to_cpu(data->nan.current_ami.master_rank);
		own_cg = (u64)data->nan.current_ami.master_pref << (64 - 19);
		own_cg += rx_status.mactime >> 19;

		/*
		 * Check if the cluster shall be joined
		 *
		 * When in the "scan" phase, just join immediately.
		 */
		if (cg > own_cg ||
		    (cg == own_cg && frame_amr > curr_amr) ||
		    data->nan.phase == MAC80211_HWSIM_NAN_PHASE_SCAN) {
			/* Avoid a state transition */
			data->nan.master_transition_score = 0;
			data->nan.sync_transition_score = 0;

			/*
			 * NOTE: The spec says we should TX sync beacons on the
			 * old schedule after joining. We do not implement this.
			 */

			wiphy_dbg(hw->wiphy, "NAN: joining cluster %pM\n",
				  mgmt->bssid);

			joined_cluster = true;
			adopt_tsf = true;

			memcpy(&data->nan.last_ami, &data->nan.current_ami,
			       sizeof(data->nan.last_ami));
			memcpy(&data->nan.current_ami, ami,
			       sizeof(data->nan.last_ami));
			data->nan.current_ami.hop_count += 1;

			memcpy(data->nan.cluster_id, mgmt->bssid, ETH_ALEN);

			/*
			 * Assume we are UP if we joined a cluster.
			 *
			 * If the other anchor master is still in the warmup
			 * phase, then we may temporarily become the anchor
			 * master until it sets its own master preference to
			 * be non-zero.
			 */
			data->nan.phase = MAC80211_HWSIM_NAN_PHASE_UP;
			data->nan.random_factor_valid_dwst = 0;
		}
	}

	/*
	 * Anchor master selection
	 */
	/* We are not anchor master */
	if (is_same_cluster && is_sync_beacon && ami &&
	    data->nan.current_ami.hop_count != 0) {
		if (le64_to_cpu(data->nan.current_ami.master_rank) <
		    le64_to_cpu(ami->master_rank)) {
			if (ami->master_rank == data->nan.last_ami.master_rank &&
			    le32_to_cpu(ami->ambtt) <=
			    le32_to_cpu(data->nan.last_ami.ambtt)) {
				/* disregard frame */
			} else {
				memcpy(&data->nan.last_ami,
				       &data->nan.current_ami,
				       sizeof(data->nan.last_ami));
				memcpy(&data->nan.current_ami, ami,
				       sizeof(data->nan.last_ami));
				data->nan.current_ami.hop_count += 1;
			}
		}

		if (le64_to_cpu(data->nan.current_ami.master_rank) >
		    le64_to_cpu(ami->master_rank)) {
			if (!ether_addr_equal(data->nan.current_ami.master_addr,
					      ami->master_addr)) {
				/* disregard frame */
			} else {
				u64 amr = hwsim_nan_get_master_rank(data);

				if (amr > le64_to_cpu(ami->master_rank)) {
					/* assume ourselves as anchor master */
					wiphy_dbg(hw->wiphy,
						  "NAN: assume anchor master role\n");
					data->nan.current_ami.master_rank =
						cpu_to_le64(amr);
					data->nan.current_ami.hop_count = 0;
					memset(&data->nan.last_ami, 0,
					       sizeof(data->nan.last_ami));
					data->nan.last_ami.ambtt =
						data->nan.current_ami.ambtt;
					data->nan.current_ami.ambtt = 0;
				} else {
					memcpy(&data->nan.last_ami,
					       &data->nan.current_ami,
					       sizeof(data->nan.last_ami));
					memcpy(&data->nan.current_ami, ami,
					       sizeof(data->nan.last_ami));
					data->nan.current_ami.hop_count += 1;
				}
			}
		}

		if (data->nan.current_ami.master_rank == ami->master_rank) {
			if (le32_to_cpu(data->nan.current_ami.ambtt) <
			    le32_to_cpu(ami->ambtt)) {
				data->nan.current_ami.ambtt = ami->ambtt;
			}

			if (data->nan.current_ami.hop_count >
			    ami->hop_count + 1) {
				data->nan.current_ami.hop_count =
					ami->hop_count + 1;
			}
		}
	}

	/* We are anchor master */
	if (is_same_cluster && is_sync_beacon && ami &&
	    data->nan.current_ami.hop_count == 0) {
		WARN_ON_ONCE(!ether_addr_equal(data->nan.current_ami.master_addr,
					       data->nan.device_vif->addr));

		if (le64_to_cpu(ami->master_rank) <
		    le64_to_cpu(data->nan.current_ami.master_rank) ||
		    ether_addr_equal(ami->master_addr,
				     data->nan.current_ami.master_addr)) {
			/* disregard */
		} else {
			wiphy_dbg(hw->wiphy, "NAN: lost anchor master role\n");
			adopt_tsf = true;
			memcpy(&data->nan.last_ami, &data->nan.current_ami,
			       sizeof(data->nan.last_ami));
			memcpy(&data->nan.current_ami, ami,
			       sizeof(data->nan.last_ami));
			data->nan.current_ami.hop_count += 1;
		}
	}

	if (adopt_tsf && !data->nan.tsf_adjusted) {
		int threshold = 5;
		s64 adjustment;

		/* Timestamp is likely inaccurate (and late) in this case */
		if (!(IEEE80211_SKB_RXCB(skb)->flag & RX_FLAG_MACTIME))
			threshold = 128;

		adjustment =
			le64_to_cpu(mgmt->u.beacon.timestamp) -
			ieee80211_calculate_rx_timestamp(hw, &rx_status,
							 skb->len, 24);

		scoped_guard(spinlock_bh, &data->tsf_offset_lock) {
			if (adjustment < -threshold || adjustment > threshold) {
				if (adjustment < -(s64)ieee80211_tu_to_usec(4) ||
				    adjustment > (s64)ieee80211_tu_to_usec(4))
					data->nan.tsf_discontinuity = true;

				wiphy_debug(hw->wiphy,
					    "NAN: Adjusting TSF by +/- %d us or more: %lld us (discontinuity: %d, from: %pM, old offset: %lld)\n",
					    threshold, adjustment,
					    data->nan.tsf_discontinuity, mgmt->sa,
					    data->tsf_offset);
			} else {
				/* smooth things out a little bit */
				adjustment /= 2;
			}

			/*
			 * Do the TSF adjustment
			 * The flag prevents further adjustments until the next
			 * 2.4 GHz DW starts to avoid race conditions for
			 * in-flight packets.
			 */
			data->nan.tsf_adjusted = true;
			data->tsf_offset += adjustment;
		}
	}

	spin_unlock_bh(&data->nan.state_lock);

	if (joined_cluster)
		ieee80211_nan_cluster_joined(data->nan.device_vif,
					     data->nan.cluster_id, false,
					     GFP_ATOMIC);
}

static void
mac80211_hwsim_nan_exec_state_transitions(struct mac80211_hwsim_data *data)
{
	bool notify_join = false;

	/*
	 * Handle NAN role and state transitions at the end of the DW period
	 * in accordance to Wi-Fi Aware version 4.0 section 3.3.7 point 2, i.e.
	 * end of 5 GHz DW if enabled else at the end of the 2.4 GHz DW.
	 */

	spin_lock(&data->nan.state_lock);

	/* Handle role transitions, Wi-Fi Aware version 4.0 section 3.3.6  */
	if (data->nan.master_transition_score < 3)
		data->nan.role = MAC80211_HWSIM_NAN_ROLE_MASTER;
	else if (data->nan.role == MAC80211_HWSIM_NAN_ROLE_MASTER &&
		 data->nan.master_transition_score >= 3)
		data->nan.role = MAC80211_HWSIM_NAN_ROLE_SYNC;
	else if (data->nan.role == MAC80211_HWSIM_NAN_ROLE_SYNC &&
		 data->nan.sync_transition_score >= 3)
		data->nan.role = MAC80211_HWSIM_NAN_ROLE_NON_SYNC;
	else if (data->nan.role == MAC80211_HWSIM_NAN_ROLE_NON_SYNC &&
		 data->nan.sync_transition_score < 3)
		data->nan.role = MAC80211_HWSIM_NAN_ROLE_SYNC;

	/*
	 * The discovery beacon timer will stop automatically. Make sure it is
	 * running if we are master. Do not bother with a proper alignment it
	 * will sync itself to the TSF after the first TX.
	 */
	if (data->nan.role == MAC80211_HWSIM_NAN_ROLE_MASTER &&
	    !hrtimer_active(&data->nan.discovery_beacon_timer))
		hrtimer_start(&data->nan.discovery_beacon_timer,
			      ns_to_ktime(10 * NSEC_PER_USEC),
			      HRTIMER_MODE_REL_SOFT);

	data->nan.master_transition_score = 0;
	data->nan.sync_transition_score = 0;

	if (data->nan.random_factor_valid_dwst == 0) {
		u64 amr;

		if (data->nan.phase == MAC80211_HWSIM_NAN_PHASE_SCAN) {
			data->nan.phase = MAC80211_HWSIM_NAN_PHASE_WARMUP;
			data->nan.random_factor_valid_dwst = NAN_WARMUP_DWST;

			notify_join = true;
		} else {
			data->nan.phase = MAC80211_HWSIM_NAN_PHASE_UP;
			data->nan.random_factor_valid_dwst =
				get_random_u32_inclusive(120, 240);
			data->nan.random_factor = get_random_u8();
		}

		amr = hwsim_nan_get_master_rank(data);

		if (data->nan.current_ami.hop_count == 0) {
			/* Update if we are already anchor master */
			data->nan.current_ami.master_rank = cpu_to_le64(amr);
		} else if (le64_to_cpu(data->nan.current_ami.master_rank) < amr) {
			/* assume role if we have a higher rank */
			wiphy_dbg(data->hw->wiphy,
				  "NAN: assume anchor master role\n");
			data->nan.current_ami.master_rank = cpu_to_le64(amr);
			data->nan.current_ami.hop_count = 0;
			memset(&data->nan.last_ami, 0,
			       sizeof(data->nan.last_ami));
			data->nan.last_ami.ambtt = data->nan.current_ami.ambtt;
			data->nan.current_ami.ambtt = 0;
		}
	} else {
		data->nan.random_factor_valid_dwst--;
	}

	spin_unlock(&data->nan.state_lock);

	if (notify_join)
		ieee80211_nan_cluster_joined(data->nan.device_vif,
					     data->nan.cluster_id, true,
					     GFP_ATOMIC);
}

static void
mac80211_hwsim_nan_tx_beacon(struct mac80211_hwsim_data *data,
			     bool is_discovery,
			     struct ieee80211_channel *channel)
{
	struct ieee80211_vendor_ie nan_ie = {
		.element_id = WLAN_EID_VENDOR_SPECIFIC,
		.len = 27 - 2,
		.oui = { u32_get_bits(WLAN_OUI_WFA, 0xff0000),
			 u32_get_bits(WLAN_OUI_WFA, 0xff00),
			 u32_get_bits(WLAN_OUI_WFA, 0xff) },
		.oui_type = WLAN_OUI_TYPE_WFA_NAN,
	};
	size_t alloc_size =
		IEEE80211_TX_STATUS_HEADROOM +
		offsetofend(struct ieee80211_mgmt, u.beacon) +
		27 /* size of NAN vendor element */;
	struct ieee80211_nan_master_indication master_indication;
	struct ieee80211_nan_attr nan_attr;
	struct ieee80211_mgmt *mgmt;
	struct sk_buff *skb;

	/*
	 * TODO: Should the configured vendor elements or NAN attributes be
	 * included in some of these beacons?
	 */

	skb = alloc_skb(alloc_size, GFP_ATOMIC);
	if (!skb)
		return;

	spin_lock(&data->nan.state_lock);

	skb_reserve(skb, IEEE80211_TX_STATUS_HEADROOM);
	mgmt = skb_put(skb, offsetofend(struct ieee80211_mgmt, u.beacon));

	memset(mgmt, 0, offsetofend(struct ieee80211_mgmt, u.beacon));
	memcpy(mgmt->sa, data->nan.device_vif->addr, ETH_ALEN);
	memset(mgmt->da, 0xff, ETH_ALEN);
	memcpy(mgmt->bssid, data->nan.cluster_id, ETH_ALEN);

	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
					  IEEE80211_STYPE_BEACON);
	mgmt->u.beacon.beacon_int = cpu_to_le16(is_discovery ? 100 : DWST_TU);
	mgmt->u.beacon.capab_info =
		cpu_to_le16(WLAN_CAPABILITY_SHORT_SLOT_TIME |
			    WLAN_CAPABILITY_SHORT_PREAMBLE);

	/* FIXME: set these to saner values? */
	mgmt->duration = 0;
	mgmt->seq_ctrl = 0;

	/* Put the NAN element */
	skb_put_data(skb, &nan_ie, sizeof(nan_ie));

	nan_attr.attr = NAN_ATTR_MASTER_INDICATION;
	nan_attr.length = cpu_to_le16(sizeof(master_indication));
	if (data->nan.phase == MAC80211_HWSIM_NAN_PHASE_UP) {
		master_indication.master_pref = data->nan.master_pref;
		master_indication.random_factor = data->nan.random_factor;
	} else {
		master_indication.master_pref = 0;
		master_indication.random_factor = 0;
	}

	skb_put_data(skb, &nan_attr, sizeof(nan_attr));
	skb_put_data(skb, &master_indication, sizeof(master_indication));

	nan_attr.attr = NAN_ATTR_CLUSTER_INFO;
	nan_attr.length = cpu_to_le16(sizeof(data->nan.current_ami));
	skb_put_data(skb, &nan_attr, sizeof(nan_attr));
	skb_put_data(skb, &data->nan.current_ami,
		     sizeof(data->nan.current_ami));

	spin_unlock(&data->nan.state_lock);

	mac80211_hwsim_tx_frame(data->hw, skb, channel);
}

enum hrtimer_restart
mac80211_hwsim_nan_slot_timer(struct hrtimer *timer)
{
	struct mac80211_hwsim_data *data =
		container_of(timer, struct mac80211_hwsim_data,
			     nan.slot_timer);
	struct ieee80211_hw *hw = data->hw;
	struct ieee80211_channel *notify_dw_chan = NULL;
	struct ieee80211_channel *beacon_sync_chan = NULL;
	u64 tsf = hwsim_nan_get_timer_tsf(data);
	u8 slot = hwsim_nan_slot_from_tsf(tsf);
	bool dwst_of_dw0 = false;
	bool dw_end = false;
	bool tx_sync_beacon;

	if (!data->nan.device_vif)
		return HRTIMER_NORESTART;

	if ((tsf & DW0_TSF_MASK & ~DWST_TSF_MASK) == 0)
		dwst_of_dw0 = true;


	scoped_guard(spinlock, &data->nan.state_lock) {
		if (data->nan.tsf_discontinuity) {
			data->nan.tsf_discontinuity = false;

			mac80211_hwsim_nan_schedule_slot(data, 32, true);

			return HRTIMER_RESTART;
		}

		if (slot == SLOT_24GHZ_DW)
			data->nan.tsf_adjusted = false;

		tx_sync_beacon =
			data->nan.phase != MAC80211_HWSIM_NAN_PHASE_SCAN &&
			data->nan.role != MAC80211_HWSIM_NAN_ROLE_NON_SYNC;
	}

	switch (slot) {
	case SLOT_24GHZ_DW:
		wiphy_dbg(data->hw->wiphy, "Start of 2.4 GHz DW, is DW0=%d\n",
			  dwst_of_dw0);
		beacon_sync_chan = ieee80211_get_channel(hw->wiphy, 2437);
		break;

	case SLOT_24GHZ_DW + 1:
		if (!(data->nan.bands & BIT(NL80211_BAND_5GHZ))) {
			notify_dw_chan = ieee80211_get_channel(hw->wiphy, 2437);
			dw_end = true;
		} else {
			notify_dw_chan = ieee80211_get_channel(hw->wiphy, 5745);
		}
		break;

	case SLOT_5GHZ_DW:
		if (data->nan.bands & BIT(NL80211_BAND_5GHZ)) {
			wiphy_dbg(data->hw->wiphy, "Start of 5 GHz DW\n");
			beacon_sync_chan =
				ieee80211_get_channel(hw->wiphy, 5745);
		}
		break;

	case SLOT_5GHZ_DW + 1:
		if (data->nan.bands & BIT(NL80211_BAND_5GHZ)) {
			notify_dw_chan =
				ieee80211_get_channel(hw->wiphy, 2437);
			dw_end = true;
		}
		break;
	}

	/* TODO: This does not implement DW contention mitigation */
	if (beacon_sync_chan && tx_sync_beacon)
		mac80211_hwsim_nan_tx_beacon(data, false, beacon_sync_chan);

	if (dw_end)
		mac80211_hwsim_nan_exec_state_transitions(data);

	if (data->nan.notify_dw && notify_dw_chan) {
		struct wireless_dev *wdev =
			ieee80211_vif_to_wdev(data->nan.device_vif);

		cfg80211_next_nan_dw_notif(wdev, notify_dw_chan, GFP_ATOMIC);
	}

	mac80211_hwsim_nan_resume_txqs(data);

	mac80211_hwsim_nan_schedule_slot(data, slot + 1, false);

	return HRTIMER_RESTART;
}

enum hrtimer_restart
mac80211_hwsim_nan_discovery_beacon_timer(struct hrtimer *timer)
{
	struct mac80211_hwsim_data *data =
		container_of(timer, struct mac80211_hwsim_data,
			     nan.discovery_beacon_timer);
	u32 remainder;
	u64 tsf_now;
	u64 tbtt;

	if (!data->nan.device_vif)
		return HRTIMER_NORESTART;

	scoped_guard(spinlock, &data->nan.state_lock) {
		if (data->nan.phase == MAC80211_HWSIM_NAN_PHASE_SCAN ||
		    data->nan.role != MAC80211_HWSIM_NAN_ROLE_MASTER)
			return HRTIMER_NORESTART;
	}

	mac80211_hwsim_nan_tx_beacon(
		data, true, ieee80211_get_channel(data->hw->wiphy, 2437));

	if (data->nan.bands & BIT(NL80211_BAND_5GHZ))
		mac80211_hwsim_nan_tx_beacon(
			data, true,
			ieee80211_get_channel(data->hw->wiphy, 5745));

	/* Read the TSF from the current time in case of adjustments */
	tsf_now = mac80211_hwsim_get_tsf(data->hw, data->nan.device_vif);

	/* Wrap value to be after the next TBTT */
	tbtt = tsf_now + ieee80211_tu_to_usec(100);

	/* Round TBTT down to the correct time */
	div_u64_rem(tbtt, ieee80211_tu_to_usec(100), &remainder);
	tbtt = tbtt - remainder;

	hrtimer_set_expires(&data->nan.discovery_beacon_timer,
			    mac80211_hwsim_tsf_to_boottime(data, tbtt));

	return HRTIMER_RESTART;
}

int mac80211_hwsim_nan_start(struct ieee80211_hw *hw,
			     struct ieee80211_vif *vif,
			     struct cfg80211_nan_conf *conf)
{
	struct mac80211_hwsim_data *data = hw->priv;

	if (vif->type != NL80211_IFTYPE_NAN)
		return -EINVAL;

	if (data->nan.device_vif)
		return -EALREADY;

	/* set this before starting the timer, as preemption might occur */
	data->nan.device_vif = vif;
	data->nan.bands = conf->bands;

	scoped_guard(spinlock_bh, &data->nan.state_lock) {
		/* Start in the "scan" phase and stay there for a little bit */
		data->nan.phase = MAC80211_HWSIM_NAN_PHASE_SCAN;
		data->nan.random_factor_valid_dwst = 1;
		data->nan.random_factor = 0;
		data->nan.master_pref = conf->master_pref;
		data->nan.role = MAC80211_HWSIM_NAN_ROLE_MASTER;
		memset(&data->nan.current_ami, 0,
		       sizeof(data->nan.current_ami));
		memset(&data->nan.last_ami, 0, sizeof(data->nan.last_ami));
		data->nan.current_ami.master_rank =
			cpu_to_le64(hwsim_nan_get_master_rank(data));
	}

	/* Just run this "soon" and start in a random schedule position */
	hrtimer_start(&data->nan.slot_timer,
		      ns_to_ktime(10 * NSEC_PER_USEC),
		      HRTIMER_MODE_REL_SOFT);

	ether_addr_copy(data->nan.cluster_id, conf->cluster_id);

	data->nan.notify_dw = conf->enable_dw_notification;

	return 0;
}

int mac80211_hwsim_nan_stop(struct ieee80211_hw *hw,
			    struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = hw->priv;

	if (vif->type != NL80211_IFTYPE_NAN || !data->nan.device_vif ||
	    data->nan.device_vif != vif)
		return -EINVAL;

	hrtimer_cancel(&data->nan.slot_timer);
	hrtimer_cancel(&data->nan.resume_txqs_timer);
	hrtimer_cancel(&data->nan.discovery_beacon_timer);
	data->nan.device_vif = NULL;

	return 0;
}

int mac80211_hwsim_nan_change_config(struct ieee80211_hw *hw,
				     struct ieee80211_vif *vif,
				     struct cfg80211_nan_conf *conf,
				     u32 changes)
{
	struct mac80211_hwsim_data *data = hw->priv;

	if (vif->type != NL80211_IFTYPE_NAN)
		return -EINVAL;

	if (!data->nan.device_vif)
		return -EINVAL;

	wiphy_debug(hw->wiphy, "nan_config_changed: changes=0x%x\n", changes);

	/* Handle only the changes we care about for simulation purposes */
	if (changes & CFG80211_NAN_CONF_CHANGED_BANDS)
		data->nan.bands = conf->bands;

	if (changes & CFG80211_NAN_CONF_CHANGED_CONFIG)
		data->nan.notify_dw = conf->enable_dw_notification;

	if (changes & CFG80211_NAN_CONF_CHANGED_PREF) {
		scoped_guard(spinlock_bh, &data->nan.state_lock)
			data->nan.master_pref = conf->master_pref;
	}

	return 0;
}

static void hwsim_nan_can_sta_transmit(void *_ctx, struct ieee80211_sta *sta)
{
	struct hwsim_nan_sta_iter_ctx *ctx = _ctx;

	if (ctx->can_tx)
		return;

	for (int i = 0; i < ARRAY_SIZE(sta->txq); i++) {
		struct ieee80211_txq *txq = sta->txq[i];

		if (!txq)
			continue;

		if (txq->vif->type != NL80211_IFTYPE_NAN &&
		    txq->vif->type != NL80211_IFTYPE_NAN_DATA)
			return;

		if (mac80211_hwsim_nan_txq_transmitting(ctx->hw, txq)) {
			ctx->can_tx = true;
			return;
		}
	}
}

static void mac80211_hwsim_nan_resume_txqs(struct mac80211_hwsim_data *data)
{
	u64 tsf = mac80211_hwsim_get_tsf(data->hw, data->nan.device_vif);
	u8 slot = hwsim_nan_slot_from_tsf(tsf);
	bool is_dw_slot = mac80211_hwsim_nan_is_dw_slot(data, slot);
	struct hwsim_nan_sta_iter_ctx ctx = {
		.hw = data->hw,
		.can_tx = false,
	};
	u32 timeout_ns;

	/* Outside DW, require local FAW schedule to proceed */
	if (!is_dw_slot) {
		scoped_guard(spinlock_bh, &data->nan.state_lock) {
			if (!data->nan.local_sched[slot].chan)
				return;
		}
	}

	guard(rcu)();

	/* Check if management queue can transmit */
	if (mac80211_hwsim_nan_txq_transmitting(data->hw,
						data->nan.device_vif->txq_mgmt))
		goto resume_txqs_timer;

	/* Check if any STA queue can transmit */
	ieee80211_iterate_stations_atomic(data->hw,
					  hwsim_nan_can_sta_transmit,
					  &ctx);

	if (!ctx.can_tx)
		return;

resume_txqs_timer:
	/*
	 * Wait a bit and also randomize things so that not everyone is TXing
	 * at the same time. Each slot is 16 TU long, this waits between 100 us
	 * and 5 ms before starting to TX (unless a new frame arrives).
	 */
	timeout_ns = get_random_u32_inclusive(100 * NSEC_PER_USEC,
					      5 * NSEC_PER_MSEC);

	hrtimer_start(&data->nan.resume_txqs_timer,
		      ns_to_ktime(timeout_ns),
		      HRTIMER_MODE_REL_SOFT);
}

static void hwsim_nan_wake_sta_iter(void *_data, struct ieee80211_sta *sta)
{
	struct ieee80211_hw *hw = _data;

	for (int i = 0; i < ARRAY_SIZE(sta->txq); i++) {
		struct ieee80211_txq *txq = sta->txq[i];

		if (!txq)
			continue;

		/* exit early if non-NAN */
		if (txq->vif->type != NL80211_IFTYPE_NAN &&
		    txq->vif->type != NL80211_IFTYPE_NAN_DATA)
			return;

		if (mac80211_hwsim_nan_txq_transmitting(hw, txq))
			ieee80211_hwsim_wake_tx_queue(hw, txq);
	}
}

enum hrtimer_restart
mac80211_hwsim_nan_resume_txqs_timer(struct hrtimer *timer)
{
	struct mac80211_hwsim_data *data =
		container_of(timer, struct mac80211_hwsim_data,
			     nan.resume_txqs_timer);

	guard(rcu)();

	/* Wake TX queue for management frames on the NAN device interface */
	if (mac80211_hwsim_nan_txq_transmitting(data->hw,
						data->nan.device_vif->txq_mgmt))
		ieee80211_hwsim_wake_tx_queue(data->hw,
					      data->nan.device_vif->txq_mgmt);

	/* Wake TX queues for all stations */
	ieee80211_iterate_stations_atomic(data->hw,
					  hwsim_nan_wake_sta_iter,
					  data->hw);

	return HRTIMER_NORESTART;
}

static void
hwsim_nan_can_mcast_sta_transmit(void *_ctx, struct ieee80211_sta *sta)
{
	struct hwsim_nan_mcast_data_iter_ctx *ctx = _ctx;
	struct ieee80211_txq *txq = sta->txq[0];

	if (!txq || txq->vif != ctx->vif)
		return;

	ctx->n_vif_sta++;
	if (mac80211_hwsim_nan_txq_transmitting(ctx->hw, txq))
		ctx->n_sta_can_tx++;
}

static bool
mac80211_hwsim_nan_mcast_data_transmitting(struct ieee80211_hw *hw,
					   struct ieee80211_txq *txq)
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct hwsim_nan_mcast_data_iter_ctx ctx = {
		.hw = hw,
		.vif = txq->vif,
		.n_sta_can_tx = 0,
		.n_vif_sta = 0,
	};

	/* Check if all the stations associated with the current
	 * interface are available.
	 */
	ieee80211_iterate_stations_atomic(data->hw,
					  hwsim_nan_can_mcast_sta_transmit,
					  &ctx);

	return ctx.n_vif_sta && ctx.n_sta_can_tx == ctx.n_vif_sta;
}

bool mac80211_hwsim_nan_txq_transmitting(struct ieee80211_hw *hw,
					 struct ieee80211_txq *txq)
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_sta *nmi_sta;
	struct hwsim_sta_priv *sp;
	bool is_dw_slot;
	u64 tsf;
	u8 slot;

	if (WARN_ON_ONCE(!data->nan.device_vif))
		return true;

	tsf = mac80211_hwsim_get_tsf(hw, data->nan.device_vif);
	slot = hwsim_nan_slot_from_tsf(tsf);

	/* Enforce a maximum channel switch time and guard against TX delays */
	if (slot != hwsim_nan_slot_from_tsf(tsf + NAN_CHAN_SWITCH_TIME_US))
		return false;

	is_dw_slot = mac80211_hwsim_nan_is_dw_slot(data, slot);

	if (!txq->sta) {
		/* Non-STA TXQ: allow management frames during DW */
		if (txq->vif->type == NL80211_IFTYPE_NAN)
			return is_dw_slot;

		/* Allow multicast data when all the peers are available
		 * on this slot
		 */
		return mac80211_hwsim_nan_mcast_data_transmitting(hw, txq);
	}

	/* STA TXQ: need peer schedule for availability check */
	nmi_sta = rcu_dereference(txq->sta->nmi) ?: txq->sta;
	sp = (void *)nmi_sta->drv_priv;

	/* DW slot: NDI can TX only mgmt but not worth checking,
	 * NMI checks peer's committed DW
	 */
	if (is_dw_slot) {
		if (txq->vif->type == NL80211_IFTYPE_NAN_DATA)
			return false;
		return hwsim_nan_peer_present_in_dw(sp, tsf);
	}

	/* FAW slot: verify local schedule and peer availability */
	return hwsim_nan_peer_present_in_faw(sp, data, slot);
}

void mac80211_hwsim_nan_get_tx_chandef(struct ieee80211_hw *hw,
				       struct cfg80211_chan_def *chandef)
{
	struct mac80211_hwsim_data *data = hw->priv;
	u64 tsf = mac80211_hwsim_get_tsf(data->hw, data->nan.device_vif);
	u8 slot = hwsim_nan_slot_from_tsf(tsf);

	/* DW slots are always 20 MHz */
	if (slot == SLOT_24GHZ_DW) {
		cfg80211_chandef_create(chandef,
					ieee80211_get_channel(hw->wiphy, 2437),
					NL80211_CHAN_NO_HT);
		return;
	}

	if (slot == SLOT_5GHZ_DW && data->nan.bands & BIT(NL80211_BAND_5GHZ)) {
		cfg80211_chandef_create(chandef,
					ieee80211_get_channel(hw->wiphy, 5745),
					NL80211_CHAN_NO_HT);
		return;
	}

	/* FAW slot: copy local schedule for this slot */
	scoped_guard(spinlock_bh, &data->nan.state_lock)
		*chandef = data->nan.local_sched[slot];
}

bool mac80211_hwsim_nan_receive(struct ieee80211_hw *hw,
				struct ieee80211_channel *channel,
				struct ieee80211_rx_status *rx_status)
{
	struct mac80211_hwsim_data *data = hw->priv;
	u8 slot;

	if (WARN_ON_ONCE(!data->nan.device_vif))
		return false;

	if (data->nan.phase == MAC80211_HWSIM_NAN_PHASE_SCAN)
		return channel->center_freq == 2437;

	if (rx_status->flag & RX_FLAG_MACTIME) {
		slot = hwsim_nan_slot_from_tsf(rx_status->mactime);
	} else {
		u64 tsf;

		/*
		 * This is not perfect, but that should be fine.
		 *
		 * Assume the frame might be a bit early in relation to our
		 * own TSF. This is largely because the TSF sync is going to be
		 * pretty bad when the frame was RXed via NL and the beacon as
		 * well as RX timestamps are not accurate.
		 */
		tsf = mac80211_hwsim_get_tsf(data->hw, data->nan.device_vif);
		slot = hwsim_nan_slot_from_tsf(tsf + 128);
	}

	if (slot == SLOT_24GHZ_DW && channel->center_freq == 2437)
		return true;

	if (slot == SLOT_5GHZ_DW && data->nan.bands & BIT(NL80211_BAND_5GHZ) &&
	    channel->center_freq == 5745)
		return true;

	/* Accept frames during FAW slots if chandef is compatible */
	return hwsim_nan_rx_chandef_compatible(data, slot, channel,
					       rx_status->bw);
}

void mac80211_hwsim_nan_local_sched_changed(struct ieee80211_hw *hw,
					    struct ieee80211_vif *vif)
{
	struct mac80211_hwsim_data *data = hw->priv;
	struct ieee80211_nan_channel **slots = vif->cfg.nan_sched.schedule;

	if (WARN_ON(vif->type != NL80211_IFTYPE_NAN))
		return;

	spin_lock_bh(&data->nan.state_lock);

	for (int i = 0; i < ARRAY_SIZE(data->nan.local_sched); i++) {
		struct ieee80211_chanctx_conf *chanctx;

		if (!slots[i] || IS_ERR(slots[i])) {
			memset(&data->nan.local_sched[i], 0,
			       sizeof(data->nan.local_sched[i]));
			continue;
		}

		chanctx = slots[i]->chanctx_conf;
		if (!chanctx) {
			memset(&data->nan.local_sched[i], 0,
			       sizeof(data->nan.local_sched[i]));
			continue;
		}

		data->nan.local_sched[i] = chanctx->def;
	}

	spin_unlock_bh(&data->nan.state_lock);
}

int mac80211_hwsim_nan_peer_sched_changed(struct ieee80211_hw *hw,
					  struct ieee80211_sta *sta)
{
	struct hwsim_sta_priv *sp = (void *)sta->drv_priv;
	struct ieee80211_nan_peer_sched *sched = sta->nan_sched;

	spin_lock_bh(&sp->nan_sched.lock);

	/* Clear existing schedule */
	sp->nan_sched.committed_dw = 0;
	for (int i = 0; i < CFG80211_NAN_MAX_PEER_MAPS; i++) {
		sp->nan_sched.maps[i].map_id = CFG80211_NAN_INVALID_MAP_ID;
		memset(sp->nan_sched.maps[i].chans, 0,
		       sizeof(sp->nan_sched.maps[i].chans));
	}

	if (!sched)
		goto out;

	sp->nan_sched.committed_dw = sched->committed_dw;

	for (int i = 0; i < CFG80211_NAN_MAX_PEER_MAPS; i++) {
		struct ieee80211_nan_peer_map *map = &sched->maps[i];

		if (map->map_id == CFG80211_NAN_INVALID_MAP_ID)
			continue;

		sp->nan_sched.maps[i].map_id = map->map_id;

		for (int j = 0; j < CFG80211_NAN_SCHED_NUM_TIME_SLOTS; j++) {
			struct ieee80211_nan_channel *peer_chan =
				map->slots[j];

			if (peer_chan && peer_chan->chanreq.oper.chan)
				sp->nan_sched.maps[i].chans[j] =
					peer_chan->chanreq.oper;
			else
				memset(&sp->nan_sched.maps[i].chans[j], 0,
				       sizeof(sp->nan_sched.maps[i].chans[j]));
		}
	}

out:
	spin_unlock_bh(&sp->nan_sched.lock);
	return 0;
}