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 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy, 494 u32 center_freq, 495 u32 bandwidth) 496 { 497 struct ieee80211_channel *c; 498 u32 start_freq, end_freq, freq; 499 unsigned int dfs_cac_ms = 0; 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) 507 return 0; 508 509 if (c->flags & IEEE80211_CHAN_DISABLED) 510 return 0; 511 512 if (!(c->flags & IEEE80211_CHAN_RADAR)) 513 continue; 514 515 if (c->dfs_cac_ms > dfs_cac_ms) 516 dfs_cac_ms = c->dfs_cac_ms; 517 } 518 519 return dfs_cac_ms; 520 } 521 522 unsigned int 523 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy, 524 const struct cfg80211_chan_def *chandef) 525 { 526 int width; 527 unsigned int t1 = 0, t2 = 0; 528 529 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 530 return 0; 531 532 width = cfg80211_chandef_get_width(chandef); 533 if (width < 0) 534 return 0; 535 536 t1 = cfg80211_get_chans_dfs_cac_time(wiphy, 537 chandef->center_freq1, 538 width); 539 540 if (!chandef->center_freq2) 541 return t1; 542 543 t2 = cfg80211_get_chans_dfs_cac_time(wiphy, 544 chandef->center_freq2, 545 width); 546 547 return max(t1, t2); 548 } 549 550 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy, 551 u32 center_freq, u32 bandwidth, 552 u32 prohibited_flags) 553 { 554 struct ieee80211_channel *c; 555 u32 freq, start_freq, end_freq; 556 557 start_freq = cfg80211_get_start_freq(center_freq, bandwidth); 558 end_freq = cfg80211_get_end_freq(center_freq, bandwidth); 559 560 for (freq = start_freq; freq <= end_freq; freq += 20) { 561 c = ieee80211_get_channel(wiphy, freq); 562 if (!c || c->flags & prohibited_flags) 563 return false; 564 } 565 566 return true; 567 } 568 569 bool cfg80211_chandef_usable(struct wiphy *wiphy, 570 const struct cfg80211_chan_def *chandef, 571 u32 prohibited_flags) 572 { 573 struct ieee80211_sta_ht_cap *ht_cap; 574 struct ieee80211_sta_vht_cap *vht_cap; 575 u32 width, control_freq; 576 577 if (WARN_ON(!cfg80211_chandef_valid(chandef))) 578 return false; 579 580 ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap; 581 vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap; 582 583 control_freq = chandef->chan->center_freq; 584 585 switch (chandef->width) { 586 case NL80211_CHAN_WIDTH_5: 587 width = 5; 588 break; 589 case NL80211_CHAN_WIDTH_10: 590 width = 10; 591 break; 592 case NL80211_CHAN_WIDTH_20: 593 if (!ht_cap->ht_supported) 594 return false; 595 case NL80211_CHAN_WIDTH_20_NOHT: 596 width = 20; 597 break; 598 case NL80211_CHAN_WIDTH_40: 599 width = 40; 600 if (!ht_cap->ht_supported) 601 return false; 602 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) || 603 ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT) 604 return false; 605 if (chandef->center_freq1 < control_freq && 606 chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS) 607 return false; 608 if (chandef->center_freq1 > control_freq && 609 chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS) 610 return false; 611 break; 612 case NL80211_CHAN_WIDTH_80P80: 613 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)) 614 return false; 615 case NL80211_CHAN_WIDTH_80: 616 if (!vht_cap->vht_supported) 617 return false; 618 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ; 619 width = 80; 620 break; 621 case NL80211_CHAN_WIDTH_160: 622 if (!vht_cap->vht_supported) 623 return false; 624 if (!(vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ)) 625 return false; 626 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ; 627 width = 160; 628 break; 629 default: 630 WARN_ON_ONCE(1); 631 return false; 632 } 633 634 /* 635 * TODO: What if there are only certain 80/160/80+80 MHz channels 636 * allowed by the driver, or only certain combinations? 637 * For 40 MHz the driver can set the NO_HT40 flags, but for 638 * 80/160 MHz and in particular 80+80 MHz this isn't really 639 * feasible and we only have NO_80MHZ/NO_160MHZ so far but 640 * no way to cover 80+80 MHz or more complex restrictions. 641 * Note that such restrictions also need to be advertised to 642 * userspace, for example for P2P channel selection. 643 */ 644 645 if (width > 20) 646 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 647 648 /* 5 and 10 MHz are only defined for the OFDM PHY */ 649 if (width < 20) 650 prohibited_flags |= IEEE80211_CHAN_NO_OFDM; 651 652 653 if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1, 654 width, prohibited_flags)) 655 return false; 656 657 if (!chandef->center_freq2) 658 return true; 659 return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2, 660 width, prohibited_flags); 661 } 662 EXPORT_SYMBOL(cfg80211_chandef_usable); 663 664 bool cfg80211_reg_can_beacon(struct wiphy *wiphy, 665 struct cfg80211_chan_def *chandef) 666 { 667 bool res; 668 u32 prohibited_flags = IEEE80211_CHAN_DISABLED | 669 IEEE80211_CHAN_NO_IR | 670 IEEE80211_CHAN_RADAR; 671 672 trace_cfg80211_reg_can_beacon(wiphy, chandef); 673 674 if (cfg80211_chandef_dfs_required(wiphy, chandef) > 0 && 675 cfg80211_chandef_dfs_available(wiphy, chandef)) { 676 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */ 677 prohibited_flags = IEEE80211_CHAN_DISABLED; 678 } 679 680 res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags); 681 682 trace_cfg80211_return_bool(res); 683 return res; 684 } 685 EXPORT_SYMBOL(cfg80211_reg_can_beacon); 686 687 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev, 688 struct cfg80211_chan_def *chandef) 689 { 690 if (!rdev->ops->set_monitor_channel) 691 return -EOPNOTSUPP; 692 if (!cfg80211_has_monitors_only(rdev)) 693 return -EBUSY; 694 695 return rdev_set_monitor_channel(rdev, chandef); 696 } 697 698 void 699 cfg80211_get_chan_state(struct wireless_dev *wdev, 700 struct ieee80211_channel **chan, 701 enum cfg80211_chan_mode *chanmode, 702 u8 *radar_detect) 703 { 704 *chan = NULL; 705 *chanmode = CHAN_MODE_UNDEFINED; 706 707 ASSERT_WDEV_LOCK(wdev); 708 709 if (wdev->netdev && !netif_running(wdev->netdev)) 710 return; 711 712 switch (wdev->iftype) { 713 case NL80211_IFTYPE_ADHOC: 714 if (wdev->current_bss) { 715 *chan = wdev->current_bss->pub.channel; 716 *chanmode = (wdev->ibss_fixed && 717 !wdev->ibss_dfs_possible) 718 ? CHAN_MODE_SHARED 719 : CHAN_MODE_EXCLUSIVE; 720 721 /* consider worst-case - IBSS can try to return to the 722 * original user-specified channel as creator */ 723 if (wdev->ibss_dfs_possible) 724 *radar_detect |= BIT(wdev->chandef.width); 725 return; 726 } 727 break; 728 case NL80211_IFTYPE_STATION: 729 case NL80211_IFTYPE_P2P_CLIENT: 730 if (wdev->current_bss) { 731 *chan = wdev->current_bss->pub.channel; 732 *chanmode = CHAN_MODE_SHARED; 733 return; 734 } 735 break; 736 case NL80211_IFTYPE_AP: 737 case NL80211_IFTYPE_P2P_GO: 738 if (wdev->cac_started) { 739 *chan = wdev->chandef.chan; 740 *chanmode = CHAN_MODE_SHARED; 741 *radar_detect |= BIT(wdev->chandef.width); 742 } else if (wdev->beacon_interval) { 743 *chan = wdev->chandef.chan; 744 *chanmode = CHAN_MODE_SHARED; 745 746 if (cfg80211_chandef_dfs_required(wdev->wiphy, 747 &wdev->chandef)) 748 *radar_detect |= BIT(wdev->chandef.width); 749 } 750 return; 751 case NL80211_IFTYPE_MESH_POINT: 752 if (wdev->mesh_id_len) { 753 *chan = wdev->chandef.chan; 754 *chanmode = CHAN_MODE_SHARED; 755 756 if (cfg80211_chandef_dfs_required(wdev->wiphy, 757 &wdev->chandef)) 758 *radar_detect |= BIT(wdev->chandef.width); 759 } 760 return; 761 case NL80211_IFTYPE_MONITOR: 762 case NL80211_IFTYPE_AP_VLAN: 763 case NL80211_IFTYPE_WDS: 764 case NL80211_IFTYPE_P2P_DEVICE: 765 /* these interface types don't really have a channel */ 766 return; 767 case NL80211_IFTYPE_UNSPECIFIED: 768 case NUM_NL80211_IFTYPES: 769 WARN_ON(1); 770 } 771 } 772