drivers/net/wireless/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  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of version 2 of the GNU General Public License as
  12  * published by the Free Software Foundation.
  13  *
  14  * This program is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  22  * USA
  23  *
  24  * The full GNU General Public License is included in this distribution
  25  * in the file called COPYING.
  26  *
  27  * Contact Information:
  28  *  Intel Linux Wireless <ilw@linux.intel.com>
  29  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  30  *
  31  * BSD LICENSE
  32  *
  33  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  34  * All rights reserved.
  35  *
  36  * Redistribution and use in source and binary forms, with or without
  37  * modification, are permitted provided that the following conditions
  38  * are met:
  39  *
  40  *  * Redistributions of source code must retain the above copyright
  41  *    notice, this list of conditions and the following disclaimer.
  42  *  * Redistributions in binary form must reproduce the above copyright
  43  *    notice, this list of conditions and the following disclaimer in
  44  *    the documentation and/or other materials provided with the
  45  *    distribution.
  46  *  * Neither the name Intel Corporation nor the names of its
  47  *    contributors may be used to endorse or promote products derived
  48  *    from this software without specific prior written permission.
  49  *
  50  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  51  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  52  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  53  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  54  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  55  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  56  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  57  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  58  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  59  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  60  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  61  *****************************************************************************/
  62 #include <linux/types.h>
  63 #include <linux/slab.h>
  64 #include <linux/export.h>
  65 #include <linux/etherdevice.h>
  66 #include <linux/pci.h>
  67 #include "iwl-drv.h"
  68 #include "iwl-modparams.h"
  69 #include "iwl-nvm-parse.h"
  70
  71 /* NVM offsets (in words) definitions */
  72 enum wkp_nvm_offsets {
  73         /* NVM HW-Section offset (in words) definitions */
  74         HW_ADDR = 0x15,
  75
  76         /* NVM SW-Section offset (in words) definitions */
  77         NVM_SW_SECTION = 0x1C0,
  78         NVM_VERSION = 0,
  79         RADIO_CFG = 1,
  80         SKU = 2,
  81         N_HW_ADDRS = 3,
  82         NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
  83
  84         /* NVM calibration section offset (in words) definitions */
  85         NVM_CALIB_SECTION = 0x2B8,
  86         XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
  87 };
  88
  89 enum family_8000_nvm_offsets {
  90         /* NVM HW-Section offset (in words) definitions */
  91         HW_ADDR0_WFPM_FAMILY_8000 = 0x12,
  92         HW_ADDR1_WFPM_FAMILY_8000 = 0x16,
  93         HW_ADDR0_PCIE_FAMILY_8000 = 0x8A,
  94         HW_ADDR1_PCIE_FAMILY_8000 = 0x8E,
  95         MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
  96
  97         /* NVM SW-Section offset (in words) definitions */
  98         NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
  99         NVM_VERSION_FAMILY_8000 = 0,
 100         RADIO_CFG_FAMILY_8000 = 2,
 101         SKU_FAMILY_8000 = 4,
 102         N_HW_ADDRS_FAMILY_8000 = 5,
 103
 104         /* NVM REGULATORY -Section offset (in words) definitions */
 105         NVM_CHANNELS_FAMILY_8000 = 0,
 106
 107         /* NVM calibration section offset (in words) definitions */
 108         NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
 109         XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
 110 };
 111
 112 /* SKU Capabilities (actual values from NVM definition) */
 113 enum nvm_sku_bits {
 114         NVM_SKU_CAP_BAND_24GHZ  = BIT(0),
 115         NVM_SKU_CAP_BAND_52GHZ  = BIT(1),
 116         NVM_SKU_CAP_11N_ENABLE  = BIT(2),
 117         NVM_SKU_CAP_11AC_ENABLE = BIT(3),
 118 };
 119
 120 /*
 121  * These are the channel numbers in the order that they are stored in the NVM
 122  */
 123 static const u8 iwl_nvm_channels[] = {
 124         /* 2.4 GHz */
 125         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 126         /* 5 GHz */
 127         36, 40, 44 , 48, 52, 56, 60, 64,
 128         100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 129         149, 153, 157, 161, 165
 130 };
 131
 132 static const u8 iwl_nvm_channels_family_8000[] = {
 133         /* 2.4 GHz */
 134         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 135         /* 5 GHz */
 136         36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
 137         96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 138         149, 153, 157, 161, 165, 169, 173, 177, 181
 139 };
 140
 141 #define IWL_NUM_CHANNELS                ARRAY_SIZE(iwl_nvm_channels)
 142 #define IWL_NUM_CHANNELS_FAMILY_8000    ARRAY_SIZE(iwl_nvm_channels_family_8000)
 143 #define NUM_2GHZ_CHANNELS               14
 144 #define NUM_2GHZ_CHANNELS_FAMILY_8000   14
 145 #define FIRST_2GHZ_HT_MINUS             5
 146 #define LAST_2GHZ_HT_PLUS               9
 147 #define LAST_5GHZ_HT                    161
 148
 149 /* rate data (static) */
 150 static struct ieee80211_rate iwl_cfg80211_rates[] = {
 151         { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
 152         { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
 153           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 154         { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
 155           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 156         { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
 157           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 158         { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
 159         { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
 160         { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
 161         { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
 162         { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
 163         { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
 164         { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
 165         { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
 166 };
 167 #define RATES_24_OFFS   0
 168 #define N_RATES_24      ARRAY_SIZE(iwl_cfg80211_rates)
 169 #define RATES_52_OFFS   4
 170 #define N_RATES_52      (N_RATES_24 - RATES_52_OFFS)
 171
 172 /**
 173  * enum iwl_nvm_channel_flags - channel flags in NVM
 174  * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 175  * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 176  * @NVM_CHANNEL_ACTIVE: active scanning allowed
 177  * @NVM_CHANNEL_RADAR: radar detection required
 178  * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
 179  * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
 180  *      on same channel on 2.4 or same UNII band on 5.2
 181  * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 182  * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 183  * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
 184  * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
 185  */
 186 enum iwl_nvm_channel_flags {
 187         NVM_CHANNEL_VALID = BIT(0),
 188         NVM_CHANNEL_IBSS = BIT(1),
 189         NVM_CHANNEL_ACTIVE = BIT(3),
 190         NVM_CHANNEL_RADAR = BIT(4),
 191         NVM_CHANNEL_INDOOR_ONLY = BIT(5),
 192         NVM_CHANNEL_GO_CONCURRENT = BIT(6),
 193         NVM_CHANNEL_WIDE = BIT(8),
 194         NVM_CHANNEL_40MHZ = BIT(9),
 195         NVM_CHANNEL_80MHZ = BIT(10),
 196         NVM_CHANNEL_160MHZ = BIT(11),
 197 };
 198
 199 #define CHECK_AND_PRINT_I(x)    \
 200         ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
 201
 202 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 203                                 struct iwl_nvm_data *data,
 204                                 const __le16 * const nvm_ch_flags)
 205 {
 206         int ch_idx;
 207         int n_channels = 0;
 208         struct ieee80211_channel *channel;
 209         u16 ch_flags;
 210         bool is_5ghz;
 211         int num_of_ch, num_2ghz_channels;
 212         const u8 *nvm_chan;
 213
 214         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 215                 num_of_ch = IWL_NUM_CHANNELS;
 216                 nvm_chan = &iwl_nvm_channels[0];
 217                 num_2ghz_channels = NUM_2GHZ_CHANNELS;
 218         } else {
 219                 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
 220                 nvm_chan = &iwl_nvm_channels_family_8000[0];
 221                 num_2ghz_channels = NUM_2GHZ_CHANNELS_FAMILY_8000;
 222         }
 223
 224         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 225                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 226
 227                 if (ch_idx >= num_2ghz_channels &&
 228                     !data->sku_cap_band_52GHz_enable)
 229                         ch_flags &= ~NVM_CHANNEL_VALID;
 230
 231                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 232                         IWL_DEBUG_EEPROM(dev,
 233                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 234                                          nvm_chan[ch_idx],
 235                                          ch_flags,
 236                                          (ch_idx >= num_2ghz_channels) ?
 237                                          "5.2" : "2.4");
 238                         continue;
 239                 }
 240
 241                 channel = &data->channels[n_channels];
 242                 n_channels++;
 243
 244                 channel->hw_value = nvm_chan[ch_idx];
 245                 channel->band = (ch_idx < num_2ghz_channels) ?
 246                                 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
 247                 channel->center_freq =
 248                         ieee80211_channel_to_frequency(
 249                                 channel->hw_value, channel->band);
 250
 251                 /* TODO: Need to be dependent to the NVM */
 252                 channel->flags = IEEE80211_CHAN_NO_HT40;
 253                 if (ch_idx < num_2ghz_channels &&
 254                     (ch_flags & NVM_CHANNEL_40MHZ)) {
 255                         if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 256                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 257                         if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 258                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 259                 } else if (nvm_chan[ch_idx] <= LAST_5GHZ_HT &&
 260                            (ch_flags & NVM_CHANNEL_40MHZ)) {
 261                         if ((ch_idx - num_2ghz_channels) % 2 == 0)
 262                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 263                         else
 264                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 265                 }
 266                 if (!(ch_flags & NVM_CHANNEL_80MHZ))
 267                         channel->flags |= IEEE80211_CHAN_NO_80MHZ;
 268                 if (!(ch_flags & NVM_CHANNEL_160MHZ))
 269                         channel->flags |= IEEE80211_CHAN_NO_160MHZ;
 270
 271                 if (!(ch_flags & NVM_CHANNEL_IBSS))
 272                         channel->flags |= IEEE80211_CHAN_NO_IR;
 273
 274                 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
 275                         channel->flags |= IEEE80211_CHAN_NO_IR;
 276
 277                 if (ch_flags & NVM_CHANNEL_RADAR)
 278                         channel->flags |= IEEE80211_CHAN_RADAR;
 279
 280                 if (ch_flags & NVM_CHANNEL_INDOOR_ONLY)
 281                         channel->flags |= IEEE80211_CHAN_INDOOR_ONLY;
 282
 283                 /* Set the GO concurrent flag only in case that NO_IR is set.
 284                  * Otherwise it is meaningless
 285                  */
 286                 if ((ch_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 287                     (channel->flags & IEEE80211_CHAN_NO_IR))
 288                         channel->flags |= IEEE80211_CHAN_GO_CONCURRENT;
 289
 290                 /* Initialize regulatory-based run-time data */
 291
 292                 /*
 293                  * Default value - highest tx power value.  max_power
 294                  * is not used in mvm, and is used for backwards compatibility
 295                  */
 296                 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
 297                 is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
 298                 IWL_DEBUG_EEPROM(dev,
 299                                  "Ch. %d [%sGHz] %s%s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
 300                                  channel->hw_value,
 301                                  is_5ghz ? "5.2" : "2.4",
 302                                  CHECK_AND_PRINT_I(VALID),
 303                                  CHECK_AND_PRINT_I(IBSS),
 304                                  CHECK_AND_PRINT_I(ACTIVE),
 305                                  CHECK_AND_PRINT_I(RADAR),
 306                                  CHECK_AND_PRINT_I(WIDE),
 307                                  CHECK_AND_PRINT_I(INDOOR_ONLY),
 308                                  CHECK_AND_PRINT_I(GO_CONCURRENT),
 309                                  ch_flags,
 310                                  channel->max_power,
 311                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 312                                   !(ch_flags & NVM_CHANNEL_RADAR))
 313                                         ? "" : "not ");
 314         }
 315
 316         return n_channels;
 317 }
 318
 319 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 320                                   struct iwl_nvm_data *data,
 321                                   struct ieee80211_sta_vht_cap *vht_cap,
 322                                   u8 tx_chains, u8 rx_chains)
 323 {
 324         int num_rx_ants = num_of_ant(rx_chains);
 325         int num_tx_ants = num_of_ant(tx_chains);
 326
 327         vht_cap->vht_supported = true;
 328
 329         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 330                        IEEE80211_VHT_CAP_RXSTBC_1 |
 331                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 332                        3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
 333                        7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 334
 335         if (num_tx_ants > 1)
 336                 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
 337         else
 338                 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 339
 340         if (iwlwifi_mod_params.amsdu_size_8K)
 341                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 342
 343         vht_cap->vht_mcs.rx_mcs_map =
 344                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 345                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 346                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 347                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 348                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 349                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 350                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 351                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 352
 353         if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
 354                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 355                 /* this works because NOT_SUPPORTED == 3 */
 356                 vht_cap->vht_mcs.rx_mcs_map |=
 357                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 358         }
 359
 360         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 361 }
 362
 363 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 364                             struct iwl_nvm_data *data,
 365                             const __le16 *ch_section, bool enable_vht,
 366                             u8 tx_chains, u8 rx_chains)
 367 {
 368         int n_channels;
 369         int n_used = 0;
 370         struct ieee80211_supported_band *sband;
 371
 372         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 373                 n_channels = iwl_init_channel_map(
 374                                 dev, cfg, data,
 375                                 &ch_section[NVM_CHANNELS]);
 376         else
 377                 n_channels = iwl_init_channel_map(
 378                                 dev, cfg, data,
 379                                 &ch_section[NVM_CHANNELS_FAMILY_8000]);
 380
 381         sband = &data->bands[IEEE80211_BAND_2GHZ];
 382         sband->band = IEEE80211_BAND_2GHZ;
 383         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 384         sband->n_bitrates = N_RATES_24;
 385         n_used += iwl_init_sband_channels(data, sband, n_channels,
 386                                           IEEE80211_BAND_2GHZ);
 387         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
 388                              tx_chains, rx_chains);
 389
 390         sband = &data->bands[IEEE80211_BAND_5GHZ];
 391         sband->band = IEEE80211_BAND_5GHZ;
 392         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 393         sband->n_bitrates = N_RATES_52;
 394         n_used += iwl_init_sband_channels(data, sband, n_channels,
 395                                           IEEE80211_BAND_5GHZ);
 396         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
 397                              tx_chains, rx_chains);
 398         if (enable_vht)
 399                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
 400                                       tx_chains, rx_chains);
 401
 402         if (n_channels != n_used)
 403                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 404                             n_used, n_channels);
 405 }
 406
 407 static int iwl_get_sku(const struct iwl_cfg *cfg,
 408                        const __le16 *nvm_sw)
 409 {
 410         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 411                 return le16_to_cpup(nvm_sw + SKU);
 412         else
 413                 return le32_to_cpup((__le32 *)(nvm_sw + SKU_FAMILY_8000));
 414 }
 415
 416 static int iwl_get_nvm_version(const struct iwl_cfg *cfg,
 417                                const __le16 *nvm_sw)
 418 {
 419         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 420                 return le16_to_cpup(nvm_sw + NVM_VERSION);
 421         else
 422                 return le32_to_cpup((__le32 *)(nvm_sw +
 423                                                NVM_VERSION_FAMILY_8000));
 424 }
 425
 426 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg,
 427                              const __le16 *nvm_sw)
 428 {
 429         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 430                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 431         else
 432                 return le32_to_cpup((__le32 *)(nvm_sw + RADIO_CFG_FAMILY_8000));
 433 }
 434
 435 #define N_HW_ADDRS_MASK_FAMILY_8000     0xF
 436 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg,
 437                               const __le16 *nvm_sw)
 438 {
 439         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 440                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 441         else
 442                 return le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000))
 443                        & N_HW_ADDRS_MASK_FAMILY_8000;
 444 }
 445
 446 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 447                               struct iwl_nvm_data *data,
 448                               u32 radio_cfg)
 449 {
 450         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 451                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 452                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 453                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 454                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 455                 return;
 456         }
 457
 458         /* set the radio configuration for family 8000 */
 459         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 460         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 461         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 462         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 463 }
 464
 465 static void iwl_set_hw_address(const struct iwl_cfg *cfg,
 466                                struct iwl_nvm_data *data,
 467                                const __le16 *nvm_sec)
 468 {
 469         const u8 *hw_addr = (const u8 *)(nvm_sec + HW_ADDR);
 470
 471         /* The byte order is little endian 16 bit, meaning 214365 */
 472         data->hw_addr[0] = hw_addr[1];
 473         data->hw_addr[1] = hw_addr[0];
 474         data->hw_addr[2] = hw_addr[3];
 475         data->hw_addr[3] = hw_addr[2];
 476         data->hw_addr[4] = hw_addr[5];
 477         data->hw_addr[5] = hw_addr[4];
 478 }
 479
 480 static void iwl_set_hw_address_family_8000(struct device *dev,
 481                                            const struct iwl_cfg *cfg,
 482                                            struct iwl_nvm_data *data,
 483                                            const __le16 *mac_override,
 484                                            const __le16 *nvm_hw)
 485 {
 486         const u8 *hw_addr;
 487
 488         if (mac_override) {
 489                 hw_addr = (const u8 *)(mac_override +
 490                                  MAC_ADDRESS_OVERRIDE_FAMILY_8000);
 491
 492                 /* The byte order is little endian 16 bit, meaning 214365 */
 493                 data->hw_addr[0] = hw_addr[1];
 494                 data->hw_addr[1] = hw_addr[0];
 495                 data->hw_addr[2] = hw_addr[3];
 496                 data->hw_addr[3] = hw_addr[2];
 497                 data->hw_addr[4] = hw_addr[5];
 498                 data->hw_addr[5] = hw_addr[4];
 499
 500                 if (is_valid_ether_addr(data->hw_addr))
 501                         return;
 502
 503                 IWL_ERR_DEV(dev,
 504                             "mac address from nvm override section is not valid\n");
 505         }
 506
 507         if (nvm_hw) {
 508                 /* read the MAC address from OTP */
 509                 if (!dev_is_pci(dev) || (data->nvm_version < 0xE08)) {
 510                         /* read the mac address from the WFPM location */
 511                         hw_addr = (const u8 *)(nvm_hw +
 512                                                HW_ADDR0_WFPM_FAMILY_8000);
 513                         data->hw_addr[0] = hw_addr[3];
 514                         data->hw_addr[1] = hw_addr[2];
 515                         data->hw_addr[2] = hw_addr[1];
 516                         data->hw_addr[3] = hw_addr[0];
 517
 518                         hw_addr = (const u8 *)(nvm_hw +
 519                                                HW_ADDR1_WFPM_FAMILY_8000);
 520                         data->hw_addr[4] = hw_addr[1];
 521                         data->hw_addr[5] = hw_addr[0];
 522                 } else if ((data->nvm_version >= 0xE08) &&
 523                            (data->nvm_version < 0xE0B)) {
 524                         /* read "reverse order"  from the PCIe location */
 525                         hw_addr = (const u8 *)(nvm_hw +
 526                                                HW_ADDR0_PCIE_FAMILY_8000);
 527                         data->hw_addr[5] = hw_addr[2];
 528                         data->hw_addr[4] = hw_addr[1];
 529                         data->hw_addr[3] = hw_addr[0];
 530
 531                         hw_addr = (const u8 *)(nvm_hw +
 532                                                HW_ADDR1_PCIE_FAMILY_8000);
 533                         data->hw_addr[2] = hw_addr[3];
 534                         data->hw_addr[1] = hw_addr[2];
 535                         data->hw_addr[0] = hw_addr[1];
 536                 } else {
 537                         /* read from the PCIe location */
 538                         hw_addr = (const u8 *)(nvm_hw +
 539                                                HW_ADDR0_PCIE_FAMILY_8000);
 540                         data->hw_addr[5] = hw_addr[0];
 541                         data->hw_addr[4] = hw_addr[1];
 542                         data->hw_addr[3] = hw_addr[2];
 543
 544                         hw_addr = (const u8 *)(nvm_hw +
 545                                                HW_ADDR1_PCIE_FAMILY_8000);
 546                         data->hw_addr[2] = hw_addr[1];
 547                         data->hw_addr[1] = hw_addr[2];
 548                         data->hw_addr[0] = hw_addr[3];
 549                 }
 550                 if (!is_valid_ether_addr(data->hw_addr))
 551                         IWL_ERR_DEV(dev,
 552                                     "mac address from hw section is not valid\n");
 553
 554                 return;
 555         }
 556
 557         IWL_ERR_DEV(dev, "mac address is not found\n");
 558 }
 559
 560 struct iwl_nvm_data *
 561 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
 562                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 563                    const __le16 *nvm_calib, const __le16 *regulatory,
 564                    const __le16 *mac_override, u8 tx_chains, u8 rx_chains)
 565 {
 566         struct iwl_nvm_data *data;
 567         u32 sku;
 568         u32 radio_cfg;
 569
 570         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 571                 data = kzalloc(sizeof(*data) +
 572                                sizeof(struct ieee80211_channel) *
 573                                IWL_NUM_CHANNELS,
 574                                GFP_KERNEL);
 575         else
 576                 data = kzalloc(sizeof(*data) +
 577                                sizeof(struct ieee80211_channel) *
 578                                IWL_NUM_CHANNELS_FAMILY_8000,
 579                                GFP_KERNEL);
 580         if (!data)
 581                 return NULL;
 582
 583         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 584
 585         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw);
 586         iwl_set_radio_cfg(cfg, data, radio_cfg);
 587
 588         sku = iwl_get_sku(cfg, nvm_sw);
 589         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 590         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 591         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 592         data->sku_cap_11ac_enable = sku & NVM_SKU_CAP_11AC_ENABLE;
 593         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 594                 data->sku_cap_11n_enable = false;
 595
 596         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 597
 598         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 599                 /* Checking for required sections */
 600                 if (!nvm_calib) {
 601                         IWL_ERR_DEV(dev,
 602                                     "Can't parse empty Calib NVM sections\n");
 603                         kfree(data);
 604                         return NULL;
 605                 }
 606                 /* in family 8000 Xtal calibration values moved to OTP */
 607                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 608                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 609         }
 610
 611         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 612                 iwl_set_hw_address(cfg, data, nvm_hw);
 613
 614                 iwl_init_sbands(dev, cfg, data, nvm_sw,
 615                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 616                                 rx_chains);
 617         } else {
 618                 /* MAC address in family 8000 */
 619                 iwl_set_hw_address_family_8000(dev, cfg, data, mac_override,
 620                                                nvm_hw);
 621
 622                 iwl_init_sbands(dev, cfg, data, regulatory,
 623                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 624                                 rx_chains);
 625         }
 626
 627         data->calib_version = 255;
 628
 629         return data;
 630 }
 631 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);