?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Linux 4.4.145
[linux/fpc-iii.git] / drivers / net / wireless / iwlwifi / iwl-nvm-parse.c
blob95b82cc132e63e887e5fa5b87bc598bc025dfc7a
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 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of version 2 of the GNU General Public License as
13 * published by the Free Software Foundation.
14 *
15 * This program is distributed in the hope that it will be useful, but
16 * WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
23 * USA
24 *
25 * The full GNU General Public License is included in this distribution
26 * in the file called COPYING.
27 *
28 * Contact Information:
29 * Intel Linux Wireless <ilw@linux.intel.com>
30 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
31 *
32 * BSD LICENSE
33 *
34 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
35 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
36 * All rights reserved.
37 *
38 * Redistribution and use in source and binary forms, with or without
39 * modification, are permitted provided that the following conditions
40 * are met:
41 *
42 * * Redistributions of source code must retain the above copyright
43 * notice, this list of conditions and the following disclaimer.
44 * * Redistributions in binary form must reproduce the above copyright
45 * notice, this list of conditions and the following disclaimer in
46 * the documentation and/or other materials provided with the
47 * distribution.
48 * * Neither the name Intel Corporation nor the names of its
49 * contributors may be used to endorse or promote products derived
50 * from this software without specific prior written permission.
51 *
52 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
53 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
54 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
55 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
56 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
57 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
58 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
59 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
60 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
61 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
62 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
63 *****************************************************************************/
64 #include <linux/types.h>
65 #include <linux/slab.h>
66 #include <linux/export.h>
67 #include <linux/etherdevice.h>
68 #include <linux/pci.h>
69 #include "iwl-drv.h"
70 #include "iwl-modparams.h"
71 #include "iwl-nvm-parse.h"
72
73 /* NVM offsets (in words) definitions */
74 enum wkp_nvm_offsets {
75 /* NVM HW-Section offset (in words) definitions */
76 SUBSYSTEM_ID = 0x0A,
77 HW_ADDR = 0x15,
78
79 /* NVM SW-Section offset (in words) definitions */
80 NVM_SW_SECTION = 0x1C0,
81 NVM_VERSION = 0,
82 RADIO_CFG = 1,
83 SKU = 2,
84 N_HW_ADDRS = 3,
85 NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
86
87 /* NVM calibration section offset (in words) definitions */
88 NVM_CALIB_SECTION = 0x2B8,
89 XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
90 };
91
92 enum family_8000_nvm_offsets {
93 /* NVM HW-Section offset (in words) definitions */
94 HW_ADDR0_WFPM_FAMILY_8000 = 0x12,
95 HW_ADDR1_WFPM_FAMILY_8000 = 0x16,
96 HW_ADDR0_PCIE_FAMILY_8000 = 0x8A,
97 HW_ADDR1_PCIE_FAMILY_8000 = 0x8E,
98 MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
99
100 /* NVM SW-Section offset (in words) definitions */
101 NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
102 NVM_VERSION_FAMILY_8000 = 0,
103 RADIO_CFG_FAMILY_8000 = 0,
104 SKU_FAMILY_8000 = 2,
105 N_HW_ADDRS_FAMILY_8000 = 3,
106
107 /* NVM REGULATORY -Section offset (in words) definitions */
108 NVM_CHANNELS_FAMILY_8000 = 0,
109 NVM_LAR_OFFSET_FAMILY_8000_OLD = 0x4C7,
110 NVM_LAR_OFFSET_FAMILY_8000 = 0x507,
111 NVM_LAR_ENABLED_FAMILY_8000 = 0x7,
112
113 /* NVM calibration section offset (in words) definitions */
114 NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
115 XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
116 };
117
118 /* SKU Capabilities (actual values from NVM definition) */
119 enum nvm_sku_bits {
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),
125 };
126
127 /*
128 * These are the channel numbers in the order that they are stored in the NVM
129 */
130 static const u8 iwl_nvm_channels[] = {
131 /* 2.4 GHz */
132 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
133 /* 5 GHz */
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
137 };
138
139 static const u8 iwl_nvm_channels_family_8000[] = {
140 /* 2.4 GHz */
141 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
142 /* 5 GHz */
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
146 };
147
148 #define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
149 #define IWL_NUM_CHANNELS_FAMILY_8000 ARRAY_SIZE(iwl_nvm_channels_family_8000)
150 #define NUM_2GHZ_CHANNELS 14
151 #define NUM_2GHZ_CHANNELS_FAMILY_8000 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
157
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, },
175 };
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)
180
181 /**
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_WIDE: 20 MHz channel okay (?)
191 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
192 * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
193 * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
194 */
195 enum iwl_nvm_channel_flags {
196 NVM_CHANNEL_VALID = BIT(0),
197 NVM_CHANNEL_IBSS = BIT(1),
198 NVM_CHANNEL_ACTIVE = BIT(3),
199 NVM_CHANNEL_RADAR = BIT(4),
200 NVM_CHANNEL_INDOOR_ONLY = BIT(5),
201 NVM_CHANNEL_GO_CONCURRENT = BIT(6),
202 NVM_CHANNEL_WIDE = BIT(8),
203 NVM_CHANNEL_40MHZ = BIT(9),
204 NVM_CHANNEL_80MHZ = BIT(10),
205 NVM_CHANNEL_160MHZ = BIT(11),
206 };
207
208 #define CHECK_AND_PRINT_I(x) \
209 ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
210
211 static u32 iwl_get_channel_flags(u8 ch_num, int ch_idx, bool is_5ghz,
212 u16 nvm_flags, const struct iwl_cfg *cfg)
213 {
214 u32 flags = IEEE80211_CHAN_NO_HT40;
215 u32 last_5ghz_ht = LAST_5GHZ_HT;
216
217 if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
218 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
219
220 if (!is_5ghz && (nvm_flags & NVM_CHANNEL_40MHZ)) {
221 if (ch_num <= LAST_2GHZ_HT_PLUS)
222 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
223 if (ch_num >= FIRST_2GHZ_HT_MINUS)
224 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
225 } else if (ch_num <= last_5ghz_ht && (nvm_flags & NVM_CHANNEL_40MHZ)) {
226 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
227 flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
228 else
229 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
230 }
231 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
232 flags |= IEEE80211_CHAN_NO_80MHZ;
233 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
234 flags |= IEEE80211_CHAN_NO_160MHZ;
235
236 if (!(nvm_flags & NVM_CHANNEL_IBSS))
237 flags |= IEEE80211_CHAN_NO_IR;
238
239 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
240 flags |= IEEE80211_CHAN_NO_IR;
241
242 if (nvm_flags & NVM_CHANNEL_RADAR)
243 flags |= IEEE80211_CHAN_RADAR;
244
245 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
246 flags |= IEEE80211_CHAN_INDOOR_ONLY;
247
248 /* Set the GO concurrent flag only in case that NO_IR is set.
249 * Otherwise it is meaningless
250 */
251 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
252 (flags & IEEE80211_CHAN_NO_IR))
253 flags |= IEEE80211_CHAN_IR_CONCURRENT;
254
255 return flags;
256 }
257
258 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
259 struct iwl_nvm_data *data,
260 const __le16 * const nvm_ch_flags,
261 bool lar_supported, bool no_wide_in_5ghz)
262 {
263 int ch_idx;
264 int n_channels = 0;
265 struct ieee80211_channel *channel;
266 u16 ch_flags;
267 int num_of_ch, num_2ghz_channels;
268 const u8 *nvm_chan;
269
270 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
271 num_of_ch = IWL_NUM_CHANNELS;
272 nvm_chan = &iwl_nvm_channels[0];
273 num_2ghz_channels = NUM_2GHZ_CHANNELS;
274 } else {
275 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
276 nvm_chan = &iwl_nvm_channels_family_8000[0];
277 num_2ghz_channels = NUM_2GHZ_CHANNELS_FAMILY_8000;
278 }
279
280 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
281 bool is_5ghz = (ch_idx >= num_2ghz_channels);
282
283 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
284
285 if (is_5ghz && !data->sku_cap_band_52GHz_enable)
286 continue;
287
288 /* workaround to disable wide channels in 5GHz */
289 if (no_wide_in_5ghz && is_5ghz) {
290 ch_flags &= ~(NVM_CHANNEL_40MHZ |
291 NVM_CHANNEL_80MHZ |
292 NVM_CHANNEL_160MHZ);
293 }
294
295 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
296 /*
297 * Channels might become valid later if lar is
298 * supported, hence we still want to add them to
299 * the list of supported channels to cfg80211.
300 */
301 IWL_DEBUG_EEPROM(dev,
302 "Ch. %d Flags %x [%sGHz] - No traffic\n",
303 nvm_chan[ch_idx],
304 ch_flags,
305 (ch_idx >= num_2ghz_channels) ?
306 "5.2" : "2.4");
307 continue;
308 }
309
310 channel = &data->channels[n_channels];
311 n_channels++;
312
313 channel->hw_value = nvm_chan[ch_idx];
314 channel->band = is_5ghz ?
315 IEEE80211_BAND_5GHZ : IEEE80211_BAND_2GHZ;
316 channel->center_freq =
317 ieee80211_channel_to_frequency(
318 channel->hw_value, channel->band);
319
320 /* Initialize regulatory-based run-time data */
321
322 /*
323 * Default value - highest tx power value. max_power
324 * is not used in mvm, and is used for backwards compatibility
325 */
326 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
327
328 /* don't put limitations in case we're using LAR */
329 if (!lar_supported)
330 channel->flags = iwl_get_channel_flags(nvm_chan[ch_idx],
331 ch_idx, is_5ghz,
332 ch_flags, cfg);
333 else
334 channel->flags = 0;
335
336 IWL_DEBUG_EEPROM(dev,
337 "Ch. %d [%sGHz] %s%s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
338 channel->hw_value,
339 is_5ghz ? "5.2" : "2.4",
340 CHECK_AND_PRINT_I(VALID),
341 CHECK_AND_PRINT_I(IBSS),
342 CHECK_AND_PRINT_I(ACTIVE),
343 CHECK_AND_PRINT_I(RADAR),
344 CHECK_AND_PRINT_I(WIDE),
345 CHECK_AND_PRINT_I(INDOOR_ONLY),
346 CHECK_AND_PRINT_I(GO_CONCURRENT),
347 ch_flags,
348 channel->max_power,
349 ((ch_flags & NVM_CHANNEL_IBSS) &&
350 !(ch_flags & NVM_CHANNEL_RADAR))
351 ? "" : "not ");
352 }
353
354 return n_channels;
355 }
356
357 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
358 struct iwl_nvm_data *data,
359 struct ieee80211_sta_vht_cap *vht_cap,
360 u8 tx_chains, u8 rx_chains)
361 {
362 int num_rx_ants = num_of_ant(rx_chains);
363 int num_tx_ants = num_of_ant(tx_chains);
364 unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
365 IEEE80211_VHT_MAX_AMPDU_1024K);
366
367 vht_cap->vht_supported = true;
368
369 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
370 IEEE80211_VHT_CAP_RXSTBC_1 |
371 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
372 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
373 max_ampdu_exponent <<
374 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
375
376 if (cfg->ht_params->ldpc)
377 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
378
379 if (data->sku_cap_mimo_disabled) {
380 num_rx_ants = 1;
381 num_tx_ants = 1;
382 }
383
384 if (num_tx_ants > 1)
385 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
386 else
387 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
388
389 if (iwlwifi_mod_params.amsdu_size_8K)
390 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
391
392 vht_cap->vht_mcs.rx_mcs_map =
393 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
394 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
395 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
396 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
397 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
398 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
399 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
400 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
401
402 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
403 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
404 /* this works because NOT_SUPPORTED == 3 */
405 vht_cap->vht_mcs.rx_mcs_map |=
406 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
407 }
408
409 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
410 }
411
412 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
413 struct iwl_nvm_data *data,
414 const __le16 *ch_section,
415 u8 tx_chains, u8 rx_chains, bool lar_supported,
416 bool no_wide_in_5ghz)
417 {
418 int n_channels;
419 int n_used = 0;
420 struct ieee80211_supported_band *sband;
421
422 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
423 n_channels = iwl_init_channel_map(
424 dev, cfg, data,
425 &ch_section[NVM_CHANNELS], lar_supported,
426 no_wide_in_5ghz);
427 else
428 n_channels = iwl_init_channel_map(
429 dev, cfg, data,
430 &ch_section[NVM_CHANNELS_FAMILY_8000],
431 lar_supported,
432 no_wide_in_5ghz);
433
434 sband = &data->bands[IEEE80211_BAND_2GHZ];
435 sband->band = IEEE80211_BAND_2GHZ;
436 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
437 sband->n_bitrates = N_RATES_24;
438 n_used += iwl_init_sband_channels(data, sband, n_channels,
439 IEEE80211_BAND_2GHZ);
440 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
441 tx_chains, rx_chains);
442
443 sband = &data->bands[IEEE80211_BAND_5GHZ];
444 sband->band = IEEE80211_BAND_5GHZ;
445 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
446 sband->n_bitrates = N_RATES_52;
447 n_used += iwl_init_sband_channels(data, sband, n_channels,
448 IEEE80211_BAND_5GHZ);
449 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
450 tx_chains, rx_chains);
451 if (data->sku_cap_11ac_enable)
452 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
453 tx_chains, rx_chains);
454
455 if (n_channels != n_used)
456 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
457 n_used, n_channels);
458 }
459
460 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
461 const __le16 *phy_sku)
462 {
463 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
464 return le16_to_cpup(nvm_sw + SKU);
465
466 return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
467 }
468
469 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
470 {
471 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
472 return le16_to_cpup(nvm_sw + NVM_VERSION);
473 else
474 return le32_to_cpup((__le32 *)(nvm_sw +
475 NVM_VERSION_FAMILY_8000));
476 }
477
478 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
479 const __le16 *phy_sku)
480 {
481 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
482 return le16_to_cpup(nvm_sw + RADIO_CFG);
483
484 return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
485
486 }
487
488 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
489 {
490 int n_hw_addr;
491
492 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
493 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
494
495 n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
496
497 return n_hw_addr & N_HW_ADDR_MASK;
498 }
499
500 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
501 struct iwl_nvm_data *data,
502 u32 radio_cfg)
503 {
504 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
505 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
506 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
507 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
508 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
509 return;
510 }
511
512 /* set the radio configuration for family 8000 */
513 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
514 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
515 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
516 data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
517 data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg);
518 data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg);
519 }
520
521 static void iwl_set_hw_address(const struct iwl_cfg *cfg,
522 struct iwl_nvm_data *data,
523 const __le16 *nvm_sec)
524 {
525 const u8 *hw_addr = (const u8 *)(nvm_sec + HW_ADDR);
526
527 /* The byte order is little endian 16 bit, meaning 214365 */
528 data->hw_addr[0] = hw_addr[1];
529 data->hw_addr[1] = hw_addr[0];
530 data->hw_addr[2] = hw_addr[3];
531 data->hw_addr[3] = hw_addr[2];
532 data->hw_addr[4] = hw_addr[5];
533 data->hw_addr[5] = hw_addr[4];
534 }
535
536 static void iwl_set_hw_address_family_8000(struct device *dev,
537 const struct iwl_cfg *cfg,
538 struct iwl_nvm_data *data,
539 const __le16 *mac_override,
540 const __le16 *nvm_hw,
541 u32 mac_addr0, u32 mac_addr1)
542 {
543 const u8 *hw_addr;
544
545 if (mac_override) {
546 static const u8 reserved_mac[] = {
547 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
548 };
549
550 hw_addr = (const u8 *)(mac_override +
551 MAC_ADDRESS_OVERRIDE_FAMILY_8000);
552
553 /*
554 * Store the MAC address from MAO section.
555 * No byte swapping is required in MAO section
556 */
557 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
558
559 /*
560 * Force the use of the OTP MAC address in case of reserved MAC
561 * address in the NVM, or if address is given but invalid.
562 */
563 if (is_valid_ether_addr(data->hw_addr) &&
564 memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
565 return;
566
567 IWL_ERR_DEV(dev,
568 "mac address from nvm override section is not valid\n");
569 }
570
571 if (nvm_hw) {
572 /* read the MAC address from HW resisters */
573 hw_addr = (const u8 *)&mac_addr0;
574 data->hw_addr[0] = hw_addr[3];
575 data->hw_addr[1] = hw_addr[2];
576 data->hw_addr[2] = hw_addr[1];
577 data->hw_addr[3] = hw_addr[0];
578
579 hw_addr = (const u8 *)&mac_addr1;
580 data->hw_addr[4] = hw_addr[1];
581 data->hw_addr[5] = hw_addr[0];
582
583 if (!is_valid_ether_addr(data->hw_addr))
584 IWL_ERR_DEV(dev,
585 "mac address from hw section is not valid\n");
586
587 return;
588 }
589
590 IWL_ERR_DEV(dev, "mac address is not found\n");
591 }
592
593 #define IWL_4165_DEVICE_ID 0x5501
594
595 static bool
596 iwl_nvm_no_wide_in_5ghz(struct device *dev, const struct iwl_cfg *cfg,
597 const __le16 *nvm_hw)
598 {
599 /*
600 * Workaround a bug in Indonesia SKUs where the regulatory in
601 * some 7000-family OTPs erroneously allow wide channels in
602 * 5GHz. To check for Indonesia, we take the SKU value from
603 * bits 1-4 in the subsystem ID and check if it is either 5 or
604 * 9. In those cases, we need to force-disable wide channels
605 * in 5GHz otherwise the FW will throw a sysassert when we try
606 * to use them.
607 */
608 if (cfg->device_family == IWL_DEVICE_FAMILY_7000) {
609 /*
610 * Unlike the other sections in the NVM, the hw
611 * section uses big-endian.
612 */
613 u16 subsystem_id = be16_to_cpup((const __be16 *)nvm_hw
614 + SUBSYSTEM_ID);
615 u8 sku = (subsystem_id & 0x1e) >> 1;
616
617 if (sku == 5 || sku == 9) {
618 IWL_DEBUG_EEPROM(dev,
619 "disabling wide channels in 5GHz (0x%0x %d)\n",
620 subsystem_id, sku);
621 return true;
622 }
623 }
624
625 return false;
626 }
627
628 struct iwl_nvm_data *
629 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
630 const __le16 *nvm_hw, const __le16 *nvm_sw,
631 const __le16 *nvm_calib, const __le16 *regulatory,
632 const __le16 *mac_override, const __le16 *phy_sku,
633 u8 tx_chains, u8 rx_chains, bool lar_fw_supported,
634 u32 mac_addr0, u32 mac_addr1, u32 hw_id)
635 {
636 struct iwl_nvm_data *data;
637 bool no_wide_in_5ghz = iwl_nvm_no_wide_in_5ghz(dev, cfg, nvm_hw);
638 u32 sku;
639 u32 radio_cfg;
640 u16 lar_config;
641
642 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
643 data = kzalloc(sizeof(*data) +
644 sizeof(struct ieee80211_channel) *
645 IWL_NUM_CHANNELS,
646 GFP_KERNEL);
647 else
648 data = kzalloc(sizeof(*data) +
649 sizeof(struct ieee80211_channel) *
650 IWL_NUM_CHANNELS_FAMILY_8000,
651 GFP_KERNEL);
652 if (!data)
653 return NULL;
654
655 data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
656
657 radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
658 iwl_set_radio_cfg(cfg, data, radio_cfg);
659 if (data->valid_tx_ant)
660 tx_chains &= data->valid_tx_ant;
661 if (data->valid_rx_ant)
662 rx_chains &= data->valid_rx_ant;
663
664 sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
665 data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
666 data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
667 data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
668 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
669 data->sku_cap_11n_enable = false;
670 data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
671 (sku & NVM_SKU_CAP_11AC_ENABLE);
672 data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
673
674 /*
675 * OTP 0x52 bug work around
676 * define antenna 1x1 according to MIMO disabled
677 */
678 if (hw_id == IWL_4165_DEVICE_ID && data->sku_cap_mimo_disabled) {
679 data->valid_tx_ant = ANT_B;
680 data->valid_rx_ant = ANT_B;
681 tx_chains = ANT_B;
682 rx_chains = ANT_B;
683 }
684
685 data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
686
687 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
688 /* Checking for required sections */
689 if (!nvm_calib) {
690 IWL_ERR_DEV(dev,
691 "Can't parse empty Calib NVM sections\n");
692 kfree(data);
693 return NULL;
694 }
695 /* in family 8000 Xtal calibration values moved to OTP */
696 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
697 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
698 }
699
700 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
701 iwl_set_hw_address(cfg, data, nvm_hw);
702
703 iwl_init_sbands(dev, cfg, data, nvm_sw,
704 tx_chains, rx_chains, lar_fw_supported,
705 no_wide_in_5ghz);
706 } else {
707 u16 lar_offset = data->nvm_version < 0xE39 ?
708 NVM_LAR_OFFSET_FAMILY_8000_OLD :
709 NVM_LAR_OFFSET_FAMILY_8000;
710
711 lar_config = le16_to_cpup(regulatory + lar_offset);
712 data->lar_enabled = !!(lar_config &
713 NVM_LAR_ENABLED_FAMILY_8000);
714
715 /* MAC address in family 8000 */
716 iwl_set_hw_address_family_8000(dev, cfg, data, mac_override,
717 nvm_hw, mac_addr0, mac_addr1);
718
719 iwl_init_sbands(dev, cfg, data, regulatory,
720 tx_chains, rx_chains,
721 lar_fw_supported && data->lar_enabled,
722 no_wide_in_5ghz);
723 }
724
725 data->calib_version = 255;
726
727 return data;
728 }
729 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
730
731 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
732 int ch_idx, u16 nvm_flags,
733 const struct iwl_cfg *cfg)
734 {
735 u32 flags = NL80211_RRF_NO_HT40;
736 u32 last_5ghz_ht = LAST_5GHZ_HT;
737
738 if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
739 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
740
741 if (ch_idx < NUM_2GHZ_CHANNELS &&
742 (nvm_flags & NVM_CHANNEL_40MHZ)) {
743 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
744 flags &= ~NL80211_RRF_NO_HT40PLUS;
745 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
746 flags &= ~NL80211_RRF_NO_HT40MINUS;
747 } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
748 (nvm_flags & NVM_CHANNEL_40MHZ)) {
749 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
750 flags &= ~NL80211_RRF_NO_HT40PLUS;
751 else
752 flags &= ~NL80211_RRF_NO_HT40MINUS;
753 }
754
755 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
756 flags |= NL80211_RRF_NO_80MHZ;
757 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
758 flags |= NL80211_RRF_NO_160MHZ;
759
760 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
761 flags |= NL80211_RRF_NO_IR;
762
763 if (nvm_flags & NVM_CHANNEL_RADAR)
764 flags |= NL80211_RRF_DFS;
765
766 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
767 flags |= NL80211_RRF_NO_OUTDOOR;
768
769 /* Set the GO concurrent flag only in case that NO_IR is set.
770 * Otherwise it is meaningless
771 */
772 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
773 (flags & NL80211_RRF_NO_IR))
774 flags |= NL80211_RRF_GO_CONCURRENT;
775
776 return flags;
777 }
778
779 struct ieee80211_regdomain *
780 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
781 int num_of_ch, __le32 *channels, u16 fw_mcc)
782 {
783 int ch_idx;
784 u16 ch_flags, prev_ch_flags = 0;
785 const u8 *nvm_chan = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
786 iwl_nvm_channels_family_8000 : iwl_nvm_channels;
787 struct ieee80211_regdomain *regd;
788 int size_of_regd;
789 struct ieee80211_reg_rule *rule;
790 enum ieee80211_band band;
791 int center_freq, prev_center_freq = 0;
792 int valid_rules = 0;
793 bool new_rule;
794 int max_num_ch = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
795 IWL_NUM_CHANNELS_FAMILY_8000 : IWL_NUM_CHANNELS;
796
797 if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
798 return ERR_PTR(-EINVAL);
799
800 if (WARN_ON(num_of_ch > max_num_ch))
801 num_of_ch = max_num_ch;
802
803 IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
804 num_of_ch);
805
806 /* build a regdomain rule for every valid channel */
807 size_of_regd =
808 sizeof(struct ieee80211_regdomain) +
809 num_of_ch * sizeof(struct ieee80211_reg_rule);
810
811 regd = kzalloc(size_of_regd, GFP_KERNEL);
812 if (!regd)
813 return ERR_PTR(-ENOMEM);
814
815 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
816 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
817 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
818 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
819 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
820 band);
821 new_rule = false;
822
823 if (!(ch_flags & NVM_CHANNEL_VALID)) {
824 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
825 "Ch. %d Flags %x [%sGHz] - No traffic\n",
826 nvm_chan[ch_idx],
827 ch_flags,
828 (ch_idx >= NUM_2GHZ_CHANNELS) ?
829 "5.2" : "2.4");
830 continue;
831 }
832
833 /* we can't continue the same rule */
834 if (ch_idx == 0 || prev_ch_flags != ch_flags ||
835 center_freq - prev_center_freq > 20) {
836 valid_rules++;
837 new_rule = true;
838 }
839
840 rule = &regd->reg_rules[valid_rules - 1];
841
842 if (new_rule)
843 rule->freq_range.start_freq_khz =
844 MHZ_TO_KHZ(center_freq - 10);
845
846 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
847
848 /* this doesn't matter - not used by FW */
849 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
850 rule->power_rule.max_eirp =
851 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
852
853 rule->flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
854 ch_flags, cfg);
855
856 /* rely on auto-calculation to merge BW of contiguous chans */
857 rule->flags |= NL80211_RRF_AUTO_BW;
858 rule->freq_range.max_bandwidth_khz = 0;
859
860 prev_ch_flags = ch_flags;
861 prev_center_freq = center_freq;
862
863 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
864 "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
865 center_freq,
866 band == IEEE80211_BAND_5GHZ ? "5.2" : "2.4",
867 CHECK_AND_PRINT_I(VALID),
868 CHECK_AND_PRINT_I(ACTIVE),
869 CHECK_AND_PRINT_I(RADAR),
870 CHECK_AND_PRINT_I(WIDE),
871 CHECK_AND_PRINT_I(40MHZ),
872 CHECK_AND_PRINT_I(80MHZ),
873 CHECK_AND_PRINT_I(160MHZ),
874 CHECK_AND_PRINT_I(INDOOR_ONLY),
875 CHECK_AND_PRINT_I(GO_CONCURRENT),
876 ch_flags,
877 ((ch_flags & NVM_CHANNEL_ACTIVE) &&
878 !(ch_flags & NVM_CHANNEL_RADAR))
879 ? "" : "not ");
880 }
881
882 regd->n_reg_rules = valid_rules;
883
884 /* set alpha2 from FW. */
885 regd->alpha2[0] = fw_mcc >> 8;
886 regd->alpha2[1] = fw_mcc & 0xff;
887
888 return regd;
889 }
890 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);
Linux with added FPC-III support