xref: /openbmc/linux/net/wireless/chan.c (revision 6774def6)
1 /*
2  * This file contains helper code to handle channel
3  * settings and keeping track of what is possible at
4  * any point in time.
5  *
6  * Copyright 2009	Johannes Berg <johannes@sipsolutions.net>
7  * Copyright 2013-2014  Intel Mobile Communications GmbH
8  */
9 
10 #include <linux/export.h>
11 #include <net/cfg80211.h>
12 #include "core.h"
13 #include "rdev-ops.h"
14 
15 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
16 			     struct ieee80211_channel *chan,
17 			     enum nl80211_channel_type chan_type)
18 {
19 	if (WARN_ON(!chan))
20 		return;
21 
22 	chandef->chan = chan;
23 	chandef->center_freq2 = 0;
24 
25 	switch (chan_type) {
26 	case NL80211_CHAN_NO_HT:
27 		chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
28 		chandef->center_freq1 = chan->center_freq;
29 		break;
30 	case NL80211_CHAN_HT20:
31 		chandef->width = NL80211_CHAN_WIDTH_20;
32 		chandef->center_freq1 = chan->center_freq;
33 		break;
34 	case NL80211_CHAN_HT40PLUS:
35 		chandef->width = NL80211_CHAN_WIDTH_40;
36 		chandef->center_freq1 = chan->center_freq + 10;
37 		break;
38 	case NL80211_CHAN_HT40MINUS:
39 		chandef->width = NL80211_CHAN_WIDTH_40;
40 		chandef->center_freq1 = chan->center_freq - 10;
41 		break;
42 	default:
43 		WARN_ON(1);
44 	}
45 }
46 EXPORT_SYMBOL(cfg80211_chandef_create);
47 
48 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
49 {
50 	u32 control_freq;
51 
52 	if (!chandef->chan)
53 		return false;
54 
55 	control_freq = chandef->chan->center_freq;
56 
57 	switch (chandef->width) {
58 	case NL80211_CHAN_WIDTH_5:
59 	case NL80211_CHAN_WIDTH_10:
60 	case NL80211_CHAN_WIDTH_20:
61 	case NL80211_CHAN_WIDTH_20_NOHT:
62 		if (chandef->center_freq1 != control_freq)
63 			return false;
64 		if (chandef->center_freq2)
65 			return false;
66 		break;
67 	case NL80211_CHAN_WIDTH_40:
68 		if (chandef->center_freq1 != control_freq + 10 &&
69 		    chandef->center_freq1 != control_freq - 10)
70 			return false;
71 		if (chandef->center_freq2)
72 			return false;
73 		break;
74 	case NL80211_CHAN_WIDTH_80P80:
75 		if (chandef->center_freq1 != control_freq + 30 &&
76 		    chandef->center_freq1 != control_freq + 10 &&
77 		    chandef->center_freq1 != control_freq - 10 &&
78 		    chandef->center_freq1 != control_freq - 30)
79 			return false;
80 		if (!chandef->center_freq2)
81 			return false;
82 		/* adjacent is not allowed -- that's a 160 MHz channel */
83 		if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
84 		    chandef->center_freq2 - chandef->center_freq1 == 80)
85 			return false;
86 		break;
87 	case NL80211_CHAN_WIDTH_80:
88 		if (chandef->center_freq1 != control_freq + 30 &&
89 		    chandef->center_freq1 != control_freq + 10 &&
90 		    chandef->center_freq1 != control_freq - 10 &&
91 		    chandef->center_freq1 != control_freq - 30)
92 			return false;
93 		if (chandef->center_freq2)
94 			return false;
95 		break;
96 	case NL80211_CHAN_WIDTH_160:
97 		if (chandef->center_freq1 != control_freq + 70 &&
98 		    chandef->center_freq1 != control_freq + 50 &&
99 		    chandef->center_freq1 != control_freq + 30 &&
100 		    chandef->center_freq1 != control_freq + 10 &&
101 		    chandef->center_freq1 != control_freq - 10 &&
102 		    chandef->center_freq1 != control_freq - 30 &&
103 		    chandef->center_freq1 != control_freq - 50 &&
104 		    chandef->center_freq1 != control_freq - 70)
105 			return false;
106 		if (chandef->center_freq2)
107 			return false;
108 		break;
109 	default:
110 		return false;
111 	}
112 
113 	return true;
114 }
115 EXPORT_SYMBOL(cfg80211_chandef_valid);
116 
117 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
118 				  int *pri40, int *pri80)
119 {
120 	int tmp;
121 
122 	switch (c->width) {
123 	case NL80211_CHAN_WIDTH_40:
124 		*pri40 = c->center_freq1;
125 		*pri80 = 0;
126 		break;
127 	case NL80211_CHAN_WIDTH_80:
128 	case NL80211_CHAN_WIDTH_80P80:
129 		*pri80 = c->center_freq1;
130 		/* n_P20 */
131 		tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
132 		/* n_P40 */
133 		tmp /= 2;
134 		/* freq_P40 */
135 		*pri40 = c->center_freq1 - 20 + 40 * tmp;
136 		break;
137 	case NL80211_CHAN_WIDTH_160:
138 		/* n_P20 */
139 		tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
140 		/* n_P40 */
141 		tmp /= 2;
142 		/* freq_P40 */
143 		*pri40 = c->center_freq1 - 60 + 40 * tmp;
144 		/* n_P80 */
145 		tmp /= 2;
146 		*pri80 = c->center_freq1 - 40 + 80 * tmp;
147 		break;
148 	default:
149 		WARN_ON_ONCE(1);
150 	}
151 }
152 
153 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
154 {
155 	int width;
156 
157 	switch (c->width) {
158 	case NL80211_CHAN_WIDTH_5:
159 		width = 5;
160 		break;
161 	case NL80211_CHAN_WIDTH_10:
162 		width = 10;
163 		break;
164 	case NL80211_CHAN_WIDTH_20:
165 	case NL80211_CHAN_WIDTH_20_NOHT:
166 		width = 20;
167 		break;
168 	case NL80211_CHAN_WIDTH_40:
169 		width = 40;
170 		break;
171 	case NL80211_CHAN_WIDTH_80P80:
172 	case NL80211_CHAN_WIDTH_80:
173 		width = 80;
174 		break;
175 	case NL80211_CHAN_WIDTH_160:
176 		width = 160;
177 		break;
178 	default:
179 		WARN_ON_ONCE(1);
180 		return -1;
181 	}
182 	return width;
183 }
184 
185 const struct cfg80211_chan_def *
186 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
187 			    const struct cfg80211_chan_def *c2)
188 {
189 	u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
190 
191 	/* If they are identical, return */
192 	if (cfg80211_chandef_identical(c1, c2))
193 		return c1;
194 
195 	/* otherwise, must have same control channel */
196 	if (c1->chan != c2->chan)
197 		return NULL;
198 
199 	/*
200 	 * If they have the same width, but aren't identical,
201 	 * then they can't be compatible.
202 	 */
203 	if (c1->width == c2->width)
204 		return NULL;
205 
206 	/*
207 	 * can't be compatible if one of them is 5 or 10 MHz,
208 	 * but they don't have the same width.
209 	 */
210 	if (c1->width == NL80211_CHAN_WIDTH_5 ||
211 	    c1->width == NL80211_CHAN_WIDTH_10 ||
212 	    c2->width == NL80211_CHAN_WIDTH_5 ||
213 	    c2->width == NL80211_CHAN_WIDTH_10)
214 		return NULL;
215 
216 	if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
217 	    c1->width == NL80211_CHAN_WIDTH_20)
218 		return c2;
219 
220 	if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
221 	    c2->width == NL80211_CHAN_WIDTH_20)
222 		return c1;
223 
224 	chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
225 	chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
226 
227 	if (c1_pri40 != c2_pri40)
228 		return NULL;
229 
230 	WARN_ON(!c1_pri80 && !c2_pri80);
231 	if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
232 		return NULL;
233 
234 	if (c1->width > c2->width)
235 		return c1;
236 	return c2;
237 }
238 EXPORT_SYMBOL(cfg80211_chandef_compatible);
239 
240 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
241 					 u32 bandwidth,
242 					 enum nl80211_dfs_state dfs_state)
243 {
244 	struct ieee80211_channel *c;
245 	u32 freq;
246 
247 	for (freq = center_freq - bandwidth/2 + 10;
248 	     freq <= center_freq + bandwidth/2 - 10;
249 	     freq += 20) {
250 		c = ieee80211_get_channel(wiphy, freq);
251 		if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
252 			continue;
253 
254 		c->dfs_state = dfs_state;
255 		c->dfs_state_entered = jiffies;
256 	}
257 }
258 
259 void cfg80211_set_dfs_state(struct wiphy *wiphy,
260 			    const struct cfg80211_chan_def *chandef,
261 			    enum nl80211_dfs_state dfs_state)
262 {
263 	int width;
264 
265 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
266 		return;
267 
268 	width = cfg80211_chandef_get_width(chandef);
269 	if (width < 0)
270 		return;
271 
272 	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
273 				     width, dfs_state);
274 
275 	if (!chandef->center_freq2)
276 		return;
277 	cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
278 				     width, dfs_state);
279 }
280 
281 static u32 cfg80211_get_start_freq(u32 center_freq,
282 				   u32 bandwidth)
283 {
284 	u32 start_freq;
285 
286 	if (bandwidth <= 20)
287 		start_freq = center_freq;
288 	else
289 		start_freq = center_freq - bandwidth/2 + 10;
290 
291 	return start_freq;
292 }
293 
294 static u32 cfg80211_get_end_freq(u32 center_freq,
295 				 u32 bandwidth)
296 {
297 	u32 end_freq;
298 
299 	if (bandwidth <= 20)
300 		end_freq = center_freq;
301 	else
302 		end_freq = center_freq + bandwidth/2 - 10;
303 
304 	return end_freq;
305 }
306 
307 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
308 					    u32 center_freq,
309 					    u32 bandwidth)
310 {
311 	struct ieee80211_channel *c;
312 	u32 freq, start_freq, end_freq;
313 
314 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
315 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
316 
317 	for (freq = start_freq; freq <= end_freq; freq += 20) {
318 		c = ieee80211_get_channel(wiphy, freq);
319 		if (!c)
320 			return -EINVAL;
321 
322 		if (c->flags & IEEE80211_CHAN_RADAR)
323 			return 1;
324 	}
325 	return 0;
326 }
327 
328 
329 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
330 				  const struct cfg80211_chan_def *chandef,
331 				  enum nl80211_iftype iftype)
332 {
333 	int width;
334 	int ret;
335 
336 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
337 		return -EINVAL;
338 
339 	switch (iftype) {
340 	case NL80211_IFTYPE_ADHOC:
341 	case NL80211_IFTYPE_AP:
342 	case NL80211_IFTYPE_P2P_GO:
343 	case NL80211_IFTYPE_MESH_POINT:
344 		width = cfg80211_chandef_get_width(chandef);
345 		if (width < 0)
346 			return -EINVAL;
347 
348 		ret = cfg80211_get_chans_dfs_required(wiphy,
349 						      chandef->center_freq1,
350 						      width);
351 		if (ret < 0)
352 			return ret;
353 		else if (ret > 0)
354 			return BIT(chandef->width);
355 
356 		if (!chandef->center_freq2)
357 			return 0;
358 
359 		ret = cfg80211_get_chans_dfs_required(wiphy,
360 						      chandef->center_freq2,
361 						      width);
362 		if (ret < 0)
363 			return ret;
364 		else if (ret > 0)
365 			return BIT(chandef->width);
366 
367 		break;
368 	case NL80211_IFTYPE_STATION:
369 	case NL80211_IFTYPE_P2P_CLIENT:
370 	case NL80211_IFTYPE_MONITOR:
371 	case NL80211_IFTYPE_AP_VLAN:
372 	case NL80211_IFTYPE_WDS:
373 	case NL80211_IFTYPE_P2P_DEVICE:
374 		break;
375 	case NL80211_IFTYPE_UNSPECIFIED:
376 	case NUM_NL80211_IFTYPES:
377 		WARN_ON(1);
378 	}
379 
380 	return 0;
381 }
382 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
383 
384 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
385 					 u32 center_freq,
386 					 u32 bandwidth)
387 {
388 	struct ieee80211_channel *c;
389 	u32 freq, start_freq, end_freq;
390 	int count = 0;
391 
392 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
393 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
394 
395 	/*
396 	 * Check entire range of channels for the bandwidth.
397 	 * Check all channels are DFS channels (DFS_USABLE or
398 	 * DFS_AVAILABLE). Return number of usable channels
399 	 * (require CAC). Allow DFS and non-DFS channel mix.
400 	 */
401 	for (freq = start_freq; freq <= end_freq; freq += 20) {
402 		c = ieee80211_get_channel(wiphy, freq);
403 		if (!c)
404 			return -EINVAL;
405 
406 		if (c->flags & IEEE80211_CHAN_DISABLED)
407 			return -EINVAL;
408 
409 		if (c->flags & IEEE80211_CHAN_RADAR) {
410 			if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
411 				return -EINVAL;
412 
413 			if (c->dfs_state == NL80211_DFS_USABLE)
414 				count++;
415 		}
416 	}
417 
418 	return count;
419 }
420 
421 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
422 				 const struct cfg80211_chan_def *chandef)
423 {
424 	int width;
425 	int r1, r2 = 0;
426 
427 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
428 		return false;
429 
430 	width = cfg80211_chandef_get_width(chandef);
431 	if (width < 0)
432 		return false;
433 
434 	r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
435 					  width);
436 
437 	if (r1 < 0)
438 		return false;
439 
440 	switch (chandef->width) {
441 	case NL80211_CHAN_WIDTH_80P80:
442 		WARN_ON(!chandef->center_freq2);
443 		r2 = cfg80211_get_chans_dfs_usable(wiphy,
444 						   chandef->center_freq2,
445 						   width);
446 		if (r2 < 0)
447 			return false;
448 		break;
449 	default:
450 		WARN_ON(chandef->center_freq2);
451 		break;
452 	}
453 
454 	return (r1 + r2 > 0);
455 }
456 
457 
458 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
459 					     u32 center_freq,
460 					     u32 bandwidth)
461 {
462 	struct ieee80211_channel *c;
463 	u32 freq, start_freq, end_freq;
464 
465 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
466 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
467 
468 	/*
469 	 * Check entire range of channels for the bandwidth.
470 	 * If any channel in between is disabled or has not
471 	 * had gone through CAC return false
472 	 */
473 	for (freq = start_freq; freq <= end_freq; freq += 20) {
474 		c = ieee80211_get_channel(wiphy, freq);
475 		if (!c)
476 			return false;
477 
478 		if (c->flags & IEEE80211_CHAN_DISABLED)
479 			return false;
480 
481 		if ((c->flags & IEEE80211_CHAN_RADAR)  &&
482 		    (c->dfs_state != NL80211_DFS_AVAILABLE))
483 			return false;
484 	}
485 
486 	return true;
487 }
488 
489 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
490 				const struct cfg80211_chan_def *chandef)
491 {
492 	int width;
493 	int r;
494 
495 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
496 		return false;
497 
498 	width = cfg80211_chandef_get_width(chandef);
499 	if (width < 0)
500 		return false;
501 
502 	r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
503 					     width);
504 
505 	/* If any of channels unavailable for cf1 just return */
506 	if (!r)
507 		return r;
508 
509 	switch (chandef->width) {
510 	case NL80211_CHAN_WIDTH_80P80:
511 		WARN_ON(!chandef->center_freq2);
512 		r = cfg80211_get_chans_dfs_available(wiphy,
513 						     chandef->center_freq2,
514 						     width);
515 	default:
516 		WARN_ON(chandef->center_freq2);
517 		break;
518 	}
519 
520 	return r;
521 }
522 
523 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
524 						    u32 center_freq,
525 						    u32 bandwidth)
526 {
527 	struct ieee80211_channel *c;
528 	u32 start_freq, end_freq, freq;
529 	unsigned int dfs_cac_ms = 0;
530 
531 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
532 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
533 
534 	for (freq = start_freq; freq <= end_freq; freq += 20) {
535 		c = ieee80211_get_channel(wiphy, freq);
536 		if (!c)
537 			return 0;
538 
539 		if (c->flags & IEEE80211_CHAN_DISABLED)
540 			return 0;
541 
542 		if (!(c->flags & IEEE80211_CHAN_RADAR))
543 			continue;
544 
545 		if (c->dfs_cac_ms > dfs_cac_ms)
546 			dfs_cac_ms = c->dfs_cac_ms;
547 	}
548 
549 	return dfs_cac_ms;
550 }
551 
552 unsigned int
553 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
554 			      const struct cfg80211_chan_def *chandef)
555 {
556 	int width;
557 	unsigned int t1 = 0, t2 = 0;
558 
559 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
560 		return 0;
561 
562 	width = cfg80211_chandef_get_width(chandef);
563 	if (width < 0)
564 		return 0;
565 
566 	t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
567 					     chandef->center_freq1,
568 					     width);
569 
570 	if (!chandef->center_freq2)
571 		return t1;
572 
573 	t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
574 					     chandef->center_freq2,
575 					     width);
576 
577 	return max(t1, t2);
578 }
579 
580 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
581 					u32 center_freq, u32 bandwidth,
582 					u32 prohibited_flags)
583 {
584 	struct ieee80211_channel *c;
585 	u32 freq, start_freq, end_freq;
586 
587 	start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
588 	end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
589 
590 	for (freq = start_freq; freq <= end_freq; freq += 20) {
591 		c = ieee80211_get_channel(wiphy, freq);
592 		if (!c || c->flags & prohibited_flags)
593 			return false;
594 	}
595 
596 	return true;
597 }
598 
599 bool cfg80211_chandef_usable(struct wiphy *wiphy,
600 			     const struct cfg80211_chan_def *chandef,
601 			     u32 prohibited_flags)
602 {
603 	struct ieee80211_sta_ht_cap *ht_cap;
604 	struct ieee80211_sta_vht_cap *vht_cap;
605 	u32 width, control_freq;
606 
607 	if (WARN_ON(!cfg80211_chandef_valid(chandef)))
608 		return false;
609 
610 	ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
611 	vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
612 
613 	control_freq = chandef->chan->center_freq;
614 
615 	switch (chandef->width) {
616 	case NL80211_CHAN_WIDTH_5:
617 		width = 5;
618 		break;
619 	case NL80211_CHAN_WIDTH_10:
620 		prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
621 		width = 10;
622 		break;
623 	case NL80211_CHAN_WIDTH_20:
624 		if (!ht_cap->ht_supported)
625 			return false;
626 	case NL80211_CHAN_WIDTH_20_NOHT:
627 		prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
628 		width = 20;
629 		break;
630 	case NL80211_CHAN_WIDTH_40:
631 		width = 40;
632 		if (!ht_cap->ht_supported)
633 			return false;
634 		if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
635 		    ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
636 			return false;
637 		if (chandef->center_freq1 < control_freq &&
638 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
639 			return false;
640 		if (chandef->center_freq1 > control_freq &&
641 		    chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
642 			return false;
643 		break;
644 	case NL80211_CHAN_WIDTH_80P80:
645 		if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
646 			return false;
647 	case NL80211_CHAN_WIDTH_80:
648 		if (!vht_cap->vht_supported)
649 			return false;
650 		prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
651 		width = 80;
652 		break;
653 	case NL80211_CHAN_WIDTH_160:
654 		if (!vht_cap->vht_supported)
655 			return false;
656 		if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
657 			return false;
658 		prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
659 		width = 160;
660 		break;
661 	default:
662 		WARN_ON_ONCE(1);
663 		return false;
664 	}
665 
666 	/*
667 	 * TODO: What if there are only certain 80/160/80+80 MHz channels
668 	 *	 allowed by the driver, or only certain combinations?
669 	 *	 For 40 MHz the driver can set the NO_HT40 flags, but for
670 	 *	 80/160 MHz and in particular 80+80 MHz this isn't really
671 	 *	 feasible and we only have NO_80MHZ/NO_160MHZ so far but
672 	 *	 no way to cover 80+80 MHz or more complex restrictions.
673 	 *	 Note that such restrictions also need to be advertised to
674 	 *	 userspace, for example for P2P channel selection.
675 	 */
676 
677 	if (width > 20)
678 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
679 
680 	/* 5 and 10 MHz are only defined for the OFDM PHY */
681 	if (width < 20)
682 		prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
683 
684 
685 	if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
686 					 width, prohibited_flags))
687 		return false;
688 
689 	if (!chandef->center_freq2)
690 		return true;
691 	return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
692 					   width, prohibited_flags);
693 }
694 EXPORT_SYMBOL(cfg80211_chandef_usable);
695 
696 /*
697  * For GO only, check if the channel can be used under permissive conditions
698  * mandated by the some regulatory bodies, i.e., the channel is marked with
699  * IEEE80211_CHAN_GO_CONCURRENT and there is an additional station interface
700  * associated to an AP on the same channel or on the same UNII band
701  * (assuming that the AP is an authorized master).
702  * In addition allow the GO to operate on a channel on which indoor operation is
703  * allowed, iff we are currently operating in an indoor environment.
704  */
705 static bool cfg80211_go_permissive_chan(struct cfg80211_registered_device *rdev,
706 					struct ieee80211_channel *chan)
707 {
708 	struct wireless_dev *wdev_iter;
709 	struct wiphy *wiphy = wiphy_idx_to_wiphy(rdev->wiphy_idx);
710 
711 	ASSERT_RTNL();
712 
713 	if (!config_enabled(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
714 	    !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
715 		return false;
716 
717 	if (regulatory_indoor_allowed() &&
718 	    (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
719 		return true;
720 
721 	if (!(chan->flags & IEEE80211_CHAN_GO_CONCURRENT))
722 		return false;
723 
724 	/*
725 	 * Generally, it is possible to rely on another device/driver to allow
726 	 * the GO concurrent relaxation, however, since the device can further
727 	 * enforce the relaxation (by doing a similar verifications as this),
728 	 * and thus fail the GO instantiation, consider only the interfaces of
729 	 * the current registered device.
730 	 */
731 	list_for_each_entry(wdev_iter, &rdev->wdev_list, list) {
732 		struct ieee80211_channel *other_chan = NULL;
733 		int r1, r2;
734 
735 		if (wdev_iter->iftype != NL80211_IFTYPE_STATION ||
736 		    !netif_running(wdev_iter->netdev))
737 			continue;
738 
739 		wdev_lock(wdev_iter);
740 		if (wdev_iter->current_bss)
741 			other_chan = wdev_iter->current_bss->pub.channel;
742 		wdev_unlock(wdev_iter);
743 
744 		if (!other_chan)
745 			continue;
746 
747 		if (chan == other_chan)
748 			return true;
749 
750 		if (chan->band != IEEE80211_BAND_5GHZ)
751 			continue;
752 
753 		r1 = cfg80211_get_unii(chan->center_freq);
754 		r2 = cfg80211_get_unii(other_chan->center_freq);
755 
756 		if (r1 != -EINVAL && r1 == r2) {
757 			/*
758 			 * At some locations channels 149-165 are considered a
759 			 * bundle, but at other locations, e.g., Indonesia,
760 			 * channels 149-161 are considered a bundle while
761 			 * channel 165 is left out and considered to be in a
762 			 * different bundle. Thus, in case that there is a
763 			 * station interface connected to an AP on channel 165,
764 			 * it is assumed that channels 149-161 are allowed for
765 			 * GO operations. However, having a station interface
766 			 * connected to an AP on channels 149-161, does not
767 			 * allow GO operation on channel 165.
768 			 */
769 			if (chan->center_freq == 5825 &&
770 			    other_chan->center_freq != 5825)
771 				continue;
772 			return true;
773 		}
774 	}
775 
776 	return false;
777 }
778 
779 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
780 			     struct cfg80211_chan_def *chandef,
781 			     enum nl80211_iftype iftype)
782 {
783 	struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
784 	bool res;
785 	u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
786 			       IEEE80211_CHAN_RADAR;
787 
788 	trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype);
789 
790 	/*
791 	 * Under certain conditions suggested by the some regulatory bodies
792 	 * a GO can operate on channels marked with IEEE80211_NO_IR
793 	 * so set this flag only if such relaxations are not enabled and
794 	 * the conditions are not met.
795 	 */
796 	if (iftype != NL80211_IFTYPE_P2P_GO ||
797 	    !cfg80211_go_permissive_chan(rdev, chandef->chan))
798 		prohibited_flags |= IEEE80211_CHAN_NO_IR;
799 
800 	if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
801 	    cfg80211_chandef_dfs_available(wiphy, chandef)) {
802 		/* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
803 		prohibited_flags = IEEE80211_CHAN_DISABLED;
804 	}
805 
806 	res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
807 
808 	trace_cfg80211_return_bool(res);
809 	return res;
810 }
811 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
812 
813 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
814 				 struct cfg80211_chan_def *chandef)
815 {
816 	if (!rdev->ops->set_monitor_channel)
817 		return -EOPNOTSUPP;
818 	if (!cfg80211_has_monitors_only(rdev))
819 		return -EBUSY;
820 
821 	return rdev_set_monitor_channel(rdev, chandef);
822 }
823 
824 void
825 cfg80211_get_chan_state(struct wireless_dev *wdev,
826 		        struct ieee80211_channel **chan,
827 		        enum cfg80211_chan_mode *chanmode,
828 		        u8 *radar_detect)
829 {
830 	int ret;
831 
832 	*chan = NULL;
833 	*chanmode = CHAN_MODE_UNDEFINED;
834 
835 	ASSERT_WDEV_LOCK(wdev);
836 
837 	if (wdev->netdev && !netif_running(wdev->netdev))
838 		return;
839 
840 	switch (wdev->iftype) {
841 	case NL80211_IFTYPE_ADHOC:
842 		if (wdev->current_bss) {
843 			*chan = wdev->current_bss->pub.channel;
844 			*chanmode = (wdev->ibss_fixed &&
845 				     !wdev->ibss_dfs_possible)
846 				  ? CHAN_MODE_SHARED
847 				  : CHAN_MODE_EXCLUSIVE;
848 
849 			/* consider worst-case - IBSS can try to return to the
850 			 * original user-specified channel as creator */
851 			if (wdev->ibss_dfs_possible)
852 				*radar_detect |= BIT(wdev->chandef.width);
853 			return;
854 		}
855 		break;
856 	case NL80211_IFTYPE_STATION:
857 	case NL80211_IFTYPE_P2P_CLIENT:
858 		if (wdev->current_bss) {
859 			*chan = wdev->current_bss->pub.channel;
860 			*chanmode = CHAN_MODE_SHARED;
861 			return;
862 		}
863 		break;
864 	case NL80211_IFTYPE_AP:
865 	case NL80211_IFTYPE_P2P_GO:
866 		if (wdev->cac_started) {
867 			*chan = wdev->chandef.chan;
868 			*chanmode = CHAN_MODE_SHARED;
869 			*radar_detect |= BIT(wdev->chandef.width);
870 		} else if (wdev->beacon_interval) {
871 			*chan = wdev->chandef.chan;
872 			*chanmode = CHAN_MODE_SHARED;
873 
874 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
875 							    &wdev->chandef,
876 							    wdev->iftype);
877 			WARN_ON(ret < 0);
878 			if (ret > 0)
879 				*radar_detect |= BIT(wdev->chandef.width);
880 		}
881 		return;
882 	case NL80211_IFTYPE_MESH_POINT:
883 		if (wdev->mesh_id_len) {
884 			*chan = wdev->chandef.chan;
885 			*chanmode = CHAN_MODE_SHARED;
886 
887 			ret = cfg80211_chandef_dfs_required(wdev->wiphy,
888 							    &wdev->chandef,
889 							    wdev->iftype);
890 			WARN_ON(ret < 0);
891 			if (ret > 0)
892 				*radar_detect |= BIT(wdev->chandef.width);
893 		}
894 		return;
895 	case NL80211_IFTYPE_MONITOR:
896 	case NL80211_IFTYPE_AP_VLAN:
897 	case NL80211_IFTYPE_WDS:
898 	case NL80211_IFTYPE_P2P_DEVICE:
899 		/* these interface types don't really have a channel */
900 		return;
901 	case NL80211_IFTYPE_UNSPECIFIED:
902 	case NUM_NL80211_IFTYPES:
903 		WARN_ON(1);
904 	}
905 }
906