1 /* 2 * DFS - Dynamic Frequency Selection 3 * Copyright (c) 2002-2013, Jouni Malinen <j@w1.fi> 4 * Copyright (c) 2013-2017, Qualcomm Atheros, Inc. 5 * 6 * This software may be distributed under the terms of the BSD license. 7 * See README for more details. 8 */ 9 10 #include "utils/includes.h" 11 12 #include "utils/common.h" 13 #include "common/ieee802_11_defs.h" 14 #include "common/hw_features_common.h" 15 #include "common/wpa_ctrl.h" 16 #include "hostapd.h" 17 #include "ap_drv_ops.h" 18 #include "drivers/driver.h" 19 #include "dfs.h" 20 21 22 static int dfs_get_used_n_chans(struct hostapd_iface *iface, int *seg1) 23 { 24 int n_chans = 1; 25 26 *seg1 = 0; 27 28 if (iface->conf->ieee80211n && iface->conf->secondary_channel) 29 n_chans = 2; 30 31 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax) { 32 switch (hostapd_get_oper_chwidth(iface->conf)) { 33 case CHANWIDTH_USE_HT: 34 break; 35 case CHANWIDTH_80MHZ: 36 n_chans = 4; 37 break; 38 case CHANWIDTH_160MHZ: 39 n_chans = 8; 40 break; 41 case CHANWIDTH_80P80MHZ: 42 n_chans = 4; 43 *seg1 = 4; 44 break; 45 default: 46 break; 47 } 48 } 49 50 return n_chans; 51 } 52 53 54 static int dfs_channel_available(struct hostapd_channel_data *chan, 55 int skip_radar) 56 { 57 /* 58 * When radar detection happens, CSA is performed. However, there's no 59 * time for CAC, so radar channels must be skipped when finding a new 60 * channel for CSA, unless they are available for immediate use. 61 */ 62 if (skip_radar && (chan->flag & HOSTAPD_CHAN_RADAR) && 63 ((chan->flag & HOSTAPD_CHAN_DFS_MASK) != 64 HOSTAPD_CHAN_DFS_AVAILABLE)) 65 return 0; 66 67 if (chan->flag & HOSTAPD_CHAN_DISABLED) 68 return 0; 69 if ((chan->flag & HOSTAPD_CHAN_RADAR) && 70 ((chan->flag & HOSTAPD_CHAN_DFS_MASK) == 71 HOSTAPD_CHAN_DFS_UNAVAILABLE)) 72 return 0; 73 return 1; 74 } 75 76 77 static int dfs_is_chan_allowed(struct hostapd_channel_data *chan, int n_chans) 78 { 79 /* 80 * The tables contain first valid channel number based on channel width. 81 * We will also choose this first channel as the control one. 82 */ 83 int allowed_40[] = { 36, 44, 52, 60, 100, 108, 116, 124, 132, 149, 157, 84 184, 192 }; 85 /* 86 * VHT80, valid channels based on center frequency: 87 * 42, 58, 106, 122, 138, 155 88 */ 89 int allowed_80[] = { 36, 52, 100, 116, 132, 149 }; 90 /* 91 * VHT160 valid channels based on center frequency: 92 * 50, 114 93 */ 94 int allowed_160[] = { 36, 100 }; 95 int *allowed = allowed_40; 96 unsigned int i, allowed_no = 0; 97 98 switch (n_chans) { 99 case 2: 100 allowed = allowed_40; 101 allowed_no = ARRAY_SIZE(allowed_40); 102 break; 103 case 4: 104 allowed = allowed_80; 105 allowed_no = ARRAY_SIZE(allowed_80); 106 break; 107 case 8: 108 allowed = allowed_160; 109 allowed_no = ARRAY_SIZE(allowed_160); 110 break; 111 default: 112 wpa_printf(MSG_DEBUG, "Unknown width for %d channels", n_chans); 113 break; 114 } 115 116 for (i = 0; i < allowed_no; i++) { 117 if (chan->chan == allowed[i]) 118 return 1; 119 } 120 121 return 0; 122 } 123 124 125 static struct hostapd_channel_data * 126 dfs_get_chan_data(struct hostapd_hw_modes *mode, int freq, int first_chan_idx) 127 { 128 int i; 129 130 for (i = first_chan_idx; i < mode->num_channels; i++) { 131 if (mode->channels[i].freq == freq) 132 return &mode->channels[i]; 133 } 134 135 return NULL; 136 } 137 138 139 static int dfs_chan_range_available(struct hostapd_hw_modes *mode, 140 int first_chan_idx, int num_chans, 141 int skip_radar) 142 { 143 struct hostapd_channel_data *first_chan, *chan; 144 int i; 145 u32 bw = num_chan_to_bw(num_chans); 146 147 if (first_chan_idx + num_chans > mode->num_channels) 148 return 0; 149 150 first_chan = &mode->channels[first_chan_idx]; 151 152 /* hostapd DFS implementation assumes the first channel as primary. 153 * If it's not allowed to use the first channel as primary, decline the 154 * whole channel range. */ 155 if (!chan_pri_allowed(first_chan)) 156 return 0; 157 158 for (i = 0; i < num_chans; i++) { 159 chan = dfs_get_chan_data(mode, first_chan->freq + i * 20, 160 first_chan_idx); 161 if (!chan) 162 return 0; 163 164 /* HT 40 MHz secondary channel availability checked only for 165 * primary channel */ 166 if (!chan_bw_allowed(chan, bw, 1, !i)) 167 return 0; 168 169 if (!dfs_channel_available(chan, skip_radar)) 170 return 0; 171 } 172 173 return 1; 174 } 175 176 177 static int is_in_chanlist(struct hostapd_iface *iface, 178 struct hostapd_channel_data *chan) 179 { 180 if (!iface->conf->acs_ch_list.num) 181 return 1; 182 183 return freq_range_list_includes(&iface->conf->acs_ch_list, chan->chan); 184 } 185 186 187 /* 188 * The function assumes HT40+ operation. 189 * Make sure to adjust the following variables after calling this: 190 * - hapd->secondary_channel 191 * - hapd->vht/he_oper_centr_freq_seg0_idx 192 * - hapd->vht/he_oper_centr_freq_seg1_idx 193 */ 194 static int dfs_find_channel(struct hostapd_iface *iface, 195 struct hostapd_channel_data **ret_chan, 196 int idx, int skip_radar) 197 { 198 struct hostapd_hw_modes *mode; 199 struct hostapd_channel_data *chan; 200 int i, channel_idx = 0, n_chans, n_chans1; 201 202 mode = iface->current_mode; 203 n_chans = dfs_get_used_n_chans(iface, &n_chans1); 204 205 wpa_printf(MSG_DEBUG, "DFS new chan checking %d channels", n_chans); 206 for (i = 0; i < mode->num_channels; i++) { 207 chan = &mode->channels[i]; 208 209 /* Skip HT40/VHT incompatible channels */ 210 if (iface->conf->ieee80211n && 211 iface->conf->secondary_channel && 212 (!dfs_is_chan_allowed(chan, n_chans) || 213 !(chan->allowed_bw & HOSTAPD_CHAN_WIDTH_40P))) 214 continue; 215 216 /* Skip incompatible chandefs */ 217 if (!dfs_chan_range_available(mode, i, n_chans, skip_radar)) 218 continue; 219 220 if (!is_in_chanlist(iface, chan)) 221 continue; 222 223 if (ret_chan && idx == channel_idx) { 224 wpa_printf(MSG_DEBUG, "Selected ch. #%d", chan->chan); 225 *ret_chan = chan; 226 return idx; 227 } 228 wpa_printf(MSG_DEBUG, "Adding channel: %d", chan->chan); 229 channel_idx++; 230 } 231 return channel_idx; 232 } 233 234 235 static void dfs_adjust_center_freq(struct hostapd_iface *iface, 236 struct hostapd_channel_data *chan, 237 int secondary_channel, 238 u8 *oper_centr_freq_seg0_idx, 239 u8 *oper_centr_freq_seg1_idx) 240 { 241 if (!iface->conf->ieee80211ac && !iface->conf->ieee80211ax) 242 return; 243 244 if (!chan) 245 return; 246 247 *oper_centr_freq_seg1_idx = 0; 248 249 switch (hostapd_get_oper_chwidth(iface->conf)) { 250 case CHANWIDTH_USE_HT: 251 if (secondary_channel == 1) 252 *oper_centr_freq_seg0_idx = chan->chan + 2; 253 else if (secondary_channel == -1) 254 *oper_centr_freq_seg0_idx = chan->chan - 2; 255 else 256 *oper_centr_freq_seg0_idx = chan->chan; 257 break; 258 case CHANWIDTH_80MHZ: 259 *oper_centr_freq_seg0_idx = chan->chan + 6; 260 break; 261 case CHANWIDTH_160MHZ: 262 *oper_centr_freq_seg0_idx = chan->chan + 14; 263 break; 264 default: 265 wpa_printf(MSG_INFO, "DFS only VHT20/40/80/160 is supported now"); 266 *oper_centr_freq_seg0_idx = 0; 267 break; 268 } 269 270 wpa_printf(MSG_DEBUG, "DFS adjusting VHT center frequency: %d, %d", 271 *oper_centr_freq_seg0_idx, 272 *oper_centr_freq_seg1_idx); 273 } 274 275 276 /* Return start channel idx we will use for mode->channels[idx] */ 277 static int dfs_get_start_chan_idx(struct hostapd_iface *iface, int *seg1_start) 278 { 279 struct hostapd_hw_modes *mode; 280 struct hostapd_channel_data *chan; 281 int channel_no = iface->conf->channel; 282 int res = -1, i; 283 int chan_seg1 = -1; 284 285 *seg1_start = -1; 286 287 /* HT40- */ 288 if (iface->conf->ieee80211n && iface->conf->secondary_channel == -1) 289 channel_no -= 4; 290 291 /* VHT/HE */ 292 if (iface->conf->ieee80211ac || iface->conf->ieee80211ax) { 293 switch (hostapd_get_oper_chwidth(iface->conf)) { 294 case CHANWIDTH_USE_HT: 295 break; 296 case CHANWIDTH_80MHZ: 297 channel_no = hostapd_get_oper_centr_freq_seg0_idx( 298 iface->conf) - 6; 299 break; 300 case CHANWIDTH_160MHZ: 301 channel_no = hostapd_get_oper_centr_freq_seg0_idx( 302 iface->conf) - 14; 303 break; 304 case CHANWIDTH_80P80MHZ: 305 channel_no = hostapd_get_oper_centr_freq_seg0_idx( 306 iface->conf) - 6; 307 chan_seg1 = hostapd_get_oper_centr_freq_seg1_idx( 308 iface->conf) - 6; 309 break; 310 default: 311 wpa_printf(MSG_INFO, 312 "DFS only VHT20/40/80/160/80+80 is supported now"); 313 channel_no = -1; 314 break; 315 } 316 } 317 318 /* Get idx */ 319 mode = iface->current_mode; 320 for (i = 0; i < mode->num_channels; i++) { 321 chan = &mode->channels[i]; 322 if (chan->chan == channel_no) { 323 res = i; 324 break; 325 } 326 } 327 328 if (res != -1 && chan_seg1 > -1) { 329 int found = 0; 330 331 /* Get idx for seg1 */ 332 mode = iface->current_mode; 333 for (i = 0; i < mode->num_channels; i++) { 334 chan = &mode->channels[i]; 335 if (chan->chan == chan_seg1) { 336 *seg1_start = i; 337 found = 1; 338 break; 339 } 340 } 341 if (!found) 342 res = -1; 343 } 344 345 if (res == -1) { 346 wpa_printf(MSG_DEBUG, 347 "DFS chan_idx seems wrong; num-ch: %d ch-no: %d conf-ch-no: %d 11n: %d sec-ch: %d vht-oper-width: %d", 348 mode->num_channels, channel_no, iface->conf->channel, 349 iface->conf->ieee80211n, 350 iface->conf->secondary_channel, 351 hostapd_get_oper_chwidth(iface->conf)); 352 353 for (i = 0; i < mode->num_channels; i++) { 354 wpa_printf(MSG_DEBUG, "Available channel: %d", 355 mode->channels[i].chan); 356 } 357 } 358 359 return res; 360 } 361 362 363 /* At least one channel have radar flag */ 364 static int dfs_check_chans_radar(struct hostapd_iface *iface, 365 int start_chan_idx, int n_chans) 366 { 367 struct hostapd_channel_data *channel; 368 struct hostapd_hw_modes *mode; 369 int i, res = 0; 370 371 mode = iface->current_mode; 372 373 for (i = 0; i < n_chans; i++) { 374 channel = &mode->channels[start_chan_idx + i]; 375 if (channel->flag & HOSTAPD_CHAN_RADAR) 376 res++; 377 } 378 379 return res; 380 } 381 382 383 /* All channels available */ 384 static int dfs_check_chans_available(struct hostapd_iface *iface, 385 int start_chan_idx, int n_chans) 386 { 387 struct hostapd_channel_data *channel; 388 struct hostapd_hw_modes *mode; 389 int i; 390 391 mode = iface->current_mode; 392 393 for (i = 0; i < n_chans; i++) { 394 channel = &mode->channels[start_chan_idx + i]; 395 396 if (channel->flag & HOSTAPD_CHAN_DISABLED) 397 break; 398 399 if (!(channel->flag & HOSTAPD_CHAN_RADAR)) 400 continue; 401 402 if ((channel->flag & HOSTAPD_CHAN_DFS_MASK) != 403 HOSTAPD_CHAN_DFS_AVAILABLE) 404 break; 405 } 406 407 return i == n_chans; 408 } 409 410 411 /* At least one channel unavailable */ 412 static int dfs_check_chans_unavailable(struct hostapd_iface *iface, 413 int start_chan_idx, 414 int n_chans) 415 { 416 struct hostapd_channel_data *channel; 417 struct hostapd_hw_modes *mode; 418 int i, res = 0; 419 420 mode = iface->current_mode; 421 422 for (i = 0; i < n_chans; i++) { 423 channel = &mode->channels[start_chan_idx + i]; 424 if (channel->flag & HOSTAPD_CHAN_DISABLED) 425 res++; 426 if ((channel->flag & HOSTAPD_CHAN_DFS_MASK) == 427 HOSTAPD_CHAN_DFS_UNAVAILABLE) 428 res++; 429 } 430 431 return res; 432 } 433 434 435 static struct hostapd_channel_data * 436 dfs_get_valid_channel(struct hostapd_iface *iface, 437 int *secondary_channel, 438 u8 *oper_centr_freq_seg0_idx, 439 u8 *oper_centr_freq_seg1_idx, 440 int skip_radar) 441 { 442 struct hostapd_hw_modes *mode; 443 struct hostapd_channel_data *chan = NULL; 444 int num_available_chandefs; 445 int chan_idx; 446 u32 _rand; 447 448 wpa_printf(MSG_DEBUG, "DFS: Selecting random channel"); 449 *secondary_channel = 0; 450 *oper_centr_freq_seg0_idx = 0; 451 *oper_centr_freq_seg1_idx = 0; 452 453 if (iface->current_mode == NULL) 454 return NULL; 455 456 mode = iface->current_mode; 457 if (mode->mode != HOSTAPD_MODE_IEEE80211A) 458 return NULL; 459 460 /* Get the count first */ 461 num_available_chandefs = dfs_find_channel(iface, NULL, 0, skip_radar); 462 if (num_available_chandefs == 0) 463 return NULL; 464 465 if (os_get_random((u8 *) &_rand, sizeof(_rand)) < 0) 466 return NULL; 467 chan_idx = _rand % num_available_chandefs; 468 dfs_find_channel(iface, &chan, chan_idx, skip_radar); 469 470 /* dfs_find_channel() calculations assume HT40+ */ 471 if (iface->conf->secondary_channel) 472 *secondary_channel = 1; 473 else 474 *secondary_channel = 0; 475 476 dfs_adjust_center_freq(iface, chan, 477 *secondary_channel, 478 oper_centr_freq_seg0_idx, 479 oper_centr_freq_seg1_idx); 480 481 return chan; 482 } 483 484 485 static int set_dfs_state_freq(struct hostapd_iface *iface, int freq, u32 state) 486 { 487 struct hostapd_hw_modes *mode; 488 struct hostapd_channel_data *chan = NULL; 489 int i; 490 491 mode = iface->current_mode; 492 if (mode == NULL) 493 return 0; 494 495 wpa_printf(MSG_DEBUG, "set_dfs_state 0x%X for %d MHz", state, freq); 496 for (i = 0; i < iface->current_mode->num_channels; i++) { 497 chan = &iface->current_mode->channels[i]; 498 if (chan->freq == freq) { 499 if (chan->flag & HOSTAPD_CHAN_RADAR) { 500 chan->flag &= ~HOSTAPD_CHAN_DFS_MASK; 501 chan->flag |= state; 502 return 1; /* Channel found */ 503 } 504 } 505 } 506 wpa_printf(MSG_WARNING, "Can't set DFS state for freq %d MHz", freq); 507 return 0; 508 } 509 510 511 static int set_dfs_state(struct hostapd_iface *iface, int freq, int ht_enabled, 512 int chan_offset, int chan_width, int cf1, 513 int cf2, u32 state) 514 { 515 int n_chans = 1, i; 516 struct hostapd_hw_modes *mode; 517 int frequency = freq; 518 int ret = 0; 519 520 mode = iface->current_mode; 521 if (mode == NULL) 522 return 0; 523 524 if (mode->mode != HOSTAPD_MODE_IEEE80211A) { 525 wpa_printf(MSG_WARNING, "current_mode != IEEE80211A"); 526 return 0; 527 } 528 529 /* Seems cf1 and chan_width is enough here */ 530 switch (chan_width) { 531 case CHAN_WIDTH_20_NOHT: 532 case CHAN_WIDTH_20: 533 n_chans = 1; 534 if (frequency == 0) 535 frequency = cf1; 536 break; 537 case CHAN_WIDTH_40: 538 n_chans = 2; 539 frequency = cf1 - 10; 540 break; 541 case CHAN_WIDTH_80: 542 n_chans = 4; 543 frequency = cf1 - 30; 544 break; 545 case CHAN_WIDTH_160: 546 n_chans = 8; 547 frequency = cf1 - 70; 548 break; 549 default: 550 wpa_printf(MSG_INFO, "DFS chan_width %d not supported", 551 chan_width); 552 break; 553 } 554 555 wpa_printf(MSG_DEBUG, "DFS freq: %dMHz, n_chans: %d", frequency, 556 n_chans); 557 for (i = 0; i < n_chans; i++) { 558 ret += set_dfs_state_freq(iface, frequency, state); 559 frequency = frequency + 20; 560 } 561 562 return ret; 563 } 564 565 566 static int dfs_are_channels_overlapped(struct hostapd_iface *iface, int freq, 567 int chan_width, int cf1, int cf2) 568 { 569 int start_chan_idx, start_chan_idx1; 570 struct hostapd_hw_modes *mode; 571 struct hostapd_channel_data *chan; 572 int n_chans, n_chans1, i, j, frequency = freq, radar_n_chans = 1; 573 u8 radar_chan; 574 int res = 0; 575 576 /* Our configuration */ 577 mode = iface->current_mode; 578 start_chan_idx = dfs_get_start_chan_idx(iface, &start_chan_idx1); 579 n_chans = dfs_get_used_n_chans(iface, &n_chans1); 580 581 /* Check we are on DFS channel(s) */ 582 if (!dfs_check_chans_radar(iface, start_chan_idx, n_chans)) 583 return 0; 584 585 /* Reported via radar event */ 586 switch (chan_width) { 587 case CHAN_WIDTH_20_NOHT: 588 case CHAN_WIDTH_20: 589 radar_n_chans = 1; 590 if (frequency == 0) 591 frequency = cf1; 592 break; 593 case CHAN_WIDTH_40: 594 radar_n_chans = 2; 595 frequency = cf1 - 10; 596 break; 597 case CHAN_WIDTH_80: 598 radar_n_chans = 4; 599 frequency = cf1 - 30; 600 break; 601 case CHAN_WIDTH_160: 602 radar_n_chans = 8; 603 frequency = cf1 - 70; 604 break; 605 default: 606 wpa_printf(MSG_INFO, "DFS chan_width %d not supported", 607 chan_width); 608 break; 609 } 610 611 ieee80211_freq_to_chan(frequency, &radar_chan); 612 613 for (i = 0; i < n_chans; i++) { 614 chan = &mode->channels[start_chan_idx + i]; 615 if (!(chan->flag & HOSTAPD_CHAN_RADAR)) 616 continue; 617 for (j = 0; j < radar_n_chans; j++) { 618 wpa_printf(MSG_DEBUG, "checking our: %d, radar: %d", 619 chan->chan, radar_chan + j * 4); 620 if (chan->chan == radar_chan + j * 4) 621 res++; 622 } 623 } 624 625 wpa_printf(MSG_DEBUG, "overlapped: %d", res); 626 627 return res; 628 } 629 630 631 static unsigned int dfs_get_cac_time(struct hostapd_iface *iface, 632 int start_chan_idx, int n_chans) 633 { 634 struct hostapd_channel_data *channel; 635 struct hostapd_hw_modes *mode; 636 int i; 637 unsigned int cac_time_ms = 0; 638 639 mode = iface->current_mode; 640 641 for (i = 0; i < n_chans; i++) { 642 channel = &mode->channels[start_chan_idx + i]; 643 if (!(channel->flag & HOSTAPD_CHAN_RADAR)) 644 continue; 645 if (channel->dfs_cac_ms > cac_time_ms) 646 cac_time_ms = channel->dfs_cac_ms; 647 } 648 649 return cac_time_ms; 650 } 651 652 653 /* 654 * Main DFS handler 655 * 1 - continue channel/ap setup 656 * 0 - channel/ap setup will be continued after CAC 657 * -1 - hit critical error 658 */ 659 int hostapd_handle_dfs(struct hostapd_iface *iface) 660 { 661 struct hostapd_channel_data *channel; 662 int res, n_chans, n_chans1, start_chan_idx, start_chan_idx1; 663 int skip_radar = 0; 664 665 if (!iface->current_mode) { 666 /* 667 * This can happen with drivers that do not provide mode 668 * information and as such, cannot really use hostapd for DFS. 669 */ 670 wpa_printf(MSG_DEBUG, 671 "DFS: No current_mode information - assume no need to perform DFS operations by hostapd"); 672 return 1; 673 } 674 675 iface->cac_started = 0; 676 677 do { 678 /* Get start (first) channel for current configuration */ 679 start_chan_idx = dfs_get_start_chan_idx(iface, 680 &start_chan_idx1); 681 if (start_chan_idx == -1) 682 return -1; 683 684 /* Get number of used channels, depend on width */ 685 n_chans = dfs_get_used_n_chans(iface, &n_chans1); 686 687 /* Setup CAC time */ 688 iface->dfs_cac_ms = dfs_get_cac_time(iface, start_chan_idx, 689 n_chans); 690 691 /* Check if any of configured channels require DFS */ 692 res = dfs_check_chans_radar(iface, start_chan_idx, n_chans); 693 wpa_printf(MSG_DEBUG, 694 "DFS %d channels required radar detection", 695 res); 696 if (!res) 697 return 1; 698 699 /* Check if all channels are DFS available */ 700 res = dfs_check_chans_available(iface, start_chan_idx, n_chans); 701 wpa_printf(MSG_DEBUG, 702 "DFS all channels available, (SKIP CAC): %s", 703 res ? "yes" : "no"); 704 if (res) 705 return 1; 706 707 /* Check if any of configured channels is unavailable */ 708 res = dfs_check_chans_unavailable(iface, start_chan_idx, 709 n_chans); 710 wpa_printf(MSG_DEBUG, "DFS %d chans unavailable - choose other channel: %s", 711 res, res ? "yes": "no"); 712 if (res) { 713 int sec = 0; 714 u8 cf1 = 0, cf2 = 0; 715 716 channel = dfs_get_valid_channel(iface, &sec, &cf1, &cf2, 717 skip_radar); 718 if (!channel) { 719 wpa_printf(MSG_ERROR, "could not get valid channel"); 720 hostapd_set_state(iface, HAPD_IFACE_DFS); 721 return 0; 722 } 723 724 iface->freq = channel->freq; 725 iface->conf->channel = channel->chan; 726 iface->conf->secondary_channel = sec; 727 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, cf1); 728 hostapd_set_oper_centr_freq_seg1_idx(iface->conf, cf2); 729 } 730 } while (res); 731 732 /* Finally start CAC */ 733 hostapd_set_state(iface, HAPD_IFACE_DFS); 734 wpa_printf(MSG_DEBUG, "DFS start CAC on %d MHz", iface->freq); 735 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_CAC_START 736 "freq=%d chan=%d sec_chan=%d, width=%d, seg0=%d, seg1=%d, cac_time=%ds", 737 iface->freq, 738 iface->conf->channel, iface->conf->secondary_channel, 739 hostapd_get_oper_chwidth(iface->conf), 740 hostapd_get_oper_centr_freq_seg0_idx(iface->conf), 741 hostapd_get_oper_centr_freq_seg1_idx(iface->conf), 742 iface->dfs_cac_ms / 1000); 743 744 res = hostapd_start_dfs_cac( 745 iface, iface->conf->hw_mode, iface->freq, iface->conf->channel, 746 iface->conf->ieee80211n, iface->conf->ieee80211ac, 747 iface->conf->ieee80211ax, 748 iface->conf->secondary_channel, 749 hostapd_get_oper_chwidth(iface->conf), 750 hostapd_get_oper_centr_freq_seg0_idx(iface->conf), 751 hostapd_get_oper_centr_freq_seg1_idx(iface->conf)); 752 753 if (res) { 754 wpa_printf(MSG_ERROR, "DFS start_dfs_cac() failed, %d", res); 755 return -1; 756 } 757 758 return 0; 759 } 760 761 762 static int hostapd_config_dfs_chan_available(struct hostapd_iface *iface) 763 { 764 int n_chans, n_chans1, start_chan_idx, start_chan_idx1; 765 766 /* Get the start (first) channel for current configuration */ 767 start_chan_idx = dfs_get_start_chan_idx(iface, &start_chan_idx1); 768 if (start_chan_idx < 0) 769 return 0; 770 771 /* Get the number of used channels, depending on width */ 772 n_chans = dfs_get_used_n_chans(iface, &n_chans1); 773 774 /* Check if all channels are DFS available */ 775 return dfs_check_chans_available(iface, start_chan_idx, n_chans); 776 } 777 778 779 int hostapd_dfs_complete_cac(struct hostapd_iface *iface, int success, int freq, 780 int ht_enabled, int chan_offset, int chan_width, 781 int cf1, int cf2) 782 { 783 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_CAC_COMPLETED 784 "success=%d freq=%d ht_enabled=%d chan_offset=%d chan_width=%d cf1=%d cf2=%d", 785 success, freq, ht_enabled, chan_offset, chan_width, cf1, cf2); 786 787 if (success) { 788 /* Complete iface/ap configuration */ 789 if (iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) { 790 /* Complete AP configuration for the first bring up. */ 791 if (iface->state != HAPD_IFACE_ENABLED) 792 hostapd_setup_interface_complete(iface, 0); 793 else 794 iface->cac_started = 0; 795 } else { 796 set_dfs_state(iface, freq, ht_enabled, chan_offset, 797 chan_width, cf1, cf2, 798 HOSTAPD_CHAN_DFS_AVAILABLE); 799 /* 800 * Just mark the channel available when CAC completion 801 * event is received in enabled state. CAC result could 802 * have been propagated from another radio having the 803 * same regulatory configuration. When CAC completion is 804 * received during non-HAPD_IFACE_ENABLED state, make 805 * sure the configured channel is available because this 806 * CAC completion event could have been propagated from 807 * another radio. 808 */ 809 if (iface->state != HAPD_IFACE_ENABLED && 810 hostapd_config_dfs_chan_available(iface)) { 811 hostapd_setup_interface_complete(iface, 0); 812 iface->cac_started = 0; 813 } 814 } 815 } 816 817 return 0; 818 } 819 820 821 int hostapd_dfs_pre_cac_expired(struct hostapd_iface *iface, int freq, 822 int ht_enabled, int chan_offset, int chan_width, 823 int cf1, int cf2) 824 { 825 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_PRE_CAC_EXPIRED 826 "freq=%d ht_enabled=%d chan_offset=%d chan_width=%d cf1=%d cf2=%d", 827 freq, ht_enabled, chan_offset, chan_width, cf1, cf2); 828 829 /* Proceed only if DFS is not offloaded to the driver */ 830 if (iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) 831 return 0; 832 833 set_dfs_state(iface, freq, ht_enabled, chan_offset, chan_width, 834 cf1, cf2, HOSTAPD_CHAN_DFS_USABLE); 835 836 return 0; 837 } 838 839 840 static int hostapd_dfs_start_channel_switch_cac(struct hostapd_iface *iface) 841 { 842 struct hostapd_channel_data *channel; 843 int secondary_channel; 844 u8 oper_centr_freq_seg0_idx = 0; 845 u8 oper_centr_freq_seg1_idx = 0; 846 int skip_radar = 0; 847 int err = 1; 848 849 /* Radar detected during active CAC */ 850 iface->cac_started = 0; 851 channel = dfs_get_valid_channel(iface, &secondary_channel, 852 &oper_centr_freq_seg0_idx, 853 &oper_centr_freq_seg1_idx, 854 skip_radar); 855 856 if (!channel) { 857 wpa_printf(MSG_ERROR, "No valid channel available"); 858 return err; 859 } 860 861 wpa_printf(MSG_DEBUG, "DFS will switch to a new channel %d", 862 channel->chan); 863 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_NEW_CHANNEL 864 "freq=%d chan=%d sec_chan=%d", channel->freq, 865 channel->chan, secondary_channel); 866 867 iface->freq = channel->freq; 868 iface->conf->channel = channel->chan; 869 iface->conf->secondary_channel = secondary_channel; 870 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, 871 oper_centr_freq_seg0_idx); 872 hostapd_set_oper_centr_freq_seg1_idx(iface->conf, 873 oper_centr_freq_seg1_idx); 874 err = 0; 875 876 hostapd_setup_interface_complete(iface, err); 877 return err; 878 } 879 880 881 static int hostapd_dfs_start_channel_switch(struct hostapd_iface *iface) 882 { 883 struct hostapd_channel_data *channel; 884 int secondary_channel; 885 u8 oper_centr_freq_seg0_idx; 886 u8 oper_centr_freq_seg1_idx; 887 int skip_radar = 1; 888 struct csa_settings csa_settings; 889 unsigned int i; 890 int err = 1; 891 struct hostapd_hw_modes *cmode = iface->current_mode; 892 893 wpa_printf(MSG_DEBUG, "%s called (CAC active: %s, CSA active: %s)", 894 __func__, iface->cac_started ? "yes" : "no", 895 hostapd_csa_in_progress(iface) ? "yes" : "no"); 896 897 /* Check if CSA in progress */ 898 if (hostapd_csa_in_progress(iface)) 899 return 0; 900 901 /* Check if active CAC */ 902 if (iface->cac_started) 903 return hostapd_dfs_start_channel_switch_cac(iface); 904 905 /* 906 * Allow selection of DFS channel in ETSI to comply with 907 * uniform spreading. 908 */ 909 if (iface->dfs_domain == HOSTAPD_DFS_REGION_ETSI) 910 skip_radar = 0; 911 912 /* Perform channel switch/CSA */ 913 channel = dfs_get_valid_channel(iface, &secondary_channel, 914 &oper_centr_freq_seg0_idx, 915 &oper_centr_freq_seg1_idx, 916 skip_radar); 917 918 if (!channel) { 919 /* 920 * If there is no channel to switch immediately to, check if 921 * there is another channel where we can switch even if it 922 * requires to perform a CAC first. 923 */ 924 skip_radar = 0; 925 channel = dfs_get_valid_channel(iface, &secondary_channel, 926 &oper_centr_freq_seg0_idx, 927 &oper_centr_freq_seg1_idx, 928 skip_radar); 929 if (!channel) { 930 wpa_printf(MSG_INFO, 931 "%s: no DFS channels left, waiting for NOP to finish", 932 __func__); 933 return err; 934 } 935 936 iface->freq = channel->freq; 937 iface->conf->channel = channel->chan; 938 iface->conf->secondary_channel = secondary_channel; 939 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, 940 oper_centr_freq_seg0_idx); 941 hostapd_set_oper_centr_freq_seg1_idx(iface->conf, 942 oper_centr_freq_seg1_idx); 943 944 hostapd_disable_iface(iface); 945 hostapd_enable_iface(iface); 946 return 0; 947 } 948 949 wpa_printf(MSG_DEBUG, "DFS will switch to a new channel %d", 950 channel->chan); 951 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_NEW_CHANNEL 952 "freq=%d chan=%d sec_chan=%d", channel->freq, 953 channel->chan, secondary_channel); 954 955 /* Setup CSA request */ 956 os_memset(&csa_settings, 0, sizeof(csa_settings)); 957 csa_settings.cs_count = 5; 958 csa_settings.block_tx = 1; 959 err = hostapd_set_freq_params(&csa_settings.freq_params, 960 iface->conf->hw_mode, 961 channel->freq, 962 channel->chan, 963 iface->conf->ieee80211n, 964 iface->conf->ieee80211ac, 965 iface->conf->ieee80211ax, 966 secondary_channel, 967 hostapd_get_oper_chwidth(iface->conf), 968 oper_centr_freq_seg0_idx, 969 oper_centr_freq_seg1_idx, 970 cmode->vht_capab, 971 &cmode->he_capab[IEEE80211_MODE_AP]); 972 973 if (err) { 974 wpa_printf(MSG_ERROR, "DFS failed to calculate CSA freq params"); 975 hostapd_disable_iface(iface); 976 return err; 977 } 978 979 for (i = 0; i < iface->num_bss; i++) { 980 err = hostapd_switch_channel(iface->bss[i], &csa_settings); 981 if (err) 982 break; 983 } 984 985 if (err) { 986 wpa_printf(MSG_WARNING, "DFS failed to schedule CSA (%d) - trying fallback", 987 err); 988 iface->freq = channel->freq; 989 iface->conf->channel = channel->chan; 990 iface->conf->secondary_channel = secondary_channel; 991 hostapd_set_oper_centr_freq_seg0_idx(iface->conf, 992 oper_centr_freq_seg0_idx); 993 hostapd_set_oper_centr_freq_seg1_idx(iface->conf, 994 oper_centr_freq_seg1_idx); 995 996 hostapd_disable_iface(iface); 997 hostapd_enable_iface(iface); 998 return 0; 999 } 1000 1001 /* Channel configuration will be updated once CSA completes and 1002 * ch_switch_notify event is received */ 1003 1004 wpa_printf(MSG_DEBUG, "DFS waiting channel switch event"); 1005 return 0; 1006 } 1007 1008 1009 int hostapd_dfs_radar_detected(struct hostapd_iface *iface, int freq, 1010 int ht_enabled, int chan_offset, int chan_width, 1011 int cf1, int cf2) 1012 { 1013 int res; 1014 1015 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_RADAR_DETECTED 1016 "freq=%d ht_enabled=%d chan_offset=%d chan_width=%d cf1=%d cf2=%d", 1017 freq, ht_enabled, chan_offset, chan_width, cf1, cf2); 1018 1019 /* Proceed only if DFS is not offloaded to the driver */ 1020 if (iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) 1021 return 0; 1022 1023 if (!iface->conf->ieee80211h) 1024 return 0; 1025 1026 /* mark radar frequency as invalid */ 1027 set_dfs_state(iface, freq, ht_enabled, chan_offset, chan_width, 1028 cf1, cf2, HOSTAPD_CHAN_DFS_UNAVAILABLE); 1029 1030 /* Skip if reported radar event not overlapped our channels */ 1031 res = dfs_are_channels_overlapped(iface, freq, chan_width, cf1, cf2); 1032 if (!res) 1033 return 0; 1034 1035 /* radar detected while operating, switch the channel. */ 1036 res = hostapd_dfs_start_channel_switch(iface); 1037 1038 return res; 1039 } 1040 1041 1042 int hostapd_dfs_nop_finished(struct hostapd_iface *iface, int freq, 1043 int ht_enabled, int chan_offset, int chan_width, 1044 int cf1, int cf2) 1045 { 1046 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_NOP_FINISHED 1047 "freq=%d ht_enabled=%d chan_offset=%d chan_width=%d cf1=%d cf2=%d", 1048 freq, ht_enabled, chan_offset, chan_width, cf1, cf2); 1049 1050 /* Proceed only if DFS is not offloaded to the driver */ 1051 if (iface->drv_flags & WPA_DRIVER_FLAGS_DFS_OFFLOAD) 1052 return 0; 1053 1054 /* TODO add correct implementation here */ 1055 set_dfs_state(iface, freq, ht_enabled, chan_offset, chan_width, 1056 cf1, cf2, HOSTAPD_CHAN_DFS_USABLE); 1057 1058 /* Handle cases where all channels were initially unavailable */ 1059 if (iface->state == HAPD_IFACE_DFS && !iface->cac_started) 1060 hostapd_handle_dfs(iface); 1061 1062 return 0; 1063 } 1064 1065 1066 int hostapd_is_dfs_required(struct hostapd_iface *iface) 1067 { 1068 int n_chans, n_chans1, start_chan_idx, start_chan_idx1, res; 1069 1070 if (!iface->conf->ieee80211h || !iface->current_mode || 1071 iface->current_mode->mode != HOSTAPD_MODE_IEEE80211A) 1072 return 0; 1073 1074 /* Get start (first) channel for current configuration */ 1075 start_chan_idx = dfs_get_start_chan_idx(iface, &start_chan_idx1); 1076 if (start_chan_idx == -1) 1077 return -1; 1078 1079 /* Get number of used channels, depend on width */ 1080 n_chans = dfs_get_used_n_chans(iface, &n_chans1); 1081 1082 /* Check if any of configured channels require DFS */ 1083 res = dfs_check_chans_radar(iface, start_chan_idx, n_chans); 1084 if (res) 1085 return res; 1086 if (start_chan_idx1 >= 0 && n_chans1 > 0) 1087 res = dfs_check_chans_radar(iface, start_chan_idx1, n_chans1); 1088 return res; 1089 } 1090 1091 1092 int hostapd_dfs_start_cac(struct hostapd_iface *iface, int freq, 1093 int ht_enabled, int chan_offset, int chan_width, 1094 int cf1, int cf2) 1095 { 1096 wpa_msg(iface->bss[0]->msg_ctx, MSG_INFO, DFS_EVENT_CAC_START 1097 "freq=%d chan=%d chan_offset=%d width=%d seg0=%d " 1098 "seg1=%d cac_time=%ds", 1099 freq, (freq - 5000) / 5, chan_offset, chan_width, cf1, cf2, 60); 1100 iface->cac_started = 1; 1101 return 0; 1102 } 1103 1104 1105 /* 1106 * Main DFS handler for offloaded case. 1107 * 2 - continue channel/AP setup for non-DFS channel 1108 * 1 - continue channel/AP setup for DFS channel 1109 * 0 - channel/AP setup will be continued after CAC 1110 * -1 - hit critical error 1111 */ 1112 int hostapd_handle_dfs_offload(struct hostapd_iface *iface) 1113 { 1114 wpa_printf(MSG_DEBUG, "%s: iface->cac_started: %d", 1115 __func__, iface->cac_started); 1116 1117 /* 1118 * If DFS has already been started, then we are being called from a 1119 * callback to continue AP/channel setup. Reset the CAC start flag and 1120 * return. 1121 */ 1122 if (iface->cac_started) { 1123 wpa_printf(MSG_DEBUG, "%s: iface->cac_started: %d", 1124 __func__, iface->cac_started); 1125 iface->cac_started = 0; 1126 return 1; 1127 } 1128 1129 if (ieee80211_is_dfs(iface->freq, iface->hw_features, 1130 iface->num_hw_features)) { 1131 wpa_printf(MSG_DEBUG, "%s: freq %d MHz requires DFS", 1132 __func__, iface->freq); 1133 return 0; 1134 } 1135 1136 wpa_printf(MSG_DEBUG, 1137 "%s: freq %d MHz does not require DFS. Continue channel/AP setup", 1138 __func__, iface->freq); 1139 return 2; 1140 } 1141