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_4K:
 401                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
 402                 break;
 403         case IWL_AMSDU_8K:
 404                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 405                 break;
 406         case IWL_AMSDU_12K:
 407                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
 408                 break;
 409         default:
 410                 break;
 411         }
 412
 413         vht_cap->vht_mcs.rx_mcs_map =
 414                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 415                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 416                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 417                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 418                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 419                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 420                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 421                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 422
 423         if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
 424                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 425                 /* this works because NOT_SUPPORTED == 3 */
 426                 vht_cap->vht_mcs.rx_mcs_map |=
 427                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 428         }
 429
 430         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 431 }
 432
 433 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 434                             struct iwl_nvm_data *data,
 435                             const __le16 *ch_section,
 436                             u8 tx_chains, u8 rx_chains, bool lar_supported)
 437 {
 438         int n_channels;
 439         int n_used = 0;
 440         struct ieee80211_supported_band *sband;
 441
 442         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 443                 n_channels = iwl_init_channel_map(
 444                                 dev, cfg, data,
 445                                 &ch_section[NVM_CHANNELS], lar_supported);
 446         else
 447                 n_channels = iwl_init_channel_map(
 448                                 dev, cfg, data,
 449                                 &ch_section[NVM_CHANNELS_FAMILY_8000],
 450                                 lar_supported);
 451
 452         sband = &data->bands[NL80211_BAND_2GHZ];
 453         sband->band = NL80211_BAND_2GHZ;
 454         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 455         sband->n_bitrates = N_RATES_24;
 456         n_used += iwl_init_sband_channels(data, sband, n_channels,
 457                                           NL80211_BAND_2GHZ);
 458         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
 459                              tx_chains, rx_chains);
 460
 461         sband = &data->bands[NL80211_BAND_5GHZ];
 462         sband->band = NL80211_BAND_5GHZ;
 463         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 464         sband->n_bitrates = N_RATES_52;
 465         n_used += iwl_init_sband_channels(data, sband, n_channels,
 466                                           NL80211_BAND_5GHZ);
 467         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
 468                              tx_chains, rx_chains);
 469         if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
 470                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
 471                                       tx_chains, rx_chains);
 472
 473         if (n_channels != n_used)
 474                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 475                             n_used, n_channels);
 476 }
 477
 478 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 479                        const __le16 *phy_sku)
 480 {
 481         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 482                 return le16_to_cpup(nvm_sw + SKU);
 483
 484         return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
 485 }
 486
 487 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 488 {
 489         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 490                 return le16_to_cpup(nvm_sw + NVM_VERSION);
 491         else
 492                 return le32_to_cpup((__le32 *)(nvm_sw +
 493                                                NVM_VERSION_FAMILY_8000));
 494 }
 495
 496 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 497                              const __le16 *phy_sku)
 498 {
 499         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 500                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 501
 502         return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
 503
 504 }
 505
 506 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 507 {
 508         int n_hw_addr;
 509
 510         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 511                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 512
 513         n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
 514
 515         return n_hw_addr & N_HW_ADDR_MASK;
 516 }
 517
 518 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 519                               struct iwl_nvm_data *data,
 520                               u32 radio_cfg)
 521 {
 522         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 523                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 524                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 525                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 526                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 527                 return;
 528         }
 529
 530         /* set the radio configuration for family 8000 */
 531         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 532         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 533         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 534         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 535         data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg);
 536         data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg);
 537 }
 538
 539 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
 540 {
 541         const u8 *hw_addr;
 542
 543         hw_addr = (const u8 *)&mac_addr0;
 544         dest[0] = hw_addr[3];
 545         dest[1] = hw_addr[2];
 546         dest[2] = hw_addr[1];
 547         dest[3] = hw_addr[0];
 548
 549         hw_addr = (const u8 *)&mac_addr1;
 550         dest[4] = hw_addr[1];
 551         dest[5] = hw_addr[0];
 552 }
 553
 554 static void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
 555                                         struct iwl_nvm_data *data)
 556 {
 557         __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
 558         __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
 559
 560         /* If OEM did not fuse address - get it from OTP */
 561         if (!mac_addr0 && !mac_addr1) {
 562                 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
 563                 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
 564         }
 565
 566         iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 567 }
 568
 569 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
 570                                            const struct iwl_cfg *cfg,
 571                                            struct iwl_nvm_data *data,
 572                                            const __le16 *mac_override,
 573                                            const __le16 *nvm_hw)
 574 {
 575         const u8 *hw_addr;
 576
 577         if (mac_override) {
 578                 static const u8 reserved_mac[] = {
 579                         0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
 580                 };
 581
 582                 hw_addr = (const u8 *)(mac_override +
 583                                  MAC_ADDRESS_OVERRIDE_FAMILY_8000);
 584
 585                 /*
 586                  * Store the MAC address from MAO section.
 587                  * No byte swapping is required in MAO section
 588                  */
 589                 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
 590
 591                 /*
 592                  * Force the use of the OTP MAC address in case of reserved MAC
 593                  * address in the NVM, or if address is given but invalid.
 594                  */
 595                 if (is_valid_ether_addr(data->hw_addr) &&
 596                     memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
 597                         return;
 598
 599                 IWL_ERR(trans,
 600                         "mac address from nvm override section is not valid\n");
 601         }
 602
 603         if (nvm_hw) {
 604                 /* read the mac address from WFMP registers */
 605                 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
 606                                                 WFMP_MAC_ADDR_0));
 607                 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
 608                                                 WFMP_MAC_ADDR_1));
 609
 610                 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 611
 612                 return;
 613         }
 614
 615         IWL_ERR(trans, "mac address is not found\n");
 616 }
 617
 618 static int iwl_set_hw_address(struct iwl_trans *trans,
 619                               const struct iwl_cfg *cfg,
 620                               struct iwl_nvm_data *data, const __le16 *nvm_hw,
 621                               const __le16 *mac_override)
 622 {
 623         if (cfg->mac_addr_from_csr) {
 624                 iwl_set_hw_address_from_csr(trans, data);
 625         } else if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 626                 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
 627
 628                 /* The byte order is little endian 16 bit, meaning 214365 */
 629                 data->hw_addr[0] = hw_addr[1];
 630                 data->hw_addr[1] = hw_addr[0];
 631                 data->hw_addr[2] = hw_addr[3];
 632                 data->hw_addr[3] = hw_addr[2];
 633                 data->hw_addr[4] = hw_addr[5];
 634                 data->hw_addr[5] = hw_addr[4];
 635         } else {
 636                 iwl_set_hw_address_family_8000(trans, cfg, data,
 637                                                mac_override, nvm_hw);
 638         }
 639
 640         if (!is_valid_ether_addr(data->hw_addr)) {
 641                 IWL_ERR(trans, "no valid mac address was found\n");
 642                 return -EINVAL;
 643         }
 644
 645         return 0;
 646 }
 647
 648 struct iwl_nvm_data *
 649 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
 650                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 651                    const __le16 *nvm_calib, const __le16 *regulatory,
 652                    const __le16 *mac_override, const __le16 *phy_sku,
 653                    u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
 654 {
 655         struct device *dev = trans->dev;
 656         struct iwl_nvm_data *data;
 657         bool lar_enabled;
 658         u32 sku, radio_cfg;
 659         u16 lar_config;
 660         const __le16 *ch_section;
 661
 662         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 663                 data = kzalloc(sizeof(*data) +
 664                                sizeof(struct ieee80211_channel) *
 665                                IWL_NUM_CHANNELS,
 666                                GFP_KERNEL);
 667         else
 668                 data = kzalloc(sizeof(*data) +
 669                                sizeof(struct ieee80211_channel) *
 670                                IWL_NUM_CHANNELS_FAMILY_8000,
 671                                GFP_KERNEL);
 672         if (!data)
 673                 return NULL;
 674
 675         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 676
 677         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
 678         iwl_set_radio_cfg(cfg, data, radio_cfg);
 679         if (data->valid_tx_ant)
 680                 tx_chains &= data->valid_tx_ant;
 681         if (data->valid_rx_ant)
 682                 rx_chains &= data->valid_rx_ant;
 683
 684         sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
 685         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 686         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 687         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 688         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 689                 data->sku_cap_11n_enable = false;
 690         data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
 691                                     (sku & NVM_SKU_CAP_11AC_ENABLE);
 692         data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
 693
 694         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 695
 696         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 697                 /* Checking for required sections */
 698                 if (!nvm_calib) {
 699                         IWL_ERR(trans,
 700                                 "Can't parse empty Calib NVM sections\n");
 701                         kfree(data);
 702                         return NULL;
 703                 }
 704                 /* in family 8000 Xtal calibration values moved to OTP */
 705                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 706                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 707                 lar_enabled = true;
 708                 ch_section = nvm_sw;
 709         } else {
 710                 u16 lar_offset = data->nvm_version < 0xE39 ?
 711                                  NVM_LAR_OFFSET_FAMILY_8000_OLD :
 712                                  NVM_LAR_OFFSET_FAMILY_8000;
 713
 714                 lar_config = le16_to_cpup(regulatory + lar_offset);
 715                 data->lar_enabled = !!(lar_config &
 716                                        NVM_LAR_ENABLED_FAMILY_8000);
 717                 lar_enabled = data->lar_enabled;
 718                 ch_section = regulatory;
 719         }
 720
 721         /* If no valid mac address was found - bail out */
 722         if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
 723                 kfree(data);
 724                 return NULL;
 725         }
 726
 727         iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
 728                         lar_fw_supported && lar_enabled);
 729         data->calib_version = 255;
 730
 731         return data;
 732 }
 733 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
 734
 735 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
 736                                        int ch_idx, u16 nvm_flags,
 737                                        const struct iwl_cfg *cfg)
 738 {
 739         u32 flags = NL80211_RRF_NO_HT40;
 740         u32 last_5ghz_ht = LAST_5GHZ_HT;
 741
 742         if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
 743                 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
 744
 745         if (ch_idx < NUM_2GHZ_CHANNELS &&
 746             (nvm_flags & NVM_CHANNEL_40MHZ)) {
 747                 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 748                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 749                 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 750                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 751         } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
 752                    (nvm_flags & NVM_CHANNEL_40MHZ)) {
 753                 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 754                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 755                 else
 756                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 757         }
 758
 759         if (!(nvm_flags & NVM_CHANNEL_80MHZ))
 760                 flags |= NL80211_RRF_NO_80MHZ;
 761         if (!(nvm_flags & NVM_CHANNEL_160MHZ))
 762                 flags |= NL80211_RRF_NO_160MHZ;
 763
 764         if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
 765                 flags |= NL80211_RRF_NO_IR;
 766
 767         if (nvm_flags & NVM_CHANNEL_RADAR)
 768                 flags |= NL80211_RRF_DFS;
 769
 770         if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
 771                 flags |= NL80211_RRF_NO_OUTDOOR;
 772
 773         /* Set the GO concurrent flag only in case that NO_IR is set.
 774          * Otherwise it is meaningless
 775          */
 776         if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 777             (flags & NL80211_RRF_NO_IR))
 778                 flags |= NL80211_RRF_GO_CONCURRENT;
 779
 780         return flags;
 781 }
 782
 783 struct ieee80211_regdomain *
 784 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
 785                        int num_of_ch, __le32 *channels, u16 fw_mcc)
 786 {
 787         int ch_idx;
 788         u16 ch_flags, prev_ch_flags = 0;
 789         const u8 *nvm_chan = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 790                              iwl_nvm_channels_family_8000 : iwl_nvm_channels;
 791         struct ieee80211_regdomain *regd;
 792         int size_of_regd;
 793         struct ieee80211_reg_rule *rule;
 794         enum nl80211_band band;
 795         int center_freq, prev_center_freq = 0;
 796         int valid_rules = 0;
 797         bool new_rule;
 798         int max_num_ch = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 799                          IWL_NUM_CHANNELS_FAMILY_8000 : IWL_NUM_CHANNELS;
 800
 801         if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
 802                 return ERR_PTR(-EINVAL);
 803
 804         if (WARN_ON(num_of_ch > max_num_ch))
 805                 num_of_ch = max_num_ch;
 806
 807         IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
 808                       num_of_ch);
 809
 810         /* build a regdomain rule for every valid channel */
 811         size_of_regd =
 812                 sizeof(struct ieee80211_regdomain) +
 813                 num_of_ch * sizeof(struct ieee80211_reg_rule);
 814
 815         regd = kzalloc(size_of_regd, GFP_KERNEL);
 816         if (!regd)
 817                 return ERR_PTR(-ENOMEM);
 818
 819         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 820                 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
 821                 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
 822                        NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 823                 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
 824                                                              band);
 825                 new_rule = false;
 826
 827                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 828                         IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 829                                       "Ch. %d Flags %x [%sGHz] - No traffic\n",
 830                                       nvm_chan[ch_idx],
 831                                       ch_flags,
 832                                       (ch_idx >= NUM_2GHZ_CHANNELS) ?
 833                                       "5.2" : "2.4");
 834                         continue;
 835                 }
 836
 837                 /* we can't continue the same rule */
 838                 if (ch_idx == 0 || prev_ch_flags != ch_flags ||
 839                     center_freq - prev_center_freq > 20) {
 840                         valid_rules++;
 841                         new_rule = true;
 842                 }
 843
 844                 rule = &regd->reg_rules[valid_rules - 1];
 845
 846                 if (new_rule)
 847                         rule->freq_range.start_freq_khz =
 848                                                 MHZ_TO_KHZ(center_freq - 10);
 849
 850                 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
 851
 852                 /* this doesn't matter - not used by FW */
 853                 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
 854                 rule->power_rule.max_eirp =
 855                         DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
 856
 857                 rule->flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
 858                                                           ch_flags, cfg);
 859
 860                 /* rely on auto-calculation to merge BW of contiguous chans */
 861                 rule->flags |= NL80211_RRF_AUTO_BW;
 862                 rule->freq_range.max_bandwidth_khz = 0;
 863
 864                 prev_ch_flags = ch_flags;
 865                 prev_center_freq = center_freq;
 866
 867                 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 868                               "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
 869                               center_freq,
 870                               band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
 871                               CHECK_AND_PRINT_I(VALID),
 872                               CHECK_AND_PRINT_I(ACTIVE),
 873                               CHECK_AND_PRINT_I(RADAR),
 874                               CHECK_AND_PRINT_I(WIDE),
 875                               CHECK_AND_PRINT_I(40MHZ),
 876                               CHECK_AND_PRINT_I(80MHZ),
 877                               CHECK_AND_PRINT_I(160MHZ),
 878                               CHECK_AND_PRINT_I(INDOOR_ONLY),
 879                               CHECK_AND_PRINT_I(GO_CONCURRENT),
 880                               ch_flags,
 881                               ((ch_flags & NVM_CHANNEL_ACTIVE) &&
 882                                !(ch_flags & NVM_CHANNEL_RADAR))
 883                                          ? "" : "not ");
 884         }
 885
 886         regd->n_reg_rules = valid_rules;
 887
 888         /* set alpha2 from FW. */
 889         regd->alpha2[0] = fw_mcc >> 8;
 890         regd->alpha2[1] = fw_mcc & 0xff;
 891
 892         return regd;
 893 }
 894 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);