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