blob: 0f506220a3bde0e4b73c043fa9ea6a7f6b404ed0 [file] [log] [blame]
Johannes Berg59bbb6f2009-08-07 17:22:35 +02001/*
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>
Johannes Berg2740f0c2014-09-03 15:24:58 +03007 * Copyright 2013-2014 Intel Mobile Communications GmbH
Johannes Berg59bbb6f2009-08-07 17:22:35 +02008 */
9
Alexander Simon54858ee5b2011-11-30 16:56:32 +010010#include <linux/export.h>
Johannes Berg59bbb6f2009-08-07 17:22:35 +020011#include <net/cfg80211.h>
12#include "core.h"
Hila Gonene35e4d22012-06-27 17:19:42 +030013#include "rdev-ops.h"
Johannes Berg59bbb6f2009-08-07 17:22:35 +020014
Johannes Berg3d9d1d62012-11-08 23:14:50 +010015void 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}
46EXPORT_SYMBOL(cfg80211_chandef_create);
47
Johannes Berg9f5e8f62012-11-22 16:59:45 +010048bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
Johannes Berg3d9d1d62012-11-08 23:14:50 +010049{
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) {
Simon Wunderlich2f301ab2013-05-16 13:00:28 +020058 case NL80211_CHAN_WIDTH_5:
59 case NL80211_CHAN_WIDTH_10:
Johannes Berg3d9d1d62012-11-08 23:14:50 +010060 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;
Johannes Berg9cab3152012-12-14 00:19:08 +010082 /* 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;
Johannes Berg3d9d1d62012-11-08 23:14:50 +010086 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}
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100115EXPORT_SYMBOL(cfg80211_chandef_valid);
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100116
117static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
Johannes Bergfc1f48f2014-10-29 17:05:39 +0100118 u32 *pri40, u32 *pri80)
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100119{
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
Simon Wunderlich04f39042013-02-08 18:16:19 +0100153static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
154{
155 int width;
156
157 switch (c->width) {
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200158 case NL80211_CHAN_WIDTH_5:
159 width = 5;
160 break;
161 case NL80211_CHAN_WIDTH_10:
162 width = 10;
163 break;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100164 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
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100185const struct cfg80211_chan_def *
186cfg80211_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
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200206 /*
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
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100216 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}
238EXPORT_SYMBOL(cfg80211_chandef_compatible);
239
Simon Wunderlich04f39042013-02-08 18:16:19 +0100240static 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
259void 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
Janusz Dziedzic40d1ba62013-11-05 14:48:47 +0100281static 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
294static 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
Simon Wunderlich04f39042013-02-08 18:16:19 +0100307static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
308 u32 center_freq,
309 u32 bandwidth)
310{
311 struct ieee80211_channel *c;
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200312 u32 freq, start_freq, end_freq;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100313
Janusz Dziedzic40d1ba62013-11-05 14:48:47 +0100314 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
315 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200316
317 for (freq = start_freq; freq <= end_freq; freq += 20) {
Simon Wunderlich04f39042013-02-08 18:16:19 +0100318 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
329int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200330 const struct cfg80211_chan_def *chandef,
331 enum nl80211_iftype iftype)
Simon Wunderlich04f39042013-02-08 18:16:19 +0100332{
333 int width;
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200334 int ret;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100335
336 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
337 return -EINVAL;
338
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200339 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;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100347
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200348 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);
Simon Wunderlich04f39042013-02-08 18:16:19 +0100355
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200356 if (!chandef->center_freq2)
357 return 0;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100358
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200359 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:
Rostislav Lisovy6e0bd6c2014-11-03 10:33:18 +0100369 case NL80211_IFTYPE_OCB:
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200370 case NL80211_IFTYPE_P2P_CLIENT:
371 case NL80211_IFTYPE_MONITOR:
372 case NL80211_IFTYPE_AP_VLAN:
373 case NL80211_IFTYPE_WDS:
374 case NL80211_IFTYPE_P2P_DEVICE:
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200375 break;
Luciano Coelho00ec75f2014-05-15 13:05:39 +0300376 case NL80211_IFTYPE_UNSPECIFIED:
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200377 case NUM_NL80211_IFTYPES:
378 WARN_ON(1);
379 }
380
381 return 0;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100382}
Simon Wunderlich774f0732013-08-28 13:41:28 +0200383EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
Simon Wunderlich04f39042013-02-08 18:16:19 +0100384
Janusz Dziedzicfe7c3a12013-11-05 14:48:48 +0100385static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
386 u32 center_freq,
387 u32 bandwidth)
388{
389 struct ieee80211_channel *c;
390 u32 freq, start_freq, end_freq;
391 int count = 0;
392
393 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
394 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
395
396 /*
397 * Check entire range of channels for the bandwidth.
398 * Check all channels are DFS channels (DFS_USABLE or
399 * DFS_AVAILABLE). Return number of usable channels
400 * (require CAC). Allow DFS and non-DFS channel mix.
401 */
402 for (freq = start_freq; freq <= end_freq; freq += 20) {
403 c = ieee80211_get_channel(wiphy, freq);
404 if (!c)
405 return -EINVAL;
406
407 if (c->flags & IEEE80211_CHAN_DISABLED)
408 return -EINVAL;
409
410 if (c->flags & IEEE80211_CHAN_RADAR) {
411 if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
412 return -EINVAL;
413
414 if (c->dfs_state == NL80211_DFS_USABLE)
415 count++;
416 }
417 }
418
419 return count;
420}
421
422bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
423 const struct cfg80211_chan_def *chandef)
424{
425 int width;
426 int r1, r2 = 0;
427
428 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
429 return false;
430
431 width = cfg80211_chandef_get_width(chandef);
432 if (width < 0)
433 return false;
434
435 r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
436 width);
437
438 if (r1 < 0)
439 return false;
440
441 switch (chandef->width) {
442 case NL80211_CHAN_WIDTH_80P80:
443 WARN_ON(!chandef->center_freq2);
444 r2 = cfg80211_get_chans_dfs_usable(wiphy,
445 chandef->center_freq2,
446 width);
447 if (r2 < 0)
448 return false;
449 break;
450 default:
451 WARN_ON(chandef->center_freq2);
452 break;
453 }
454
455 return (r1 + r2 > 0);
456}
457
458
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100459static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
460 u32 center_freq,
461 u32 bandwidth)
462{
463 struct ieee80211_channel *c;
464 u32 freq, start_freq, end_freq;
465
466 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
467 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
468
469 /*
470 * Check entire range of channels for the bandwidth.
471 * If any channel in between is disabled or has not
472 * had gone through CAC return false
473 */
474 for (freq = start_freq; freq <= end_freq; freq += 20) {
475 c = ieee80211_get_channel(wiphy, freq);
476 if (!c)
477 return false;
478
479 if (c->flags & IEEE80211_CHAN_DISABLED)
480 return false;
481
482 if ((c->flags & IEEE80211_CHAN_RADAR) &&
483 (c->dfs_state != NL80211_DFS_AVAILABLE))
484 return false;
485 }
486
487 return true;
488}
489
490static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
491 const struct cfg80211_chan_def *chandef)
492{
493 int width;
494 int r;
495
496 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
497 return false;
498
499 width = cfg80211_chandef_get_width(chandef);
500 if (width < 0)
501 return false;
502
503 r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
504 width);
505
506 /* If any of channels unavailable for cf1 just return */
507 if (!r)
508 return r;
509
510 switch (chandef->width) {
511 case NL80211_CHAN_WIDTH_80P80:
512 WARN_ON(!chandef->center_freq2);
513 r = cfg80211_get_chans_dfs_available(wiphy,
514 chandef->center_freq2,
515 width);
Colin Ian King680682d2016-07-17 19:55:27 +0100516 break;
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100517 default:
518 WARN_ON(chandef->center_freq2);
519 break;
520 }
521
522 return r;
523}
524
Janusz Dziedzic31559f32014-02-21 19:46:13 +0100525static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
526 u32 center_freq,
527 u32 bandwidth)
528{
529 struct ieee80211_channel *c;
530 u32 start_freq, end_freq, freq;
531 unsigned int dfs_cac_ms = 0;
532
533 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
534 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
535
536 for (freq = start_freq; freq <= end_freq; freq += 20) {
537 c = ieee80211_get_channel(wiphy, freq);
538 if (!c)
539 return 0;
540
541 if (c->flags & IEEE80211_CHAN_DISABLED)
542 return 0;
543
544 if (!(c->flags & IEEE80211_CHAN_RADAR))
545 continue;
546
547 if (c->dfs_cac_ms > dfs_cac_ms)
548 dfs_cac_ms = c->dfs_cac_ms;
549 }
550
551 return dfs_cac_ms;
552}
553
554unsigned int
555cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
556 const struct cfg80211_chan_def *chandef)
557{
558 int width;
559 unsigned int t1 = 0, t2 = 0;
560
561 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
562 return 0;
563
564 width = cfg80211_chandef_get_width(chandef);
565 if (width < 0)
566 return 0;
567
568 t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
569 chandef->center_freq1,
570 width);
571
572 if (!chandef->center_freq2)
573 return t1;
574
575 t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
576 chandef->center_freq2,
577 width);
578
579 return max(t1, t2);
580}
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100581
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100582static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
583 u32 center_freq, u32 bandwidth,
584 u32 prohibited_flags)
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100585{
586 struct ieee80211_channel *c;
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200587 u32 freq, start_freq, end_freq;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100588
Janusz Dziedzic40d1ba62013-11-05 14:48:47 +0100589 start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
590 end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200591
592 for (freq = start_freq; freq <= end_freq; freq += 20) {
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100593 c = ieee80211_get_channel(wiphy, freq);
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100594 if (!c || c->flags & prohibited_flags)
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100595 return false;
596 }
597
598 return true;
599}
600
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100601bool cfg80211_chandef_usable(struct wiphy *wiphy,
602 const struct cfg80211_chan_def *chandef,
603 u32 prohibited_flags)
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100604{
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100605 struct ieee80211_sta_ht_cap *ht_cap;
606 struct ieee80211_sta_vht_cap *vht_cap;
Jouni Malinen08f6f142014-12-11 23:48:55 +0200607 u32 width, control_freq, cap;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100608
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100609 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100610 return false;
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100611
612 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
613 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
614
615 control_freq = chandef->chan->center_freq;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100616
617 switch (chandef->width) {
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200618 case NL80211_CHAN_WIDTH_5:
619 width = 5;
620 break;
621 case NL80211_CHAN_WIDTH_10:
Rostislav Lisovyea077c12014-04-15 14:37:55 +0200622 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200623 width = 10;
624 break;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100625 case NL80211_CHAN_WIDTH_20:
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100626 if (!ht_cap->ht_supported)
627 return false;
628 case NL80211_CHAN_WIDTH_20_NOHT:
Rostislav Lisovyea077c12014-04-15 14:37:55 +0200629 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100630 width = 20;
Mark Mentovai09a02fd2010-11-17 16:34:37 -0500631 break;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100632 case NL80211_CHAN_WIDTH_40:
633 width = 40;
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100634 if (!ht_cap->ht_supported)
635 return false;
636 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
637 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
638 return false;
639 if (chandef->center_freq1 < control_freq &&
640 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
641 return false;
642 if (chandef->center_freq1 > control_freq &&
643 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
644 return false;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100645 break;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100646 case NL80211_CHAN_WIDTH_80P80:
Jouni Malinen08f6f142014-12-11 23:48:55 +0200647 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
648 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100649 return false;
650 case NL80211_CHAN_WIDTH_80:
651 if (!vht_cap->vht_supported)
652 return false;
Johannes Bergc7a6ee22012-12-12 17:50:39 +0100653 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100654 width = 80;
655 break;
656 case NL80211_CHAN_WIDTH_160:
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100657 if (!vht_cap->vht_supported)
658 return false;
Jouni Malinen08f6f142014-12-11 23:48:55 +0200659 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
660 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
661 cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100662 return false;
Johannes Bergc7a6ee22012-12-12 17:50:39 +0100663 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100664 width = 160;
Mark Mentovai09a02fd2010-11-17 16:34:37 -0500665 break;
Luis R. Rodriguez9236d832010-11-12 16:31:23 -0800666 default:
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100667 WARN_ON_ONCE(1);
Luis R. Rodriguez9236d832010-11-12 16:31:23 -0800668 return false;
Beni Lev4ee3e062012-08-27 12:49:39 +0300669 }
Luis R. Rodriguez9236d832010-11-12 16:31:23 -0800670
Johannes Bergc7a6ee22012-12-12 17:50:39 +0100671 /*
672 * TODO: What if there are only certain 80/160/80+80 MHz channels
673 * allowed by the driver, or only certain combinations?
674 * For 40 MHz the driver can set the NO_HT40 flags, but for
675 * 80/160 MHz and in particular 80+80 MHz this isn't really
676 * feasible and we only have NO_80MHZ/NO_160MHZ so far but
677 * no way to cover 80+80 MHz or more complex restrictions.
678 * Note that such restrictions also need to be advertised to
679 * userspace, for example for P2P channel selection.
680 */
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100681
Johannes Berga6662db2012-12-04 20:49:42 +0100682 if (width > 20)
683 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
684
Simon Wunderlich2f301ab2013-05-16 13:00:28 +0200685 /* 5 and 10 MHz are only defined for the OFDM PHY */
686 if (width < 20)
687 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
688
689
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100690 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
691 width, prohibited_flags))
692 return false;
693
694 if (!chandef->center_freq2)
695 return true;
696 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
697 width, prohibited_flags);
698}
699EXPORT_SYMBOL(cfg80211_chandef_usable);
700
Ilan Peer174e0cd2014-02-23 09:13:01 +0200701/*
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300702 * Check if the channel can be used under permissive conditions mandated by
703 * some regulatory bodies, i.e., the channel is marked with
704 * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
Ilan Peer174e0cd2014-02-23 09:13:01 +0200705 * associated to an AP on the same channel or on the same UNII band
706 * (assuming that the AP is an authorized master).
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300707 * In addition allow operation on a channel on which indoor operation is
Ilan Peerc8866e52014-02-23 09:13:03 +0200708 * allowed, iff we are currently operating in an indoor environment.
Ilan Peer174e0cd2014-02-23 09:13:01 +0200709 */
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300710static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
711 enum nl80211_iftype iftype,
Ilan Peer174e0cd2014-02-23 09:13:01 +0200712 struct ieee80211_channel *chan)
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100713{
Avraham Sternbe69c242015-04-27 16:52:16 +0300714 struct wireless_dev *wdev;
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300715 struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
Ilan Peer174e0cd2014-02-23 09:13:01 +0200716
717 ASSERT_RTNL();
718
Masahiro Yamada97f26452016-08-03 13:45:50 -0700719 if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
Ilan Peerc8866e52014-02-23 09:13:03 +0200720 !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
721 return false;
722
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300723 /* only valid for GO and TDLS off-channel (station/p2p-CL) */
724 if (iftype != NL80211_IFTYPE_P2P_GO &&
725 iftype != NL80211_IFTYPE_STATION &&
726 iftype != NL80211_IFTYPE_P2P_CLIENT)
727 return false;
728
Ilan Peerc8866e52014-02-23 09:13:03 +0200729 if (regulatory_indoor_allowed() &&
730 (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
731 return true;
732
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300733 if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
Ilan Peer174e0cd2014-02-23 09:13:01 +0200734 return false;
735
736 /*
737 * Generally, it is possible to rely on another device/driver to allow
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300738 * the IR concurrent relaxation, however, since the device can further
Ilan Peer174e0cd2014-02-23 09:13:01 +0200739 * enforce the relaxation (by doing a similar verifications as this),
740 * and thus fail the GO instantiation, consider only the interfaces of
741 * the current registered device.
742 */
Johannes Berg53873f12016-05-03 16:52:04 +0300743 list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
Ilan Peer174e0cd2014-02-23 09:13:01 +0200744 struct ieee80211_channel *other_chan = NULL;
745 int r1, r2;
746
Avraham Sternbe69c242015-04-27 16:52:16 +0300747 wdev_lock(wdev);
748 if (wdev->iftype == NL80211_IFTYPE_STATION &&
749 wdev->current_bss)
750 other_chan = wdev->current_bss->pub.channel;
Ilan Peer174e0cd2014-02-23 09:13:01 +0200751
Avraham Sternbe69c242015-04-27 16:52:16 +0300752 /*
753 * If a GO already operates on the same GO_CONCURRENT channel,
754 * this one (maybe the same one) can beacon as well. We allow
755 * the operation even if the station we relied on with
756 * GO_CONCURRENT is disconnected now. But then we must make sure
757 * we're not outdoor on an indoor-only channel.
758 */
Arik Nemtsov06f207f2015-05-06 16:28:31 +0300759 if (iftype == NL80211_IFTYPE_P2P_GO &&
760 wdev->iftype == NL80211_IFTYPE_P2P_GO &&
Avraham Sternbe69c242015-04-27 16:52:16 +0300761 wdev->beacon_interval &&
762 !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
763 other_chan = wdev->chandef.chan;
764 wdev_unlock(wdev);
Ilan Peer174e0cd2014-02-23 09:13:01 +0200765
766 if (!other_chan)
767 continue;
768
769 if (chan == other_chan)
770 return true;
771
Johannes Berg57fbcce2016-04-12 15:56:15 +0200772 if (chan->band != NL80211_BAND_5GHZ)
Ilan Peer174e0cd2014-02-23 09:13:01 +0200773 continue;
774
775 r1 = cfg80211_get_unii(chan->center_freq);
776 r2 = cfg80211_get_unii(other_chan->center_freq);
777
Ilan Peer46d53722014-04-23 09:22:58 +0300778 if (r1 != -EINVAL && r1 == r2) {
779 /*
780 * At some locations channels 149-165 are considered a
781 * bundle, but at other locations, e.g., Indonesia,
782 * channels 149-161 are considered a bundle while
783 * channel 165 is left out and considered to be in a
784 * different bundle. Thus, in case that there is a
785 * station interface connected to an AP on channel 165,
786 * it is assumed that channels 149-161 are allowed for
787 * GO operations. However, having a station interface
788 * connected to an AP on channels 149-161, does not
789 * allow GO operation on channel 165.
790 */
791 if (chan->center_freq == 5825 &&
792 other_chan->center_freq != 5825)
793 continue;
Ilan Peer174e0cd2014-02-23 09:13:01 +0200794 return true;
Ilan Peer46d53722014-04-23 09:22:58 +0300795 }
Ilan Peer174e0cd2014-02-23 09:13:01 +0200796 }
797
798 return false;
799}
800
Arik Nemtsov923b3522015-07-08 15:41:44 +0300801static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
802 struct cfg80211_chan_def *chandef,
803 enum nl80211_iftype iftype,
804 bool check_no_ir)
Ilan Peer174e0cd2014-02-23 09:13:01 +0200805{
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100806 bool res;
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100807 u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100808 IEEE80211_CHAN_RADAR;
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100809
Arik Nemtsov923b3522015-07-08 15:41:44 +0300810 trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
Ilan Peer174e0cd2014-02-23 09:13:01 +0200811
Arik Nemtsov923b3522015-07-08 15:41:44 +0300812 if (check_no_ir)
Ilan Peer174e0cd2014-02-23 09:13:01 +0200813 prohibited_flags |= IEEE80211_CHAN_NO_IR;
Johannes Berg9f5e8f62012-11-22 16:59:45 +0100814
Luciano Coelho00ec75f2014-05-15 13:05:39 +0300815 if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
Janusz Dziedzic6bc54fb2013-11-06 13:55:53 +0100816 cfg80211_chandef_dfs_available(wiphy, chandef)) {
817 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
818 prohibited_flags = IEEE80211_CHAN_DISABLED;
819 }
820
821 res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
Johannes Berg3d9d1d62012-11-08 23:14:50 +0100822
823 trace_cfg80211_return_bool(res);
824 return res;
Luis R. Rodriguez9236d832010-11-12 16:31:23 -0800825}
Arik Nemtsov923b3522015-07-08 15:41:44 +0300826
827bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
828 struct cfg80211_chan_def *chandef,
829 enum nl80211_iftype iftype)
830{
831 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
832}
Johannes Berg683b6d32012-11-08 21:25:48 +0100833EXPORT_SYMBOL(cfg80211_reg_can_beacon);
Luis R. Rodriguez9236d832010-11-12 16:31:23 -0800834
Arik Nemtsov923b3522015-07-08 15:41:44 +0300835bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
836 struct cfg80211_chan_def *chandef,
837 enum nl80211_iftype iftype)
838{
839 bool check_no_ir;
840
841 ASSERT_RTNL();
842
843 /*
844 * Under certain conditions suggested by some regulatory bodies a
845 * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
846 * only if such relaxations are not enabled and the conditions are not
847 * met.
848 */
849 check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
850 chandef->chan);
851
852 return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
853}
854EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
855
Johannes Berge8c9bd52012-06-06 08:18:22 +0200856int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
Johannes Berg683b6d32012-11-08 21:25:48 +0100857 struct cfg80211_chan_def *chandef)
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200858{
Johannes Berge8c9bd52012-06-06 08:18:22 +0200859 if (!rdev->ops->set_monitor_channel)
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200860 return -EOPNOTSUPP;
Michal Kazior4f03c1e2012-06-29 12:47:03 +0200861 if (!cfg80211_has_monitors_only(rdev))
862 return -EBUSY;
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200863
Johannes Berg683b6d32012-11-08 21:25:48 +0100864 return rdev_set_monitor_channel(rdev, chandef);
Johannes Berg59bbb6f2009-08-07 17:22:35 +0200865}
Michal Kazior26ab9a02012-06-29 12:47:00 +0200866
867void
Johannes Berg8e95ea42012-07-10 19:39:02 +0200868cfg80211_get_chan_state(struct wireless_dev *wdev,
Michal Kazior26ab9a02012-06-29 12:47:00 +0200869 struct ieee80211_channel **chan,
Michal Kazior9e0e2962014-01-29 14:22:27 +0100870 enum cfg80211_chan_mode *chanmode,
871 u8 *radar_detect)
Michal Kazior26ab9a02012-06-29 12:47:00 +0200872{
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200873 int ret;
874
Michal Kazior26ab9a02012-06-29 12:47:00 +0200875 *chan = NULL;
876 *chanmode = CHAN_MODE_UNDEFINED;
877
Michal Kazior26ab9a02012-06-29 12:47:00 +0200878 ASSERT_WDEV_LOCK(wdev);
879
Johannes Berg98104fde2012-06-16 00:19:54 +0200880 if (wdev->netdev && !netif_running(wdev->netdev))
Michal Kazior26ab9a02012-06-29 12:47:00 +0200881 return;
882
883 switch (wdev->iftype) {
884 case NL80211_IFTYPE_ADHOC:
885 if (wdev->current_bss) {
886 *chan = wdev->current_bss->pub.channel;
Simon Wunderlich5336fa82013-10-07 18:41:05 +0200887 *chanmode = (wdev->ibss_fixed &&
888 !wdev->ibss_dfs_possible)
Michal Kazior26ab9a02012-06-29 12:47:00 +0200889 ? CHAN_MODE_SHARED
890 : CHAN_MODE_EXCLUSIVE;
Michal Kazior9e0e2962014-01-29 14:22:27 +0100891
892 /* consider worst-case - IBSS can try to return to the
893 * original user-specified channel as creator */
894 if (wdev->ibss_dfs_possible)
895 *radar_detect |= BIT(wdev->chandef.width);
Michal Kazior26ab9a02012-06-29 12:47:00 +0200896 return;
897 }
Johannes Berg0f0094b2013-10-25 12:46:44 +0200898 break;
Michal Kazior26ab9a02012-06-29 12:47:00 +0200899 case NL80211_IFTYPE_STATION:
900 case NL80211_IFTYPE_P2P_CLIENT:
901 if (wdev->current_bss) {
902 *chan = wdev->current_bss->pub.channel;
903 *chanmode = CHAN_MODE_SHARED;
904 return;
905 }
906 break;
907 case NL80211_IFTYPE_AP:
908 case NL80211_IFTYPE_P2P_GO:
Simon Wunderlich04f39042013-02-08 18:16:19 +0100909 if (wdev->cac_started) {
Michal Kazior9e0e2962014-01-29 14:22:27 +0100910 *chan = wdev->chandef.chan;
Simon Wunderlich04f39042013-02-08 18:16:19 +0100911 *chanmode = CHAN_MODE_SHARED;
Michal Kazior9e0e2962014-01-29 14:22:27 +0100912 *radar_detect |= BIT(wdev->chandef.width);
Simon Wunderlich04f39042013-02-08 18:16:19 +0100913 } else if (wdev->beacon_interval) {
Michal Kazior9e0e2962014-01-29 14:22:27 +0100914 *chan = wdev->chandef.chan;
Felix Fietkauf53594a2012-07-12 16:10:02 +0200915 *chanmode = CHAN_MODE_SHARED;
Michal Kazior9e0e2962014-01-29 14:22:27 +0100916
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200917 ret = cfg80211_chandef_dfs_required(wdev->wiphy,
918 &wdev->chandef,
919 wdev->iftype);
920 WARN_ON(ret < 0);
921 if (ret > 0)
Michal Kazior9e0e2962014-01-29 14:22:27 +0100922 *radar_detect |= BIT(wdev->chandef.width);
Felix Fietkauf53594a2012-07-12 16:10:02 +0200923 }
924 return;
Michal Kazior26ab9a02012-06-29 12:47:00 +0200925 case NL80211_IFTYPE_MESH_POINT:
Felix Fietkauf53594a2012-07-12 16:10:02 +0200926 if (wdev->mesh_id_len) {
Michal Kazior9e0e2962014-01-29 14:22:27 +0100927 *chan = wdev->chandef.chan;
Felix Fietkauf53594a2012-07-12 16:10:02 +0200928 *chanmode = CHAN_MODE_SHARED;
Michal Kazior9e0e2962014-01-29 14:22:27 +0100929
Luciano Coelho2beb6dab2014-02-18 11:40:36 +0200930 ret = cfg80211_chandef_dfs_required(wdev->wiphy,
931 &wdev->chandef,
932 wdev->iftype);
933 WARN_ON(ret < 0);
934 if (ret > 0)
Michal Kazior9e0e2962014-01-29 14:22:27 +0100935 *radar_detect |= BIT(wdev->chandef.width);
Felix Fietkauf53594a2012-07-12 16:10:02 +0200936 }
Michal Kazior26ab9a02012-06-29 12:47:00 +0200937 return;
Rostislav Lisovy6e0bd6c2014-11-03 10:33:18 +0100938 case NL80211_IFTYPE_OCB:
939 if (wdev->chandef.chan) {
940 *chan = wdev->chandef.chan;
941 *chanmode = CHAN_MODE_SHARED;
942 return;
943 }
944 break;
Michal Kazior26ab9a02012-06-29 12:47:00 +0200945 case NL80211_IFTYPE_MONITOR:
946 case NL80211_IFTYPE_AP_VLAN:
947 case NL80211_IFTYPE_WDS:
Johannes Berg98104fde2012-06-16 00:19:54 +0200948 case NL80211_IFTYPE_P2P_DEVICE:
Johannes Berge7aceef2014-02-12 14:21:15 +0100949 /* these interface types don't really have a channel */
Johannes Berg98104fde2012-06-16 00:19:54 +0200950 return;
Michal Kazior26ab9a02012-06-29 12:47:00 +0200951 case NL80211_IFTYPE_UNSPECIFIED:
952 case NUM_NL80211_IFTYPES:
953 WARN_ON(1);
954 }
Michal Kazior26ab9a02012-06-29 12:47:00 +0200955}