drivers/net/wireless/intel/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  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  10  * Copyright(c) 2016 Intel Deutschland GmbH
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of version 2 of the GNU General Public License as
  14  * published by the Free Software Foundation.
  15  *
  16  * This program is distributed in the hope that it will be useful, but
  17  * WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  19  * General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
  24  * USA
  25  *
  26  * The full GNU General Public License is included in this distribution
  27  * in the file called COPYING.
  28  *
  29  * Contact Information:
  30  *  Intel Linux Wireless <linuxwifi@intel.com>
  31  * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
  32  *
  33  * BSD LICENSE
  34  *
  35  * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
  36  * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
  37  * All rights reserved.
  38  *
  39  * Redistribution and use in source and binary forms, with or without
  40  * modification, are permitted provided that the following conditions
  41  * are met:
  42  *
  43  *  * Redistributions of source code must retain the above copyright
  44  *    notice, this list of conditions and the following disclaimer.
  45  *  * Redistributions in binary form must reproduce the above copyright
  46  *    notice, this list of conditions and the following disclaimer in
  47  *    the documentation and/or other materials provided with the
  48  *    distribution.
  49  *  * Neither the name Intel Corporation nor the names of its
  50  *    contributors may be used to endorse or promote products derived
  51  *    from this software without specific prior written permission.
  52  *
  53  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  54  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  55  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  56  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  57  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  58  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  59  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  60  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  61  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  62  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  63  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  64  *****************************************************************************/
  65 #include <linux/types.h>
  66 #include <linux/slab.h>
  67 #include <linux/export.h>
  68 #include <linux/etherdevice.h>
  69 #include <linux/pci.h>
  70 #include <linux/acpi.h>
  71 #include "iwl-drv.h"
  72 #include "iwl-modparams.h"
  73 #include "iwl-nvm-parse.h"
  74 #include "iwl-prph.h"
  75 #include "iwl-io.h"
  76 #include "iwl-csr.h"
  77
  78 /* NVM offsets (in words) definitions */
  79 enum wkp_nvm_offsets {
  80         /* NVM HW-Section offset (in words) definitions */
  81         SUBSYSTEM_ID = 0x0A,
  82         HW_ADDR = 0x15,
  83
  84         /* NVM SW-Section offset (in words) definitions */
  85         NVM_SW_SECTION = 0x1C0,
  86         NVM_VERSION = 0,
  87         RADIO_CFG = 1,
  88         SKU = 2,
  89         N_HW_ADDRS = 3,
  90         NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
  91
  92         /* NVM calibration section offset (in words) definitions */
  93         NVM_CALIB_SECTION = 0x2B8,
  94         XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
  95 };
  96
  97 enum family_8000_nvm_offsets {
  98         /* NVM HW-Section offset (in words) definitions */
  99         HW_ADDR0_WFPM_FAMILY_8000 = 0x12,
 100         HW_ADDR1_WFPM_FAMILY_8000 = 0x16,
 101         HW_ADDR0_PCIE_FAMILY_8000 = 0x8A,
 102         HW_ADDR1_PCIE_FAMILY_8000 = 0x8E,
 103         MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
 104
 105         /* NVM SW-Section offset (in words) definitions */
 106         NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
 107         NVM_VERSION_FAMILY_8000 = 0,
 108         RADIO_CFG_FAMILY_8000 = 0,
 109         SKU_FAMILY_8000 = 2,
 110         N_HW_ADDRS_FAMILY_8000 = 3,
 111
 112         /* NVM REGULATORY -Section offset (in words) definitions */
 113         NVM_CHANNELS_FAMILY_8000 = 0,
 114         NVM_LAR_OFFSET_FAMILY_8000_OLD = 0x4C7,
 115         NVM_LAR_OFFSET_FAMILY_8000 = 0x507,
 116         NVM_LAR_ENABLED_FAMILY_8000 = 0x7,
 117
 118         /* NVM calibration section offset (in words) definitions */
 119         NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
 120         XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
 121 };
 122
 123 /* SKU Capabilities (actual values from NVM definition) */
 124 enum nvm_sku_bits {
 125         NVM_SKU_CAP_BAND_24GHZ          = BIT(0),
 126         NVM_SKU_CAP_BAND_52GHZ          = BIT(1),
 127         NVM_SKU_CAP_11N_ENABLE          = BIT(2),
 128         NVM_SKU_CAP_11AC_ENABLE         = BIT(3),
 129         NVM_SKU_CAP_MIMO_DISABLE        = BIT(5),
 130 };
 131
 132 /*
 133  * These are the channel numbers in the order that they are stored in the NVM
 134  */
 135 static const u8 iwl_nvm_channels[] = {
 136         /* 2.4 GHz */
 137         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 138         /* 5 GHz */
 139         36, 40, 44 , 48, 52, 56, 60, 64,
 140         100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 141         149, 153, 157, 161, 165
 142 };
 143
 144 static const u8 iwl_nvm_channels_family_8000[] = {
 145         /* 2.4 GHz */
 146         1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
 147         /* 5 GHz */
 148         36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
 149         96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
 150         149, 153, 157, 161, 165, 169, 173, 177, 181
 151 };
 152
 153 #define IWL_NUM_CHANNELS                ARRAY_SIZE(iwl_nvm_channels)
 154 #define IWL_NUM_CHANNELS_FAMILY_8000    ARRAY_SIZE(iwl_nvm_channels_family_8000)
 155 #define NUM_2GHZ_CHANNELS               14
 156 #define NUM_2GHZ_CHANNELS_FAMILY_8000   14
 157 #define FIRST_2GHZ_HT_MINUS             5
 158 #define LAST_2GHZ_HT_PLUS               9
 159 #define LAST_5GHZ_HT                    165
 160 #define LAST_5GHZ_HT_FAMILY_8000        181
 161 #define N_HW_ADDR_MASK                  0xF
 162
 163 /* rate data (static) */
 164 static struct ieee80211_rate iwl_cfg80211_rates[] = {
 165         { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
 166         { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
 167           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 168         { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
 169           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 170         { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
 171           .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
 172         { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
 173         { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
 174         { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
 175         { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
 176         { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
 177         { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
 178         { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
 179         { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
 180 };
 181 #define RATES_24_OFFS   0
 182 #define N_RATES_24      ARRAY_SIZE(iwl_cfg80211_rates)
 183 #define RATES_52_OFFS   4
 184 #define N_RATES_52      (N_RATES_24 - RATES_52_OFFS)
 185
 186 /**
 187  * enum iwl_nvm_channel_flags - channel flags in NVM
 188  * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 189  * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 190  * @NVM_CHANNEL_ACTIVE: active scanning allowed
 191  * @NVM_CHANNEL_RADAR: radar detection required
 192  * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
 193  * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
 194  *      on same channel on 2.4 or same UNII band on 5.2
 195  * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 196  * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 197  * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
 198  * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
 199  */
 200 enum iwl_nvm_channel_flags {
 201         NVM_CHANNEL_VALID = BIT(0),
 202         NVM_CHANNEL_IBSS = BIT(1),
 203         NVM_CHANNEL_ACTIVE = BIT(3),
 204         NVM_CHANNEL_RADAR = BIT(4),
 205         NVM_CHANNEL_INDOOR_ONLY = BIT(5),
 206         NVM_CHANNEL_GO_CONCURRENT = BIT(6),
 207         NVM_CHANNEL_WIDE = BIT(8),
 208         NVM_CHANNEL_40MHZ = BIT(9),
 209         NVM_CHANNEL_80MHZ = BIT(10),
 210         NVM_CHANNEL_160MHZ = BIT(11),
 211 };
 212
 213 #define CHECK_AND_PRINT_I(x)    \
 214         ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
 215
 216 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz,
 217                                  u16 nvm_flags, const struct iwl_cfg *cfg)
 218 {
 219         u32 flags = IEEE80211_CHAN_NO_HT40;
 220         u32 last_5ghz_ht = LAST_5GHZ_HT;
 221
 222         if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
 223                 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
 224
 225         if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) {
 226                 if (ch_num <= LAST_2GHZ_HT_PLUS)
 227                         flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 228                 if (ch_num >= FIRST_2GHZ_HT_MINUS)
 229                         flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 230         } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) {
 231                 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 232                         flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
 233                 else
 234                         flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
 235         }
 236         if (!(nvm_flags & NVM_CHANNEL_80MHZ))
 237                 flags |= IEEE80211_CHAN_NO_80MHZ;
 238         if (!(nvm_flags & NVM_CHANNEL_160MHZ))
 239                 flags |= IEEE80211_CHAN_NO_160MHZ;
 240
 241         if (!(nvm_flags & NVM_CHANNEL_IBSS))
 242                 flags |= IEEE80211_CHAN_NO_IR;
 243
 244         if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
 245                 flags |= IEEE80211_CHAN_NO_IR;
 246
 247         if (nvm_flags & NVM_CHANNEL_RADAR)
 248                 flags |= IEEE80211_CHAN_RADAR;
 249
 250         if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
 251                 flags |= IEEE80211_CHAN_INDOOR_ONLY;
 252
 253         /* Set the GO concurrent flag only in case that NO_IR is set.
 254          * Otherwise it is meaningless
 255          */
 256         if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 257             (flags & IEEE80211_CHAN_NO_IR))
 258                 flags |= IEEE80211_CHAN_IR_CONCURRENT;
 259
 260         return flags;
 261 }
 262
 263 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
 264                                 struct iwl_nvm_data *data,
 265                                 const __le16 * const nvm_ch_flags,
 266                                 bool lar_supported, bool no_wide_in_5ghz)
 267 {
 268         int ch_idx;
 269         int n_channels = 0;
 270         struct ieee80211_channel *channel;
 271         u16 ch_flags;
 272         int num_of_ch, num_2ghz_channels;
 273         const u8 *nvm_chan;
 274
 275         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 276                 num_of_ch = IWL_NUM_CHANNELS;
 277                 nvm_chan = &iwl_nvm_channels[0];
 278                 num_2ghz_channels = NUM_2GHZ_CHANNELS;
 279         } else {
 280                 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
 281                 nvm_chan = &iwl_nvm_channels_family_8000[0];
 282                 num_2ghz_channels = NUM_2GHZ_CHANNELS_FAMILY_8000;
 283         }
 284
 285         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 286                 bool is_5ghz = (ch_idx >= num_2ghz_channels);
 287
 288                 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
 289
 290                 if (is_5ghz && !data->sku_cap_band_52GHz_enable)
 291                         continue;
 292
 293                 /* workaround to disable wide channels in 5GHz */
 294                 if (no_wide_in_5ghz && is_5ghz) {
 295                         ch_flags &= ~(NVM_CHANNEL_40MHZ |
 296                                      NVM_CHANNEL_80MHZ |
 297                                      NVM_CHANNEL_160MHZ);
 298                 }
 299
 300                 if (ch_flags & NVM_CHANNEL_160MHZ)
 301                         data->vht160_supported = true;
 302
 303                 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
 304                         /*
 305                          * Channels might become valid later if lar is
 306                          * supported, hence we still want to add them to
 307                          * the list of supported channels to cfg80211.
 308                          */
 309                         IWL_DEBUG_EEPROM(dev,
 310                                          "Ch. %d Flags %x [%sGHz] - No traffic\n",
 311                                          nvm_chan[ch_idx],
 312                                          ch_flags,
 313                                          (ch_idx >= num_2ghz_channels) ?
 314                                          "5.2" : "2.4");
 315                         continue;
 316                 }
 317
 318                 channel = &data->channels[n_channels];
 319                 n_channels++;
 320
 321                 channel->hw_value = nvm_chan[ch_idx];
 322                 channel->band = is_5ghz ?
 323                                 NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
 324                 channel->center_freq =
 325                         ieee80211_channel_to_frequency(
 326                                 channel->hw_value, channel->band);
 327
 328                 /* Initialize regulatory-based run-time data */
 329
 330                 /*
 331                  * Default value - highest tx power value.  max_power
 332                  * is not used in mvm, and is used for backwards compatibility
 333                  */
 334                 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
 335
 336                 /* don't put limitations in case we're using LAR */
 337                 if (!lar_supported)
 338                         channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
 339                                                                ch_idx, is_5ghz,
 340                                                                ch_flags, cfg);
 341                 else
 342                         channel->flags = 0;
 343
 344                 IWL_DEBUG_EEPROM(dev,
 345                                  "Ch. %d [%sGHz] flags 0x%x %s%s%s%s%s%s%s%s%s%s(%ddBm): Ad-Hoc %ssupported\n",
 346                                  channel->hw_value,
 347                                  is_5ghz ? "5.2" : "2.4",
 348                                  ch_flags,
 349                                  CHECK_AND_PRINT_I(VALID),
 350                                  CHECK_AND_PRINT_I(IBSS),
 351                                  CHECK_AND_PRINT_I(ACTIVE),
 352                                  CHECK_AND_PRINT_I(RADAR),
 353                                  CHECK_AND_PRINT_I(INDOOR_ONLY),
 354                                  CHECK_AND_PRINT_I(GO_CONCURRENT),
 355                                  CHECK_AND_PRINT_I(WIDE),
 356                                  CHECK_AND_PRINT_I(40MHZ),
 357                                  CHECK_AND_PRINT_I(80MHZ),
 358                                  CHECK_AND_PRINT_I(160MHZ),
 359                                  channel->max_power,
 360                                  ((ch_flags & NVM_CHANNEL_IBSS) &&
 361                                   !(ch_flags & NVM_CHANNEL_RADAR))
 362                                         ? "" : "not ");
 363         }
 364
 365         return n_channels;
 366 }
 367
 368 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
 369                                   struct iwl_nvm_data *data,
 370                                   struct ieee80211_sta_vht_cap *vht_cap,
 371                                   u8 tx_chains, u8 rx_chains)
 372 {
 373         int num_rx_ants = num_of_ant(rx_chains);
 374         int num_tx_ants = num_of_ant(tx_chains);
 375         unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
 376                                            IEEE80211_VHT_MAX_AMPDU_1024K);
 377
 378         vht_cap->vht_supported = true;
 379
 380         vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
 381                        IEEE80211_VHT_CAP_RXSTBC_1 |
 382                        IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
 383                        3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
 384                        max_ampdu_exponent <<
 385                        IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
 386
 387         if (data->vht160_supported)
 388                 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
 389                                 IEEE80211_VHT_CAP_SHORT_GI_160;
 390
 391         if (cfg->vht_mu_mimo_supported)
 392                 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
 393
 394         if (cfg->ht_params->ldpc)
 395                 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
 396
 397         if (data->sku_cap_mimo_disabled) {
 398                 num_rx_ants = 1;
 399                 num_tx_ants = 1;
 400         }
 401
 402         if (num_tx_ants > 1)
 403                 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
 404         else
 405                 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
 406
 407         switch (iwlwifi_mod_params.amsdu_size) {
 408         case IWL_AMSDU_DEF:
 409                 if (cfg->mq_rx_supported)
 410                         vht_cap->cap |=
 411                                 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
 412                 else
 413                         vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
 414                 break;
 415         case IWL_AMSDU_4K:
 416                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
 417                 break;
 418         case IWL_AMSDU_8K:
 419                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
 420                 break;
 421         case IWL_AMSDU_12K:
 422                 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
 423                 break;
 424         default:
 425                 break;
 426         }
 427
 428         vht_cap->vht_mcs.rx_mcs_map =
 429                 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
 430                             IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
 431                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
 432                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
 433                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
 434                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
 435                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
 436                             IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
 437
 438         if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
 439                 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
 440                 /* this works because NOT_SUPPORTED == 3 */
 441                 vht_cap->vht_mcs.rx_mcs_map |=
 442                         cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
 443         }
 444
 445         vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
 446 }
 447
 448 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
 449                             struct iwl_nvm_data *data,
 450                             const __le16 *ch_section,
 451                             u8 tx_chains, u8 rx_chains, bool lar_supported,
 452                             bool no_wide_in_5ghz)
 453 {
 454         int n_channels;
 455         int n_used = 0;
 456         struct ieee80211_supported_band *sband;
 457
 458         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 459                 n_channels = iwl_init_channel_map(
 460                                 dev, cfg, data,
 461                                 &ch_section[NVM_CHANNELS], lar_supported,
 462                                 no_wide_in_5ghz);
 463         else
 464                 n_channels = iwl_init_channel_map(
 465                                 dev, cfg, data,
 466                                 &ch_section[NVM_CHANNELS_FAMILY_8000],
 467                                 lar_supported,
 468                                 no_wide_in_5ghz);
 469
 470         sband = &data->bands[NL80211_BAND_2GHZ];
 471         sband->band = NL80211_BAND_2GHZ;
 472         sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
 473         sband->n_bitrates = N_RATES_24;
 474         n_used += iwl_init_sband_channels(data, sband, n_channels,
 475                                           NL80211_BAND_2GHZ);
 476         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
 477                              tx_chains, rx_chains);
 478
 479         sband = &data->bands[NL80211_BAND_5GHZ];
 480         sband->band = NL80211_BAND_5GHZ;
 481         sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
 482         sband->n_bitrates = N_RATES_52;
 483         n_used += iwl_init_sband_channels(data, sband, n_channels,
 484                                           NL80211_BAND_5GHZ);
 485         iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
 486                              tx_chains, rx_chains);
 487         if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
 488                 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
 489                                       tx_chains, rx_chains);
 490
 491         if (n_channels != n_used)
 492                 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
 493                             n_used, n_channels);
 494 }
 495
 496 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 497                        const __le16 *phy_sku)
 498 {
 499         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 500                 return le16_to_cpup(nvm_sw + SKU);
 501
 502         return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
 503 }
 504
 505 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 506 {
 507         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 508                 return le16_to_cpup(nvm_sw + NVM_VERSION);
 509         else
 510                 return le32_to_cpup((__le32 *)(nvm_sw +
 511                                                NVM_VERSION_FAMILY_8000));
 512 }
 513
 514 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
 515                              const __le16 *phy_sku)
 516 {
 517         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 518                 return le16_to_cpup(nvm_sw + RADIO_CFG);
 519
 520         return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
 521
 522 }
 523
 524 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
 525 {
 526         int n_hw_addr;
 527
 528         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 529                 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
 530
 531         n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
 532
 533         return n_hw_addr & N_HW_ADDR_MASK;
 534 }
 535
 536 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
 537                               struct iwl_nvm_data *data,
 538                               u32 radio_cfg)
 539 {
 540         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 541                 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
 542                 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
 543                 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
 544                 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
 545                 return;
 546         }
 547
 548         /* set the radio configuration for family 8000 */
 549         data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
 550         data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
 551         data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
 552         data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
 553         data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg);
 554         data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg);
 555 }
 556
 557 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
 558 {
 559         const u8 *hw_addr;
 560
 561         hw_addr = (const u8 *)&mac_addr0;
 562         dest[0] = hw_addr[3];
 563         dest[1] = hw_addr[2];
 564         dest[2] = hw_addr[1];
 565         dest[3] = hw_addr[0];
 566
 567         hw_addr = (const u8 *)&mac_addr1;
 568         dest[4] = hw_addr[1];
 569         dest[5] = hw_addr[0];
 570 }
 571
 572 static void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
 573                                         struct iwl_nvm_data *data)
 574 {
 575         __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
 576         __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
 577
 578         iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 579         /*
 580          * If the OEM fused a valid address, use it instead of the one in the
 581          * OTP
 582          */
 583         if (is_valid_ether_addr(data->hw_addr))
 584                 return;
 585
 586         mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
 587         mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
 588
 589         iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 590 }
 591
 592 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
 593                                            const struct iwl_cfg *cfg,
 594                                            struct iwl_nvm_data *data,
 595                                            const __le16 *mac_override,
 596                                            const __le16 *nvm_hw)
 597 {
 598         const u8 *hw_addr;
 599
 600         if (mac_override) {
 601                 static const u8 reserved_mac[] = {
 602                         0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
 603                 };
 604
 605                 hw_addr = (const u8 *)(mac_override +
 606                                  MAC_ADDRESS_OVERRIDE_FAMILY_8000);
 607
 608                 /*
 609                  * Store the MAC address from MAO section.
 610                  * No byte swapping is required in MAO section
 611                  */
 612                 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
 613
 614                 /*
 615                  * Force the use of the OTP MAC address in case of reserved MAC
 616                  * address in the NVM, or if address is given but invalid.
 617                  */
 618                 if (is_valid_ether_addr(data->hw_addr) &&
 619                     memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
 620                         return;
 621
 622                 IWL_ERR(trans,
 623                         "mac address from nvm override section is not valid\n");
 624         }
 625
 626         if (nvm_hw) {
 627                 /* read the mac address from WFMP registers */
 628                 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
 629                                                 WFMP_MAC_ADDR_0));
 630                 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
 631                                                 WFMP_MAC_ADDR_1));
 632
 633                 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
 634
 635                 return;
 636         }
 637
 638         IWL_ERR(trans, "mac address is not found\n");
 639 }
 640
 641 static int iwl_set_hw_address(struct iwl_trans *trans,
 642                               const struct iwl_cfg *cfg,
 643                               struct iwl_nvm_data *data, const __le16 *nvm_hw,
 644                               const __le16 *mac_override)
 645 {
 646         if (cfg->mac_addr_from_csr) {
 647                 iwl_set_hw_address_from_csr(trans, data);
 648         } else if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 649                 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
 650
 651                 /* The byte order is little endian 16 bit, meaning 214365 */
 652                 data->hw_addr[0] = hw_addr[1];
 653                 data->hw_addr[1] = hw_addr[0];
 654                 data->hw_addr[2] = hw_addr[3];
 655                 data->hw_addr[3] = hw_addr[2];
 656                 data->hw_addr[4] = hw_addr[5];
 657                 data->hw_addr[5] = hw_addr[4];
 658         } else {
 659                 iwl_set_hw_address_family_8000(trans, cfg, data,
 660                                                mac_override, nvm_hw);
 661         }
 662
 663         if (!is_valid_ether_addr(data->hw_addr)) {
 664                 IWL_ERR(trans, "no valid mac address was found\n");
 665                 return -EINVAL;
 666         }
 667
 668         return 0;
 669 }
 670
 671 static bool
 672 iwl_nvm_no_wide_in_5ghz(struct device *dev, const struct iwl_cfg *cfg,
 673                         const __le16 *nvm_hw)
 674 {
 675         /*
 676          * Workaround a bug in Indonesia SKUs where the regulatory in
 677          * some 7000-family OTPs erroneously allow wide channels in
 678          * 5GHz.  To check for Indonesia, we take the SKU value from
 679          * bits 1-4 in the subsystem ID and check if it is either 5 or
 680          * 9.  In those cases, we need to force-disable wide channels
 681          * in 5GHz otherwise the FW will throw a sysassert when we try
 682          * to use them.
 683          */
 684         if (cfg->device_family == IWL_DEVICE_FAMILY_7000) {
 685                 /*
 686                  * Unlike the other sections in the NVM, the hw
 687                  * section uses big-endian.
 688                  */
 689                 u16 subsystem_id = be16_to_cpup((const __be16 *)nvm_hw
 690                                                 + SUBSYSTEM_ID);
 691                 u8 sku = (subsystem_id & 0x1e) >> 1;
 692
 693                 if (sku == 5 || sku == 9) {
 694                         IWL_DEBUG_EEPROM(dev,
 695                                          "disabling wide channels in 5GHz (0x%0x %d)\n",
 696                                          subsystem_id, sku);
 697                         return true;
 698                 }
 699         }
 700
 701         return false;
 702 }
 703
 704 struct iwl_nvm_data *
 705 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
 706                    const __le16 *nvm_hw, const __le16 *nvm_sw,
 707                    const __le16 *nvm_calib, const __le16 *regulatory,
 708                    const __le16 *mac_override, const __le16 *phy_sku,
 709                    u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
 710 {
 711         struct device *dev = trans->dev;
 712         struct iwl_nvm_data *data;
 713         bool lar_enabled;
 714         bool no_wide_in_5ghz = iwl_nvm_no_wide_in_5ghz(dev, cfg, nvm_hw);
 715         u32 sku, radio_cfg;
 716         u16 lar_config;
 717         const __le16 *ch_section;
 718
 719         if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
 720                 data = kzalloc(sizeof(*data) +
 721                                sizeof(struct ieee80211_channel) *
 722                                IWL_NUM_CHANNELS,
 723                                GFP_KERNEL);
 724         else
 725                 data = kzalloc(sizeof(*data) +
 726                                sizeof(struct ieee80211_channel) *
 727                                IWL_NUM_CHANNELS_FAMILY_8000,
 728                                GFP_KERNEL);
 729         if (!data)
 730                 return NULL;
 731
 732         data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
 733
 734         radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
 735         iwl_set_radio_cfg(cfg, data, radio_cfg);
 736         if (data->valid_tx_ant)
 737                 tx_chains &= data->valid_tx_ant;
 738         if (data->valid_rx_ant)
 739                 rx_chains &= data->valid_rx_ant;
 740
 741         sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
 742         data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
 743         data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
 744         data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
 745         if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
 746                 data->sku_cap_11n_enable = false;
 747         data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
 748                                     (sku & NVM_SKU_CAP_11AC_ENABLE);
 749         data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
 750
 751         data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
 752
 753         if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
 754                 /* Checking for required sections */
 755                 if (!nvm_calib) {
 756                         IWL_ERR(trans,
 757                                 "Can't parse empty Calib NVM sections\n");
 758                         kfree(data);
 759                         return NULL;
 760                 }
 761                 /* in family 8000 Xtal calibration values moved to OTP */
 762                 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
 763                 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
 764                 lar_enabled = true;
 765                 ch_section = nvm_sw;
 766         } else {
 767                 u16 lar_offset = data->nvm_version < 0xE39 ?
 768                                  NVM_LAR_OFFSET_FAMILY_8000_OLD :
 769                                  NVM_LAR_OFFSET_FAMILY_8000;
 770
 771                 lar_config = le16_to_cpup(regulatory + lar_offset);
 772                 data->lar_enabled = !!(lar_config &
 773                                        NVM_LAR_ENABLED_FAMILY_8000);
 774                 lar_enabled = data->lar_enabled;
 775                 ch_section = regulatory;
 776         }
 777
 778         /* If no valid mac address was found - bail out */
 779         if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
 780                 kfree(data);
 781                 return NULL;
 782         }
 783
 784         iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
 785                         lar_fw_supported && lar_enabled, no_wide_in_5ghz);
 786         data->calib_version = 255;
 787
 788         return data;
 789 }
 790 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
 791
 792 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
 793                                        int ch_idx, u16 nvm_flags,
 794                                        const struct iwl_cfg *cfg)
 795 {
 796         u32 flags = NL80211_RRF_NO_HT40;
 797         u32 last_5ghz_ht = LAST_5GHZ_HT;
 798
 799         if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
 800                 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
 801
 802         if (ch_idx < NUM_2GHZ_CHANNELS &&
 803             (nvm_flags & NVM_CHANNEL_40MHZ)) {
 804                 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
 805                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 806                 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
 807                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 808         } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
 809                    (nvm_flags & NVM_CHANNEL_40MHZ)) {
 810                 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
 811                         flags &= ~NL80211_RRF_NO_HT40PLUS;
 812                 else
 813                         flags &= ~NL80211_RRF_NO_HT40MINUS;
 814         }
 815
 816         if (!(nvm_flags & NVM_CHANNEL_80MHZ))
 817                 flags |= NL80211_RRF_NO_80MHZ;
 818         if (!(nvm_flags & NVM_CHANNEL_160MHZ))
 819                 flags |= NL80211_RRF_NO_160MHZ;
 820
 821         if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
 822                 flags |= NL80211_RRF_NO_IR;
 823
 824         if (nvm_flags & NVM_CHANNEL_RADAR)
 825                 flags |= NL80211_RRF_DFS;
 826
 827         if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
 828                 flags |= NL80211_RRF_NO_OUTDOOR;
 829
 830         /* Set the GO concurrent flag only in case that NO_IR is set.
 831          * Otherwise it is meaningless
 832          */
 833         if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
 834             (flags & NL80211_RRF_NO_IR))
 835                 flags |= NL80211_RRF_GO_CONCURRENT;
 836
 837         return flags;
 838 }
 839
 840 struct ieee80211_regdomain *
 841 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
 842                        int num_of_ch, __le32 *channels, u16 fw_mcc)
 843 {
 844         int ch_idx;
 845         u16 ch_flags, prev_ch_flags = 0;
 846         const u8 *nvm_chan = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 847                              iwl_nvm_channels_family_8000 : iwl_nvm_channels;
 848         struct ieee80211_regdomain *regd;
 849         int size_of_regd;
 850         struct ieee80211_reg_rule *rule;
 851         enum nl80211_band band;
 852         int center_freq, prev_center_freq = 0;
 853         int valid_rules = 0;
 854         bool new_rule;
 855         int max_num_ch = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
 856                          IWL_NUM_CHANNELS_FAMILY_8000 : IWL_NUM_CHANNELS;
 857
 858         if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
 859                 return ERR_PTR(-EINVAL);
 860
 861         if (WARN_ON(num_of_ch > max_num_ch))
 862                 num_of_ch = max_num_ch;
 863
 864         IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
 865                       num_of_ch);
 866
 867         /* build a regdomain rule for every valid channel */
 868         size_of_regd =
 869                 sizeof(struct ieee80211_regdomain) +
 870                 num_of_ch * sizeof(struct ieee80211_reg_rule);
 871
 872         regd = kzalloc(size_of_regd, GFP_KERNEL);
 873         if (!regd)
 874                 return ERR_PTR(-ENOMEM);
 875
 876         for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
 877                 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
 878                 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
 879                        NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 880                 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
 881                                                              band);
 882                 new_rule = false;
 883
 884                 if (!(ch_flags & NVM_CHANNEL_VALID)) {
 885                         IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 886                                       "Ch. %d Flags %x [%sGHz] - No traffic\n",
 887                                       nvm_chan[ch_idx],
 888                                       ch_flags,
 889                                       (ch_idx >= NUM_2GHZ_CHANNELS) ?
 890                                       "5.2" : "2.4");
 891                         continue;
 892                 }
 893
 894                 /* we can't continue the same rule */
 895                 if (ch_idx == 0 || prev_ch_flags != ch_flags ||
 896                     center_freq - prev_center_freq > 20) {
 897                         valid_rules++;
 898                         new_rule = true;
 899                 }
 900
 901                 rule = &regd->reg_rules[valid_rules - 1];
 902
 903                 if (new_rule)
 904                         rule->freq_range.start_freq_khz =
 905                                                 MHZ_TO_KHZ(center_freq - 10);
 906
 907                 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
 908
 909                 /* this doesn't matter - not used by FW */
 910                 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
 911                 rule->power_rule.max_eirp =
 912                         DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
 913
 914                 rule->flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
 915                                                           ch_flags, cfg);
 916
 917                 /* rely on auto-calculation to merge BW of contiguous chans */
 918                 rule->flags |= NL80211_RRF_AUTO_BW;
 919                 rule->freq_range.max_bandwidth_khz = 0;
 920
 921                 prev_ch_flags = ch_flags;
 922                 prev_center_freq = center_freq;
 923
 924                 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
 925                               "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
 926                               center_freq,
 927                               band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
 928                               CHECK_AND_PRINT_I(VALID),
 929                               CHECK_AND_PRINT_I(ACTIVE),
 930                               CHECK_AND_PRINT_I(RADAR),
 931                               CHECK_AND_PRINT_I(WIDE),
 932                               CHECK_AND_PRINT_I(40MHZ),
 933                               CHECK_AND_PRINT_I(80MHZ),
 934                               CHECK_AND_PRINT_I(160MHZ),
 935                               CHECK_AND_PRINT_I(INDOOR_ONLY),
 936                               CHECK_AND_PRINT_I(GO_CONCURRENT),
 937                               ch_flags,
 938                               ((ch_flags & NVM_CHANNEL_ACTIVE) &&
 939                                !(ch_flags & NVM_CHANNEL_RADAR))
 940                                          ? "" : "not ");
 941         }
 942
 943         regd->n_reg_rules = valid_rules;
 944
 945         /* set alpha2 from FW. */
 946         regd->alpha2[0] = fw_mcc >> 8;
 947         regd->alpha2[1] = fw_mcc & 0xff;
 948
 949         return regd;
 950 }
 951 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);
 952
 953 #ifdef CONFIG_ACPI
 954 #define WRDD_METHOD             "WRDD"
 955 #define WRDD_WIFI               (0x07)
 956 #define WRDD_WIGIG              (0x10)
 957
 958 static u32 iwl_wrdd_get_mcc(struct device *dev, union acpi_object *wrdd)
 959 {
 960         union acpi_object *mcc_pkg, *domain_type, *mcc_value;
 961         u32 i;
 962
 963         if (wrdd->type != ACPI_TYPE_PACKAGE ||
 964             wrdd->package.count < 2 ||
 965             wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||
 966             wrdd->package.elements[0].integer.value != 0) {
 967                 IWL_DEBUG_EEPROM(dev, "Unsupported wrdd structure\n");
 968                 return 0;
 969         }
 970
 971         for (i = 1 ; i < wrdd->package.count ; ++i) {
 972                 mcc_pkg = &wrdd->package.elements[i];
 973
 974                 if (mcc_pkg->type != ACPI_TYPE_PACKAGE ||
 975                     mcc_pkg->package.count < 2 ||
 976                     mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||
 977                     mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
 978                         mcc_pkg = NULL;
 979                         continue;
 980                 }
 981
 982                 domain_type = &mcc_pkg->package.elements[0];
 983                 if (domain_type->integer.value == WRDD_WIFI)
 984                         break;
 985
 986                 mcc_pkg = NULL;
 987         }
 988
 989         if (mcc_pkg) {
 990                 mcc_value = &mcc_pkg->package.elements[1];
 991                 return mcc_value->integer.value;
 992         }
 993
 994         return 0;
 995 }
 996
 997 int iwl_get_bios_mcc(struct device *dev, char *mcc)
 998 {
 999         acpi_handle root_handle;
1000         acpi_handle handle;
1001         struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};
1002         acpi_status status;
1003         u32 mcc_val;
1004
1005         root_handle = ACPI_HANDLE(dev);
1006         if (!root_handle) {
1007                 IWL_DEBUG_EEPROM(dev,
1008                                  "Could not retrieve root port ACPI handle\n");
1009                 return -ENOENT;
1010         }
1011
1012         /* Get the method's handle */
1013         status = acpi_get_handle(root_handle, (acpi_string)WRDD_METHOD,
1014                                  &handle);
1015         if (ACPI_FAILURE(status)) {
1016                 IWL_DEBUG_EEPROM(dev, "WRD method not found\n");
1017                 return -ENOENT;
1018         }
1019
1020         /* Call WRDD with no arguments */
1021         status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);
1022         if (ACPI_FAILURE(status)) {
1023                 IWL_DEBUG_EEPROM(dev, "WRDC invocation failed (0x%x)\n",
1024                                  status);
1025                 return -ENOENT;
1026         }
1027
1028         mcc_val = iwl_wrdd_get_mcc(dev, wrdd.pointer);
1029         kfree(wrdd.pointer);
1030         if (!mcc_val)
1031                 return -ENOENT;
1032
1033         mcc[0] = (mcc_val >> 8) & 0xff;
1034         mcc[1] = mcc_val & 0xff;
1035         mcc[2] = '\0';
1036         return 0;
1037 }
1038 IWL_EXPORT_SYMBOL(iwl_get_bios_mcc);
1039 #endif