contrib/wpa_supplicant/src/ap/dfs.c

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