[net-next-2.6.git] / drivers / net / wireless / wl12xx / wl1251_cmd.c

#include "wl1251_cmd.h"

#include <linux/module.h>
#include <linux/slab.h>
#include <linux/crc7.h>

#include "wl1251.h"
#include "wl1251_reg.h"
#include "wl1251_io.h"
#include "wl1251_ps.h"
#include "wl1251_acx.h"

/**
 * send command to firmware
 *
 * @wl: wl struct
 * @id: command id
 * @buf: buffer containing the command, must work with dma
 * @len: length of the buffer
 */
int wl1251_cmd_send(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
	struct wl1251_cmd_header *cmd;
	unsigned long timeout;
	u32 intr;
	int ret = 0;

	cmd = buf;
	cmd->id = id;
	cmd->status = 0;

	WARN_ON(len % 4 != 0);

	wl1251_mem_write(wl, wl->cmd_box_addr, buf, len);

	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);

	timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT);

	intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
	while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) {
		if (time_after(jiffies, timeout)) {
			wl1251_error("command complete timeout");
			ret = -ETIMEDOUT;
			goto out;
		}

		msleep(1);

		intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
	}

	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
			   WL1251_ACX_INTR_CMD_COMPLETE);

out:
	return ret;
}

/**
 * send test command to firmware
 *
 * @wl: wl struct
 * @buf: buffer containing the command, with all headers, must work with dma
 * @len: length of the buffer
 * @answer: is answer needed
 */
int wl1251_cmd_test(struct wl1251 *wl, void *buf, size_t buf_len, u8 answer)
{
	int ret;

	wl1251_debug(DEBUG_CMD, "cmd test");

	ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);

	if (ret < 0) {
		wl1251_warning("TEST command failed");
		return ret;
	}

	if (answer) {
		struct wl1251_command *cmd_answer;

		/*
		 * The test command got in, we can read the answer.
		 * The answer would be a wl1251_command, where the
		 * parameter array contains the actual answer.
		 */
		wl1251_mem_read(wl, wl->cmd_box_addr, buf, buf_len);

		cmd_answer = buf;

		if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
			wl1251_error("TEST command answer error: %d",
				     cmd_answer->header.status);
	}

	return 0;
}

/**
 * read acx from firmware
 *
 * @wl: wl struct
 * @id: acx id
 * @buf: buffer for the response, including all headers, must work with dma
 * @len: lenght of buf
 */
int wl1251_cmd_interrogate(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
	struct acx_header *acx = buf;
	int ret;

	wl1251_debug(DEBUG_CMD, "cmd interrogate");

	acx->id = id;

	/* payload length, does not include any headers */
	acx->len = len - sizeof(*acx);

	ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
	if (ret < 0) {
		wl1251_error("INTERROGATE command failed");
		goto out;
	}

	/* the interrogate command got in, we can read the answer */
	wl1251_mem_read(wl, wl->cmd_box_addr, buf, len);

	acx = buf;
	if (acx->cmd.status != CMD_STATUS_SUCCESS)
		wl1251_error("INTERROGATE command error: %d",
			     acx->cmd.status);

out:
	return ret;
}

/**
 * write acx value to firmware
 *
 * @wl: wl struct
 * @id: acx id
 * @buf: buffer containing acx, including all headers, must work with dma
 * @len: length of buf
 */
int wl1251_cmd_configure(struct wl1251 *wl, u16 id, void *buf, size_t len)
{
	struct acx_header *acx = buf;
	int ret;

	wl1251_debug(DEBUG_CMD, "cmd configure");

	acx->id = id;

	/* payload length, does not include any headers */
	acx->len = len - sizeof(*acx);

	ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
	if (ret < 0) {
		wl1251_warning("CONFIGURE command NOK");
		return ret;
	}

	return 0;
}

int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
		   void *bitmap, u16 bitmap_len, u8 bitmap_control)
{
	struct wl1251_cmd_vbm_update *vbm;
	int ret;

	wl1251_debug(DEBUG_CMD, "cmd vbm");

	vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
	if (!vbm) {
		ret = -ENOMEM;
		goto out;
	}

	/* Count and period will be filled by the target */
	vbm->tim.bitmap_ctrl = bitmap_control;
	if (bitmap_len > PARTIAL_VBM_MAX) {
		wl1251_warning("cmd vbm len is %d B, truncating to %d",
			       bitmap_len, PARTIAL_VBM_MAX);
		bitmap_len = PARTIAL_VBM_MAX;
	}
	memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);
	vbm->tim.identity = identity;
	vbm->tim.length = bitmap_len + 3;

	vbm->len = cpu_to_le16(bitmap_len + 5);

	ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
	if (ret < 0) {
		wl1251_error("VBM command failed");
		goto out;
	}

