util.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2/*
   3 * Copyright 2002-2005, Instant802 Networks, Inc.
   4 * Copyright 2005-2006, Devicescape Software, Inc.
   5 * Copyright 2006-2007	Jiri Benc <jbenc@suse.cz>
   6 * Copyright 2007	Johannes Berg <johannes@sipsolutions.net>
   7 * Copyright 2013-2014  Intel Mobile Communications GmbH
   8 * Copyright (C) 2015-2017	Intel Deutschland GmbH
   9 * Copyright (C) 2018-2025 Intel Corporation
  10 *
  11 * utilities for mac80211
  12 */
  13
  14#include <net/mac80211.h>
  15#include <linux/netdevice.h>
  16#include <linux/export.h>
  17#include <linux/types.h>
  18#include <linux/slab.h>
  19#include <linux/skbuff.h>
  20#include <linux/etherdevice.h>
  21#include <linux/if_arp.h>
  22#include <linux/bitmap.h>
  23#include <linux/crc32.h>
  24#include <net/net_namespace.h>
  25#include <net/cfg80211.h>
  26#include <net/rtnetlink.h>
  27#include <kunit/visibility.h>
  28
  29#include "ieee80211_i.h"
  30#include "driver-ops.h"
  31#include "rate.h"
  32#include "mesh.h"
  33#include "wme.h"
  34#include "led.h"
  35#include "wep.h"
  36
  37/* privid for wiphys to determine whether they belong to us or not */
  38const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
  39
  40struct ieee80211_hw *wiphy_to_ieee80211_hw(struct wiphy *wiphy)
  41{
  42	struct ieee80211_local *local;
  43
  44	local = wiphy_priv(wiphy);
  45	return &local->hw;
  46}
  47EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
  48
  49const struct ieee80211_conn_settings ieee80211_conn_settings_unlimited = {
  50	.mode = IEEE80211_CONN_MODE_EHT,
  51	.bw_limit = IEEE80211_CONN_BW_LIMIT_320,
  52};
  53
  54u8 *ieee80211_get_bssid(struct ieee80211_hdr *hdr, size_t len,
  55			enum nl80211_iftype type)
  56{
  57	__le16 fc = hdr->frame_control;
  58
  59	if (ieee80211_is_data(fc)) {
  60		if (len < 24) /* drop incorrect hdr len (data) */
  61			return NULL;
  62
  63		if (ieee80211_has_a4(fc))
  64			return NULL;
  65		if (ieee80211_has_tods(fc))
  66			return hdr->addr1;
  67		if (ieee80211_has_fromds(fc))
  68			return hdr->addr2;
  69
  70		return hdr->addr3;
  71	}
  72
  73	if (ieee80211_is_s1g_beacon(fc)) {
  74		struct ieee80211_ext *ext = (void *) hdr;
  75
  76		return ext->u.s1g_beacon.sa;
  77	}
  78
  79	if (ieee80211_is_mgmt(fc)) {
  80		if (len < 24) /* drop incorrect hdr len (mgmt) */
  81			return NULL;
  82		return hdr->addr3;
  83	}
  84
  85	if (ieee80211_is_ctl(fc)) {
  86		if (ieee80211_is_pspoll(fc))
  87			return hdr->addr1;
  88
  89		if (ieee80211_is_back_req(fc)) {
  90			switch (type) {
  91			case NL80211_IFTYPE_STATION:
  92				return hdr->addr2;
  93			case NL80211_IFTYPE_AP:
  94			case NL80211_IFTYPE_AP_VLAN:
  95				return hdr->addr1;
  96			default:
  97				break; /* fall through to the return */
  98			}
  99		}
 100	}
 101
 102	return NULL;
 103}
 104EXPORT_SYMBOL(ieee80211_get_bssid);
 105
 106void ieee80211_tx_set_protected(struct ieee80211_tx_data *tx)
 107{
 108	struct sk_buff *skb;
 109	struct ieee80211_hdr *hdr;
 110
 111	skb_queue_walk(&tx->skbs, skb) {
 112		hdr = (struct ieee80211_hdr *) skb->data;
 113		hdr->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
 114	}
 115}
 116
 117int ieee80211_frame_duration(enum nl80211_band band, size_t len,
 118			     int rate, int erp, int short_preamble)
 119{
 120	int dur;
 121
 122	/* calculate duration (in microseconds, rounded up to next higher
 123	 * integer if it includes a fractional microsecond) to send frame of
 124	 * len bytes (does not include FCS) at the given rate. Duration will
 125	 * also include SIFS.
 126	 *
 127	 * rate is in 100 kbps, so divident is multiplied by 10 in the
 128	 * DIV_ROUND_UP() operations.
 129	 */
 130
 131	if (band == NL80211_BAND_5GHZ || erp) {
 132		/*
 133		 * OFDM:
 134		 *
 135		 * N_DBPS = DATARATE x 4
 136		 * N_SYM = Ceiling((16+8xLENGTH+6) / N_DBPS)
 137		 *	(16 = SIGNAL time, 6 = tail bits)
 138		 * TXTIME = T_PREAMBLE + T_SIGNAL + T_SYM x N_SYM + Signal Ext
 139		 *
 140		 * T_SYM = 4 usec
 141		 * 802.11a - 18.5.2: aSIFSTime = 16 usec
 142		 * 802.11g - 19.8.4: aSIFSTime = 10 usec +
 143		 *	signal ext = 6 usec
 144		 */
 145		dur = 16; /* SIFS + signal ext */
 146		dur += 16; /* IEEE 802.11-2012 18.3.2.4: T_PREAMBLE = 16 usec */
 147		dur += 4; /* IEEE 802.11-2012 18.3.2.4: T_SIGNAL = 4 usec */
 148
 149		/* rates should already consider the channel bandwidth,
 150		 * don't apply divisor again.
 151		 */
 152		dur += 4 * DIV_ROUND_UP((16 + 8 * (len + 4) + 6) * 10,
 153					4 * rate); /* T_SYM x N_SYM */
 154	} else {
 155		/*
 156		 * 802.11b or 802.11g with 802.11b compatibility:
 157		 * 18.3.4: TXTIME = PreambleLength + PLCPHeaderTime +
 158		 * Ceiling(((LENGTH+PBCC)x8)/DATARATE). PBCC=0.
 159		 *
 160		 * 802.11 (DS): 15.3.3, 802.11b: 18.3.4
 161		 * aSIFSTime = 10 usec
 162		 * aPreambleLength = 144 usec or 72 usec with short preamble
 163		 * aPLCPHeaderLength = 48 usec or 24 usec with short preamble
 164		 */
 165		dur = 10; /* aSIFSTime = 10 usec */
 166		dur += short_preamble ? (72 + 24) : (144 + 48);
 167
 168		dur += DIV_ROUND_UP(8 * (len + 4) * 10, rate);
 169	}
 170
 171	return dur;
 172}
 173
 174/* Exported duration function for driver use */
 175__le16 ieee80211_generic_frame_duration(struct ieee80211_hw *hw,
 176					struct ieee80211_vif *vif,
 177					enum nl80211_band band,
 178					size_t frame_len,
 179					struct ieee80211_rate *rate)
 180{
 181	struct ieee80211_sub_if_data *sdata;
 182	u16 dur;
 183	int erp;
 184	bool short_preamble = false;
 185
 186	erp = 0;
 187	if (vif) {
 188		sdata = vif_to_sdata(vif);
 189		short_preamble = sdata->vif.bss_conf.use_short_preamble;
 190		if (sdata->deflink.operating_11g_mode)
 191			erp = rate->flags & IEEE80211_RATE_ERP_G;
 192	}
 193
 194	dur = ieee80211_frame_duration(band, frame_len, rate->bitrate, erp,
 195				       short_preamble);
 196
 197	return cpu_to_le16(dur);
 198}
 199EXPORT_SYMBOL(ieee80211_generic_frame_duration);
 200
 201__le16 ieee80211_rts_duration(struct ieee80211_hw *hw,
 202			      struct ieee80211_vif *vif, size_t frame_len,
 203			      const struct ieee80211_tx_info *frame_txctl)
 204{
 205	struct ieee80211_local *local = hw_to_local(hw);
 206	struct ieee80211_rate *rate;
 207	struct ieee80211_sub_if_data *sdata;
 208	bool short_preamble;
 209	int erp, bitrate;
 210	u16 dur;
 211	struct ieee80211_supported_band *sband;
 212
 213	sband = local->hw.wiphy->bands[frame_txctl->band];
 214
 215	short_preamble = false;
 216
 217	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 218
 219	erp = 0;
 220	if (vif) {
 221		sdata = vif_to_sdata(vif);
 222		short_preamble = sdata->vif.bss_conf.use_short_preamble;
 223		if (sdata->deflink.operating_11g_mode)
 224			erp = rate->flags & IEEE80211_RATE_ERP_G;
 225	}
 226
 227	bitrate = rate->bitrate;
 228
 229	/* CTS duration */
 230	dur = ieee80211_frame_duration(sband->band, 10, bitrate,
 231				       erp, short_preamble);
 232	/* Data frame duration */
 233	dur += ieee80211_frame_duration(sband->band, frame_len, bitrate,
 234					erp, short_preamble);
 235	/* ACK duration */
 236	dur += ieee80211_frame_duration(sband->band, 10, bitrate,
 237					erp, short_preamble);
 238
 239	return cpu_to_le16(dur);
 240}
 241EXPORT_SYMBOL(ieee80211_rts_duration);
 242
 243__le16 ieee80211_ctstoself_duration(struct ieee80211_hw *hw,
 244				    struct ieee80211_vif *vif,
 245				    size_t frame_len,
 246				    const struct ieee80211_tx_info *frame_txctl)
 247{
 248	struct ieee80211_local *local = hw_to_local(hw);
 249	struct ieee80211_rate *rate;
 250	struct ieee80211_sub_if_data *sdata;
 251	bool short_preamble;
 252	int erp, bitrate;
 253	u16 dur;
 254	struct ieee80211_supported_band *sband;
 255
 256	sband = local->hw.wiphy->bands[frame_txctl->band];
 257
 258	short_preamble = false;
 259
 260	rate = &sband->bitrates[frame_txctl->control.rts_cts_rate_idx];
 261	erp = 0;
 262	if (vif) {
 263		sdata = vif_to_sdata(vif);
 264		short_preamble = sdata->vif.bss_conf.use_short_preamble;
 265		if (sdata->deflink.operating_11g_mode)
 266			erp = rate->flags & IEEE80211_RATE_ERP_G;
 267	}
 268
 269	bitrate = rate->bitrate;
 270
 271	/* Data frame duration */
 272	dur = ieee80211_frame_duration(sband->band, frame_len, bitrate,
 273				       erp, short_preamble);
 274	if (!(frame_txctl->flags & IEEE80211_TX_CTL_NO_ACK)) {
 275		/* ACK duration */
 276		dur += ieee80211_frame_duration(sband->band, 10, bitrate,
 277						erp, short_preamble);
 278	}
 279
 280	return cpu_to_le16(dur);
 281}
 282EXPORT_SYMBOL(ieee80211_ctstoself_duration);
 283
 284static void wake_tx_push_queue(struct ieee80211_local *local,
 285			       struct ieee80211_sub_if_data *sdata,
 286			       struct ieee80211_txq *queue)
 287{
 288	struct ieee80211_tx_control control = {
 289		.sta = queue->sta,
 290	};
 291	struct sk_buff *skb;
 292
 293	while (1) {
 294		skb = ieee80211_tx_dequeue(&local->hw, queue);
 295		if (!skb)
 296			break;
 297
 298		drv_tx(local, &control, skb);
 299	}
 300}
 301
 302/* wake_tx_queue handler for driver not implementing a custom one*/
 303void ieee80211_handle_wake_tx_queue(struct ieee80211_hw *hw,
 304				    struct ieee80211_txq *txq)
 305{
 306	struct ieee80211_local *local = hw_to_local(hw);
 307	struct ieee80211_sub_if_data *sdata = vif_to_sdata(txq->vif);
 308	struct ieee80211_txq *queue;
 309
 310	spin_lock(&local->handle_wake_tx_queue_lock);
 311
 312	/* Use ieee80211_next_txq() for airtime fairness accounting */
 313	ieee80211_txq_schedule_start(hw, txq->ac);
 314	while ((queue = ieee80211_next_txq(hw, txq->ac))) {
 315		wake_tx_push_queue(local, sdata, queue);
 316		ieee80211_return_txq(hw, queue, false);
 317	}
 318	ieee80211_txq_schedule_end(hw, txq->ac);
 319	spin_unlock(&local->handle_wake_tx_queue_lock);
 320}
 321EXPORT_SYMBOL(ieee80211_handle_wake_tx_queue);
 322
 323static void __ieee80211_wake_txqs(struct ieee80211_sub_if_data *sdata, int ac)
 324{
 325	struct ieee80211_local *local = sdata->local;
 326	struct ieee80211_vif *vif = &sdata->vif;
 327	struct fq *fq = &local->fq;
 328	struct ps_data *ps = NULL;
 329	struct txq_info *txqi;
 330	struct sta_info *sta;
 331	int i;
 332
 333	local_bh_disable();
 334	spin_lock(&fq->lock);
 335
 336	if (!test_bit(SDATA_STATE_RUNNING, &sdata->state))
 337		goto out;
 338
 339	if (sdata->vif.type == NL80211_IFTYPE_AP)
 340		ps = &sdata->bss->ps;
 341
 342	list_for_each_entry_rcu(sta, &local->sta_list, list) {
 343		if (sdata != sta->sdata)
 344			continue;
 345
 346		for (i = 0; i < ARRAY_SIZE(sta->sta.txq); i++) {
 347			struct ieee80211_txq *txq = sta->sta.txq[i];
 348
 349			if (!txq)
 350				continue;
 351
 352			txqi = to_txq_info(txq);
 353
 354			if (ac != txq->ac)
 355				continue;
 356
 357			if (!test_and_clear_bit(IEEE80211_TXQ_DIRTY,
 358						&txqi->flags))
 359				continue;
 360
 361			spin_unlock(&fq->lock);
 362			drv_wake_tx_queue(local, txqi);
 363			spin_lock(&fq->lock);
 364		}
 365	}
 366
 367	if (!vif->txq)
 368		goto out;
 369
 370	txqi = to_txq_info(vif->txq);
 371
 372	if (!test_and_clear_bit(IEEE80211_TXQ_DIRTY, &txqi->flags) ||
 373	    (ps && atomic_read(&ps->num_sta_ps)) || ac != vif->txq->ac)
 374		goto out;
 375
 376	spin_unlock(&fq->lock);
 377
 378	drv_wake_tx_queue(local, txqi);
 379	local_bh_enable();
 380	return;
 381out:
 382	spin_unlock(&fq->lock);
 383	local_bh_enable();
 384}
 385
 386static void
 387__releases(&local->queue_stop_reason_lock)
 388__acquires(&local->queue_stop_reason_lock)
 389_ieee80211_wake_txqs(struct ieee80211_local *local, unsigned long *flags)
 390{
 391	struct ieee80211_sub_if_data *sdata;
 392	int n_acs = IEEE80211_NUM_ACS;
 393	int i;
 394
 395	rcu_read_lock();
 396
 397	if (local->hw.queues < IEEE80211_NUM_ACS)
 398		n_acs = 1;
 399
 400	for (i = 0; i < local->hw.queues; i++) {
 401		if (local->queue_stop_reasons[i])
 402			continue;
 403
 404		spin_unlock_irqrestore(&local->queue_stop_reason_lock, *flags);
 405		list_for_each_entry_rcu(sdata, &local->interfaces, list) {
 406			int ac;
 407
 408			for (ac = 0; ac < n_acs; ac++) {
 409				int ac_queue = sdata->vif.hw_queue[ac];
 410
 411				if (ac_queue == i ||
 412				    sdata->vif.cab_queue == i)
 413					__ieee80211_wake_txqs(sdata, ac);
 414			}
 415		}
 416		spin_lock_irqsave(&local->queue_stop_reason_lock, *flags);
 417	}
 418
 419	rcu_read_unlock();
 420}
 421
 422void ieee80211_wake_txqs(struct tasklet_struct *t)
 423{
 424	struct ieee80211_local *local = from_tasklet(local, t,
 425						     wake_txqs_tasklet);
 426	unsigned long flags;
 427
 428	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 429	_ieee80211_wake_txqs(local, &flags);
 430	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 431}
 432
 433static void __ieee80211_wake_queue(struct ieee80211_hw *hw, int queue,
 434				   enum queue_stop_reason reason,
 435				   bool refcounted,
 436				   unsigned long *flags)
 437{
 438	struct ieee80211_local *local = hw_to_local(hw);
 439
 440	if (WARN_ON(queue >= hw->queues))
 441		return;
 442
 443	if (!test_bit(reason, &local->queue_stop_reasons[queue]))
 444		return;
 445
 446	if (!refcounted) {
 447		local->q_stop_reasons[queue][reason] = 0;
 448	} else {
 449		local->q_stop_reasons[queue][reason]--;
 450		if (WARN_ON(local->q_stop_reasons[queue][reason] < 0))
 451			local->q_stop_reasons[queue][reason] = 0;
 452	}
 453
 454	if (local->q_stop_reasons[queue][reason] == 0)
 455		__clear_bit(reason, &local->queue_stop_reasons[queue]);
 456
 457	trace_wake_queue(local, queue, reason,
 458			 local->q_stop_reasons[queue][reason]);
 459
 460	if (local->queue_stop_reasons[queue] != 0)
 461		/* someone still has this queue stopped */
 462		return;
 463
 464	if (!skb_queue_empty(&local->pending[queue]))
 465		tasklet_schedule(&local->tx_pending_tasklet);
 466
 467	/*
 468	 * Calling _ieee80211_wake_txqs here can be a problem because it may
 469	 * release queue_stop_reason_lock which has been taken by
 470	 * __ieee80211_wake_queue's caller. It is certainly not very nice to
 471	 * release someone's lock, but it is fine because all the callers of
 472	 * __ieee80211_wake_queue call it right before releasing the lock.
 473	 */
 474	if (reason == IEEE80211_QUEUE_STOP_REASON_DRIVER)
 475		tasklet_schedule(&local->wake_txqs_tasklet);
 476	else
 477		_ieee80211_wake_txqs(local, flags);
 478}
 479
 480void ieee80211_wake_queue_by_reason(struct ieee80211_hw *hw, int queue,
 481				    enum queue_stop_reason reason,
 482				    bool refcounted)
 483{
 484	struct ieee80211_local *local = hw_to_local(hw);
 485	unsigned long flags;
 486
 487	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 488	__ieee80211_wake_queue(hw, queue, reason, refcounted, &flags);
 489	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 490}
 491
 492void ieee80211_wake_queue(struct ieee80211_hw *hw, int queue)
 493{
 494	ieee80211_wake_queue_by_reason(hw, queue,
 495				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
 496				       false);
 497}
 498EXPORT_SYMBOL(ieee80211_wake_queue);
 499
 500static void __ieee80211_stop_queue(struct ieee80211_hw *hw, int queue,
 501				   enum queue_stop_reason reason,
 502				   bool refcounted)
 503{
 504	struct ieee80211_local *local = hw_to_local(hw);
 505
 506	if (WARN_ON(queue >= hw->queues))
 507		return;
 508
 509	if (!refcounted)
 510		local->q_stop_reasons[queue][reason] = 1;
 511	else
 512		local->q_stop_reasons[queue][reason]++;
 513
 514	trace_stop_queue(local, queue, reason,
 515			 local->q_stop_reasons[queue][reason]);
 516
 517	set_bit(reason, &local->queue_stop_reasons[queue]);
 518}
 519
 520void ieee80211_stop_queue_by_reason(struct ieee80211_hw *hw, int queue,
 521				    enum queue_stop_reason reason,
 522				    bool refcounted)
 523{
 524	struct ieee80211_local *local = hw_to_local(hw);
 525	unsigned long flags;
 526
 527	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 528	__ieee80211_stop_queue(hw, queue, reason, refcounted);
 529	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 530}
 531
 532void ieee80211_stop_queue(struct ieee80211_hw *hw, int queue)
 533{
 534	ieee80211_stop_queue_by_reason(hw, queue,
 535				       IEEE80211_QUEUE_STOP_REASON_DRIVER,
 536				       false);
 537}
 538EXPORT_SYMBOL(ieee80211_stop_queue);
 539
 540void ieee80211_add_pending_skb(struct ieee80211_local *local,
 541			       struct sk_buff *skb)
 542{
 543	struct ieee80211_hw *hw = &local->hw;
 544	unsigned long flags;
 545	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 546	int queue = info->hw_queue;
 547
 548	if (WARN_ON(!info->control.vif)) {
 549		ieee80211_free_txskb(&local->hw, skb);
 550		return;
 551	}
 552
 553	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 554	__ieee80211_stop_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 555			       false);
 556	__skb_queue_tail(&local->pending[queue], skb);
 557	__ieee80211_wake_queue(hw, queue, IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 558			       false, &flags);
 559	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 560}
 561
 562void ieee80211_add_pending_skbs(struct ieee80211_local *local,
 563				struct sk_buff_head *skbs)
 564{
 565	struct ieee80211_hw *hw = &local->hw;
 566	struct sk_buff *skb;
 567	unsigned long flags;
 568	int queue, i;
 569
 570	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 571	while ((skb = skb_dequeue(skbs))) {
 572		struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
 573
 574		if (WARN_ON(!info->control.vif)) {
 575			ieee80211_free_txskb(&local->hw, skb);
 576			continue;
 577		}
 578
 579		queue = info->hw_queue;
 580
 581		__ieee80211_stop_queue(hw, queue,
 582				IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 583				false);
 584
 585		__skb_queue_tail(&local->pending[queue], skb);
 586	}
 587
 588	for (i = 0; i < hw->queues; i++)
 589		__ieee80211_wake_queue(hw, i,
 590			IEEE80211_QUEUE_STOP_REASON_SKB_ADD,
 591			false, &flags);
 592	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 593}
 594
 595void ieee80211_stop_queues_by_reason(struct ieee80211_hw *hw,
 596				     unsigned long queues,
 597				     enum queue_stop_reason reason,
 598				     bool refcounted)
 599{
 600	struct ieee80211_local *local = hw_to_local(hw);
 601	unsigned long flags;
 602	int i;
 603
 604	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 605
 606	for_each_set_bit(i, &queues, hw->queues)
 607		__ieee80211_stop_queue(hw, i, reason, refcounted);
 608
 609	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 610}
 611
 612void ieee80211_stop_queues(struct ieee80211_hw *hw)
 613{
 614	ieee80211_stop_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 615					IEEE80211_QUEUE_STOP_REASON_DRIVER,
 616					false);
 617}
 618EXPORT_SYMBOL(ieee80211_stop_queues);
 619
 620int ieee80211_queue_stopped(struct ieee80211_hw *hw, int queue)
 621{
 622	struct ieee80211_local *local = hw_to_local(hw);
 623	unsigned long flags;
 624	int ret;
 625
 626	if (WARN_ON(queue >= hw->queues))
 627		return true;
 628
 629	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 630	ret = test_bit(IEEE80211_QUEUE_STOP_REASON_DRIVER,
 631		       &local->queue_stop_reasons[queue]);
 632	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 633	return ret;
 634}
 635EXPORT_SYMBOL(ieee80211_queue_stopped);
 636
 637void ieee80211_wake_queues_by_reason(struct ieee80211_hw *hw,
 638				     unsigned long queues,
 639				     enum queue_stop_reason reason,
 640				     bool refcounted)
 641{
 642	struct ieee80211_local *local = hw_to_local(hw);
 643	unsigned long flags;
 644	int i;
 645
 646	spin_lock_irqsave(&local->queue_stop_reason_lock, flags);
 647
 648	for_each_set_bit(i, &queues, hw->queues)
 649		__ieee80211_wake_queue(hw, i, reason, refcounted, &flags);
 650
 651	spin_unlock_irqrestore(&local->queue_stop_reason_lock, flags);
 652}
 653
 654void ieee80211_wake_queues(struct ieee80211_hw *hw)
 655{
 656	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
 657					IEEE80211_QUEUE_STOP_REASON_DRIVER,
 658					false);
 659}
 660EXPORT_SYMBOL(ieee80211_wake_queues);
 661
 662unsigned int
 663ieee80211_get_vif_queues(struct ieee80211_local *local,
 664			 struct ieee80211_sub_if_data *sdata)
 665{
 666	unsigned int queues;
 667
 668	if (sdata && ieee80211_hw_check(&local->hw, QUEUE_CONTROL)) {
 669		int ac;
 670
 671		queues = 0;
 672
 673		for (ac = 0; ac < IEEE80211_NUM_ACS; ac++)
 674			if (sdata->vif.hw_queue[ac] != IEEE80211_INVAL_HW_QUEUE)
 675				queues |= BIT(sdata->vif.hw_queue[ac]);
 676		if (sdata->vif.cab_queue != IEEE80211_INVAL_HW_QUEUE)
 677			queues |= BIT(sdata->vif.cab_queue);
 678	} else {
 679		/* all queues */
 680		queues = BIT(local->hw.queues) - 1;
 681	}
 682
 683	return queues;
 684}
 685
 686void __ieee80211_flush_queues(struct ieee80211_local *local,
 687			      struct ieee80211_sub_if_data *sdata,
 688			      unsigned int queues, bool drop)
 689{
 690	if (!local->ops->flush && !drop)
 691		return;
 692
 693	/*
 694	 * If no queue was set, or if the HW doesn't support
 695	 * IEEE80211_HW_QUEUE_CONTROL - flush all queues
 696	 */
 697	if (!queues || !ieee80211_hw_check(&local->hw, QUEUE_CONTROL))
 698		queues = ieee80211_get_vif_queues(local, sdata);
 699
 700	ieee80211_stop_queues_by_reason(&local->hw, queues,
 701					IEEE80211_QUEUE_STOP_REASON_FLUSH,
 702					false);
 703
 704	if (drop) {
 705		struct sta_info *sta;
 706
 707		/* Purge the queues, so the frames on them won't be
 708		 * sent during __ieee80211_wake_queue()
 709		 */
 710		list_for_each_entry(sta, &local->sta_list, list) {
 711			if (sdata != sta->sdata)
 712				continue;
 713			ieee80211_purge_sta_txqs(sta);
 714		}
 715	}
 716
 717	if (local->ops->flush)
 718		drv_flush(local, sdata, queues, drop);
 719
 720	ieee80211_wake_queues_by_reason(&local->hw, queues,
 721					IEEE80211_QUEUE_STOP_REASON_FLUSH,
 722					false);
 723}
 724
 725void ieee80211_flush_queues(struct ieee80211_local *local,
 726			    struct ieee80211_sub_if_data *sdata, bool drop)
 727{
 728	__ieee80211_flush_queues(local, sdata, 0, drop);
 729}
 730
 731static void __iterate_interfaces(struct ieee80211_local *local,
 732				 u32 iter_flags,
 733				 void (*iterator)(void *data, u8 *mac,
 734						  struct ieee80211_vif *vif),
 735				 void *data)
 736{
 737	struct ieee80211_sub_if_data *sdata;
 738	bool active_only = iter_flags & IEEE80211_IFACE_ITER_ACTIVE;
 739
 740	list_for_each_entry_rcu(sdata, &local->interfaces, list,
 741				lockdep_is_held(&local->iflist_mtx) ||
 742				lockdep_is_held(&local->hw.wiphy->mtx)) {
 743		switch (sdata->vif.type) {
 744		case NL80211_IFTYPE_MONITOR:
 745			if (!(sdata->u.mntr.flags & MONITOR_FLAG_ACTIVE) &&
 746			    !ieee80211_hw_check(&local->hw, NO_VIRTUAL_MONITOR))
 747				continue;
 748			break;
 749		case NL80211_IFTYPE_AP_VLAN:
 750			continue;
 751		default:
 752			break;
 753		}
 754		if (!(iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL) &&
 755		    active_only && !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 756			continue;
 757		if ((iter_flags & IEEE80211_IFACE_SKIP_SDATA_NOT_IN_DRIVER) &&
 758		    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 759			continue;
 760		if (ieee80211_sdata_running(sdata) || !active_only)
 761			iterator(data, sdata->vif.addr,
 762				 &sdata->vif);
 763	}
 764
 765	sdata = rcu_dereference_check(local->monitor_sdata,
 766				      lockdep_is_held(&local->iflist_mtx) ||
 767				      lockdep_is_held(&local->hw.wiphy->mtx));
 768	if (sdata && ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF) &&
 769	    (iter_flags & IEEE80211_IFACE_ITER_RESUME_ALL || !active_only ||
 770	     sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 771		iterator(data, sdata->vif.addr, &sdata->vif);
 772}
 773
 774void ieee80211_iterate_interfaces(
 775	struct ieee80211_hw *hw, u32 iter_flags,
 776	void (*iterator)(void *data, u8 *mac,
 777			 struct ieee80211_vif *vif),
 778	void *data)
 779{
 780	struct ieee80211_local *local = hw_to_local(hw);
 781
 782	mutex_lock(&local->iflist_mtx);
 783	__iterate_interfaces(local, iter_flags, iterator, data);
 784	mutex_unlock(&local->iflist_mtx);
 785}
 786EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
 787
 788void ieee80211_iterate_active_interfaces_atomic(
 789	struct ieee80211_hw *hw, u32 iter_flags,
 790	void (*iterator)(void *data, u8 *mac,
 791			 struct ieee80211_vif *vif),
 792	void *data)
 793{
 794	struct ieee80211_local *local = hw_to_local(hw);
 795
 796	rcu_read_lock();
 797	__iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
 798			     iterator, data);
 799	rcu_read_unlock();
 800}
 801EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
 802
 803void ieee80211_iterate_active_interfaces_mtx(
 804	struct ieee80211_hw *hw, u32 iter_flags,
 805	void (*iterator)(void *data, u8 *mac,
 806			 struct ieee80211_vif *vif),
 807	void *data)
 808{
 809	struct ieee80211_local *local = hw_to_local(hw);
 810
 811	lockdep_assert_wiphy(hw->wiphy);
 812
 813	__iterate_interfaces(local, iter_flags | IEEE80211_IFACE_ITER_ACTIVE,
 814			     iterator, data);
 815}
 816EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx);
 817
 818static void __iterate_stations(struct ieee80211_local *local,
 819			       void (*iterator)(void *data,
 820						struct ieee80211_sta *sta),
 821			       void *data)
 822{
 823	struct sta_info *sta;
 824
 825	list_for_each_entry_rcu(sta, &local->sta_list, list,
 826				lockdep_is_held(&local->hw.wiphy->mtx)) {
 827		if (!sta->uploaded)
 828			continue;
 829
 830		iterator(data, &sta->sta);
 831	}
 832}
 833
 834void ieee80211_iterate_stations_atomic(struct ieee80211_hw *hw,
 835			void (*iterator)(void *data,
 836					 struct ieee80211_sta *sta),
 837			void *data)
 838{
 839	struct ieee80211_local *local = hw_to_local(hw);
 840
 841	rcu_read_lock();
 842	__iterate_stations(local, iterator, data);
 843	rcu_read_unlock();
 844}
 845EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
 846
 847void ieee80211_iterate_stations_mtx(struct ieee80211_hw *hw,
 848				    void (*iterator)(void *data,
 849						     struct ieee80211_sta *sta),
 850				    void *data)
 851{
 852	struct ieee80211_local *local = hw_to_local(hw);
 853
 854	lockdep_assert_wiphy(local->hw.wiphy);
 855
 856	__iterate_stations(local, iterator, data);
 857}
 858EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_mtx);
 859
 860struct ieee80211_vif *wdev_to_ieee80211_vif(struct wireless_dev *wdev)
 861{
 862	struct ieee80211_sub_if_data *sdata = IEEE80211_WDEV_TO_SUB_IF(wdev);
 863
 864	if (!ieee80211_sdata_running(sdata) ||
 865	    !(sdata->flags & IEEE80211_SDATA_IN_DRIVER))
 866		return NULL;
 867	return &sdata->vif;
 868}
 869EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
 870
 871struct wireless_dev *ieee80211_vif_to_wdev(struct ieee80211_vif *vif)
 872{
 873	if (!vif)
 874		return NULL;
 875
 876	return &vif_to_sdata(vif)->wdev;
 877}
 878EXPORT_SYMBOL_GPL(ieee80211_vif_to_wdev);
 879
 880/*
 881 * Nothing should have been stuffed into the workqueue during
 882 * the suspend->resume cycle. Since we can't check each caller
 883 * of this function if we are already quiescing / suspended,
 884 * check here and don't WARN since this can actually happen when
 885 * the rx path (for example) is racing against __ieee80211_suspend
 886 * and suspending / quiescing was set after the rx path checked
 887 * them.
 888 */
 889static bool ieee80211_can_queue_work(struct ieee80211_local *local)
 890{
 891	if (local->quiescing || (local->suspended && !local->resuming)) {
 892		pr_warn("queueing ieee80211 work while going to suspend\n");
 893		return false;
 894	}
 895
 896	return true;
 897}
 898
 899void ieee80211_queue_work(struct ieee80211_hw *hw, struct work_struct *work)
 900{
 901	struct ieee80211_local *local = hw_to_local(hw);
 902
 903	if (!ieee80211_can_queue_work(local))
 904		return;
 905
 906	queue_work(local->workqueue, work);
 907}
 908EXPORT_SYMBOL(ieee80211_queue_work);
 909
 910void ieee80211_queue_delayed_work(struct ieee80211_hw *hw,
 911				  struct delayed_work *dwork,
 912				  unsigned long delay)
 913{
 914	struct ieee80211_local *local = hw_to_local(hw);
 915
 916	if (!ieee80211_can_queue_work(local))
 917		return;
 918
 919	queue_delayed_work(local->workqueue, dwork, delay);
 920}
 921EXPORT_SYMBOL(ieee80211_queue_delayed_work);
 922
 923void ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data *sdata,
 924					   struct ieee80211_tx_queue_params
 925					   *qparam, int ac)
 926{
 927	struct ieee80211_chanctx_conf *chanctx_conf;
 928	const struct ieee80211_reg_rule *rrule;
 929	const struct ieee80211_wmm_ac *wmm_ac;
 930	u16 center_freq = 0;
 931
 932	if (sdata->vif.type != NL80211_IFTYPE_AP &&
 933	    sdata->vif.type != NL80211_IFTYPE_STATION)
 934		return;
 935
 936	rcu_read_lock();
 937	chanctx_conf = rcu_dereference(sdata->vif.bss_conf.chanctx_conf);
 938	if (chanctx_conf)
 939		center_freq = chanctx_conf->def.chan->center_freq;
 940
 941	if (!center_freq) {
 942		rcu_read_unlock();
 943		return;
 944	}
 945
 946	rrule = freq_reg_info(sdata->wdev.wiphy, MHZ_TO_KHZ(center_freq));
 947
 948	if (IS_ERR_OR_NULL(rrule) || !rrule->has_wmm) {
 949		rcu_read_unlock();
 950		return;
 951	}
 952
 953	if (sdata->vif.type == NL80211_IFTYPE_AP)
 954		wmm_ac = &rrule->wmm_rule.ap[ac];
 955	else
 956		wmm_ac = &rrule->wmm_rule.client[ac];
 957	qparam->cw_min = max_t(u16, qparam->cw_min, wmm_ac->cw_min);
 958	qparam->cw_max = max_t(u16, qparam->cw_max, wmm_ac->cw_max);
 959	qparam->aifs = max_t(u8, qparam->aifs, wmm_ac->aifsn);
 960	qparam->txop = min_t(u16, qparam->txop, wmm_ac->cot / 32);
 961	rcu_read_unlock();
 962}
 963
 964void ieee80211_set_wmm_default(struct ieee80211_link_data *link,
 965			       bool bss_notify, bool enable_qos)
 966{
 967	struct ieee80211_sub_if_data *sdata = link->sdata;
 968	struct ieee80211_local *local = sdata->local;
 969	struct ieee80211_tx_queue_params qparam;
 970	struct ieee80211_chanctx_conf *chanctx_conf;
 971	int ac;
 972	bool use_11b;
 973	bool is_ocb; /* Use another EDCA parameters if dot11OCBActivated=true */
 974	int aCWmin, aCWmax;
 975
 976	if (!local->ops->conf_tx)
 977		return;
 978
 979	if (local->hw.queues < IEEE80211_NUM_ACS)
 980		return;
 981
 982	memset(&qparam, 0, sizeof(qparam));
 983
 984	rcu_read_lock();
 985	chanctx_conf = rcu_dereference(link->conf->chanctx_conf);
 986	use_11b = (chanctx_conf &&
 987		   chanctx_conf->def.chan->band == NL80211_BAND_2GHZ) &&
 988		 !link->operating_11g_mode;
 989	rcu_read_unlock();
 990
 991	is_ocb = (sdata->vif.type == NL80211_IFTYPE_OCB);
 992
 993	/* Set defaults according to 802.11-2007 Table 7-37 */
 994	aCWmax = 1023;
 995	if (use_11b)
 996		aCWmin = 31;
 997	else
 998		aCWmin = 15;
 999
1000	/* Configure old 802.11b/g medium access rules. */
1001	qparam.cw_max = aCWmax;
1002	qparam.cw_min = aCWmin;
1003	qparam.txop = 0;
1004	qparam.aifs = 2;
1005
1006	for (ac = 0; ac < IEEE80211_NUM_ACS; ac++) {
1007		/* Update if QoS is enabled. */
1008		if (enable_qos) {
1009			switch (ac) {
1010			case IEEE80211_AC_BK:
1011				qparam.cw_max = aCWmax;
1012				qparam.cw_min = aCWmin;
1013				qparam.txop = 0;
1014				if (is_ocb)
1015					qparam.aifs = 9;
1016				else
1017					qparam.aifs = 7;
1018				break;
1019			/* never happens but let's not leave undefined */
1020			default:
1021			case IEEE80211_AC_BE:
1022				qparam.cw_max = aCWmax;
1023				qparam.cw_min = aCWmin;
1024				qparam.txop = 0;
1025				if (is_ocb)
1026					qparam.aifs = 6;
1027				else
1028					qparam.aifs = 3;
1029				break;
1030			case IEEE80211_AC_VI:
1031				qparam.cw_max = aCWmin;
1032				qparam.cw_min = (aCWmin + 1) / 2 - 1;
1033				if (is_ocb)
1034					qparam.txop = 0;
1035				else if (use_11b)
1036					qparam.txop = 6016/32;
1037				else
1038					qparam.txop = 3008/32;
1039
1040				if (is_ocb)
1041					qparam.aifs = 3;
1042				else
1043					qparam.aifs = 2;
1044				break;
1045			case IEEE80211_AC_VO:
1046				qparam.cw_max = (aCWmin + 1) / 2 - 1;
1047				qparam.cw_min = (aCWmin + 1) / 4 - 1;
1048				if (is_ocb)
1049					qparam.txop = 0;
1050				else if (use_11b)
1051					qparam.txop = 3264/32;
1052				else
1053					qparam.txop = 1504/32;
1054				qparam.aifs = 2;
1055				break;
1056			}
1057		}
1058		ieee80211_regulatory_limit_wmm_params(sdata, &qparam, ac);
1059
1060		qparam.uapsd = false;
1061
1062		link->tx_conf[ac] = qparam;
1063		drv_conf_tx(local, link, ac, &qparam);
1064	}
1065
1066	if (sdata->vif.type != NL80211_IFTYPE_MONITOR &&
1067	    sdata->vif.type != NL80211_IFTYPE_P2P_DEVICE &&
1068	    sdata->vif.type != NL80211_IFTYPE_NAN) {
1069		link->conf->qos = enable_qos;
1070		if (bss_notify)
1071			ieee80211_link_info_change_notify(sdata, link,
1072							  BSS_CHANGED_QOS);
1073	}
1074}
1075
1076void ieee80211_send_auth(struct ieee80211_sub_if_data *sdata,
1077			 u16 transaction, u16 auth_alg, u16 status,
1078			 const u8 *extra, size_t extra_len, const u8 *da,
1079			 const u8 *bssid, const u8 *key, u8 key_len, u8 key_idx,
1080			 u32 tx_flags)
1081{
1082	struct ieee80211_local *local = sdata->local;
1083	struct sk_buff *skb;
1084	struct ieee80211_mgmt *mgmt;
1085	bool multi_link = ieee80211_vif_is_mld(&sdata->vif);
1086	struct {
1087		u8 id;
1088		u8 len;
1089		u8 ext_id;
1090		struct ieee80211_multi_link_elem ml;
1091		struct ieee80211_mle_basic_common_info basic;
1092	} __packed mle = {
1093		.id = WLAN_EID_EXTENSION,
1094		.len = sizeof(mle) - 2,
1095		.ext_id = WLAN_EID_EXT_EHT_MULTI_LINK,
1096		.ml.control = cpu_to_le16(IEEE80211_ML_CONTROL_TYPE_BASIC),
1097		.basic.len = sizeof(mle.basic),
1098	};
1099	int err;
1100
1101	memcpy(mle.basic.mld_mac_addr, sdata->vif.addr, ETH_ALEN);
1102
1103	/* 24 + 6 = header + auth_algo + auth_transaction + status_code */
1104	skb = dev_alloc_skb(local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN +
1105			    24 + 6 + extra_len + IEEE80211_WEP_ICV_LEN +
1106			    multi_link * sizeof(mle));
1107	if (!skb)
1108		return;
1109
1110	skb_reserve(skb, local->hw.extra_tx_headroom + IEEE80211_WEP_IV_LEN);
1111
1112	mgmt = skb_put_zero(skb, 24 + 6);
1113	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
1114					  IEEE80211_STYPE_AUTH);
1115	memcpy(mgmt->da, da, ETH_ALEN);
1116	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1117	memcpy(mgmt->bssid, bssid, ETH_ALEN);
1118	mgmt->u.auth.auth_alg = cpu_to_le16(auth_alg);
1119	mgmt->u.auth.auth_transaction = cpu_to_le16(transaction);
1120	mgmt->u.auth.status_code = cpu_to_le16(status);
1121	if (extra)
1122		skb_put_data(skb, extra, extra_len);
1123	if (multi_link)
1124		skb_put_data(skb, &mle, sizeof(mle));
1125
1126	if (auth_alg == WLAN_AUTH_SHARED_KEY && transaction == 3) {
1127		mgmt->frame_control |= cpu_to_le16(IEEE80211_FCTL_PROTECTED);
1128		err = ieee80211_wep_encrypt(local, skb, key, key_len, key_idx);
1129		if (WARN_ON(err)) {
1130			kfree_skb(skb);
1131			return;
1132		}
1133	}
1134
1135	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT |
1136					tx_flags;
1137	ieee80211_tx_skb(sdata, skb);
1138}
1139
1140void ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data *sdata,
1141				    const u8 *da, const u8 *bssid,
1142				    u16 stype, u16 reason,
1143				    bool send_frame, u8 *frame_buf)
1144{
1145	struct ieee80211_local *local = sdata->local;
1146	struct sk_buff *skb;
1147	struct ieee80211_mgmt *mgmt = (void *)frame_buf;
1148
1149	/* build frame */
1150	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT | stype);
1151	mgmt->duration = 0; /* initialize only */
1152	mgmt->seq_ctrl = 0; /* initialize only */
1153	memcpy(mgmt->da, da, ETH_ALEN);
1154	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
1155	memcpy(mgmt->bssid, bssid, ETH_ALEN);
1156	/* u.deauth.reason_code == u.disassoc.reason_code */
1157	mgmt->u.deauth.reason_code = cpu_to_le16(reason);
1158
1159	if (send_frame) {
1160		skb = dev_alloc_skb(local->hw.extra_tx_headroom +
1161				    IEEE80211_DEAUTH_FRAME_LEN);
1162		if (!skb)
1163			return;
1164
1165		skb_reserve(skb, local->hw.extra_tx_headroom);
1166
1167		/* copy in frame */
1168		skb_put_data(skb, mgmt, IEEE80211_DEAUTH_FRAME_LEN);
1169
1170		if (sdata->vif.type != NL80211_IFTYPE_STATION ||
1171		    !(sdata->u.mgd.flags & IEEE80211_STA_MFP_ENABLED))
1172			IEEE80211_SKB_CB(skb)->flags |=
1173				IEEE80211_TX_INTFL_DONT_ENCRYPT;
1174
1175		ieee80211_tx_skb(sdata, skb);
1176	}
1177}
1178
1179static int ieee80211_put_s1g_cap(struct sk_buff *skb,
1180				 struct ieee80211_sta_s1g_cap *s1g_cap)
1181{
1182	if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_s1g_cap))
1183		return -ENOBUFS;
1184
1185	skb_put_u8(skb, WLAN_EID_S1G_CAPABILITIES);
1186	skb_put_u8(skb, sizeof(struct ieee80211_s1g_cap));
1187
1188	skb_put_data(skb, &s1g_cap->cap, sizeof(s1g_cap->cap));
1189	skb_put_data(skb, &s1g_cap->nss_mcs, sizeof(s1g_cap->nss_mcs));
1190
1191	return 0;
1192}
1193
1194static int ieee80211_put_preq_ies_band(struct sk_buff *skb,
1195				       struct ieee80211_sub_if_data *sdata,
1196				       const u8 *ie, size_t ie_len,
1197				       size_t *offset,
1198				       enum nl80211_band band,
1199				       u32 rate_mask,
1200				       struct cfg80211_chan_def *chandef,
1201				       u32 flags)
1202{
1203	struct ieee80211_local *local = sdata->local;
1204	struct ieee80211_supported_band *sband;
1205	int i, err;
1206	size_t noffset;
1207	bool have_80mhz = false;
1208
1209	*offset = 0;
1210
1211	sband = local->hw.wiphy->bands[band];
1212	if (WARN_ON_ONCE(!sband))
1213		return 0;
1214
1215	/* For direct scan add S1G IE and consider its override bits */
1216	if (band == NL80211_BAND_S1GHZ)
1217		return ieee80211_put_s1g_cap(skb, &sband->s1g_cap);
1218
1219	err = ieee80211_put_srates_elem(skb, sband, 0,
1220					~rate_mask, WLAN_EID_SUPP_RATES);
1221	if (err)
1222		return err;
1223
1224	/* insert "request information" if in custom IEs */
1225	if (ie && ie_len) {
1226		static const u8 before_extrates[] = {
1227			WLAN_EID_SSID,
1228			WLAN_EID_SUPP_RATES,
1229			WLAN_EID_REQUEST,
1230		};
1231		noffset = ieee80211_ie_split(ie, ie_len,
1232					     before_extrates,
1233					     ARRAY_SIZE(before_extrates),
1234					     *offset);
1235		if (skb_tailroom(skb) < noffset - *offset)
1236			return -ENOBUFS;
1237		skb_put_data(skb, ie + *offset, noffset - *offset);
1238		*offset = noffset;
1239	}
1240
1241	err = ieee80211_put_srates_elem(skb, sband, 0,
1242					~rate_mask, WLAN_EID_EXT_SUPP_RATES);
1243	if (err)
1244		return err;
1245
1246	if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
1247		if (skb_tailroom(skb) < 3)
1248			return -ENOBUFS;
1249		skb_put_u8(skb, WLAN_EID_DS_PARAMS);
1250		skb_put_u8(skb, 1);
1251		skb_put_u8(skb,
1252			   ieee80211_frequency_to_channel(chandef->chan->center_freq));
1253	}
1254
1255	if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT)
1256		return 0;
1257
1258	/* insert custom IEs that go before HT */
1259	if (ie && ie_len) {
1260		static const u8 before_ht[] = {
1261			/*
1262			 * no need to list the ones split off already
1263			 * (or generated here)
1264			 */
1265			WLAN_EID_DS_PARAMS,
1266			WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1267		};
1268		noffset = ieee80211_ie_split(ie, ie_len,
1269					     before_ht, ARRAY_SIZE(before_ht),
1270					     *offset);
1271		if (skb_tailroom(skb) < noffset - *offset)
1272			return -ENOBUFS;
1273		skb_put_data(skb, ie + *offset, noffset - *offset);
1274		*offset = noffset;
1275	}
1276
1277	if (sband->ht_cap.ht_supported) {
1278		u8 *pos;
1279
1280		if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap))
1281			return -ENOBUFS;
1282
1283		pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap));
1284		ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1285					  sband->ht_cap.cap);
1286	}
1287
1288	/* insert custom IEs that go before VHT */
1289	if (ie && ie_len) {
1290		static const u8 before_vht[] = {
1291			/*
1292			 * no need to list the ones split off already
1293			 * (or generated here)
1294			 */
1295			WLAN_EID_BSS_COEX_2040,
1296			WLAN_EID_EXT_CAPABILITY,
1297			WLAN_EID_SSID_LIST,
1298			WLAN_EID_CHANNEL_USAGE,
1299			WLAN_EID_INTERWORKING,
1300			WLAN_EID_MESH_ID,
1301			/* 60 GHz (Multi-band, DMG, MMS) can't happen */
1302		};
1303		noffset = ieee80211_ie_split(ie, ie_len,
1304					     before_vht, ARRAY_SIZE(before_vht),
1305					     *offset);
1306		if (skb_tailroom(skb) < noffset - *offset)
1307			return -ENOBUFS;
1308		skb_put_data(skb, ie + *offset, noffset - *offset);
1309		*offset = noffset;
1310	}
1311
1312	/* Check if any channel in this sband supports at least 80 MHz */
1313	for (i = 0; i < sband->n_channels; i++) {
1314		if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
1315						IEEE80211_CHAN_NO_80MHZ))
1316			continue;
1317
1318		have_80mhz = true;
1319		break;
1320	}
1321
1322	if (sband->vht_cap.vht_supported && have_80mhz) {
1323		u8 *pos;
1324
1325		if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_vht_cap))
1326			return -ENOBUFS;
1327
1328		pos = skb_put(skb, 2 + sizeof(struct ieee80211_vht_cap));
1329		ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1330					   sband->vht_cap.cap);
1331	}
1332
1333	/* insert custom IEs that go before HE */
1334	if (ie && ie_len) {
1335		static const u8 before_he[] = {
1336			/*
1337			 * no need to list the ones split off before VHT
1338			 * or generated here
1339			 */
1340			WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS,
1341			WLAN_EID_AP_CSN,
1342			/* TODO: add 11ah/11aj/11ak elements */
1343		};
1344		noffset = ieee80211_ie_split(ie, ie_len,
1345					     before_he, ARRAY_SIZE(before_he),
1346					     *offset);
1347		if (skb_tailroom(skb) < noffset - *offset)
1348			return -ENOBUFS;
1349		skb_put_data(skb, ie + *offset, noffset - *offset);
1350		*offset = noffset;
1351	}
1352
1353	if (cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1354					 IEEE80211_CHAN_NO_HE)) {
1355		err = ieee80211_put_he_cap(skb, sdata, sband, NULL);
1356		if (err)
1357			return err;
1358	}
1359
1360	if (cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1361					 IEEE80211_CHAN_NO_HE |
1362					 IEEE80211_CHAN_NO_EHT)) {
1363		err = ieee80211_put_eht_cap(skb, sdata, sband, NULL);
1364		if (err)
1365			return err;
1366	}
1367
1368	err = ieee80211_put_he_6ghz_cap(skb, sdata, IEEE80211_SMPS_OFF);
1369	if (err)
1370		return err;
1371
1372	/*
1373	 * If adding more here, adjust code in main.c
1374	 * that calculates local->scan_ies_len.
1375	 */
1376
1377	return 0;
1378}
1379
1380static int ieee80211_put_preq_ies(struct sk_buff *skb,
1381				  struct ieee80211_sub_if_data *sdata,
1382				  struct ieee80211_scan_ies *ie_desc,
1383				  const u8 *ie, size_t ie_len,
1384				  u8 bands_used, u32 *rate_masks,
1385				  struct cfg80211_chan_def *chandef,
1386				  u32 flags)
1387{
1388	size_t custom_ie_offset = 0;
1389	int i, err;
1390
1391	memset(ie_desc, 0, sizeof(*ie_desc));
1392
1393	for (i = 0; i < NUM_NL80211_BANDS; i++) {
1394		if (bands_used & BIT(i)) {
1395			ie_desc->ies[i] = skb_tail_pointer(skb);
1396			err = ieee80211_put_preq_ies_band(skb, sdata,
1397							  ie, ie_len,
1398							  &custom_ie_offset,
1399							  i, rate_masks[i],
1400							  chandef, flags);
1401			if (err)
1402				return err;
1403			ie_desc->len[i] = skb_tail_pointer(skb) -
1404					  ie_desc->ies[i];
1405		}
1406	}
1407
1408	/* add any remaining custom IEs */
1409	if (ie && ie_len) {
1410		if (WARN_ONCE(skb_tailroom(skb) < ie_len - custom_ie_offset,
1411			      "not enough space for preq custom IEs\n"))
1412			return -ENOBUFS;
1413		ie_desc->common_ies = skb_tail_pointer(skb);
1414		skb_put_data(skb, ie + custom_ie_offset,
1415			     ie_len - custom_ie_offset);
1416		ie_desc->common_ie_len = skb_tail_pointer(skb) -
1417					 ie_desc->common_ies;
1418	}
1419
1420	return 0;
1421};
1422
1423int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer,
1424			     size_t buffer_len,
1425			     struct ieee80211_scan_ies *ie_desc,
1426			     const u8 *ie, size_t ie_len,
1427			     u8 bands_used, u32 *rate_masks,
1428			     struct cfg80211_chan_def *chandef,
1429			     u32 flags)
1430{
1431	struct sk_buff *skb = alloc_skb(buffer_len, GFP_KERNEL);
1432	uintptr_t offs;
1433	int ret, i;
1434	u8 *start;
1435
1436	if (!skb)
1437		return -ENOMEM;
1438
1439	start = skb_tail_pointer(skb);
1440	memset(start, 0, skb_tailroom(skb));
1441	ret = ieee80211_put_preq_ies(skb, sdata, ie_desc, ie, ie_len,
1442				     bands_used, rate_masks, chandef,
1443				     flags);
1444	if (ret < 0) {
1445		goto out;
1446	}
1447
1448	if (skb->len > buffer_len) {
1449		ret = -ENOBUFS;
1450		goto out;
1451	}
1452
1453	memcpy(buffer, start, skb->len);
1454
1455	/* adjust ie_desc for copy */
1456	for (i = 0; i < NUM_NL80211_BANDS; i++) {
1457		offs = ie_desc->ies[i] - start;
1458		ie_desc->ies[i] = buffer + offs;
1459	}
1460	offs = ie_desc->common_ies - start;
1461	ie_desc->common_ies = buffer + offs;
1462
1463	ret = skb->len;
1464out:
1465	consume_skb(skb);
1466	return ret;
1467}
1468
1469struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1470					  const u8 *src, const u8 *dst,
1471					  u32 ratemask,
1472					  struct ieee80211_channel *chan,
1473					  const u8 *ssid, size_t ssid_len,
1474					  const u8 *ie, size_t ie_len,
1475					  u32 flags)
1476{
1477	struct ieee80211_local *local = sdata->local;
1478	struct cfg80211_chan_def chandef;
1479	struct sk_buff *skb;
1480	struct ieee80211_mgmt *mgmt;
1481	u32 rate_masks[NUM_NL80211_BANDS] = {};
1482	struct ieee80211_scan_ies dummy_ie_desc;
1483
1484	/*
1485	 * Do not send DS Channel parameter for directed probe requests
1486	 * in order to maximize the chance that we get a response.  Some
1487	 * badly-behaved APs don't respond when this parameter is included.
1488	 */
1489	chandef.width = sdata->vif.bss_conf.chanreq.oper.width;
1490	if (flags & IEEE80211_PROBE_FLAG_DIRECTED)
1491		chandef.chan = NULL;
1492	else
1493		chandef.chan = chan;
1494
1495	skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
1496				     local->scan_ies_len + ie_len);
1497	if (!skb)
1498		return NULL;
1499
1500	rate_masks[chan->band] = ratemask;
1501	ieee80211_put_preq_ies(skb, sdata, &dummy_ie_desc,
1502			       ie, ie_len, BIT(chan->band),
1503			       rate_masks, &chandef, flags);
1504
1505	if (dst) {
1506		mgmt = (struct ieee80211_mgmt *) skb->data;
1507		memcpy(mgmt->da, dst, ETH_ALEN);
1508		memcpy(mgmt->bssid, dst, ETH_ALEN);
1509	}
1510
1511	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1512
1513	return skb;
1514}
1515
1516u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1517			    struct ieee802_11_elems *elems,
1518			    enum nl80211_band band, u32 *basic_rates)
1519{
1520	struct ieee80211_supported_band *sband;
1521	size_t num_rates;
1522	u32 supp_rates;
1523	int i, j;
1524
1525	sband = sdata->local->hw.wiphy->bands[band];
1526	if (WARN_ON(!sband))
1527		return 1;
1528
1529	num_rates = sband->n_bitrates;
1530	supp_rates = 0;
1531	for (i = 0; i < elems->supp_rates_len +
1532		     elems->ext_supp_rates_len; i++) {
1533		u8 rate = 0;
1534		int own_rate;
1535		bool is_basic;
1536		if (i < elems->supp_rates_len)
1537			rate = elems->supp_rates[i];
1538		else if (elems->ext_supp_rates)
1539			rate = elems->ext_supp_rates
1540				[i - elems->supp_rates_len];
1541		own_rate = 5 * (rate & 0x7f);
1542		is_basic = !!(rate & 0x80);
1543
1544		if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1545			continue;
1546
1547		for (j = 0; j < num_rates; j++) {
1548			int brate = sband->bitrates[j].bitrate;
1549
1550			if (brate == own_rate) {
1551				supp_rates |= BIT(j);
1552				if (basic_rates && is_basic)
1553					*basic_rates |= BIT(j);
1554			}
1555		}
1556	}
1557	return supp_rates;
1558}
1559
1560void ieee80211_stop_device(struct ieee80211_local *local, bool suspend)
1561{
1562	local_bh_disable();
1563	ieee80211_handle_queued_frames(local);
1564	local_bh_enable();
1565
1566	ieee80211_led_radio(local, false);
1567	ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
1568
1569	wiphy_work_cancel(local->hw.wiphy, &local->reconfig_filter);
1570
1571	flush_workqueue(local->workqueue);
1572	wiphy_work_flush(local->hw.wiphy, NULL);
1573	drv_stop(local, suspend);
1574}
1575
1576static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
1577					   bool aborted)
1578{
1579	/* It's possible that we don't handle the scan completion in
1580	 * time during suspend, so if it's still marked as completed
1581	 * here, queue the work and flush it to clean things up.
1582	 * Instead of calling the worker function directly here, we
1583	 * really queue it to avoid potential races with other flows
1584	 * scheduling the same work.
1585	 */
1586	if (test_bit(SCAN_COMPLETED, &local->scanning)) {
1587		/* If coming from reconfiguration failure, abort the scan so
1588		 * we don't attempt to continue a partial HW scan - which is
1589		 * possible otherwise if (e.g.) the 2.4 GHz portion was the
1590		 * completed scan, and a 5 GHz portion is still pending.
1591		 */
1592		if (aborted)
1593			set_bit(SCAN_ABORTED, &local->scanning);
1594		wiphy_delayed_work_queue(local->hw.wiphy, &local->scan_work, 0);
1595		wiphy_delayed_work_flush(local->hw.wiphy, &local->scan_work);
1596	}
1597}
1598
1599static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
1600{
1601	struct ieee80211_sub_if_data *sdata;
1602	struct ieee80211_chanctx *ctx;
1603
1604	lockdep_assert_wiphy(local->hw.wiphy);
1605
1606	/*
1607	 * We get here if during resume the device can't be restarted properly.
1608	 * We might also get here if this happens during HW reset, which is a
1609	 * slightly different situation and we need to drop all connections in
1610	 * the latter case.
1611	 *
1612	 * Ask cfg80211 to turn off all interfaces, this will result in more
1613	 * warnings but at least we'll then get into a clean stopped state.
1614	 */
1615
1616	local->resuming = false;
1617	local->suspended = false;
1618	local->in_reconfig = false;
1619	local->reconfig_failure = true;
1620
1621	ieee80211_flush_completed_scan(local, true);
1622
1623	/* scheduled scan clearly can't be running any more, but tell
1624	 * cfg80211 and clear local state
1625	 */
1626	ieee80211_sched_scan_end(local);
1627
1628	list_for_each_entry(sdata, &local->interfaces, list)
1629		sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
1630
1631	/* Mark channel contexts as not being in the driver any more to avoid
1632	 * removing them from the driver during the shutdown process...
1633	 */
1634	list_for_each_entry(ctx, &local->chanctx_list, list)
1635		ctx->driver_present = false;
1636}
1637
1638static void ieee80211_assign_chanctx(struct ieee80211_local *local,
1639				     struct ieee80211_sub_if_data *sdata,
1640				     struct ieee80211_link_data *link)
1641{
1642	struct ieee80211_chanctx_conf *conf;
1643	struct ieee80211_chanctx *ctx;
1644
1645	lockdep_assert_wiphy(local->hw.wiphy);
1646
1647	conf = rcu_dereference_protected(link->conf->chanctx_conf,
1648					 lockdep_is_held(&local->hw.wiphy->mtx));
1649	if (conf) {
1650		ctx = container_of(conf, struct ieee80211_chanctx, conf);
1651		drv_assign_vif_chanctx(local, sdata, link->conf, ctx);
1652	}
1653}
1654
1655static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
1656{
1657	struct ieee80211_local *local = sdata->local;
1658	struct sta_info *sta;
1659
1660	lockdep_assert_wiphy(local->hw.wiphy);
1661
1662	/* add STAs back */
1663	list_for_each_entry(sta, &local->sta_list, list) {
1664		enum ieee80211_sta_state state;
1665
1666		if (!sta->uploaded || sta->sdata != sdata)
1667			continue;
1668
1669		for (state = IEEE80211_STA_NOTEXIST;
1670		     state < sta->sta_state; state++)
1671			WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1672					      state + 1));
1673	}
1674}
1675
1676static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
1677{
1678	struct cfg80211_nan_func *func, **funcs;
1679	int res, id, i = 0;
1680
1681	res = drv_start_nan(sdata->local, sdata,
1682			    &sdata->u.nan.conf);
1683	if (WARN_ON(res))
1684		return res;
1685
1686	funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
1687			sizeof(*funcs),
1688			GFP_KERNEL);
1689	if (!funcs)
1690		return -ENOMEM;
1691
1692	/* Add all the functions:
1693	 * This is a little bit ugly. We need to call a potentially sleeping
1694	 * callback for each NAN function, so we can't hold the spinlock.
1695	 */
1696	spin_lock_bh(&sdata->u.nan.func_lock);
1697
1698	idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
1699		funcs[i++] = func;
1700
1701	spin_unlock_bh(&sdata->u.nan.func_lock);
1702
1703	for (i = 0; funcs[i]; i++) {
1704		res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
1705		if (WARN_ON(res))
1706			ieee80211_nan_func_terminated(&sdata->vif,
1707						      funcs[i]->instance_id,
1708						      NL80211_NAN_FUNC_TERM_REASON_ERROR,
1709						      GFP_KERNEL);
1710	}
1711
1712	kfree(funcs);
1713
1714	return 0;
1715}
1716
1717static void ieee80211_reconfig_ap_links(struct ieee80211_local *local,
1718					struct ieee80211_sub_if_data *sdata,
1719					u64 changed)
1720{
1721	int link_id;
1722
1723	for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
1724		struct ieee80211_link_data *link;
1725
1726		if (!(sdata->vif.active_links & BIT(link_id)))
1727			continue;
1728
1729		link = sdata_dereference(sdata->link[link_id], sdata);
1730		if (!link)
1731			continue;
1732
1733		if (rcu_access_pointer(link->u.ap.beacon))
1734			drv_start_ap(local, sdata, link->conf);
1735
1736		if (!link->conf->enable_beacon)
1737			continue;
1738
1739		changed |= BSS_CHANGED_BEACON |
1740			   BSS_CHANGED_BEACON_ENABLED;
1741
1742		ieee80211_link_info_change_notify(sdata, link, changed);
1743	}
1744}
1745
1746int ieee80211_reconfig(struct ieee80211_local *local)
1747{
1748	struct ieee80211_hw *hw = &local->hw;
1749	struct ieee80211_sub_if_data *sdata;
1750	struct ieee80211_chanctx *ctx;
1751	struct sta_info *sta;
1752	int res, i;
1753	bool reconfig_due_to_wowlan = false;
1754	struct ieee80211_sub_if_data *sched_scan_sdata;
1755	struct cfg80211_sched_scan_request *sched_scan_req;
1756	bool sched_scan_stopped = false;
1757	bool suspended = local->suspended;
1758	bool in_reconfig = false;
1759
1760	lockdep_assert_wiphy(local->hw.wiphy);
1761
1762	/* nothing to do if HW shouldn't run */
1763	if (!local->open_count)
1764		goto wake_up;
1765
1766#ifdef CONFIG_PM
1767	if (suspended)
1768		local->resuming = true;
1769
1770	if (local->wowlan) {
1771		/*
1772		 * In the wowlan case, both mac80211 and the device
1773		 * are functional when the resume op is called, so
1774		 * clear local->suspended so the device could operate
1775		 * normally (e.g. pass rx frames).
1776		 */
1777		local->suspended = false;
1778		res = drv_resume(local);
1779		local->wowlan = false;
1780		if (res < 0) {
1781			local->resuming = false;
1782			return res;
1783		}
1784		if (res == 0)
1785			goto wake_up;
1786		WARN_ON(res > 1);
1787		/*
1788		 * res is 1, which means the driver requested
1789		 * to go through a regular reset on wakeup.
1790		 * restore local->suspended in this case.
1791		 */
1792		reconfig_due_to_wowlan = true;
1793		local->suspended = true;
1794	}
1795#endif
1796
1797	/*
1798	 * In case of hw_restart during suspend (without wowlan),
1799	 * cancel restart work, as we are reconfiguring the device
1800	 * anyway.
1801	 * Note that restart_work is scheduled on a frozen workqueue,
1802	 * so we can't deadlock in this case.
1803	 */
1804	if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
1805		cancel_work_sync(&local->restart_work);
1806
1807	local->started = false;
1808
1809	/*
1810	 * Upon resume hardware can sometimes be goofy due to
1811	 * various platform / driver / bus issues, so restarting
1812	 * the device may at times not work immediately. Propagate
1813	 * the error.
1814	 */
1815	res = drv_start(local);
1816	if (res) {
1817		if (suspended)
1818			WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
1819		else
1820			WARN(1, "Hardware became unavailable during restart.\n");
1821		ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
1822						IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1823						false);
1824		ieee80211_handle_reconfig_failure(local);
1825		return res;
1826	}
1827
1828	/* setup fragmentation threshold */
1829	drv_set_frag_threshold(local, -1, hw->wiphy->frag_threshold);
1830
1831	/* setup RTS threshold */
1832	if (hw->wiphy->n_radio > 0) {
1833		for (i = 0; i < hw->wiphy->n_radio; i++) {
1834			u32 rts_threshold =
1835				hw->wiphy->radio_cfg[i].rts_threshold;
1836
1837			drv_set_rts_threshold(local, i, rts_threshold);
1838		}
1839	} else {
1840		drv_set_rts_threshold(local, -1, hw->wiphy->rts_threshold);
1841	}
1842
1843	/* reset coverage class */
1844	drv_set_coverage_class(local, -1, hw->wiphy->coverage_class);
1845
1846	ieee80211_led_radio(local, true);
1847	ieee80211_mod_tpt_led_trig(local,
1848				   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1849
1850	/* add interfaces */
1851	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);
1852	if (sdata && ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) {
1853		/* in HW restart it exists already */
1854		WARN_ON(local->resuming);
1855		res = drv_add_interface(local, sdata);
1856		if (WARN_ON(res)) {
1857			RCU_INIT_POINTER(local->monitor_sdata, NULL);
1858			synchronize_net();
1859			kfree(sdata);
1860		}
1861	}
1862
1863	list_for_each_entry(sdata, &local->interfaces, list) {
1864		if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
1865		    !ieee80211_hw_check(&local->hw, NO_VIRTUAL_MONITOR))
1866			continue;
1867		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1868		    ieee80211_sdata_running(sdata)) {
1869			res = drv_add_interface(local, sdata);
1870			if (WARN_ON(res))
1871				break;
1872		}
1873	}
1874
1875	/* If adding any of the interfaces failed above, roll back and
1876	 * report failure.
1877	 */
1878	if (res) {
1879		list_for_each_entry_continue_reverse(sdata, &local->interfaces,
1880						     list) {
1881			if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
1882			    !ieee80211_hw_check(&local->hw, NO_VIRTUAL_MONITOR))
1883				continue;
1884			if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1885			    ieee80211_sdata_running(sdata))
1886				drv_remove_interface(local, sdata);
1887		}
1888		ieee80211_handle_reconfig_failure(local);
1889		return res;
1890	}
1891
1892	/* add channel contexts */
1893	list_for_each_entry(ctx, &local->chanctx_list, list)
1894		if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1895			WARN_ON(drv_add_chanctx(local, ctx));
1896
1897	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);
1898	if (sdata && ieee80211_sdata_running(sdata))
1899		ieee80211_assign_chanctx(local, sdata, &sdata->deflink);
1900
1901	/* reconfigure hardware */
1902	ieee80211_hw_config(local, -1, IEEE80211_CONF_CHANGE_LISTEN_INTERVAL |
1903				       IEEE80211_CONF_CHANGE_MONITOR |
1904				       IEEE80211_CONF_CHANGE_PS |
1905				       IEEE80211_CONF_CHANGE_RETRY_LIMITS |
1906				       IEEE80211_CONF_CHANGE_IDLE);
1907
1908	ieee80211_configure_filter(local);
1909
1910	/* Finally also reconfigure all the BSS information */
1911	list_for_each_entry(sdata, &local->interfaces, list) {
1912		/* common change flags for all interface types - link only */
1913		u64 changed = BSS_CHANGED_ERP_CTS_PROT |
1914			      BSS_CHANGED_ERP_PREAMBLE |
1915			      BSS_CHANGED_ERP_SLOT |
1916			      BSS_CHANGED_HT |
1917			      BSS_CHANGED_BASIC_RATES |
1918			      BSS_CHANGED_BEACON_INT |
1919			      BSS_CHANGED_BSSID |
1920			      BSS_CHANGED_CQM |
1921			      BSS_CHANGED_QOS |
1922			      BSS_CHANGED_TXPOWER |
1923			      BSS_CHANGED_MCAST_RATE;
1924		struct ieee80211_link_data *link = NULL;
1925		unsigned int link_id;
1926		u32 active_links = 0;
1927
1928		if (!ieee80211_sdata_running(sdata))
1929			continue;
1930
1931		if (ieee80211_vif_is_mld(&sdata->vif)) {
1932			struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS] = {
1933				[0] = &sdata->vif.bss_conf,
1934			};
1935
1936			if (sdata->vif.type == NL80211_IFTYPE_STATION) {
1937				/* start with a single active link */
1938				active_links = sdata->vif.active_links;
1939				link_id = ffs(active_links) - 1;
1940				sdata->vif.active_links = BIT(link_id);
1941			}
1942
1943			drv_change_vif_links(local, sdata, 0,
1944					     sdata->vif.active_links,
1945					     old);
1946		}
1947
1948		sdata->restart_active_links = active_links;
1949
1950		for (link_id = 0;
1951		     link_id < ARRAY_SIZE(sdata->vif.link_conf);
1952		     link_id++) {
1953			if (!ieee80211_vif_link_active(&sdata->vif, link_id))
1954				continue;
1955
1956			link = sdata_dereference(sdata->link[link_id], sdata);
1957			if (!link)
1958				continue;
1959
1960			ieee80211_assign_chanctx(local, sdata, link);
1961		}
1962
1963		switch (sdata->vif.type) {
1964		case NL80211_IFTYPE_AP_VLAN:
1965		case NL80211_IFTYPE_MONITOR:
1966			break;
1967		case NL80211_IFTYPE_ADHOC:
1968			if (sdata->vif.cfg.ibss_joined)
1969				WARN_ON(drv_join_ibss(local, sdata));
1970			fallthrough;
1971		default:
1972			ieee80211_reconfig_stations(sdata);
1973			fallthrough;
1974		case NL80211_IFTYPE_AP: /* AP stations are handled later */
1975			for (i = 0; i < IEEE80211_NUM_ACS; i++)
1976				drv_conf_tx(local, &sdata->deflink, i,
1977					    &sdata->deflink.tx_conf[i]);
1978			break;
1979		}
1980
1981		if (sdata->vif.bss_conf.mu_mimo_owner)
1982			changed |= BSS_CHANGED_MU_GROUPS;
1983
1984		if (!ieee80211_vif_is_mld(&sdata->vif))
1985			changed |= BSS_CHANGED_IDLE;
1986
1987		switch (sdata->vif.type) {
1988		case NL80211_IFTYPE_STATION:
1989			if (!ieee80211_vif_is_mld(&sdata->vif)) {
1990				changed |= BSS_CHANGED_ASSOC |
1991					   BSS_CHANGED_ARP_FILTER |
1992					   BSS_CHANGED_PS;
1993
1994				/* Re-send beacon info report to the driver */
1995				if (sdata->deflink.u.mgd.have_beacon)
1996					changed |= BSS_CHANGED_BEACON_INFO;
1997
1998				if (sdata->vif.bss_conf.max_idle_period ||
1999				    sdata->vif.bss_conf.protected_keep_alive)
2000					changed |= BSS_CHANGED_KEEP_ALIVE;
2001
2002				ieee80211_bss_info_change_notify(sdata,
2003								 changed);
2004			} else if (!WARN_ON(!link)) {
2005				ieee80211_link_info_change_notify(sdata, link,
2006								  changed);
2007				changed = BSS_CHANGED_ASSOC |
2008					  BSS_CHANGED_IDLE |
2009					  BSS_CHANGED_PS |
2010					  BSS_CHANGED_ARP_FILTER;
2011				ieee80211_vif_cfg_change_notify(sdata, changed);
2012			}
2013			break;
2014		case NL80211_IFTYPE_OCB:
2015			changed |= BSS_CHANGED_OCB;
2016			ieee80211_bss_info_change_notify(sdata, changed);
2017			break;
2018		case NL80211_IFTYPE_ADHOC:
2019			changed |= BSS_CHANGED_IBSS;
2020			fallthrough;
2021		case NL80211_IFTYPE_AP:
2022			changed |= BSS_CHANGED_P2P_PS;
2023
2024			if (ieee80211_vif_is_mld(&sdata->vif))
2025				ieee80211_vif_cfg_change_notify(sdata,
2026								BSS_CHANGED_SSID);
2027			else
2028				changed |= BSS_CHANGED_SSID;
2029
2030			if (sdata->vif.bss_conf.ftm_responder == 1 &&
2031			    wiphy_ext_feature_isset(sdata->local->hw.wiphy,
2032					NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
2033				changed |= BSS_CHANGED_FTM_RESPONDER;
2034
2035			if (sdata->vif.type == NL80211_IFTYPE_AP) {
2036				changed |= BSS_CHANGED_AP_PROBE_RESP;
2037
2038				if (ieee80211_vif_is_mld(&sdata->vif)) {
2039					ieee80211_reconfig_ap_links(local,
2040								    sdata,
2041								    changed);
2042					break;
2043				}
2044
2045				if (rcu_access_pointer(sdata->deflink.u.ap.beacon))
2046					drv_start_ap(local, sdata,
2047						     sdata->deflink.conf);
2048			}
2049			fallthrough;
2050		case NL80211_IFTYPE_MESH_POINT:
2051			if (sdata->vif.bss_conf.enable_beacon) {
2052				changed |= BSS_CHANGED_BEACON |
2053					   BSS_CHANGED_BEACON_ENABLED;
2054				ieee80211_bss_info_change_notify(sdata, changed);
2055			}
2056			break;
2057		case NL80211_IFTYPE_NAN:
2058			res = ieee80211_reconfig_nan(sdata);
2059			if (res < 0) {
2060				ieee80211_handle_reconfig_failure(local);
2061				return res;
2062			}
2063			break;
2064		case NL80211_IFTYPE_AP_VLAN:
2065		case NL80211_IFTYPE_MONITOR:
2066		case NL80211_IFTYPE_P2P_DEVICE:
2067			/* nothing to do */
2068			break;
2069		case NL80211_IFTYPE_UNSPECIFIED:
2070		case NUM_NL80211_IFTYPES:
2071		case NL80211_IFTYPE_P2P_CLIENT:
2072		case NL80211_IFTYPE_P2P_GO:
2073		case NL80211_IFTYPE_WDS:
2074			WARN_ON(1);
2075			break;
2076		}
2077	}
2078
2079	ieee80211_recalc_ps(local);
2080
2081	/*
2082	 * The sta might be in psm against the ap (e.g. because
2083	 * this was the state before a hw restart), so we
2084	 * explicitly send a null packet in order to make sure
2085	 * it'll sync against the ap (and get out of psm).
2086	 */
2087	if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
2088		list_for_each_entry(sdata, &local->interfaces, list) {
2089			if (sdata->vif.type != NL80211_IFTYPE_STATION)
2090				continue;
2091			if (!sdata->u.mgd.associated)
2092				continue;
2093
2094			ieee80211_send_nullfunc(local, sdata, false);
2095		}
2096	}
2097
2098	/* APs are now beaconing, add back stations */
2099	list_for_each_entry(sdata, &local->interfaces, list) {
2100		if (!ieee80211_sdata_running(sdata))
2101			continue;
2102
2103		switch (sdata->vif.type) {
2104		case NL80211_IFTYPE_AP_VLAN:
2105		case NL80211_IFTYPE_AP:
2106			ieee80211_reconfig_stations(sdata);
2107			break;
2108		default:
2109			break;
2110		}
2111	}
2112
2113	/* add back keys */
2114	list_for_each_entry(sdata, &local->interfaces, list)
2115		ieee80211_reenable_keys(sdata);
2116
2117	/* re-enable multi-link for client interfaces */
2118	list_for_each_entry(sdata, &local->interfaces, list) {
2119		if (sdata->restart_active_links)
2120			ieee80211_set_active_links(&sdata->vif,
2121						   sdata->restart_active_links);
2122		/*
2123		 * If a link switch was scheduled before the restart, and ran
2124		 * before reconfig, it will do nothing, so re-schedule.
2125		 */
2126		if (sdata->desired_active_links)
2127			wiphy_work_queue(sdata->local->hw.wiphy,
2128					 &sdata->activate_links_work);
2129	}
2130
2131	/* Reconfigure sched scan if it was interrupted by FW restart */
2132	sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
2133						lockdep_is_held(&local->hw.wiphy->mtx));
2134	sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
2135						lockdep_is_held(&local->hw.wiphy->mtx));
2136	if (sched_scan_sdata && sched_scan_req)
2137		/*
2138		 * Sched scan stopped, but we don't want to report it. Instead,
2139		 * we're trying to reschedule. However, if more than one scan
2140		 * plan was set, we cannot reschedule since we don't know which
2141		 * scan plan was currently running (and some scan plans may have
2142		 * already finished).
2143		 */
2144		if (sched_scan_req->n_scan_plans > 1 ||
2145		    __ieee80211_request_sched_scan_start(sched_scan_sdata,
2146							 sched_scan_req)) {
2147			RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
2148			RCU_INIT_POINTER(local->sched_scan_req, NULL);
2149			sched_scan_stopped = true;
2150		}
2151
2152	if (sched_scan_stopped)
2153		cfg80211_sched_scan_stopped_locked(local->hw.wiphy, 0);
2154
2155 wake_up:
2156	/*
2157	 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
2158	 * sessions can be established after a resume.
2159	 *
2160	 * Also tear down aggregation sessions since reconfiguring
2161	 * them in a hardware restart scenario is not easily done
2162	 * right now, and the hardware will have lost information
2163	 * about the sessions, but we and the AP still think they
2164	 * are active. This is really a workaround though.
2165	 */
2166	if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
2167		list_for_each_entry(sta, &local->sta_list, list) {
2168			if (!local->resuming)
2169				ieee80211_sta_tear_down_BA_sessions(
2170						sta, AGG_STOP_LOCAL_REQUEST);
2171			clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
2172		}
2173	}
2174
2175	/*
2176	 * If this is for hw restart things are still running.
2177	 * We may want to change that later, however.
2178	 */
2179	if (local->open_count && (!suspended || reconfig_due_to_wowlan))
2180		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
2181
2182	if (local->in_reconfig) {
2183		in_reconfig = local->in_reconfig;
2184		local->in_reconfig = false;
2185		barrier();
2186
2187		ieee80211_reconfig_roc(local);
2188
2189		/* Requeue all works */
2190		list_for_each_entry(sdata, &local->interfaces, list) {
2191			if (ieee80211_sdata_running(sdata))
2192				wiphy_work_queue(local->hw.wiphy, &sdata->work);
2193		}
2194	}
2195
2196	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
2197					IEEE80211_QUEUE_STOP_REASON_SUSPEND,
2198					false);
2199
2200	if (in_reconfig) {
2201		list_for_each_entry(sdata, &local->interfaces, list) {
2202			if (!ieee80211_sdata_running(sdata))
2203				continue;
2204			if (sdata->vif.type == NL80211_IFTYPE_STATION)
2205				ieee80211_sta_restart(sdata);
2206		}
2207	}
2208
2209	/* Passing NULL means an interface is picked for configuration */
2210	if (local->virt_monitors > 0 &&
2211	    local->virt_monitors == local->open_count)
2212		ieee80211_add_virtual_monitor(local, NULL);
2213
2214	if (!suspended)
2215		return 0;
2216
2217#ifdef CONFIG_PM
2218	/* first set suspended false, then resuming */
2219	local->suspended = false;
2220	mb();
2221	local->resuming = false;
2222
2223	ieee80211_flush_completed_scan(local, false);
2224
2225	if (local->open_count && !reconfig_due_to_wowlan)
2226		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
2227
2228	list_for_each_entry(sdata, &local->interfaces, list) {
2229		if (!ieee80211_sdata_running(sdata))
2230			continue;
2231		if (sdata->vif.type == NL80211_IFTYPE_STATION)
2232			ieee80211_sta_restart(sdata);
2233	}
2234
2235	mod_timer(&local->sta_cleanup, jiffies + 1);
2236#else
2237	WARN_ON(1);
2238#endif
2239
2240	return 0;
2241}
2242
2243static void ieee80211_reconfig_disconnect(struct ieee80211_vif *vif, u8 flag)
2244{
2245	struct ieee80211_sub_if_data *sdata;
2246	struct ieee80211_local *local;
2247	struct ieee80211_key *key;
2248
2249	if (WARN_ON(!vif))
2250		return;
2251
2252	sdata = vif_to_sdata(vif);
2253	local = sdata->local;
2254
2255	lockdep_assert_wiphy(local->hw.wiphy);
2256
2257	if (WARN_ON(flag & IEEE80211_SDATA_DISCONNECT_RESUME &&
2258		    !local->resuming))
2259		return;
2260
2261	if (WARN_ON(flag & IEEE80211_SDATA_DISCONNECT_HW_RESTART &&
2262		    !local->in_reconfig))
2263		return;
2264
2265	if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2266		return;
2267
2268	sdata->flags |= flag;
2269
2270	list_for_each_entry(key, &sdata->key_list, list)
2271		key->flags |= KEY_FLAG_TAINTED;
2272}
2273
2274void ieee80211_hw_restart_disconnect(struct ieee80211_vif *vif)
2275{
2276	ieee80211_reconfig_disconnect(vif, IEEE80211_SDATA_DISCONNECT_HW_RESTART);
2277}
2278EXPORT_SYMBOL_GPL(ieee80211_hw_restart_disconnect);
2279
2280void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
2281{
2282	ieee80211_reconfig_disconnect(vif, IEEE80211_SDATA_DISCONNECT_RESUME);
2283}
2284EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
2285
2286void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata,
2287			   struct ieee80211_link_data *link)
2288{
2289	struct ieee80211_local *local = sdata->local;
2290	struct ieee80211_chanctx_conf *chanctx_conf;
2291	struct ieee80211_chanctx *chanctx;
2292
2293	lockdep_assert_wiphy(local->hw.wiphy);
2294
2295	chanctx_conf = rcu_dereference_protected(link->conf->chanctx_conf,
2296						 lockdep_is_held(&local->hw.wiphy->mtx));
2297
2298	/*
2299	 * This function can be called from a work, thus it may be possible
2300	 * that the chanctx_conf is removed (due to a disconnection, for
2301	 * example).
2302	 * So nothing should be done in such case.
2303	 */
2304	if (!chanctx_conf)
2305		return;
2306
2307	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2308	ieee80211_recalc_smps_chanctx(local, chanctx);
2309}
2310
2311void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata,
2312				  int link_id)
2313{
2314	struct ieee80211_local *local = sdata->local;
2315	struct ieee80211_chanctx_conf *chanctx_conf;
2316	struct ieee80211_chanctx *chanctx;
2317	int i;
2318
2319	lockdep_assert_wiphy(local->hw.wiphy);
2320
2321	for (i = 0; i < ARRAY_SIZE(sdata->vif.link_conf); i++) {
2322		struct ieee80211_bss_conf *bss_conf;
2323
2324		if (link_id >= 0 && link_id != i)
2325			continue;
2326
2327		rcu_read_lock();
2328		bss_conf = rcu_dereference(sdata->vif.link_conf[i]);
2329		if (!bss_conf) {
2330			rcu_read_unlock();
2331			continue;
2332		}
2333
2334		chanctx_conf = rcu_dereference_protected(bss_conf->chanctx_conf,
2335							 lockdep_is_held(&local->hw.wiphy->mtx));
2336		/*
2337		 * Since we hold the wiphy mutex (checked above)
2338		 * we can take the chanctx_conf pointer out of the
2339		 * RCU critical section, it cannot go away without
2340		 * the mutex. Just the way we reached it could - in
2341		 * theory - go away, but we don't really care and
2342		 * it really shouldn't happen anyway.
2343		 */
2344		rcu_read_unlock();
2345
2346		if (!chanctx_conf)
2347			return;
2348
2349		chanctx = container_of(chanctx_conf, struct ieee80211_chanctx,
2350				       conf);
2351		ieee80211_recalc_chanctx_min_def(local, chanctx);
2352	}
2353}
2354
2355size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
2356{
2357	size_t pos = offset;
2358
2359	while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
2360		pos += 2 + ies[pos + 1];
2361
2362	return pos;
2363}
2364
2365u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2366			      u16 cap)
2367{
2368	__le16 tmp;
2369
2370	*pos++ = WLAN_EID_HT_CAPABILITY;
2371	*pos++ = sizeof(struct ieee80211_ht_cap);
2372	memset(pos, 0, sizeof(struct ieee80211_ht_cap));
2373
2374	/* capability flags */
2375	tmp = cpu_to_le16(cap);
2376	memcpy(pos, &tmp, sizeof(u16));
2377	pos += sizeof(u16);
2378
2379	/* AMPDU parameters */
2380	*pos++ = ht_cap->ampdu_factor |
2381		 (ht_cap->ampdu_density <<
2382			IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
2383
2384	/* MCS set */
2385	memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
2386	pos += sizeof(ht_cap->mcs);
2387
2388	/* extended capabilities */
2389	pos += sizeof(__le16);
2390
2391	/* BF capabilities */
2392	pos += sizeof(__le32);
2393
2394	/* antenna selection */
2395	pos += sizeof(u8);
2396
2397	return pos;
2398}
2399
2400u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2401			       u32 cap)
2402{
2403	__le32 tmp;
2404
2405	*pos++ = WLAN_EID_VHT_CAPABILITY;
2406	*pos++ = sizeof(struct ieee80211_vht_cap);
2407	memset(pos, 0, sizeof(struct ieee80211_vht_cap));
2408
2409	/* capability flags */
2410	tmp = cpu_to_le32(cap);
2411	memcpy(pos, &tmp, sizeof(u32));
2412	pos += sizeof(u32);
2413
2414	/* VHT MCS set */
2415	memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
2416	pos += sizeof(vht_cap->vht_mcs);
2417
2418	return pos;
2419}
2420
2421/* this may return more than ieee80211_put_he_6ghz_cap() will need */
2422u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata)
2423{
2424	const struct ieee80211_sta_he_cap *he_cap;
2425	struct ieee80211_supported_band *sband;
2426	u8 n;
2427
2428	sband = ieee80211_get_sband(sdata);
2429	if (!sband)
2430		return 0;
2431
2432	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
2433	if (!he_cap)
2434		return 0;
2435
2436	n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2437	return 2 + 1 +
2438	       sizeof(he_cap->he_cap_elem) + n +
2439	       ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2440				     he_cap->he_cap_elem.phy_cap_info);
2441}
2442
2443static void
2444ieee80211_get_adjusted_he_cap(const struct ieee80211_conn_settings *conn,
2445			      const struct ieee80211_sta_he_cap *he_cap,
2446			      struct ieee80211_he_cap_elem *elem)
2447{
2448	u8 ru_limit, max_ru;
2449
2450	*elem = he_cap->he_cap_elem;
2451
2452	switch (conn->bw_limit) {
2453	case IEEE80211_CONN_BW_LIMIT_20:
2454		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_242;
2455		break;
2456	case IEEE80211_CONN_BW_LIMIT_40:
2457		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_484;
2458		break;
2459	case IEEE80211_CONN_BW_LIMIT_80:
2460		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_996;
2461		break;
2462	default:
2463		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_2x996;
2464		break;
2465	}
2466
2467	max_ru = elem->phy_cap_info[8] & IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_MASK;
2468	max_ru = min(max_ru, ru_limit);
2469	elem->phy_cap_info[8] &= ~IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_MASK;
2470	elem->phy_cap_info[8] |= max_ru;
2471
2472	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_40) {
2473		elem->phy_cap_info[0] &=
2474			~(IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
2475			  IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G);
2476		elem->phy_cap_info[9] &=
2477			~IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM;
2478	}
2479
2480	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_160) {
2481		elem->phy_cap_info[0] &=
2482			~(IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
2483			  IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G);
2484		elem->phy_cap_info[5] &=
2485			~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK;
2486		elem->phy_cap_info[7] &=
2487			~(IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
2488			  IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ);
2489	}
2490}
2491
2492int ieee80211_put_he_cap(struct sk_buff *skb,
2493			 struct ieee80211_sub_if_data *sdata,
2494			 const struct ieee80211_supported_band *sband,
2495			 const struct ieee80211_conn_settings *conn)
2496{
2497	const struct ieee80211_sta_he_cap *he_cap;
2498	struct ieee80211_he_cap_elem elem;
2499	u8 *len;
2500	u8 n;
2501	u8 ie_len;
2502
2503	if (!conn)
2504		conn = &ieee80211_conn_settings_unlimited;
2505
2506	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
2507	if (!he_cap)
2508		return 0;
2509
2510	/* modify on stack first to calculate 'n' and 'ie_len' correctly */
2511	ieee80211_get_adjusted_he_cap(conn, he_cap, &elem);
2512
2513	n = ieee80211_he_mcs_nss_size(&elem);
2514	ie_len = 2 + 1 +
2515		 sizeof(he_cap->he_cap_elem) + n +
2516		 ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2517				       he_cap->he_cap_elem.phy_cap_info);
2518
2519	if (skb_tailroom(skb) < ie_len)
2520		return -ENOBUFS;
2521
2522	skb_put_u8(skb, WLAN_EID_EXTENSION);
2523	len = skb_put(skb, 1); /* We'll set the size later below */
2524	skb_put_u8(skb, WLAN_EID_EXT_HE_CAPABILITY);
2525
2526	/* Fixed data */
2527	skb_put_data(skb, &elem, sizeof(elem));
2528
2529	skb_put_data(skb, &he_cap->he_mcs_nss_supp, n);
2530
2531	/* Check if PPE Threshold should be present */
2532	if ((he_cap->he_cap_elem.phy_cap_info[6] &
2533	     IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
2534		goto end;
2535
2536	/*
2537	 * Calculate how many PPET16/PPET8 pairs are to come. Algorithm:
2538	 * (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK)
2539	 */
2540	n = hweight8(he_cap->ppe_thres[0] &
2541		     IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
2542	n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >>
2543		   IEEE80211_PPE_THRES_NSS_POS));
2544
2545	/*
2546	 * Each pair is 6 bits, and we need to add the 7 "header" bits to the
2547	 * total size.
2548	 */
2549	n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
2550	n = DIV_ROUND_UP(n, 8);
2551
2552	/* Copy PPE Thresholds */
2553	skb_put_data(skb, &he_cap->ppe_thres, n);
2554
2555end:
2556	*len = skb_tail_pointer(skb) - len - 1;
2557	return 0;
2558}
2559
2560int ieee80211_put_reg_conn(struct sk_buff *skb,
2561			   enum ieee80211_channel_flags flags)
2562{
2563	u8 reg_conn = IEEE80211_REG_CONN_LPI_VALID |
2564		      IEEE80211_REG_CONN_LPI_VALUE |
2565		      IEEE80211_REG_CONN_SP_VALID;
2566
2567	if (!(flags & IEEE80211_CHAN_NO_6GHZ_AFC_CLIENT))
2568		reg_conn |= IEEE80211_REG_CONN_SP_VALUE;
2569
2570	skb_put_u8(skb, WLAN_EID_EXTENSION);
2571	skb_put_u8(skb, 1 + sizeof(reg_conn));
2572	skb_put_u8(skb, WLAN_EID_EXT_NON_AP_STA_REG_CON);
2573	skb_put_u8(skb, reg_conn);
2574	return 0;
2575}
2576
2577int ieee80211_put_he_6ghz_cap(struct sk_buff *skb,
2578			      struct ieee80211_sub_if_data *sdata,
2579			      enum ieee80211_smps_mode smps_mode)
2580{
2581	struct ieee80211_supported_band *sband;
2582	const struct ieee80211_sband_iftype_data *iftd;
2583	enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
2584	__le16 cap;
2585
2586	if (!cfg80211_any_usable_channels(sdata->local->hw.wiphy,
2587					  BIT(NL80211_BAND_6GHZ),
2588					  IEEE80211_CHAN_NO_HE))
2589		return 0;
2590
2591	sband = sdata->local->hw.wiphy->bands[NL80211_BAND_6GHZ];
2592
2593	iftd = ieee80211_get_sband_iftype_data(sband, iftype);
2594	if (!iftd)
2595		return 0;
2596
2597	/* Check for device HE 6 GHz capability before adding element */
2598	if (!iftd->he_6ghz_capa.capa)
2599		return 0;
2600
2601	cap = iftd->he_6ghz_capa.capa;
2602	cap &= cpu_to_le16(~IEEE80211_HE_6GHZ_CAP_SM_PS);
2603
2604	switch (smps_mode) {
2605	case IEEE80211_SMPS_AUTOMATIC:
2606	case IEEE80211_SMPS_NUM_MODES:
2607		WARN_ON(1);
2608		fallthrough;
2609	case IEEE80211_SMPS_OFF:
2610		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED,
2611					IEEE80211_HE_6GHZ_CAP_SM_PS);
2612		break;
2613	case IEEE80211_SMPS_STATIC:
2614		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC,
2615					IEEE80211_HE_6GHZ_CAP_SM_PS);
2616		break;
2617	case IEEE80211_SMPS_DYNAMIC:
2618		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC,
2619					IEEE80211_HE_6GHZ_CAP_SM_PS);
2620		break;
2621	}
2622
2623	if (skb_tailroom(skb) < 2 + 1 + sizeof(cap))
2624		return -ENOBUFS;
2625
2626	skb_put_u8(skb, WLAN_EID_EXTENSION);
2627	skb_put_u8(skb, 1 + sizeof(cap));
2628	skb_put_u8(skb, WLAN_EID_EXT_HE_6GHZ_CAPA);
2629	skb_put_data(skb, &cap, sizeof(cap));
2630	return 0;
2631}
2632
2633u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2634			       const struct cfg80211_chan_def *chandef,
2635			       u16 prot_mode, bool rifs_mode)
2636{
2637	struct ieee80211_ht_operation *ht_oper;
2638	/* Build HT Information */
2639	*pos++ = WLAN_EID_HT_OPERATION;
2640	*pos++ = sizeof(struct ieee80211_ht_operation);
2641	ht_oper = (struct ieee80211_ht_operation *)pos;
2642	ht_oper->primary_chan = ieee80211_frequency_to_channel(
2643					chandef->chan->center_freq);
2644	switch (chandef->width) {
2645	case NL80211_CHAN_WIDTH_160:
2646	case NL80211_CHAN_WIDTH_80P80:
2647	case NL80211_CHAN_WIDTH_80:
2648	case NL80211_CHAN_WIDTH_40:
2649		if (chandef->center_freq1 > chandef->chan->center_freq)
2650			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2651		else
2652			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2653		break;
2654	case NL80211_CHAN_WIDTH_320:
2655		/* HT information element should not be included on 6GHz */
2656		WARN_ON(1);
2657		return pos;
2658	default:
2659		ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
2660		break;
2661	}
2662	if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
2663	    chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
2664	    chandef->width != NL80211_CHAN_WIDTH_20)
2665		ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
2666
2667	if (rifs_mode)
2668		ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
2669
2670	ht_oper->operation_mode = cpu_to_le16(prot_mode);
2671	ht_oper->stbc_param = 0x0000;
2672
2673	/* It seems that Basic MCS set and Supported MCS set
2674	   are identical for the first 10 bytes */
2675	memset(&ht_oper->basic_set, 0, 16);
2676	memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
2677
2678	return pos + sizeof(struct ieee80211_ht_operation);
2679}
2680
2681void ieee80211_ie_build_wide_bw_cs(u8 *pos,
2682				   const struct cfg80211_chan_def *chandef)
2683{
2684	*pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH;	/* EID */
2685	*pos++ = 3;					/* IE length */
2686	/* New channel width */
2687	switch (chandef->width) {
2688	case NL80211_CHAN_WIDTH_80:
2689		*pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
2690		break;
2691	case NL80211_CHAN_WIDTH_160:
2692		*pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
2693		break;
2694	case NL80211_CHAN_WIDTH_80P80:
2695		*pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
2696		break;
2697	case NL80211_CHAN_WIDTH_320:
2698		/* The behavior is not defined for 320 MHz channels */
2699		WARN_ON(1);
2700		fallthrough;
2701	default:
2702		*pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
2703	}
2704
2705	/* new center frequency segment 0 */
2706	*pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
2707	/* new center frequency segment 1 */
2708	if (chandef->center_freq2)
2709		*pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
2710	else
2711		*pos++ = 0;
2712}
2713
2714u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2715				const struct cfg80211_chan_def *chandef)
2716{
2717	struct ieee80211_vht_operation *vht_oper;
2718
2719	*pos++ = WLAN_EID_VHT_OPERATION;
2720	*pos++ = sizeof(struct ieee80211_vht_operation);
2721	vht_oper = (struct ieee80211_vht_operation *)pos;
2722	vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
2723							chandef->center_freq1);
2724	if (chandef->center_freq2)
2725		vht_oper->center_freq_seg1_idx =
2726			ieee80211_frequency_to_channel(chandef->center_freq2);
2727	else
2728		vht_oper->center_freq_seg1_idx = 0x00;
2729
2730	switch (chandef->width) {
2731	case NL80211_CHAN_WIDTH_160:
2732		/*
2733		 * Convert 160 MHz channel width to new style as interop
2734		 * workaround.
2735		 */
2736		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2737		vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
2738		if (chandef->chan->center_freq < chandef->center_freq1)
2739			vht_oper->center_freq_seg0_idx -= 8;
2740		else
2741			vht_oper->center_freq_seg0_idx += 8;
2742		break;
2743	case NL80211_CHAN_WIDTH_80P80:
2744		/*
2745		 * Convert 80+80 MHz channel width to new style as interop
2746		 * workaround.
2747		 */
2748		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2749		break;
2750	case NL80211_CHAN_WIDTH_80:
2751		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2752		break;
2753	case NL80211_CHAN_WIDTH_320:
2754		/* VHT information element should not be included on 6GHz */
2755		WARN_ON(1);
2756		return pos;
2757	default:
2758		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
2759		break;
2760	}
2761
2762	/* don't require special VHT peer rates */
2763	vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
2764
2765	return pos + sizeof(struct ieee80211_vht_operation);
2766}
2767
2768u8 *ieee80211_ie_build_he_oper(u8 *pos, const struct cfg80211_chan_def *chandef)
2769{
2770	struct ieee80211_he_operation *he_oper;
2771	struct ieee80211_he_6ghz_oper *he_6ghz_op;
2772	struct cfg80211_chan_def he_chandef;
2773	u32 he_oper_params;
2774	u8 ie_len = 1 + sizeof(struct ieee80211_he_operation);
2775
2776	if (chandef->chan->band == NL80211_BAND_6GHZ)
2777		ie_len += sizeof(struct ieee80211_he_6ghz_oper);
2778
2779	*pos++ = WLAN_EID_EXTENSION;
2780	*pos++ = ie_len;
2781	*pos++ = WLAN_EID_EXT_HE_OPERATION;
2782
2783	he_oper_params = 0;
2784	he_oper_params |= u32_encode_bits(1023, /* disabled */
2785				IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
2786	he_oper_params |= u32_encode_bits(1,
2787				IEEE80211_HE_OPERATION_ER_SU_DISABLE);
2788	he_oper_params |= u32_encode_bits(1,
2789				IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED);
2790	if (chandef->chan->band == NL80211_BAND_6GHZ)
2791		he_oper_params |= u32_encode_bits(1,
2792				IEEE80211_HE_OPERATION_6GHZ_OP_INFO);
2793
2794	he_oper = (struct ieee80211_he_operation *)pos;
2795	he_oper->he_oper_params = cpu_to_le32(he_oper_params);
2796
2797	/* don't require special HE peer rates */
2798	he_oper->he_mcs_nss_set = cpu_to_le16(0xffff);
2799	pos += sizeof(struct ieee80211_he_operation);
2800
2801	if (chandef->chan->band != NL80211_BAND_6GHZ)
2802		goto out;
2803
2804	cfg80211_chandef_create(&he_chandef, chandef->chan, NL80211_CHAN_NO_HT);
2805	he_chandef.center_freq1 = chandef->center_freq1;
2806	he_chandef.center_freq2 = chandef->center_freq2;
2807	he_chandef.width = chandef->width;
2808
2809	/* TODO add VHT operational */
2810	he_6ghz_op = (struct ieee80211_he_6ghz_oper *)pos;
2811	he_6ghz_op->minrate = 6; /* 6 Mbps */
2812	he_6ghz_op->primary =
2813		ieee80211_frequency_to_channel(he_chandef.chan->center_freq);
2814	he_6ghz_op->ccfs0 =
2815		ieee80211_frequency_to_channel(he_chandef.center_freq1);
2816	if (he_chandef.center_freq2)
2817		he_6ghz_op->ccfs1 =
2818			ieee80211_frequency_to_channel(he_chandef.center_freq2);
2819	else
2820		he_6ghz_op->ccfs1 = 0;
2821
2822	switch (he_chandef.width) {
2823	case NL80211_CHAN_WIDTH_320:
2824		/* Downgrade EHT 320 MHz BW to 160 MHz for HE and set new
2825		 * center_freq1
2826		 */
2827		ieee80211_chandef_downgrade(&he_chandef, NULL);
2828		he_6ghz_op->ccfs0 =
2829			ieee80211_frequency_to_channel(he_chandef.center_freq1);
2830		fallthrough;
2831	case NL80211_CHAN_WIDTH_160:
2832		/* Convert 160 MHz channel width to new style as interop
2833		 * workaround.
2834		 */
2835		he_6ghz_op->control =
2836			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
2837		he_6ghz_op->ccfs1 = he_6ghz_op->ccfs0;
2838		if (he_chandef.chan->center_freq < he_chandef.center_freq1)
2839			he_6ghz_op->ccfs0 -= 8;
2840		else
2841			he_6ghz_op->ccfs0 += 8;
2842		fallthrough;
2843	case NL80211_CHAN_WIDTH_80P80:
2844		he_6ghz_op->control =
2845			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
2846		break;
2847	case NL80211_CHAN_WIDTH_80:
2848		he_6ghz_op->control =
2849			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ;
2850		break;
2851	case NL80211_CHAN_WIDTH_40:
2852		he_6ghz_op->control =
2853			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ;
2854		break;
2855	default:
2856		he_6ghz_op->control =
2857			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ;
2858		break;
2859	}
2860
2861	pos += sizeof(struct ieee80211_he_6ghz_oper);
2862
2863out:
2864	return pos;
2865}
2866
2867u8 *ieee80211_ie_build_eht_oper(u8 *pos, const struct cfg80211_chan_def *chandef,
2868				const struct ieee80211_sta_eht_cap *eht_cap)
2869
2870{
2871	const struct ieee80211_eht_mcs_nss_supp_20mhz_only *eht_mcs_nss =
2872					&eht_cap->eht_mcs_nss_supp.only_20mhz;
2873	struct ieee80211_eht_operation *eht_oper;
2874	struct ieee80211_eht_operation_info *eht_oper_info;
2875	u8 eht_oper_len = offsetof(struct ieee80211_eht_operation, optional);
2876	u8 eht_oper_info_len =
2877		offsetof(struct ieee80211_eht_operation_info, optional);
2878	u8 chan_width = 0;
2879
2880	*pos++ = WLAN_EID_EXTENSION;
2881	*pos++ = 1 + eht_oper_len + eht_oper_info_len;
2882	*pos++ = WLAN_EID_EXT_EHT_OPERATION;
2883
2884	eht_oper = (struct ieee80211_eht_operation *)pos;
2885
2886	memcpy(&eht_oper->basic_mcs_nss, eht_mcs_nss, sizeof(*eht_mcs_nss));
2887	eht_oper->params |= IEEE80211_EHT_OPER_INFO_PRESENT;
2888	pos += eht_oper_len;
2889
2890	eht_oper_info =
2891		(struct ieee80211_eht_operation_info *)eht_oper->optional;
2892
2893	eht_oper_info->ccfs0 =
2894		ieee80211_frequency_to_channel(chandef->center_freq1);
2895	if (chandef->center_freq2)
2896		eht_oper_info->ccfs1 =
2897			ieee80211_frequency_to_channel(chandef->center_freq2);
2898	else
2899		eht_oper_info->ccfs1 = 0;
2900
2901	switch (chandef->width) {
2902	case NL80211_CHAN_WIDTH_320:
2903		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_320MHZ;
2904		eht_oper_info->ccfs1 = eht_oper_info->ccfs0;
2905		if (chandef->chan->center_freq < chandef->center_freq1)
2906			eht_oper_info->ccfs0 -= 16;
2907		else
2908			eht_oper_info->ccfs0 += 16;
2909		break;
2910	case NL80211_CHAN_WIDTH_160:
2911		eht_oper_info->ccfs1 = eht_oper_info->ccfs0;
2912		if (chandef->chan->center_freq < chandef->center_freq1)
2913			eht_oper_info->ccfs0 -= 8;
2914		else
2915			eht_oper_info->ccfs0 += 8;
2916		fallthrough;
2917	case NL80211_CHAN_WIDTH_80P80:
2918		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_160MHZ;
2919		break;
2920	case NL80211_CHAN_WIDTH_80:
2921		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_80MHZ;
2922		break;
2923	case NL80211_CHAN_WIDTH_40:
2924		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_40MHZ;
2925		break;
2926	default:
2927		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_20MHZ;
2928		break;
2929	}
2930	eht_oper_info->control = chan_width;
2931	pos += eht_oper_info_len;
2932
2933	/* TODO: eht_oper_info->optional */
2934
2935	return pos;
2936}
2937
2938bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
2939			       struct cfg80211_chan_def *chandef)
2940{
2941	enum nl80211_channel_type channel_type;
2942
2943	if (!ht_oper)
2944		return false;
2945
2946	switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2947	case IEEE80211_HT_PARAM_CHA_SEC_NONE:
2948		channel_type = NL80211_CHAN_HT20;
2949		break;
2950	case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2951		channel_type = NL80211_CHAN_HT40PLUS;
2952		break;
2953	case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2954		channel_type = NL80211_CHAN_HT40MINUS;
2955		break;
2956	default:
2957		return false;
2958	}
2959
2960	cfg80211_chandef_create(chandef, chandef->chan, channel_type);
2961	return true;
2962}
2963
2964bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
2965				const struct ieee80211_vht_operation *oper,
2966				const struct ieee80211_ht_operation *htop,
2967				struct cfg80211_chan_def *chandef)
2968{
2969	struct cfg80211_chan_def new = *chandef;
2970	int cf0, cf1;
2971	int ccfs0, ccfs1, ccfs2;
2972	int ccf0, ccf1;
2973	u32 vht_cap;
2974	bool support_80_80 = false;
2975	bool support_160 = false;
2976	u8 ext_nss_bw_supp = u32_get_bits(vht_cap_info,
2977					  IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
2978	u8 supp_chwidth = u32_get_bits(vht_cap_info,
2979				       IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK);
2980
2981	if (!oper || !htop)
2982		return false;
2983
2984	vht_cap = hw->wiphy->bands[chandef->chan->band]->vht_cap.cap;
2985	support_160 = (vht_cap & (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK |
2986				  IEEE80211_VHT_CAP_EXT_NSS_BW_MASK));
2987	support_80_80 = ((vht_cap &
2988			 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
2989			(vht_cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
2990			 vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
2991			((vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) >>
2992				    IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT > 1));
2993	ccfs0 = oper->center_freq_seg0_idx;
2994	ccfs1 = oper->center_freq_seg1_idx;
2995	ccfs2 = (le16_to_cpu(htop->operation_mode) &
2996				IEEE80211_HT_OP_MODE_CCFS2_MASK)
2997			>> IEEE80211_HT_OP_MODE_CCFS2_SHIFT;
2998
2999	ccf0 = ccfs0;
3000
3001	/* if not supported, parse as though we didn't understand it */
3002	if (!ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW))
3003		ext_nss_bw_supp = 0;
3004
3005	/*
3006	 * Cf. IEEE 802.11 Table 9-250
3007	 *
3008	 * We really just consider that because it's inefficient to connect
3009	 * at a higher bandwidth than we'll actually be able to use.
3010	 */
3011	switch ((supp_chwidth << 4) | ext_nss_bw_supp) {
3012	default:
3013	case 0x00:
3014		ccf1 = 0;
3015		support_160 = false;
3016		support_80_80 = false;
3017		break;
3018	case 0x01:
3019		support_80_80 = false;
3020		fallthrough;
3021	case 0x02:
3022	case 0x03:
3023		ccf1 = ccfs2;
3024		break;
3025	case 0x10:
3026		ccf1 = ccfs1;
3027		break;
3028	case 0x11:
3029	case 0x12:
3030		if (!ccfs1)
3031			ccf1 = ccfs2;
3032		else
3033			ccf1 = ccfs1;
3034		break;
3035	case 0x13:
3036	case 0x20:
3037	case 0x23:
3038		ccf1 = ccfs1;
3039		break;
3040	}
3041
3042	cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band);
3043	cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band);
3044
3045	switch (oper->chan_width) {
3046	case IEEE80211_VHT_CHANWIDTH_USE_HT:
3047		/* just use HT information directly */
3048		break;
3049	case IEEE80211_VHT_CHANWIDTH_80MHZ:
3050		new.width = NL80211_CHAN_WIDTH_80;
3051		new.center_freq1 = cf0;
3052		/* If needed, adjust based on the newer interop workaround. */
3053		if (ccf1) {
3054			unsigned int diff;
3055
3056			diff = abs(ccf1 - ccf0);
3057			if ((diff == 8) && support_160) {
3058				new.width = NL80211_CHAN_WIDTH_160;
3059				new.center_freq1 = cf1;
3060			} else if ((diff > 8) && support_80_80) {
3061				new.width = NL80211_CHAN_WIDTH_80P80;
3062				new.center_freq2 = cf1;
3063			}
3064		}
3065		break;
3066	case IEEE80211_VHT_CHANWIDTH_160MHZ:
3067		/* deprecated encoding */
3068		new.width = NL80211_CHAN_WIDTH_160;
3069		new.center_freq1 = cf0;
3070		break;
3071	case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
3072		/* deprecated encoding */
3073		new.width = NL80211_CHAN_WIDTH_80P80;
3074		new.center_freq1 = cf0;
3075		new.center_freq2 = cf1;
3076		break;
3077	default:
3078		return false;
3079	}
3080
3081	if (!cfg80211_chandef_valid(&new))
3082		return false;
3083
3084	*chandef = new;
3085	return true;
3086}
3087
3088void ieee80211_chandef_eht_oper(const struct ieee80211_eht_operation_info *info,
3089				struct cfg80211_chan_def *chandef)
3090{
3091	chandef->center_freq1 =
3092		ieee80211_channel_to_frequency(info->ccfs0,
3093					       chandef->chan->band);
3094
3095	switch (u8_get_bits(info->control,
3096			    IEEE80211_EHT_OPER_CHAN_WIDTH)) {
3097	case IEEE80211_EHT_OPER_CHAN_WIDTH_20MHZ:
3098		chandef->width = NL80211_CHAN_WIDTH_20;
3099		break;
3100	case IEEE80211_EHT_OPER_CHAN_WIDTH_40MHZ:
3101		chandef->width = NL80211_CHAN_WIDTH_40;
3102		break;
3103	case IEEE80211_EHT_OPER_CHAN_WIDTH_80MHZ:
3104		chandef->width = NL80211_CHAN_WIDTH_80;
3105		break;
3106	case IEEE80211_EHT_OPER_CHAN_WIDTH_160MHZ:
3107		chandef->width = NL80211_CHAN_WIDTH_160;
3108		chandef->center_freq1 =
3109			ieee80211_channel_to_frequency(info->ccfs1,
3110						       chandef->chan->band);
3111		break;
3112	case IEEE80211_EHT_OPER_CHAN_WIDTH_320MHZ:
3113		chandef->width = NL80211_CHAN_WIDTH_320;
3114		chandef->center_freq1 =
3115			ieee80211_channel_to_frequency(info->ccfs1,
3116						       chandef->chan->band);
3117		break;
3118	}
3119}
3120
3121bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_local *local,
3122				    const struct ieee80211_he_operation *he_oper,
3123				    const struct ieee80211_eht_operation *eht_oper,
3124				    struct cfg80211_chan_def *chandef)
3125{
3126	struct cfg80211_chan_def he_chandef = *chandef;
3127	const struct ieee80211_he_6ghz_oper *he_6ghz_oper;
3128	u32 freq;
3129
3130	if (chandef->chan->band != NL80211_BAND_6GHZ)
3131		return true;
3132
3133	if (!he_oper)
3134		return false;
3135
3136	he_6ghz_oper = ieee80211_he_6ghz_oper(he_oper);
3137	if (!he_6ghz_oper)
3138		return false;
3139
3140	/*
3141	 * The EHT operation IE does not contain the primary channel so the
3142	 * primary channel frequency should be taken from the 6 GHz operation
3143	 * information.
3144	 */
3145	freq = ieee80211_channel_to_frequency(he_6ghz_oper->primary,
3146					      NL80211_BAND_6GHZ);
3147	he_chandef.chan = ieee80211_get_channel(local->hw.wiphy, freq);
3148
3149	if (!he_chandef.chan)
3150		return false;
3151
3152	if (!eht_oper ||
3153	    !(eht_oper->params & IEEE80211_EHT_OPER_INFO_PRESENT)) {
3154		switch (u8_get_bits(he_6ghz_oper->control,
3155				    IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH)) {
3156		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ:
3157			he_chandef.width = NL80211_CHAN_WIDTH_20;
3158			break;
3159		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ:
3160			he_chandef.width = NL80211_CHAN_WIDTH_40;
3161			break;
3162		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ:
3163			he_chandef.width = NL80211_CHAN_WIDTH_80;
3164			break;
3165		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ:
3166			he_chandef.width = NL80211_CHAN_WIDTH_80;
3167			if (!he_6ghz_oper->ccfs1)
3168				break;
3169			if (abs(he_6ghz_oper->ccfs1 - he_6ghz_oper->ccfs0) == 8)
3170				he_chandef.width = NL80211_CHAN_WIDTH_160;
3171			else
3172				he_chandef.width = NL80211_CHAN_WIDTH_80P80;
3173			break;
3174		}
3175
3176		if (he_chandef.width == NL80211_CHAN_WIDTH_160) {
3177			he_chandef.center_freq1 =
3178				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3179							       NL80211_BAND_6GHZ);
3180		} else {
3181			he_chandef.center_freq1 =
3182				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0,
3183							       NL80211_BAND_6GHZ);
3184			he_chandef.center_freq2 =
3185				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3186							       NL80211_BAND_6GHZ);
3187		}
3188	} else {
3189		ieee80211_chandef_eht_oper((const void *)eht_oper->optional,
3190					   &he_chandef);
3191		he_chandef.punctured =
3192			ieee80211_eht_oper_dis_subchan_bitmap(eht_oper);
3193	}
3194
3195	if (!cfg80211_chandef_valid(&he_chandef))
3196		return false;
3197
3198	*chandef = he_chandef;
3199
3200	return true;
3201}
3202
3203bool ieee80211_chandef_s1g_oper(struct ieee80211_local *local,
3204				const struct ieee80211_s1g_oper_ie *oper,
3205				struct cfg80211_chan_def *chandef)
3206{
3207	u32 oper_khz, pri_1mhz_khz, pri_2mhz_khz;
3208
3209	if (!oper)
3210		return false;
3211
3212	switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER, oper->ch_width)) {
3213	case IEEE80211_S1G_CHANWIDTH_1MHZ:
3214		chandef->width = NL80211_CHAN_WIDTH_1;
3215		break;
3216	case IEEE80211_S1G_CHANWIDTH_2MHZ:
3217		chandef->width = NL80211_CHAN_WIDTH_2;
3218		break;
3219	case IEEE80211_S1G_CHANWIDTH_4MHZ:
3220		chandef->width = NL80211_CHAN_WIDTH_4;
3221		break;
3222	case IEEE80211_S1G_CHANWIDTH_8MHZ:
3223		chandef->width = NL80211_CHAN_WIDTH_8;
3224		break;
3225	case IEEE80211_S1G_CHANWIDTH_16MHZ:
3226		chandef->width = NL80211_CHAN_WIDTH_16;
3227		break;
3228	default:
3229		return false;
3230	}
3231
3232	chandef->s1g_primary_2mhz = false;
3233
3234	switch (u8_get_bits(oper->ch_width, S1G_OPER_CH_WIDTH_PRIMARY)) {
3235	case IEEE80211_S1G_PRI_CHANWIDTH_1MHZ:
3236		pri_1mhz_khz = ieee80211_channel_to_freq_khz(
3237			oper->primary_ch, NL80211_BAND_S1GHZ);
3238		break;
3239	case IEEE80211_S1G_PRI_CHANWIDTH_2MHZ:
3240		chandef->s1g_primary_2mhz = true;
3241		pri_2mhz_khz = ieee80211_channel_to_freq_khz(
3242			oper->primary_ch, NL80211_BAND_S1GHZ);
3243
3244		if (u8_get_bits(oper->ch_width, S1G_OPER_CH_PRIMARY_LOCATION) ==
3245		    S1G_2M_PRIMARY_LOCATION_LOWER)
3246			pri_1mhz_khz = pri_2mhz_khz - 500;
3247		else
3248			pri_1mhz_khz = pri_2mhz_khz + 500;
3249		break;
3250	default:
3251		return false;
3252	}
3253
3254	oper_khz = ieee80211_channel_to_freq_khz(oper->oper_ch,
3255						 NL80211_BAND_S1GHZ);
3256	chandef->center_freq1 = KHZ_TO_MHZ(oper_khz);
3257	chandef->freq1_offset = oper_khz % 1000;
3258	chandef->chan =
3259		ieee80211_get_channel_khz(local->hw.wiphy, pri_1mhz_khz);
3260
3261	return chandef->chan;
3262}
3263
3264int ieee80211_put_srates_elem(struct sk_buff *skb,
3265			      const struct ieee80211_supported_band *sband,
3266			      u32 basic_rates, u32 masked_rates,
3267			      u8 element_id)
3268{
3269	u8 i, rates, skip;
3270
3271	rates = 0;
3272	for (i = 0; i < sband->n_bitrates; i++) {
3273		if (masked_rates & BIT(i))
3274			continue;
3275		rates++;
3276	}
3277
3278	if (element_id == WLAN_EID_SUPP_RATES) {
3279		rates = min_t(u8, rates, 8);
3280		skip = 0;
3281	} else {
3282		skip = 8;
3283		if (rates <= skip)
3284			return 0;
3285		rates -= skip;
3286	}
3287
3288	if (skb_tailroom(skb) < rates + 2)
3289		return -ENOBUFS;
3290
3291	skb_put_u8(skb, element_id);
3292	skb_put_u8(skb, rates);
3293
3294	for (i = 0; i < sband->n_bitrates && rates; i++) {
3295		int rate;
3296		u8 basic;
3297
3298		if (masked_rates & BIT(i))
3299			continue;
3300
3301		if (skip > 0) {
3302			skip--;
3303			continue;
3304		}
3305
3306		basic = basic_rates & BIT(i) ? 0x80 : 0;
3307
3308		rate = DIV_ROUND_UP(sband->bitrates[i].bitrate, 5);
3309		skb_put_u8(skb, basic | (u8)rate);
3310		rates--;
3311	}
3312
3313	WARN(rates > 0, "rates confused: rates:%d, element:%d\n",
3314	     rates, element_id);
3315
3316	return 0;
3317}
3318
3319int ieee80211_ave_rssi(struct ieee80211_vif *vif, int link_id)
3320{
3321	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3322	struct ieee80211_link_data *link_data;
3323
3324	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
3325		return 0;
3326
3327	if (link_id < 0)
3328		link_data = &sdata->deflink;
3329	else
3330		link_data = wiphy_dereference(sdata->local->hw.wiphy,
3331					      sdata->link[link_id]);
3332
3333	if (WARN_ON_ONCE(!link_data))
3334		return -99;
3335
3336	return -ewma_beacon_signal_read(&link_data->u.mgd.ave_beacon_signal);
3337}
3338EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
3339
3340u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
3341{
3342	if (!mcs)
3343		return 1;
3344
3345	/* TODO: consider rx_highest */
3346
3347	if (mcs->rx_mask[3])
3348		return 4;
3349	if (mcs->rx_mask[2])
3350		return 3;
3351	if (mcs->rx_mask[1])
3352		return 2;
3353	return 1;
3354}
3355
3356/**
3357 * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
3358 * @local: mac80211 hw info struct
3359 * @status: RX status
3360 * @mpdu_len: total MPDU length (including FCS)
3361 * @mpdu_offset: offset into MPDU to calculate timestamp at
3362 *
3363 * This function calculates the RX timestamp at the given MPDU offset, taking
3364 * into account what the RX timestamp was. An offset of 0 will just normalize
3365 * the timestamp to TSF at beginning of MPDU reception.
3366 *
3367 * Returns: the calculated timestamp
3368 */
3369u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
3370				     struct ieee80211_rx_status *status,
3371				     unsigned int mpdu_len,
3372				     unsigned int mpdu_offset)
3373{
3374	u64 ts = status->mactime;
3375	bool mactime_plcp_start;
3376	struct rate_info ri;
3377	u16 rate;
3378	u8 n_ltf;
3379
3380	if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
3381		return 0;
3382
3383	mactime_plcp_start = (status->flag & RX_FLAG_MACTIME) ==
3384				RX_FLAG_MACTIME_PLCP_START;
3385
3386	memset(&ri, 0, sizeof(ri));
3387
3388	ri.bw = status->bw;
3389
3390	/* Fill cfg80211 rate info */
3391	switch (status->encoding) {
3392	case RX_ENC_EHT:
3393		ri.flags |= RATE_INFO_FLAGS_EHT_MCS;
3394		ri.mcs = status->rate_idx;
3395		ri.nss = status->nss;
3396		ri.eht_ru_alloc = status->eht.ru;
3397		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3398			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3399		/* TODO/FIXME: is this right? handle other PPDUs */
3400		if (mactime_plcp_start) {
3401			mpdu_offset += 2;
3402			ts += 36;
3403		}
3404		break;
3405	case RX_ENC_HE:
3406		ri.flags |= RATE_INFO_FLAGS_HE_MCS;
3407		ri.mcs = status->rate_idx;
3408		ri.nss = status->nss;
3409		ri.he_ru_alloc = status->he_ru;
3410		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3411			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3412
3413		/*
3414		 * See P802.11ax_D6.0, section 27.3.4 for
3415		 * VHT PPDU format.
3416		 */
3417		if (mactime_plcp_start) {
3418			mpdu_offset += 2;
3419			ts += 36;
3420
3421			/*
3422			 * TODO:
3423			 * For HE MU PPDU, add the HE-SIG-B.
3424			 * For HE ER PPDU, add 8us for the HE-SIG-A.
3425			 * For HE TB PPDU, add 4us for the HE-STF.
3426			 * Add the HE-LTF durations - variable.
3427			 */
3428		}
3429
3430		break;
3431	case RX_ENC_HT:
3432		ri.mcs = status->rate_idx;
3433		ri.flags |= RATE_INFO_FLAGS_MCS;
3434		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3435			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3436
3437		/*
3438		 * See P802.11REVmd_D3.0, section 19.3.2 for
3439		 * HT PPDU format.
3440		 */
3441		if (mactime_plcp_start) {
3442			mpdu_offset += 2;
3443			if (status->enc_flags & RX_ENC_FLAG_HT_GF)
3444				ts += 24;
3445			else
3446				ts += 32;
3447
3448			/*
3449			 * Add Data HT-LTFs per streams
3450			 * TODO: add Extension HT-LTFs, 4us per LTF
3451			 */
3452			n_ltf = ((ri.mcs >> 3) & 3) + 1;
3453			n_ltf = n_ltf == 3 ? 4 : n_ltf;
3454			ts += n_ltf * 4;
3455		}
3456
3457		break;
3458	case RX_ENC_VHT:
3459		ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
3460		ri.mcs = status->rate_idx;
3461		ri.nss = status->nss;
3462		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3463			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3464
3465		/*
3466		 * See P802.11REVmd_D3.0, section 21.3.2 for
3467		 * VHT PPDU format.
3468		 */
3469		if (mactime_plcp_start) {
3470			mpdu_offset += 2;
3471			ts += 36;
3472
3473			/*
3474			 * Add VHT-LTFs per streams
3475			 */
3476			n_ltf = (ri.nss != 1) && (ri.nss % 2) ?
3477				ri.nss + 1 : ri.nss;
3478			ts += 4 * n_ltf;
3479		}
3480
3481		break;
3482	default:
3483		WARN_ON(1);
3484		fallthrough;
3485	case RX_ENC_LEGACY: {
3486		struct ieee80211_supported_band *sband;
3487
3488		sband = local->hw.wiphy->bands[status->band];
3489		ri.legacy = sband->bitrates[status->rate_idx].bitrate;
3490
3491		if (mactime_plcp_start) {
3492			if (status->band == NL80211_BAND_5GHZ) {
3493				ts += 20;
3494				mpdu_offset += 2;
3495			} else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
3496				ts += 96;
3497			} else {
3498				ts += 192;
3499			}
3500		}
3501		break;
3502		}
3503	}
3504
3505	rate = cfg80211_calculate_bitrate(&ri);
3506	if (WARN_ONCE(!rate,
3507		      "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
3508		      (unsigned long long)status->flag, status->rate_idx,
3509		      status->nss))
3510		return 0;
3511
3512	/* rewind from end of MPDU */
3513	if ((status->flag & RX_FLAG_MACTIME) == RX_FLAG_MACTIME_END)
3514		ts -= mpdu_len * 8 * 10 / rate;
3515
3516	ts += mpdu_offset * 8 * 10 / rate;
3517
3518	return ts;
3519}
3520
3521/* Cancel CAC for the interfaces under the specified @local. If @ctx is
3522 * also provided, only the interfaces using that ctx will be canceled.
3523 */
3524void ieee80211_dfs_cac_cancel(struct ieee80211_local *local,
3525			      struct ieee80211_chanctx *ctx)
3526{
3527	struct ieee80211_sub_if_data *sdata;
3528	struct cfg80211_chan_def chandef;
3529	struct ieee80211_link_data *link;
3530	struct ieee80211_chanctx_conf *chanctx_conf;
3531	unsigned int link_id;
3532
3533	lockdep_assert_wiphy(local->hw.wiphy);
3534
3535	list_for_each_entry(sdata, &local->interfaces, list) {
3536		for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS;
3537		     link_id++) {
3538			link = sdata_dereference(sdata->link[link_id],
3539						 sdata);
3540			if (!link)
3541				continue;
3542
3543			chanctx_conf = sdata_dereference(link->conf->chanctx_conf,
3544							 sdata);
3545			if (ctx && &ctx->conf != chanctx_conf)
3546				continue;
3547
3548			wiphy_delayed_work_cancel(local->hw.wiphy,
3549						  &link->dfs_cac_timer_work);
3550
3551			if (!sdata->wdev.links[link_id].cac_started)
3552				continue;
3553
3554			chandef = link->conf->chanreq.oper;
3555			ieee80211_link_release_channel(link);
3556			cfg80211_cac_event(sdata->dev, &chandef,
3557					   NL80211_RADAR_CAC_ABORTED,
3558					   GFP_KERNEL, link_id);
3559		}
3560	}
3561}
3562
3563void ieee80211_dfs_radar_detected_work(struct wiphy *wiphy,
3564				       struct wiphy_work *work)
3565{
3566	struct ieee80211_local *local =
3567		container_of(work, struct ieee80211_local, radar_detected_work);
3568	struct cfg80211_chan_def chandef;
3569	struct ieee80211_chanctx *ctx;
3570
3571	lockdep_assert_wiphy(local->hw.wiphy);
3572
3573	list_for_each_entry(ctx, &local->chanctx_list, list) {
3574		if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3575			continue;
3576
3577		if (!ctx->radar_detected)
3578			continue;
3579
3580		ctx->radar_detected = false;
3581
3582		chandef = ctx->conf.def;
3583
3584		ieee80211_dfs_cac_cancel(local, ctx);
3585		cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
3586	}
3587}
3588
3589static void
3590ieee80211_radar_mark_chan_ctx_iterator(struct ieee80211_hw *hw,
3591				       struct ieee80211_chanctx_conf *chanctx_conf,
3592				       void *data)
3593{
3594	struct ieee80211_chanctx *ctx =
3595		container_of(chanctx_conf, struct ieee80211_chanctx,
3596			     conf);
3597
3598	if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3599		return;
3600
3601	if (data && data != chanctx_conf)
3602		return;
3603
3604	ctx->radar_detected = true;
3605}
3606
3607void ieee80211_radar_detected(struct ieee80211_hw *hw,
3608			      struct ieee80211_chanctx_conf *chanctx_conf)
3609{
3610	struct ieee80211_local *local = hw_to_local(hw);
3611
3612	trace_api_radar_detected(local);
3613
3614	ieee80211_iter_chan_contexts_atomic(hw, ieee80211_radar_mark_chan_ctx_iterator,
3615					    chanctx_conf);
3616
3617	wiphy_work_queue(hw->wiphy, &local->radar_detected_work);
3618}
3619EXPORT_SYMBOL(ieee80211_radar_detected);
3620
3621void ieee80211_chandef_downgrade(struct cfg80211_chan_def *c,
3622				 struct ieee80211_conn_settings *conn)
3623{
3624	enum nl80211_chan_width new_primary_width;
3625	struct ieee80211_conn_settings _ignored = {};
3626
3627	/* allow passing NULL if caller doesn't care */
3628	if (!conn)
3629		conn = &_ignored;
3630
3631again:
3632	/* no-HT indicates nothing to do */
3633	new_primary_width = NL80211_CHAN_WIDTH_20_NOHT;
3634
3635	switch (c->width) {
3636	default:
3637	case NL80211_CHAN_WIDTH_20_NOHT:
3638		WARN_ON_ONCE(1);
3639		fallthrough;
3640	case NL80211_CHAN_WIDTH_20:
3641		c->width = NL80211_CHAN_WIDTH_20_NOHT;
3642		conn->mode = IEEE80211_CONN_MODE_LEGACY;
3643		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3644		c->punctured = 0;
3645		break;
3646	case NL80211_CHAN_WIDTH_40:
3647		c->width = NL80211_CHAN_WIDTH_20;
3648		c->center_freq1 = c->chan->center_freq;
3649		if (conn->mode == IEEE80211_CONN_MODE_VHT)
3650			conn->mode = IEEE80211_CONN_MODE_HT;
3651		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3652		c->punctured = 0;
3653		break;
3654	case NL80211_CHAN_WIDTH_80:
3655		new_primary_width = NL80211_CHAN_WIDTH_40;
3656		if (conn->mode == IEEE80211_CONN_MODE_VHT)
3657			conn->mode = IEEE80211_CONN_MODE_HT;
3658		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_40;
3659		break;
3660	case NL80211_CHAN_WIDTH_80P80:
3661		c->center_freq2 = 0;
3662		c->width = NL80211_CHAN_WIDTH_80;
3663		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_80;
3664		break;
3665	case NL80211_CHAN_WIDTH_160:
3666		new_primary_width = NL80211_CHAN_WIDTH_80;
3667		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_80;
3668		break;
3669	case NL80211_CHAN_WIDTH_320:
3670		new_primary_width = NL80211_CHAN_WIDTH_160;
3671		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_160;
3672		break;
3673	case NL80211_CHAN_WIDTH_1:
3674	case NL80211_CHAN_WIDTH_2:
3675	case NL80211_CHAN_WIDTH_4:
3676	case NL80211_CHAN_WIDTH_8:
3677	case NL80211_CHAN_WIDTH_16:
3678		WARN_ON_ONCE(1);
3679		/* keep c->width */
3680		conn->mode = IEEE80211_CONN_MODE_S1G;
3681		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3682		break;
3683	case NL80211_CHAN_WIDTH_5:
3684	case NL80211_CHAN_WIDTH_10:
3685		WARN_ON_ONCE(1);
3686		/* keep c->width */
3687		conn->mode = IEEE80211_CONN_MODE_LEGACY;
3688		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3689		break;
3690	}
3691
3692	if (new_primary_width != NL80211_CHAN_WIDTH_20_NOHT) {
3693		c->center_freq1 = cfg80211_chandef_primary(c, new_primary_width,
3694							   &c->punctured);
3695		c->width = new_primary_width;
3696	}
3697
3698	/*
3699	 * With an 80 MHz channel, we might have the puncturing in the primary
3700	 * 40 Mhz channel, but that's not valid when downgraded to 40 MHz width.
3701	 * In that case, downgrade again.
3702	 */
3703	if (!cfg80211_chandef_valid(c) && c->punctured)
3704		goto again;
3705
3706	WARN_ON_ONCE(!cfg80211_chandef_valid(c));
3707}
3708
3709int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
3710			      struct cfg80211_csa_settings *csa_settings)
3711{
3712	struct sk_buff *skb;
3713	struct ieee80211_mgmt *mgmt;
3714	struct ieee80211_local *local = sdata->local;
3715	int freq;
3716	int hdr_len = offsetofend(struct ieee80211_mgmt,
3717				  u.action.u.chan_switch);
3718	u8 *pos;
3719
3720	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3721	    sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3722		return -EOPNOTSUPP;
3723
3724	skb = dev_alloc_skb(local->tx_headroom + hdr_len +
3725			    5 + /* channel switch announcement element */
3726			    3 + /* secondary channel offset element */
3727			    5 + /* wide bandwidth channel switch announcement */
3728			    8); /* mesh channel switch parameters element */
3729	if (!skb)
3730		return -ENOMEM;
3731
3732	skb_reserve(skb, local->tx_headroom);
3733	mgmt = skb_put_zero(skb, hdr_len);
3734	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3735					  IEEE80211_STYPE_ACTION);
3736
3737	eth_broadcast_addr(mgmt->da);
3738	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
3739	if (ieee80211_vif_is_mesh(&sdata->vif)) {
3740		memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
3741	} else {
3742		struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
3743		memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
3744	}
3745	mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
3746	mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
3747	pos = skb_put(skb, 5);
3748	*pos++ = WLAN_EID_CHANNEL_SWITCH;			/* EID */
3749	*pos++ = 3;						/* IE length */
3750	*pos++ = csa_settings->block_tx ? 1 : 0;		/* CSA mode */
3751	freq = csa_settings->chandef.chan->center_freq;
3752	*pos++ = ieee80211_frequency_to_channel(freq);		/* channel */
3753	*pos++ = csa_settings->count;				/* count */
3754
3755	if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
3756		enum nl80211_channel_type ch_type;
3757
3758		skb_put(skb, 3);
3759		*pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;	/* EID */
3760		*pos++ = 1;					/* IE length */
3761		ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
3762		if (ch_type == NL80211_CHAN_HT40PLUS)
3763			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3764		else
3765			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3766	}
3767
3768	if (ieee80211_vif_is_mesh(&sdata->vif)) {
3769		struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
3770
3771		skb_put(skb, 8);
3772		*pos++ = WLAN_EID_CHAN_SWITCH_PARAM;		/* EID */
3773		*pos++ = 6;					/* IE length */
3774		*pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL;	/* Mesh TTL */
3775		*pos = 0x00;	/* Mesh Flag: Tx Restrict, Initiator, Reason */
3776		*pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
3777		*pos++ |= csa_settings->block_tx ?
3778			  WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
3779		put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
3780		pos += 2;
3781		put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
3782		pos += 2;
3783	}
3784
3785	if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
3786	    csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
3787	    csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
3788		skb_put(skb, 5);
3789		ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
3790	}
3791
3792	ieee80211_tx_skb(sdata, skb);
3793	return 0;
3794}
3795
3796static bool
3797ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
3798{
3799	s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
3800	int skip;
3801
3802	if (end > 0)
3803		return false;
3804
3805	/* One shot NOA  */
3806	if (data->count[i] == 1)
3807		return false;
3808
3809	if (data->desc[i].interval == 0)
3810		return false;
3811
3812	/* End time is in the past, check for repetitions */
3813	skip = DIV_ROUND_UP(-end, data->desc[i].interval);
3814	if (data->count[i] < 255) {
3815		if (data->count[i] <= skip) {
3816			data->count[i] = 0;
3817			return false;
3818		}
3819
3820		data->count[i] -= skip;
3821	}
3822
3823	data->desc[i].start += skip * data->desc[i].interval;
3824
3825	return true;
3826}
3827
3828static bool
3829ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
3830			     s32 *offset)
3831{
3832	bool ret = false;
3833	int i;
3834
3835	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3836		s32 cur;
3837
3838		if (!data->count[i])
3839			continue;
3840
3841		if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
3842			ret = true;
3843
3844		cur = data->desc[i].start - tsf;
3845		if (cur > *offset)
3846			continue;
3847
3848		cur = data->desc[i].start + data->desc[i].duration - tsf;
3849		if (cur > *offset)
3850			*offset = cur;
3851	}
3852
3853	return ret;
3854}
3855
3856static u32
3857ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
3858{
3859	s32 offset = 0;
3860	int tries = 0;
3861	/*
3862	 * arbitrary limit, used to avoid infinite loops when combined NoA
3863	 * descriptors cover the full time period.
3864	 */
3865	int max_tries = 5;
3866
3867	ieee80211_extend_absent_time(data, tsf, &offset);
3868	do {
3869		if (!ieee80211_extend_absent_time(data, tsf, &offset))
3870			break;
3871
3872		tries++;
3873	} while (tries < max_tries);
3874
3875	return offset;
3876}
3877
3878void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
3879{
3880	u32 next_offset = BIT(31) - 1;
3881	int i;
3882
3883	data->absent = 0;
3884	data->has_next_tsf = false;
3885	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3886		s32 start;
3887
3888		if (!data->count[i])
3889			continue;
3890
3891		ieee80211_extend_noa_desc(data, tsf, i);
3892		start = data->desc[i].start - tsf;
3893		if (start <= 0)
3894			data->absent |= BIT(i);
3895
3896		if (next_offset > start)
3897			next_offset = start;
3898
3899		data->has_next_tsf = true;
3900	}
3901
3902	if (data->absent)
3903		next_offset = ieee80211_get_noa_absent_time(data, tsf);
3904
3905	data->next_tsf = tsf + next_offset;
3906}
3907EXPORT_SYMBOL(ieee80211_update_p2p_noa);
3908
3909int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
3910			    struct ieee80211_noa_data *data, u32 tsf)
3911{
3912	int ret = 0;
3913	int i;
3914
3915	memset(data, 0, sizeof(*data));
3916
3917	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3918		const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
3919
3920		if (!desc->count || !desc->duration)
3921			continue;
3922
3923		data->count[i] = desc->count;
3924		data->desc[i].start = le32_to_cpu(desc->start_time);
3925		data->desc[i].duration = le32_to_cpu(desc->duration);
3926		data->desc[i].interval = le32_to_cpu(desc->interval);
3927
3928		if (data->count[i] > 1 &&
3929		    data->desc[i].interval < data->desc[i].duration)
3930			continue;
3931
3932		ieee80211_extend_noa_desc(data, tsf, i);
3933		ret++;
3934	}
3935
3936	if (ret)
3937		ieee80211_update_p2p_noa(data, tsf);
3938
3939	return ret;
3940}
3941EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
3942
3943void ieee80211_recalc_dtim(struct ieee80211_sub_if_data *sdata, u64 tsf)
3944{
3945	u64 dtim_count = 0;
3946	u32 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
3947	u8 dtim_period = sdata->vif.bss_conf.dtim_period;
3948	struct ps_data *ps;
3949	u8 bcns_from_dtim;
3950
3951	if (tsf == -1ULL || !beacon_int || !dtim_period)
3952		return;
3953
3954	if (sdata->vif.type == NL80211_IFTYPE_AP ||
3955	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
3956		if (!sdata->bss)
3957			return;
3958
3959		ps = &sdata->bss->ps;
3960	} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
3961		ps = &sdata->u.mesh.ps;
3962	} else {
3963		return;
3964	}
3965
3966	/*
3967	 * actually finds last dtim_count, mac80211 will update in
3968	 * __beacon_add_tim().
3969	 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
3970	 */
3971	do_div(tsf, beacon_int);
3972	bcns_from_dtim = do_div(tsf, dtim_period);
3973	/* just had a DTIM */
3974	if (!bcns_from_dtim)
3975		dtim_count = 0;
3976	else
3977		dtim_count = dtim_period - bcns_from_dtim;
3978
3979	ps->dtim_count = dtim_count;
3980}
3981
3982/*
3983 * Given a long beacon period, calculate the current index into
3984 * that period to determine the number of TSBTTs until the next TBTT.
3985 * It is completely valid to have a short beacon period that differs
3986 * from the dtim period (i.e a TBTT thats not a DTIM).
3987 */
3988void ieee80211_recalc_sb_count(struct ieee80211_sub_if_data *sdata, u64 tsf)
3989{
3990	u32 sb_idx;
3991	struct ps_data *ps = &sdata->bss->ps;
3992	u8 lb_period = sdata->vif.bss_conf.s1g_long_beacon_period;
3993	u32 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
3994
3995	/* No mesh / IBSS support for short beaconing */
3996	if (tsf == -1ULL || !lb_period ||
3997	    (sdata->vif.type != NL80211_IFTYPE_AP &&
3998	     sdata->vif.type != NL80211_IFTYPE_AP_VLAN))
3999		return;
4000
4001	/* find the current TSBTT index in our lb_period */
4002	do_div(tsf, beacon_int);
4003	sb_idx = do_div(tsf, lb_period);
4004
4005	/* num TSBTTs until the next TBTT */
4006	ps->sb_count = sb_idx ? lb_period - sb_idx : 0;
4007}
4008
4009static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
4010					 struct ieee80211_chanctx *ctx)
4011{
4012	struct ieee80211_link_data *link;
4013	u8 radar_detect = 0;
4014
4015	lockdep_assert_wiphy(local->hw.wiphy);
4016
4017	if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
4018		return 0;
4019
4020	for_each_sdata_link(local, link) {
4021		if (rcu_access_pointer(link->conf->chanctx_conf) == &ctx->conf) {
4022			/*
4023			 * An in-place reservation context should not have any
4024			 * assigned links until it replaces the other context.
4025			 */
4026			WARN_ON(ctx->replace_state ==
4027				IEEE80211_CHANCTX_REPLACES_OTHER);
4028
4029			if (link->radar_required)
4030				radar_detect |=
4031					BIT(link->conf->chanreq.oper.width);
4032		}
4033
4034		if (link->reserved_chanctx == ctx &&
4035		    link->reserved_radar_required)
4036			radar_detect |= BIT(link->reserved.oper.width);
4037	}
4038
4039	return radar_detect;
4040}
4041
4042bool ieee80211_is_radio_idx_in_scan_req(struct wiphy *wiphy,
4043					struct cfg80211_scan_request *scan_req,
4044					int radio_idx)
4045{
4046	struct ieee80211_channel *chan;
4047	int i, chan_radio_idx;
4048
4049	for (i = 0; i < scan_req->n_channels; i++) {
4050		chan = scan_req->channels[i];
4051		chan_radio_idx = cfg80211_get_radio_idx_by_chan(wiphy, chan);
4052
4053		/* The radio index either matched successfully, or an error
4054		 * occurred. For example, if radio-level information is
4055		 * missing, the same error value is returned. This
4056		 * typically implies a single-radio setup, in which case
4057		 * the operation should not be allowed.
4058		 */
4059		if (chan_radio_idx == radio_idx)
4060			return true;
4061	}
4062
4063	return false;
4064}
4065
4066static u32
4067__ieee80211_get_radio_mask(struct ieee80211_sub_if_data *sdata)
4068{
4069	struct ieee80211_bss_conf *link_conf;
4070	struct ieee80211_chanctx_conf *conf;
4071	unsigned int link_id;
4072	u32 mask = 0;
4073
4074	for_each_vif_active_link(&sdata->vif, link_conf, link_id) {
4075		conf = sdata_dereference(link_conf->chanctx_conf, sdata);
4076		if (!conf || conf->radio_idx < 0)
4077			continue;
4078
4079		mask |= BIT(conf->radio_idx);
4080	}
4081
4082	return mask;
4083}
4084
4085u32 ieee80211_get_radio_mask(struct wiphy *wiphy, struct net_device *dev)
4086{
4087	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
4088
4089	return __ieee80211_get_radio_mask(sdata);
4090}
4091
4092static bool
4093ieee80211_sdata_uses_radio(struct ieee80211_sub_if_data *sdata, int radio_idx)
4094{
4095	if (radio_idx < 0)
4096		return true;
4097
4098	return __ieee80211_get_radio_mask(sdata) & BIT(radio_idx);
4099}
4100
4101static int
4102ieee80211_fill_ifcomb_params(struct ieee80211_local *local,
4103			     struct iface_combination_params *params,
4104			     const struct cfg80211_chan_def *chandef,
4105			     struct ieee80211_sub_if_data *sdata)
4106{
4107	struct ieee80211_sub_if_data *sdata_iter;
4108	struct ieee80211_chanctx *ctx;
4109	int total = !!sdata;
4110
4111	list_for_each_entry(ctx, &local->chanctx_list, list) {
4112		if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4113			continue;
4114
4115		if (params->radio_idx >= 0 &&
4116		    ctx->conf.radio_idx != params->radio_idx)
4117			continue;
4118
4119		params->radar_detect |=
4120			ieee80211_chanctx_radar_detect(local, ctx);
4121
4122		if (chandef && ctx->mode != IEEE80211_CHANCTX_EXCLUSIVE &&
4123		    cfg80211_chandef_compatible(chandef, &ctx->conf.def))
4124			continue;
4125
4126		params->num_different_channels++;
4127	}
4128
4129	list_for_each_entry(sdata_iter, &local->interfaces, list) {
4130		struct wireless_dev *wdev_iter;
4131
4132		wdev_iter = &sdata_iter->wdev;
4133
4134		if (sdata_iter == sdata ||
4135		    !ieee80211_sdata_running(sdata_iter) ||
4136		    cfg80211_iftype_allowed(local->hw.wiphy,
4137					    wdev_iter->iftype, 0, 1))
4138			continue;
4139
4140		if (!ieee80211_sdata_uses_radio(sdata_iter, params->radio_idx))
4141			continue;
4142
4143		params->iftype_num[wdev_iter->iftype]++;
4144		total++;
4145	}
4146
4147	return total;
4148}
4149
4150int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
4151				 const struct cfg80211_chan_def *chandef,
4152				 enum ieee80211_chanctx_mode chanmode,
4153				 u8 radar_detect, int radio_idx)
4154{
4155	bool shared = chanmode == IEEE80211_CHANCTX_SHARED;
4156	struct ieee80211_local *local = sdata->local;
4157	enum nl80211_iftype iftype = sdata->wdev.iftype;
4158	struct iface_combination_params params = {
4159		.radar_detect = radar_detect,
4160		.radio_idx = radio_idx,
4161	};
4162	int total;
4163
4164	lockdep_assert_wiphy(local->hw.wiphy);
4165
4166	if (WARN_ON(hweight32(radar_detect) > 1))
4167		return -EINVAL;
4168
4169	if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4170		    !chandef->chan))
4171		return -EINVAL;
4172
4173	if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
4174		return -EINVAL;
4175
4176	if (sdata->vif.type == NL80211_IFTYPE_AP ||
4177	    sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
4178		/*
4179		 * always passing this is harmless, since it'll be the
4180		 * same value that cfg80211 finds if it finds the same
4181		 * interface ... and that's always allowed
4182		 */
4183		params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
4184	}
4185
4186	/* Always allow software iftypes */
4187	if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) {
4188		if (radar_detect)
4189			return -EINVAL;
4190		return 0;
4191	}
4192
4193	if (chandef)
4194		params.num_different_channels = 1;
4195
4196	if (iftype != NL80211_IFTYPE_UNSPECIFIED)
4197		params.iftype_num[iftype] = 1;
4198
4199	total = ieee80211_fill_ifcomb_params(local, &params,
4200					     shared ? chandef : NULL,
4201					     sdata);
4202	if (total == 1 && !params.radar_detect)
4203		return 0;
4204
4205	return cfg80211_check_combinations(local->hw.wiphy, &params);
4206}
4207
4208static void
4209ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
4210			 void *data)
4211{
4212	u32 *max_num_different_channels = data;
4213
4214	*max_num_different_channels = max(*max_num_different_channels,
4215					  c->num_different_channels);
4216}
4217
4218int ieee80211_max_num_channels(struct ieee80211_local *local, int radio_idx)
4219{
4220	u32 max_num_different_channels = 1;
4221	int err;
4222	struct iface_combination_params params = {
4223		.radio_idx = radio_idx,
4224	};
4225
4226	lockdep_assert_wiphy(local->hw.wiphy);
4227
4228	ieee80211_fill_ifcomb_params(local, &params, NULL, NULL);
4229
4230	err = cfg80211_iter_combinations(local->hw.wiphy, &params,
4231					 ieee80211_iter_max_chans,
4232					 &max_num_different_channels);
4233	if (err < 0)
4234		return err;
4235
4236	return max_num_different_channels;
4237}
4238
4239void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata,
4240				struct ieee80211_sta_s1g_cap *caps,
4241				struct sk_buff *skb)
4242{
4243	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
4244	struct ieee80211_s1g_cap s1g_capab;
4245	u8 *pos;
4246	int i;
4247
4248	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
4249		return;
4250
4251	if (!caps->s1g)
4252		return;
4253
4254	memcpy(s1g_capab.capab_info, caps->cap, sizeof(caps->cap));
4255	memcpy(s1g_capab.supp_mcs_nss, caps->nss_mcs, sizeof(caps->nss_mcs));
4256
4257	/* override the capability info */
4258	for (i = 0; i < sizeof(ifmgd->s1g_capa.capab_info); i++) {
4259		u8 mask = ifmgd->s1g_capa_mask.capab_info[i];
4260
4261		s1g_capab.capab_info[i] &= ~mask;
4262		s1g_capab.capab_info[i] |= ifmgd->s1g_capa.capab_info[i] & mask;
4263	}
4264
4265	/* then MCS and NSS set */
4266	for (i = 0; i < sizeof(ifmgd->s1g_capa.supp_mcs_nss); i++) {
4267		u8 mask = ifmgd->s1g_capa_mask.supp_mcs_nss[i];
4268
4269		s1g_capab.supp_mcs_nss[i] &= ~mask;
4270		s1g_capab.supp_mcs_nss[i] |=
4271			ifmgd->s1g_capa.supp_mcs_nss[i] & mask;
4272	}
4273
4274	pos = skb_put(skb, 2 + sizeof(s1g_capab));
4275	*pos++ = WLAN_EID_S1G_CAPABILITIES;
4276	*pos++ = sizeof(s1g_capab);
4277
4278	memcpy(pos, &s1g_capab, sizeof(s1g_capab));
4279}
4280
4281void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata,
4282				  struct sk_buff *skb)
4283{
4284	u8 *pos = skb_put(skb, 3);
4285
4286	*pos++ = WLAN_EID_AID_REQUEST;
4287	*pos++ = 1;
4288	*pos++ = 0;
4289}
4290
4291u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
4292{
4293	*buf++ = WLAN_EID_VENDOR_SPECIFIC;
4294	*buf++ = 7; /* len */
4295	*buf++ = 0x00; /* Microsoft OUI 00:50:F2 */
4296	*buf++ = 0x50;
4297	*buf++ = 0xf2;
4298	*buf++ = 2; /* WME */
4299	*buf++ = 0; /* WME info */
4300	*buf++ = 1; /* WME ver */
4301	*buf++ = qosinfo; /* U-APSD no in use */
4302
4303	return buf;
4304}
4305
4306void ieee80211_txq_get_depth(struct ieee80211_txq *txq,
4307			     unsigned long *frame_cnt,
4308			     unsigned long *byte_cnt)
4309{
4310	struct txq_info *txqi = to_txq_info(txq);
4311	u32 frag_cnt = 0, frag_bytes = 0;
4312	struct sk_buff *skb;
4313
4314	skb_queue_walk(&txqi->frags, skb) {
4315		frag_cnt++;
4316		frag_bytes += skb->len;
4317	}
4318
4319	if (frame_cnt)
4320		*frame_cnt = txqi->tin.backlog_packets + frag_cnt;
4321
4322	if (byte_cnt)
4323		*byte_cnt = txqi->tin.backlog_bytes + frag_bytes;
4324}
4325EXPORT_SYMBOL(ieee80211_txq_get_depth);
4326
4327const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = {
4328	IEEE80211_WMM_IE_STA_QOSINFO_AC_VO,
4329	IEEE80211_WMM_IE_STA_QOSINFO_AC_VI,
4330	IEEE80211_WMM_IE_STA_QOSINFO_AC_BE,
4331	IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
4332};
4333
4334u16 ieee80211_encode_usf(int listen_interval)
4335{
4336	static const int listen_int_usf[] = { 1, 10, 1000, 10000 };
4337	u16 ui, usf = 0;
4338
4339	/* find greatest USF */
4340	while (usf < IEEE80211_MAX_USF) {
4341		if (listen_interval % listen_int_usf[usf + 1])
4342			break;
4343		usf += 1;
4344	}
4345	ui = listen_interval / listen_int_usf[usf];
4346
4347	/* error if there is a remainder. Should've been checked by user */
4348	WARN_ON_ONCE(ui > IEEE80211_MAX_UI);
4349	listen_interval = FIELD_PREP(LISTEN_INT_USF, usf) |
4350			  FIELD_PREP(LISTEN_INT_UI, ui);
4351
4352	return (u16) listen_interval;
4353}
4354
4355/* this may return more than ieee80211_put_eht_cap() will need */
4356u8 ieee80211_ie_len_eht_cap(struct ieee80211_sub_if_data *sdata)
4357{
4358	const struct ieee80211_sta_he_cap *he_cap;
4359	const struct ieee80211_sta_eht_cap *eht_cap;
4360	struct ieee80211_supported_band *sband;
4361	bool is_ap;
4362	u8 n;
4363
4364	sband = ieee80211_get_sband(sdata);
4365	if (!sband)
4366		return 0;
4367
4368	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
4369	eht_cap = ieee80211_get_eht_iftype_cap_vif(sband, &sdata->vif);
4370	if (!he_cap || !eht_cap)
4371		return 0;
4372
4373	is_ap = sdata->vif.type == NL80211_IFTYPE_AP;
4374
4375	n = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
4376				       &eht_cap->eht_cap_elem,
4377				       is_ap);
4378	return 2 + 1 +
4379	       sizeof(eht_cap->eht_cap_elem) + n +
4380	       ieee80211_eht_ppe_size(eht_cap->eht_ppe_thres[0],
4381				      eht_cap->eht_cap_elem.phy_cap_info);
4382	return 0;
4383}
4384
4385int ieee80211_put_eht_cap(struct sk_buff *skb,
4386			  struct ieee80211_sub_if_data *sdata,
4387			  const struct ieee80211_supported_band *sband,
4388			  const struct ieee80211_conn_settings *conn)
4389{
4390	const struct ieee80211_sta_he_cap *he_cap =
4391		ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
4392	const struct ieee80211_sta_eht_cap *eht_cap =
4393		ieee80211_get_eht_iftype_cap_vif(sband, &sdata->vif);
4394	bool for_ap = sdata->vif.type == NL80211_IFTYPE_AP;
4395	struct ieee80211_eht_cap_elem_fixed fixed;
4396	struct ieee80211_he_cap_elem he;
4397	u8 mcs_nss_len, ppet_len;
4398	u8 orig_mcs_nss_len;
4399	u8 ie_len;
4400
4401	if (!conn)
4402		conn = &ieee80211_conn_settings_unlimited;
4403
4404	/* Make sure we have place for the IE */
4405	if (!he_cap || !eht_cap)
4406		return 0;
4407
4408	orig_mcs_nss_len = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
4409						      &eht_cap->eht_cap_elem,
4410						      for_ap);
4411
4412	ieee80211_get_adjusted_he_cap(conn, he_cap, &he);
4413
4414	fixed = eht_cap->eht_cap_elem;
4415
4416	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_80)
4417		fixed.phy_cap_info[6] &=
4418			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_80MHZ;
4419
4420	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_160) {
4421		fixed.phy_cap_info[1] &=
4422			~IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_160MHZ_MASK;
4423		fixed.phy_cap_info[2] &=
4424			~IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_160MHZ_MASK;
4425		fixed.phy_cap_info[6] &=
4426			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_160MHZ;
4427	}
4428
4429	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_320) {
4430		fixed.phy_cap_info[0] &=
4431			~IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ;
4432		fixed.phy_cap_info[1] &=
4433			~IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_320MHZ_MASK;
4434		fixed.phy_cap_info[2] &=
4435			~IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_320MHZ_MASK;
4436		fixed.phy_cap_info[6] &=
4437			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_320MHZ;
4438	}
4439
4440	if (conn->bw_limit == IEEE80211_CONN_BW_LIMIT_20)
4441		fixed.phy_cap_info[0] &=
4442			~IEEE80211_EHT_PHY_CAP0_242_TONE_RU_GT20MHZ;
4443
4444	mcs_nss_len = ieee80211_eht_mcs_nss_size(&he, &fixed, for_ap);
4445	ppet_len = ieee80211_eht_ppe_size(eht_cap->eht_ppe_thres[0],
4446					  fixed.phy_cap_info);
4447
4448	ie_len = 2 + 1 + sizeof(eht_cap->eht_cap_elem) + mcs_nss_len + ppet_len;
4449	if (skb_tailroom(skb) < ie_len)
4450		return -ENOBUFS;
4451
4452	skb_put_u8(skb, WLAN_EID_EXTENSION);
4453	skb_put_u8(skb, ie_len - 2);
4454	skb_put_u8(skb, WLAN_EID_EXT_EHT_CAPABILITY);
4455	skb_put_data(skb, &fixed, sizeof(fixed));
4456
4457	if (mcs_nss_len == 4 && orig_mcs_nss_len != 4) {
4458		/*
4459		 * If the (non-AP) STA became 20 MHz only, then convert from
4460		 * <=80 to 20-MHz-only format, where MCSes are indicated in
4461		 * the groups 0-7, 8-9, 10-11, 12-13 rather than just 0-9,
4462		 * 10-11, 12-13. Thus, use 0-9 for 0-7 and 8-9.
4463		 */
4464		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs9_max_nss);
4465		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs9_max_nss);
4466		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs11_max_nss);
4467		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs13_max_nss);
4468	} else {
4469		skb_put_data(skb, &eht_cap->eht_mcs_nss_supp, mcs_nss_len);
4470	}
4471
4472	if (ppet_len)
4473		skb_put_data(skb, &eht_cap->eht_ppe_thres, ppet_len);
4474
4475	return 0;
4476}
4477
4478const char *ieee80211_conn_mode_str(enum ieee80211_conn_mode mode)
4479{
4480	static const char * const modes[] = {
4481		[IEEE80211_CONN_MODE_S1G] = "S1G",
4482		[IEEE80211_CONN_MODE_LEGACY] = "legacy",
4483		[IEEE80211_CONN_MODE_HT] = "HT",
4484		[IEEE80211_CONN_MODE_VHT] = "VHT",
4485		[IEEE80211_CONN_MODE_HE] = "HE",
4486		[IEEE80211_CONN_MODE_EHT] = "EHT",
4487	};
4488
4489	if (WARN_ON(mode >= ARRAY_SIZE(modes)))
4490		return "<out of range>";
4491
4492	return modes[mode] ?: "<missing string>";
4493}
4494
4495enum ieee80211_conn_bw_limit
4496ieee80211_min_bw_limit_from_chandef(struct cfg80211_chan_def *chandef)
4497{
4498	switch (chandef->width) {
4499	case NL80211_CHAN_WIDTH_20_NOHT:
4500	case NL80211_CHAN_WIDTH_20:
4501		return IEEE80211_CONN_BW_LIMIT_20;
4502	case NL80211_CHAN_WIDTH_40:
4503		return IEEE80211_CONN_BW_LIMIT_40;
4504	case NL80211_CHAN_WIDTH_80:
4505		return IEEE80211_CONN_BW_LIMIT_80;
4506	case NL80211_CHAN_WIDTH_80P80:
4507	case NL80211_CHAN_WIDTH_160:
4508		return IEEE80211_CONN_BW_LIMIT_160;
4509	case NL80211_CHAN_WIDTH_320:
4510		return IEEE80211_CONN_BW_LIMIT_320;
4511	default:
4512		WARN(1, "unhandled chandef width %d\n", chandef->width);
4513		return IEEE80211_CONN_BW_LIMIT_20;
4514	}
4515}
4516
4517void ieee80211_clear_tpe(struct ieee80211_parsed_tpe *tpe)
4518{
4519	for (int i = 0; i < 2; i++) {
4520		tpe->max_local[i].valid = false;
4521		memset(tpe->max_local[i].power,
4522		       IEEE80211_TPE_MAX_TX_PWR_NO_CONSTRAINT,
4523		       sizeof(tpe->max_local[i].power));
4524
4525		tpe->max_reg_client[i].valid = false;
4526		memset(tpe->max_reg_client[i].power,
4527		       IEEE80211_TPE_MAX_TX_PWR_NO_CONSTRAINT,
4528		       sizeof(tpe->max_reg_client[i].power));
4529
4530		tpe->psd_local[i].valid = false;
4531		memset(tpe->psd_local[i].power,
4532		       IEEE80211_TPE_PSD_NO_LIMIT,
4533		       sizeof(tpe->psd_local[i].power));
4534
4535		tpe->psd_reg_client[i].valid = false;
4536		memset(tpe->psd_reg_client[i].power,
4537		       IEEE80211_TPE_PSD_NO_LIMIT,
4538		       sizeof(tpe->psd_reg_client[i].power));
4539	}
4540}
4541
4542bool ieee80211_vif_nan_started(struct ieee80211_vif *vif)
4543{
4544	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
4545
4546	return vif->type == NL80211_IFTYPE_NAN && sdata->u.nan.started;
4547}
4548EXPORT_SYMBOL_GPL(ieee80211_vif_nan_started);