mirror of
https://github.com/nxp-imx/mwifiex.git
synced 2024-08-20 04:25:26 +00:00
changes: 1. WCSWREL-126: Fixed PCIE9098 suspend fail on imx8mq. 2. WCSWREL-87: Hostsleep fails as DUT doesnot wake up on traffic/pattern. Signed-off-by: Sherry Sun <sherry.sun@nxp.com> Approved-by: Tian Yang <yang.tian@nxp.com>
7244 lines
188 KiB
C
7244 lines
188 KiB
C
/** @file moal_ioctl.c
|
|
*
|
|
* @brief This file contains ioctl function to MLAN
|
|
*
|
|
*
|
|
* Copyright 2008-2021 NXP
|
|
*
|
|
* This software file (the File) is distributed by NXP
|
|
* under the terms of the GNU General Public License Version 2, June 1991
|
|
* (the License). You may use, redistribute and/or modify the File in
|
|
* accordance with the terms and conditions of the License, a copy of which
|
|
* is available by writing to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA or on the
|
|
* worldwide web at http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
|
|
*
|
|
* THE FILE IS DISTRIBUTED AS-IS, WITHOUT WARRANTY OF ANY KIND, AND THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE EXPRESSLY DISCLAIMED. The License provides additional details about
|
|
* this warranty disclaimer.
|
|
*
|
|
*/
|
|
|
|
/********************************************************
|
|
Change log:
|
|
10/21/2008: initial version
|
|
********************************************************/
|
|
|
|
#include "moal_main.h"
|
|
#include "moal_eth_ioctl.h"
|
|
#ifdef SDIO
|
|
#include "moal_sdio.h"
|
|
#endif
|
|
#ifdef USB
|
|
#include "moal_usb.h"
|
|
#endif
|
|
#ifdef UAP_SUPPORT
|
|
#include "moal_uap.h"
|
|
#endif
|
|
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
#include "moal_cfg80211.h"
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
|
#include "moal_cfg80211_util.h"
|
|
#endif
|
|
#endif
|
|
|
|
/********************************************************
|
|
Local Variables
|
|
********************************************************/
|
|
#define MRVL_TLV_HEADER_SIZE 4
|
|
/* NXP Channel config TLV ID */
|
|
#define MRVL_CHANNELCONFIG_TLV_ID (0x0100 + 0x2a) /* 0x012a */
|
|
|
|
typedef struct _hostcmd_header {
|
|
/** Command Header : Command */
|
|
t_u16 command;
|
|
/** Command Header : Size */
|
|
t_u16 size;
|
|
/** Command Header : Sequence number */
|
|
t_u16 seq_num;
|
|
/** Command Header : Result */
|
|
t_u16 result;
|
|
/** Command action */
|
|
t_u16 action;
|
|
} hostcmd_header, *phostcmd_header;
|
|
|
|
/** Region code mapping */
|
|
typedef struct _region_code_mapping_t {
|
|
/** Region */
|
|
t_u8 region[COUNTRY_CODE_LEN];
|
|
/** Code */
|
|
t_u8 code;
|
|
} region_code_mapping_t;
|
|
|
|
#define EU_REGION_CODE 0x30
|
|
|
|
/** Region code mapping table */
|
|
static region_code_mapping_t region_code_mapping[] = {
|
|
{"00", 0x00}, /* World */
|
|
{"US", 0x10}, /* US FCC */
|
|
{"CA", 0x20}, /* IC Canada */
|
|
{"SG", 0x10}, /* Singapore */
|
|
{"EU", 0x30}, /* ETSI */
|
|
{"AU", 0x30}, /* Australia */
|
|
{"KR", 0x30}, /* Republic Of Korea */
|
|
{"JP", 0x40}, /* Japan */
|
|
{"CN", 0x50}, /* China */
|
|
{"BR", 0x09}, /* Brazil */
|
|
{"RU", 0x0f}, /* Russia */
|
|
{"IN", 0x06}, /* India */
|
|
{"MY", 0x06}, /* Malaysia */
|
|
{"MX", 0x07}, /* Mexico */
|
|
{"NE", 0x30}, /* New Zeland */
|
|
};
|
|
|
|
/** EEPROM Region code mapping table */
|
|
static region_code_mapping_t hw_region_code_mapping[] = {
|
|
{"00 ", 0x00}, /* World */
|
|
{"US ", 0x10}, /* US FCC */
|
|
{"CA ", 0x20}, /* IC Canada */
|
|
{"KR ", 0x30}, /* Korea */
|
|
{"CN ", 0x50}, /* China */
|
|
{"ES ", 0x31}, /* Spain */
|
|
{"FR ", 0x32}, /* France */
|
|
{"JP ", 0x40}, /* Japan */
|
|
{"JP ", 0x41}, /* Japan */
|
|
};
|
|
|
|
/** Country code for ETSI */
|
|
static t_u8 eu_country_code_table[][COUNTRY_CODE_LEN] = {
|
|
"AL", "AD", "AT", "AU", "BY", "BE", "BA", "BG", "HR", "CY", "CZ", "DK",
|
|
"EE", "FI", "FR", "MK", "DE", "GR", "HU", "IS", "IE", "IT", "KR", "LV",
|
|
"LI", "LT", "LU", "MT", "MD", "MC", "ME", "NL", "NO", "PL", "RO", "RU",
|
|
"SM", "RS", "SI", "SK", "ES", "SE", "CH", "TR", "UA", "UK", "GB", "NE"};
|
|
|
|
/********************************************************
|
|
Global Variables
|
|
********************************************************/
|
|
|
|
#if LINUX_VERSION_CODE > KERNEL_VERSION(2, 6, 29)
|
|
#ifdef UAP_SUPPORT
|
|
/** Network device handlers for uAP */
|
|
extern const struct net_device_ops woal_uap_netdev_ops;
|
|
#endif
|
|
#ifdef STA_SUPPORT
|
|
/** Network device handlers for STA */
|
|
extern const struct net_device_ops woal_netdev_ops;
|
|
#endif
|
|
#endif
|
|
|
|
/********************************************************
|
|
Local Functions
|
|
********************************************************/
|
|
/**
|
|
* @brief This function converts region string to region code
|
|
*
|
|
* @param country_code Region string
|
|
*
|
|
* @return Region code
|
|
*/
|
|
static t_bool woal_is_country_code_supported(t_u8 *country_code)
|
|
{
|
|
t_u8 i;
|
|
ENTER();
|
|
|
|
for (i = 0; i < ARRAY_SIZE(region_code_mapping); i++) {
|
|
if (!memcmp(country_code, region_code_mapping[i].region,
|
|
COUNTRY_CODE_LEN - 1)) {
|
|
PRINTM(MIOCTL,
|
|
"found country code in region_code table\n");
|
|
LEAVE();
|
|
return MTRUE;
|
|
}
|
|
}
|
|
|
|
LEAVE();
|
|
return MFALSE;
|
|
}
|
|
/**
|
|
* @brief This function converts region string to region code
|
|
*
|
|
* @param region_string Region string
|
|
*
|
|
* @return Region code
|
|
*/
|
|
static t_u8 region_string_2_region_code(char *region_string)
|
|
{
|
|
t_u8 i;
|
|
|
|
ENTER();
|
|
for (i = 0; i < ARRAY_SIZE(region_code_mapping); i++) {
|
|
if (!memcmp(region_string, region_code_mapping[i].region,
|
|
strlen(region_string))) {
|
|
LEAVE();
|
|
return region_code_mapping[i].code;
|
|
}
|
|
}
|
|
|
|
/* If still not found, look for code in EU country code table */
|
|
for (i = 0; i < ARRAY_SIZE(eu_country_code_table); i++) {
|
|
if (!memcmp(region_string, eu_country_code_table[i],
|
|
COUNTRY_CODE_LEN - 1)) {
|
|
PRINTM(MIOCTL, "found region code=%d in EU table\n",
|
|
EU_REGION_CODE);
|
|
LEAVE();
|
|
return EU_REGION_CODE;
|
|
}
|
|
}
|
|
|
|
/* Default is US */
|
|
LEAVE();
|
|
return region_code_mapping[0].code;
|
|
}
|
|
|
|
/**
|
|
* @brief This function converts region string to region code
|
|
*
|
|
* @param country_code Region string
|
|
*
|
|
* @return Region code
|
|
*/
|
|
t_bool woal_is_etsi_country(t_u8 *country_code)
|
|
{
|
|
t_u8 i;
|
|
ENTER();
|
|
|
|
for (i = 0; i < ARRAY_SIZE(eu_country_code_table); i++) {
|
|
if (!memcmp(country_code, eu_country_code_table[i],
|
|
COUNTRY_CODE_LEN - 1)) {
|
|
PRINTM(MIOCTL, "found region code=%d in EU table\n",
|
|
EU_REGION_CODE);
|
|
LEAVE();
|
|
return MTRUE;
|
|
}
|
|
}
|
|
|
|
LEAVE();
|
|
return MFALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief This function converts region string to region code
|
|
*
|
|
* @param region_code region code
|
|
*
|
|
* @return Region string or NULL
|
|
*/
|
|
char *region_code_2_string(t_u8 region_code)
|
|
{
|
|
t_u8 i;
|
|
|
|
ENTER();
|
|
for (i = 0; i < ARRAY_SIZE(hw_region_code_mapping); i++) {
|
|
if (hw_region_code_mapping[i].code == region_code) {
|
|
LEAVE();
|
|
return hw_region_code_mapping[i].region;
|
|
}
|
|
}
|
|
LEAVE();
|
|
return NULL;
|
|
}
|
|
|
|
t_u8 woal_is_valid_alpha2(char *alpha2)
|
|
{
|
|
if (!alpha2 || strlen(alpha2) < 2)
|
|
return MFALSE;
|
|
if (isalpha(alpha2[0]) && isalpha(alpha2[1]))
|
|
return MTRUE;
|
|
return MFALSE;
|
|
}
|
|
|
|
/**
|
|
* @brief Get second channel offset
|
|
*
|
|
* @param chan channel num
|
|
* @return second channel offset
|
|
*/
|
|
t_u8 woal_get_second_channel_offset(int chan)
|
|
{
|
|
t_u8 chan2Offset = SEC_CHAN_NONE;
|
|
|
|
switch (chan) {
|
|
case 36:
|
|
case 44:
|
|
case 52:
|
|
case 60:
|
|
case 100:
|
|
case 108:
|
|
case 116:
|
|
case 124:
|
|
case 132:
|
|
case 140:
|
|
case 149:
|
|
case 157:
|
|
chan2Offset = SEC_CHAN_ABOVE;
|
|
break;
|
|
case 40:
|
|
case 48:
|
|
case 56:
|
|
case 64:
|
|
case 104:
|
|
case 112:
|
|
case 120:
|
|
case 128:
|
|
case 136:
|
|
case 144:
|
|
case 153:
|
|
case 161:
|
|
chan2Offset = SEC_CHAN_BELOW;
|
|
break;
|
|
case 165:
|
|
/* Special Case: 20Mhz-only Channel */
|
|
chan2Offset = SEC_CHAN_NONE;
|
|
break;
|
|
}
|
|
return chan2Offset;
|
|
}
|
|
|
|
/**
|
|
* @brief Copy mc address to the mlist
|
|
*
|
|
* @param mlist A pointer to mlan_multicast_list structure
|
|
* @param mac mc address
|
|
*
|
|
* @return N/A
|
|
*/
|
|
static inline void woal_copy_mc_addr(mlan_multicast_list *mlist,
|
|
mlan_802_11_mac_addr mac)
|
|
{
|
|
t_u32 i = 0;
|
|
for (i = 0; i < mlist->num_multicast_addr; i++) {
|
|
if (!memcmp(&mlist->mac_list[i], mac, ETH_ALEN))
|
|
return;
|
|
}
|
|
if (mlist->num_multicast_addr < MLAN_MAX_MULTICAST_LIST_SIZE)
|
|
moal_memcpy_ext(NULL,
|
|
&mlist->mac_list[mlist->num_multicast_addr],
|
|
mac, ETH_ALEN, sizeof(mlan_802_11_mac_addr));
|
|
mlist->num_multicast_addr++;
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief Copy multicast table
|
|
*
|
|
* @param mlist A pointer to mlan_multicast_list structure
|
|
* @param dev A pointer to net_device structure
|
|
*
|
|
* @return Number of multicast addresses
|
|
*/
|
|
static inline int woal_copy_mcast_addr(mlan_multicast_list *mlist,
|
|
struct net_device *dev)
|
|
{
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
|
|
struct dev_mc_list *mcptr = dev->mc_list;
|
|
int i = 0;
|
|
#else
|
|
struct netdev_hw_addr *mcptr = NULL;
|
|
#endif /* < 2.6.35 */
|
|
|
|
ENTER();
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
|
|
for (i = 0; i < dev->mc_count && mcptr; i++) {
|
|
woal_copy_mc_addr(mlist, mcptr->dmi_addr);
|
|
mcptr = mcptr->next;
|
|
}
|
|
#else
|
|
netdev_for_each_mc_addr (mcptr, dev)
|
|
woal_copy_mc_addr(mlist, mcptr->addr);
|
|
#endif /* < 2.6.35 */
|
|
LEAVE();
|
|
return mlist->num_multicast_addr;
|
|
}
|
|
|
|
/**
|
|
* @brief copy mc list from all the active interface
|
|
*
|
|
* @param handle A pointer to moal_handle
|
|
* @param mlist A pointer to multicast list
|
|
*
|
|
* @return total_mc_count
|
|
*/
|
|
static int woal_copy_all_mc_list(moal_handle *handle,
|
|
mlan_multicast_list *mlist)
|
|
{
|
|
int i;
|
|
moal_private *priv = NULL;
|
|
#ifdef STA_SUPPORT
|
|
int mc_count = 0;
|
|
#endif
|
|
ENTER();
|
|
for (i = 0; i < handle->priv_num && (priv = handle->priv[i]); i++) {
|
|
#ifdef STA_SUPPORT
|
|
if (GET_BSS_ROLE(handle->priv[i]) == MLAN_BSS_ROLE_STA) {
|
|
if (handle->priv[i]->media_connected == MTRUE) {
|
|
#if LINUX_VERSION_CODE < KERNEL_VERSION(2, 6, 35)
|
|
mc_count = priv->netdev->mc_count;
|
|
#else
|
|
mc_count = netdev_mc_count(priv->netdev);
|
|
#endif
|
|
if (mc_count)
|
|
woal_copy_mcast_addr(mlist,
|
|
priv->netdev);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
PRINTM(MIOCTL, "total mc_count=%d\n", mlist->num_multicast_addr);
|
|
LEAVE();
|
|
return mlist->num_multicast_addr;
|
|
}
|
|
|
|
/**
|
|
* @brief Fill in wait queue
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait A pointer to wait_queue structure
|
|
* @param wait_option Wait option
|
|
*
|
|
* @return N/A
|
|
*/
|
|
static inline void woal_fill_wait_queue(moal_private *priv, wait_queue *wait,
|
|
t_u8 wait_option)
|
|
{
|
|
ENTER();
|
|
wait->start_time = jiffies;
|
|
wait->condition = MFALSE;
|
|
wait->wait_timeout = MFALSE;
|
|
switch (wait_option) {
|
|
case MOAL_NO_WAIT:
|
|
break;
|
|
case MOAL_IOCTL_WAIT:
|
|
init_waitqueue_head(&wait->wait);
|
|
break;
|
|
case MOAL_IOCTL_WAIT_TIMEOUT:
|
|
init_waitqueue_head(&wait->wait);
|
|
wait->wait_timeout = MTRUE;
|
|
break;
|
|
}
|
|
LEAVE();
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief Wait mlan ioctl complete
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param req A pointer to mlan_ioctl_req structure
|
|
* @param wait_option Wait option
|
|
*
|
|
* @return N/A
|
|
*/
|
|
static inline mlan_status woal_wait_ioctl_complete(moal_private *priv,
|
|
mlan_ioctl_req *req,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status status;
|
|
wait_queue *wait = (wait_queue *)req->reserved_1;
|
|
unsigned long flags;
|
|
|
|
ENTER();
|
|
|
|
priv->phandle->ioctl_timeout = MFALSE;
|
|
|
|
switch (wait_option) {
|
|
case MOAL_NO_WAIT:
|
|
break;
|
|
case MOAL_IOCTL_WAIT:
|
|
while (wait_event_interruptible_exclusive(
|
|
wait->wait, wait->condition) == -ERESTARTSYS &&
|
|
wait->retry < MAX_RETRY_CNT) {
|
|
wait->retry++;
|
|
}
|
|
break;
|
|
case MOAL_IOCTL_WAIT_TIMEOUT:
|
|
wait_event_timeout(wait->wait, wait->condition,
|
|
MOAL_IOCTL_TIMEOUT);
|
|
break;
|
|
}
|
|
spin_lock_irqsave(&priv->phandle->driver_lock, flags);
|
|
if (wait->condition == MFALSE) {
|
|
if (wait_option == MOAL_IOCTL_WAIT_TIMEOUT) {
|
|
priv->phandle->ioctl_timeout = MTRUE;
|
|
PRINTM(MMSG,
|
|
"wlan: IOCTL timeout %p id=0x%x, sub_id=0x%x, wait_option=%d, action=%d\n",
|
|
req, req->req_id, (*(t_u32 *)req->pbuf),
|
|
wait_option, (int)req->action);
|
|
} else {
|
|
PRINTM(MMSG,
|
|
"wlan: IOCTL by signal %p id=0x%x, sub_id=0x%x, wait_option=%d, action=%d\n",
|
|
req, req->req_id, (*(t_u32 *)req->pbuf),
|
|
wait_option, (int)req->action);
|
|
}
|
|
req->reserved_1 = 0;
|
|
status = MLAN_STATUS_PENDING;
|
|
} else {
|
|
status = wait->status;
|
|
}
|
|
spin_unlock_irqrestore(&priv->phandle->driver_lock, flags);
|
|
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief CAC period block cmd handler
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param req A pointer to mlan_ioctl_req buffer
|
|
*
|
|
* @return MTRUE/MFALSE
|
|
*/
|
|
static inline t_bool woal_cac_period_block_cmd(moal_private *priv,
|
|
pmlan_ioctl_req req)
|
|
{
|
|
mlan_status ret = MFALSE;
|
|
t_u32 sub_command;
|
|
|
|
ENTER();
|
|
if (req == NULL || req->pbuf == NULL)
|
|
goto done;
|
|
|
|
sub_command = *(t_u32 *)req->pbuf;
|
|
|
|
switch (req->req_id) {
|
|
case MLAN_IOCTL_SCAN:
|
|
if (sub_command == MLAN_OID_SCAN_NORMAL ||
|
|
sub_command == MLAN_OID_SCAN_SPECIFIC_SSID ||
|
|
sub_command == MLAN_OID_SCAN_USER_CONFIG)
|
|
ret = MTRUE;
|
|
break;
|
|
case MLAN_IOCTL_BSS:
|
|
if (sub_command == MLAN_OID_BSS_STOP ||
|
|
sub_command == MLAN_OID_BSS_CHANNEL
|
|
/* sub_command == MLAN_OID_BSS_ROLE */)
|
|
ret = MTRUE;
|
|
#ifdef UAP_SUPPORT
|
|
else if (sub_command == MLAN_OID_UAP_BSS_CONFIG) {
|
|
mlan_ds_bss *bss = (mlan_ds_bss *)req->pbuf;
|
|
if (bss->param.bss_config.channel)
|
|
ret = MTRUE;
|
|
else
|
|
ret = MFALSE;
|
|
}
|
|
#endif
|
|
break;
|
|
case MLAN_IOCTL_RADIO_CFG:
|
|
if (sub_command == MLAN_OID_BAND_CFG ||
|
|
sub_command == MLAN_OID_REMAIN_CHAN_CFG)
|
|
ret = MTRUE;
|
|
break;
|
|
case MLAN_IOCTL_SNMP_MIB:
|
|
if (sub_command == MLAN_OID_SNMP_MIB_DOT11D)
|
|
ret = MTRUE;
|
|
#if defined(UAP_SUPPORT)
|
|
if (sub_command == MLAN_OID_SNMP_MIB_DOT11H)
|
|
ret = MTRUE;
|
|
#endif
|
|
break;
|
|
case MLAN_IOCTL_11D_CFG:
|
|
#ifdef STA_SUPPORT
|
|
if (sub_command == MLAN_OID_11D_CFG_ENABLE)
|
|
ret = MTRUE;
|
|
#endif
|
|
#ifdef UAP_SUPPORT
|
|
if (sub_command == MLAN_OID_11D_DOMAIN_INFO)
|
|
ret = MTRUE;
|
|
#endif
|
|
if (sub_command == MLAN_OID_11D_DOMAIN_INFO_EXT)
|
|
ret = MTRUE;
|
|
break;
|
|
case MLAN_IOCTL_MISC_CFG:
|
|
if (sub_command == MLAN_OID_MISC_REGION)
|
|
ret = MTRUE;
|
|
if (sub_command == MLAN_OID_MISC_HOST_CMD) {
|
|
phostcmd_header phostcmd;
|
|
t_u8 *ptlv_buf;
|
|
t_u16 tag, length;
|
|
|
|
phostcmd =
|
|
(phostcmd_header)((pmlan_ds_misc_cfg)req->pbuf)
|
|
->param.hostcmd.cmd;
|
|
ptlv_buf = (t_u8 *)phostcmd + sizeof(hostcmd_header);
|
|
if (phostcmd->action == MLAN_ACT_SET) {
|
|
while (ptlv_buf <
|
|
(t_u8 *)phostcmd + phostcmd->size) {
|
|
tag = *(t_u16 *)ptlv_buf;
|
|
length = *(t_u16 *)(ptlv_buf + 2);
|
|
/* Check Blocking TLV here, should add
|
|
* more... */
|
|
if (tag == MRVL_CHANNELCONFIG_TLV_ID) {
|
|
ret = MTRUE;
|
|
break;
|
|
}
|
|
ptlv_buf +=
|
|
(length + MRVL_TLV_HEADER_SIZE);
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case MLAN_IOCTL_11H_CFG:
|
|
/* Prevent execute more than once */
|
|
if (sub_command == MLAN_OID_11H_CHANNEL_CHECK)
|
|
ret = MTRUE;
|
|
break;
|
|
default:
|
|
ret = MFALSE;
|
|
break;
|
|
}
|
|
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/********************************************************
|
|
Global Functions
|
|
********************************************************/
|
|
|
|
/**
|
|
* @brief Send ioctl request to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param req A pointer to mlan_ioctl_req buffer
|
|
* @param wait_option Wait option (MOAL_WAIT or MOAL_NO_WAIT)
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING
|
|
* -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_request_ioctl(moal_private *priv, mlan_ioctl_req *req,
|
|
t_u8 wait_option)
|
|
{
|
|
wait_queue *wait = NULL;
|
|
mlan_status status;
|
|
unsigned long flags;
|
|
t_u32 sub_command = 0;
|
|
|
|
ENTER();
|
|
|
|
if (!priv || !priv->phandle || !priv->phandle->pmlan_adapter || !req) {
|
|
PRINTM(MINFO,
|
|
"priv or priv->phandle or priv->phandle->pmlan_adapter or req is null\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
|
|
sub_command = *(t_u32 *)req->pbuf;
|
|
|
|
if (sub_command != MLAN_OID_GET_DEBUG_INFO) {
|
|
if (priv->phandle->surprise_removed == MTRUE ||
|
|
priv->phandle->driver_status) {
|
|
PRINTM(MCMND,
|
|
"IOCTL is not allowed while the device is not present or hang\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
if (priv->phandle->is_suspended == MTRUE) {
|
|
PRINTM(MCMND, "IOCTL is not allowed while suspended\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
#ifdef MFG_CMD_SUPPORT
|
|
if (mfg_mode && sub_command != MLAN_OID_MISC_HOST_CMD) {
|
|
PRINTM(MCMND, "Only HOST_CMD allowed in MFG mode\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
#endif
|
|
}
|
|
/* For MLAN_OID_MISC_HOST_CMD, action is 0, "action set" is checked
|
|
* later */
|
|
if ((req->action == MLAN_ACT_SET || req->action == 0) &&
|
|
priv->phandle->cac_period == MTRUE) {
|
|
/* CAC checking period left to complete jiffies */
|
|
long cac_left_jiffies;
|
|
|
|
/* cac_left_jiffies will be negative if and only if
|
|
* event MLAN_EVENT_ID_DRV_MEAS_REPORT recieved from FW
|
|
* after CAC measure period ends,
|
|
* usually this could be considered as a FW bug
|
|
*/
|
|
cac_left_jiffies =
|
|
priv->phandle->cac_timer_jiffies -
|
|
(jiffies - priv->phandle->meas_start_jiffies);
|
|
if (priv->phandle->cac_period_jiffies) {
|
|
cac_left_jiffies =
|
|
priv->phandle->cac_period_jiffies -
|
|
(jiffies - priv->phandle->meas_start_jiffies);
|
|
}
|
|
if (priv->phandle->cac_restart)
|
|
cac_left_jiffies = DEF_CAC_DWELL_TIME * HZ / 1000;
|
|
if (cac_left_jiffies < 0) {
|
|
/* Avoid driver hang in FW died during CAC measure
|
|
* period */
|
|
priv->phandle->cac_period = MFALSE;
|
|
PRINTM(MERROR,
|
|
"CAC measure period spends longer than scheduled time "
|
|
"or meas done event never received\n");
|
|
status = MLAN_STATUS_FAILURE;
|
|
#ifdef UAP_SUPPORT
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
|
if (priv->uap_host_based &&
|
|
moal_extflg_isset(priv->phandle, EXT_DFS_OFFLOAD))
|
|
woal_cfg80211_dfs_vendor_event(
|
|
priv, event_dfs_cac_aborted,
|
|
&priv->chan);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
|
|
goto done;
|
|
}
|
|
|
|
/* Check BSS START first */
|
|
if (sub_command == MLAN_OID_BSS_START) {
|
|
mlan_ds_bss *bss;
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
/*
|
|
* Bss delay start after channel report received,
|
|
* not block the driver by delay executing. This is
|
|
* because a BSS_START cmd is always executed right
|
|
* after channel check issued.
|
|
*/
|
|
if (priv->phandle->delay_bss_start == MFALSE) {
|
|
PRINTM(MMSG,
|
|
"Received BSS Start command during CAC period, delay executing %ld seconds\n",
|
|
cac_left_jiffies / HZ);
|
|
priv->phandle->delay_bss_start = MTRUE;
|
|
moal_memcpy_ext(
|
|
priv->phandle,
|
|
&priv->phandle->delay_ssid_bssid,
|
|
&bss->param.ssid_bssid,
|
|
sizeof(mlan_ssid_bssid),
|
|
sizeof(mlan_ssid_bssid));
|
|
/* TODO: return success to allow the half below
|
|
* of routines of which calling BSS start to
|
|
* execute
|
|
*/
|
|
status = MLAN_STATUS_SUCCESS;
|
|
goto done;
|
|
} else {
|
|
/* TODO: not blocking it, just return failure */
|
|
PRINTM(MMSG,
|
|
"Only one BSS Start command allowed for delay executing!\n");
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
}
|
|
if (woal_cac_period_block_cmd(priv, req)) {
|
|
priv->phandle->meas_wait_q_woken = MFALSE;
|
|
PRINTM(MMSG,
|
|
"CAC check is on going... Blocking Command %ld seconds\n",
|
|
cac_left_jiffies / HZ);
|
|
/* blocking timeout set to 1.5 * CAC checking period
|
|
* left time */
|
|
wait_event_interruptible_timeout(
|
|
priv->phandle->meas_wait_q,
|
|
priv->phandle->meas_wait_q_woken,
|
|
cac_left_jiffies * 3 / 2);
|
|
}
|
|
}
|
|
#ifdef UAP_CFG80211
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 12, 0)
|
|
else if (priv->phandle->is_cac_timer_set &&
|
|
(req->action == MLAN_ACT_SET || req->action == 0)) {
|
|
if (woal_cac_period_block_cmd(priv, req)) {
|
|
PRINTM(MMSG,
|
|
"CAC check is on going... Blocking Command\n");
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
else if (priv->phandle->cac_period) {
|
|
PRINTM(MINFO, "Operation during CAC check period.\n");
|
|
}
|
|
wait = (wait_queue *)req->reserved_1;
|
|
req->bss_index = priv->bss_index;
|
|
if (wait_option)
|
|
woal_fill_wait_queue(priv, wait, wait_option);
|
|
else
|
|
req->reserved_1 = 0;
|
|
|
|
/* Call MLAN ioctl handle */
|
|
atomic_inc(&priv->phandle->ioctl_pending);
|
|
spin_lock_irqsave(&priv->phandle->ioctl_lock, flags);
|
|
status = mlan_ioctl(priv->phandle->pmlan_adapter, req);
|
|
spin_unlock_irqrestore(&priv->phandle->ioctl_lock, flags);
|
|
switch (status) {
|
|
case MLAN_STATUS_PENDING:
|
|
if (wait_option == MOAL_NO_WAIT)
|
|
PRINTM(MIOCTL, "IOCTL MOAL_NO_WAIT: %p\n", req);
|
|
else
|
|
PRINTM(MIOCTL,
|
|
"IOCTL pending: %p id=0x%x, sub_id=0x%x wait_option=%d, action=%d\n",
|
|
req, req->req_id, (*(t_u32 *)req->pbuf),
|
|
wait_option, (int)req->action);
|
|
/* Status pending, wake up main process */
|
|
queue_work(priv->phandle->workqueue, &priv->phandle->main_work);
|
|
|
|
/* Wait for completion */
|
|
if (wait_option)
|
|
status = woal_wait_ioctl_complete(priv, req,
|
|
wait_option);
|
|
break;
|
|
case MLAN_STATUS_SUCCESS:
|
|
case MLAN_STATUS_FAILURE:
|
|
case MLAN_STATUS_RESOURCE:
|
|
if (req)
|
|
PRINTM(MIOCTL,
|
|
"IOCTL: %p id=0x%x, sub_id=0x%x wait_option=%d, action=%d status=%d\n",
|
|
req, req->req_id, (*(t_u32 *)req->pbuf),
|
|
wait_option, (int)req->action, status);
|
|
atomic_dec(&priv->phandle->ioctl_pending);
|
|
break;
|
|
default:
|
|
atomic_dec(&priv->phandle->ioctl_pending);
|
|
break;
|
|
}
|
|
|
|
done:
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Send set MAC address request to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING
|
|
* -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_request_set_mac_address(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status status;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_MAC_ADDR;
|
|
moal_memcpy_ext(priv->phandle, &bss->param.mac_addr, priv->current_addr,
|
|
sizeof(mlan_802_11_mac_addr),
|
|
sizeof(mlan_802_11_mac_addr));
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_FAILURE) {
|
|
PRINTM(MERROR,
|
|
"set mac address failed! status=%d, error_code=0x%x\n",
|
|
status, req->status_code);
|
|
} else {
|
|
moal_memcpy_ext(priv->phandle, priv->netdev->dev_addr,
|
|
priv->current_addr, ETH_ALEN, ETH_ALEN);
|
|
HEXDUMP("priv->MacAddr:", priv->current_addr, ETH_ALEN);
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Send multicast list request to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param dev A pointer to net_device structure
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_request_set_multicast_list(moal_private *priv, struct net_device *dev)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status status;
|
|
int mc_count = 0;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
PRINTM(MERROR, "%s:Fail to allocate ioctl req buffer\n",
|
|
__func__);
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_MULTICAST_LIST;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_SET;
|
|
if (dev->flags & IFF_PROMISC) {
|
|
bss->param.multicast_list.mode = MLAN_PROMISC_MODE;
|
|
} else if (dev->flags & IFF_ALLMULTI) {
|
|
bss->param.multicast_list.mode = MLAN_ALL_MULTI_MODE;
|
|
} else {
|
|
bss->param.multicast_list.mode = MLAN_MULTICAST_MODE;
|
|
mc_count = woal_copy_all_mc_list(priv->phandle,
|
|
&bss->param.multicast_list);
|
|
if (mc_count > MLAN_MAX_MULTICAST_LIST_SIZE)
|
|
bss->param.multicast_list.mode = MLAN_ALL_MULTI_MODE;
|
|
}
|
|
PRINTM(MCMND, "%s set multicast_list\n", dev->name);
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
done:
|
|
LEAVE();
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief Send deauth command to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param mac MAC address to deauthenticate
|
|
* @param reason code reason code to deauthenticate
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_disconnect(moal_private *priv, t_u8 wait_option, t_u8 *mac,
|
|
t_u16 reason_code)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status status;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_STOP;
|
|
if (mac)
|
|
moal_memcpy_ext(priv->phandle,
|
|
&bss->param.deauth_param.mac_addr, mac,
|
|
sizeof(mlan_802_11_mac_addr),
|
|
sizeof(bss->param.deauth_param.mac_addr));
|
|
bss->param.deauth_param.reason_code = reason_code;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
#ifdef REASSOCIATION
|
|
priv->reassoc_required = MFALSE;
|
|
#endif /* REASSOCIATION */
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
#if defined(UAP_SUPPORT)
|
|
/**
|
|
* @brief Get non-global oper class
|
|
*
|
|
* @param priv Pointer to moal_private structure
|
|
* @param bw bandwidth
|
|
* @param channel channel
|
|
* @param oper_class pointer to oper_class
|
|
|
|
* @return non-global operclass
|
|
*/
|
|
int woal_priv_get_nonglobal_operclass_by_bw_channel(moal_private *priv,
|
|
t_u8 bandwidth,
|
|
t_u8 channel,
|
|
t_u8 *oper_class)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)ioctl_req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_OPER_CLASS;
|
|
ioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
ioctl_req->action = MLAN_ACT_GET;
|
|
misc->param.bw_chan_oper.bandwidth = bandwidth;
|
|
misc->param.bw_chan_oper.channel = channel;
|
|
|
|
status = woal_request_ioctl(priv, ioctl_req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
*oper_class = misc->param.bw_chan_oper.oper_class;
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Send bss_start command to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param ssid_bssid A point to mlan_ssid_bssid structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_bss_start(moal_private *priv, t_u8 wait_option,
|
|
mlan_ssid_bssid *ssid_bssid)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status status;
|
|
|
|
ENTER();
|
|
|
|
/* Stop the O.S. TX queue When we are roaming */
|
|
woal_stop_queue(priv->netdev);
|
|
if (priv->media_connected == MFALSE) {
|
|
if (netif_carrier_ok(priv->netdev))
|
|
netif_carrier_off(priv->netdev);
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_START;
|
|
if (ssid_bssid)
|
|
moal_memcpy_ext(priv->phandle, &bss->param.ssid_bssid,
|
|
ssid_bssid, sizeof(mlan_ssid_bssid),
|
|
sizeof(mlan_ssid_bssid));
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (ssid_bssid)
|
|
moal_memcpy_ext(priv->phandle, ssid_bssid,
|
|
&bss->param.ssid_bssid, sizeof(mlan_ssid_bssid),
|
|
sizeof(mlan_ssid_bssid));
|
|
#ifdef STA_CFG80211
|
|
#ifdef STA_SUPPORT
|
|
priv->assoc_status = req->status_code;
|
|
#endif
|
|
#endif
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get BSS info
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param bss_info A pointer to mlan_bss_info structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_bss_info(moal_private *priv, t_u8 wait_option,
|
|
mlan_bss_info *bss_info)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_get_info *info = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_get_info));
|
|
if (req == NULL) {
|
|
PRINTM(MERROR,
|
|
"Fail to allocate the buffer for get bss_info\n");
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
info = (mlan_ds_get_info *)req->pbuf;
|
|
info->sub_command = MLAN_OID_GET_BSS_INFO;
|
|
req->req_id = MLAN_IOCTL_GET_INFO;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS) {
|
|
if (bss_info)
|
|
moal_memcpy_ext(priv->phandle, bss_info,
|
|
&info->param.bss_info,
|
|
sizeof(mlan_bss_info),
|
|
sizeof(mlan_bss_info));
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get generic IE
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param ie Information element
|
|
* @param ie_len Length of the IE
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_gen_ie(moal_private *priv, t_u32 action, t_u8 *ie,
|
|
int *ie_len, t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
if ((action == MLAN_ACT_GET) && (ie == NULL || ie_len == NULL)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
if (action == MLAN_ACT_SET && *ie_len > MAX_IE_SIZE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_GEN_IE;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = action;
|
|
misc->param.gen_ie.type = MLAN_IE_TYPE_GEN_IE;
|
|
|
|
if (action == MLAN_ACT_SET) {
|
|
misc->param.gen_ie.len = *ie_len;
|
|
if (*ie_len)
|
|
moal_memcpy_ext(priv->phandle,
|
|
misc->param.gen_ie.ie_data, ie, *ie_len,
|
|
MAX_IE_SIZE);
|
|
}
|
|
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (action == MLAN_ACT_GET) {
|
|
*ie_len = misc->param.gen_ie.len;
|
|
if (*ie_len)
|
|
moal_memcpy_ext(priv->phandle, ie,
|
|
misc->param.gen_ie.ie_data, *ie_len,
|
|
*ie_len);
|
|
}
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#ifdef STA_SUPPORT
|
|
/**
|
|
* @brief Set/Get retry count
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param wait_option Wait option
|
|
* @param value Retry value
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_retry(moal_private *priv, t_u32 action,
|
|
t_u8 wait_option, int *value)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_snmp_mib *mib = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_snmp_mib));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
mib = (mlan_ds_snmp_mib *)req->pbuf;
|
|
mib->sub_command = MLAN_OID_SNMP_MIB_RETRY_COUNT;
|
|
req->req_id = MLAN_IOCTL_SNMP_MIB;
|
|
req->action = action;
|
|
|
|
if (action == MLAN_ACT_SET) {
|
|
if (*value < MLAN_TX_RETRY_MIN || *value > MLAN_TX_RETRY_MAX) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
mib->param.retry_count = *value;
|
|
}
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS && action == MLAN_ACT_GET)
|
|
*value = mib->param.retry_count;
|
|
#ifdef STA_CFG80211
|
|
/* If set is invoked from other than iw i.e iwconfig,
|
|
* wiphy retry count should be updated as well */
|
|
if (IS_STA_CFG80211(priv->phandle->params.cfg80211_wext) &&
|
|
priv->wdev && priv->wdev->wiphy &&
|
|
(GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) &&
|
|
(action == MLAN_ACT_SET)) {
|
|
priv->wdev->wiphy->retry_long = (t_u8)*value;
|
|
priv->wdev->wiphy->retry_short = (t_u8)*value;
|
|
}
|
|
#endif
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Performs pre-warm-reset
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
*
|
|
* @return 0 if successful else negative value
|
|
*/
|
|
int woal_pre_warmreset(moal_private *priv)
|
|
{
|
|
moal_handle *handle = priv->phandle;
|
|
int ret = 0;
|
|
int intf_num;
|
|
#ifdef WIFI_DIRECT_SUPPORT
|
|
#if defined(STA_SUPPORT) && defined(UAP_SUPPORT)
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
t_u8 bss_role = MLAN_BSS_ROLE_STA;
|
|
#endif
|
|
#endif
|
|
#endif /* WIFI_DIRECT_SUPPORT */
|
|
|
|
ENTER();
|
|
#ifdef USB
|
|
#ifdef CONFIG_USB_SUSPEND
|
|
if (IS_USB(handle->card_type) && handle->is_suspended &&
|
|
woal_exit_usb_suspend(handle)) {
|
|
PRINTM(MERROR, "Failed to resume the suspended device\n");
|
|
LEAVE();
|
|
return -EFAULT;
|
|
}
|
|
#endif /* CONFIG_USB_SUSPEND */
|
|
#endif
|
|
woal_cancel_cac_block(priv);
|
|
/* Reset all interfaces */
|
|
ret = woal_reset_intf(priv, MOAL_IOCTL_WAIT, MTRUE);
|
|
/* Initialize private structures */
|
|
for (intf_num = 0; intf_num < handle->priv_num; intf_num++) {
|
|
woal_init_priv(handle->priv[intf_num], MOAL_IOCTL_WAIT);
|
|
#ifdef WIFI_DIRECT_SUPPORT
|
|
#if defined(STA_SUPPORT) && defined(UAP_SUPPORT)
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
if ((handle->priv[intf_num]->bss_type ==
|
|
MLAN_BSS_TYPE_WIFIDIRECT) &&
|
|
(GET_BSS_ROLE(handle->priv[intf_num]) ==
|
|
MLAN_BSS_ROLE_UAP)) {
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
woal_bss_role_cfg(handle->priv[intf_num],
|
|
MLAN_ACT_SET, MOAL_IOCTL_WAIT,
|
|
&bss_role)) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
#endif /* STA_WEXT || UAP_WEXT */
|
|
#endif /* STA_SUPPORT && UAP_SUPPORT */
|
|
#endif /* WIFI_DIRECT_SUPPORT */
|
|
}
|
|
woal_shutdown_fw(priv, MOAL_IOCTL_WAIT);
|
|
#ifdef WIFI_DIRECT_SUPPORT
|
|
#if defined(STA_SUPPORT) && defined(UAP_SUPPORT)
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
done:
|
|
#endif /* STA_WEXT || UAP_WEXT */
|
|
#endif /* STA_SUPPORT && UAP_SUPPORT */
|
|
#endif /* WIFI_DIRECT_SUPPORT */
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief warm reset
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
*
|
|
* @return 0 success, otherwise failure
|
|
*/
|
|
int woal_warmreset(moal_private *priv)
|
|
{
|
|
moal_handle *handle = priv->phandle;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
int ret = 0;
|
|
int intf_num;
|
|
|
|
/* Restart the firmware */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req) {
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_WARM_RESET;
|
|
misc->param.fw_reload = MTRUE;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
PRINTM(MERROR, "warm reset failure!\n");
|
|
ret = -EFAULT;
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
goto done;
|
|
}
|
|
kfree(req);
|
|
}
|
|
#ifdef USB
|
|
if (IS_USB(handle->card_type) && handle->params.usb_aggr == 1) {
|
|
/* Enable USB aggregation in FW */
|
|
if (woal_usb_aggr_init(handle)) {
|
|
PRINTM(MERROR, "usb aggr init fail\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (moal_extflg_isset(handle, EXT_AGGR_CTRL)) {
|
|
/* Enable aggregation in FW */
|
|
if (woal_init_aggr_ctrl(handle, MOAL_IOCTL_WAIT)) {
|
|
PRINTM(MERROR, "Fail to init aggr ctrl\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
/* Enable interfaces */
|
|
for (intf_num = 0; intf_num < handle->priv_num; intf_num++) {
|
|
netif_device_attach(handle->priv[intf_num]->netdev);
|
|
woal_start_queue(handle->priv[intf_num]->netdev);
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get RTS threshold
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param wait_option Wait option
|
|
* @param value RTS threshold value
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_rts(moal_private *priv, t_u32 action, t_u8 wait_option,
|
|
int *value)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_snmp_mib *mib = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_snmp_mib));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
mib = (mlan_ds_snmp_mib *)req->pbuf;
|
|
mib->sub_command = MLAN_OID_SNMP_MIB_RTS_THRESHOLD;
|
|
req->req_id = MLAN_IOCTL_SNMP_MIB;
|
|
req->action = action;
|
|
|
|
if (action == MLAN_ACT_SET) {
|
|
if (*value < MLAN_RTS_MIN_VALUE ||
|
|
*value > MLAN_RTS_MAX_VALUE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
mib->param.rts_threshold = *value;
|
|
}
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS && action == MLAN_ACT_GET)
|
|
*value = mib->param.rts_threshold;
|
|
#ifdef STA_CFG80211
|
|
/* If set is invoked from other than iw i.e iwconfig,
|
|
* wiphy RTS threshold should be updated as well */
|
|
if (IS_STA_CFG80211(priv->phandle->params.cfg80211_wext) &&
|
|
priv->wdev && priv->wdev->wiphy &&
|
|
(GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) &&
|
|
(action == MLAN_ACT_SET))
|
|
priv->wdev->wiphy->rts_threshold = *value;
|
|
#endif
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get Fragment threshold
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param wait_option Wait option
|
|
* @param value Fragment threshold value
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_frag(moal_private *priv, t_u32 action,
|
|
t_u8 wait_option, int *value)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_snmp_mib *mib = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_snmp_mib));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
mib = (mlan_ds_snmp_mib *)req->pbuf;
|
|
mib->sub_command = MLAN_OID_SNMP_MIB_FRAG_THRESHOLD;
|
|
req->req_id = MLAN_IOCTL_SNMP_MIB;
|
|
req->action = action;
|
|
|
|
if (action == MLAN_ACT_SET) {
|
|
if (*value < MLAN_FRAG_MIN_VALUE ||
|
|
*value > MLAN_FRAG_MAX_VALUE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
mib->param.frag_threshold = *value;
|
|
}
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS && action == MLAN_ACT_GET)
|
|
*value = mib->param.frag_threshold;
|
|
#ifdef STA_CFG80211
|
|
/* If set is invoked from other than iw i.e iwconfig,
|
|
* wiphy fragment threshold should be updated as well */
|
|
if (IS_STA_CFG80211(priv->phandle->params.cfg80211_wext) &&
|
|
priv->wdev && priv->wdev->wiphy &&
|
|
(GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) &&
|
|
(action == MLAN_ACT_SET))
|
|
priv->wdev->wiphy->frag_threshold = *value;
|
|
#endif
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get TX power
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param power_cfg A pinter to mlan_power_cfg_t structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_tx_power(moal_private *priv, t_u32 action,
|
|
mlan_power_cfg_t *power_cfg)
|
|
{
|
|
mlan_ds_power_cfg *pcfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_power_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
pcfg = (mlan_ds_power_cfg *)req->pbuf;
|
|
pcfg->sub_command = MLAN_OID_POWER_CFG;
|
|
req->req_id = MLAN_IOCTL_POWER_CFG;
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET && power_cfg)
|
|
moal_memcpy_ext(priv->phandle, &pcfg->param.power_cfg,
|
|
power_cfg, sizeof(mlan_power_cfg_t),
|
|
sizeof(mlan_power_cfg_t));
|
|
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (ret == MLAN_STATUS_SUCCESS && power_cfg)
|
|
moal_memcpy_ext(priv->phandle, power_cfg,
|
|
&pcfg->param.power_cfg,
|
|
sizeof(mlan_power_cfg_t),
|
|
sizeof(mlan_power_cfg_t));
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get IEEE power management
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param disabled A pointer to disabled flag
|
|
* @param power_type IEEE power type
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_power_mgmt(moal_private *priv, t_u32 action,
|
|
int *disabled, int power_type,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_pm_cfg *pm_cfg = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
pm_cfg = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pm_cfg->sub_command = MLAN_OID_PM_CFG_IEEE_PS;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
req->action = action;
|
|
|
|
if (action == MLAN_ACT_SET) {
|
|
PRINTM(MINFO, "PS_MODE set power disabled=%d power type=%#x\n",
|
|
*disabled, power_type);
|
|
if (*disabled)
|
|
pm_cfg->param.ps_mode = 0;
|
|
else {
|
|
/* Check not support case only (vwrq->disabled == FALSE)
|
|
*/
|
|
if ((power_type & MW_POWER_TYPE) == MW_POWER_TIMEOUT) {
|
|
PRINTM(MERROR,
|
|
"Setting power timeout is not supported\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
} else if ((power_type & MW_POWER_TYPE) ==
|
|
MW_POWER_PERIOD) {
|
|
PRINTM(MERROR,
|
|
"Setting power period is not supported\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
pm_cfg->param.ps_mode = 1;
|
|
}
|
|
}
|
|
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (ret == MLAN_STATUS_SUCCESS && action == MLAN_ACT_GET)
|
|
*disabled = pm_cfg->param.ps_mode;
|
|
|
|
#ifdef STA_CFG80211
|
|
/* If set is invoked from other than iw i.e iwconfig,
|
|
* wiphy IEEE power save mode should be updated */
|
|
if (IS_STA_CFG80211(priv->phandle->params.cfg80211_wext) &&
|
|
priv->wdev && (GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA) &&
|
|
(action == MLAN_ACT_SET)) {
|
|
if (*disabled)
|
|
priv->wdev->ps = MFALSE;
|
|
else
|
|
priv->wdev->ps = MTRUE;
|
|
}
|
|
#endif
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set Country Code
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param region A pointer to region string
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --success, otherwise
|
|
* fail
|
|
*/
|
|
static int woal_set_countrycode(moal_private *priv, char *country)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *pcfg_misc = NULL;
|
|
mlan_ds_misc_country_code *country_code = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
pcfg_misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
country_code = &pcfg_misc->param.country_code;
|
|
pcfg_misc->sub_command = MLAN_OID_MISC_COUNTRY_CODE;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
|
|
memset(country_code->country_code, 0, COUNTRY_CODE_LEN);
|
|
moal_memcpy_ext(priv->phandle, country_code->country_code, country,
|
|
COUNTRY_CODE_LEN - 1, COUNTRY_CODE_LEN - 1);
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set region code
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param region A pointer to region string
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --success, otherwise
|
|
* fail
|
|
*/
|
|
mlan_status woal_set_region_code(moal_private *priv, char *region)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_misc_cfg *cfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
if (woal_is_country_code_supported(region))
|
|
return woal_set_countrycode(priv, region);
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
cfg = (mlan_ds_misc_cfg *)req->pbuf;
|
|
cfg->sub_command = MLAN_OID_MISC_REGION;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
cfg->param.region_code = region_string_2_region_code(region);
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get data rate
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param datarate A pointer to mlan_rate_cfg_t structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_data_rate(moal_private *priv, t_u8 action,
|
|
mlan_rate_cfg_t *datarate)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_rate *rate = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_rate));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
rate = (mlan_ds_rate *)req->pbuf;
|
|
rate->param.rate_cfg.rate_type = MLAN_RATE_VALUE;
|
|
rate->sub_command = MLAN_OID_RATE_CFG;
|
|
req->req_id = MLAN_IOCTL_RATE;
|
|
req->action = action;
|
|
|
|
if (datarate && (action == MLAN_ACT_SET))
|
|
moal_memcpy_ext(priv->phandle, &rate->param.rate_cfg, datarate,
|
|
sizeof(mlan_rate_cfg_t),
|
|
sizeof(mlan_rate_cfg_t));
|
|
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret == MLAN_STATUS_SUCCESS && datarate && action == MLAN_ACT_GET)
|
|
moal_memcpy_ext(priv->phandle, datarate, &rate->param.rate_cfg,
|
|
sizeof(mlan_rate_cfg_t),
|
|
sizeof(mlan_rate_cfg_t));
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get assoc_resp buffer
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param assoc_rsp A pointer to mlan_ds_misc_assoc_rsp structure
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_assoc_rsp(moal_private *priv,
|
|
mlan_ds_misc_assoc_rsp *assoc_rsp,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
PRINTM(MERROR, "Fail to allocate buffer for get assoc resp\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
misc = (pmlan_ds_misc_cfg)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_ASSOC_RSP;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS && assoc_rsp)
|
|
moal_memcpy_ext(priv->phandle, assoc_rsp,
|
|
&misc->param.assoc_resp,
|
|
sizeof(mlan_ds_misc_assoc_rsp),
|
|
sizeof(mlan_ds_misc_assoc_rsp));
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Send get FW info request to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param fw_info FW information
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_request_get_fw_info(moal_private *priv, t_u8 wait_option,
|
|
mlan_fw_info *fw_info)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_get_info *info;
|
|
mlan_status status;
|
|
ENTER();
|
|
memset(priv->current_addr, 0xff, ETH_ALEN);
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(
|
|
sizeof(mlan_ds_get_info));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
info = (mlan_ds_get_info *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_GET_INFO;
|
|
req->action = MLAN_ACT_GET;
|
|
info->sub_command = MLAN_OID_GET_FW_INFO;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS) {
|
|
priv->phandle->fw_release_number = info->param.fw_info.fw_ver;
|
|
priv->phandle->fw_hotfix_version =
|
|
info->param.fw_info.hotfix_version;
|
|
priv->phandle->fw_ecsa_enable = info->param.fw_info.ecsa_enable;
|
|
priv->phandle->fw_getlog_enable =
|
|
info->param.fw_info.getlog_enable;
|
|
if (priv->current_addr[0] == 0xff)
|
|
moal_memcpy_ext(priv->phandle, priv->current_addr,
|
|
&info->param.fw_info.mac_addr,
|
|
sizeof(mlan_802_11_mac_addr), ETH_ALEN);
|
|
moal_memcpy_ext(priv->phandle, priv->netdev->dev_addr,
|
|
priv->current_addr, ETH_ALEN, ETH_ALEN);
|
|
if (fw_info)
|
|
moal_memcpy_ext(priv->phandle, fw_info,
|
|
&info->param.fw_info,
|
|
sizeof(mlan_fw_info),
|
|
sizeof(mlan_fw_info));
|
|
DBG_HEXDUMP(MCMD_D, "mac", priv->current_addr, 6);
|
|
} else
|
|
PRINTM(MERROR,
|
|
"get fw info failed! status=%d, error_code=0x%x\n",
|
|
status, req->status_code);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get current channel of active interface
|
|
*
|
|
* @param priv A pointer to moal_private
|
|
* @param channel A pointer to chan_band_info structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS or MLAN_STATUS_FAILURE
|
|
*/
|
|
mlan_status woal_get_active_intf_channel(moal_private *priv,
|
|
chan_band_info *channel)
|
|
{
|
|
moal_handle *handle = priv->phandle;
|
|
int i;
|
|
for (i = 0; i < handle->priv_num; i++) {
|
|
#ifdef STA_SUPPORT
|
|
if (GET_BSS_ROLE(handle->priv[i]) == MLAN_BSS_ROLE_STA) {
|
|
if (handle->priv[i]->media_connected == MTRUE)
|
|
return woal_get_sta_channel(handle->priv[i],
|
|
MOAL_IOCTL_WAIT,
|
|
channel);
|
|
}
|
|
#endif
|
|
#ifdef UAP_SUPPORT
|
|
if (GET_BSS_ROLE(handle->priv[i]) == MLAN_BSS_ROLE_UAP) {
|
|
if (handle->priv[i]->bss_started == MTRUE)
|
|
return woal_set_get_ap_channel(handle->priv[i],
|
|
MLAN_ACT_GET,
|
|
MOAL_IOCTL_WAIT,
|
|
channel);
|
|
}
|
|
#endif
|
|
}
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
|
|
#ifdef STA_SUPPORT
|
|
/**
|
|
* @brief Send get ext cap info request to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param buf data buffer
|
|
* @param len data buffer length
|
|
*
|
|
* @return number of bytes of extended capability -- success,
|
|
* otherwise error
|
|
*/
|
|
int woal_request_extcap(moal_private *priv, t_u8 *buf, t_u8 len)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *cfg = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
if (buf == NULL || len <= 0 || len < sizeof(ExtCap_t)) {
|
|
ret = -EINVAL;
|
|
goto out;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto out;
|
|
}
|
|
cfg = (mlan_ds_misc_cfg *)req->pbuf;
|
|
cfg->sub_command = MLAN_OID_MISC_EXT_CAP_CFG;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto out;
|
|
}
|
|
memset(buf, 0, len);
|
|
moal_memcpy_ext(priv->phandle, buf, &cfg->param.ext_cap,
|
|
sizeof(ExtCap_t), len);
|
|
ret = sizeof(ExtCap_t);
|
|
out:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Get debug info
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param debug_info A pointer to mlan_debug_info structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_debug_info(moal_private *priv, t_u8 wait_option,
|
|
mlan_debug_info *debug_info)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_get_info *info = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(t_u32) +
|
|
sizeof(mlan_debug_info));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
info = (mlan_ds_get_info *)req->pbuf;
|
|
info->sub_command = MLAN_OID_GET_DEBUG_INFO;
|
|
req->req_id = MLAN_IOCTL_GET_INFO;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS) {
|
|
if (debug_info) {
|
|
moal_memcpy_ext(priv->phandle, debug_info,
|
|
&info->param.debug_info,
|
|
sizeof(mlan_debug_info),
|
|
sizeof(mlan_debug_info));
|
|
}
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
/**
|
|
* @brief host command ioctl function
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wrq A pointer to iwreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_host_command(moal_private *priv, struct iwreq *wrq)
|
|
{
|
|
HostCmd_Header cmd_header;
|
|
int ret = 0;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Sanity check */
|
|
if (wrq->u.data.pointer == NULL) {
|
|
PRINTM(MERROR, "hostcmd IOCTL corrupt data\n");
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
memset(&cmd_header, 0, sizeof(cmd_header));
|
|
|
|
/* get command header */
|
|
if (copy_from_user(&cmd_header, wrq->u.data.pointer,
|
|
sizeof(HostCmd_Header))) {
|
|
PRINTM(MERROR, "copy from user failed: Host command header\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
misc->param.hostcmd.len = woal_le16_to_cpu(cmd_header.size);
|
|
|
|
PRINTM(MINFO, "Host command len = %u\n", misc->param.hostcmd.len);
|
|
|
|
if (!misc->param.hostcmd.len ||
|
|
misc->param.hostcmd.len > MRVDRV_SIZE_OF_CMD_BUFFER) {
|
|
PRINTM(MERROR, "Invalid data buffer length\n");
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
|
|
/* get the whole command from user */
|
|
if (copy_from_user(misc->param.hostcmd.cmd, wrq->u.data.pointer,
|
|
woal_le16_to_cpu(cmd_header.size))) {
|
|
PRINTM(MERROR, "copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
misc->sub_command = MLAN_OID_MISC_HOST_CMD;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
if (copy_to_user(wrq->u.data.pointer, (t_u8 *)misc->param.hostcmd.cmd,
|
|
misc->param.hostcmd.len)) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
wrq->u.data.length = misc->param.hostcmd.len;
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#if defined(WIFI_DIRECT_SUPPORT) || defined(UAP_SUPPORT)
|
|
/**
|
|
* @brief host command ioctl function
|
|
*
|
|
* @param dev A pointer to net_device structure
|
|
* @param req A pointer to ifreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
/********* format of ifr_data *************/
|
|
/* buf_len + Hostcmd_body */
|
|
/* buf_len: 4 bytes */
|
|
/* the length of the buf which */
|
|
/* can be used to return data */
|
|
/* to application */
|
|
/* Hostcmd_body */
|
|
/*******************************************/
|
|
int woal_hostcmd_ioctl(struct net_device *dev, struct ifreq *req)
|
|
{
|
|
moal_private *priv = (moal_private *)netdev_priv(dev);
|
|
t_u32 buf_len = 0;
|
|
HostCmd_Header cmd_header;
|
|
int ret = 0;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Sanity check */
|
|
if (req->ifr_data == NULL) {
|
|
PRINTM(MERROR, "uap_hostcmd_ioctl() corrupt data\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (copy_from_user(&buf_len, req->ifr_data, sizeof(buf_len))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
memset(&cmd_header, 0, sizeof(cmd_header));
|
|
|
|
/* get command header */
|
|
if (copy_from_user(&cmd_header, req->ifr_data + sizeof(buf_len),
|
|
sizeof(HostCmd_Header))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
PRINTM(MINFO, "Host command len = %d\n",
|
|
woal_le16_to_cpu(cmd_header.size));
|
|
|
|
if (woal_le16_to_cpu(cmd_header.size) > MRVDRV_SIZE_OF_CMD_BUFFER) {
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
misc = (mlan_ds_misc_cfg *)ioctl_req->pbuf;
|
|
|
|
misc->param.hostcmd.len = woal_le16_to_cpu(cmd_header.size);
|
|
|
|
/* get the whole command from user */
|
|
if (copy_from_user(misc->param.hostcmd.cmd,
|
|
req->ifr_data + sizeof(buf_len),
|
|
misc->param.hostcmd.len)) {
|
|
PRINTM(MERROR, "copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
misc->sub_command = MLAN_OID_MISC_HOST_CMD;
|
|
ioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
|
|
status = woal_request_ioctl(priv, ioctl_req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
if (misc->param.hostcmd.len > buf_len) {
|
|
PRINTM(MERROR,
|
|
"buf_len is too small, resp_len=%d, buf_len=%d\n",
|
|
(int)misc->param.hostcmd.len, (int)buf_len);
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
if (copy_to_user(req->ifr_data + sizeof(buf_len),
|
|
(t_u8 *)misc->param.hostcmd.cmd,
|
|
misc->param.hostcmd.len)) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief CUSTOM_IE ioctl handler
|
|
*
|
|
* @param dev A pointer to net_device structure
|
|
* @param req A pointer to ifreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_custom_ie_ioctl(struct net_device *dev, struct ifreq *req)
|
|
{
|
|
moal_private *priv = (moal_private *)netdev_priv(dev);
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ds_misc_custom_ie *pcustom_ie = NULL;
|
|
int ret = 0;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
|
|
/* Sanity check */
|
|
if (req->ifr_data == NULL) {
|
|
PRINTM(MERROR, "woal_custom_ie_ioctl() corrupt data\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
pcustom_ie = kzalloc(sizeof(mlan_ds_misc_custom_ie), flag);
|
|
if (!pcustom_ie) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
if (copy_from_user(pcustom_ie, req->ifr_data,
|
|
sizeof(mlan_ds_misc_custom_ie))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)ioctl_req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_CUSTOM_IE;
|
|
ioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
if ((pcustom_ie->len == 0) ||
|
|
(pcustom_ie->len == sizeof(pcustom_ie->ie_data_list[0].ie_index)))
|
|
ioctl_req->action = MLAN_ACT_GET;
|
|
else
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
|
|
moal_memcpy_ext(priv->phandle, &misc->param.cust_ie, pcustom_ie,
|
|
sizeof(mlan_ds_misc_custom_ie),
|
|
sizeof(mlan_ds_misc_custom_ie));
|
|
|
|
status = woal_request_ioctl(priv, ioctl_req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (ioctl_req->action == MLAN_ACT_GET) {
|
|
if (copy_to_user(req->ifr_data, &misc->param.cust_ie,
|
|
sizeof(mlan_ds_misc_custom_ie))) {
|
|
PRINTM(MERROR, "Copy to user failed!\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
} else if (ioctl_req->status_code == MLAN_ERROR_IOCTL_FAIL) {
|
|
/* send a separate error code to indicate error from driver */
|
|
ret = EFAULT;
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
kfree(pcustom_ie);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief send raw data packet ioctl function
|
|
*
|
|
* @param dev A pointer to net_device structure
|
|
* @param req A pointer to ifreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_send_host_packet(struct net_device *dev, struct ifreq *req)
|
|
{
|
|
moal_private *priv = (moal_private *)netdev_priv(dev);
|
|
t_u32 packet_len = 0;
|
|
int ret = 0;
|
|
pmlan_buffer pmbuf = NULL;
|
|
mlan_status status;
|
|
|
|
ENTER();
|
|
|
|
if (!priv || !priv->phandle) {
|
|
PRINTM(MERROR, "priv or handle is NULL\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
/* Sanity check */
|
|
if (req->ifr_data == NULL) {
|
|
PRINTM(MERROR, "woal_send_host_packet() corrupt data\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (copy_from_user(&packet_len, req->ifr_data, sizeof(packet_len))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
#define PACKET_HEADER_LEN 8
|
|
#define MV_ETH_FRAME_LEN 1514
|
|
if (packet_len > MV_ETH_FRAME_LEN) {
|
|
PRINTM(MERROR, "Invalid packet length %d\n", packet_len);
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
pmbuf = woal_alloc_mlan_buffer(
|
|
priv->phandle, (int)(MLAN_MIN_DATA_HEADER_LEN +
|
|
(int)packet_len + PACKET_HEADER_LEN));
|
|
if (!pmbuf) {
|
|
PRINTM(MERROR, "Fail to allocate mlan_buffer\n");
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
pmbuf->data_offset = MLAN_MIN_DATA_HEADER_LEN;
|
|
|
|
/* get whole packet and header */
|
|
if (copy_from_user(pmbuf->pbuf + pmbuf->data_offset,
|
|
req->ifr_data + sizeof(packet_len),
|
|
PACKET_HEADER_LEN + packet_len)) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
woal_free_mlan_buffer(priv->phandle, pmbuf);
|
|
goto done;
|
|
}
|
|
pmbuf->data_len = PACKET_HEADER_LEN + packet_len;
|
|
pmbuf->buf_type = MLAN_BUF_TYPE_RAW_DATA;
|
|
pmbuf->bss_index = priv->bss_index;
|
|
|
|
status = mlan_send_packet(priv->phandle->pmlan_adapter, pmbuf);
|
|
switch (status) {
|
|
case MLAN_STATUS_PENDING:
|
|
atomic_inc(&priv->phandle->tx_pending);
|
|
queue_work(priv->phandle->workqueue, &priv->phandle->main_work);
|
|
break;
|
|
case MLAN_STATUS_SUCCESS:
|
|
woal_free_mlan_buffer(priv->phandle, pmbuf);
|
|
break;
|
|
case MLAN_STATUS_FAILURE:
|
|
default:
|
|
woal_free_mlan_buffer(priv->phandle, pmbuf);
|
|
ret = -EFAULT;
|
|
break;
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#if defined(UAP_WEXT)
|
|
/**
|
|
* @brief Set/Get CUSTOM_IE ioctl handler
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param mask Mask to set or clear from caller
|
|
* @param ie IE buffer to set for beacon
|
|
* @param ie_len Length of the IE
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_set_get_custom_ie(moal_private *priv, t_u16 mask, t_u8 *ie, int ie_len)
|
|
{
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ds_misc_custom_ie *misc_ie = NULL;
|
|
int ret = 0;
|
|
custom_ie *pcust_bcn_ie = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (ioctl_req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)ioctl_req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_CUSTOM_IE;
|
|
ioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
misc_ie = &misc->param.cust_ie;
|
|
|
|
misc_ie->type = TLV_TYPE_MGMT_IE;
|
|
misc_ie->len = (sizeof(custom_ie) - MAX_IE_SIZE) + ie_len;
|
|
pcust_bcn_ie = misc_ie->ie_data_list;
|
|
pcust_bcn_ie->ie_index = 0xffff;
|
|
pcust_bcn_ie->mgmt_subtype_mask = mask;
|
|
pcust_bcn_ie->ie_length = ie_len;
|
|
moal_memcpy_ext(priv->phandle, pcust_bcn_ie->ie_buffer, ie, ie_len,
|
|
MAX_IE_SIZE);
|
|
|
|
status = woal_request_ioctl(priv, ioctl_req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS)
|
|
ret = -EFAULT;
|
|
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif /* defined(HOST_TXRX_MGMT_FRAME) && defined(UAP_WEXT) */
|
|
|
|
/**
|
|
* @brief TDLS configuration ioctl handler
|
|
*
|
|
* @param dev A pointer to net_device structure
|
|
* @param req A pointer to ifreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_tdls_config_ioctl(struct net_device *dev, struct ifreq *req)
|
|
{
|
|
moal_private *priv = (moal_private *)netdev_priv(dev);
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
mlan_ds_misc_tdls_config *tdls_data = NULL;
|
|
int ret = 0;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
|
|
/* Sanity check */
|
|
if (req->ifr_data == NULL) {
|
|
PRINTM(MERROR, "woal_tdls_config_ioctl() corrupt data\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
tdls_data = kzalloc(sizeof(mlan_ds_misc_tdls_config), flag);
|
|
if (!tdls_data) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
if (copy_from_user(tdls_data, req->ifr_data,
|
|
sizeof(mlan_ds_misc_tdls_config))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)ioctl_req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_TDLS_CONFIG;
|
|
ioctl_req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
if (tdls_data->tdls_action == WLAN_TDLS_DISCOVERY_REQ ||
|
|
tdls_data->tdls_action == WLAN_TDLS_LINK_STATUS)
|
|
ioctl_req->action = MLAN_ACT_GET;
|
|
else
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
|
|
moal_memcpy_ext(priv->phandle, &misc->param.tdls_config, tdls_data,
|
|
sizeof(mlan_ds_misc_tdls_config),
|
|
sizeof(mlan_ds_misc_tdls_config));
|
|
|
|
status = woal_request_ioctl(priv, ioctl_req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (tdls_data->tdls_action == WLAN_TDLS_DISCOVERY_REQ ||
|
|
tdls_data->tdls_action == WLAN_TDLS_LINK_STATUS) {
|
|
if (copy_to_user(req->ifr_data, &misc->param.tdls_config,
|
|
sizeof(mlan_ds_misc_tdls_config))) {
|
|
PRINTM(MERROR, "Copy to user failed!\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
kfree(tdls_data);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief ioctl function get BSS type
|
|
*
|
|
* @param dev A pointer to net_device structure
|
|
* @param req A pointer to ifreq structure
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_get_bss_type(struct net_device *dev, struct ifreq *req)
|
|
{
|
|
int ret = 0;
|
|
moal_private *priv = (moal_private *)netdev_priv(dev);
|
|
int bss_type;
|
|
|
|
ENTER();
|
|
|
|
bss_type = (int)priv->bss_type;
|
|
if (copy_to_user(req->ifr_data, &bss_type, sizeof(int))) {
|
|
PRINTM(MINFO, "Copy to user failed!\n");
|
|
ret = -EFAULT;
|
|
}
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#if defined(STA_SUPPORT) && defined(UAP_SUPPORT)
|
|
/**
|
|
* @brief Swithces BSS role of interface
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: set or get
|
|
* @param wait_option Wait option (MOAL_WAIT or MOAL_NO_WAIT)
|
|
* @param bss_role A pointer to bss role
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
mlan_status woal_bss_role_cfg(moal_private *priv, t_u8 action, t_u8 wait_option,
|
|
t_u8 *bss_role)
|
|
{
|
|
int ret = 0;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
struct net_device *dev = priv->netdev;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_ROLE;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET) {
|
|
if (priv->bss_role == *bss_role) {
|
|
PRINTM(MWARN, "BSS is in desired role already\n");
|
|
goto done;
|
|
} else {
|
|
bss->param.bss_role = *bss_role;
|
|
}
|
|
}
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (action == MLAN_ACT_GET) {
|
|
*bss_role = bss->param.bss_role;
|
|
} else {
|
|
/* Update moal_private */
|
|
priv->bss_role = *bss_role;
|
|
if (priv->bss_type == MLAN_BSS_TYPE_UAP)
|
|
priv->bss_type = MLAN_BSS_TYPE_STA;
|
|
else if (priv->bss_type == MLAN_BSS_TYPE_STA)
|
|
priv->bss_type = MLAN_BSS_TYPE_UAP;
|
|
|
|
if (*bss_role == MLAN_BSS_ROLE_UAP) {
|
|
/* Switch: STA -> uAP */
|
|
/* Setup the OS Interface to our functions */
|
|
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 29)
|
|
dev->do_ioctl = woal_uap_do_ioctl;
|
|
dev->set_multicast_list = woal_uap_set_multicast_list;
|
|
#else
|
|
dev->netdev_ops = &woal_uap_netdev_ops;
|
|
#endif
|
|
#ifdef UAP_WEXT
|
|
if (IS_UAP_WEXT(priv->phandle->params.cfg80211_wext)) {
|
|
#if WIRELESS_EXT < 21
|
|
dev->get_wireless_stats =
|
|
woal_get_uap_wireless_stats;
|
|
#endif
|
|
dev->wireless_handlers =
|
|
(struct iw_handler_def
|
|
*)&woal_uap_handler_def;
|
|
}
|
|
#endif /* UAP_WEXT */
|
|
} else if (*bss_role == MLAN_BSS_ROLE_STA) {
|
|
/* Switch: uAP -> STA */
|
|
/* Setup the OS Interface to our functions */
|
|
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2, 6, 29)
|
|
dev->do_ioctl = woal_do_ioctl;
|
|
dev->set_multicast_list = woal_set_multicast_list;
|
|
#else
|
|
dev->netdev_ops = &woal_netdev_ops;
|
|
#endif
|
|
#ifdef STA_WEXT
|
|
if (IS_STA_WEXT(priv->phandle->params.cfg80211_wext)) {
|
|
#if WIRELESS_EXT < 21
|
|
dev->get_wireless_stats =
|
|
woal_get_wireless_stats;
|
|
#endif
|
|
dev->wireless_handlers =
|
|
(struct iw_handler_def
|
|
*)&woal_handler_def;
|
|
}
|
|
#endif /* STA_WEXT */
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
/**
|
|
* @brief Set/Get BSS role
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wrq A pointer to iwreq structure
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_set_get_bss_role(moal_private *priv, struct iwreq *wrq)
|
|
{
|
|
int ret = 0;
|
|
int bss_role = 0;
|
|
t_u8 action = MLAN_ACT_GET;
|
|
|
|
ENTER();
|
|
|
|
if (wrq->u.data.length) {
|
|
if (copy_from_user(&bss_role, wrq->u.data.pointer,
|
|
sizeof(int))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
if ((bss_role != MLAN_BSS_ROLE_STA &&
|
|
bss_role != MLAN_BSS_ROLE_UAP)
|
|
#ifdef WIFI_DIRECT_SUPPORT
|
|
|| (priv->bss_type != MLAN_BSS_TYPE_WIFIDIRECT)
|
|
#endif
|
|
) {
|
|
PRINTM(MWARN, "Invalid BSS role\n");
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
if (bss_role == (int)GET_BSS_ROLE(priv)) {
|
|
PRINTM(MWARN, "Already BSS is in desired role\n");
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
action = MLAN_ACT_SET;
|
|
/* Reset interface */
|
|
woal_reset_intf(priv, MOAL_IOCTL_WAIT, MFALSE);
|
|
}
|
|
|
|
if (MLAN_STATUS_SUCCESS != woal_bss_role_cfg(priv, action,
|
|
MOAL_IOCTL_WAIT,
|
|
(t_u8 *)&bss_role)) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (!wrq->u.data.length) {
|
|
if (copy_to_user(wrq->u.data.pointer, &bss_role, sizeof(int))) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
wrq->u.data.length = 1;
|
|
} else {
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
if (IS_STA_OR_UAP_CFG80211(priv->phandle->params.cfg80211_wext))
|
|
woal_clear_all_mgmt_ies(priv, MOAL_IOCTL_WAIT);
|
|
#endif
|
|
/* Initialize private structures */
|
|
woal_init_priv(priv, MOAL_IOCTL_WAIT);
|
|
|
|
/* Enable interfaces */
|
|
netif_device_attach(priv->netdev);
|
|
woal_start_queue(priv->netdev);
|
|
}
|
|
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif /* STA_WEXT || UAP_WEXT */
|
|
#endif /* STA_SUPPORT && UAP_SUPPORT */
|
|
|
|
/**
|
|
* @brief Set/Get DTIM period
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param wait_option Wait option
|
|
* @param value DTIM period
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_dtim_period(moal_private *priv, t_u32 action,
|
|
t_u8 wait_option, t_u8 *value)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_snmp_mib *mib = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_snmp_mib));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
mib = (mlan_ds_snmp_mib *)req->pbuf;
|
|
mib->sub_command = MLAN_OID_SNMP_MIB_DTIM_PERIOD;
|
|
req->req_id = MLAN_IOCTL_SNMP_MIB;
|
|
req->action = action;
|
|
|
|
if (action == MLAN_ACT_SET)
|
|
mib->param.dtim_period = *value;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS && action == MLAN_ACT_GET)
|
|
*value = (t_u8)mib->param.dtim_period;
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get Host Sleep parameters
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: set or get
|
|
* @param wait_option Wait option (MOAL_WAIT or MOAL_NO_WAIT)
|
|
* @param hscfg A pointer to mlan_ds_hs_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_hs_params(moal_private *priv, t_u16 action,
|
|
t_u8 wait_option, mlan_ds_hs_cfg *hscfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_pm_cfg *pmcfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
pmcfg = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pmcfg->sub_command = MLAN_OID_PM_CFG_HS_CFG;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET)
|
|
moal_memcpy_ext(priv->phandle, &pmcfg->param.hs_cfg, hscfg,
|
|
sizeof(mlan_ds_hs_cfg), sizeof(mlan_ds_hs_cfg));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
if (hscfg && action == MLAN_ACT_GET) {
|
|
moal_memcpy_ext(priv->phandle, hscfg,
|
|
&pmcfg->param.hs_cfg,
|
|
sizeof(mlan_ds_hs_cfg),
|
|
sizeof(mlan_ds_hs_cfg));
|
|
}
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get wakeup reason
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wakeup_reason A pointer to mlan_ds_hs_wakeup_reason structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_get_wakeup_reason(moal_private *priv,
|
|
mlan_ds_hs_wakeup_reason *wakeup_reason)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_pm_cfg *pmcfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
pmcfg = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pmcfg->sub_command = MLAN_OID_PM_HS_WAKEUP_REASON;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT_TIMEOUT);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
wakeup_reason->hs_wakeup_reason =
|
|
pmcfg->param.wakeup_reason.hs_wakeup_reason;
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set or Get wowlan config
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: action to config wowlan
|
|
* @param wait_option Wait option (MOAL_WAIT or MOAL_NO_WAIT)
|
|
* @param mefcfg A pointer to mlan_ds_misc_mef_flt_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_FAILURE
|
|
*/
|
|
mlan_status woal_set_get_wowlan_config(moal_private *priv, t_u16 action,
|
|
t_u8 wait_option,
|
|
mlan_ds_misc_mef_flt_cfg *mefcfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_misc_cfg *misccfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
/** Allocate an IOCTL request buffer*/
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
/** Fill request buffer */
|
|
misccfg = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misccfg->sub_command = MLAN_OID_MISC_MEF_FLT_CFG;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = action;
|
|
moal_memcpy_ext(priv->phandle, &misccfg->param.mef_flt_cfg, mefcfg,
|
|
sizeof(mlan_ds_misc_mef_flt_cfg),
|
|
sizeof(mlan_ds_misc_mef_flt_cfg));
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
if (mefcfg && action == MLAN_ACT_GET) {
|
|
moal_memcpy_ext(priv->phandle, mefcfg,
|
|
&misccfg->param.mef_flt_cfg,
|
|
sizeof(mlan_ds_misc_mef_flt_cfg),
|
|
sizeof(mlan_ds_misc_mef_flt_cfg));
|
|
}
|
|
}
|
|
if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING)
|
|
PRINTM(MIOCTL, "Set Get wowlan IOCTL failed!\n");
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Cancel Host Sleep configuration
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS, MLAN_STATUS_PENDING,
|
|
* or MLAN_STATUS_FAILURE
|
|
*/
|
|
mlan_status woal_cancel_hs(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
#ifdef STA_CFG80211
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
|
|
moal_handle *handle = NULL;
|
|
#endif
|
|
#endif
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_hs_cfg hscfg;
|
|
#ifdef STA_CFG80211
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
|
|
int i;
|
|
#endif
|
|
#endif
|
|
ENTER();
|
|
|
|
if (!priv) {
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
/* Cancel Host Sleep */
|
|
hscfg.conditions = HOST_SLEEP_CFG_CANCEL;
|
|
hscfg.is_invoke_hostcmd = MTRUE;
|
|
ret = woal_set_get_hs_params(priv, MLAN_ACT_SET, wait_option, &hscfg);
|
|
|
|
#ifdef STA_CFG80211
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
|
|
handle = priv->phandle;
|
|
if (GTK_REKEY_OFFLOAD_SUSPEND == handle->params.gtk_rekey_offload) {
|
|
PRINTM(MIOCTL,
|
|
"Cancel Host Sleep... clear gtk rekey offload of FW\n");
|
|
for (i = 0; i < handle->priv_num; i++) {
|
|
if (handle->priv[i] &&
|
|
handle->priv[i]->gtk_data_ready) {
|
|
PRINTM(MCMND, "clear GTK in resume\n");
|
|
woal_set_rekey_data(handle->priv[i], NULL,
|
|
MLAN_ACT_CLEAR,
|
|
wait_option);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/** @brief This function enables the host sleep
|
|
*
|
|
* @param priv A Pointer to the moal_private structure
|
|
* @return MTRUE or MFALSE
|
|
*/
|
|
int woal_enable_hs(moal_private *priv)
|
|
{
|
|
mlan_ds_hs_cfg hscfg;
|
|
moal_handle *handle = NULL;
|
|
int hs_actived = MFALSE;
|
|
int timeout = 0;
|
|
int i;
|
|
#ifdef SDIO_SUSPEND_RESUME
|
|
mlan_ds_ps_info pm_info;
|
|
#endif
|
|
pmlan_ds_misc_keep_alive keep_alive = NULL;
|
|
|
|
ENTER();
|
|
|
|
if (priv == NULL) {
|
|
PRINTM(MERROR, "Invalid priv\n");
|
|
goto done;
|
|
}
|
|
handle = priv->phandle;
|
|
if (handle->hs_activated == MTRUE) {
|
|
PRINTM(MIOCTL, "HS Already actived\n");
|
|
hs_actived = MTRUE;
|
|
goto done;
|
|
}
|
|
for (i = 0; i < MIN(handle->priv_num, MLAN_MAX_BSS_NUM); i++) {
|
|
if (handle->priv[i] &&
|
|
(GET_BSS_ROLE(handle->priv[i]) == MLAN_BSS_ROLE_STA)) {
|
|
if (moal_extflg_isset(handle,
|
|
EXT_DISCONNECT_ON_SUSPEND) &&
|
|
handle->priv[i]->media_connected == MTRUE) {
|
|
PRINTM(MIOCTL, "disconnect on suspend\n");
|
|
woal_disconnect(handle->priv[i], MOAL_NO_WAIT,
|
|
NULL, DEF_DEAUTH_REASON_CODE);
|
|
}
|
|
}
|
|
if (handle->priv[i]) {
|
|
PRINTM(MIOCTL, "woal_delba_all on priv[%d]\n", i);
|
|
woal_delba_all(handle->priv[i], MOAL_NO_WAIT);
|
|
}
|
|
}
|
|
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(2, 6, 39)
|
|
if (priv->phandle->is_remain_timer_set) {
|
|
woal_cancel_timer(&priv->phandle->remain_timer);
|
|
woal_remain_timer_func(priv->phandle);
|
|
}
|
|
/* cancel pending remain on channel */
|
|
if (priv->phandle->remain_on_channel) {
|
|
t_u8 channel_status;
|
|
moal_private *remain_priv =
|
|
priv->phandle->priv[priv->phandle->remain_bss_index];
|
|
if (remain_priv) {
|
|
woal_cfg80211_remain_on_channel_cfg(remain_priv,
|
|
MOAL_NO_WAIT, MTRUE,
|
|
&channel_status,
|
|
NULL, 0, 0);
|
|
if (priv->phandle->cookie) {
|
|
cfg80211_remain_on_channel_expired(
|
|
#if CFG80211_VERSION_CODE < KERNEL_VERSION(3, 6, 0)
|
|
remain_priv->netdev,
|
|
#else
|
|
remain_priv->wdev,
|
|
#endif
|
|
priv->phandle->cookie,
|
|
&priv->phandle->chan,
|
|
#if CFG80211_VERSION_CODE < KERNEL_VERSION(3, 8, 0)
|
|
priv->phandle->channel_type,
|
|
#endif
|
|
GFP_ATOMIC);
|
|
priv->phandle->cookie = 0;
|
|
}
|
|
}
|
|
priv->phandle->remain_on_channel = MFALSE;
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
#ifdef STA_SUPPORT
|
|
woal_reconfig_bgscan(priv->phandle);
|
|
#endif
|
|
|
|
#ifdef STA_CFG80211
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 1, 0)
|
|
if (GTK_REKEY_OFFLOAD_SUSPEND == handle->params.gtk_rekey_offload) {
|
|
PRINTM(MIOCTL,
|
|
"Host Sleep enabled... set gtk rekey offload to FW\n");
|
|
for (i = 0; i < handle->priv_num; i++) {
|
|
if (handle->priv[i] &&
|
|
handle->priv[i]->gtk_data_ready) {
|
|
PRINTM(MCMND, "set GTK before suspend\n");
|
|
woal_set_rekey_data(
|
|
handle->priv[i],
|
|
&handle->priv[i]->gtk_rekey_data,
|
|
MLAN_ACT_SET, MOAL_NO_WAIT);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endif
|
|
|
|
for (i = 0; i < MAX_KEEP_ALIVE_ID; i++) {
|
|
keep_alive = &handle->keep_alive[i];
|
|
if (keep_alive && keep_alive->cached && keep_alive->enable) {
|
|
keep_alive->cached = false;
|
|
woal_start_mkeep_alive(
|
|
woal_get_priv(handle, MLAN_BSS_ROLE_ANY),
|
|
keep_alive->mkeep_alive_id, keep_alive->packet,
|
|
keep_alive->pkt_len, keep_alive->src_mac,
|
|
keep_alive->dst_mac, keep_alive->send_interval,
|
|
keep_alive->retry_interval,
|
|
keep_alive->retry_count);
|
|
keep_alive->pkt_len = 0;
|
|
memset(keep_alive->packet, 0, MKEEP_ALIVE_IP_PKT_MAX);
|
|
}
|
|
}
|
|
/* Enable Host Sleep */
|
|
handle->hs_activate_wait_q_woken = MFALSE;
|
|
memset(&hscfg, 0, sizeof(mlan_ds_hs_cfg));
|
|
hscfg.is_invoke_hostcmd = MTRUE;
|
|
if (woal_set_get_hs_params(priv, MLAN_ACT_SET, MOAL_NO_WAIT, &hscfg) ==
|
|
MLAN_STATUS_FAILURE) {
|
|
PRINTM(MIOCTL, "IOCTL request HS enable failed\n");
|
|
goto done;
|
|
}
|
|
timeout = wait_event_timeout(handle->hs_activate_wait_q,
|
|
handle->hs_activate_wait_q_woken,
|
|
HS_ACTIVE_TIMEOUT);
|
|
#ifdef SDIO_MMC
|
|
if (IS_SD(handle->card_type)) {
|
|
sdio_claim_host(((struct sdio_mmc_card *)handle->card)->func);
|
|
}
|
|
#endif
|
|
|
|
#ifdef SDIO_SUSPEND_RESUME
|
|
memset(&pm_info, 0, sizeof(mlan_ds_ps_info));
|
|
#endif
|
|
if ((handle->hs_activated == MTRUE) ||
|
|
(handle->is_suspended == MTRUE)) {
|
|
PRINTM(MCMND, "suspend success! force=%u skip=%u\n",
|
|
handle->hs_force_count, handle->hs_skip_count);
|
|
hs_actived = MTRUE;
|
|
}
|
|
#ifdef SDIO_SUSPEND_RESUME
|
|
else if (IS_SD(handle->card_type)) {
|
|
handle->suspend_fail = MTRUE;
|
|
woal_get_pm_info(priv, &pm_info);
|
|
if (pm_info.is_suspend_allowed == MTRUE) {
|
|
#ifdef MMC_PM_FUNC_SUSPENDED
|
|
woal_wlan_is_suspended(priv->phandle);
|
|
#endif
|
|
handle->hs_force_count++;
|
|
PRINTM(MCMND, "suspend allowed! force=%u skip=%u\n",
|
|
handle->hs_force_count, handle->hs_skip_count);
|
|
hs_actived = MTRUE;
|
|
}
|
|
}
|
|
#endif /* SDIO_SUSPEND_RESUME*/
|
|
#ifdef SDIO_MMC
|
|
if (IS_SD(handle->card_type)) {
|
|
sdio_release_host(((struct sdio_mmc_card *)handle->card)->func);
|
|
}
|
|
#endif
|
|
if (hs_actived != MTRUE) {
|
|
handle->hs_skip_count++;
|
|
#ifdef SDIO_SUSPEND_RESUME
|
|
if (IS_SD(handle->card_type)) {
|
|
PRINTM(MCMND,
|
|
"suspend skipped! timeout=%d allow=%d force=%u skip=%u\n",
|
|
timeout, (int)pm_info.is_suspend_allowed,
|
|
handle->hs_force_count, handle->hs_skip_count);
|
|
}
|
|
#else
|
|
PRINTM(MCMND, "suspend skipped! timeout=%d skip=%u\n", timeout,
|
|
handle->hs_skip_count);
|
|
#endif
|
|
woal_cancel_hs(priv, MOAL_NO_WAIT);
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return hs_actived;
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
/**
|
|
* @brief This function send soft_reset command to firmware
|
|
*
|
|
* @param handle A pointer to moal_handle structure
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING on success,
|
|
* otherwise failure code
|
|
*/
|
|
mlan_status woal_request_soft_reset(moal_handle *handle)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
|
|
ENTER();
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req) {
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_SOFT_RESET;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
ret = woal_request_ioctl(woal_get_priv(handle,
|
|
MLAN_BSS_ROLE_ANY),
|
|
req, MOAL_IOCTL_WAIT);
|
|
}
|
|
|
|
handle->surprise_removed = MTRUE;
|
|
woal_sched_timeout(5);
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif /* CONFIG_PROC_FS */
|
|
|
|
/**
|
|
* @brief Set wapi enable
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param enable MTRUE or MFALSE
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_wapi_enable(moal_private *priv, t_u8 wait_option,
|
|
t_u32 enable)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_WAPI_ENABLED;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
sec->param.wapi_enabled = enable;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get version
|
|
*
|
|
* @param handle A pointer to moal_handle structure
|
|
* @param version A pointer to version buffer
|
|
* @param max_len max length of version buffer
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_get_version(moal_handle *handle, char *version, int max_len)
|
|
{
|
|
t_u8 hotfix_ver = 0;
|
|
union {
|
|
t_u32 l;
|
|
t_u8 c[4];
|
|
} ver;
|
|
char fw_ver[32];
|
|
|
|
ENTER();
|
|
|
|
hotfix_ver = handle->fw_hotfix_version;
|
|
ver.l = handle->fw_release_number;
|
|
|
|
if (hotfix_ver) {
|
|
snprintf(fw_ver, sizeof(fw_ver), "%u.%u.%u.p%u.%u", ver.c[2],
|
|
ver.c[1], ver.c[0], ver.c[3], hotfix_ver);
|
|
|
|
} else {
|
|
snprintf(fw_ver, sizeof(fw_ver), "%u.%u.%u.p%u", ver.c[2],
|
|
ver.c[1], ver.c[0], ver.c[3]);
|
|
}
|
|
|
|
snprintf(version, max_len, handle->driver_version, fw_ver);
|
|
|
|
LEAVE();
|
|
}
|
|
|
|
#if defined(STA_WEXT) || defined(UAP_WEXT)
|
|
/**
|
|
* @brief Get Driver Version
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param req A pointer to ifreq structure
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_get_driver_version(moal_private *priv, struct ifreq *req)
|
|
{
|
|
struct iwreq *wrq = (struct iwreq *)req;
|
|
int len;
|
|
char buf[MLAN_MAX_VER_STR_LEN];
|
|
ENTER();
|
|
|
|
woal_get_version(priv->phandle, buf, sizeof(buf) - 1);
|
|
|
|
len = strlen(buf);
|
|
if (wrq->u.data.pointer) {
|
|
if (copy_to_user(wrq->u.data.pointer, buf, len)) {
|
|
PRINTM(MERROR, "Copy to user failed\n");
|
|
LEAVE();
|
|
return -EFAULT;
|
|
}
|
|
wrq->u.data.length = len;
|
|
}
|
|
PRINTM(MINFO, "MOAL VERSION: %s\n", buf);
|
|
LEAVE();
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* @brief Get extended driver version
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param ireq A pointer to ifreq structure
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_get_driver_verext(moal_private *priv, struct ifreq *ireq)
|
|
{
|
|
struct iwreq *wrq = (struct iwreq *)ireq;
|
|
mlan_ds_get_info *info = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
int ret = 0;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_get_info));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
info = (mlan_ds_get_info *)req->pbuf;
|
|
info->sub_command = MLAN_OID_GET_VER_EXT;
|
|
req->req_id = MLAN_IOCTL_GET_INFO;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
if (!wrq->u.data.flags) {
|
|
info->param.ver_ext.version_str_sel =
|
|
*((int *)(wrq->u.name + SUBCMD_OFFSET));
|
|
} else {
|
|
if (copy_from_user(
|
|
&info->param.ver_ext.version_str_sel,
|
|
wrq->u.data.pointer,
|
|
sizeof(info->param.ver_ext.version_str_sel))) {
|
|
PRINTM(MERROR, "Copy from user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
} else {
|
|
if (((t_s32)(info->param.ver_ext.version_str_sel)) <
|
|
0) {
|
|
PRINTM(MERROR, "Invalid arguments!\n");
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
}
|
|
}
|
|
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
if (wrq->u.data.pointer) {
|
|
if (copy_to_user(wrq->u.data.pointer,
|
|
info->param.ver_ext.version_str,
|
|
strlen(info->param.ver_ext.version_str))) {
|
|
PRINTM(MERROR, "Copy to user failed\n");
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
wrq->u.data.length = strlen(info->param.ver_ext.version_str);
|
|
}
|
|
|
|
PRINTM(MINFO, "MOAL EXTENDED VERSION: %s\n",
|
|
info->param.ver_ext.version_str);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
#ifdef DEBUG_LEVEL1
|
|
/**
|
|
* @brief Set driver debug bit masks to mlan in order to enhance performance
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param drv_dbg Driver debug level
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_set_drvdbg(moal_private *priv, t_u32 drv_dbg)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
int ret = 0;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_DRVDBG;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
misc->param.drvdbg = drv_dbg;
|
|
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Mgmt frame forward registration
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: set or get
|
|
* @param pmgmt_subtype_mask A Pointer to mgmt frame subtype mask
|
|
* @param wait_option wait option (MOAL_WAIT or MOAL_NO_WAIT)
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_reg_rx_mgmt_ind(moal_private *priv, t_u16 action,
|
|
t_u32 *pmgmt_subtype_mask, t_u8 wait_option)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
int ret = 0;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_RX_MGMT_IND;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = action;
|
|
misc->param.mgmt_subtype_mask = *pmgmt_subtype_mask;
|
|
if (req->action == MLAN_ACT_SET)
|
|
moal_memcpy_ext(priv->phandle, &misc->param.mgmt_subtype_mask,
|
|
pmgmt_subtype_mask,
|
|
sizeof(misc->param.mgmt_subtype_mask),
|
|
sizeof(misc->param.mgmt_subtype_mask));
|
|
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
|
|
if (req->action == MLAN_ACT_GET)
|
|
moal_memcpy_ext(priv->phandle, pmgmt_subtype_mask,
|
|
&misc->param.mgmt_subtype_mask,
|
|
sizeof(misc->param.mgmt_subtype_mask),
|
|
sizeof(misc->param.mgmt_subtype_mask));
|
|
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get Transmit beamforming capabilities
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: set or get
|
|
* @param tx_bf_cap A pointer to tx_buf_cap buffer
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_tx_bf_cap(moal_private *priv, t_u16 action,
|
|
t_u32 *tx_bf_cap)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_11n_cfg *bf_cfg = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
if (!tx_bf_cap) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_11n_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bf_cfg = (mlan_ds_11n_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_11N_CFG;
|
|
bf_cfg->sub_command = MLAN_OID_11N_CFG_TX_BF_CAP;
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET)
|
|
bf_cfg->param.tx_bf_cap = *tx_bf_cap;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_SUCCESS) {
|
|
goto done;
|
|
}
|
|
|
|
if (action == MLAN_ACT_GET)
|
|
*tx_bf_cap = bf_cfg->param.tx_bf_cap;
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get Transmit beamforming configuration
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action: set or get
|
|
* @param tx_bf_cfg A pointer to tx_bf_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_get_tx_bf_cfg(moal_private *priv, t_u16 action,
|
|
mlan_ds_11n_tx_bf_cfg *tx_bf_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_11n_cfg *bf_cfg = NULL;
|
|
|
|
ENTER();
|
|
|
|
/* Sanity test */
|
|
if (tx_bf_cfg == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_11n_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bf_cfg = (mlan_ds_11n_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_11N_CFG;
|
|
bf_cfg->sub_command = MLAN_OID_11N_CFG_TX_BF_CFG;
|
|
|
|
req->action = action;
|
|
moal_memcpy_ext(priv->phandle, &bf_cfg->param.tx_bf, tx_bf_cfg,
|
|
sizeof(mlan_ds_11n_tx_bf_cfg),
|
|
sizeof(mlan_ds_11n_tx_bf_cfg));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (action == MLAN_ACT_GET)
|
|
moal_memcpy_ext(priv->phandle, tx_bf_cfg, &bf_cfg->param.tx_bf,
|
|
sizeof(mlan_ds_11n_tx_bf_cfg),
|
|
sizeof(mlan_ds_11n_tx_bf_cfg));
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Handle ioctl resp
|
|
*
|
|
* @param priv Pointer to moal_private structure
|
|
* @param req Pointer to mlan_ioctl_req structure
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_process_ioctl_resp(moal_private *priv, mlan_ioctl_req *req)
|
|
{
|
|
int cfg80211_wext;
|
|
|
|
ENTER();
|
|
|
|
if (priv == NULL) {
|
|
LEAVE();
|
|
return;
|
|
}
|
|
cfg80211_wext = priv->phandle->params.cfg80211_wext;
|
|
switch (req->req_id) {
|
|
case MLAN_IOCTL_GET_INFO:
|
|
#ifdef STA_WEXT
|
|
#ifdef STA_SUPPORT
|
|
if (IS_STA_WEXT(cfg80211_wext) &&
|
|
GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA)
|
|
woal_ioctl_get_info_resp(priv,
|
|
(mlan_ds_get_info *)req->pbuf);
|
|
#endif
|
|
#endif
|
|
#ifdef UAP_WEXT
|
|
#ifdef UAP_SUPPORT
|
|
if (IS_UAP_WEXT(cfg80211_wext) &&
|
|
GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_UAP)
|
|
woal_ioctl_get_uap_info_resp(
|
|
priv, (mlan_ds_get_info *)req->pbuf);
|
|
#endif
|
|
#endif
|
|
break;
|
|
#ifdef STA_WEXT
|
|
#ifdef STA_SUPPORT
|
|
case MLAN_IOCTL_BSS:
|
|
if (IS_STA_WEXT(cfg80211_wext) &&
|
|
GET_BSS_ROLE(priv) == MLAN_BSS_ROLE_STA)
|
|
woal_ioctl_get_bss_resp(priv, (mlan_ds_bss *)req->pbuf);
|
|
break;
|
|
#endif
|
|
#endif
|
|
case MLAN_IOCTL_MISC_CFG:
|
|
woal_ioctl_get_misc_conf(priv, (mlan_ds_misc_cfg *)req->pbuf);
|
|
default:
|
|
break;
|
|
}
|
|
|
|
LEAVE();
|
|
return;
|
|
}
|
|
|
|
/**
|
|
* @brief Get PM info
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param pm_info A pointer to mlan_ds_ps_info structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_pm_info(moal_private *priv, mlan_ds_ps_info *pm_info)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_pm_cfg *pmcfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
PRINTM(MERROR, "Fail to alloc mlan_ds_pm_cfg buffer\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
pmcfg = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pmcfg->sub_command = MLAN_OID_PM_INFO;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
if (pm_info) {
|
|
moal_memcpy_ext(priv->phandle, pm_info,
|
|
&pmcfg->param.ps_info,
|
|
sizeof(mlan_ds_ps_info),
|
|
sizeof(mlan_ds_ps_info));
|
|
}
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get Deep Sleep
|
|
*
|
|
* @param priv Pointer to the moal_private driver data struct
|
|
* @param data Pointer to return deep_sleep setting
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_get_deep_sleep(moal_private *priv, t_u32 *data)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_pm_cfg *pm = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
pm = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pm->sub_command = MLAN_OID_PM_CFG_DEEP_SLEEP;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
|
|
req->action = MLAN_ACT_GET;
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
*data = pm->param.auto_deep_sleep.auto_ds;
|
|
*(data + 1) = pm->param.auto_deep_sleep.idletime;
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set Deep Sleep
|
|
*
|
|
* @param priv Pointer to the moal_private driver data struct
|
|
* @param wait_option wait option
|
|
* @param bdeep_sleep TRUE--enalbe deepsleep, FALSE--disable deepsleep
|
|
* @param idletime Idle time for optimized PS API
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_set_deep_sleep(moal_private *priv, t_u8 wait_option,
|
|
BOOLEAN bdeep_sleep, t_u16 idletime)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_pm_cfg *pm = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
pm = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pm->sub_command = MLAN_OID_PM_CFG_DEEP_SLEEP;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
|
|
req->action = MLAN_ACT_SET;
|
|
if (bdeep_sleep == MTRUE) {
|
|
PRINTM(MIOCTL, "Deep Sleep: sleep\n");
|
|
pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_ON;
|
|
if (idletime)
|
|
pm->param.auto_deep_sleep.idletime = idletime;
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
} else {
|
|
PRINTM(MIOCTL, "%lu : Deep Sleep: wakeup\n", jiffies);
|
|
pm->param.auto_deep_sleep.auto_ds = DEEP_SLEEP_OFF;
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS && ret != MLAN_STATUS_PENDING) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Cancel CAC period block
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_cancel_cac_block(moal_private *priv)
|
|
{
|
|
ENTER();
|
|
/* if during CAC period, wake up wait queue */
|
|
if (priv->phandle->cac_period == MTRUE) {
|
|
priv->phandle->cac_period = MFALSE;
|
|
/* Make sure Chan Report is cancelled */
|
|
woal_11h_cancel_chan_report_ioctl(priv, MOAL_IOCTL_WAIT);
|
|
priv->phandle->meas_start_jiffies = 0;
|
|
if (priv->phandle->delay_bss_start == MTRUE)
|
|
priv->phandle->delay_bss_start = MFALSE;
|
|
if (priv->phandle->meas_wait_q_woken == MFALSE) {
|
|
priv->phandle->meas_wait_q_woken = MTRUE;
|
|
wake_up_interruptible(&priv->phandle->meas_wait_q);
|
|
}
|
|
#ifdef UAP_SUPPORT
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
|
if (priv->uap_host_based &&
|
|
moal_extflg_isset(priv->phandle, EXT_DFS_OFFLOAD))
|
|
woal_cfg80211_dfs_vendor_event(
|
|
priv, event_dfs_cac_aborted, &priv->chan);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
}
|
|
LEAVE();
|
|
}
|
|
|
|
/** MEAS report timeout value in seconds */
|
|
|
|
/**
|
|
* @brief Issue MLAN_OID_11H_CHANNEL_CHECK ioctl
|
|
*
|
|
* @param priv Pointer to the moal_private driver data struct
|
|
* @param wait_option wait option
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_11h_channel_check_ioctl(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_11h_cfg *ds_11hcfg = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
#ifdef UAP_SUPPORT
|
|
if (priv->skip_cac) {
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/* Skip sending request/report query when DFS_REPEATER_MODE is on. This
|
|
* would get rid of CAC timers before starting BSSes in
|
|
* DFS_REPEATER_MODE
|
|
*/
|
|
if (priv->phandle->dfs_repeater_mode) {
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
if (woal_is_any_interface_active(priv->phandle)) {
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_11h_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
ds_11hcfg = (mlan_ds_11h_cfg *)req->pbuf;
|
|
|
|
ds_11hcfg->sub_command = MLAN_OID_11H_CHANNEL_CHECK;
|
|
ds_11hcfg->param.chan_rpt_req.host_based = MFALSE;
|
|
req->req_id = MLAN_IOCTL_11H_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
/* Send Channel Check command and wait until the report is ready */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
goto done;
|
|
}
|
|
|
|
/* set flag from here */
|
|
priv->phandle->cac_period = MTRUE;
|
|
priv->phandle->meas_start_jiffies = jiffies;
|
|
priv->phandle->cac_timer_jiffies =
|
|
ds_11hcfg->param.chan_rpt_req.millisec_dwell_time * HZ / 1000;
|
|
|
|
#ifdef UAP_SUPPORT
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
#if CFG80211_VERSION_CODE >= KERNEL_VERSION(3, 14, 0)
|
|
if (priv->uap_host_based &&
|
|
moal_extflg_isset(priv->phandle, EXT_DFS_OFFLOAD))
|
|
woal_cfg80211_dfs_vendor_event(priv, event_dfs_cac_started,
|
|
&priv->chan);
|
|
#endif
|
|
#endif
|
|
#endif
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Issue MLAN_OID_11H_CHAN_REPORT_REQUEST ioctl to cancel dozer
|
|
*
|
|
* @param priv Pointer to the moal_private driver data struct
|
|
* @param wait_option wait option
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_11h_cancel_chan_report_ioctl(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
int ret = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_11h_cfg *ds_11hcfg = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
PRINTM(MCMND, "wlan: woal_11h_cancel_chan_report\n");
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_11h_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
ds_11hcfg = (mlan_ds_11h_cfg *)req->pbuf;
|
|
|
|
ds_11hcfg->sub_command = MLAN_OID_11H_CHAN_REPORT_REQUEST;
|
|
req->req_id = MLAN_IOCTL_11H_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
ds_11hcfg->param.chan_rpt_req.millisec_dwell_time = 0;
|
|
/* Send Channel Check command and wait until the report is ready */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set remain channel
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param pchan A pointer to mlan_ds_remain_chan structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_remain_channel_ioctl(moal_private *priv, t_u8 wait_option,
|
|
mlan_ds_remain_chan *pchan)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_radio_cfg *radio_cfg = NULL;
|
|
|
|
ENTER();
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_radio_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
radio_cfg = (mlan_ds_radio_cfg *)req->pbuf;
|
|
radio_cfg->sub_command = MLAN_OID_REMAIN_CHAN_CFG;
|
|
req->req_id = MLAN_IOCTL_RADIO_CFG;
|
|
|
|
req->action = MLAN_ACT_SET;
|
|
moal_memcpy_ext(priv->phandle, &radio_cfg->param.remain_chan, pchan,
|
|
sizeof(mlan_ds_remain_chan),
|
|
sizeof(mlan_ds_remain_chan));
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
moal_memcpy_ext(priv->phandle, pchan,
|
|
&radio_cfg->param.remain_chan,
|
|
sizeof(mlan_ds_remain_chan),
|
|
sizeof(mlan_ds_remain_chan));
|
|
PRINTM(MCMND,
|
|
"Remain_chan_cfg: remove=%d, channel=%d, remain_period=%d\n",
|
|
pchan->remove, pchan->channel, pchan->remain_period);
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#ifdef WIFI_DIRECT_SUPPORT
|
|
/**
|
|
* @brief set/get wifi direct mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action set or get
|
|
* @param mode A pointer to wifi direct mode
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_wifi_direct_mode_cfg(moal_private *priv, t_u16 action,
|
|
t_u16 *mode)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
|
|
ENTER();
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_WIFI_DIRECT_MODE;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET)
|
|
bss->param.wfd_mode = *mode;
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
*mode = bss->param.wfd_mode;
|
|
PRINTM(MIOCTL, "ACT=%d, wifi_direct_mode=%d\n", action, *mode);
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set p2p config
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param p2p_config A pointer to mlan_ds_wifi_direct_config structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_p2p_config(moal_private *priv, t_u32 action,
|
|
mlan_ds_wifi_direct_config *p2p_config)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc_cfg = NULL;
|
|
|
|
ENTER();
|
|
if (!p2p_config) {
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
misc_cfg = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc_cfg->sub_command = MLAN_OID_MISC_WIFI_DIRECT_CONFIG;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = action;
|
|
moal_memcpy_ext(priv->phandle, &misc_cfg->param.p2p_config, p2p_config,
|
|
sizeof(mlan_ds_wifi_direct_config),
|
|
sizeof(mlan_ds_wifi_direct_config));
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
if (action == MLAN_ACT_GET)
|
|
moal_memcpy_ext(priv->phandle, p2p_config,
|
|
&misc_cfg->param.p2p_config,
|
|
sizeof(mlan_ds_wifi_direct_config),
|
|
sizeof(mlan_ds_wifi_direct_config));
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif /* WIFI_DIRECT_SUPPORT */
|
|
|
|
#ifdef STA_SUPPORT
|
|
/**
|
|
* @brief Get STA Channel Info
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param channel A pointer to channel info
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_sta_channel(moal_private *priv, t_u8 wait_option,
|
|
chan_band_info *channel)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
PRINTM(MERROR, "woal_get_sta_channel req alloc fail\n");
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_BSS_CHAN_INFO;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS && channel)
|
|
moal_memcpy_ext(priv->phandle, channel,
|
|
&(bss->param.sta_channel),
|
|
sizeof(chan_band_info), sizeof(chan_band_info));
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get RSSI info
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param signal A pointer tp mlan_ds_get_signal structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_get_signal_info(moal_private *priv, t_u8 wait_option,
|
|
mlan_ds_get_signal *signal)
|
|
{
|
|
mlan_ds_get_info *info = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_get_info));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
info = (mlan_ds_get_info *)req->pbuf;
|
|
info->sub_command = MLAN_OID_GET_SIGNAL;
|
|
info->param.signal.selector = ALL_RSSI_INFO_MASK;
|
|
req->req_id = MLAN_IOCTL_GET_INFO;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS) {
|
|
if (signal)
|
|
moal_memcpy_ext(priv->phandle, signal,
|
|
&info->param.signal,
|
|
sizeof(mlan_ds_get_signal),
|
|
sizeof(mlan_ds_get_signal));
|
|
#ifdef STA_WEXT
|
|
if (IS_STA_WEXT(priv->phandle->params.cfg80211_wext)) {
|
|
if (info->param.signal.selector & BCN_RSSI_AVG_MASK)
|
|
priv->w_stats.qual.level =
|
|
info->param.signal.bcn_rssi_avg;
|
|
if (info->param.signal.selector & BCN_NF_AVG_MASK)
|
|
priv->w_stats.qual.noise =
|
|
info->param.signal.bcn_nf_avg;
|
|
}
|
|
#endif
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get scan table
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param scan_resp A pointer to mlan_scan_resp structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_get_scan_table(moal_private *priv, t_u8 wait_option,
|
|
mlan_scan_resp *scan_resp)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
if (!scan_resp) {
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
scan = (mlan_ds_scan *)req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_NORMAL;
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_GET;
|
|
moal_memcpy_ext(priv->phandle, (void *)&scan->param.scan_resp,
|
|
(void *)scan_resp, sizeof(mlan_scan_resp),
|
|
sizeof(mlan_scan_resp));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS) {
|
|
if (scan_resp) {
|
|
moal_memcpy_ext(priv->phandle, scan_resp,
|
|
&scan->param.scan_resp,
|
|
sizeof(mlan_scan_resp),
|
|
sizeof(mlan_scan_resp));
|
|
}
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Request a scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param req_ssid A pointer to mlan_802_11_ssid structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_request_scan(moal_private *priv, t_u8 wait_option,
|
|
mlan_802_11_ssid *req_ssid)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
moal_handle *handle = priv->phandle;
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
if (MOAL_ACQ_SEMAPHORE_BLOCK(&handle->async_sem)) {
|
|
PRINTM(MERROR, "Acquire semaphore error, request_scan\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
handle->scan_pending_on_block = MTRUE;
|
|
handle->scan_priv = priv;
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (ioctl_req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
scan = (mlan_ds_scan *)ioctl_req->pbuf;
|
|
|
|
if (req_ssid && req_ssid->ssid_len != 0) {
|
|
/* Specific SSID scan */
|
|
ioctl_req->req_id = MLAN_IOCTL_SCAN;
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
|
|
scan->sub_command = MLAN_OID_SCAN_SPECIFIC_SSID;
|
|
|
|
moal_memcpy_ext(handle, scan->param.scan_req.scan_ssid.ssid,
|
|
req_ssid->ssid, req_ssid->ssid_len,
|
|
MLAN_MAX_SSID_LENGTH);
|
|
scan->param.scan_req.scan_ssid.ssid_len =
|
|
MIN(MLAN_MAX_SSID_LENGTH, req_ssid->ssid_len);
|
|
} else {
|
|
/* Normal scan */
|
|
ioctl_req->req_id = MLAN_IOCTL_SCAN;
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
|
|
scan->sub_command = MLAN_OID_SCAN_NORMAL;
|
|
}
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, ioctl_req, wait_option);
|
|
|
|
if (status == MLAN_STATUS_FAILURE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
handle->scan_pending_on_block = MFALSE;
|
|
handle->scan_priv = NULL;
|
|
MOAL_REL_SEMAPHORE(&handle->async_sem);
|
|
}
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Change Adhoc Channel
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param channel The channel to be set.
|
|
* @param wait_option wait_option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS--success, MLAN_STATUS_FAILURE--fail
|
|
*/
|
|
mlan_status woal_change_adhoc_chan(moal_private *priv, int channel,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_bss_info bss_info;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
memset(&bss_info, 0, sizeof(bss_info));
|
|
|
|
/* Get BSS information */
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
woal_get_bss_info(priv, wait_option, &bss_info)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
if (bss_info.bss_mode == MLAN_BSS_MODE_INFRA) {
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
goto done;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Get current channel */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
bss->sub_command = MLAN_OID_IBSS_CHANNEL;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (bss->param.bss_chan.channel == (unsigned int)channel) {
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
goto done;
|
|
}
|
|
PRINTM(MINFO, "Updating Channel from %d to %d\n",
|
|
(int)bss->param.bss_chan.channel, channel);
|
|
|
|
if (bss_info.media_connected != MTRUE) {
|
|
ret = MLAN_STATUS_SUCCESS;
|
|
goto done;
|
|
}
|
|
|
|
/* Do disonnect*/
|
|
bss->sub_command = MLAN_OID_BSS_STOP;
|
|
memset((t_u8 *)&bss->param.bssid, 0, ETH_ALEN);
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
/* Do specific SSID scanning */
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
woal_request_scan(priv, wait_option, &bss_info.ssid)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
/* Start/Join Adhoc network */
|
|
bss->sub_command = MLAN_OID_BSS_START;
|
|
memset(&bss->param.ssid_bssid, 0, sizeof(mlan_ssid_bssid));
|
|
moal_memcpy_ext(priv->phandle, &bss->param.ssid_bssid.ssid,
|
|
&bss_info.ssid, sizeof(mlan_802_11_ssid),
|
|
sizeof(mlan_802_11_ssid));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Find the best network to associate
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param ssid_bssid A pointer to mlan_ssid_bssid structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_find_best_network(moal_private *priv, t_u8 wait_option,
|
|
mlan_ssid_bssid *ssid_bssid)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
if (!ssid_bssid) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_GET;
|
|
bss->sub_command = MLAN_OID_BSS_FIND_BSS;
|
|
|
|
moal_memcpy_ext(priv->phandle, &bss->param.ssid_bssid, ssid_bssid,
|
|
sizeof(mlan_ssid_bssid), sizeof(mlan_ssid_bssid));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_SUCCESS) {
|
|
moal_memcpy_ext(priv->phandle, ssid_bssid,
|
|
&bss->param.ssid_bssid, sizeof(mlan_ssid_bssid),
|
|
sizeof(mlan_ssid_bssid));
|
|
PRINTM(MINFO, "Find network: ssid=%s, " MACSTR ", idx=%d\n",
|
|
ssid_bssid->ssid.ssid,
|
|
MAC2STR((t_u8 *)&ssid_bssid->bssid),
|
|
(int)ssid_bssid->idx);
|
|
}
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Find the best network to associate
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param bssid A pointer to bssid
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_find_bssid(moal_private *priv, mlan_802_11_mac_addr bssid)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_GET;
|
|
bss->sub_command = MLAN_OID_BSS_FIND_BSSID;
|
|
|
|
moal_memcpy_ext(priv->phandle, &bss->param.bssid, bssid,
|
|
sizeof(mlan_802_11_mac_addr),
|
|
sizeof(mlan_802_11_mac_addr));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Check if AP channel is valid for STA Region
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param ssid_bssid A pointer to mlan_ssid_bssid structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_11d_check_ap_channel(moal_private *priv, t_u8 wait_option,
|
|
mlan_ssid_bssid *ssid_bssid)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_bss *bss = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
if (!ssid_bssid) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_bss));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
bss = (mlan_ds_bss *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_BSS;
|
|
req->action = MLAN_ACT_GET;
|
|
bss->sub_command = MLAN_OID_BSS_11D_CHECK_CHANNEL;
|
|
|
|
moal_memcpy_ext(priv->phandle, &bss->param.ssid_bssid, ssid_bssid,
|
|
sizeof(mlan_ssid_bssid), sizeof(mlan_ssid_bssid));
|
|
|
|
PRINTM(MINFO, "ssid=%s, " MACSTR ", idx=%d\n", ssid_bssid->ssid.ssid,
|
|
MAC2STR((t_u8 *)&ssid_bssid->bssid), (int)ssid_bssid->idx);
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get authentication mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param auth_mode A pointer to authentication mode
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_auth_mode(moal_private *priv, t_u8 wait_option,
|
|
t_u32 *auth_mode)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_AUTH_MODE;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS && auth_mode)
|
|
*auth_mode = sec->param.auth_mode;
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get encrypt mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param encrypt_mode A pointer to encrypt mode
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_encrypt_mode(moal_private *priv, t_u8 wait_option,
|
|
t_u32 *encrypt_mode)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_ENCRYPT_MODE;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS && encrypt_mode)
|
|
*encrypt_mode = sec->param.encrypt_mode;
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Get WPA enable
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param enable A pointer to wpa enable status
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_wpa_enable(moal_private *priv, t_u8 wait_option,
|
|
t_u32 *enable)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_WPA_ENABLED;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_GET;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
if (status == MLAN_STATUS_SUCCESS && enable)
|
|
*enable = sec->param.wpa_enabled;
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Set authentication mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param auth_mode Authentication mode
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_auth_mode(moal_private *priv, t_u8 wait_option,
|
|
t_u32 auth_mode)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_AUTH_MODE;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
sec->param.auth_mode = auth_mode;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Set encrypt mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param encrypt_mode Encryption mode
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_encrypt_mode(moal_private *priv, t_u8 wait_option,
|
|
t_u32 encrypt_mode)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_ENCRYPT_MODE;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
sec->param.encrypt_mode = encrypt_mode;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Set wpa enable
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param enable MTRUE or MFALSE
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_wpa_enable(moal_private *priv, t_u8 wait_option,
|
|
t_u32 enable)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_WPA_ENABLED;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
sec->param.wpa_enabled = enable;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief enable wep key
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING --
|
|
* success, otherwise fail
|
|
*/
|
|
mlan_status woal_enable_wep_key(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_sec_cfg *sec = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_sec_cfg));
|
|
if (req == NULL) {
|
|
status = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
sec = (mlan_ds_sec_cfg *)req->pbuf;
|
|
sec->sub_command = MLAN_OID_SEC_CFG_ENCRYPT_KEY;
|
|
req->req_id = MLAN_IOCTL_SEC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
sec->param.encrypt_key.key_disable = MFALSE;
|
|
sec->param.encrypt_key.key_index = MLAN_KEY_INDEX_DEFAULT;
|
|
sec->param.encrypt_key.is_current_wep_key = MTRUE;
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return status;
|
|
}
|
|
|
|
/**
|
|
* @brief Request user scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param scan_cfg A pointer to wlan_user_scan_config structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_request_userscan(moal_private *priv, t_u8 wait_option,
|
|
wlan_user_scan_cfg *scan_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
moal_handle *handle = priv->phandle;
|
|
ENTER();
|
|
|
|
if (MOAL_ACQ_SEMAPHORE_BLOCK(&handle->async_sem)) {
|
|
PRINTM(MERROR, "Acquire semaphore error, request_scan\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
handle->scan_pending_on_block = MTRUE;
|
|
handle->scan_priv = priv;
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan) +
|
|
sizeof(wlan_user_scan_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
scan = (mlan_ds_scan *)ioctl_req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_USER_CONFIG;
|
|
ioctl_req->req_id = MLAN_IOCTL_SCAN;
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
moal_memcpy_ext(handle, scan->param.user_scan.scan_cfg_buf, scan_cfg,
|
|
sizeof(wlan_user_scan_cfg), sizeof(wlan_user_scan_cfg));
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, ioctl_req, wait_option);
|
|
if (status == MLAN_STATUS_FAILURE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
else if (wait_option != MOAL_NO_WAIT) {
|
|
PRINTM(MMSG, "scan interrupted by Signal, Cancel it...");
|
|
woal_cancel_scan(priv, MOAL_IOCTL_WAIT_TIMEOUT);
|
|
}
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
handle->scan_pending_on_block = MFALSE;
|
|
handle->scan_priv = NULL;
|
|
MOAL_REL_SEMAPHORE(&handle->async_sem);
|
|
}
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief woal_get_scan_config
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param scan_cfg A pointer to scan_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_scan_config(moal_private *priv, mlan_scan_cfg *scan_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
scan = (mlan_ds_scan *)req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_CONFIG;
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_GET;
|
|
memset(&scan->param.scan_cfg, 0, sizeof(mlan_scan_cfg));
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret == MLAN_STATUS_SUCCESS && scan_cfg)
|
|
moal_memcpy_ext(priv->phandle, scan_cfg, &scan->param.scan_cfg,
|
|
sizeof(mlan_scan_cfg), sizeof(mlan_scan_cfg));
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set scan time
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param active_scan_time Active scan time
|
|
* @param passive_scan_time Passive scan time
|
|
* @param specific_scan_time Specific scan time
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_scan_time(moal_private *priv, t_u16 active_scan_time,
|
|
t_u16 passive_scan_time,
|
|
t_u16 specific_scan_time)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_scan_cfg scan_cfg;
|
|
|
|
ENTER();
|
|
|
|
memset(&scan_cfg, 0, sizeof(scan_cfg));
|
|
if (MLAN_STATUS_SUCCESS != woal_get_scan_config(priv, &scan_cfg)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
scan = (mlan_ds_scan *)req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_CONFIG;
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_SET;
|
|
memset(&scan->param.scan_cfg, 0, sizeof(mlan_scan_cfg));
|
|
scan_cfg.scan_time.active_scan_time = active_scan_time;
|
|
scan_cfg.scan_time.specific_scan_time = specific_scan_time;
|
|
scan_cfg.scan_time.passive_scan_time = passive_scan_time;
|
|
PRINTM(MIOCTL, "Set specific=%d, active=%d, passive=%d\n",
|
|
(int)active_scan_time, (int)passive_scan_time,
|
|
(int)specific_scan_time);
|
|
moal_memcpy_ext(priv->phandle, &scan->param.scan_cfg, &scan_cfg,
|
|
sizeof(mlan_scan_cfg), sizeof(mlan_scan_cfg));
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief request scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param scan_cfg A pointer to wlan_user_scan_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_do_scan(moal_private *priv, wlan_user_scan_cfg *scan_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
moal_handle *handle = priv->phandle;
|
|
|
|
ENTER();
|
|
if (handle->scan_pending_on_block == MTRUE) {
|
|
PRINTM(MINFO, "scan already in processing...\n");
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#ifdef REASSOCIATION
|
|
if (MOAL_ACQ_SEMAPHORE_BLOCK(&handle->reassoc_sem)) {
|
|
PRINTM(MERROR, "Acquire semaphore error, woal_do_combo_scan\n");
|
|
LEAVE();
|
|
return -EBUSY;
|
|
}
|
|
#endif /* REASSOCIATION */
|
|
priv->report_scan_result = MTRUE;
|
|
|
|
if (!scan_cfg)
|
|
ret = woal_request_scan(priv, MOAL_NO_WAIT, NULL);
|
|
else
|
|
ret = woal_request_userscan(priv, MOAL_NO_WAIT, scan_cfg);
|
|
|
|
#ifdef REASSOCIATION
|
|
MOAL_REL_SEMAPHORE(&handle->reassoc_sem);
|
|
#endif
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Cancel pending scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_cancel_scan(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
moal_handle *handle = priv->phandle;
|
|
moal_private *scan_priv = handle->scan_priv;
|
|
#ifdef STA_CFG80211
|
|
unsigned long flags;
|
|
#endif
|
|
/* If scan is in process, cancel the scan command */
|
|
if (!handle->scan_pending_on_block || !scan_priv)
|
|
return ret;
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_SET;
|
|
((mlan_ds_scan *)req->pbuf)->sub_command = MLAN_OID_SCAN_CANCEL;
|
|
ret = woal_request_ioctl(scan_priv, req, wait_option);
|
|
handle->scan_pending_on_block = MFALSE;
|
|
MOAL_REL_SEMAPHORE(&handle->async_sem);
|
|
#ifdef STA_CFG80211
|
|
spin_lock_irqsave(&handle->scan_req_lock, flags);
|
|
if (IS_STA_CFG80211(handle->params.cfg80211_wext) &&
|
|
handle->scan_request) {
|
|
/** some supplicant can not handle SCAN abort event */
|
|
if (scan_priv->bss_type == MLAN_BSS_TYPE_STA)
|
|
woal_cfg80211_scan_done(handle->scan_request, MTRUE);
|
|
else
|
|
woal_cfg80211_scan_done(handle->scan_request, MFALSE);
|
|
handle->scan_request = NULL;
|
|
}
|
|
spin_unlock_irqrestore(&handle->scan_req_lock, flags);
|
|
#endif
|
|
/* add 10ms delay, incase firmware delay 0x7f event after scan cancel
|
|
* command response */
|
|
woal_sched_timeout(10);
|
|
handle->scan_priv = NULL;
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief find ssid in scan_table
|
|
*
|
|
* @param priv A pointer to moal_private
|
|
* @param ssid_bssid A pointer to mlan_ssid_bssid structure
|
|
*
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_FAILURE
|
|
*/
|
|
int woal_find_essid(moal_private *priv, mlan_ssid_bssid *ssid_bssid,
|
|
t_u8 wait_option)
|
|
{
|
|
int ret = 0;
|
|
mlan_scan_resp scan_resp;
|
|
wifi_timeval t;
|
|
ENTER();
|
|
|
|
if (MLAN_STATUS_SUCCESS !=
|
|
woal_get_scan_table(priv, wait_option, &scan_resp)) {
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
#ifdef STA_CFG80211
|
|
if (priv->ft_pre_connect || priv->ft_ie_len) {
|
|
/** skip check the scan age out */
|
|
ret = woal_find_best_network(priv, wait_option, ssid_bssid);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
woal_get_monotonic_time(&t);
|
|
/** scan result timeout value */
|
|
#define SCAN_RESULT_AGEOUT 10
|
|
if (t.time_sec > (scan_resp.age_in_secs + SCAN_RESULT_AGEOUT)) {
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
ret = woal_find_best_network(priv, wait_option, ssid_bssid);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Request user scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param scan_cfg A pointer to wlan_bgscan_cfg structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_request_bgscan(moal_private *priv, t_u8 wait_option,
|
|
wlan_bgscan_cfg *scan_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *ioctl_req = NULL;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
ioctl_req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan) +
|
|
sizeof(wlan_bgscan_cfg));
|
|
if (ioctl_req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
scan = (mlan_ds_scan *)ioctl_req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_BGSCAN_CONFIG;
|
|
ioctl_req->req_id = MLAN_IOCTL_SCAN;
|
|
ioctl_req->action = MLAN_ACT_SET;
|
|
moal_memcpy_ext(priv->phandle, scan->param.user_scan.scan_cfg_buf,
|
|
scan_cfg, sizeof(wlan_bgscan_cfg),
|
|
sizeof(wlan_bgscan_cfg));
|
|
|
|
/* Send IOCTL request to MLAN */
|
|
status = woal_request_ioctl(priv, ioctl_req, wait_option);
|
|
if (status == MLAN_STATUS_FAILURE) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(ioctl_req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set bgscan config
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param buf A pointer to scan command buf
|
|
* @param length buf length
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_bg_scan(moal_private *priv, char *buf, int length)
|
|
{
|
|
t_u8 *ptr = buf + strlen("BGSCAN-CONFIG") + 1;
|
|
int buf_left = length - (strlen("BGSCAN-CONFIG") + 1);
|
|
int band = 0;
|
|
int num_ssid = 0;
|
|
int ssid_len = 0;
|
|
mlan_status ret = MLAN_STATUS_FAILURE;
|
|
|
|
ENTER();
|
|
memset(&priv->scan_cfg, 0, sizeof(priv->scan_cfg));
|
|
priv->scan_cfg.report_condition =
|
|
BG_SCAN_SSID_MATCH | BG_SCAN_WAIT_ALL_CHAN_DONE;
|
|
while (buf_left >= 2) {
|
|
switch (*ptr) {
|
|
case WEXT_CSCAN_SSID_SECTION:
|
|
ssid_len = *(ptr + 1);
|
|
if ((buf_left < (ssid_len + 2)) ||
|
|
(ssid_len > MLAN_MAX_SSID_LENGTH)) {
|
|
PRINTM(MERROR,
|
|
"Invalid ssid, buf_left=%d, ssid_len=%d\n",
|
|
buf_left, ssid_len);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
if (ssid_len &&
|
|
(num_ssid < (MRVDRV_MAX_SSID_LIST_LENGTH - 1))) {
|
|
strncpy(priv->scan_cfg.ssid_list[num_ssid].ssid,
|
|
ptr + 2, ssid_len);
|
|
priv->scan_cfg.ssid_list[num_ssid].max_len = 0;
|
|
PRINTM(MIOCTL, "BG scan: ssid=%s\n",
|
|
priv->scan_cfg.ssid_list[num_ssid].ssid);
|
|
num_ssid++;
|
|
}
|
|
buf_left -= ssid_len + 2;
|
|
ptr += ssid_len + 2;
|
|
break;
|
|
case WEXT_BGSCAN_RSSI_SECTION:
|
|
priv->scan_cfg.report_condition =
|
|
BG_SCAN_SSID_RSSI_MATCH |
|
|
BG_SCAN_WAIT_ALL_CHAN_DONE;
|
|
priv->scan_cfg.rssi_threshold = ptr[1];
|
|
PRINTM(MIOCTL, "BG scan: rssi_threshold=%d\n",
|
|
(int)priv->scan_cfg.rssi_threshold);
|
|
ptr += 2;
|
|
buf_left -= 2;
|
|
break;
|
|
case WEXT_BGSCAN_REPEAT_SECTION:
|
|
priv->scan_cfg.repeat_count = (t_u16)ptr[1];
|
|
PRINTM(MIOCTL, "BG scan: repeat_count=%d\n",
|
|
(int)priv->scan_cfg.repeat_count);
|
|
ptr += 2;
|
|
buf_left -= 2;
|
|
break;
|
|
case WEXT_BGSCAN_INTERVAL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid scan_interval, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
priv->scan_cfg.scan_interval =
|
|
(ptr[2] << 8 | ptr[1]) * 1000;
|
|
PRINTM(MIOCTL, "BG scan: scan_interval=%d\n",
|
|
(int)priv->scan_cfg.scan_interval);
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
default:
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
}
|
|
/** set bgscan when ssid_num > 0 */
|
|
if (num_ssid) {
|
|
if (MLAN_STATUS_SUCCESS != woal_get_band(priv, &band)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
switch (band) {
|
|
case WIFI_FREQUENCY_BAND_2GHZ:
|
|
priv->scan_cfg.chan_list[0].radio_type =
|
|
0 | BAND_SPECIFIED;
|
|
break;
|
|
case WIFI_FREQUENCY_BAND_5GHZ:
|
|
priv->scan_cfg.chan_list[0].radio_type =
|
|
1 | BAND_SPECIFIED;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
priv->scan_cfg.bss_type = MLAN_BSS_MODE_INFRA;
|
|
priv->scan_cfg.action = BG_SCAN_ACT_SET;
|
|
priv->scan_cfg.enable = MTRUE;
|
|
moal_memcpy_ext(priv->phandle, priv->scan_cfg.random_mac,
|
|
priv->random_mac, ETH_ALEN,
|
|
sizeof(priv->scan_cfg.random_mac));
|
|
ret = woal_request_bgscan(priv, MOAL_IOCTL_WAIT,
|
|
&priv->scan_cfg);
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#ifdef STA_CFG80211
|
|
/**
|
|
* @brief set bgscan and new rssi_low_threshold
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param set_rssi flag for set rssi_low_threshold
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_config_bgscan_and_rssi(moal_private *priv, t_u8 set_rssi)
|
|
{
|
|
char rssi_low[11];
|
|
mlan_bss_info bss_info;
|
|
int band = 0;
|
|
|
|
ENTER();
|
|
if (!priv->rssi_low) {
|
|
LEAVE();
|
|
return;
|
|
}
|
|
memset(&bss_info, 0, sizeof(bss_info));
|
|
woal_get_bss_info(priv, MOAL_IOCTL_WAIT, &bss_info);
|
|
if (!bss_info.media_connected) {
|
|
PRINTM(MIOCTL, "We already lost connection\n");
|
|
LEAVE();
|
|
return;
|
|
}
|
|
memset(&priv->scan_cfg, 0, sizeof(priv->scan_cfg));
|
|
strncpy(priv->scan_cfg.ssid_list[0].ssid, bss_info.ssid.ssid,
|
|
bss_info.ssid.ssid_len);
|
|
priv->scan_cfg.ssid_list[0].max_len = 0;
|
|
|
|
priv->scan_cfg.report_condition =
|
|
BG_SCAN_SSID_RSSI_MATCH | BG_SCAN_WAIT_ALL_CHAN_DONE;
|
|
priv->scan_cfg.rssi_threshold = priv->rssi_low - RSSI_HYSTERESIS;
|
|
priv->scan_cfg.repeat_count = DEF_REPEAT_COUNT;
|
|
priv->scan_cfg.scan_interval = MIN_BGSCAN_INTERVAL;
|
|
woal_get_band(priv, &band);
|
|
switch (band) {
|
|
case WIFI_FREQUENCY_BAND_2GHZ:
|
|
priv->scan_cfg.chan_list[0].radio_type = 0 | BAND_SPECIFIED;
|
|
break;
|
|
case WIFI_FREQUENCY_BAND_5GHZ:
|
|
priv->scan_cfg.chan_list[0].radio_type = 1 | BAND_SPECIFIED;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
priv->scan_cfg.bss_type = MLAN_BSS_MODE_INFRA;
|
|
priv->scan_cfg.action = BG_SCAN_ACT_SET;
|
|
priv->scan_cfg.enable = MTRUE;
|
|
moal_memcpy_ext(priv->phandle, priv->scan_cfg.random_mac,
|
|
priv->random_mac, ETH_ALEN,
|
|
sizeof(priv->scan_cfg.random_mac));
|
|
woal_request_bgscan(priv, MOAL_NO_WAIT, &priv->scan_cfg);
|
|
if (set_rssi &&
|
|
((priv->rssi_low + RSSI_HYSTERESIS) <= LOWEST_RSSI_THRESHOLD)) {
|
|
priv->rssi_low += RSSI_HYSTERESIS;
|
|
snprintf(rssi_low, sizeof(rssi_low), "%d", priv->rssi_low);
|
|
woal_set_rssi_low_threshold(priv, rssi_low, MOAL_NO_WAIT);
|
|
}
|
|
LEAVE();
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief stop bg scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_stop_bg_scan(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
wlan_bgscan_cfg scan_cfg;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
|
|
memset(&scan_cfg, 0, sizeof(scan_cfg));
|
|
scan_cfg.action = BG_SCAN_ACT_SET;
|
|
scan_cfg.enable = MFALSE;
|
|
ret = woal_request_bgscan(priv, wait_option, &scan_cfg);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set bgscan config
|
|
*
|
|
* @param handle A pointer to moal_handle structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
void woal_reconfig_bgscan(moal_handle *handle)
|
|
{
|
|
int i;
|
|
for (i = 0; i < MIN(handle->priv_num, MLAN_MAX_BSS_NUM); i++) {
|
|
if (handle->priv[i] &&
|
|
(GET_BSS_ROLE(handle->priv[i]) == MLAN_BSS_ROLE_STA)) {
|
|
if (handle->priv[i]->bg_scan_start &&
|
|
handle->priv[i]->bg_scan_reported) {
|
|
PRINTM(MIOCTL, "Reconfig BGSCAN\n");
|
|
woal_request_bgscan(handle->priv[i],
|
|
MOAL_NO_WAIT,
|
|
&handle->priv[i]->scan_cfg);
|
|
handle->priv[i]->bg_scan_reported = MFALSE;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief set rssi low threshold
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param rssi A pointer to low rssi
|
|
* @param wait_option Wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_rssi_low_threshold(moal_private *priv, char *rssi,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
int low_rssi = 0;
|
|
|
|
ENTER();
|
|
if (priv->media_connected == MFALSE)
|
|
goto done;
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
misc->sub_command = MLAN_OID_MISC_SUBSCRIBE_EVENT;
|
|
req->action = MLAN_ACT_SET;
|
|
misc->param.subscribe_event.evt_action = SUBSCRIBE_EVT_ACT_BITWISE_SET;
|
|
misc->param.subscribe_event.evt_bitmap = SUBSCRIBE_EVT_RSSI_LOW;
|
|
misc->param.subscribe_event.evt_bitmap |= SUBSCRIBE_EVT_PRE_BEACON_LOST;
|
|
misc->param.subscribe_event.pre_beacon_miss = DEFAULT_PRE_BEACON_MISS;
|
|
|
|
if (MLAN_STATUS_SUCCESS != woal_atoi(&low_rssi, rssi)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
#ifdef STA_CFG80211
|
|
priv->mrvl_rssi_low = low_rssi;
|
|
#endif
|
|
misc->param.subscribe_event.low_rssi = low_rssi;
|
|
misc->param.subscribe_event.low_rssi_freq = 0;
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret == MLAN_STATUS_FAILURE) {
|
|
PRINTM(MERROR, "request set rssi_low_threshold fail!\n");
|
|
goto done;
|
|
}
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#if defined(STA_CFG80211)
|
|
/**
|
|
* @brief set rssi low threshold
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param event_id event id.
|
|
* @param wait_option wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_rssi_threshold(moal_private *priv, t_u32 event_id,
|
|
t_u8 wait_option)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
|
|
ENTER();
|
|
if (priv->media_connected == MFALSE)
|
|
goto done;
|
|
if (priv->mrvl_rssi_low || !priv->cqm_rssi_thold)
|
|
goto done;
|
|
if (event_id == MLAN_EVENT_ID_FW_BCN_RSSI_LOW) {
|
|
if (priv->last_rssi_low < 100)
|
|
priv->last_rssi_low += priv->cqm_rssi_hyst;
|
|
priv->last_rssi_high = abs(priv->cqm_rssi_high_thold);
|
|
} else if (event_id == MLAN_EVENT_ID_FW_BCN_RSSI_HIGH) {
|
|
priv->last_rssi_low = abs(priv->cqm_rssi_thold);
|
|
if (priv->last_rssi_high > priv->cqm_rssi_hyst)
|
|
priv->last_rssi_high -= priv->cqm_rssi_hyst;
|
|
} else {
|
|
priv->last_rssi_low = abs(priv->cqm_rssi_thold);
|
|
priv->last_rssi_high = abs(priv->cqm_rssi_high_thold);
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
misc->sub_command = MLAN_OID_MISC_SUBSCRIBE_EVENT;
|
|
req->action = MLAN_ACT_SET;
|
|
if (!event_id && !priv->cqm_rssi_thold && !priv->cqm_rssi_hyst)
|
|
misc->param.subscribe_event.evt_action =
|
|
SUBSCRIBE_EVT_ACT_BITWISE_CLR;
|
|
else
|
|
misc->param.subscribe_event.evt_action =
|
|
SUBSCRIBE_EVT_ACT_BITWISE_SET;
|
|
misc->param.subscribe_event.evt_bitmap =
|
|
SUBSCRIBE_EVT_RSSI_LOW | SUBSCRIBE_EVT_RSSI_HIGH;
|
|
misc->param.subscribe_event.low_rssi_freq = 0;
|
|
misc->param.subscribe_event.low_rssi = priv->last_rssi_low;
|
|
misc->param.subscribe_event.high_rssi_freq = 0;
|
|
misc->param.subscribe_event.high_rssi = priv->last_rssi_high;
|
|
PRINTM(MIOCTL, "rssi_low=%d, rssi_high=%d action=%d\n",
|
|
(int)priv->last_rssi_low, (int)priv->last_rssi_high,
|
|
misc->param.subscribe_event.evt_action);
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Get power mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param powermode A pointer to powermode buf
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_powermode(moal_private *priv, int *powermode)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
int ps_mode;
|
|
|
|
ENTER();
|
|
|
|
if (MLAN_STATUS_SUCCESS != woal_set_get_power_mgmt(priv, MLAN_ACT_GET,
|
|
&ps_mode, 0,
|
|
MOAL_IOCTL_WAIT)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
if (ps_mode)
|
|
*powermode = MFALSE;
|
|
else
|
|
*powermode = MTRUE;
|
|
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set scan type
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param scan_type MLAN_SCAN_TYPE_ACTIVE/MLAN_SCAN_TYPE_PASSIVE
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_scan_type(moal_private *priv, t_u32 scan_type)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_scan_cfg scan_cfg;
|
|
|
|
ENTER();
|
|
memset(&scan_cfg, 0, sizeof(scan_cfg));
|
|
if (MLAN_STATUS_SUCCESS != woal_get_scan_config(priv, &scan_cfg)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
scan = (mlan_ds_scan *)req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_CONFIG;
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_SET;
|
|
memset(&scan->param.scan_cfg, 0, sizeof(mlan_scan_cfg));
|
|
scan_cfg.scan_type = scan_type;
|
|
PRINTM(MIOCTL, "Set scan_type=%d\n", (int)scan_type);
|
|
moal_memcpy_ext(priv->phandle, &scan->param.scan_cfg, &scan_cfg,
|
|
sizeof(mlan_scan_cfg), sizeof(mlan_scan_cfg));
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief enable/disable ext_scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param enable MTRUE -- enable, MFALSE --disable
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_enable_ext_scan(moal_private *priv, t_u8 enable)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_scan *scan = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_scan_cfg scan_cfg;
|
|
|
|
ENTER();
|
|
memset(&scan_cfg, 0, sizeof(scan_cfg));
|
|
if (MLAN_STATUS_SUCCESS != woal_get_scan_config(priv, &scan_cfg)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_scan));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
scan = (mlan_ds_scan *)req->pbuf;
|
|
scan->sub_command = MLAN_OID_SCAN_CONFIG;
|
|
req->req_id = MLAN_IOCTL_SCAN;
|
|
req->action = MLAN_ACT_SET;
|
|
memset(&scan->param.scan_cfg, 0, sizeof(mlan_scan_cfg));
|
|
scan_cfg.ext_scan = enable;
|
|
PRINTM(MIOCTL, "Set ext_scan=%d\n", (int)enable);
|
|
moal_memcpy_ext(priv->phandle, &scan->param.scan_cfg, &scan_cfg,
|
|
sizeof(mlan_scan_cfg), sizeof(mlan_scan_cfg));
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set power mode
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param powermode A pointer to powermode string.
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_powermode(moal_private *priv, char *powermode)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
int disabled;
|
|
|
|
ENTER();
|
|
|
|
if (*powermode == '1') {
|
|
PRINTM(MIOCTL, "Disable power save\n");
|
|
disabled = 1;
|
|
} else if (*powermode == '0') {
|
|
PRINTM(MIOCTL, "Enable power save\n");
|
|
disabled = 0;
|
|
} else {
|
|
PRINTM(MERROR, "unsupported power mode\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
if (MLAN_STATUS_SUCCESS != woal_set_get_power_mgmt(priv, MLAN_ACT_SET,
|
|
&disabled, 0,
|
|
MOAL_IOCTL_WAIT))
|
|
ret = MLAN_STATUS_FAILURE;
|
|
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set combo scan
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param buf A pointer to scan command buf
|
|
* @param length buf length
|
|
*
|
|
* @return 0 -- success, otherwise fail
|
|
*/
|
|
int woal_set_combo_scan(moal_private *priv, char *buf, int length)
|
|
{
|
|
int ret = 0;
|
|
wlan_user_scan_cfg scan_cfg;
|
|
t_u8 *ptr = buf + WEXT_CSCAN_HEADER_SIZE;
|
|
int buf_left = length - WEXT_CSCAN_HEADER_SIZE;
|
|
int num_ssid = 0;
|
|
int num_chan = 0;
|
|
int ssid_len = 0;
|
|
int i = 0;
|
|
t_u16 passive_scan_time = 0;
|
|
t_u16 specific_scan_time = 0;
|
|
|
|
ENTER();
|
|
memset(&scan_cfg, 0, sizeof(scan_cfg));
|
|
while (buf_left >= 2) {
|
|
switch (*ptr) {
|
|
case WEXT_CSCAN_SSID_SECTION:
|
|
ssid_len = *(ptr + 1);
|
|
if ((buf_left < (ssid_len + 2)) ||
|
|
(ssid_len > MLAN_MAX_SSID_LENGTH)) {
|
|
PRINTM(MERROR,
|
|
"Invalid ssid, buf_left=%d, ssid_len=%d\n",
|
|
buf_left, ssid_len);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
if (ssid_len &&
|
|
(num_ssid < (MRVDRV_MAX_SSID_LIST_LENGTH - 1))) {
|
|
strncpy(scan_cfg.ssid_list[num_ssid].ssid,
|
|
ptr + 2, ssid_len);
|
|
scan_cfg.ssid_list[num_ssid].max_len = 0;
|
|
PRINTM(MIOCTL, "Combo scan: ssid=%s\n",
|
|
scan_cfg.ssid_list[num_ssid].ssid);
|
|
num_ssid++;
|
|
}
|
|
buf_left -= ssid_len + 2;
|
|
ptr += ssid_len + 2;
|
|
break;
|
|
case WEXT_CSCAN_CHANNEL_SECTION:
|
|
num_chan = ptr[1];
|
|
if ((buf_left < (num_chan + 2)) ||
|
|
(num_chan > WLAN_USER_SCAN_CHAN_MAX)) {
|
|
PRINTM(MERROR,
|
|
"Invalid channel list, buf_left=%d, num_chan=%d\n",
|
|
buf_left, num_chan);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
for (i = 0; i < num_chan; i++) {
|
|
scan_cfg.chan_list[i].chan_number = ptr[2 + i];
|
|
PRINTM(MIOCTL, "Combo scan: chan=%d\n",
|
|
scan_cfg.chan_list[i].chan_number);
|
|
}
|
|
buf_left -= 2 + num_chan;
|
|
ptr += 2 + num_chan;
|
|
break;
|
|
case WEXT_CSCAN_PASV_DWELL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid PASV_DWELL_SECTION, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
passive_scan_time = ptr[2] << 8 | ptr[1];
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
case WEXT_CSCAN_HOME_DWELL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid HOME_DWELL_SECTION, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
specific_scan_time = ptr[2] << 8 | ptr[1];
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
default:
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
}
|
|
if (passive_scan_time || specific_scan_time) {
|
|
PRINTM(MIOCTL,
|
|
"Set passive_scan_time=%d specific_scan_time=%d\n",
|
|
passive_scan_time, specific_scan_time);
|
|
if (MLAN_STATUS_FAILURE ==
|
|
woal_set_scan_time(priv, 0, passive_scan_time,
|
|
specific_scan_time)) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
}
|
|
if (num_ssid || num_chan) {
|
|
if (num_ssid) {
|
|
/* Add broadcast scan to ssid_list */
|
|
scan_cfg.ssid_list[num_ssid].max_len = 0xff;
|
|
if (priv->scan_type == MLAN_SCAN_TYPE_PASSIVE)
|
|
woal_set_scan_type(priv, MLAN_SCAN_TYPE_ACTIVE);
|
|
}
|
|
if (MLAN_STATUS_FAILURE == woal_do_scan(priv, &scan_cfg))
|
|
ret = -EFAULT;
|
|
if (num_ssid && (priv->scan_type == MLAN_SCAN_TYPE_PASSIVE))
|
|
woal_set_scan_type(priv, MLAN_SCAN_TYPE_PASSIVE);
|
|
} else {
|
|
/* request broadcast scan */
|
|
if (MLAN_STATUS_FAILURE == woal_do_scan(priv, NULL))
|
|
ret = -EFAULT;
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Get band
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param band A pointer to band buf
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_get_band(moal_private *priv, int *band)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_radio_cfg *radio_cfg = NULL;
|
|
int support_band = 0;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_radio_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
radio_cfg = (mlan_ds_radio_cfg *)req->pbuf;
|
|
radio_cfg->sub_command = MLAN_OID_BAND_CFG;
|
|
req->req_id = MLAN_IOCTL_RADIO_CFG;
|
|
/* Get config_bands, adhoc_start_band and adhoc_channel values from MLAN
|
|
*/
|
|
req->action = MLAN_ACT_GET;
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (radio_cfg->param.band_cfg.config_bands &
|
|
(BAND_B | BAND_G | BAND_GN))
|
|
support_band |= WIFI_FREQUENCY_BAND_2GHZ;
|
|
if (radio_cfg->param.band_cfg.config_bands & (BAND_A | BAND_AN))
|
|
support_band |= WIFI_FREQUENCY_BAND_5GHZ;
|
|
*band = support_band;
|
|
if (support_band == WIFI_FREQUENCY_ALL_BAND)
|
|
*band = WIFI_FREQUENCY_BAND_AUTO;
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief set band
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param pband A pointer to band string.
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_band(moal_private *priv, char *pband)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
int band = 0;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_radio_cfg *radio_cfg = NULL;
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
int cfg80211_wext = priv->phandle->params.cfg80211_wext;
|
|
#endif
|
|
|
|
ENTER();
|
|
if (priv->media_connected == MTRUE) {
|
|
PRINTM(MERROR, "Set band is not allowed in connected state\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_radio_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
radio_cfg = (mlan_ds_radio_cfg *)req->pbuf;
|
|
radio_cfg->sub_command = MLAN_OID_BAND_CFG;
|
|
req->req_id = MLAN_IOCTL_RADIO_CFG;
|
|
|
|
/* Get fw supported values from MLAN */
|
|
req->action = MLAN_ACT_GET;
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
if (*pband == '0') {
|
|
PRINTM(MIOCTL, "Set band to AUTO\n");
|
|
band = radio_cfg->param.band_cfg.fw_bands;
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
if (IS_STA_OR_UAP_CFG80211(cfg80211_wext) && priv->wdev &&
|
|
priv->wdev->wiphy) {
|
|
if (radio_cfg->param.band_cfg.fw_bands & BAND_A)
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_5GHZ] =
|
|
&cfg80211_band_5ghz;
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_2GHZ] =
|
|
&cfg80211_band_2ghz;
|
|
}
|
|
#endif
|
|
} else if (*pband == '1') {
|
|
PRINTM(MIOCTL, "Set band to 5G\n");
|
|
if (!(radio_cfg->param.band_cfg.fw_bands & BAND_A)) {
|
|
PRINTM(MERROR, "Don't support 5G band\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
band = BAND_A;
|
|
if (radio_cfg->param.band_cfg.fw_bands & BAND_AN)
|
|
band |= BAND_AN;
|
|
if (radio_cfg->param.band_cfg.fw_bands & BAND_AAC)
|
|
band |= BAND_AAC;
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
if (IS_STA_OR_UAP_CFG80211(cfg80211_wext) && priv->wdev &&
|
|
priv->wdev->wiphy) {
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_5GHZ] =
|
|
&cfg80211_band_5ghz;
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = NULL;
|
|
}
|
|
#endif
|
|
} else if (*pband == '2') {
|
|
PRINTM(MIOCTL, "Set band to 2G\n");
|
|
band = BAND_B | BAND_G;
|
|
band |= BAND_GN;
|
|
#if defined(STA_CFG80211) || defined(UAP_CFG80211)
|
|
if (IS_STA_OR_UAP_CFG80211(cfg80211_wext) && priv->wdev &&
|
|
priv->wdev->wiphy) {
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = NULL;
|
|
priv->wdev->wiphy->bands[IEEE80211_BAND_2GHZ] =
|
|
&cfg80211_band_2ghz;
|
|
}
|
|
#endif
|
|
} else {
|
|
PRINTM(MERROR, "unsupported band\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
/* Set config_bands to MLAN */
|
|
req->action = MLAN_ACT_SET;
|
|
memset(&radio_cfg->param.band_cfg, 0, sizeof(mlan_ds_band_cfg));
|
|
radio_cfg->param.band_cfg.config_bands = band;
|
|
radio_cfg->param.band_cfg.adhoc_start_band = band;
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Add RX Filter
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param rxfilter A pointer to rxfilter string.
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_add_rxfilter(moal_private *priv, char *rxfilter)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
/* Android command:
|
|
"DRIVER RXFILTER-ADD 0"
|
|
"DRIVER RXFILTER-ADD 1"
|
|
"DRIVER RXFILTER-ADD 3" */
|
|
if (*rxfilter == '0') {
|
|
PRINTM(MIOCTL, "Add IPV4 multicast filter\n");
|
|
priv->rx_filter |= RX_FILTER_IPV4_MULTICAST;
|
|
} else if (*rxfilter == '1') {
|
|
PRINTM(MIOCTL, "Add broadcast filter\n");
|
|
priv->rx_filter |= RX_FILTER_BROADCAST;
|
|
} else if (*rxfilter == '2') {
|
|
PRINTM(MIOCTL, "Add unicast filter\n");
|
|
priv->rx_filter |= RX_FILTER_UNICAST;
|
|
} else if (*rxfilter == '3') {
|
|
PRINTM(MIOCTL, "Add IPV6 multicast fitler\n");
|
|
priv->rx_filter |= RX_FILTER_IPV6_MULTICAST;
|
|
} else {
|
|
PRINTM(MERROR, "unsupported rx fitler\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Remove RX Filter
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param rxfilter A pointer to rxfilter string.
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_remove_rxfilter(moal_private *priv, char *rxfilter)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
if (*rxfilter == '0') {
|
|
PRINTM(MIOCTL, "Remove IPV4 multicast filter\n");
|
|
priv->rx_filter &= ~RX_FILTER_IPV4_MULTICAST;
|
|
} else if (*rxfilter == '1') {
|
|
PRINTM(MIOCTL, "Remove broadcast filter\n");
|
|
priv->rx_filter &= ~RX_FILTER_BROADCAST;
|
|
} else if (*rxfilter == '2') {
|
|
PRINTM(MIOCTL, "Remove unicast filter\n");
|
|
priv->rx_filter &= ~RX_FILTER_UNICAST;
|
|
} else if (*rxfilter == '3') {
|
|
PRINTM(MIOCTL, "Remove IPV6 multicast fitler\n");
|
|
priv->rx_filter &= ~RX_FILTER_IPV6_MULTICAST;
|
|
} else {
|
|
PRINTM(MERROR, "unsupported rx fitler\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
done:
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set/Get WMM IE QoS configuration
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param action Action set or get
|
|
* @param qos_cfg A pointer to QoS configuration structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_priv_qos_cfg(moal_private *priv, t_u32 action, char *qos_cfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_wmm_cfg *cfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
int qosinfo = 0;
|
|
|
|
ENTER();
|
|
|
|
if (qos_cfg == NULL) {
|
|
PRINTM(MERROR, "QOS info buffer is null\n");
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
if ((action == MLAN_ACT_SET) &&
|
|
(MLAN_STATUS_SUCCESS != woal_atoi(&qosinfo, qos_cfg))) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_wmm_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
cfg = (mlan_ds_wmm_cfg *)req->pbuf;
|
|
cfg->sub_command = MLAN_OID_WMM_CFG_QOS;
|
|
req->req_id = MLAN_IOCTL_WMM_CFG;
|
|
req->action = action;
|
|
if (action == MLAN_ACT_SET) {
|
|
cfg->param.qos_cfg = (t_u8)qosinfo;
|
|
PRINTM(MIOCTL, "set qosinfo=%d\n", qosinfo);
|
|
}
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
if (action == MLAN_ACT_GET)
|
|
*qos_cfg = cfg->param.qos_cfg;
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set sleep period
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param psleeppd A pointer to sleep period configuration structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_set_sleeppd(moal_private *priv, char *psleeppd)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ds_pm_cfg *pm_cfg = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
int sleeppd = 0;
|
|
|
|
ENTER();
|
|
|
|
if (MLAN_STATUS_SUCCESS != woal_atoi(&sleeppd, psleeppd)) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
PRINTM(MIOCTL, "set sleeppd=%d\n", sleeppd);
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_pm_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
pm_cfg = (mlan_ds_pm_cfg *)req->pbuf;
|
|
pm_cfg->sub_command = MLAN_OID_PM_CFG_SLEEP_PD;
|
|
req->req_id = MLAN_IOCTL_PM_CFG;
|
|
if ((sleeppd <= MAX_SLEEP_PERIOD && sleeppd >= MIN_SLEEP_PERIOD) ||
|
|
(sleeppd == 0) || (sleeppd == SLEEP_PERIOD_RESERVED_FF)) {
|
|
req->action = MLAN_ACT_SET;
|
|
pm_cfg->param.sleep_period = sleeppd;
|
|
} else {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set scan period function
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param buf A pointer to scan command buf
|
|
* @param length buf length
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
int woal_set_scan_cfg(moal_private *priv, char *buf, int length)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
t_u8 *ptr = buf + NL80211_SCANCFG_HEADER_SIZE;
|
|
int buf_left = length - NL80211_SCANCFG_HEADER_SIZE;
|
|
t_u16 active_scan_time = 0;
|
|
t_u16 passive_scan_time = 0;
|
|
t_u16 specific_scan_time = 0;
|
|
|
|
ENTER();
|
|
while (buf_left >= 2) {
|
|
switch (*ptr) {
|
|
case NL80211_SCANCFG_ACTV_DWELL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid ACTV_DWELL_SECTION, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
active_scan_time = ptr[2] << 8 | ptr[1];
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
case NL80211_SCANCFG_PASV_DWELL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid PASV_DWELL_SECTION, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
passive_scan_time = ptr[2] << 8 | ptr[1];
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
case NL80211_SCANCFG_SPCF_DWELL_SECTION:
|
|
if (buf_left < 3) {
|
|
PRINTM(MERROR,
|
|
"Invalid SPCF_DWELL_SECTION, buf_left=%d\n",
|
|
buf_left);
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
specific_scan_time = ptr[2] << 8 | ptr[1];
|
|
ptr += 3;
|
|
buf_left -= 3;
|
|
break;
|
|
default:
|
|
buf_left = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (active_scan_time || passive_scan_time || specific_scan_time) {
|
|
PRINTM(MIOCTL,
|
|
"Set active_scan_time= %d passive_scan_time=%d specific_scan_time=%d\n",
|
|
active_scan_time, passive_scan_time, specific_scan_time);
|
|
if (MLAN_STATUS_FAILURE ==
|
|
woal_set_scan_time(priv, active_scan_time,
|
|
passive_scan_time, specific_scan_time)) {
|
|
ret = -EFAULT;
|
|
}
|
|
}
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Set Radio On/OFF
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param option Radio Option
|
|
*
|
|
* @return 0 --success, otherwise fail
|
|
*/
|
|
int woal_set_radio(moal_private *priv, t_u8 option)
|
|
{
|
|
int ret = 0;
|
|
mlan_ds_radio_cfg *radio = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
ENTER();
|
|
if ((option != 0) && (option != 1)) {
|
|
ret = -EINVAL;
|
|
goto done;
|
|
}
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_radio_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
radio = (mlan_ds_radio_cfg *)req->pbuf;
|
|
radio->sub_command = MLAN_OID_RADIO_CTRL;
|
|
req->req_id = MLAN_IOCTL_RADIO_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
radio->param.radio_on_off = option;
|
|
status = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (status != MLAN_STATUS_SUCCESS)
|
|
ret = -EFAULT;
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
#endif /* STA_SUPPORT */
|
|
|
|
#ifdef USB
|
|
/**
|
|
* @brief Initialize USB packet aggregation control
|
|
*
|
|
* @param handle A pointer to moal_private structure
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS -- success, otherwise fail
|
|
*/
|
|
mlan_status woal_usb_aggr_init(moal_handle *handle)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
moal_private *priv = NULL;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *pcfg_misc = NULL;
|
|
mlan_ds_misc_usb_aggr_ctrl *aggr_param = NULL;
|
|
t_u8 usb_aggr_enable;
|
|
struct usb_card_rec *cardp = NULL;
|
|
int i = 0, resubmit_urbs = 0;
|
|
|
|
ENTER();
|
|
|
|
if (!handle) {
|
|
PRINTM(MERROR, "Handle is null\n");
|
|
LEAVE();
|
|
return MLAN_STATUS_FAILURE;
|
|
}
|
|
priv = woal_get_priv(handle, MLAN_BSS_ROLE_STA);
|
|
if (!priv) {
|
|
PRINTM(MERROR, "STA priv is null\n");
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
if (handle->card == NULL) {
|
|
PRINTM(MERROR, "Card is null in %s()\n", __func__);
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
cardp = (struct usb_card_rec *)handle->card;
|
|
|
|
/* Check module parameter */
|
|
if (handle->params.usb_aggr == 0 || handle->params.usb_aggr == 2) {
|
|
usb_aggr_enable = MFALSE;
|
|
} else if (handle->params.usb_aggr == 1) {
|
|
usb_aggr_enable = MTRUE;
|
|
} else {
|
|
PRINTM(MWARN,
|
|
"Invalid module param (usb_aggr) value %d, "
|
|
"using MLAN default\n",
|
|
handle->params.usb_aggr);
|
|
handle->params.usb_aggr = 0;
|
|
usb_aggr_enable = MFALSE;
|
|
}
|
|
|
|
/* Allocate an IOCTL request buffer */
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
/* Fill request buffer */
|
|
pcfg_misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
pcfg_misc->sub_command = MLAN_OID_MISC_USB_AGGR_CTRL;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
aggr_param = &pcfg_misc->param.usb_aggr_params;
|
|
/* Initialize TX aggr default values */
|
|
aggr_param->tx_aggr_ctrl.enable = usb_aggr_enable;
|
|
aggr_param->tx_aggr_ctrl.aggr_mode = MLAN_USB_AGGR_MODE_NUM;
|
|
aggr_param->tx_aggr_ctrl.aggr_align =
|
|
MAX(handle->params.max_tx_buf, MLAN_USB_TX_AGGR_ALIGN);
|
|
aggr_param->tx_aggr_ctrl.aggr_max = MLAN_USB_TX_MAX_AGGR_NUM;
|
|
aggr_param->tx_aggr_ctrl.aggr_tmo =
|
|
MLAN_USB_TX_AGGR_TIMEOUT_MSEC * 1000;
|
|
|
|
/* Initialize RX deaggr default values */
|
|
aggr_param->rx_deaggr_ctrl.enable = usb_aggr_enable;
|
|
aggr_param->rx_deaggr_ctrl.aggr_mode = MLAN_USB_AGGR_MODE_NUM;
|
|
aggr_param->rx_deaggr_ctrl.aggr_align = MLAN_USB_RX_ALIGN_SIZE;
|
|
aggr_param->rx_deaggr_ctrl.aggr_max = MLAN_USB_RX_MAX_AGGR_NUM;
|
|
aggr_param->rx_deaggr_ctrl.aggr_tmo = MLAN_USB_RX_DEAGGR_TIMEOUT_USEC;
|
|
|
|
/* Do not fail driver init due to command failure */
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
/* Disable the feature if FW return failure/unsupported */
|
|
if (req->status_code)
|
|
cardp->tx_aggr_ctrl.enable = MFALSE;
|
|
else
|
|
moal_memcpy_ext(handle, &cardp->tx_aggr_ctrl,
|
|
&aggr_param->tx_aggr_ctrl,
|
|
sizeof(usb_aggr_ctrl_cfg),
|
|
sizeof(usb_aggr_ctrl_cfg));
|
|
|
|
if (req->status_code) {
|
|
/* Disable the feature if FW return failure/unsupported */
|
|
cardp->rx_deaggr_ctrl.enable = MFALSE;
|
|
} else {
|
|
/* Default is disable, resubmit URBs only for enable */
|
|
if (cardp->rx_deaggr_ctrl.enable != usb_aggr_enable)
|
|
resubmit_urbs = 1;
|
|
}
|
|
if (resubmit_urbs) {
|
|
/* Indicate resubmition from here */
|
|
cardp->resubmit_urbs = 1;
|
|
/* Rx SG feature is disabled due to FW failure/unsupported,
|
|
* kill the URBs, they will be resubmitted after saving the
|
|
* parameters to USB card */
|
|
if (atomic_read(&cardp->rx_data_urb_pending)) {
|
|
for (i = 0; i < MVUSB_RX_DATA_URB; i++) {
|
|
if (cardp->rx_data_list[i].urb) {
|
|
usb_kill_urb(
|
|
cardp->rx_data_list[i].urb);
|
|
usb_init_urb(
|
|
cardp->rx_data_list[i].urb);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Default is disable, update only for enable case */
|
|
moal_memcpy_ext(handle, &cardp->rx_deaggr_ctrl,
|
|
&aggr_param->rx_deaggr_ctrl,
|
|
sizeof(usb_aggr_ctrl_cfg),
|
|
sizeof(usb_aggr_ctrl_cfg));
|
|
|
|
/* Ensure the next data URBs will use the modified parameters */
|
|
if (!atomic_read(&cardp->rx_data_urb_pending)) {
|
|
/* Submit multiple Rx data URBs */
|
|
woal_usb_submit_rx_data_urbs(handle);
|
|
}
|
|
cardp->resubmit_urbs = 0;
|
|
}
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
* @brief Set hotspot configuration value to mlan layer
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option wait option
|
|
* @param hotspotcfg Hotspot configuration value
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_set_hotspotcfg(moal_private *priv, t_u8 wait_option,
|
|
t_u32 hotspotcfg)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *cfg = NULL;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req == NULL) {
|
|
ret = MLAN_STATUS_FAILURE;
|
|
goto done;
|
|
}
|
|
|
|
cfg = (mlan_ds_misc_cfg *)req->pbuf;
|
|
cfg->param.hotspot_cfg = hotspotcfg;
|
|
req->action = MLAN_ACT_SET;
|
|
|
|
cfg->sub_command = MLAN_OID_MISC_HOTSPOT_CFG;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
|
|
ret = woal_request_ioctl(priv, req, wait_option);
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
done:
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Send delelte all BA command to MLAN
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_delba_all(moal_private *priv, t_u8 wait_option)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_11n_cfg *cfg_11n = NULL;
|
|
mlan_ds_11n_delba *del_ba = NULL;
|
|
t_u8 zero_mac[MLAN_MAC_ADDR_LENGTH] = {0};
|
|
mlan_status status = MLAN_STATUS_SUCCESS;
|
|
int ret = 0;
|
|
|
|
req = (mlan_ioctl_req *)woal_alloc_mlan_ioctl_req(
|
|
sizeof(mlan_ds_11n_cfg));
|
|
if (req == NULL) {
|
|
ret = -ENOMEM;
|
|
goto done;
|
|
}
|
|
cfg_11n = (mlan_ds_11n_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_11N_CFG;
|
|
cfg_11n->sub_command = MLAN_OID_11N_CFG_DELBA;
|
|
|
|
del_ba = &cfg_11n->param.del_ba;
|
|
memset(del_ba, 0, sizeof(mlan_ds_11n_delba));
|
|
del_ba->direction = DELBA_RX | DELBA_TX;
|
|
del_ba->tid = DELBA_ALL_TIDS;
|
|
moal_memcpy_ext(priv->phandle, del_ba->peer_mac_addr, zero_mac,
|
|
ETH_ALEN, sizeof(del_ba->peer_mac_addr));
|
|
|
|
status = woal_request_ioctl(priv, req, wait_option);
|
|
|
|
if (status != MLAN_STATUS_SUCCESS) {
|
|
ret = -EFAULT;
|
|
goto done;
|
|
}
|
|
|
|
done:
|
|
if (status != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Send 11d enable/disable command to firmware.
|
|
*
|
|
* @param priv A pointer to moal_private structure
|
|
* @param wait_option Wait option
|
|
* @param enable Enable/Disable 11d
|
|
*
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING -- success,
|
|
* otherwise fail
|
|
*/
|
|
mlan_status woal_set_11d(moal_private *priv, t_u8 wait_option, t_u8 enable)
|
|
{
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_snmp_mib *snmp = NULL;
|
|
mlan_status ret = MLAN_STATUS_SUCCESS;
|
|
|
|
ENTER();
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_snmp_mib));
|
|
if (req == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
req->action = MLAN_ACT_SET;
|
|
req->req_id = MLAN_IOCTL_SNMP_MIB;
|
|
|
|
snmp = (mlan_ds_snmp_mib *)req->pbuf;
|
|
snmp->sub_command = MLAN_OID_SNMP_MIB_DOT11D;
|
|
snmp->param.oid_value = enable;
|
|
|
|
ret = woal_request_ioctl(priv, req, MOAL_IOCTL_WAIT);
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief Handle miscellaneous ioctls for asynchronous command response
|
|
*
|
|
* @param priv Pointer to moal_private structure
|
|
* @param info Pointer to mlan_ds_misc_cfg structure
|
|
*
|
|
* @return N/A
|
|
*/
|
|
void woal_ioctl_get_misc_conf(moal_private *priv, mlan_ds_misc_cfg *info)
|
|
{
|
|
ENTER();
|
|
switch (info->sub_command) {
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
#ifdef CONFIG_PROC_FS
|
|
#define RADIO_MODE_STR_LEN 20
|
|
#define TX_PWR_STR_LEN 20
|
|
#define TX_CONT_STR_LEN 50
|
|
#define TX_FRAME_STR_LEN 200
|
|
#define HE_TB_TX_STR_LEN 30
|
|
|
|
/*
|
|
* @brief Parse mfg cmd radio mode string
|
|
*
|
|
* @param s A pointer to user buffer
|
|
* @param len Length of user buffer
|
|
* @param d A pointer to mfg_cmd_generic_cfg struct
|
|
* @return 0 on success, -EINVAL otherwise
|
|
*/
|
|
static int parse_radio_mode_string(const char *s, size_t len,
|
|
struct mfg_cmd_generic_cfg *d)
|
|
{
|
|
int ret = MLAN_STATUS_SUCCESS;
|
|
char *string = NULL;
|
|
char *tmp = NULL;
|
|
char *pos = NULL;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
if (!s || !d) {
|
|
LEAVE();
|
|
return -EINVAL;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
string = kzalloc(RADIO_MODE_STR_LEN, flag);
|
|
if (string == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
moal_memcpy_ext(NULL, string, s + strlen("radio_mode="),
|
|
len - strlen("radio_mode="), RADIO_MODE_STR_LEN - 1);
|
|
|
|
tmp = string;
|
|
string = strstrip(string);
|
|
|
|
/* radio mode index 0 */
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data1 = (t_u32)woal_string_to_number(pos);
|
|
|
|
/* radio mode index 1 */
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data2 = (t_u32)woal_string_to_number(pos);
|
|
|
|
if ((d->data1 > 14 || d->data1 < 0) || (d->data2 > 14 || d->data2 < 0))
|
|
ret = -EINVAL;
|
|
|
|
kfree(tmp);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* @brief Parse mfg cmd tx pwr string
|
|
*
|
|
* @param s A pointer to user buffer
|
|
* @param len Length of user buffer
|
|
* @param d A pointer to mfg_cmd_generic_cfg struct
|
|
* @return 0 on success, -EINVAL otherwise
|
|
*/
|
|
static int parse_tx_pwr_string(const char *s, size_t len,
|
|
struct mfg_cmd_generic_cfg *d)
|
|
{
|
|
int ret = MLAN_STATUS_SUCCESS;
|
|
char *string = NULL;
|
|
char *tmp = NULL;
|
|
char *pos = NULL;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
if (!s || !d) {
|
|
LEAVE();
|
|
return -EINVAL;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
string = kzalloc(TX_PWR_STR_LEN, flag);
|
|
if (string == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
moal_memcpy_ext(NULL, string, s + strlen("tx_power="),
|
|
len - strlen("tx_power="), TX_PWR_STR_LEN - 1);
|
|
|
|
tmp = string;
|
|
string = strstrip(string);
|
|
|
|
/* tx power value */
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data1 = (t_u32)woal_string_to_number(pos);
|
|
|
|
/* modulation */
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data2 = (t_u32)woal_string_to_number(pos);
|
|
|
|
/* path id */
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data3 = (t_u32)woal_string_to_number(pos);
|
|
|
|
if ((d->data1 > 24) || (d->data2 > 2))
|
|
ret = -EINVAL;
|
|
|
|
kfree(tmp);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
/*
|
|
* @brief Parse mfg cmd tx cont string
|
|
*
|
|
* @param s A pointer to user buffer
|
|
* @param len Length of user buffer
|
|
* @param d A pointer to mfg_cmd_tx_cont struct
|
|
* @return 0 on success, -EINVAL otherwise
|
|
*/
|
|
static int parse_tx_cont_string(const char *s, size_t len,
|
|
struct mfg_cmd_tx_cont *d)
|
|
{
|
|
int ret = MLAN_STATUS_SUCCESS;
|
|
char *string = NULL;
|
|
char *tmp = NULL;
|
|
char *pos = NULL;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
if (!s || !d) {
|
|
LEAVE();
|
|
return -EINVAL;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
string = kzalloc(TX_CONT_STR_LEN, flag);
|
|
if (string == NULL) {
|
|
LEAVE();
|
|
return -ENOMEM;
|
|
}
|
|
|
|
moal_memcpy_ext(NULL, string, s + strlen("tx_continuous="),
|
|
len - strlen("tx_continuous="), TX_CONT_STR_LEN - 1);
|
|
|
|
tmp = string;
|
|
string = strstrip(string);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->enable_tx = (t_u32)woal_string_to_number(pos);
|
|
|
|
if (d->enable_tx == MFALSE)
|
|
goto done;
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->cw_mode = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->payload_pattern = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->cs_mode = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->act_sub_ch = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->tx_rate = (t_u32)woal_string_to_number(pos);
|
|
|
|
if ((d->enable_tx > 1) || (d->cw_mode > 1) || (d->cs_mode > 1) ||
|
|
(d->act_sub_ch == 2 || d->act_sub_ch > 3))
|
|
ret = -EINVAL;
|
|
done:
|
|
kfree(tmp);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* @brief Parse mfg cmd tx frame string
|
|
*
|
|
* @param s A pointer to user buffer
|
|
* @param len Length of user buffer
|
|
* @param d A pointer to mfg_cmd_tx_frame2 struct
|
|
* @return 0 on success, -EINVAL otherwise
|
|
*/
|
|
static int parse_tx_frame_string(const char *s, size_t len,
|
|
struct mfg_cmd_tx_frame2 *d)
|
|
{
|
|
int ret = MLAN_STATUS_SUCCESS;
|
|
char *string = NULL;
|
|
char *tmp = NULL;
|
|
char *pos = NULL;
|
|
int i;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
if (!s || !d) {
|
|
LEAVE();
|
|
return -EINVAL;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
string = kzalloc(TX_FRAME_STR_LEN, flag);
|
|
if (string == NULL)
|
|
return -ENOMEM;
|
|
|
|
moal_memcpy_ext(NULL, string, s + strlen("tx_frame="),
|
|
len - strlen("tx_frame="), TX_FRAME_STR_LEN - 1);
|
|
|
|
tmp = string;
|
|
string = strstrip(string);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->enable = (t_u32)woal_string_to_number(pos);
|
|
|
|
if (d->enable == MFALSE)
|
|
goto done;
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->data_rate = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->frame_pattern = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->frame_length = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->adjust_burst_sifs = (t_u16)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->burst_sifs_in_us = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->short_preamble = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->act_sub_ch = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->short_gi = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->adv_coding = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->tx_bf = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->gf_mode = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->stbc = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->NumPkt = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->MaxPE = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->BeamChange = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->Dcm = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->Doppler = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->MidP = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->QNum = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos) {
|
|
for (i = 0; i < ETH_ALEN; i++) {
|
|
pos = strsep(&string, ":");
|
|
if (pos)
|
|
d->bssid[i] = woal_atox(pos);
|
|
}
|
|
}
|
|
|
|
if ((d->enable > 1) || (d->frame_length == 0) ||
|
|
(d->adjust_burst_sifs > 1) || (d->burst_sifs_in_us > 255) ||
|
|
(d->short_preamble > 1) ||
|
|
(d->act_sub_ch == 2 || d->act_sub_ch > 3) || (d->short_gi > 1) ||
|
|
(d->adv_coding > 1) || (d->tx_bf > 1) || (d->gf_mode > 1) ||
|
|
(d->stbc > 1))
|
|
ret = -EINVAL;
|
|
done:
|
|
kfree(tmp);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/*
|
|
* @brief Parse mfg cmd HE TB Tx string
|
|
*
|
|
* @param s A pointer to user buffer
|
|
* @param len Length of user buffer
|
|
* @param d A pointer to mfg_Cmd_HE_TBTx_t struct
|
|
* @return 0 on success, -EINVAL otherwise
|
|
*/
|
|
static int parse_he_tb_tx_string(const char *s, size_t len,
|
|
struct mfg_Cmd_HE_TBTx_t *d)
|
|
{
|
|
int ret = MLAN_STATUS_SUCCESS;
|
|
char *string = NULL;
|
|
char *tmp = NULL;
|
|
char *pos = NULL;
|
|
gfp_t flag;
|
|
|
|
ENTER();
|
|
if (!s || !d) {
|
|
LEAVE();
|
|
return -EINVAL;
|
|
}
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC : GFP_KERNEL;
|
|
string = kzalloc(HE_TB_TX_STR_LEN, flag);
|
|
if (string == NULL)
|
|
return -ENOMEM;
|
|
|
|
moal_memcpy_ext(NULL, string, s + strlen("he_tb_tx="),
|
|
len - strlen("he_tb_tx="), HE_TB_TX_STR_LEN - 1);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->enable = (t_u32)woal_string_to_number(pos);
|
|
|
|
if (d->enable == MFALSE)
|
|
goto done;
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->qnum = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->aid = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->axq_mu_timer = (t_u32)woal_string_to_number(pos);
|
|
|
|
pos = strsep(&string, " \t");
|
|
if (pos)
|
|
d->tx_power = (t_u16)woal_string_to_number(pos);
|
|
|
|
if (d->enable > 1)
|
|
ret = -EINVAL;
|
|
|
|
done:
|
|
kfree(tmp);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
/*
|
|
* @brief This function enables/disables RF test mode in firmware
|
|
*
|
|
* @param handle A pointer to moal_handle structure
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING on success,
|
|
* otherwise failure code
|
|
*/
|
|
mlan_status woal_process_rf_test_mode(moal_handle *handle, t_u32 mode)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_FAILURE;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
t_u32 flag = 0;
|
|
|
|
ENTER();
|
|
#ifdef MFG_CMD_SUPPORT
|
|
if (mfg_mode) {
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif
|
|
if (mode != MFG_CMD_SET_TEST_MODE && mode != MFG_CMD_UNSET_TEST_MODE) {
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (req) {
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
misc->sub_command = MLAN_OID_MISC_RF_TEST_GENERIC;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
req->action = MLAN_ACT_SET;
|
|
if (mode == MFG_CMD_SET_TEST_MODE)
|
|
misc->param.mfg_generic_cfg.mfg_cmd =
|
|
MFG_CMD_SET_TEST_MODE;
|
|
ret = woal_request_ioctl(woal_get_priv(handle,
|
|
MLAN_BSS_ROLE_ANY),
|
|
req, MOAL_IOCTL_WAIT);
|
|
}
|
|
|
|
if (ret == MLAN_STATUS_SUCCESS && mode == MFG_CMD_SET_TEST_MODE &&
|
|
handle->rf_data == NULL) {
|
|
flag = (in_atomic() || irqs_disabled()) ? GFP_ATOMIC :
|
|
GFP_KERNEL;
|
|
/* Allocate memory to hold RF test mode data */
|
|
handle->rf_data =
|
|
kzalloc(sizeof(struct rf_test_mode_data), flag);
|
|
if (!handle->rf_data)
|
|
PRINTM(MERROR,
|
|
"Couldn't allocate memory for RF test mode\n");
|
|
handle->rf_test_mode = MTRUE;
|
|
if (handle->rf_data) {
|
|
/* antenna is set to 1 by default */
|
|
handle->rf_data->tx_antenna = 1;
|
|
handle->rf_data->rx_antenna = 1;
|
|
}
|
|
} else if (mode == MFG_CMD_UNSET_TEST_MODE) {
|
|
if (handle->rf_data) {
|
|
/* Free RF test mode data memory */
|
|
kfree(handle->rf_data);
|
|
handle->rf_data = NULL;
|
|
}
|
|
handle->rf_test_mode = MFALSE;
|
|
}
|
|
if (ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
|
|
/**
|
|
* @brief This function sends RF test mode command in firmware
|
|
*
|
|
* @param handle A pointer to moal_handle structure
|
|
* @return MLAN_STATUS_SUCCESS/MLAN_STATUS_PENDING on success,
|
|
* otherwise failure code
|
|
*/
|
|
mlan_status woal_process_rf_test_mode_cmd(moal_handle *handle, t_u32 cmd,
|
|
const char *buffer, size_t len,
|
|
t_u32 action, t_u32 val)
|
|
{
|
|
mlan_status ret = MLAN_STATUS_FAILURE;
|
|
mlan_ioctl_req *req = NULL;
|
|
mlan_ds_misc_cfg *misc = NULL;
|
|
int err = MFALSE;
|
|
int i;
|
|
|
|
ENTER();
|
|
|
|
if (!handle->rf_test_mode || !handle->rf_data)
|
|
goto done;
|
|
|
|
req = woal_alloc_mlan_ioctl_req(sizeof(mlan_ds_misc_cfg));
|
|
if (!req)
|
|
goto done;
|
|
|
|
misc = (mlan_ds_misc_cfg *)req->pbuf;
|
|
req->req_id = MLAN_IOCTL_MISC_CFG;
|
|
misc->sub_command = MLAN_OID_MISC_RF_TEST_GENERIC;
|
|
req->action = action;
|
|
|
|
switch (cmd) {
|
|
case MFG_CMD_TX_ANT:
|
|
if (val != 1 && val != 2 && val != 3)
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_RX_ANT:
|
|
if (val != 1 && val != 2 && val != 3)
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_RF_BAND_AG:
|
|
if (val != 0 && val != 1)
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_RF_CHANNELBW:
|
|
if (val != 0 && val != 1 &&
|
|
(val != 4 ||
|
|
(val == 4 && handle->rf_data->band == BAND_2GHZ)))
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_RF_CHAN:
|
|
break;
|
|
case MFG_CMD_CLR_RX_ERR:
|
|
break;
|
|
case MFG_CMD_RADIO_MODE_CFG:
|
|
if (parse_radio_mode_string(buffer, len,
|
|
&misc->param.mfg_generic_cfg))
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_RFPWR:
|
|
if (parse_tx_pwr_string(buffer, len,
|
|
&misc->param.mfg_generic_cfg))
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_TX_CONT:
|
|
misc->sub_command = MLAN_OID_MISC_RF_TEST_TX_CONT;
|
|
if (parse_tx_cont_string(buffer, len, &misc->param.mfg_tx_cont))
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_TX_FRAME:
|
|
misc->sub_command = MLAN_OID_MISC_RF_TEST_TX_FRAME;
|
|
if (parse_tx_frame_string(buffer, len,
|
|
&misc->param.mfg_tx_frame2))
|
|
err = MTRUE;
|
|
break;
|
|
case MFG_CMD_CONFIG_MAC_HE_TB_TX:
|
|
misc->sub_command = MLAN_OID_MISC_RF_TEST_HE_POWER;
|
|
if (parse_he_tb_tx_string(buffer, len,
|
|
&misc->param.mfg_he_power))
|
|
err = MTRUE;
|
|
break;
|
|
default:
|
|
err = MTRUE;
|
|
}
|
|
|
|
if (!err) {
|
|
misc->param.mfg_generic_cfg.mfg_cmd = (t_u32)cmd;
|
|
if (cmd != MFG_CMD_RFPWR &&
|
|
misc->sub_command == MLAN_OID_MISC_RF_TEST_GENERIC)
|
|
misc->param.mfg_generic_cfg.data1 = val;
|
|
|
|
ret = woal_request_ioctl(woal_get_priv(handle,
|
|
MLAN_BSS_ROLE_ANY),
|
|
req, MOAL_IOCTL_WAIT);
|
|
}
|
|
if (ret != MLAN_STATUS_SUCCESS)
|
|
goto done;
|
|
|
|
switch (cmd) {
|
|
case MFG_CMD_TX_ANT:
|
|
handle->rf_data->tx_antenna = misc->param.mfg_generic_cfg.data1;
|
|
break;
|
|
case MFG_CMD_RX_ANT:
|
|
handle->rf_data->rx_antenna = misc->param.mfg_generic_cfg.data1;
|
|
break;
|
|
case MFG_CMD_RADIO_MODE_CFG:
|
|
handle->rf_data->radio_mode[0] =
|
|
misc->param.mfg_generic_cfg.data1;
|
|
handle->rf_data->radio_mode[1] =
|
|
misc->param.mfg_generic_cfg.data2;
|
|
break;
|
|
case MFG_CMD_RF_BAND_AG:
|
|
handle->rf_data->band = misc->param.mfg_generic_cfg.data1;
|
|
/* set fw default bw and channel config on band change */
|
|
handle->rf_data->bandwidth = CHANNEL_BW_20MHZ;
|
|
if (handle->rf_data->band == BAND_2GHZ)
|
|
handle->rf_data->channel = 6;
|
|
else if (handle->rf_data->band == BAND_5GHZ)
|
|
handle->rf_data->channel = 36;
|
|
break;
|
|
case MFG_CMD_RF_CHANNELBW:
|
|
handle->rf_data->bandwidth = misc->param.mfg_generic_cfg.data1;
|
|
break;
|
|
case MFG_CMD_RF_CHAN:
|
|
handle->rf_data->channel = misc->param.mfg_generic_cfg.data1;
|
|
break;
|
|
case MFG_CMD_CLR_RX_ERR:
|
|
handle->rf_data->rx_tot_pkt_count =
|
|
misc->param.mfg_generic_cfg.data1;
|
|
handle->rf_data->rx_mcast_bcast_pkt_count =
|
|
misc->param.mfg_generic_cfg.data2;
|
|
handle->rf_data->rx_pkt_fcs_err_count =
|
|
misc->param.mfg_generic_cfg.data3;
|
|
break;
|
|
case MFG_CMD_RFPWR:
|
|
handle->rf_data->tx_power_data[0] =
|
|
misc->param.mfg_generic_cfg.data1;
|
|
handle->rf_data->tx_power_data[1] =
|
|
misc->param.mfg_generic_cfg.data2;
|
|
handle->rf_data->tx_power_data[2] =
|
|
misc->param.mfg_generic_cfg.data3;
|
|
break;
|
|
case MFG_CMD_TX_CONT:
|
|
handle->rf_data->tx_cont_data[0] =
|
|
misc->param.mfg_tx_cont.enable_tx;
|
|
handle->rf_data->tx_cont_data[1] =
|
|
misc->param.mfg_tx_cont.cw_mode;
|
|
handle->rf_data->tx_cont_data[2] =
|
|
misc->param.mfg_tx_cont.payload_pattern;
|
|
handle->rf_data->tx_cont_data[3] =
|
|
misc->param.mfg_tx_cont.cs_mode;
|
|
handle->rf_data->tx_cont_data[4] =
|
|
misc->param.mfg_tx_cont.act_sub_ch;
|
|
handle->rf_data->tx_cont_data[5] =
|
|
misc->param.mfg_tx_cont.tx_rate;
|
|
break;
|
|
case MFG_CMD_TX_FRAME:
|
|
handle->rf_data->tx_frame_data[0] =
|
|
misc->param.mfg_tx_frame2.enable;
|
|
handle->rf_data->tx_frame_data[1] =
|
|
misc->param.mfg_tx_frame2.data_rate;
|
|
handle->rf_data->tx_frame_data[2] =
|
|
misc->param.mfg_tx_frame2.frame_pattern;
|
|
handle->rf_data->tx_frame_data[3] =
|
|
misc->param.mfg_tx_frame2.frame_length;
|
|
handle->rf_data->tx_frame_data[4] =
|
|
misc->param.mfg_tx_frame2.adjust_burst_sifs;
|
|
handle->rf_data->tx_frame_data[5] =
|
|
misc->param.mfg_tx_frame2.burst_sifs_in_us;
|
|
handle->rf_data->tx_frame_data[6] =
|
|
misc->param.mfg_tx_frame2.short_preamble;
|
|
handle->rf_data->tx_frame_data[7] =
|
|
misc->param.mfg_tx_frame2.act_sub_ch;
|
|
handle->rf_data->tx_frame_data[8] =
|
|
misc->param.mfg_tx_frame2.short_gi;
|
|
handle->rf_data->tx_frame_data[9] =
|
|
misc->param.mfg_tx_frame2.adv_coding;
|
|
handle->rf_data->tx_frame_data[10] =
|
|
misc->param.mfg_tx_frame2.tx_bf;
|
|
handle->rf_data->tx_frame_data[11] =
|
|
misc->param.mfg_tx_frame2.gf_mode;
|
|
handle->rf_data->tx_frame_data[12] =
|
|
misc->param.mfg_tx_frame2.stbc;
|
|
handle->rf_data->tx_frame_data[13] =
|
|
misc->param.mfg_tx_frame2.NumPkt;
|
|
handle->rf_data->tx_frame_data[14] =
|
|
misc->param.mfg_tx_frame2.MaxPE;
|
|
handle->rf_data->tx_frame_data[15] =
|
|
misc->param.mfg_tx_frame2.BeamChange;
|
|
handle->rf_data->tx_frame_data[16] =
|
|
misc->param.mfg_tx_frame2.Dcm;
|
|
handle->rf_data->tx_frame_data[17] =
|
|
misc->param.mfg_tx_frame2.Doppler;
|
|
handle->rf_data->tx_frame_data[18] =
|
|
misc->param.mfg_tx_frame2.MidP;
|
|
handle->rf_data->tx_frame_data[19] =
|
|
misc->param.mfg_tx_frame2.QNum;
|
|
for (i = 0; i < ETH_ALEN; i++) {
|
|
handle->rf_data->bssid[i] =
|
|
misc->param.mfg_tx_frame2.bssid[i];
|
|
}
|
|
break;
|
|
case MFG_CMD_CONFIG_MAC_HE_TB_TX:
|
|
handle->rf_data->he_tb_tx[0] = misc->param.mfg_he_power.enable;
|
|
handle->rf_data->he_tb_tx[1] = misc->param.mfg_he_power.qnum;
|
|
handle->rf_data->he_tb_tx[2] = misc->param.mfg_he_power.aid;
|
|
handle->rf_data->he_tb_tx[3] =
|
|
misc->param.mfg_he_power.axq_mu_timer;
|
|
handle->rf_data->he_tb_tx[4] =
|
|
misc->param.mfg_he_power.tx_power;
|
|
break;
|
|
}
|
|
done:
|
|
if (err || ret != MLAN_STATUS_PENDING)
|
|
kfree(req);
|
|
|
|
LEAVE();
|
|
return ret;
|
|
}
|
|
#endif /* RF_TEST_MODE */
|