[deliverable/linux.git] / drivers / net / wireless / libertas / fw.c

/**
  * This file contains the initialization for FW and HW
  */
#include <linux/moduleparam.h>
#include <linux/firmware.h>

#include "host.h"
#include "sbi.h"
#include "defs.h"
#include "decl.h"
#include "dev.h"
#include "fw.h"
#include "wext.h"
#include "if_usb.h"

char *libertas_fw_name = NULL;
module_param_named(fw_name, libertas_fw_name, charp, 0644);

/**
 *  @brief This function checks the validity of Boot2/FW image.
 *
 *  @param data              pointer to image
 *         len               image length
 *  @return     0 or -1
 */
static int check_fwfile_format(u8 *data, u32 totlen)
{
	u8  bincmd, exit;
	u32 blksize, offset, len;
	int ret;

	ret = 1;
	exit = len = 0;

	do {
		bincmd = *data;
		blksize = *(u32*)(data + offsetof(struct fwheader, datalength));
		switch (bincmd) {
		case FW_HAS_DATA_TO_RECV:
			offset = sizeof(struct fwheader) + blksize;
			data += offset;
			len += offset;
			if (len >= totlen)
				exit = 1;
			break;
		case FW_HAS_LAST_BLOCK:
			exit = 1;
			ret = 0;
			break;
		default:
			exit = 1;
			break;
		}
	} while (!exit);

	if (ret)
		lbs_pr_err("firmware file format check FAIL\n");
	else
		lbs_deb_fw("firmware file format check PASS\n");

	return ret;
}

/**
 *  @brief This function downloads firmware image, gets
 *  HW spec from firmware and set basic parameters to
 *  firmware.
 *
 *  @param priv    A pointer to wlan_private structure
 *  @return 	   0 or -1
 */
static int wlan_setup_station_hw(wlan_private * priv)
{
	int ret = -1;
	wlan_adapter *adapter = priv->adapter;

	lbs_deb_enter(LBS_DEB_FW);

	if ((ret = request_firmware(&priv->firmware, libertas_fw_name,
				    priv->hotplug_device)) < 0) {
		lbs_pr_err("request_firmware() failed with %#x\n",
		       ret);
		lbs_pr_err("firmware %s not found\n", libertas_fw_name);
		goto done;
	}

	if(check_fwfile_format(priv->firmware->data, priv->firmware->size)) {
		release_firmware(priv->firmware);
		goto done;
	}

	ret = libertas_sbi_prog_firmware(priv);

	release_firmware(priv->firmware);

	if (ret) {
		lbs_deb_fw("bootloader in invalid state\n");
		ret = -1;
		goto done;
	}

	/*
	 * Read MAC address from HW
	 */
	memset(adapter->current_addr, 0xff, ETH_ALEN);

	ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec,
				    0, cmd_option_waitforrsp, 0, NULL);

	if (ret) {
		ret = -1;
		goto done;
	}

	libertas_set_mac_packet_filter(priv);

	/* Get the supported Data rates */
	ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
				    cmd_act_get_tx_rate,
				    cmd_option_waitforrsp, 0, NULL);

	if (ret) {
		ret = -1;
		goto done;
	}

	ret = 0;
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

static int wlan_allocate_adapter(wlan_private * priv)
{
	u32 ulbufsize;
	wlan_adapter *adapter = priv->adapter;

	struct bss_descriptor *ptempscantable;

	/* Allocate buffer to store the BSSID list */
	ulbufsize = sizeof(struct bss_descriptor) * MRVDRV_MAX_BSSID_LIST;
	if (!(ptempscantable = kzalloc(ulbufsize, GFP_KERNEL))) {
		libertas_free_adapter(priv);
		return -1;
	}
	adapter->scantable = ptempscantable;

	/* Allocate the command buffers */
	libertas_allocate_cmd_buffer(priv);

	memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
	adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
	adapter->libertas_ps_confirm_sleep.command =
	    cpu_to_le16(cmd_802_11_ps_mode);
	adapter->libertas_ps_confirm_sleep.size =
	    cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
	adapter->libertas_ps_confirm_sleep.result = 0;
	adapter->libertas_ps_confirm_sleep.action =
	    cpu_to_le16(cmd_subcmd_sleep_confirmed);

	return 0;
}

