2011-04-27 06:25:29 +08:00
|
|
|
/*
|
|
|
|
* This file contains the handling of command.
|
|
|
|
* It prepares command and sends it to firmware when it is ready.
|
|
|
|
*/
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2011-06-06 18:43:46 +08:00
|
|
|
#include <linux/hardirq.h>
|
2008-04-01 20:50:43 +08:00
|
|
|
#include <linux/kfifo.h>
|
2009-10-22 21:30:58 +08:00
|
|
|
#include <linux/sched.h>
|
include cleanup: Update gfp.h and slab.h includes to prepare for breaking implicit slab.h inclusion from percpu.h
percpu.h is included by sched.h and module.h and thus ends up being
included when building most .c files. percpu.h includes slab.h which
in turn includes gfp.h making everything defined by the two files
universally available and complicating inclusion dependencies.
percpu.h -> slab.h dependency is about to be removed. Prepare for
this change by updating users of gfp and slab facilities include those
headers directly instead of assuming availability. As this conversion
needs to touch large number of source files, the following script is
used as the basis of conversion.
http://userweb.kernel.org/~tj/misc/slabh-sweep.py
The script does the followings.
* Scan files for gfp and slab usages and update includes such that
only the necessary includes are there. ie. if only gfp is used,
gfp.h, if slab is used, slab.h.
* When the script inserts a new include, it looks at the include
blocks and try to put the new include such that its order conforms
to its surrounding. It's put in the include block which contains
core kernel includes, in the same order that the rest are ordered -
alphabetical, Christmas tree, rev-Xmas-tree or at the end if there
doesn't seem to be any matching order.
* If the script can't find a place to put a new include (mostly
because the file doesn't have fitting include block), it prints out
an error message indicating which .h file needs to be added to the
file.
The conversion was done in the following steps.
1. The initial automatic conversion of all .c files updated slightly
over 4000 files, deleting around 700 includes and adding ~480 gfp.h
and ~3000 slab.h inclusions. The script emitted errors for ~400
files.
2. Each error was manually checked. Some didn't need the inclusion,
some needed manual addition while adding it to implementation .h or
embedding .c file was more appropriate for others. This step added
inclusions to around 150 files.
3. The script was run again and the output was compared to the edits
from #2 to make sure no file was left behind.
4. Several build tests were done and a couple of problems were fixed.
e.g. lib/decompress_*.c used malloc/free() wrappers around slab
APIs requiring slab.h to be added manually.
5. The script was run on all .h files but without automatically
editing them as sprinkling gfp.h and slab.h inclusions around .h
files could easily lead to inclusion dependency hell. Most gfp.h
inclusion directives were ignored as stuff from gfp.h was usually
wildly available and often used in preprocessor macros. Each
slab.h inclusion directive was examined and added manually as
necessary.
6. percpu.h was updated not to include slab.h.
7. Build test were done on the following configurations and failures
were fixed. CONFIG_GCOV_KERNEL was turned off for all tests (as my
distributed build env didn't work with gcov compiles) and a few
more options had to be turned off depending on archs to make things
build (like ipr on powerpc/64 which failed due to missing writeq).
* x86 and x86_64 UP and SMP allmodconfig and a custom test config.
* powerpc and powerpc64 SMP allmodconfig
* sparc and sparc64 SMP allmodconfig
* ia64 SMP allmodconfig
* s390 SMP allmodconfig
* alpha SMP allmodconfig
* um on x86_64 SMP allmodconfig
8. percpu.h modifications were reverted so that it could be applied as
a separate patch and serve as bisection point.
Given the fact that I had only a couple of failures from tests on step
6, I'm fairly confident about the coverage of this conversion patch.
If there is a breakage, it's likely to be something in one of the arch
headers which should be easily discoverable easily on most builds of
the specific arch.
Signed-off-by: Tejun Heo <tj@kernel.org>
Guess-its-ok-by: Christoph Lameter <cl@linux-foundation.org>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Lee Schermerhorn <Lee.Schermerhorn@hp.com>
2010-03-24 16:04:11 +08:00
|
|
|
#include <linux/slab.h>
|
2010-07-28 03:54:34 +08:00
|
|
|
#include <linux/if_arp.h>
|
2011-05-28 04:14:23 +08:00
|
|
|
#include <linux/export.h>
|
2009-10-22 21:30:58 +08:00
|
|
|
|
2007-02-10 22:25:27 +08:00
|
|
|
#include "decl.h"
|
2010-06-15 00:31:26 +08:00
|
|
|
#include "cfg.h"
|
2007-12-12 01:42:16 +08:00
|
|
|
#include "cmd.h"
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 03:55:21 +08:00
|
|
|
#define CAL_NF(nf) ((s32)(-(s32)(nf)))
|
|
|
|
#define CAL_RSSI(snr, nf) ((s32)((s32)(snr) + CAL_NF(nf)))
|
2009-10-22 21:30:58 +08:00
|
|
|
|
2008-03-19 17:11:00 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_cmd_copyback - Simple callback that copies response back into command
|
2008-03-19 17:11:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @extra: A pointer to the original command structure for which
|
|
|
|
* 'resp' is a response
|
|
|
|
* @resp: A pointer to the command response
|
2008-03-19 17:11:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2008-03-19 17:11:00 +08:00
|
|
|
*/
|
|
|
|
int lbs_cmd_copyback(struct lbs_private *priv, unsigned long extra,
|
|
|
|
struct cmd_header *resp)
|
|
|
|
{
|
|
|
|
struct cmd_header *buf = (void *)extra;
|
|
|
|
uint16_t copy_len;
|
|
|
|
|
|
|
|
copy_len = min(le16_to_cpu(buf->size), le16_to_cpu(resp->size));
|
|
|
|
memcpy(buf, resp, copy_len);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(lbs_cmd_copyback);
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_cmd_async_callback - Simple callback that ignores the result.
|
|
|
|
* Use this if you just want to send a command to the hardware, but don't
|
2008-03-19 17:11:00 +08:00
|
|
|
* care for the result.
|
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: ignored
|
|
|
|
* @extra: ignored
|
|
|
|
* @resp: ignored
|
2008-03-19 17:11:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 for success
|
2008-03-19 17:11:00 +08:00
|
|
|
*/
|
|
|
|
static int lbs_cmd_async_callback(struct lbs_private *priv, unsigned long extra,
|
|
|
|
struct cmd_header *resp)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2007-02-10 22:25:27 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* is_command_allowed_in_ps - tests if a command is allowed in Power Save mode
|
|
|
|
*
|
|
|
|
* @cmd: the command ID
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 1 if allowed, 0 if not allowed
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2007-12-11 04:24:47 +08:00
|
|
|
static u8 is_command_allowed_in_ps(u16 cmd)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-11 04:24:47 +08:00
|
|
|
switch (cmd) {
|
|
|
|
case CMD_802_11_RSSI:
|
|
|
|
return 1;
|
2010-05-19 18:24:38 +08:00
|
|
|
case CMD_802_11_HOST_SLEEP_CFG:
|
|
|
|
return 1;
|
2007-12-11 04:24:47 +08:00
|
|
|
default:
|
|
|
|
break;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2007-12-12 01:42:16 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_update_hw_spec - Updates the hardware details like MAC address
|
|
|
|
* and regulatory region
|
2007-12-12 01:42:16 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
2007-12-12 01:42:16 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2007-12-12 01:42:16 +08:00
|
|
|
*/
|
|
|
|
int lbs_update_hw_spec(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-12 01:42:16 +08:00
|
|
|
struct cmd_ds_get_hw_spec cmd;
|
|
|
|
int ret = -1;
|
|
|
|
u32 i;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 01:42:16 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
memcpy(cmd.permanentaddr, priv->current_addr, ETH_ALEN);
|
2007-12-13 05:00:42 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_GET_HW_SPEC, &cmd);
|
2007-12-12 01:42:16 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
priv->fwcapinfo = le32_to_cpu(cmd.fwcapinfo);
|
|
|
|
|
2008-01-16 22:55:22 +08:00
|
|
|
/* The firmware release is in an interesting format: the patch
|
|
|
|
* level is in the most significant nibble ... so fix that: */
|
|
|
|
priv->fwrelease = le32_to_cpu(cmd.fwrelease);
|
|
|
|
priv->fwrelease = (priv->fwrelease << 8) |
|
|
|
|
(priv->fwrelease >> 24 & 0xff);
|
|
|
|
|
|
|
|
/* Some firmware capabilities:
|
|
|
|
* CF card firmware 5.0.16p0: cap 0x00000303
|
|
|
|
* USB dongle firmware 5.110.17p2: cap 0x00000303
|
|
|
|
*/
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev, "%pM, fw %u.%u.%up%u, cap 0x%08x\n",
|
2008-10-28 06:59:26 +08:00
|
|
|
cmd.permanentaddr,
|
2008-01-16 22:55:22 +08:00
|
|
|
priv->fwrelease >> 24 & 0xff,
|
|
|
|
priv->fwrelease >> 16 & 0xff,
|
|
|
|
priv->fwrelease >> 8 & 0xff,
|
|
|
|
priv->fwrelease & 0xff,
|
|
|
|
priv->fwcapinfo);
|
2007-12-12 01:42:16 +08:00
|
|
|
lbs_deb_cmd("GET_HW_SPEC: hardware interface 0x%x, hardware spec 0x%04x\n",
|
|
|
|
cmd.hwifversion, cmd.version);
|
|
|
|
|
|
|
|
/* Clamp region code to 8-bit since FW spec indicates that it should
|
|
|
|
* only ever be 8-bit, even though the field size is 16-bit. Some firmware
|
|
|
|
* returns non-zero high 8 bits here.
|
2009-07-17 01:19:53 +08:00
|
|
|
*
|
|
|
|
* Firmware version 4.0.102 used in CF8381 has region code shifted. We
|
|
|
|
* need to check for this problem and handle it properly.
|
2007-12-12 01:42:16 +08:00
|
|
|
*/
|
2009-07-17 01:19:53 +08:00
|
|
|
if (MRVL_FW_MAJOR_REV(priv->fwrelease) == MRVL_FW_V4)
|
|
|
|
priv->regioncode = (le16_to_cpu(cmd.regioncode) >> 8) & 0xFF;
|
|
|
|
else
|
|
|
|
priv->regioncode = le16_to_cpu(cmd.regioncode) & 0xFF;
|
2007-12-12 01:42:16 +08:00
|
|
|
|
|
|
|
for (i = 0; i < MRVDRV_MAX_REGION_CODE; i++) {
|
|
|
|
/* use the region code to search for the index */
|
|
|
|
if (priv->regioncode == lbs_region_code_to_index[i])
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* if it's unidentified region code, use the default (USA) */
|
|
|
|
if (i >= MRVDRV_MAX_REGION_CODE) {
|
|
|
|
priv->regioncode = 0x10;
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev,
|
|
|
|
"unidentified region code; using the default (USA)\n");
|
2007-12-12 01:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->current_addr[0] == 0xff)
|
|
|
|
memmove(priv->current_addr, cmd.permanentaddr, ETH_ALEN);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2011-01-22 04:44:49 +08:00
|
|
|
if (!priv->copied_hwaddr) {
|
|
|
|
memcpy(priv->dev->dev_addr, priv->current_addr, ETH_ALEN);
|
|
|
|
if (priv->mesh_dev)
|
|
|
|
memcpy(priv->mesh_dev->dev_addr,
|
|
|
|
priv->current_addr, ETH_ALEN);
|
|
|
|
priv->copied_hwaddr = 1;
|
|
|
|
}
|
2007-12-12 01:42:16 +08:00
|
|
|
|
|
|
|
out:
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
2007-12-12 01:42:16 +08:00
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2010-05-19 18:24:38 +08:00
|
|
|
static int lbs_ret_host_sleep_cfg(struct lbs_private *priv, unsigned long dummy,
|
|
|
|
struct cmd_header *resp)
|
|
|
|
{
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2010-07-08 09:13:48 +08:00
|
|
|
if (priv->is_host_sleep_activated) {
|
2010-05-19 18:24:38 +08:00
|
|
|
priv->is_host_sleep_configured = 0;
|
|
|
|
if (priv->psstate == PS_STATE_FULL_POWER) {
|
|
|
|
priv->is_host_sleep_activated = 0;
|
|
|
|
wake_up_interruptible(&priv->host_sleep_q);
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
priv->is_host_sleep_configured = 1;
|
|
|
|
}
|
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2008-10-21 07:46:56 +08:00
|
|
|
int lbs_host_sleep_cfg(struct lbs_private *priv, uint32_t criteria,
|
|
|
|
struct wol_config *p_wol_config)
|
2007-12-13 04:19:29 +08:00
|
|
|
{
|
|
|
|
struct cmd_ds_host_sleep cmd_config;
|
|
|
|
int ret;
|
|
|
|
|
2010-10-31 21:40:33 +08:00
|
|
|
/*
|
|
|
|
* Certain firmware versions do not support EHS_REMOVE_WAKEUP command
|
|
|
|
* and the card will return a failure. Since we need to be
|
|
|
|
* able to reset the mask, in those cases we set a 0 mask instead.
|
|
|
|
*/
|
|
|
|
if (criteria == EHS_REMOVE_WAKEUP && !priv->ehs_remove_supported)
|
|
|
|
criteria = 0;
|
|
|
|
|
2007-12-15 16:46:44 +08:00
|
|
|
cmd_config.hdr.size = cpu_to_le16(sizeof(cmd_config));
|
2007-12-13 04:19:29 +08:00
|
|
|
cmd_config.criteria = cpu_to_le32(criteria);
|
2007-12-13 09:06:06 +08:00
|
|
|
cmd_config.gpio = priv->wol_gpio;
|
|
|
|
cmd_config.gap = priv->wol_gap;
|
2007-12-13 04:19:29 +08:00
|
|
|
|
2008-10-21 07:46:56 +08:00
|
|
|
if (p_wol_config != NULL)
|
|
|
|
memcpy((uint8_t *)&cmd_config.wol_conf, (uint8_t *)p_wol_config,
|
|
|
|
sizeof(struct wol_config));
|
|
|
|
else
|
|
|
|
cmd_config.wol_conf.action = CMD_ACT_ACTION_NONE;
|
|
|
|
|
2010-05-19 18:24:38 +08:00
|
|
|
ret = __lbs_cmd(priv, CMD_802_11_HOST_SLEEP_CFG, &cmd_config.hdr,
|
|
|
|
le16_to_cpu(cmd_config.hdr.size),
|
|
|
|
lbs_ret_host_sleep_cfg, 0);
|
2007-12-13 09:06:06 +08:00
|
|
|
if (!ret) {
|
2010-05-19 18:24:38 +08:00
|
|
|
if (p_wol_config)
|
2008-10-21 07:46:56 +08:00
|
|
|
memcpy((uint8_t *) p_wol_config,
|
|
|
|
(uint8_t *)&cmd_config.wol_conf,
|
|
|
|
sizeof(struct wol_config));
|
2007-12-13 09:06:06 +08:00
|
|
|
} else {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev, "HOST_SLEEP_CFG failed %d\n", ret);
|
2007-12-13 04:19:29 +08:00
|
|
|
}
|
2007-12-13 09:06:06 +08:00
|
|
|
|
2007-12-13 04:19:29 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(lbs_host_sleep_cfg);
|
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_ps_mode - Sets the Power Save mode
|
2010-07-28 04:08:08 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @cmd_action: The Power Save operation (PS_MODE_ACTION_ENTER_PS or
|
2010-07-28 04:08:08 +08:00
|
|
|
* PS_MODE_ACTION_EXIT_PS)
|
2011-04-27 06:25:29 +08:00
|
|
|
* @block: Whether to block on a response or not
|
2010-07-28 04:08:08 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2010-07-28 04:08:08 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_ps_mode(struct lbs_private *priv, u16 cmd_action, bool block)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2010-07-28 04:08:08 +08:00
|
|
|
struct cmd_ds_802_11_ps_mode cmd;
|
|
|
|
int ret = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(cmd_action);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
if (cmd_action == PS_MODE_ACTION_ENTER_PS) {
|
|
|
|
lbs_deb_cmd("PS_MODE: action ENTER_PS\n");
|
|
|
|
cmd.multipledtim = cpu_to_le16(1); /* Default DTIM multiple */
|
|
|
|
} else if (cmd_action == PS_MODE_ACTION_EXIT_PS) {
|
|
|
|
lbs_deb_cmd("PS_MODE: action EXIT_PS\n");
|
|
|
|
} else {
|
|
|
|
/* We don't handle CONFIRM_SLEEP here because it needs to
|
|
|
|
* be fastpathed to the firmware.
|
|
|
|
*/
|
|
|
|
lbs_deb_cmd("PS_MODE: unknown action 0x%X\n", cmd_action);
|
|
|
|
ret = -EOPNOTSUPP;
|
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
if (block)
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_PS_MODE, &cmd);
|
|
|
|
else
|
|
|
|
lbs_cmd_async(priv, CMD_802_11_PS_MODE, &cmd.hdr, sizeof (cmd));
|
|
|
|
|
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-12-18 12:48:31 +08:00
|
|
|
int lbs_cmd_802_11_sleep_params(struct lbs_private *priv, uint16_t cmd_action,
|
|
|
|
struct sleep_params *sp)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-18 12:48:31 +08:00
|
|
|
struct cmd_ds_802_11_sleep_params cmd;
|
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:31:18 +08:00
|
|
|
if (cmd_action == CMD_ACT_GET) {
|
2007-12-18 12:48:31 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
} else {
|
|
|
|
cmd.error = cpu_to_le16(sp->sp_error);
|
|
|
|
cmd.offset = cpu_to_le16(sp->sp_offset);
|
|
|
|
cmd.stabletime = cpu_to_le16(sp->sp_stabletime);
|
|
|
|
cmd.calcontrol = sp->sp_calcontrol;
|
|
|
|
cmd.externalsleepclk = sp->sp_extsleepclk;
|
|
|
|
cmd.reserved = cpu_to_le16(sp->sp_reserved);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
2007-12-18 12:48:31 +08:00
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(cmd_action);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-18 12:48:31 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_SLEEP_PARAMS, &cmd);
|
|
|
|
|
|
|
|
if (!ret) {
|
|
|
|
lbs_deb_cmd("error 0x%x, offset 0x%x, stabletime 0x%x, "
|
|
|
|
"calcontrol 0x%x extsleepclk 0x%x\n",
|
|
|
|
le16_to_cpu(cmd.error), le16_to_cpu(cmd.offset),
|
|
|
|
le16_to_cpu(cmd.stabletime), cmd.calcontrol,
|
|
|
|
cmd.externalsleepclk);
|
|
|
|
|
|
|
|
sp->sp_error = le16_to_cpu(cmd.error);
|
|
|
|
sp->sp_offset = le16_to_cpu(cmd.offset);
|
|
|
|
sp->sp_stabletime = le16_to_cpu(cmd.stabletime);
|
|
|
|
sp->sp_calcontrol = cmd.calcontrol;
|
|
|
|
sp->sp_extsleepclk = cmd.externalsleepclk;
|
|
|
|
sp->sp_reserved = le16_to_cpu(cmd.reserved);
|
|
|
|
}
|
|
|
|
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
2007-02-10 22:25:27 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2009-10-01 11:04:38 +08:00
|
|
|
static int lbs_wait_for_ds_awake(struct lbs_private *priv)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
|
|
|
|
if (priv->is_deep_sleep) {
|
|
|
|
if (!wait_event_interruptible_timeout(priv->ds_awake_q,
|
|
|
|
!priv->is_deep_sleep, (10 * HZ))) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_err(priv->dev, "ds_awake_q: timer expired\n");
|
2009-10-01 11:04:38 +08:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
int lbs_set_deep_sleep(struct lbs_private *priv, int deep_sleep)
|
|
|
|
{
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
|
|
|
|
if (deep_sleep) {
|
|
|
|
if (priv->is_deep_sleep != 1) {
|
|
|
|
lbs_deb_cmd("deep sleep: sleep\n");
|
|
|
|
BUG_ON(!priv->enter_deep_sleep);
|
|
|
|
ret = priv->enter_deep_sleep(priv);
|
|
|
|
if (!ret) {
|
|
|
|
netif_stop_queue(priv->dev);
|
|
|
|
netif_carrier_off(priv->dev);
|
|
|
|
}
|
|
|
|
} else {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_err(priv->dev, "deep sleep: already enabled\n");
|
2009-10-01 11:04:38 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (priv->is_deep_sleep) {
|
|
|
|
lbs_deb_cmd("deep sleep: wakeup\n");
|
|
|
|
BUG_ON(!priv->exit_deep_sleep);
|
|
|
|
ret = priv->exit_deep_sleep(priv);
|
|
|
|
if (!ret) {
|
|
|
|
ret = lbs_wait_for_ds_awake(priv);
|
|
|
|
if (ret)
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_err(priv->dev,
|
|
|
|
"deep sleep: wakeup failed\n");
|
2009-10-01 11:04:38 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-08 09:13:48 +08:00
|
|
|
static int lbs_ret_host_sleep_activate(struct lbs_private *priv,
|
|
|
|
unsigned long dummy,
|
|
|
|
struct cmd_header *cmd)
|
|
|
|
{
|
|
|
|
lbs_deb_enter(LBS_DEB_FW);
|
|
|
|
priv->is_host_sleep_activated = 1;
|
|
|
|
wake_up_interruptible(&priv->host_sleep_q);
|
|
|
|
lbs_deb_leave(LBS_DEB_FW);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int lbs_set_host_sleep(struct lbs_private *priv, int host_sleep)
|
|
|
|
{
|
|
|
|
struct cmd_header cmd;
|
|
|
|
int ret = 0;
|
|
|
|
uint32_t criteria = EHS_REMOVE_WAKEUP;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
|
|
|
|
if (host_sleep) {
|
|
|
|
if (priv->is_host_sleep_activated != 1) {
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
ret = lbs_host_sleep_cfg(priv, priv->wol_criteria,
|
|
|
|
(struct wol_config *)NULL);
|
|
|
|
if (ret) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev,
|
|
|
|
"Host sleep configuration failed: %d\n",
|
|
|
|
ret);
|
2010-07-08 09:13:48 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
if (priv->psstate == PS_STATE_FULL_POWER) {
|
|
|
|
ret = __lbs_cmd(priv,
|
|
|
|
CMD_802_11_HOST_SLEEP_ACTIVATE,
|
|
|
|
&cmd,
|
|
|
|
sizeof(cmd),
|
|
|
|
lbs_ret_host_sleep_activate, 0);
|
|
|
|
if (ret)
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev,
|
|
|
|
"HOST_SLEEP_ACTIVATE failed: %d\n",
|
|
|
|
ret);
|
2010-07-08 09:13:48 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!wait_event_interruptible_timeout(
|
|
|
|
priv->host_sleep_q,
|
|
|
|
priv->is_host_sleep_activated,
|
|
|
|
(10 * HZ))) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_err(priv->dev,
|
|
|
|
"host_sleep_q: timer expired\n");
|
2010-07-08 09:13:48 +08:00
|
|
|
ret = -1;
|
|
|
|
}
|
|
|
|
} else {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_err(priv->dev, "host sleep: already enabled\n");
|
2010-07-08 09:13:48 +08:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
if (priv->is_host_sleep_activated)
|
|
|
|
ret = lbs_host_sleep_cfg(priv, criteria,
|
|
|
|
(struct wol_config *)NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_snmp_mib - Set an SNMP MIB value
|
2008-09-11 00:49:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @oid: The OID to set in the firmware
|
|
|
|
* @val: Value to set the OID to
|
2008-09-11 00:49:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2008-09-11 00:49:00 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_snmp_mib(struct lbs_private *priv, u32 oid, u16 val)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2008-09-11 00:49:00 +08:00
|
|
|
struct cmd_ds_802_11_snmp_mib cmd;
|
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
memset(&cmd, 0, sizeof (cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
cmd.oid = cpu_to_le16((u16) oid);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
switch (oid) {
|
|
|
|
case SNMP_MIB_OID_BSS_TYPE:
|
|
|
|
cmd.bufsize = cpu_to_le16(sizeof(u8));
|
2009-10-22 21:30:59 +08:00
|
|
|
cmd.value[0] = val;
|
2008-09-11 00:49:00 +08:00
|
|
|
break;
|
|
|
|
case SNMP_MIB_OID_11D_ENABLE:
|
|
|
|
case SNMP_MIB_OID_FRAG_THRESHOLD:
|
|
|
|
case SNMP_MIB_OID_RTS_THRESHOLD:
|
|
|
|
case SNMP_MIB_OID_SHORT_RETRY_LIMIT:
|
|
|
|
case SNMP_MIB_OID_LONG_RETRY_LIMIT:
|
|
|
|
cmd.bufsize = cpu_to_le16(sizeof(u16));
|
|
|
|
*((__le16 *)(&cmd.value)) = cpu_to_le16(val);
|
2007-02-10 22:25:27 +08:00
|
|
|
break;
|
2008-09-11 00:49:00 +08:00
|
|
|
default:
|
|
|
|
lbs_deb_cmd("SNMP_CMD: (set) unhandled OID 0x%x\n", oid);
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
lbs_deb_cmd("SNMP_CMD: (set) oid 0x%x, oid size 0x%x, value 0x%x\n",
|
|
|
|
le16_to_cpu(cmd.oid), le16_to_cpu(cmd.bufsize), val);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_snmp_mib - Get an SNMP MIB value
|
2008-09-11 00:49:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @oid: The OID to retrieve from the firmware
|
|
|
|
* @out_val: Location for the returned value
|
2008-09-11 00:49:00 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2008-09-11 00:49:00 +08:00
|
|
|
*/
|
|
|
|
int lbs_get_snmp_mib(struct lbs_private *priv, u32 oid, u16 *out_val)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_snmp_mib cmd;
|
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
memset(&cmd, 0, sizeof (cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_GET);
|
|
|
|
cmd.oid = cpu_to_le16(oid);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_SNMP_MIB, &cmd);
|
|
|
|
if (ret)
|
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
switch (le16_to_cpu(cmd.bufsize)) {
|
|
|
|
case sizeof(u8):
|
2009-10-22 21:30:59 +08:00
|
|
|
*out_val = cmd.value[0];
|
2008-09-11 00:49:00 +08:00
|
|
|
break;
|
|
|
|
case sizeof(u16):
|
|
|
|
*out_val = le16_to_cpu(*((__le16 *)(&cmd.value)));
|
2007-02-10 22:25:27 +08:00
|
|
|
break;
|
|
|
|
default:
|
2008-09-11 00:49:00 +08:00
|
|
|
lbs_deb_cmd("SNMP_CMD: (get) unhandled OID 0x%x size %d\n",
|
|
|
|
oid, le16_to_cpu(cmd.bufsize));
|
2007-02-10 22:25:27 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2008-09-11 00:49:00 +08:00
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_tx_power - Get the min, max, and current TX power
|
2008-08-20 03:15:35 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @curlevel: Current power level in dBm
|
|
|
|
* @minlevel: Minimum supported power level in dBm (optional)
|
|
|
|
* @maxlevel: Maximum supported power level in dBm (optional)
|
2008-08-20 03:15:35 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2008-08-20 03:15:35 +08:00
|
|
|
*/
|
|
|
|
int lbs_get_tx_power(struct lbs_private *priv, s16 *curlevel, s16 *minlevel,
|
|
|
|
s16 *maxlevel)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2008-08-20 03:15:35 +08:00
|
|
|
struct cmd_ds_802_11_rf_tx_power cmd;
|
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_GET);
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
|
|
|
|
if (ret == 0) {
|
|
|
|
*curlevel = le16_to_cpu(cmd.curlevel);
|
|
|
|
if (minlevel)
|
2008-10-29 17:35:02 +08:00
|
|
|
*minlevel = cmd.minlevel;
|
2008-08-20 03:15:35 +08:00
|
|
|
if (maxlevel)
|
2008-10-29 17:35:02 +08:00
|
|
|
*maxlevel = cmd.maxlevel;
|
2008-08-20 03:15:35 +08:00
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_tx_power - Set the TX power
|
2008-08-20 03:15:35 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @dbm: The desired power level in dBm
|
2008-08-20 03:15:35 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2008-08-20 03:15:35 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_tx_power(struct lbs_private *priv, s16 dbm)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_rf_tx_power cmd;
|
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
cmd.curlevel = cpu_to_le16(dbm);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-20 03:15:35 +08:00
|
|
|
lbs_deb_cmd("SET_RF_TX_POWER: %d dBm\n", dbm);
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RF_TX_POWER, &cmd);
|
2007-05-25 23:27:16 +08:00
|
|
|
|
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
2008-08-20 03:15:35 +08:00
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 03:54:34 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_monitor_mode - Enable or disable monitor mode
|
|
|
|
* (only implemented on OLPC usb8388 FW)
|
2010-07-28 03:54:34 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @enable: 1 to enable monitor mode, 0 to disable
|
2010-07-28 03:54:34 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2010-07-28 03:54:34 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_monitor_mode(struct lbs_private *priv, int enable)
|
2007-08-03 01:16:55 +08:00
|
|
|
{
|
2010-07-28 03:54:34 +08:00
|
|
|
struct cmd_ds_802_11_monitor_mode cmd;
|
|
|
|
int ret;
|
2007-08-03 01:16:55 +08:00
|
|
|
|
2010-07-28 03:54:34 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
if (enable)
|
|
|
|
cmd.mode = cpu_to_le16(0x1);
|
2007-08-03 01:16:55 +08:00
|
|
|
|
2010-07-28 03:54:34 +08:00
|
|
|
lbs_deb_cmd("SET_MONITOR_MODE: %d\n", enable);
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_MONITOR_MODE, &cmd);
|
|
|
|
if (ret == 0) {
|
|
|
|
priv->dev->type = enable ? ARPHRD_IEEE80211_RADIOTAP :
|
|
|
|
ARPHRD_ETHER;
|
2007-08-03 01:16:55 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 03:54:34 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
|
|
|
return ret;
|
2007-08-03 01:16:55 +08:00
|
|
|
}
|
|
|
|
|
2007-12-12 05:54:15 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_channel - Get the radio channel
|
2007-12-12 05:54:15 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
2007-12-12 05:54:15 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: The channel on success, error on failure
|
2007-12-12 05:54:15 +08:00
|
|
|
*/
|
2009-10-16 23:33:56 +08:00
|
|
|
static int lbs_get_channel(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-12 05:54:15 +08:00
|
|
|
struct cmd_ds_802_11_rf_channel cmd;
|
|
|
|
int ret = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-04-09 16:23:31 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
2007-12-12 05:54:15 +08:00
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_GET);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-13 05:00:42 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
|
2007-12-12 05:54:15 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 06:35:51 +08:00
|
|
|
ret = le16_to_cpu(cmd.channel);
|
|
|
|
lbs_deb_cmd("current radio channel is %d\n", ret);
|
2007-12-12 05:54:15 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-04-02 22:52:19 +08:00
|
|
|
int lbs_update_channel(struct lbs_private *priv)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/* the channel in f/w could be out of sync; get the current channel */
|
|
|
|
lbs_deb_enter(LBS_DEB_ASSOC);
|
|
|
|
|
|
|
|
ret = lbs_get_channel(priv);
|
|
|
|
if (ret > 0) {
|
2009-10-22 21:30:50 +08:00
|
|
|
priv->channel = ret;
|
2008-04-02 22:52:19 +08:00
|
|
|
ret = 0;
|
|
|
|
}
|
|
|
|
lbs_deb_leave_args(LBS_DEB_ASSOC, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2007-12-12 05:54:15 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_channel - Set the radio channel
|
2007-12-12 05:54:15 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @channel: The desired channel, or 0 to clear a locked channel
|
2007-12-12 05:54:15 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error on failure
|
2007-12-12 05:54:15 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_channel(struct lbs_private *priv, u8 channel)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_rf_channel cmd;
|
2008-10-13 18:52:42 +08:00
|
|
|
#ifdef DEBUG
|
2009-10-22 21:30:50 +08:00
|
|
|
u8 old_channel = priv->channel;
|
2008-10-13 18:52:42 +08:00
|
|
|
#endif
|
2007-12-12 05:54:15 +08:00
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
|
2008-04-09 16:23:31 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
2007-12-12 05:54:15 +08:00
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_OPT_802_11_RF_CHANNEL_SET);
|
|
|
|
cmd.channel = cpu_to_le16(channel);
|
|
|
|
|
2007-12-13 05:00:42 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RF_CHANNEL, &cmd);
|
2007-12-12 05:54:15 +08:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
|
2009-10-22 21:30:50 +08:00
|
|
|
priv->channel = (uint8_t) le16_to_cpu(cmd.channel);
|
2007-12-12 06:35:51 +08:00
|
|
|
lbs_deb_cmd("channel switch from %d to %d\n", old_channel,
|
2009-10-22 21:30:50 +08:00
|
|
|
priv->channel);
|
2007-12-12 05:54:15 +08:00
|
|
|
|
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 03:55:21 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_rssi - Get current RSSI and noise floor
|
2010-07-28 03:55:21 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @rssi: On successful return, signal level in mBm
|
|
|
|
* @nf: On successful return, Noise floor
|
2010-07-28 03:55:21 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: The channel on success, error on failure
|
2010-07-28 03:55:21 +08:00
|
|
|
*/
|
|
|
|
int lbs_get_rssi(struct lbs_private *priv, s8 *rssi, s8 *nf)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_rssi cmd;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
|
|
|
|
BUG_ON(rssi == NULL);
|
|
|
|
BUG_ON(nf == NULL);
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
/* Average SNR over last 8 beacons */
|
|
|
|
cmd.n_or_snr = cpu_to_le16(8);
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RSSI, &cmd);
|
|
|
|
if (ret == 0) {
|
|
|
|
*nf = CAL_NF(le16_to_cpu(cmd.nf));
|
|
|
|
*rssi = CAL_RSSI(le16_to_cpu(cmd.n_or_snr), le16_to_cpu(cmd.nf));
|
|
|
|
}
|
|
|
|
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-28 03:56:05 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_11d_domain_info - Send regulatory and 802.11d domain information
|
|
|
|
* to the firmware
|
2010-07-28 03:56:05 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: pointer to &struct lbs_private
|
|
|
|
* @request: cfg80211 regulatory request structure
|
|
|
|
* @bands: the device's supported bands and channels
|
2010-07-28 03:56:05 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error code on failure
|
2010-07-28 03:56:05 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_11d_domain_info(struct lbs_private *priv,
|
|
|
|
struct regulatory_request *request,
|
|
|
|
struct ieee80211_supported_band **bands)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11d_domain_info cmd;
|
|
|
|
struct mrvl_ie_domain_param_set *domain = &cmd.domain;
|
|
|
|
struct ieee80211_country_ie_triplet *t;
|
|
|
|
enum ieee80211_band band;
|
|
|
|
struct ieee80211_channel *ch;
|
|
|
|
u8 num_triplet = 0;
|
|
|
|
u8 num_parsed_chan = 0;
|
|
|
|
u8 first_channel = 0, next_chan = 0, max_pwr = 0;
|
|
|
|
u8 i, flag = 0;
|
|
|
|
size_t triplet_size;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_11D);
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
|
|
|
|
lbs_deb_11d("Setting country code '%c%c'\n",
|
|
|
|
request->alpha2[0], request->alpha2[1]);
|
|
|
|
|
|
|
|
domain->header.type = cpu_to_le16(TLV_TYPE_DOMAIN);
|
|
|
|
|
|
|
|
/* Set country code */
|
|
|
|
domain->country_code[0] = request->alpha2[0];
|
|
|
|
domain->country_code[1] = request->alpha2[1];
|
|
|
|
domain->country_code[2] = ' ';
|
|
|
|
|
|
|
|
/* Now set up the channel triplets; firmware is somewhat picky here
|
|
|
|
* and doesn't validate channel numbers and spans; hence it would
|
|
|
|
* interpret a triplet of (36, 4, 20) as channels 36, 37, 38, 39. Since
|
|
|
|
* the last 3 aren't valid channels, the driver is responsible for
|
|
|
|
* splitting that up into 4 triplet pairs of (36, 1, 20) + (40, 1, 20)
|
|
|
|
* etc.
|
|
|
|
*/
|
|
|
|
for (band = 0;
|
|
|
|
(band < IEEE80211_NUM_BANDS) && (num_triplet < MAX_11D_TRIPLETS);
|
|
|
|
band++) {
|
|
|
|
|
|
|
|
if (!bands[band])
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (i = 0;
|
|
|
|
(i < bands[band]->n_channels) && (num_triplet < MAX_11D_TRIPLETS);
|
|
|
|
i++) {
|
|
|
|
ch = &bands[band]->channels[i];
|
|
|
|
if (ch->flags & IEEE80211_CHAN_DISABLED)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
if (!flag) {
|
|
|
|
flag = 1;
|
|
|
|
next_chan = first_channel = (u32) ch->hw_value;
|
|
|
|
max_pwr = ch->max_power;
|
|
|
|
num_parsed_chan = 1;
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if ((ch->hw_value == next_chan + 1) &&
|
|
|
|
(ch->max_power == max_pwr)) {
|
|
|
|
/* Consolidate adjacent channels */
|
|
|
|
next_chan++;
|
|
|
|
num_parsed_chan++;
|
|
|
|
} else {
|
|
|
|
/* Add this triplet */
|
|
|
|
lbs_deb_11d("11D triplet (%d, %d, %d)\n",
|
|
|
|
first_channel, num_parsed_chan,
|
|
|
|
max_pwr);
|
|
|
|
t = &domain->triplet[num_triplet];
|
|
|
|
t->chans.first_channel = first_channel;
|
|
|
|
t->chans.num_channels = num_parsed_chan;
|
|
|
|
t->chans.max_power = max_pwr;
|
|
|
|
num_triplet++;
|
|
|
|
flag = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (flag) {
|
|
|
|
/* Add last triplet */
|
|
|
|
lbs_deb_11d("11D triplet (%d, %d, %d)\n", first_channel,
|
|
|
|
num_parsed_chan, max_pwr);
|
|
|
|
t = &domain->triplet[num_triplet];
|
|
|
|
t->chans.first_channel = first_channel;
|
|
|
|
t->chans.num_channels = num_parsed_chan;
|
|
|
|
t->chans.max_power = max_pwr;
|
|
|
|
num_triplet++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
lbs_deb_11d("# triplets %d\n", num_triplet);
|
|
|
|
|
|
|
|
/* Set command header sizes */
|
|
|
|
triplet_size = num_triplet * sizeof(struct ieee80211_country_ie_triplet);
|
|
|
|
domain->header.len = cpu_to_le16(sizeof(domain->country_code) +
|
|
|
|
triplet_size);
|
|
|
|
|
|
|
|
lbs_deb_hex(LBS_DEB_11D, "802.11D domain param set",
|
|
|
|
(u8 *) &cmd.domain.country_code,
|
|
|
|
le16_to_cpu(domain->header.len));
|
|
|
|
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd.hdr) +
|
|
|
|
sizeof(cmd.action) +
|
|
|
|
sizeof(cmd.domain.header) +
|
|
|
|
sizeof(cmd.domain.country_code) +
|
|
|
|
triplet_size);
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11D_DOMAIN_INFO, &cmd);
|
|
|
|
|
|
|
|
lbs_deb_leave_args(LBS_DEB_11D, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_reg - Read a MAC, Baseband, or RF register
|
2010-07-28 04:01:07 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: pointer to &struct lbs_private
|
|
|
|
* @reg: register command, one of CMD_MAC_REG_ACCESS,
|
|
|
|
* CMD_BBP_REG_ACCESS, or CMD_RF_REG_ACCESS
|
|
|
|
* @offset: byte offset of the register to get
|
|
|
|
* @value: on success, the value of the register at 'offset'
|
2010-07-28 04:01:07 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error code on failure
|
2010-07-28 04:01:07 +08:00
|
|
|
*/
|
|
|
|
int lbs_get_reg(struct lbs_private *priv, u16 reg, u16 offset, u32 *value)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2010-07-28 04:01:07 +08:00
|
|
|
struct cmd_ds_reg_access cmd;
|
|
|
|
int ret = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
BUG_ON(value == NULL);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_GET);
|
2011-07-09 18:57:05 +08:00
|
|
|
cmd.offset = cpu_to_le16(offset);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
if (reg != CMD_MAC_REG_ACCESS &&
|
|
|
|
reg != CMD_BBP_REG_ACCESS &&
|
|
|
|
reg != CMD_RF_REG_ACCESS) {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, reg, &cmd);
|
2011-07-09 18:57:05 +08:00
|
|
|
if (!ret) {
|
2010-07-28 04:01:07 +08:00
|
|
|
if (reg == CMD_BBP_REG_ACCESS || reg == CMD_RF_REG_ACCESS)
|
|
|
|
*value = cmd.value.bbp_rf;
|
|
|
|
else if (reg == CMD_MAC_REG_ACCESS)
|
|
|
|
*value = le32_to_cpu(cmd.value.mac);
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_reg - Write a MAC, Baseband, or RF register
|
2010-07-28 04:01:07 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: pointer to &struct lbs_private
|
|
|
|
* @reg: register command, one of CMD_MAC_REG_ACCESS,
|
|
|
|
* CMD_BBP_REG_ACCESS, or CMD_RF_REG_ACCESS
|
|
|
|
* @offset: byte offset of the register to set
|
|
|
|
* @value: the value to write to the register at 'offset'
|
2010-07-28 04:01:07 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success, error code on failure
|
2010-07-28 04:01:07 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_reg(struct lbs_private *priv, u16 reg, u16 offset, u32 value)
|
|
|
|
{
|
|
|
|
struct cmd_ds_reg_access cmd;
|
|
|
|
int ret = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
2011-07-09 18:57:05 +08:00
|
|
|
cmd.offset = cpu_to_le16(offset);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
if (reg == CMD_BBP_REG_ACCESS || reg == CMD_RF_REG_ACCESS)
|
|
|
|
cmd.value.bbp_rf = (u8) (value & 0xFF);
|
|
|
|
else if (reg == CMD_MAC_REG_ACCESS)
|
|
|
|
cmd.value.mac = cpu_to_le32(value);
|
|
|
|
else {
|
|
|
|
ret = -EINVAL;
|
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 04:01:07 +08:00
|
|
|
ret = lbs_cmd_with_response(priv, reg, &cmd);
|
|
|
|
|
|
|
|
out:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
|
|
|
return ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-12-16 09:04:54 +08:00
|
|
|
static void lbs_queue_cmd(struct lbs_private *priv,
|
|
|
|
struct cmd_ctrl_node *cmdnode)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-12-16 09:04:54 +08:00
|
|
|
int addtail = 1;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-15 13:41:51 +08:00
|
|
|
if (!cmdnode) {
|
|
|
|
lbs_deb_host("QUEUE_CMD: cmdnode is NULL\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
goto done;
|
|
|
|
}
|
2007-12-15 13:09:25 +08:00
|
|
|
if (!cmdnode->cmdbuf->size) {
|
|
|
|
lbs_deb_host("DNLD_CMD: cmd size is zero\n");
|
|
|
|
goto done;
|
|
|
|
}
|
2007-12-15 17:22:52 +08:00
|
|
|
cmdnode->result = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
/* Exit_PS command needs to be queued in the header always. */
|
2007-12-12 02:49:39 +08:00
|
|
|
if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_PS_MODE) {
|
2010-07-28 04:08:08 +08:00
|
|
|
struct cmd_ds_802_11_ps_mode *psm = (void *) &cmdnode->cmdbuf;
|
2007-12-12 02:49:39 +08:00
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
if (psm->action == cpu_to_le16(PS_MODE_ACTION_EXIT_PS)) {
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->psstate != PS_STATE_FULL_POWER)
|
2007-02-10 22:25:27 +08:00
|
|
|
addtail = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2010-07-28 04:08:08 +08:00
|
|
|
if (le16_to_cpu(cmdnode->cmdbuf->command) == CMD_802_11_WAKEUP_CONFIRM)
|
2010-05-19 18:24:38 +08:00
|
|
|
addtail = 0;
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-08 08:35:00 +08:00
|
|
|
if (addtail)
|
2007-12-09 04:04:36 +08:00
|
|
|
list_add_tail(&cmdnode->list, &priv->cmdpendingq);
|
2007-12-08 08:35:00 +08:00
|
|
|
else
|
2007-12-09 04:04:36 +08:00
|
|
|
list_add(&cmdnode->list, &priv->cmdpendingq);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("QUEUE_CMD: inserted command 0x%04x into cmdpendingq\n",
|
2007-12-15 13:41:51 +08:00
|
|
|
le16_to_cpu(cmdnode->cmdbuf->command));
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
done:
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-12-18 05:03:58 +08:00
|
|
|
static void lbs_submit_command(struct lbs_private *priv,
|
|
|
|
struct cmd_ctrl_node *cmdnode)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2007-12-12 02:49:39 +08:00
|
|
|
struct cmd_header *cmd;
|
2007-12-18 05:03:58 +08:00
|
|
|
uint16_t cmdsize;
|
|
|
|
uint16_t command;
|
2008-05-14 22:30:28 +08:00
|
|
|
int timeo = 3 * HZ;
|
2007-12-18 05:03:58 +08:00
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
cmd = cmdnode->cmdbuf;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2011-05-27 04:31:08 +08:00
|
|
|
priv->seqnum++;
|
|
|
|
cmd->seqnum = cpu_to_le16(priv->seqnum);
|
2007-12-09 04:04:36 +08:00
|
|
|
priv->cur_cmd = cmdnode;
|
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
cmdsize = le16_to_cpu(cmd->size);
|
|
|
|
command = le16_to_cpu(cmd->command);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-18 05:03:58 +08:00
|
|
|
/* These commands take longer */
|
2009-05-23 08:05:25 +08:00
|
|
|
if (command == CMD_802_11_SCAN || command == CMD_802_11_ASSOCIATE)
|
2008-05-14 22:30:28 +08:00
|
|
|
timeo = 5 * HZ;
|
2007-12-18 05:03:58 +08:00
|
|
|
|
2008-03-26 17:04:44 +08:00
|
|
|
lbs_deb_cmd("DNLD_CMD: command 0x%04x, seq %d, size %d\n",
|
|
|
|
command, le16_to_cpu(cmd->seqnum), cmdsize);
|
2008-01-29 16:14:40 +08:00
|
|
|
lbs_deb_hex(LBS_DEB_CMD, "DNLD_CMD", (void *) cmdnode->cmdbuf, cmdsize);
|
2007-08-02 23:54:31 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) cmd, cmdsize);
|
2007-12-18 05:03:58 +08:00
|
|
|
|
2007-12-15 13:09:25 +08:00
|
|
|
if (ret) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev, "DNLD_CMD: hw_host_to_card failed: %d\n",
|
|
|
|
ret);
|
2007-12-18 05:03:58 +08:00
|
|
|
/* Let the timer kick in and retry, and potentially reset
|
|
|
|
the whole thing if the condition persists */
|
2008-05-14 22:30:28 +08:00
|
|
|
timeo = HZ/4;
|
2008-01-29 16:14:40 +08:00
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2009-10-01 11:04:38 +08:00
|
|
|
if (command == CMD_802_11_DEEP_SLEEP) {
|
|
|
|
if (priv->is_auto_deep_sleep_enabled) {
|
|
|
|
priv->wakeup_dev_required = 1;
|
|
|
|
priv->dnld_sent = 0;
|
|
|
|
}
|
|
|
|
priv->is_deep_sleep = 1;
|
|
|
|
lbs_complete_command(priv, cmdnode, 0);
|
|
|
|
} else {
|
|
|
|
/* Setup the timer after transmit command */
|
|
|
|
mod_timer(&priv->command_timer, jiffies + timeo);
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-18 05:03:58 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2011-04-27 06:25:29 +08:00
|
|
|
/*
|
2007-02-10 22:25:27 +08:00
|
|
|
* This function inserts command node to cmdfreeq
|
2007-12-09 04:04:36 +08:00
|
|
|
* after cleans it. Requires priv->driver_lock held.
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2007-12-15 14:52:54 +08:00
|
|
|
static void __lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
|
2007-12-15 15:02:56 +08:00
|
|
|
struct cmd_ctrl_node *cmdnode)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-15 15:02:56 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
|
|
|
|
|
|
|
if (!cmdnode)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
cmdnode->callback = NULL;
|
|
|
|
cmdnode->callback_arg = 0;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-15 15:02:56 +08:00
|
|
|
memset(cmdnode->cmdbuf, 0, LBS_CMD_BUFFER_SIZE);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-15 15:02:56 +08:00
|
|
|
list_add_tail(&cmdnode->list, &priv->cmdfreeq);
|
|
|
|
out:
|
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-11-23 22:43:44 +08:00
|
|
|
static void lbs_cleanup_and_insert_cmd(struct lbs_private *priv,
|
|
|
|
struct cmd_ctrl_node *ptempcmd)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-11-16 07:05:47 +08:00
|
|
|
__lbs_cleanup_and_insert_cmd(priv, ptempcmd);
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2011-07-09 22:41:25 +08:00
|
|
|
void __lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
|
|
|
|
int result)
|
2007-12-15 14:52:54 +08:00
|
|
|
{
|
2011-07-09 22:41:25 +08:00
|
|
|
/*
|
|
|
|
* Normally, commands are removed from cmdpendingq before being
|
|
|
|
* submitted. However, we can arrive here on alternative codepaths
|
|
|
|
* where the command is still pending. Make sure the command really
|
|
|
|
* isn't part of a list at this point.
|
|
|
|
*/
|
|
|
|
list_del_init(&cmd->list);
|
|
|
|
|
2007-12-15 17:22:52 +08:00
|
|
|
cmd->result = result;
|
2007-12-15 15:02:56 +08:00
|
|
|
cmd->cmdwaitqwoken = 1;
|
2011-07-09 22:41:25 +08:00
|
|
|
wake_up(&cmd->cmdwait_q);
|
2007-12-15 15:02:56 +08:00
|
|
|
|
2008-03-19 17:11:00 +08:00
|
|
|
if (!cmd->callback || cmd->callback == lbs_cmd_async_callback)
|
2007-12-15 15:06:16 +08:00
|
|
|
__lbs_cleanup_and_insert_cmd(priv, cmd);
|
2007-12-15 14:52:54 +08:00
|
|
|
priv->cur_cmd = NULL;
|
2011-08-01 23:43:13 +08:00
|
|
|
wake_up(&priv->waitq);
|
2011-07-09 22:41:25 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
void lbs_complete_command(struct lbs_private *priv, struct cmd_ctrl_node *cmd,
|
|
|
|
int result)
|
|
|
|
{
|
|
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
|
|
|
__lbs_complete_command(priv, cmd, result);
|
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-12-15 14:52:54 +08:00
|
|
|
}
|
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
int lbs_set_radio(struct lbs_private *priv, u8 preamble, u8 radio_on)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-18 11:43:48 +08:00
|
|
|
struct cmd_ds_802_11_radio_control cmd;
|
2008-08-22 05:51:07 +08:00
|
|
|
int ret = -EINVAL;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-18 11:43:48 +08:00
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
/* Only v8 and below support setting the preamble */
|
|
|
|
if (priv->fwrelease < 0x09000000) {
|
|
|
|
switch (preamble) {
|
|
|
|
case RADIO_PREAMBLE_SHORT:
|
|
|
|
case RADIO_PREAMBLE_AUTO:
|
|
|
|
case RADIO_PREAMBLE_LONG:
|
|
|
|
cmd.control = cpu_to_le16(preamble);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
2007-12-18 11:43:48 +08:00
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
if (radio_on)
|
|
|
|
cmd.control |= cpu_to_le16(0x1);
|
|
|
|
else {
|
|
|
|
cmd.control &= cpu_to_le16(~0x1);
|
|
|
|
priv->txpower_cur = 0;
|
2007-12-18 11:43:48 +08:00
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
lbs_deb_cmd("RADIO_CONTROL: radio %s, preamble %d\n",
|
|
|
|
radio_on ? "ON" : "OFF", preamble);
|
2007-12-18 11:43:48 +08:00
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
priv->radio_on = radio_on;
|
2007-12-18 11:43:48 +08:00
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_RADIO_CONTROL, &cmd);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-08-22 05:51:07 +08:00
|
|
|
out:
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_leave_args(LBS_DEB_CMD, "ret %d", ret);
|
2007-02-10 22:25:27 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-03-18 18:20:21 +08:00
|
|
|
void lbs_set_mac_control(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2008-03-12 23:05:40 +08:00
|
|
|
struct cmd_ds_mac_control cmd;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-05-25 23:27:16 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-03-12 23:05:40 +08:00
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
2008-03-12 23:06:43 +08:00
|
|
|
cmd.action = cpu_to_le16(priv->mac_control);
|
2008-03-12 23:05:40 +08:00
|
|
|
cmd.reserved = 0;
|
|
|
|
|
2008-05-20 20:32:45 +08:00
|
|
|
lbs_cmd_async(priv, CMD_MAC_CONTROL, &cmd.hdr, sizeof(cmd));
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-03-18 18:20:21 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_allocate_cmd_buffer - allocates the command buffer and links
|
|
|
|
* it to command free queue
|
|
|
|
*
|
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 for success or -1 on error
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2007-11-23 22:43:44 +08:00
|
|
|
int lbs_allocate_cmd_buffer(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
int ret = 0;
|
2007-12-12 02:49:39 +08:00
|
|
|
u32 bufsize;
|
2007-02-10 22:25:27 +08:00
|
|
|
u32 i;
|
2007-12-12 02:49:39 +08:00
|
|
|
struct cmd_ctrl_node *cmdarray;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
/* Allocate and initialize the command array */
|
|
|
|
bufsize = sizeof(struct cmd_ctrl_node) * LBS_NUM_CMD_BUFFERS;
|
|
|
|
if (!(cmdarray = kzalloc(bufsize, GFP_KERNEL))) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("ALLOC_CMD_BUF: tempcmd_array is NULL\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
2007-12-12 02:49:39 +08:00
|
|
|
priv->cmd_array = cmdarray;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
/* Allocate and initialize each command buffer in the command array */
|
|
|
|
for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
|
|
|
|
cmdarray[i].cmdbuf = kzalloc(LBS_CMD_BUFFER_SIZE, GFP_KERNEL);
|
|
|
|
if (!cmdarray[i].cmdbuf) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("ALLOC_CMD_BUF: ptempvirtualaddr is NULL\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
|
|
|
|
init_waitqueue_head(&cmdarray[i].cmdwait_q);
|
|
|
|
lbs_cleanup_and_insert_cmd(priv, &cmdarray[i]);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
ret = 0;
|
2007-05-25 23:27:16 +08:00
|
|
|
|
|
|
|
done:
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
|
2007-02-10 22:25:27 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_free_cmd_buffer - free the command buffer
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
*
|
|
|
|
* returns: 0 for success
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2007-11-23 22:43:44 +08:00
|
|
|
int lbs_free_cmd_buffer(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
2007-12-12 02:49:39 +08:00
|
|
|
struct cmd_ctrl_node *cmdarray;
|
2007-02-10 22:25:27 +08:00
|
|
|
unsigned int i;
|
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
/* need to check if cmd array is allocated or not */
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->cmd_array == NULL) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("FREE_CMD_BUF: cmd_array is NULL\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
cmdarray = priv->cmd_array;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
/* Release shared memory buffers */
|
2007-12-12 02:49:39 +08:00
|
|
|
for (i = 0; i < LBS_NUM_CMD_BUFFERS; i++) {
|
|
|
|
if (cmdarray[i].cmdbuf) {
|
|
|
|
kfree(cmdarray[i].cmdbuf);
|
|
|
|
cmdarray[i].cmdbuf = NULL;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Release cmd_ctrl_node */
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->cmd_array) {
|
|
|
|
kfree(priv->cmd_array);
|
|
|
|
priv->cmd_array = NULL;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
done:
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_get_free_cmd_node - gets a free command node if available in
|
|
|
|
* command free queue
|
|
|
|
*
|
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: A pointer to &cmd_ctrl_node structure on success
|
|
|
|
* or %NULL on error
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2010-07-28 04:16:24 +08:00
|
|
|
static struct cmd_ctrl_node *lbs_get_free_cmd_node(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
struct cmd_ctrl_node *tempnode;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if (!priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
return NULL;
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if (!list_empty(&priv->cmdfreeq)) {
|
|
|
|
tempnode = list_first_entry(&priv->cmdfreeq,
|
2007-12-06 20:01:21 +08:00
|
|
|
struct cmd_ctrl_node, list);
|
2011-07-09 22:41:25 +08:00
|
|
|
list_del_init(&tempnode->list);
|
2007-02-10 22:25:27 +08:00
|
|
|
} else {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("GET_CMD_NODE: cmd_ctrl_node is not available\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
tempnode = NULL;
|
|
|
|
}
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
return tempnode;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_execute_next_command - execute next command in command
|
|
|
|
* pending queue. Will put firmware back to PS mode if applicable.
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
*
|
|
|
|
* returns: 0 on success or -1 on error
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2007-11-23 22:43:44 +08:00
|
|
|
int lbs_execute_next_command(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
struct cmd_ctrl_node *cmdnode = NULL;
|
2007-12-12 02:49:39 +08:00
|
|
|
struct cmd_header *cmd;
|
2007-02-10 22:25:27 +08:00
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
2008-01-29 16:14:40 +08:00
|
|
|
/* Debug group is LBS_DEB_THREAD and not LBS_DEB_HOST, because the
|
|
|
|
* only caller to us is lbs_thread() and we get even when a
|
|
|
|
* data packet is received */
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_THREAD);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->cur_cmd) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_alert(priv->dev,
|
|
|
|
"EXEC_NEXT_CMD: already processing command!\n");
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if (!list_empty(&priv->cmdpendingq)) {
|
|
|
|
cmdnode = list_first_entry(&priv->cmdpendingq,
|
2007-12-06 20:01:21 +08:00
|
|
|
struct cmd_ctrl_node, list);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
if (cmdnode) {
|
2007-12-12 02:49:39 +08:00
|
|
|
cmd = cmdnode->cmdbuf;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-12-12 02:49:39 +08:00
|
|
|
if (is_command_allowed_in_ps(le16_to_cpu(cmd->command))) {
|
2007-12-09 04:04:36 +08:00
|
|
|
if ((priv->psstate == PS_STATE_SLEEP) ||
|
|
|
|
(priv->psstate == PS_STATE_PRE_SLEEP)) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: cannot send cmd 0x%04x in psstate %d\n",
|
2007-12-12 02:49:39 +08:00
|
|
|
le16_to_cpu(cmd->command),
|
2007-12-09 04:04:36 +08:00
|
|
|
priv->psstate);
|
2007-02-10 22:25:27 +08:00
|
|
|
ret = -1;
|
|
|
|
goto done;
|
|
|
|
}
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("EXEC_NEXT_CMD: OK to send command "
|
2007-12-12 02:49:39 +08:00
|
|
|
"0x%04x in psstate %d\n",
|
|
|
|
le16_to_cpu(cmd->command), priv->psstate);
|
2007-12-09 04:04:36 +08:00
|
|
|
} else if (priv->psstate != PS_STATE_FULL_POWER) {
|
2007-02-10 22:25:27 +08:00
|
|
|
/*
|
|
|
|
* 1. Non-PS command:
|
|
|
|
* Queue it. set needtowakeup to TRUE if current state
|
2010-07-28 04:08:08 +08:00
|
|
|
* is SLEEP, otherwise call send EXIT_PS.
|
|
|
|
* 2. PS command but not EXIT_PS:
|
2007-02-10 22:25:27 +08:00
|
|
|
* Ignore it.
|
2010-07-28 04:08:08 +08:00
|
|
|
* 3. PS command EXIT_PS:
|
2007-02-10 22:25:27 +08:00
|
|
|
* Set needtowakeup to TRUE if current state is SLEEP,
|
|
|
|
* otherwise send this command down to firmware
|
|
|
|
* immediately.
|
|
|
|
*/
|
2007-12-12 02:49:39 +08:00
|
|
|
if (cmd->command != cpu_to_le16(CMD_802_11_PS_MODE)) {
|
2007-02-10 22:25:27 +08:00
|
|
|
/* Prepare to send Exit PS,
|
|
|
|
* this non PS command will be sent later */
|
2007-12-09 04:04:36 +08:00
|
|
|
if ((priv->psstate == PS_STATE_SLEEP)
|
|
|
|
|| (priv->psstate == PS_STATE_PRE_SLEEP)
|
2007-02-10 22:25:27 +08:00
|
|
|
) {
|
|
|
|
/* w/ new scheme, it will not reach here.
|
|
|
|
since it is blocked in main_thread. */
|
2007-12-09 04:04:36 +08:00
|
|
|
priv->needtowakeup = 1;
|
2010-07-28 04:08:08 +08:00
|
|
|
} else {
|
|
|
|
lbs_set_ps_mode(priv,
|
|
|
|
PS_MODE_ACTION_EXIT_PS,
|
|
|
|
false);
|
|
|
|
}
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
goto done;
|
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* PS command. Ignore it if it is not Exit_PS.
|
|
|
|
* otherwise send it down immediately.
|
|
|
|
*/
|
2007-12-17 12:26:54 +08:00
|
|
|
struct cmd_ds_802_11_ps_mode *psm = (void *)&cmd[1];
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: PS cmd, action 0x%02x\n",
|
2007-02-10 22:25:27 +08:00
|
|
|
psm->action);
|
|
|
|
if (psm->action !=
|
2010-07-28 04:08:08 +08:00
|
|
|
cpu_to_le16(PS_MODE_ACTION_EXIT_PS)) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: ignore ENTER_PS cmd\n");
|
2007-12-15 14:52:54 +08:00
|
|
|
lbs_complete_command(priv, cmdnode, 0);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if ((priv->psstate == PS_STATE_SLEEP) ||
|
|
|
|
(priv->psstate == PS_STATE_PRE_SLEEP)) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: ignore EXIT_PS cmd in sleep\n");
|
2007-12-15 14:52:54 +08:00
|
|
|
lbs_complete_command(priv, cmdnode, 0);
|
2007-12-09 04:04:36 +08:00
|
|
|
priv->needtowakeup = 1;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: sending EXIT_PS\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
}
|
2011-05-09 17:40:42 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2011-07-09 22:41:25 +08:00
|
|
|
list_del_init(&cmdnode->list);
|
2011-05-09 17:40:42 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("EXEC_NEXT_CMD: sending command 0x%04x\n",
|
2007-12-12 02:49:39 +08:00
|
|
|
le16_to_cpu(cmd->command));
|
2007-12-15 13:09:25 +08:00
|
|
|
lbs_submit_command(priv, cmdnode);
|
2007-02-10 22:25:27 +08:00
|
|
|
} else {
|
|
|
|
/*
|
|
|
|
* check if in power save mode, if yes, put the device back
|
|
|
|
* to PS mode
|
|
|
|
*/
|
2010-06-15 00:31:26 +08:00
|
|
|
#ifdef TODO
|
|
|
|
/*
|
|
|
|
* This was the old code for libertas+wext. Someone that
|
|
|
|
* understands this beast should re-code it in a sane way.
|
|
|
|
*
|
|
|
|
* I actually don't understand why this is related to WPA
|
|
|
|
* and to connection status, shouldn't powering should be
|
|
|
|
* independ of such things?
|
|
|
|
*/
|
2007-12-09 04:04:36 +08:00
|
|
|
if ((priv->psmode != LBS802_11POWERMODECAM) &&
|
|
|
|
(priv->psstate == PS_STATE_FULL_POWER) &&
|
|
|
|
((priv->connect_status == LBS_CONNECTED) ||
|
2009-12-02 22:26:01 +08:00
|
|
|
lbs_mesh_connected(priv))) {
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->secinfo.WPAenabled ||
|
|
|
|
priv->secinfo.WPA2enabled) {
|
2007-02-10 22:25:27 +08:00
|
|
|
/* check for valid WPA group keys */
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->wpa_mcast_key.len ||
|
|
|
|
priv->wpa_unicast_key.len) {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
2007-02-10 22:25:27 +08:00
|
|
|
"EXEC_NEXT_CMD: WPA enabled and GTK_SET"
|
|
|
|
" go back to PS_SLEEP");
|
2010-07-28 04:08:08 +08:00
|
|
|
lbs_set_ps_mode(priv,
|
|
|
|
PS_MODE_ACTION_ENTER_PS,
|
|
|
|
false);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
} else {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host(
|
|
|
|
"EXEC_NEXT_CMD: cmdpendingq empty, "
|
|
|
|
"go back to PS_SLEEP");
|
2010-07-28 04:08:08 +08:00
|
|
|
lbs_set_ps_mode(priv, PS_MODE_ACTION_ENTER_PS,
|
|
|
|
false);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
}
|
2010-06-15 00:31:26 +08:00
|
|
|
#endif
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
ret = 0;
|
|
|
|
done:
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_THREAD);
|
2007-02-10 22:25:27 +08:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2008-03-26 20:22:11 +08:00
|
|
|
static void lbs_send_confirmsleep(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
unsigned long flags;
|
2008-03-26 20:22:11 +08:00
|
|
|
int ret;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2008-03-26 20:22:11 +08:00
|
|
|
lbs_deb_hex(LBS_DEB_HOST, "sleep confirm", (u8 *) &confirm_sleep,
|
|
|
|
sizeof(confirm_sleep));
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-03-26 20:22:11 +08:00
|
|
|
ret = priv->hw_host_to_card(priv, MVMS_CMD, (u8 *) &confirm_sleep,
|
|
|
|
sizeof(confirm_sleep));
|
2007-02-10 22:25:27 +08:00
|
|
|
if (ret) {
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_alert(priv->dev, "confirm_sleep failed\n");
|
2008-04-01 20:50:43 +08:00
|
|
|
goto out;
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
2008-04-01 20:50:43 +08:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
|
|
|
|
2008-06-04 17:10:40 +08:00
|
|
|
/* We don't get a response on the sleep-confirmation */
|
|
|
|
priv->dnld_sent = DNLD_RES_RECEIVED;
|
|
|
|
|
2010-05-19 18:24:38 +08:00
|
|
|
if (priv->is_host_sleep_configured) {
|
|
|
|
priv->is_host_sleep_activated = 1;
|
|
|
|
wake_up_interruptible(&priv->host_sleep_q);
|
|
|
|
}
|
|
|
|
|
2008-04-01 20:50:43 +08:00
|
|
|
/* If nothing to do, go back to sleep (?) */
|
2009-12-22 06:37:28 +08:00
|
|
|
if (!kfifo_len(&priv->event_fifo) && !priv->resp_len[priv->resp_idx])
|
2008-04-01 20:50:43 +08:00
|
|
|
priv->psstate = PS_STATE_SLEEP;
|
|
|
|
|
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
|
|
|
|
|
|
|
out:
|
2008-03-26 20:22:11 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_ps_confirm_sleep - checks condition and prepares to
|
|
|
|
* send sleep confirm command to firmware if ok
|
|
|
|
*
|
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
2007-02-10 22:25:27 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: n/a
|
2007-02-10 22:25:27 +08:00
|
|
|
*/
|
2008-03-19 21:25:18 +08:00
|
|
|
void lbs_ps_confirm_sleep(struct lbs_private *priv)
|
2007-02-10 22:25:27 +08:00
|
|
|
{
|
|
|
|
unsigned long flags =0;
|
2008-03-19 21:25:18 +08:00
|
|
|
int allowed = 1;
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
2008-06-04 17:10:40 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-05-26 01:05:16 +08:00
|
|
|
if (priv->dnld_sent) {
|
2007-02-10 22:25:27 +08:00
|
|
|
allowed = 0;
|
2007-12-12 13:14:21 +08:00
|
|
|
lbs_deb_host("dnld_sent was set\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2008-04-01 20:50:43 +08:00
|
|
|
/* In-progress command? */
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->cur_cmd) {
|
2007-02-10 22:25:27 +08:00
|
|
|
allowed = 0;
|
2007-12-12 13:14:21 +08:00
|
|
|
lbs_deb_host("cur_cmd was set\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
2008-04-01 20:50:43 +08:00
|
|
|
|
|
|
|
/* Pending events or command responses? */
|
2009-12-22 06:37:28 +08:00
|
|
|
if (kfifo_len(&priv->event_fifo) || priv->resp_len[priv->resp_idx]) {
|
2007-02-10 22:25:27 +08:00
|
|
|
allowed = 0;
|
2008-04-01 20:50:43 +08:00
|
|
|
lbs_deb_host("pending events or command responses\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-02-10 22:25:27 +08:00
|
|
|
|
|
|
|
if (allowed) {
|
2007-11-16 07:05:47 +08:00
|
|
|
lbs_deb_host("sending lbs_ps_confirm_sleep\n");
|
2008-03-26 20:22:11 +08:00
|
|
|
lbs_send_confirmsleep(priv);
|
2007-02-10 22:25:27 +08:00
|
|
|
} else {
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_host("sleep confirm has been delayed\n");
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
|
|
|
|
2007-08-02 23:54:31 +08:00
|
|
|
lbs_deb_leave(LBS_DEB_HOST);
|
2007-02-10 22:25:27 +08:00
|
|
|
}
|
2007-12-06 00:58:11 +08:00
|
|
|
|
|
|
|
|
2008-09-12 02:17:25 +08:00
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_tpc_cfg - Configures the transmission power control functionality
|
2008-09-12 02:17:25 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @enable: Transmission power control enable
|
|
|
|
* @p0: Power level when link quality is good (dBm).
|
|
|
|
* @p1: Power level when link quality is fair (dBm).
|
|
|
|
* @p2: Power level when link quality is poor (dBm).
|
|
|
|
* @usesnr: Use Signal to Noise Ratio in TPC
|
2008-09-12 02:17:25 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on success
|
2008-09-12 02:17:25 +08:00
|
|
|
*/
|
|
|
|
int lbs_set_tpc_cfg(struct lbs_private *priv, int enable, int8_t p0, int8_t p1,
|
|
|
|
int8_t p2, int usesnr)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_tpc_cfg cmd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
cmd.enable = !!enable;
|
2008-09-26 23:34:35 +08:00
|
|
|
cmd.usesnr = !!usesnr;
|
2008-09-12 02:17:25 +08:00
|
|
|
cmd.P0 = p0;
|
|
|
|
cmd.P1 = p1;
|
|
|
|
cmd.P2 = p2;
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_TPC_CFG, &cmd);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
2011-04-27 06:25:29 +08:00
|
|
|
* lbs_set_power_adapt_cfg - Configures the power adaptation settings
|
2008-09-12 02:17:25 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* @priv: A pointer to &struct lbs_private structure
|
|
|
|
* @enable: Power adaptation enable
|
|
|
|
* @p0: Power level for 1, 2, 5.5 and 11 Mbps (dBm).
|
|
|
|
* @p1: Power level for 6, 9, 12, 18, 22, 24 and 36 Mbps (dBm).
|
|
|
|
* @p2: Power level for 48 and 54 Mbps (dBm).
|
2008-09-12 02:17:25 +08:00
|
|
|
*
|
2011-04-27 06:25:29 +08:00
|
|
|
* returns: 0 on Success
|
2008-09-12 02:17:25 +08:00
|
|
|
*/
|
|
|
|
|
|
|
|
int lbs_set_power_adapt_cfg(struct lbs_private *priv, int enable, int8_t p0,
|
|
|
|
int8_t p1, int8_t p2)
|
|
|
|
{
|
|
|
|
struct cmd_ds_802_11_pa_cfg cmd;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
memset(&cmd, 0, sizeof(cmd));
|
|
|
|
cmd.hdr.size = cpu_to_le16(sizeof(cmd));
|
|
|
|
cmd.action = cpu_to_le16(CMD_ACT_SET);
|
|
|
|
cmd.enable = !!enable;
|
|
|
|
cmd.P0 = p0;
|
|
|
|
cmd.P1 = p1;
|
|
|
|
cmd.P2 = p2;
|
|
|
|
|
|
|
|
ret = lbs_cmd_with_response(priv, CMD_802_11_PA_CFG , &cmd);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-10-14 22:49:53 +08:00
|
|
|
struct cmd_ctrl_node *__lbs_cmd_async(struct lbs_private *priv,
|
2008-03-19 17:11:00 +08:00
|
|
|
uint16_t command, struct cmd_header *in_cmd, int in_cmd_size,
|
|
|
|
int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
|
|
|
|
unsigned long callback_arg)
|
2007-12-06 00:58:11 +08:00
|
|
|
{
|
|
|
|
struct cmd_ctrl_node *cmdnode;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
if (priv->surpriseremoved) {
|
2007-12-06 00:58:11 +08:00
|
|
|
lbs_deb_host("PREP_CMD: card removed\n");
|
2007-12-15 16:09:33 +08:00
|
|
|
cmdnode = ERR_PTR(-ENOENT);
|
2007-12-06 00:58:11 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2010-07-28 04:15:45 +08:00
|
|
|
/* No commands are allowed in Deep Sleep until we toggle the GPIO
|
|
|
|
* to wake up the card and it has signaled that it's ready.
|
|
|
|
*/
|
|
|
|
if (!priv->is_auto_deep_sleep_enabled) {
|
|
|
|
if (priv->is_deep_sleep) {
|
|
|
|
lbs_deb_cmd("command not allowed in deep sleep\n");
|
|
|
|
cmdnode = ERR_PTR(-EBUSY);
|
|
|
|
goto done;
|
|
|
|
}
|
2009-10-07 10:20:28 +08:00
|
|
|
}
|
|
|
|
|
2010-07-28 04:16:24 +08:00
|
|
|
cmdnode = lbs_get_free_cmd_node(priv);
|
2007-12-06 00:58:11 +08:00
|
|
|
if (cmdnode == NULL) {
|
|
|
|
lbs_deb_host("PREP_CMD: cmdnode is NULL\n");
|
|
|
|
|
|
|
|
/* Wake up main thread to execute next command */
|
2011-08-01 23:43:13 +08:00
|
|
|
wake_up(&priv->waitq);
|
2007-12-15 16:09:33 +08:00
|
|
|
cmdnode = ERR_PTR(-ENOBUFS);
|
2007-12-06 00:58:11 +08:00
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-08 08:59:54 +08:00
|
|
|
cmdnode->callback = callback;
|
2007-12-11 02:36:10 +08:00
|
|
|
cmdnode->callback_arg = callback_arg;
|
2007-12-06 00:58:11 +08:00
|
|
|
|
2007-12-12 01:33:30 +08:00
|
|
|
/* Copy the incoming command to the buffer */
|
2007-12-12 02:49:39 +08:00
|
|
|
memcpy(cmdnode->cmdbuf, in_cmd, in_cmd_size);
|
2007-12-12 01:33:30 +08:00
|
|
|
|
2011-05-27 04:31:08 +08:00
|
|
|
/* Set command, clean result, move to buffer */
|
2007-12-12 02:49:39 +08:00
|
|
|
cmdnode->cmdbuf->command = cpu_to_le16(command);
|
|
|
|
cmdnode->cmdbuf->size = cpu_to_le16(in_cmd_size);
|
|
|
|
cmdnode->cmdbuf->result = 0;
|
2007-12-06 00:58:11 +08:00
|
|
|
|
|
|
|
lbs_deb_host("PREP_CMD: command 0x%04x\n", command);
|
|
|
|
|
|
|
|
cmdnode->cmdwaitqwoken = 0;
|
2007-12-16 09:04:54 +08:00
|
|
|
lbs_queue_cmd(priv, cmdnode);
|
2011-08-01 23:43:13 +08:00
|
|
|
wake_up(&priv->waitq);
|
2007-12-06 00:58:11 +08:00
|
|
|
|
2007-12-15 16:09:33 +08:00
|
|
|
done:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_HOST, "ret %p", cmdnode);
|
|
|
|
return cmdnode;
|
|
|
|
}
|
|
|
|
|
2008-03-19 17:11:00 +08:00
|
|
|
void lbs_cmd_async(struct lbs_private *priv, uint16_t command,
|
|
|
|
struct cmd_header *in_cmd, int in_cmd_size)
|
|
|
|
{
|
|
|
|
lbs_deb_enter(LBS_DEB_CMD);
|
|
|
|
__lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
|
|
|
|
lbs_cmd_async_callback, 0);
|
|
|
|
lbs_deb_leave(LBS_DEB_CMD);
|
|
|
|
}
|
|
|
|
|
2007-12-15 16:09:33 +08:00
|
|
|
int __lbs_cmd(struct lbs_private *priv, uint16_t command,
|
|
|
|
struct cmd_header *in_cmd, int in_cmd_size,
|
|
|
|
int (*callback)(struct lbs_private *, unsigned long, struct cmd_header *),
|
|
|
|
unsigned long callback_arg)
|
|
|
|
{
|
|
|
|
struct cmd_ctrl_node *cmdnode;
|
|
|
|
unsigned long flags;
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
lbs_deb_enter(LBS_DEB_HOST);
|
|
|
|
|
|
|
|
cmdnode = __lbs_cmd_async(priv, command, in_cmd, in_cmd_size,
|
|
|
|
callback, callback_arg);
|
|
|
|
if (IS_ERR(cmdnode)) {
|
|
|
|
ret = PTR_ERR(cmdnode);
|
|
|
|
goto done;
|
|
|
|
}
|
|
|
|
|
2007-12-06 00:58:11 +08:00
|
|
|
might_sleep();
|
2011-07-09 22:41:25 +08:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Be careful with signals here. A signal may be received as the system
|
|
|
|
* goes into suspend or resume. We do not want this to interrupt the
|
|
|
|
* command, so we perform an uninterruptible sleep.
|
|
|
|
*/
|
|
|
|
wait_event(cmdnode->cmdwait_q, cmdnode->cmdwaitqwoken);
|
2007-12-06 00:58:11 +08:00
|
|
|
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_lock_irqsave(&priv->driver_lock, flags);
|
2007-12-15 17:22:52 +08:00
|
|
|
ret = cmdnode->result;
|
|
|
|
if (ret)
|
2011-05-03 07:49:15 +08:00
|
|
|
netdev_info(priv->dev, "PREP_CMD: command 0x%04x failed: %d\n",
|
|
|
|
command, ret);
|
2007-12-15 16:09:33 +08:00
|
|
|
|
2007-12-15 15:06:16 +08:00
|
|
|
__lbs_cleanup_and_insert_cmd(priv, cmdnode);
|
2007-12-09 04:04:36 +08:00
|
|
|
spin_unlock_irqrestore(&priv->driver_lock, flags);
|
2007-12-06 00:58:11 +08:00
|
|
|
|
|
|
|
done:
|
|
|
|
lbs_deb_leave_args(LBS_DEB_HOST, "ret %d", ret);
|
|
|
|
return ret;
|
|
|
|
}
|
2007-12-11 04:11:23 +08:00
|
|
|
EXPORT_SYMBOL_GPL(__lbs_cmd);
|