?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
pktgen: add needed include file
[linux/fpc-iii.git] / net / wireless / chan.c
blob50f6195c8b70b816ab35ade4075c5f71de105b35
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 */
8
9 #include <linux/export.h>
10 #include <net/cfg80211.h>
11 #include "core.h"
12 #include "rdev-ops.h"
13
14 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
15 struct ieee80211_channel *chan,
16 enum nl80211_channel_type chan_type)
17 {
18 if (WARN_ON(!chan))
19 return;
20
21 chandef->chan = chan;
22 chandef->center_freq2 = 0;
23
24 switch (chan_type) {
25 case NL80211_CHAN_NO_HT:
26 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
27 chandef->center_freq1 = chan->center_freq;
28 break;
29 case NL80211_CHAN_HT20:
30 chandef->width = NL80211_CHAN_WIDTH_20;
31 chandef->center_freq1 = chan->center_freq;
32 break;
33 case NL80211_CHAN_HT40PLUS:
34 chandef->width = NL80211_CHAN_WIDTH_40;
35 chandef->center_freq1 = chan->center_freq + 10;
36 break;
37 case NL80211_CHAN_HT40MINUS:
38 chandef->width = NL80211_CHAN_WIDTH_40;
39 chandef->center_freq1 = chan->center_freq - 10;
40 break;
41 default:
42 WARN_ON(1);
43 }
44 }
45 EXPORT_SYMBOL(cfg80211_chandef_create);
46
47 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
48 {
49 u32 control_freq;
50
51 if (!chandef->chan)
52 return false;
53
54 control_freq = chandef->chan->center_freq;
55
56 switch (chandef->width) {
57 case NL80211_CHAN_WIDTH_5:
58 case NL80211_CHAN_WIDTH_10:
59 case NL80211_CHAN_WIDTH_20:
60 case NL80211_CHAN_WIDTH_20_NOHT:
61 if (chandef->center_freq1 != control_freq)
62 return false;
63 if (chandef->center_freq2)
64 return false;
65 break;
66 case NL80211_CHAN_WIDTH_40:
67 if (chandef->center_freq1 != control_freq + 10 &&
68 chandef->center_freq1 != control_freq - 10)
69 return false;
70 if (chandef->center_freq2)
71 return false;
72 break;
73 case NL80211_CHAN_WIDTH_80P80:
74 if (chandef->center_freq1 != control_freq + 30 &&
75 chandef->center_freq1 != control_freq + 10 &&
76 chandef->center_freq1 != control_freq - 10 &&
77 chandef->center_freq1 != control_freq - 30)
78 return false;
79 if (!chandef->center_freq2)
80 return false;
81 /* adjacent is not allowed -- that's a 160 MHz channel */
82 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
83 chandef->center_freq2 - chandef->center_freq1 == 80)
84 return false;
85 break;
86 case NL80211_CHAN_WIDTH_80:
87 if (chandef->center_freq1 != control_freq + 30 &&
88 chandef->center_freq1 != control_freq + 10 &&
89 chandef->center_freq1 != control_freq - 10 &&
90 chandef->center_freq1 != control_freq - 30)
91 return false;
92 if (chandef->center_freq2)
93 return false;
94 break;
95 case NL80211_CHAN_WIDTH_160:
96 if (chandef->center_freq1 != control_freq + 70 &&
97 chandef->center_freq1 != control_freq + 50 &&
98 chandef->center_freq1 != control_freq + 30 &&
99 chandef->center_freq1 != control_freq + 10 &&
100 chandef->center_freq1 != control_freq - 10 &&
101 chandef->center_freq1 != control_freq - 30 &&
102 chandef->center_freq1 != control_freq - 50 &&
103 chandef->center_freq1 != control_freq - 70)
104 return false;
105 if (chandef->center_freq2)
106 return false;
107 break;
108 default:
109 return false;
110 }
111
112 return true;
113 }
114 EXPORT_SYMBOL(cfg80211_chandef_valid);
115
116 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
117 int *pri40, int *pri80)
118 {
119 int tmp;
120
121 switch (c->width) {
122 case NL80211_CHAN_WIDTH_40:
123 *pri40 = c->center_freq1;
124 *pri80 = 0;
125 break;
126 case NL80211_CHAN_WIDTH_80:
127 case NL80211_CHAN_WIDTH_80P80:
128 *pri80 = c->center_freq1;
129 /* n_P20 */
130 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
131 /* n_P40 */
132 tmp /= 2;
133 /* freq_P40 */
134 *pri40 = c->center_freq1 - 20 + 40 * tmp;
135 break;
136 case NL80211_CHAN_WIDTH_160:
137 /* n_P20 */
138 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
139 /* n_P40 */
140 tmp /= 2;
141 /* freq_P40 */
142 *pri40 = c->center_freq1 - 60 + 40 * tmp;
143 /* n_P80 */
144 tmp /= 2;
145 *pri80 = c->center_freq1 - 40 + 80 * tmp;
146 break;
147 default:
148 WARN_ON_ONCE(1);
149 }
150 }
151
152 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
153 {
154 int width;
155
156 switch (c->width) {
157 case NL80211_CHAN_WIDTH_5:
158 width = 5;
159 break;
160 case NL80211_CHAN_WIDTH_10:
161 width = 10;
162 break;
163 case NL80211_CHAN_WIDTH_20:
164 case NL80211_CHAN_WIDTH_20_NOHT:
165 width = 20;
166 break;
167 case NL80211_CHAN_WIDTH_40:
168 width = 40;
169 break;
170 case NL80211_CHAN_WIDTH_80P80:
171 case NL80211_CHAN_WIDTH_80:
172 width = 80;
173 break;
174 case NL80211_CHAN_WIDTH_160:
175 width = 160;
176 break;
177 default:
178 WARN_ON_ONCE(1);
179 return -1;
180 }
181 return width;
182 }
183
184 const struct cfg80211_chan_def *
185 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
186 const struct cfg80211_chan_def *c2)
187 {
188 u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
189
190 /* If they are identical, return */
191 if (cfg80211_chandef_identical(c1, c2))
192 return c1;
193
194 /* otherwise, must have same control channel */
195 if (c1->chan != c2->chan)
196 return NULL;
197
198 /*
199 * If they have the same width, but aren't identical,
200 * then they can't be compatible.
201 */
202 if (c1->width == c2->width)
203 return NULL;
204
205 /*
206 * can't be compatible if one of them is 5 or 10 MHz,
207 * but they don't have the same width.
208 */
209 if (c1->width == NL80211_CHAN_WIDTH_5 ||
210 c1->width == NL80211_CHAN_WIDTH_10 ||
211 c2->width == NL80211_CHAN_WIDTH_5 ||
212 c2->width == NL80211_CHAN_WIDTH_10)
213 return NULL;
214
215 if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
216 c1->width == NL80211_CHAN_WIDTH_20)
217 return c2;
218
219 if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
220 c2->width == NL80211_CHAN_WIDTH_20)
221 return c1;
222
223 chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
224 chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
225
226 if (c1_pri40 != c2_pri40)
227 return NULL;
228
229 WARN_ON(!c1_pri80 && !c2_pri80);
230 if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
231 return NULL;
232
233 if (c1->width > c2->width)
234 return c1;
235 return c2;
236 }
237 EXPORT_SYMBOL(cfg80211_chandef_compatible);
238
239 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
240 u32 bandwidth,
241 enum nl80211_dfs_state dfs_state)
242 {
243 struct ieee80211_channel *c;
244 u32 freq;
245
246 for (freq = center_freq - bandwidth/2 + 10;
247 freq <= center_freq + bandwidth/2 - 10;
248 freq += 20) {
249 c = ieee80211_get_channel(wiphy, freq);
250 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
251 continue;
252
253 c->dfs_state = dfs_state;
254 c->dfs_state_entered = jiffies;
255 }
256 }
257
258 void cfg80211_set_dfs_state(struct wiphy *wiphy,
259 const struct cfg80211_chan_def *chandef,
260 enum nl80211_dfs_state dfs_state)
261 {
262 int width;
263
264 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
265 return;
266
267 width = cfg80211_chandef_get_width(chandef);
268 if (width < 0)
269 return;
270
271 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
272 width, dfs_state);
273
274 if (!chandef->center_freq2)
275 return;
276 cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
277 width, dfs_state);
278 }
279
280 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
281 u32 center_freq,
282 u32 bandwidth)
283 {
284 struct ieee80211_channel *c;
285 u32 freq, start_freq, end_freq;
286
287 if (bandwidth <= 20) {
288 start_freq = center_freq;
289 end_freq = center_freq;
290 } else {
291 start_freq = center_freq - bandwidth/2 + 10;
292 end_freq = center_freq + bandwidth/2 - 10;
293 }
294
295 for (freq = start_freq; freq <= end_freq; freq += 20) {
296 c = ieee80211_get_channel(wiphy, freq);
297 if (!c)
298 return -EINVAL;
299
300 if (c->flags & IEEE80211_CHAN_RADAR)
301 return 1;
302 }
303 return 0;
304 }
305
306
307 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
308 const struct cfg80211_chan_def *chandef)
309 {
310 int width;
311 int r;
312
313 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
314 return -EINVAL;
315
316 width = cfg80211_chandef_get_width(chandef);
317 if (width < 0)
318 return -EINVAL;
319
320 r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1,
321 width);
322 if (r)
323 return r;
324
325 if (!chandef->center_freq2)
326 return 0;
327
328 return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2,
329 width);
330 }
331
332 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
333 u32 center_freq, u32 bandwidth,
334 u32 prohibited_flags)
335 {
336 struct ieee80211_channel *c;
337 u32 freq, start_freq, end_freq;
338
339 if (bandwidth <= 20) {
340 start_freq = center_freq;
341 end_freq = center_freq;
342 } else {
343 start_freq = center_freq - bandwidth/2 + 10;
344 end_freq = center_freq + bandwidth/2 - 10;
345 }
346
347 for (freq = start_freq; freq <= end_freq; freq += 20) {
348 c = ieee80211_get_channel(wiphy, freq);
349 if (!c)
350 return false;
351
352 /* check for radar flags */
353 if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) &&
354 (c->dfs_state != NL80211_DFS_AVAILABLE))
355 return false;
356
357 /* check for the other flags */
358 if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR)
359 return false;
360 }
361
362 return true;
363 }
364
365 bool cfg80211_chandef_usable(struct wiphy *wiphy,
366 const struct cfg80211_chan_def *chandef,
367 u32 prohibited_flags)
368 {
369 struct ieee80211_sta_ht_cap *ht_cap;
370 struct ieee80211_sta_vht_cap *vht_cap;
371 u32 width, control_freq;
372
373 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
374 return false;
375
376 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
377 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
378
379 control_freq = chandef->chan->center_freq;
380
381 switch (chandef->width) {
382 case NL80211_CHAN_WIDTH_5:
383 width = 5;
384 break;
385 case NL80211_CHAN_WIDTH_10:
386 width = 10;
387 break;
388 case NL80211_CHAN_WIDTH_20:
389 if (!ht_cap->ht_supported)
390 return false;
391 case NL80211_CHAN_WIDTH_20_NOHT:
392 width = 20;
393 break;
394 case NL80211_CHAN_WIDTH_40:
395 width = 40;
396 if (!ht_cap->ht_supported)
397 return false;
398 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
399 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
400 return false;
401 if (chandef->center_freq1 < control_freq &&
402 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
403 return false;
404 if (chandef->center_freq1 > control_freq &&
405 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
406 return false;
407 break;
408 case NL80211_CHAN_WIDTH_80P80:
409 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
410 return false;
411 case NL80211_CHAN_WIDTH_80:
412 if (!vht_cap->vht_supported)
413 return false;
414 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
415 width = 80;
416 break;
417 case NL80211_CHAN_WIDTH_160:
418 if (!vht_cap->vht_supported)
419 return false;
420 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
421 return false;
422 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
423 width = 160;
424 break;
425 default:
426 WARN_ON_ONCE(1);
427 return false;
428 }
429
430 /*
431 * TODO: What if there are only certain 80/160/80+80 MHz channels
432 * allowed by the driver, or only certain combinations?
433 * For 40 MHz the driver can set the NO_HT40 flags, but for
434 * 80/160 MHz and in particular 80+80 MHz this isn't really
435 * feasible and we only have NO_80MHZ/NO_160MHZ so far but
436 * no way to cover 80+80 MHz or more complex restrictions.
437 * Note that such restrictions also need to be advertised to
438 * userspace, for example for P2P channel selection.
439 */
440
441 if (width > 20)
442 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
443
444 /* 5 and 10 MHz are only defined for the OFDM PHY */
445 if (width < 20)
446 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
447
448
449 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
450 width, prohibited_flags))
451 return false;
452
453 if (!chandef->center_freq2)
454 return true;
455 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
456 width, prohibited_flags);
457 }
458 EXPORT_SYMBOL(cfg80211_chandef_usable);
459
460 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
461 struct cfg80211_chan_def *chandef)
462 {
463 bool res;
464
465 trace_cfg80211_reg_can_beacon(wiphy, chandef);
466
467 res = cfg80211_chandef_usable(wiphy, chandef,
468 IEEE80211_CHAN_DISABLED |
469 IEEE80211_CHAN_PASSIVE_SCAN |
470 IEEE80211_CHAN_NO_IBSS |
471 IEEE80211_CHAN_RADAR);
472
473 trace_cfg80211_return_bool(res);
474 return res;
475 }
476 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
477
478 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
479 struct cfg80211_chan_def *chandef)
480 {
481 if (!rdev->ops->set_monitor_channel)
482 return -EOPNOTSUPP;
483 if (!cfg80211_has_monitors_only(rdev))
484 return -EBUSY;
485
486 return rdev_set_monitor_channel(rdev, chandef);
487 }
488
489 void
490 cfg80211_get_chan_state(struct wireless_dev *wdev,
491 struct ieee80211_channel **chan,
492 enum cfg80211_chan_mode *chanmode)
493 {
494 *chan = NULL;
495 *chanmode = CHAN_MODE_UNDEFINED;
496
497 ASSERT_WDEV_LOCK(wdev);
498
499 if (wdev->netdev && !netif_running(wdev->netdev))
500 return;
501
502 switch (wdev->iftype) {
503 case NL80211_IFTYPE_ADHOC:
504 if (wdev->current_bss) {
505 *chan = wdev->current_bss->pub.channel;
506 *chanmode = wdev->ibss_fixed
507 ? CHAN_MODE_SHARED
508 : CHAN_MODE_EXCLUSIVE;
509 return;
510 }
511 case NL80211_IFTYPE_STATION:
512 case NL80211_IFTYPE_P2P_CLIENT:
513 if (wdev->current_bss) {
514 *chan = wdev->current_bss->pub.channel;
515 *chanmode = CHAN_MODE_SHARED;
516 return;
517 }
518 break;
519 case NL80211_IFTYPE_AP:
520 case NL80211_IFTYPE_P2P_GO:
521 if (wdev->cac_started) {
522 *chan = wdev->channel;
523 *chanmode = CHAN_MODE_SHARED;
524 } else if (wdev->beacon_interval) {
525 *chan = wdev->channel;
526 *chanmode = CHAN_MODE_SHARED;
527 }
528 return;
529 case NL80211_IFTYPE_MESH_POINT:
530 if (wdev->mesh_id_len) {
531 *chan = wdev->channel;
532 *chanmode = CHAN_MODE_SHARED;
533 }
534 return;
535 case NL80211_IFTYPE_MONITOR:
536 case NL80211_IFTYPE_AP_VLAN:
537 case NL80211_IFTYPE_WDS:
538 /* these interface types don't really have a channel */
539 return;
540 case NL80211_IFTYPE_P2P_DEVICE:
541 if (wdev->wiphy->features &
542 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
543 *chanmode = CHAN_MODE_EXCLUSIVE;
544 return;
545 case NL80211_IFTYPE_UNSPECIFIED:
546 case NUM_NL80211_IFTYPES:
547 WARN_ON(1);
548 }
549
550 return;
551 }
Linux with added FPC-III support