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 u32 cfg80211_get_start_freq(u32 center_freq, 281 u32 bandwidth) 282 { 283 u32 start_freq; 284 285 if (bandwidth <= 20) 286 start_freq = center_freq; 287 else 288 start_freq = center_freq - bandwidth/2 + 10; 289 290 return start_freq; 291 } 292 293 static u32 cfg80211_get_end_freq(u32 center_freq, 294 u32 bandwidth) 295 { 296 u32 end_freq; 297 298 if (bandwidth <= 20) 299 end_freq = center_freq; 300 else 301 end_freq = center_freq + bandwidth/2 - 10; 302 303 return end_freq; 304 } 305 306 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy, 307 u32 center_freq, 308 u32 bandwidth) 309 { 310 struct ieee80211_channel *c; 311 u32 freq, start_freq, end_freq; 312 313 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 314 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 315 316 for (freq = start_freq; freq <= end_freq; freq += 20) { 317 c = ieee80211_get_channel(wiphy, freq); 318 if (!c) 319 return -EINVAL; 320 321 if (c->flags & IEEE80211_CHAN_RADAR) 322 return 1; 323 } 324 return 0; 325 } 326 327 328 int cfg80211_chandef_dfs_required(struct wiphy *wiphy, 329 const struct cfg80211_chan_def *chandef) 330 { 331 int width; 332 int r; 333 334 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 335 return -EINVAL; 336 337 width = cfg80211_chandef_get_width(chandef); 338 if (width < 0) 339 return -EINVAL; 340 341 r = cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq1, 342 width); 343 if (r) 344 return r; 345 346 if (!chandef->center_freq2) 347 return 0; 348 349 return cfg80211_get_chans_dfs_required(wiphy, chandef->center_freq2, 350 width); 351 } 352 EXPORT_SYMBOL(cfg80211_chandef_dfs_required); 353 354 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy, 355 u32 center_freq, 356 u32 bandwidth) 357 { 358 struct ieee80211_channel *c; 359 u32 freq, start_freq, end_freq; 360 int count = 0; 361 362 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 363 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 364 365 /* 366 * Check entire range of channels for the bandwidth. 367 * Check all channels are DFS channels (DFS_USABLE or 368 * DFS_AVAILABLE). Return number of usable channels 369 * (require CAC). Allow DFS and non-DFS channel mix. 370 */ 371 for (freq = start_freq; freq <= end_freq; freq += 20) { 372 c = ieee80211_get_channel(wiphy, freq); 373 if (!c) 374 return -EINVAL; 375 376 if (c->flags & IEEE80211_CHAN_DISABLED) 377 return -EINVAL; 378 379 if (c->flags & IEEE80211_CHAN_RADAR) { 380 if (c->dfs_state == NL80211_DFS_UNAVAILABLE) 381 return -EINVAL; 382 383 if (c->dfs_state == NL80211_DFS_USABLE) 384 count++; 385 } 386 } 387 388 return count; 389 } 390 391 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy, 392 const struct cfg80211_chan_def *chandef) 393 { 394 int width; 395 int r1, r2 = 0; 396 397 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 398 return false; 399 400 width = cfg80211_chandef_get_width(chandef); 401 if (width < 0) 402 return false; 403 404 r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1, 405 width); 406 407 if (r1 < 0) 408 return false; 409 410 switch (chandef->width) { 411 case NL80211_CHAN_WIDTH_80P80: 412 WARN_ON(!chandef->center_freq2); 413 r2 = cfg80211_get_chans_dfs_usable(wiphy, 414 chandef->center_freq2, 415 width); 416 if (r2 < 0) 417 return false; 418 break; 419 default: 420 WARN_ON(chandef->center_freq2); 421 break; 422 } 423 424 return (r1 + r2 > 0); 425 } 426 427 428 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy, 429 u32 center_freq, 430 u32 bandwidth) 431 { 432 struct ieee80211_channel *c; 433 u32 freq, start_freq, end_freq; 434 435 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 436 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 437 438 /* 439 * Check entire range of channels for the bandwidth. 440 * If any channel in between is disabled or has not 441 * had gone through CAC return false 442 */ 443 for (freq = start_freq; freq <= end_freq; freq += 20) { 444 c = ieee80211_get_channel(wiphy, freq); 445 if (!c) 446 return false; 447 448 if (c->flags & IEEE80211_CHAN_DISABLED) 449 return false; 450 451 if ((c->flags & IEEE80211_CHAN_RADAR) && 452 (c->dfs_state != NL80211_DFS_AVAILABLE)) 453 return false; 454 } 455 456 return true; 457 } 458 459 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy, 460 const struct cfg80211_chan_def *chandef) 461 { 462 int width; 463 int r; 464 465 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 466 return false; 467 468 width = cfg80211_chandef_get_width(chandef); 469 if (width < 0) 470 return false; 471 472 r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1, 473 width); 474 475 /* If any of channels unavailable for cf1 just return */ 476 if (!r) 477 return r; 478 479 switch (chandef->width) { 480 case NL80211_CHAN_WIDTH_80P80: 481 WARN_ON(!chandef->center_freq2); 482 r = cfg80211_get_chans_dfs_available(wiphy, 483 chandef->center_freq2, 484 width); 485 default: 486 WARN_ON(chandef->center_freq2); 487 break; 488 } 489 490 return r; 491 } 492 493 494 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy, 495 u32 center_freq, u32 bandwidth, 496 u32 prohibited_flags) 497 { 498 struct ieee80211_channel *c; 499 u32 freq, start_freq, end_freq; 500 501 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 502 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 503 504 for (freq = start_freq; freq <= end_freq; freq += 20) { 505 c = ieee80211_get_channel(wiphy, freq); 506 if (!c || c->flags & prohibited_flags) 507 return false; 508 } 509 510 return true; 511 } 512 513 bool cfg80211_chandef_usable(struct wiphy *wiphy, 514 const struct cfg80211_chan_def *chandef, 515 u32 prohibited_flags) 516 { 517 struct ieee80211_sta_ht_cap *ht_cap; 518 struct ieee80211_sta_vht_cap *vht_cap; 519 u32 width, control_freq; 520 521 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 522 return false; 523 524 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 525 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 526 527 control_freq = chandef->chan->center_freq; 528 529 switch (chandef->width) { 530 case NL80211_CHAN_WIDTH_5: 531 width = 5; 532 break; 533 case NL80211_CHAN_WIDTH_10: 534 width = 10; 535 break; 536 case NL80211_CHAN_WIDTH_20: 537 if (!ht_cap->ht_supported) 538 return false; 539 case NL80211_CHAN_WIDTH_20_NOHT: 540 width = 20; 541 break; 542 case NL80211_CHAN_WIDTH_40: 543 width = 40; 544 if (!ht_cap->ht_supported) 545 return false; 546 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 547 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 548 return false; 549 if (chandef->center_freq1 < control_freq && 550 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 551 return false; 552 if (chandef->center_freq1 > control_freq && 553 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 554 return false; 555 break; 556 case NL80211_CHAN_WIDTH_80P80: 557 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) 558 return false; 559 case NL80211_CHAN_WIDTH_80: 560 if (!vht_cap->vht_supported) 561 return false; 562 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 563 width = 80; 564 break; 565 case NL80211_CHAN_WIDTH_160: 566 if (!vht_cap->vht_supported) 567 return false; 568 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)) 569 return false; 570 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 571 width = 160; 572 break; 573 default: 574 WARN_ON_ONCE(1); 575 return false; 576 } 577 578 /* 579 * TODO: What if there are only certain 80/160/80+80 MHz channels 580 * allowed by the driver, or only certain combinations? 581 * For 40 MHz the driver can set the NO_HT40 flags, but for 582 * 80/160 MHz and in particular 80+80 MHz this isn't really 583 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 584 * no way to cover 80+80 MHz or more complex restrictions. 585 * Note that such restrictions also need to be advertised to 586 * userspace, for example for P2P channel selection. 587 */ 588 589 if (width > 20) 590 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 591 592 /* 5 and 10 MHz are only defined for the OFDM PHY */ 593 if (width < 20) 594 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 595 596 597 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1, 598 width, prohibited_flags)) 599 return false; 600 601 if (!chandef->center_freq2) 602 return true; 603 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2, 604 width, prohibited_flags); 605 } 606 EXPORT_SYMBOL(cfg80211_chandef_usable); 607 608 bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 609 struct cfg80211_chan_def *chandef) 610 { 611 bool res; 612 u32 prohibited_flags = IEEE80211_CHAN_DISABLED | 613 IEEE80211_CHAN_NO_IR | 614 IEEE80211_CHAN_RADAR; 615 616 trace_cfg80211_reg_can_beacon(wiphy, chandef); 617 618 if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 && 619 cfg80211_chandef_dfs_available(wiphy, chandef)) { 620 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */ 621 prohibited_flags = IEEE80211_CHAN_DISABLED; 622 } 623 624 res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags); 625 626 trace_cfg80211_return_bool(res); 627 return res; 628 } 629 EXPORT_SYMBOL(cfg80211_reg_can_beacon); 630 631 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 632 struct cfg80211_chan_def *chandef) 633 { 634 if (!rdev->ops->set_monitor_channel) 635 return -EOPNOTSUPP; 636 if (!cfg80211_has_monitors_only(rdev)) 637 return -EBUSY; 638 639 return rdev_set_monitor_channel(rdev, chandef); 640 } 641 642 void 643 cfg80211_get_chan_state(struct wireless_dev *wdev, 644 struct ieee80211_channel **chan, 645 enum cfg80211_chan_mode *chanmode) 646 { 647 *chan = NULL; 648 *chanmode = CHAN_MODE_UNDEFINED; 649 650 ASSERT_WDEV_LOCK(wdev); 651 652 if (wdev->netdev && !netif_running(wdev->netdev)) 653 return; 654 655 switch (wdev->iftype) { 656 case NL80211_IFTYPE_ADHOC: 657 if (wdev->current_bss) { 658 *chan = wdev->current_bss->pub.channel; 659 *chanmode = (wdev->ibss_fixed && 660 !wdev->ibss_dfs_possible) 661 ? CHAN_MODE_SHARED 662 : CHAN_MODE_EXCLUSIVE; 663 return; 664 } 665 break; 666 case NL80211_IFTYPE_STATION: 667 case NL80211_IFTYPE_P2P_CLIENT: 668 if (wdev->current_bss) { 669 *chan = wdev->current_bss->pub.channel; 670 *chanmode = CHAN_MODE_SHARED; 671 return; 672 } 673 break; 674 case NL80211_IFTYPE_AP: 675 case NL80211_IFTYPE_P2P_GO: 676 if (wdev->cac_started) { 677 *chan = wdev->channel; 678 *chanmode = CHAN_MODE_SHARED; 679 } else if (wdev->beacon_interval) { 680 *chan = wdev->channel; 681 *chanmode = CHAN_MODE_SHARED; 682 } 683 return; 684 case NL80211_IFTYPE_MESH_POINT: 685 if (wdev->mesh_id_len) { 686 *chan = wdev->channel; 687 *chanmode = CHAN_MODE_SHARED; 688 } 689 return; 690 case NL80211_IFTYPE_MONITOR: 691 case NL80211_IFTYPE_AP_VLAN: 692 case NL80211_IFTYPE_WDS: 693 /* these interface types don't really have a channel */ 694 return; 695 case NL80211_IFTYPE_P2P_DEVICE: 696 if (wdev->wiphy->features & 697 NL80211_FEATURE_P2P_DEVICE_NEEDS_CHANNEL) 698 *chanmode = CHAN_MODE_EXCLUSIVE; 699 return; 700 case NL80211_IFTYPE_UNSPECIFIED: 701 case NUM_NL80211_IFTYPES: 702 WARN_ON(1); 703 } 704 705 return; 706 } 707