]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/net/wireless/intel/iwlwifi/iwl-nvm-parse.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-linus-4.8' of git://git.code.sf.net/p/openipmi/linux-ipmi
[mirror_ubuntu-artful-kernel.git] / drivers / net / wireless / intel / iwlwifi / iwl-nvm-parse.c
1 /******************************************************************************
2 *
3 * This file is provided under a dual BSD/GPLv2 license. When using or
4 * redistributing this file, you may do so under either license.
5 *
6 * GPL LICENSE SUMMARY
7 *
8 * Copyright(c) 2008 - 2014 Intel Corporation. All rights reserved.
9 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
10 * Copyright(c) 2016 Intel Deutschland GmbH
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of version 2 of the GNU General Public License as
14 * published by the Free Software Foundation.
15 *
16 * This program is distributed in the hope that it will be useful, but
17 * WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
19 * General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
24 * USA
25 *
26 * The full GNU General Public License is included in this distribution
27 * in the file called COPYING.
28 *
29 * Contact Information:
30 * Intel Linux Wireless <linuxwifi@intel.com>
31 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
32 *
33 * BSD LICENSE
34 *
35 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
36 * Copyright(c) 2013 - 2015 Intel Mobile Communications GmbH
37 * All rights reserved.
38 *
39 * Redistribution and use in source and binary forms, with or without
40 * modification, are permitted provided that the following conditions
41 * are met:
42 *
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
48 * distribution.
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.
52 *
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>
70 #include "iwl-drv.h"
71 #include "iwl-modparams.h"
72 #include "iwl-nvm-parse.h"
73 #include "iwl-prph.h"
74 #include "iwl-io.h"
75 #include "iwl-csr.h"
76
77 /* NVM offsets (in words) definitions */
78 enum wkp_nvm_offsets {
79 /* NVM HW-Section offset (in words) definitions */
80 HW_ADDR = 0x15,
81
82 /* NVM SW-Section offset (in words) definitions */
83 NVM_SW_SECTION = 0x1C0,
84 NVM_VERSION = 0,
85 RADIO_CFG = 1,
86 SKU = 2,
87 N_HW_ADDRS = 3,
88 NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
89
90 /* NVM calibration section offset (in words) definitions */
91 NVM_CALIB_SECTION = 0x2B8,
92 XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
93 };
94
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,
102
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,
107 SKU_FAMILY_8000 = 2,
108 N_HW_ADDRS_FAMILY_8000 = 3,
109
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,
115
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
119 };
120
121 /* SKU Capabilities (actual values from NVM definition) */
122 enum nvm_sku_bits {
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),
128 };
129
130 /*
131 * These are the channel numbers in the order that they are stored in the NVM
132 */
133 static const u8 iwl_nvm_channels[] = {
134 /* 2.4 GHz */
135 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
136 /* 5 GHz */
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
140 };
141
142 static const u8 iwl_nvm_channels_family_8000[] = {
143 /* 2.4 GHz */
144 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
145 /* 5 GHz */
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
149 };
150
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
160
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, },
178 };
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)
183
184 /**
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 (?)
197 */
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),
209 };
210
211 #define CHECK_AND_PRINT_I(x) \
212 ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
213
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)
216 {
217 u32 flags = IEEE80211_CHAN_NO_HT40;
218 u32 last_5ghz_ht = LAST_5GHZ_HT;
219
220 if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
221 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
222
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;
231 else
232 flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
233 }
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;
238
239 if (!(nvm_flags & NVM_CHANNEL_IBSS))
240 flags |= IEEE80211_CHAN_NO_IR;
241
242 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
243 flags |= IEEE80211_CHAN_NO_IR;
244
245 if (nvm_flags & NVM_CHANNEL_RADAR)
246 flags |= IEEE80211_CHAN_RADAR;
247
248 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
249 flags |= IEEE80211_CHAN_INDOOR_ONLY;
250
251 /* Set the GO concurrent flag only in case that NO_IR is set.
252 * Otherwise it is meaningless
253 */
254 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
255 (flags & IEEE80211_CHAN_NO_IR))
256 flags |= IEEE80211_CHAN_IR_CONCURRENT;
257
258 return flags;
259 }
260
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,
264 bool lar_supported)
265 {
266 int ch_idx;
267 int n_channels = 0;
268 struct ieee80211_channel *channel;
269 u16 ch_flags;
270 bool is_5ghz;
271 int num_of_ch, num_2ghz_channels;
272 const u8 *nvm_chan;
273
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;
278 } else {
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;
282 }
283
284 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
285 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
286
287 if (ch_idx >= num_2ghz_channels &&
288 !data->sku_cap_band_52GHz_enable)
289 continue;
290
291 if (ch_flags & NVM_CHANNEL_160MHZ)
292 data->vht160_supported = true;
293
294 if (!lar_supported && !(ch_flags & NVM_CHANNEL_VALID)) {
295 /*
296 * Channels might become valid later if lar is
297 * supported, hence we still want to add them to
298 * the list of supported channels to cfg80211.
299 */
300 IWL_DEBUG_EEPROM(dev,
301 "Ch. %d Flags %x [%sGHz] - No traffic\n",
302 nvm_chan[ch_idx],
303 ch_flags,
304 (ch_idx >= num_2ghz_channels) ?
305 "5.2" : "2.4");
306 continue;
307 }
308
309 channel = &data->channels[n_channels];
310 n_channels++;
311
312 channel->hw_value = nvm_chan[ch_idx];
313 channel->band = (ch_idx < num_2ghz_channels) ?
314 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
315 channel->center_freq =
316 ieee80211_channel_to_frequency(
317 channel->hw_value, channel->band);
318
319 /* Initialize regulatory-based run-time data */
320
321 /*
322 * Default value - highest tx power value. max_power
323 * is not used in mvm, and is used for backwards compatibility
324 */
325 channel->max_power = IWL_DEFAULT_MAX_TX_POWER;
326 is_5ghz = channel->band == NL80211_BAND_5GHZ;
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] flags 0x%x %s%s%s%s%s%s%s%s%s%s(%ddBm): Ad-Hoc %ssupported\n",
338 channel->hw_value,
339 is_5ghz ? "5.2" : "2.4",
340 ch_flags,
341 CHECK_AND_PRINT_I(VALID),
342 CHECK_AND_PRINT_I(IBSS),
343 CHECK_AND_PRINT_I(ACTIVE),
344 CHECK_AND_PRINT_I(RADAR),
345 CHECK_AND_PRINT_I(INDOOR_ONLY),
346 CHECK_AND_PRINT_I(GO_CONCURRENT),
347 CHECK_AND_PRINT_I(WIDE),
348 CHECK_AND_PRINT_I(40MHZ),
349 CHECK_AND_PRINT_I(80MHZ),
350 CHECK_AND_PRINT_I(160MHZ),
351 channel->max_power,
352 ((ch_flags & NVM_CHANNEL_IBSS) &&
353 !(ch_flags & NVM_CHANNEL_RADAR))
354 ? "" : "not ");
355 }
356
357 return n_channels;
358 }
359
360 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
361 struct iwl_nvm_data *data,
362 struct ieee80211_sta_vht_cap *vht_cap,
363 u8 tx_chains, u8 rx_chains)
364 {
365 int num_rx_ants = num_of_ant(rx_chains);
366 int num_tx_ants = num_of_ant(tx_chains);
367 unsigned int max_ampdu_exponent = (cfg->max_vht_ampdu_exponent ?:
368 IEEE80211_VHT_MAX_AMPDU_1024K);
369
370 vht_cap->vht_supported = true;
371
372 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
373 IEEE80211_VHT_CAP_RXSTBC_1 |
374 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
375 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
376 max_ampdu_exponent <<
377 IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
378
379 if (data->vht160_supported)
380 vht_cap->cap |= IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ |
381 IEEE80211_VHT_CAP_SHORT_GI_160;
382
383 if (cfg->vht_mu_mimo_supported)
384 vht_cap->cap |= IEEE80211_VHT_CAP_MU_BEAMFORMEE_CAPABLE;
385
386 if (cfg->ht_params->ldpc)
387 vht_cap->cap |= IEEE80211_VHT_CAP_RXLDPC;
388
389 if (data->sku_cap_mimo_disabled) {
390 num_rx_ants = 1;
391 num_tx_ants = 1;
392 }
393
394 if (num_tx_ants > 1)
395 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
396 else
397 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
398
399 switch (iwlwifi_mod_params.amsdu_size) {
400 case IWL_AMSDU_DEF:
401 if (cfg->mq_rx_supported)
402 vht_cap->cap |=
403 IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
404 else
405 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
406 break;
407 case IWL_AMSDU_4K:
408 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895;
409 break;
410 case IWL_AMSDU_8K:
411 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
412 break;
413 case IWL_AMSDU_12K:
414 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454;
415 break;
416 default:
417 break;
418 }
419
420 vht_cap->vht_mcs.rx_mcs_map =
421 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
422 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
423 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
424 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
425 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
426 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
427 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
428 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
429
430 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
431 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
432 /* this works because NOT_SUPPORTED == 3 */
433 vht_cap->vht_mcs.rx_mcs_map |=
434 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
435 }
436
437 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
438 }
439
440 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
441 struct iwl_nvm_data *data,
442 const __le16 *ch_section,
443 u8 tx_chains, u8 rx_chains, bool lar_supported)
444 {
445 int n_channels;
446 int n_used = 0;
447 struct ieee80211_supported_band *sband;
448
449 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
450 n_channels = iwl_init_channel_map(
451 dev, cfg, data,
452 &ch_section[NVM_CHANNELS], lar_supported);
453 else
454 n_channels = iwl_init_channel_map(
455 dev, cfg, data,
456 &ch_section[NVM_CHANNELS_FAMILY_8000],
457 lar_supported);
458
459 sband = &data->bands[NL80211_BAND_2GHZ];
460 sband->band = NL80211_BAND_2GHZ;
461 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
462 sband->n_bitrates = N_RATES_24;
463 n_used += iwl_init_sband_channels(data, sband, n_channels,
464 NL80211_BAND_2GHZ);
465 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_2GHZ,
466 tx_chains, rx_chains);
467
468 sband = &data->bands[NL80211_BAND_5GHZ];
469 sband->band = NL80211_BAND_5GHZ;
470 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
471 sband->n_bitrates = N_RATES_52;
472 n_used += iwl_init_sband_channels(data, sband, n_channels,
473 NL80211_BAND_5GHZ);
474 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, NL80211_BAND_5GHZ,
475 tx_chains, rx_chains);
476 if (data->sku_cap_11ac_enable && !iwlwifi_mod_params.disable_11ac)
477 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
478 tx_chains, rx_chains);
479
480 if (n_channels != n_used)
481 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
482 n_used, n_channels);
483 }
484
485 static int iwl_get_sku(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
486 const __le16 *phy_sku)
487 {
488 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
489 return le16_to_cpup(nvm_sw + SKU);
490
491 return le32_to_cpup((__le32 *)(phy_sku + SKU_FAMILY_8000));
492 }
493
494 static int iwl_get_nvm_version(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
495 {
496 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
497 return le16_to_cpup(nvm_sw + NVM_VERSION);
498 else
499 return le32_to_cpup((__le32 *)(nvm_sw +
500 NVM_VERSION_FAMILY_8000));
501 }
502
503 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg, const __le16 *nvm_sw,
504 const __le16 *phy_sku)
505 {
506 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
507 return le16_to_cpup(nvm_sw + RADIO_CFG);
508
509 return le32_to_cpup((__le32 *)(phy_sku + RADIO_CFG_FAMILY_8000));
510
511 }
512
513 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg, const __le16 *nvm_sw)
514 {
515 int n_hw_addr;
516
517 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
518 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
519
520 n_hw_addr = le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000));
521
522 return n_hw_addr & N_HW_ADDR_MASK;
523 }
524
525 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
526 struct iwl_nvm_data *data,
527 u32 radio_cfg)
528 {
529 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
530 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
531 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
532 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
533 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
534 return;
535 }
536
537 /* set the radio configuration for family 8000 */
538 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
539 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
540 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
541 data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
542 data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK_FAMILY_8000(radio_cfg);
543 data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK_FAMILY_8000(radio_cfg);
544 }
545
546 static void iwl_flip_hw_address(__le32 mac_addr0, __le32 mac_addr1, u8 *dest)
547 {
548 const u8 *hw_addr;
549
550 hw_addr = (const u8 *)&mac_addr0;
551 dest[0] = hw_addr[3];
552 dest[1] = hw_addr[2];
553 dest[2] = hw_addr[1];
554 dest[3] = hw_addr[0];
555
556 hw_addr = (const u8 *)&mac_addr1;
557 dest[4] = hw_addr[1];
558 dest[5] = hw_addr[0];
559 }
560
561 static void iwl_set_hw_address_from_csr(struct iwl_trans *trans,
562 struct iwl_nvm_data *data)
563 {
564 __le32 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_STRAP));
565 __le32 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_STRAP));
566
567 /* If OEM did not fuse address - get it from OTP */
568 if (!mac_addr0 && !mac_addr1) {
569 mac_addr0 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR0_OTP));
570 mac_addr1 = cpu_to_le32(iwl_read32(trans, CSR_MAC_ADDR1_OTP));
571 }
572
573 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
574 }
575
576 static void iwl_set_hw_address_family_8000(struct iwl_trans *trans,
577 const struct iwl_cfg *cfg,
578 struct iwl_nvm_data *data,
579 const __le16 *mac_override,
580 const __le16 *nvm_hw)
581 {
582 const u8 *hw_addr;
583
584 if (mac_override) {
585 static const u8 reserved_mac[] = {
586 0x02, 0xcc, 0xaa, 0xff, 0xee, 0x00
587 };
588
589 hw_addr = (const u8 *)(mac_override +
590 MAC_ADDRESS_OVERRIDE_FAMILY_8000);
591
592 /*
593 * Store the MAC address from MAO section.
594 * No byte swapping is required in MAO section
595 */
596 memcpy(data->hw_addr, hw_addr, ETH_ALEN);
597
598 /*
599 * Force the use of the OTP MAC address in case of reserved MAC
600 * address in the NVM, or if address is given but invalid.
601 */
602 if (is_valid_ether_addr(data->hw_addr) &&
603 memcmp(reserved_mac, hw_addr, ETH_ALEN) != 0)
604 return;
605
606 IWL_ERR(trans,
607 "mac address from nvm override section is not valid\n");
608 }
609
610 if (nvm_hw) {
611 /* read the mac address from WFMP registers */
612 __le32 mac_addr0 = cpu_to_le32(iwl_trans_read_prph(trans,
613 WFMP_MAC_ADDR_0));
614 __le32 mac_addr1 = cpu_to_le32(iwl_trans_read_prph(trans,
615 WFMP_MAC_ADDR_1));
616
617 iwl_flip_hw_address(mac_addr0, mac_addr1, data->hw_addr);
618
619 return;
620 }
621
622 IWL_ERR(trans, "mac address is not found\n");
623 }
624
625 static int iwl_set_hw_address(struct iwl_trans *trans,
626 const struct iwl_cfg *cfg,
627 struct iwl_nvm_data *data, const __le16 *nvm_hw,
628 const __le16 *mac_override)
629 {
630 if (cfg->mac_addr_from_csr) {
631 iwl_set_hw_address_from_csr(trans, data);
632 } else if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
633 const u8 *hw_addr = (const u8 *)(nvm_hw + HW_ADDR);
634
635 /* The byte order is little endian 16 bit, meaning 214365 */
636 data->hw_addr[0] = hw_addr[1];
637 data->hw_addr[1] = hw_addr[0];
638 data->hw_addr[2] = hw_addr[3];
639 data->hw_addr[3] = hw_addr[2];
640 data->hw_addr[4] = hw_addr[5];
641 data->hw_addr[5] = hw_addr[4];
642 } else {
643 iwl_set_hw_address_family_8000(trans, cfg, data,
644 mac_override, nvm_hw);
645 }
646
647 if (!is_valid_ether_addr(data->hw_addr)) {
648 IWL_ERR(trans, "no valid mac address was found\n");
649 return -EINVAL;
650 }
651
652 return 0;
653 }
654
655 struct iwl_nvm_data *
656 iwl_parse_nvm_data(struct iwl_trans *trans, const struct iwl_cfg *cfg,
657 const __le16 *nvm_hw, const __le16 *nvm_sw,
658 const __le16 *nvm_calib, const __le16 *regulatory,
659 const __le16 *mac_override, const __le16 *phy_sku,
660 u8 tx_chains, u8 rx_chains, bool lar_fw_supported)
661 {
662 struct device *dev = trans->dev;
663 struct iwl_nvm_data *data;
664 bool lar_enabled;
665 u32 sku, radio_cfg;
666 u16 lar_config;
667 const __le16 *ch_section;
668
669 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
670 data = kzalloc(sizeof(*data) +
671 sizeof(struct ieee80211_channel) *
672 IWL_NUM_CHANNELS,
673 GFP_KERNEL);
674 else
675 data = kzalloc(sizeof(*data) +
676 sizeof(struct ieee80211_channel) *
677 IWL_NUM_CHANNELS_FAMILY_8000,
678 GFP_KERNEL);
679 if (!data)
680 return NULL;
681
682 data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
683
684 radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw, phy_sku);
685 iwl_set_radio_cfg(cfg, data, radio_cfg);
686 if (data->valid_tx_ant)
687 tx_chains &= data->valid_tx_ant;
688 if (data->valid_rx_ant)
689 rx_chains &= data->valid_rx_ant;
690
691 sku = iwl_get_sku(cfg, nvm_sw, phy_sku);
692 data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
693 data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
694 data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
695 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
696 data->sku_cap_11n_enable = false;
697 data->sku_cap_11ac_enable = data->sku_cap_11n_enable &&
698 (sku & NVM_SKU_CAP_11AC_ENABLE);
699 data->sku_cap_mimo_disabled = sku & NVM_SKU_CAP_MIMO_DISABLE;
700
701 data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
702
703 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
704 /* Checking for required sections */
705 if (!nvm_calib) {
706 IWL_ERR(trans,
707 "Can't parse empty Calib NVM sections\n");
708 kfree(data);
709 return NULL;
710 }
711 /* in family 8000 Xtal calibration values moved to OTP */
712 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
713 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
714 lar_enabled = true;
715 ch_section = nvm_sw;
716 } else {
717 u16 lar_offset = data->nvm_version < 0xE39 ?
718 NVM_LAR_OFFSET_FAMILY_8000_OLD :
719 NVM_LAR_OFFSET_FAMILY_8000;
720
721 lar_config = le16_to_cpup(regulatory + lar_offset);
722 data->lar_enabled = !!(lar_config &
723 NVM_LAR_ENABLED_FAMILY_8000);
724 lar_enabled = data->lar_enabled;
725 ch_section = regulatory;
726 }
727
728 /* If no valid mac address was found - bail out */
729 if (iwl_set_hw_address(trans, cfg, data, nvm_hw, mac_override)) {
730 kfree(data);
731 return NULL;
732 }
733
734 iwl_init_sbands(dev, cfg, data, ch_section, tx_chains, rx_chains,
735 lar_fw_supported && lar_enabled);
736 data->calib_version = 255;
737
738 return data;
739 }
740 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
741
742 static u32 iwl_nvm_get_regdom_bw_flags(const u8 *nvm_chan,
743 int ch_idx, u16 nvm_flags,
744 const struct iwl_cfg *cfg)
745 {
746 u32 flags = NL80211_RRF_NO_HT40;
747 u32 last_5ghz_ht = LAST_5GHZ_HT;
748
749 if (cfg->device_family == IWL_DEVICE_FAMILY_8000)
750 last_5ghz_ht = LAST_5GHZ_HT_FAMILY_8000;
751
752 if (ch_idx < NUM_2GHZ_CHANNELS &&
753 (nvm_flags & NVM_CHANNEL_40MHZ)) {
754 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
755 flags &= ~NL80211_RRF_NO_HT40PLUS;
756 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
757 flags &= ~NL80211_RRF_NO_HT40MINUS;
758 } else if (nvm_chan[ch_idx] <= last_5ghz_ht &&
759 (nvm_flags & NVM_CHANNEL_40MHZ)) {
760 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
761 flags &= ~NL80211_RRF_NO_HT40PLUS;
762 else
763 flags &= ~NL80211_RRF_NO_HT40MINUS;
764 }
765
766 if (!(nvm_flags & NVM_CHANNEL_80MHZ))
767 flags |= NL80211_RRF_NO_80MHZ;
768 if (!(nvm_flags & NVM_CHANNEL_160MHZ))
769 flags |= NL80211_RRF_NO_160MHZ;
770
771 if (!(nvm_flags & NVM_CHANNEL_ACTIVE))
772 flags |= NL80211_RRF_NO_IR;
773
774 if (nvm_flags & NVM_CHANNEL_RADAR)
775 flags |= NL80211_RRF_DFS;
776
777 if (nvm_flags & NVM_CHANNEL_INDOOR_ONLY)
778 flags |= NL80211_RRF_NO_OUTDOOR;
779
780 /* Set the GO concurrent flag only in case that NO_IR is set.
781 * Otherwise it is meaningless
782 */
783 if ((nvm_flags & NVM_CHANNEL_GO_CONCURRENT) &&
784 (flags & NL80211_RRF_NO_IR))
785 flags |= NL80211_RRF_GO_CONCURRENT;
786
787 return flags;
788 }
789
790 struct ieee80211_regdomain *
791 iwl_parse_nvm_mcc_info(struct device *dev, const struct iwl_cfg *cfg,
792 int num_of_ch, __le32 *channels, u16 fw_mcc)
793 {
794 int ch_idx;
795 u16 ch_flags, prev_ch_flags = 0;
796 const u8 *nvm_chan = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
797 iwl_nvm_channels_family_8000 : iwl_nvm_channels;
798 struct ieee80211_regdomain *regd;
799 int size_of_regd;
800 struct ieee80211_reg_rule *rule;
801 enum nl80211_band band;
802 int center_freq, prev_center_freq = 0;
803 int valid_rules = 0;
804 bool new_rule;
805 int max_num_ch = cfg->device_family == IWL_DEVICE_FAMILY_8000 ?
806 IWL_NUM_CHANNELS_FAMILY_8000 : IWL_NUM_CHANNELS;
807
808 if (WARN_ON_ONCE(num_of_ch > NL80211_MAX_SUPP_REG_RULES))
809 return ERR_PTR(-EINVAL);
810
811 if (WARN_ON(num_of_ch > max_num_ch))
812 num_of_ch = max_num_ch;
813
814 IWL_DEBUG_DEV(dev, IWL_DL_LAR, "building regdom for %d channels\n",
815 num_of_ch);
816
817 /* build a regdomain rule for every valid channel */
818 size_of_regd =
819 sizeof(struct ieee80211_regdomain) +
820 num_of_ch * sizeof(struct ieee80211_reg_rule);
821
822 regd = kzalloc(size_of_regd, GFP_KERNEL);
823 if (!regd)
824 return ERR_PTR(-ENOMEM);
825
826 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
827 ch_flags = (u16)__le32_to_cpup(channels + ch_idx);
828 band = (ch_idx < NUM_2GHZ_CHANNELS) ?
829 NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
830 center_freq = ieee80211_channel_to_frequency(nvm_chan[ch_idx],
831 band);
832 new_rule = false;
833
834 if (!(ch_flags & NVM_CHANNEL_VALID)) {
835 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
836 "Ch. %d Flags %x [%sGHz] - No traffic\n",
837 nvm_chan[ch_idx],
838 ch_flags,
839 (ch_idx >= NUM_2GHZ_CHANNELS) ?
840 "5.2" : "2.4");
841 continue;
842 }
843
844 /* we can't continue the same rule */
845 if (ch_idx == 0 || prev_ch_flags != ch_flags ||
846 center_freq - prev_center_freq > 20) {
847 valid_rules++;
848 new_rule = true;
849 }
850
851 rule = &regd->reg_rules[valid_rules - 1];
852
853 if (new_rule)
854 rule->freq_range.start_freq_khz =
855 MHZ_TO_KHZ(center_freq - 10);
856
857 rule->freq_range.end_freq_khz = MHZ_TO_KHZ(center_freq + 10);
858
859 /* this doesn't matter - not used by FW */
860 rule->power_rule.max_antenna_gain = DBI_TO_MBI(6);
861 rule->power_rule.max_eirp =
862 DBM_TO_MBM(IWL_DEFAULT_MAX_TX_POWER);
863
864 rule->flags = iwl_nvm_get_regdom_bw_flags(nvm_chan, ch_idx,
865 ch_flags, cfg);
866
867 /* rely on auto-calculation to merge BW of contiguous chans */
868 rule->flags |= NL80211_RRF_AUTO_BW;
869 rule->freq_range.max_bandwidth_khz = 0;
870
871 prev_ch_flags = ch_flags;
872 prev_center_freq = center_freq;
873
874 IWL_DEBUG_DEV(dev, IWL_DL_LAR,
875 "Ch. %d [%sGHz] %s%s%s%s%s%s%s%s%s(0x%02x): Ad-Hoc %ssupported\n",
876 center_freq,
877 band == NL80211_BAND_5GHZ ? "5.2" : "2.4",
878 CHECK_AND_PRINT_I(VALID),
879 CHECK_AND_PRINT_I(ACTIVE),
880 CHECK_AND_PRINT_I(RADAR),
881 CHECK_AND_PRINT_I(WIDE),
882 CHECK_AND_PRINT_I(40MHZ),
883 CHECK_AND_PRINT_I(80MHZ),
884 CHECK_AND_PRINT_I(160MHZ),
885 CHECK_AND_PRINT_I(INDOOR_ONLY),
886 CHECK_AND_PRINT_I(GO_CONCURRENT),
887 ch_flags,
888 ((ch_flags & NVM_CHANNEL_ACTIVE) &&
889 !(ch_flags & NVM_CHANNEL_RADAR))
890 ? "" : "not ");
891 }
892
893 regd->n_reg_rules = valid_rules;
894
895 /* set alpha2 from FW. */
896 regd->alpha2[0] = fw_mcc >> 8;
897 regd->alpha2[1] = fw_mcc & 0xff;
898
899 return regd;
900 }
901 IWL_EXPORT_SYMBOL(iwl_parse_nvm_mcc_info);
Ubuntu Artful kernel mirror