drivers/staging/brcm80211/brcmsmac/wlc_channel.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/types.h>
  19 #include <linux/module.h>
  20 #include <linux/pci.h>
  21
  22 #include <bcmdefs.h>
  23 #include <bcmutils.h>
  24 #include <siutils.h>
  25 #include <sbhnddma.h>
  26 #include <wlioctl.h>
  27
  28 #include "wlc_types.h"
  29 #include "d11.h"
  30 #include "wlc_cfg.h"
  31 #include "wlc_scb.h"
  32 #include "wlc_pub.h"
  33 #include "wlc_key.h"
  34 #include "phy/wlc_phy_hal.h"
  35 #include "wlc_bmac.h"
  36 #include "wlc_rate.h"
  37 #include "wlc_channel.h"
  38 #include "wlc_bsscfg.h"
  39 #include "wlc_main.h"
  40 #include "wlc_stf.h"
  41 #include "wl_dbg.h"
  42
  43 #define VALID_CHANNEL20_DB(wlc, val) wlc_valid_channel20_db((wlc)->cmi, val)
  44 #define VALID_CHANNEL20_IN_BAND(wlc, bandunit, val) \
  45         wlc_valid_channel20_in_band((wlc)->cmi, bandunit, val)
  46 #define VALID_CHANNEL20(wlc, val) wlc_valid_channel20((wlc)->cmi, val)
  47
  48 typedef struct wlc_cm_band {
  49         u8 locale_flags;        /* locale_info_t flags */
  50         chanvec_t valid_channels;       /* List of valid channels in the country */
  51         const chanvec_t *restricted_channels;   /* List of restricted use channels */
  52         const chanvec_t *radar_channels;        /* List of radar sensitive channels */
  53         u8 PAD[8];
  54 } wlc_cm_band_t;
  55
  56 struct wlc_cm_info {
  57         struct wlc_pub *pub;
  58         struct wlc_info *wlc;
  59         char srom_ccode[WLC_CNTRY_BUF_SZ];      /* Country Code in SROM */
  60         uint srom_regrev;       /* Regulatory Rev for the SROM ccode */
  61         const country_info_t *country;  /* current country def */
  62         char ccode[WLC_CNTRY_BUF_SZ];   /* current internal Country Code */
  63         uint regrev;            /* current Regulatory Revision */
  64         char country_abbrev[WLC_CNTRY_BUF_SZ];  /* current advertised ccode */
  65         wlc_cm_band_t bandstate[MAXBANDS];      /* per-band state (one per phy/radio) */
  66         /* quiet channels currently for radar sensitivity or 11h support */
  67         chanvec_t quiet_channels;       /* channels on which we cannot transmit */
  68 };
  69
  70 static int wlc_channels_init(wlc_cm_info_t *wlc_cm,
  71                              const country_info_t *country);
  72 static void wlc_set_country_common(wlc_cm_info_t *wlc_cm,
  73                                    const char *country_abbrev,
  74                                    const char *ccode, uint regrev,
  75                                    const country_info_t *country);
  76 static int wlc_set_countrycode(wlc_cm_info_t *wlc_cm, const char *ccode);
  77 static int wlc_set_countrycode_rev(wlc_cm_info_t *wlc_cm,
  78                                    const char *country_abbrev,
  79                                    const char *ccode, int regrev);
  80 static int wlc_country_aggregate_map(wlc_cm_info_t *wlc_cm, const char *ccode,
  81                                      char *mapped_ccode, uint *mapped_regrev);
  82 static const country_info_t *wlc_country_lookup_direct(const char *ccode,
  83                                                        uint regrev);
  84 static const country_info_t *wlc_countrycode_map(wlc_cm_info_t *wlc_cm,
  85                                                  const char *ccode,
  86                                                  char *mapped_ccode,
  87                                                  uint *mapped_regrev);
  88 static void wlc_channels_commit(wlc_cm_info_t *wlc_cm);
  89 static void wlc_quiet_channels_reset(wlc_cm_info_t *wlc_cm);
  90 static bool wlc_quiet_chanspec(wlc_cm_info_t *wlc_cm, chanspec_t chspec);
  91 static bool wlc_valid_channel20_db(wlc_cm_info_t *wlc_cm, uint val);
  92 static bool wlc_valid_channel20_in_band(wlc_cm_info_t *wlc_cm, uint bandunit,
  93                                         uint val);
  94 static bool wlc_valid_channel20(wlc_cm_info_t *wlc_cm, uint val);
  95 static const country_info_t *wlc_country_lookup(struct wlc_info *wlc,
  96                                                 const char *ccode);
  97 static void wlc_locale_get_channels(const locale_info_t *locale,
  98                                     chanvec_t *valid_channels);
  99 static const locale_info_t *wlc_get_locale_2g(u8 locale_idx);
 100 static const locale_info_t *wlc_get_locale_5g(u8 locale_idx);
 101 static bool wlc_japan(struct wlc_info *wlc);
 102 static bool wlc_japan_ccode(const char *ccode);
 103 static void wlc_channel_min_txpower_limits_with_local_constraint(wlc_cm_info_t *
 104                                                                  wlc_cm,
 105                                                                  struct
 106                                                                  txpwr_limits
 107                                                                  *txpwr,
 108                                                                  u8
 109                                                                  local_constraint_qdbm);
 110 void wlc_locale_add_channels(chanvec_t *target, const chanvec_t *channels);
 111 static const locale_mimo_info_t *wlc_get_mimo_2g(u8 locale_idx);
 112 static const locale_mimo_info_t *wlc_get_mimo_5g(u8 locale_idx);
 113
 114 /* QDB() macro takes a dB value and converts to a quarter dB value */
 115 #ifdef QDB
 116 #undef QDB
 117 #endif
 118 #define QDB(n) ((n) * WLC_TXPWR_DB_FACTOR)
 119
 120 /* Regulatory Matrix Spreadsheet (CLM) MIMO v3.7.9 */
 121
 122 /*
 123  * Some common channel sets
 124  */
 125
 126 /* No channels */
 127 static const chanvec_t chanvec_none = {
 128         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 129          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 130          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 131          0x00, 0x00, 0x00, 0x00}
 132 };
 133
 134 /* All 2.4 GHz HW channels */
 135 const chanvec_t chanvec_all_2G = {
 136         {0xfe, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 137          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 138          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 139          0x00, 0x00, 0x00, 0x00}
 140 };
 141
 142 /* All 5 GHz HW channels */
 143 const chanvec_t chanvec_all_5G = {
 144         {0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0x11, 0x11,
 145          0x01, 0x00, 0x00, 0x00, 0x10, 0x11, 0x11, 0x11,
 146          0x11, 0x11, 0x20, 0x22, 0x22, 0x00, 0x00, 0x11,
 147          0x11, 0x11, 0x11, 0x01}
 148 };
 149
 150 /*
 151  * Radar channel sets
 152  */
 153
 154 /* No radar */
 155 #define radar_set_none chanvec_none
 156
 157 static const chanvec_t radar_set1 = {   /* Channels 52 - 64, 100 - 140 */
 158         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11,        /* 52 - 60 */
 159          0x01, 0x00, 0x00, 0x00, 0x10, 0x11, 0x11, 0x11,        /* 64, 100 - 124 */
 160          0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,        /* 128 - 140 */
 161          0x00, 0x00, 0x00, 0x00}
 162 };
 163
 164 /*
 165  * Restricted channel sets
 166  */
 167
 168 #define restricted_set_none chanvec_none
 169
 170 /* Channels 34, 38, 42, 46 */
 171 static const chanvec_t restricted_set_japan_legacy = {
 172         {0x00, 0x00, 0x00, 0x00, 0x44, 0x44, 0x00, 0x00,
 173          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 174          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 175          0x00, 0x00, 0x00, 0x00}
 176 };
 177
 178 /* Channels 12, 13 */
 179 static const chanvec_t restricted_set_2g_short = {
 180         {0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 181          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 182          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 183          0x00, 0x00, 0x00, 0x00}
 184 };
 185
 186 /* Channel 165 */
 187 static const chanvec_t restricted_chan_165 = {
 188         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 189          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 190          0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
 191          0x00, 0x00, 0x00, 0x00}
 192 };
 193
 194 /* Channels 36 - 48 & 149 - 165 */
 195 static const chanvec_t restricted_low_hi = {
 196         {0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x01, 0x00,
 197          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 198          0x00, 0x00, 0x20, 0x22, 0x22, 0x00, 0x00, 0x00,
 199          0x00, 0x00, 0x00, 0x00}
 200 };
 201
 202 /* Channels 12 - 14 */
 203 static const chanvec_t restricted_set_12_13_14 = {
 204         {0x00, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 205          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 206          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 207          0x00, 0x00, 0x00, 0x00}
 208 };
 209
 210 #define  LOCALE_CHAN_01_11       (1<<0)
 211 #define  LOCALE_CHAN_12_13       (1<<1)
 212 #define  LOCALE_CHAN_14          (1<<2)
 213 #define  LOCALE_SET_5G_LOW_JP1   (1<<3) /* 34-48, step 2 */
 214 #define  LOCALE_SET_5G_LOW_JP2   (1<<4) /* 34-46, step 4 */
 215 #define  LOCALE_SET_5G_LOW1      (1<<5) /* 36-48, step 4 */
 216 #define  LOCALE_SET_5G_LOW2      (1<<6) /* 52 */
 217 #define  LOCALE_SET_5G_LOW3      (1<<7) /* 56-64, step 4 */
 218 #define  LOCALE_SET_5G_MID1      (1<<8) /* 100-116, step 4 */
 219 #define  LOCALE_SET_5G_MID2      (1<<9) /* 120-124, step 4 */
 220 #define  LOCALE_SET_5G_MID3      (1<<10)        /* 128 */
 221 #define  LOCALE_SET_5G_HIGH1     (1<<11)        /* 132-140, step 4 */
 222 #define  LOCALE_SET_5G_HIGH2     (1<<12)        /* 149-161, step 4 */
 223 #define  LOCALE_SET_5G_HIGH3     (1<<13)        /* 165 */
 224 #define  LOCALE_CHAN_52_140_ALL  (1<<14)
 225 #define  LOCALE_SET_5G_HIGH4     (1<<15)        /* 184-216 */
 226
 227 #define  LOCALE_CHAN_36_64       (LOCALE_SET_5G_LOW1 | LOCALE_SET_5G_LOW2 | LOCALE_SET_5G_LOW3)
 228 #define  LOCALE_CHAN_52_64       (LOCALE_SET_5G_LOW2 | LOCALE_SET_5G_LOW3)
 229 #define  LOCALE_CHAN_100_124     (LOCALE_SET_5G_MID1 | LOCALE_SET_5G_MID2)
 230 #define  LOCALE_CHAN_100_140     \
 231         (LOCALE_SET_5G_MID1 | LOCALE_SET_5G_MID2 | LOCALE_SET_5G_MID3 | LOCALE_SET_5G_HIGH1)
 232 #define  LOCALE_CHAN_149_165     (LOCALE_SET_5G_HIGH2 | LOCALE_SET_5G_HIGH3)
 233 #define  LOCALE_CHAN_184_216     LOCALE_SET_5G_HIGH4
 234
 235 #define  LOCALE_CHAN_01_14      (LOCALE_CHAN_01_11 | LOCALE_CHAN_12_13 | LOCALE_CHAN_14)
 236
 237 #define  LOCALE_RADAR_SET_NONE            0
 238 #define  LOCALE_RADAR_SET_1               1
 239
 240 #define  LOCALE_RESTRICTED_NONE           0
 241 #define  LOCALE_RESTRICTED_SET_2G_SHORT   1
 242 #define  LOCALE_RESTRICTED_CHAN_165       2
 243 #define  LOCALE_CHAN_ALL_5G               3
 244 #define  LOCALE_RESTRICTED_JAPAN_LEGACY   4
 245 #define  LOCALE_RESTRICTED_11D_2G         5
 246 #define  LOCALE_RESTRICTED_11D_5G         6
 247 #define  LOCALE_RESTRICTED_LOW_HI         7
 248 #define  LOCALE_RESTRICTED_12_13_14       8
 249
 250 /* global memory to provide working buffer for expanded locale */
 251
 252 static const chanvec_t *g_table_radar_set[] = {
 253         &chanvec_none,
 254         &radar_set1
 255 };
 256
 257 static const chanvec_t *g_table_restricted_chan[] = {
 258         &chanvec_none,          /* restricted_set_none */
 259         &restricted_set_2g_short,
 260         &restricted_chan_165,
 261         &chanvec_all_5G,
 262         &restricted_set_japan_legacy,
 263         &chanvec_all_2G,        /* restricted_set_11d_2G */
 264         &chanvec_all_5G,        /* restricted_set_11d_5G */
 265         &restricted_low_hi,
 266         &restricted_set_12_13_14
 267 };
 268
 269 static const chanvec_t locale_2g_01_11 = {
 270         {0xfe, 0x0f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 271          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 272          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 273          0x00, 0x00, 0x00, 0x00}
 274 };
 275
 276 static const chanvec_t locale_2g_12_13 = {
 277         {0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 278          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 279          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 280          0x00, 0x00, 0x00, 0x00}
 281 };
 282
 283 static const chanvec_t locale_2g_14 = {
 284         {0x00, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 285          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 286          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 287          0x00, 0x00, 0x00, 0x00}
 288 };
 289
 290 static const chanvec_t locale_5g_LOW_JP1 = {
 291         {0x00, 0x00, 0x00, 0x00, 0x54, 0x55, 0x01, 0x00,
 292          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 293          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 294          0x00, 0x00, 0x00, 0x00}
 295 };
 296
 297 static const chanvec_t locale_5g_LOW_JP2 = {
 298         {0x00, 0x00, 0x00, 0x00, 0x44, 0x44, 0x00, 0x00,
 299          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 300          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 301          0x00, 0x00, 0x00, 0x00}
 302 };
 303
 304 static const chanvec_t locale_5g_LOW1 = {
 305         {0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x01, 0x00,
 306          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 307          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 308          0x00, 0x00, 0x00, 0x00}
 309 };
 310
 311 static const chanvec_t locale_5g_LOW2 = {
 312         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
 313          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 314          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 315          0x00, 0x00, 0x00, 0x00}
 316 };
 317
 318 static const chanvec_t locale_5g_LOW3 = {
 319         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
 320          0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 321          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 322          0x00, 0x00, 0x00, 0x00}
 323 };
 324
 325 static const chanvec_t locale_5g_MID1 = {
 326         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 327          0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x11, 0x00,
 328          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 329          0x00, 0x00, 0x00, 0x00}
 330 };
 331
 332 static const chanvec_t locale_5g_MID2 = {
 333         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 334          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
 335          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 336          0x00, 0x00, 0x00, 0x00}
 337 };
 338
 339 static const chanvec_t locale_5g_MID3 = {
 340         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 341          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 342          0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 343          0x00, 0x00, 0x00, 0x00}
 344 };
 345
 346 static const chanvec_t locale_5g_HIGH1 = {
 347         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 348          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 349          0x10, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 350          0x00, 0x00, 0x00, 0x00}
 351 };
 352
 353 static const chanvec_t locale_5g_HIGH2 = {
 354         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 355          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 356          0x00, 0x00, 0x20, 0x22, 0x02, 0x00, 0x00, 0x00,
 357          0x00, 0x00, 0x00, 0x00}
 358 };
 359
 360 static const chanvec_t locale_5g_HIGH3 = {
 361         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 362          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 363          0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
 364          0x00, 0x00, 0x00, 0x00}
 365 };
 366
 367 static const chanvec_t locale_5g_52_140_ALL = {
 368         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11,
 369          0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
 370          0x11, 0x11, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
 371          0x00, 0x00, 0x00, 0x00}
 372 };
 373
 374 static const chanvec_t locale_5g_HIGH4 = {
 375         {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 376          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 377          0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11,
 378          0x11, 0x11, 0x11, 0x11}
 379 };
 380
 381 static const chanvec_t *g_table_locale_base[] = {
 382         &locale_2g_01_11,
 383         &locale_2g_12_13,
 384         &locale_2g_14,
 385         &locale_5g_LOW_JP1,
 386         &locale_5g_LOW_JP2,
 387         &locale_5g_LOW1,
 388         &locale_5g_LOW2,
 389         &locale_5g_LOW3,
 390         &locale_5g_MID1,
 391         &locale_5g_MID2,
 392         &locale_5g_MID3,
 393         &locale_5g_HIGH1,
 394         &locale_5g_HIGH2,
 395         &locale_5g_HIGH3,
 396         &locale_5g_52_140_ALL,
 397         &locale_5g_HIGH4
 398 };
 399
 400 void wlc_locale_add_channels(chanvec_t *target, const chanvec_t *channels)
 401 {
 402         u8 i;
 403         for (i = 0; i < sizeof(chanvec_t); i++) {
 404                 target->vec[i] |= channels->vec[i];
 405         }
 406 }
 407
 408 static void wlc_locale_get_channels(const locale_info_t *locale,
 409                                     chanvec_t *channels)
 410 {
 411         u8 i;
 412
 413         memset(channels, 0, sizeof(chanvec_t));
 414
 415         for (i = 0; i < ARRAY_SIZE(g_table_locale_base); i++) {
 416                 if (locale->valid_channels & (1 << i)) {
 417                         wlc_locale_add_channels(channels,
 418                                                 g_table_locale_base[i]);
 419                 }
 420         }
 421 }
 422
 423 /*
 424  * Locale Definitions - 2.4 GHz
 425  */
 426 static const locale_info_t locale_i = { /* locale i. channel 1 - 13 */
 427         LOCALE_CHAN_01_11 | LOCALE_CHAN_12_13,
 428         LOCALE_RADAR_SET_NONE,
 429         LOCALE_RESTRICTED_SET_2G_SHORT,
 430         {QDB(19), QDB(19), QDB(19),
 431          QDB(19), QDB(19), QDB(19)},
 432         {20, 20, 20, 0},
 433         WLC_EIRP
 434 };
 435
 436 /*
 437  * Locale Definitions - 5 GHz
 438  */
 439 static const locale_info_t locale_11 = {
 440         /* locale 11. channel 36 - 48, 52 - 64, 100 - 140, 149 - 165 */
 441         LOCALE_CHAN_36_64 | LOCALE_CHAN_100_140 | LOCALE_CHAN_149_165,
 442         LOCALE_RADAR_SET_1,
 443         LOCALE_RESTRICTED_NONE,
 444         {QDB(21), QDB(21), QDB(21), QDB(21), QDB(21)},
 445         {23, 23, 23, 30, 30},
 446         WLC_EIRP | WLC_DFS_EU
 447 };
 448
 449 #define LOCALE_2G_IDX_i                 0
 450 static const locale_info_t *g_locale_2g_table[] = {
 451         &locale_i
 452 };
 453
 454 #define LOCALE_5G_IDX_11        0
 455 static const locale_info_t *g_locale_5g_table[] = {
 456         &locale_11
 457 };
 458
 459 /*
 460  * MIMO Locale Definitions - 2.4 GHz
 461  */
 462 static const locale_mimo_info_t locale_bn = {
 463         {QDB(13), QDB(13), QDB(13), QDB(13), QDB(13),
 464          QDB(13), QDB(13), QDB(13), QDB(13), QDB(13),
 465          QDB(13), QDB(13), QDB(13)},
 466         {0, 0, QDB(13), QDB(13), QDB(13),
 467          QDB(13), QDB(13), QDB(13), QDB(13), QDB(13),
 468          QDB(13), 0, 0},
 469         0
 470 };
 471
 472 /* locale mimo 2g indexes */
 473 #define LOCALE_MIMO_IDX_bn                      0
 474
 475 static const locale_mimo_info_t *g_mimo_2g_table[] = {
 476         &locale_bn
 477 };
 478
 479 /*
 480  * MIMO Locale Definitions - 5 GHz
 481  */
 482 static const locale_mimo_info_t locale_11n = {
 483         { /* 12.5 dBm */ 50, 50, 50, QDB(15), QDB(15)},
 484         {QDB(14), QDB(15), QDB(15), QDB(15), QDB(15)},
 485         0
 486 };
 487
 488 #define LOCALE_MIMO_IDX_11n                     0
 489 static const locale_mimo_info_t *g_mimo_5g_table[] = {
 490         &locale_11n
 491 };
 492
 493 #ifdef LC
 494 #undef LC
 495 #endif
 496 #define LC(id)  LOCALE_MIMO_IDX_ ## id
 497
 498 #ifdef LC_2G
 499 #undef LC_2G
 500 #endif
 501 #define LC_2G(id)       LOCALE_2G_IDX_ ## id
 502
 503 #ifdef LC_5G
 504 #undef LC_5G
 505 #endif
 506 #define LC_5G(id)       LOCALE_5G_IDX_ ## id
 507
 508 #define LOCALES(band2, band5, mimo2, mimo5)     {LC_2G(band2), LC_5G(band5), LC(mimo2), LC(mimo5)}
 509
 510 static const struct {
 511         char abbrev[WLC_CNTRY_BUF_SZ];  /* country abbreviation */
 512         country_info_t country;
 513 } cntry_locales[] = {
 514         {
 515         "X2", LOCALES(i, 11, bn, 11n)}, /* Worldwide RoW 2 */
 516 };
 517
 518 #ifdef SUPPORT_40MHZ
 519 /* 20MHz channel info for 40MHz pairing support */
 520 struct chan20_info {
 521         u8 sb;
 522         u8 adj_sbs;
 523 };
 524
 525 /* indicates adjacent channels that are allowed for a 40 Mhz channel and
 526  * those that permitted by the HT
 527  */
 528 struct chan20_info chan20_info[] = {
 529         /* 11b/11g */
 530 /* 0 */ {1, (CH_UPPER_SB | CH_EWA_VALID)},
 531 /* 1 */ {2, (CH_UPPER_SB | CH_EWA_VALID)},
 532 /* 2 */ {3, (CH_UPPER_SB | CH_EWA_VALID)},
 533 /* 3 */ {4, (CH_UPPER_SB | CH_EWA_VALID)},
 534 /* 4 */ {5, (CH_UPPER_SB | CH_LOWER_SB | CH_EWA_VALID)},
 535 /* 5 */ {6, (CH_UPPER_SB | CH_LOWER_SB | CH_EWA_VALID)},
 536 /* 6 */ {7, (CH_UPPER_SB | CH_LOWER_SB | CH_EWA_VALID)},
 537 /* 7 */ {8, (CH_UPPER_SB | CH_LOWER_SB | CH_EWA_VALID)},
 538 /* 8 */ {9, (CH_UPPER_SB | CH_LOWER_SB | CH_EWA_VALID)},
 539 /* 9 */ {10, (CH_LOWER_SB | CH_EWA_VALID)},
 540 /* 10 */ {11, (CH_LOWER_SB | CH_EWA_VALID)},
 541 /* 11 */ {12, (CH_LOWER_SB)},
 542 /* 12 */ {13, (CH_LOWER_SB)},
 543 /* 13 */ {14, (CH_LOWER_SB)},
 544
 545 /* 11a japan high */
 546 /* 14 */ {34, (CH_UPPER_SB)},
 547 /* 15 */ {38, (CH_LOWER_SB)},
 548 /* 16 */ {42, (CH_LOWER_SB)},
 549 /* 17 */ {46, (CH_LOWER_SB)},
 550
 551 /* 11a usa low */
 552 /* 18 */ {36, (CH_UPPER_SB | CH_EWA_VALID)},
 553 /* 19 */ {40, (CH_LOWER_SB | CH_EWA_VALID)},
 554 /* 20 */ {44, (CH_UPPER_SB | CH_EWA_VALID)},
 555 /* 21 */ {48, (CH_LOWER_SB | CH_EWA_VALID)},
 556 /* 22 */ {52, (CH_UPPER_SB | CH_EWA_VALID)},
 557 /* 23 */ {56, (CH_LOWER_SB | CH_EWA_VALID)},
 558 /* 24 */ {60, (CH_UPPER_SB | CH_EWA_VALID)},
 559 /* 25 */ {64, (CH_LOWER_SB | CH_EWA_VALID)},
 560
 561 /* 11a Europe */
 562 /* 26 */ {100, (CH_UPPER_SB | CH_EWA_VALID)},
 563 /* 27 */ {104, (CH_LOWER_SB | CH_EWA_VALID)},
 564 /* 28 */ {108, (CH_UPPER_SB | CH_EWA_VALID)},
 565 /* 29 */ {112, (CH_LOWER_SB | CH_EWA_VALID)},
 566 /* 30 */ {116, (CH_UPPER_SB | CH_EWA_VALID)},
 567 /* 31 */ {120, (CH_LOWER_SB | CH_EWA_VALID)},
 568 /* 32 */ {124, (CH_UPPER_SB | CH_EWA_VALID)},
 569 /* 33 */ {128, (CH_LOWER_SB | CH_EWA_VALID)},
 570 /* 34 */ {132, (CH_UPPER_SB | CH_EWA_VALID)},
 571 /* 35 */ {136, (CH_LOWER_SB | CH_EWA_VALID)},
 572 /* 36 */ {140, (CH_LOWER_SB)},
 573
 574 /* 11a usa high, ref5 only */
 575 /* The 0x80 bit in pdiv means these are REF5, other entries are REF20 */
 576 /* 37 */ {149, (CH_UPPER_SB | CH_EWA_VALID)},
 577 /* 38 */ {153, (CH_LOWER_SB | CH_EWA_VALID)},
 578 /* 39 */ {157, (CH_UPPER_SB | CH_EWA_VALID)},
 579 /* 40 */ {161, (CH_LOWER_SB | CH_EWA_VALID)},
 580 /* 41 */ {165, (CH_LOWER_SB)},
 581
 582 /* 11a japan */
 583 /* 42 */ {184, (CH_UPPER_SB)},
 584 /* 43 */ {188, (CH_LOWER_SB)},
 585 /* 44 */ {192, (CH_UPPER_SB)},
 586 /* 45 */ {196, (CH_LOWER_SB)},
 587 /* 46 */ {200, (CH_UPPER_SB)},
 588 /* 47 */ {204, (CH_LOWER_SB)},
 589 /* 48 */ {208, (CH_UPPER_SB)},
 590 /* 49 */ {212, (CH_LOWER_SB)},
 591 /* 50 */ {216, (CH_LOWER_SB)}
 592 };
 593 #endif                          /* SUPPORT_40MHZ */
 594
 595 static const locale_info_t *wlc_get_locale_2g(u8 locale_idx)
 596 {
 597         if (locale_idx >= ARRAY_SIZE(g_locale_2g_table)) {
 598                 WL_ERROR("%s: locale 2g index size out of range %d\n",
 599                          __func__, locale_idx);
 600                 ASSERT(locale_idx < ARRAY_SIZE(g_locale_2g_table));
 601                 return NULL;
 602         }
 603         return g_locale_2g_table[locale_idx];
 604 }
 605
 606 static const locale_info_t *wlc_get_locale_5g(u8 locale_idx)
 607 {
 608         if (locale_idx >= ARRAY_SIZE(g_locale_5g_table)) {
 609                 WL_ERROR("%s: locale 5g index size out of range %d\n",
 610                          __func__, locale_idx);
 611                 ASSERT(locale_idx < ARRAY_SIZE(g_locale_5g_table));
 612                 return NULL;
 613         }
 614         return g_locale_5g_table[locale_idx];
 615 }
 616
 617 const locale_mimo_info_t *wlc_get_mimo_2g(u8 locale_idx)
 618 {
 619         if (locale_idx >= ARRAY_SIZE(g_mimo_2g_table)) {
 620                 WL_ERROR("%s: mimo 2g index size out of range %d\n",
 621                          __func__, locale_idx);
 622                 return NULL;
 623         }
 624         return g_mimo_2g_table[locale_idx];
 625 }
 626
 627 const locale_mimo_info_t *wlc_get_mimo_5g(u8 locale_idx)
 628 {
 629         if (locale_idx >= ARRAY_SIZE(g_mimo_5g_table)) {
 630                 WL_ERROR("%s: mimo 5g index size out of range %d\n",
 631                          __func__, locale_idx);
 632                 return NULL;
 633         }
 634         return g_mimo_5g_table[locale_idx];
 635 }
 636
 637 wlc_cm_info_t *wlc_channel_mgr_attach(struct wlc_info *wlc)
 638 {
 639         wlc_cm_info_t *wlc_cm;
 640         char country_abbrev[WLC_CNTRY_BUF_SZ];
 641         const country_info_t *country;
 642         struct wlc_pub *pub = wlc->pub;
 643         char *ccode;
 644
 645         WL_TRACE("wl%d: wlc_channel_mgr_attach\n", wlc->pub->unit);
 646
 647         wlc_cm = kzalloc(sizeof(wlc_cm_info_t), GFP_ATOMIC);
 648         if (wlc_cm == NULL) {
 649                 WL_ERROR("wl%d: %s: out of memory", pub->unit, __func__);
 650                 return NULL;
 651         }
 652         wlc_cm->pub = pub;
 653         wlc_cm->wlc = wlc;
 654         wlc->cmi = wlc_cm;
 655
 656         /* store the country code for passing up as a regulatory hint */
 657         ccode = getvar(wlc->pub->vars, "ccode");
 658         if (ccode) {
 659                 strncpy(wlc->pub->srom_ccode, ccode, WLC_CNTRY_BUF_SZ - 1);
 660                 WL_NONE("%s: SROM country code is %c%c\n",
 661                         __func__,
 662                         wlc->pub->srom_ccode[0], wlc->pub->srom_ccode[1]);
 663         }
 664
 665         /* internal country information which must match regulatory constraints in firmware */
 666         memset(country_abbrev, 0, WLC_CNTRY_BUF_SZ);
 667         strncpy(country_abbrev, "X2", sizeof(country_abbrev) - 1);
 668         country = wlc_country_lookup(wlc, country_abbrev);
 669
 670         ASSERT(country != NULL);
 671
 672         /* save default country for exiting 11d regulatory mode */
 673         strncpy(wlc->country_default, country_abbrev, WLC_CNTRY_BUF_SZ - 1);
 674
 675         /* initialize autocountry_default to driver default */
 676         strncpy(wlc->autocountry_default, "X2", WLC_CNTRY_BUF_SZ - 1);
 677
 678         wlc_set_countrycode(wlc_cm, country_abbrev);
 679
 680         return wlc_cm;
 681 }
 682
 683 void wlc_channel_mgr_detach(wlc_cm_info_t *wlc_cm)
 684 {
 685         kfree(wlc_cm);
 686 }
 687
 688 u8 wlc_channel_locale_flags_in_band(wlc_cm_info_t *wlc_cm, uint bandunit)
 689 {
 690         return wlc_cm->bandstate[bandunit].locale_flags;
 691 }
 692
 693 /* set the driver's current country and regulatory information using a country code
 694  * as the source. Lookup built in country information found with the country code.
 695  */
 696 static int wlc_set_countrycode(wlc_cm_info_t *wlc_cm, const char *ccode)
 697 {
 698         char country_abbrev[WLC_CNTRY_BUF_SZ];
 699         strncpy(country_abbrev, ccode, WLC_CNTRY_BUF_SZ);
 700         return wlc_set_countrycode_rev(wlc_cm, country_abbrev, ccode, -1);
 701 }
 702
 703 static int
 704 wlc_set_countrycode_rev(wlc_cm_info_t *wlc_cm,
 705                         const char *country_abbrev,
 706                         const char *ccode, int regrev)
 707 {
 708         const country_info_t *country;
 709         char mapped_ccode[WLC_CNTRY_BUF_SZ];
 710         uint mapped_regrev;
 711
 712         WL_NONE("%s: (country_abbrev \"%s\", ccode \"%s\", regrev %d) SPROM \"%s\"/%u\n",
 713                 __func__, country_abbrev, ccode, regrev,
 714                 wlc_cm->srom_ccode, wlc_cm->srom_regrev);
 715
 716         /* if regrev is -1, lookup the mapped country code,
 717          * otherwise use the ccode and regrev directly
 718          */
 719         if (regrev == -1) {
 720                 /* map the country code to a built-in country code, regrev, and country_info */
 721                 country =
 722                     wlc_countrycode_map(wlc_cm, ccode, mapped_ccode,
 723                                         &mapped_regrev);
 724         } else {
 725                 /* find the matching built-in country definition */
 726                 ASSERT(0);
 727                 country = wlc_country_lookup_direct(ccode, regrev);
 728                 strncpy(mapped_ccode, ccode, WLC_CNTRY_BUF_SZ);
 729                 mapped_regrev = regrev;
 730         }
 731
 732         if (country == NULL)
 733                 return BCME_BADARG;
 734
 735         /* set the driver state for the country */
 736         wlc_set_country_common(wlc_cm, country_abbrev, mapped_ccode,
 737                                mapped_regrev, country);
 738
 739         return 0;
 740 }
 741
 742 /* set the driver's current country and regulatory information using a country code
 743  * as the source. Look up built in country information found with the country code.
 744  */
 745 static void
 746 wlc_set_country_common(wlc_cm_info_t *wlc_cm,
 747                        const char *country_abbrev,
 748                        const char *ccode, uint regrev,
 749                        const country_info_t *country)
 750 {
 751         const locale_mimo_info_t *li_mimo;
 752         const locale_info_t *locale;
 753         struct wlc_info *wlc = wlc_cm->wlc;
 754         char prev_country_abbrev[WLC_CNTRY_BUF_SZ];
 755
 756         ASSERT(country != NULL);
 757
 758         /* save current country state */
 759         wlc_cm->country = country;
 760
 761         memset(&prev_country_abbrev, 0, WLC_CNTRY_BUF_SZ);
 762         strncpy(prev_country_abbrev, wlc_cm->country_abbrev,
 763                 WLC_CNTRY_BUF_SZ - 1);
 764
 765         strncpy(wlc_cm->country_abbrev, country_abbrev, WLC_CNTRY_BUF_SZ - 1);
 766         strncpy(wlc_cm->ccode, ccode, WLC_CNTRY_BUF_SZ - 1);
 767         wlc_cm->regrev = regrev;
 768
 769         /* disable/restore nmode based on country regulations */
 770         li_mimo = wlc_get_mimo_2g(country->locale_mimo_2G);
 771         if (li_mimo && (li_mimo->flags & WLC_NO_MIMO)) {
 772                 wlc_set_nmode(wlc, OFF);
 773                 wlc->stf->no_cddstbc = true;
 774         } else {
 775                 wlc->stf->no_cddstbc = false;
 776                 if (N_ENAB(wlc->pub) != wlc->protection->nmode_user)
 777                         wlc_set_nmode(wlc, wlc->protection->nmode_user);
 778         }
 779
 780         wlc_stf_ss_update(wlc, wlc->bandstate[BAND_2G_INDEX]);
 781         wlc_stf_ss_update(wlc, wlc->bandstate[BAND_5G_INDEX]);
 782         /* set or restore gmode as required by regulatory */
 783         locale = wlc_get_locale_2g(country->locale_2G);
 784         if (locale && (locale->flags & WLC_NO_OFDM)) {
 785                 wlc_set_gmode(wlc, GMODE_LEGACY_B, false);
 786         } else {
 787                 wlc_set_gmode(wlc, wlc->protection->gmode_user, false);
 788         }
 789
 790         wlc_channels_init(wlc_cm, country);
 791
 792         return;
 793 }
 794
 795 /* Lookup a country info structure from a null terminated country code
 796  * The lookup is case sensitive.
 797  */
 798 static const country_info_t *wlc_country_lookup(struct wlc_info *wlc,
 799                                          const char *ccode)
 800 {
 801         const country_info_t *country;
 802         char mapped_ccode[WLC_CNTRY_BUF_SZ];
 803         uint mapped_regrev;
 804
 805         /* map the country code to a built-in country code, regrev, and country_info struct */
 806         country =
 807             wlc_countrycode_map(wlc->cmi, ccode, mapped_ccode, &mapped_regrev);
 808
 809         return country;
 810 }
 811
 812 static const country_info_t *wlc_countrycode_map(wlc_cm_info_t *wlc_cm,
 813                                                  const char *ccode,
 814                                                  char *mapped_ccode,
 815                                                  uint *mapped_regrev)
 816 {
 817         struct wlc_info *wlc = wlc_cm->wlc;
 818         const country_info_t *country;
 819         uint srom_regrev = wlc_cm->srom_regrev;
 820         const char *srom_ccode = wlc_cm->srom_ccode;
 821         int mapped;
 822
 823         /* check for currently supported ccode size */
 824         if (strlen(ccode) > (WLC_CNTRY_BUF_SZ - 1)) {
 825                 WL_ERROR("wl%d: %s: ccode \"%s\" too long for match\n",
 826                          wlc->pub->unit, __func__, ccode);
 827                 return NULL;
 828         }
 829
 830         /* default mapping is the given ccode and regrev 0 */
 831         strncpy(mapped_ccode, ccode, WLC_CNTRY_BUF_SZ);
 832         *mapped_regrev = 0;
 833
 834         /* If the desired country code matches the srom country code,
 835          * then the mapped country is the srom regulatory rev.
 836          * Otherwise look for an aggregate mapping.
 837          */
 838         if (!strcmp(srom_ccode, ccode)) {
 839                 *mapped_regrev = srom_regrev;
 840                 mapped = 0;
 841                 WL_ERROR("srom_code == ccode %s\n", __func__);
 842                 ASSERT(0);
 843         } else {
 844                 mapped =
 845                     wlc_country_aggregate_map(wlc_cm, ccode, mapped_ccode,
 846                                               mapped_regrev);
 847         }
 848
 849         /* find the matching built-in country definition */
 850         country = wlc_country_lookup_direct(mapped_ccode, *mapped_regrev);
 851
 852         /* if there is not an exact rev match, default to rev zero */
 853         if (country == NULL && *mapped_regrev != 0) {
 854                 *mapped_regrev = 0;
 855                 ASSERT(0);
 856                 country =
 857                     wlc_country_lookup_direct(mapped_ccode, *mapped_regrev);
 858         }
 859
 860         return country;
 861 }
 862
 863 static int
 864 wlc_country_aggregate_map(wlc_cm_info_t *wlc_cm, const char *ccode,
 865                           char *mapped_ccode, uint *mapped_regrev)
 866 {
 867         return false;
 868 }
 869
 870 /* Lookup a country info structure from a null terminated country
 871  * abbreviation and regrev directly with no translation.
 872  */
 873 static const country_info_t *wlc_country_lookup_direct(const char *ccode,
 874                                                        uint regrev)
 875 {
 876         uint size, i;
 877
 878         /* Should just return 0 for single locale driver. */
 879         /* Keep it this way in case we add more locales. (for now anyway) */
 880
 881         /* all other country def arrays are for regrev == 0, so if regrev is non-zero, fail */
 882         if (regrev > 0)
 883                 return NULL;
 884
 885         /* find matched table entry from country code */
 886         size = ARRAY_SIZE(cntry_locales);
 887         for (i = 0; i < size; i++) {
 888                 if (strcmp(ccode, cntry_locales[i].abbrev) == 0) {
 889                         return &cntry_locales[i].country;
 890                 }
 891         }
 892
 893         WL_ERROR("%s: Returning NULL\n", __func__);
 894         ASSERT(0);
 895         return NULL;
 896 }
 897
 898 static int
 899 wlc_channels_init(wlc_cm_info_t *wlc_cm, const country_info_t *country)
 900 {
 901         struct wlc_info *wlc = wlc_cm->wlc;
 902         uint i, j;
 903         struct wlcband *band;
 904         const locale_info_t *li;
 905         chanvec_t sup_chan;
 906         const locale_mimo_info_t *li_mimo;
 907
 908         band = wlc->band;
 909         for (i = 0; i < NBANDS(wlc);
 910              i++, band = wlc->bandstate[OTHERBANDUNIT(wlc)]) {
 911
 912                 li = BAND_5G(band->bandtype) ?
 913                     wlc_get_locale_5g(country->locale_5G) :
 914                     wlc_get_locale_2g(country->locale_2G);
 915                 ASSERT(li);
 916                 wlc_cm->bandstate[band->bandunit].locale_flags = li->flags;
 917                 li_mimo = BAND_5G(band->bandtype) ?
 918                     wlc_get_mimo_5g(country->locale_mimo_5G) :
 919                     wlc_get_mimo_2g(country->locale_mimo_2G);
 920                 ASSERT(li_mimo);
 921
 922                 /* merge the mimo non-mimo locale flags */
 923                 wlc_cm->bandstate[band->bandunit].locale_flags |=
 924                     li_mimo->flags;
 925
 926                 wlc_cm->bandstate[band->bandunit].restricted_channels =
 927                     g_table_restricted_chan[li->restricted_channels];
 928                 wlc_cm->bandstate[band->bandunit].radar_channels =
 929                     g_table_radar_set[li->radar_channels];
 930
 931                 /* set the channel availability,
 932                  * masking out the channels that may not be supported on this phy
 933                  */
 934                 wlc_phy_chanspec_band_validch(band->pi, band->bandtype,
 935                                               &sup_chan);
 936                 wlc_locale_get_channels(li,
 937                                         &wlc_cm->bandstate[band->bandunit].
 938                                         valid_channels);
 939                 for (j = 0; j < sizeof(chanvec_t); j++)
 940                         wlc_cm->bandstate[band->bandunit].valid_channels.
 941                             vec[j] &= sup_chan.vec[j];
 942         }
 943
 944         wlc_quiet_channels_reset(wlc_cm);
 945         wlc_channels_commit(wlc_cm);
 946
 947         return 0;
 948 }
 949
 950 /* Update the radio state (enable/disable) and tx power targets
 951  * based on a new set of channel/regulatory information
 952  */
 953 static void wlc_channels_commit(wlc_cm_info_t *wlc_cm)
 954 {
 955         struct wlc_info *wlc = wlc_cm->wlc;
 956         uint chan;
 957         struct txpwr_limits txpwr;
 958
 959         /* search for the existence of any valid channel */
 960         for (chan = 0; chan < MAXCHANNEL; chan++) {
 961                 if (VALID_CHANNEL20_DB(wlc, chan)) {
 962                         break;
 963                 }
 964         }
 965         if (chan == MAXCHANNEL)
 966                 chan = INVCHANNEL;
 967
 968         /* based on the channel search above, set or clear WL_RADIO_COUNTRY_DISABLE */
 969         if (chan == INVCHANNEL) {
 970                 /* country/locale with no valid channels, set the radio disable bit */
 971                 mboolset(wlc->pub->radio_disabled, WL_RADIO_COUNTRY_DISABLE);
 972                 WL_ERROR("wl%d: %s: no valid channel for \"%s\" nbands %d bandlocked %d\n",
 973                          wlc->pub->unit, __func__,
 974                          wlc_cm->country_abbrev, NBANDS(wlc), wlc->bandlocked);
 975         } else
 976             if (mboolisset(wlc->pub->radio_disabled,
 977                 WL_RADIO_COUNTRY_DISABLE)) {
 978                 /* country/locale with valid channel, clear the radio disable bit */
 979                 mboolclr(wlc->pub->radio_disabled, WL_RADIO_COUNTRY_DISABLE);
 980         }
 981
 982         /* Now that the country abbreviation is set, if the radio supports 2G, then
 983          * set channel 14 restrictions based on the new locale.
 984          */
 985         if (NBANDS(wlc) > 1 || BAND_2G(wlc->band->bandtype)) {
 986                 wlc_phy_chanspec_ch14_widefilter_set(wlc->band->pi,
 987                                                      wlc_japan(wlc) ? true :
 988                                                      false);
 989         }
 990
 991         if (wlc->pub->up && chan != INVCHANNEL) {
 992                 wlc_channel_reg_limits(wlc_cm, wlc->chanspec, &txpwr);
 993                 wlc_channel_min_txpower_limits_with_local_constraint(wlc_cm,
 994                                                                      &txpwr,
 995                                                                      WLC_TXPWR_MAX);
 996                 wlc_phy_txpower_limit_set(wlc->band->pi, &txpwr, wlc->chanspec);
 997         }
 998 }
 999