static void wlan_init_adapter(wlan_private * priv)
{
	wlan_adapter *adapter = priv->adapter;
	int i;

	adapter->scanprobes = 0;

	adapter->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR;
	adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;

	/* ATIM params */
	adapter->atimwindow = 0;

	adapter->connect_status = libertas_disconnected;
	memset(adapter->current_addr, 0xff, ETH_ALEN);

	/* scan type */
	adapter->scantype = cmd_scan_type_active;

	/* scan mode */
	adapter->scanmode = cmd_bss_type_any;

	/* 802.11 specific */
	adapter->secinfo.wep_enabled = 0;
	for (i = 0; i < sizeof(adapter->wep_keys) / sizeof(adapter->wep_keys[0]);
	     i++)
		memset(&adapter->wep_keys[i], 0, sizeof(struct WLAN_802_11_KEY));
	adapter->wep_tx_keyidx = 0;
	adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
	adapter->mode = IW_MODE_INFRA;

	adapter->assoc_req = NULL;

	adapter->numinscantable = 0;
	adapter->pattemptedbssdesc = NULL;
	mutex_init(&adapter->lock);

	adapter->prescan = 1;

	memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams));

	/* PnP and power profile */
	adapter->surpriseremoved = 0;

	adapter->currentpacketfilter =
	    cmd_act_mac_rx_on | cmd_act_mac_tx_on;

	adapter->radioon = RADIO_ON;
	adapter->txantenna = RF_ANTENNA_2;
	adapter->rxantenna = RF_ANTENNA_AUTO;

	adapter->is_datarate_auto = 1;
	adapter->beaconperiod = MRVDRV_BEACON_INTERVAL;

	// set default value of capinfo.
#define SHORT_PREAMBLE_ALLOWED		1
	memset(&adapter->capinfo, 0, sizeof(adapter->capinfo));
	adapter->capinfo.shortpreamble = SHORT_PREAMBLE_ALLOWED;

	adapter->adhocchannel = DEFAULT_AD_HOC_CHANNEL;

	adapter->psmode = wlan802_11powermodecam;
	adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;

	adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;

	adapter->psstate = PS_STATE_FULL_POWER;
	adapter->needtowakeup = 0;
	adapter->locallisteninterval = 0;	/* default value in firmware will be used */

	adapter->datarate = 0;	// Initially indicate the rate as auto

	adapter->adhoc_grate_enabled = 0;

	adapter->intcounter = 0;

	adapter->currenttxskb = NULL;
	adapter->pkttxctrl = 0;

	memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUE*sizeof(struct sk_buff*));
	adapter->tx_queue_idx = 0;
	spin_lock_init(&adapter->txqueue_lock);

	return;
}

static void command_timer_fn(unsigned long data);

int libertas_init_fw(wlan_private * priv)
{
	int ret = -1;
	wlan_adapter *adapter = priv->adapter;

	lbs_deb_enter(LBS_DEB_FW);

	/* Allocate adapter structure */
	if ((ret = wlan_allocate_adapter(priv)) != 0)
		goto done;

	/* init adapter structure */
	wlan_init_adapter(priv);

	/* init timer etc. */
	setup_timer(&adapter->command_timer, command_timer_fn,
			(unsigned long)priv);

	/* download fimrware etc. */
	if ((ret = wlan_setup_station_hw(priv)) != 0) {
		del_timer_sync(&adapter->command_timer);
		goto done;
	}

	/* init 802.11d */
	libertas_init_11d(priv);

	ret = 0;
done:
	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
	return ret;
}