out:
	kfree(vbm);
	return 0;
}

int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
{
	struct cmd_enabledisable_path *cmd;
	int ret;
	u16 cmd_rx, cmd_tx;

	wl1251_debug(DEBUG_CMD, "cmd data path");

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (!cmd) {
		ret = -ENOMEM;
		goto out;
	}

	cmd->channel = channel;

	if (enable) {
		cmd_rx = CMD_ENABLE_RX;
		cmd_tx = CMD_ENABLE_TX;
	} else {
		cmd_rx = CMD_DISABLE_RX;
		cmd_tx = CMD_DISABLE_TX;
	}

	ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
	if (ret < 0) {
		wl1251_error("rx %s cmd for channel %d failed",
			     enable ? "start" : "stop", channel);
		goto out;
	}

	wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
		     enable ? "start" : "stop", channel);

	ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
	if (ret < 0) {
		wl1251_error("tx %s cmd for channel %d failed",
			     enable ? "start" : "stop", channel);
		return ret;
	}

	wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
		     enable ? "start" : "stop", channel);

out:
	kfree(cmd);
	return ret;
}

int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
		    u16 beacon_interval, u8 dtim_interval)
{
	struct cmd_join *join;
	int ret, i;
	u8 *bssid;

	join = kzalloc(sizeof(*join), GFP_KERNEL);
	if (!join) {
		ret = -ENOMEM;
		goto out;
	}

	wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d",
		     bss_type == BSS_TYPE_IBSS ? " ibss" : "",
		     channel, beacon_interval, dtim_interval);

	/* Reverse order BSSID */
	bssid = (u8 *) &join->bssid_lsb;
	for (i = 0; i < ETH_ALEN; i++)
		bssid[i] = wl->bssid[ETH_ALEN - i - 1];

	join->rx_config_options = wl->rx_config;
	join->rx_filter_options = wl->rx_filter;

	/*
	 * FIXME: disable temporarily all filters because after commit
	 * 9cef8737 "mac80211: fix managed mode BSSID handling" broke
	 * association. The filter logic needs to be implemented properly
	 * and once that is done, this hack can be removed.
	 */
	join->rx_config_options = 0;
	join->rx_filter_options = WL1251_DEFAULT_RX_FILTER;

	join->basic_rate_set = RATE_MASK_1MBPS | RATE_MASK_2MBPS |
		RATE_MASK_5_5MBPS | RATE_MASK_11MBPS;

	join->beacon_interval = beacon_interval;
	join->dtim_interval = dtim_interval;
	join->bss_type = bss_type;
	join->channel = channel;
	join->ctrl = JOIN_CMD_CTRL_TX_FLUSH;

	ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
	if (ret < 0) {
		wl1251_error("failed to initiate cmd join");
		goto out;
	}

out:
	kfree(join);
	return ret;
}

int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
{
	struct wl1251_cmd_ps_params *ps_params = NULL;
	int ret = 0;

	wl1251_debug(DEBUG_CMD, "cmd set ps mode");

	ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
	if (!ps_params) {
		ret = -ENOMEM;
		goto out;
	}

	ps_params->ps_mode = ps_mode;
	ps_params->send_null_data = 1;
	ps_params->retries = 5;
	ps_params->hang_over_period = 128;
	ps_params->null_data_rate = 1; /* 1 Mbps */

	ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
			      sizeof(*ps_params));
	if (ret < 0) {
		wl1251_error("cmd set_ps_mode failed");
		goto out;
	}

out:
	kfree(ps_params);
	return ret;
}

int wl1251_cmd_read_memory(struct wl1251 *wl, u32 addr, void *answer,
			   size_t len)
{
	struct cmd_read_write_memory *cmd;
	int ret = 0;

	wl1251_debug(DEBUG_CMD, "cmd read memory");

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (!cmd) {
		ret = -ENOMEM;
		goto out;
	}

	WARN_ON(len > MAX_READ_SIZE);
	len = min_t(size_t, len, MAX_READ_SIZE);

	cmd->addr = addr;
	cmd->size = len;

	ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
	if (ret < 0) {
		wl1251_error("read memory command failed: %d", ret);
		goto out;
	}

	/* the read command got in, we can now read the answer */
	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));

	if (cmd->header.status != CMD_STATUS_SUCCESS)
		wl1251_error("error in read command result: %d",
			     cmd->header.status);

	memcpy(answer, cmd->value, len);

