LCOV - code coverage report
Current view: top level - net/wireless - chan.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 371 0.0 %
Date: 2020-10-17 15:46:16 Functions: 0 29 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       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                 :          0 :         return freq >= 58320 && freq <= 70200;
      20                 :            : }
      21                 :            : 
      22                 :          0 : void cfg80211_chandef_create(struct cfg80211_chan_def *chandef,
      23                 :            :                              struct ieee80211_channel *chan,
      24                 :            :                              enum nl80211_channel_type chan_type)
      25                 :            : {
      26                 :          0 :         if (WARN_ON(!chan))
      27                 :          0 :                 return;
      28                 :            : 
      29                 :          0 :         chandef->chan = chan;
      30                 :          0 :         chandef->center_freq2 = 0;
      31                 :          0 :         chandef->edmg.bw_config = 0;
      32                 :          0 :         chandef->edmg.channels = 0;
      33                 :            : 
      34                 :          0 :         switch (chan_type) {
      35                 :            :         case NL80211_CHAN_NO_HT:
      36                 :          0 :                 chandef->width = NL80211_CHAN_WIDTH_20_NOHT;
      37                 :          0 :                 chandef->center_freq1 = chan->center_freq;
      38                 :          0 :                 break;
      39                 :            :         case NL80211_CHAN_HT20:
      40                 :          0 :                 chandef->width = NL80211_CHAN_WIDTH_20;
      41                 :          0 :                 chandef->center_freq1 = chan->center_freq;
      42                 :          0 :                 break;
      43                 :            :         case NL80211_CHAN_HT40PLUS:
      44                 :          0 :                 chandef->width = NL80211_CHAN_WIDTH_40;
      45                 :          0 :                 chandef->center_freq1 = chan->center_freq + 10;
      46                 :          0 :                 break;
      47                 :            :         case NL80211_CHAN_HT40MINUS:
      48                 :          0 :                 chandef->width = NL80211_CHAN_WIDTH_40;
      49                 :          0 :                 chandef->center_freq1 = chan->center_freq - 10;
      50                 :          0 :                 break;
      51                 :            :         default:
      52                 :          0 :                 WARN_ON(1);
      53                 :            :         }
      54                 :            : }
      55                 :            : EXPORT_SYMBOL(cfg80211_chandef_create);
      56                 :            : 
      57                 :          0 : 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                 :          0 :         if (!chandef->edmg.channels || !chandef->edmg.bw_config)
      65                 :            :                 return false;
      66                 :            : 
      67                 :          0 :         if (!cfg80211_valid_60g_freq(chandef->chan->center_freq))
      68                 :            :                 return false;
      69                 :            : 
      70                 :          0 :         for (i = 0; i < 6; i++) {
      71                 :          0 :                 if (chandef->edmg.channels & BIT(i)) {
      72                 :          0 :                         contiguous++;
      73                 :          0 :                         num_of_enabled++;
      74                 :            :                 } else {
      75                 :            :                         contiguous = 0;
      76                 :            :                 }
      77                 :            : 
      78                 :          0 :                 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                 :          0 :         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                 :          0 :                 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                 :          0 :                 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                 :          0 :                 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                 :          0 :                 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                 :          0 :         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                 :          0 :                 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                 :          0 :                 if (num_of_enabled < 4 || max_contiguous < 2)
     133                 :            :                         return false;
     134                 :            :                 break;
     135                 :            :         default:
     136                 :            :                 return false;
     137                 :            :         }
     138                 :            : 
     139                 :          0 :         return true;
     140                 :            : }
     141                 :            : 
     142                 :          0 : bool cfg80211_chandef_valid(const struct cfg80211_chan_def *chandef)
     143                 :            : {
     144                 :            :         u32 control_freq;
     145                 :            : 
     146                 :          0 :         if (!chandef->chan)
     147                 :            :                 return false;
     148                 :            : 
     149                 :          0 :         control_freq = chandef->chan->center_freq;
     150                 :            : 
     151                 :          0 :         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                 :          0 :                 if (chandef->center_freq1 != control_freq)
     157                 :            :                         return false;
     158                 :          0 :                 if (chandef->center_freq2)
     159                 :            :                         return false;
     160                 :            :                 break;
     161                 :            :         case NL80211_CHAN_WIDTH_40:
     162                 :          0 :                 if (chandef->center_freq1 != control_freq + 10 &&
     163                 :          0 :                     chandef->center_freq1 != control_freq - 10)
     164                 :            :                         return false;
     165                 :          0 :                 if (chandef->center_freq2)
     166                 :            :                         return false;
     167                 :            :                 break;
     168                 :            :         case NL80211_CHAN_WIDTH_80P80:
     169                 :          0 :                 if (chandef->center_freq1 != control_freq + 30 &&
     170                 :          0 :                     chandef->center_freq1 != control_freq + 10 &&
     171                 :          0 :                     chandef->center_freq1 != control_freq - 10 &&
     172                 :          0 :                     chandef->center_freq1 != control_freq - 30)
     173                 :            :                         return false;
     174                 :          0 :                 if (!chandef->center_freq2)
     175                 :            :                         return false;
     176                 :            :                 /* adjacent is not allowed -- that's a 160 MHz channel */
     177                 :          0 :                 if (chandef->center_freq1 - chandef->center_freq2 == 80 ||
     178                 :          0 :                     chandef->center_freq2 - chandef->center_freq1 == 80)
     179                 :            :                         return false;
     180                 :            :                 break;
     181                 :            :         case NL80211_CHAN_WIDTH_80:
     182                 :          0 :                 if (chandef->center_freq1 != control_freq + 30 &&
     183                 :          0 :                     chandef->center_freq1 != control_freq + 10 &&
     184                 :          0 :                     chandef->center_freq1 != control_freq - 10 &&
     185                 :          0 :                     chandef->center_freq1 != control_freq - 30)
     186                 :            :                         return false;
     187                 :          0 :                 if (chandef->center_freq2)
     188                 :            :                         return false;
     189                 :            :                 break;
     190                 :            :         case NL80211_CHAN_WIDTH_160:
     191                 :          0 :                 if (chandef->center_freq1 != control_freq + 70 &&
     192                 :          0 :                     chandef->center_freq1 != control_freq + 50 &&
     193                 :          0 :                     chandef->center_freq1 != control_freq + 30 &&
     194                 :          0 :                     chandef->center_freq1 != control_freq + 10 &&
     195                 :          0 :                     chandef->center_freq1 != control_freq - 10 &&
     196                 :          0 :                     chandef->center_freq1 != control_freq - 30 &&
     197                 :          0 :                     chandef->center_freq1 != control_freq - 50 &&
     198                 :          0 :                     chandef->center_freq1 != control_freq - 70)
     199                 :            :                         return false;
     200                 :          0 :                 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                 :          0 :         if (chandef->center_freq1 == 2484 &&
     209                 :            :             chandef->width != NL80211_CHAN_WIDTH_20_NOHT)
     210                 :            :                 return false;
     211                 :            : 
     212                 :          0 :         if (cfg80211_chandef_is_edmg(chandef) &&
     213                 :          0 :             !cfg80211_edmg_chandef_valid(chandef))
     214                 :            :                 return false;
     215                 :            : 
     216                 :          0 :         return true;
     217                 :            : }
     218                 :            : EXPORT_SYMBOL(cfg80211_chandef_valid);
     219                 :            : 
     220                 :          0 : static void chandef_primary_freqs(const struct cfg80211_chan_def *c,
     221                 :            :                                   u32 *pri40, u32 *pri80)
     222                 :            : {
     223                 :            :         int tmp;
     224                 :            : 
     225                 :          0 :         switch (c->width) {
     226                 :            :         case NL80211_CHAN_WIDTH_40:
     227                 :          0 :                 *pri40 = c->center_freq1;
     228                 :          0 :                 *pri80 = 0;
     229                 :          0 :                 break;
     230                 :            :         case NL80211_CHAN_WIDTH_80:
     231                 :            :         case NL80211_CHAN_WIDTH_80P80:
     232                 :          0 :                 *pri80 = c->center_freq1;
     233                 :            :                 /* n_P20 */
     234                 :          0 :                 tmp = (30 + c->chan->center_freq - c->center_freq1)/20;
     235                 :            :                 /* n_P40 */
     236                 :          0 :                 tmp /= 2;
     237                 :            :                 /* freq_P40 */
     238                 :          0 :                 *pri40 = c->center_freq1 - 20 + 40 * tmp;
     239                 :          0 :                 break;
     240                 :            :         case NL80211_CHAN_WIDTH_160:
     241                 :            :                 /* n_P20 */
     242                 :          0 :                 tmp = (70 + c->chan->center_freq - c->center_freq1)/20;
     243                 :            :                 /* n_P40 */
     244                 :          0 :                 tmp /= 2;
     245                 :            :                 /* freq_P40 */
     246                 :          0 :                 *pri40 = c->center_freq1 - 60 + 40 * tmp;
     247                 :            :                 /* n_P80 */
     248                 :          0 :                 tmp /= 2;
     249                 :          0 :                 *pri80 = c->center_freq1 - 40 + 80 * tmp;
     250                 :          0 :                 break;
     251                 :            :         default:
     252                 :          0 :                 WARN_ON_ONCE(1);
     253                 :            :         }
     254                 :          0 : }
     255                 :            : 
     256                 :          0 : static int cfg80211_chandef_get_width(const struct cfg80211_chan_def *c)
     257                 :            : {
     258                 :            :         int width;
     259                 :            : 
     260                 :          0 :         switch (c->width) {
     261                 :            :         case NL80211_CHAN_WIDTH_5:
     262                 :            :                 width = 5;
     263                 :            :                 break;
     264                 :            :         case NL80211_CHAN_WIDTH_10:
     265                 :            :                 width = 10;
     266                 :          0 :                 break;
     267                 :            :         case NL80211_CHAN_WIDTH_20:
     268                 :            :         case NL80211_CHAN_WIDTH_20_NOHT:
     269                 :            :                 width = 20;
     270                 :          0 :                 break;
     271                 :            :         case NL80211_CHAN_WIDTH_40:
     272                 :            :                 width = 40;
     273                 :          0 :                 break;
     274                 :            :         case NL80211_CHAN_WIDTH_80P80:
     275                 :            :         case NL80211_CHAN_WIDTH_80:
     276                 :            :                 width = 80;
     277                 :          0 :                 break;
     278                 :            :         case NL80211_CHAN_WIDTH_160:
     279                 :            :                 width = 160;
     280                 :          0 :                 break;
     281                 :            :         default:
     282                 :          0 :                 WARN_ON_ONCE(1);
     283                 :            :                 return -1;
     284                 :            :         }
     285                 :          0 :         return width;
     286                 :            : }
     287                 :            : 
     288                 :            : const struct cfg80211_chan_def *
     289                 :          0 : 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                 :          0 :         if (cfg80211_chandef_identical(c1, c2))
     296                 :            :                 return c1;
     297                 :            : 
     298                 :            :         /* otherwise, must have same control channel */
     299                 :          0 :         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                 :          0 :         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                 :          0 :         if (c1->width == NL80211_CHAN_WIDTH_5 ||
     314                 :          0 :             c1->width == NL80211_CHAN_WIDTH_10 ||
     315                 :          0 :             c2->width == NL80211_CHAN_WIDTH_5 ||
     316                 :            :             c2->width == NL80211_CHAN_WIDTH_10)
     317                 :            :                 return NULL;
     318                 :            : 
     319                 :          0 :         if (c1->width == NL80211_CHAN_WIDTH_20_NOHT ||
     320                 :            :             c1->width == NL80211_CHAN_WIDTH_20)
     321                 :            :                 return c2;
     322                 :            : 
     323                 :          0 :         if (c2->width == NL80211_CHAN_WIDTH_20_NOHT ||
     324                 :            :             c2->width == NL80211_CHAN_WIDTH_20)
     325                 :            :                 return c1;
     326                 :            : 
     327                 :          0 :         chandef_primary_freqs(c1, &c1_pri40, &c1_pri80);
     328                 :          0 :         chandef_primary_freqs(c2, &c2_pri40, &c2_pri80);
     329                 :            : 
     330                 :          0 :         if (c1_pri40 != c2_pri40)
     331                 :            :                 return NULL;
     332                 :            : 
     333                 :          0 :         WARN_ON(!c1_pri80 && !c2_pri80);
     334                 :          0 :         if (c1_pri80 && c2_pri80 && c1_pri80 != c2_pri80)
     335                 :            :                 return NULL;
     336                 :            : 
     337                 :          0 :         if (c1->width > c2->width)
     338                 :            :                 return c1;
     339                 :          0 :         return c2;
     340                 :            : }
     341                 :            : EXPORT_SYMBOL(cfg80211_chandef_compatible);
     342                 :            : 
     343                 :          0 : 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                 :          0 :         for (freq = center_freq - bandwidth/2 + 10;
     351                 :          0 :              freq <= center_freq + bandwidth/2 - 10;
     352                 :          0 :              freq += 20) {
     353                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     354                 :          0 :                 if (!c || !(c->flags & IEEE80211_CHAN_RADAR))
     355                 :          0 :                         continue;
     356                 :            : 
     357                 :          0 :                 c->dfs_state = dfs_state;
     358                 :          0 :                 c->dfs_state_entered = jiffies;
     359                 :            :         }
     360                 :          0 : }
     361                 :            : 
     362                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     369                 :            :                 return;
     370                 :            : 
     371                 :          0 :         width = cfg80211_chandef_get_width(chandef);
     372                 :          0 :         if (width < 0)
     373                 :            :                 return;
     374                 :            : 
     375                 :          0 :         cfg80211_set_chans_dfs_state(wiphy, chandef->center_freq1,
     376                 :            :                                      width, dfs_state);
     377                 :            : 
     378                 :          0 :         if (!chandef->center_freq2)
     379                 :            :                 return;
     380                 :          0 :         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                 :          0 :         if (bandwidth <= 20)
     390                 :            :                 start_freq = center_freq;
     391                 :            :         else
     392                 :          0 :                 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                 :          0 :         if (bandwidth <= 20)
     403                 :            :                 end_freq = center_freq;
     404                 :            :         else
     405                 :          0 :                 end_freq = center_freq + bandwidth/2 - 10;
     406                 :            : 
     407                 :            :         return end_freq;
     408                 :            : }
     409                 :            : 
     410                 :          0 : 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                 :          0 :         for (freq = start_freq; freq <= end_freq; freq += 20) {
     421                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     422                 :          0 :                 if (!c)
     423                 :            :                         return -EINVAL;
     424                 :            : 
     425                 :          0 :                 if (c->flags & IEEE80211_CHAN_RADAR)
     426                 :            :                         return 1;
     427                 :            :         }
     428                 :            :         return 0;
     429                 :            : }
     430                 :            : 
     431                 :            : 
     432                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     440                 :            :                 return -EINVAL;
     441                 :            : 
     442                 :          0 :         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                 :          0 :                 width = cfg80211_chandef_get_width(chandef);
     448                 :          0 :                 if (width < 0)
     449                 :            :                         return -EINVAL;
     450                 :            : 
     451                 :          0 :                 ret = cfg80211_get_chans_dfs_required(wiphy,
     452                 :            :                                                       chandef->center_freq1,
     453                 :            :                                                       width);
     454                 :          0 :                 if (ret < 0)
     455                 :            :                         return ret;
     456                 :          0 :                 else if (ret > 0)
     457                 :          0 :                         return BIT(chandef->width);
     458                 :            : 
     459                 :          0 :                 if (!chandef->center_freq2)
     460                 :            :                         return 0;
     461                 :            : 
     462                 :          0 :                 ret = cfg80211_get_chans_dfs_required(wiphy,
     463                 :            :                                                       chandef->center_freq2,
     464                 :            :                                                       width);
     465                 :          0 :                 if (ret < 0)
     466                 :            :                         return ret;
     467                 :          0 :                 else if (ret > 0)
     468                 :          0 :                         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                 :          0 :                 WARN_ON(1);
     483                 :            :         }
     484                 :            : 
     485                 :            :         return 0;
     486                 :            : }
     487                 :            : EXPORT_SYMBOL(cfg80211_chandef_dfs_required);
     488                 :            : 
     489                 :          0 : 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                 :          0 :         for (freq = start_freq; freq <= end_freq; freq += 20) {
     507                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     508                 :          0 :                 if (!c)
     509                 :            :                         return -EINVAL;
     510                 :            : 
     511                 :          0 :                 if (c->flags & IEEE80211_CHAN_DISABLED)
     512                 :            :                         return -EINVAL;
     513                 :            : 
     514                 :          0 :                 if (c->flags & IEEE80211_CHAN_RADAR) {
     515                 :          0 :                         if (c->dfs_state == NL80211_DFS_UNAVAILABLE)
     516                 :            :                                 return -EINVAL;
     517                 :            : 
     518                 :          0 :                         if (c->dfs_state == NL80211_DFS_USABLE)
     519                 :          0 :                                 count++;
     520                 :            :                 }
     521                 :            :         }
     522                 :            : 
     523                 :          0 :         return count;
     524                 :            : }
     525                 :            : 
     526                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     533                 :            :                 return false;
     534                 :            : 
     535                 :          0 :         width = cfg80211_chandef_get_width(chandef);
     536                 :          0 :         if (width < 0)
     537                 :            :                 return false;
     538                 :            : 
     539                 :          0 :         r1 = cfg80211_get_chans_dfs_usable(wiphy, chandef->center_freq1,
     540                 :            :                                           width);
     541                 :            : 
     542                 :          0 :         if (r1 < 0)
     543                 :            :                 return false;
     544                 :            : 
     545                 :          0 :         switch (chandef->width) {
     546                 :            :         case NL80211_CHAN_WIDTH_80P80:
     547                 :          0 :                 WARN_ON(!chandef->center_freq2);
     548                 :          0 :                 r2 = cfg80211_get_chans_dfs_usable(wiphy,
     549                 :            :                                                    chandef->center_freq2,
     550                 :            :                                                    width);
     551                 :          0 :                 if (r2 < 0)
     552                 :            :                         return false;
     553                 :            :                 break;
     554                 :            :         default:
     555                 :          0 :                 WARN_ON(chandef->center_freq2);
     556                 :            :                 break;
     557                 :            :         }
     558                 :            : 
     559                 :          0 :         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                 :          0 : bool cfg80211_is_sub_chan(struct cfg80211_chan_def *chandef,
     567                 :            :                           struct ieee80211_channel *chan)
     568                 :            : {
     569                 :            :         int width;
     570                 :            :         u32 freq;
     571                 :            : 
     572                 :          0 :         if (chandef->chan->center_freq == chan->center_freq)
     573                 :            :                 return true;
     574                 :            : 
     575                 :          0 :         width = cfg80211_chandef_get_width(chandef);
     576                 :          0 :         if (width <= 20)
     577                 :            :                 return false;
     578                 :            : 
     579                 :          0 :         for (freq = chandef->center_freq1 - width / 2 + 10;
     580                 :          0 :              freq <= chandef->center_freq1 + width / 2 - 10; freq += 20) {
     581                 :          0 :                 if (chan->center_freq == freq)
     582                 :            :                         return true;
     583                 :            :         }
     584                 :            : 
     585                 :          0 :         if (!chandef->center_freq2)
     586                 :            :                 return false;
     587                 :            : 
     588                 :          0 :         for (freq = chandef->center_freq2 - width / 2 + 10;
     589                 :          0 :              freq <= chandef->center_freq2 + width / 2 - 10; freq += 20) {
     590                 :          0 :                 if (chan->center_freq == freq)
     591                 :            :                         return true;
     592                 :            :         }
     593                 :            : 
     594                 :            :         return false;
     595                 :            : }
     596                 :            : 
     597                 :          0 : bool cfg80211_beaconing_iface_active(struct wireless_dev *wdev)
     598                 :            : {
     599                 :            :         bool active = false;
     600                 :            : 
     601                 :            :         ASSERT_WDEV_LOCK(wdev);
     602                 :            : 
     603                 :          0 :         if (!wdev->chandef.chan)
     604                 :            :                 return false;
     605                 :            : 
     606                 :          0 :         switch (wdev->iftype) {
     607                 :            :         case NL80211_IFTYPE_AP:
     608                 :            :         case NL80211_IFTYPE_P2P_GO:
     609                 :          0 :                 active = wdev->beacon_interval != 0;
     610                 :          0 :                 break;
     611                 :            :         case NL80211_IFTYPE_ADHOC:
     612                 :          0 :                 active = wdev->ssid_len != 0;
     613                 :          0 :                 break;
     614                 :            :         case NL80211_IFTYPE_MESH_POINT:
     615                 :          0 :                 active = wdev->mesh_id_len != 0;
     616                 :          0 :                 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                 :          0 :                 WARN_ON(1);
     630                 :            :         }
     631                 :            : 
     632                 :          0 :         return active;
     633                 :            : }
     634                 :            : 
     635                 :          0 : static bool cfg80211_is_wiphy_oper_chan(struct wiphy *wiphy,
     636                 :            :                                         struct ieee80211_channel *chan)
     637                 :            : {
     638                 :            :         struct wireless_dev *wdev;
     639                 :            : 
     640                 :          0 :         list_for_each_entry(wdev, &wiphy->wdev_list, list) {
     641                 :            :                 wdev_lock(wdev);
     642                 :          0 :                 if (!cfg80211_beaconing_iface_active(wdev)) {
     643                 :            :                         wdev_unlock(wdev);
     644                 :          0 :                         continue;
     645                 :            :                 }
     646                 :            : 
     647                 :          0 :                 if (cfg80211_is_sub_chan(&wdev->chandef, chan)) {
     648                 :            :                         wdev_unlock(wdev);
     649                 :          0 :                         return true;
     650                 :            :                 }
     651                 :            :                 wdev_unlock(wdev);
     652                 :            :         }
     653                 :            : 
     654                 :            :         return false;
     655                 :            : }
     656                 :            : 
     657                 :          0 : bool cfg80211_any_wiphy_oper_chan(struct wiphy *wiphy,
     658                 :            :                                   struct ieee80211_channel *chan)
     659                 :            : {
     660                 :            :         struct cfg80211_registered_device *rdev;
     661                 :            : 
     662                 :          0 :         ASSERT_RTNL();
     663                 :            : 
     664                 :          0 :         if (!(chan->flags & IEEE80211_CHAN_RADAR))
     665                 :            :                 return false;
     666                 :            : 
     667                 :          0 :         list_for_each_entry(rdev, &cfg80211_rdev_list, list) {
     668                 :          0 :                 if (!reg_dfs_domain_same(wiphy, &rdev->wiphy))
     669                 :          0 :                         continue;
     670                 :            : 
     671                 :          0 :                 if (cfg80211_is_wiphy_oper_chan(&rdev->wiphy, chan))
     672                 :            :                         return true;
     673                 :            :         }
     674                 :            : 
     675                 :            :         return false;
     676                 :            : }
     677                 :            : 
     678                 :          0 : 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                 :          0 :         for (freq = start_freq; freq <= end_freq; freq += 20) {
     698                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     699                 :          0 :                 if (!c)
     700                 :            :                         return false;
     701                 :            : 
     702                 :          0 :                 if (c->flags & IEEE80211_CHAN_DISABLED)
     703                 :            :                         return false;
     704                 :            : 
     705                 :          0 :                 if ((c->flags & IEEE80211_CHAN_RADAR) &&
     706                 :          0 :                     (c->dfs_state != NL80211_DFS_AVAILABLE) &&
     707                 :          0 :                     !(c->dfs_state == NL80211_DFS_USABLE && dfs_offload))
     708                 :            :                         return false;
     709                 :            :         }
     710                 :            : 
     711                 :            :         return true;
     712                 :            : }
     713                 :            : 
     714                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     721                 :            :                 return false;
     722                 :            : 
     723                 :          0 :         width = cfg80211_chandef_get_width(chandef);
     724                 :          0 :         if (width < 0)
     725                 :            :                 return false;
     726                 :            : 
     727                 :          0 :         r = cfg80211_get_chans_dfs_available(wiphy, chandef->center_freq1,
     728                 :            :                                              width);
     729                 :            : 
     730                 :            :         /* If any of channels unavailable for cf1 just return */
     731                 :          0 :         if (!r)
     732                 :            :                 return r;
     733                 :            : 
     734                 :          0 :         switch (chandef->width) {
     735                 :            :         case NL80211_CHAN_WIDTH_80P80:
     736                 :          0 :                 WARN_ON(!chandef->center_freq2);
     737                 :          0 :                 r = cfg80211_get_chans_dfs_available(wiphy,
     738                 :            :                                                      chandef->center_freq2,
     739                 :            :                                                      width);
     740                 :          0 :                 break;
     741                 :            :         default:
     742                 :          0 :                 WARN_ON(chandef->center_freq2);
     743                 :            :                 break;
     744                 :            :         }
     745                 :            : 
     746                 :          0 :         return r;
     747                 :            : }
     748                 :            : 
     749                 :          0 : 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                 :          0 :         for (freq = start_freq; freq <= end_freq; freq += 20) {
     761                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     762                 :          0 :                 if (!c)
     763                 :            :                         return 0;
     764                 :            : 
     765                 :          0 :                 if (c->flags & IEEE80211_CHAN_DISABLED)
     766                 :            :                         return 0;
     767                 :            : 
     768                 :          0 :                 if (!(c->flags & IEEE80211_CHAN_RADAR))
     769                 :          0 :                         continue;
     770                 :            : 
     771                 :          0 :                 if (c->dfs_cac_ms > dfs_cac_ms)
     772                 :            :                         dfs_cac_ms = c->dfs_cac_ms;
     773                 :            :         }
     774                 :            : 
     775                 :          0 :         return dfs_cac_ms;
     776                 :            : }
     777                 :            : 
     778                 :            : unsigned int
     779                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     786                 :            :                 return 0;
     787                 :            : 
     788                 :          0 :         width = cfg80211_chandef_get_width(chandef);
     789                 :          0 :         if (width < 0)
     790                 :            :                 return 0;
     791                 :            : 
     792                 :          0 :         t1 = cfg80211_get_chans_dfs_cac_time(wiphy,
     793                 :            :                                              chandef->center_freq1,
     794                 :            :                                              width);
     795                 :            : 
     796                 :          0 :         if (!chandef->center_freq2)
     797                 :            :                 return t1;
     798                 :            : 
     799                 :          0 :         t2 = cfg80211_get_chans_dfs_cac_time(wiphy,
     800                 :            :                                              chandef->center_freq2,
     801                 :            :                                              width);
     802                 :            : 
     803                 :          0 :         return max(t1, t2);
     804                 :            : }
     805                 :            : 
     806                 :          0 : 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                 :          0 :         for (freq = start_freq; freq <= end_freq; freq += 20) {
     817                 :          0 :                 c = ieee80211_get_channel(wiphy, freq);
     818                 :          0 :                 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                 :          0 : 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                 :          0 :         if (!edmg_channels && !edmg_bw_config)
     836                 :            :                 return true;
     837                 :            : 
     838                 :          0 :         if ((!edmg_channels && edmg_bw_config) ||
     839                 :            :             (edmg_channels && !edmg_bw_config))
     840                 :            :                 return false;
     841                 :            : 
     842                 :          0 :         if (!(edmg_channels & BIT(primary_channel - 1)))
     843                 :            :                 return false;
     844                 :            : 
     845                 :            :         /* 60GHz channels 1..6 */
     846                 :          0 :         for (i = 0; i < 6; i++) {
     847                 :          0 :                 if (!(edmg_channels & BIT(i)))
     848                 :          0 :                         continue;
     849                 :            : 
     850                 :          0 :                 if (!(edmg_cap->channels & BIT(i)))
     851                 :            :                         return false;
     852                 :            : 
     853                 :          0 :                 channels_counter++;
     854                 :            : 
     855                 :          0 :                 freq = ieee80211_channel_to_frequency(i + 1,
     856                 :            :                                                       NL80211_BAND_60GHZ);
     857                 :          0 :                 chan = ieee80211_get_channel(wiphy, freq);
     858                 :          0 :                 if (!chan || chan->flags & IEEE80211_CHAN_DISABLED)
     859                 :            :                         return false;
     860                 :            :         }
     861                 :            : 
     862                 :            :         /* IEEE802.11 allows max 4 channels */
     863                 :          0 :         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                 :          0 :         if ((edmg_bw_config % 4) > (edmg_cap->bw_config % 4))
     870                 :            :                 return false;
     871                 :            : 
     872                 :          0 :         if (edmg_bw_config > edmg_cap->bw_config)
     873                 :            :                 return false;
     874                 :            : 
     875                 :          0 :         return true;
     876                 :            : }
     877                 :            : 
     878                 :          0 : 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                 :          0 :         if (WARN_ON(!cfg80211_chandef_valid(chandef)))
     888                 :            :                 return false;
     889                 :            : 
     890                 :          0 :         ht_cap = &wiphy->bands[chandef->chan->band]->ht_cap;
     891                 :            :         vht_cap = &wiphy->bands[chandef->chan->band]->vht_cap;
     892                 :          0 :         edmg_cap = &wiphy->bands[chandef->chan->band]->edmg_cap;
     893                 :            : 
     894                 :          0 :         if (edmg_cap->channels &&
     895                 :          0 :             !cfg80211_edmg_usable(wiphy,
     896                 :            :                                   chandef->edmg.channels,
     897                 :            :                                   chandef->edmg.bw_config,
     898                 :          0 :                                   chandef->chan->hw_value,
     899                 :            :                                   edmg_cap))
     900                 :            :                 return false;
     901                 :            : 
     902                 :          0 :         control_freq = chandef->chan->center_freq;
     903                 :            : 
     904                 :          0 :         switch (chandef->width) {
     905                 :            :         case NL80211_CHAN_WIDTH_5:
     906                 :            :                 width = 5;
     907                 :            :                 break;
     908                 :            :         case NL80211_CHAN_WIDTH_10:
     909                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_10MHZ;
     910                 :            :                 width = 10;
     911                 :          0 :                 break;
     912                 :            :         case NL80211_CHAN_WIDTH_20:
     913                 :          0 :                 if (!ht_cap->ht_supported)
     914                 :            :                         return false;
     915                 :            :                 /* fall through */
     916                 :            :         case NL80211_CHAN_WIDTH_20_NOHT:
     917                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_20MHZ;
     918                 :            :                 width = 20;
     919                 :          0 :                 break;
     920                 :            :         case NL80211_CHAN_WIDTH_40:
     921                 :            :                 width = 40;
     922                 :          0 :                 if (!ht_cap->ht_supported)
     923                 :            :                         return false;
     924                 :          0 :                 if (!(ht_cap->cap & IEEE80211_HT_CAP_SUP_WIDTH_20_40) ||
     925                 :            :                     ht_cap->cap & IEEE80211_HT_CAP_40MHZ_INTOLERANT)
     926                 :            :                         return false;
     927                 :          0 :                 if (chandef->center_freq1 < control_freq &&
     928                 :          0 :                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40MINUS)
     929                 :            :                         return false;
     930                 :          0 :                 if (chandef->center_freq1 > control_freq &&
     931                 :          0 :                     chandef->chan->flags & IEEE80211_CHAN_NO_HT40PLUS)
     932                 :            :                         return false;
     933                 :            :                 break;
     934                 :            :         case NL80211_CHAN_WIDTH_80P80:
     935                 :          0 :                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
     936                 :          0 :                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
     937                 :            :                         return false;
     938                 :            :                 /* fall through */
     939                 :            :         case NL80211_CHAN_WIDTH_80:
     940                 :          0 :                 if (!vht_cap->vht_supported)
     941                 :            :                         return false;
     942                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_80MHZ;
     943                 :            :                 width = 80;
     944                 :          0 :                 break;
     945                 :            :         case NL80211_CHAN_WIDTH_160:
     946                 :          0 :                 if (!vht_cap->vht_supported)
     947                 :            :                         return false;
     948                 :          0 :                 cap = vht_cap->cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK;
     949                 :          0 :                 if (cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ &&
     950                 :          0 :                     cap != IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ)
     951                 :            :                         return false;
     952                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_160MHZ;
     953                 :            :                 width = 160;
     954                 :          0 :                 break;
     955                 :            :         default:
     956                 :          0 :                 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                 :          0 :         if (width > 20)
     972                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
     973                 :            : 
     974                 :            :         /* 5 and 10 MHz are only defined for the OFDM PHY */
     975                 :          0 :         if (width < 20)
     976                 :          0 :                 prohibited_flags |= IEEE80211_CHAN_NO_OFDM;
     977                 :            : 
     978                 :            : 
     979                 :          0 :         if (!cfg80211_secondary_chans_ok(wiphy, chandef->center_freq1,
     980                 :            :                                          width, prohibited_flags))
     981                 :            :                 return false;
     982                 :            : 
     983                 :          0 :         if (!chandef->center_freq2)
     984                 :            :                 return true;
     985                 :          0 :         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                 :          0 : 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                 :          0 :         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                 :          0 : 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                 :          0 :         trace_cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
    1101                 :            : 
    1102                 :          0 :         if (check_no_ir)
    1103                 :            :                 prohibited_flags |= IEEE80211_CHAN_NO_IR;
    1104                 :            : 
    1105                 :          0 :         if (cfg80211_chandef_dfs_required(wiphy, chandef, iftype) > 0 &&
    1106                 :          0 :             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                 :          0 :         res = cfg80211_chandef_usable(wiphy, chandef, prohibited_flags);
    1112                 :            : 
    1113                 :          0 :         trace_cfg80211_return_bool(res);
    1114                 :          0 :         return res;
    1115                 :            : }
    1116                 :            : 
    1117                 :          0 : bool cfg80211_reg_can_beacon(struct wiphy *wiphy,
    1118                 :            :                              struct cfg80211_chan_def *chandef,
    1119                 :            :                              enum nl80211_iftype iftype)
    1120                 :            : {
    1121                 :          0 :         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, true);
    1122                 :            : }
    1123                 :            : EXPORT_SYMBOL(cfg80211_reg_can_beacon);
    1124                 :            : 
    1125                 :          0 : 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                 :          0 :         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                 :          0 :         check_no_ir = !cfg80211_ir_permissive_chan(wiphy, iftype,
    1140                 :          0 :                                                    chandef->chan);
    1141                 :            : 
    1142                 :          0 :         return _cfg80211_reg_can_beacon(wiphy, chandef, iftype, check_no_ir);
    1143                 :            : }
    1144                 :            : EXPORT_SYMBOL(cfg80211_reg_can_beacon_relax);
    1145                 :            : 
    1146                 :          0 : int cfg80211_set_monitor_channel(struct cfg80211_registered_device *rdev,
    1147                 :            :                                  struct cfg80211_chan_def *chandef)
    1148                 :            : {
    1149                 :          0 :         if (!rdev->ops->set_monitor_channel)
    1150                 :            :                 return -EOPNOTSUPP;
    1151                 :          0 :         if (!cfg80211_has_monitors_only(rdev))
    1152                 :            :                 return -EBUSY;
    1153                 :            : 
    1154                 :          0 :         return rdev_set_monitor_channel(rdev, chandef);
    1155                 :            : }
    1156                 :            : 
    1157                 :            : void
    1158                 :          0 : 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                 :          0 :         *chan = NULL;
    1166                 :          0 :         *chanmode = CHAN_MODE_UNDEFINED;
    1167                 :            : 
    1168                 :            :         ASSERT_WDEV_LOCK(wdev);
    1169                 :            : 
    1170                 :          0 :         if (wdev->netdev && !netif_running(wdev->netdev))
    1171                 :            :                 return;
    1172                 :            : 
    1173                 :          0 :         switch (wdev->iftype) {
    1174                 :            :         case NL80211_IFTYPE_ADHOC:
    1175                 :          0 :                 if (wdev->current_bss) {
    1176                 :          0 :                         *chan = wdev->current_bss->pub.channel;
    1177                 :          0 :                         *chanmode = (wdev->ibss_fixed &&
    1178                 :          0 :                                      !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                 :          0 :                         if (wdev->ibss_dfs_possible)
    1185                 :          0 :                                 *radar_detect |= BIT(wdev->chandef.width);
    1186                 :            :                         return;
    1187                 :            :                 }
    1188                 :            :                 break;
    1189                 :            :         case NL80211_IFTYPE_STATION:
    1190                 :            :         case NL80211_IFTYPE_P2P_CLIENT:
    1191                 :          0 :                 if (wdev->current_bss) {
    1192                 :          0 :                         *chan = wdev->current_bss->pub.channel;
    1193                 :          0 :                         *chanmode = CHAN_MODE_SHARED;
    1194                 :          0 :                         return;
    1195                 :            :                 }
    1196                 :            :                 break;
    1197                 :            :         case NL80211_IFTYPE_AP:
    1198                 :            :         case NL80211_IFTYPE_P2P_GO:
    1199                 :          0 :                 if (wdev->cac_started) {
    1200                 :          0 :                         *chan = wdev->chandef.chan;
    1201                 :          0 :                         *chanmode = CHAN_MODE_SHARED;
    1202                 :          0 :                         *radar_detect |= BIT(wdev->chandef.width);
    1203                 :          0 :                 } else if (wdev->beacon_interval) {
    1204                 :          0 :                         *chan = wdev->chandef.chan;
    1205                 :          0 :                         *chanmode = CHAN_MODE_SHARED;
    1206                 :            : 
    1207                 :          0 :                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
    1208                 :          0 :                                                             &wdev->chandef,
    1209                 :            :                                                             wdev->iftype);
    1210                 :          0 :                         WARN_ON(ret < 0);
    1211                 :          0 :                         if (ret > 0)
    1212                 :          0 :                                 *radar_detect |= BIT(wdev->chandef.width);
    1213                 :            :                 }
    1214                 :            :                 return;
    1215                 :            :         case NL80211_IFTYPE_MESH_POINT:
    1216                 :          0 :                 if (wdev->mesh_id_len) {
    1217                 :          0 :                         *chan = wdev->chandef.chan;
    1218                 :          0 :                         *chanmode = CHAN_MODE_SHARED;
    1219                 :            : 
    1220                 :          0 :                         ret = cfg80211_chandef_dfs_required(wdev->wiphy,
    1221                 :          0 :                                                             &wdev->chandef,
    1222                 :            :                                                             wdev->iftype);
    1223                 :          0 :                         WARN_ON(ret < 0);
    1224                 :          0 :                         if (ret > 0)
    1225                 :          0 :                                 *radar_detect |= BIT(wdev->chandef.width);
    1226                 :            :                 }
    1227                 :            :                 return;
    1228                 :            :         case NL80211_IFTYPE_OCB:
    1229                 :          0 :                 if (wdev->chandef.chan) {
    1230                 :          0 :                         *chan = wdev->chandef.chan;
    1231                 :          0 :                         *chanmode = CHAN_MODE_SHARED;
    1232                 :          0 :                         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                 :          0 :                 WARN_ON(1);
    1245                 :            :         }
    1246                 :            : }
    

Generated by: LCOV version 1.14