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 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 * All rights reserved.
39 * Redistribution and use in source and binary forms, with or without
40 * modification, are permitted provided that the following conditions
43 * * Redistributions of source code must retain the above copyright
44 * notice, this list of conditions and the following disclaimer.
45 * * Redistributions in binary form must reproduce the above copyright
46 * notice, this list of conditions and the following disclaimer in
47 * the documentation and/or other materials provided with the
49 * * Neither the name Intel Corporation nor the names of its
50 * contributors may be used to endorse or promote products derived
51 * from this software without specific prior written permission.
53 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
54 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
55 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
56 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
57 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
58 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
59 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
60 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
61 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
62 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
63 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
64 *****************************************************************************/
65 #include <linux/types.h>
66 #include <linux/slab.h>
67 #include <linux/export.h>
68 #include <linux/etherdevice.h>
69 #include <linux/pci.h>
71 #include "iwl-modparams.h"
72 #include "iwl-nvm-parse.h"
77 /* NVM offsets (in words) definitions */
78 enum wkp_nvm_offsets
{
79 /* NVM HW-Section offset (in words) definitions */
82 /* NVM SW-Section offset (in words) definitions */
83 NVM_SW_SECTION
= 0x1C0,
88 NVM_CHANNELS
= 0x1E0 - NVM_SW_SECTION
,
90 /* NVM calibration section offset (in words) definitions */
91 NVM_CALIB_SECTION
= 0x2B8,
92 XTAL_CALIB
= 0x316 - NVM_CALIB_SECTION
95 enum family_8000_nvm_offsets
{
96 /* NVM HW-Section offset (in words) definitions */
97 HW_ADDR0_WFPM_FAMILY_8000
= 0x12,
98 HW_ADDR1_WFPM_FAMILY_8000
= 0x16,
99 HW_ADDR0_PCIE_FAMILY_8000
= 0x8A,
100 HW_ADDR1_PCIE_FAMILY_8000
= 0x8E,
101 MAC_ADDRESS_OVERRIDE_FAMILY_8000
= 1,
103 /* NVM SW-Section offset (in words) definitions */
104 NVM_SW_SECTION_FAMILY_8000
= 0x1C0,
105 NVM_VERSION_FAMILY_8000
= 0,
106 RADIO_CFG_FAMILY_8000
= 0,
108 N_HW_ADDRS_FAMILY_8000
= 3,
110 /* NVM REGULATORY -Section offset (in words) definitions */
111 NVM_CHANNELS_FAMILY_8000
= 0,
112 NVM_LAR_OFFSET_FAMILY_8000_OLD
= 0x4C7,
113 NVM_LAR_OFFSET_FAMILY_8000
= 0x507,
114 NVM_LAR_ENABLED_FAMILY_8000
= 0x7,
116 /* NVM calibration section offset (in words) definitions */
117 NVM_CALIB_SECTION_FAMILY_8000
= 0x2B8,
118 XTAL_CALIB_FAMILY_8000
= 0x316 - NVM_CALIB_SECTION_FAMILY_8000
121 /* SKU Capabilities (actual values from NVM definition) */
123 NVM_SKU_CAP_BAND_24GHZ
= BIT(0),
124 NVM_SKU_CAP_BAND_52GHZ
= BIT(1),
125 NVM_SKU_CAP_11N_ENABLE
= BIT(2),
126 NVM_SKU_CAP_11AC_ENABLE
= BIT(3),
127 NVM_SKU_CAP_MIMO_DISABLE
= BIT(5),
131 * These are the channel numbers in the order that they are stored in the NVM
133 static const u8 iwl_nvm_channels
[] = {
135 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
137 36, 40, 44 , 48, 52, 56, 60, 64,
138 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
139 149, 153, 157, 161, 165
142 static const u8 iwl_nvm_channels_family_8000
[] = {
144 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
146 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
147 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
148 149, 153, 157, 161, 165, 169, 173, 177, 181
151 #define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
152 #define IWL_NUM_CHANNELS_FAMILY_8000 ARRAY_SIZE(iwl_nvm_channels_family_8000)
153 #define NUM_2GHZ_CHANNELS 14
154 #define NUM_2GHZ_CHANNELS_FAMILY_8000 14
155 #define FIRST_2GHZ_HT_MINUS 5
156 #define LAST_2GHZ_HT_PLUS 9
157 #define LAST_5GHZ_HT 165
158 #define LAST_5GHZ_HT_FAMILY_8000 181
159 #define N_HW_ADDR_MASK 0xF
161 /* rate data (static) */
162 static struct ieee80211_rate iwl_cfg80211_rates
[] = {
163 { .bitrate
= 1 * 10, .hw_value
= 0, .hw_value_short
= 0, },
164 { .bitrate
= 2 * 10, .hw_value
= 1, .hw_value_short
= 1,
165 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
, },
166 { .bitrate
= 5.5 * 10, .hw_value
= 2, .hw_value_short
= 2,
167 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
, },
168 { .bitrate
= 11 * 10, .hw_value
= 3, .hw_value_short
= 3,
169 .flags
= IEEE80211_RATE_SHORT_PREAMBLE
, },
170 { .bitrate
= 6 * 10, .hw_value
= 4, .hw_value_short
= 4, },
171 { .bitrate
= 9 * 10, .hw_value
= 5, .hw_value_short
= 5, },
172 { .bitrate
= 12 * 10, .hw_value
= 6, .hw_value_short
= 6, },
173 { .bitrate
= 18 * 10, .hw_value
= 7, .hw_value_short
= 7, },
174 { .bitrate
= 24 * 10, .hw_value
= 8, .hw_value_short
= 8, },
175 { .bitrate
= 36 * 10, .hw_value
= 9, .hw_value_short
= 9, },
176 { .bitrate
= 48 * 10, .hw_value
= 10, .hw_value_short
= 10, },
177 { .bitrate
= 54 * 10, .hw_value
= 11, .hw_value_short
= 11, },
179 #define RATES_24_OFFS 0
180 #define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
181 #define RATES_52_OFFS 4
182 #define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
185 * enum iwl_nvm_channel_flags - channel flags in NVM
186 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
187 * @NVM_CHANNEL_IBSS: usable as an IBSS channel
188 * @NVM_CHANNEL_ACTIVE: active scanning allowed
189 * @NVM_CHANNEL_RADAR: radar detection required
190 * @NVM_CHANNEL_INDOOR_ONLY: only indoor use is allowed
191 * @NVM_CHANNEL_GO_CONCURRENT: GO operation is allowed when connected to BSS
192 * on same channel on 2.4 or same UNII band on 5.2
193 * @NVM_CHANNEL_WIDE: 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 (?)
198 enum iwl_nvm_channel_flags
{
199 NVM_CHANNEL_VALID
= BIT(0),
200 NVM_CHANNEL_IBSS
= BIT(1),
201 NVM_CHANNEL_ACTIVE
= BIT(3),
202 NVM_CHANNEL_RADAR
= BIT(4),
203 NVM_CHANNEL_INDOOR_ONLY
= BIT(5),
204 NVM_CHANNEL_GO_CONCURRENT
= BIT(6),
205 NVM_CHANNEL_WIDE
= BIT(8),
206 NVM_CHANNEL_40MHZ
= BIT(9),
207 NVM_CHANNEL_80MHZ
= BIT(10),
208 NVM_CHANNEL_160MHZ
= BIT(11),
211 #define CHECK_AND_PRINT_I(x) \
212 ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
214 static u32
iwl_get_channel_flags(u8 ch_num
, int ch_idx
, bool is_5ghz
,
215 u16 nvm_flags
, const struct iwl_cfg
*cfg
)
217 u32 flags
= IEEE80211_CHAN_NO_HT40
;
218 u32 last_5ghz_ht
= LAST_5GHZ_HT
;
220 if (cfg
->device_family
== IWL_DEVICE_FAMILY_8000
)
221 last_5ghz_ht
= LAST_5GHZ_HT_FAMILY_8000
;
223 if (!is_5ghz
&& (nvm_flags
& NVM_CHANNEL_40MHZ
)) {
224 if (ch_num
<= LAST_2GHZ_HT_PLUS
)
225 flags
&= ~IEEE80211_CHAN_NO_HT40PLUS
;
226 if (ch_num
>= FIRST_2GHZ_HT_MINUS
)
227 flags
&= ~IEEE80211_CHAN_NO_HT40MINUS
;
228 } else if (ch_num
<= last_5ghz_ht
&& (nvm_flags
& NVM_CHANNEL_40MHZ
)) {
229 if ((ch_idx
- NUM_2GHZ_CHANNELS
) % 2 == 0)
230 flags
&= ~IEEE80211_CHAN_NO_HT40PLUS
;
232 flags
&= ~IEEE80211_CHAN_NO_HT40MINUS
;
234 if (!(nvm_flags
& NVM_CHANNEL_80MHZ
))
235 flags
|= IEEE80211_CHAN_NO_80MHZ
;
236 if (!(nvm_flags
& NVM_CHANNEL_160MHZ
))
237 flags
|= IEEE80211_CHAN_NO_160MHZ
;
239 if (!(nvm_flags
& NVM_CHANNEL_IBSS
))
240 flags
|= IEEE80211_CHAN_NO_IR
;
242 if (!(nvm_flags
& NVM_CHANNEL_ACTIVE
))
243 flags
|= IEEE80211_CHAN_NO_IR
;
245 if (nvm_flags
& NVM_CHANNEL_RADAR
)
246 flags
|= IEEE80211_CHAN_RADAR
;
248 if (nvm_flags
& NVM_CHANNEL_INDOOR_ONLY
)
249 flags
|= IEEE80211_CHAN_INDOOR_ONLY
;
251 /* Set the GO concurrent flag only in case that NO_IR is set.
252 * Otherwise it is meaningless
254 if ((nvm_flags
& NVM_CHANNEL_GO_CONCURRENT
) &&
255 (flags
& IEEE80211_CHAN_NO_IR
))
256 flags
|= IEEE80211_CHAN_IR_CONCURRENT
;
261 static int iwl_init_channel_map(struct device
*dev
, const struct iwl_cfg
*cfg
,
262 struct iwl_nvm_data
*data
,
263 const __le16
* const nvm_ch_flags
,
268 struct ieee80211_channel
*channel
;
271 int num_of_ch
, num_2ghz_channels
;
274 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
) {
275 num_of_ch
= IWL_NUM_CHANNELS
;
276 nvm_chan
= &iwl_nvm_channels
[0];
277 num_2ghz_channels
= NUM_2GHZ_CHANNELS
;
279 num_of_ch
= IWL_NUM_CHANNELS_FAMILY_8000
;
280 nvm_chan
= &iwl_nvm_channels_family_8000
[0];
281 num_2ghz_channels
= NUM_2GHZ_CHANNELS_FAMILY_8000
;
284 for (ch_idx
= 0; ch_idx
< num_of_ch
; ch_idx
++) {
285 ch_flags
= __le16_to_cpup(nvm_ch_flags
+ ch_idx
);
287 if (ch_idx
>= num_2ghz_channels
&&
288 !data
->sku_cap_band_52GHz_enable
)
291 if (!lar_supported
&& !(ch_flags
& NVM_CHANNEL_VALID
)) {
293 * Channels might become valid later if lar is
294 * supported, hence we still want to add them to
295 * the list of supported channels to cfg80211.
297 IWL_DEBUG_EEPROM(dev
,
298 "Ch. %d Flags %x [%sGHz] - No traffic\n",
301 (ch_idx
>= num_2ghz_channels
) ?
306 channel
= &data
->channels
[n_channels
];
309 channel
->hw_value
= nvm_chan
[ch_idx
];
310 channel
->band
= (ch_idx
< num_2ghz_channels
) ?
311 NL80211_BAND_2GHZ
: NL80211_BAND_5GHZ
;
312 channel
->center_freq
=
313 ieee80211_channel_to_frequency(
314 channel
->hw_value
, channel
->band
);
316 /* Initialize regulatory-based run-time data */
319 * Default value - highest tx power value. max_power
320 * is not used in mvm, and is used for backwards compatibility
322 channel
->max_power
= IWL_DEFAULT_MAX_TX_POWER
;
323 is_5ghz
= channel
->band
== NL80211_BAND_5GHZ
;
325 /* don't put limitations in case we're using LAR */
327 channel
->flags
= iwl_get_channel_flags(nvm_chan
[ch_idx
],
333 IWL_DEBUG_EEPROM(dev
,
334 "Ch. %d [%sGHz] %s%s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
336 is_5ghz
? "5.2" : "2.4",
337 CHECK_AND_PRINT_I(VALID
),
338 CHECK_AND_PRINT_I(IBSS
),
339 CHECK_AND_PRINT_I(ACTIVE
),
340 CHECK_AND_PRINT_I(RADAR
),
341 CHECK_AND_PRINT_I(WIDE
),
342 CHECK_AND_PRINT_I(INDOOR_ONLY
),
343 CHECK_AND_PRINT_I(GO_CONCURRENT
),
346 ((ch_flags
& NVM_CHANNEL_IBSS
) &&
347 !(ch_flags
& NVM_CHANNEL_RADAR
))
354 static void iwl_init_vht_hw_capab(const struct iwl_cfg
*cfg
,
355 struct iwl_nvm_data
*data
,
356 struct ieee80211_sta_vht_cap
*vht_cap
,
357 u8 tx_chains
, u8 rx_chains
)
359 int num_rx_ants
= num_of_ant(rx_chains
);
360 int num_tx_ants
= num_of_ant(tx_chains
);
361 unsigned int max_ampdu_exponent
= (cfg
->max_vht_ampdu_exponent
?:
362 IEEE80211_VHT_MAX_AMPDU_1024K
);
364 vht_cap
->vht_supported
= true;
366 vht_cap
->cap
= IEEE80211_VHT_CAP_SHORT_GI_80
|
367 IEEE80211_VHT_CAP_RXSTBC_1
|
368 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE
|
369 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT
|
370 max_ampdu_exponent
<<
371 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT
;
373 if (cfg
->vht_mu_mimo_supported
)
374 vht_cap
->cap
|= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE
;
376 if (cfg
->ht_params
->ldpc
)
377 vht_cap
->cap
|= IEEE80211_VHT_CAP_RXLDPC
;
379 if (data
->sku_cap_mimo_disabled
) {
385 vht_cap
->cap
|= IEEE80211_VHT_CAP_TXSTBC
;
387 vht_cap
->cap
|= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN
;
389 switch (iwlwifi_mod_params
.amsdu_size
) {
391 vht_cap
->cap
|= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895
;
394 vht_cap
->cap
|= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991
;
397 vht_cap
->cap
|= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454
;
403 vht_cap
->vht_mcs
.rx_mcs_map
=
404 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9
<< 0 |
405 IEEE80211_VHT_MCS_SUPPORT_0_9
<< 2 |
406 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 4 |
407 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 6 |
408 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 8 |
409 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 10 |
410 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 12 |
411 IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 14);
413 if (num_rx_ants
== 1 || cfg
->rx_with_siso_diversity
) {
414 vht_cap
->cap
|= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN
;
415 /* this works because NOT_SUPPORTED == 3 */
416 vht_cap
->vht_mcs
.rx_mcs_map
|=
417 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED
<< 2);
420 vht_cap
->vht_mcs
.tx_mcs_map
= vht_cap
->vht_mcs
.rx_mcs_map
;
423 static void iwl_init_sbands(struct device
*dev
, const struct iwl_cfg
*cfg
,
424 struct iwl_nvm_data
*data
,
425 const __le16
*ch_section
,
426 u8 tx_chains
, u8 rx_chains
, bool lar_supported
)
430 struct ieee80211_supported_band
*sband
;
432 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
433 n_channels
= iwl_init_channel_map(
435 &ch_section
[NVM_CHANNELS
], lar_supported
);
437 n_channels
= iwl_init_channel_map(
439 &ch_section
[NVM_CHANNELS_FAMILY_8000
],
442 sband
= &data
->bands
[NL80211_BAND_2GHZ
];
443 sband
->band
= NL80211_BAND_2GHZ
;
444 sband
->bitrates
= &iwl_cfg80211_rates
[RATES_24_OFFS
];
445 sband
->n_bitrates
= N_RATES_24
;
446 n_used
+= iwl_init_sband_channels(data
, sband
, n_channels
,
448 iwl_init_ht_hw_capab(cfg
, data
, &sband
->ht_cap
, NL80211_BAND_2GHZ
,
449 tx_chains
, rx_chains
);
451 sband
= &data
->bands
[NL80211_BAND_5GHZ
];
452 sband
->band
= NL80211_BAND_5GHZ
;
453 sband
->bitrates
= &iwl_cfg80211_rates
[RATES_52_OFFS
];
454 sband
->n_bitrates
= N_RATES_52
;
455 n_used
+= iwl_init_sband_channels(data
, sband
, n_channels
,
457 iwl_init_ht_hw_capab(cfg
, data
, &sband
->ht_cap
, NL80211_BAND_5GHZ
,
458 tx_chains
, rx_chains
);
459 if (data
->sku_cap_11ac_enable
&& !iwlwifi_mod_params
.disable_11ac
)
460 iwl_init_vht_hw_capab(cfg
, data
, &sband
->vht_cap
,
461 tx_chains
, rx_chains
);
463 if (n_channels
!= n_used
)
464 IWL_ERR_DEV(dev
, "NVM: used only %d of %d channels\n",
468 static int iwl_get_sku(const struct iwl_cfg
*cfg
, const __le16
*nvm_sw
,
469 const __le16
*phy_sku
)
471 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
472 return le16_to_cpup(nvm_sw
+ SKU
);
474 return le32_to_cpup((__le32
*)(phy_sku
+ SKU_FAMILY_8000
));
477 static int iwl_get_nvm_version(const struct iwl_cfg
*cfg
, const __le16
*nvm_sw
)
479 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
480 return le16_to_cpup(nvm_sw
+ NVM_VERSION
);
482 return le32_to_cpup((__le32
*)(nvm_sw
+
483 NVM_VERSION_FAMILY_8000
));
486 static int iwl_get_radio_cfg(const struct iwl_cfg
*cfg
, const __le16
*nvm_sw
,
487 const __le16
*phy_sku
)
489 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
490 return le16_to_cpup(nvm_sw
+ RADIO_CFG
);
492 return le32_to_cpup((__le32
*)(phy_sku
+ RADIO_CFG_FAMILY_8000
));
496 static int iwl_get_n_hw_addrs(const struct iwl_cfg
*cfg
, const __le16
*nvm_sw
)
500 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
501 return le16_to_cpup(nvm_sw
+ N_HW_ADDRS
);
503 n_hw_addr
= le32_to_cpup((__le32
*)(nvm_sw
+ N_HW_ADDRS_FAMILY_8000
));
505 return n_hw_addr
& N_HW_ADDR_MASK
;
508 static void iwl_set_radio_cfg(const struct iwl_cfg
*cfg
,
509 struct iwl_nvm_data
*data
,
512 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
) {
513 data
->radio_cfg_type
= NVM_RF_CFG_TYPE_MSK(radio_cfg
);
514 data
->radio_cfg_step
= NVM_RF_CFG_STEP_MSK(radio_cfg
);
515 data
->radio_cfg_dash
= NVM_RF_CFG_DASH_MSK(radio_cfg
);
516 data
->radio_cfg_pnum
= NVM_RF_CFG_PNUM_MSK(radio_cfg
);
520 /* set the radio configuration for family 8000 */
521 data
->radio_cfg_type
= NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg
);
522 data
->radio_cfg_step
= NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg
);
523 data
->radio_cfg_dash
= NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg
);
524 data
->radio_cfg_pnum
= NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg
);
525 data
->valid_tx_ant
= NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg
);
526 data
->valid_rx_ant
= NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg
);
529 static void iwl_flip_hw_address(__le32 mac_addr0
, __le32 mac_addr1
, u8
*dest
)
533 hw_addr
= (const u8
*)&mac_addr0
;
534 dest
[0] = hw_addr
[3];
535 dest
[1] = hw_addr
[2];
536 dest
[2] = hw_addr
[1];
537 dest
[3] = hw_addr
[0];
539 hw_addr
= (const u8
*)&mac_addr1
;
540 dest
[4] = hw_addr
[1];
541 dest
[5] = hw_addr
[0];
544 static void iwl_set_hw_address_from_csr(struct iwl_trans
*trans
,
545 struct iwl_nvm_data
*data
)
547 __le32 mac_addr0
= cpu_to_le32(iwl_read32(trans
, CSR_MAC_ADDR0_STRAP
));
548 __le32 mac_addr1
= cpu_to_le32(iwl_read32(trans
, CSR_MAC_ADDR1_STRAP
));
550 /* If OEM did not fuse address - get it from OTP */
551 if (!mac_addr0
&& !mac_addr1
) {
552 mac_addr0
= cpu_to_le32(iwl_read32(trans
, CSR_MAC_ADDR0_OTP
));
553 mac_addr1
= cpu_to_le32(iwl_read32(trans
, CSR_MAC_ADDR1_OTP
));
556 iwl_flip_hw_address(mac_addr0
, mac_addr1
, data
->hw_addr
);
559 static void iwl_set_hw_address_family_8000(struct iwl_trans
*trans
,
560 const struct iwl_cfg
*cfg
,
561 struct iwl_nvm_data
*data
,
562 const __le16
*mac_override
,
563 const __le16
*nvm_hw
)
568 static const u8 reserved_mac
[] = {
569 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
572 hw_addr
= (const u8
*)(mac_override
+
573 MAC_ADDRESS_OVERRIDE_FAMILY_8000
);
576 * Store the MAC address from MAO section.
577 * No byte swapping is required in MAO section
579 memcpy(data
->hw_addr
, hw_addr
, ETH_ALEN
);
582 * Force the use of the OTP MAC address in case of reserved MAC
583 * address in the NVM, or if address is given but invalid.
585 if (is_valid_ether_addr(data
->hw_addr
) &&
586 memcmp(reserved_mac
, hw_addr
, ETH_ALEN
) != 0)
590 "mac address from nvm override section is not valid\n");
594 /* read the mac address from WFMP registers */
595 __le32 mac_addr0
= cpu_to_le32(iwl_trans_read_prph(trans
,
597 __le32 mac_addr1
= cpu_to_le32(iwl_trans_read_prph(trans
,
600 iwl_flip_hw_address(mac_addr0
, mac_addr1
, data
->hw_addr
);
605 IWL_ERR(trans
, "mac address is not found\n");
608 static int iwl_set_hw_address(struct iwl_trans
*trans
,
609 const struct iwl_cfg
*cfg
,
610 struct iwl_nvm_data
*data
, const __le16
*nvm_hw
,
611 const __le16
*mac_override
)
613 if (cfg
->mac_addr_from_csr
) {
614 iwl_set_hw_address_from_csr(trans
, data
);
615 } else if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
) {
616 const u8
*hw_addr
= (const u8
*)(nvm_hw
+ HW_ADDR
);
618 /* The byte order is little endian 16 bit, meaning 214365 */
619 data
->hw_addr
[0] = hw_addr
[1];
620 data
->hw_addr
[1] = hw_addr
[0];
621 data
->hw_addr
[2] = hw_addr
[3];
622 data
->hw_addr
[3] = hw_addr
[2];
623 data
->hw_addr
[4] = hw_addr
[5];
624 data
->hw_addr
[5] = hw_addr
[4];
626 iwl_set_hw_address_family_8000(trans
, cfg
, data
,
627 mac_override
, nvm_hw
);
630 if (!is_valid_ether_addr(data
->hw_addr
)) {
631 IWL_ERR(trans
, "no valid mac address was found\n");
638 struct iwl_nvm_data
*
639 iwl_parse_nvm_data(struct iwl_trans
*trans
, const struct iwl_cfg
*cfg
,
640 const __le16
*nvm_hw
, const __le16
*nvm_sw
,
641 const __le16
*nvm_calib
, const __le16
*regulatory
,
642 const __le16
*mac_override
, const __le16
*phy_sku
,
643 u8 tx_chains
, u8 rx_chains
, bool lar_fw_supported
)
645 struct device
*dev
= trans
->dev
;
646 struct iwl_nvm_data
*data
;
650 const __le16
*ch_section
;
652 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
)
653 data
= kzalloc(sizeof(*data
) +
654 sizeof(struct ieee80211_channel
) *
658 data
= kzalloc(sizeof(*data
) +
659 sizeof(struct ieee80211_channel
) *
660 IWL_NUM_CHANNELS_FAMILY_8000
,
665 data
->nvm_version
= iwl_get_nvm_version(cfg
, nvm_sw
);
667 radio_cfg
= iwl_get_radio_cfg(cfg
, nvm_sw
, phy_sku
);
668 iwl_set_radio_cfg(cfg
, data
, radio_cfg
);
669 if (data
->valid_tx_ant
)
670 tx_chains
&= data
->valid_tx_ant
;
671 if (data
->valid_rx_ant
)
672 rx_chains
&= data
->valid_rx_ant
;
674 sku
= iwl_get_sku(cfg
, nvm_sw
, phy_sku
);
675 data
->sku_cap_band_24GHz_enable
= sku
& NVM_SKU_CAP_BAND_24GHZ
;
676 data
->sku_cap_band_52GHz_enable
= sku
& NVM_SKU_CAP_BAND_52GHZ
;
677 data
->sku_cap_11n_enable
= sku
& NVM_SKU_CAP_11N_ENABLE
;
678 if (iwlwifi_mod_params
.disable_11n
& IWL_DISABLE_HT_ALL
)
679 data
->sku_cap_11n_enable
= false;
680 data
->sku_cap_11ac_enable
= data
->sku_cap_11n_enable
&&
681 (sku
& NVM_SKU_CAP_11AC_ENABLE
);
682 data
->sku_cap_mimo_disabled
= sku
& NVM_SKU_CAP_MIMO_DISABLE
;
684 data
->n_hw_addrs
= iwl_get_n_hw_addrs(cfg
, nvm_sw
);
686 if (cfg
->device_family
!= IWL_DEVICE_FAMILY_8000
) {
687 /* Checking for required sections */
690 "Can't parse empty Calib NVM sections\n");
694 /* in family 8000 Xtal calibration values moved to OTP */
695 data
->xtal_calib
[0] = *(nvm_calib
+ XTAL_CALIB
);
696 data
->xtal_calib
[1] = *(nvm_calib
+ XTAL_CALIB
+ 1);
700 u16 lar_offset
= data
->nvm_version
< 0xE39 ?
701 NVM_LAR_OFFSET_FAMILY_8000_OLD
:
702 NVM_LAR_OFFSET_FAMILY_8000
;
704 lar_config
= le16_to_cpup(regulatory
+ lar_offset
);
705 data
->lar_enabled
= !!(lar_config
&
706 NVM_LAR_ENABLED_FAMILY_8000
);
707 lar_enabled
= data
->lar_enabled
;
708 ch_section
= regulatory
;
711 /* If no valid mac address was found - bail out */
712 if (iwl_set_hw_address(trans
, cfg
, data
, nvm_hw
, mac_override
)) {
717 iwl_init_sbands(dev
, cfg
, data
, ch_section
, tx_chains
, rx_chains
,
718 lar_fw_supported
&& lar_enabled
);
719 data
->calib_version
= 255;
723 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data
);
725 static u32
iwl_nvm_get_regdom_bw_flags(const u8
*nvm_chan
,
726 int ch_idx
, u16 nvm_flags
,
727 const struct iwl_cfg
*cfg
)
729 u32 flags
= NL80211_RRF_NO_HT40
;
730 u32 last_5ghz_ht
= LAST_5GHZ_HT
;
732 if (cfg
->device_family
== IWL_DEVICE_FAMILY_8000
)
733 last_5ghz_ht
= LAST_5GHZ_HT_FAMILY_8000
;
735 if (ch_idx
< NUM_2GHZ_CHANNELS
&&
736 (nvm_flags
& NVM_CHANNEL_40MHZ
)) {
737 if (nvm_chan
[ch_idx
] <= LAST_2GHZ_HT_PLUS
)
738 flags
&= ~NL80211_RRF_NO_HT40PLUS
;
739 if (nvm_chan
[ch_idx
] >= FIRST_2GHZ_HT_MINUS
)
740 flags
&= ~NL80211_RRF_NO_HT40MINUS
;
741 } else if (nvm_chan
[ch_idx
] <= last_5ghz_ht
&&
742 (nvm_flags
& NVM_CHANNEL_40MHZ
)) {
743 if ((ch_idx
- NUM_2GHZ_CHANNELS
) % 2 == 0)
744 flags
&= ~NL80211_RRF_NO_HT40PLUS
;
746 flags
&= ~NL80211_RRF_NO_HT40MINUS
;
749 if (!(nvm_flags
& NVM_CHANNEL_80MHZ
))
750 flags
|= NL80211_RRF_NO_80MHZ
;
751 if (!(nvm_flags
& NVM_CHANNEL_160MHZ
))
752 flags
|= NL80211_RRF_NO_160MHZ
;
754 if (!(nvm_flags
& NVM_CHANNEL_ACTIVE
))
755 flags
|= NL80211_RRF_NO_IR
;
757 if (nvm_flags
& NVM_CHANNEL_RADAR
)
758 flags
|= NL80211_RRF_DFS
;
760 if (nvm_flags
& NVM_CHANNEL_INDOOR_ONLY
)
761 flags
|= NL80211_RRF_NO_OUTDOOR
;
763 /* Set the GO concurrent flag only in case that NO_IR is set.
764 * Otherwise it is meaningless
766 if ((nvm_flags
& NVM_CHANNEL_GO_CONCURRENT
) &&
767 (flags
& NL80211_RRF_NO_IR
))
768 flags
|= NL80211_RRF_GO_CONCURRENT
;
773 struct ieee80211_regdomain
*
774 iwl_parse_nvm_mcc_info(struct device
*dev
, const struct iwl_cfg
*cfg
,
775 int num_of_ch
, __le32
*channels
, u16 fw_mcc
)
778 u16 ch_flags
, prev_ch_flags
= 0;
779 const u8
*nvm_chan
= cfg
->device_family
== IWL_DEVICE_FAMILY_8000
?
780 iwl_nvm_channels_family_8000
: iwl_nvm_channels
;
781 struct ieee80211_regdomain
*regd
;
783 struct ieee80211_reg_rule
*rule
;
784 enum nl80211_band band
;
785 int center_freq
, prev_center_freq
= 0;
788 int max_num_ch
= cfg
->device_family
== IWL_DEVICE_FAMILY_8000
?
789 IWL_NUM_CHANNELS_FAMILY_8000
: IWL_NUM_CHANNELS
;
791 if (WARN_ON_ONCE(num_of_ch
> NL80211_MAX_SUPP_REG_RULES
))
792 return ERR_PTR(-EINVAL
);
794 if (WARN_ON(num_of_ch
> max_num_ch
))
795 num_of_ch
= max_num_ch
;
797 IWL_DEBUG_DEV(dev
, IWL_DL_LAR
, "building regdom for %d channels\n",
800 /* build a regdomain rule for every valid channel */
802 sizeof(struct ieee80211_regdomain
) +
803 num_of_ch
* sizeof(struct ieee80211_reg_rule
);
805 regd
= kzalloc(size_of_regd
, GFP_KERNEL
);
807 return ERR_PTR(-ENOMEM
);
809 for (ch_idx
= 0; ch_idx
< num_of_ch
; ch_idx
++) {
810 ch_flags
= (u16
)__le32_to_cpup(channels
+ ch_idx
);
811 band
= (ch_idx
< NUM_2GHZ_CHANNELS
) ?
812 NL80211_BAND_2GHZ
: NL80211_BAND_5GHZ
;
813 center_freq
= ieee80211_channel_to_frequency(nvm_chan
[ch_idx
],
817 if (!(ch_flags
& NVM_CHANNEL_VALID
)) {
818 IWL_DEBUG_DEV(dev
, IWL_DL_LAR
,
819 "Ch. %d Flags %x [%sGHz] - No traffic\n",
822 (ch_idx
>= NUM_2GHZ_CHANNELS
) ?
827 /* we can't continue the same rule */
828 if (ch_idx
== 0 || prev_ch_flags
!= ch_flags
||
829 center_freq
- prev_center_freq
> 20) {
834 rule
= ®d
->reg_rules
[valid_rules
- 1];
837 rule
->freq_range
.start_freq_khz
=
838 MHZ_TO_KHZ(center_freq
- 10);
840 rule
->freq_range
.end_freq_khz
= MHZ_TO_KHZ(center_freq
+ 10);
842 /* this doesn't matter - not used by FW */
843 rule
->power_rule
.max_antenna_gain
= DBI_TO_MBI(6);
844 rule
->power_rule
.max_eirp
=
845 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER
);
847 rule
->flags
= iwl_nvm_get_regdom_bw_flags(nvm_chan
, ch_idx
,
850 /* rely on auto-calculation to merge BW of contiguous chans */
851 rule
->flags
|= NL80211_RRF_AUTO_BW
;
852 rule
->freq_range
.max_bandwidth_khz
= 0;
854 prev_ch_flags
= ch_flags
;
855 prev_center_freq
= center_freq
;
857 IWL_DEBUG_DEV(dev
, IWL_DL_LAR
,
858 "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
860 band
== NL80211_BAND_5GHZ
? "5.2" : "2.4",
861 CHECK_AND_PRINT_I(VALID
),
862 CHECK_AND_PRINT_I(ACTIVE
),
863 CHECK_AND_PRINT_I(RADAR
),
864 CHECK_AND_PRINT_I(WIDE
),
865 CHECK_AND_PRINT_I(40MHZ
),
866 CHECK_AND_PRINT_I(80MHZ
),
867 CHECK_AND_PRINT_I(160MHZ
),
868 CHECK_AND_PRINT_I(INDOOR_ONLY
),
869 CHECK_AND_PRINT_I(GO_CONCURRENT
),
871 ((ch_flags
& NVM_CHANNEL_ACTIVE
) &&
872 !(ch_flags
& NVM_CHANNEL_RADAR
))
876 regd
->n_reg_rules
= valid_rules
;
878 /* set alpha2 from FW. */
879 regd
->alpha2
[0] = fw_mcc
>> 8;
880 regd
->alpha2
[1] = fw_mcc
& 0xff;
884 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info
);