out:
	kfree(cmd);
	return ret;
}

int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
			    void *buf, size_t buf_len)
{
	struct wl1251_cmd_packet_template *cmd;
	size_t cmd_len;
	int ret = 0;

	wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);

	WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
	buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
	cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);

	cmd = kzalloc(cmd_len, GFP_KERNEL);
	if (!cmd) {
		ret = -ENOMEM;
		goto out;
	}

	cmd->size = cpu_to_le16(buf_len);

	if (buf)
		memcpy(cmd->data, buf, buf_len);

	ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
	if (ret < 0) {
		wl1251_warning("cmd set_template failed: %d", ret);
		goto out;
	}

out:
	kfree(cmd);
	return ret;
}

int wl1251_cmd_scan(struct wl1251 *wl, u8 *ssid, size_t ssid_len,
		    struct ieee80211_channel *channels[],
		    unsigned int n_channels, unsigned int n_probes)
{
	struct wl1251_cmd_scan *cmd;
	int i, ret = 0;

	wl1251_debug(DEBUG_CMD, "cmd scan");

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;

	cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
	cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN |
						    CFG_RX_MGMT_EN |
						    CFG_RX_BCN_EN);
	cmd->params.scan_options = 0;
	cmd->params.num_channels = n_channels;
	cmd->params.num_probe_requests = n_probes;
	cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */
	cmd->params.tid_trigger = 0;

	for (i = 0; i < n_channels; i++) {
		cmd->channels[i].min_duration =
			cpu_to_le32(WL1251_SCAN_MIN_DURATION);
		cmd->channels[i].max_duration =
			cpu_to_le32(WL1251_SCAN_MAX_DURATION);
		memset(&cmd->channels[i].bssid_lsb, 0xff, 4);
		memset(&cmd->channels[i].bssid_msb, 0xff, 2);
		cmd->channels[i].early_termination = 0;
		cmd->channels[i].tx_power_att = 0;
		cmd->channels[i].channel = channels[i]->hw_value;
	}

	cmd->params.ssid_len = ssid_len;
	if (ssid)
		memcpy(cmd->params.ssid, ssid, ssid_len);

	ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd));
	if (ret < 0) {
		wl1251_error("cmd scan failed: %d", ret);
		goto out;
	}

	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));

	if (cmd->header.status != CMD_STATUS_SUCCESS) {
		wl1251_error("cmd scan status wasn't success: %d",
			     cmd->header.status);
		ret = -EIO;
		goto out;
	}

out:
	kfree(cmd);
	return ret;
}

int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)
{
	struct wl1251_cmd_trigger_scan_to *cmd;
	int ret;

	wl1251_debug(DEBUG_CMD, "cmd trigger scan to");

	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	if (!cmd)
		return -ENOMEM;

	cmd->timeout = timeout;

	ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd));
	if (ret < 0) {
		wl1251_error("cmd trigger scan to failed: %d", ret);
		goto out;
	}

out:
	kfree(cmd);
	return ret;
}
Commit	Line	Data
ef2f8d45	1	#include "wl1251_cmd.h"
2f01a1f5 KV	2
2f01a1f5 KV	3	#include <linux/module.h>
5a0e3ad6	4	#include <linux/slab.h>
2f01a1f5	5	#include <linux/crc7.h>
2f01a1f5	6
13674118	7	#include "wl1251.h"
29d904c4	8	#include "wl1251_reg.h"
0764de64	9	#include "wl1251_io.h"
ef2f8d45 KV	10	#include "wl1251_ps.h"
ef2f8d45 KV	11	#include "wl1251_acx.h"
ff25839b KV	12
	13	/**
	14	* send command to firmware
	15	*
	16	* @wl: wl struct
	17	* @id: command id
	18	* @buf: buffer containing the command, must work with dma
	19	* @len: length of the buffer
	20	*/
