[deliverable/linux.git] / drivers / net / wireless / iwmc3200wifi / eeprom.c

/*
 * Intel Wireless Multicomm 3200 WiFi driver
 *
 * Copyright (C) 2009 Intel Corporation. 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 of 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.
 *
 *
 * Intel Corporation <ilw@linux.intel.com>
 * Samuel Ortiz <samuel.ortiz@intel.com>
 * Zhu Yi <yi.zhu@intel.com>
 *
 */

#include <linux/kernel.h>

#include "iwm.h"
#include "umac.h"
#include "commands.h"
#include "eeprom.h"

static struct iwm_eeprom_entry eeprom_map[] = {
	[IWM_EEPROM_SIG] =
	{"Signature", IWM_EEPROM_SIG_OFF, IWM_EEPROM_SIG_LEN},

	[IWM_EEPROM_VERSION] =
	{"Version", IWM_EEPROM_VERSION_OFF, IWM_EEPROM_VERSION_LEN},

	[IWM_EEPROM_OEM_HW_VERSION] =
	{"OEM HW version", IWM_EEPROM_OEM_HW_VERSION_OFF,
	 IWM_EEPROM_OEM_HW_VERSION_LEN},

	[IWM_EEPROM_MAC_VERSION] =
	{"MAC version", IWM_EEPROM_MAC_VERSION_OFF, IWM_EEPROM_MAC_VERSION_LEN},

	[IWM_EEPROM_CARD_ID] =
	{"Card ID", IWM_EEPROM_CARD_ID_OFF, IWM_EEPROM_CARD_ID_LEN},

	[IWM_EEPROM_RADIO_CONF] =
	{"Radio config", IWM_EEPROM_RADIO_CONF_OFF, IWM_EEPROM_RADIO_CONF_LEN},

	[IWM_EEPROM_SKU_CAP] =
	{"SKU capabilities", IWM_EEPROM_SKU_CAP_OFF, IWM_EEPROM_SKU_CAP_LEN},

	[IWM_EEPROM_FAT_CHANNELS_CAP] =
	{"HT channels capabilities", IWM_EEPROM_FAT_CHANNELS_CAP_OFF,
	 IWM_EEPROM_FAT_CHANNELS_CAP_LEN},

	[IWM_EEPROM_CALIB_RXIQ_OFFSET] =
	{"RX IQ offset", IWM_EEPROM_CALIB_RXIQ_OFF, IWM_EEPROM_INDIRECT_LEN},

	[IWM_EEPROM_CALIB_RXIQ] =
	{"Calib RX IQ", 0, IWM_EEPROM_CALIB_RXIQ_LEN},
};


static int iwm_eeprom_read(struct iwm_priv *iwm, u8 eeprom_id)
{
	int ret;
	u32 entry_size, chunk_size, data_offset = 0, addr_offset = 0;
	u32 addr;
	struct iwm_udma_wifi_cmd udma_cmd;
	struct iwm_umac_cmd umac_cmd;
	struct iwm_umac_cmd_eeprom_proxy eeprom_cmd;

	if (eeprom_id > (IWM_EEPROM_LAST - 1))
		return -EINVAL;

	entry_size = eeprom_map[eeprom_id].length;

	if (eeprom_id >= IWM_EEPROM_INDIRECT_DATA) {
		/* indirect data */
		u32 off_id = eeprom_id - IWM_EEPROM_INDIRECT_DATA +
			     IWM_EEPROM_INDIRECT_OFFSET;

		eeprom_map[eeprom_id].offset =
			*(u16 *)(iwm->eeprom + eeprom_map[off_id].offset) << 1;
	}

	addr = eeprom_map[eeprom_id].offset;

	udma_cmd.eop = 1;
	udma_cmd.credit_group = 0x4;
	udma_cmd.ra_tid = UMAC_HDI_ACT_TBL_IDX_HOST_CMD;
	udma_cmd.lmac_offset = 0;

	umac_cmd.id = UMAC_CMD_OPCODE_EEPROM_PROXY;
	umac_cmd.resp = 1;

	while (entry_size > 0) {
		chunk_size = min_t(u32, entry_size, IWM_MAX_EEPROM_DATA_LEN);

		eeprom_cmd.hdr.type =
			cpu_to_le32(IWM_UMAC_CMD_EEPROM_TYPE_READ);
		eeprom_cmd.hdr.offset = cpu_to_le32(addr + addr_offset);
		eeprom_cmd.hdr.len = cpu_to_le32(chunk_size);

		ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd,
					    &umac_cmd, &eeprom_cmd,
				     sizeof(struct iwm_umac_cmd_eeprom_proxy));
		if (ret < 0) {
			IWM_ERR(iwm, "Couldn't read eeprom\n");
			return ret;
		}

		ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_EEPROM_PROXY,
				       IWM_SRC_UMAC, 2*HZ);
		if (ret < 0) {
			IWM_ERR(iwm, "Did not get any eeprom answer\n");
			return ret;
		}

		data_offset += chunk_size;
		addr_offset += chunk_size;
		entry_size -= chunk_size;
	}

	return 0;
}