1000 /* reset the quiet channels vector to the union of the restricted and radar channel sets */
1001 static void wlc_quiet_channels_reset(wlc_cm_info_t *wlc_cm)
1002 {
1003         struct wlc_info *wlc = wlc_cm->wlc;
1004         uint i, j;
1005         struct wlcband *band;
1006         const chanvec_t *chanvec;
1007
1008         memset(&wlc_cm->quiet_channels, 0, sizeof(chanvec_t));
1009
1010         band = wlc->band;
1011         for (i = 0; i < NBANDS(wlc);
1012              i++, band = wlc->bandstate[OTHERBANDUNIT(wlc)]) {
1013
1014                 /* initialize quiet channels for restricted channels */
1015                 chanvec = wlc_cm->bandstate[band->bandunit].restricted_channels;
1016                 for (j = 0; j < sizeof(chanvec_t); j++)
1017                         wlc_cm->quiet_channels.vec[j] |= chanvec->vec[j];
1018
1019         }
1020 }
1021
1022 static bool wlc_quiet_chanspec(wlc_cm_info_t *wlc_cm, chanspec_t chspec)
1023 {
1024         return N_ENAB(wlc_cm->wlc->pub) && CHSPEC_IS40(chspec) ?
1025                 (isset
1026                  (wlc_cm->quiet_channels.vec,
1027                   LOWER_20_SB(CHSPEC_CHANNEL(chspec)))
1028                  || isset(wlc_cm->quiet_channels.vec,
1029                           UPPER_20_SB(CHSPEC_CHANNEL(chspec)))) : isset(wlc_cm->
1030                                                                         quiet_channels.
1031                                                                         vec,
1032                                                                         CHSPEC_CHANNEL
1033                                                                         (chspec));
1034 }
1035
1036 /* Is the channel valid for the current locale? (but don't consider channels not
1037  *   available due to bandlocking)
1038  */
1039 static bool wlc_valid_channel20_db(wlc_cm_info_t *wlc_cm, uint val)
1040 {
1041         struct wlc_info *wlc = wlc_cm->wlc;
1042
1043         return VALID_CHANNEL20(wlc, val) ||
1044                 (!wlc->bandlocked
1045                  && VALID_CHANNEL20_IN_BAND(wlc, OTHERBANDUNIT(wlc), val));
1046 }
1047
1048 /* Is the channel valid for the current locale and specified band? */
1049 static bool
1050 wlc_valid_channel20_in_band(wlc_cm_info_t *wlc_cm, uint bandunit, uint val)
1051 {
1052         return ((val < MAXCHANNEL)
1053                 && isset(wlc_cm->bandstate[bandunit].valid_channels.vec, val));
1054 }
1055
1056 /* Is the channel valid for the current locale and current band? */
1057 static bool wlc_valid_channel20(wlc_cm_info_t *wlc_cm, uint val)
1058 {
1059         struct wlc_info *wlc = wlc_cm->wlc;
1060
1061         return ((val < MAXCHANNEL) &&
1062                 isset(wlc_cm->bandstate[wlc->band->bandunit].valid_channels.vec,
1063                       val));
1064 }
1065
1066 static void
1067 wlc_channel_min_txpower_limits_with_local_constraint(wlc_cm_info_t *wlc_cm,
1068                                                      struct txpwr_limits *txpwr,
1069                                                      u8
1070                                                      local_constraint_qdbm)
1071 {
1072         int j;
1073
1074         /* CCK Rates */
1075         for (j = 0; j < WL_TX_POWER_CCK_NUM; j++) {
1076                 txpwr->cck[j] = min(txpwr->cck[j], local_constraint_qdbm);
1077         }
1078
1079         /* 20 MHz Legacy OFDM SISO */
1080         for (j = 0; j < WL_TX_POWER_OFDM_NUM; j++) {
1081                 txpwr->ofdm[j] = min(txpwr->ofdm[j], local_constraint_qdbm);
1082         }
1083
1084         /* 20 MHz Legacy OFDM CDD */
1085         for (j = 0; j < WLC_NUM_RATES_OFDM; j++) {
1086                 txpwr->ofdm_cdd[j] =
1087                     min(txpwr->ofdm_cdd[j], local_constraint_qdbm);
1088         }
1089
1090         /* 40 MHz Legacy OFDM SISO */
1091         for (j = 0; j < WLC_NUM_RATES_OFDM; j++) {
1092                 txpwr->ofdm_40_siso[j] =
1093                     min(txpwr->ofdm_40_siso[j], local_constraint_qdbm);
1094         }
1095
1096         /* 40 MHz Legacy OFDM CDD */
1097         for (j = 0; j < WLC_NUM_RATES_OFDM; j++) {
1098                 txpwr->ofdm_40_cdd[j] =
1099                     min(txpwr->ofdm_40_cdd[j], local_constraint_qdbm);
1100         }
1101
1102         /* 20MHz MCS 0-7 SISO */
1103         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1104                 txpwr->mcs_20_siso[j] =
1105                     min(txpwr->mcs_20_siso[j], local_constraint_qdbm);
1106         }
1107
1108         /* 20MHz MCS 0-7 CDD */
1109         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1110                 txpwr->mcs_20_cdd[j] =
1111                     min(txpwr->mcs_20_cdd[j], local_constraint_qdbm);
1112         }
1113
1114         /* 20MHz MCS 0-7 STBC */
1115         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1116                 txpwr->mcs_20_stbc[j] =
1117                     min(txpwr->mcs_20_stbc[j], local_constraint_qdbm);
1118         }
1119
1120         /* 20MHz MCS 8-15 MIMO */
1121         for (j = 0; j < WLC_NUM_RATES_MCS_2_STREAM; j++)
1122                 txpwr->mcs_20_mimo[j] =
1123                     min(txpwr->mcs_20_mimo[j], local_constraint_qdbm);
1124
1125         /* 40MHz MCS 0-7 SISO */
1126         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1127                 txpwr->mcs_40_siso[j] =
1128                     min(txpwr->mcs_40_siso[j], local_constraint_qdbm);
1129         }
1130
1131         /* 40MHz MCS 0-7 CDD */
1132         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1133                 txpwr->mcs_40_cdd[j] =
1134                     min(txpwr->mcs_40_cdd[j], local_constraint_qdbm);
1135         }
1136
1137         /* 40MHz MCS 0-7 STBC */
1138         for (j = 0; j < WLC_NUM_RATES_MCS_1_STREAM; j++) {
1139                 txpwr->mcs_40_stbc[j] =
1140                     min(txpwr->mcs_40_stbc[j], local_constraint_qdbm);
1141         }
1142
1143         /* 40MHz MCS 8-15 MIMO */
1144         for (j = 0; j < WLC_NUM_RATES_MCS_2_STREAM; j++)
1145                 txpwr->mcs_40_mimo[j] =
1146                     min(txpwr->mcs_40_mimo[j], local_constraint_qdbm);
1147
1148         /* 40MHz MCS 32 */
1149         txpwr->mcs32 = min(txpwr->mcs32, local_constraint_qdbm);
1150
1151 }
1152
1153 void
1154 wlc_channel_set_chanspec(wlc_cm_info_t *wlc_cm, chanspec_t chanspec,
1155                          u8 local_constraint_qdbm)
1156 {
1157         struct wlc_info *wlc = wlc_cm->wlc;
1158         struct txpwr_limits txpwr;
1159
1160         wlc_channel_reg_limits(wlc_cm, chanspec, &txpwr);
1161
1162         wlc_channel_min_txpower_limits_with_local_constraint(wlc_cm, &txpwr,
1163                                                              local_constraint_qdbm);
1164
1165         wlc_bmac_set_chanspec(wlc->hw, chanspec,
1166                               (wlc_quiet_chanspec(wlc_cm, chanspec) != 0),
1167                               &txpwr);
1168 }
1169
1170 #ifdef POWER_DBG
1171 static void wlc_phy_txpower_limits_dump(txpwr_limits_t *txpwr)
1172 {
1173         int i;
1174         char buf[80];
1175         char fraction[4][4] = { "   ", ".25", ".5 ", ".75" };
1176
1177         sprintf(buf, "CCK                ");
1178         for (i = 0; i < WLC_NUM_RATES_CCK; i++) {
1179                 sprintf(buf[strlen(buf)], " %2d%s",
1180                         txpwr->cck[i] / WLC_TXPWR_DB_FACTOR,
1181                         fraction[txpwr->cck[i] % WLC_TXPWR_DB_FACTOR]);
1182         }
1183         printk(KERN_DEBUG "%s\n", buf);
1184
1185         sprintf(buf, "20 MHz OFDM SISO   ");
1186         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1187                 sprintf(buf[strlen(buf)], " %2d%s",
1188                         txpwr->ofdm[i] / WLC_TXPWR_DB_FACTOR,
1189                         fraction[txpwr->ofdm[i] % WLC_TXPWR_DB_FACTOR]);
1190         }
1191         printk(KERN_DEBUG "%s\n", buf);
1192
1193         sprintf(buf, "20 MHz OFDM CDD    ");
1194         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1195                 sprintf(buf[strlen(buf)], " %2d%s",
1196                         txpwr->ofdm_cdd[i] / WLC_TXPWR_DB_FACTOR,
1197                         fraction[txpwr->ofdm_cdd[i] % WLC_TXPWR_DB_FACTOR]);
1198         }
1199         printk(KERN_DEBUG "%s\n", buf);
1200
1201         sprintf(buf, "40 MHz OFDM SISO   ");
1202         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1203                 sprintf(buf[strlen(buf)], " %2d%s",
1204                         txpwr->ofdm_40_siso[i] / WLC_TXPWR_DB_FACTOR,
1205                         fraction[txpwr->ofdm_40_siso[i] % WLC_TXPWR_DB_FACTOR]);
1206         }
1207         printk(KERN_DEBUG "%s\n", buf);
1208
1209         sprintf(buf, "40 MHz OFDM CDD    ");
1210         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1211                 sprintf(buf[strlen(buf)], " %2d%s",
1212                         txpwr->ofdm_40_cdd[i] / WLC_TXPWR_DB_FACTOR,
1213                         fraction[txpwr->ofdm_40_cdd[i] % WLC_TXPWR_DB_FACTOR]);
1214         }
1215         printk(KERN_DEBUG "%s\n", buf);
1216
1217         sprintf(buf, "20 MHz MCS0-7 SISO ");
1218         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1219                 sprintf(buf[strlen(buf)], " %2d%s",
1220                         txpwr->mcs_20_siso[i] / WLC_TXPWR_DB_FACTOR,
1221                         fraction[txpwr->mcs_20_siso[i] % WLC_TXPWR_DB_FACTOR]);
1222         }
1223         printk(KERN_DEBUG "%s\n", buf);
1224
1225         sprintf(buf, "20 MHz MCS0-7 CDD  ");
1226         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1227                 sprintf(buf[strlen(buf)], " %2d%s",
1228                         txpwr->mcs_20_cdd[i] / WLC_TXPWR_DB_FACTOR,
1229                         fraction[txpwr->mcs_20_cdd[i] % WLC_TXPWR_DB_FACTOR]);
1230         }
1231         printk(KERN_DEBUG "%s\n", buf);
1232
1233         sprintf(buf, "20 MHz MCS0-7 STBC ");
1234         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1235                 sprintf(buf[strlen(buf)], " %2d%s",
1236                         txpwr->mcs_20_stbc[i] / WLC_TXPWR_DB_FACTOR,
1237                         fraction[txpwr->mcs_20_stbc[i] % WLC_TXPWR_DB_FACTOR]);
1238         }
1239         printk(KERN_DEBUG "%s\n", buf);
1240
1241         sprintf(buf, "20 MHz MCS8-15 SDM ");
1242         for (i = 0; i < WLC_NUM_RATES_MCS_2_STREAM; i++) {
1243                 sprintf(buf[strlen(buf)], " %2d%s",
1244                         txpwr->mcs_20_mimo[i] / WLC_TXPWR_DB_FACTOR,
1245                         fraction[txpwr->mcs_20_mimo[i] % WLC_TXPWR_DB_FACTOR]);
1246         }
1247         printk(KERN_DEBUG "%s\n", buf);
1248
1249         sprintf(buf, "40 MHz MCS0-7 SISO ");
1250         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1251                 sprintf(buf[strlen(buf)], " %2d%s",
1252                         txpwr->mcs_40_siso[i] / WLC_TXPWR_DB_FACTOR,
1253                         fraction[txpwr->mcs_40_siso[i] % WLC_TXPWR_DB_FACTOR]);
1254         }
1255         printk(KERN_DEBUG "%s\n", buf);
1256
1257         sprintf(buf, "40 MHz MCS0-7 CDD  ");
1258         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1259                 sprintf(buf[strlen(buf)], " %2d%s",
1260                         txpwr->mcs_40_cdd[i] / WLC_TXPWR_DB_FACTOR,
1261                         fraction[txpwr->mcs_40_cdd[i] % WLC_TXPWR_DB_FACTOR]);
1262         }
1263         printk(KERN_DEBUG "%s\n", buf);
1264
1265         sprintf(buf, "40 MHz MCS0-7 STBC ");
1266         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1267                 sprintf(buf[strlen(buf)], " %2d%s",
1268                         txpwr->mcs_40_stbc[i] / WLC_TXPWR_DB_FACTOR,
1269                         fraction[txpwr->mcs_40_stbc[i] % WLC_TXPWR_DB_FACTOR]);
1270         }
1271         printk(KERN_DEBUG "%s\n", buf);
1272
1273         sprintf(buf, "40 MHz MCS8-15 SDM ");
1274         for (i = 0; i < WLC_NUM_RATES_MCS_2_STREAM; i++) {
1275                 sprintf(buf[strlen(buf)], " %2d%s",
1276                         txpwr->mcs_40_mimo[i] / WLC_TXPWR_DB_FACTOR,
1277                         fraction[txpwr->mcs_40_mimo[i] % WLC_TXPWR_DB_FACTOR]);
1278         }
1279         printk(KERN_DEBUG "%s\n", buf);
1280
1281         printk(KERN_DEBUG "MCS32               %2d%s\n",
1282                txpwr->mcs32 / WLC_TXPWR_DB_FACTOR,
1283                fraction[txpwr->mcs32 % WLC_TXPWR_DB_FACTOR]);
1284 }
1285 #endif                          /* POWER_DBG */
1286
1287 void
1288 wlc_channel_reg_limits(wlc_cm_info_t *wlc_cm, chanspec_t chanspec,
1289                        txpwr_limits_t *txpwr)
1290 {
1291         struct wlc_info *wlc = wlc_cm->wlc;
1292         uint i;
1293         uint chan;
1294         int maxpwr;
1295         int delta;
1296         const country_info_t *country;
1297         struct wlcband *band;
1298         const locale_info_t *li;
1299         int conducted_max;
1300         int conducted_ofdm_max;
1301         const locale_mimo_info_t *li_mimo;
1302         int maxpwr20, maxpwr40;
1303         int maxpwr_idx;
1304         uint j;
1305
1306         memset(txpwr, 0, sizeof(txpwr_limits_t));
1307
1308         if (!wlc_valid_chanspec_db(wlc_cm, chanspec)) {
1309                 country = wlc_country_lookup(wlc, wlc->autocountry_default);
1310                 if (country == NULL)
1311                         return;
1312         } else {
1313                 country = wlc_cm->country;
1314         }
1315
1316         chan = CHSPEC_CHANNEL(chanspec);
1317         band = wlc->bandstate[CHSPEC_WLCBANDUNIT(chanspec)];
1318         li = BAND_5G(band->bandtype) ?
1319             wlc_get_locale_5g(country->locale_5G) :
1320             wlc_get_locale_2g(country->locale_2G);
1321
1322         li_mimo = BAND_5G(band->bandtype) ?
1323             wlc_get_mimo_5g(country->locale_mimo_5G) :
1324             wlc_get_mimo_2g(country->locale_mimo_2G);
1325
1326         if (li->flags & WLC_EIRP) {
1327                 delta = band->antgain;
1328         } else {
1329                 delta = 0;
1330                 if (band->antgain > QDB(6))
1331                         delta = band->antgain - QDB(6); /* Excess over 6 dB */
1332         }
1333
1334         if (li == &locale_i) {
1335                 conducted_max = QDB(22);
1336                 conducted_ofdm_max = QDB(22);
1337         }
1338
1339         /* CCK txpwr limits for 2.4G band */
1340         if (BAND_2G(band->bandtype)) {
1341                 maxpwr = li->maxpwr[CHANNEL_POWER_IDX_2G_CCK(chan)];
1342
1343                 maxpwr = maxpwr - delta;
1344                 maxpwr = max(maxpwr, 0);
1345                 maxpwr = min(maxpwr, conducted_max);
1346
1347                 for (i = 0; i < WLC_NUM_RATES_CCK; i++)
1348                         txpwr->cck[i] = (u8) maxpwr;
1349         }
1350
1351         /* OFDM txpwr limits for 2.4G or 5G bands */
1352         if (BAND_2G(band->bandtype)) {
1353                 maxpwr = li->maxpwr[CHANNEL_POWER_IDX_2G_OFDM(chan)];
1354
1355         } else {
1356                 maxpwr = li->maxpwr[CHANNEL_POWER_IDX_5G(chan)];
1357         }
1358
1359         maxpwr = maxpwr - delta;
1360         maxpwr = max(maxpwr, 0);
1361         maxpwr = min(maxpwr, conducted_ofdm_max);
1362
1363         /* Keep OFDM lmit below CCK limit */
1364         if (BAND_2G(band->bandtype))
1365                 maxpwr = min_t(int, maxpwr, txpwr->cck[0]);
1366
1367         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1368                 txpwr->ofdm[i] = (u8) maxpwr;
1369         }
1370
1371         for (i = 0; i < WLC_NUM_RATES_OFDM; i++) {
1372                 /* OFDM 40 MHz SISO has the same power as the corresponding MCS0-7 rate unless
1373                  * overriden by the locale specific code. We set this value to 0 as a
1374                  * flag (presumably 0 dBm isn't a possibility) and then copy the MCS0-7 value
1375                  * to the 40 MHz value if it wasn't explicitly set.
1376                  */
1377                 txpwr->ofdm_40_siso[i] = 0;
1378
1379                 txpwr->ofdm_cdd[i] = (u8) maxpwr;
1380
1381                 txpwr->ofdm_40_cdd[i] = 0;
1382         }
1383
1384         /* MIMO/HT specific limits */
1385         if (li_mimo->flags & WLC_EIRP) {
1386                 delta = band->antgain;
1387         } else {
1388                 delta = 0;
1389                 if (band->antgain > QDB(6))
1390                         delta = band->antgain - QDB(6); /* Excess over 6 dB */
1391         }
1392
1393         if (BAND_2G(band->bandtype))
1394                 maxpwr_idx = (chan - 1);
1395         else
1396                 maxpwr_idx = CHANNEL_POWER_IDX_5G(chan);
1397
1398         maxpwr20 = li_mimo->maxpwr20[maxpwr_idx];
1399         maxpwr40 = li_mimo->maxpwr40[maxpwr_idx];
1400
1401         maxpwr20 = maxpwr20 - delta;
1402         maxpwr20 = max(maxpwr20, 0);
1403         maxpwr40 = maxpwr40 - delta;
1404         maxpwr40 = max(maxpwr40, 0);
1405
1406         /* Fill in the MCS 0-7 (SISO) rates */
1407         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1408
1409                 /* 20 MHz has the same power as the corresponding OFDM rate unless
1410                  * overriden by the locale specific code.
1411                  */
1412                 txpwr->mcs_20_siso[i] = txpwr->ofdm[i];
1413                 txpwr->mcs_40_siso[i] = 0;
1414         }
1415
1416         /* Fill in the MCS 0-7 CDD rates */
1417         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1418                 txpwr->mcs_20_cdd[i] = (u8) maxpwr20;
1419                 txpwr->mcs_40_cdd[i] = (u8) maxpwr40;
1420         }
1421
1422         /* These locales have SISO expressed in the table and override CDD later */
1423         if (li_mimo == &locale_bn) {
1424                 if (li_mimo == &locale_bn) {
1425                         maxpwr20 = QDB(16);
1426                         maxpwr40 = 0;
1427
1428                         if (chan >= 3 && chan <= 11) {
1429                                 maxpwr40 = QDB(16);
1430                         }
1431                 }
1432
1433                 for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1434                         txpwr->mcs_20_siso[i] = (u8) maxpwr20;
1435                         txpwr->mcs_40_siso[i] = (u8) maxpwr40;
1436                 }
1437         }
1438
1439         /* Fill in the MCS 0-7 STBC rates */
1440         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1441                 txpwr->mcs_20_stbc[i] = 0;
1442                 txpwr->mcs_40_stbc[i] = 0;
1443         }
1444
1445         /* Fill in the MCS 8-15 SDM rates */
1446         for (i = 0; i < WLC_NUM_RATES_MCS_2_STREAM; i++) {
1447                 txpwr->mcs_20_mimo[i] = (u8) maxpwr20;
1448                 txpwr->mcs_40_mimo[i] = (u8) maxpwr40;
1449         }
1450
1451         /* Fill in MCS32 */
1452         txpwr->mcs32 = (u8) maxpwr40;
1453
1454         for (i = 0, j = 0; i < WLC_NUM_RATES_OFDM; i++, j++) {
1455                 if (txpwr->ofdm_40_cdd[i] == 0)
1456                         txpwr->ofdm_40_cdd[i] = txpwr->mcs_40_cdd[j];
1457                 if (i == 0) {
1458                         i = i + 1;
1459                         if (txpwr->ofdm_40_cdd[i] == 0)
1460                                 txpwr->ofdm_40_cdd[i] = txpwr->mcs_40_cdd[j];
1461                 }
1462         }
1463
1464         /* Copy the 40 MHZ MCS 0-7 CDD value to the 40 MHZ MCS 0-7 SISO value if it wasn't
1465          * provided explicitly.
1466          */
1467
1468         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1469                 if (txpwr->mcs_40_siso[i] == 0)
1470                         txpwr->mcs_40_siso[i] = txpwr->mcs_40_cdd[i];
1471         }
1472
1473         for (i = 0, j = 0; i < WLC_NUM_RATES_OFDM; i++, j++) {
1474                 if (txpwr->ofdm_40_siso[i] == 0)
1475                         txpwr->ofdm_40_siso[i] = txpwr->mcs_40_siso[j];
1476                 if (i == 0) {
1477                         i = i + 1;
1478                         if (txpwr->ofdm_40_siso[i] == 0)
1479                                 txpwr->ofdm_40_siso[i] = txpwr->mcs_40_siso[j];
1480                 }
1481         }
1482
1483         /* Copy the 20 and 40 MHz MCS0-7 CDD values to the corresponding STBC values if they weren't
1484          * provided explicitly.
1485          */
1486         for (i = 0; i < WLC_NUM_RATES_MCS_1_STREAM; i++) {
1487                 if (txpwr->mcs_20_stbc[i] == 0)
1488                         txpwr->mcs_20_stbc[i] = txpwr->mcs_20_cdd[i];
1489
1490                 if (txpwr->mcs_40_stbc[i] == 0)
1491                         txpwr->mcs_40_stbc[i] = txpwr->mcs_40_cdd[i];
1492         }
1493
1494 #ifdef POWER_DBG
1495         wlc_phy_txpower_limits_dump(txpwr);
1496 #endif
1497         return;
1498 }
1499
1500 /* Returns true if currently set country is Japan or variant */
1501 static bool wlc_japan(struct wlc_info *wlc)
1502 {
1503         return wlc_japan_ccode(wlc->cmi->country_abbrev);
1504 }
1505
1506 /* JP, J1 - J10 are Japan ccodes */
1507 static bool wlc_japan_ccode(const char *ccode)
1508 {
1509         return (ccode[0] == 'J' &&
1510                 (ccode[1] == 'P' || (ccode[1] >= '1' && ccode[1] <= '9')));
1511 }
1512
1513 /*
1514  * Validate the chanspec for this locale, for 40MHZ we need to also check that the sidebands
1515  * are valid 20MZH channels in this locale and they are also a legal HT combination
1516  */
1517 static bool
1518 wlc_valid_chanspec_ext(wlc_cm_info_t *wlc_cm, chanspec_t chspec, bool dualband)
1519 {
1520         struct wlc_info *wlc = wlc_cm->wlc;
1521         u8 channel = CHSPEC_CHANNEL(chspec);
1522
1523         /* check the chanspec */
1524         if (wf_chspec_malformed(chspec)) {
1525                 WL_ERROR("wl%d: malformed chanspec 0x%x\n",
1526                          wlc->pub->unit, chspec);
1527                 ASSERT(0);
1528                 return false;
1529         }
1530
1531         if (CHANNEL_BANDUNIT(wlc_cm->wlc, channel) !=
1532             CHSPEC_WLCBANDUNIT(chspec))
1533                 return false;
1534
1535         /* Check a 20Mhz channel */
1536         if (CHSPEC_IS20(chspec)) {
1537                 if (dualband)
1538                         return VALID_CHANNEL20_DB(wlc_cm->wlc, channel);
1539                 else
1540                         return VALID_CHANNEL20(wlc_cm->wlc, channel);
1541         }
1542 #ifdef SUPPORT_40MHZ
1543         /* We know we are now checking a 40MHZ channel, so we should only be here
1544          * for NPHYS
1545          */
1546         if (WLCISNPHY(wlc->band) || WLCISSSLPNPHY(wlc->band)) {
1547                 u8 upper_sideband = 0, idx;
1548                 u8 num_ch20_entries =
1549                     sizeof(chan20_info) / sizeof(struct chan20_info);
1550
1551                 if (!VALID_40CHANSPEC_IN_BAND(wlc, CHSPEC_WLCBANDUNIT(chspec)))
1552                         return false;
1553
1554                 if (dualband) {
1555                         if (!VALID_CHANNEL20_DB(wlc, LOWER_20_SB(channel)) ||
1556                             !VALID_CHANNEL20_DB(wlc, UPPER_20_SB(channel)))
1557                                 return false;
1558                 } else {
1559                         if (!VALID_CHANNEL20(wlc, LOWER_20_SB(channel)) ||
1560                             !VALID_CHANNEL20(wlc, UPPER_20_SB(channel)))
1561                                 return false;
1562                 }
1563
1564                 /* find the lower sideband info in the sideband array */
1565                 for (idx = 0; idx < num_ch20_entries; idx++) {
1566                         if (chan20_info[idx].sb == LOWER_20_SB(channel))
1567                                 upper_sideband = chan20_info[idx].adj_sbs;
1568                 }
1569                 /* check that the lower sideband allows an upper sideband */
1570                 if ((upper_sideband & (CH_UPPER_SB | CH_EWA_VALID)) ==
1571                     (CH_UPPER_SB | CH_EWA_VALID))
1572                         return true;
1573                 return false;
1574         }
1575 #endif                          /* 40 MHZ */
1576
1577         return false;
1578 }
1579
1580 bool wlc_valid_chanspec_db(wlc_cm_info_t *wlc_cm, chanspec_t chspec)
1581 {
1582         return wlc_valid_chanspec_ext(wlc_cm, chspec, true);
1583 }