80301cdc	21	int wl1251_cmd_send(struct wl1251 wl, u16 id, void buf, size_t len)
2f01a1f5	22	{
80301cdc	23	struct wl1251_cmd_header *cmd;
2f01a1f5	24	unsigned long timeout;
2f01a1f5 KV	25	u32 intr;
	26	int ret = 0;
	27
ff25839b KV	28	cmd = buf;
	29	cmd->id = id;
	30	cmd->status = 0;
	31
	32	WARN_ON(len % 4 != 0);
2f01a1f5	33
0764de64	34	wl1251_mem_write(wl, wl->cmd_box_addr, buf, len);
2f01a1f5	35
80301cdc	36	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_TRIG, INTR_TRIG_CMD);
2f01a1f5	37
80301cdc	38	timeout = jiffies + msecs_to_jiffies(WL1251_COMMAND_TIMEOUT);
2f01a1f5	39
80301cdc	40	intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
0e71bb08	41	while (!(intr & WL1251_ACX_INTR_CMD_COMPLETE)) {
2f01a1f5	42	if (time_after(jiffies, timeout)) {
80301cdc	43	wl1251_error("command complete timeout");
2f01a1f5 KV	44	ret = -ETIMEDOUT;
	45	goto out;
	46	}
	47
	48	msleep(1);
	49
80301cdc	50	intr = wl1251_reg_read32(wl, ACX_REG_INTERRUPT_NO_CLEAR);
2f01a1f5 KV	51	}
2f01a1f5 KV	52
80301cdc	53	wl1251_reg_write32(wl, ACX_REG_INTERRUPT_ACK,
0e71bb08	54	WL1251_ACX_INTR_CMD_COMPLETE);
2f01a1f5 KV	55
2f01a1f5 KV	56	out:
2f01a1f5 KV	57	return ret;
	58	}
	59
ff25839b KV	60	/**
	61	* send test command to firmware
	62	*
	63	* @wl: wl struct
6021b289	64	* @buf: buffer containing the command, with all headers, must work with dma
ff25839b KV	65	* @len: length of the buffer
ff25839b KV	66	* @answer: is answer needed
ff25839b	67	*/
80301cdc	68	int wl1251_cmd_test(struct wl1251 wl, void buf, size_t buf_len, u8 answer)
2f01a1f5 KV	69	{
	70	int ret;
	71
80301cdc	72	wl1251_debug(DEBUG_CMD, "cmd test");
2f01a1f5	73
80301cdc	74	ret = wl1251_cmd_send(wl, CMD_TEST, buf, buf_len);
ff25839b	75
2f01a1f5	76	if (ret < 0) {
80301cdc	77	wl1251_warning("TEST command failed");
6021b289	78	return ret;
2f01a1f5 KV	79	}
	80
	81	if (answer) {
80301cdc	82	struct wl1251_command *cmd_answer;
6021b289	83
2f01a1f5 KV	84	/*
2f01a1f5 KV	85	* The test command got in, we can read the answer.
80301cdc	86	* The answer would be a wl1251_command, where the
2f01a1f5 KV	87	* parameter array contains the actual answer.
2f01a1f5 KV	88	*/
0764de64	89	wl1251_mem_read(wl, wl->cmd_box_addr, buf, buf_len);
2f01a1f5	90
6021b289 AK	91	cmd_answer = buf;
	92
	93	if (cmd_answer->header.status != CMD_STATUS_SUCCESS)
80301cdc	94	wl1251_error("TEST command answer error: %d",
6021b289	95	cmd_answer->header.status);
2f01a1f5 KV	96	}
2f01a1f5 KV	97
6021b289	98	return 0;
2f01a1f5 KV	99	}
2f01a1f5 KV	100
ff25839b KV	101	/**
	102	* read acx from firmware
	103	*
	104	* @wl: wl struct
	105	* @id: acx id
	106	* @buf: buffer for the response, including all headers, must work with dma
	107	* @len: lenght of buf
	108	*/
