[linux-2.6-block.git] / drivers / net / wireless / iwlwifi / iwl-nvm-parse.c

/******************************************************************************
 *
 * This file is provided under a dual BSD/GPLv2 license.  When using or
 * redistributing this file, you may do so under either license.
 *
 * GPL LICENSE SUMMARY
 *
 * Copyright(c) 2008 - 2013 Intel Corporation. All rights reserved.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of version 2 of the GNU General Public License as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110,
 * USA
 *
 * The full GNU General Public License is included in this distribution
 * in the file called LICENSE.GPL.
 *
 * Contact Information:
 *  Intel Linux Wireless <ilw@linux.intel.com>
 * Intel Corporation, 5200 N.E. Elam Young Parkway, Hillsboro, OR 97124-6497
 *
 * BSD LICENSE
 *
 * Copyright(c) 2005 - 2013 Intel Corporation. All rights reserved.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name Intel Corporation nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *****************************************************************************/
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/export.h>
#include "iwl-modparams.h"
#include "iwl-nvm-parse.h"

/* NVM offsets (in words) definitions */
enum wkp_nvm_offsets {
	/* NVM HW-Section offset (in words) definitions */
	HW_ADDR = 0x15,

/* NVM SW-Section offset (in words) definitions */
	NVM_SW_SECTION = 0x1C0,
	NVM_VERSION = 0,
	RADIO_CFG = 1,
	SKU = 2,
	N_HW_ADDRS = 3,
	NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,

/* NVM calibration section offset (in words) definitions */
	NVM_CALIB_SECTION = 0x2B8,
	XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
};

/* SKU Capabilities (actual values from NVM definition) */
enum nvm_sku_bits {
	NVM_SKU_CAP_BAND_24GHZ	= BIT(0),
	NVM_SKU_CAP_BAND_52GHZ	= BIT(1),
	NVM_SKU_CAP_11N_ENABLE	= BIT(2),
};

/* radio config bits (actual values from NVM definition) */
#define NVM_RF_CFG_DASH_MSK(x)   (x & 0x3)         /* bits 0-1   */
#define NVM_RF_CFG_STEP_MSK(x)   ((x >> 2)  & 0x3) /* bits 2-3   */
#define NVM_RF_CFG_TYPE_MSK(x)   ((x >> 4)  & 0x3) /* bits 4-5   */
#define NVM_RF_CFG_PNUM_MSK(x)   ((x >> 6)  & 0x3) /* bits 6-7   */
#define NVM_RF_CFG_TX_ANT_MSK(x) ((x >> 8)  & 0xF) /* bits 8-11  */
#define NVM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF) /* bits 12-15 */

/*
 * These are the channel numbers in the order that they are stored in the NVM
 */
static const u8 iwl_nvm_channels[] = {
	/* 2.4 GHz */
	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
	/* 5 GHz */
	36, 40, 44 , 48, 52, 56, 60, 64,
	100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
	149, 153, 157, 161, 165
};

#define IWL_NUM_CHANNELS	ARRAY_SIZE(iwl_nvm_channels)
#define NUM_2GHZ_CHANNELS	14
#define FIRST_2GHZ_HT_MINUS	5
#define LAST_2GHZ_HT_PLUS	9
#define LAST_5GHZ_HT		161


