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