80301cdc	109	int wl1251_cmd_interrogate(struct wl1251 wl, u16 id, void buf, size_t len)
2f01a1f5	110	{
ff25839b	111	struct acx_header *acx = buf;
2f01a1f5 KV	112	int ret;
2f01a1f5 KV	113
80301cdc	114	wl1251_debug(DEBUG_CMD, "cmd interrogate");
2f01a1f5	115
ff25839b	116	acx->id = id;
2f01a1f5	117
ff25839b KV	118	/* payload length, does not include any headers */
	119	acx->len = len - sizeof(*acx);
	120
80301cdc	121	ret = wl1251_cmd_send(wl, CMD_INTERROGATE, acx, sizeof(*acx));
2f01a1f5	122	if (ret < 0) {
80301cdc	123	wl1251_error("INTERROGATE command failed");
ff25839b	124	goto out;
2f01a1f5 KV	125	}
2f01a1f5 KV	126
2f01a1f5	127	/* the interrogate command got in, we can read the answer */
0764de64	128	wl1251_mem_read(wl, wl->cmd_box_addr, buf, len);
2f01a1f5	129
ff25839b KV	130	acx = buf;
ff25839b KV	131	if (acx->cmd.status != CMD_STATUS_SUCCESS)
80301cdc	132	wl1251_error("INTERROGATE command error: %d",
ff25839b	133	acx->cmd.status);
2f01a1f5	134
ff25839b KV	135	out:
ff25839b KV	136	return ret;
2f01a1f5 KV	137	}
2f01a1f5 KV	138
ff25839b KV	139	/**
	140	* write acx value to firmware
	141	*
	142	* @wl: wl struct
	143	* @id: acx id
	144	* @buf: buffer containing acx, including all headers, must work with dma
	145	* @len: length of buf
	146	*/
80301cdc	147	int wl1251_cmd_configure(struct wl1251 wl, u16 id, void buf, size_t len)
2f01a1f5	148	{
ff25839b	149	struct acx_header *acx = buf;
2f01a1f5 KV	150	int ret;
2f01a1f5 KV	151
80301cdc	152	wl1251_debug(DEBUG_CMD, "cmd configure");
2f01a1f5	153
ff25839b KV	154	acx->id = id;
	155
	156	/* payload length, does not include any headers */
	157	acx->len = len - sizeof(*acx);
	158
80301cdc	159	ret = wl1251_cmd_send(wl, CMD_CONFIGURE, acx, len);
2f01a1f5	160	if (ret < 0) {
80301cdc	161	wl1251_warning("CONFIGURE command NOK");
2f01a1f5 KV	162	return ret;
	163	}
	164
	165	return 0;
2f01a1f5 KV	166	}
2f01a1f5 KV	167
80301cdc	168	int wl1251_cmd_vbm(struct wl1251 *wl, u8 identity,
2f01a1f5 KV	169	void *bitmap, u16 bitmap_len, u8 bitmap_control)
2f01a1f5 KV	170	{
80301cdc	171	struct wl1251_cmd_vbm_update *vbm;
2f01a1f5 KV	172	int ret;
2f01a1f5 KV	173
80301cdc	174	wl1251_debug(DEBUG_CMD, "cmd vbm");
2f01a1f5	175
ff25839b KV	176	vbm = kzalloc(sizeof(*vbm), GFP_KERNEL);
	177	if (!vbm) {
	178	ret = -ENOMEM;
	179	goto out;
	180	}
	181
2f01a1f5	182	/* Count and period will be filled by the target */
ff25839b	183	vbm->tim.bitmap_ctrl = bitmap_control;
2f01a1f5	184	if (bitmap_len > PARTIAL_VBM_MAX) {
80301cdc	185	wl1251_warning("cmd vbm len is %d B, truncating to %d",
2f01a1f5 KV	186	bitmap_len, PARTIAL_VBM_MAX);
	187	bitmap_len = PARTIAL_VBM_MAX;
	188	}
ff25839b KV	189	memcpy(vbm->tim.pvb_field, bitmap, bitmap_len);
	190	vbm->tim.identity = identity;
	191	vbm->tim.length = bitmap_len + 3;
2f01a1f5	192
ff25839b	193	vbm->len = cpu_to_le16(bitmap_len + 5);
2f01a1f5	194
80301cdc	195	ret = wl1251_cmd_send(wl, CMD_VBM, vbm, sizeof(*vbm));
2f01a1f5	196	if (ret < 0) {
80301cdc	197	wl1251_error("VBM command failed");
ff25839b	198	goto out;
2f01a1f5 KV	199	}
2f01a1f5 KV	200
ff25839b KV	201	out:
ff25839b KV	202	kfree(vbm);
2f01a1f5 KV	203	return 0;
	204	}
	205
