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 */
80 enum wkp_nvm_offsets {
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
98 enum ext_nvm_offsets {
99 /* NVM HW-Section offset (in words) definitions */
100 MAC_ADDRESS_OVERRIDE_EXT_NVM = 1,
102 /* NVM SW-Section offset (in words) definitions */
103 NVM_VERSION_EXT_NVM = 0,
104 RADIO_CFG_FAMILY_EXT_NVM = 0,
106 N_HW_ADDRS_FAMILY_8000 = 3,
108 /* NVM REGULATORY -Section offset (in words) definitions */
109 NVM_CHANNELS_EXTENDED = 0,
110 NVM_LAR_OFFSET_OLD = 0x4C7,
111 NVM_LAR_OFFSET = 0x507,
112 NVM_LAR_ENABLED = 0x7,
115 /* SKU Capabilities (actual values from NVM definition) */
117 NVM_SKU_CAP_BAND_24GHZ = BIT(0),
118 NVM_SKU_CAP_BAND_52GHZ = BIT(1),
119 NVM_SKU_CAP_11N_ENABLE = BIT(2),
120 NVM_SKU_CAP_11AC_ENABLE = BIT(3),
121 NVM_SKU_CAP_MIMO_DISABLE = BIT(5),
125 * These are the channel numbers in the order that they are stored in the NVM
127 static const u8 iwl_nvm_channels[] = {
129 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
131 36, 40, 44 , 48, 52, 56, 60, 64,
132 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
133 149, 153, 157, 161, 165
136 static const u8 iwl_ext_nvm_channels[] = {
138 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
140 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
141 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
142 149, 153, 157, 161, 165, 169, 173, 177, 181
145 #define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
146 #define IWL_NUM_CHANNELS_EXT ARRAY_SIZE(iwl_ext_nvm_channels)
147 #define NUM_2GHZ_CHANNELS 14
148 #define NUM_2GHZ_CHANNELS_EXT 14
149 #define FIRST_2GHZ_HT_MINUS 5
150 #define LAST_2GHZ_HT_PLUS 9
151 #define LAST_5GHZ_HT 165
152 #define LAST_5GHZ_HT_FAMILY_8000 181
153 #define N_HW_ADDR_MASK 0xF
155 /* rate data (static) */
156 static struct ieee80211_rate iwl_cfg80211_rates[] = {
157 { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
158 { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
159 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
160 { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
161 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
162 { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
163 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
164 { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
165 { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
166 { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
167 { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
168 { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
169 { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
170 { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
171 { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
173 #define RATES_24_OFFS 0
174 #define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
175 #define RATES_52_OFFS 4
176 #define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
179 * enum iwl_nvm_channel_flags - channel flags in NVM
180 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
181 * @NVM_CHANNEL_IBSS: usable as an IBSS channel
182 * @NVM_CHANNEL_ACTIVE: active scanning allowed
183 * @NVM_CHANNEL_RADAR: radar detection required
184 * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
185 * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
186 * on same channel on 2.4 or same UNII band on 5.2
187 * @NVM_CHANNEL_UNIFORM: uniform spreading required
188 * @NVM_CHANNEL_20MHZ: 20 MHz channel okay
189 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay
190 * @NVM_CHANNEL_80MHZ: 80 MHz channel okay
191 * @NVM_CHANNEL_160MHZ: 160 MHz channel okay
192 * @NVM_CHANNEL_DC_HIGH: DC HIGH required/allowed (?)
194 enum iwl_nvm_channel_flags {
195 NVM_CHANNEL_VALID = BIT(0),
196 NVM_CHANNEL_IBSS = BIT(1),
197 NVM_CHANNEL_ACTIVE = BIT(3),
198 NVM_CHANNEL_RADAR = BIT(4),
199 NVM_CHANNEL_INDOOR_ONLY = BIT(5),
200 NVM_CHANNEL_GO_CONCURRENT = BIT(6),
201 NVM_CHANNEL_UNIFORM = BIT(7),
202 NVM_CHANNEL_20MHZ = BIT(8),
203 NVM_CHANNEL_40MHZ = BIT(9),
204 NVM_CHANNEL_80MHZ = BIT(10),
205 NVM_CHANNEL_160MHZ = BIT(11),
206 NVM_CHANNEL_DC_HIGH = BIT(12),
209 #define CHECK_AND_PRINT_I(x) \
210 ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
212 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz,
213 u16 nvm_flags, const struct iwl_cfg *cfg)
215 u32 flags = IEEE80211_CHAN_NO_HT40;
216 u32 last_5ghz_ht = LAST_5GHZ_HT;
219 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
221 if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) {
222 if (ch_num <= LAST_2GHZ_HT_PLUS)
223 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
224 if (ch_num >= FIRST_2GHZ_HT_MINUS)
225 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
226 } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) {
227 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
228 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
230 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
232 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
233 flags |= IEEE80211_CHAN_NO_80MHZ;
234 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
235 flags |= IEEE80211_CHAN_NO_160MHZ;
237 if (!(nvm_flags & NVM_CHANNEL_IBSS))
238 flags |= IEEE80211_CHAN_NO_IR;
240 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
241 flags |= IEEE80211_CHAN_NO_IR;
243 if (nvm_flags & NVM_CHANNEL_RADAR)
244 flags |= IEEE80211_CHAN_RADAR;
246 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
247 flags |= IEEE80211_CHAN_INDOOR_ONLY;
249 /* Set the GO concurrent flag only in case that NO_IR is set.
250 * Otherwise it is meaningless
252 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
253 (flags & IEEE80211_CHAN_NO_IR))
254 flags |= IEEE80211_CHAN_IR_CONCURRENT;
259 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
260 struct iwl_nvm_data *data,
261 const __le16 * const nvm_ch_flags,
262 bool lar_supported, bool no_wide_in_5ghz)
266 struct ieee80211_channel *channel;
268 int num_of_ch, num_2ghz_channels;
272 num_of_ch = IWL_NUM_CHANNELS;
273 nvm_chan = &iwl_nvm_channels[0];
274 num_2ghz_channels = NUM_2GHZ_CHANNELS;
276 num_of_ch = IWL_NUM_CHANNELS_EXT;
277 nvm_chan = &iwl_ext_nvm_channels[0];
278 num_2ghz_channels = NUM_2GHZ_CHANNELS_EXT;
281 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
282 bool is_5ghz = (ch_idx >= num_2ghz_channels);
284 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
286 if (is_5ghz && !data->sku_cap_band_52GHz_enable)
289 /* workaround to disable wide channels in 5GHz */
290 if (no_wide_in_5ghz && is_5ghz) {
291 ch_flags &= ~(NVM_CHANNEL_40MHZ |
296 if (ch_flags & NVM_CHANNEL_160MHZ)
297 data->vht160_supported = true;
299 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
301 * Channels might become valid later if lar is
302 * supported, hence we still want to add them to
303 * the list of supported channels to cfg80211.
305 IWL_DEBUG_EEPROM(dev,
306 "Ch. %d Flags %x [%sGHz] - No traffic\n",
309 (ch_idx >= num_2ghz_channels) ?
314 channel = &data->channels[n_channels];
317 channel->hw_value = nvm_chan[ch_idx];
318 channel->band = is_5ghz ?
319 NL80211_BAND_5GHZ : NL80211_BAND_2GHZ;
320 channel->center_freq =
321 ieee80211_channel_to_frequency(
322 channel->hw_value, channel->band);
324 /* Initialize regulatory-based run-time data */
327 * Default value - highest tx power value. max_power
328 * is not used in mvm, and is used for backwards compatibility
330 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
332 /* don't put limitations in case we're using LAR */
334 channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
340 IWL_DEBUG_EEPROM(dev,
341 "Ch. %d [%sGHz] flags 0x%x %s%s%s%s%s%s%s%s%s%s%s%s(%ddBm): Ad-Hoc %ssupported\n",
343 is_5ghz ? "5.2" : "2.4",
345 CHECK_AND_PRINT_I(VALID),
346 CHECK_AND_PRINT_I(IBSS),
347 CHECK_AND_PRINT_I(ACTIVE),
348 CHECK_AND_PRINT_I(RADAR),
349 CHECK_AND_PRINT_I(INDOOR_ONLY),
350 CHECK_AND_PRINT_I(GO_CONCURRENT),
351 CHECK_AND_PRINT_I(UNIFORM),
352 CHECK_AND_PRINT_I(20MHZ),
353 CHECK_AND_PRINT_I(40MHZ),
354 CHECK_AND_PRINT_I(80MHZ),
355 CHECK_AND_PRINT_I(160MHZ),
356 CHECK_AND_PRINT_I(DC_HIGH),
358 ((ch_flags & NVM_CHANNEL_IBSS) &&
359 !(ch_flags & NVM_CHANNEL_RADAR))
366 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
367 struct iwl_nvm_data *data,
368 struct ieee80211_sta_vht_cap *vht_cap,
369 u8 tx_chains, u8 rx_chains)
371 int num_rx_ants = num_of_ant(rx_chains);
372 int num_tx_ants = num_of_ant(tx_chains);
373 unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
374 IEEE80211_VHT_MAX_AMPDU_1024K);
376 vht_cap->vht_supported = true;
378 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
379 IEEE80211_VHT_CAP_RXSTBC_1 |
380 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
381 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
382 max_ampdu_exponent <<
383 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
385 if (data->vht160_supported)
386 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
387 IEEE80211_VHT_CAP_SHORT_GI_160;
389 if (cfg->vht_mu_mimo_supported)
390 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
392 if (cfg->ht_params->ldpc)
393 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
395 if (data->sku_cap_mimo_disabled) {
401 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
403 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
405 switch (iwlwifi_mod_params.amsdu_size) {
407 if (cfg->mq_rx_supported)
409 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
411 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
414 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
417 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
420 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
426 vht_cap->vht_mcs.rx_mcs_map =
427 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
428 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
429 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
430 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
431 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
432 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
433 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
434 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
436 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
437 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
438 /* this works because NOT_SUPPORTED == 3 */
439 vht_cap->vht_mcs.rx_mcs_map |=
440 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
443 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
446 void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
447 struct iwl_nvm_data *data, const __le16 *nvm_ch_flags,
448 u8 tx_chains, u8 rx_chains, bool lar_supported,
449 bool no_wide_in_5ghz)
453 struct ieee80211_supported_band *sband;
455 n_channels = iwl_init_channel_map(dev, cfg, data, nvm_ch_flags,
456 lar_supported, no_wide_in_5ghz);
457 sband = &data->bands[NL80211_BAND_2GHZ];
458 sband->band = NL80211_BAND_2GHZ;
459 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
460 sband->n_bitrates = N_RATES_24;
461 n_used += iwl_init_sband_channels(data, sband, n_channels,
463 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
464 tx_chains, rx_chains);
466 sband = &data->bands[NL80211_BAND_5GHZ];
467 sband->band = NL80211_BAND_5GHZ;
468 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
469 sband->n_bitrates = N_RATES_52;
470 n_used += iwl_init_sband_channels(data, sband, n_channels,
472 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
473 tx_chains, rx_chains);
474 if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
475 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
476 tx_chains, rx_chains);
478 if (n_channels != n_used)
479 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
482 IWL_EXPORT_SYMBOL(iwl_init_sbands);
484 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
485 const __le16 *phy_sku)
488 return le16_to_cpup(nvm_sw + SKU);
490 return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
493 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
496 return le16_to_cpup(nvm_sw + NVM_VERSION);
498 return le32_to_cpup((__le32 *)(nvm_sw +
499 NVM_VERSION_EXT_NVM));
502 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
503 const __le16 *phy_sku)
506 return le16_to_cpup(nvm_sw + RADIO_CFG);
508 return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_EXT_NVM));
512 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
517 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
519 n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
521 return n_hw_addr & N_HW_ADDR_MASK;
524 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
525 struct iwl_nvm_data *data,
529 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
530 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
531 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
532 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
536 /* set the radio configuration for family 8000 */
537 data->radio_cfg_type = EXT_NVM_RF_CFG_TYPE_MSK(radio_cfg);
538 data->radio_cfg_step = EXT_NVM_RF_CFG_STEP_MSK(radio_cfg);
539 data->radio_cfg_dash = EXT_NVM_RF_CFG_DASH_MSK(radio_cfg);
540 data->radio_cfg_pnum = EXT_NVM_RF_CFG_FLAVOR_MSK(radio_cfg);
541 data->valid_tx_ant = EXT_NVM_RF_CFG_TX_ANT_MSK(radio_cfg);
542 data->valid_rx_ant = EXT_NVM_RF_CFG_RX_ANT_MSK(radio_cfg);
545 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
549 hw_addr = (const u8 *)&mac_addr0;
550 dest[0] = hw_addr[3];
551 dest[1] = hw_addr[2];
552 dest[2] = hw_addr[1];
553 dest[3] = hw_addr[0];
555 hw_addr = (const u8 *)&mac_addr1;
556 dest[4] = hw_addr[1];
557 dest[5] = hw_addr[0];
560 void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
561 struct iwl_nvm_data *data)
563 __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
564 __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
566 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
568 * If the OEM fused a valid address, use it instead of the one in the
571 if (is_valid_ether_addr(data->hw_addr))
574 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
575 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
577 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
579 IWL_EXPORT_SYMBOL(iwl_set_hw_address_from_csr);
581 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
582 const struct iwl_cfg *cfg,
583 struct iwl_nvm_data *data,
584 const __le16 *mac_override,
585 const __be16 *nvm_hw)
590 static const u8 reserved_mac[] = {
591 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
594 hw_addr = (const u8 *)(mac_override +
595 MAC_ADDRESS_OVERRIDE_EXT_NVM);
598 * Store the MAC address from MAO section.
599 * No byte swapping is required in MAO section
601 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
604 * Force the use of the OTP MAC address in case of reserved MAC
605 * address in the NVM, or if address is given but invalid.
607 if (is_valid_ether_addr(data->hw_addr) &&
608 memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
612 "mac address from nvm override section is not valid\n");
616 /* read the mac address from WFMP registers */
617 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
619 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
622 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
627 IWL_ERR(trans, "mac address is not found\n");
630 static int iwl_set_hw_address(struct iwl_trans *trans,
631 const struct iwl_cfg *cfg,
632 struct iwl_nvm_data *data, const __be16 *nvm_hw,
633 const __le16 *mac_override)
635 if (cfg->mac_addr_from_csr) {
636 iwl_set_hw_address_from_csr(trans, data);
637 } else if (!cfg->ext_nvm) {
638 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
640 /* The byte order is little endian 16 bit, meaning 214365 */
641 data->hw_addr[0] = hw_addr[1];
642 data->hw_addr[1] = hw_addr[0];
643 data->hw_addr[2] = hw_addr[3];
644 data->hw_addr[3] = hw_addr[2];
645 data->hw_addr[4] = hw_addr[5];
646 data->hw_addr[5] = hw_addr[4];
648 iwl_set_hw_address_family_8000(trans, cfg, data,
649 mac_override, nvm_hw);
652 if (!is_valid_ether_addr(data->hw_addr)) {
653 IWL_ERR(trans, "no valid mac address was found\n");
657 IWL_INFO(trans, "base HW address: %pM\n", data->hw_addr);
663 iwl_nvm_no_wide_in_5ghz(struct device *dev, const struct iwl_cfg *cfg,
664 const __be16 *nvm_hw)
667 * Workaround a bug in Indonesia SKUs where the regulatory in
668 * some 7000-family OTPs erroneously allow wide channels in
669 * 5GHz. To check for Indonesia, we take the SKU value from
670 * bits 1-4 in the subsystem ID and check if it is either 5 or
671 * 9. In those cases, we need to force-disable wide channels
672 * in 5GHz otherwise the FW will throw a sysassert when we try
675 if (cfg->device_family == IWL_DEVICE_FAMILY_7000) {
677 * Unlike the other sections in the NVM, the hw
678 * section uses big-endian.
680 u16 subsystem_id = be16_to_cpup(nvm_hw + SUBSYSTEM_ID);
681 u8 sku = (subsystem_id & 0x1e) >> 1;
683 if (sku == 5 || sku == 9) {
684 IWL_DEBUG_EEPROM(dev,
685 "disabling wide channels in 5GHz (0x%0x %d)\n",
694 struct iwl_nvm_data *
695 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
696 const __be16 *nvm_hw, const __le16 *nvm_sw,
697 const __le16 *nvm_calib, const __le16 *regulatory,
698 const __le16 *mac_override, const __le16 *phy_sku,
699 u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
701 struct device *dev = trans->dev;
702 struct iwl_nvm_data *data;
704 bool no_wide_in_5ghz = iwl_nvm_no_wide_in_5ghz(dev, cfg, nvm_hw);
707 const __le16 *ch_section;
710 data = kzalloc(sizeof(*data) +
711 sizeof(struct ieee80211_channel) *
715 data = kzalloc(sizeof(*data) +
716 sizeof(struct ieee80211_channel) *
717 IWL_NUM_CHANNELS_EXT,
722 data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
724 radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
725 iwl_set_radio_cfg(cfg, data, radio_cfg);
726 if (data->valid_tx_ant)
727 tx_chains &= data->valid_tx_ant;
728 if (data->valid_rx_ant)
729 rx_chains &= data->valid_rx_ant;
731 sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
732 data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
733 data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
734 data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
735 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
736 data->sku_cap_11n_enable = false;
737 data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
738 (sku & NVM_SKU_CAP_11AC_ENABLE);
739 data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
741 data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
744 /* Checking for required sections */
747 "Can't parse empty Calib NVM sections\n");
751 /* in family 8000 Xtal calibration values moved to OTP */
752 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
753 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
755 ch_section = &nvm_sw[NVM_CHANNELS];
757 u16 lar_offset = data->nvm_version < 0xE39 ?
761 lar_config = le16_to_cpup(regulatory + lar_offset);
762 data->lar_enabled = !!(lar_config &
764 lar_enabled = data->lar_enabled;
765 ch_section = ®ulatory[NVM_CHANNELS_EXTENDED];
768 /* If no valid mac address was found - bail out */
769 if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
774 iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
775 lar_fw_supported && lar_enabled, no_wide_in_5ghz);
776 data->calib_version = 255;
780 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
782 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
783 int ch_idx, u16 nvm_flags,
784 const struct iwl_cfg *cfg)
786 u32 flags = NL80211_RRF_NO_HT40;
787 u32 last_5ghz_ht = LAST_5GHZ_HT;
790 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
792 if (ch_idx < NUM_2GHZ_CHANNELS &&
793 (nvm_flags & NVM_CHANNEL_40MHZ)) {
794 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
795 flags &= ~NL80211_RRF_NO_HT40PLUS;
796 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
797 flags &= ~NL80211_RRF_NO_HT40MINUS;
798 } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
799 (nvm_flags & NVM_CHANNEL_40MHZ)) {
800 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
801 flags &= ~NL80211_RRF_NO_HT40PLUS;
803 flags &= ~NL80211_RRF_NO_HT40MINUS;
806 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
807 flags |= NL80211_RRF_NO_80MHZ;
808 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
809 flags |= NL80211_RRF_NO_160MHZ;
811 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
812 flags |= NL80211_RRF_NO_IR;
814 if (nvm_flags & NVM_CHANNEL_RADAR)
815 flags |= NL80211_RRF_DFS;
817 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
818 flags |= NL80211_RRF_NO_OUTDOOR;
820 /* Set the GO concurrent flag only in case that NO_IR is set.
821 * Otherwise it is meaningless
823 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
824 (flags & NL80211_RRF_NO_IR))
825 flags |= NL80211_RRF_GO_CONCURRENT;
830 struct ieee80211_regdomain *
831 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
832 int num_of_ch, __le32 *channels, u16 fw_mcc)
836 u32 reg_rule_flags, prev_reg_rule_flags = 0;
837 const u8 *nvm_chan = cfg->ext_nvm ?
838 iwl_ext_nvm_channels : iwl_nvm_channels;
839 struct ieee80211_regdomain *regd;
841 struct ieee80211_reg_rule *rule;
842 enum nl80211_band band;
843 int center_freq, prev_center_freq = 0;
846 int max_num_ch = cfg->ext_nvm ?
847 IWL_NUM_CHANNELS_EXT : IWL_NUM_CHANNELS;
849 if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
850 return ERR_PTR(-EINVAL);
852 if (WARN_ON(num_of_ch > max_num_ch))
853 num_of_ch = max_num_ch;
855 IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
858 /* build a regdomain rule for every valid channel */
860 sizeof(struct ieee80211_regdomain) +
861 num_of_ch * sizeof(struct ieee80211_reg_rule);
863 regd = kzalloc(size_of_regd, GFP_KERNEL);
865 return ERR_PTR(-ENOMEM);
867 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
868 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
869 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
870 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
871 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
875 if (!(ch_flags & NVM_CHANNEL_VALID)) {
876 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
877 "Ch. %d Flags %x [%sGHz] - No traffic\n",
880 (ch_idx >= NUM_2GHZ_CHANNELS) ?
885 reg_rule_flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
888 /* we can't continue the same rule */
889 if (ch_idx == 0 || prev_reg_rule_flags != reg_rule_flags ||
890 center_freq - prev_center_freq > 20) {
895 rule = ®d->reg_rules[valid_rules - 1];
898 rule->freq_range.start_freq_khz =
899 MHZ_TO_KHZ(center_freq - 10);
901 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
903 /* this doesn't matter - not used by FW */
904 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
905 rule->power_rule.max_eirp =
906 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
908 rule->flags = reg_rule_flags;
910 /* rely on auto-calculation to merge BW of contiguous chans */
911 rule->flags |= NL80211_RRF_AUTO_BW;
912 rule->freq_range.max_bandwidth_khz = 0;
914 prev_center_freq = center_freq;
915 prev_reg_rule_flags = reg_rule_flags;
917 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
918 "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s%s%s%s(0x%02x)\n",
920 band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
921 CHECK_AND_PRINT_I(VALID),
922 CHECK_AND_PRINT_I(IBSS),
923 CHECK_AND_PRINT_I(ACTIVE),
924 CHECK_AND_PRINT_I(RADAR),
925 CHECK_AND_PRINT_I(INDOOR_ONLY),
926 CHECK_AND_PRINT_I(GO_CONCURRENT),
927 CHECK_AND_PRINT_I(UNIFORM),
928 CHECK_AND_PRINT_I(20MHZ),
929 CHECK_AND_PRINT_I(40MHZ),
930 CHECK_AND_PRINT_I(80MHZ),
931 CHECK_AND_PRINT_I(160MHZ),
932 CHECK_AND_PRINT_I(DC_HIGH),
934 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
935 "Ch. %d [%sGHz] reg_flags 0x%x: %s\n",
937 band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
939 ((ch_flags & NVM_CHANNEL_ACTIVE) &&
940 !(ch_flags & NVM_CHANNEL_RADAR))
944 regd->n_reg_rules = valid_rules;
946 /* set alpha2 from FW. */
947 regd->alpha2[0] = fw_mcc >> 8;
948 regd->alpha2[1] = fw_mcc & 0xff;
952 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);
955 #define WRDD_METHOD "WRDD"
956 #define WRDD_WIFI (0x07)
957 #define WRDD_WIGIG (0x10)
959 static u32 iwl_wrdd_get_mcc(struct device *dev, union acpi_object *wrdd)
961 union acpi_object *mcc_pkg, *domain_type, *mcc_value;
964 if (wrdd->type != ACPI_TYPE_PACKAGE ||
965 wrdd->package.count < 2 ||
966 wrdd->package.elements[0].type != ACPI_TYPE_INTEGER ||
967 wrdd->package.elements[0].integer.value != 0) {
968 IWL_DEBUG_EEPROM(dev, "Unsupported wrdd structure\n");
972 for (i = 1 ; i < wrdd->package.count ; ++i) {
973 mcc_pkg = &wrdd->package.elements[i];
975 if (mcc_pkg->type != ACPI_TYPE_PACKAGE ||
976 mcc_pkg->package.count < 2 ||
977 mcc_pkg->package.elements[0].type != ACPI_TYPE_INTEGER ||
978 mcc_pkg->package.elements[1].type != ACPI_TYPE_INTEGER) {
983 domain_type = &mcc_pkg->package.elements[0];
984 if (domain_type->integer.value == WRDD_WIFI)
991 mcc_value = &mcc_pkg->package.elements[1];
992 return mcc_value->integer.value;
998 int iwl_get_bios_mcc(struct device *dev, char *mcc)
1000 acpi_handle root_handle;
1002 struct acpi_buffer wrdd = {ACPI_ALLOCATE_BUFFER, NULL};
1006 root_handle = ACPI_HANDLE(dev);
1008 IWL_DEBUG_EEPROM(dev,
1009 "Could not retrieve root port ACPI handle\n");
1013 /* Get the method's handle */
1014 status = acpi_get_handle(root_handle, (acpi_string)WRDD_METHOD,
1016 if (ACPI_FAILURE(status)) {
1017 IWL_DEBUG_EEPROM(dev, "WRD method not found\n");
1021 /* Call WRDD with no arguments */
1022 status = acpi_evaluate_object(handle, NULL, NULL, &wrdd);
1023 if (ACPI_FAILURE(status)) {
1024 IWL_DEBUG_EEPROM(dev, "WRDC invocation failed (0x%x)\n",
1029 mcc_val = iwl_wrdd_get_mcc(dev, wrdd.pointer);
1030 kfree(wrdd.pointer);
1034 mcc[0] = (mcc_val >> 8) & 0xff;
1035 mcc[1] = mcc_val & 0xff;
1039 IWL_EXPORT_SYMBOL(iwl_get_bios_mcc);