drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c

   1 /******************************************************************************
   2  *
   3  * This file is provided under a dual BSD/GPLv2 license.  When using or
   4  * redistributing this file, you may do so under either license.
   5  *
   6  * GPL LICENSE SUMMARY
   7  *
   8  * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
   9  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  10  * Copyright(c) 2016 Intel Deutschland GmbH
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of version 2 of the GNU General Public License as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  24  * USA
  25  *
  26  * The full GNU General Public License is included in this distribution
  27  * in the file called COPYING.
  28  *
  29  * Contact Information:
  30  *  Intel Linux Wireless <linuxwifi@intel.com>
  31  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  32  *
  33  * BSD LICENSE
  34  *
  35  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  36  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  37  * All rights reserved.
  38  *
  39  * Redistribution and use in source and binary forms, with or without
  40  * modification, are permitted provided that the following conditions
  41  * are met:
  42  *
  43  *  * Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  *  * Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in
  47  *    the documentation and/or other materials provided with the
  48  *    distribution.
  49  *  * Neither the name Intel Corporation nor the names of its
  50  *    contributors may be used to endorse or promote products derived
  51  *    from this software without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  54  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  55  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  56  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  57  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  58  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  59  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  60  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  61  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  63  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  64  *****************************************************************************/
  65 #include <linux/types.h>
  66 #include <linux/slab.h>
  67 #include <linux/export.h>
  68 #include <linux/etherdevice.h>
  69 #include <linux/pci.h>
  70 #include "iwl-drv.h"
  71 #include "iwl-modparams.h"
  72 #include "iwl-nvm-parse.h"
  73 #include "iwl-prph.h"
  74 #include "iwl-io.h"
  75 #include "iwl-csr.h"
  76
  77 /* NVM offsets (in words) definitions */
  78 enum wkp_nvm_offsets {
  79         /* NVM HW-Section offset (in words) definitions */
  80         HW_ADDR = 0x15,
  81
  82         /* NVM SW-Section offset (in words) definitions */
  83         NVM_SW_SECTION = 0x1C0,
  84         NVM_VERSION = 0,
  85         RADIO_CFG = 1,
  86         SKU = 2,
  87         N_HW_ADDRS = 3,
  88         NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
  89
  90         /* NVM calibration section offset (in words) definitions */
  91         NVM_CALIB_SECTION = 0x2B8,
  92         XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
  93 };
  94
  95 enum family_8000_nvm_offsets {
  96         /* NVM HW-Section offset (in words) definitions */
  97         HW_ADDR0_WFPM_FAMILY_8000 = 0x12,
  98         HW_ADDR1_WFPM_FAMILY_8000 = 0x16,
  99         HW_ADDR0_PCIE_FAMILY_8000 = 0x8A,
 100         HW_ADDR1_PCIE_FAMILY_8000 = 0x8E,
 101         MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
 102
 103         /* NVM SW-Section offset (in words) definitions */
 104         NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
 105         NVM_VERSION_FAMILY_8000 = 0,
 106         RADIO_CFG_FAMILY_8000 = 0,
 107         SKU_FAMILY_8000 = 2,
 108         N_HW_ADDRS_FAMILY_8000 = 3,
 109
 110         /* NVM REGULATORY -Section offset (in words) definitions */
 111         NVM_CHANNELS_FAMILY_8000 = 0,
 112         NVM_LAR_OFFSET_FAMILY_8000_OLD = 0x4C7,
 113         NVM_LAR_OFFSET_FAMILY_8000 = 0x507,
 114         NVM_LAR_ENABLED_FAMILY_8000 = 0x7,
 115
 116         /* NVM calibration section offset (in words) definitions */
 117         NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
 118         XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
 119 };
 120
 121 /* SKU Capabilities (actual values from NVM definition) */
 122 enum nvm_sku_bits {
 123         NVM_SKU_CAP_BAND_24GHZ          = BIT(0),
 124         NVM_SKU_CAP_BAND_52GHZ          = BIT(1),
 125         NVM_SKU_CAP_11N_ENABLE          = BIT(2),
 126         NVM_SKU_CAP_11AC_ENABLE         = BIT(3),
 127         NVM_SKU_CAP_MIMO_DISABLE        = BIT(5),
 128 };
 129
 130 /*
 131  * These are the channel numbers in the order that they are stored in the NVM
 132  */
 133 static const u8 iwl_nvm_channels[] = {
 134         /* 2.4 GHz */
 135         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 136         /* 5 GHz */
 137         36, 40, 44 , 48, 52, 56, 60, 64,
 138         100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 139         149, 153, 157, 161, 165
 140 };
 141
 142 static const u8 iwl_nvm_channels_family_8000[] = {
 143         /* 2.4 GHz */
 144         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 145         /* 5 GHz */
 146         36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
 147         96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 148         149, 153, 157, 161, 165, 169, 173, 177, 181
 149 };
 150
 151 #define IWL_NUM_CHANNELS                ARRAY_SIZE(iwl_nvm_channels)
 152 #define IWL_NUM_CHANNELS_FAMILY_8000    ARRAY_SIZE(iwl_nvm_channels_family_8000)
 153 #define NUM_2GHZ_CHANNELS               14
 154 #define NUM_2GHZ_CHANNELS_FAMILY_8000   14
 155 #define FIRST_2GHZ_HT_MINUS             5
 156 #define LAST_2GHZ_HT_PLUS               9
 157 #define LAST_5GHZ_HT                    165
 158 #define LAST_5GHZ_HT_FAMILY_8000        181
 159 #define N_HW_ADDR_MASK                  0xF
 160
 161 /* rate data (static) */
 162 static struct ieee80211_rate iwl_cfg80211_rates[] = {
 163         { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
 164         { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
 165           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 166         { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
 167           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 168         { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
 169           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 170         { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
 171         { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
 172         { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
 173         { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
 174         { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
 175         { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
 176         { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
 177         { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
 178 };
 179 #define RATES_24_OFFS   0
 180 #define N_RATES_24      ARRAY_SIZE(iwl_cfg80211_rates)
 181 #define RATES_52_OFFS   4
 182 #define N_RATES_52      (N_RATES_24 - RATES_52_OFFS)
 183
 184 /**
 185  * enum iwl_nvm_channel_flags - channel flags in NVM
 186  * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 187  * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 188  * @NVM_CHANNEL_ACTIVE: active scanning allowed
 189  * @NVM_CHANNEL_RADAR: radar detection required
 190  * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
 191  * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
 192  *      on same channel on 2.4 or same UNII band on 5.2
 193  * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 194  * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 195  * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
 196  * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
 197  */
 198 enum iwl_nvm_channel_flags {
 199         NVM_CHANNEL_VALID = BIT(0),
 200         NVM_CHANNEL_IBSS = BIT(1),
 201         NVM_CHANNEL_ACTIVE = BIT(3),
 202         NVM_CHANNEL_RADAR = BIT(4),
 203         NVM_CHANNEL_INDOOR_ONLY = BIT(5),
 204         NVM_CHANNEL_GO_CONCURRENT = BIT(6),
 205         NVM_CHANNEL_WIDE = BIT(8),
 206         NVM_CHANNEL_40MHZ = BIT(9),
 207         NVM_CHANNEL_80MHZ = BIT(10),
 208         NVM_CHANNEL_160MHZ = BIT(11),
 209 };
 210
 211 #define CHECK_AND_PRINT_I(x)    \
 212         ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
 213
 214 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz,
 215                                  u16 nvm_flags, const struct iwl_cfg *cfg)
 216 {
 217         u32 flags = IEEE80211_CHAN_NO_HT40;
 218         u32 last_5ghz_ht = LAST_5GHZ_HT;
 219
 220         if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
 221                 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
 222
 223         if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) {
 224                 if (ch_num <= LAST_2GHZ_HT_PLUS)
 225                         flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 226                 if (ch_num >= FIRST_2GHZ_HT_MINUS)
 227                         flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 228         } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) {
 229                 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 230                         flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 231                 else
 232                         flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 233         }
 234         if (!(nvm_flags & NVM_CHANNEL_80MHZ))
 235                 flags |= IEEE80211_CHAN_NO_80MHZ;
 236         if (!(nvm_flags & NVM_CHANNEL_160MHZ))
 237                 flags |= IEEE80211_CHAN_NO_160MHZ;
 238
 239         if (!(nvm_flags & NVM_CHANNEL_IBSS))
 240                 flags |= IEEE80211_CHAN_NO_IR;
 241
 242         if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
 243                 flags |= IEEE80211_CHAN_NO_IR;
 244
 245         if (nvm_flags & NVM_CHANNEL_RADAR)
 246                 flags |= IEEE80211_CHAN_RADAR;
 247
 248         if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
 249                 flags |= IEEE80211_CHAN_INDOOR_ONLY;
 250
 251         /* Set the GO concurrent flag only in case that NO_IR is set.
 252          * Otherwise it is meaningless
 253          */
 254         if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 255             (flags & IEEE80211_CHAN_NO_IR))
 256                 flags |= IEEE80211_CHAN_IR_CONCURRENT;
 257
 258         return flags;
 259 }
 260
 261 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 262                                 struct iwl_nvm_data *data,
 263                                 const __le16 * const nvm_ch_flags,
 264                                 bool lar_supported)
 265 {
 266         int ch_idx;
 267         int n_channels = 0;
 268         struct ieee80211_channel *channel;
 269         u16 ch_flags;
 270         bool is_5ghz;
 271         int num_of_ch, num_2ghz_channels;
 272         const u8 *nvm_chan;
 273
 274         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 275                 num_of_ch = IWL_NUM_CHANNELS;
 276                 nvm_chan = &iwl_nvm_channels[0];
 277                 num_2ghz_channels = NUM_2GHZ_CHANNELS;
 278         } else {
 279                 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
 280                 nvm_chan = &iwl_nvm_channels_family_8000[0];
 281                 num_2ghz_channels = NUM_2GHZ_CHANNELS_FAMILY_8000;
 282         }
 283
 284         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 285                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 286
 287                 if (ch_idx >= num_2ghz_channels &&
 288                     !data->sku_cap_band_52GHz_enable)
 289                         continue;
 290
 291                 if (ch_flags & NVM_CHANNEL_160MHZ)
 292                         data->vht160_supported = true;
 293
 294                 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
 295                         /*
 296                          * Channels might become valid later if lar is
 297                          * supported, hence we still want to add them to
 298                          * the list of supported channels to cfg80211.
 299                          */
 300                         IWL_DEBUG_EEPROM(dev,
 301                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 302                                          nvm_chan[ch_idx],
 303                                          ch_flags,
 304                                          (ch_idx >= num_2ghz_channels) ?
 305                                          "5.2" : "2.4");
 306                         continue;
 307                 }
 308
 309                 channel = &data->channels[n_channels];
 310                 n_channels++;
 311
 312                 channel->hw_value = nvm_chan[ch_idx];
 313                 channel->band = (ch_idx < num_2ghz_channels) ?
 314                                 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 315                 channel->center_freq =
 316                         ieee80211_channel_to_frequency(
 317                                 channel->hw_value, channel->band);
 318
 319                 /* Initialize regulatory-based run-time data */
 320
 321                 /*
 322                  * Default value - highest tx power value.  max_power
 323                  * is not used in mvm, and is used for backwards compatibility
 324                  */
 325                 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
 326                 is_5ghz = channel->band == NL80211_BAND_5GHZ;
 327
 328                 /* don't put limitations in case we're using LAR */
 329                 if (!lar_supported)
 330                         channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
 331                                                                ch_idx, is_5ghz,
 332                                                                ch_flags, cfg);
 333                 else
 334                         channel->flags = 0;
 335
 336                 IWL_DEBUG_EEPROM(dev,
 337                                  "Ch. %d [%sGHz] flags 0x%x %s%s%s%s%s%s%s%s%s%s(%ddBm): Ad-Hoc %ssupported\n",
 338                                  channel->hw_value,
 339                                  is_5ghz ? "5.2" : "2.4",
 340                                  ch_flags,
 341                                  CHECK_AND_PRINT_I(VALID),
 342                                  CHECK_AND_PRINT_I(IBSS),
 343                                  CHECK_AND_PRINT_I(ACTIVE),
 344                                  CHECK_AND_PRINT_I(RADAR),
 345                                  CHECK_AND_PRINT_I(INDOOR_ONLY),
 346                                  CHECK_AND_PRINT_I(GO_CONCURRENT),
 347                                  CHECK_AND_PRINT_I(WIDE),
 348                                  CHECK_AND_PRINT_I(40MHZ),
 349                                  CHECK_AND_PRINT_I(80MHZ),
 350                                  CHECK_AND_PRINT_I(160MHZ),
 351                                  channel->max_power,
 352                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 353                                   !(ch_flags & NVM_CHANNEL_RADAR))
 354                                         ? "" : "not ");
 355         }
 356
 357         return n_channels;
 358 }
 359
 360 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 361                                   struct iwl_nvm_data *data,
 362                                   struct ieee80211_sta_vht_cap *vht_cap,
 363                                   u8 tx_chains, u8 rx_chains)
 364 {
 365         int num_rx_ants = num_of_ant(rx_chains);
 366         int num_tx_ants = num_of_ant(tx_chains);
 367         unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
 368                                            IEEE80211_VHT_MAX_AMPDU_1024K);
 369
 370         vht_cap->vht_supported = true;
 371
 372         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 373                        IEEE80211_VHT_CAP_RXSTBC_1 |
 374                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 375                        3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
 376                        max_ampdu_exponent <<
 377                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 378
 379         if (data->vht160_supported)
 380                 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
 381                                 IEEE80211_VHT_CAP_SHORT_GI_160;
 382
 383         if (cfg->vht_mu_mimo_supported)
 384                 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
 385
 386         if (cfg->ht_params->ldpc)
 387                 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
 388
 389         if (data->sku_cap_mimo_disabled) {
 390                 num_rx_ants = 1;
 391                 num_tx_ants = 1;
 392         }
 393
 394         if (num_tx_ants > 1)
 395                 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
 396         else
 397                 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 398
 399         switch (iwlwifi_mod_params.amsdu_size) {
 400         case IWL_AMSDU_DEF:
 401                 if (cfg->mq_rx_supported)
 402                         vht_cap->cap |=
 403                                 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
 404                 else
 405                         vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
 406                 break;
 407         case IWL_AMSDU_4K:
 408                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
 409                 break;
 410         case IWL_AMSDU_8K:
 411                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 412                 break;
 413         case IWL_AMSDU_12K:
 414                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
 415                 break;
 416         default:
 417                 break;
 418         }
 419
 420         vht_cap->vht_mcs.rx_mcs_map =
 421                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 422                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 423                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 424                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 425                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 426                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 427                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 428                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 429
 430         if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
 431                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 432                 /* this works because NOT_SUPPORTED == 3 */
 433                 vht_cap->vht_mcs.rx_mcs_map |=
 434                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 435         }
 436
 437         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 438 }
 439
 440 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 441                             struct iwl_nvm_data *data,
 442                             const __le16 *ch_section,
 443                             u8 tx_chains, u8 rx_chains, bool lar_supported)
 444 {
 445         int n_channels;
 446         int n_used = 0;
 447         struct ieee80211_supported_band *sband;
 448
 449         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 450                 n_channels = iwl_init_channel_map(
 451                                 dev, cfg, data,
 452                                 &ch_section[NVM_CHANNELS], lar_supported);
 453         else
 454                 n_channels = iwl_init_channel_map(
 455                                 dev, cfg, data,
 456                                 &ch_section[NVM_CHANNELS_FAMILY_8000],
 457                                 lar_supported);
 458
 459         sband = &data->bands[NL80211_BAND_2GHZ];
 460         sband->band = NL80211_BAND_2GHZ;
 461         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 462         sband->n_bitrates = N_RATES_24;
 463         n_used += iwl_init_sband_channels(data, sband, n_channels,
 464                                           NL80211_BAND_2GHZ);
 465         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
 466                              tx_chains, rx_chains);
 467
 468         sband = &data->bands[NL80211_BAND_5GHZ];
 469         sband->band = NL80211_BAND_5GHZ;
 470         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 471         sband->n_bitrates = N_RATES_52;
 472         n_used += iwl_init_sband_channels(data, sband, n_channels,
 473                                           NL80211_BAND_5GHZ);
 474         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
 475                              tx_chains, rx_chains);
 476         if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
 477                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
 478                                       tx_chains, rx_chains);
 479
 480         if (n_channels != n_used)
 481                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 482                             n_used, n_channels);
 483 }
 484
 485 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 486                        const __le16 *phy_sku)
 487 {
 488         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 489                 return le16_to_cpup(nvm_sw + SKU);
 490
 491         return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
 492 }
 493
 494 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 495 {
 496         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 497                 return le16_to_cpup(nvm_sw + NVM_VERSION);
 498         else
 499                 return le32_to_cpup((__le32 *)(nvm_sw +
 500                                                NVM_VERSION_FAMILY_8000));
 501 }
 502
 503 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 504                              const __le16 *phy_sku)
 505 {
 506         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 507                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 508
 509         return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
 510
 511 }
 512
 513 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 514 {
 515         int n_hw_addr;
 516
 517         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 518                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 519
 520         n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
 521
 522         return n_hw_addr & N_HW_ADDR_MASK;
 523 }
 524
 525 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 526                               struct iwl_nvm_data *data,
 527                               u32 radio_cfg)
 528 {
 529         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 530                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 531                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 532                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 533                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 534                 return;
 535         }
 536
 537         /* set the radio configuration for family 8000 */
 538         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 539         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 540         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 541         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 542         data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg);
 543         data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg);
 544 }
 545
 546 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
 547 {
 548         const u8 *hw_addr;
 549
 550         hw_addr = (const u8 *)&mac_addr0;
 551         dest[0] = hw_addr[3];
 552         dest[1] = hw_addr[2];
 553         dest[2] = hw_addr[1];
 554         dest[3] = hw_addr[0];
 555
 556         hw_addr = (const u8 *)&mac_addr1;
 557         dest[4] = hw_addr[1];
 558         dest[5] = hw_addr[0];
 559 }
 560
 561 static void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
 562                                         struct iwl_nvm_data *data)
 563 {
 564         __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
 565         __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
 566
 567         /* If OEM did not fuse address - get it from OTP */
 568         if (!mac_addr0 && !mac_addr1) {
 569                 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
 570                 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
 571         }
 572
 573         iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 574 }
 575
 576 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
 577                                            const struct iwl_cfg *cfg,
 578                                            struct iwl_nvm_data *data,
 579                                            const __le16 *mac_override,
 580                                            const __le16 *nvm_hw)
 581 {
 582         const u8 *hw_addr;
 583
 584         if (mac_override) {
 585                 static const u8 reserved_mac[] = {
 586                         0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
 587                 };
 588
 589                 hw_addr = (const u8 *)(mac_override +
 590                                  MAC_ADDRESS_OVERRIDE_FAMILY_8000);
 591
 592                 /*
 593                  * Store the MAC address from MAO section.
 594                  * No byte swapping is required in MAO section
 595                  */
 596                 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
 597
 598                 /*
 599                  * Force the use of the OTP MAC address in case of reserved MAC
 600                  * address in the NVM, or if address is given but invalid.
 601                  */
 602                 if (is_valid_ether_addr(data->hw_addr) &&
 603                     memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
 604                         return;
 605
 606                 IWL_ERR(trans,
 607                         "mac address from nvm override section is not valid\n");
 608         }
 609
 610         if (nvm_hw) {
 611                 /* read the mac address from WFMP registers */
 612                 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
 613                                                 WFMP_MAC_ADDR_0));
 614                 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
 615                                                 WFMP_MAC_ADDR_1));
 616
 617                 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 618
 619                 return;
 620         }
 621
 622         IWL_ERR(trans, "mac address is not found\n");
 623 }
 624
 625 static int iwl_set_hw_address(struct iwl_trans *trans,
 626                               const struct iwl_cfg *cfg,
 627                               struct iwl_nvm_data *data, const __le16 *nvm_hw,
 628                               const __le16 *mac_override)
 629 {
 630         if (cfg->mac_addr_from_csr) {
 631                 iwl_set_hw_address_from_csr(trans, data);
 632         } else if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 633                 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
 634
 635                 /* The byte order is little endian 16 bit, meaning 214365 */
 636                 data->hw_addr[0] = hw_addr[1];
 637                 data->hw_addr[1] = hw_addr[0];
 638                 data->hw_addr[2] = hw_addr[3];
 639                 data->hw_addr[3] = hw_addr[2];
 640                 data->hw_addr[4] = hw_addr[5];
 641                 data->hw_addr[5] = hw_addr[4];
 642         } else {
 643                 iwl_set_hw_address_family_8000(trans, cfg, data,
 644                                                mac_override, nvm_hw);
 645         }
 646
 647         if (!is_valid_ether_addr(data->hw_addr)) {
 648                 IWL_ERR(trans, "no valid mac address was found\n");
 649                 return -EINVAL;
 650         }
 651
 652         return 0;
 653 }
 654
 655 struct iwl_nvm_data *
 656 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
 657                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 658                    const __le16 *nvm_calib, const __le16 *regulatory,
 659                    const __le16 *mac_override, const __le16 *phy_sku,
 660                    u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
 661 {
 662         struct device *dev = trans->dev;
 663         struct iwl_nvm_data *data;
 664         bool lar_enabled;
 665         u32 sku, radio_cfg;
 666         u16 lar_config;
 667         const __le16 *ch_section;
 668
 669         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 670                 data = kzalloc(sizeof(*data) +
 671                                sizeof(struct ieee80211_channel) *
 672                                IWL_NUM_CHANNELS,
 673                                GFP_KERNEL);
 674         else
 675                 data = kzalloc(sizeof(*data) +
 676                                sizeof(struct ieee80211_channel) *
 677                                IWL_NUM_CHANNELS_FAMILY_8000,
 678                                GFP_KERNEL);
 679         if (!data)
 680                 return NULL;
 681
 682         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 683
 684         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
 685         iwl_set_radio_cfg(cfg, data, radio_cfg);
 686         if (data->valid_tx_ant)
 687                 tx_chains &= data->valid_tx_ant;
 688         if (data->valid_rx_ant)
 689                 rx_chains &= data->valid_rx_ant;
 690
 691         sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
 692         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 693         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 694         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 695         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 696                 data->sku_cap_11n_enable = false;
 697         data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
 698                                     (sku & NVM_SKU_CAP_11AC_ENABLE);
 699         data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
 700
 701         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 702
 703         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 704                 /* Checking for required sections */
 705                 if (!nvm_calib) {
 706                         IWL_ERR(trans,
 707                                 "Can't parse empty Calib NVM sections\n");
 708                         kfree(data);
 709                         return NULL;
 710                 }
 711                 /* in family 8000 Xtal calibration values moved to OTP */
 712                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 713                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 714                 lar_enabled = true;
 715                 ch_section = nvm_sw;
 716         } else {
 717                 u16 lar_offset = data->nvm_version < 0xE39 ?
 718                                  NVM_LAR_OFFSET_FAMILY_8000_OLD :
 719                                  NVM_LAR_OFFSET_FAMILY_8000;
 720
 721                 lar_config = le16_to_cpup(regulatory + lar_offset);
 722                 data->lar_enabled = !!(lar_config &
 723                                        NVM_LAR_ENABLED_FAMILY_8000);
 724                 lar_enabled = data->lar_enabled;
 725                 ch_section = regulatory;
 726         }
 727
 728         /* If no valid mac address was found - bail out */
 729         if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
 730                 kfree(data);
 731                 return NULL;
 732         }
 733
 734         iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
 735                         lar_fw_supported && lar_enabled);
 736         data->calib_version = 255;
 737
 738         return data;
 739 }
 740 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
 741
 742 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
 743                                        int ch_idx, u16 nvm_flags,
 744                                        const struct iwl_cfg *cfg)
 745 {
 746         u32 flags = NL80211_RRF_NO_HT40;
 747         u32 last_5ghz_ht = LAST_5GHZ_HT;
 748
 749         if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
 750                 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
 751
 752         if (ch_idx < NUM_2GHZ_CHANNELS &&
 753             (nvm_flags & NVM_CHANNEL_40MHZ)) {
 754                 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 755                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 756                 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 757                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 758         } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
 759                    (nvm_flags & NVM_CHANNEL_40MHZ)) {
 760                 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 761                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 762                 else
 763                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 764         }
 765
 766         if (!(nvm_flags & NVM_CHANNEL_80MHZ))
 767                 flags |= NL80211_RRF_NO_80MHZ;
 768         if (!(nvm_flags & NVM_CHANNEL_160MHZ))
 769                 flags |= NL80211_RRF_NO_160MHZ;
 770
 771         if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
 772                 flags |= NL80211_RRF_NO_IR;
 773
 774         if (nvm_flags & NVM_CHANNEL_RADAR)
 775                 flags |= NL80211_RRF_DFS;
 776
 777         if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
 778                 flags |= NL80211_RRF_NO_OUTDOOR;
 779
 780         /* Set the GO concurrent flag only in case that NO_IR is set.
 781          * Otherwise it is meaningless
 782          */
 783         if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 784             (flags & NL80211_RRF_NO_IR))
 785                 flags |= NL80211_RRF_GO_CONCURRENT;
 786
 787         return flags;
 788 }
 789
 790 struct ieee80211_regdomain *
 791 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
 792                        int num_of_ch, __le32 *channels, u16 fw_mcc)
 793 {
 794         int ch_idx;
 795         u16 ch_flags, prev_ch_flags = 0;
 796         const u8 *nvm_chan = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 797                              iwl_nvm_channels_family_8000 : iwl_nvm_channels;
 798         struct ieee80211_regdomain *regd;
 799         int size_of_regd;
 800         struct ieee80211_reg_rule *rule;
 801         enum nl80211_band band;
 802         int center_freq, prev_center_freq = 0;
 803         int valid_rules = 0;
 804         bool new_rule;
 805         int max_num_ch = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 806                          IWL_NUM_CHANNELS_FAMILY_8000 : IWL_NUM_CHANNELS;
 807
 808         if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
 809                 return ERR_PTR(-EINVAL);
 810
 811         if (WARN_ON(num_of_ch > max_num_ch))
 812                 num_of_ch = max_num_ch;
 813
 814         IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
 815                       num_of_ch);
 816
 817         /* build a regdomain rule for every valid channel */
 818         size_of_regd =
 819                 sizeof(struct ieee80211_regdomain) +
 820                 num_of_ch * sizeof(struct ieee80211_reg_rule);
 821
 822         regd = kzalloc(size_of_regd, GFP_KERNEL);
 823         if (!regd)
 824                 return ERR_PTR(-ENOMEM);
 825
 826         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 827                 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
 828                 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
 829                        NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 830                 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
 831                                                              band);
 832                 new_rule = false;
 833
 834                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 835                         IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 836                                       "Ch. %d Flags %x [%sGHz] - No traffic\n",
 837                                       nvm_chan[ch_idx],
 838                                       ch_flags,
 839                                       (ch_idx >= NUM_2GHZ_CHANNELS) ?
 840                                       "5.2" : "2.4");
 841                         continue;
 842                 }
 843
 844                 /* we can't continue the same rule */
 845                 if (ch_idx == 0 || prev_ch_flags != ch_flags ||
 846                     center_freq - prev_center_freq > 20) {
 847                         valid_rules++;
 848                         new_rule = true;
 849                 }
 850
 851                 rule = &regd->reg_rules[valid_rules - 1];
 852
 853                 if (new_rule)
 854                         rule->freq_range.start_freq_khz =
 855                                                 MHZ_TO_KHZ(center_freq - 10);
 856
 857                 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
 858
 859                 /* this doesn't matter - not used by FW */
 860                 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
 861                 rule->power_rule.max_eirp =
 862                         DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
 863
 864                 rule->flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
 865                                                           ch_flags, cfg);
 866
 867                 /* rely on auto-calculation to merge BW of contiguous chans */
 868                 rule->flags |= NL80211_RRF_AUTO_BW;
 869                 rule->freq_range.max_bandwidth_khz = 0;
 870
 871                 prev_ch_flags = ch_flags;
 872                 prev_center_freq = center_freq;
 873
 874                 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 875                               "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
 876                               center_freq,
 877                               band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
 878                               CHECK_AND_PRINT_I(VALID),
 879                               CHECK_AND_PRINT_I(ACTIVE),
 880                               CHECK_AND_PRINT_I(RADAR),
 881                               CHECK_AND_PRINT_I(WIDE),
 882                               CHECK_AND_PRINT_I(40MHZ),
 883                               CHECK_AND_PRINT_I(80MHZ),
 884                               CHECK_AND_PRINT_I(160MHZ),
 885                               CHECK_AND_PRINT_I(INDOOR_ONLY),
 886                               CHECK_AND_PRINT_I(GO_CONCURRENT),
 887                               ch_flags,
 888                               ((ch_flags & NVM_CHANNEL_ACTIVE) &&
 889                                !(ch_flags & NVM_CHANNEL_RADAR))
 890                                          ? "" : "not ");
 891         }
 892
 893         regd->n_reg_rules = valid_rules;
 894
 895         /* set alpha2 from FW. */
 896         regd->alpha2[0] = fw_mcc >> 8;
 897         regd->alpha2[1] = fw_mcc & 0xff;
 898
 899         return regd;
 900 }
 901 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);