u8 *iwm_eeprom_access(struct iwm_priv *iwm, u8 eeprom_id)
{
	if (!iwm->eeprom)
		return ERR_PTR(-ENODEV);

	return iwm->eeprom + eeprom_map[eeprom_id].offset;
}

int iwm_eeprom_fat_channels(struct iwm_priv *iwm)
{
	struct wiphy *wiphy = iwm_to_wiphy(iwm);
	struct ieee80211_supported_band *band;
	u16 *channels, i;

	channels = (u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_FAT_CHANNELS_CAP);
	if (IS_ERR(channels))
		return PTR_ERR(channels);

	band = wiphy->bands[IEEE80211_BAND_2GHZ];
	band->ht_cap.ht_supported = true;

	for (i = 0; i < IWM_EEPROM_FAT_CHANNELS_24; i++)
		if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
			band->ht_cap.ht_supported = false;

	band = wiphy->bands[IEEE80211_BAND_5GHZ];
	band->ht_cap.ht_supported = true;
	for (i = IWM_EEPROM_FAT_CHANNELS_24; i < IWM_EEPROM_FAT_CHANNELS; i++)
		if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
			band->ht_cap.ht_supported = false;

	return 0;
}

int iwm_eeprom_init(struct iwm_priv *iwm)
{
	int i, ret = 0;
	char name[32];

	iwm->eeprom = kzalloc(IWM_EEPROM_LEN, GFP_KERNEL);
	if (!iwm->eeprom)
		return -ENOMEM;

	for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
		ret = iwm_eeprom_read(iwm, i);
		if (ret < 0) {
			IWM_ERR(iwm, "Couldn't read eeprom entry #%d: %s\n",
				i, eeprom_map[i].name);
			break;
		}
	}

	IWM_DBG_BOOT(iwm, DBG, "EEPROM dump:\n");
	for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
		memset(name, 0, 32);
		sprintf(name, "%s: ", eeprom_map[i].name);

		IWM_HEXDUMP(iwm, DBG, BOOT, name,
			    iwm->eeprom + eeprom_map[i].offset,
			    eeprom_map[i].length);
	}

	return ret;
}

