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 /* 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, num_2ghz_channels;
 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                 num_2ghz_channels = NUM_2GHZ_CHANNELS;
 212         } else {
 213                 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
 214                 nvm_chan = &iwl_nvm_channels_family_8000[0];
 215                 num_2ghz_channels = NUM_2GHZ_CHANNELS_FAMILY_8000;
 216         }
 217
 218         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 219                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 220
 221                 if (ch_idx >= num_2ghz_channels &&
 222                     !data->sku_cap_band_52GHz_enable)
 223                         ch_flags &= ~NVM_CHANNEL_VALID;
 224
 225                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 226                         IWL_DEBUG_EEPROM(dev,
 227                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 228                                          nvm_chan[ch_idx],
 229                                          ch_flags,
 230                                          (ch_idx >= num_2ghz_channels) ?
 231                                          "5.2" : "2.4");
 232                         continue;
 233                 }
 234
 235                 channel = &data->channels[n_channels];
 236                 n_channels++;
 237
 238                 channel->hw_value = nvm_chan[ch_idx];
 239                 channel->band = (ch_idx < num_2ghz_channels) ?
 240                                 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
 241                 channel->center_freq =
 242                         ieee80211_channel_to_frequency(
 243                                 channel->hw_value, channel->band);
 244
 245                 /* TODO: Need to be dependent to the NVM */
 246                 channel->flags = IEEE80211_CHAN_NO_HT40;
 247                 if (ch_idx < num_2ghz_channels &&
 248                     (ch_flags & NVM_CHANNEL_40MHZ)) {
 249                         if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 250                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 251                         if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 252                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 253                 } else if (nvm_chan[ch_idx] <= LAST_5GHZ_HT &&
 254                            (ch_flags & NVM_CHANNEL_40MHZ)) {
 255                         if ((ch_idx - num_2ghz_channels) % 2 == 0)
 256                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 257                         else
 258                                 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 259                 }
 260                 if (!(ch_flags & NVM_CHANNEL_80MHZ))
 261                         channel->flags |= IEEE80211_CHAN_NO_80MHZ;
 262                 if (!(ch_flags & NVM_CHANNEL_160MHZ))
 263                         channel->flags |= IEEE80211_CHAN_NO_160MHZ;
 264
 265                 if (!(ch_flags & NVM_CHANNEL_IBSS))
 266                         channel->flags |= IEEE80211_CHAN_NO_IR;
 267
 268                 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
 269                         channel->flags |= IEEE80211_CHAN_NO_IR;
 270
 271                 if (ch_flags & NVM_CHANNEL_RADAR)
 272                         channel->flags |= IEEE80211_CHAN_RADAR;
 273
 274                 /* Initialize regulatory-based run-time data */
 275
 276                 /*
 277                  * Default value - highest tx power value.  max_power
 278                  * is not used in mvm, and is used for backwards compatibility
 279                  */
 280                 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
 281                 is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
 282                 IWL_DEBUG_EEPROM(dev,
 283                                  "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
 284                                  channel->hw_value,
 285                                  is_5ghz ? "5.2" : "2.4",
 286                                  CHECK_AND_PRINT_I(VALID),
 287                                  CHECK_AND_PRINT_I(IBSS),
 288                                  CHECK_AND_PRINT_I(ACTIVE),
 289                                  CHECK_AND_PRINT_I(RADAR),
 290                                  CHECK_AND_PRINT_I(WIDE),
 291                                  CHECK_AND_PRINT_I(DFS),
 292                                  ch_flags,
 293                                  channel->max_power,
 294                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 295                                   !(ch_flags & NVM_CHANNEL_RADAR))
 296                                         ? "" : "not ");
 297         }
 298
 299         return n_channels;
 300 }
 301
 302 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 303                                   struct iwl_nvm_data *data,
 304                                   struct ieee80211_sta_vht_cap *vht_cap,
 305                                   u8 tx_chains, u8 rx_chains)
 306 {
 307         int num_rx_ants = num_of_ant(rx_chains);
 308         int num_tx_ants = num_of_ant(tx_chains);
 309
 310         vht_cap->vht_supported = true;
 311
 312         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 313                        IEEE80211_VHT_CAP_RXSTBC_1 |
 314                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 315                        3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
 316                        7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 317
 318         if (num_tx_ants > 1)
 319                 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
 320         else
 321                 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 322
 323         if (iwlwifi_mod_params.amsdu_size_8K)
 324                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 325
 326         vht_cap->vht_mcs.rx_mcs_map =
 327                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 328                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 329                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 330                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 331                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 332                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 333                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 334                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 335
 336         if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
 337                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 338                 /* this works because NOT_SUPPORTED == 3 */
 339                 vht_cap->vht_mcs.rx_mcs_map |=
 340                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 341         }
 342
 343         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 344 }
 345
 346 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 347                             struct iwl_nvm_data *data,
 348                             const __le16 *ch_section, bool enable_vht,
 349                             u8 tx_chains, u8 rx_chains)
 350 {
 351         int n_channels;
 352         int n_used = 0;
 353         struct ieee80211_supported_band *sband;
 354
 355         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 356                 n_channels = iwl_init_channel_map(
 357                                 dev, cfg, data,
 358                                 &ch_section[NVM_CHANNELS]);
 359         else
 360                 n_channels = iwl_init_channel_map(
 361                                 dev, cfg, data,
 362                                 &ch_section[NVM_CHANNELS_FAMILY_8000]);
 363
 364         sband = &data->bands[IEEE80211_BAND_2GHZ];
 365         sband->band = IEEE80211_BAND_2GHZ;
 366         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 367         sband->n_bitrates = N_RATES_24;
 368         n_used += iwl_init_sband_channels(data, sband, n_channels,
 369                                           IEEE80211_BAND_2GHZ);
 370         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
 371                              tx_chains, rx_chains);
 372
 373         sband = &data->bands[IEEE80211_BAND_5GHZ];
 374         sband->band = IEEE80211_BAND_5GHZ;
 375         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 376         sband->n_bitrates = N_RATES_52;
 377         n_used += iwl_init_sband_channels(data, sband, n_channels,
 378                                           IEEE80211_BAND_5GHZ);
 379         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
 380                              tx_chains, rx_chains);
 381         if (enable_vht)
 382                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
 383                                       tx_chains, rx_chains);
 384
 385         if (n_channels != n_used)
 386                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 387                             n_used, n_channels);
 388 }
 389
 390 static int iwl_get_sku(const struct iwl_cfg *cfg,
 391                        const __le16 *nvm_sw)
 392 {
 393         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 394                 return le16_to_cpup(nvm_sw + SKU);
 395         else
 396                 return le32_to_cpup((__le32 *)(nvm_sw + SKU_FAMILY_8000));
 397 }
 398
 399 static int iwl_get_nvm_version(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 + NVM_VERSION);
 404         else
 405                 return le32_to_cpup((__le32 *)(nvm_sw +
 406                                                NVM_VERSION_FAMILY_8000));
 407 }
 408
 409 static int iwl_get_radio_cfg(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 + RADIO_CFG);
 414         else
 415                 return le32_to_cpup((__le32 *)(nvm_sw + RADIO_CFG_FAMILY_8000));
 416 }
 417
 418 #define N_HW_ADDRS_MASK_FAMILY_8000     0xF
 419 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg,
 420                               const __le16 *nvm_sw)
 421 {
 422         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 423                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 424         else
 425                 return le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000))
 426                        & N_HW_ADDRS_MASK_FAMILY_8000;
 427 }
 428
 429 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 430                               struct iwl_nvm_data *data,
 431                               u32 radio_cfg)
 432 {
 433         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 434                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 435                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 436                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 437                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 438                 return;
 439         }
 440
 441         /* set the radio configuration for family 8000 */
 442         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 443         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 444         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 445         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 446 }
 447
 448 static void iwl_set_hw_address(const struct iwl_cfg *cfg,
 449                                struct iwl_nvm_data *data,
 450                                const __le16 *nvm_sec)
 451 {
 452         const u8 *hw_addr = (const u8 *)(nvm_sec + HW_ADDR);
 453
 454         /* The byte order is little endian 16 bit, meaning 214365 */
 455         data->hw_addr[0] = hw_addr[1];
 456         data->hw_addr[1] = hw_addr[0];
 457         data->hw_addr[2] = hw_addr[3];
 458         data->hw_addr[3] = hw_addr[2];
 459         data->hw_addr[4] = hw_addr[5];
 460         data->hw_addr[5] = hw_addr[4];
 461 }
 462
 463 static void iwl_set_hw_address_family_8000(const struct iwl_cfg *cfg,
 464                                            struct iwl_nvm_data *data,
 465                                            const __le16 *mac_override,
 466                                            const __le16 *nvm_hw)
 467 {
 468         const u8 *hw_addr;
 469
 470         if (mac_override) {
 471                 hw_addr = (const u8 *)(mac_override +
 472                                  MAC_ADDRESS_OVERRIDE_FAMILY_8000);
 473
 474                 /* The byte order is little endian 16 bit, meaning 214365 */
 475                 data->hw_addr[0] = hw_addr[1];
 476                 data->hw_addr[1] = hw_addr[0];
 477                 data->hw_addr[2] = hw_addr[3];
 478                 data->hw_addr[3] = hw_addr[2];
 479                 data->hw_addr[4] = hw_addr[5];
 480                 data->hw_addr[5] = hw_addr[4];
 481
 482                 if (is_valid_ether_addr(hw_addr))
 483                         return;
 484         }
 485
 486         /* take the MAC address from the OTP */
 487         hw_addr = (const u8 *)(nvm_hw + HW_ADDR0_FAMILY_8000);
 488         data->hw_addr[0] = hw_addr[3];
 489         data->hw_addr[1] = hw_addr[2];
 490         data->hw_addr[2] = hw_addr[1];
 491         data->hw_addr[3] = hw_addr[0];
 492
 493         hw_addr = (const u8 *)(nvm_hw + HW_ADDR1_FAMILY_8000);
 494         data->hw_addr[4] = hw_addr[1];
 495         data->hw_addr[5] = hw_addr[0];
 496 }
 497
 498 struct iwl_nvm_data *
 499 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
 500                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 501                    const __le16 *nvm_calib, const __le16 *regulatory,
 502                    const __le16 *mac_override, u8 tx_chains, u8 rx_chains)
 503 {
 504         struct iwl_nvm_data *data;
 505         u32 sku;
 506         u32 radio_cfg;
 507
 508         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 509                 data = kzalloc(sizeof(*data) +
 510                                sizeof(struct ieee80211_channel) *
 511                                IWL_NUM_CHANNELS,
 512                                GFP_KERNEL);
 513         else
 514                 data = kzalloc(sizeof(*data) +
 515                                sizeof(struct ieee80211_channel) *
 516                                IWL_NUM_CHANNELS_FAMILY_8000,
 517                                GFP_KERNEL);
 518         if (!data)
 519                 return NULL;
 520
 521         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 522
 523         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw);
 524         iwl_set_radio_cfg(cfg, data, radio_cfg);
 525
 526         sku = iwl_get_sku(cfg, nvm_sw);
 527         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 528         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 529         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 530         data->sku_cap_11ac_enable = sku & NVM_SKU_CAP_11AC_ENABLE;
 531         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 532                 data->sku_cap_11n_enable = false;
 533
 534         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 535
 536         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 537                 /* Checking for required sections */
 538                 if (!nvm_calib) {
 539                         IWL_ERR_DEV(dev,
 540                                     "Can't parse empty Calib NVM sections\n");
 541                         kfree(data);
 542                         return NULL;
 543                 }
 544                 /* in family 8000 Xtal calibration values moved to OTP */
 545                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 546                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 547         }
 548
 549         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 550                 iwl_set_hw_address(cfg, data, nvm_hw);
 551
 552                 iwl_init_sbands(dev, cfg, data, nvm_sw,
 553                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 554                                 rx_chains);
 555         } else {
 556                 /* MAC address in family 8000 */
 557                 iwl_set_hw_address_family_8000(cfg, data, mac_override, nvm_hw);
 558
 559                 iwl_init_sbands(dev, cfg, data, regulatory,
 560                                 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
 561                                 rx_chains);
 562         }
 563
 564         data->calib_version = 255;
 565
 566         return data;
 567 }
 568 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);