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