void libertas_free_adapter(wlan_private * priv)
{
	wlan_adapter *adapter = priv->adapter;

	if (!adapter) {
		lbs_deb_fw("why double free adapter?\n");
		return;
	}

	lbs_deb_fw("free command buffer\n");
	libertas_free_cmd_buffer(priv);

	lbs_deb_fw("free command_timer\n");
	del_timer(&adapter->command_timer);

	lbs_deb_fw("free scantable\n");
	if (adapter->scantable) {
		kfree(adapter->scantable);
		adapter->scantable = NULL;
	}

	/* Free the adapter object itself */
	lbs_deb_fw("free adapter\n");
	kfree(adapter);
	priv->adapter = NULL;
}

/**
 *  This function handles the timeout of command sending.
 *  It will re-send the same command again.
 */
static void command_timer_fn(unsigned long data)
{
	wlan_private *priv = (wlan_private *)data;
	wlan_adapter *adapter = priv->adapter;
	struct cmd_ctrl_node *ptempnode;
	struct cmd_ds_command *cmd;
	unsigned long flags;

	ptempnode = adapter->cur_cmd;
	if (ptempnode == NULL) {
		lbs_deb_fw("ptempnode empty\n");
		return;
	}

	cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr;
	if (!cmd) {
		lbs_deb_fw("cmd is NULL\n");
		return;
	}

	lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command);

	if (!adapter->fw_ready)
		return;

	spin_lock_irqsave(&adapter->driver_lock, flags);
	adapter->cur_cmd = NULL;
	spin_unlock_irqrestore(&adapter->driver_lock, flags);

	lbs_deb_fw("re-sending same command because of timeout\n");
	libertas_queue_cmd(adapter, ptempnode, 0);

	wake_up_interruptible(&priv->mainthread.waitq);

	return;
}
Commit	Line	Data
876c9d3a MT	1	/**
	2	* This file contains the initialization for FW and HW
	3	*/
876c9d3a	4	#include <linux/moduleparam.h>
876c9d3a	5	#include <linux/firmware.h>
876c9d3a MT	6
	7	#include "host.h"
	8	#include "sbi.h"
	9	#include "defs.h"
	10	#include "decl.h"
	11	#include "dev.h"
	12	#include "fw.h"
	13	#include "wext.h"
	14	#include "if_usb.h"
	15
	16	char *libertas_fw_name = NULL;
	17	module_param_named(fw_name, libertas_fw_name, charp, 0644);
	18
