net/wireless/chan.c

/* [<][>][^][v][top][bottom][index][help] */
This source file includes following definitions.
cfg80211_valid_60g_freq
cfg80211_chandef_create
cfg80211_edmg_chandef_valid
cfg80211_chandef_valid
chandef_primary_freqs
cfg80211_chandef_get_width
cfg80211_chandef_compatible
cfg80211_set_chans_dfs_state
cfg80211_set_dfs_state
cfg80211_get_start_freq
cfg80211_get_end_freq
cfg80211_get_chans_dfs_required
cfg80211_chandef_dfs_required
cfg80211_get_chans_dfs_usable
cfg80211_chandef_dfs_usable
cfg80211_is_sub_chan
cfg80211_beaconing_iface_active
cfg80211_is_wiphy_oper_chan
cfg80211_any_wiphy_oper_chan
cfg80211_get_chans_dfs_available
cfg80211_chandef_dfs_available
cfg80211_get_chans_dfs_cac_time
cfg80211_chandef_dfs_cac_time
cfg80211_secondary_chans_ok
cfg80211_edmg_usable
cfg80211_chandef_usable
cfg80211_ir_permissive_chan
_cfg80211_reg_can_beacon
cfg80211_reg_can_beacon
cfg80211_reg_can_beacon_relax
cfg80211_set_monitor_channel
cfg80211_get_chan_state
   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * This file contains helper code to handle channel
   4  * settings and keeping track of what is possible at
   5  * any point in time.
   6  *
   7  * Copyright 2009       Johannes Berg <johannes@sipsolutions.net>
   8  * Copyright 2013-2014  Intel Mobile Communications GmbH
   9  * Copyright 2018       Intel Corporation
  10  */
  11 
  12 #include <linux/export.h>
  13 #include <net/cfg80211.h>
  14 #include "core.h"
  15 #include "rdev-ops.h"
  16 
  17 static bool cfg80211_valid_60g_freq(u32 freq)
  18 {
  19         return freq >= 58320 && freq <= 70200;
  20 }
  21 
  22 void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
  23                              struct ieee80211_channel *chan,
  24                              enum nl80211_channel_type chan_type)
  25 {
  26         if (WARN_ON(!chan))
  27                 return;
  28 
  29         chandef->chan = chan;
  30         chandef->center_freq2 = 0;
  31         chandef->edmg.bw_config = 0;
  32         chandef->edmg.channels = 0;
  33 
  34         switch (chan_type) {
  35         case NL80211_CHAN_NO_HT:
  36                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
  37                 chandef->center_freq1 = chan->center_freq;
  38                 break;
  39         case NL80211_CHAN_HT20:
  40                 chandef->width = NL80211_CHAN_WIDTH_20;
  41                 chandef->center_freq1 = chan->center_freq;
  42                 break;
  43         case NL80211_CHAN_HT40PLUS:
  44                 chandef->width = NL80211_CHAN_WIDTH_40;
  45                 chandef->center_freq1 = chan->center_freq + 10;
  46                 break;
  47         case NL80211_CHAN_HT40MINUS:
  48                 chandef->width = NL80211_CHAN_WIDTH_40;
  49                 chandef->center_freq1 = chan->center_freq - 10;
  50                 break;
  51         default:
  52                 WARN_ON(1);
  53         }
  54 }
  55 EXPORT_SYMBOL(cfg80211_chandef_create);
  56 
  57 static bool cfg80211_edmg_chandef_valid(const struct cfg80211_chan_def *chandef)
  58 {
  59         int max_contiguous = 0;
  60         int num_of_enabled = 0;
  61         int contiguous = 0;
  62         int i;
  63 
  64         if (!chandef->edmg.channels || !chandef->edmg.bw_config)
  65                 return false;
  66 
  67         if (!cfg80211_valid_60g_freq(chandef->chan->center_freq))
  68                 return false;
  69 
  70         for (i = 0; i < 6; i++) {
  71                 if (chandef->edmg.channels & BIT(i)) {
  72                         contiguous++;
  73                         num_of_enabled++;
  74                 } else {
  75                         contiguous = 0;
  76                 }
  77 
  78                 max_contiguous = max(contiguous, max_contiguous);
  79         }
  80         /* basic verification of edmg configuration according to
  81          * IEEE P802.11ay/D4.0 section 9.4.2.251
  82          */
  83         /* check bw_config against contiguous edmg channels */
  84         switch (chandef->edmg.bw_config) {
  85         case IEEE80211_EDMG_BW_CONFIG_4:
  86         case IEEE80211_EDMG_BW_CONFIG_8:
  87         case IEEE80211_EDMG_BW_CONFIG_12:
  88                 if (max_contiguous < 1)
  89                         return false;
  90                 break;
  91         case IEEE80211_EDMG_BW_CONFIG_5:
  92         case IEEE80211_EDMG_BW_CONFIG_9:
  93         case IEEE80211_EDMG_BW_CONFIG_13:
  94                 if (max_contiguous < 2)
  95                         return false;
  96                 break;
  97         case IEEE80211_EDMG_BW_CONFIG_6:
  98         case IEEE80211_EDMG_BW_CONFIG_10:
  99         case IEEE80211_EDMG_BW_CONFIG_14:
 100                 if (max_contiguous < 3)
 101                         return false;
 102                 break;
 103         case IEEE80211_EDMG_BW_CONFIG_7:
 104         case IEEE80211_EDMG_BW_CONFIG_11:
 105         case IEEE80211_EDMG_BW_CONFIG_15:
 106                 if (max_contiguous < 4)
 107                         return false;
 108                 break;
 109 
 110         default:
 111                 return false;
 112         }
 113 
 114         /* check bw_config against aggregated (non contiguous) edmg channels */
 115         switch (chandef->edmg.bw_config) {
 116         case IEEE80211_EDMG_BW_CONFIG_4:
 117         case IEEE80211_EDMG_BW_CONFIG_5:
 118         case IEEE80211_EDMG_BW_CONFIG_6:
 119         case IEEE80211_EDMG_BW_CONFIG_7:
 120                 break;
 121         case IEEE80211_EDMG_BW_CONFIG_8:
 122         case IEEE80211_EDMG_BW_CONFIG_9:
 123         case IEEE80211_EDMG_BW_CONFIG_10:
 124         case IEEE80211_EDMG_BW_CONFIG_11:
 125                 if (num_of_enabled < 2)
 126                         return false;
 127                 break;
 128         case IEEE80211_EDMG_BW_CONFIG_12:
 129         case IEEE80211_EDMG_BW_CONFIG_13:
 130         case IEEE80211_EDMG_BW_CONFIG_14:
 131         case IEEE80211_EDMG_BW_CONFIG_15:
 132                 if (num_of_enabled < 4 || max_contiguous < 2)
 133                         return false;
 134                 break;
 135         default:
 136                 return false;
 137         }
 138 
 139         return true;
 140 }
 141 
 142 bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
 143 {
 144         u32 control_freq;
 145 
 146         if (!chandef->chan)
 147                 return false;
 148 
 149         control_freq = chandef->chan->center_freq;
 150 
 151         switch (chandef->width) {
 152         case NL80211_CHAN_WIDTH_5:
 153         case NL80211_CHAN_WIDTH_10:
 154         case NL80211_CHAN_WIDTH_20:
 155         case NL80211_CHAN_WIDTH_20_NOHT:
 156                 if (chandef->center_freq1 != control_freq)
 157                         return false;
 158                 if (chandef->center_freq2)
 159                         return false;
 160                 break;
 161         case NL80211_CHAN_WIDTH_40:
 162                 if (chandef->center_freq1 != control_freq + 10 &&
 163                     chandef->center_freq1 != control_freq - 10)
 164                         return false;
 165                 if (chandef->center_freq2)
 166                         return false;
 167                 break;
 168         case NL80211_CHAN_WIDTH_80P80:
 169                 if (chandef->center_freq1 != control_freq + 30 &&
 170                     chandef->center_freq1 != control_freq + 10 &&
 171                     chandef->center_freq1 != control_freq - 10 &&
 172                     chandef->center_freq1 != control_freq - 30)
 173                         return false;
 174                 if (!chandef->center_freq2)
 175                         return false;
 176                 /* adjacent is not allowed -- that's a 160 MHz channel */
 177                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
 178                     chandef->center_freq2 - chandef->center_freq1 == 80)
 179                         return false;
 180                 break;
 181         case NL80211_CHAN_WIDTH_80:
 182                 if (chandef->center_freq1 != control_freq + 30 &&
 183                     chandef->center_freq1 != control_freq + 10 &&
 184                     chandef->center_freq1 != control_freq - 10 &&
 185                     chandef->center_freq1 != control_freq - 30)
 186                         return false;
 187                 if (chandef->center_freq2)
 188                         return false;
 189                 break;
 190         case NL80211_CHAN_WIDTH_160:
 191                 if (chandef->center_freq1 != control_freq + 70 &&
 192                     chandef->center_freq1 != control_freq + 50 &&
 193                     chandef->center_freq1 != control_freq + 30 &&
 194                     chandef->center_freq1 != control_freq + 10 &&
 195                     chandef->center_freq1 != control_freq - 10 &&
 196                     chandef->center_freq1 != control_freq - 30 &&
 197                     chandef->center_freq1 != control_freq - 50 &&
 198                     chandef->center_freq1 != control_freq - 70)
 199                         return false;
 200                 if (chandef->center_freq2)
 201                         return false;
 202                 break;
 203         default:
 204                 return false;
 205         }
 206 
 207         /* channel 14 is only for IEEE 802.11b */
 208         if (chandef->center_freq1 == 2484 &&
 209             chandef->width != NL80211_CHAN_WIDTH_20_NOHT)
 210                 return false;
 211 
 212         if (cfg80211_chandef_is_edmg(chandef) &&
 213             !cfg80211_edmg_chandef_valid(chandef))
 214                 return false;
 215 
 216         return true;
 217 }
 218 EXPORT_SYMBOL(cfg80211_chandef_valid);
 219 
 220 static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
 221                                   u32 *pri40, u32 *pri80)
 222 {
 223         int tmp;
 224 
 225         switch (c->width) {
 226         case NL80211_CHAN_WIDTH_40:
 227                 *pri40 = c->center_freq1;
 228                 *pri80 = 0;
 229                 break;
 230         case NL80211_CHAN_WIDTH_80:
 231         case NL80211_CHAN_WIDTH_80P80:
 232                 *pri80 = c->center_freq1;
 233                 /* n_P20 */
 234                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
 235                 /* n_P40 */
 236                 tmp /= 2;
 237                 /* freq_P40 */
 238                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
 239                 break;
 240         case NL80211_CHAN_WIDTH_160:
 241                 /* n_P20 */
 242                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
 243                 /* n_P40 */
 244                 tmp /= 2;
 245                 /* freq_P40 */
 246                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
 247                 /* n_P80 */
 248                 tmp /= 2;
 249                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
 250                 break;
 251         default:
 252                 WARN_ON_ONCE(1);
 253         }
 254 }
 255 
 256 static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
 257 {
 258         int width;
 259 
 260         switch (c->width) {
 261         case NL80211_CHAN_WIDTH_5:
 262                 width = 5;
 263                 break;
 264         case NL80211_CHAN_WIDTH_10:
 265                 width = 10;
 266                 break;
 267         case NL80211_CHAN_WIDTH_20:
 268         case NL80211_CHAN_WIDTH_20_NOHT:
 269                 width = 20;
 270                 break;
 271         case NL80211_CHAN_WIDTH_40:
 272                 width = 40;
 273                 break;
 274         case NL80211_CHAN_WIDTH_80P80:
 275         case NL80211_CHAN_WIDTH_80:
 276                 width = 80;
 277                 break;
 278         case NL80211_CHAN_WIDTH_160:
 279                 width = 160;
 280                 break;
 281         default:
 282                 WARN_ON_ONCE(1);
 283                 return -1;
 284         }
 285         return width;
 286 }
 287 
 288 const struct cfg80211_chan_def *
 289 cfg80211_chandef_compatible(const struct cfg80211_chan_def *c1,
 290                             const struct cfg80211_chan_def *c2)
 291 {
 292         u32 c1_pri40, c1_pri80, c2_pri40, c2_pri80;
 293 
 294         /* If they are identical, return */
 295         if (cfg80211_chandef_identical(c1, c2))
 296                 return c1;
 297 
 298         /* otherwise, must have same control channel */
 299         if (c1->chan != c2->chan)
 300                 return NULL;
 301 
 302         /*
 303          * If they have the same width, but aren't identical,
 304          * then they can't be compatible.
 305          */
 306         if (c1->width == c2->width)
 307                 return NULL;
 308 
 309         /*
 310          * can't be compatible if one of them is 5 or 10 MHz,
 311          * but they don't have the same width.
 312          */
 313         if (c1->width == NL80211_CHAN_WIDTH_5 ||
 314             c1->width == NL80211_CHAN_WIDTH_10 ||
 315             c2->width == NL80211_CHAN_WIDTH_5 ||
 316             c2->width == NL80211_CHAN_WIDTH_10)
 317                 return NULL;
 318 
 319         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
 320             c1->width == NL80211_CHAN_WIDTH_20)
 321                 return c2;
 322 
 323         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
 324             c2->width == NL80211_CHAN_WIDTH_20)
 325                 return c1;
 326 
 327         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
 328         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
 329 
 330         if (c1_pri40 != c2_pri40)
 331                 return NULL;
 332 
 333         WARN_ON(!c1_pri80 && !c2_pri80);
 334         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
 335                 return NULL;
 336 
 337         if (c1->width > c2->width)
 338                 return c1;
 339         return c2;
 340 }
 341 EXPORT_SYMBOL(cfg80211_chandef_compatible);
 342 
 343 static void cfg80211_set_chans_dfs_state(struct wiphy *wiphy, u32 center_freq,
 344                                          u32 bandwidth,
 345                                          enum nl80211_dfs_state dfs_state)
 346 {
 347         struct ieee80211_channel *c;
 348         u32 freq;
 349 
 350         for (freq = center_freq - bandwidth/2 + 10;
 351              freq <= center_freq + bandwidth/2 - 10;
 352              freq += 20) {
 353                 c = ieee80211_get_channel(wiphy, freq);
 354                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
 355                         continue;
 356 
 357                 c->dfs_state = dfs_state;
 358                 c->dfs_state_entered = jiffies;
 359         }
 360 }
 361 
 362 void cfg80211_set_dfs_state(struct wiphy *wiphy,
 363                             const struct cfg80211_chan_def *chandef,
 364                             enum nl80211_dfs_state dfs_state)
 365 {
 366         int width;
 367 
 368         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 369                 return;
 370 
 371         width = cfg80211_chandef_get_width(chandef);
 372         if (width < 0)
 373                 return;
 374 
 375         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
 376                                      width, dfs_state);
 377 
 378         if (!chandef->center_freq2)
 379                 return;
 380         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq2,
 381                                      width, dfs_state);
 382 }
 383 
 384 static u32 cfg80211_get_start_freq(u32 center_freq,
 385                                    u32 bandwidth)
 386 {
 387         u32 start_freq;
 388 
 389         if (bandwidth <= 20)
 390                 start_freq = center_freq;
 391         else
 392                 start_freq = center_freq - bandwidth/2 + 10;
 393 
 394         return start_freq;
 395 }
 396 
 397 static u32 cfg80211_get_end_freq(u32 center_freq,
 398                                  u32 bandwidth)
 399 {
 400         u32 end_freq;
 401 
 402         if (bandwidth <= 20)
 403                 end_freq = center_freq;
 404         else
 405                 end_freq = center_freq + bandwidth/2 - 10;
 406 
 407         return end_freq;
 408 }
 409 
 410 static int cfg80211_get_chans_dfs_required(struct wiphy *wiphy,
 411                                             u32 center_freq,
 412                                             u32 bandwidth)
 413 {
 414         struct ieee80211_channel *c;
 415         u32 freq, start_freq, end_freq;
 416 
 417         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 418         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 419 
 420         for (freq = start_freq; freq <= end_freq; freq += 20) {
 421                 c = ieee80211_get_channel(wiphy, freq);
 422                 if (!c)
 423                         return -EINVAL;
 424 
 425                 if (c->flags & IEEE80211_CHAN_RADAR)
 426                         return 1;
 427         }
 428         return 0;
 429 }
 430 
 431 
 432 int cfg80211_chandef_dfs_required(struct wiphy *wiphy,
 433                                   const struct cfg80211_chan_def *chandef,
 434                                   enum nl80211_iftype iftype)
 435 {
 436         int width;
 437         int ret;
 438 
 439         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 440                 return -EINVAL;
 441 
 442         switch (iftype) {
 443         case NL80211_IFTYPE_ADHOC:
 444         case NL80211_IFTYPE_AP:
 445         case NL80211_IFTYPE_P2P_GO:
 446         case NL80211_IFTYPE_MESH_POINT:
 447                 width = cfg80211_chandef_get_width(chandef);
 448                 if (width < 0)
 449                         return -EINVAL;
 450 
 451                 ret = cfg80211_get_chans_dfs_required(wiphy,
 452                                                       chandef->center_freq1,
 453                                                       width);
 454                 if (ret < 0)
 455                         return ret;
 456                 else if (ret > 0)
 457                         return BIT(chandef->width);
 458 
 459                 if (!chandef->center_freq2)
 460                         return 0;
 461 
 462                 ret = cfg80211_get_chans_dfs_required(wiphy,
 463                                                       chandef->center_freq2,
 464                                                       width);
 465                 if (ret < 0)
 466                         return ret;
 467                 else if (ret > 0)
 468                         return BIT(chandef->width);
 469 
 470                 break;
 471         case NL80211_IFTYPE_STATION:
 472         case NL80211_IFTYPE_OCB:
 473         case NL80211_IFTYPE_P2P_CLIENT:
 474         case NL80211_IFTYPE_MONITOR:
 475         case NL80211_IFTYPE_AP_VLAN:
 476         case NL80211_IFTYPE_WDS:
 477         case NL80211_IFTYPE_P2P_DEVICE:
 478         case NL80211_IFTYPE_NAN:
 479                 break;
 480         case NL80211_IFTYPE_UNSPECIFIED:
 481         case NUM_NL80211_IFTYPES:
 482                 WARN_ON(1);
 483         }
 484 
 485         return 0;
 486 }
 487 EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
 488 
 489 static int cfg80211_get_chans_dfs_usable(struct wiphy *wiphy,
 490                                          u32 center_freq,
 491                                          u32 bandwidth)
 492 {
 493         struct ieee80211_channel *c;
 494         u32 freq, start_freq, end_freq;
 495         int count = 0;
 496 
 497         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 498         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 499 
 500         /*
 501          * Check entire range of channels for the bandwidth.
 502          * Check all channels are DFS channels (DFS_USABLE or
 503          * DFS_AVAILABLE). Return number of usable channels
 504          * (require CAC). Allow DFS and non-DFS channel mix.
 505          */
 506         for (freq = start_freq; freq <= end_freq; freq += 20) {
 507                 c = ieee80211_get_channel(wiphy, freq);
 508                 if (!c)
 509                         return -EINVAL;
 510 
 511                 if (c->flags & IEEE80211_CHAN_DISABLED)
 512                         return -EINVAL;
 513 
 514                 if (c->flags & IEEE80211_CHAN_RADAR) {
 515                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
 516                                 return -EINVAL;
 517 
 518                         if (c->dfs_state == NL80211_DFS_USABLE)
 519                                 count++;
 520                 }
 521         }
 522 
 523         return count;
 524 }
 525 
 526 bool cfg80211_chandef_dfs_usable(struct wiphy *wiphy,
 527                                  const struct cfg80211_chan_def *chandef)
 528 {
 529         int width;
 530         int r1, r2 = 0;
 531 
 532         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 533                 return false;
 534 
 535         width = cfg80211_chandef_get_width(chandef);
 536         if (width < 0)
 537                 return false;
 538 
 539         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
 540                                           width);
 541 
 542         if (r1 < 0)
 543                 return false;
 544 
 545         switch (chandef->width) {
 546         case NL80211_CHAN_WIDTH_80P80:
 547                 WARN_ON(!chandef->center_freq2);
 548                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
 549                                                    chandef->center_freq2,
 550                                                    width);
 551                 if (r2 < 0)
 552                         return false;
 553                 break;
 554         default:
 555                 WARN_ON(chandef->center_freq2);
 556                 break;
 557         }
 558 
 559         return (r1 + r2 > 0);
 560 }
 561 
 562 /*
 563  * Checks if center frequency of chan falls with in the bandwidth
 564  * range of chandef.
 565  */
 566 bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
 567                           struct ieee80211_channel *chan)
 568 {
 569         int width;
 570         u32 freq;
 571 
 572         if (chandef->chan->center_freq == chan->center_freq)
 573                 return true;
 574 
 575         width = cfg80211_chandef_get_width(chandef);
 576         if (width <= 20)
 577                 return false;
 578 
 579         for (freq = chandef->center_freq1 - width / 2 + 10;
 580              freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
 581                 if (chan->center_freq == freq)
 582                         return true;
 583         }
 584 
 585         if (!chandef->center_freq2)
 586                 return false;
 587 
 588         for (freq = chandef->center_freq2 - width / 2 + 10;
 589              freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
 590                 if (chan->center_freq == freq)
 591                         return true;
 592         }
 593 
 594         return false;
 595 }
 596 
 597 bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
 598 {
 599         bool active = false;
 600 
 601         ASSERT_WDEV_LOCK(wdev);
 602 
 603         if (!wdev->chandef.chan)
 604                 return false;
 605 
 606         switch (wdev->iftype) {
 607         case NL80211_IFTYPE_AP:
 608         case NL80211_IFTYPE_P2P_GO:
 609                 active = wdev->beacon_interval != 0;
 610                 break;
 611         case NL80211_IFTYPE_ADHOC:
 612                 active = wdev->ssid_len != 0;
 613                 break;
 614         case NL80211_IFTYPE_MESH_POINT:
 615                 active = wdev->mesh_id_len != 0;
 616                 break;
 617         case NL80211_IFTYPE_STATION:
 618         case NL80211_IFTYPE_OCB:
 619         case NL80211_IFTYPE_P2P_CLIENT:
 620         case NL80211_IFTYPE_MONITOR:
 621         case NL80211_IFTYPE_AP_VLAN:
 622         case NL80211_IFTYPE_WDS:
 623         case NL80211_IFTYPE_P2P_DEVICE:
 624         /* Can NAN type be considered as beaconing interface? */
 625         case NL80211_IFTYPE_NAN:
 626                 break;
 627         case NL80211_IFTYPE_UNSPECIFIED:
 628         case NUM_NL80211_IFTYPES:
 629                 WARN_ON(1);
 630         }
 631 
 632         return active;
 633 }
 634 
 635 static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
 636                                         struct ieee80211_channel *chan)
 637 {
 638         struct wireless_dev *wdev;
 639 
 640         list_for_each_entry(wdev, &wiphy->wdev_list, list) {
 641                 wdev_lock(wdev);
 642                 if (!cfg80211_beaconing_iface_active(wdev)) {
 643                         wdev_unlock(wdev);
 644                         continue;
 645                 }
 646 
 647                 if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
 648                         wdev_unlock(wdev);
 649                         return true;
 650                 }
 651                 wdev_unlock(wdev);
 652         }
 653 
 654         return false;
 655 }
 656 
 657 bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
 658                                   struct ieee80211_channel *chan)
 659 {
 660         struct cfg80211_registered_device *rdev;
 661 
 662         ASSERT_RTNL();
 663 
 664         if (!(chan->flags & IEEE80211_CHAN_RADAR))
 665                 return false;
 666 
 667         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
 668                 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
 669                         continue;
 670 
 671                 if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
 672                         return true;
 673         }
 674 
 675         return false;
 676 }
 677 
 678 static bool cfg80211_get_chans_dfs_available(struct wiphy *wiphy,
 679                                              u32 center_freq,
 680                                              u32 bandwidth)
 681 {
 682         struct ieee80211_channel *c;
 683         u32 freq, start_freq, end_freq;
 684         bool dfs_offload;
 685 
 686         dfs_offload = wiphy_ext_feature_isset(wiphy,
 687                                               NL80211_EXT_FEATURE_DFS_OFFLOAD);
 688 
 689         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 690         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 691 
 692         /*
 693          * Check entire range of channels for the bandwidth.
 694          * If any channel in between is disabled or has not
 695          * had gone through CAC return false
 696          */
 697         for (freq = start_freq; freq <= end_freq; freq += 20) {
 698                 c = ieee80211_get_channel(wiphy, freq);
 699                 if (!c)
 700                         return false;
 701 
 702                 if (c->flags & IEEE80211_CHAN_DISABLED)
 703                         return false;
 704 
 705                 if ((c->flags & IEEE80211_CHAN_RADAR) &&
 706                     (c->dfs_state != NL80211_DFS_AVAILABLE) &&
 707                     !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
 708                         return false;
 709         }
 710 
 711         return true;
 712 }
 713 
 714 static bool cfg80211_chandef_dfs_available(struct wiphy *wiphy,
 715                                 const struct cfg80211_chan_def *chandef)
 716 {
 717         int width;
 718         int r;
 719 
 720         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 721                 return false;
 722 
 723         width = cfg80211_chandef_get_width(chandef);
 724         if (width < 0)
 725                 return false;
 726 
 727         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
 728                                              width);
 729 
 730         /* If any of channels unavailable for cf1 just return */
 731         if (!r)
 732                 return r;
 733 
 734         switch (chandef->width) {
 735         case NL80211_CHAN_WIDTH_80P80:
 736                 WARN_ON(!chandef->center_freq2);
 737                 r = cfg80211_get_chans_dfs_available(wiphy,
 738                                                      chandef->center_freq2,
 739                                                      width);
 740                 break;
 741         default:
 742                 WARN_ON(chandef->center_freq2);
 743                 break;
 744         }
 745 
 746         return r;
 747 }
 748 
 749 static unsigned int cfg80211_get_chans_dfs_cac_time(struct wiphy *wiphy,
 750                                                     u32 center_freq,
 751                                                     u32 bandwidth)
 752 {
 753         struct ieee80211_channel *c;
 754         u32 start_freq, end_freq, freq;
 755         unsigned int dfs_cac_ms = 0;
 756 
 757         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 758         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 759 
 760         for (freq = start_freq; freq <= end_freq; freq += 20) {
 761                 c = ieee80211_get_channel(wiphy, freq);
 762                 if (!c)
 763                         return 0;
 764 
 765                 if (c->flags & IEEE80211_CHAN_DISABLED)
 766                         return 0;
 767 
 768                 if (!(c->flags & IEEE80211_CHAN_RADAR))
 769                         continue;
 770 
 771                 if (c->dfs_cac_ms > dfs_cac_ms)
 772                         dfs_cac_ms = c->dfs_cac_ms;
 773         }
 774 
 775         return dfs_cac_ms;
 776 }
 777 
 778 unsigned int
 779 cfg80211_chandef_dfs_cac_time(struct wiphy *wiphy,
 780                               const struct cfg80211_chan_def *chandef)
 781 {
 782         int width;
 783         unsigned int t1 = 0, t2 = 0;
 784 
 785         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 786                 return 0;
 787 
 788         width = cfg80211_chandef_get_width(chandef);
 789         if (width < 0)
 790                 return 0;
 791 
 792         t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
 793                                              chandef->center_freq1,
 794                                              width);
 795 
 796         if (!chandef->center_freq2)
 797                 return t1;
 798 
 799         t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
 800                                              chandef->center_freq2,
 801                                              width);
 802 
 803         return max(t1, t2);
 804 }
 805 
 806 static bool cfg80211_secondary_chans_ok(struct wiphy *wiphy,
 807                                         u32 center_freq, u32 bandwidth,
 808                                         u32 prohibited_flags)
 809 {
 810         struct ieee80211_channel *c;
 811         u32 freq, start_freq, end_freq;
 812 
 813         start_freq = cfg80211_get_start_freq(center_freq, bandwidth);
 814         end_freq = cfg80211_get_end_freq(center_freq, bandwidth);
 815 
 816         for (freq = start_freq; freq <= end_freq; freq += 20) {
 817                 c = ieee80211_get_channel(wiphy, freq);
 818                 if (!c || c->flags & prohibited_flags)
 819                         return false;
 820         }
 821 
 822         return true;
 823 }
 824 
 825 /* check if the operating channels are valid and supported */
 826 static bool cfg80211_edmg_usable(struct wiphy *wiphy, u8 edmg_channels,
 827                                  enum ieee80211_edmg_bw_config edmg_bw_config,
 828                                  int primary_channel,
 829                                  struct ieee80211_edmg *edmg_cap)
 830 {
 831         struct ieee80211_channel *chan;
 832         int i, freq;
 833         int channels_counter = 0;
 834 
 835         if (!edmg_channels && !edmg_bw_config)
 836                 return true;
 837 
 838         if ((!edmg_channels && edmg_bw_config) ||
 839             (edmg_channels && !edmg_bw_config))
 840                 return false;
 841 
 842         if (!(edmg_channels & BIT(primary_channel - 1)))
 843                 return false;
 844 
 845         /* 60GHz channels 1..6 */
 846         for (i = 0; i < 6; i++) {
 847                 if (!(edmg_channels & BIT(i)))
 848                         continue;
 849 
 850                 if (!(edmg_cap->channels & BIT(i)))
 851                         return false;
 852 
 853                 channels_counter++;
 854 
 855                 freq = ieee80211_channel_to_frequency(i + 1,
 856                                                       NL80211_BAND_60GHZ);
 857                 chan = ieee80211_get_channel(wiphy, freq);
 858                 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
 859                         return false;
 860         }
 861 
 862         /* IEEE802.11 allows max 4 channels */
 863         if (channels_counter > 4)
 864                 return false;
 865 
 866         /* check bw_config is a subset of what driver supports
 867          * (see IEEE P802.11ay/D4.0 section 9.4.2.251, Table 13)
 868          */
 869         if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
 870                 return false;
 871 
 872         if (edmg_bw_config > edmg_cap->bw_config)
 873                 return false;
 874 
 875         return true;
 876 }
 877 
 878 bool cfg80211_chandef_usable(struct wiphy *wiphy,
 879                              const struct cfg80211_chan_def *chandef,
 880                              u32 prohibited_flags)
 881 {
 882         struct ieee80211_sta_ht_cap *ht_cap;
 883         struct ieee80211_sta_vht_cap *vht_cap;
 884         struct ieee80211_edmg *edmg_cap;
 885         u32 width, control_freq, cap;
 886 
 887         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
 888                 return false;
 889 
 890         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
 891         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
 892         edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
 893 
 894         if (edmg_cap->channels &&
 895             !cfg80211_edmg_usable(wiphy,
 896                                   chandef->edmg.channels,
 897                                   chandef->edmg.bw_config,
 898                                   chandef->chan->hw_value,
 899                                   edmg_cap))
 900                 return false;
 901 
 902         control_freq = chandef->chan->center_freq;
 903 
 904         switch (chandef->width) {
 905         case NL80211_CHAN_WIDTH_5:
 906                 width = 5;
 907                 break;
 908         case NL80211_CHAN_WIDTH_10:
 909                 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
 910                 width = 10;
 911                 break;
 912         case NL80211_CHAN_WIDTH_20:
 913                 if (!ht_cap->ht_supported)
 914                         return false;
 915                 /* fall through */
 916         case NL80211_CHAN_WIDTH_20_NOHT:
 917                 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
 918                 width = 20;
 919                 break;
 920         case NL80211_CHAN_WIDTH_40:
 921                 width = 40;
 922                 if (!ht_cap->ht_supported)
 923                         return false;
 924                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
 925                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
 926                         return false;
 927                 if (chandef->center_freq1 < control_freq &&
 928                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
 929                         return false;
 930                 if (chandef->center_freq1 > control_freq &&
 931                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
 932                         return false;
 933                 break;
 934         case NL80211_CHAN_WIDTH_80P80:
 935                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 936                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 937                         return false;
 938                 /* fall through */
 939         case NL80211_CHAN_WIDTH_80:
 940                 if (!vht_cap->vht_supported)
 941                         return false;
 942                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
 943                 width = 80;
 944                 break;
 945         case NL80211_CHAN_WIDTH_160:
 946                 if (!vht_cap->vht_supported)
 947                         return false;
 948                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
 949                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
 950                     cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
 951                         return false;
 952                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
 953                 width = 160;
 954                 break;
 955         default:
 956                 WARN_ON_ONCE(1);
 957                 return false;
 958         }
 959 
 960         /*
 961          * TODO: What if there are only certain 80/160/80+80 MHz channels
 962          *       allowed by the driver, or only certain combinations?
 963          *       For 40 MHz the driver can set the NO_HT40 flags, but for
 964          *       80/160 MHz and in particular 80+80 MHz this isn't really
 965          *       feasible and we only have NO_80MHZ/NO_160MHZ so far but
 966          *       no way to cover 80+80 MHz or more complex restrictions.
 967          *       Note that such restrictions also need to be advertised to
 968          *       userspace, for example for P2P channel selection.
 969          */
 970 
 971         if (width > 20)
 972                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 973 
 974         /* 5 and 10 MHz are only defined for the OFDM PHY */
 975         if (width < 20)
 976                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
 977 
 978 
 979         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
 980                                          width, prohibited_flags))
 981                 return false;
 982 
 983         if (!chandef->center_freq2)
 984                 return true;
 985         return cfg80211_secondary_chans_ok(wiphy, chandef->center_freq2,
 986                                            width, prohibited_flags);
 987 }
 988 EXPORT_SYMBOL(cfg80211_chandef_usable);
 989 
 990 /*
 991  * Check if the channel can be used under permissive conditions mandated by
 992  * some regulatory bodies, i.e., the channel is marked with
 993  * IEEE80211_CHAN_IR_CONCURRENT and there is an additional station interface
 994  * associated to an AP on the same channel or on the same UNII band
 995  * (assuming that the AP is an authorized master).
 996  * In addition allow operation on a channel on which indoor operation is
 997  * allowed, iff we are currently operating in an indoor environment.
 998  */
 999 static bool cfg80211_ir_permissive_chan(struct wiphy *wiphy,
1000                                         enum nl80211_iftype iftype,
1001                                         struct ieee80211_channel *chan)
1002 {
1003         struct wireless_dev *wdev;
1004         struct cfg80211_registered_device *rdev = wiphy_to_rdev(wiphy);
1005 
1006         ASSERT_RTNL();
1007 
1008         if (!IS_ENABLED(CONFIG_CFG80211_REG_RELAX_NO_IR) ||
1009             !(wiphy->regulatory_flags & REGULATORY_ENABLE_RELAX_NO_IR))
1010                 return false;
1011 
1012         /* only valid for GO and TDLS off-channel (station/p2p-CL) */
1013         if (iftype != NL80211_IFTYPE_P2P_GO &&
1014             iftype != NL80211_IFTYPE_STATION &&
1015             iftype != NL80211_IFTYPE_P2P_CLIENT)
1016                 return false;
1017 
1018         if (regulatory_indoor_allowed() &&
1019             (chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1020                 return true;
1021 
1022         if (!(chan->flags & IEEE80211_CHAN_IR_CONCURRENT))
1023                 return false;
1024 
1025         /*
1026          * Generally, it is possible to rely on another device/driver to allow
1027          * the IR concurrent relaxation, however, since the device can further
1028          * enforce the relaxation (by doing a similar verifications as this),
1029          * and thus fail the GO instantiation, consider only the interfaces of
1030          * the current registered device.
1031          */
1032         list_for_each_entry(wdev, &rdev->wiphy.wdev_list, list) {
1033                 struct ieee80211_channel *other_chan = NULL;
1034                 int r1, r2;
1035 
1036                 wdev_lock(wdev);
1037                 if (wdev->iftype == NL80211_IFTYPE_STATION &&
1038                     wdev->current_bss)
1039                         other_chan = wdev->current_bss->pub.channel;
1040 
1041                 /*
1042                  * If a GO already operates on the same GO_CONCURRENT channel,
1043                  * this one (maybe the same one) can beacon as well. We allow
1044                  * the operation even if the station we relied on with
1045                  * GO_CONCURRENT is disconnected now. But then we must make sure
1046                  * we're not outdoor on an indoor-only channel.
1047                  */
1048                 if (iftype == NL80211_IFTYPE_P2P_GO &&
1049                     wdev->iftype == NL80211_IFTYPE_P2P_GO &&
1050                     wdev->beacon_interval &&
1051                     !(chan->flags & IEEE80211_CHAN_INDOOR_ONLY))
1052                         other_chan = wdev->chandef.chan;
1053                 wdev_unlock(wdev);
1054 
1055                 if (!other_chan)
1056                         continue;
1057 
1058                 if (chan == other_chan)
1059                         return true;
1060 
1061                 if (chan->band != NL80211_BAND_5GHZ &&
1062                     chan->band != NL80211_BAND_6GHZ)
1063                         continue;
1064 
1065                 r1 = cfg80211_get_unii(chan->center_freq);
1066                 r2 = cfg80211_get_unii(other_chan->center_freq);
1067 
1068                 if (r1 != -EINVAL && r1 == r2) {
1069                         /*
1070                          * At some locations channels 149-165 are considered a
1071                          * bundle, but at other locations, e.g., Indonesia,
1072                          * channels 149-161 are considered a bundle while
1073                          * channel 165 is left out and considered to be in a
1074                          * different bundle. Thus, in case that there is a
1075                          * station interface connected to an AP on channel 165,
1076                          * it is assumed that channels 149-161 are allowed for
1077                          * GO operations. However, having a station interface
1078                          * connected to an AP on channels 149-161, does not
1079                          * allow GO operation on channel 165.
1080                          */
1081                         if (chan->center_freq == 5825 &&
1082                             other_chan->center_freq != 5825)
1083                                 continue;
1084                         return true;
1085                 }
1086         }
1087 
1088         return false;
1089 }
1090 
1091 static bool _cfg80211_reg_can_beacon(struct wiphy *wiphy,
1092                                      struct cfg80211_chan_def *chandef,
1093                                      enum nl80211_iftype iftype,
1094                                      bool check_no_ir)
1095 {
1096         bool res;
1097         u32 prohibited_flags = IEEE80211_CHAN_DISABLED |
1098                                IEEE80211_CHAN_RADAR;
1099 
1100         trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1101 
1102         if (check_no_ir)
1103                 prohibited_flags |= IEEE80211_CHAN_NO_IR;
1104 
1105         if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
1106             cfg80211_chandef_dfs_available(wiphy, chandef)) {
1107                 /* We can skip IEEE80211_CHAN_NO_IR if chandef dfs available */
1108                 prohibited_flags = IEEE80211_CHAN_DISABLED;
1109         }
1110 
1111         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
1112 
1113         trace_cfg80211_return_bool(res);
1114         return res;
1115 }
1116 
1117 bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
1118                              struct cfg80211_chan_def *chandef,
1119                              enum nl80211_iftype iftype)
1120 {
1121         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
1122 }
1123 EXPORT_SYMBOL(cfg80211_reg_can_beacon);
1124 
1125 bool cfg80211_reg_can_beacon_relax(struct wiphy *wiphy,
1126                                    struct cfg80211_chan_def *chandef,
1127                                    enum nl80211_iftype iftype)
1128 {
1129         bool check_no_ir;
1130 
1131         ASSERT_RTNL();
1132 
1133         /*
1134          * Under certain conditions suggested by some regulatory bodies a
1135          * GO/STA can IR on channels marked with IEEE80211_NO_IR. Set this flag
1136          * only if such relaxations are not enabled and the conditions are not
1137          * met.
1138          */
1139         check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
1140                                                    chandef->chan);
1141 
1142         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
1143 }
1144 EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
1145 
1146 int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
1147                                  struct cfg80211_chan_def *chandef)
1148 {
1149         if (!rdev->ops->set_monitor_channel)
1150                 return -EOPNOTSUPP;
1151         if (!cfg80211_has_monitors_only(rdev))
1152                 return -EBUSY;
1153 
1154         return rdev_set_monitor_channel(rdev, chandef);
1155 }
1156 
1157 void
1158 cfg80211_get_chan_state(struct wireless_dev *wdev,
1159                         struct ieee80211_channel **chan,
1160                         enum cfg80211_chan_mode *chanmode,
1161                         u8 *radar_detect)
1162 {
1163         int ret;
1164 
1165         *chan = NULL;
1166         *chanmode = CHAN_MODE_UNDEFINED;
1167 
1168         ASSERT_WDEV_LOCK(wdev);
1169 
1170         if (wdev->netdev && !netif_running(wdev->netdev))
1171                 return;
1172 
1173         switch (wdev->iftype) {
1174         case NL80211_IFTYPE_ADHOC:
1175                 if (wdev->current_bss) {
1176                         *chan = wdev->current_bss->pub.channel;
1177                         *chanmode = (wdev->ibss_fixed &&
1178                                      !wdev->ibss_dfs_possible)
1179                                   ? CHAN_MODE_SHARED
1180                                   : CHAN_MODE_EXCLUSIVE;
1181 
1182                         /* consider worst-case - IBSS can try to return to the
1183                          * original user-specified channel as creator */
1184                         if (wdev->ibss_dfs_possible)
1185                                 *radar_detect |= BIT(wdev->chandef.width);
1186                         return;
1187                 }
1188                 break;
1189         case NL80211_IFTYPE_STATION:
1190         case NL80211_IFTYPE_P2P_CLIENT:
1191                 if (wdev->current_bss) {
1192                         *chan = wdev->current_bss->pub.channel;
1193                         *chanmode = CHAN_MODE_SHARED;
1194                         return;
1195                 }
1196                 break;
1197         case NL80211_IFTYPE_AP:
1198         case NL80211_IFTYPE_P2P_GO:
1199                 if (wdev->cac_started) {
1200                         *chan = wdev->chandef.chan;
1201                         *chanmode = CHAN_MODE_SHARED;
1202                         *radar_detect |= BIT(wdev->chandef.width);
1203                 } else if (wdev->beacon_interval) {
1204                         *chan = wdev->chandef.chan;
1205                         *chanmode = CHAN_MODE_SHARED;
1206 
1207                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1208                                                             &wdev->chandef,
1209                                                             wdev->iftype);
1210                         WARN_ON(ret < 0);
1211                         if (ret > 0)
1212                                 *radar_detect |= BIT(wdev->chandef.width);
1213                 }
1214                 return;
1215         case NL80211_IFTYPE_MESH_POINT:
1216                 if (wdev->mesh_id_len) {
1217                         *chan = wdev->chandef.chan;
1218                         *chanmode = CHAN_MODE_SHARED;
1219 
1220                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
1221                                                             &wdev->chandef,
1222                                                             wdev->iftype);
1223                         WARN_ON(ret < 0);
1224                         if (ret > 0)
1225                                 *radar_detect |= BIT(wdev->chandef.width);
1226                 }
1227                 return;
1228         case NL80211_IFTYPE_OCB:
1229                 if (wdev->chandef.chan) {
1230                         *chan = wdev->chandef.chan;
1231                         *chanmode = CHAN_MODE_SHARED;
1232                         return;
1233                 }
1234                 break;
1235         case NL80211_IFTYPE_MONITOR:
1236         case NL80211_IFTYPE_AP_VLAN:
1237         case NL80211_IFTYPE_WDS:
1238         case NL80211_IFTYPE_P2P_DEVICE:
1239         case NL80211_IFTYPE_NAN:
1240                 /* these interface types don't really have a channel */
1241                 return;
1242         case NL80211_IFTYPE_UNSPECIFIED:
1243         case NUM_NL80211_IFTYPES:
1244                 WARN_ON(1);
1245         }
1246 }
/* [<][>][^][v][top][bottom][index][help] */
root/net/wireless/chan.c

DEFINITIONS
