?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
macvtap: signal truncated packets
[linux/fpc-iii.git] / net / wireless / chan.c
blob9b8cc877eb191a2a62370c9f2617bed513200d24
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 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
332
333 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
334 u32 center_freq, u32 bandwidth,
335 u32 prohibited_flags)
336 {
337 struct ieee80211_channel *c;
338 u32 freq, start_freq, end_freq;
339
340 if (bandwidth <= 20) {
341 start_freq = center_freq;
342 end_freq = center_freq;
343 } else {
344 start_freq = center_freq - bandwidth/2 + 10;
345 end_freq = center_freq + bandwidth/2 - 10;
346 }
347
348 for (freq = start_freq; freq <= end_freq; freq += 20) {
349 c = ieee80211_get_channel(wiphy, freq);
350 if (!c)
351 return false;
352
353 /* check for radar flags */
354 if ((prohibited_flags & c->flags & IEEE80211_CHAN_RADAR) &&
355 (c->dfs_state != NL80211_DFS_AVAILABLE))
356 return false;
357
358 /* check for the other flags */
359 if (c->flags & prohibited_flags & ~IEEE80211_CHAN_RADAR)
360 return false;
361 }
362
363 return true;
364 }
365
366 bool cfg80211_chandef_usable(struct wiphy *wiphy,
367 const struct cfg80211_chan_def *chandef,
368 u32 prohibited_flags)
369 {
370 struct ieee80211_sta_ht_cap *ht_cap;
371 struct ieee80211_sta_vht_cap *vht_cap;
372 u32 width, control_freq;
373
374 if (WARN_ON(!cfg80211_chandef_valid(chandef)))
375 return false;
376
377 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
378 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
379
380 control_freq = chandef->chan->center_freq;
381
382 switch (chandef->width) {
383 case NL80211_CHAN_WIDTH_5:
384 width = 5;
385 break;
386 case NL80211_CHAN_WIDTH_10:
387 width = 10;
388 break;
389 case NL80211_CHAN_WIDTH_20:
390 if (!ht_cap->ht_supported)
391 return false;
392 case NL80211_CHAN_WIDTH_20_NOHT:
393 width = 20;
394 break;
395 case NL80211_CHAN_WIDTH_40:
396 width = 40;
397 if (!ht_cap->ht_supported)
398 return false;
399 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
400 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
401 return false;
402 if (chandef->center_freq1 < control_freq &&
403 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
404 return false;
405 if (chandef->center_freq1 > control_freq &&
406 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
407 return false;
408 break;
409 case NL80211_CHAN_WIDTH_80P80:
410 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ))
411 return false;
412 case NL80211_CHAN_WIDTH_80:
413 if (!vht_cap->vht_supported)
414 return false;
415 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
416 width = 80;
417 break;
418 case NL80211_CHAN_WIDTH_160:
419 if (!vht_cap->vht_supported)
420 return false;
421 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ))
422 return false;
423 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
424 width = 160;
425 break;
426 default:
427 WARN_ON_ONCE(1);
428 return false;
429 }
430
431 /*
432 * TODO: What if there are only certain 80/160/80+80 MHz channels
433 * allowed by the driver, or only certain combinations?
434 * For 40 MHz the driver can set the NO_HT40 flags, but for
435 * 80/160 MHz and in particular 80+80 MHz this isn't really
436 * feasible and we only have NO_80MHZ/NO_160MHZ so far but
437 * no way to cover 80+80 MHz or more complex restrictions.
438 * Note that such restrictions also need to be advertised to
439 * userspace, for example for P2P channel selection.
440 */
441
442 if (width > 20)
443 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
444
445 /* 5 and 10 MHz are only defined for the OFDM PHY */
446 if (width < 20)
447 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
448
449
450 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
451 width, prohibited_flags))
452 return false;
453
454 if (!chandef->center_freq2)
455 return true;
456 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
457 width, prohibited_flags);
458 }
459 EXPORT_SYMBOL(cfg80211_chandef_usable);
460
461 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
462 struct cfg80211_chan_def *chandef)
463 {
464 bool res;
465
466 trace_cfg80211_reg_can_beacon(wiphy, chandef);
467
468 res = cfg80211_chandef_usable(wiphy, chandef,
469 IEEE80211_CHAN_DISABLED |
470 IEEE80211_CHAN_PASSIVE_SCAN |
471 IEEE80211_CHAN_NO_IBSS |
472 IEEE80211_CHAN_RADAR);
473
474 trace_cfg80211_return_bool(res);
475 return res;
476 }
477 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
478
479 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
480 struct cfg80211_chan_def *chandef)
481 {
482 if (!rdev->ops->set_monitor_channel)
483 return -EOPNOTSUPP;
484 if (!cfg80211_has_monitors_only(rdev))
485 return -EBUSY;
486
487 return rdev_set_monitor_channel(rdev, chandef);
488 }
489
490 void
491 cfg80211_get_chan_state(struct wireless_dev *wdev,
492 struct ieee80211_channel **chan,
493 enum cfg80211_chan_mode *chanmode)
494 {
495 *chan = NULL;
496 *chanmode = CHAN_MODE_UNDEFINED;
497
498 ASSERT_WDEV_LOCK(wdev);
499
500 if (wdev->netdev && !netif_running(wdev->netdev))
501 return;
502
503 switch (wdev->iftype) {
504 case NL80211_IFTYPE_ADHOC:
505 if (wdev->current_bss) {
506 *chan = wdev->current_bss->pub.channel;
507 *chanmode = (wdev->ibss_fixed &&
508 !wdev->ibss_dfs_possible)
509 ? CHAN_MODE_SHARED
510 : CHAN_MODE_EXCLUSIVE;
511 return;
512 }
513 case NL80211_IFTYPE_STATION:
514 case NL80211_IFTYPE_P2P_CLIENT:
515 if (wdev->current_bss) {
516 *chan = wdev->current_bss->pub.channel;
517 *chanmode = CHAN_MODE_SHARED;
518 return;
519 }
520 break;
521 case NL80211_IFTYPE_AP:
522 case NL80211_IFTYPE_P2P_GO:
523 if (wdev->cac_started) {
524 *chan = wdev->channel;
525 *chanmode = CHAN_MODE_SHARED;
526 } else if (wdev->beacon_interval) {
527 *chan = wdev->channel;
528 *chanmode = CHAN_MODE_SHARED;
529 }
530 return;
531 case NL80211_IFTYPE_MESH_POINT:
532 if (wdev->mesh_id_len) {
533 *chan = wdev->channel;
534 *chanmode = CHAN_MODE_SHARED;
535 }
536 return;
537 case NL80211_IFTYPE_MONITOR:
538 case NL80211_IFTYPE_AP_VLAN:
539 case NL80211_IFTYPE_WDS:
540 /* these interface types don't really have a channel */
541 return;
542 case NL80211_IFTYPE_P2P_DEVICE:
543 if (wdev->wiphy->features &
544 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL)
545 *chanmode = CHAN_MODE_EXCLUSIVE;
546 return;
547 case NL80211_IFTYPE_UNSPECIFIED:
548 case NUM_NL80211_IFTYPES:
549 WARN_ON(1);
550 }
551
552 return;
553 }
Linux with added FPC-III support