xref: /linux/net/mac80211/util.c (revision 4003c9e78778e93188a09d6043a74f7154449d43)
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 */
38 const void *const mac80211_wiphy_privid = &mac80211_wiphy_privid;
39 
wiphy_to_ieee80211_hw(struct wiphy * wiphy)40 struct 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 }
47 EXPORT_SYMBOL(wiphy_to_ieee80211_hw);
48 
49 const struct ieee80211_conn_settings ieee80211_conn_settings_unlimited = {
50 	.mode = IEEE80211_CONN_MODE_EHT,
51 	.bw_limit = IEEE80211_CONN_BW_LIMIT_320,
52 };
53 
ieee80211_get_bssid(struct ieee80211_hdr * hdr,size_t len,enum nl80211_iftype type)54 u8 *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 }
104 EXPORT_SYMBOL(ieee80211_get_bssid);
105 
ieee80211_tx_set_protected(struct ieee80211_tx_data * tx)106 void 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 
ieee80211_frame_duration(enum nl80211_band band,size_t len,int rate,int erp,int short_preamble)117 int 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 */
ieee80211_generic_frame_duration(struct ieee80211_hw * hw,struct ieee80211_vif * vif,enum nl80211_band band,size_t frame_len,struct ieee80211_rate * rate)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 }
199 EXPORT_SYMBOL(ieee80211_generic_frame_duration);
200 
ieee80211_rts_duration(struct ieee80211_hw * hw,struct ieee80211_vif * vif,size_t frame_len,const struct ieee80211_tx_info * frame_txctl)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 }
241 EXPORT_SYMBOL(ieee80211_rts_duration);
242 
ieee80211_ctstoself_duration(struct ieee80211_hw * hw,struct ieee80211_vif * vif,size_t frame_len,const struct ieee80211_tx_info * frame_txctl)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 }
282 EXPORT_SYMBOL(ieee80211_ctstoself_duration);
283 
wake_tx_push_queue(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata,struct ieee80211_txq * queue)284 static 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*/
ieee80211_handle_wake_tx_queue(struct ieee80211_hw * hw,struct ieee80211_txq * txq)303 void 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 }
321 EXPORT_SYMBOL(ieee80211_handle_wake_tx_queue);
322 
__ieee80211_wake_txqs(struct ieee80211_sub_if_data * sdata,int ac)323 static 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;
381 out:
382 	spin_unlock(&fq->lock);
383 	local_bh_enable();
384 }
385 
386 static void
387 __releases(&local->queue_stop_reason_lock)
388 __acquires(&local->queue_stop_reason_lock)
_ieee80211_wake_txqs(struct ieee80211_local * local,unsigned long * flags)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 
ieee80211_wake_txqs(struct tasklet_struct * t)422 void 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 
__ieee80211_wake_queue(struct ieee80211_hw * hw,int queue,enum queue_stop_reason reason,bool refcounted,unsigned long * flags)433 static 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 
ieee80211_wake_queue_by_reason(struct ieee80211_hw * hw,int queue,enum queue_stop_reason reason,bool refcounted)480 void 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 
ieee80211_wake_queue(struct ieee80211_hw * hw,int queue)492 void 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 }
498 EXPORT_SYMBOL(ieee80211_wake_queue);
499 
__ieee80211_stop_queue(struct ieee80211_hw * hw,int queue,enum queue_stop_reason reason,bool refcounted)500 static 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 
ieee80211_stop_queue_by_reason(struct ieee80211_hw * hw,int queue,enum queue_stop_reason reason,bool refcounted)520 void 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 
ieee80211_stop_queue(struct ieee80211_hw * hw,int queue)532 void 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 }
538 EXPORT_SYMBOL(ieee80211_stop_queue);
539 
ieee80211_add_pending_skb(struct ieee80211_local * local,struct sk_buff * skb)540 void 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 
ieee80211_add_pending_skbs(struct ieee80211_local * local,struct sk_buff_head * skbs)562 void 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 
ieee80211_stop_queues_by_reason(struct ieee80211_hw * hw,unsigned long queues,enum queue_stop_reason reason,bool refcounted)595 void 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 
ieee80211_stop_queues(struct ieee80211_hw * hw)612 void 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 }
618 EXPORT_SYMBOL(ieee80211_stop_queues);
619 
ieee80211_queue_stopped(struct ieee80211_hw * hw,int queue)620 int 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 }
635 EXPORT_SYMBOL(ieee80211_queue_stopped);
636 
ieee80211_wake_queues_by_reason(struct ieee80211_hw * hw,unsigned long queues,enum queue_stop_reason reason,bool refcounted)637 void 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 
ieee80211_wake_queues(struct ieee80211_hw * hw)654 void 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 }
660 EXPORT_SYMBOL(ieee80211_wake_queues);
661 
662 unsigned int
ieee80211_get_vif_queues(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata)663 ieee80211_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 
__ieee80211_flush_queues(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata,unsigned int queues,bool drop)686 void __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 
ieee80211_flush_queues(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata,bool drop)725 void 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 
__iterate_interfaces(struct ieee80211_local * local,u32 iter_flags,void (* iterator)(void * data,u8 * mac,struct ieee80211_vif * vif),void * data)731 static 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 
ieee80211_iterate_interfaces(struct ieee80211_hw * hw,u32 iter_flags,void (* iterator)(void * data,u8 * mac,struct ieee80211_vif * vif),void * data)774 void 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 }
786 EXPORT_SYMBOL_GPL(ieee80211_iterate_interfaces);
787 
ieee80211_iterate_active_interfaces_atomic(struct ieee80211_hw * hw,u32 iter_flags,void (* iterator)(void * data,u8 * mac,struct ieee80211_vif * vif),void * data)788 void 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 }
801 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_atomic);
802 
ieee80211_iterate_active_interfaces_mtx(struct ieee80211_hw * hw,u32 iter_flags,void (* iterator)(void * data,u8 * mac,struct ieee80211_vif * vif),void * data)803 void 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 }
816 EXPORT_SYMBOL_GPL(ieee80211_iterate_active_interfaces_mtx);
817 
__iterate_stations(struct ieee80211_local * local,void (* iterator)(void * data,struct ieee80211_sta * sta),void * data)818 static 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 
ieee80211_iterate_stations_atomic(struct ieee80211_hw * hw,void (* iterator)(void * data,struct ieee80211_sta * sta),void * data)834 void 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 }
845 EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_atomic);
846 
ieee80211_iterate_stations_mtx(struct ieee80211_hw * hw,void (* iterator)(void * data,struct ieee80211_sta * sta),void * data)847 void 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 }
858 EXPORT_SYMBOL_GPL(ieee80211_iterate_stations_mtx);
859 
wdev_to_ieee80211_vif(struct wireless_dev * wdev)860 struct 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 }
869 EXPORT_SYMBOL_GPL(wdev_to_ieee80211_vif);
870 
ieee80211_vif_to_wdev(struct ieee80211_vif * vif)871 struct 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 }
878 EXPORT_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  */
ieee80211_can_queue_work(struct ieee80211_local * local)889 static 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 
ieee80211_queue_work(struct ieee80211_hw * hw,struct work_struct * work)899 void 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 }
908 EXPORT_SYMBOL(ieee80211_queue_work);
909 
ieee80211_queue_delayed_work(struct ieee80211_hw * hw,struct delayed_work * dwork,unsigned long delay)910 void 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 }
921 EXPORT_SYMBOL(ieee80211_queue_delayed_work);
922 
ieee80211_regulatory_limit_wmm_params(struct ieee80211_sub_if_data * sdata,struct ieee80211_tx_queue_params * qparam,int ac)923 void 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 
ieee80211_set_wmm_default(struct ieee80211_link_data * link,bool bss_notify,bool enable_qos)964 void 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 
ieee80211_send_auth(struct ieee80211_sub_if_data * sdata,u16 transaction,u16 auth_alg,u16 status,const u8 * extra,size_t extra_len,const u8 * da,const u8 * bssid,const u8 * key,u8 key_len,u8 key_idx,u32 tx_flags)1076 void 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 
ieee80211_send_deauth_disassoc(struct ieee80211_sub_if_data * sdata,const u8 * da,const u8 * bssid,u16 stype,u16 reason,bool send_frame,u8 * frame_buf)1140 void 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 
ieee80211_put_s1g_cap(struct sk_buff * skb,struct ieee80211_sta_s1g_cap * s1g_cap)1179 static 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 
ieee80211_put_preq_ies_band(struct sk_buff * skb,struct ieee80211_sub_if_data * sdata,const u8 * ie,size_t ie_len,size_t * offset,enum nl80211_band band,u32 rate_mask,struct cfg80211_chan_def * chandef,u32 flags)1194 static 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 	u32 rate_flags;
1208 	bool have_80mhz = false;
1209 
1210 	*offset = 0;
1211 
1212 	sband = local->hw.wiphy->bands[band];
1213 	if (WARN_ON_ONCE(!sband))
1214 		return 0;
1215 
1216 	rate_flags = ieee80211_chandef_rate_flags(chandef);
1217 
1218 	/* For direct scan add S1G IE and consider its override bits */
1219 	if (band == NL80211_BAND_S1GHZ)
1220 		return ieee80211_put_s1g_cap(skb, &sband->s1g_cap);
1221 
1222 	err = ieee80211_put_srates_elem(skb, sband, 0, rate_flags,
1223 					~rate_mask, WLAN_EID_SUPP_RATES);
1224 	if (err)
1225 		return err;
1226 
1227 	/* insert "request information" if in custom IEs */
1228 	if (ie && ie_len) {
1229 		static const u8 before_extrates[] = {
1230 			WLAN_EID_SSID,
1231 			WLAN_EID_SUPP_RATES,
1232 			WLAN_EID_REQUEST,
1233 		};
1234 		noffset = ieee80211_ie_split(ie, ie_len,
1235 					     before_extrates,
1236 					     ARRAY_SIZE(before_extrates),
1237 					     *offset);
1238 		if (skb_tailroom(skb) < noffset - *offset)
1239 			return -ENOBUFS;
1240 		skb_put_data(skb, ie + *offset, noffset - *offset);
1241 		*offset = noffset;
1242 	}
1243 
1244 	err = ieee80211_put_srates_elem(skb, sband, 0, rate_flags,
1245 					~rate_mask, WLAN_EID_EXT_SUPP_RATES);
1246 	if (err)
1247 		return err;
1248 
1249 	if (chandef->chan && sband->band == NL80211_BAND_2GHZ) {
1250 		if (skb_tailroom(skb) < 3)
1251 			return -ENOBUFS;
1252 		skb_put_u8(skb, WLAN_EID_DS_PARAMS);
1253 		skb_put_u8(skb, 1);
1254 		skb_put_u8(skb,
1255 			   ieee80211_frequency_to_channel(chandef->chan->center_freq));
1256 	}
1257 
1258 	if (flags & IEEE80211_PROBE_FLAG_MIN_CONTENT)
1259 		return 0;
1260 
1261 	/* insert custom IEs that go before HT */
1262 	if (ie && ie_len) {
1263 		static const u8 before_ht[] = {
1264 			/*
1265 			 * no need to list the ones split off already
1266 			 * (or generated here)
1267 			 */
1268 			WLAN_EID_DS_PARAMS,
1269 			WLAN_EID_SUPPORTED_REGULATORY_CLASSES,
1270 		};
1271 		noffset = ieee80211_ie_split(ie, ie_len,
1272 					     before_ht, ARRAY_SIZE(before_ht),
1273 					     *offset);
1274 		if (skb_tailroom(skb) < noffset - *offset)
1275 			return -ENOBUFS;
1276 		skb_put_data(skb, ie + *offset, noffset - *offset);
1277 		*offset = noffset;
1278 	}
1279 
1280 	if (sband->ht_cap.ht_supported) {
1281 		u8 *pos;
1282 
1283 		if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_ht_cap))
1284 			return -ENOBUFS;
1285 
1286 		pos = skb_put(skb, 2 + sizeof(struct ieee80211_ht_cap));
1287 		ieee80211_ie_build_ht_cap(pos, &sband->ht_cap,
1288 					  sband->ht_cap.cap);
1289 	}
1290 
1291 	/* insert custom IEs that go before VHT */
1292 	if (ie && ie_len) {
1293 		static const u8 before_vht[] = {
1294 			/*
1295 			 * no need to list the ones split off already
1296 			 * (or generated here)
1297 			 */
1298 			WLAN_EID_BSS_COEX_2040,
1299 			WLAN_EID_EXT_CAPABILITY,
1300 			WLAN_EID_SSID_LIST,
1301 			WLAN_EID_CHANNEL_USAGE,
1302 			WLAN_EID_INTERWORKING,
1303 			WLAN_EID_MESH_ID,
1304 			/* 60 GHz (Multi-band, DMG, MMS) can't happen */
1305 		};
1306 		noffset = ieee80211_ie_split(ie, ie_len,
1307 					     before_vht, ARRAY_SIZE(before_vht),
1308 					     *offset);
1309 		if (skb_tailroom(skb) < noffset - *offset)
1310 			return -ENOBUFS;
1311 		skb_put_data(skb, ie + *offset, noffset - *offset);
1312 		*offset = noffset;
1313 	}
1314 
1315 	/* Check if any channel in this sband supports at least 80 MHz */
1316 	for (i = 0; i < sband->n_channels; i++) {
1317 		if (sband->channels[i].flags & (IEEE80211_CHAN_DISABLED |
1318 						IEEE80211_CHAN_NO_80MHZ))
1319 			continue;
1320 
1321 		have_80mhz = true;
1322 		break;
1323 	}
1324 
1325 	if (sband->vht_cap.vht_supported && have_80mhz) {
1326 		u8 *pos;
1327 
1328 		if (skb_tailroom(skb) < 2 + sizeof(struct ieee80211_vht_cap))
1329 			return -ENOBUFS;
1330 
1331 		pos = skb_put(skb, 2 + sizeof(struct ieee80211_vht_cap));
1332 		ieee80211_ie_build_vht_cap(pos, &sband->vht_cap,
1333 					   sband->vht_cap.cap);
1334 	}
1335 
1336 	/* insert custom IEs that go before HE */
1337 	if (ie && ie_len) {
1338 		static const u8 before_he[] = {
1339 			/*
1340 			 * no need to list the ones split off before VHT
1341 			 * or generated here
1342 			 */
1343 			WLAN_EID_EXTENSION, WLAN_EID_EXT_FILS_REQ_PARAMS,
1344 			WLAN_EID_AP_CSN,
1345 			/* TODO: add 11ah/11aj/11ak elements */
1346 		};
1347 		noffset = ieee80211_ie_split(ie, ie_len,
1348 					     before_he, ARRAY_SIZE(before_he),
1349 					     *offset);
1350 		if (skb_tailroom(skb) < noffset - *offset)
1351 			return -ENOBUFS;
1352 		skb_put_data(skb, ie + *offset, noffset - *offset);
1353 		*offset = noffset;
1354 	}
1355 
1356 	if (cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1357 					 IEEE80211_CHAN_NO_HE)) {
1358 		err = ieee80211_put_he_cap(skb, sdata, sband, NULL);
1359 		if (err)
1360 			return err;
1361 	}
1362 
1363 	if (cfg80211_any_usable_channels(local->hw.wiphy, BIT(sband->band),
1364 					 IEEE80211_CHAN_NO_HE |
1365 					 IEEE80211_CHAN_NO_EHT)) {
1366 		err = ieee80211_put_eht_cap(skb, sdata, sband, NULL);
1367 		if (err)
1368 			return err;
1369 	}
1370 
1371 	err = ieee80211_put_he_6ghz_cap(skb, sdata, IEEE80211_SMPS_OFF);
1372 	if (err)
1373 		return err;
1374 
1375 	/*
1376 	 * If adding more here, adjust code in main.c
1377 	 * that calculates local->scan_ies_len.
1378 	 */
1379 
1380 	return 0;
1381 }
1382 
ieee80211_put_preq_ies(struct sk_buff * skb,struct ieee80211_sub_if_data * sdata,struct ieee80211_scan_ies * ie_desc,const u8 * ie,size_t ie_len,u8 bands_used,u32 * rate_masks,struct cfg80211_chan_def * chandef,u32 flags)1383 static int ieee80211_put_preq_ies(struct sk_buff *skb,
1384 				  struct ieee80211_sub_if_data *sdata,
1385 				  struct ieee80211_scan_ies *ie_desc,
1386 				  const u8 *ie, size_t ie_len,
1387 				  u8 bands_used, u32 *rate_masks,
1388 				  struct cfg80211_chan_def *chandef,
1389 				  u32 flags)
1390 {
1391 	size_t custom_ie_offset = 0;
1392 	int i, err;
1393 
1394 	memset(ie_desc, 0, sizeof(*ie_desc));
1395 
1396 	for (i = 0; i < NUM_NL80211_BANDS; i++) {
1397 		if (bands_used & BIT(i)) {
1398 			ie_desc->ies[i] = skb_tail_pointer(skb);
1399 			err = ieee80211_put_preq_ies_band(skb, sdata,
1400 							  ie, ie_len,
1401 							  &custom_ie_offset,
1402 							  i, rate_masks[i],
1403 							  chandef, flags);
1404 			if (err)
1405 				return err;
1406 			ie_desc->len[i] = skb_tail_pointer(skb) -
1407 					  ie_desc->ies[i];
1408 		}
1409 	}
1410 
1411 	/* add any remaining custom IEs */
1412 	if (ie && ie_len) {
1413 		if (WARN_ONCE(skb_tailroom(skb) < ie_len - custom_ie_offset,
1414 			      "not enough space for preq custom IEs\n"))
1415 			return -ENOBUFS;
1416 		ie_desc->common_ies = skb_tail_pointer(skb);
1417 		skb_put_data(skb, ie + custom_ie_offset,
1418 			     ie_len - custom_ie_offset);
1419 		ie_desc->common_ie_len = skb_tail_pointer(skb) -
1420 					 ie_desc->common_ies;
1421 	}
1422 
1423 	return 0;
1424 };
1425 
ieee80211_build_preq_ies(struct ieee80211_sub_if_data * sdata,u8 * buffer,size_t buffer_len,struct ieee80211_scan_ies * ie_desc,const u8 * ie,size_t ie_len,u8 bands_used,u32 * rate_masks,struct cfg80211_chan_def * chandef,u32 flags)1426 int ieee80211_build_preq_ies(struct ieee80211_sub_if_data *sdata, u8 *buffer,
1427 			     size_t buffer_len,
1428 			     struct ieee80211_scan_ies *ie_desc,
1429 			     const u8 *ie, size_t ie_len,
1430 			     u8 bands_used, u32 *rate_masks,
1431 			     struct cfg80211_chan_def *chandef,
1432 			     u32 flags)
1433 {
1434 	struct sk_buff *skb = alloc_skb(buffer_len, GFP_KERNEL);
1435 	uintptr_t offs;
1436 	int ret, i;
1437 	u8 *start;
1438 
1439 	if (!skb)
1440 		return -ENOMEM;
1441 
1442 	start = skb_tail_pointer(skb);
1443 	memset(start, 0, skb_tailroom(skb));
1444 	ret = ieee80211_put_preq_ies(skb, sdata, ie_desc, ie, ie_len,
1445 				     bands_used, rate_masks, chandef,
1446 				     flags);
1447 	if (ret < 0) {
1448 		goto out;
1449 	}
1450 
1451 	if (skb->len > buffer_len) {
1452 		ret = -ENOBUFS;
1453 		goto out;
1454 	}
1455 
1456 	memcpy(buffer, start, skb->len);
1457 
1458 	/* adjust ie_desc for copy */
1459 	for (i = 0; i < NUM_NL80211_BANDS; i++) {
1460 		offs = ie_desc->ies[i] - start;
1461 		ie_desc->ies[i] = buffer + offs;
1462 	}
1463 	offs = ie_desc->common_ies - start;
1464 	ie_desc->common_ies = buffer + offs;
1465 
1466 	ret = skb->len;
1467 out:
1468 	consume_skb(skb);
1469 	return ret;
1470 }
1471 
ieee80211_build_probe_req(struct ieee80211_sub_if_data * sdata,const u8 * src,const u8 * dst,u32 ratemask,struct ieee80211_channel * chan,const u8 * ssid,size_t ssid_len,const u8 * ie,size_t ie_len,u32 flags)1472 struct sk_buff *ieee80211_build_probe_req(struct ieee80211_sub_if_data *sdata,
1473 					  const u8 *src, const u8 *dst,
1474 					  u32 ratemask,
1475 					  struct ieee80211_channel *chan,
1476 					  const u8 *ssid, size_t ssid_len,
1477 					  const u8 *ie, size_t ie_len,
1478 					  u32 flags)
1479 {
1480 	struct ieee80211_local *local = sdata->local;
1481 	struct cfg80211_chan_def chandef;
1482 	struct sk_buff *skb;
1483 	struct ieee80211_mgmt *mgmt;
1484 	u32 rate_masks[NUM_NL80211_BANDS] = {};
1485 	struct ieee80211_scan_ies dummy_ie_desc;
1486 
1487 	/*
1488 	 * Do not send DS Channel parameter for directed probe requests
1489 	 * in order to maximize the chance that we get a response.  Some
1490 	 * badly-behaved APs don't respond when this parameter is included.
1491 	 */
1492 	chandef.width = sdata->vif.bss_conf.chanreq.oper.width;
1493 	if (flags & IEEE80211_PROBE_FLAG_DIRECTED)
1494 		chandef.chan = NULL;
1495 	else
1496 		chandef.chan = chan;
1497 
1498 	skb = ieee80211_probereq_get(&local->hw, src, ssid, ssid_len,
1499 				     local->scan_ies_len + ie_len);
1500 	if (!skb)
1501 		return NULL;
1502 
1503 	rate_masks[chan->band] = ratemask;
1504 	ieee80211_put_preq_ies(skb, sdata, &dummy_ie_desc,
1505 			       ie, ie_len, BIT(chan->band),
1506 			       rate_masks, &chandef, flags);
1507 
1508 	if (dst) {
1509 		mgmt = (struct ieee80211_mgmt *) skb->data;
1510 		memcpy(mgmt->da, dst, ETH_ALEN);
1511 		memcpy(mgmt->bssid, dst, ETH_ALEN);
1512 	}
1513 
1514 	IEEE80211_SKB_CB(skb)->flags |= IEEE80211_TX_INTFL_DONT_ENCRYPT;
1515 
1516 	return skb;
1517 }
1518 
ieee80211_sta_get_rates(struct ieee80211_sub_if_data * sdata,struct ieee802_11_elems * elems,enum nl80211_band band,u32 * basic_rates)1519 u32 ieee80211_sta_get_rates(struct ieee80211_sub_if_data *sdata,
1520 			    struct ieee802_11_elems *elems,
1521 			    enum nl80211_band band, u32 *basic_rates)
1522 {
1523 	struct ieee80211_supported_band *sband;
1524 	size_t num_rates;
1525 	u32 supp_rates, rate_flags;
1526 	int i, j;
1527 
1528 	sband = sdata->local->hw.wiphy->bands[band];
1529 	if (WARN_ON(!sband))
1530 		return 1;
1531 
1532 	rate_flags =
1533 		ieee80211_chandef_rate_flags(&sdata->vif.bss_conf.chanreq.oper);
1534 
1535 	num_rates = sband->n_bitrates;
1536 	supp_rates = 0;
1537 	for (i = 0; i < elems->supp_rates_len +
1538 		     elems->ext_supp_rates_len; i++) {
1539 		u8 rate = 0;
1540 		int own_rate;
1541 		bool is_basic;
1542 		if (i < elems->supp_rates_len)
1543 			rate = elems->supp_rates[i];
1544 		else if (elems->ext_supp_rates)
1545 			rate = elems->ext_supp_rates
1546 				[i - elems->supp_rates_len];
1547 		own_rate = 5 * (rate & 0x7f);
1548 		is_basic = !!(rate & 0x80);
1549 
1550 		if (is_basic && (rate & 0x7f) == BSS_MEMBERSHIP_SELECTOR_HT_PHY)
1551 			continue;
1552 
1553 		for (j = 0; j < num_rates; j++) {
1554 			int brate;
1555 			if ((rate_flags & sband->bitrates[j].flags)
1556 			    != rate_flags)
1557 				continue;
1558 
1559 			brate = sband->bitrates[j].bitrate;
1560 
1561 			if (brate == own_rate) {
1562 				supp_rates |= BIT(j);
1563 				if (basic_rates && is_basic)
1564 					*basic_rates |= BIT(j);
1565 			}
1566 		}
1567 	}
1568 	return supp_rates;
1569 }
1570 
ieee80211_stop_device(struct ieee80211_local * local,bool suspend)1571 void ieee80211_stop_device(struct ieee80211_local *local, bool suspend)
1572 {
1573 	local_bh_disable();
1574 	ieee80211_handle_queued_frames(local);
1575 	local_bh_enable();
1576 
1577 	ieee80211_led_radio(local, false);
1578 	ieee80211_mod_tpt_led_trig(local, 0, IEEE80211_TPT_LEDTRIG_FL_RADIO);
1579 
1580 	wiphy_work_cancel(local->hw.wiphy, &local->reconfig_filter);
1581 
1582 	flush_workqueue(local->workqueue);
1583 	wiphy_work_flush(local->hw.wiphy, NULL);
1584 	drv_stop(local, suspend);
1585 }
1586 
ieee80211_flush_completed_scan(struct ieee80211_local * local,bool aborted)1587 static void ieee80211_flush_completed_scan(struct ieee80211_local *local,
1588 					   bool aborted)
1589 {
1590 	/* It's possible that we don't handle the scan completion in
1591 	 * time during suspend, so if it's still marked as completed
1592 	 * here, queue the work and flush it to clean things up.
1593 	 * Instead of calling the worker function directly here, we
1594 	 * really queue it to avoid potential races with other flows
1595 	 * scheduling the same work.
1596 	 */
1597 	if (test_bit(SCAN_COMPLETED, &local->scanning)) {
1598 		/* If coming from reconfiguration failure, abort the scan so
1599 		 * we don't attempt to continue a partial HW scan - which is
1600 		 * possible otherwise if (e.g.) the 2.4 GHz portion was the
1601 		 * completed scan, and a 5 GHz portion is still pending.
1602 		 */
1603 		if (aborted)
1604 			set_bit(SCAN_ABORTED, &local->scanning);
1605 		wiphy_delayed_work_queue(local->hw.wiphy, &local->scan_work, 0);
1606 		wiphy_delayed_work_flush(local->hw.wiphy, &local->scan_work);
1607 	}
1608 }
1609 
ieee80211_handle_reconfig_failure(struct ieee80211_local * local)1610 static void ieee80211_handle_reconfig_failure(struct ieee80211_local *local)
1611 {
1612 	struct ieee80211_sub_if_data *sdata;
1613 	struct ieee80211_chanctx *ctx;
1614 
1615 	lockdep_assert_wiphy(local->hw.wiphy);
1616 
1617 	/*
1618 	 * We get here if during resume the device can't be restarted properly.
1619 	 * We might also get here if this happens during HW reset, which is a
1620 	 * slightly different situation and we need to drop all connections in
1621 	 * the latter case.
1622 	 *
1623 	 * Ask cfg80211 to turn off all interfaces, this will result in more
1624 	 * warnings but at least we'll then get into a clean stopped state.
1625 	 */
1626 
1627 	local->resuming = false;
1628 	local->suspended = false;
1629 	local->in_reconfig = false;
1630 	local->reconfig_failure = true;
1631 
1632 	ieee80211_flush_completed_scan(local, true);
1633 
1634 	/* scheduled scan clearly can't be running any more, but tell
1635 	 * cfg80211 and clear local state
1636 	 */
1637 	ieee80211_sched_scan_end(local);
1638 
1639 	list_for_each_entry(sdata, &local->interfaces, list)
1640 		sdata->flags &= ~IEEE80211_SDATA_IN_DRIVER;
1641 
1642 	/* Mark channel contexts as not being in the driver any more to avoid
1643 	 * removing them from the driver during the shutdown process...
1644 	 */
1645 	list_for_each_entry(ctx, &local->chanctx_list, list)
1646 		ctx->driver_present = false;
1647 }
1648 
ieee80211_assign_chanctx(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata,struct ieee80211_link_data * link)1649 static void ieee80211_assign_chanctx(struct ieee80211_local *local,
1650 				     struct ieee80211_sub_if_data *sdata,
1651 				     struct ieee80211_link_data *link)
1652 {
1653 	struct ieee80211_chanctx_conf *conf;
1654 	struct ieee80211_chanctx *ctx;
1655 
1656 	lockdep_assert_wiphy(local->hw.wiphy);
1657 
1658 	conf = rcu_dereference_protected(link->conf->chanctx_conf,
1659 					 lockdep_is_held(&local->hw.wiphy->mtx));
1660 	if (conf) {
1661 		ctx = container_of(conf, struct ieee80211_chanctx, conf);
1662 		drv_assign_vif_chanctx(local, sdata, link->conf, ctx);
1663 	}
1664 }
1665 
ieee80211_reconfig_stations(struct ieee80211_sub_if_data * sdata)1666 static void ieee80211_reconfig_stations(struct ieee80211_sub_if_data *sdata)
1667 {
1668 	struct ieee80211_local *local = sdata->local;
1669 	struct sta_info *sta;
1670 
1671 	lockdep_assert_wiphy(local->hw.wiphy);
1672 
1673 	/* add STAs back */
1674 	list_for_each_entry(sta, &local->sta_list, list) {
1675 		enum ieee80211_sta_state state;
1676 
1677 		if (!sta->uploaded || sta->sdata != sdata)
1678 			continue;
1679 
1680 		for (state = IEEE80211_STA_NOTEXIST;
1681 		     state < sta->sta_state; state++)
1682 			WARN_ON(drv_sta_state(local, sta->sdata, sta, state,
1683 					      state + 1));
1684 	}
1685 }
1686 
ieee80211_reconfig_nan(struct ieee80211_sub_if_data * sdata)1687 static int ieee80211_reconfig_nan(struct ieee80211_sub_if_data *sdata)
1688 {
1689 	struct cfg80211_nan_func *func, **funcs;
1690 	int res, id, i = 0;
1691 
1692 	res = drv_start_nan(sdata->local, sdata,
1693 			    &sdata->u.nan.conf);
1694 	if (WARN_ON(res))
1695 		return res;
1696 
1697 	funcs = kcalloc(sdata->local->hw.max_nan_de_entries + 1,
1698 			sizeof(*funcs),
1699 			GFP_KERNEL);
1700 	if (!funcs)
1701 		return -ENOMEM;
1702 
1703 	/* Add all the functions:
1704 	 * This is a little bit ugly. We need to call a potentially sleeping
1705 	 * callback for each NAN function, so we can't hold the spinlock.
1706 	 */
1707 	spin_lock_bh(&sdata->u.nan.func_lock);
1708 
1709 	idr_for_each_entry(&sdata->u.nan.function_inst_ids, func, id)
1710 		funcs[i++] = func;
1711 
1712 	spin_unlock_bh(&sdata->u.nan.func_lock);
1713 
1714 	for (i = 0; funcs[i]; i++) {
1715 		res = drv_add_nan_func(sdata->local, sdata, funcs[i]);
1716 		if (WARN_ON(res))
1717 			ieee80211_nan_func_terminated(&sdata->vif,
1718 						      funcs[i]->instance_id,
1719 						      NL80211_NAN_FUNC_TERM_REASON_ERROR,
1720 						      GFP_KERNEL);
1721 	}
1722 
1723 	kfree(funcs);
1724 
1725 	return 0;
1726 }
1727 
ieee80211_reconfig_ap_links(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata,u64 changed)1728 static void ieee80211_reconfig_ap_links(struct ieee80211_local *local,
1729 					struct ieee80211_sub_if_data *sdata,
1730 					u64 changed)
1731 {
1732 	int link_id;
1733 
1734 	for (link_id = 0; link_id < ARRAY_SIZE(sdata->link); link_id++) {
1735 		struct ieee80211_link_data *link;
1736 
1737 		if (!(sdata->vif.active_links & BIT(link_id)))
1738 			continue;
1739 
1740 		link = sdata_dereference(sdata->link[link_id], sdata);
1741 		if (!link)
1742 			continue;
1743 
1744 		if (rcu_access_pointer(link->u.ap.beacon))
1745 			drv_start_ap(local, sdata, link->conf);
1746 
1747 		if (!link->conf->enable_beacon)
1748 			continue;
1749 
1750 		changed |= BSS_CHANGED_BEACON |
1751 			   BSS_CHANGED_BEACON_ENABLED;
1752 
1753 		ieee80211_link_info_change_notify(sdata, link, changed);
1754 	}
1755 }
1756 
ieee80211_reconfig(struct ieee80211_local * local)1757 int ieee80211_reconfig(struct ieee80211_local *local)
1758 {
1759 	struct ieee80211_hw *hw = &local->hw;
1760 	struct ieee80211_sub_if_data *sdata;
1761 	struct ieee80211_chanctx *ctx;
1762 	struct sta_info *sta;
1763 	int res, i;
1764 	bool reconfig_due_to_wowlan = false;
1765 	struct ieee80211_sub_if_data *sched_scan_sdata;
1766 	struct cfg80211_sched_scan_request *sched_scan_req;
1767 	bool sched_scan_stopped = false;
1768 	bool suspended = local->suspended;
1769 	bool in_reconfig = false;
1770 
1771 	lockdep_assert_wiphy(local->hw.wiphy);
1772 
1773 	/* nothing to do if HW shouldn't run */
1774 	if (!local->open_count)
1775 		goto wake_up;
1776 
1777 #ifdef CONFIG_PM
1778 	if (suspended)
1779 		local->resuming = true;
1780 
1781 	if (local->wowlan) {
1782 		/*
1783 		 * In the wowlan case, both mac80211 and the device
1784 		 * are functional when the resume op is called, so
1785 		 * clear local->suspended so the device could operate
1786 		 * normally (e.g. pass rx frames).
1787 		 */
1788 		local->suspended = false;
1789 		res = drv_resume(local);
1790 		local->wowlan = false;
1791 		if (res < 0) {
1792 			local->resuming = false;
1793 			return res;
1794 		}
1795 		if (res == 0)
1796 			goto wake_up;
1797 		WARN_ON(res > 1);
1798 		/*
1799 		 * res is 1, which means the driver requested
1800 		 * to go through a regular reset on wakeup.
1801 		 * restore local->suspended in this case.
1802 		 */
1803 		reconfig_due_to_wowlan = true;
1804 		local->suspended = true;
1805 	}
1806 #endif
1807 
1808 	/*
1809 	 * In case of hw_restart during suspend (without wowlan),
1810 	 * cancel restart work, as we are reconfiguring the device
1811 	 * anyway.
1812 	 * Note that restart_work is scheduled on a frozen workqueue,
1813 	 * so we can't deadlock in this case.
1814 	 */
1815 	if (suspended && local->in_reconfig && !reconfig_due_to_wowlan)
1816 		cancel_work_sync(&local->restart_work);
1817 
1818 	local->started = false;
1819 
1820 	/*
1821 	 * Upon resume hardware can sometimes be goofy due to
1822 	 * various platform / driver / bus issues, so restarting
1823 	 * the device may at times not work immediately. Propagate
1824 	 * the error.
1825 	 */
1826 	res = drv_start(local);
1827 	if (res) {
1828 		if (suspended)
1829 			WARN(1, "Hardware became unavailable upon resume. This could be a software issue prior to suspend or a hardware issue.\n");
1830 		else
1831 			WARN(1, "Hardware became unavailable during restart.\n");
1832 		ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
1833 						IEEE80211_QUEUE_STOP_REASON_SUSPEND,
1834 						false);
1835 		ieee80211_handle_reconfig_failure(local);
1836 		return res;
1837 	}
1838 
1839 	/* setup fragmentation threshold */
1840 	drv_set_frag_threshold(local, hw->wiphy->frag_threshold);
1841 
1842 	/* setup RTS threshold */
1843 	drv_set_rts_threshold(local, hw->wiphy->rts_threshold);
1844 
1845 	/* reset coverage class */
1846 	drv_set_coverage_class(local, hw->wiphy->coverage_class);
1847 
1848 	ieee80211_led_radio(local, true);
1849 	ieee80211_mod_tpt_led_trig(local,
1850 				   IEEE80211_TPT_LEDTRIG_FL_RADIO, 0);
1851 
1852 	/* add interfaces */
1853 	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);
1854 	if (sdata && ieee80211_hw_check(&local->hw, WANT_MONITOR_VIF)) {
1855 		/* in HW restart it exists already */
1856 		WARN_ON(local->resuming);
1857 		res = drv_add_interface(local, sdata);
1858 		if (WARN_ON(res)) {
1859 			RCU_INIT_POINTER(local->monitor_sdata, NULL);
1860 			synchronize_net();
1861 			kfree(sdata);
1862 		}
1863 	}
1864 
1865 	list_for_each_entry(sdata, &local->interfaces, list) {
1866 		if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
1867 		    !ieee80211_hw_check(&local->hw, NO_VIRTUAL_MONITOR))
1868 			continue;
1869 		if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1870 		    ieee80211_sdata_running(sdata)) {
1871 			res = drv_add_interface(local, sdata);
1872 			if (WARN_ON(res))
1873 				break;
1874 		}
1875 	}
1876 
1877 	/* If adding any of the interfaces failed above, roll back and
1878 	 * report failure.
1879 	 */
1880 	if (res) {
1881 		list_for_each_entry_continue_reverse(sdata, &local->interfaces,
1882 						     list) {
1883 			if (sdata->vif.type == NL80211_IFTYPE_MONITOR &&
1884 			    !ieee80211_hw_check(&local->hw, NO_VIRTUAL_MONITOR))
1885 				continue;
1886 			if (sdata->vif.type != NL80211_IFTYPE_AP_VLAN &&
1887 			    ieee80211_sdata_running(sdata))
1888 				drv_remove_interface(local, sdata);
1889 		}
1890 		ieee80211_handle_reconfig_failure(local);
1891 		return res;
1892 	}
1893 
1894 	/* add channel contexts */
1895 	list_for_each_entry(ctx, &local->chanctx_list, list)
1896 		if (ctx->replace_state != IEEE80211_CHANCTX_REPLACES_OTHER)
1897 			WARN_ON(drv_add_chanctx(local, ctx));
1898 
1899 	sdata = wiphy_dereference(local->hw.wiphy, local->monitor_sdata);
1900 	if (sdata && ieee80211_sdata_running(sdata))
1901 		ieee80211_assign_chanctx(local, sdata, &sdata->deflink);
1902 
1903 	/* reconfigure hardware */
1904 	ieee80211_hw_config(local, IEEE80211_CONF_CHANGE_LISTEN_INTERVAL |
1905 				   IEEE80211_CONF_CHANGE_MONITOR |
1906 				   IEEE80211_CONF_CHANGE_PS |
1907 				   IEEE80211_CONF_CHANGE_RETRY_LIMITS |
1908 				   IEEE80211_CONF_CHANGE_IDLE);
1909 
1910 	ieee80211_configure_filter(local);
1911 
1912 	/* Finally also reconfigure all the BSS information */
1913 	list_for_each_entry(sdata, &local->interfaces, list) {
1914 		/* common change flags for all interface types - link only */
1915 		u64 changed = BSS_CHANGED_ERP_CTS_PROT |
1916 			      BSS_CHANGED_ERP_PREAMBLE |
1917 			      BSS_CHANGED_ERP_SLOT |
1918 			      BSS_CHANGED_HT |
1919 			      BSS_CHANGED_BASIC_RATES |
1920 			      BSS_CHANGED_BEACON_INT |
1921 			      BSS_CHANGED_BSSID |
1922 			      BSS_CHANGED_CQM |
1923 			      BSS_CHANGED_QOS |
1924 			      BSS_CHANGED_TXPOWER |
1925 			      BSS_CHANGED_MCAST_RATE;
1926 		struct ieee80211_link_data *link = NULL;
1927 		unsigned int link_id;
1928 		u32 active_links = 0;
1929 
1930 		if (!ieee80211_sdata_running(sdata))
1931 			continue;
1932 
1933 		if (ieee80211_vif_is_mld(&sdata->vif)) {
1934 			struct ieee80211_bss_conf *old[IEEE80211_MLD_MAX_NUM_LINKS] = {
1935 				[0] = &sdata->vif.bss_conf,
1936 			};
1937 
1938 			if (sdata->vif.type == NL80211_IFTYPE_STATION) {
1939 				/* start with a single active link */
1940 				active_links = sdata->vif.active_links;
1941 				link_id = ffs(active_links) - 1;
1942 				sdata->vif.active_links = BIT(link_id);
1943 			}
1944 
1945 			drv_change_vif_links(local, sdata, 0,
1946 					     sdata->vif.active_links,
1947 					     old);
1948 		}
1949 
1950 		sdata->restart_active_links = active_links;
1951 
1952 		for (link_id = 0;
1953 		     link_id < ARRAY_SIZE(sdata->vif.link_conf);
1954 		     link_id++) {
1955 			if (!ieee80211_vif_link_active(&sdata->vif, link_id))
1956 				continue;
1957 
1958 			link = sdata_dereference(sdata->link[link_id], sdata);
1959 			if (!link)
1960 				continue;
1961 
1962 			ieee80211_assign_chanctx(local, sdata, link);
1963 		}
1964 
1965 		switch (sdata->vif.type) {
1966 		case NL80211_IFTYPE_AP_VLAN:
1967 		case NL80211_IFTYPE_MONITOR:
1968 			break;
1969 		case NL80211_IFTYPE_ADHOC:
1970 			if (sdata->vif.cfg.ibss_joined)
1971 				WARN_ON(drv_join_ibss(local, sdata));
1972 			fallthrough;
1973 		default:
1974 			ieee80211_reconfig_stations(sdata);
1975 			fallthrough;
1976 		case NL80211_IFTYPE_AP: /* AP stations are handled later */
1977 			for (i = 0; i < IEEE80211_NUM_ACS; i++)
1978 				drv_conf_tx(local, &sdata->deflink, i,
1979 					    &sdata->deflink.tx_conf[i]);
1980 			break;
1981 		}
1982 
1983 		if (sdata->vif.bss_conf.mu_mimo_owner)
1984 			changed |= BSS_CHANGED_MU_GROUPS;
1985 
1986 		if (!ieee80211_vif_is_mld(&sdata->vif))
1987 			changed |= BSS_CHANGED_IDLE;
1988 
1989 		switch (sdata->vif.type) {
1990 		case NL80211_IFTYPE_STATION:
1991 			if (!ieee80211_vif_is_mld(&sdata->vif)) {
1992 				changed |= BSS_CHANGED_ASSOC |
1993 					   BSS_CHANGED_ARP_FILTER |
1994 					   BSS_CHANGED_PS;
1995 
1996 				/* Re-send beacon info report to the driver */
1997 				if (sdata->deflink.u.mgd.have_beacon)
1998 					changed |= BSS_CHANGED_BEACON_INFO;
1999 
2000 				if (sdata->vif.bss_conf.max_idle_period ||
2001 				    sdata->vif.bss_conf.protected_keep_alive)
2002 					changed |= BSS_CHANGED_KEEP_ALIVE;
2003 
2004 				ieee80211_bss_info_change_notify(sdata,
2005 								 changed);
2006 			} else if (!WARN_ON(!link)) {
2007 				ieee80211_link_info_change_notify(sdata, link,
2008 								  changed);
2009 				changed = BSS_CHANGED_ASSOC |
2010 					  BSS_CHANGED_IDLE |
2011 					  BSS_CHANGED_PS |
2012 					  BSS_CHANGED_ARP_FILTER;
2013 				ieee80211_vif_cfg_change_notify(sdata, changed);
2014 			}
2015 			break;
2016 		case NL80211_IFTYPE_OCB:
2017 			changed |= BSS_CHANGED_OCB;
2018 			ieee80211_bss_info_change_notify(sdata, changed);
2019 			break;
2020 		case NL80211_IFTYPE_ADHOC:
2021 			changed |= BSS_CHANGED_IBSS;
2022 			fallthrough;
2023 		case NL80211_IFTYPE_AP:
2024 			changed |= BSS_CHANGED_P2P_PS;
2025 
2026 			if (ieee80211_vif_is_mld(&sdata->vif))
2027 				ieee80211_vif_cfg_change_notify(sdata,
2028 								BSS_CHANGED_SSID);
2029 			else
2030 				changed |= BSS_CHANGED_SSID;
2031 
2032 			if (sdata->vif.bss_conf.ftm_responder == 1 &&
2033 			    wiphy_ext_feature_isset(sdata->local->hw.wiphy,
2034 					NL80211_EXT_FEATURE_ENABLE_FTM_RESPONDER))
2035 				changed |= BSS_CHANGED_FTM_RESPONDER;
2036 
2037 			if (sdata->vif.type == NL80211_IFTYPE_AP) {
2038 				changed |= BSS_CHANGED_AP_PROBE_RESP;
2039 
2040 				if (ieee80211_vif_is_mld(&sdata->vif)) {
2041 					ieee80211_reconfig_ap_links(local,
2042 								    sdata,
2043 								    changed);
2044 					break;
2045 				}
2046 
2047 				if (rcu_access_pointer(sdata->deflink.u.ap.beacon))
2048 					drv_start_ap(local, sdata,
2049 						     sdata->deflink.conf);
2050 			}
2051 			fallthrough;
2052 		case NL80211_IFTYPE_MESH_POINT:
2053 			if (sdata->vif.bss_conf.enable_beacon) {
2054 				changed |= BSS_CHANGED_BEACON |
2055 					   BSS_CHANGED_BEACON_ENABLED;
2056 				ieee80211_bss_info_change_notify(sdata, changed);
2057 			}
2058 			break;
2059 		case NL80211_IFTYPE_NAN:
2060 			res = ieee80211_reconfig_nan(sdata);
2061 			if (res < 0) {
2062 				ieee80211_handle_reconfig_failure(local);
2063 				return res;
2064 			}
2065 			break;
2066 		case NL80211_IFTYPE_AP_VLAN:
2067 		case NL80211_IFTYPE_MONITOR:
2068 		case NL80211_IFTYPE_P2P_DEVICE:
2069 			/* nothing to do */
2070 			break;
2071 		case NL80211_IFTYPE_UNSPECIFIED:
2072 		case NUM_NL80211_IFTYPES:
2073 		case NL80211_IFTYPE_P2P_CLIENT:
2074 		case NL80211_IFTYPE_P2P_GO:
2075 		case NL80211_IFTYPE_WDS:
2076 			WARN_ON(1);
2077 			break;
2078 		}
2079 	}
2080 
2081 	ieee80211_recalc_ps(local);
2082 
2083 	/*
2084 	 * The sta might be in psm against the ap (e.g. because
2085 	 * this was the state before a hw restart), so we
2086 	 * explicitly send a null packet in order to make sure
2087 	 * it'll sync against the ap (and get out of psm).
2088 	 */
2089 	if (!(local->hw.conf.flags & IEEE80211_CONF_PS)) {
2090 		list_for_each_entry(sdata, &local->interfaces, list) {
2091 			if (sdata->vif.type != NL80211_IFTYPE_STATION)
2092 				continue;
2093 			if (!sdata->u.mgd.associated)
2094 				continue;
2095 
2096 			ieee80211_send_nullfunc(local, sdata, false);
2097 		}
2098 	}
2099 
2100 	/* APs are now beaconing, add back stations */
2101 	list_for_each_entry(sdata, &local->interfaces, list) {
2102 		if (!ieee80211_sdata_running(sdata))
2103 			continue;
2104 
2105 		switch (sdata->vif.type) {
2106 		case NL80211_IFTYPE_AP_VLAN:
2107 		case NL80211_IFTYPE_AP:
2108 			ieee80211_reconfig_stations(sdata);
2109 			break;
2110 		default:
2111 			break;
2112 		}
2113 	}
2114 
2115 	/* add back keys */
2116 	list_for_each_entry(sdata, &local->interfaces, list)
2117 		ieee80211_reenable_keys(sdata);
2118 
2119 	/* re-enable multi-link for client interfaces */
2120 	list_for_each_entry(sdata, &local->interfaces, list) {
2121 		if (sdata->restart_active_links)
2122 			ieee80211_set_active_links(&sdata->vif,
2123 						   sdata->restart_active_links);
2124 		/*
2125 		 * If a link switch was scheduled before the restart, and ran
2126 		 * before reconfig, it will do nothing, so re-schedule.
2127 		 */
2128 		if (sdata->desired_active_links)
2129 			wiphy_work_queue(sdata->local->hw.wiphy,
2130 					 &sdata->activate_links_work);
2131 	}
2132 
2133 	/* Reconfigure sched scan if it was interrupted by FW restart */
2134 	sched_scan_sdata = rcu_dereference_protected(local->sched_scan_sdata,
2135 						lockdep_is_held(&local->hw.wiphy->mtx));
2136 	sched_scan_req = rcu_dereference_protected(local->sched_scan_req,
2137 						lockdep_is_held(&local->hw.wiphy->mtx));
2138 	if (sched_scan_sdata && sched_scan_req)
2139 		/*
2140 		 * Sched scan stopped, but we don't want to report it. Instead,
2141 		 * we're trying to reschedule. However, if more than one scan
2142 		 * plan was set, we cannot reschedule since we don't know which
2143 		 * scan plan was currently running (and some scan plans may have
2144 		 * already finished).
2145 		 */
2146 		if (sched_scan_req->n_scan_plans > 1 ||
2147 		    __ieee80211_request_sched_scan_start(sched_scan_sdata,
2148 							 sched_scan_req)) {
2149 			RCU_INIT_POINTER(local->sched_scan_sdata, NULL);
2150 			RCU_INIT_POINTER(local->sched_scan_req, NULL);
2151 			sched_scan_stopped = true;
2152 		}
2153 
2154 	if (sched_scan_stopped)
2155 		cfg80211_sched_scan_stopped_locked(local->hw.wiphy, 0);
2156 
2157  wake_up:
2158 
2159 	if (local->monitors == local->open_count && local->monitors > 0)
2160 		ieee80211_add_virtual_monitor(local);
2161 
2162 	/*
2163 	 * Clear the WLAN_STA_BLOCK_BA flag so new aggregation
2164 	 * sessions can be established after a resume.
2165 	 *
2166 	 * Also tear down aggregation sessions since reconfiguring
2167 	 * them in a hardware restart scenario is not easily done
2168 	 * right now, and the hardware will have lost information
2169 	 * about the sessions, but we and the AP still think they
2170 	 * are active. This is really a workaround though.
2171 	 */
2172 	if (ieee80211_hw_check(hw, AMPDU_AGGREGATION)) {
2173 		list_for_each_entry(sta, &local->sta_list, list) {
2174 			if (!local->resuming)
2175 				ieee80211_sta_tear_down_BA_sessions(
2176 						sta, AGG_STOP_LOCAL_REQUEST);
2177 			clear_sta_flag(sta, WLAN_STA_BLOCK_BA);
2178 		}
2179 	}
2180 
2181 	/*
2182 	 * If this is for hw restart things are still running.
2183 	 * We may want to change that later, however.
2184 	 */
2185 	if (local->open_count && (!suspended || reconfig_due_to_wowlan))
2186 		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_RESTART);
2187 
2188 	if (local->in_reconfig) {
2189 		in_reconfig = local->in_reconfig;
2190 		local->in_reconfig = false;
2191 		barrier();
2192 
2193 		ieee80211_reconfig_roc(local);
2194 
2195 		/* Requeue all works */
2196 		list_for_each_entry(sdata, &local->interfaces, list) {
2197 			if (ieee80211_sdata_running(sdata))
2198 				wiphy_work_queue(local->hw.wiphy, &sdata->work);
2199 		}
2200 	}
2201 
2202 	ieee80211_wake_queues_by_reason(hw, IEEE80211_MAX_QUEUE_MAP,
2203 					IEEE80211_QUEUE_STOP_REASON_SUSPEND,
2204 					false);
2205 
2206 	if (in_reconfig) {
2207 		list_for_each_entry(sdata, &local->interfaces, list) {
2208 			if (!ieee80211_sdata_running(sdata))
2209 				continue;
2210 			if (sdata->vif.type == NL80211_IFTYPE_STATION)
2211 				ieee80211_sta_restart(sdata);
2212 		}
2213 	}
2214 
2215 	if (!suspended)
2216 		return 0;
2217 
2218 #ifdef CONFIG_PM
2219 	/* first set suspended false, then resuming */
2220 	local->suspended = false;
2221 	mb();
2222 	local->resuming = false;
2223 
2224 	ieee80211_flush_completed_scan(local, false);
2225 
2226 	if (local->open_count && !reconfig_due_to_wowlan)
2227 		drv_reconfig_complete(local, IEEE80211_RECONFIG_TYPE_SUSPEND);
2228 
2229 	list_for_each_entry(sdata, &local->interfaces, list) {
2230 		if (!ieee80211_sdata_running(sdata))
2231 			continue;
2232 		if (sdata->vif.type == NL80211_IFTYPE_STATION)
2233 			ieee80211_sta_restart(sdata);
2234 	}
2235 
2236 	mod_timer(&local->sta_cleanup, jiffies + 1);
2237 #else
2238 	WARN_ON(1);
2239 #endif
2240 
2241 	return 0;
2242 }
2243 
ieee80211_reconfig_disconnect(struct ieee80211_vif * vif,u8 flag)2244 static void ieee80211_reconfig_disconnect(struct ieee80211_vif *vif, u8 flag)
2245 {
2246 	struct ieee80211_sub_if_data *sdata;
2247 	struct ieee80211_local *local;
2248 	struct ieee80211_key *key;
2249 
2250 	if (WARN_ON(!vif))
2251 		return;
2252 
2253 	sdata = vif_to_sdata(vif);
2254 	local = sdata->local;
2255 
2256 	lockdep_assert_wiphy(local->hw.wiphy);
2257 
2258 	if (WARN_ON(flag & IEEE80211_SDATA_DISCONNECT_RESUME &&
2259 		    !local->resuming))
2260 		return;
2261 
2262 	if (WARN_ON(flag & IEEE80211_SDATA_DISCONNECT_HW_RESTART &&
2263 		    !local->in_reconfig))
2264 		return;
2265 
2266 	if (WARN_ON(vif->type != NL80211_IFTYPE_STATION))
2267 		return;
2268 
2269 	sdata->flags |= flag;
2270 
2271 	list_for_each_entry(key, &sdata->key_list, list)
2272 		key->flags |= KEY_FLAG_TAINTED;
2273 }
2274 
ieee80211_hw_restart_disconnect(struct ieee80211_vif * vif)2275 void ieee80211_hw_restart_disconnect(struct ieee80211_vif *vif)
2276 {
2277 	ieee80211_reconfig_disconnect(vif, IEEE80211_SDATA_DISCONNECT_HW_RESTART);
2278 }
2279 EXPORT_SYMBOL_GPL(ieee80211_hw_restart_disconnect);
2280 
ieee80211_resume_disconnect(struct ieee80211_vif * vif)2281 void ieee80211_resume_disconnect(struct ieee80211_vif *vif)
2282 {
2283 	ieee80211_reconfig_disconnect(vif, IEEE80211_SDATA_DISCONNECT_RESUME);
2284 }
2285 EXPORT_SYMBOL_GPL(ieee80211_resume_disconnect);
2286 
ieee80211_recalc_smps(struct ieee80211_sub_if_data * sdata,struct ieee80211_link_data * link)2287 void ieee80211_recalc_smps(struct ieee80211_sub_if_data *sdata,
2288 			   struct ieee80211_link_data *link)
2289 {
2290 	struct ieee80211_local *local = sdata->local;
2291 	struct ieee80211_chanctx_conf *chanctx_conf;
2292 	struct ieee80211_chanctx *chanctx;
2293 
2294 	lockdep_assert_wiphy(local->hw.wiphy);
2295 
2296 	chanctx_conf = rcu_dereference_protected(link->conf->chanctx_conf,
2297 						 lockdep_is_held(&local->hw.wiphy->mtx));
2298 
2299 	/*
2300 	 * This function can be called from a work, thus it may be possible
2301 	 * that the chanctx_conf is removed (due to a disconnection, for
2302 	 * example).
2303 	 * So nothing should be done in such case.
2304 	 */
2305 	if (!chanctx_conf)
2306 		return;
2307 
2308 	chanctx = container_of(chanctx_conf, struct ieee80211_chanctx, conf);
2309 	ieee80211_recalc_smps_chanctx(local, chanctx);
2310 }
2311 
ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data * sdata,int link_id)2312 void ieee80211_recalc_min_chandef(struct ieee80211_sub_if_data *sdata,
2313 				  int link_id)
2314 {
2315 	struct ieee80211_local *local = sdata->local;
2316 	struct ieee80211_chanctx_conf *chanctx_conf;
2317 	struct ieee80211_chanctx *chanctx;
2318 	int i;
2319 
2320 	lockdep_assert_wiphy(local->hw.wiphy);
2321 
2322 	for (i = 0; i < ARRAY_SIZE(sdata->vif.link_conf); i++) {
2323 		struct ieee80211_bss_conf *bss_conf;
2324 
2325 		if (link_id >= 0 && link_id != i)
2326 			continue;
2327 
2328 		rcu_read_lock();
2329 		bss_conf = rcu_dereference(sdata->vif.link_conf[i]);
2330 		if (!bss_conf) {
2331 			rcu_read_unlock();
2332 			continue;
2333 		}
2334 
2335 		chanctx_conf = rcu_dereference_protected(bss_conf->chanctx_conf,
2336 							 lockdep_is_held(&local->hw.wiphy->mtx));
2337 		/*
2338 		 * Since we hold the wiphy mutex (checked above)
2339 		 * we can take the chanctx_conf pointer out of the
2340 		 * RCU critical section, it cannot go away without
2341 		 * the mutex. Just the way we reached it could - in
2342 		 * theory - go away, but we don't really care and
2343 		 * it really shouldn't happen anyway.
2344 		 */
2345 		rcu_read_unlock();
2346 
2347 		if (!chanctx_conf)
2348 			return;
2349 
2350 		chanctx = container_of(chanctx_conf, struct ieee80211_chanctx,
2351 				       conf);
2352 		ieee80211_recalc_chanctx_min_def(local, chanctx, NULL, false);
2353 	}
2354 }
2355 
ieee80211_ie_split_vendor(const u8 * ies,size_t ielen,size_t offset)2356 size_t ieee80211_ie_split_vendor(const u8 *ies, size_t ielen, size_t offset)
2357 {
2358 	size_t pos = offset;
2359 
2360 	while (pos < ielen && ies[pos] != WLAN_EID_VENDOR_SPECIFIC)
2361 		pos += 2 + ies[pos + 1];
2362 
2363 	return pos;
2364 }
2365 
ieee80211_ie_build_ht_cap(u8 * pos,struct ieee80211_sta_ht_cap * ht_cap,u16 cap)2366 u8 *ieee80211_ie_build_ht_cap(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2367 			      u16 cap)
2368 {
2369 	__le16 tmp;
2370 
2371 	*pos++ = WLAN_EID_HT_CAPABILITY;
2372 	*pos++ = sizeof(struct ieee80211_ht_cap);
2373 	memset(pos, 0, sizeof(struct ieee80211_ht_cap));
2374 
2375 	/* capability flags */
2376 	tmp = cpu_to_le16(cap);
2377 	memcpy(pos, &tmp, sizeof(u16));
2378 	pos += sizeof(u16);
2379 
2380 	/* AMPDU parameters */
2381 	*pos++ = ht_cap->ampdu_factor |
2382 		 (ht_cap->ampdu_density <<
2383 			IEEE80211_HT_AMPDU_PARM_DENSITY_SHIFT);
2384 
2385 	/* MCS set */
2386 	memcpy(pos, &ht_cap->mcs, sizeof(ht_cap->mcs));
2387 	pos += sizeof(ht_cap->mcs);
2388 
2389 	/* extended capabilities */
2390 	pos += sizeof(__le16);
2391 
2392 	/* BF capabilities */
2393 	pos += sizeof(__le32);
2394 
2395 	/* antenna selection */
2396 	pos += sizeof(u8);
2397 
2398 	return pos;
2399 }
2400 
ieee80211_ie_build_vht_cap(u8 * pos,struct ieee80211_sta_vht_cap * vht_cap,u32 cap)2401 u8 *ieee80211_ie_build_vht_cap(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2402 			       u32 cap)
2403 {
2404 	__le32 tmp;
2405 
2406 	*pos++ = WLAN_EID_VHT_CAPABILITY;
2407 	*pos++ = sizeof(struct ieee80211_vht_cap);
2408 	memset(pos, 0, sizeof(struct ieee80211_vht_cap));
2409 
2410 	/* capability flags */
2411 	tmp = cpu_to_le32(cap);
2412 	memcpy(pos, &tmp, sizeof(u32));
2413 	pos += sizeof(u32);
2414 
2415 	/* VHT MCS set */
2416 	memcpy(pos, &vht_cap->vht_mcs, sizeof(vht_cap->vht_mcs));
2417 	pos += sizeof(vht_cap->vht_mcs);
2418 
2419 	return pos;
2420 }
2421 
2422 /* this may return more than ieee80211_put_he_6ghz_cap() will need */
ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data * sdata)2423 u8 ieee80211_ie_len_he_cap(struct ieee80211_sub_if_data *sdata)
2424 {
2425 	const struct ieee80211_sta_he_cap *he_cap;
2426 	struct ieee80211_supported_band *sband;
2427 	u8 n;
2428 
2429 	sband = ieee80211_get_sband(sdata);
2430 	if (!sband)
2431 		return 0;
2432 
2433 	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
2434 	if (!he_cap)
2435 		return 0;
2436 
2437 	n = ieee80211_he_mcs_nss_size(&he_cap->he_cap_elem);
2438 	return 2 + 1 +
2439 	       sizeof(he_cap->he_cap_elem) + n +
2440 	       ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2441 				     he_cap->he_cap_elem.phy_cap_info);
2442 }
2443 
2444 static void
ieee80211_get_adjusted_he_cap(const struct ieee80211_conn_settings * conn,const struct ieee80211_sta_he_cap * he_cap,struct ieee80211_he_cap_elem * elem)2445 ieee80211_get_adjusted_he_cap(const struct ieee80211_conn_settings *conn,
2446 			      const struct ieee80211_sta_he_cap *he_cap,
2447 			      struct ieee80211_he_cap_elem *elem)
2448 {
2449 	u8 ru_limit, max_ru;
2450 
2451 	*elem = he_cap->he_cap_elem;
2452 
2453 	switch (conn->bw_limit) {
2454 	case IEEE80211_CONN_BW_LIMIT_20:
2455 		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_242;
2456 		break;
2457 	case IEEE80211_CONN_BW_LIMIT_40:
2458 		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_484;
2459 		break;
2460 	case IEEE80211_CONN_BW_LIMIT_80:
2461 		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_996;
2462 		break;
2463 	default:
2464 		ru_limit = IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_2x996;
2465 		break;
2466 	}
2467 
2468 	max_ru = elem->phy_cap_info[8] & IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_MASK;
2469 	max_ru = min(max_ru, ru_limit);
2470 	elem->phy_cap_info[8] &= ~IEEE80211_HE_PHY_CAP8_DCM_MAX_RU_MASK;
2471 	elem->phy_cap_info[8] |= max_ru;
2472 
2473 	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_40) {
2474 		elem->phy_cap_info[0] &=
2475 			~(IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G |
2476 			  IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G);
2477 		elem->phy_cap_info[9] &=
2478 			~IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM;
2479 	}
2480 
2481 	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_160) {
2482 		elem->phy_cap_info[0] &=
2483 			~(IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G |
2484 			  IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G);
2485 		elem->phy_cap_info[5] &=
2486 			~IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK;
2487 		elem->phy_cap_info[7] &=
2488 			~(IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ |
2489 			  IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ);
2490 	}
2491 }
2492 
ieee80211_put_he_cap(struct sk_buff * skb,struct ieee80211_sub_if_data * sdata,const struct ieee80211_supported_band * sband,const struct ieee80211_conn_settings * conn)2493 int ieee80211_put_he_cap(struct sk_buff *skb,
2494 			 struct ieee80211_sub_if_data *sdata,
2495 			 const struct ieee80211_supported_band *sband,
2496 			 const struct ieee80211_conn_settings *conn)
2497 {
2498 	const struct ieee80211_sta_he_cap *he_cap;
2499 	struct ieee80211_he_cap_elem elem;
2500 	u8 *len;
2501 	u8 n;
2502 	u8 ie_len;
2503 
2504 	if (!conn)
2505 		conn = &ieee80211_conn_settings_unlimited;
2506 
2507 	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
2508 	if (!he_cap)
2509 		return 0;
2510 
2511 	/* modify on stack first to calculate 'n' and 'ie_len' correctly */
2512 	ieee80211_get_adjusted_he_cap(conn, he_cap, &elem);
2513 
2514 	n = ieee80211_he_mcs_nss_size(&elem);
2515 	ie_len = 2 + 1 +
2516 		 sizeof(he_cap->he_cap_elem) + n +
2517 		 ieee80211_he_ppe_size(he_cap->ppe_thres[0],
2518 				       he_cap->he_cap_elem.phy_cap_info);
2519 
2520 	if (skb_tailroom(skb) < ie_len)
2521 		return -ENOBUFS;
2522 
2523 	skb_put_u8(skb, WLAN_EID_EXTENSION);
2524 	len = skb_put(skb, 1); /* We'll set the size later below */
2525 	skb_put_u8(skb, WLAN_EID_EXT_HE_CAPABILITY);
2526 
2527 	/* Fixed data */
2528 	skb_put_data(skb, &elem, sizeof(elem));
2529 
2530 	skb_put_data(skb, &he_cap->he_mcs_nss_supp, n);
2531 
2532 	/* Check if PPE Threshold should be present */
2533 	if ((he_cap->he_cap_elem.phy_cap_info[6] &
2534 	     IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
2535 		goto end;
2536 
2537 	/*
2538 	 * Calculate how many PPET16/PPET8 pairs are to come. Algorithm:
2539 	 * (NSS_M1 + 1) x (num of 1 bits in RU_INDEX_BITMASK)
2540 	 */
2541 	n = hweight8(he_cap->ppe_thres[0] &
2542 		     IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
2543 	n *= (1 + ((he_cap->ppe_thres[0] & IEEE80211_PPE_THRES_NSS_MASK) >>
2544 		   IEEE80211_PPE_THRES_NSS_POS));
2545 
2546 	/*
2547 	 * Each pair is 6 bits, and we need to add the 7 "header" bits to the
2548 	 * total size.
2549 	 */
2550 	n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
2551 	n = DIV_ROUND_UP(n, 8);
2552 
2553 	/* Copy PPE Thresholds */
2554 	skb_put_data(skb, &he_cap->ppe_thres, n);
2555 
2556 end:
2557 	*len = skb_tail_pointer(skb) - len - 1;
2558 	return 0;
2559 }
2560 
ieee80211_put_he_6ghz_cap(struct sk_buff * skb,struct ieee80211_sub_if_data * sdata,enum ieee80211_smps_mode smps_mode)2561 int ieee80211_put_he_6ghz_cap(struct sk_buff *skb,
2562 			      struct ieee80211_sub_if_data *sdata,
2563 			      enum ieee80211_smps_mode smps_mode)
2564 {
2565 	struct ieee80211_supported_band *sband;
2566 	const struct ieee80211_sband_iftype_data *iftd;
2567 	enum nl80211_iftype iftype = ieee80211_vif_type_p2p(&sdata->vif);
2568 	__le16 cap;
2569 
2570 	if (!cfg80211_any_usable_channels(sdata->local->hw.wiphy,
2571 					  BIT(NL80211_BAND_6GHZ),
2572 					  IEEE80211_CHAN_NO_HE))
2573 		return 0;
2574 
2575 	sband = sdata->local->hw.wiphy->bands[NL80211_BAND_6GHZ];
2576 
2577 	iftd = ieee80211_get_sband_iftype_data(sband, iftype);
2578 	if (!iftd)
2579 		return 0;
2580 
2581 	/* Check for device HE 6 GHz capability before adding element */
2582 	if (!iftd->he_6ghz_capa.capa)
2583 		return 0;
2584 
2585 	cap = iftd->he_6ghz_capa.capa;
2586 	cap &= cpu_to_le16(~IEEE80211_HE_6GHZ_CAP_SM_PS);
2587 
2588 	switch (smps_mode) {
2589 	case IEEE80211_SMPS_AUTOMATIC:
2590 	case IEEE80211_SMPS_NUM_MODES:
2591 		WARN_ON(1);
2592 		fallthrough;
2593 	case IEEE80211_SMPS_OFF:
2594 		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_DISABLED,
2595 					IEEE80211_HE_6GHZ_CAP_SM_PS);
2596 		break;
2597 	case IEEE80211_SMPS_STATIC:
2598 		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_STATIC,
2599 					IEEE80211_HE_6GHZ_CAP_SM_PS);
2600 		break;
2601 	case IEEE80211_SMPS_DYNAMIC:
2602 		cap |= le16_encode_bits(WLAN_HT_CAP_SM_PS_DYNAMIC,
2603 					IEEE80211_HE_6GHZ_CAP_SM_PS);
2604 		break;
2605 	}
2606 
2607 	if (skb_tailroom(skb) < 2 + 1 + sizeof(cap))
2608 		return -ENOBUFS;
2609 
2610 	skb_put_u8(skb, WLAN_EID_EXTENSION);
2611 	skb_put_u8(skb, 1 + sizeof(cap));
2612 	skb_put_u8(skb, WLAN_EID_EXT_HE_6GHZ_CAPA);
2613 	skb_put_data(skb, &cap, sizeof(cap));
2614 	return 0;
2615 }
2616 
ieee80211_ie_build_ht_oper(u8 * pos,struct ieee80211_sta_ht_cap * ht_cap,const struct cfg80211_chan_def * chandef,u16 prot_mode,bool rifs_mode)2617 u8 *ieee80211_ie_build_ht_oper(u8 *pos, struct ieee80211_sta_ht_cap *ht_cap,
2618 			       const struct cfg80211_chan_def *chandef,
2619 			       u16 prot_mode, bool rifs_mode)
2620 {
2621 	struct ieee80211_ht_operation *ht_oper;
2622 	/* Build HT Information */
2623 	*pos++ = WLAN_EID_HT_OPERATION;
2624 	*pos++ = sizeof(struct ieee80211_ht_operation);
2625 	ht_oper = (struct ieee80211_ht_operation *)pos;
2626 	ht_oper->primary_chan = ieee80211_frequency_to_channel(
2627 					chandef->chan->center_freq);
2628 	switch (chandef->width) {
2629 	case NL80211_CHAN_WIDTH_160:
2630 	case NL80211_CHAN_WIDTH_80P80:
2631 	case NL80211_CHAN_WIDTH_80:
2632 	case NL80211_CHAN_WIDTH_40:
2633 		if (chandef->center_freq1 > chandef->chan->center_freq)
2634 			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
2635 		else
2636 			ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
2637 		break;
2638 	case NL80211_CHAN_WIDTH_320:
2639 		/* HT information element should not be included on 6GHz */
2640 		WARN_ON(1);
2641 		return pos;
2642 	default:
2643 		ht_oper->ht_param = IEEE80211_HT_PARAM_CHA_SEC_NONE;
2644 		break;
2645 	}
2646 	if (ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40 &&
2647 	    chandef->width != NL80211_CHAN_WIDTH_20_NOHT &&
2648 	    chandef->width != NL80211_CHAN_WIDTH_20)
2649 		ht_oper->ht_param |= IEEE80211_HT_PARAM_CHAN_WIDTH_ANY;
2650 
2651 	if (rifs_mode)
2652 		ht_oper->ht_param |= IEEE80211_HT_PARAM_RIFS_MODE;
2653 
2654 	ht_oper->operation_mode = cpu_to_le16(prot_mode);
2655 	ht_oper->stbc_param = 0x0000;
2656 
2657 	/* It seems that Basic MCS set and Supported MCS set
2658 	   are identical for the first 10 bytes */
2659 	memset(&ht_oper->basic_set, 0, 16);
2660 	memcpy(&ht_oper->basic_set, &ht_cap->mcs, 10);
2661 
2662 	return pos + sizeof(struct ieee80211_ht_operation);
2663 }
2664 
ieee80211_ie_build_wide_bw_cs(u8 * pos,const struct cfg80211_chan_def * chandef)2665 void ieee80211_ie_build_wide_bw_cs(u8 *pos,
2666 				   const struct cfg80211_chan_def *chandef)
2667 {
2668 	*pos++ = WLAN_EID_WIDE_BW_CHANNEL_SWITCH;	/* EID */
2669 	*pos++ = 3;					/* IE length */
2670 	/* New channel width */
2671 	switch (chandef->width) {
2672 	case NL80211_CHAN_WIDTH_80:
2673 		*pos++ = IEEE80211_VHT_CHANWIDTH_80MHZ;
2674 		break;
2675 	case NL80211_CHAN_WIDTH_160:
2676 		*pos++ = IEEE80211_VHT_CHANWIDTH_160MHZ;
2677 		break;
2678 	case NL80211_CHAN_WIDTH_80P80:
2679 		*pos++ = IEEE80211_VHT_CHANWIDTH_80P80MHZ;
2680 		break;
2681 	case NL80211_CHAN_WIDTH_320:
2682 		/* The behavior is not defined for 320 MHz channels */
2683 		WARN_ON(1);
2684 		fallthrough;
2685 	default:
2686 		*pos++ = IEEE80211_VHT_CHANWIDTH_USE_HT;
2687 	}
2688 
2689 	/* new center frequency segment 0 */
2690 	*pos++ = ieee80211_frequency_to_channel(chandef->center_freq1);
2691 	/* new center frequency segment 1 */
2692 	if (chandef->center_freq2)
2693 		*pos++ = ieee80211_frequency_to_channel(chandef->center_freq2);
2694 	else
2695 		*pos++ = 0;
2696 }
2697 
ieee80211_ie_build_vht_oper(u8 * pos,struct ieee80211_sta_vht_cap * vht_cap,const struct cfg80211_chan_def * chandef)2698 u8 *ieee80211_ie_build_vht_oper(u8 *pos, struct ieee80211_sta_vht_cap *vht_cap,
2699 				const struct cfg80211_chan_def *chandef)
2700 {
2701 	struct ieee80211_vht_operation *vht_oper;
2702 
2703 	*pos++ = WLAN_EID_VHT_OPERATION;
2704 	*pos++ = sizeof(struct ieee80211_vht_operation);
2705 	vht_oper = (struct ieee80211_vht_operation *)pos;
2706 	vht_oper->center_freq_seg0_idx = ieee80211_frequency_to_channel(
2707 							chandef->center_freq1);
2708 	if (chandef->center_freq2)
2709 		vht_oper->center_freq_seg1_idx =
2710 			ieee80211_frequency_to_channel(chandef->center_freq2);
2711 	else
2712 		vht_oper->center_freq_seg1_idx = 0x00;
2713 
2714 	switch (chandef->width) {
2715 	case NL80211_CHAN_WIDTH_160:
2716 		/*
2717 		 * Convert 160 MHz channel width to new style as interop
2718 		 * workaround.
2719 		 */
2720 		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2721 		vht_oper->center_freq_seg1_idx = vht_oper->center_freq_seg0_idx;
2722 		if (chandef->chan->center_freq < chandef->center_freq1)
2723 			vht_oper->center_freq_seg0_idx -= 8;
2724 		else
2725 			vht_oper->center_freq_seg0_idx += 8;
2726 		break;
2727 	case NL80211_CHAN_WIDTH_80P80:
2728 		/*
2729 		 * Convert 80+80 MHz channel width to new style as interop
2730 		 * workaround.
2731 		 */
2732 		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2733 		break;
2734 	case NL80211_CHAN_WIDTH_80:
2735 		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_80MHZ;
2736 		break;
2737 	case NL80211_CHAN_WIDTH_320:
2738 		/* VHT information element should not be included on 6GHz */
2739 		WARN_ON(1);
2740 		return pos;
2741 	default:
2742 		vht_oper->chan_width = IEEE80211_VHT_CHANWIDTH_USE_HT;
2743 		break;
2744 	}
2745 
2746 	/* don't require special VHT peer rates */
2747 	vht_oper->basic_mcs_set = cpu_to_le16(0xffff);
2748 
2749 	return pos + sizeof(struct ieee80211_vht_operation);
2750 }
2751 
ieee80211_ie_build_he_oper(u8 * pos,const struct cfg80211_chan_def * chandef)2752 u8 *ieee80211_ie_build_he_oper(u8 *pos, const struct cfg80211_chan_def *chandef)
2753 {
2754 	struct ieee80211_he_operation *he_oper;
2755 	struct ieee80211_he_6ghz_oper *he_6ghz_op;
2756 	struct cfg80211_chan_def he_chandef;
2757 	u32 he_oper_params;
2758 	u8 ie_len = 1 + sizeof(struct ieee80211_he_operation);
2759 
2760 	if (chandef->chan->band == NL80211_BAND_6GHZ)
2761 		ie_len += sizeof(struct ieee80211_he_6ghz_oper);
2762 
2763 	*pos++ = WLAN_EID_EXTENSION;
2764 	*pos++ = ie_len;
2765 	*pos++ = WLAN_EID_EXT_HE_OPERATION;
2766 
2767 	he_oper_params = 0;
2768 	he_oper_params |= u32_encode_bits(1023, /* disabled */
2769 				IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK);
2770 	he_oper_params |= u32_encode_bits(1,
2771 				IEEE80211_HE_OPERATION_ER_SU_DISABLE);
2772 	he_oper_params |= u32_encode_bits(1,
2773 				IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED);
2774 	if (chandef->chan->band == NL80211_BAND_6GHZ)
2775 		he_oper_params |= u32_encode_bits(1,
2776 				IEEE80211_HE_OPERATION_6GHZ_OP_INFO);
2777 
2778 	he_oper = (struct ieee80211_he_operation *)pos;
2779 	he_oper->he_oper_params = cpu_to_le32(he_oper_params);
2780 
2781 	/* don't require special HE peer rates */
2782 	he_oper->he_mcs_nss_set = cpu_to_le16(0xffff);
2783 	pos += sizeof(struct ieee80211_he_operation);
2784 
2785 	if (chandef->chan->band != NL80211_BAND_6GHZ)
2786 		goto out;
2787 
2788 	cfg80211_chandef_create(&he_chandef, chandef->chan, NL80211_CHAN_NO_HT);
2789 	he_chandef.center_freq1 = chandef->center_freq1;
2790 	he_chandef.center_freq2 = chandef->center_freq2;
2791 	he_chandef.width = chandef->width;
2792 
2793 	/* TODO add VHT operational */
2794 	he_6ghz_op = (struct ieee80211_he_6ghz_oper *)pos;
2795 	he_6ghz_op->minrate = 6; /* 6 Mbps */
2796 	he_6ghz_op->primary =
2797 		ieee80211_frequency_to_channel(he_chandef.chan->center_freq);
2798 	he_6ghz_op->ccfs0 =
2799 		ieee80211_frequency_to_channel(he_chandef.center_freq1);
2800 	if (he_chandef.center_freq2)
2801 		he_6ghz_op->ccfs1 =
2802 			ieee80211_frequency_to_channel(he_chandef.center_freq2);
2803 	else
2804 		he_6ghz_op->ccfs1 = 0;
2805 
2806 	switch (he_chandef.width) {
2807 	case NL80211_CHAN_WIDTH_320:
2808 		/* Downgrade EHT 320 MHz BW to 160 MHz for HE and set new
2809 		 * center_freq1
2810 		 */
2811 		ieee80211_chandef_downgrade(&he_chandef, NULL);
2812 		he_6ghz_op->ccfs0 =
2813 			ieee80211_frequency_to_channel(he_chandef.center_freq1);
2814 		fallthrough;
2815 	case NL80211_CHAN_WIDTH_160:
2816 		/* Convert 160 MHz channel width to new style as interop
2817 		 * workaround.
2818 		 */
2819 		he_6ghz_op->control =
2820 			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
2821 		he_6ghz_op->ccfs1 = he_6ghz_op->ccfs0;
2822 		if (he_chandef.chan->center_freq < he_chandef.center_freq1)
2823 			he_6ghz_op->ccfs0 -= 8;
2824 		else
2825 			he_6ghz_op->ccfs0 += 8;
2826 		fallthrough;
2827 	case NL80211_CHAN_WIDTH_80P80:
2828 		he_6ghz_op->control =
2829 			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ;
2830 		break;
2831 	case NL80211_CHAN_WIDTH_80:
2832 		he_6ghz_op->control =
2833 			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ;
2834 		break;
2835 	case NL80211_CHAN_WIDTH_40:
2836 		he_6ghz_op->control =
2837 			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ;
2838 		break;
2839 	default:
2840 		he_6ghz_op->control =
2841 			IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ;
2842 		break;
2843 	}
2844 
2845 	pos += sizeof(struct ieee80211_he_6ghz_oper);
2846 
2847 out:
2848 	return pos;
2849 }
2850 
ieee80211_ie_build_eht_oper(u8 * pos,const struct cfg80211_chan_def * chandef,const struct ieee80211_sta_eht_cap * eht_cap)2851 u8 *ieee80211_ie_build_eht_oper(u8 *pos, const struct cfg80211_chan_def *chandef,
2852 				const struct ieee80211_sta_eht_cap *eht_cap)
2853 
2854 {
2855 	const struct ieee80211_eht_mcs_nss_supp_20mhz_only *eht_mcs_nss =
2856 					&eht_cap->eht_mcs_nss_supp.only_20mhz;
2857 	struct ieee80211_eht_operation *eht_oper;
2858 	struct ieee80211_eht_operation_info *eht_oper_info;
2859 	u8 eht_oper_len = offsetof(struct ieee80211_eht_operation, optional);
2860 	u8 eht_oper_info_len =
2861 		offsetof(struct ieee80211_eht_operation_info, optional);
2862 	u8 chan_width = 0;
2863 
2864 	*pos++ = WLAN_EID_EXTENSION;
2865 	*pos++ = 1 + eht_oper_len + eht_oper_info_len;
2866 	*pos++ = WLAN_EID_EXT_EHT_OPERATION;
2867 
2868 	eht_oper = (struct ieee80211_eht_operation *)pos;
2869 
2870 	memcpy(&eht_oper->basic_mcs_nss, eht_mcs_nss, sizeof(*eht_mcs_nss));
2871 	eht_oper->params |= IEEE80211_EHT_OPER_INFO_PRESENT;
2872 	pos += eht_oper_len;
2873 
2874 	eht_oper_info =
2875 		(struct ieee80211_eht_operation_info *)eht_oper->optional;
2876 
2877 	eht_oper_info->ccfs0 =
2878 		ieee80211_frequency_to_channel(chandef->center_freq1);
2879 	if (chandef->center_freq2)
2880 		eht_oper_info->ccfs1 =
2881 			ieee80211_frequency_to_channel(chandef->center_freq2);
2882 	else
2883 		eht_oper_info->ccfs1 = 0;
2884 
2885 	switch (chandef->width) {
2886 	case NL80211_CHAN_WIDTH_320:
2887 		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_320MHZ;
2888 		eht_oper_info->ccfs1 = eht_oper_info->ccfs0;
2889 		if (chandef->chan->center_freq < chandef->center_freq1)
2890 			eht_oper_info->ccfs0 -= 16;
2891 		else
2892 			eht_oper_info->ccfs0 += 16;
2893 		break;
2894 	case NL80211_CHAN_WIDTH_160:
2895 		eht_oper_info->ccfs1 = eht_oper_info->ccfs0;
2896 		if (chandef->chan->center_freq < chandef->center_freq1)
2897 			eht_oper_info->ccfs0 -= 8;
2898 		else
2899 			eht_oper_info->ccfs0 += 8;
2900 		fallthrough;
2901 	case NL80211_CHAN_WIDTH_80P80:
2902 		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_160MHZ;
2903 		break;
2904 	case NL80211_CHAN_WIDTH_80:
2905 		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_80MHZ;
2906 		break;
2907 	case NL80211_CHAN_WIDTH_40:
2908 		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_40MHZ;
2909 		break;
2910 	default:
2911 		chan_width = IEEE80211_EHT_OPER_CHAN_WIDTH_20MHZ;
2912 		break;
2913 	}
2914 	eht_oper_info->control = chan_width;
2915 	pos += eht_oper_info_len;
2916 
2917 	/* TODO: eht_oper_info->optional */
2918 
2919 	return pos;
2920 }
2921 
ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation * ht_oper,struct cfg80211_chan_def * chandef)2922 bool ieee80211_chandef_ht_oper(const struct ieee80211_ht_operation *ht_oper,
2923 			       struct cfg80211_chan_def *chandef)
2924 {
2925 	enum nl80211_channel_type channel_type;
2926 
2927 	if (!ht_oper)
2928 		return false;
2929 
2930 	switch (ht_oper->ht_param & IEEE80211_HT_PARAM_CHA_SEC_OFFSET) {
2931 	case IEEE80211_HT_PARAM_CHA_SEC_NONE:
2932 		channel_type = NL80211_CHAN_HT20;
2933 		break;
2934 	case IEEE80211_HT_PARAM_CHA_SEC_ABOVE:
2935 		channel_type = NL80211_CHAN_HT40PLUS;
2936 		break;
2937 	case IEEE80211_HT_PARAM_CHA_SEC_BELOW:
2938 		channel_type = NL80211_CHAN_HT40MINUS;
2939 		break;
2940 	default:
2941 		return false;
2942 	}
2943 
2944 	cfg80211_chandef_create(chandef, chandef->chan, channel_type);
2945 	return true;
2946 }
2947 
ieee80211_chandef_vht_oper(struct ieee80211_hw * hw,u32 vht_cap_info,const struct ieee80211_vht_operation * oper,const struct ieee80211_ht_operation * htop,struct cfg80211_chan_def * chandef)2948 bool ieee80211_chandef_vht_oper(struct ieee80211_hw *hw, u32 vht_cap_info,
2949 				const struct ieee80211_vht_operation *oper,
2950 				const struct ieee80211_ht_operation *htop,
2951 				struct cfg80211_chan_def *chandef)
2952 {
2953 	struct cfg80211_chan_def new = *chandef;
2954 	int cf0, cf1;
2955 	int ccfs0, ccfs1, ccfs2;
2956 	int ccf0, ccf1;
2957 	u32 vht_cap;
2958 	bool support_80_80 = false;
2959 	bool support_160 = false;
2960 	u8 ext_nss_bw_supp = u32_get_bits(vht_cap_info,
2961 					  IEEE80211_VHT_CAP_EXT_NSS_BW_MASK);
2962 	u8 supp_chwidth = u32_get_bits(vht_cap_info,
2963 				       IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK);
2964 
2965 	if (!oper || !htop)
2966 		return false;
2967 
2968 	vht_cap = hw->wiphy->bands[chandef->chan->band]->vht_cap.cap;
2969 	support_160 = (vht_cap & (IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK |
2970 				  IEEE80211_VHT_CAP_EXT_NSS_BW_MASK));
2971 	support_80_80 = ((vht_cap &
2972 			 IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ) ||
2973 			(vht_cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
2974 			 vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) ||
2975 			((vht_cap & IEEE80211_VHT_CAP_EXT_NSS_BW_MASK) >>
2976 				    IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT > 1));
2977 	ccfs0 = oper->center_freq_seg0_idx;
2978 	ccfs1 = oper->center_freq_seg1_idx;
2979 	ccfs2 = (le16_to_cpu(htop->operation_mode) &
2980 				IEEE80211_HT_OP_MODE_CCFS2_MASK)
2981 			>> IEEE80211_HT_OP_MODE_CCFS2_SHIFT;
2982 
2983 	ccf0 = ccfs0;
2984 
2985 	/* if not supported, parse as though we didn't understand it */
2986 	if (!ieee80211_hw_check(hw, SUPPORTS_VHT_EXT_NSS_BW))
2987 		ext_nss_bw_supp = 0;
2988 
2989 	/*
2990 	 * Cf. IEEE 802.11 Table 9-250
2991 	 *
2992 	 * We really just consider that because it's inefficient to connect
2993 	 * at a higher bandwidth than we'll actually be able to use.
2994 	 */
2995 	switch ((supp_chwidth << 4) | ext_nss_bw_supp) {
2996 	default:
2997 	case 0x00:
2998 		ccf1 = 0;
2999 		support_160 = false;
3000 		support_80_80 = false;
3001 		break;
3002 	case 0x01:
3003 		support_80_80 = false;
3004 		fallthrough;
3005 	case 0x02:
3006 	case 0x03:
3007 		ccf1 = ccfs2;
3008 		break;
3009 	case 0x10:
3010 		ccf1 = ccfs1;
3011 		break;
3012 	case 0x11:
3013 	case 0x12:
3014 		if (!ccfs1)
3015 			ccf1 = ccfs2;
3016 		else
3017 			ccf1 = ccfs1;
3018 		break;
3019 	case 0x13:
3020 	case 0x20:
3021 	case 0x23:
3022 		ccf1 = ccfs1;
3023 		break;
3024 	}
3025 
3026 	cf0 = ieee80211_channel_to_frequency(ccf0, chandef->chan->band);
3027 	cf1 = ieee80211_channel_to_frequency(ccf1, chandef->chan->band);
3028 
3029 	switch (oper->chan_width) {
3030 	case IEEE80211_VHT_CHANWIDTH_USE_HT:
3031 		/* just use HT information directly */
3032 		break;
3033 	case IEEE80211_VHT_CHANWIDTH_80MHZ:
3034 		new.width = NL80211_CHAN_WIDTH_80;
3035 		new.center_freq1 = cf0;
3036 		/* If needed, adjust based on the newer interop workaround. */
3037 		if (ccf1) {
3038 			unsigned int diff;
3039 
3040 			diff = abs(ccf1 - ccf0);
3041 			if ((diff == 8) && support_160) {
3042 				new.width = NL80211_CHAN_WIDTH_160;
3043 				new.center_freq1 = cf1;
3044 			} else if ((diff > 8) && support_80_80) {
3045 				new.width = NL80211_CHAN_WIDTH_80P80;
3046 				new.center_freq2 = cf1;
3047 			}
3048 		}
3049 		break;
3050 	case IEEE80211_VHT_CHANWIDTH_160MHZ:
3051 		/* deprecated encoding */
3052 		new.width = NL80211_CHAN_WIDTH_160;
3053 		new.center_freq1 = cf0;
3054 		break;
3055 	case IEEE80211_VHT_CHANWIDTH_80P80MHZ:
3056 		/* deprecated encoding */
3057 		new.width = NL80211_CHAN_WIDTH_80P80;
3058 		new.center_freq1 = cf0;
3059 		new.center_freq2 = cf1;
3060 		break;
3061 	default:
3062 		return false;
3063 	}
3064 
3065 	if (!cfg80211_chandef_valid(&new))
3066 		return false;
3067 
3068 	*chandef = new;
3069 	return true;
3070 }
3071 
ieee80211_chandef_eht_oper(const struct ieee80211_eht_operation_info * info,struct cfg80211_chan_def * chandef)3072 void ieee80211_chandef_eht_oper(const struct ieee80211_eht_operation_info *info,
3073 				struct cfg80211_chan_def *chandef)
3074 {
3075 	chandef->center_freq1 =
3076 		ieee80211_channel_to_frequency(info->ccfs0,
3077 					       chandef->chan->band);
3078 
3079 	switch (u8_get_bits(info->control,
3080 			    IEEE80211_EHT_OPER_CHAN_WIDTH)) {
3081 	case IEEE80211_EHT_OPER_CHAN_WIDTH_20MHZ:
3082 		chandef->width = NL80211_CHAN_WIDTH_20;
3083 		break;
3084 	case IEEE80211_EHT_OPER_CHAN_WIDTH_40MHZ:
3085 		chandef->width = NL80211_CHAN_WIDTH_40;
3086 		break;
3087 	case IEEE80211_EHT_OPER_CHAN_WIDTH_80MHZ:
3088 		chandef->width = NL80211_CHAN_WIDTH_80;
3089 		break;
3090 	case IEEE80211_EHT_OPER_CHAN_WIDTH_160MHZ:
3091 		chandef->width = NL80211_CHAN_WIDTH_160;
3092 		chandef->center_freq1 =
3093 			ieee80211_channel_to_frequency(info->ccfs1,
3094 						       chandef->chan->band);
3095 		break;
3096 	case IEEE80211_EHT_OPER_CHAN_WIDTH_320MHZ:
3097 		chandef->width = NL80211_CHAN_WIDTH_320;
3098 		chandef->center_freq1 =
3099 			ieee80211_channel_to_frequency(info->ccfs1,
3100 						       chandef->chan->band);
3101 		break;
3102 	}
3103 }
3104 
ieee80211_chandef_he_6ghz_oper(struct ieee80211_local * local,const struct ieee80211_he_operation * he_oper,const struct ieee80211_eht_operation * eht_oper,struct cfg80211_chan_def * chandef)3105 bool ieee80211_chandef_he_6ghz_oper(struct ieee80211_local *local,
3106 				    const struct ieee80211_he_operation *he_oper,
3107 				    const struct ieee80211_eht_operation *eht_oper,
3108 				    struct cfg80211_chan_def *chandef)
3109 {
3110 	struct cfg80211_chan_def he_chandef = *chandef;
3111 	const struct ieee80211_he_6ghz_oper *he_6ghz_oper;
3112 	u32 freq;
3113 
3114 	if (chandef->chan->band != NL80211_BAND_6GHZ)
3115 		return true;
3116 
3117 	if (!he_oper)
3118 		return false;
3119 
3120 	he_6ghz_oper = ieee80211_he_6ghz_oper(he_oper);
3121 	if (!he_6ghz_oper)
3122 		return false;
3123 
3124 	/*
3125 	 * The EHT operation IE does not contain the primary channel so the
3126 	 * primary channel frequency should be taken from the 6 GHz operation
3127 	 * information.
3128 	 */
3129 	freq = ieee80211_channel_to_frequency(he_6ghz_oper->primary,
3130 					      NL80211_BAND_6GHZ);
3131 	he_chandef.chan = ieee80211_get_channel(local->hw.wiphy, freq);
3132 
3133 	if (!he_chandef.chan)
3134 		return false;
3135 
3136 	if (!eht_oper ||
3137 	    !(eht_oper->params & IEEE80211_EHT_OPER_INFO_PRESENT)) {
3138 		switch (u8_get_bits(he_6ghz_oper->control,
3139 				    IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH)) {
3140 		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_20MHZ:
3141 			he_chandef.width = NL80211_CHAN_WIDTH_20;
3142 			break;
3143 		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_40MHZ:
3144 			he_chandef.width = NL80211_CHAN_WIDTH_40;
3145 			break;
3146 		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_80MHZ:
3147 			he_chandef.width = NL80211_CHAN_WIDTH_80;
3148 			break;
3149 		case IEEE80211_HE_6GHZ_OPER_CTRL_CHANWIDTH_160MHZ:
3150 			he_chandef.width = NL80211_CHAN_WIDTH_80;
3151 			if (!he_6ghz_oper->ccfs1)
3152 				break;
3153 			if (abs(he_6ghz_oper->ccfs1 - he_6ghz_oper->ccfs0) == 8)
3154 				he_chandef.width = NL80211_CHAN_WIDTH_160;
3155 			else
3156 				he_chandef.width = NL80211_CHAN_WIDTH_80P80;
3157 			break;
3158 		}
3159 
3160 		if (he_chandef.width == NL80211_CHAN_WIDTH_160) {
3161 			he_chandef.center_freq1 =
3162 				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3163 							       NL80211_BAND_6GHZ);
3164 		} else {
3165 			he_chandef.center_freq1 =
3166 				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs0,
3167 							       NL80211_BAND_6GHZ);
3168 			he_chandef.center_freq2 =
3169 				ieee80211_channel_to_frequency(he_6ghz_oper->ccfs1,
3170 							       NL80211_BAND_6GHZ);
3171 		}
3172 	} else {
3173 		ieee80211_chandef_eht_oper((const void *)eht_oper->optional,
3174 					   &he_chandef);
3175 		he_chandef.punctured =
3176 			ieee80211_eht_oper_dis_subchan_bitmap(eht_oper);
3177 	}
3178 
3179 	if (!cfg80211_chandef_valid(&he_chandef))
3180 		return false;
3181 
3182 	*chandef = he_chandef;
3183 
3184 	return true;
3185 }
3186 
ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie * oper,struct cfg80211_chan_def * chandef)3187 bool ieee80211_chandef_s1g_oper(const struct ieee80211_s1g_oper_ie *oper,
3188 				struct cfg80211_chan_def *chandef)
3189 {
3190 	u32 oper_freq;
3191 
3192 	if (!oper)
3193 		return false;
3194 
3195 	switch (FIELD_GET(S1G_OPER_CH_WIDTH_OPER, oper->ch_width)) {
3196 	case IEEE80211_S1G_CHANWIDTH_1MHZ:
3197 		chandef->width = NL80211_CHAN_WIDTH_1;
3198 		break;
3199 	case IEEE80211_S1G_CHANWIDTH_2MHZ:
3200 		chandef->width = NL80211_CHAN_WIDTH_2;
3201 		break;
3202 	case IEEE80211_S1G_CHANWIDTH_4MHZ:
3203 		chandef->width = NL80211_CHAN_WIDTH_4;
3204 		break;
3205 	case IEEE80211_S1G_CHANWIDTH_8MHZ:
3206 		chandef->width = NL80211_CHAN_WIDTH_8;
3207 		break;
3208 	case IEEE80211_S1G_CHANWIDTH_16MHZ:
3209 		chandef->width = NL80211_CHAN_WIDTH_16;
3210 		break;
3211 	default:
3212 		return false;
3213 	}
3214 
3215 	oper_freq = ieee80211_channel_to_freq_khz(oper->oper_ch,
3216 						  NL80211_BAND_S1GHZ);
3217 	chandef->center_freq1 = KHZ_TO_MHZ(oper_freq);
3218 	chandef->freq1_offset = oper_freq % 1000;
3219 
3220 	return true;
3221 }
3222 
ieee80211_put_srates_elem(struct sk_buff * skb,const struct ieee80211_supported_band * sband,u32 basic_rates,u32 rate_flags,u32 masked_rates,u8 element_id)3223 int ieee80211_put_srates_elem(struct sk_buff *skb,
3224 			      const struct ieee80211_supported_band *sband,
3225 			      u32 basic_rates, u32 rate_flags, u32 masked_rates,
3226 			      u8 element_id)
3227 {
3228 	u8 i, rates, skip;
3229 
3230 	rates = 0;
3231 	for (i = 0; i < sband->n_bitrates; i++) {
3232 		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3233 			continue;
3234 		if (masked_rates & BIT(i))
3235 			continue;
3236 		rates++;
3237 	}
3238 
3239 	if (element_id == WLAN_EID_SUPP_RATES) {
3240 		rates = min_t(u8, rates, 8);
3241 		skip = 0;
3242 	} else {
3243 		skip = 8;
3244 		if (rates <= skip)
3245 			return 0;
3246 		rates -= skip;
3247 	}
3248 
3249 	if (skb_tailroom(skb) < rates + 2)
3250 		return -ENOBUFS;
3251 
3252 	skb_put_u8(skb, element_id);
3253 	skb_put_u8(skb, rates);
3254 
3255 	for (i = 0; i < sband->n_bitrates && rates; i++) {
3256 		int rate;
3257 		u8 basic;
3258 
3259 		if ((rate_flags & sband->bitrates[i].flags) != rate_flags)
3260 			continue;
3261 		if (masked_rates & BIT(i))
3262 			continue;
3263 
3264 		if (skip > 0) {
3265 			skip--;
3266 			continue;
3267 		}
3268 
3269 		basic = basic_rates & BIT(i) ? 0x80 : 0;
3270 
3271 		rate = DIV_ROUND_UP(sband->bitrates[i].bitrate, 5);
3272 		skb_put_u8(skb, basic | (u8)rate);
3273 		rates--;
3274 	}
3275 
3276 	WARN(rates > 0, "rates confused: rates:%d, element:%d\n",
3277 	     rates, element_id);
3278 
3279 	return 0;
3280 }
3281 
ieee80211_ave_rssi(struct ieee80211_vif * vif)3282 int ieee80211_ave_rssi(struct ieee80211_vif *vif)
3283 {
3284 	struct ieee80211_sub_if_data *sdata = vif_to_sdata(vif);
3285 
3286 	if (WARN_ON_ONCE(sdata->vif.type != NL80211_IFTYPE_STATION))
3287 		return 0;
3288 
3289 	return -ewma_beacon_signal_read(&sdata->deflink.u.mgd.ave_beacon_signal);
3290 }
3291 EXPORT_SYMBOL_GPL(ieee80211_ave_rssi);
3292 
ieee80211_mcs_to_chains(const struct ieee80211_mcs_info * mcs)3293 u8 ieee80211_mcs_to_chains(const struct ieee80211_mcs_info *mcs)
3294 {
3295 	if (!mcs)
3296 		return 1;
3297 
3298 	/* TODO: consider rx_highest */
3299 
3300 	if (mcs->rx_mask[3])
3301 		return 4;
3302 	if (mcs->rx_mask[2])
3303 		return 3;
3304 	if (mcs->rx_mask[1])
3305 		return 2;
3306 	return 1;
3307 }
3308 
3309 /**
3310  * ieee80211_calculate_rx_timestamp - calculate timestamp in frame
3311  * @local: mac80211 hw info struct
3312  * @status: RX status
3313  * @mpdu_len: total MPDU length (including FCS)
3314  * @mpdu_offset: offset into MPDU to calculate timestamp at
3315  *
3316  * This function calculates the RX timestamp at the given MPDU offset, taking
3317  * into account what the RX timestamp was. An offset of 0 will just normalize
3318  * the timestamp to TSF at beginning of MPDU reception.
3319  *
3320  * Returns: the calculated timestamp
3321  */
ieee80211_calculate_rx_timestamp(struct ieee80211_local * local,struct ieee80211_rx_status * status,unsigned int mpdu_len,unsigned int mpdu_offset)3322 u64 ieee80211_calculate_rx_timestamp(struct ieee80211_local *local,
3323 				     struct ieee80211_rx_status *status,
3324 				     unsigned int mpdu_len,
3325 				     unsigned int mpdu_offset)
3326 {
3327 	u64 ts = status->mactime;
3328 	bool mactime_plcp_start;
3329 	struct rate_info ri;
3330 	u16 rate;
3331 	u8 n_ltf;
3332 
3333 	if (WARN_ON(!ieee80211_have_rx_timestamp(status)))
3334 		return 0;
3335 
3336 	mactime_plcp_start = (status->flag & RX_FLAG_MACTIME) ==
3337 				RX_FLAG_MACTIME_PLCP_START;
3338 
3339 	memset(&ri, 0, sizeof(ri));
3340 
3341 	ri.bw = status->bw;
3342 
3343 	/* Fill cfg80211 rate info */
3344 	switch (status->encoding) {
3345 	case RX_ENC_EHT:
3346 		ri.flags |= RATE_INFO_FLAGS_EHT_MCS;
3347 		ri.mcs = status->rate_idx;
3348 		ri.nss = status->nss;
3349 		ri.eht_ru_alloc = status->eht.ru;
3350 		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3351 			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3352 		/* TODO/FIXME: is this right? handle other PPDUs */
3353 		if (mactime_plcp_start) {
3354 			mpdu_offset += 2;
3355 			ts += 36;
3356 		}
3357 		break;
3358 	case RX_ENC_HE:
3359 		ri.flags |= RATE_INFO_FLAGS_HE_MCS;
3360 		ri.mcs = status->rate_idx;
3361 		ri.nss = status->nss;
3362 		ri.he_ru_alloc = status->he_ru;
3363 		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3364 			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3365 
3366 		/*
3367 		 * See P802.11ax_D6.0, section 27.3.4 for
3368 		 * VHT PPDU format.
3369 		 */
3370 		if (mactime_plcp_start) {
3371 			mpdu_offset += 2;
3372 			ts += 36;
3373 
3374 			/*
3375 			 * TODO:
3376 			 * For HE MU PPDU, add the HE-SIG-B.
3377 			 * For HE ER PPDU, add 8us for the HE-SIG-A.
3378 			 * For HE TB PPDU, add 4us for the HE-STF.
3379 			 * Add the HE-LTF durations - variable.
3380 			 */
3381 		}
3382 
3383 		break;
3384 	case RX_ENC_HT:
3385 		ri.mcs = status->rate_idx;
3386 		ri.flags |= RATE_INFO_FLAGS_MCS;
3387 		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3388 			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3389 
3390 		/*
3391 		 * See P802.11REVmd_D3.0, section 19.3.2 for
3392 		 * HT PPDU format.
3393 		 */
3394 		if (mactime_plcp_start) {
3395 			mpdu_offset += 2;
3396 			if (status->enc_flags & RX_ENC_FLAG_HT_GF)
3397 				ts += 24;
3398 			else
3399 				ts += 32;
3400 
3401 			/*
3402 			 * Add Data HT-LTFs per streams
3403 			 * TODO: add Extension HT-LTFs, 4us per LTF
3404 			 */
3405 			n_ltf = ((ri.mcs >> 3) & 3) + 1;
3406 			n_ltf = n_ltf == 3 ? 4 : n_ltf;
3407 			ts += n_ltf * 4;
3408 		}
3409 
3410 		break;
3411 	case RX_ENC_VHT:
3412 		ri.flags |= RATE_INFO_FLAGS_VHT_MCS;
3413 		ri.mcs = status->rate_idx;
3414 		ri.nss = status->nss;
3415 		if (status->enc_flags & RX_ENC_FLAG_SHORT_GI)
3416 			ri.flags |= RATE_INFO_FLAGS_SHORT_GI;
3417 
3418 		/*
3419 		 * See P802.11REVmd_D3.0, section 21.3.2 for
3420 		 * VHT PPDU format.
3421 		 */
3422 		if (mactime_plcp_start) {
3423 			mpdu_offset += 2;
3424 			ts += 36;
3425 
3426 			/*
3427 			 * Add VHT-LTFs per streams
3428 			 */
3429 			n_ltf = (ri.nss != 1) && (ri.nss % 2) ?
3430 				ri.nss + 1 : ri.nss;
3431 			ts += 4 * n_ltf;
3432 		}
3433 
3434 		break;
3435 	default:
3436 		WARN_ON(1);
3437 		fallthrough;
3438 	case RX_ENC_LEGACY: {
3439 		struct ieee80211_supported_band *sband;
3440 
3441 		sband = local->hw.wiphy->bands[status->band];
3442 		ri.legacy = sband->bitrates[status->rate_idx].bitrate;
3443 
3444 		if (mactime_plcp_start) {
3445 			if (status->band == NL80211_BAND_5GHZ) {
3446 				ts += 20;
3447 				mpdu_offset += 2;
3448 			} else if (status->enc_flags & RX_ENC_FLAG_SHORTPRE) {
3449 				ts += 96;
3450 			} else {
3451 				ts += 192;
3452 			}
3453 		}
3454 		break;
3455 		}
3456 	}
3457 
3458 	rate = cfg80211_calculate_bitrate(&ri);
3459 	if (WARN_ONCE(!rate,
3460 		      "Invalid bitrate: flags=0x%llx, idx=%d, vht_nss=%d\n",
3461 		      (unsigned long long)status->flag, status->rate_idx,
3462 		      status->nss))
3463 		return 0;
3464 
3465 	/* rewind from end of MPDU */
3466 	if ((status->flag & RX_FLAG_MACTIME) == RX_FLAG_MACTIME_END)
3467 		ts -= mpdu_len * 8 * 10 / rate;
3468 
3469 	ts += mpdu_offset * 8 * 10 / rate;
3470 
3471 	return ts;
3472 }
3473 
3474 /* Cancel CAC for the interfaces under the specified @local. If @ctx is
3475  * also provided, only the interfaces using that ctx will be canceled.
3476  */
ieee80211_dfs_cac_cancel(struct ieee80211_local * local,struct ieee80211_chanctx * ctx)3477 void ieee80211_dfs_cac_cancel(struct ieee80211_local *local,
3478 			      struct ieee80211_chanctx *ctx)
3479 {
3480 	struct ieee80211_sub_if_data *sdata;
3481 	struct cfg80211_chan_def chandef;
3482 	struct ieee80211_link_data *link;
3483 	struct ieee80211_chanctx_conf *chanctx_conf;
3484 	unsigned int link_id;
3485 
3486 	lockdep_assert_wiphy(local->hw.wiphy);
3487 
3488 	list_for_each_entry(sdata, &local->interfaces, list) {
3489 		for (link_id = 0; link_id < IEEE80211_MLD_MAX_NUM_LINKS;
3490 		     link_id++) {
3491 			link = sdata_dereference(sdata->link[link_id],
3492 						 sdata);
3493 			if (!link)
3494 				continue;
3495 
3496 			chanctx_conf = sdata_dereference(link->conf->chanctx_conf,
3497 							 sdata);
3498 			if (ctx && &ctx->conf != chanctx_conf)
3499 				continue;
3500 
3501 			wiphy_delayed_work_cancel(local->hw.wiphy,
3502 						  &link->dfs_cac_timer_work);
3503 
3504 			if (!sdata->wdev.links[link_id].cac_started)
3505 				continue;
3506 
3507 			chandef = link->conf->chanreq.oper;
3508 			ieee80211_link_release_channel(link);
3509 			cfg80211_cac_event(sdata->dev, &chandef,
3510 					   NL80211_RADAR_CAC_ABORTED,
3511 					   GFP_KERNEL, link_id);
3512 		}
3513 	}
3514 }
3515 
ieee80211_dfs_radar_detected_work(struct wiphy * wiphy,struct wiphy_work * work)3516 void ieee80211_dfs_radar_detected_work(struct wiphy *wiphy,
3517 				       struct wiphy_work *work)
3518 {
3519 	struct ieee80211_local *local =
3520 		container_of(work, struct ieee80211_local, radar_detected_work);
3521 	struct cfg80211_chan_def chandef;
3522 	struct ieee80211_chanctx *ctx;
3523 
3524 	lockdep_assert_wiphy(local->hw.wiphy);
3525 
3526 	list_for_each_entry(ctx, &local->chanctx_list, list) {
3527 		if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3528 			continue;
3529 
3530 		if (!ctx->radar_detected)
3531 			continue;
3532 
3533 		ctx->radar_detected = false;
3534 
3535 		chandef = ctx->conf.def;
3536 
3537 		ieee80211_dfs_cac_cancel(local, ctx);
3538 		cfg80211_radar_event(local->hw.wiphy, &chandef, GFP_KERNEL);
3539 	}
3540 }
3541 
3542 static void
ieee80211_radar_mark_chan_ctx_iterator(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * chanctx_conf,void * data)3543 ieee80211_radar_mark_chan_ctx_iterator(struct ieee80211_hw *hw,
3544 				       struct ieee80211_chanctx_conf *chanctx_conf,
3545 				       void *data)
3546 {
3547 	struct ieee80211_chanctx *ctx =
3548 		container_of(chanctx_conf, struct ieee80211_chanctx,
3549 			     conf);
3550 
3551 	if (ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER)
3552 		return;
3553 
3554 	if (data && data != chanctx_conf)
3555 		return;
3556 
3557 	ctx->radar_detected = true;
3558 }
3559 
ieee80211_radar_detected(struct ieee80211_hw * hw,struct ieee80211_chanctx_conf * chanctx_conf)3560 void ieee80211_radar_detected(struct ieee80211_hw *hw,
3561 			      struct ieee80211_chanctx_conf *chanctx_conf)
3562 {
3563 	struct ieee80211_local *local = hw_to_local(hw);
3564 
3565 	trace_api_radar_detected(local);
3566 
3567 	ieee80211_iter_chan_contexts_atomic(hw, ieee80211_radar_mark_chan_ctx_iterator,
3568 					    chanctx_conf);
3569 
3570 	wiphy_work_queue(hw->wiphy, &local->radar_detected_work);
3571 }
3572 EXPORT_SYMBOL(ieee80211_radar_detected);
3573 
ieee80211_chandef_downgrade(struct cfg80211_chan_def * c,struct ieee80211_conn_settings * conn)3574 void ieee80211_chandef_downgrade(struct cfg80211_chan_def *c,
3575 				 struct ieee80211_conn_settings *conn)
3576 {
3577 	enum nl80211_chan_width new_primary_width;
3578 	struct ieee80211_conn_settings _ignored = {};
3579 
3580 	/* allow passing NULL if caller doesn't care */
3581 	if (!conn)
3582 		conn = &_ignored;
3583 
3584 again:
3585 	/* no-HT indicates nothing to do */
3586 	new_primary_width = NL80211_CHAN_WIDTH_20_NOHT;
3587 
3588 	switch (c->width) {
3589 	default:
3590 	case NL80211_CHAN_WIDTH_20_NOHT:
3591 		WARN_ON_ONCE(1);
3592 		fallthrough;
3593 	case NL80211_CHAN_WIDTH_20:
3594 		c->width = NL80211_CHAN_WIDTH_20_NOHT;
3595 		conn->mode = IEEE80211_CONN_MODE_LEGACY;
3596 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3597 		c->punctured = 0;
3598 		break;
3599 	case NL80211_CHAN_WIDTH_40:
3600 		c->width = NL80211_CHAN_WIDTH_20;
3601 		c->center_freq1 = c->chan->center_freq;
3602 		if (conn->mode == IEEE80211_CONN_MODE_VHT)
3603 			conn->mode = IEEE80211_CONN_MODE_HT;
3604 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3605 		c->punctured = 0;
3606 		break;
3607 	case NL80211_CHAN_WIDTH_80:
3608 		new_primary_width = NL80211_CHAN_WIDTH_40;
3609 		if (conn->mode == IEEE80211_CONN_MODE_VHT)
3610 			conn->mode = IEEE80211_CONN_MODE_HT;
3611 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_40;
3612 		break;
3613 	case NL80211_CHAN_WIDTH_80P80:
3614 		c->center_freq2 = 0;
3615 		c->width = NL80211_CHAN_WIDTH_80;
3616 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_80;
3617 		break;
3618 	case NL80211_CHAN_WIDTH_160:
3619 		new_primary_width = NL80211_CHAN_WIDTH_80;
3620 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_80;
3621 		break;
3622 	case NL80211_CHAN_WIDTH_320:
3623 		new_primary_width = NL80211_CHAN_WIDTH_160;
3624 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_160;
3625 		break;
3626 	case NL80211_CHAN_WIDTH_1:
3627 	case NL80211_CHAN_WIDTH_2:
3628 	case NL80211_CHAN_WIDTH_4:
3629 	case NL80211_CHAN_WIDTH_8:
3630 	case NL80211_CHAN_WIDTH_16:
3631 		WARN_ON_ONCE(1);
3632 		/* keep c->width */
3633 		conn->mode = IEEE80211_CONN_MODE_S1G;
3634 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3635 		break;
3636 	case NL80211_CHAN_WIDTH_5:
3637 	case NL80211_CHAN_WIDTH_10:
3638 		WARN_ON_ONCE(1);
3639 		/* keep c->width */
3640 		conn->mode = IEEE80211_CONN_MODE_LEGACY;
3641 		conn->bw_limit = IEEE80211_CONN_BW_LIMIT_20;
3642 		break;
3643 	}
3644 
3645 	if (new_primary_width != NL80211_CHAN_WIDTH_20_NOHT) {
3646 		c->center_freq1 = cfg80211_chandef_primary(c, new_primary_width,
3647 							   &c->punctured);
3648 		c->width = new_primary_width;
3649 	}
3650 
3651 	/*
3652 	 * With an 80 MHz channel, we might have the puncturing in the primary
3653 	 * 40 Mhz channel, but that's not valid when downgraded to 40 MHz width.
3654 	 * In that case, downgrade again.
3655 	 */
3656 	if (!cfg80211_chandef_valid(c) && c->punctured)
3657 		goto again;
3658 
3659 	WARN_ON_ONCE(!cfg80211_chandef_valid(c));
3660 }
3661 
ieee80211_send_action_csa(struct ieee80211_sub_if_data * sdata,struct cfg80211_csa_settings * csa_settings)3662 int ieee80211_send_action_csa(struct ieee80211_sub_if_data *sdata,
3663 			      struct cfg80211_csa_settings *csa_settings)
3664 {
3665 	struct sk_buff *skb;
3666 	struct ieee80211_mgmt *mgmt;
3667 	struct ieee80211_local *local = sdata->local;
3668 	int freq;
3669 	int hdr_len = offsetofend(struct ieee80211_mgmt,
3670 				  u.action.u.chan_switch);
3671 	u8 *pos;
3672 
3673 	if (sdata->vif.type != NL80211_IFTYPE_ADHOC &&
3674 	    sdata->vif.type != NL80211_IFTYPE_MESH_POINT)
3675 		return -EOPNOTSUPP;
3676 
3677 	skb = dev_alloc_skb(local->tx_headroom + hdr_len +
3678 			    5 + /* channel switch announcement element */
3679 			    3 + /* secondary channel offset element */
3680 			    5 + /* wide bandwidth channel switch announcement */
3681 			    8); /* mesh channel switch parameters element */
3682 	if (!skb)
3683 		return -ENOMEM;
3684 
3685 	skb_reserve(skb, local->tx_headroom);
3686 	mgmt = skb_put_zero(skb, hdr_len);
3687 	mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
3688 					  IEEE80211_STYPE_ACTION);
3689 
3690 	eth_broadcast_addr(mgmt->da);
3691 	memcpy(mgmt->sa, sdata->vif.addr, ETH_ALEN);
3692 	if (ieee80211_vif_is_mesh(&sdata->vif)) {
3693 		memcpy(mgmt->bssid, sdata->vif.addr, ETH_ALEN);
3694 	} else {
3695 		struct ieee80211_if_ibss *ifibss = &sdata->u.ibss;
3696 		memcpy(mgmt->bssid, ifibss->bssid, ETH_ALEN);
3697 	}
3698 	mgmt->u.action.category = WLAN_CATEGORY_SPECTRUM_MGMT;
3699 	mgmt->u.action.u.chan_switch.action_code = WLAN_ACTION_SPCT_CHL_SWITCH;
3700 	pos = skb_put(skb, 5);
3701 	*pos++ = WLAN_EID_CHANNEL_SWITCH;			/* EID */
3702 	*pos++ = 3;						/* IE length */
3703 	*pos++ = csa_settings->block_tx ? 1 : 0;		/* CSA mode */
3704 	freq = csa_settings->chandef.chan->center_freq;
3705 	*pos++ = ieee80211_frequency_to_channel(freq);		/* channel */
3706 	*pos++ = csa_settings->count;				/* count */
3707 
3708 	if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_40) {
3709 		enum nl80211_channel_type ch_type;
3710 
3711 		skb_put(skb, 3);
3712 		*pos++ = WLAN_EID_SECONDARY_CHANNEL_OFFSET;	/* EID */
3713 		*pos++ = 1;					/* IE length */
3714 		ch_type = cfg80211_get_chandef_type(&csa_settings->chandef);
3715 		if (ch_type == NL80211_CHAN_HT40PLUS)
3716 			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_ABOVE;
3717 		else
3718 			*pos++ = IEEE80211_HT_PARAM_CHA_SEC_BELOW;
3719 	}
3720 
3721 	if (ieee80211_vif_is_mesh(&sdata->vif)) {
3722 		struct ieee80211_if_mesh *ifmsh = &sdata->u.mesh;
3723 
3724 		skb_put(skb, 8);
3725 		*pos++ = WLAN_EID_CHAN_SWITCH_PARAM;		/* EID */
3726 		*pos++ = 6;					/* IE length */
3727 		*pos++ = sdata->u.mesh.mshcfg.dot11MeshTTL;	/* Mesh TTL */
3728 		*pos = 0x00;	/* Mesh Flag: Tx Restrict, Initiator, Reason */
3729 		*pos |= WLAN_EID_CHAN_SWITCH_PARAM_INITIATOR;
3730 		*pos++ |= csa_settings->block_tx ?
3731 			  WLAN_EID_CHAN_SWITCH_PARAM_TX_RESTRICT : 0x00;
3732 		put_unaligned_le16(WLAN_REASON_MESH_CHAN, pos); /* Reason Cd */
3733 		pos += 2;
3734 		put_unaligned_le16(ifmsh->pre_value, pos);/* Precedence Value */
3735 		pos += 2;
3736 	}
3737 
3738 	if (csa_settings->chandef.width == NL80211_CHAN_WIDTH_80 ||
3739 	    csa_settings->chandef.width == NL80211_CHAN_WIDTH_80P80 ||
3740 	    csa_settings->chandef.width == NL80211_CHAN_WIDTH_160) {
3741 		skb_put(skb, 5);
3742 		ieee80211_ie_build_wide_bw_cs(pos, &csa_settings->chandef);
3743 	}
3744 
3745 	ieee80211_tx_skb(sdata, skb);
3746 	return 0;
3747 }
3748 
3749 static bool
ieee80211_extend_noa_desc(struct ieee80211_noa_data * data,u32 tsf,int i)3750 ieee80211_extend_noa_desc(struct ieee80211_noa_data *data, u32 tsf, int i)
3751 {
3752 	s32 end = data->desc[i].start + data->desc[i].duration - (tsf + 1);
3753 	int skip;
3754 
3755 	if (end > 0)
3756 		return false;
3757 
3758 	/* One shot NOA  */
3759 	if (data->count[i] == 1)
3760 		return false;
3761 
3762 	if (data->desc[i].interval == 0)
3763 		return false;
3764 
3765 	/* End time is in the past, check for repetitions */
3766 	skip = DIV_ROUND_UP(-end, data->desc[i].interval);
3767 	if (data->count[i] < 255) {
3768 		if (data->count[i] <= skip) {
3769 			data->count[i] = 0;
3770 			return false;
3771 		}
3772 
3773 		data->count[i] -= skip;
3774 	}
3775 
3776 	data->desc[i].start += skip * data->desc[i].interval;
3777 
3778 	return true;
3779 }
3780 
3781 static bool
ieee80211_extend_absent_time(struct ieee80211_noa_data * data,u32 tsf,s32 * offset)3782 ieee80211_extend_absent_time(struct ieee80211_noa_data *data, u32 tsf,
3783 			     s32 *offset)
3784 {
3785 	bool ret = false;
3786 	int i;
3787 
3788 	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3789 		s32 cur;
3790 
3791 		if (!data->count[i])
3792 			continue;
3793 
3794 		if (ieee80211_extend_noa_desc(data, tsf + *offset, i))
3795 			ret = true;
3796 
3797 		cur = data->desc[i].start - tsf;
3798 		if (cur > *offset)
3799 			continue;
3800 
3801 		cur = data->desc[i].start + data->desc[i].duration - tsf;
3802 		if (cur > *offset)
3803 			*offset = cur;
3804 	}
3805 
3806 	return ret;
3807 }
3808 
3809 static u32
ieee80211_get_noa_absent_time(struct ieee80211_noa_data * data,u32 tsf)3810 ieee80211_get_noa_absent_time(struct ieee80211_noa_data *data, u32 tsf)
3811 {
3812 	s32 offset = 0;
3813 	int tries = 0;
3814 	/*
3815 	 * arbitrary limit, used to avoid infinite loops when combined NoA
3816 	 * descriptors cover the full time period.
3817 	 */
3818 	int max_tries = 5;
3819 
3820 	ieee80211_extend_absent_time(data, tsf, &offset);
3821 	do {
3822 		if (!ieee80211_extend_absent_time(data, tsf, &offset))
3823 			break;
3824 
3825 		tries++;
3826 	} while (tries < max_tries);
3827 
3828 	return offset;
3829 }
3830 
ieee80211_update_p2p_noa(struct ieee80211_noa_data * data,u32 tsf)3831 void ieee80211_update_p2p_noa(struct ieee80211_noa_data *data, u32 tsf)
3832 {
3833 	u32 next_offset = BIT(31) - 1;
3834 	int i;
3835 
3836 	data->absent = 0;
3837 	data->has_next_tsf = false;
3838 	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3839 		s32 start;
3840 
3841 		if (!data->count[i])
3842 			continue;
3843 
3844 		ieee80211_extend_noa_desc(data, tsf, i);
3845 		start = data->desc[i].start - tsf;
3846 		if (start <= 0)
3847 			data->absent |= BIT(i);
3848 
3849 		if (next_offset > start)
3850 			next_offset = start;
3851 
3852 		data->has_next_tsf = true;
3853 	}
3854 
3855 	if (data->absent)
3856 		next_offset = ieee80211_get_noa_absent_time(data, tsf);
3857 
3858 	data->next_tsf = tsf + next_offset;
3859 }
3860 EXPORT_SYMBOL(ieee80211_update_p2p_noa);
3861 
ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr * attr,struct ieee80211_noa_data * data,u32 tsf)3862 int ieee80211_parse_p2p_noa(const struct ieee80211_p2p_noa_attr *attr,
3863 			    struct ieee80211_noa_data *data, u32 tsf)
3864 {
3865 	int ret = 0;
3866 	int i;
3867 
3868 	memset(data, 0, sizeof(*data));
3869 
3870 	for (i = 0; i < IEEE80211_P2P_NOA_DESC_MAX; i++) {
3871 		const struct ieee80211_p2p_noa_desc *desc = &attr->desc[i];
3872 
3873 		if (!desc->count || !desc->duration)
3874 			continue;
3875 
3876 		data->count[i] = desc->count;
3877 		data->desc[i].start = le32_to_cpu(desc->start_time);
3878 		data->desc[i].duration = le32_to_cpu(desc->duration);
3879 		data->desc[i].interval = le32_to_cpu(desc->interval);
3880 
3881 		if (data->count[i] > 1 &&
3882 		    data->desc[i].interval < data->desc[i].duration)
3883 			continue;
3884 
3885 		ieee80211_extend_noa_desc(data, tsf, i);
3886 		ret++;
3887 	}
3888 
3889 	if (ret)
3890 		ieee80211_update_p2p_noa(data, tsf);
3891 
3892 	return ret;
3893 }
3894 EXPORT_SYMBOL(ieee80211_parse_p2p_noa);
3895 
ieee80211_recalc_dtim(struct ieee80211_local * local,struct ieee80211_sub_if_data * sdata)3896 void ieee80211_recalc_dtim(struct ieee80211_local *local,
3897 			   struct ieee80211_sub_if_data *sdata)
3898 {
3899 	u64 tsf = drv_get_tsf(local, sdata);
3900 	u64 dtim_count = 0;
3901 	u16 beacon_int = sdata->vif.bss_conf.beacon_int * 1024;
3902 	u8 dtim_period = sdata->vif.bss_conf.dtim_period;
3903 	struct ps_data *ps;
3904 	u8 bcns_from_dtim;
3905 
3906 	if (tsf == -1ULL || !beacon_int || !dtim_period)
3907 		return;
3908 
3909 	if (sdata->vif.type == NL80211_IFTYPE_AP ||
3910 	    sdata->vif.type == NL80211_IFTYPE_AP_VLAN) {
3911 		if (!sdata->bss)
3912 			return;
3913 
3914 		ps = &sdata->bss->ps;
3915 	} else if (ieee80211_vif_is_mesh(&sdata->vif)) {
3916 		ps = &sdata->u.mesh.ps;
3917 	} else {
3918 		return;
3919 	}
3920 
3921 	/*
3922 	 * actually finds last dtim_count, mac80211 will update in
3923 	 * __beacon_add_tim().
3924 	 * dtim_count = dtim_period - (tsf / bcn_int) % dtim_period
3925 	 */
3926 	do_div(tsf, beacon_int);
3927 	bcns_from_dtim = do_div(tsf, dtim_period);
3928 	/* just had a DTIM */
3929 	if (!bcns_from_dtim)
3930 		dtim_count = 0;
3931 	else
3932 		dtim_count = dtim_period - bcns_from_dtim;
3933 
3934 	ps->dtim_count = dtim_count;
3935 }
3936 
ieee80211_chanctx_radar_detect(struct ieee80211_local * local,struct ieee80211_chanctx * ctx)3937 static u8 ieee80211_chanctx_radar_detect(struct ieee80211_local *local,
3938 					 struct ieee80211_chanctx *ctx)
3939 {
3940 	struct ieee80211_link_data *link;
3941 	u8 radar_detect = 0;
3942 
3943 	lockdep_assert_wiphy(local->hw.wiphy);
3944 
3945 	if (WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED))
3946 		return 0;
3947 
3948 	list_for_each_entry(link, &ctx->reserved_links, reserved_chanctx_list)
3949 		if (link->reserved_radar_required)
3950 			radar_detect |= BIT(link->reserved.oper.width);
3951 
3952 	/*
3953 	 * An in-place reservation context should not have any assigned vifs
3954 	 * until it replaces the other context.
3955 	 */
3956 	WARN_ON(ctx->replace_state == IEEE80211_CHANCTX_REPLACES_OTHER &&
3957 		!list_empty(&ctx->assigned_links));
3958 
3959 	list_for_each_entry(link, &ctx->assigned_links, assigned_chanctx_list) {
3960 		if (!link->radar_required)
3961 			continue;
3962 
3963 		radar_detect |=
3964 			BIT(link->conf->chanreq.oper.width);
3965 	}
3966 
3967 	return radar_detect;
3968 }
3969 
3970 static u32
__ieee80211_get_radio_mask(struct ieee80211_sub_if_data * sdata)3971 __ieee80211_get_radio_mask(struct ieee80211_sub_if_data *sdata)
3972 {
3973 	struct ieee80211_bss_conf *link_conf;
3974 	struct ieee80211_chanctx_conf *conf;
3975 	unsigned int link_id;
3976 	u32 mask = 0;
3977 
3978 	for_each_vif_active_link(&sdata->vif, link_conf, link_id) {
3979 		conf = sdata_dereference(link_conf->chanctx_conf, sdata);
3980 		if (!conf || conf->radio_idx < 0)
3981 			continue;
3982 
3983 		mask |= BIT(conf->radio_idx);
3984 	}
3985 
3986 	return mask;
3987 }
3988 
ieee80211_get_radio_mask(struct wiphy * wiphy,struct net_device * dev)3989 u32 ieee80211_get_radio_mask(struct wiphy *wiphy, struct net_device *dev)
3990 {
3991 	struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
3992 
3993 	return __ieee80211_get_radio_mask(sdata);
3994 }
3995 
3996 static bool
ieee80211_sdata_uses_radio(struct ieee80211_sub_if_data * sdata,int radio_idx)3997 ieee80211_sdata_uses_radio(struct ieee80211_sub_if_data *sdata, int radio_idx)
3998 {
3999 	if (radio_idx < 0)
4000 		return true;
4001 
4002 	return __ieee80211_get_radio_mask(sdata) & BIT(radio_idx);
4003 }
4004 
4005 static int
ieee80211_fill_ifcomb_params(struct ieee80211_local * local,struct iface_combination_params * params,const struct cfg80211_chan_def * chandef,struct ieee80211_sub_if_data * sdata)4006 ieee80211_fill_ifcomb_params(struct ieee80211_local *local,
4007 			     struct iface_combination_params *params,
4008 			     const struct cfg80211_chan_def *chandef,
4009 			     struct ieee80211_sub_if_data *sdata)
4010 {
4011 	struct ieee80211_sub_if_data *sdata_iter;
4012 	struct ieee80211_chanctx *ctx;
4013 	int total = !!sdata;
4014 
4015 	list_for_each_entry(ctx, &local->chanctx_list, list) {
4016 		if (ctx->replace_state == IEEE80211_CHANCTX_WILL_BE_REPLACED)
4017 			continue;
4018 
4019 		if (params->radio_idx >= 0 &&
4020 		    ctx->conf.radio_idx != params->radio_idx)
4021 			continue;
4022 
4023 		params->radar_detect |=
4024 			ieee80211_chanctx_radar_detect(local, ctx);
4025 
4026 		if (chandef && ctx->mode != IEEE80211_CHANCTX_EXCLUSIVE &&
4027 		    cfg80211_chandef_compatible(chandef, &ctx->conf.def))
4028 			continue;
4029 
4030 		params->num_different_channels++;
4031 	}
4032 
4033 	list_for_each_entry(sdata_iter, &local->interfaces, list) {
4034 		struct wireless_dev *wdev_iter;
4035 
4036 		wdev_iter = &sdata_iter->wdev;
4037 
4038 		if (sdata_iter == sdata ||
4039 		    !ieee80211_sdata_running(sdata_iter) ||
4040 		    cfg80211_iftype_allowed(local->hw.wiphy,
4041 					    wdev_iter->iftype, 0, 1))
4042 			continue;
4043 
4044 		if (!ieee80211_sdata_uses_radio(sdata_iter, params->radio_idx))
4045 			continue;
4046 
4047 		params->iftype_num[wdev_iter->iftype]++;
4048 		total++;
4049 	}
4050 
4051 	return total;
4052 }
4053 
ieee80211_check_combinations(struct ieee80211_sub_if_data * sdata,const struct cfg80211_chan_def * chandef,enum ieee80211_chanctx_mode chanmode,u8 radar_detect,int radio_idx)4054 int ieee80211_check_combinations(struct ieee80211_sub_if_data *sdata,
4055 				 const struct cfg80211_chan_def *chandef,
4056 				 enum ieee80211_chanctx_mode chanmode,
4057 				 u8 radar_detect, int radio_idx)
4058 {
4059 	bool shared = chanmode == IEEE80211_CHANCTX_SHARED;
4060 	struct ieee80211_local *local = sdata->local;
4061 	enum nl80211_iftype iftype = sdata->wdev.iftype;
4062 	struct iface_combination_params params = {
4063 		.radar_detect = radar_detect,
4064 		.radio_idx = radio_idx,
4065 	};
4066 	int total;
4067 
4068 	lockdep_assert_wiphy(local->hw.wiphy);
4069 
4070 	if (WARN_ON(hweight32(radar_detect) > 1))
4071 		return -EINVAL;
4072 
4073 	if (WARN_ON(chandef && chanmode == IEEE80211_CHANCTX_SHARED &&
4074 		    !chandef->chan))
4075 		return -EINVAL;
4076 
4077 	if (WARN_ON(iftype >= NUM_NL80211_IFTYPES))
4078 		return -EINVAL;
4079 
4080 	if (sdata->vif.type == NL80211_IFTYPE_AP ||
4081 	    sdata->vif.type == NL80211_IFTYPE_MESH_POINT) {
4082 		/*
4083 		 * always passing this is harmless, since it'll be the
4084 		 * same value that cfg80211 finds if it finds the same
4085 		 * interface ... and that's always allowed
4086 		 */
4087 		params.new_beacon_int = sdata->vif.bss_conf.beacon_int;
4088 	}
4089 
4090 	/* Always allow software iftypes */
4091 	if (cfg80211_iftype_allowed(local->hw.wiphy, iftype, 0, 1)) {
4092 		if (radar_detect)
4093 			return -EINVAL;
4094 		return 0;
4095 	}
4096 
4097 	if (chandef)
4098 		params.num_different_channels = 1;
4099 
4100 	if (iftype != NL80211_IFTYPE_UNSPECIFIED)
4101 		params.iftype_num[iftype] = 1;
4102 
4103 	total = ieee80211_fill_ifcomb_params(local, &params,
4104 					     shared ? chandef : NULL,
4105 					     sdata);
4106 	if (total == 1 && !params.radar_detect)
4107 		return 0;
4108 
4109 	return cfg80211_check_combinations(local->hw.wiphy, &params);
4110 }
4111 
4112 static void
ieee80211_iter_max_chans(const struct ieee80211_iface_combination * c,void * data)4113 ieee80211_iter_max_chans(const struct ieee80211_iface_combination *c,
4114 			 void *data)
4115 {
4116 	u32 *max_num_different_channels = data;
4117 
4118 	*max_num_different_channels = max(*max_num_different_channels,
4119 					  c->num_different_channels);
4120 }
4121 
ieee80211_max_num_channels(struct ieee80211_local * local,int radio_idx)4122 int ieee80211_max_num_channels(struct ieee80211_local *local, int radio_idx)
4123 {
4124 	u32 max_num_different_channels = 1;
4125 	int err;
4126 	struct iface_combination_params params = {
4127 		.radio_idx = radio_idx,
4128 	};
4129 
4130 	lockdep_assert_wiphy(local->hw.wiphy);
4131 
4132 	ieee80211_fill_ifcomb_params(local, &params, NULL, NULL);
4133 
4134 	err = cfg80211_iter_combinations(local->hw.wiphy, &params,
4135 					 ieee80211_iter_max_chans,
4136 					 &max_num_different_channels);
4137 	if (err < 0)
4138 		return err;
4139 
4140 	return max_num_different_channels;
4141 }
4142 
ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data * sdata,struct ieee80211_sta_s1g_cap * caps,struct sk_buff * skb)4143 void ieee80211_add_s1g_capab_ie(struct ieee80211_sub_if_data *sdata,
4144 				struct ieee80211_sta_s1g_cap *caps,
4145 				struct sk_buff *skb)
4146 {
4147 	struct ieee80211_if_managed *ifmgd = &sdata->u.mgd;
4148 	struct ieee80211_s1g_cap s1g_capab;
4149 	u8 *pos;
4150 	int i;
4151 
4152 	if (WARN_ON(sdata->vif.type != NL80211_IFTYPE_STATION))
4153 		return;
4154 
4155 	if (!caps->s1g)
4156 		return;
4157 
4158 	memcpy(s1g_capab.capab_info, caps->cap, sizeof(caps->cap));
4159 	memcpy(s1g_capab.supp_mcs_nss, caps->nss_mcs, sizeof(caps->nss_mcs));
4160 
4161 	/* override the capability info */
4162 	for (i = 0; i < sizeof(ifmgd->s1g_capa.capab_info); i++) {
4163 		u8 mask = ifmgd->s1g_capa_mask.capab_info[i];
4164 
4165 		s1g_capab.capab_info[i] &= ~mask;
4166 		s1g_capab.capab_info[i] |= ifmgd->s1g_capa.capab_info[i] & mask;
4167 	}
4168 
4169 	/* then MCS and NSS set */
4170 	for (i = 0; i < sizeof(ifmgd->s1g_capa.supp_mcs_nss); i++) {
4171 		u8 mask = ifmgd->s1g_capa_mask.supp_mcs_nss[i];
4172 
4173 		s1g_capab.supp_mcs_nss[i] &= ~mask;
4174 		s1g_capab.supp_mcs_nss[i] |=
4175 			ifmgd->s1g_capa.supp_mcs_nss[i] & mask;
4176 	}
4177 
4178 	pos = skb_put(skb, 2 + sizeof(s1g_capab));
4179 	*pos++ = WLAN_EID_S1G_CAPABILITIES;
4180 	*pos++ = sizeof(s1g_capab);
4181 
4182 	memcpy(pos, &s1g_capab, sizeof(s1g_capab));
4183 }
4184 
ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data * sdata,struct sk_buff * skb)4185 void ieee80211_add_aid_request_ie(struct ieee80211_sub_if_data *sdata,
4186 				  struct sk_buff *skb)
4187 {
4188 	u8 *pos = skb_put(skb, 3);
4189 
4190 	*pos++ = WLAN_EID_AID_REQUEST;
4191 	*pos++ = 1;
4192 	*pos++ = 0;
4193 }
4194 
ieee80211_add_wmm_info_ie(u8 * buf,u8 qosinfo)4195 u8 *ieee80211_add_wmm_info_ie(u8 *buf, u8 qosinfo)
4196 {
4197 	*buf++ = WLAN_EID_VENDOR_SPECIFIC;
4198 	*buf++ = 7; /* len */
4199 	*buf++ = 0x00; /* Microsoft OUI 00:50:F2 */
4200 	*buf++ = 0x50;
4201 	*buf++ = 0xf2;
4202 	*buf++ = 2; /* WME */
4203 	*buf++ = 0; /* WME info */
4204 	*buf++ = 1; /* WME ver */
4205 	*buf++ = qosinfo; /* U-APSD no in use */
4206 
4207 	return buf;
4208 }
4209 
ieee80211_txq_get_depth(struct ieee80211_txq * txq,unsigned long * frame_cnt,unsigned long * byte_cnt)4210 void ieee80211_txq_get_depth(struct ieee80211_txq *txq,
4211 			     unsigned long *frame_cnt,
4212 			     unsigned long *byte_cnt)
4213 {
4214 	struct txq_info *txqi = to_txq_info(txq);
4215 	u32 frag_cnt = 0, frag_bytes = 0;
4216 	struct sk_buff *skb;
4217 
4218 	skb_queue_walk(&txqi->frags, skb) {
4219 		frag_cnt++;
4220 		frag_bytes += skb->len;
4221 	}
4222 
4223 	if (frame_cnt)
4224 		*frame_cnt = txqi->tin.backlog_packets + frag_cnt;
4225 
4226 	if (byte_cnt)
4227 		*byte_cnt = txqi->tin.backlog_bytes + frag_bytes;
4228 }
4229 EXPORT_SYMBOL(ieee80211_txq_get_depth);
4230 
4231 const u8 ieee80211_ac_to_qos_mask[IEEE80211_NUM_ACS] = {
4232 	IEEE80211_WMM_IE_STA_QOSINFO_AC_VO,
4233 	IEEE80211_WMM_IE_STA_QOSINFO_AC_VI,
4234 	IEEE80211_WMM_IE_STA_QOSINFO_AC_BE,
4235 	IEEE80211_WMM_IE_STA_QOSINFO_AC_BK
4236 };
4237 
ieee80211_encode_usf(int listen_interval)4238 u16 ieee80211_encode_usf(int listen_interval)
4239 {
4240 	static const int listen_int_usf[] = { 1, 10, 1000, 10000 };
4241 	u16 ui, usf = 0;
4242 
4243 	/* find greatest USF */
4244 	while (usf < IEEE80211_MAX_USF) {
4245 		if (listen_interval % listen_int_usf[usf + 1])
4246 			break;
4247 		usf += 1;
4248 	}
4249 	ui = listen_interval / listen_int_usf[usf];
4250 
4251 	/* error if there is a remainder. Should've been checked by user */
4252 	WARN_ON_ONCE(ui > IEEE80211_MAX_UI);
4253 	listen_interval = FIELD_PREP(LISTEN_INT_USF, usf) |
4254 			  FIELD_PREP(LISTEN_INT_UI, ui);
4255 
4256 	return (u16) listen_interval;
4257 }
4258 
4259 /* this may return more than ieee80211_put_eht_cap() will need */
ieee80211_ie_len_eht_cap(struct ieee80211_sub_if_data * sdata)4260 u8 ieee80211_ie_len_eht_cap(struct ieee80211_sub_if_data *sdata)
4261 {
4262 	const struct ieee80211_sta_he_cap *he_cap;
4263 	const struct ieee80211_sta_eht_cap *eht_cap;
4264 	struct ieee80211_supported_band *sband;
4265 	bool is_ap;
4266 	u8 n;
4267 
4268 	sband = ieee80211_get_sband(sdata);
4269 	if (!sband)
4270 		return 0;
4271 
4272 	he_cap = ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
4273 	eht_cap = ieee80211_get_eht_iftype_cap_vif(sband, &sdata->vif);
4274 	if (!he_cap || !eht_cap)
4275 		return 0;
4276 
4277 	is_ap = sdata->vif.type == NL80211_IFTYPE_AP;
4278 
4279 	n = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
4280 				       &eht_cap->eht_cap_elem,
4281 				       is_ap);
4282 	return 2 + 1 +
4283 	       sizeof(eht_cap->eht_cap_elem) + n +
4284 	       ieee80211_eht_ppe_size(eht_cap->eht_ppe_thres[0],
4285 				      eht_cap->eht_cap_elem.phy_cap_info);
4286 	return 0;
4287 }
4288 
ieee80211_put_eht_cap(struct sk_buff * skb,struct ieee80211_sub_if_data * sdata,const struct ieee80211_supported_band * sband,const struct ieee80211_conn_settings * conn)4289 int ieee80211_put_eht_cap(struct sk_buff *skb,
4290 			  struct ieee80211_sub_if_data *sdata,
4291 			  const struct ieee80211_supported_band *sband,
4292 			  const struct ieee80211_conn_settings *conn)
4293 {
4294 	const struct ieee80211_sta_he_cap *he_cap =
4295 		ieee80211_get_he_iftype_cap_vif(sband, &sdata->vif);
4296 	const struct ieee80211_sta_eht_cap *eht_cap =
4297 		ieee80211_get_eht_iftype_cap_vif(sband, &sdata->vif);
4298 	bool for_ap = sdata->vif.type == NL80211_IFTYPE_AP;
4299 	struct ieee80211_eht_cap_elem_fixed fixed;
4300 	struct ieee80211_he_cap_elem he;
4301 	u8 mcs_nss_len, ppet_len;
4302 	u8 orig_mcs_nss_len;
4303 	u8 ie_len;
4304 
4305 	if (!conn)
4306 		conn = &ieee80211_conn_settings_unlimited;
4307 
4308 	/* Make sure we have place for the IE */
4309 	if (!he_cap || !eht_cap)
4310 		return 0;
4311 
4312 	orig_mcs_nss_len = ieee80211_eht_mcs_nss_size(&he_cap->he_cap_elem,
4313 						      &eht_cap->eht_cap_elem,
4314 						      for_ap);
4315 
4316 	ieee80211_get_adjusted_he_cap(conn, he_cap, &he);
4317 
4318 	fixed = eht_cap->eht_cap_elem;
4319 
4320 	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_80)
4321 		fixed.phy_cap_info[6] &=
4322 			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_80MHZ;
4323 
4324 	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_160) {
4325 		fixed.phy_cap_info[1] &=
4326 			~IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_160MHZ_MASK;
4327 		fixed.phy_cap_info[2] &=
4328 			~IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_160MHZ_MASK;
4329 		fixed.phy_cap_info[6] &=
4330 			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_160MHZ;
4331 	}
4332 
4333 	if (conn->bw_limit < IEEE80211_CONN_BW_LIMIT_320) {
4334 		fixed.phy_cap_info[0] &=
4335 			~IEEE80211_EHT_PHY_CAP0_320MHZ_IN_6GHZ;
4336 		fixed.phy_cap_info[1] &=
4337 			~IEEE80211_EHT_PHY_CAP1_BEAMFORMEE_SS_320MHZ_MASK;
4338 		fixed.phy_cap_info[2] &=
4339 			~IEEE80211_EHT_PHY_CAP2_SOUNDING_DIM_320MHZ_MASK;
4340 		fixed.phy_cap_info[6] &=
4341 			~IEEE80211_EHT_PHY_CAP6_MCS15_SUPP_320MHZ;
4342 	}
4343 
4344 	if (conn->bw_limit == IEEE80211_CONN_BW_LIMIT_20)
4345 		fixed.phy_cap_info[0] &=
4346 			~IEEE80211_EHT_PHY_CAP0_242_TONE_RU_GT20MHZ;
4347 
4348 	mcs_nss_len = ieee80211_eht_mcs_nss_size(&he, &fixed, for_ap);
4349 	ppet_len = ieee80211_eht_ppe_size(eht_cap->eht_ppe_thres[0],
4350 					  fixed.phy_cap_info);
4351 
4352 	ie_len = 2 + 1 + sizeof(eht_cap->eht_cap_elem) + mcs_nss_len + ppet_len;
4353 	if (skb_tailroom(skb) < ie_len)
4354 		return -ENOBUFS;
4355 
4356 	skb_put_u8(skb, WLAN_EID_EXTENSION);
4357 	skb_put_u8(skb, ie_len - 2);
4358 	skb_put_u8(skb, WLAN_EID_EXT_EHT_CAPABILITY);
4359 	skb_put_data(skb, &fixed, sizeof(fixed));
4360 
4361 	if (mcs_nss_len == 4 && orig_mcs_nss_len != 4) {
4362 		/*
4363 		 * If the (non-AP) STA became 20 MHz only, then convert from
4364 		 * <=80 to 20-MHz-only format, where MCSes are indicated in
4365 		 * the groups 0-7, 8-9, 10-11, 12-13 rather than just 0-9,
4366 		 * 10-11, 12-13. Thus, use 0-9 for 0-7 and 8-9.
4367 		 */
4368 		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs9_max_nss);
4369 		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs9_max_nss);
4370 		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs11_max_nss);
4371 		skb_put_u8(skb, eht_cap->eht_mcs_nss_supp.bw._80.rx_tx_mcs13_max_nss);
4372 	} else {
4373 		skb_put_data(skb, &eht_cap->eht_mcs_nss_supp, mcs_nss_len);
4374 	}
4375 
4376 	if (ppet_len)
4377 		skb_put_data(skb, &eht_cap->eht_ppe_thres, ppet_len);
4378 
4379 	return 0;
4380 }
4381 
ieee80211_conn_mode_str(enum ieee80211_conn_mode mode)4382 const char *ieee80211_conn_mode_str(enum ieee80211_conn_mode mode)
4383 {
4384 	static const char * const modes[] = {
4385 		[IEEE80211_CONN_MODE_S1G] = "S1G",
4386 		[IEEE80211_CONN_MODE_LEGACY] = "legacy",
4387 		[IEEE80211_CONN_MODE_HT] = "HT",
4388 		[IEEE80211_CONN_MODE_VHT] = "VHT",
4389 		[IEEE80211_CONN_MODE_HE] = "HE",
4390 		[IEEE80211_CONN_MODE_EHT] = "EHT",
4391 	};
4392 
4393 	if (WARN_ON(mode >= ARRAY_SIZE(modes)))
4394 		return "<out of range>";
4395 
4396 	return modes[mode] ?: "<missing string>";
4397 }
4398 
4399 enum ieee80211_conn_bw_limit
ieee80211_min_bw_limit_from_chandef(struct cfg80211_chan_def * chandef)4400 ieee80211_min_bw_limit_from_chandef(struct cfg80211_chan_def *chandef)
4401 {
4402 	switch (chandef->width) {
4403 	case NL80211_CHAN_WIDTH_20_NOHT:
4404 	case NL80211_CHAN_WIDTH_20:
4405 		return IEEE80211_CONN_BW_LIMIT_20;
4406 	case NL80211_CHAN_WIDTH_40:
4407 		return IEEE80211_CONN_BW_LIMIT_40;
4408 	case NL80211_CHAN_WIDTH_80:
4409 		return IEEE80211_CONN_BW_LIMIT_80;
4410 	case NL80211_CHAN_WIDTH_80P80:
4411 	case NL80211_CHAN_WIDTH_160:
4412 		return IEEE80211_CONN_BW_LIMIT_160;
4413 	case NL80211_CHAN_WIDTH_320:
4414 		return IEEE80211_CONN_BW_LIMIT_320;
4415 	default:
4416 		WARN(1, "unhandled chandef width %d\n", chandef->width);
4417 		return IEEE80211_CONN_BW_LIMIT_20;
4418 	}
4419 }
4420 
ieee80211_clear_tpe(struct ieee80211_parsed_tpe * tpe)4421 void ieee80211_clear_tpe(struct ieee80211_parsed_tpe *tpe)
4422 {
4423 	for (int i = 0; i < 2; i++) {
4424 		tpe->max_local[i].valid = false;
4425 		memset(tpe->max_local[i].power,
4426 		       IEEE80211_TPE_MAX_TX_PWR_NO_CONSTRAINT,
4427 		       sizeof(tpe->max_local[i].power));
4428 
4429 		tpe->max_reg_client[i].valid = false;
4430 		memset(tpe->max_reg_client[i].power,
4431 		       IEEE80211_TPE_MAX_TX_PWR_NO_CONSTRAINT,
4432 		       sizeof(tpe->max_reg_client[i].power));
4433 
4434 		tpe->psd_local[i].valid = false;
4435 		memset(tpe->psd_local[i].power,
4436 		       IEEE80211_TPE_PSD_NO_LIMIT,
4437 		       sizeof(tpe->psd_local[i].power));
4438 
4439 		tpe->psd_reg_client[i].valid = false;
4440 		memset(tpe->psd_reg_client[i].power,
4441 		       IEEE80211_TPE_PSD_NO_LIMIT,
4442 		       sizeof(tpe->psd_reg_client[i].power));
4443 	}
4444 }
4445