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