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