80301cdc	206	int wl1251_cmd_data_path(struct wl1251 *wl, u8 channel, bool enable)
2f01a1f5	207	{
ff25839b	208	struct cmd_enabledisable_path *cmd;
2f01a1f5 KV	209	int ret;
	210	u16 cmd_rx, cmd_tx;
	211
80301cdc	212	wl1251_debug(DEBUG_CMD, "cmd data path");
2f01a1f5	213
ff25839b KV	214	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	215	if (!cmd) {
	216	ret = -ENOMEM;
	217	goto out;
	218	}
	219
	220	cmd->channel = channel;
	221
2f01a1f5 KV	222	if (enable) {
	223	cmd_rx = CMD_ENABLE_RX;
	224	cmd_tx = CMD_ENABLE_TX;
	225	} else {
	226	cmd_rx = CMD_DISABLE_RX;
	227	cmd_tx = CMD_DISABLE_TX;
	228	}
	229
80301cdc	230	ret = wl1251_cmd_send(wl, cmd_rx, cmd, sizeof(*cmd));
2f01a1f5	231	if (ret < 0) {
80301cdc	232	wl1251_error("rx %s cmd for channel %d failed",
2f01a1f5	233	enable ? "start" : "stop", channel);
ff25839b	234	goto out;
2f01a1f5 KV	235	}
2f01a1f5 KV	236
80301cdc	237	wl1251_debug(DEBUG_BOOT, "rx %s cmd channel %d",
2f01a1f5 KV	238	enable ? "start" : "stop", channel);
2f01a1f5 KV	239
80301cdc	240	ret = wl1251_cmd_send(wl, cmd_tx, cmd, sizeof(*cmd));
2f01a1f5	241	if (ret < 0) {
80301cdc	242	wl1251_error("tx %s cmd for channel %d failed",
2f01a1f5 KV	243	enable ? "start" : "stop", channel);
	244	return ret;
	245	}
	246
80301cdc	247	wl1251_debug(DEBUG_BOOT, "tx %s cmd channel %d",
2f01a1f5 KV	248	enable ? "start" : "stop", channel);
2f01a1f5 KV	249
ff25839b KV	250	out:
	251	kfree(cmd);
	252	return ret;
2f01a1f5 KV	253	}
2f01a1f5 KV	254
c88f8754 KV	255	int wl1251_cmd_join(struct wl1251 *wl, u8 bss_type, u8 channel,
c88f8754 KV	256	u16 beacon_interval, u8 dtim_interval)
2f01a1f5	257	{
ff25839b	258	struct cmd_join *join;
2f01a1f5 KV	259	int ret, i;
	260	u8 *bssid;
	261
ff25839b KV	262	join = kzalloc(sizeof(*join), GFP_KERNEL);
	263	if (!join) {
	264	ret = -ENOMEM;
	265	goto out;
	266	}
	267
c88f8754	268	wl1251_debug(DEBUG_CMD, "cmd join%s ch %d %d/%d",
e2fd4611	269	bss_type == BSS_TYPE_IBSS ? " ibss" : "",
c88f8754	270	channel, beacon_interval, dtim_interval);
2f01a1f5 KV	271
2f01a1f5 KV	272	/* Reverse order BSSID */
ff25839b	273	bssid = (u8 *) &join->bssid_lsb;
2f01a1f5 KV	274	for (i = 0; i < ETH_ALEN; i++)
	275	bssid[i] = wl->bssid[ETH_ALEN - i - 1];
	276
ff25839b KV	277	join->rx_config_options = wl->rx_config;
ff25839b KV	278	join->rx_filter_options = wl->rx_filter;
2f01a1f5	279
f26b32ed KV	280	/*
	281	* FIXME: disable temporarily all filters because after commit
	282	* 9cef8737 "mac80211: fix managed mode BSSID handling" broke
	283	* association. The filter logic needs to be implemented properly
	284	* and once that is done, this hack can be removed.
	285	*/
	286	join->rx_config_options = 0;
	287	join->rx_filter_options = WL1251_DEFAULT_RX_FILTER;
	288
ff25839b	289	join->basic_rate_set = RATE_MASK_1MBPS \| RATE_MASK_2MBPS \|
2f01a1f5 KV	290	RATE_MASK_5_5MBPS \| RATE_MASK_11MBPS;
2f01a1f5 KV	291
ff25839b KV	292	join->beacon_interval = beacon_interval;
	293	join->dtim_interval = dtim_interval;
	294	join->bss_type = bss_type;
c88f8754	295	join->channel = channel;
ff25839b	296	join->ctrl = JOIN_CMD_CTRL_TX_FLUSH;
2f01a1f5	297
80301cdc	298	ret = wl1251_cmd_send(wl, CMD_START_JOIN, join, sizeof(*join));
2f01a1f5	299	if (ret < 0) {
80301cdc	300	wl1251_error("failed to initiate cmd join");
ff25839b	301	goto out;
2f01a1f5 KV	302	}
2f01a1f5 KV	303
ff25839b KV	304	out:
	305	kfree(join);
	306	return ret;
2f01a1f5 KV	307	}
2f01a1f5 KV	308
80301cdc	309	int wl1251_cmd_ps_mode(struct wl1251 *wl, u8 ps_mode)
2f01a1f5	310	{
80301cdc	311	struct wl1251_cmd_ps_params *ps_params = NULL;
ff25839b	312	int ret = 0;
2f01a1f5	313
80301cdc	314	wl1251_debug(DEBUG_CMD, "cmd set ps mode");
2f01a1f5	315
ff25839b KV	316	ps_params = kzalloc(sizeof(*ps_params), GFP_KERNEL);
	317	if (!ps_params) {
	318	ret = -ENOMEM;
	319	goto out;
	320	}
	321
	322	ps_params->ps_mode = ps_mode;
	323	ps_params->send_null_data = 1;
	324	ps_params->retries = 5;
	325	ps_params->hang_over_period = 128;
	326	ps_params->null_data_rate = 1; /* 1 Mbps */
2f01a1f5	327
80301cdc	328	ret = wl1251_cmd_send(wl, CMD_SET_PS_MODE, ps_params,
ff25839b	329	sizeof(*ps_params));
2f01a1f5	330	if (ret < 0) {
80301cdc	331	wl1251_error("cmd set_ps_mode failed");
ff25839b	332	goto out;
2f01a1f5 KV	333	}
2f01a1f5 KV	334
ff25839b KV	335	out:
	336	kfree(ps_params);
	337	return ret;
2f01a1f5 KV	338	}
2f01a1f5 KV	339
80301cdc	340	int wl1251_cmd_read_memory(struct wl1251 wl, u32 addr, void answer,
ff25839b	341	size_t len)
2f01a1f5	342	{
ff25839b KV	343	struct cmd_read_write_memory *cmd;
ff25839b KV	344	int ret = 0;
2f01a1f5	345
80301cdc	346	wl1251_debug(DEBUG_CMD, "cmd read memory");
2f01a1f5	347
ff25839b KV	348	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	349	if (!cmd) {
	350	ret = -ENOMEM;
	351	goto out;
	352	}
	353
	354	WARN_ON(len > MAX_READ_SIZE);
	355	len = min_t(size_t, len, MAX_READ_SIZE);
	356
	357	cmd->addr = addr;
	358	cmd->size = len;
2f01a1f5	359
80301cdc	360	ret = wl1251_cmd_send(wl, CMD_READ_MEMORY, cmd, sizeof(*cmd));
2f01a1f5	361	if (ret < 0) {
80301cdc	362	wl1251_error("read memory command failed: %d", ret);
ff25839b	363	goto out;
2f01a1f5 KV	364	}
	365
	366	/* the read command got in, we can now read the answer */
0764de64	367	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
2f01a1f5	368
ff25839b	369	if (cmd->header.status != CMD_STATUS_SUCCESS)
80301cdc	370	wl1251_error("error in read command result: %d",
ff25839b	371	cmd->header.status);
2f01a1f5	372
ff25839b	373	memcpy(answer, cmd->value, len);
2f01a1f5	374
ff25839b KV	375	out:
	376	kfree(cmd);
	377	return ret;
2f01a1f5 KV	378	}
2f01a1f5 KV	379
80301cdc	380	int wl1251_cmd_template_set(struct wl1251 *wl, u16 cmd_id,
2f01a1f5 KV	381	void *buf, size_t buf_len)
2f01a1f5 KV	382	{
80301cdc	383	struct wl1251_cmd_packet_template *cmd;
ff25839b KV	384	size_t cmd_len;
ff25839b KV	385	int ret = 0;
2f01a1f5	386
80301cdc	387	wl1251_debug(DEBUG_CMD, "cmd template %d", cmd_id);
2f01a1f5	388
80301cdc KV	389	WARN_ON(buf_len > WL1251_MAX_TEMPLATE_SIZE);
80301cdc KV	390	buf_len = min_t(size_t, buf_len, WL1251_MAX_TEMPLATE_SIZE);
ff25839b KV	391	cmd_len = ALIGN(sizeof(*cmd) + buf_len, 4);
	392
	393	cmd = kzalloc(cmd_len, GFP_KERNEL);
	394	if (!cmd) {
	395	ret = -ENOMEM;
	396	goto out;
	397	}
	398
	399	cmd->size = cpu_to_le16(buf_len);
2f01a1f5 KV	400
2f01a1f5 KV	401	if (buf)
ff25839b	402	memcpy(cmd->data, buf, buf_len);
2f01a1f5	403
80301cdc	404	ret = wl1251_cmd_send(wl, cmd_id, cmd, cmd_len);
2f01a1f5	405	if (ret < 0) {
80301cdc	406	wl1251_warning("cmd set_template failed: %d", ret);
ff25839b	407	goto out;
2f01a1f5 KV	408	}
2f01a1f5 KV	409
ff25839b KV	410	out:
	411	kfree(cmd);
	412	return ret;
2f01a1f5	413	}
3a98c30f KV	414
3a98c30f KV	415	int wl1251_cmd_scan(struct wl1251 wl, u8 ssid, size_t ssid_len,
dc52f0a8	416	struct ieee80211_channel *channels[],
3a98c30f KV	417	unsigned int n_channels, unsigned int n_probes)
	418	{
	419	struct wl1251_cmd_scan *cmd;
	420	int i, ret = 0;
	421
	422	wl1251_debug(DEBUG_CMD, "cmd scan");
	423
	424	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	425	if (!cmd)
	426	return -ENOMEM;
	427
	428	cmd->params.rx_config_options = cpu_to_le32(CFG_RX_ALL_GOOD);
	429	cmd->params.rx_filter_options = cpu_to_le32(CFG_RX_PRSP_EN \|
	430	CFG_RX_MGMT_EN \|
	431	CFG_RX_BCN_EN);
	432	cmd->params.scan_options = 0;
	433	cmd->params.num_channels = n_channels;
	434	cmd->params.num_probe_requests = n_probes;
	435	cmd->params.tx_rate = cpu_to_le16(1 << 1); /* 2 Mbps */
	436	cmd->params.tid_trigger = 0;
	437
	438	for (i = 0; i < n_channels; i++) {
	439	cmd->channels[i].min_duration =
	440	cpu_to_le32(WL1251_SCAN_MIN_DURATION);
	441	cmd->channels[i].max_duration =
	442	cpu_to_le32(WL1251_SCAN_MAX_DURATION);
	443	memset(&cmd->channels[i].bssid_lsb, 0xff, 4);
	444	memset(&cmd->channels[i].bssid_msb, 0xff, 2);
	445	cmd->channels[i].early_termination = 0;
	446	cmd->channels[i].tx_power_att = 0;
dc52f0a8	447	cmd->channels[i].channel = channels[i]->hw_value;
3a98c30f KV	448	}
	449
	450	cmd->params.ssid_len = ssid_len;
	451	if (ssid)
	452	memcpy(cmd->params.ssid, ssid, ssid_len);
	453
	454	ret = wl1251_cmd_send(wl, CMD_SCAN, cmd, sizeof(*cmd));
	455	if (ret < 0) {
	456	wl1251_error("cmd scan failed: %d", ret);
	457	goto out;
	458	}
	459
	460	wl1251_mem_read(wl, wl->cmd_box_addr, cmd, sizeof(*cmd));
	461
	462	if (cmd->header.status != CMD_STATUS_SUCCESS) {
	463	wl1251_error("cmd scan status wasn't success: %d",
	464	cmd->header.status);
	465	ret = -EIO;
	466	goto out;
	467	}
	468
	469	out:
	470	kfree(cmd);
	471	return ret;
	472	}
	473
	474	int wl1251_cmd_trigger_scan_to(struct wl1251 *wl, u32 timeout)
	475	{
	476	struct wl1251_cmd_trigger_scan_to *cmd;
	477	int ret;
	478
	479	wl1251_debug(DEBUG_CMD, "cmd trigger scan to");
	480
	481	cmd = kzalloc(sizeof(*cmd), GFP_KERNEL);
	482	if (!cmd)
	483	return -ENOMEM;
	484
	485	cmd->timeout = timeout;
	486
fe0dbcc9	487	ret = wl1251_cmd_send(wl, CMD_TRIGGER_SCAN_TO, cmd, sizeof(*cmd));
3a98c30f KV	488	if (ret < 0) {
	489	wl1251_error("cmd trigger scan to failed: %d", ret);
	490	goto out;
	491	}
	492
	493	out:
	494	kfree(cmd);
	495	return ret;
	496	}