void iwm_eeprom_exit(struct iwm_priv *iwm)
{
	kfree(iwm->eeprom);
}
Commit	Line	Data
bb9f8692 ZY	1	/*
	2	* Intel Wireless Multicomm 3200 WiFi driver
	3	*
	4	* Copyright (C) 2009 Intel Corporation. All rights reserved.
	5	*
	6	* Redistribution and use in source and binary forms, with or without
	7	* modification, are permitted provided that the following conditions
	8	* are met:
	9	*
	10	* * Redistributions of source code must retain the above copyright
	11	* notice, this list of conditions and the following disclaimer.
	12	* * Redistributions in binary form must reproduce the above copyright
	13	* notice, this list of conditions and the following disclaimer in
	14	* the documentation and/or other materials provided with the
	15	* distribution.
	16	* * Neither the name of Intel Corporation nor the names of its
	17	* contributors may be used to endorse or promote products derived
	18	* from this software without specific prior written permission.
	19	*
	20	* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	21	* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	22	* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	23	* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	24	* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	25	* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	26	* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	27	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	28	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	29	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	30	* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	31	*
	32	*
	33	* Intel Corporation <ilw@linux.intel.com>
	34	* Samuel Ortiz <samuel.ortiz@intel.com>
	35	* Zhu Yi <yi.zhu@intel.com>
	36	*
	37	*/
	38
	39	#include <linux/kernel.h>
	40
	41	#include "iwm.h"
	42	#include "umac.h"
	43	#include "commands.h"
	44	#include "eeprom.h"
	45
	46	static struct iwm_eeprom_entry eeprom_map[] = {
	47	[IWM_EEPROM_SIG] =
	48	{"Signature", IWM_EEPROM_SIG_OFF, IWM_EEPROM_SIG_LEN},
	49
	50	[IWM_EEPROM_VERSION] =
	51	{"Version", IWM_EEPROM_VERSION_OFF, IWM_EEPROM_VERSION_LEN},
	52
	53	[IWM_EEPROM_OEM_HW_VERSION] =
	54	{"OEM HW version", IWM_EEPROM_OEM_HW_VERSION_OFF,
	55	IWM_EEPROM_OEM_HW_VERSION_LEN},
	56
	57	[IWM_EEPROM_MAC_VERSION] =
	58	{"MAC version", IWM_EEPROM_MAC_VERSION_OFF, IWM_EEPROM_MAC_VERSION_LEN},
	59
	60	[IWM_EEPROM_CARD_ID] =
	61	{"Card ID", IWM_EEPROM_CARD_ID_OFF, IWM_EEPROM_CARD_ID_LEN},
	62
	63	[IWM_EEPROM_RADIO_CONF] =
	64	{"Radio config", IWM_EEPROM_RADIO_CONF_OFF, IWM_EEPROM_RADIO_CONF_LEN},
65
66	[IWM_EEPROM_SKU_CAP] =
67	{"SKU capabilities", IWM_EEPROM_SKU_CAP_OFF, IWM_EEPROM_SKU_CAP_LEN},
68
902b6667 SO	69	[IWM_EEPROM_FAT_CHANNELS_CAP] =
	70	{"HT channels capabilities", IWM_EEPROM_FAT_CHANNELS_CAP_OFF,
	71	IWM_EEPROM_FAT_CHANNELS_CAP_LEN},
	72
bb9f8692 ZY	73	[IWM_EEPROM_CALIB_RXIQ_OFFSET] =
	74	{"RX IQ offset", IWM_EEPROM_CALIB_RXIQ_OFF, IWM_EEPROM_INDIRECT_LEN},
	75
	76	[IWM_EEPROM_CALIB_RXIQ] =
	77	{"Calib RX IQ", 0, IWM_EEPROM_CALIB_RXIQ_LEN},
	78	};
	79
	80
	81	static int iwm_eeprom_read(struct iwm_priv *iwm, u8 eeprom_id)
	82	{
	83	int ret;
	84	u32 entry_size, chunk_size, data_offset = 0, addr_offset = 0;
	85	u32 addr;
	86	struct iwm_udma_wifi_cmd udma_cmd;
	87	struct iwm_umac_cmd umac_cmd;
	88	struct iwm_umac_cmd_eeprom_proxy eeprom_cmd;
	89
	90	if (eeprom_id > (IWM_EEPROM_LAST - 1))
	91	return -EINVAL;
	92
	93	entry_size = eeprom_map[eeprom_id].length;
	94
	95	if (eeprom_id >= IWM_EEPROM_INDIRECT_DATA) {
	96	/* indirect data */
	97	u32 off_id = eeprom_id - IWM_EEPROM_INDIRECT_DATA +
	98	IWM_EEPROM_INDIRECT_OFFSET;
	99
	100	eeprom_map[eeprom_id].offset =
	101	(u16 )(iwm->eeprom + eeprom_map[off_id].offset) << 1;
	102	}
	103
	104	addr = eeprom_map[eeprom_id].offset;
	105
	106	udma_cmd.eop = 1;
	107	udma_cmd.credit_group = 0x4;
	108	udma_cmd.ra_tid = UMAC_HDI_ACT_TBL_IDX_HOST_CMD;
	109	udma_cmd.lmac_offset = 0;
	110
	111	umac_cmd.id = UMAC_CMD_OPCODE_EEPROM_PROXY;
	112	umac_cmd.resp = 1;
	113
	114	while (entry_size > 0) {
	115	chunk_size = min_t(u32, entry_size, IWM_MAX_EEPROM_DATA_LEN);
	116
	117	eeprom_cmd.hdr.type =
	118	cpu_to_le32(IWM_UMAC_CMD_EEPROM_TYPE_READ);
	119	eeprom_cmd.hdr.offset = cpu_to_le32(addr + addr_offset);
	120	eeprom_cmd.hdr.len = cpu_to_le32(chunk_size);
	121
	122	ret = iwm_hal_send_umac_cmd(iwm, &udma_cmd,
	123	&umac_cmd, &eeprom_cmd,
	124	sizeof(struct iwm_umac_cmd_eeprom_proxy));
	125	if (ret < 0) {
	126	IWM_ERR(iwm, "Couldn't read eeprom\n");
	127	return ret;
	128	}
	129
	130	ret = iwm_notif_handle(iwm, UMAC_CMD_OPCODE_EEPROM_PROXY,
	131	IWM_SRC_UMAC, 2*HZ);
	132	if (ret < 0) {
	133	IWM_ERR(iwm, "Did not get any eeprom answer\n");
	134	return ret;
	135	}
	136
137	data_offset += chunk_size;
138	addr_offset += chunk_size;
139	entry_size -= chunk_size;
140	}
141
142	return 0;
143	}
144
145	u8 iwm_eeprom_access(struct iwm_priv iwm, u8 eeprom_id)
146	{
147	if (!iwm->eeprom)
148	return ERR_PTR(-ENODEV);
149
150	return iwm->eeprom + eeprom_map[eeprom_id].offset;
151	}
152
902b6667 SO	153	int iwm_eeprom_fat_channels(struct iwm_priv *iwm)
	154	{
	155	struct wiphy *wiphy = iwm_to_wiphy(iwm);
	156	struct ieee80211_supported_band *band;
	157	u16 *channels, i;
	158
	159	channels = (u16 *)iwm_eeprom_access(iwm, IWM_EEPROM_FAT_CHANNELS_CAP);
	160	if (IS_ERR(channels))
	161	return PTR_ERR(channels);
	162
	163	band = wiphy->bands[IEEE80211_BAND_2GHZ];
	164	band->ht_cap.ht_supported = true;
	165
	166	for (i = 0; i < IWM_EEPROM_FAT_CHANNELS_24; i++)
	167	if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
	168	band->ht_cap.ht_supported = false;
	169
	170	band = wiphy->bands[IEEE80211_BAND_5GHZ];
	171	band->ht_cap.ht_supported = true;
	172	for (i = IWM_EEPROM_FAT_CHANNELS_24; i < IWM_EEPROM_FAT_CHANNELS; i++)
	173	if (!(channels[i] & IWM_EEPROM_FAT_CHANNEL_ENABLED))
	174	band->ht_cap.ht_supported = false;
	175
	176	return 0;
	177	}
	178
