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