876c9d3a MT	19	/**
	20	* @brief This function checks the validity of Boot2/FW image.
	21	*
	22	* @param data pointer to image
	23	* len image length
	24	* @return 0 or -1
	25	*/
	26	static int check_fwfile_format(u8 *data, u32 totlen)
	27	{
	28	u8 bincmd, exit;
	29	u32 blksize, offset, len;
	30	int ret;
	31
	32	ret = 1;
	33	exit = len = 0;
	34
	35	do {
	36	bincmd = *data;
	37	blksize = (u32)(data + offsetof(struct fwheader, datalength));
	38	switch (bincmd) {
	39	case FW_HAS_DATA_TO_RECV:
	40	offset = sizeof(struct fwheader) + blksize;
	41	data += offset;
	42	len += offset;
	43	if (len >= totlen)
	44	exit = 1;
	45	break;
	46	case FW_HAS_LAST_BLOCK:
	47	exit = 1;
	48	ret = 0;
	49	break;
	50	default:
	51	exit = 1;
	52	break;
	53	}
	54	} while (!exit);
	55
	56	if (ret)
9012b28a	57	lbs_pr_err("firmware file format check FAIL\n");
876c9d3a	58	else
9012b28a	59	lbs_deb_fw("firmware file format check PASS\n");
876c9d3a MT	60
	61	return ret;
	62	}
	63
	64	/**
	65	* @brief This function downloads firmware image, gets
	66	* HW spec from firmware and set basic parameters to
	67	* firmware.
	68	*
	69	* @param priv A pointer to wlan_private structure
	70	* @return 0 or -1
	71	*/
	72	static int wlan_setup_station_hw(wlan_private * priv)
	73	{
	74	int ret = -1;
	75	wlan_adapter *adapter = priv->adapter;
	76
9012b28a	77	lbs_deb_enter(LBS_DEB_FW);
876c9d3a MT	78
	79	if ((ret = request_firmware(&priv->firmware, libertas_fw_name,
	80	priv->hotplug_device)) < 0) {
9012b28a	81	lbs_pr_err("request_firmware() failed with %#x\n",
876c9d3a	82	ret);
9012b28a	83	lbs_pr_err("firmware %s not found\n", libertas_fw_name);
876c9d3a MT	84	goto done;
	85	}
	86
	87	if(check_fwfile_format(priv->firmware->data, priv->firmware->size)) {
	88	release_firmware(priv->firmware);
	89	goto done;
	90	}
	91
	92	ret = libertas_sbi_prog_firmware(priv);
	93
	94	release_firmware(priv->firmware);
	95
	96	if (ret) {
9012b28a	97	lbs_deb_fw("bootloader in invalid state\n");
876c9d3a MT	98	ret = -1;
	99	goto done;
	100	}
	101
	102	/*
	103	* Read MAC address from HW
	104	*/
	105	memset(adapter->current_addr, 0xff, ETH_ALEN);
	106
	107	ret = libertas_prepare_and_send_command(priv, cmd_get_hw_spec,
	108	0, cmd_option_waitforrsp, 0, NULL);
	109
	110	if (ret) {
	111	ret = -1;
	112	goto done;
	113	}
	114
	115	libertas_set_mac_packet_filter(priv);
	116
	117	/* Get the supported Data rates */
	118	ret = libertas_prepare_and_send_command(priv, cmd_802_11_data_rate,
	119	cmd_act_get_tx_rate,
	120	cmd_option_waitforrsp, 0, NULL);
	121
	122	if (ret) {
	123	ret = -1;
	124	goto done;
	125	}
	126
	127	ret = 0;
	128	done:
9012b28a HS	129	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
9012b28a HS	130	return ret;
876c9d3a MT	131	}
	132
	133	static int wlan_allocate_adapter(wlan_private * priv)
	134	{
	135	u32 ulbufsize;
	136	wlan_adapter *adapter = priv->adapter;
	137
	138	struct bss_descriptor *ptempscantable;
	139
	140	/* Allocate buffer to store the BSSID list */
	141	ulbufsize = sizeof(struct bss_descriptor) * MRVDRV_MAX_BSSID_LIST;
fb3dddf2	142	if (!(ptempscantable = kzalloc(ulbufsize, GFP_KERNEL))) {
876c9d3a MT	143	libertas_free_adapter(priv);
	144	return -1;
	145	}
876c9d3a	146	adapter->scantable = ptempscantable;
876c9d3a MT	147
	148	/* Allocate the command buffers */
	149	libertas_allocate_cmd_buffer(priv);
	150
	151	memset(&adapter->libertas_ps_confirm_sleep, 0, sizeof(struct PS_CMD_ConfirmSleep));
	152	adapter->libertas_ps_confirm_sleep.seqnum = cpu_to_le16(++adapter->seqnum);
	153	adapter->libertas_ps_confirm_sleep.command =
	154	cpu_to_le16(cmd_802_11_ps_mode);
	155	adapter->libertas_ps_confirm_sleep.size =
	156	cpu_to_le16(sizeof(struct PS_CMD_ConfirmSleep));
	157	adapter->libertas_ps_confirm_sleep.result = 0;
	158	adapter->libertas_ps_confirm_sleep.action =
	159	cpu_to_le16(cmd_subcmd_sleep_confirmed);
	160
	161	return 0;
	162	}
	163
	164	static void wlan_init_adapter(wlan_private * priv)
	165	{
	166	wlan_adapter *adapter = priv->adapter;
	167	int i;
	168
	169	adapter->scanprobes = 0;
	170
	171	adapter->bcn_avg_factor = DEFAULT_BCN_AVG_FACTOR;
	172	adapter->data_avg_factor = DEFAULT_DATA_AVG_FACTOR;
	173
	174	/* ATIM params */
	175	adapter->atimwindow = 0;
	176
	177	adapter->connect_status = libertas_disconnected;
	178	memset(adapter->current_addr, 0xff, ETH_ALEN);
	179
	180	/* scan type */
	181	adapter->scantype = cmd_scan_type_active;
	182
	183	/* scan mode */
	184	adapter->scanmode = cmd_bss_type_any;
	185
	186	/* 802.11 specific */
889c05bd	187	adapter->secinfo.wep_enabled = 0;
876c9d3a MT	188	for (i = 0; i < sizeof(adapter->wep_keys) / sizeof(adapter->wep_keys[0]);
	189	i++)
	190	memset(&adapter->wep_keys[i], 0, sizeof(struct WLAN_802_11_KEY));
	191	adapter->wep_tx_keyidx = 0;
6affe785	192	adapter->secinfo.auth_mode = IW_AUTH_ALG_OPEN_SYSTEM;
0dc5a290	193	adapter->mode = IW_MODE_INFRA;
876c9d3a MT	194
	195	adapter->assoc_req = NULL;
	196
	197	adapter->numinscantable = 0;
	198	adapter->pattemptedbssdesc = NULL;
	199	mutex_init(&adapter->lock);
	200
	201	adapter->prescan = 1;
	202
	203	memset(&adapter->curbssparams, 0, sizeof(adapter->curbssparams));
	204
	205	/* PnP and power profile */
	206	adapter->surpriseremoved = 0;
	207
	208	adapter->currentpacketfilter =
	209	cmd_act_mac_rx_on \| cmd_act_mac_tx_on;
	210
	211	adapter->radioon = RADIO_ON;
	212	adapter->txantenna = RF_ANTENNA_2;
	213	adapter->rxantenna = RF_ANTENNA_AUTO;
	214
	215	adapter->is_datarate_auto = 1;
	216	adapter->beaconperiod = MRVDRV_BEACON_INTERVAL;
	217
	218	// set default value of capinfo.
	219	#define SHORT_PREAMBLE_ALLOWED 1
	220	memset(&adapter->capinfo, 0, sizeof(adapter->capinfo));
	221	adapter->capinfo.shortpreamble = SHORT_PREAMBLE_ALLOWED;
	222
	223	adapter->adhocchannel = DEFAULT_AD_HOC_CHANNEL;
	224
	225	adapter->psmode = wlan802_11powermodecam;
	226	adapter->multipledtim = MRVDRV_DEFAULT_MULTIPLE_DTIM;
	227
	228	adapter->listeninterval = MRVDRV_DEFAULT_LISTEN_INTERVAL;
	229
	230	adapter->psstate = PS_STATE_FULL_POWER;
	231	adapter->needtowakeup = 0;
	232	adapter->locallisteninterval = 0; /* default value in firmware will be used */
	233
	234	adapter->datarate = 0; // Initially indicate the rate as auto
	235
	236	adapter->adhoc_grate_enabled = 0;
	237
	238	adapter->intcounter = 0;
	239
	240	adapter->currenttxskb = NULL;
	241	adapter->pkttxctrl = 0;
	242
	243	memset(&adapter->tx_queue_ps, 0, NR_TX_QUEUEsizeof(struct sk_buff));
	244	adapter->tx_queue_idx = 0;
	245	spin_lock_init(&adapter->txqueue_lock);
	246
	247	return;
	248	}
	249
	250	static void command_timer_fn(unsigned long data);
	251
	252	int libertas_init_fw(wlan_private * priv)
	253	{
	254	int ret = -1;
	255	wlan_adapter *adapter = priv->adapter;
	256
9012b28a	257	lbs_deb_enter(LBS_DEB_FW);
876c9d3a MT	258
	259	/* Allocate adapter structure */
	260	if ((ret = wlan_allocate_adapter(priv)) != 0)
	261	goto done;
	262
	263	/* init adapter structure */
	264	wlan_init_adapter(priv);
	265
	266	/* init timer etc. */
	267	setup_timer(&adapter->command_timer, command_timer_fn,
	268	(unsigned long)priv);
	269
	270	/* download fimrware etc. */
	271	if ((ret = wlan_setup_station_hw(priv)) != 0) {
	272	del_timer_sync(&adapter->command_timer);
	273	goto done;
	274	}
	275
	276	/* init 802.11d */
	277	libertas_init_11d(priv);
	278
	279	ret = 0;
	280	done:
9012b28a	281	lbs_deb_leave_args(LBS_DEB_FW, "ret %d", ret);
876c9d3a MT	282	return ret;
	283	}
	284
	285	void libertas_free_adapter(wlan_private * priv)
	286	{
	287	wlan_adapter *adapter = priv->adapter;
	288
	289	if (!adapter) {
9012b28a	290	lbs_deb_fw("why double free adapter?\n");
876c9d3a MT	291	return;
	292	}
	293
9012b28a	294	lbs_deb_fw("free command buffer\n");
876c9d3a MT	295	libertas_free_cmd_buffer(priv);
876c9d3a MT	296
9012b28a	297	lbs_deb_fw("free command_timer\n");
876c9d3a MT	298	del_timer(&adapter->command_timer);
876c9d3a MT	299
9012b28a	300	lbs_deb_fw("free scantable\n");
876c9d3a MT	301	if (adapter->scantable) {
	302	kfree(adapter->scantable);
	303	adapter->scantable = NULL;
	304	}
	305
876c9d3a	306	/* Free the adapter object itself */
9012b28a	307	lbs_deb_fw("free adapter\n");
876c9d3a MT	308	kfree(adapter);
	309	priv->adapter = NULL;
	310	}
	311
	312	/**
	313	* This function handles the timeout of command sending.
	314	* It will re-send the same command again.
	315	*/
	316	static void command_timer_fn(unsigned long data)
	317	{
	318	wlan_private priv = (wlan_private )data;
	319	wlan_adapter *adapter = priv->adapter;
	320	struct cmd_ctrl_node *ptempnode;
	321	struct cmd_ds_command *cmd;
	322	unsigned long flags;
	323
	324	ptempnode = adapter->cur_cmd;
596f2d05	325	if (ptempnode == NULL) {
9012b28a	326	lbs_deb_fw("ptempnode empty\n");
596f2d05 ET	327	return;
	328	}
	329
876c9d3a	330	cmd = (struct cmd_ds_command *)ptempnode->bufvirtualaddr;
596f2d05	331	if (!cmd) {
9012b28a	332	lbs_deb_fw("cmd is NULL\n");
596f2d05 ET	333	return;
596f2d05 ET	334	}
876c9d3a	335
9012b28a	336	lbs_deb_fw("command_timer_fn fired, cmd %x\n", cmd->command);
876c9d3a MT	337
	338	if (!adapter->fw_ready)
	339	return;
	340
876c9d3a MT	341	spin_lock_irqsave(&adapter->driver_lock, flags);
	342	adapter->cur_cmd = NULL;
	343	spin_unlock_irqrestore(&adapter->driver_lock, flags);
	344
9012b28a	345	lbs_deb_fw("re-sending same command because of timeout\n");
876c9d3a MT	346	libertas_queue_cmd(adapter, ptempnode, 0);
	347
	348	wake_up_interruptible(&priv->mainthread.waitq);
	349
	350	return;
	351	}