/* rate data (static) */
static struct ieee80211_rate iwl_cfg80211_rates[] = {
	{ .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
	{ .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
	{ .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
	{ .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
	  .flags = IEEE80211_RATE_SHORT_PREAMBLE, },
	{ .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
	{ .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
	{ .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
	{ .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
	{ .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
	{ .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
	{ .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
	{ .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
};
#define RATES_24_OFFS	0
#define N_RATES_24	ARRAY_SIZE(iwl_cfg80211_rates)
#define RATES_52_OFFS	4
#define N_RATES_52	(N_RATES_24 - RATES_52_OFFS)

/**
 * enum iwl_nvm_channel_flags - channel flags in NVM
 * @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
 * @NVM_CHANNEL_IBSS: usable as an IBSS channel
 * @NVM_CHANNEL_ACTIVE: active scanning allowed
 * @NVM_CHANNEL_RADAR: radar detection required
 * @NVM_CHANNEL_DFS: dynamic freq selection candidate
 * @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
 * @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
 */
enum iwl_nvm_channel_flags {
	NVM_CHANNEL_VALID = BIT(0),
	NVM_CHANNEL_IBSS = BIT(1),
	NVM_CHANNEL_ACTIVE = BIT(3),
	NVM_CHANNEL_RADAR = BIT(4),
	NVM_CHANNEL_DFS = BIT(7),
	NVM_CHANNEL_WIDE = BIT(8),
	NVM_CHANNEL_40MHZ = BIT(9),
};

#define CHECK_AND_PRINT_I(x)	\
	((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")

static int iwl_init_channel_map(struct device *dev, const struct iwl_cfg *cfg,
				struct iwl_nvm_data *data,
				const __le16 * const nvm_ch_flags)
{
	int ch_idx;
	int n_channels = 0;
	struct ieee80211_channel *channel;
	u16 ch_flags;
	bool is_5ghz;

	for (ch_idx = 0; ch_idx < IWL_NUM_CHANNELS; ch_idx++) {
		ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
		if (!(ch_flags & NVM_CHANNEL_VALID)) {
			IWL_DEBUG_EEPROM(dev,
					 "Ch. %d Flags %x [%sGHz] - No traffic\n",
					 iwl_nvm_channels[ch_idx],
					 ch_flags,
					 (ch_idx >= NUM_2GHZ_CHANNELS) ?
					 "5.2" : "2.4");
			continue;
		}

		channel = &data->channels[n_channels];
		n_channels++;

		channel->hw_value = iwl_nvm_channels[ch_idx];
		channel->band = (ch_idx < NUM_2GHZ_CHANNELS) ?
				IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
		channel->center_freq =
			ieee80211_channel_to_frequency(
				channel->hw_value, channel->band);

		/* TODO: Need to be dependent to the NVM */
		channel->flags = IEEE80211_CHAN_NO_HT40;
		if (ch_idx < NUM_2GHZ_CHANNELS &&
		    (ch_flags & NVM_CHANNEL_40MHZ)) {
			if (iwl_nvm_channels[ch_idx] <= LAST_2GHZ_HT_PLUS)
				channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
			if (iwl_nvm_channels[ch_idx] >= FIRST_2GHZ_HT_MINUS)
				channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
		} else if (iwl_nvm_channels[ch_idx] <= LAST_5GHZ_HT &&
			   (ch_flags & NVM_CHANNEL_40MHZ)) {
			if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
				channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
			else
				channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
		}

		if (!(ch_flags & NVM_CHANNEL_IBSS))
			channel->flags |= IEEE80211_CHAN_NO_IBSS;

		if (!(ch_flags & NVM_CHANNEL_ACTIVE))
			channel->flags |= IEEE80211_CHAN_PASSIVE_SCAN;

		if (ch_flags & NVM_CHANNEL_RADAR)
			channel->flags |= IEEE80211_CHAN_RADAR;

		/* Initialize regulatory-based run-time data */

		/* TODO: read the real value from the NVM */
		channel->max_power = 0;
		is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
		IWL_DEBUG_EEPROM(dev,
				 "Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
				 channel->hw_value,
				 is_5ghz ? "5.2" : "2.4",
				 CHECK_AND_PRINT_I(VALID),
				 CHECK_AND_PRINT_I(IBSS),
				 CHECK_AND_PRINT_I(ACTIVE),
				 CHECK_AND_PRINT_I(RADAR),
				 CHECK_AND_PRINT_I(WIDE),
				 CHECK_AND_PRINT_I(DFS),
				 ch_flags,
				 channel->max_power,
				 ((ch_flags & NVM_CHANNEL_IBSS) &&
				  !(ch_flags & NVM_CHANNEL_RADAR))
					? "" : "not ");
	}

	return n_channels;
}

static void iwl_init_sbands(struct device *dev, const struct iwl_cfg *cfg,
			    struct iwl_nvm_data *data, const __le16 *nvm_sw)
{
	int n_channels = iwl_init_channel_map(dev, cfg, data,
			&nvm_sw[NVM_CHANNELS]);
	int n_used = 0;
	struct ieee80211_supported_band *sband;

	sband = &data->bands[IEEE80211_BAND_2GHZ];
	sband->band = IEEE80211_BAND_2GHZ;
	sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
	sband->n_bitrates = N_RATES_24;
	n_used += iwl_init_sband_channels(data, sband, n_channels,
					  IEEE80211_BAND_2GHZ);
	iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ);

	sband = &data->bands[IEEE80211_BAND_5GHZ];
	sband->band = IEEE80211_BAND_5GHZ;
	sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
	sband->n_bitrates = N_RATES_52;
	n_used += iwl_init_sband_channels(data, sband, n_channels,
					  IEEE80211_BAND_5GHZ);
	iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ);

	if (n_channels != n_used)
		IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
			    n_used, n_channels);
}

struct iwl_nvm_data *
iwl_parse_nvm_data(struct device *dev, const struct iwl_cfg *cfg,
		   const __le16 *nvm_hw, const __le16 *nvm_sw,
		   const __le16 *nvm_calib)
{
	struct iwl_nvm_data *data;
	u8 hw_addr[ETH_ALEN];
	u16 radio_cfg, sku;

	data = kzalloc(sizeof(*data) +
		       sizeof(struct ieee80211_channel) * IWL_NUM_CHANNELS,
		       GFP_KERNEL);
	if (!data)
		return NULL;

	data->nvm_version = le16_to_cpup(nvm_sw + NVM_VERSION);

	radio_cfg = le16_to_cpup(nvm_sw + RADIO_CFG);
	data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
	data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
	data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
	data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
	data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK(radio_cfg);
	data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK(radio_cfg);

	sku = le16_to_cpup(nvm_sw + SKU);
	data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
	data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
	data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
	if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
		data->sku_cap_11n_enable = false;

	/* check overrides (some devices have wrong NVM) */
	if (cfg->valid_tx_ant)
		data->valid_tx_ant = cfg->valid_tx_ant;
	if (cfg->valid_rx_ant)
		data->valid_rx_ant = cfg->valid_rx_ant;

	if (!data->valid_tx_ant || !data->valid_rx_ant) {
		IWL_ERR_DEV(dev, "invalid antennas (0x%x, 0x%x)\n",
			    data->valid_tx_ant, data->valid_rx_ant);
		kfree(data);
		return NULL;
	}

	data->n_hw_addrs = le16_to_cpup(nvm_sw + N_HW_ADDRS);

	data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
	data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);

	/* The byte order is little endian 16 bit, meaning 214365 */
	memcpy(hw_addr, nvm_hw + HW_ADDR, ETH_ALEN);
	data->hw_addr[0] = hw_addr[1];
	data->hw_addr[1] = hw_addr[0];
	data->hw_addr[2] = hw_addr[3];
	data->hw_addr[3] = hw_addr[2];
	data->hw_addr[4] = hw_addr[5];
	data->hw_addr[5] = hw_addr[4];

	iwl_init_sbands(dev, cfg, data, nvm_sw);

	data->calib_version = 255;   /* TODO:
					this value will prevent some checks from
					failing, we need to check if this
					field is still needed, and if it does,
					where is it in the NVM*/

	return data;
}
EXPORT_SYMBOL_GPL(iwl_parse_nvm_data);
Commit	Line	Data
b1e1adfa JB	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 - 2013 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 LICENSE.GPL.
	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 - 2013 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-modparams.h"
66	#include "iwl-nvm-parse.h"
67
68	/* NVM offsets (in words) definitions */
69	enum wkp_nvm_offsets {
70	/* NVM HW-Section offset (in words) definitions */
71	HW_ADDR = 0x15,
72
73	/* NVM SW-Section offset (in words) definitions */
74	NVM_SW_SECTION = 0x1C0,
75	NVM_VERSION = 0,
76	RADIO_CFG = 1,
77	SKU = 2,
78	N_HW_ADDRS = 3,
79	NVM_CHANNELS = 0x1E0 - NVM_SW_SECTION,
80
81	/* NVM calibration section offset (in words) definitions */
82	NVM_CALIB_SECTION = 0x2B8,
83	XTAL_CALIB = 0x316 - NVM_CALIB_SECTION
84	};
85
86	/* SKU Capabilities (actual values from NVM definition) */
87	enum nvm_sku_bits {
88	NVM_SKU_CAP_BAND_24GHZ = BIT(0),
89	NVM_SKU_CAP_BAND_52GHZ = BIT(1),
90	NVM_SKU_CAP_11N_ENABLE = BIT(2),
91	};
92
93	/* radio config bits (actual values from NVM definition) */
94	#define NVM_RF_CFG_DASH_MSK(x) (x & 0x3) /* bits 0-1 */
95	#define NVM_RF_CFG_STEP_MSK(x) ((x >> 2) & 0x3) /* bits 2-3 */
96	#define NVM_RF_CFG_TYPE_MSK(x) ((x >> 4) & 0x3) /* bits 4-5 */
97	#define NVM_RF_CFG_PNUM_MSK(x) ((x >> 6) & 0x3) /* bits 6-7 */
98	#define NVM_RF_CFG_TX_ANT_MSK(x) ((x >> 8) & 0xF) /* bits 8-11 */
99	#define NVM_RF_CFG_RX_ANT_MSK(x) ((x >> 12) & 0xF) /* bits 12-15 */
100
101	/*
102	* These are the channel numbers in the order that they are stored in the NVM
103	*/
104	static const u8 iwl_nvm_channels[] = {
105	/* 2.4 GHz */
106	1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
107	/* 5 GHz */
108	36, 40, 44 , 48, 52, 56, 60, 64,
109	100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144,
110	149, 153, 157, 161, 165
111	};
112
113	#define IWL_NUM_CHANNELS ARRAY_SIZE(iwl_nvm_channels)
114	#define NUM_2GHZ_CHANNELS 14
115	#define FIRST_2GHZ_HT_MINUS 5
116	#define LAST_2GHZ_HT_PLUS 9
117	#define LAST_5GHZ_HT 161
118
119
120	/* rate data (static) */
121	static struct ieee80211_rate iwl_cfg80211_rates[] = {
122	{ .bitrate = 1 * 10, .hw_value = 0, .hw_value_short = 0, },
123	{ .bitrate = 2 * 10, .hw_value = 1, .hw_value_short = 1,
124	.flags = IEEE80211_RATE_SHORT_PREAMBLE, },
125	{ .bitrate = 5.5 * 10, .hw_value = 2, .hw_value_short = 2,
126	.flags = IEEE80211_RATE_SHORT_PREAMBLE, },
127	{ .bitrate = 11 * 10, .hw_value = 3, .hw_value_short = 3,
128	.flags = IEEE80211_RATE_SHORT_PREAMBLE, },
129	{ .bitrate = 6 * 10, .hw_value = 4, .hw_value_short = 4, },
130	{ .bitrate = 9 * 10, .hw_value = 5, .hw_value_short = 5, },
131	{ .bitrate = 12 * 10, .hw_value = 6, .hw_value_short = 6, },
132	{ .bitrate = 18 * 10, .hw_value = 7, .hw_value_short = 7, },
133	{ .bitrate = 24 * 10, .hw_value = 8, .hw_value_short = 8, },
134	{ .bitrate = 36 * 10, .hw_value = 9, .hw_value_short = 9, },
135	{ .bitrate = 48 * 10, .hw_value = 10, .hw_value_short = 10, },
136	{ .bitrate = 54 * 10, .hw_value = 11, .hw_value_short = 11, },
137	};
138	#define RATES_24_OFFS 0
139	#define N_RATES_24 ARRAY_SIZE(iwl_cfg80211_rates)
140	#define RATES_52_OFFS 4
141	#define N_RATES_52 (N_RATES_24 - RATES_52_OFFS)
142
143	/**
144	* enum iwl_nvm_channel_flags - channel flags in NVM
145	* @NVM_CHANNEL_VALID: channel is usable for this SKU/geo
146	* @NVM_CHANNEL_IBSS: usable as an IBSS channel
147	* @NVM_CHANNEL_ACTIVE: active scanning allowed
148	* @NVM_CHANNEL_RADAR: radar detection required
149	* @NVM_CHANNEL_DFS: dynamic freq selection candidate
150	* @NVM_CHANNEL_WIDE: 20 MHz channel okay (?)
151	* @NVM_CHANNEL_40MHZ: 40 MHz channel okay (?)
152	*/
153	enum iwl_nvm_channel_flags {
154	NVM_CHANNEL_VALID = BIT(0),
155	NVM_CHANNEL_IBSS = BIT(1),
156	NVM_CHANNEL_ACTIVE = BIT(3),
157	NVM_CHANNEL_RADAR = BIT(4),
158	NVM_CHANNEL_DFS = BIT(7),
159	NVM_CHANNEL_WIDE = BIT(8),
160	NVM_CHANNEL_40MHZ = BIT(9),
161	};
162
163	#define CHECK_AND_PRINT_I(x) \
164	((ch_flags & NVM_CHANNEL_##x) ? # x " " : "")
165
166	static int iwl_init_channel_map(struct device dev, const struct iwl_cfg cfg,
167	struct iwl_nvm_data *data,
168	const __le16 * const nvm_ch_flags)
169	{
170	int ch_idx;
171	int n_channels = 0;
172	struct ieee80211_channel *channel;
173	u16 ch_flags;
174	bool is_5ghz;
175
176	for (ch_idx = 0; ch_idx < IWL_NUM_CHANNELS; ch_idx++) {
177	ch_flags = __le16_to_cpup(nvm_ch_flags + ch_idx);
178	if (!(ch_flags & NVM_CHANNEL_VALID)) {
179	IWL_DEBUG_EEPROM(dev,
180	"Ch. %d Flags %x [%sGHz] - No traffic\n",
181	iwl_nvm_channels[ch_idx],
182	ch_flags,
183	(ch_idx >= NUM_2GHZ_CHANNELS) ?
184	"5.2" : "2.4");
185	continue;
186	}
187
188	channel = &data->channels[n_channels];
189	n_channels++;
190
191	channel->hw_value = iwl_nvm_channels[ch_idx];
192	channel->band = (ch_idx < NUM_2GHZ_CHANNELS) ?
193	IEEE80211_BAND_2GHZ : IEEE80211_BAND_5GHZ;
194	channel->center_freq =
195	ieee80211_channel_to_frequency(
196	channel->hw_value, channel->band);
197
198	/* TODO: Need to be dependent to the NVM */
199	channel->flags = IEEE80211_CHAN_NO_HT40;
200	if (ch_idx < NUM_2GHZ_CHANNELS &&
201	(ch_flags & NVM_CHANNEL_40MHZ)) {
202	if (iwl_nvm_channels[ch_idx] <= LAST_2GHZ_HT_PLUS)
203	channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
204	if (iwl_nvm_channels[ch_idx] >= FIRST_2GHZ_HT_MINUS)
205	channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
206	} else if (iwl_nvm_channels[ch_idx] <= LAST_5GHZ_HT &&
207	(ch_flags & NVM_CHANNEL_40MHZ)) {
208	if ((ch_idx - NUM_2GHZ_CHANNELS) % 2 == 0)
209	channel->flags &= ~IEEE80211_CHAN_NO_HT40PLUS;
210	else
211	channel->flags &= ~IEEE80211_CHAN_NO_HT40MINUS;
212	}
213
214	if (!(ch_flags & NVM_CHANNEL_IBSS))
215	channel->flags \|= IEEE80211_CHAN_NO_IBSS;
216
217	if (!(ch_flags & NVM_CHANNEL_ACTIVE))
218	channel->flags \|= IEEE80211_CHAN_PASSIVE_SCAN;
219
220	if (ch_flags & NVM_CHANNEL_RADAR)
221	channel->flags \|= IEEE80211_CHAN_RADAR;
222
223	/* Initialize regulatory-based run-time data */
224
225	/* TODO: read the real value from the NVM */
226	channel->max_power = 0;
227	is_5ghz = channel->band == IEEE80211_BAND_5GHZ;
228	IWL_DEBUG_EEPROM(dev,
229	"Ch. %d [%sGHz] %s%s%s%s%s%s(0x%02x %ddBm): Ad-Hoc %ssupported\n",
230	channel->hw_value,
231	is_5ghz ? "5.2" : "2.4",
232	CHECK_AND_PRINT_I(VALID),
233	CHECK_AND_PRINT_I(IBSS),
234	CHECK_AND_PRINT_I(ACTIVE),
235	CHECK_AND_PRINT_I(RADAR),
236	CHECK_AND_PRINT_I(WIDE),
237	CHECK_AND_PRINT_I(DFS),
238	ch_flags,
239	channel->max_power,
240	((ch_flags & NVM_CHANNEL_IBSS) &&
241	!(ch_flags & NVM_CHANNEL_RADAR))
242	? "" : "not ");
243	}
244
245	return n_channels;
246	}
247
248	static void iwl_init_sbands(struct device dev, const struct iwl_cfg cfg,
249	struct iwl_nvm_data data, const __le16 nvm_sw)
250	{
251	int n_channels = iwl_init_channel_map(dev, cfg, data,
252	&nvm_sw[NVM_CHANNELS]);
253	int n_used = 0;
254	struct ieee80211_supported_band *sband;
255
256	sband = &data->bands[IEEE80211_BAND_2GHZ];
257	sband->band = IEEE80211_BAND_2GHZ;
258	sband->bitrates = &iwl_cfg80211_rates[RATES_24_OFFS];
259	sband->n_bitrates = N_RATES_24;
260	n_used += iwl_init_sband_channels(data, sband, n_channels,
261	IEEE80211_BAND_2GHZ);
262	iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_2GHZ);
263
264	sband = &data->bands[IEEE80211_BAND_5GHZ];
265	sband->band = IEEE80211_BAND_5GHZ;
266	sband->bitrates = &iwl_cfg80211_rates[RATES_52_OFFS];
267	sband->n_bitrates = N_RATES_52;
268	n_used += iwl_init_sband_channels(data, sband, n_channels,
269	IEEE80211_BAND_5GHZ);
270	iwl_init_ht_hw_capab(cfg, data, &sband->ht_cap, IEEE80211_BAND_5GHZ);
271
272	if (n_channels != n_used)
273	IWL_ERR_DEV(dev, "NVM: used only %d of %d channels\n",
274	n_used, n_channels);
275	}
276
277	struct iwl_nvm_data *
278	iwl_parse_nvm_data(struct device dev, const struct iwl_cfg cfg,
279	const __le16 nvm_hw, const __le16 nvm_sw,
280	const __le16 *nvm_calib)
281	{
282	struct iwl_nvm_data *data;
283	u8 hw_addr[ETH_ALEN];
284	u16 radio_cfg, sku;
285
286	data = kzalloc(sizeof(*data) +
287	sizeof(struct ieee80211_channel) * IWL_NUM_CHANNELS,
288	GFP_KERNEL);
289	if (!data)
290	return NULL;
291
292	data->nvm_version = le16_to_cpup(nvm_sw + NVM_VERSION);
293
294	radio_cfg = le16_to_cpup(nvm_sw + RADIO_CFG);
295	data->radio_cfg_type = NVM_RF_CFG_TYPE_MSK(radio_cfg);
296	data->radio_cfg_step = NVM_RF_CFG_STEP_MSK(radio_cfg);
297	data->radio_cfg_dash = NVM_RF_CFG_DASH_MSK(radio_cfg);
298	data->radio_cfg_pnum = NVM_RF_CFG_PNUM_MSK(radio_cfg);
299	data->valid_tx_ant = NVM_RF_CFG_TX_ANT_MSK(radio_cfg);
300	data->valid_rx_ant = NVM_RF_CFG_RX_ANT_MSK(radio_cfg);
301
302	sku = le16_to_cpup(nvm_sw + SKU);
303	data->sku_cap_band_24GHz_enable = sku & NVM_SKU_CAP_BAND_24GHZ;
304	data->sku_cap_band_52GHz_enable = sku & NVM_SKU_CAP_BAND_52GHZ;
305	data->sku_cap_11n_enable = sku & NVM_SKU_CAP_11N_ENABLE;
306	if (iwlwifi_mod_params.disable_11n & IWL_DISABLE_HT_ALL)
307	data->sku_cap_11n_enable = false;
308
309	/* check overrides (some devices have wrong NVM) */
310	if (cfg->valid_tx_ant)
311	data->valid_tx_ant = cfg->valid_tx_ant;
312	if (cfg->valid_rx_ant)
313	data->valid_rx_ant = cfg->valid_rx_ant;
314
315	if (!data->valid_tx_ant \|\| !data->valid_rx_ant) {
316	IWL_ERR_DEV(dev, "invalid antennas (0x%x, 0x%x)\n",
317	data->valid_tx_ant, data->valid_rx_ant);
318	kfree(data);
319	return NULL;
320	}
321
322	data->n_hw_addrs = le16_to_cpup(nvm_sw + N_HW_ADDRS);
323
324	data->xtal_calib[0] = *(nvm_calib + XTAL_CALIB);
325	data->xtal_calib[1] = *(nvm_calib + XTAL_CALIB + 1);
326
327	/* The byte order is little endian 16 bit, meaning 214365 */
328	memcpy(hw_addr, nvm_hw + HW_ADDR, ETH_ALEN);
329	data->hw_addr[0] = hw_addr[1];
330	data->hw_addr[1] = hw_addr[0];
331	data->hw_addr[2] = hw_addr[3];
332	data->hw_addr[3] = hw_addr[2];
333	data->hw_addr[4] = hw_addr[5];
334	data->hw_addr[5] = hw_addr[4];
335
336	iwl_init_sbands(dev, cfg, data, nvm_sw);
337
338	data->calib_version = 255; /* TODO:
339	this value will prevent some checks from
340	failing, we need to check if this
341	field is still needed, and if it does,
342	where is it in the NVM*/
343
344	return data;
345	}
346	EXPORT_SYMBOL_GPL(iwl_parse_nvm_data);