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