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