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 - 2017 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 * Copyright(c) 2016 - 2017 Intel Deutschland GmbH 38 * All rights reserved. 39 * 40 * Redistribution and use in source and binary forms, with or without 41 * modification, are permitted provided that the following conditions 42 * are met: 43 * 44 * * Redistributions of source code must retain the above copyright 45 * notice, this list of conditions and the following disclaimer. 46 * * Redistributions in binary form must reproduce the above copyright 47 * notice, this list of conditions and the following disclaimer in 48 * the documentation and/or other materials provided with the 49 * distribution. 50 * * Neither the name Intel Corporation nor the names of its 51 * contributors may be used to endorse or promote products derived 52 * from this software without specific prior written permission. 53 * 54 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 55 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 56 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 57 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 58 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 59 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 60 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 61 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 62 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 63 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 64 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 65 *****************************************************************************/ 66 #include <linux/types.h> 67 #include <linux/slab.h> 68 #include <linux/export.h> 69 #include <linux/etherdevice.h> 70 #include <linux/pci.h> 71 #include <linux/acpi.h> 72 #include "iwl-drv.h" 73 #include "iwl-modparams.h" 74 #include "iwl-nvm-parse.h" 75 #include "iwl-prph.h" 76 #include "iwl-io.h" 77 #include "iwl-csr.h" 78 79 /* NVM offsets (in words) definitions */ 80 enum nvm_offsets { 81 /* NVM HW-Section offset (in words) definitions */ 82 SUBSYSTEM_ID = 0x0A, 83 HW_ADDR = 0x15, 84 85 /* NVM SW-Section offset (in words) definitions */ 86 NVM_SW_SECTION = 0x1C0, 87 NVM_VERSION = 0, 88 RADIO_CFG = 1, 89 SKU = 2, 90 N_HW_ADDRS = 3, 91 NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION, 92 93 /* NVM calibration section offset (in words) definitions */ 94 NVM_CALIB_SECTION = 0x2B8, 95 XTAL_CALIB = 0x316 - NVM_CALIB_SECTION, 96 97 /* NVM REGULATORY -Section offset (in words) definitions */ 98 NVM_CHANNELS_SDP = 0, 99 }; 100 101 enum ext_nvm_offsets { 102 /* NVM HW-Section offset (in words) definitions */ 103 MAC_ADDRESS_OVERRIDE_EXT_NVM = 1, 104 105 /* NVM SW-Section offset (in words) definitions */ 106 NVM_VERSION_EXT_NVM = 0, 107 RADIO_CFG_FAMILY_EXT_NVM = 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_EXTENDED = 0, 113 NVM_LAR_OFFSET_OLD = 0x4C7, 114 NVM_LAR_OFFSET = 0x507, 115 NVM_LAR_ENABLED = 0x7, 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_ext_nvm_channels[] = { 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_EXT ARRAY_SIZE(iwl_ext_nvm_channels) 150 #define NUM_2GHZ_CHANNELS 14 151 #define NUM_2GHZ_CHANNELS_EXT 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_UNIFORM: uniform spreading required 191 * @NVM_CHANNEL_20MHZ: 20 MHz channel okay 192 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay 193 * @NVM_CHANNEL_80MHZ: 80 MHz channel okay 194 * @NVM_CHANNEL_160MHZ: 160 MHz channel okay 195 * @NVM_CHANNEL_DC_HIGH: DC HIGH required/allowed (?) 196 */ 197 enum iwl_nvm_channel_flags { 198 NVM_CHANNEL_VALID = BIT(0), 199 NVM_CHANNEL_IBSS = BIT(1), 200 NVM_CHANNEL_ACTIVE = BIT(3), 201 NVM_CHANNEL_RADAR = BIT(4), 202 NVM_CHANNEL_INDOOR_ONLY = BIT(5), 203 NVM_CHANNEL_GO_CONCURRENT = BIT(6), 204 NVM_CHANNEL_UNIFORM = BIT(7), 205 NVM_CHANNEL_20MHZ = BIT(8), 206 NVM_CHANNEL_40MHZ = BIT(9), 207 NVM_CHANNEL_80MHZ = BIT(10), 208 NVM_CHANNEL_160MHZ = BIT(11), 209 NVM_CHANNEL_DC_HIGH = BIT(12), 210 }; 211 212 static inline void iwl_nvm_print_channel_flags(struct device *dev, u32 level, 213 int chan, u16 flags) 214 { 215 #define CHECK_AND_PRINT_I(x) \ 216 ((flags & NVM_CHANNEL_##x) ? " " #x : "") 217 218 if (!(flags & NVM_CHANNEL_VALID)) { 219 IWL_DEBUG_DEV(dev, level, "Ch. %d: 0x%x: No traffic\n", 220 chan, flags); 221 return; 222 } 223 224 /* Note: already can print up to 101 characters, 110 is the limit! */ 225 IWL_DEBUG_DEV(dev, level, 226 "Ch. %d: 0x%x:%s%s%s%s%s%s%s%s%s%s%s%s\n", 227 chan, flags, 228 CHECK_AND_PRINT_I(VALID), 229 CHECK_AND_PRINT_I(IBSS), 230 CHECK_AND_PRINT_I(ACTIVE), 231 CHECK_AND_PRINT_I(RADAR), 232 CHECK_AND_PRINT_I(INDOOR_ONLY), 233 CHECK_AND_PRINT_I(GO_CONCURRENT), 234 CHECK_AND_PRINT_I(UNIFORM), 235 CHECK_AND_PRINT_I(20MHZ), 236 CHECK_AND_PRINT_I(40MHZ), 237 CHECK_AND_PRINT_I(80MHZ), 238 CHECK_AND_PRINT_I(160MHZ), 239 CHECK_AND_PRINT_I(DC_HIGH)); 240 #undef CHECK_AND_PRINT_I 241 } 242 243 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz, 244 u16 nvm_flags, const struct iwl_cfg *cfg) 245 { 246 u32 flags = IEEE80211_CHAN_NO_HT40; 247 u32 last_5ghz_ht = LAST_5GHZ_HT; 248 249 if (cfg->nvm_type == IWL_NVM_EXT) 250 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000; 251 252 if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) { 253 if (ch_num <= LAST_2GHZ_HT_PLUS) 254 flags &= ~IEEE80211_CHAN_NO_HT40PLUS; 255 if (ch_num >= FIRST_2GHZ_HT_MINUS) 256 flags &= ~IEEE80211_CHAN_NO_HT40MINUS; 257 } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) { 258 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0) 259 flags &= ~IEEE80211_CHAN_NO_HT40PLUS; 260 else 261 flags &= ~IEEE80211_CHAN_NO_HT40MINUS; 262 } 263 if (!(nvm_flags & NVM_CHANNEL_80MHZ)) 264 flags |= IEEE80211_CHAN_NO_80MHZ; 265 if (!(nvm_flags & NVM_CHANNEL_160MHZ)) 266 flags |= IEEE80211_CHAN_NO_160MHZ; 267 268 if (!(nvm_flags & NVM_CHANNEL_IBSS)) 269 flags |= IEEE80211_CHAN_NO_IR; 270 271 if (!(nvm_flags & NVM_CHANNEL_ACTIVE)) 272 flags |= IEEE80211_CHAN_NO_IR; 273 274 if (nvm_flags & NVM_CHANNEL_RADAR) 275 flags |= IEEE80211_CHAN_RADAR; 276 277 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY) 278 flags |= IEEE80211_CHAN_INDOOR_ONLY; 279 280 /* Set the GO concurrent flag only in case that NO_IR is set. 281 * Otherwise it is meaningless 282 */ 283 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) && 284 (flags & IEEE80211_CHAN_NO_IR)) 285 flags |= IEEE80211_CHAN_IR_CONCURRENT; 286 287 return flags; 288 } 289 290 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg, 291 struct iwl_nvm_data *data, 292 const __le16 * const nvm_ch_flags, 293 bool lar_supported, bool no_wide_in_5ghz) 294 { 295 int ch_idx; 296 int n_channels = 0; 297 struct ieee80211_channel *channel; 298 u16 ch_flags; 299 int num_of_ch, num_2ghz_channels; 300 const u8 *nvm_chan; 301 302 if (cfg->nvm_type != IWL_NVM_EXT) { 303 num_of_ch = IWL_NUM_CHANNELS; 304 nvm_chan = &iwl_nvm_channels[0]; 305 num_2ghz_channels = NUM_2GHZ_CHANNELS; 306 } else { 307 num_of_ch = IWL_NUM_CHANNELS_EXT; 308 nvm_chan = &iwl_ext_nvm_channels[0]; 309 num_2ghz_channels = NUM_2GHZ_CHANNELS_EXT; 310 } 311 312 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) { 313 bool is_5ghz = (ch_idx >= num_2ghz_channels); 314 315 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx); 316 317 if (is_5ghz && !data->sku_cap_band_52GHz_enable) 318 continue; 319 320 /* workaround to disable wide channels in 5GHz */ 321 if (no_wide_in_5ghz && is_5ghz) { 322 ch_flags &= ~(NVM_CHANNEL_40MHZ | 323 NVM_CHANNEL_80MHZ | 324 NVM_CHANNEL_160MHZ); 325 } 326 327 if (ch_flags & NVM_CHANNEL_160MHZ) 328 data->vht160_supported = true; 329 330 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) { 331 /* 332 * Channels might become valid later if lar is 333 * supported, hence we still want to add them to 334 * the list of supported channels to cfg80211. 335 */ 336 iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM, 337 nvm_chan[ch_idx], ch_flags); 338 continue; 339 } 340 341 channel = &data->channels[n_channels]; 342 n_channels++; 343 344 channel->hw_value = nvm_chan[ch_idx]; 345 channel->band = is_5ghz ? 346 NL80211_BAND_5GHZ : NL80211_BAND_2GHZ; 347 channel->center_freq = 348 ieee80211_channel_to_frequency( 349 channel->hw_value, channel->band); 350 351 /* Initialize regulatory-based run-time data */ 352 353 /* 354 * Default value - highest tx power value. max_power 355 * is not used in mvm, and is used for backwards compatibility 356 */ 357 channel->max_power = IWL_DEFAULT_MAX_TX_POWER; 358 359 /* don't put limitations in case we're using LAR */ 360 if (!lar_supported) 361 channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx], 362 ch_idx, is_5ghz, 363 ch_flags, cfg); 364 else 365 channel->flags = 0; 366 367 iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM, 368 channel->hw_value, ch_flags); 369 IWL_DEBUG_EEPROM(dev, "Ch. %d: %ddBm\n", 370 channel->hw_value, channel->max_power); 371 } 372 373 return n_channels; 374 } 375 376 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg, 377 struct iwl_nvm_data *data, 378 struct ieee80211_sta_vht_cap *vht_cap, 379 u8 tx_chains, u8 rx_chains) 380 { 381 int num_rx_ants = num_of_ant(rx_chains); 382 int num_tx_ants = num_of_ant(tx_chains); 383 unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?: 384 IEEE80211_VHT_MAX_AMPDU_1024K); 385 386 vht_cap->vht_supported = true; 387 388 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 | 389 IEEE80211_VHT_CAP_RXSTBC_1 | 390 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE | 391 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT | 392 max_ampdu_exponent << 393 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT; 394 395 if (data->vht160_supported) 396 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ | 397 IEEE80211_VHT_CAP_SHORT_GI_160; 398 399 if (cfg->vht_mu_mimo_supported) 400 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE; 401 402 if (cfg->ht_params->ldpc) 403 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC; 404 405 if (data->sku_cap_mimo_disabled) { 406 num_rx_ants = 1; 407 num_tx_ants = 1; 408 } 409 410 if (num_tx_ants > 1) 411 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC; 412 else 413 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN; 414 415 switch (iwlwifi_mod_params.amsdu_size) { 416 case IWL_AMSDU_DEF: 417 if (cfg->mq_rx_supported) 418 vht_cap->cap |= 419 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454; 420 else 421 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895; 422 break; 423 case IWL_AMSDU_4K: 424 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895; 425 break; 426 case IWL_AMSDU_8K: 427 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991; 428 break; 429 case IWL_AMSDU_12K: 430 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454; 431 break; 432 default: 433 break; 434 } 435 436 vht_cap->vht_mcs.rx_mcs_map = 437 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 | 438 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 | 439 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 | 440 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 | 441 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 | 442 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 | 443 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 | 444 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14); 445 446 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) { 447 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN; 448 /* this works because NOT_SUPPORTED == 3 */ 449 vht_cap->vht_mcs.rx_mcs_map |= 450 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2); 451 } 452 453 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map; 454 } 455 456 void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg, 457 struct iwl_nvm_data *data, const __le16 *nvm_ch_flags, 458 u8 tx_chains, u8 rx_chains, bool lar_supported, 459 bool no_wide_in_5ghz) 460 { 461 int n_channels; 462 int n_used = 0; 463 struct ieee80211_supported_band *sband; 464 465 n_channels = iwl_init_channel_map(dev, cfg, data, nvm_ch_flags, 466 lar_supported, no_wide_in_5ghz); 467 sband = &data->bands[NL80211_BAND_2GHZ]; 468 sband->band = NL80211_BAND_2GHZ; 469 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS]; 470 sband->n_bitrates = N_RATES_24; 471 n_used += iwl_init_sband_channels(data, sband, n_channels, 472 NL80211_BAND_2GHZ); 473 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ, 474 tx_chains, rx_chains); 475 476 sband = &data->bands[NL80211_BAND_5GHZ]; 477 sband->band = NL80211_BAND_5GHZ; 478 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS]; 479 sband->n_bitrates = N_RATES_52; 480 n_used += iwl_init_sband_channels(data, sband, n_channels, 481 NL80211_BAND_5GHZ); 482 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ, 483 tx_chains, rx_chains); 484 if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac) 485 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap, 486 tx_chains, rx_chains); 487 488 if (n_channels != n_used) 489 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n", 490 n_used, n_channels); 491 } 492 IWL_EXPORT_SYMBOL(iwl_init_sbands); 493 494 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw, 495 const __le16 *phy_sku) 496 { 497 if (cfg->nvm_type != IWL_NVM_EXT) 498 return le16_to_cpup(nvm_sw + SKU); 499 500 return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000)); 501 } 502 503 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw) 504 { 505 if (cfg->nvm_type != IWL_NVM_EXT) 506 return le16_to_cpup(nvm_sw + NVM_VERSION); 507 else 508 return le32_to_cpup((__le32 *)(nvm_sw + 509 NVM_VERSION_EXT_NVM)); 510 } 511 512 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw, 513 const __le16 *phy_sku) 514 { 515 if (cfg->nvm_type != IWL_NVM_EXT) 516 return le16_to_cpup(nvm_sw + RADIO_CFG); 517 518 return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_EXT_NVM)); 519 520 } 521 522 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw) 523 { 524 int n_hw_addr; 525 526 if (cfg->nvm_type != IWL_NVM_EXT) 527 return le16_to_cpup(nvm_sw + N_HW_ADDRS); 528 529 n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000)); 530 531 return n_hw_addr & N_HW_ADDR_MASK; 532 } 533 534 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg, 535 struct iwl_nvm_data *data, 536 u32 radio_cfg) 537 { 538 if (cfg->nvm_type != IWL_NVM_EXT) { 539 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg); 540 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg); 541 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg); 542 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg); 543 return; 544 } 545 546 /* set the radio configuration for family 8000 */ 547 data->radio_cfg_type = EXT_NVM_RF_CFG_TYPE_MSK(radio_cfg); 548 data->radio_cfg_step = EXT_NVM_RF_CFG_STEP_MSK(radio_cfg); 549 data->radio_cfg_dash = EXT_NVM_RF_CFG_DASH_MSK(radio_cfg); 550 data->radio_cfg_pnum = EXT_NVM_RF_CFG_FLAVOR_MSK(radio_cfg); 551 data->valid_tx_ant = EXT_NVM_RF_CFG_TX_ANT_MSK(radio_cfg); 552 data->valid_rx_ant = EXT_NVM_RF_CFG_RX_ANT_MSK(radio_cfg); 553 } 554 555 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest) 556 { 557 const u8 *hw_addr; 558 559 hw_addr = (const u8 *)&mac_addr0; 560 dest[0] = hw_addr[3]; 561 dest[1] = hw_addr[2]; 562 dest[2] = hw_addr[1]; 563 dest[3] = hw_addr[0]; 564 565 hw_addr = (const u8 *)&mac_addr1; 566 dest[4] = hw_addr[1]; 567 dest[5] = hw_addr[0]; 568 } 569 570 void iwl_set_hw_address_from_csr(struct iwl_trans *trans, 571 struct iwl_nvm_data *data) 572 { 573 __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP)); 574 __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP)); 575 576 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr); 577 /* 578 * If the OEM fused a valid address, use it instead of the one in the 579 * OTP 580 */ 581 if (is_valid_ether_addr(data->hw_addr)) 582 return; 583 584 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP)); 585 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP)); 586 587 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr); 588 } 589 IWL_EXPORT_SYMBOL(iwl_set_hw_address_from_csr); 590 591 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans, 592 const struct iwl_cfg *cfg, 593 struct iwl_nvm_data *data, 594 const __le16 *mac_override, 595 const __be16 *nvm_hw) 596 { 597 const u8 *hw_addr; 598 599 if (mac_override) { 600 static const u8 reserved_mac[] = { 601 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00 602 }; 603 604 hw_addr = (const u8 *)(mac_override + 605 MAC_ADDRESS_OVERRIDE_EXT_NVM); 606 607 /* 608 * Store the MAC address from MAO section. 609 * No byte swapping is required in MAO section 610 */ 611 memcpy(data->hw_addr, hw_addr, ETH_ALEN); 612 613 /* 614 * Force the use of the OTP MAC address in case of reserved MAC 615 * address in the NVM, or if address is given but invalid. 616 */ 617 if (is_valid_ether_addr(data->hw_addr) && 618 memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0) 619 return; 620 621 IWL_ERR(trans, 622 "mac address from nvm override section is not valid\n"); 623 } 624 625 if (nvm_hw) { 626 /* read the mac address from WFMP registers */ 627 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans, 628 WFMP_MAC_ADDR_0)); 629 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans, 630 WFMP_MAC_ADDR_1)); 631 632 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr); 633 634 return; 635 } 636 637 IWL_ERR(trans, "mac address is not found\n"); 638 } 639 640 static int iwl_set_hw_address(struct iwl_trans *trans, 641 const struct iwl_cfg *cfg, 642 struct iwl_nvm_data *data, const __be16 *nvm_hw, 643 const __le16 *mac_override) 644 { 645 if (cfg->mac_addr_from_csr) { 646 iwl_set_hw_address_from_csr(trans, data); 647 } else if (cfg->nvm_type != IWL_NVM_EXT) { 648 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR); 649 650 /* The byte order is little endian 16 bit, meaning 214365 */ 651 data->hw_addr[0] = hw_addr[1]; 652 data->hw_addr[1] = hw_addr[0]; 653 data->hw_addr[2] = hw_addr[3]; 654 data->hw_addr[3] = hw_addr[2]; 655 data->hw_addr[4] = hw_addr[5]; 656 data->hw_addr[5] = hw_addr[4]; 657 } else { 658 iwl_set_hw_address_family_8000(trans, cfg, data, 659 mac_override, nvm_hw); 660 } 661 662 if (!is_valid_ether_addr(data->hw_addr)) { 663 IWL_ERR(trans, "no valid mac address was found\n"); 664 return -EINVAL; 665 } 666 667 IWL_INFO(trans, "base HW address: %pM\n", data->hw_addr); 668 669 return 0; 670 } 671 672 static bool 673 iwl_nvm_no_wide_in_5ghz(struct device *dev, const struct iwl_cfg *cfg, 674 const __be16 *nvm_hw) 675 { 676 /* 677 * Workaround a bug in Indonesia SKUs where the regulatory in 678 * some 7000-family OTPs erroneously allow wide channels in 679 * 5GHz. To check for Indonesia, we take the SKU value from 680 * bits 1-4 in the subsystem ID and check if it is either 5 or 681 * 9. In those cases, we need to force-disable wide channels 682 * in 5GHz otherwise the FW will throw a sysassert when we try 683 * to use them. 684 */ 685 if (cfg->device_family == IWL_DEVICE_FAMILY_7000) { 686 /* 687 * Unlike the other sections in the NVM, the hw 688 * section uses big-endian. 689 */ 690 u16 subsystem_id = be16_to_cpup(nvm_hw + 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 __be16 *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->nvm_type != IWL_NVM_EXT) 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_EXT, 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->nvm_type != IWL_NVM_EXT) { 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 762 ch_section = cfg->nvm_type == IWL_NVM_SDP ? 763 ®ulatory[NVM_CHANNELS_SDP] : 764 &nvm_sw[NVM_CHANNELS]; 765 766 /* in family 8000 Xtal calibration values moved to OTP */ 767 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB); 768 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1); 769 lar_enabled = true; 770 } else { 771 u16 lar_offset = data->nvm_version < 0xE39 ? 772 NVM_LAR_OFFSET_OLD : 773 NVM_LAR_OFFSET; 774 775 lar_config = le16_to_cpup(regulatory + lar_offset); 776 data->lar_enabled = !!(lar_config & 777 NVM_LAR_ENABLED); 778 lar_enabled = data->lar_enabled; 779 ch_section = ®ulatory[NVM_CHANNELS_EXTENDED]; 780 } 781 782 /* If no valid mac address was found - bail out */ 783 if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) { 784 kfree(data); 785 return NULL; 786 } 787 788 iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains, 789 lar_fw_supported && lar_enabled, no_wide_in_5ghz); 790 data->calib_version = 255; 791 792 return data; 793 } 794 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data); 795 796 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan, 797 int ch_idx, u16 nvm_flags, 798 const struct iwl_cfg *cfg) 799 { 800 u32 flags = NL80211_RRF_NO_HT40; 801 u32 last_5ghz_ht = LAST_5GHZ_HT; 802 803 if (cfg->nvm_type == IWL_NVM_EXT) 804 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000; 805 806 if (ch_idx < NUM_2GHZ_CHANNELS && 807 (nvm_flags & NVM_CHANNEL_40MHZ)) { 808 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS) 809 flags &= ~NL80211_RRF_NO_HT40PLUS; 810 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS) 811 flags &= ~NL80211_RRF_NO_HT40MINUS; 812 } else if (nvm_chan[ch_idx] <= last_5ghz_ht && 813 (nvm_flags & NVM_CHANNEL_40MHZ)) { 814 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0) 815 flags &= ~NL80211_RRF_NO_HT40PLUS; 816 else 817 flags &= ~NL80211_RRF_NO_HT40MINUS; 818 } 819 820 if (!(nvm_flags & NVM_CHANNEL_80MHZ)) 821 flags |= NL80211_RRF_NO_80MHZ; 822 if (!(nvm_flags & NVM_CHANNEL_160MHZ)) 823 flags |= NL80211_RRF_NO_160MHZ; 824 825 if (!(nvm_flags & NVM_CHANNEL_ACTIVE)) 826 flags |= NL80211_RRF_NO_IR; 827 828 if (nvm_flags & NVM_CHANNEL_RADAR) 829 flags |= NL80211_RRF_DFS; 830 831 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY) 832 flags |= NL80211_RRF_NO_OUTDOOR; 833 834 /* Set the GO concurrent flag only in case that NO_IR is set. 835 * Otherwise it is meaningless 836 */ 837 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) && 838 (flags & NL80211_RRF_NO_IR)) 839 flags |= NL80211_RRF_GO_CONCURRENT; 840 841 return flags; 842 } 843 844 struct ieee80211_regdomain * 845 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg, 846 int num_of_ch, __le32 *channels, u16 fw_mcc) 847 { 848 int ch_idx; 849 u16 ch_flags; 850 u32 reg_rule_flags, prev_reg_rule_flags = 0; 851 const u8 *nvm_chan = cfg->nvm_type == IWL_NVM_EXT ? 852 iwl_ext_nvm_channels : iwl_nvm_channels; 853 struct ieee80211_regdomain *regd; 854 int size_of_regd; 855 struct ieee80211_reg_rule *rule; 856 enum nl80211_band band; 857 int center_freq, prev_center_freq = 0; 858 int valid_rules = 0; 859 bool new_rule; 860 int max_num_ch = cfg->nvm_type == IWL_NVM_EXT ? 861 IWL_NUM_CHANNELS_EXT : IWL_NUM_CHANNELS; 862 863 if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES)) 864 return ERR_PTR(-EINVAL); 865 866 if (WARN_ON(num_of_ch > max_num_ch)) 867 num_of_ch = max_num_ch; 868 869 IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n", 870 num_of_ch); 871 872 /* build a regdomain rule for every valid channel */ 873 size_of_regd = 874 sizeof(struct ieee80211_regdomain) + 875 num_of_ch * sizeof(struct ieee80211_reg_rule); 876 877 regd = kzalloc(size_of_regd, GFP_KERNEL); 878 if (!regd) 879 return ERR_PTR(-ENOMEM); 880 881 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) { 882 ch_flags = (u16)__le32_to_cpup(channels + ch_idx); 883 band = (ch_idx < NUM_2GHZ_CHANNELS) ? 884 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ; 885 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx], 886 band); 887 new_rule = false; 888 889 if (!(ch_flags & NVM_CHANNEL_VALID)) { 890 iwl_nvm_print_channel_flags(dev, IWL_DL_LAR, 891 nvm_chan[ch_idx], ch_flags); 892 continue; 893 } 894 895 reg_rule_flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx, 896 ch_flags, cfg); 897 898 /* we can't continue the same rule */ 899 if (ch_idx == 0 || prev_reg_rule_flags != reg_rule_flags || 900 center_freq - prev_center_freq > 20) { 901 valid_rules++; 902 new_rule = true; 903 } 904 905 rule = ®d->reg_rules[valid_rules - 1]; 906 907 if (new_rule) 908 rule->freq_range.start_freq_khz = 909 MHZ_TO_KHZ(center_freq - 10); 910 911 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10); 912 913 /* this doesn't matter - not used by FW */ 914 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6); 915 rule->power_rule.max_eirp = 916 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER); 917 918 rule->flags = reg_rule_flags; 919 920 /* rely on auto-calculation to merge BW of contiguous chans */ 921 rule->flags |= NL80211_RRF_AUTO_BW; 922 rule->freq_range.max_bandwidth_khz = 0; 923 924 prev_center_freq = center_freq; 925 prev_reg_rule_flags = reg_rule_flags; 926 927 iwl_nvm_print_channel_flags(dev, IWL_DL_LAR, 928 nvm_chan[ch_idx], ch_flags); 929 } 930 931 regd->n_reg_rules = valid_rules; 932 933 /* set alpha2 from FW. */ 934 regd->alpha2[0] = fw_mcc >> 8; 935 regd->alpha2[1] = fw_mcc & 0xff; 936 937 return regd; 938 } 939 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info); 940 941 #ifdef CONFIG_ACPI 942 #define WRDD_METHOD "WRDD" 943 #define WRDD_WIFI (0x07) 944 #define WRDD_WIGIG (0x10) 945 946 static u32 iwl_wrdd_get_mcc(struct device *dev, union acpi_object *wrdd) 947 { 948 union acpi_object *mcc_pkg, *domain_type, *mcc_value; 949 u32 i; 950 951 if (wrdd->type != ACPI_TYPE_PACKAGE || 952 wrdd->package.count < 2 || 953 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER || 954 wrdd->package.elements[0].integer.value != 0) { 955 IWL_DEBUG_EEPROM(dev, "Unsupported wrdd structure\n"); 956 return 0; 957 } 958 959 for (i = 1 ; i < wrdd->package.count ; ++i) { 960 mcc_pkg = &wrdd->package.elements[i]; 961 962 if (mcc_pkg->type != ACPI_TYPE_PACKAGE || 963 mcc_pkg->package.count < 2 || 964 mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER || 965 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) { 966 mcc_pkg = NULL; 967 continue; 968 } 969 970 domain_type = &mcc_pkg->package.elements[0]; 971 if (domain_type->integer.value == WRDD_WIFI) 972 break; 973 974 mcc_pkg = NULL; 975 } 976 977 if (mcc_pkg) { 978 mcc_value = &mcc_pkg->package.elements[1]; 979 return mcc_value->integer.value; 980 } 981 982 return 0; 983 } 984 985 int iwl_get_bios_mcc(struct device *dev, char *mcc) 986 { 987 acpi_handle root_handle; 988 acpi_handle handle; 989 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL}; 990 acpi_status status; 991 u32 mcc_val; 992 993 root_handle = ACPI_HANDLE(dev); 994 if (!root_handle) { 995 IWL_DEBUG_EEPROM(dev, 996 "Could not retrieve root port ACPI handle\n"); 997 return -ENOENT; 998 } 999 1000 /* Get the method's handle */ 1001 status = acpi_get_handle(root_handle, (acpi_string)WRDD_METHOD, 1002 &handle); 1003 if (ACPI_FAILURE(status)) { 1004 IWL_DEBUG_EEPROM(dev, "WRD method not found\n"); 1005 return -ENOENT; 1006 } 1007 1008 /* Call WRDD with no arguments */ 1009 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd); 1010 if (ACPI_FAILURE(status)) { 1011 IWL_DEBUG_EEPROM(dev, "WRDC invocation failed (0x%x)\n", 1012 status); 1013 return -ENOENT; 1014 } 1015 1016 mcc_val = iwl_wrdd_get_mcc(dev, wrdd.pointer); 1017 kfree(wrdd.pointer); 1018 if (!mcc_val) 1019 return -ENOENT; 1020 1021 mcc[0] = (mcc_val >> 8) & 0xff; 1022 mcc[1] = mcc_val & 0xff; 1023 mcc[2] = '\0'; 1024 return 0; 1025 } 1026 IWL_EXPORT_SYMBOL(iwl_get_bios_mcc); 1027 #endif 1028