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