projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
net/xfrm/xfrm_output.c: move EXPORT_SYMBOL
[deliverable/linux.git] / drivers / net / wireless / 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 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of version 2 of the GNU General Public License as
12 * published by the Free Software Foundation.
13 *
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
22 * USA
23 *
24 * The full GNU General Public License is included in this distribution
25 * in the file called COPYING.
26 *
27 * Contact Information:
28 * Intel Linux Wireless <ilw@linux.intel.com>
29 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
30 *
31 * BSD LICENSE
32 *
33 * Copyright(c) 2005 - 2014 Intel Corporation. All rights reserved.
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 *
40 * * Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * * Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in
44 * the documentation and/or other materials provided with the
45 * distribution.
46 * * Neither the name Intel Corporation nor the names of its
47 * contributors may be used to endorse or promote products derived
48 * from this software without specific prior written permission.
49 *
50 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
51 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
52 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
53 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
54 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
55 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
56 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
60 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
61 *****************************************************************************/
62 #include <linux/types.h>
63 #include <linux/slab.h>
64 #include <linux/export.h>
65 #include "iwl-drv.h"
66 #include "iwl-modparams.h"
67 #include "iwl-nvm-parse.h"
68
69 /* NVM offsets (in words) definitions */
70 enum wkp_nvm_offsets {
71 /* NVM HW-Section offset (in words) definitions */
72 HW_ADDR = 0x15,
73
74 /* NVM SW-Section offset (in words) definitions */
75 NVM_SW_SECTION = 0x1C0,
76 NVM_VERSION = 0,
77 RADIO_CFG = 1,
78 SKU = 2,
79 N_HW_ADDRS = 3,
80 NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
81
82 /* NVM calibration section offset (in words) definitions */
83 NVM_CALIB_SECTION = 0x2B8,
84 XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
85 };
86
87 enum family_8000_nvm_offsets {
88 /* NVM HW-Section offset (in words) definitions */
89 HW_ADDR0_FAMILY_8000 = 0x12,
90 HW_ADDR1_FAMILY_8000 = 0x16,
91 MAC_ADDRESS_OVERRIDE_FAMILY_8000 = 1,
92
93 /* NVM SW-Section offset (in words) definitions */
94 NVM_SW_SECTION_FAMILY_8000 = 0x1C0,
95 NVM_VERSION_FAMILY_8000 = 0,
96 RADIO_CFG_FAMILY_8000 = 2,
97 SKU_FAMILY_8000 = 4,
98 N_HW_ADDRS_FAMILY_8000 = 5,
99
100 /* NVM REGULATORY -Section offset (in words) definitions */
101 NVM_CHANNELS_FAMILY_8000 = 0,
102
103 /* NVM calibration section offset (in words) definitions */
104 NVM_CALIB_SECTION_FAMILY_8000 = 0x2B8,
105 XTAL_CALIB_FAMILY_8000 = 0x316 - NVM_CALIB_SECTION_FAMILY_8000
106 };
107
108 /* SKU Capabilities (actual values from NVM definition) */
109 enum nvm_sku_bits {
110 NVM_SKU_CAP_BAND_24GHZ = BIT(0),
111 NVM_SKU_CAP_BAND_52GHZ = BIT(1),
112 NVM_SKU_CAP_11N_ENABLE = BIT(2),
113 NVM_SKU_CAP_11AC_ENABLE = BIT(3),
114 };
115
116 /*
117 * These are the channel numbers in the order that they are stored in the NVM
118 */
119 static const u8 iwl_nvm_channels[] = {
120 /* 2.4 GHz */
121 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
122 /* 5 GHz */
123 36, 40, 44 , 48, 52, 56, 60, 64,
124 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
125 149, 153, 157, 161, 165
126 };
127
128 static const u8 iwl_nvm_channels_family_8000[] = {
129 /* 2.4 GHz */
130 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
131 /* 5 GHz */
132 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92,
133 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
134 149, 153, 157, 161, 165, 169, 173, 177, 181
135 };
136
137 #define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
138 #define IWL_NUM_CHANNELS_FAMILY_8000 ARRAY_SIZE(iwl_nvm_channels_family_8000)
139 #define NUM_2GHZ_CHANNELS 14
140 #define FIRST_2GHZ_HT_MINUS 5
141 #define LAST_2GHZ_HT_PLUS 9
142 #define LAST_5GHZ_HT 161
143
144 #define DEFAULT_MAX_TX_POWER 16
145
146 /* rate data (static) */
147 static struct ieee80211_rate iwl_cfg80211_rates[] = {
148 { .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
149 { .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
150 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
151 { .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
152 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
153 { .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
154 .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
155 { .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
156 { .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
157 { .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
158 { .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
159 { .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
160 { .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
161 { .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
162 { .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
163 };
164 #define RATES_24_OFFS 0
165 #define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
166 #define RATES_52_OFFS 4
167 #define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
168
169 /**
170 * enum iwl_nvm_channel_flags - channel flags in NVM
171 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
172 * @NVM_CHANNEL_IBSS: usable as an IBSS channel
173 * @NVM_CHANNEL_ACTIVE: active scanning allowed
174 * @NVM_CHANNEL_RADAR: radar detection required
175 * @NVM_CHANNEL_DFS: dynamic freq selection candidate
176 * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
177 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
178 * @NVM_CHANNEL_80MHZ: 80 MHz channel okay (?)
179 * @NVM_CHANNEL_160MHZ: 160 MHz channel okay (?)
180 */
181 enum iwl_nvm_channel_flags {
182 NVM_CHANNEL_VALID = BIT(0),
183 NVM_CHANNEL_IBSS = BIT(1),
184 NVM_CHANNEL_ACTIVE = BIT(3),
185 NVM_CHANNEL_RADAR = BIT(4),
186 NVM_CHANNEL_DFS = BIT(7),
187 NVM_CHANNEL_WIDE = BIT(8),
188 NVM_CHANNEL_40MHZ = BIT(9),
189 NVM_CHANNEL_80MHZ = BIT(10),
190 NVM_CHANNEL_160MHZ = BIT(11),
191 };
192
193 #define CHECK_AND_PRINT_I(x) \
194 ((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
195
196 static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
197 struct iwl_nvm_data *data,
198 const __le16 * const nvm_ch_flags)
199 {
200 int ch_idx;
201 int n_channels = 0;
202 struct ieee80211_channel *channel;
203 u16 ch_flags;
204 bool is_5ghz;
205 int num_of_ch;
206 const u8 *nvm_chan;
207
208 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
209 num_of_ch = IWL_NUM_CHANNELS;
210 nvm_chan = &iwl_nvm_channels[0];
211 } else {
212 num_of_ch = IWL_NUM_CHANNELS_FAMILY_8000;
213 nvm_chan = &iwl_nvm_channels_family_8000[0];
214 }
215
216 for (ch_idx = 0; ch_idx < num_of_ch; ch_idx++) {
217 ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
218
219 if (ch_idx >= NUM_2GHZ_CHANNELS &&
220 !data->sku_cap_band_52GHz_enable)
221 ch_flags &= ~NVM_CHANNEL_VALID;
222
223 if (!(ch_flags & NVM_CHANNEL_VALID)) {
224 IWL_DEBUG_EEPROM(dev,
225 "Ch. %d Flags %x [%sGHz] - No traffic\n",
226 nvm_chan[ch_idx],
227 ch_flags,
228 (ch_idx >= NUM_2GHZ_CHANNELS) ?
229 "5.2" : "2.4");
230 continue;
231 }
232
233 channel = &data->channels[n_channels];
234 n_channels++;
235
236 channel->hw_value = nvm_chan[ch_idx];
237 channel->band = (ch_idx < NUM_2GHZ_CHANNELS) ?
238 IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
239 channel->center_freq =
240 ieee80211_channel_to_frequency(
241 channel->hw_value, channel->band);
242
243 /* TODO: Need to be dependent to the NVM */
244 channel->flags = IEEE80211_CHAN_NO_HT40;
245 if (ch_idx < NUM_2GHZ_CHANNELS &&
246 (ch_flags & NVM_CHANNEL_40MHZ)) {
247 if (nvm_chan[ch_idx] <= LAST_2GHZ_HT_PLUS)
248 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
249 if (nvm_chan[ch_idx] >= FIRST_2GHZ_HT_MINUS)
250 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
251 } else if (nvm_chan[ch_idx] <= LAST_5GHZ_HT &&
252 (ch_flags & NVM_CHANNEL_40MHZ)) {
253 if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
254 channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
255 else
256 channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
257 }
258 if (!(ch_flags & NVM_CHANNEL_80MHZ))
259 channel->flags |= IEEE80211_CHAN_NO_80MHZ;
260 if (!(ch_flags & NVM_CHANNEL_160MHZ))
261 channel->flags |= IEEE80211_CHAN_NO_160MHZ;
262
263 if (!(ch_flags & NVM_CHANNEL_IBSS))
264 channel->flags |= IEEE80211_CHAN_NO_IR;
265
266 if (!(ch_flags & NVM_CHANNEL_ACTIVE))
267 channel->flags |= IEEE80211_CHAN_NO_IR;
268
269 if (ch_flags & NVM_CHANNEL_RADAR)
270 channel->flags |= IEEE80211_CHAN_RADAR;
271
272 /* Initialize regulatory-based run-time data */
273
274 /*
275 * Default value - highest tx power value. max_power
276 * is not used in mvm, and is used for backwards compatibility
277 */
278 channel->max_power = DEFAULT_MAX_TX_POWER;
279 is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
280 IWL_DEBUG_EEPROM(dev,
281 "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
282 channel->hw_value,
283 is_5ghz ? "5.2" : "2.4",
284 CHECK_AND_PRINT_I(VALID),
285 CHECK_AND_PRINT_I(IBSS),
286 CHECK_AND_PRINT_I(ACTIVE),
287 CHECK_AND_PRINT_I(RADAR),
288 CHECK_AND_PRINT_I(WIDE),
289 CHECK_AND_PRINT_I(DFS),
290 ch_flags,
291 channel->max_power,
292 ((ch_flags & NVM_CHANNEL_IBSS) &&
293 !(ch_flags & NVM_CHANNEL_RADAR))
294 ? "" : "not ");
295 }
296
297 return n_channels;
298 }
299
300 static void iwl_init_vht_hw_capab(const struct iwl_cfg *cfg,
301 struct iwl_nvm_data *data,
302 struct ieee80211_sta_vht_cap *vht_cap,
303 u8 tx_chains, u8 rx_chains)
304 {
305 int num_rx_ants = num_of_ant(rx_chains);
306 int num_tx_ants = num_of_ant(tx_chains);
307
308 vht_cap->vht_supported = true;
309
310 vht_cap->cap = IEEE80211_VHT_CAP_SHORT_GI_80 |
311 IEEE80211_VHT_CAP_RXSTBC_1 |
312 IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE |
313 3 << IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT |
314 7 << IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_SHIFT;
315
316 if (num_tx_ants > 1)
317 vht_cap->cap |= IEEE80211_VHT_CAP_TXSTBC;
318 else
319 vht_cap->cap |= IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
320
321 if (iwlwifi_mod_params.amsdu_size_8K)
322 vht_cap->cap |= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991;
323
324 vht_cap->vht_mcs.rx_mcs_map =
325 cpu_to_le16(IEEE80211_VHT_MCS_SUPPORT_0_9 << 0 |
326 IEEE80211_VHT_MCS_SUPPORT_0_9 << 2 |
327 IEEE80211_VHT_MCS_NOT_SUPPORTED << 4 |
328 IEEE80211_VHT_MCS_NOT_SUPPORTED << 6 |
329 IEEE80211_VHT_MCS_NOT_SUPPORTED << 8 |
330 IEEE80211_VHT_MCS_NOT_SUPPORTED << 10 |
331 IEEE80211_VHT_MCS_NOT_SUPPORTED << 12 |
332 IEEE80211_VHT_MCS_NOT_SUPPORTED << 14);
333
334 if (num_rx_ants == 1 || cfg->rx_with_siso_diversity) {
335 vht_cap->cap |= IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN;
336 /* this works because NOT_SUPPORTED == 3 */
337 vht_cap->vht_mcs.rx_mcs_map |=
338 cpu_to_le16(IEEE80211_VHT_MCS_NOT_SUPPORTED << 2);
339 }
340
341 vht_cap->vht_mcs.tx_mcs_map = vht_cap->vht_mcs.rx_mcs_map;
342 }
343
344 static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
345 struct iwl_nvm_data *data,
346 const __le16 *ch_section, bool enable_vht,
347 u8 tx_chains, u8 rx_chains)
348 {
349 int n_channels;
350 int n_used = 0;
351 struct ieee80211_supported_band *sband;
352
353 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
354 n_channels = iwl_init_channel_map(
355 dev, cfg, data,
356 &ch_section[NVM_CHANNELS]);
357 else
358 n_channels = iwl_init_channel_map(
359 dev, cfg, data,
360 &ch_section[NVM_CHANNELS_FAMILY_8000]);
361
362 sband = &data->bands[IEEE80211_BAND_2GHZ];
363 sband->band = IEEE80211_BAND_2GHZ;
364 sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
365 sband->n_bitrates = N_RATES_24;
366 n_used += iwl_init_sband_channels(data, sband, n_channels,
367 IEEE80211_BAND_2GHZ);
368 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ,
369 tx_chains, rx_chains);
370
371 sband = &data->bands[IEEE80211_BAND_5GHZ];
372 sband->band = IEEE80211_BAND_5GHZ;
373 sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
374 sband->n_bitrates = N_RATES_52;
375 n_used += iwl_init_sband_channels(data, sband, n_channels,
376 IEEE80211_BAND_5GHZ);
377 iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ,
378 tx_chains, rx_chains);
379 if (enable_vht)
380 iwl_init_vht_hw_capab(cfg, data, &sband->vht_cap,
381 tx_chains, rx_chains);
382
383 if (n_channels != n_used)
384 IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
385 n_used, n_channels);
386 }
387
388 static int iwl_get_sku(const struct iwl_cfg *cfg,
389 const __le16 *nvm_sw)
390 {
391 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
392 return le16_to_cpup(nvm_sw + SKU);
393 else
394 return le32_to_cpup((__le32 *)(nvm_sw + SKU_FAMILY_8000));
395 }
396
397 static int iwl_get_nvm_version(const struct iwl_cfg *cfg,
398 const __le16 *nvm_sw)
399 {
400 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
401 return le16_to_cpup(nvm_sw + NVM_VERSION);
402 else
403 return le32_to_cpup((__le32 *)(nvm_sw +
404 NVM_VERSION_FAMILY_8000));
405 }
406
407 static int iwl_get_radio_cfg(const struct iwl_cfg *cfg,
408 const __le16 *nvm_sw)
409 {
410 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
411 return le16_to_cpup(nvm_sw + RADIO_CFG);
412 else
413 return le32_to_cpup((__le32 *)(nvm_sw + RADIO_CFG_FAMILY_8000));
414 }
415
416 #define N_HW_ADDRS_MASK_FAMILY_8000 0xF
417 static int iwl_get_n_hw_addrs(const struct iwl_cfg *cfg,
418 const __le16 *nvm_sw)
419 {
420 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
421 return le16_to_cpup(nvm_sw + N_HW_ADDRS);
422 else
423 return le32_to_cpup((__le32 *)(nvm_sw + N_HW_ADDRS_FAMILY_8000))
424 & N_HW_ADDRS_MASK_FAMILY_8000;
425 }
426
427 static void iwl_set_radio_cfg(const struct iwl_cfg *cfg,
428 struct iwl_nvm_data *data,
429 u32 radio_cfg)
430 {
431 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
432 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
433 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
434 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
435 data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
436 return;
437 }
438
439 /* set the radio configuration for family 8000 */
440 data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK_FAMILY_8000(radio_cfg);
441 data->radio_cfg_step = NVM_RF_CFG_STEP_MSK_FAMILY_8000(radio_cfg);
442 data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK_FAMILY_8000(radio_cfg);
443 data->radio_cfg_pnum = NVM_RF_CFG_FLAVOR_MSK_FAMILY_8000(radio_cfg);
444 }
445
446 static void iwl_set_hw_address(const struct iwl_cfg *cfg,
447 struct iwl_nvm_data *data,
448 const __le16 *nvm_sec)
449 {
450 u8 hw_addr[ETH_ALEN];
451
452 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
453 memcpy(hw_addr, nvm_sec + HW_ADDR, ETH_ALEN);
454 else
455 memcpy(hw_addr, nvm_sec + MAC_ADDRESS_OVERRIDE_FAMILY_8000,
456 ETH_ALEN);
457
458 /* The byte order is little endian 16 bit, meaning 214365 */
459 data->hw_addr[0] = hw_addr[1];
460 data->hw_addr[1] = hw_addr[0];
461 data->hw_addr[2] = hw_addr[3];
462 data->hw_addr[3] = hw_addr[2];
463 data->hw_addr[4] = hw_addr[5];
464 data->hw_addr[5] = hw_addr[4];
465 }
466
467 struct iwl_nvm_data *
468 iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
469 const __le16 *nvm_hw, const __le16 *nvm_sw,
470 const __le16 *nvm_calib, const __le16 *regulatory,
471 const __le16 *mac_override, u8 tx_chains, u8 rx_chains)
472 {
473 struct iwl_nvm_data *data;
474 u32 sku;
475 u32 radio_cfg;
476
477 if (cfg->device_family != IWL_DEVICE_FAMILY_8000)
478 data = kzalloc(sizeof(*data) +
479 sizeof(struct ieee80211_channel) *
480 IWL_NUM_CHANNELS,
481 GFP_KERNEL);
482 else
483 data = kzalloc(sizeof(*data) +
484 sizeof(struct ieee80211_channel) *
485 IWL_NUM_CHANNELS_FAMILY_8000,
486 GFP_KERNEL);
487 if (!data)
488 return NULL;
489
490 data->nvm_version = iwl_get_nvm_version(cfg, nvm_sw);
491
492 radio_cfg = iwl_get_radio_cfg(cfg, nvm_sw);
493 iwl_set_radio_cfg(cfg, data, radio_cfg);
494
495 sku = iwl_get_sku(cfg, nvm_sw);
496 data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
497 data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
498 data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
499 data->sku_cap_11ac_enable = sku & NVM_SKU_CAP_11AC_ENABLE;
500 if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
501 data->sku_cap_11n_enable = false;
502
503 data->n_hw_addrs = iwl_get_n_hw_addrs(cfg, nvm_sw);
504
505 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
506 /* Checking for required sections */
507 if (!nvm_calib) {
508 IWL_ERR_DEV(dev,
509 "Can't parse empty Calib NVM sections\n");
510 kfree(data);
511 return NULL;
512 }
513 /* in family 8000 Xtal calibration values moved to OTP */
514 data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
515 data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
516 }
517
518 if (cfg->device_family != IWL_DEVICE_FAMILY_8000) {
519 iwl_set_hw_address(cfg, data, nvm_hw);
520
521 iwl_init_sbands(dev, cfg, data, nvm_sw,
522 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
523 rx_chains);
524 } else {
525 /* MAC address in family 8000 */
526 iwl_set_hw_address(cfg, data, mac_override);
527
528 iwl_init_sbands(dev, cfg, data, regulatory,
529 sku & NVM_SKU_CAP_11AC_ENABLE, tx_chains,
530 rx_chains);
531 }
532
533 data->calib_version = 255;
534
535 return data;
536 }
537 IWL_EXPORT_SYMBOL(iwl_parse_nvm_data);
Linux kernel - Deliverables
This page took 0.070112 seconds and 5 git commands to generate.