1 /******************************************************************************
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.
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
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.
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.
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,
26 * The full GNU General Public License is included in this distribution
27 * in the file called COPYING.
29 * Contact Information:
30 * Intel Linux Wireless <linuxwifi@intel.com>
31 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
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.
40 * Redistribution and use in source and binary forms, with or without
41 * modification, are permitted provided that the following conditions
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
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.
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>
73 #include "iwl-modparams.h"
74 #include "iwl-nvm-parse.h"
79 /* NVM offsets (in words) definitions */
81 /* NVM HW-Section offset (in words) definitions */
85 /* NVM SW-Section offset (in words) definitions */
86 NVM_SW_SECTION = 0x1C0,
91 NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
93 /* NVM calibration section offset (in words) definitions */
94 NVM_CALIB_SECTION = 0x2B8,
95 XTAL_CALIB = 0x316 - NVM_CALIB_SECTION,
97 /* NVM REGULATORY -Section offset (in words) definitions */
101 enum ext_nvm_offsets {
102 /* NVM HW-Section offset (in words) definitions */
103 MAC_ADDRESS_OVERRIDE_EXT_NVM = 1,
105 /* NVM SW-Section offset (in words) definitions */
106 NVM_VERSION_EXT_NVM = 0,
107 RADIO_CFG_FAMILY_EXT_NVM = 0,
109 N_HW_ADDRS_FAMILY_8000 = 3,
111 /* NVM REGULATORY -Section offset (in words) definitions */
112 NVM_CHANNELS_EXTENDED = 0,
113 NVM_LAR_OFFSET_OLD = 0x4C7,
114 NVM_LAR_OFFSET = 0x507,
115 NVM_LAR_ENABLED = 0x7,
118 /* SKU Capabilities (actual values from NVM definition) */
120 NVM_SKU_CAP_BAND_24GHZ = BIT(0),
121 NVM_SKU_CAP_BAND_52GHZ = BIT(1),
122 NVM_SKU_CAP_11N_ENABLE = BIT(2),
123 NVM_SKU_CAP_11AC_ENABLE = BIT(3),
124 NVM_SKU_CAP_MIMO_DISABLE = BIT(5),
128 * These are the channel numbers in the order that they are stored in the NVM
130 static const u8 iwl_nvm_channels[] = {
132 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
134 36, 40, 44 , 48, 52, 56, 60, 64,
135 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
136 149, 153, 157, 161, 165
139 static const u8 iwl_ext_nvm_channels[] = {
141 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
143 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
144 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
145 149, 153, 157, 161, 165, 169, 173, 177, 181
148 #define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
149 #define IWL_NUM_CHANNELS_EXT ARRAY_SIZE(iwl_ext_nvm_channels)
150 #define NUM_2GHZ_CHANNELS 14
151 #define NUM_2GHZ_CHANNELS_EXT 14
152 #define FIRST_2GHZ_HT_MINUS 5
153 #define LAST_2GHZ_HT_PLUS 9
154 #define LAST_5GHZ_HT 165
155 #define LAST_5GHZ_HT_FAMILY_8000 181
156 #define N_HW_ADDR_MASK 0xF
158 /* rate data (static) */
159 static struct ieee80211_rate iwl_cfg80211_rates[] = {
160 { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
161 { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
162 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
163 { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
164 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
165 { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
166 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
167 { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
168 { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
169 { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
170 { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
171 { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
172 { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
173 { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
174 { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
176 #define RATES_24_OFFS 0
177 #define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
178 #define RATES_52_OFFS 4
179 #define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
182 * enum iwl_nvm_channel_flags - channel flags in NVM
183 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
184 * @NVM_CHANNEL_IBSS: usable as an IBSS channel
185 * @NVM_CHANNEL_ACTIVE: active scanning allowed
186 * @NVM_CHANNEL_RADAR: radar detection required
187 * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
188 * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
189 * on same channel on 2.4 or same UNII band on 5.2
190 * @NVM_CHANNEL_UNIFORM: uniform spreading required
191 * @NVM_CHANNEL_20MHZ: 20 MHz channel okay
192 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay
193 * @NVM_CHANNEL_80MHZ: 80 MHz channel okay
194 * @NVM_CHANNEL_160MHZ: 160 MHz channel okay
195 * @NVM_CHANNEL_DC_HIGH: DC HIGH required/allowed (?)
197 enum iwl_nvm_channel_flags {
198 NVM_CHANNEL_VALID = BIT(0),
199 NVM_CHANNEL_IBSS = BIT(1),
200 NVM_CHANNEL_ACTIVE = BIT(3),
201 NVM_CHANNEL_RADAR = BIT(4),
202 NVM_CHANNEL_INDOOR_ONLY = BIT(5),
203 NVM_CHANNEL_GO_CONCURRENT = BIT(6),
204 NVM_CHANNEL_UNIFORM = BIT(7),
205 NVM_CHANNEL_20MHZ = BIT(8),
206 NVM_CHANNEL_40MHZ = BIT(9),
207 NVM_CHANNEL_80MHZ = BIT(10),
208 NVM_CHANNEL_160MHZ = BIT(11),
209 NVM_CHANNEL_DC_HIGH = BIT(12),
212 static inline void iwl_nvm_print_channel_flags(struct device *dev, u32 level,
215 #define CHECK_AND_PRINT_I(x) \
216 ((flags & NVM_CHANNEL_##x) ? " " #x : "")
218 if (!(flags & NVM_CHANNEL_VALID)) {
219 IWL_DEBUG_DEV(dev, level, "Ch. %d: 0x%x: No traffic\n",
224 /* Note: already can print up to 101 characters, 110 is the limit! */
225 IWL_DEBUG_DEV(dev, level,
226 "Ch. %d: 0x%x:%s%s%s%s%s%s%s%s%s%s%s%s\n",
228 CHECK_AND_PRINT_I(VALID),
229 CHECK_AND_PRINT_I(IBSS),
230 CHECK_AND_PRINT_I(ACTIVE),
231 CHECK_AND_PRINT_I(RADAR),
232 CHECK_AND_PRINT_I(INDOOR_ONLY),
233 CHECK_AND_PRINT_I(GO_CONCURRENT),
234 CHECK_AND_PRINT_I(UNIFORM),
235 CHECK_AND_PRINT_I(20MHZ),
236 CHECK_AND_PRINT_I(40MHZ),
237 CHECK_AND_PRINT_I(80MHZ),
238 CHECK_AND_PRINT_I(160MHZ),
239 CHECK_AND_PRINT_I(DC_HIGH));
240 #undef CHECK_AND_PRINT_I
243 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz,
244 u16 nvm_flags, const struct iwl_cfg *cfg)
246 u32 flags = IEEE80211_CHAN_NO_HT40;
247 u32 last_5ghz_ht = LAST_5GHZ_HT;
249 if (cfg->nvm_type == IWL_NVM_EXT)
250 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
252 if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) {
253 if (ch_num <= LAST_2GHZ_HT_PLUS)
254 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
255 if (ch_num >= FIRST_2GHZ_HT_MINUS)
256 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
257 } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) {
258 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
259 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
261 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
263 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
264 flags |= IEEE80211_CHAN_NO_80MHZ;
265 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
266 flags |= IEEE80211_CHAN_NO_160MHZ;
268 if (!(nvm_flags & NVM_CHANNEL_IBSS))
269 flags |= IEEE80211_CHAN_NO_IR;
271 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
272 flags |= IEEE80211_CHAN_NO_IR;
274 if (nvm_flags & NVM_CHANNEL_RADAR)
275 flags |= IEEE80211_CHAN_RADAR;
277 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
278 flags |= IEEE80211_CHAN_INDOOR_ONLY;
280 /* Set the GO concurrent flag only in case that NO_IR is set.
281 * Otherwise it is meaningless
283 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
284 (flags & IEEE80211_CHAN_NO_IR))
285 flags |= IEEE80211_CHAN_IR_CONCURRENT;
290 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
291 struct iwl_nvm_data *data,
292 const __le16 * const nvm_ch_flags,
293 bool lar_supported, bool no_wide_in_5ghz)
297 struct ieee80211_channel *channel;
299 int num_of_ch, num_2ghz_channels;
302 if (cfg->nvm_type != IWL_NVM_EXT) {
303 num_of_ch = IWL_NUM_CHANNELS;
304 nvm_chan = &iwl_nvm_channels[0];
305 num_2ghz_channels = NUM_2GHZ_CHANNELS;
307 num_of_ch = IWL_NUM_CHANNELS_EXT;
308 nvm_chan = &iwl_ext_nvm_channels[0];
309 num_2ghz_channels = NUM_2GHZ_CHANNELS_EXT;
312 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
313 bool is_5ghz = (ch_idx >= num_2ghz_channels);
315 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
317 if (is_5ghz && !data->sku_cap_band_52GHz_enable)
320 /* workaround to disable wide channels in 5GHz */
321 if (no_wide_in_5ghz && is_5ghz) {
322 ch_flags &= ~(NVM_CHANNEL_40MHZ |
327 if (ch_flags & NVM_CHANNEL_160MHZ)
328 data->vht160_supported = true;
330 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
332 * Channels might become valid later if lar is
333 * supported, hence we still want to add them to
334 * the list of supported channels to cfg80211.
336 iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM,
337 nvm_chan[ch_idx], ch_flags);
341 channel = &data->channels[n_channels];
344 channel->hw_value = nvm_chan[ch_idx];
345 channel->band = is_5ghz ?
346 NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
347 channel->center_freq =
348 ieee80211_channel_to_frequency(
349 channel->hw_value, channel->band);
351 /* Initialize regulatory-based run-time data */
354 * Default value - highest tx power value. max_power
355 * is not used in mvm, and is used for backwards compatibility
357 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
359 /* don't put limitations in case we're using LAR */
361 channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
367 iwl_nvm_print_channel_flags(dev, IWL_DL_EEPROM,
368 channel->hw_value, ch_flags);
369 IWL_DEBUG_EEPROM(dev, "Ch. %d: %ddBm\n",
370 channel->hw_value, channel->max_power);
376 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
377 struct iwl_nvm_data *data,
378 struct ieee80211_sta_vht_cap *vht_cap,
379 u8 tx_chains, u8 rx_chains)
381 int num_rx_ants = num_of_ant(rx_chains);
382 int num_tx_ants = num_of_ant(tx_chains);
383 unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
384 IEEE80211_VHT_MAX_AMPDU_1024K);
386 vht_cap->vht_supported = true;
388 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
389 IEEE80211_VHT_CAP_RXSTBC_1 |
390 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
391 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
392 max_ampdu_exponent <<
393 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
395 if (data->vht160_supported)
396 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
397 IEEE80211_VHT_CAP_SHORT_GI_160;
399 if (cfg->vht_mu_mimo_supported)
400 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
402 if (cfg->ht_params->ldpc)
403 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
405 if (data->sku_cap_mimo_disabled) {
411 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
413 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
415 switch (iwlwifi_mod_params.amsdu_size) {
417 if (cfg->mq_rx_supported)
419 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
421 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
424 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
427 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
430 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
436 vht_cap->vht_mcs.rx_mcs_map =
437 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
438 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
439 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
440 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
441 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
442 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
443 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
444 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
446 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
447 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
448 /* this works because NOT_SUPPORTED == 3 */
449 vht_cap->vht_mcs.rx_mcs_map |=
450 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
453 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
456 void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
457 struct iwl_nvm_data *data, const __le16 *nvm_ch_flags,
458 u8 tx_chains, u8 rx_chains, bool lar_supported,
459 bool no_wide_in_5ghz)
463 struct ieee80211_supported_band *sband;
465 n_channels = iwl_init_channel_map(dev, cfg, data, nvm_ch_flags,
466 lar_supported, no_wide_in_5ghz);
467 sband = &data->bands[NL80211_BAND_2GHZ];
468 sband->band = NL80211_BAND_2GHZ;
469 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
470 sband->n_bitrates = N_RATES_24;
471 n_used += iwl_init_sband_channels(data, sband, n_channels,
473 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
474 tx_chains, rx_chains);
476 sband = &data->bands[NL80211_BAND_5GHZ];
477 sband->band = NL80211_BAND_5GHZ;
478 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
479 sband->n_bitrates = N_RATES_52;
480 n_used += iwl_init_sband_channels(data, sband, n_channels,
482 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
483 tx_chains, rx_chains);
484 if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
485 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
486 tx_chains, rx_chains);
488 if (n_channels != n_used)
489 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
492 IWL_EXPORT_SYMBOL(iwl_init_sbands);
494 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
495 const __le16 *phy_sku)
497 if (cfg->nvm_type != IWL_NVM_EXT)
498 return le16_to_cpup(nvm_sw + SKU);
500 return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
503 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
505 if (cfg->nvm_type != IWL_NVM_EXT)
506 return le16_to_cpup(nvm_sw + NVM_VERSION);
508 return le32_to_cpup((__le32 *)(nvm_sw +
509 NVM_VERSION_EXT_NVM));
512 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
513 const __le16 *phy_sku)
515 if (cfg->nvm_type != IWL_NVM_EXT)
516 return le16_to_cpup(nvm_sw + RADIO_CFG);
518 return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_EXT_NVM));
522 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
526 if (cfg->nvm_type != IWL_NVM_EXT)
527 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
529 n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
531 return n_hw_addr & N_HW_ADDR_MASK;
534 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
535 struct iwl_nvm_data *data,
538 if (cfg->nvm_type != IWL_NVM_EXT) {
539 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
540 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
541 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
542 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
546 /* set the radio configuration for family 8000 */
547 data->radio_cfg_type = EXT_NVM_RF_CFG_TYPE_MSK(radio_cfg);
548 data->radio_cfg_step = EXT_NVM_RF_CFG_STEP_MSK(radio_cfg);
549 data->radio_cfg_dash = EXT_NVM_RF_CFG_DASH_MSK(radio_cfg);
550 data->radio_cfg_pnum = EXT_NVM_RF_CFG_FLAVOR_MSK(radio_cfg);
551 data->valid_tx_ant = EXT_NVM_RF_CFG_TX_ANT_MSK(radio_cfg);
552 data->valid_rx_ant = EXT_NVM_RF_CFG_RX_ANT_MSK(radio_cfg);
555 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
559 hw_addr = (const u8 *)&mac_addr0;
560 dest[0] = hw_addr[3];
561 dest[1] = hw_addr[2];
562 dest[2] = hw_addr[1];
563 dest[3] = hw_addr[0];
565 hw_addr = (const u8 *)&mac_addr1;
566 dest[4] = hw_addr[1];
567 dest[5] = hw_addr[0];
570 void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
571 struct iwl_nvm_data *data)
573 __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
574 __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
576 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
578 * If the OEM fused a valid address, use it instead of the one in the
581 if (is_valid_ether_addr(data->hw_addr))
584 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
585 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
587 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
589 IWL_EXPORT_SYMBOL(iwl_set_hw_address_from_csr);
591 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
592 const struct iwl_cfg *cfg,
593 struct iwl_nvm_data *data,
594 const __le16 *mac_override,
595 const __be16 *nvm_hw)
600 static const u8 reserved_mac[] = {
601 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
604 hw_addr = (const u8 *)(mac_override +
605 MAC_ADDRESS_OVERRIDE_EXT_NVM);
608 * Store the MAC address from MAO section.
609 * No byte swapping is required in MAO section
611 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
614 * Force the use of the OTP MAC address in case of reserved MAC
615 * address in the NVM, or if address is given but invalid.
617 if (is_valid_ether_addr(data->hw_addr) &&
618 memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
622 "mac address from nvm override section is not valid\n");
626 /* read the mac address from WFMP registers */
627 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
629 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
632 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
637 IWL_ERR(trans, "mac address is not found\n");
640 static int iwl_set_hw_address(struct iwl_trans *trans,
641 const struct iwl_cfg *cfg,
642 struct iwl_nvm_data *data, const __be16 *nvm_hw,
643 const __le16 *mac_override)
645 if (cfg->mac_addr_from_csr) {
646 iwl_set_hw_address_from_csr(trans, data);
647 } else if (cfg->nvm_type != IWL_NVM_EXT) {
648 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
650 /* The byte order is little endian 16 bit, meaning 214365 */
651 data->hw_addr[0] = hw_addr[1];
652 data->hw_addr[1] = hw_addr[0];
653 data->hw_addr[2] = hw_addr[3];
654 data->hw_addr[3] = hw_addr[2];
655 data->hw_addr[4] = hw_addr[5];
656 data->hw_addr[5] = hw_addr[4];
658 iwl_set_hw_address_family_8000(trans, cfg, data,
659 mac_override, nvm_hw);
662 if (!is_valid_ether_addr(data->hw_addr)) {
663 IWL_ERR(trans, "no valid mac address was found\n");
667 IWL_INFO(trans, "base HW address: %pM\n", data->hw_addr);
673 iwl_nvm_no_wide_in_5ghz(struct device *dev, const struct iwl_cfg *cfg,
674 const __be16 *nvm_hw)
677 * Workaround a bug in Indonesia SKUs where the regulatory in
678 * some 7000-family OTPs erroneously allow wide channels in
679 * 5GHz. To check for Indonesia, we take the SKU value from
680 * bits 1-4 in the subsystem ID and check if it is either 5 or
681 * 9. In those cases, we need to force-disable wide channels
682 * in 5GHz otherwise the FW will throw a sysassert when we try
685 if (cfg->device_family == IWL_DEVICE_FAMILY_7000) {
687 * Unlike the other sections in the NVM, the hw
688 * section uses big-endian.
690 u16 subsystem_id = be16_to_cpup(nvm_hw + SUBSYSTEM_ID);
691 u8 sku = (subsystem_id & 0x1e) >> 1;
693 if (sku == 5 || sku == 9) {
694 IWL_DEBUG_EEPROM(dev,
695 "disabling wide channels in 5GHz (0x%0x %d)\n",
704 struct iwl_nvm_data *
705 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
706 const __be16 *nvm_hw, const __le16 *nvm_sw,
707 const __le16 *nvm_calib, const __le16 *regulatory,
708 const __le16 *mac_override, const __le16 *phy_sku,
709 u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
711 struct device *dev = trans->dev;
712 struct iwl_nvm_data *data;
714 bool no_wide_in_5ghz = iwl_nvm_no_wide_in_5ghz(dev, cfg, nvm_hw);
717 const __le16 *ch_section;
719 if (cfg->nvm_type != IWL_NVM_EXT)
720 data = kzalloc(sizeof(*data) +
721 sizeof(struct ieee80211_channel) *
725 data = kzalloc(sizeof(*data) +
726 sizeof(struct ieee80211_channel) *
727 IWL_NUM_CHANNELS_EXT,
732 data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
734 radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
735 iwl_set_radio_cfg(cfg, data, radio_cfg);
736 if (data->valid_tx_ant)
737 tx_chains &= data->valid_tx_ant;
738 if (data->valid_rx_ant)
739 rx_chains &= data->valid_rx_ant;
741 sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
742 data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
743 data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
744 data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
745 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
746 data->sku_cap_11n_enable = false;
747 data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
748 (sku & NVM_SKU_CAP_11AC_ENABLE);
749 data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
751 data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
753 if (cfg->nvm_type != IWL_NVM_EXT) {
754 /* Checking for required sections */
757 "Can't parse empty Calib NVM sections\n");
762 ch_section = cfg->nvm_type == IWL_NVM_SDP ?
763 ®ulatory[NVM_CHANNELS_SDP] :
764 &nvm_sw[NVM_CHANNELS];
766 /* in family 8000 Xtal calibration values moved to OTP */
767 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
768 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
771 u16 lar_offset = data->nvm_version < 0xE39 ?
775 lar_config = le16_to_cpup(regulatory + lar_offset);
776 data->lar_enabled = !!(lar_config &
778 lar_enabled = data->lar_enabled;
779 ch_section = ®ulatory[NVM_CHANNELS_EXTENDED];
782 /* If no valid mac address was found - bail out */
783 if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
788 iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
789 lar_fw_supported && lar_enabled, no_wide_in_5ghz);
790 data->calib_version = 255;
794 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
796 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
797 int ch_idx, u16 nvm_flags,
798 const struct iwl_cfg *cfg)
800 u32 flags = NL80211_RRF_NO_HT40;
801 u32 last_5ghz_ht = LAST_5GHZ_HT;
803 if (cfg->nvm_type == IWL_NVM_EXT)
804 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
806 if (ch_idx < NUM_2GHZ_CHANNELS &&
807 (nvm_flags & NVM_CHANNEL_40MHZ)) {
808 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
809 flags &= ~NL80211_RRF_NO_HT40PLUS;
810 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
811 flags &= ~NL80211_RRF_NO_HT40MINUS;
812 } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
813 (nvm_flags & NVM_CHANNEL_40MHZ)) {
814 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
815 flags &= ~NL80211_RRF_NO_HT40PLUS;
817 flags &= ~NL80211_RRF_NO_HT40MINUS;
820 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
821 flags |= NL80211_RRF_NO_80MHZ;
822 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
823 flags |= NL80211_RRF_NO_160MHZ;
825 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
826 flags |= NL80211_RRF_NO_IR;
828 if (nvm_flags & NVM_CHANNEL_RADAR)
829 flags |= NL80211_RRF_DFS;
831 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
832 flags |= NL80211_RRF_NO_OUTDOOR;
834 /* Set the GO concurrent flag only in case that NO_IR is set.
835 * Otherwise it is meaningless
837 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
838 (flags & NL80211_RRF_NO_IR))
839 flags |= NL80211_RRF_GO_CONCURRENT;
844 struct ieee80211_regdomain *
845 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
846 int num_of_ch, __le32 *channels, u16 fw_mcc)
850 u32 reg_rule_flags, prev_reg_rule_flags = 0;
851 const u8 *nvm_chan = cfg->nvm_type == IWL_NVM_EXT ?
852 iwl_ext_nvm_channels : iwl_nvm_channels;
853 struct ieee80211_regdomain *regd;
855 struct ieee80211_reg_rule *rule;
856 enum nl80211_band band;
857 int center_freq, prev_center_freq = 0;
860 int max_num_ch = cfg->nvm_type == IWL_NVM_EXT ?
861 IWL_NUM_CHANNELS_EXT : IWL_NUM_CHANNELS;
863 if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
864 return ERR_PTR(-EINVAL);
866 if (WARN_ON(num_of_ch > max_num_ch))
867 num_of_ch = max_num_ch;
869 IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
872 /* build a regdomain rule for every valid channel */
874 sizeof(struct ieee80211_regdomain) +
875 num_of_ch * sizeof(struct ieee80211_reg_rule);
877 regd = kzalloc(size_of_regd, GFP_KERNEL);
879 return ERR_PTR(-ENOMEM);
881 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
882 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
883 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
884 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
885 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
889 if (!(ch_flags & NVM_CHANNEL_VALID)) {
890 iwl_nvm_print_channel_flags(dev, IWL_DL_LAR,
891 nvm_chan[ch_idx], ch_flags);
895 reg_rule_flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
898 /* we can't continue the same rule */
899 if (ch_idx == 0 || prev_reg_rule_flags != reg_rule_flags ||
900 center_freq - prev_center_freq > 20) {
905 rule = ®d->reg_rules[valid_rules - 1];
908 rule->freq_range.start_freq_khz =
909 MHZ_TO_KHZ(center_freq - 10);
911 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
913 /* this doesn't matter - not used by FW */
914 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
915 rule->power_rule.max_eirp =
916 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
918 rule->flags = reg_rule_flags;
920 /* rely on auto-calculation to merge BW of contiguous chans */
921 rule->flags |= NL80211_RRF_AUTO_BW;
922 rule->freq_range.max_bandwidth_khz = 0;
924 prev_center_freq = center_freq;
925 prev_reg_rule_flags = reg_rule_flags;
927 iwl_nvm_print_channel_flags(dev, IWL_DL_LAR,
928 nvm_chan[ch_idx], ch_flags);
931 regd->n_reg_rules = valid_rules;
933 /* set alpha2 from FW. */
934 regd->alpha2[0] = fw_mcc >> 8;
935 regd->alpha2[1] = fw_mcc & 0xff;
939 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);
942 #define WRDD_METHOD "WRDD"
943 #define WRDD_WIFI (0x07)
944 #define WRDD_WIGIG (0x10)
946 static u32 iwl_wrdd_get_mcc(struct device *dev, union acpi_object *wrdd)
948 union acpi_object *mcc_pkg, *domain_type, *mcc_value;
951 if (wrdd->type != ACPI_TYPE_PACKAGE ||
952 wrdd->package.count < 2 ||
953 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||
954 wrdd->package.elements[0].integer.value != 0) {
955 IWL_DEBUG_EEPROM(dev, "Unsupported wrdd structure\n");
959 for (i = 1 ; i < wrdd->package.count ; ++i) {
960 mcc_pkg = &wrdd->package.elements[i];
962 if (mcc_pkg->type != ACPI_TYPE_PACKAGE ||
963 mcc_pkg->package.count < 2 ||
964 mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||
965 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
970 domain_type = &mcc_pkg->package.elements[0];
971 if (domain_type->integer.value == WRDD_WIFI)
978 mcc_value = &mcc_pkg->package.elements[1];
979 return mcc_value->integer.value;
985 int iwl_get_bios_mcc(struct device *dev, char *mcc)
987 acpi_handle root_handle;
989 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};
993 root_handle = ACPI_HANDLE(dev);
995 IWL_DEBUG_EEPROM(dev,
996 "Could not retrieve root port ACPI handle\n");
1000 /* Get the method's handle */
1001 status = acpi_get_handle(root_handle, (acpi_string)WRDD_METHOD,
1003 if (ACPI_FAILURE(status)) {
1004 IWL_DEBUG_EEPROM(dev, "WRD method not found\n");
1008 /* Call WRDD with no arguments */
1009 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);
1010 if (ACPI_FAILURE(status)) {
1011 IWL_DEBUG_EEPROM(dev, "WRDC invocation failed (0x%x)\n",
1016 mcc_val = iwl_wrdd_get_mcc(dev, wrdd.pointer);
1017 kfree(wrdd.pointer);
1021 mcc[0] = (mcc_val >> 8) & 0xff;
1022 mcc[1] = mcc_val & 0xff;
1026 IWL_EXPORT_SYMBOL(iwl_get_bios_mcc);