bb9f8692 ZY	179	int iwm_eeprom_init(struct iwm_priv *iwm)
	180	{
	181	int i, ret = 0;
	182	char name[32];
	183
	184	iwm->eeprom = kzalloc(IWM_EEPROM_LEN, GFP_KERNEL);
	185	if (!iwm->eeprom)
	186	return -ENOMEM;
	187
	188	for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
bb9f8692 ZY	189	ret = iwm_eeprom_read(iwm, i);
	190	if (ret < 0) {
	191	IWM_ERR(iwm, "Couldn't read eeprom entry #%d: %s\n",
	192	i, eeprom_map[i].name);
	193	break;
	194	}
	195	}
	196
	197	IWM_DBG_BOOT(iwm, DBG, "EEPROM dump:\n");
	198	for (i = IWM_EEPROM_FIRST; i < IWM_EEPROM_LAST; i++) {
	199	memset(name, 0, 32);
	200	sprintf(name, "%s: ", eeprom_map[i].name);
	201
	202	IWM_HEXDUMP(iwm, DBG, BOOT, name,
	203	iwm->eeprom + eeprom_map[i].offset,
	204	eeprom_map[i].length);
	205	}
	206
	207	return ret;
	208	}
	209
	210	void iwm_eeprom_exit(struct iwm_priv *iwm)
	211	{
	212	kfree(iwm->eeprom);
	213	}