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 "iwl-drv.h"
  66 #include "iwl-modparams.h"
  67 #include "iwl-nvm-parse.h"
  68
  69 /* NVM offsets (in words) definitions */
  70 enum wkp_nvm_offsets {
  71         /* NVM HW-Section offset (in words) definitions */
  72         HW_ADDR = 0x15,
  73
  74         /* NVM SW-Section offset (in words) definitions */
  75         NVM_SW_SECTION = 0x1C0,
  76         NVM_VERSION = 0,
  77         RADIO_CFG = 1,
  78         SKU = 2,
  79         N_HW_ADDRS = 3,
  80         NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
  81
  82         /* NVM calibration section offset (in words) definitions */
  83         NVM_CALIB_SECTION = 0x2B8,
  84         XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
  85 };
  86
  87 enum family_8000_nvm_offsets {
  88         /* NVM HW-Section offset (in words) definitions */
  89         HW_ADDR0_FAMILY_8000 = 0x12,
  90         HW_ADDR1_FAMILY_8000 = 0x16,
  91         MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
  92
  93         /* NVM SW-Section offset (in words) definitions */
  94         NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
  95         NVM_VERSION_FAMILY_8000 = 0,
  96         RADIO_CFG_FAMILY_8000 = 2,
  97         SKU_FAMILY_8000 = 4,
  98         N_HW_ADDRS_FAMILY_8000 = 5,
  99
 100         /* NVM REGULATORY -Section offset (in words) definitions */
 101         NVM_CHANNELS_FAMILY_8000 = 0,
 102
 103         /* NVM calibration section offset (in words) definitions */
 104         NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
 105         XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
 106 };
 107
 108 /* SKU Capabilities (actual values from NVM definition) */
 109 enum nvm_sku_bits {
 110         NVM_SKU_CAP_BAND_24GHZ  = BIT(0),
 111         NVM_SKU_CAP_BAND_52GHZ  = BIT(1),
 112         NVM_SKU_CAP_11N_ENABLE  = BIT(2),
 113         NVM_SKU_CAP_11AC_ENABLE = BIT(3),
 114 };
 115
 116 /*
 117  * These are the channel numbers in the order that they are stored in the NVM
 118  */
 119 static const u8 iwl_nvm_channels[] = {
 120         /* 2.4 GHz */
 121         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 122         /* 5 GHz */
 123         36, 40, 44 , 48, 52, 56, 60, 64,
 124         100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 125         149, 153, 157, 161, 165
 126 };
 127
 128 static const u8 iwl_nvm_channels_family_8000[] = {
 129         /* 2.4 GHz */
 130         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
 131         /* 5 GHz */
 132         36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
 133         96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 134         149, 153, 157, 161, 165, 169, 173, 177, 181
 135 };
 136
 137 #define IWL_NUM_CHANNELS        ARRAY_SIZE(iwl_nvm_channels)
 138 #define IWL_NUM_CHANNELS_FAMILY_8000    ARRAY_SIZE(iwl_nvm_channels_family_8000)
 139 #define NUM_2GHZ_CHANNELS       14
 140 #define FIRST_2GHZ_HT_MINUS     5
 141 #define LAST_2GHZ_HT_PLUS       9
 142 #define LAST_5GHZ_HT            161
 143
 144 #define DEFAULT_MAX_TX_POWER 16
 145
 146 /* rate data (static) */
 147 static struct ieee80211_rate iwl_cfg80211_rates[] = {
 148         { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
 149         { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
 150           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 151         { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
 152           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 153         { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
 154           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 155         { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
 156         { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
 157         { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
 158         { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
 159         { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
 160         { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
 161         { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
 162         { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
 163 };
 164 #define RATES_24_OFFS   0
 165 #define N_RATES_24      ARRAY_SIZE(iwl_cfg80211_rates)
 166 #define RATES_52_OFFS   4
 167 #define N_RATES_52      (N_RATES_24 - RATES_52_OFFS)
 168
 169 /**
 170  * enum iwl_nvm_channel_flags - channel flags in NVM
 171  * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 172  * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 173  * @NVM_CHANNEL_ACTIVE: active scanning allowed
 174  * @NVM_CHANNEL_RADAR: radar detection required
 175  * @NVM_CHANNEL_DFS: dynamic freq selection candidate
 176  * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 177  * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 178  * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
 179  * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
 180  */
 181 enum iwl_nvm_channel_flags {
 182         NVM_CHANNEL_VALID = BIT(0),
 183         NVM_CHANNEL_IBSS = BIT(1),
 184         NVM_CHANNEL_ACTIVE = BIT(3),
 185         NVM_CHANNEL_RADAR = BIT(4),
 186         NVM_CHANNEL_DFS = BIT(7),
 187         NVM_CHANNEL_WIDE = BIT(8),
 188         NVM_CHANNEL_40MHZ = BIT(9),
 189         NVM_CHANNEL_80MHZ = BIT(10),
 190         NVM_CHANNEL_160MHZ = BIT(11),
 191 };
 192
 193 #define CHECK_AND_PRINT_I(x)    \
 194         ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
 195
 196 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 197                                 struct iwl_nvm_data *data,
 198                                 const __le16 * const nvm_ch_flags)
 199 {
 200         int ch_idx;
 201         int n_channels = 0;
 202         struct ieee80211_channel *channel;
 203         u16 ch_flags;
 204         bool is_5ghz;
 205         int num_of_ch;
 206         const u8 *nvm_chan;
 207
 208         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 209                 num_of_ch = IWL_NUM_CHANNELS;
 210                 nvm_chan = &iwl_nvm_channels[0];
 211         } else {
 212                 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
 213                 nvm_chan = &iwl_nvm_channels_family_8000[0];
 214         }
 215
 216         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 217                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 218                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 219                         IWL_DEBUG_EEPROM(dev,
 220                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 221                                          nvm_chan[ch_idx],
 222                                          ch_flags,
 223                                          (ch_idx >= NUM_2GHZ_CHANNELS) ?
 224                                          "5.2" : "2.4");
 225                         continue;
 226                 }
 227
 228                 channel = &data->channels[n_channels];
 229                 n_channels++;
 230
 231                 channel->hw_value = nvm_chan[ch_idx];
 232                 channel->band = (ch_idx < NUM_2GHZ_CHANNELS) ?
 233                                 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
 234                 channel->center_freq =
 235                         ieee80211_channel_to_frequency(
 236                                 channel->hw_value, channel->band);
 237
 238                 /* TODO: Need to be dependent to the NVM */
 239                 channel->flags = IEEE80211_CHAN_NO_HT40;
 240                 if (ch_idx < NUM_2GHZ_CHANNELS &&
 241                     (ch_flags & NVM_CHANNEL_40MHZ)) {
 242                         if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 243                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 244                         if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 245                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 246                 } else if (nvm_chan[ch_idx] <= LAST_5GHZ_HT &&
 247                            (ch_flags & NVM_CHANNEL_40MHZ)) {
 248                         if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 249                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 250                         else
 251                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 252                 }
 253                 if (!(ch_flags & NVM_CHANNEL_80MHZ))
 254                         channel->flags |= IEEE80211_CHAN_NO_80MHZ;
 255                 if (!(ch_flags & NVM_CHANNEL_160MHZ))
 256                         channel->flags |= IEEE80211_CHAN_NO_160MHZ;
 257
 258                 if (!(ch_flags & NVM_CHANNEL_IBSS))
 259                         channel->flags |= IEEE80211_CHAN_NO_IR;
 260
 261                 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
 262                         channel->flags |= IEEE80211_CHAN_NO_IR;
 263
 264                 if (ch_flags & NVM_CHANNEL_RADAR)
 265                         channel->flags |= IEEE80211_CHAN_RADAR;
 266
 267                 /* Initialize regulatory-based run-time data */
 268
 269                 /*
 270                  * Default value - highest tx power value.  max_power
 271                  * is not used in mvm, and is used for backwards compatibility
 272                  */
 273                 channel->max_power = DEFAULT_MAX_TX_POWER;
 274                 is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
 275                 IWL_DEBUG_EEPROM(dev,
 276                                  "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
 277                                  channel->hw_value,
 278                                  is_5ghz ? "5.2" : "2.4",
 279                                  CHECK_AND_PRINT_I(VALID),
 280                                  CHECK_AND_PRINT_I(IBSS),
 281                                  CHECK_AND_PRINT_I(ACTIVE),
 282                                  CHECK_AND_PRINT_I(RADAR),
 283                                  CHECK_AND_PRINT_I(WIDE),
 284                                  CHECK_AND_PRINT_I(DFS),
 285                                  ch_flags,
 286                                  channel->max_power,
 287                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 288                                   !(ch_flags & NVM_CHANNEL_RADAR))
 289                                         ? "" : "not ");
 290         }
 291
 292         return n_channels;
 293 }
 294
 295 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 296                                   struct iwl_nvm_data *data,
 297                                   struct ieee80211_sta_vht_cap *vht_cap)
 298 {
 299         int num_ants = num_of_ant(data->valid_rx_ant);
 300
 301         vht_cap->vht_supported = true;
 302
 303         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 304                        IEEE80211_VHT_CAP_RXSTBC_1 |
 305                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 306                        3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
 307                        7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 308
 309         if (num_ants > 1)
 310                 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
 311
 312         if (iwlwifi_mod_params.amsdu_size_8K)
 313                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 314
 315         vht_cap->vht_mcs.rx_mcs_map =
 316                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 317                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 318                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 319                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 320                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 321                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 322                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 323                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 324
 325         if (num_ants == 1 ||
 326             cfg->rx_with_siso_diversity) {
 327                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
 328                                 IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 329                 /* this works because NOT_SUPPORTED == 3 */
 330                 vht_cap->vht_mcs.rx_mcs_map |=
 331                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 332         }
 333
 334         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 335 }
 336
 337 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 338                             struct iwl_nvm_data *data,
 339                             const __le16 *ch_section, bool enable_vht,
 340                             u8 tx_chains, u8 rx_chains)
 341 {
 342         int n_channels;
 343         int n_used = 0;
 344         struct ieee80211_supported_band *sband;
 345
 346         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 347                 n_channels = iwl_init_channel_map(
 348                                 dev, cfg, data,
 349                                 &ch_section[NVM_CHANNELS]);
 350         else
 351                 n_channels = iwl_init_channel_map(
 352                                 dev, cfg, data,
 353                                 &ch_section[NVM_CHANNELS_FAMILY_8000]);
 354
 355         sband = &data->bands[IEEE80211_BAND_2GHZ];
 356         sband->band = IEEE80211_BAND_2GHZ;
 357         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 358         sband->n_bitrates = N_RATES_24;
 359         n_used += iwl_init_sband_channels(data, sband, n_channels,
 360                                           IEEE80211_BAND_2GHZ);
 361         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
 362                              tx_chains, rx_chains);
 363
 364         sband = &data->bands[IEEE80211_BAND_5GHZ];
 365         sband->band = IEEE80211_BAND_5GHZ;
 366         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 367         sband->n_bitrates = N_RATES_52;
 368         n_used += iwl_init_sband_channels(data, sband, n_channels,
 369                                           IEEE80211_BAND_5GHZ);
 370         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
 371                              tx_chains, rx_chains);
 372         if (enable_vht)
 373                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap);
 374
 375         if (n_channels != n_used)
 376                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 377                             n_used, n_channels);
 378 }
 379
 380 static int iwl_get_sku(const struct iwl_cfg *cfg,
 381                        const __le16 *nvm_sw)
 382 {
 383         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 384                 return le16_to_cpup(nvm_sw + SKU);
 385         else
 386                 return le32_to_cpup((__le32 *)(nvm_sw + SKU_FAMILY_8000));
 387 }
 388
 389 static int iwl_get_nvm_version(const struct iwl_cfg *cfg,
 390                                const __le16 *nvm_sw)
 391 {
 392         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 393                 return le16_to_cpup(nvm_sw + NVM_VERSION);
 394         else
 395                 return le32_to_cpup((__le32 *)(nvm_sw +
 396                                                NVM_VERSION_FAMILY_8000));
 397 }
 398
 399 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg,
 400                              const __le16 *nvm_sw)
 401 {
 402         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 403                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 404         else
 405                 return le32_to_cpup((__le32 *)(nvm_sw + RADIO_CFG_FAMILY_8000));
 406 }
 407
 408 #define N_HW_ADDRS_MASK_FAMILY_8000     0xF
 409 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg,
 410                               const __le16 *nvm_sw)
 411 {
 412         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 413                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 414         else
 415                 return le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000))
 416                        & N_HW_ADDRS_MASK_FAMILY_8000;
 417 }
 418
 419 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 420                               struct iwl_nvm_data *data,
 421                               u32 radio_cfg)
 422 {
 423         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 424                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 425                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 426                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 427                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 428                 return;
 429         }
 430
 431         /* set the radio configuration for family 8000 */
 432         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 433         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 434         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 435         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 436 }
 437
 438 static void iwl_set_hw_address(const struct iwl_cfg *cfg,
 439                                struct iwl_nvm_data *data,
 440                                const __le16 *nvm_sec)
 441 {
 442         u8 hw_addr[ETH_ALEN];
 443
 444         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 445                 memcpy(hw_addr, nvm_sec + HW_ADDR, ETH_ALEN);
 446         else
 447                 memcpy(hw_addr, nvm_sec + MAC_ADDRESS_OVERRIDE_FAMILY_8000,
 448                        ETH_ALEN);
 449
 450         /* The byte order is little endian 16 bit, meaning 214365 */
 451         data->hw_addr[0] = hw_addr[1];
 452         data->hw_addr[1] = hw_addr[0];
 453         data->hw_addr[2] = hw_addr[3];
 454         data->hw_addr[3] = hw_addr[2];
 455         data->hw_addr[4] = hw_addr[5];
 456         data->hw_addr[5] = hw_addr[4];
 457 }
 458
 459 struct iwl_nvm_data *
 460 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
 461                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 462                    const __le16 *nvm_calib, const __le16 *regulatory,
 463                    const __le16 *mac_override, u8 tx_chains, u8 rx_chains)
 464 {
 465         struct iwl_nvm_data *data;
 466         u32 sku;
 467         u32 radio_cfg;
 468
 469         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 470                 data = kzalloc(sizeof(*data) +
 471                                sizeof(struct ieee80211_channel) *
 472                                IWL_NUM_CHANNELS,
 473                                GFP_KERNEL);
 474         else
 475                 data = kzalloc(sizeof(*data) +
 476                                sizeof(struct ieee80211_channel) *
 477                                IWL_NUM_CHANNELS_FAMILY_8000,
 478                                GFP_KERNEL);
 479         if (!data)
 480                 return NULL;
 481
 482         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 483
 484         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw);
 485         iwl_set_radio_cfg(cfg, data, radio_cfg);
 486
 487         sku = iwl_get_sku(cfg, nvm_sw);
 488         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 489         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 490         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 491         data->sku_cap_11ac_enable = sku & NVM_SKU_CAP_11AC_ENABLE;
 492         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 493                 data->sku_cap_11n_enable = false;
 494
 495         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 496
 497         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 498                 /* Checking for required sections */
 499                 if (!nvm_calib) {
 500                         IWL_ERR_DEV(dev,
 501                                     "Can't parse empty Calib NVM sections\n");
 502                         kfree(data);
 503                         return NULL;
 504                 }
 505                 /* in family 8000 Xtal calibration values moved to OTP */
 506                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 507                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 508         }
 509
 510         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 511                 iwl_set_hw_address(cfg, data, nvm_hw);
 512
 513                 iwl_init_sbands(dev, cfg, data, nvm_sw,
 514                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 515                                 rx_chains);
 516         } else {
 517                 /* MAC address in family 8000 */
 518                 iwl_set_hw_address(cfg, data, mac_override);
 519
 520                 iwl_init_sbands(dev, cfg, data, regulatory,
 521                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 522                                 rx_chains);
 523         }
 524
 525         data->calib_version = 255;
 526
 527         return data;
 528 }
 529 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);