#include "wilc_wlan_if.h"
#include "wilc_msgqueue.h"
#include <linux/etherdevice.h>
+#include "wilc_wfi_netdevice.h"
extern u8 connecting;
#define BA_SESSION_DEFAULT_BUFFER_SIZE 16
#define BA_SESSION_DEFAULT_TIMEOUT 1000
#define BLOCK_ACK_REQ_SIZE 0x14
+#define FALSE_FRMWR_CHANNEL 100
struct cfg_param_attr {
struct cfg_param_val cfg_attr_info;
u8 idx;
u8 duration[4];
u8 interval[4];
- u8 au8StartTime[4];
+ u8 start_time[4];
};
static struct host_if_drv *wfidrv_list[NUM_CONCURRENT_IFC + 1];
static struct semaphore hif_sema_driver;
static struct semaphore hif_sema_wait_response;
static struct semaphore hif_sema_deinit;
-struct timer_list g_hPeriodicRSSI;
+static struct timer_list periodic_rssi;
+u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
+static u8 rcv_assoc_resp[MAX_ASSOC_RESP_FRAME_SIZE];
-u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
+static bool scan_while_connected;
+
+static s8 rssi;
+static s8 link_speed;
+static u8 ch_no;
+static u8 set_ip[2][4];
+static u8 get_ip[2][4];
+static u32 inactive_time;
+static u8 del_beacon;
+static u32 clients_count;
-static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
-
-bool gbScanWhileConnected;
-
-static s8 gs8Rssi;
-static s8 gs8lnkspd;
-static u8 gu8Chnl;
-static u8 gs8SetIP[2][4];
-static u8 gs8GetIP[2][4];
-static u32 gu32InactiveTime;
-static u8 gu8DelBcn;
-static u32 gu32WidConnRstHack;
-
-u8 *gu8FlushedJoinReq;
-u8 *gu8FlushedInfoElemAsoc;
-u8 gu8Flushed11iMode;
-u8 gu8FlushedAuthType;
-u32 gu32FlushedJoinReqSize;
-u32 gu32FlushedInfoElemAsocSize;
-struct host_if_drv *gu8FlushedJoinReqDrvHandler;
+static u8 *join_req;
+u8 *info_element;
+static u8 mode_11i;
+u8 auth_type;
+u32 join_req_size;
+static u32 info_element_size;
+static struct host_if_drv *join_req_drv;
#define REAL_JOIN_REQ 0
#define FLUSHED_JOIN_REQ 1
#define FLUSHED_BYTE_POS 79
static s32 Handle_SetChannel(struct host_if_drv *hif_drv,
struct channel_attr *pstrHostIFSetChan)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
-
- strWID.id = (u16)WID_CURRENT_CHANNEL;
- strWID.type = WID_CHAR;
- strWID.val = (char *)&(pstrHostIFSetChan->set_ch);
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_CURRENT_CHANNEL;
+ wid.type = WID_CHAR;
+ wid.val = (char *)&pstrHostIFSetChan->set_ch;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Setting channel\n");
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+
+ if (result) {
PRINT_ER("Failed to set channel\n");
return -EINVAL;
}
- return s32Error;
+ return result;
}
static s32 Handle_SetWfiDrvHandler(struct host_if_drv *hif_drv,
struct drv_handler *pstrHostIfSetDrvHandler)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
-
- strWID.id = (u16)WID_SET_DRV_HANDLER;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&(pstrHostIfSetDrvHandler->u32Address);
- strWID.size = sizeof(u32);
+ wid.id = (u16)WID_SET_DRV_HANDLER;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&pstrHostIfSetDrvHandler->handler;
+ wid.size = sizeof(u32);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- pstrHostIfSetDrvHandler->u32Address);
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ pstrHostIfSetDrvHandler->handler);
if (!hif_drv)
up(&hif_sema_driver);
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to set driver handler\n");
return -EINVAL;
}
- return s32Error;
+ return result;
}
static s32 Handle_SetOperationMode(struct host_if_drv *hif_drv,
struct op_mode *pstrHostIfSetOperationMode)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
-
- strWID.id = (u16)WID_SET_OPERATION_MODE;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&(pstrHostIfSetOperationMode->u32Mode);
- strWID.size = sizeof(u32);
-
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ wid.id = (u16)WID_SET_OPERATION_MODE;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&pstrHostIfSetOperationMode->mode;
+ wid.size = sizeof(u32);
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- if ((pstrHostIfSetOperationMode->u32Mode) == IDLE_MODE)
+ if ((pstrHostIfSetOperationMode->mode) == IDLE_MODE)
up(&hif_sema_driver);
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to set driver handler\n");
return -EINVAL;
}
- return s32Error;
+ return result;
}
s32 Handle_set_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
{
-
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
char firmwareIPAddress[4] = {0};
if (pu8IPAddr[0] < 192)
PRINT_INFO(HOSTINF_DBG, "Indx = %d, Handling set IP = %pI4\n", idx, pu8IPAddr);
- memcpy(gs8SetIP[idx], pu8IPAddr, IP_ALEN);
+ memcpy(set_ip[idx], pu8IPAddr, IP_ALEN);
- strWID.id = (u16)WID_IP_ADDRESS;
- strWID.type = WID_STR;
- strWID.val = (u8 *)pu8IPAddr;
- strWID.size = IP_ALEN;
-
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ wid.id = (u16)WID_IP_ADDRESS;
+ wid.type = WID_STR;
+ wid.val = (u8 *)pu8IPAddr;
+ wid.size = IP_ALEN;
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
host_int_get_ipaddress(hif_drv, firmwareIPAddress, idx);
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to set IP address\n");
return -EINVAL;
}
PRINT_INFO(HOSTINF_DBG, "IP address set\n");
- return s32Error;
+ return result;
}
s32 Handle_get_IPAddress(struct host_if_drv *hif_drv, u8 *pu8IPAddr, u8 idx)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
-
- strWID.id = (u16)WID_IP_ADDRESS;
- strWID.type = WID_STR;
- strWID.val = kmalloc(IP_ALEN, GFP_KERNEL);
- strWID.size = IP_ALEN;
+ wid.id = (u16)WID_IP_ADDRESS;
+ wid.type = WID_STR;
+ wid.val = kmalloc(IP_ALEN, GFP_KERNEL);
+ wid.size = IP_ALEN;
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- PRINT_INFO(HOSTINF_DBG, "%pI4\n", strWID.val);
+ PRINT_INFO(HOSTINF_DBG, "%pI4\n", wid.val);
- memcpy(gs8GetIP[idx], strWID.val, IP_ALEN);
+ memcpy(get_ip[idx], wid.val, IP_ALEN);
- kfree(strWID.val);
+ kfree(wid.val);
- if (memcmp(gs8GetIP[idx], gs8SetIP[idx], IP_ALEN) != 0)
- host_int_setup_ipaddress(hif_drv, gs8SetIP[idx], idx);
+ if (memcmp(get_ip[idx], set_ip[idx], IP_ALEN) != 0)
+ host_int_setup_ipaddress(hif_drv, set_ip[idx], idx);
- if (s32Error != 0) {
+ if (result != 0) {
PRINT_ER("Failed to get IP address\n");
return -EINVAL;
}
PRINT_INFO(HOSTINF_DBG, "IP address retrieved:: u8IfIdx = %d\n", idx);
- PRINT_INFO(HOSTINF_DBG, "%pI4\n", gs8GetIP[idx]);
+ PRINT_INFO(HOSTINF_DBG, "%pI4\n", get_ip[idx]);
PRINT_INFO(HOSTINF_DBG, "\n");
- return s32Error;
+ return result;
}
static s32 Handle_SetMacAddress(struct host_if_drv *hif_drv,
struct set_mac_addr *pstrHostIfSetMacAddress)
{
-
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *mac_buf = kmalloc(ETH_ALEN, GFP_KERNEL);
- if (mac_buf == NULL) {
+ if (!mac_buf) {
PRINT_ER("No buffer to send mac address\n");
return -EFAULT;
}
- memcpy(mac_buf, pstrHostIfSetMacAddress->u8MacAddress, ETH_ALEN);
+ memcpy(mac_buf, pstrHostIfSetMacAddress->mac_addr, ETH_ALEN);
- strWID.id = (u16)WID_MAC_ADDR;
- strWID.type = WID_STR;
- strWID.val = mac_buf;
- strWID.size = ETH_ALEN;
- PRINT_D(GENERIC_DBG, "mac addr = :%pM\n", strWID.val);
+ wid.id = (u16)WID_MAC_ADDR;
+ wid.type = WID_STR;
+ wid.val = mac_buf;
+ wid.size = ETH_ALEN;
+ PRINT_D(GENERIC_DBG, "mac addr = :%pM\n", wid.val);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result) {
PRINT_ER("Failed to set mac address\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
kfree(mac_buf);
- return s32Error;
+ return result;
}
static s32 Handle_GetMacAddress(struct host_if_drv *hif_drv,
struct get_mac_addr *pstrHostIfGetMacAddress)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
+ wid.id = (u16)WID_MAC_ADDR;
+ wid.type = WID_STR;
+ wid.val = pstrHostIfGetMacAddress->mac_addr;
+ wid.size = ETH_ALEN;
- strWID.id = (u16)WID_MAC_ADDR;
- strWID.type = WID_STR;
- strWID.val = pstrHostIfGetMacAddress->u8MacAddress;
- strWID.size = ETH_ALEN;
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to get mac address\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
up(&hif_sema_wait_response);
- return s32Error;
+ return result;
}
static s32 Handle_CfgParam(struct host_if_drv *hif_drv,
struct cfg_param_attr *strHostIFCfgParamAttr)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct wid strWIDList[32];
u8 u8WidCnt = 0;
down(&hif_drv->gtOsCfgValuesSem);
-
PRINT_D(HOSTINF_DBG, "Setting CFG params\n");
if (strHostIFCfgParamAttr->cfg_attr_info.flag & BSS_TYPE) {
hif_drv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->cfg_attr_info.bss_type;
} else {
PRINT_ER("check value 6 over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->cfg_attr_info.auth_type;
} else {
PRINT_ER("Impossible value \n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->cfg_attr_info.auth_timeout;
} else {
PRINT_ER("Range(1 ~ 65535) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->cfg_attr_info.power_mgmt_mode;
} else {
PRINT_ER("Invalide power mode\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.short_retry_limit = strHostIFCfgParamAttr->cfg_attr_info.short_retry_limit;
} else {
PRINT_ER("Range(1~256) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.long_retry_limit = strHostIFCfgParamAttr->cfg_attr_info.long_retry_limit;
} else {
PRINT_ER("Range(1~256) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
}
if (strHostIFCfgParamAttr->cfg_attr_info.flag & FRAG_THRESHOLD) {
-
if (strHostIFCfgParamAttr->cfg_attr_info.frag_threshold > 255 && strHostIFCfgParamAttr->cfg_attr_info.frag_threshold < 7937) {
strWIDList[u8WidCnt].id = WID_FRAG_THRESHOLD;
strWIDList[u8WidCnt].val = (s8 *)&strHostIFCfgParamAttr->cfg_attr_info.frag_threshold;
hif_drv->strCfgValues.frag_threshold = strHostIFCfgParamAttr->cfg_attr_info.frag_threshold;
} else {
PRINT_ER("Threshold Range fail\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->cfg_attr_info.rts_threshold;
} else {
PRINT_ER("Threshold Range fail\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.preamble_type = strHostIFCfgParamAttr->cfg_attr_info.preamble_type;
} else {
PRINT_ER("Preamle Range(0~2) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->cfg_attr_info.short_slot_allowed;
} else {
PRINT_ER("Short slot(2) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->cfg_attr_info.txop_prot_disabled;
} else {
PRINT_ER("TXOP prot disable\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->cfg_attr_info.beacon_interval;
} else {
PRINT_ER("Beacon interval(1~65535) fail\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.dtim_period = strHostIFCfgParamAttr->cfg_attr_info.dtim_period;
} else {
PRINT_ER("DTIM range(1~255) fail\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->cfg_attr_info.site_survey_enabled;
} else {
PRINT_ER("Site survey disable\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.site_survey_scan_time = strHostIFCfgParamAttr->cfg_attr_info.site_survey_scan_time;
} else {
PRINT_ER("Site survey scan time(1~65535) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.active_scan_time = strHostIFCfgParamAttr->cfg_attr_info.active_scan_time;
} else {
PRINT_ER("Active scan time(1~65535) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
hif_drv->strCfgValues.passive_scan_time = strHostIFCfgParamAttr->cfg_attr_info.passive_scan_time;
} else {
PRINT_ER("Passive scan time(1~65535) over\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
}
if (strHostIFCfgParamAttr->cfg_attr_info.flag & CURRENT_TX_RATE) {
enum CURRENT_TXRATE curr_tx_rate = strHostIFCfgParamAttr->cfg_attr_info.curr_tx_rate;
+
if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1
|| curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5
|| curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6
hif_drv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
} else {
PRINT_ER("out of TX rate\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto ERRORHANDLER;
}
u8WidCnt++;
}
- s32Error = send_config_pkt(SET_CFG, strWIDList, u8WidCnt,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, strWIDList, u8WidCnt,
+ get_id_from_handler(hif_drv));
+
+ if (result)
PRINT_ER("Error in setting CFG params\n");
ERRORHANDLER:
up(&hif_drv->gtOsCfgValuesSem);
- return s32Error;
+ return result;
}
static s32 Handle_wait_msg_q_empty(void)
static s32 Handle_Scan(struct host_if_drv *hif_drv,
struct scan_attr *pstrHostIFscanAttr)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct wid strWIDList[5];
u32 u32WidsCount = 0;
u32 i;
PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
PRINT_D(HOSTINF_DBG, "Scanning: In [%d] state\n", hif_drv->enuHostIFstate);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = pstrHostIFscanAttr->result;
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid = pstrHostIFscanAttr->arg;
+ hif_drv->usr_scan_req.pfUserScanResult = pstrHostIFscanAttr->result;
+ hif_drv->usr_scan_req.u32UserScanPvoid = pstrHostIFscanAttr->arg;
if ((hif_drv->enuHostIFstate >= HOST_IF_SCANNING) && (hif_drv->enuHostIFstate < HOST_IF_CONNECTED)) {
PRINT_D(GENERIC_DBG, "Don't scan we are already in [%d] state\n", hif_drv->enuHostIFstate);
PRINT_ER("Already scan\n");
- s32Error = -EBUSY;
+ result = -EBUSY;
goto ERRORHANDLER;
}
if (g_obtainingIP || connecting) {
PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
PRINT_ER("Don't do obss scan\n");
- s32Error = -EBUSY;
+ result = -EBUSY;
goto ERRORHANDLER;
}
PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
-
- hif_drv->strWILC_UsrScanReq.u32RcvdChCount = 0;
+ hif_drv->usr_scan_req.u32RcvdChCount = 0;
strWIDList[u32WidsCount].id = (u16)WID_SSID_PROBE_REQ;
strWIDList[u32WidsCount].type = WID_STR;
valuesize += ((pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen) + 1);
pu8HdnNtwrksWidVal = kmalloc(valuesize + 1, GFP_KERNEL);
strWIDList[u32WidsCount].val = pu8HdnNtwrksWidVal;
- if (strWIDList[u32WidsCount].val != NULL) {
+ if (strWIDList[u32WidsCount].val) {
pu8Buffer = strWIDList[u32WidsCount].val;
*pu8Buffer++ = pstrHostIFscanAttr->hidden_network.u8ssidnum;
pu8Buffer += pstrHostIFscanAttr->hidden_network.pstrHiddenNetworkInfo[i].u8ssidlen;
}
-
-
strWIDList[u32WidsCount].size = (s32)(valuesize + 1);
u32WidsCount++;
}
strWIDList[u32WidsCount].id = WID_SCAN_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->type));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrHostIFscanAttr->type;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_SCAN_CHANNEL_LIST;
strWIDList[u32WidsCount].type = WID_BIN_DATA;
- if (pstrHostIFscanAttr->ch_freq_list != NULL && pstrHostIFscanAttr->ch_list_len > 0) {
+ if (pstrHostIFscanAttr->ch_freq_list &&
+ pstrHostIFscanAttr->ch_list_len > 0) {
int i;
for (i = 0; i < pstrHostIFscanAttr->ch_list_len; i++) {
strWIDList[u32WidsCount].id = WID_START_SCAN_REQ;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrHostIFscanAttr->src));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrHostIFscanAttr->src;
u32WidsCount++;
if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED)
- gbScanWhileConnected = true;
+ scan_while_connected = true;
else if (hif_drv->enuHostIFstate == HOST_IF_IDLE)
- gbScanWhileConnected = false;
+ scan_while_connected = false;
- s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
+ get_id_from_handler(hif_drv));
- if (s32Error)
+ if (result)
PRINT_ER("Failed to send scan paramters config packet\n");
else
PRINT_D(HOSTINF_DBG, "Successfully sent SCAN params config packet\n");
ERRORHANDLER:
- if (s32Error) {
+ if (result) {
del_timer(&hif_drv->hScanTimer);
Handle_ScanDone(hif_drv, SCAN_EVENT_ABORTED);
}
kfree(pu8HdnNtwrksWidVal);
- return s32Error;
+ return result;
}
static s32 Handle_ScanDone(struct host_if_drv *hif_drv,
enum scan_event enuEvent)
{
- s32 s32Error = 0;
+ s32 result = 0;
u8 u8abort_running_scan;
- struct wid strWID;
-
+ struct wid wid;
PRINT_D(HOSTINF_DBG, "in Handle_ScanDone()\n");
if (enuEvent == SCAN_EVENT_ABORTED) {
PRINT_D(GENERIC_DBG, "Abort running scan\n");
u8abort_running_scan = 1;
- strWID.id = (u16)WID_ABORT_RUNNING_SCAN;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u8abort_running_scan;
- strWID.size = sizeof(char);
-
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ wid.id = (u16)WID_ABORT_RUNNING_SCAN;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u8abort_running_scan;
+ wid.size = sizeof(char);
+
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+
+ if (result) {
PRINT_ER("Failed to set abort running scan\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
}
if (!hif_drv) {
PRINT_ER("Driver handler is NULL\n");
- return s32Error;
+ return result;
}
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult(enuEvent, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
- return s32Error;
+ return result;
}
u8 u8ConnectedSSID[6] = {0};
static s32 Handle_Connect(struct host_if_drv *hif_drv,
struct connect_attr *pstrHostIFconnectAttr)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct wid strWIDList[8];
u32 u32WidsCount = 0, dummyval = 0;
u8 *pu8CurrByte = NULL;
PRINT_D(GENERIC_DBG, "Handling connect request\n");
if (memcmp(pstrHostIFconnectAttr->bssid, u8ConnectedSSID, ETH_ALEN) == 0) {
-
- s32Error = 0;
+ result = 0;
PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n");
- return s32Error;
+ return result;
}
PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n");
ptstrJoinBssParam = (struct join_bss_param *)pstrHostIFconnectAttr->params;
- if (ptstrJoinBssParam == NULL) {
+ if (!ptstrJoinBssParam) {
PRINT_ER("Required BSSID not found\n");
- s32Error = -ENOENT;
+ result = -ENOENT;
goto ERRORHANDLER;
}
- if (pstrHostIFconnectAttr->bssid != NULL) {
+ if (pstrHostIFconnectAttr->bssid) {
hif_drv->strWILC_UsrConnReq.pu8bssid = kmalloc(6, GFP_KERNEL);
memcpy(hif_drv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->bssid, 6);
}
hif_drv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssid_len;
- if (pstrHostIFconnectAttr->ssid != NULL) {
+ if (pstrHostIFconnectAttr->ssid) {
hif_drv->strWILC_UsrConnReq.pu8ssid = kmalloc(pstrHostIFconnectAttr->ssid_len + 1, GFP_KERNEL);
- memcpy(hif_drv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->ssid,
- pstrHostIFconnectAttr->ssid_len);
+ memcpy(hif_drv->strWILC_UsrConnReq.pu8ssid,
+ pstrHostIFconnectAttr->ssid,
+ pstrHostIFconnectAttr->ssid_len);
hif_drv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssid_len] = '\0';
}
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->ies_len;
- if (pstrHostIFconnectAttr->ies != NULL) {
+ if (pstrHostIFconnectAttr->ies) {
hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
- memcpy(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->ies,
- pstrHostIFconnectAttr->ies_len);
+ memcpy(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
+ pstrHostIFconnectAttr->ies,
+ pstrHostIFconnectAttr->ies_len);
}
hif_drv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->security;
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
-
- gu32FlushedInfoElemAsocSize = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
- gu8FlushedInfoElemAsoc = kmalloc(gu32FlushedInfoElemAsocSize, GFP_KERNEL);
- memcpy(gu8FlushedInfoElemAsoc, hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
- gu32FlushedInfoElemAsocSize);
+ info_element_size = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
+ info_element = kmalloc(info_element_size, GFP_KERNEL);
+ memcpy(info_element, hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
+ info_element_size);
}
}
strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(hif_drv->strWILC_UsrConnReq.u8security));
+ strWIDList[u32WidsCount].val = (s8 *)&hif_drv->strWILC_UsrConnReq.u8security;
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
- gu8Flushed11iMode = hif_drv->strWILC_UsrConnReq.u8security;
+ mode_11i = hif_drv->strWILC_UsrConnReq.u8security;
PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", hif_drv->strWILC_UsrConnReq.u8security);
-
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
u32WidsCount++;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7))
- gu8FlushedAuthType = (u8)hif_drv->strWILC_UsrConnReq.tenuAuth_type;
+ auth_type = (u8)hif_drv->strWILC_UsrConnReq.tenuAuth_type;
PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", hif_drv->strWILC_UsrConnReq.tenuAuth_type);
PRINT_D(HOSTINF_DBG, "Connecting to network of SSID %s on channel %d\n",
strWIDList[u32WidsCount].val = kmalloc(strWIDList[u32WidsCount].size, GFP_KERNEL);
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
- gu32FlushedJoinReqSize = strWIDList[u32WidsCount].size;
- gu8FlushedJoinReq = kmalloc(gu32FlushedJoinReqSize, GFP_KERNEL);
+ join_req_size = strWIDList[u32WidsCount].size;
+ join_req = kmalloc(join_req_size, GFP_KERNEL);
}
- if (strWIDList[u32WidsCount].val == NULL) {
- s32Error = -EFAULT;
+ if (!strWIDList[u32WidsCount].val) {
+ result = -EFAULT;
goto ERRORHANDLER;
}
pu8CurrByte = strWIDList[u32WidsCount].val;
-
- if (pstrHostIFconnectAttr->ssid != NULL) {
+ if (pstrHostIFconnectAttr->ssid) {
memcpy(pu8CurrByte, pstrHostIFconnectAttr->ssid, pstrHostIFconnectAttr->ssid_len);
pu8CurrByte[pstrHostIFconnectAttr->ssid_len] = '\0';
}
*(pu8CurrByte++) = ((ptstrJoinBssParam->cap_info) >> 8) & 0xFF;
PRINT_D(HOSTINF_DBG, "* Cap Info %0x*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8)));
- if (pstrHostIFconnectAttr->bssid != NULL)
+ if (pstrHostIFconnectAttr->bssid)
+ memcpy(pu8CurrByte, pstrHostIFconnectAttr->bssid, 6);
+ pu8CurrByte += 6;
+
+ if (pstrHostIFconnectAttr->bssid)
memcpy(pu8CurrByte, pstrHostIFconnectAttr->bssid, 6);
pu8CurrByte += 6;
memcpy(pu8CurrByte, ptstrJoinBssParam->interval, sizeof(ptstrJoinBssParam->interval));
pu8CurrByte += sizeof(ptstrJoinBssParam->interval);
- memcpy(pu8CurrByte, ptstrJoinBssParam->au8StartTime, sizeof(ptstrJoinBssParam->au8StartTime));
-
- pu8CurrByte += sizeof(ptstrJoinBssParam->au8StartTime);
-
+ memcpy(pu8CurrByte, ptstrJoinBssParam->start_time, sizeof(ptstrJoinBssParam->start_time));
+ pu8CurrByte += sizeof(ptstrJoinBssParam->start_time);
} else
PRINT_D(HOSTINF_DBG, "NOA not present\n");
pu8CurrByte = strWIDList[u32WidsCount].val;
u32WidsCount++;
- gu32WidConnRstHack = 0;
if (memcmp("DIRECT-", pstrHostIFconnectAttr->ssid, 7)) {
- memcpy(gu8FlushedJoinReq, pu8CurrByte, gu32FlushedJoinReqSize);
- gu8FlushedJoinReqDrvHandler = hif_drv;
+ memcpy(join_req, pu8CurrByte, join_req_size);
+ join_req_drv = hif_drv;
}
PRINT_D(GENERIC_DBG, "send HOST_IF_WAITING_CONN_RESP\n");
- if (pstrHostIFconnectAttr->bssid != NULL) {
+ if (pstrHostIFconnectAttr->bssid) {
memcpy(u8ConnectedSSID, pstrHostIFconnectAttr->bssid, ETH_ALEN);
PRINT_D(GENERIC_DBG, "save Bssid = %pM\n", pstrHostIFconnectAttr->bssid);
PRINT_D(GENERIC_DBG, "save bssid = %pM\n", u8ConnectedSSID);
}
- s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
+ get_id_from_handler(hif_drv));
+ if (result) {
PRINT_ER("failed to send config packet\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
goto ERRORHANDLER;
} else {
PRINT_D(GENERIC_DBG, "set HOST_IF_WAITING_CONN_RESP\n");
}
ERRORHANDLER:
- if (s32Error) {
+ if (result) {
tstrConnectInfo strConnectInfo;
del_timer(&hif_drv->hConnectTimer);
memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
- if (pstrHostIFconnectAttr->result != NULL) {
- if (pstrHostIFconnectAttr->bssid != NULL)
+ if (pstrHostIFconnectAttr->result) {
+ if (pstrHostIFconnectAttr->bssid)
memcpy(strConnectInfo.au8bssid, pstrHostIFconnectAttr->bssid, 6);
- if (pstrHostIFconnectAttr->ies != NULL) {
+ if (pstrHostIFconnectAttr->ies) {
strConnectInfo.ReqIEsLen = pstrHostIFconnectAttr->ies_len;
strConnectInfo.pu8ReqIEs = kmalloc(pstrHostIFconnectAttr->ies_len, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs,
- pstrHostIFconnectAttr->ies,
- pstrHostIFconnectAttr->ies_len);
+ pstrHostIFconnectAttr->ies,
+ pstrHostIFconnectAttr->ies_len);
}
pstrHostIFconnectAttr->result(CONN_DISCONN_EVENT_CONN_RESP,
pstrHostIFconnectAttr->ies = NULL;
kfree(pu8CurrByte);
- return s32Error;
+ return result;
}
static s32 Handle_FlushConnect(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct wid strWIDList[5];
u32 u32WidsCount = 0;
u8 *pu8CurrByte = NULL;
strWIDList[u32WidsCount].id = WID_INFO_ELEMENT_ASSOCIATE;
strWIDList[u32WidsCount].type = WID_BIN_DATA;
- strWIDList[u32WidsCount].val = gu8FlushedInfoElemAsoc;
- strWIDList[u32WidsCount].size = gu32FlushedInfoElemAsocSize;
+ strWIDList[u32WidsCount].val = info_element;
+ strWIDList[u32WidsCount].size = info_element_size;
u32WidsCount++;
strWIDList[u32WidsCount].id = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(gu8Flushed11iMode));
+ strWIDList[u32WidsCount].val = (s8 *)(&(mode_11i));
u32WidsCount++;
-
-
strWIDList[u32WidsCount].id = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&gu8FlushedAuthType);
+ strWIDList[u32WidsCount].val = (s8 *)(&auth_type);
u32WidsCount++;
strWIDList[u32WidsCount].id = (u16)WID_JOIN_REQ_EXTENDED;
strWIDList[u32WidsCount].type = WID_STR;
- strWIDList[u32WidsCount].size = gu32FlushedJoinReqSize;
- strWIDList[u32WidsCount].val = (s8 *)gu8FlushedJoinReq;
+ strWIDList[u32WidsCount].size = join_req_size;
+ strWIDList[u32WidsCount].val = (s8 *)join_req;
pu8CurrByte = strWIDList[u32WidsCount].val;
pu8CurrByte += FLUSHED_BYTE_POS;
u32WidsCount++;
- s32Error = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
- get_id_from_handler(gu8FlushedJoinReqDrvHandler));
- if (s32Error) {
+ result = send_config_pkt(SET_CFG, strWIDList, u32WidsCount,
+ get_id_from_handler(join_req_drv));
+ if (result) {
PRINT_ER("failed to send config packet\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
}
- return s32Error;
+ return result;
}
static s32 Handle_ConnectTimeout(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
+ s32 result = 0;
tstrConnectInfo strConnectInfo;
- struct wid strWID;
+ struct wid wid;
u16 u16DummyReasonCode = 0;
if (!hif_drv) {
PRINT_ER("Driver handler is NULL\n");
- return s32Error;
+ return result;
}
hif_drv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = false;
-
+ scan_while_connected = false;
memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
- if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
- if (hif_drv->strWILC_UsrConnReq.pu8bssid != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
+ if (hif_drv->strWILC_UsrConnReq.pu8bssid) {
memcpy(strConnectInfo.au8bssid,
- hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
+ hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
}
- if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) {
strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs,
- hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
- hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
+ hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs,
+ hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
}
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
PRINT_ER("Connect callback function pointer is NULL\n");
}
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u16DummyReasonCode;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u16DummyReasonCode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send dissconect config packet\n");
hif_drv->strWILC_UsrConnReq.ssidLen = 0;
eth_zero_addr(u8ConnectedSSID);
- if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedJoinReq);
- gu8FlushedJoinReq = NULL;
+ if (join_req && join_req_drv == hif_drv) {
+ kfree(join_req);
+ join_req = NULL;
}
- if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedInfoElemAsoc);
- gu8FlushedInfoElemAsoc = NULL;
+
+ if (info_element && join_req_drv == hif_drv) {
+ kfree(info_element);
+ info_element = NULL;
}
- return s32Error;
+ return result;
}
static s32 Handle_RcvdNtwrkInfo(struct host_if_drv *hif_drv,
{
u32 i;
bool bNewNtwrkFound;
-
-
-
- s32 s32Error = 0;
+ s32 result = 0;
tstrNetworkInfo *pstrNetworkInfo = NULL;
void *pJoinParams = NULL;
bNewNtwrkFound = true;
PRINT_INFO(HOSTINF_DBG, "Handling received network info\n");
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n");
parse_network_info(pstrRcvdNetworkInfo->buffer, &pstrNetworkInfo);
- if ((pstrNetworkInfo == NULL)
- || (hif_drv->strWILC_UsrScanReq.pfUserScanResult == NULL)) {
+ if ((!pstrNetworkInfo) ||
+ (!hif_drv->usr_scan_req.pfUserScanResult)) {
PRINT_ER("driver is null\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
goto done;
}
- for (i = 0; i < hif_drv->strWILC_UsrScanReq.u32RcvdChCount; i++) {
-
- if ((hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid != NULL) &&
- (pstrNetworkInfo->au8bssid != NULL)) {
- if (memcmp(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid,
- pstrNetworkInfo->au8bssid, 6) == 0) {
- if (pstrNetworkInfo->s8rssi <= hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi) {
+ for (i = 0; i < hif_drv->usr_scan_req.u32RcvdChCount; i++) {
+ if ((hif_drv->usr_scan_req.astrFoundNetworkInfo[i].au8bssid) &&
+ (pstrNetworkInfo->au8bssid)) {
+ if (memcmp(hif_drv->usr_scan_req.astrFoundNetworkInfo[i].au8bssid,
+ pstrNetworkInfo->au8bssid, 6) == 0) {
+ if (pstrNetworkInfo->s8rssi <= hif_drv->usr_scan_req.astrFoundNetworkInfo[i].s8rssi) {
PRINT_D(HOSTINF_DBG, "Network previously discovered\n");
goto done;
} else {
- hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
+ hif_drv->usr_scan_req.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
bNewNtwrkFound = false;
break;
}
}
}
- if (bNewNtwrkFound == true) {
+ if (bNewNtwrkFound) {
PRINT_D(HOSTINF_DBG, "New network found\n");
- if (hif_drv->strWILC_UsrScanReq.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
- hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
+ if (hif_drv->usr_scan_req.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) {
+ hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi;
- if ((hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid != NULL)
- && (pstrNetworkInfo->au8bssid != NULL)) {
- memcpy(hif_drv->strWILC_UsrScanReq.astrFoundNetworkInfo[hif_drv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid,
- pstrNetworkInfo->au8bssid, 6);
+ if (hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].au8bssid &&
+ pstrNetworkInfo->au8bssid) {
+ memcpy(hif_drv->usr_scan_req.astrFoundNetworkInfo[hif_drv->usr_scan_req.u32RcvdChCount].au8bssid,
+ pstrNetworkInfo->au8bssid, 6);
- hif_drv->strWILC_UsrScanReq.u32RcvdChCount++;
+ hif_drv->usr_scan_req.u32RcvdChCount++;
pstrNetworkInfo->bNewNetwork = true;
pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid,
- pJoinParams);
-
-
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
+ hif_drv->usr_scan_req.u32UserScanPvoid,
+ pJoinParams);
}
} else {
PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit\n");
}
} else {
pstrNetworkInfo->bNewNetwork = false;
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
}
}
kfree(pstrRcvdNetworkInfo->buffer);
pstrRcvdNetworkInfo->buffer = NULL;
- if (pstrNetworkInfo != NULL) {
+ if (pstrNetworkInfo) {
DeallocateNetworkInfo(pstrNetworkInfo);
pstrNetworkInfo = NULL;
}
- return s32Error;
+ return result;
}
static s32 Handle_RcvdGnrlAsyncInfo(struct host_if_drv *hif_drv,
struct rcvd_async_info *pstrRcvdGnrlAsyncInfo)
{
- s32 s32Error = 0;
+ s32 result = 0;
u8 u8MsgType = 0;
u8 u8MsgID = 0;
u16 u16MsgLen = 0;
if ((hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) ||
(hif_drv->enuHostIFstate == HOST_IF_CONNECTED) ||
- hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
- if ((pstrRcvdGnrlAsyncInfo->buffer == NULL) ||
- (hif_drv->strWILC_UsrConnReq.pfUserConnectResult == NULL)) {
+ hif_drv->usr_scan_req.pfUserScanResult) {
+ if (!pstrRcvdGnrlAsyncInfo->buffer ||
+ !hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
PRINT_ER("driver is null\n");
return -EINVAL;
}
memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
if (u8MacStatus == MAC_CONNECTED) {
- memset(gapu8RcvdAssocResp, 0, MAX_ASSOC_RESP_FRAME_SIZE);
+ memset(rcv_assoc_resp, 0, MAX_ASSOC_RESP_FRAME_SIZE);
host_int_get_assoc_res_info(hif_drv,
- gapu8RcvdAssocResp,
+ rcv_assoc_resp,
MAX_ASSOC_RESP_FRAME_SIZE,
&u32RcvdAssocRespInfoLen);
PRINT_INFO(HOSTINF_DBG, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen);
if (u32RcvdAssocRespInfoLen != 0) {
-
PRINT_D(HOSTINF_DBG, "Parsing association response\n");
- s32Err = ParseAssocRespInfo(gapu8RcvdAssocResp, u32RcvdAssocRespInfoLen,
+ s32Err = ParseAssocRespInfo(rcv_assoc_resp, u32RcvdAssocRespInfoLen,
&pstrConnectRespInfo);
if (s32Err) {
PRINT_ER("ParseAssocRespInfo() returned error %d\n", s32Err);
if (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE) {
PRINT_INFO(HOSTINF_DBG, "Association response received : Successful connection status\n");
- if (pstrConnectRespInfo->pu8RespIEs != NULL) {
+ if (pstrConnectRespInfo->pu8RespIEs) {
strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen;
-
-
strConnectInfo.pu8RespIEs = kmalloc(pstrConnectRespInfo->u16RespIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs,
pstrConnectRespInfo->u16RespIEsLen);
}
}
- if (pstrConnectRespInfo != NULL) {
+ if (pstrConnectRespInfo) {
DeallocateAssocRespInfo(pstrConnectRespInfo);
pstrConnectRespInfo = NULL;
}
eth_zero_addr(u8ConnectedSSID);
}
- if (hif_drv->strWILC_UsrConnReq.pu8bssid != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pu8bssid) {
PRINT_D(HOSTINF_DBG, "Retrieving actual BSSID from AP\n");
memcpy(strConnectInfo.au8bssid, hif_drv->strWILC_UsrConnReq.pu8bssid, 6);
}
}
-
- if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs) {
strConnectInfo.ReqIEsLen = hif_drv->strWILC_UsrConnReq.ConnReqIEsLen;
strConnectInfo.pu8ReqIEs = kmalloc(hif_drv->strWILC_UsrConnReq.ConnReqIEsLen, GFP_KERNEL);
memcpy(strConnectInfo.pu8ReqIEs,
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen);
}
-
del_timer(&hif_drv->hConnectTimer);
hif_drv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
&strConnectInfo,
} else {
PRINT_D(HOSTINF_DBG, "MAC status : %d and Connect Status : %d\n", u8MacStatus, strConnectInfo.u16ConnectStatus);
hif_drv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = false;
+ scan_while_connected = false;
}
kfree(strConnectInfo.pu8RespIEs);
memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo));
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >>\n\n");
del_timer(&hif_drv->hScanTimer);
Handle_ScanDone((void *)hif_drv, SCAN_EVENT_ABORTED);
strDisconnectNotifInfo.ie = NULL;
strDisconnectNotifInfo.ie_len = 0;
- if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
g_obtainingIP = false;
host_int_set_power_mgmt(hif_drv, 0, 0);
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
- if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedJoinReq);
- gu8FlushedJoinReq = NULL;
+ if (join_req && join_req_drv == hif_drv) {
+ kfree(join_req);
+ join_req = NULL;
}
- if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedInfoElemAsoc);
- gu8FlushedInfoElemAsoc = NULL;
+
+ if (info_element && join_req_drv == hif_drv) {
+ kfree(info_element);
+ info_element = NULL;
}
hif_drv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = false;
+ scan_while_connected = false;
} else if ((u8MacStatus == MAC_DISCONNECTED) &&
- (hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL)) {
+ (hif_drv->usr_scan_req.pfUserScanResult)) {
PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW while scanning\n");
PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running Scan >>\n\n");
del_timer(&hif_drv->hScanTimer);
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult)
+ if (hif_drv->usr_scan_req.pfUserScanResult)
Handle_ScanDone(hif_drv, SCAN_EVENT_ABORTED);
-
}
-
}
kfree(pstrRcvdGnrlAsyncInfo->buffer);
pstrRcvdGnrlAsyncInfo->buffer = NULL;
- return s32Error;
+ return result;
}
static int Handle_Key(struct host_if_drv *hif_drv,
struct key_attr *pstrHostIFkeyAttr)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
struct wid strWIDList[5];
u8 i;
u8 *pu8keybuf;
s8 ret = 0;
switch (pstrHostIFkeyAttr->type) {
-
-
case WEP:
if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
-
PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
- PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", (pstrHostIFkeyAttr->attr.wep.index));
+ PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", pstrHostIFkeyAttr->attr.wep.index);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.mode;
strWIDList[1].id = WID_AUTH_TYPE;
strWIDList[1].type = WID_CHAR;
strWIDList[1].size = sizeof(char);
- strWIDList[1].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.auth_type));
+ strWIDList[1].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.auth_type;
strWIDList[2].id = (u16)WID_KEY_ID;
strWIDList[2].type = WID_CHAR;
- strWIDList[2].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
+ strWIDList[2].val = (s8 *)&pstrHostIFkeyAttr->attr.wep.index;
strWIDList[2].size = sizeof(char);
- pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len, GFP_KERNEL);
+ pu8keybuf = kmemdup(pstrHostIFkeyAttr->attr.wep.key,
+ pstrHostIFkeyAttr->attr.wep.key_len,
+ GFP_KERNEL);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send Key\n");
- return -1;
+ return -ENOMEM;
}
- memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wep.key,
- pstrHostIFkeyAttr->attr.wep.key_len);
-
kfree(pstrHostIFkeyAttr->attr.wep.key);
strWIDList[3].id = (u16)WID_WEP_KEY_VALUE;
strWIDList[3].size = pstrHostIFkeyAttr->attr.wep.key_len;
strWIDList[3].val = (s8 *)pu8keybuf;
-
- s32Error = send_config_pkt(SET_CFG, strWIDList, 4,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, strWIDList, 4,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
-
-
}
if (pstrHostIFkeyAttr->action & ADDKEY) {
PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
pu8keybuf = kmalloc(pstrHostIFkeyAttr->attr.wep.key_len + 2, GFP_KERNEL);
- if (pu8keybuf == NULL) {
+ if (!pu8keybuf) {
PRINT_ER("No buffer to send Key\n");
- return -1;
+ return -ENOMEM;
}
pu8keybuf[0] = pstrHostIFkeyAttr->attr.wep.index;
memcpy(pu8keybuf + 1, &pstrHostIFkeyAttr->attr.wep.key_len, 1);
memcpy(pu8keybuf + 2, pstrHostIFkeyAttr->attr.wep.key,
- pstrHostIFkeyAttr->attr.wep.key_len);
+ pstrHostIFkeyAttr->attr.wep.key_len);
kfree(pstrHostIFkeyAttr->attr.wep.key);
- strWID.id = (u16)WID_ADD_WEP_KEY;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
+ wid.id = (u16)WID_ADD_WEP_KEY;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = pstrHostIFkeyAttr->attr.wep.key_len + 2;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
} else if (pstrHostIFkeyAttr->action & REMOVEKEY) {
-
PRINT_D(HOSTINF_DBG, "Removing key\n");
- strWID.id = (u16)WID_REMOVE_WEP_KEY;
- strWID.type = WID_STR;
+ wid.id = (u16)WID_REMOVE_WEP_KEY;
+ wid.type = WID_STR;
s8idxarray[0] = (s8)pstrHostIFkeyAttr->attr.wep.index;
- strWID.val = s8idxarray;
- strWID.size = 1;
+ wid.val = s8idxarray;
+ wid.size = 1;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
} else {
- strWID.id = (u16)WID_KEY_ID;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)(&(pstrHostIFkeyAttr->attr.wep.index));
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_KEY_ID;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&pstrHostIFkeyAttr->attr.wep.index;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Setting default key index\n");
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
}
up(&hif_drv->hSemTestKeyBlock);
break;
case WPARxGtk:
if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
- if (pu8keybuf == NULL) {
+ if (!pu8keybuf) {
PRINT_ER("No buffer to send RxGTK Key\n");
- ret = -1;
+ ret = -ENOMEM;
goto _WPARxGtk_end_case_;
}
- if (pstrHostIFkeyAttr->attr.wpa.seq != NULL)
+ if (pstrHostIFkeyAttr->attr.wpa.seq)
memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->attr.wpa.seq, 8);
memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
- pstrHostIFkeyAttr->attr.wpa.key_len);
+ pstrHostIFkeyAttr->attr.wpa.key_len);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
strWIDList[1].id = (u16)WID_ADD_RX_GTK;
strWIDList[1].type = WID_STR;
strWIDList[1].val = (s8 *)pu8keybuf;
strWIDList[1].size = RX_MIC_KEY_MSG_LEN;
- s32Error = send_config_pkt(SET_CFG, strWIDList, 2,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, strWIDList, 2,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
up(&hif_drv->hSemTestKeyBlock);
pu8keybuf = kzalloc(RX_MIC_KEY_MSG_LEN, GFP_KERNEL);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send RxGTK Key\n");
- ret = -1;
+ ret = -ENOMEM;
goto _WPARxGtk_end_case_;
}
memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->attr.wpa.index, 1);
memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->attr.wpa.key,
- pstrHostIFkeyAttr->attr.wpa.key_len);
+ pstrHostIFkeyAttr->attr.wpa.key_len);
- strWID.id = (u16)WID_ADD_RX_GTK;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = RX_MIC_KEY_MSG_LEN;
+ wid.id = (u16)WID_ADD_RX_GTK;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = RX_MIC_KEY_MSG_LEN;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
up(&hif_drv->hSemTestKeyBlock);
_WPARxGtk_end_case_:
kfree(pstrHostIFkeyAttr->attr.wpa.key);
kfree(pstrHostIFkeyAttr->attr.wpa.seq);
- if (ret == -1)
+ if (ret)
return ret;
break;
case WPAPtk:
if (pstrHostIFkeyAttr->action & ADDKEY_AP) {
-
-
pu8keybuf = kmalloc(PTK_KEY_MSG_LEN + 1, GFP_KERNEL);
-
-
-
- if (pu8keybuf == NULL) {
+ if (!pu8keybuf) {
PRINT_ER("No buffer to send PTK Key\n");
- ret = -1;
+ ret = -ENOMEM;
goto _WPAPtk_end_case_;
-
}
memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.index, 1);
memcpy(pu8keybuf + 7, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
memcpy(pu8keybuf + 8, pstrHostIFkeyAttr->attr.wpa.key,
- pstrHostIFkeyAttr->attr.wpa.key_len);
+ pstrHostIFkeyAttr->attr.wpa.key_len);
strWIDList[0].id = (u16)WID_11I_MODE;
strWIDList[0].type = WID_CHAR;
strWIDList[0].size = sizeof(char);
- strWIDList[0].val = (s8 *)(&(pstrHostIFkeyAttr->attr.wpa.mode));
+ strWIDList[0].val = (s8 *)&pstrHostIFkeyAttr->attr.wpa.mode;
strWIDList[1].id = (u16)WID_ADD_PTK;
strWIDList[1].type = WID_STR;
strWIDList[1].val = (s8 *)pu8keybuf;
strWIDList[1].size = PTK_KEY_MSG_LEN + 1;
- s32Error = send_config_pkt(SET_CFG, strWIDList, 2,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, strWIDList, 2,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
up(&hif_drv->hSemTestKeyBlock);
}
if (pstrHostIFkeyAttr->action & ADDKEY) {
-
-
pu8keybuf = kmalloc(PTK_KEY_MSG_LEN, GFP_KERNEL);
-
-
-
- if (pu8keybuf == NULL) {
+ if (!pu8keybuf) {
PRINT_ER("No buffer to send PTK Key\n");
- ret = -1;
+ ret = -ENOMEM;
goto _WPAPtk_end_case_;
-
}
memcpy(pu8keybuf, pstrHostIFkeyAttr->attr.wpa.mac_addr, 6);
memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->attr.wpa.key_len, 1);
memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->attr.wpa.key,
- pstrHostIFkeyAttr->attr.wpa.key_len);
+ pstrHostIFkeyAttr->attr.wpa.key_len);
- strWID.id = (u16)WID_ADD_PTK;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = PTK_KEY_MSG_LEN;
+ wid.id = (u16)WID_ADD_PTK;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = PTK_KEY_MSG_LEN;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
up(&hif_drv->hSemTestKeyBlock);
}
_WPAPtk_end_case_:
kfree(pstrHostIFkeyAttr->attr.wpa.key);
- if (ret == -1)
+ if (ret)
return ret;
break;
-
case PMKSA:
PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n");
pu8keybuf = kmalloc((pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1, GFP_KERNEL);
- if (pu8keybuf == NULL) {
+ if (!pu8keybuf) {
PRINT_ER("No buffer to send PMKSA Key\n");
- return -1;
+ return -ENOMEM;
}
pu8keybuf[0] = pstrHostIFkeyAttr->attr.pmkid.numpmkid;
memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->attr.pmkid.pmkidlist[i].pmkid, PMKID_LEN);
}
- strWID.id = (u16)WID_PMKID_INFO;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8keybuf;
- strWID.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
+ wid.id = (u16)WID_PMKID_INFO;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8keybuf;
+ wid.size = (pstrHostIFkeyAttr->attr.pmkid.numpmkid * PMKSA_KEY_LEN) + 1;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
kfree(pu8keybuf);
break;
}
- if (s32Error)
+ if (result)
PRINT_ER("Failed to send key config packet\n");
-
- return s32Error;
+ return result;
}
static void Handle_Disconnect(struct host_if_drv *hif_drv)
{
- struct wid strWID;
+ struct wid wid;
- s32 s32Error = 0;
+ s32 result = 0;
u16 u16DummyReasonCode = 0;
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&u16DummyReasonCode;
- strWID.size = sizeof(char);
-
-
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&u16DummyReasonCode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
eth_zero_addr(u8ConnectedSSID);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to send dissconect config packet\n");
} else {
tstrDisconnectNotifInfo strDisconnectNotifInfo;
strDisconnectNotifInfo.ie = NULL;
strDisconnectNotifInfo.ie_len = 0;
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
del_timer(&hif_drv->hScanTimer);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
- if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
+ if (hif_drv->strWILC_UsrConnReq.pfUserConnectResult) {
if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
del_timer(&hif_drv->hConnectTimer);
PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL\n");
}
- gbScanWhileConnected = false;
+ scan_while_connected = false;
hif_drv->enuHostIFstate = HOST_IF_IDLE;
hif_drv->strWILC_UsrConnReq.ConnReqIEsLen = 0;
kfree(hif_drv->strWILC_UsrConnReq.pu8ConnReqIEs);
- if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedJoinReq);
- gu8FlushedJoinReq = NULL;
- }
- if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == hif_drv) {
- kfree(gu8FlushedInfoElemAsoc);
- gu8FlushedInfoElemAsoc = NULL;
+ if (join_req && join_req_drv == hif_drv) {
+ kfree(join_req);
+ join_req = NULL;
}
+ if (info_element && join_req_drv == hif_drv) {
+ kfree(info_element);
+ info_element = NULL;
+ }
}
up(&hif_drv->hSemTestDisconnectBlock);
}
-
void resolve_disconnect_aberration(struct host_if_drv *hif_drv)
{
if (!hif_drv)
static s32 Handle_GetChnl(struct host_if_drv *hif_drv)
{
+ s32 result = 0;
+ struct wid wid;
- s32 s32Error = 0;
- struct wid strWID;
-
- strWID.id = (u16)WID_CURRENT_CHANNEL;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&gu8Chnl;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_CURRENT_CHANNEL;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&ch_no;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting channel value\n");
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to get channel number\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
up(&hif_drv->hSemGetCHNL);
- return s32Error;
-
-
-
+ return result;
}
static void Handle_GetRssi(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
- strWID.id = (u16)WID_RSSI;
- strWID.type = WID_CHAR;
- strWID.val = &gs8Rssi;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_RSSI;
+ wid.type = WID_CHAR;
+ wid.val = &rssi;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting RSSI value\n");
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result) {
PRINT_ER("Failed to get RSSI value\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
up(&hif_drv->hSemGetRSSI);
-
-
}
-
static void Handle_GetLinkspeed(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
- gs8lnkspd = 0;
+ link_speed = 0;
- strWID.id = (u16)WID_LINKSPEED;
- strWID.type = WID_CHAR;
- strWID.val = &gs8lnkspd;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_LINKSPEED;
+ wid.type = WID_CHAR;
+ wid.val = &link_speed;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n");
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result) {
PRINT_ER("Failed to get LINKSPEED value\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
- up(&(hif_drv->hSemGetLINKSPEED));
-
-
+ up(&hif_drv->hSemGetLINKSPEED);
}
s32 Handle_GetStatistics(struct host_if_drv *hif_drv, struct rf_info *pstrStatistics)
{
struct wid strWIDList[5];
- u32 u32WidsCount = 0, s32Error = 0;
+ u32 u32WidsCount = 0, result = 0;
strWIDList[u32WidsCount].id = WID_LINKSPEED;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u8LinkSpeed));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u8LinkSpeed;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_RSSI;
strWIDList[u32WidsCount].type = WID_CHAR;
strWIDList[u32WidsCount].size = sizeof(char);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->s8RSSI));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->s8RSSI;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32TxCount;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32RxCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32RxCount;
u32WidsCount++;
strWIDList[u32WidsCount].id = WID_FAILED_COUNT;
strWIDList[u32WidsCount].type = WID_INT;
strWIDList[u32WidsCount].size = sizeof(u32);
- strWIDList[u32WidsCount].val = (s8 *)(&(pstrStatistics->u32TxFailureCount));
+ strWIDList[u32WidsCount].val = (s8 *)&pstrStatistics->u32TxFailureCount;
u32WidsCount++;
- s32Error = send_config_pkt(GET_CFG, strWIDList, u32WidsCount,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(GET_CFG, strWIDList, u32WidsCount,
+ get_id_from_handler(hif_drv));
- if (s32Error)
+ if (result)
PRINT_ER("Failed to send scan paramters config packet\n");
up(&hif_sema_wait_response);
return 0;
-
}
static s32 Handle_Get_InActiveTime(struct host_if_drv *hif_drv,
struct sta_inactive_t *strHostIfStaInactiveT)
{
-
- s32 s32Error = 0;
+ s32 result = 0;
u8 *stamac;
- struct wid strWID;
-
- strWID.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
- strWID.type = WID_STR;
- strWID.size = ETH_ALEN;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
+ struct wid wid;
+ wid.id = (u16)WID_SET_STA_MAC_INACTIVE_TIME;
+ wid.type = WID_STR;
+ wid.size = ETH_ALEN;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
- stamac = strWID.val;
+ stamac = wid.val;
memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN);
-
PRINT_D(CFG80211_DBG, "SETING STA inactive time\n");
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
-
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to SET incative time\n");
return -EFAULT;
}
+ wid.id = (u16)WID_GET_INACTIVE_TIME;
+ wid.type = WID_INT;
+ wid.val = (s8 *)&inactive_time;
+ wid.size = sizeof(u32);
- strWID.id = (u16)WID_GET_INACTIVE_TIME;
- strWID.type = WID_INT;
- strWID.val = (s8 *)&gu32InactiveTime;
- strWID.size = sizeof(u32);
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
-
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
-
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to get incative time\n");
return -EFAULT;
}
-
- PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", gu32InactiveTime);
+ PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", inactive_time);
up(&hif_drv->hSemInactiveTime);
- return s32Error;
-
-
-
+ return result;
}
static void Handle_AddBeacon(struct host_if_drv *hif_drv,
struct beacon_attr *pstrSetBeaconParam)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Adding BEACON\n");
- strWID.id = (u16)WID_ADD_BEACON;
- strWID.type = WID_BIN;
- strWID.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.id = (u16)WID_ADD_BEACON;
+ wid.type = WID_BIN;
+ wid.size = pstrSetBeaconParam->head_len + pstrSetBeaconParam->tail_len + 16;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = (pstrSetBeaconParam->interval & 0xFF);
*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 8) & 0xFF);
*pu8CurrByte++ = ((pstrSetBeaconParam->interval >> 16) & 0xFF);
memcpy(pu8CurrByte, pstrSetBeaconParam->tail, pstrSetBeaconParam->tail_len);
pu8CurrByte += pstrSetBeaconParam->tail_len;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send add beacon config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
kfree(pstrSetBeaconParam->head);
kfree(pstrSetBeaconParam->tail);
}
static void Handle_DelBeacon(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_DEL_BEACON;
- strWID.type = WID_CHAR;
- strWID.size = sizeof(char);
- strWID.val = &gu8DelBcn;
+ wid.id = (u16)WID_DEL_BEACON;
+ wid.type = WID_CHAR;
+ wid.size = sizeof(char);
+ wid.val = &del_beacon;
- if (strWID.val == NULL)
+ if (!wid.val)
return;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
PRINT_D(HOSTINF_DBG, "Deleting BEACON\n");
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send delete beacon config packet\n");
}
static void Handle_AddStation(struct host_if_drv *hif_drv,
struct add_sta_param *pstrStationParam)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Handling add station\n");
- strWID.id = (u16)WID_ADD_STA;
- strWID.type = WID_BIN;
- strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
+ wid.id = (u16)WID_ADD_STA;
+ wid.type = WID_BIN;
+ wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error != 0)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result != 0)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
kfree(pstrStationParam->pu8Rates);
- kfree(strWID.val);
+ kfree(wid.val);
}
static void Handle_DelAllSta(struct host_if_drv *hif_drv,
struct del_all_sta *pstrDelAllStaParam)
{
- s32 s32Error = 0;
-
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
u8 i;
u8 au8Zero_Buff[6] = {0};
- strWID.id = (u16)WID_DEL_ALL_STA;
- strWID.type = WID_STR;
- strWID.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
+ wid.id = (u16)WID_DEL_ALL_STA;
+ wid.type = WID_STR;
+ wid.size = (pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1;
PRINT_D(HOSTINF_DBG, "Handling delete station\n");
- strWID.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.val = kmalloc((pstrDelAllStaParam->assoc_sta * ETH_ALEN) + 1, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*(pu8CurrByte++) = pstrDelAllStaParam->assoc_sta;
pu8CurrByte += ETH_ALEN;
}
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
up(&hif_sema_wait_response);
}
static void Handle_DelStation(struct host_if_drv *hif_drv,
struct del_sta *pstrDelStaParam)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_REMOVE_STA;
- strWID.type = WID_BIN;
- strWID.size = ETH_ALEN;
+ wid.id = (u16)WID_REMOVE_STA;
+ wid.type = WID_BIN;
+ wid.size = ETH_ALEN;
PRINT_D(HOSTINF_DBG, "Handling delete station\n");
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
memcpy(pu8CurrByte, pstrDelStaParam->mac_addr, ETH_ALEN);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send add station config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
+ kfree(wid.val);
}
static void Handle_EditStation(struct host_if_drv *hif_drv,
struct add_sta_param *pstrStationParam)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
- strWID.id = (u16)WID_EDIT_STA;
- strWID.type = WID_BIN;
- strWID.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
+ wid.id = (u16)WID_EDIT_STA;
+ wid.type = WID_BIN;
+ wid.size = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates;
PRINT_D(HOSTINF_DBG, "Handling edit station\n");
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send edit station config packet\n");
ERRORHANDLER:
kfree(pstrStationParam->pu8Rates);
- kfree(strWID.val);
+ kfree(wid.val);
}
static int Handle_RemainOnChan(struct host_if_drv *hif_drv,
struct remain_ch *pstrHostIfRemainOnChan)
{
- s32 s32Error = 0;
+ s32 result = 0;
u8 u8remain_on_chan_flag;
- struct wid strWID;
+ struct wid wid;
if (!hif_drv->u8RemainOnChan_pendingreq) {
hif_drv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid;
pstrHostIfRemainOnChan->u16Channel = hif_drv->strHostIfRemainOnChan.u16Channel;
}
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_INFO(GENERIC_DBG, "Required to remain on chan while scanning return\n");
hif_drv->u8RemainOnChan_pendingreq = 1;
- s32Error = -EBUSY;
+ result = -EBUSY;
goto ERRORHANDLER;
}
if (hif_drv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
PRINT_INFO(GENERIC_DBG, "Required to remain on chan while connecting return\n");
- s32Error = -EBUSY;
+ result = -EBUSY;
goto ERRORHANDLER;
}
if (g_obtainingIP || connecting) {
PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n");
- s32Error = -EBUSY;
+ result = -EBUSY;
goto ERRORHANDLER;
}
PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel);
u8remain_on_chan_flag = true;
- strWID.id = (u16)WID_REMAIN_ON_CHAN;
- strWID.type = WID_STR;
- strWID.size = 2;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
-
- if (strWID.val == NULL) {
- s32Error = -ENOMEM;
+ wid.id = (u16)WID_REMAIN_ON_CHAN;
+ wid.type = WID_STR;
+ wid.size = 2;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val) {
+ result = -ENOMEM;
goto ERRORHANDLER;
}
- strWID.val[0] = u8remain_on_chan_flag;
- strWID.val[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
+ wid.val[0] = u8remain_on_chan_flag;
+ wid.val[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error != 0)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result != 0)
PRINT_ER("Failed to set remain on channel\n");
ERRORHANDLER:
if (hif_drv->u8RemainOnChan_pendingreq)
hif_drv->u8RemainOnChan_pendingreq = 0;
}
- return s32Error;
+
+ return result;
}
static int Handle_RegisterFrame(struct host_if_drv *hif_drv,
struct reg_frame *pstrHostIfRegisterFrame)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType);
- strWID.id = (u16)WID_REGISTER_FRAME;
- strWID.type = WID_STR;
- strWID.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.id = (u16)WID_REGISTER_FRAME;
+ wid.type = WID_STR;
+ wid.val = kmalloc(sizeof(u16) + 2, GFP_KERNEL);
+ if (!wid.val)
return -ENOMEM;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = pstrHostIfRegisterFrame->bReg;
*pu8CurrByte++ = pstrHostIfRegisterFrame->u8Regid;
- memcpy(pu8CurrByte, &(pstrHostIfRegisterFrame->u16FrameType), sizeof(u16));
-
+ memcpy(pu8CurrByte, &pstrHostIfRegisterFrame->u16FrameType,
+ sizeof(u16));
- strWID.size = sizeof(u16) + 2;
+ wid.size = sizeof(u16) + 2;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result) {
PRINT_ER("Failed to frame register config packet\n");
- s32Error = -EINVAL;
+ result = -EINVAL;
}
- return s32Error;
-
+ return result;
}
-#define FALSE_FRMWR_CHANNEL 100
static u32 Handle_ListenStateExpired(struct host_if_drv *hif_drv,
struct remain_ch *pstrHostIfRemainOnChan)
{
u8 u8remain_on_chan_flag;
- struct wid strWID;
- s32 s32Error = 0;
+ struct wid wid;
+ s32 result = 0;
PRINT_D(HOSTINF_DBG, "CANCEL REMAIN ON CHAN\n");
if (P2P_LISTEN_STATE) {
u8remain_on_chan_flag = false;
- strWID.id = (u16)WID_REMAIN_ON_CHAN;
- strWID.type = WID_STR;
- strWID.size = 2;
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
+ wid.id = (u16)WID_REMAIN_ON_CHAN;
+ wid.type = WID_STR;
+ wid.size = 2;
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ if (!wid.val)
PRINT_ER("Failed to allocate memory\n");
- strWID.val[0] = u8remain_on_chan_flag;
- strWID.val[1] = FALSE_FRMWR_CHANNEL;
+ wid.val[0] = u8remain_on_chan_flag;
+ wid.val[1] = FALSE_FRMWR_CHANNEL;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error != 0) {
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result != 0) {
PRINT_ER("Failed to set remain on channel\n");
goto _done_;
}
P2P_LISTEN_STATE = 0;
} else {
PRINT_D(GENERIC_DBG, "Not in listen state\n");
- s32Error = -EFAULT;
+ result = -EFAULT;
}
_done_:
- return s32Error;
+ return result;
}
static void ListenTimerCB(unsigned long arg)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct host_if_drv *hif_drv = (struct host_if_drv *)arg;
msg.drv = hif_drv;
msg.body.remain_on_ch.u32ListenSessionID = hif_drv->strHostIfRemainOnChan.u32ListenSessionID;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
}
static void Handle_PowerManagement(struct host_if_drv *hif_drv,
struct power_mgmt_param *strPowerMgmtParam)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
s8 s8PowerMode;
- strWID.id = (u16)WID_POWER_MANAGEMENT;
+ wid.id = (u16)WID_POWER_MANAGEMENT;
- if (strPowerMgmtParam->enabled == true)
+ if (strPowerMgmtParam->enabled)
s8PowerMode = MIN_FAST_PS;
else
s8PowerMode = NO_POWERSAVE;
PRINT_D(HOSTINF_DBG, "Handling power mgmt to %d\n", s8PowerMode);
- strWID.val = &s8PowerMode;
- strWID.size = sizeof(char);
+ wid.val = &s8PowerMode;
+ wid.size = sizeof(char);
PRINT_D(HOSTINF_DBG, "Handling Power Management\n");
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send power management config packet\n");
}
static void Handle_SetMulticastFilter(struct host_if_drv *hif_drv,
struct set_multicast *strHostIfSetMulti)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n");
- strWID.id = (u16)WID_SETUP_MULTICAST_FILTER;
- strWID.type = WID_BIN;
- strWID.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
- strWID.val = kmalloc(strWID.size, GFP_KERNEL);
- if (strWID.val == NULL)
+ wid.id = (u16)WID_SETUP_MULTICAST_FILTER;
+ wid.type = WID_BIN;
+ wid.size = sizeof(struct set_multicast) + ((strHostIfSetMulti->cnt) * ETH_ALEN);
+ wid.val = kmalloc(wid.size, GFP_KERNEL);
+ if (!wid.val)
goto ERRORHANDLER;
- pu8CurrByte = strWID.val;
+ pu8CurrByte = wid.val;
*pu8CurrByte++ = (strHostIfSetMulti->enabled & 0xFF);
*pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 8) & 0xFF);
*pu8CurrByte++ = ((strHostIfSetMulti->enabled >> 16) & 0xFF);
if ((strHostIfSetMulti->cnt) > 0)
memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->cnt) * ETH_ALEN));
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_ER("Failed to send setup multicast config packet\n");
ERRORHANDLER:
- kfree(strWID.val);
-
+ kfree(wid.val);
}
static s32 Handle_AddBASession(struct host_if_drv *hif_drv,
struct ba_session_info *strHostIfBASessionInfo)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
int AddbaTimeout = 100;
char *ptr = NULL;
strHostIfBASessionInfo->u16SessionTimeout,
strHostIfBASessionInfo->u8Ted);
- strWID.id = (u16)WID_11E_P_ACTION_REQ;
- strWID.type = WID_STR;
- strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
- strWID.size = BLOCK_ACK_REQ_SIZE;
- ptr = strWID.val;
+ wid.id = (u16)WID_11E_P_ACTION_REQ;
+ wid.type = WID_STR;
+ wid.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
+ wid.size = BLOCK_ACK_REQ_SIZE;
+ ptr = wid.val;
*ptr++ = 0x14;
*ptr++ = 0x3;
*ptr++ = 0x0;
*ptr++ = 8;
*ptr++ = 0;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n");
-
- strWID.id = (u16)WID_11E_P_ACTION_REQ;
- strWID.type = WID_STR;
- strWID.size = 15;
- ptr = strWID.val;
+ wid.id = (u16)WID_11E_P_ACTION_REQ;
+ wid.type = WID_STR;
+ wid.size = 15;
+ ptr = wid.val;
*ptr++ = 15;
*ptr++ = 7;
*ptr++ = 0x2;
*ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF);
*ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
*ptr++ = 3;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- kfree(strWID.val);
-
- return s32Error;
+ kfree(wid.val);
+ return result;
}
static s32 Handle_DelAllRxBASessions(struct host_if_drv *hif_drv,
struct ba_session_info *strHostIfBASessionInfo)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
char *ptr = NULL;
PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x\nTID=%d\n",
strHostIfBASessionInfo->au8Bssid[2],
strHostIfBASessionInfo->u8Ted);
- strWID.id = (u16)WID_DEL_ALL_RX_BA;
- strWID.type = WID_STR;
- strWID.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
- strWID.size = BLOCK_ACK_REQ_SIZE;
- ptr = strWID.val;
+ wid.id = (u16)WID_DEL_ALL_RX_BA;
+ wid.type = WID_STR;
+ wid.val = kmalloc(BLOCK_ACK_REQ_SIZE, GFP_KERNEL);
+ wid.size = BLOCK_ACK_REQ_SIZE;
+ ptr = wid.val;
*ptr++ = 0x14;
*ptr++ = 0x3;
*ptr++ = 0x2;
*ptr++ = 0;
*ptr++ = 32;
- s32Error = send_config_pkt(SET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error)
+ result = send_config_pkt(SET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result)
PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
-
- kfree(strWID.val);
+ kfree(wid.val);
up(&hif_sema_wait_response);
- return s32Error;
-
+ return result;
}
static int hostIFthread(void *pvArg)
continue;
}
- if (msg.id == HOST_IF_MSG_CONNECT && hif_drv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
+ if (msg.id == HOST_IF_MSG_CONNECT &&
+ hif_drv->usr_scan_req.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n");
wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
usleep_range(2 * 1000, 2 * 1000);
s32 host_int_remove_key(struct host_if_drv *hif_drv, const u8 *pu8StaAddress)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_REMOVE_KEY;
- strWID.type = WID_STR;
- strWID.val = (s8 *)pu8StaAddress;
- strWID.size = 6;
+ wid.id = (u16)WID_REMOVE_KEY;
+ wid.type = WID_STR;
+ wid.val = (s8 *)pu8StaAddress;
+ wid.size = 6;
return 0;
}
return result;
}
-s32 host_int_set_WEPDefaultKeyID(struct host_if_drv *hif_drv, u8 u8Index)
+int host_int_set_wep_default_key(struct host_if_drv *hif_drv, u8 index)
{
- s32 s32Error = 0;
+ int result = 0;
struct host_if_msg msg;
-
if (!hif_drv) {
- s32Error = -EFAULT;
+ result = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return result;
}
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WEP;
msg.body.key_info.action = DEFAULTKEY;
msg.drv = hif_drv;
- msg.body.key_info.attr.wep.index = u8Index;
+ msg.body.key_info.attr.wep.index = index;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Error in sending message queue : Default key index\n");
down(&hif_drv->hSemTestKeyBlock);
- return s32Error;
+ return result;
}
s32 host_int_add_wep_key_bss_sta(struct host_if_drv *hif_drv,
u8 u8WepKeylen,
u8 u8Keyidx)
{
-
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return -EFAULT;
}
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WEP;
msg.body.key_info.action = ADDKEY;
msg.body.key_info.attr.wep.key_len = (u8WepKeylen);
msg.body.key_info.attr.wep.index = u8Keyidx;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Error in sending message queue :WEP Key\n");
down(&hif_drv->hSemTestKeyBlock);
- return s32Error;
-
+ return result;
}
s32 host_int_add_wep_key_bss_ap(struct host_if_drv *hif_drv,
u8 u8mode,
enum AUTHTYPE tenuAuth_type)
{
-
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
u8 i;
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return -EFAULT;
}
memset(&msg, 0, sizeof(struct host_if_msg));
msg.body.key_info.attr.wep.mode = u8mode;
msg.body.key_info.attr.wep.auth_type = tenuAuth_type;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ if (result)
PRINT_ER("Error in sending message queue :WEP Key\n");
down(&hif_drv->hSemTestKeyBlock);
- return s32Error;
-
+ return result;
}
s32 host_int_add_ptk(struct host_if_drv *hif_drv, const u8 *pu8Ptk,
const u8 *pu8RxMic, const u8 *pu8TxMic,
u8 mode, u8 u8Ciphermode, u8 u8Idx)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
u8 u8KeyLen = u8PtkKeylen;
u32 i;
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return -EFAULT;
}
- if (pu8RxMic != NULL)
+
+ if (pu8RxMic)
u8KeyLen += RX_MIC_KEY_LEN;
- if (pu8TxMic != NULL)
+
+ if (pu8TxMic)
u8KeyLen += TX_MIC_KEY_LEN;
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WPAPtk;
if (mode == AP_MODE) {
msg.body.key_info.attr.wpa.key = kmalloc(u8PtkKeylen, GFP_KERNEL);
memcpy(msg.body.key_info.attr.wpa.key, pu8Ptk, u8PtkKeylen);
- if (pu8RxMic != NULL) {
+ if (pu8RxMic) {
memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic, RX_MIC_KEY_LEN);
if (INFO) {
for (i = 0; i < RX_MIC_KEY_LEN; i++)
PRINT_INFO(CFG80211_DBG, "PairwiseRx[%d] = %x\n", i, pu8RxMic[i]);
}
}
- if (pu8TxMic != NULL) {
+ if (pu8TxMic) {
memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic, TX_MIC_KEY_LEN);
if (INFO) {
for (i = 0; i < TX_MIC_KEY_LEN; i++)
msg.body.key_info.attr.wpa.mode = u8Ciphermode;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ if (result)
PRINT_ER("Error in sending message queue: PTK Key\n");
down(&hif_drv->hSemTestKeyBlock);
- return s32Error;
+ return result;
}
s32 host_int_add_rx_gtk(struct host_if_drv *hif_drv, const u8 *pu8RxGtk,
const u8 *pu8RxMic, const u8 *pu8TxMic,
u8 mode, u8 u8Ciphermode)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
u8 u8KeyLen = u8GtkKeylen;
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return -EFAULT;
}
memset(&msg, 0, sizeof(struct host_if_msg));
-
- if (pu8RxMic != NULL)
+ if (pu8RxMic)
u8KeyLen += RX_MIC_KEY_LEN;
- if (pu8TxMic != NULL)
+
+ if (pu8TxMic)
u8KeyLen += TX_MIC_KEY_LEN;
- if (KeyRSC != NULL) {
+
+ if (KeyRSC) {
msg.body.key_info.attr.wpa.seq = kmalloc(u32KeyRSClen, GFP_KERNEL);
memcpy(msg.body.key_info.attr.wpa.seq, KeyRSC, u32KeyRSClen);
}
-
msg.id = HOST_IF_MSG_KEY;
msg.body.key_info.type = WPARxGtk;
msg.drv = hif_drv;
msg.body.key_info.attr.wpa.key = kmalloc(u8KeyLen, GFP_KERNEL);
memcpy(msg.body.key_info.attr.wpa.key, pu8RxGtk, u8GtkKeylen);
- if (pu8RxMic != NULL) {
- memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic, RX_MIC_KEY_LEN);
- }
- if (pu8TxMic != NULL) {
- memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic, TX_MIC_KEY_LEN);
- }
+ if (pu8RxMic)
+ memcpy(msg.body.key_info.attr.wpa.key + 16, pu8RxMic,
+ RX_MIC_KEY_LEN);
+
+ if (pu8TxMic)
+ memcpy(msg.body.key_info.attr.wpa.key + 24, pu8TxMic,
+ TX_MIC_KEY_LEN);
msg.body.key_info.attr.wpa.index = u8KeyIdx;
msg.body.key_info.attr.wpa.key_len = u8KeyLen;
msg.body.key_info.attr.wpa.seq_len = u32KeyRSClen;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Error in sending message queue: RX GTK\n");
down(&hif_drv->hSemTestKeyBlock);
- return s32Error;
+ return result;
}
s32 host_int_set_pmkid_info(struct host_if_drv *hif_drv, struct host_if_pmkid_attr *pu8PmkidInfoArray)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
u32 i;
-
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("driver is null\n");
- return s32Error;
+ return -EFAULT;
}
memset(&msg, 0, sizeof(struct host_if_msg));
msg.drv = hif_drv;
for (i = 0; i < pu8PmkidInfoArray->numpmkid; i++) {
- memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].bssid, &pu8PmkidInfoArray->pmkidlist[i].bssid,
- ETH_ALEN);
- memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].pmkid, &pu8PmkidInfoArray->pmkidlist[i].pmkid,
- PMKID_LEN);
+ memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].bssid,
+ &pu8PmkidInfoArray->pmkidlist[i].bssid, ETH_ALEN);
+ memcpy(msg.body.key_info.attr.pmkid.pmkidlist[i].pmkid,
+ &pu8PmkidInfoArray->pmkidlist[i].pmkid, PMKID_LEN);
}
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
- return s32Error;
+ return result;
}
s32 host_int_get_pmkid_info(struct host_if_drv *hif_drv,
u8 *pu8PmkidInfoArray,
u32 u32PmkidInfoLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_PMKID_INFO;
- strWID.type = WID_STR;
- strWID.size = u32PmkidInfoLen;
- strWID.val = pu8PmkidInfoArray;
+ wid.id = (u16)WID_PMKID_INFO;
+ wid.type = WID_STR;
+ wid.size = u32PmkidInfoLen;
+ wid.val = pu8PmkidInfoArray;
return 0;
}
u8 *pu8PassPhrase,
u8 u8Psklength)
{
- struct wid strWID;
+ struct wid wid;
if ((u8Psklength > 7) && (u8Psklength < 65)) {
- strWID.id = (u16)WID_11I_PSK;
- strWID.type = WID_STR;
- strWID.val = pu8PassPhrase;
- strWID.size = u8Psklength;
+ wid.id = (u16)WID_11I_PSK;
+ wid.type = WID_STR;
+ wid.val = pu8PassPhrase;
+ wid.size = u8Psklength;
}
return 0;
s32 host_int_get_MacAddress(struct host_if_drv *hif_drv, u8 *pu8MacAddress)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_MAC_ADDRESS;
- msg.body.get_mac_info.u8MacAddress = pu8MacAddress;
+ msg.body.get_mac_info.mac_addr = pu8MacAddress;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send get mac address\n");
return -EFAULT;
}
down(&hif_sema_wait_response);
- return s32Error;
+ return result;
}
s32 host_int_set_MacAddress(struct host_if_drv *hif_drv, u8 *pu8MacAddress)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
PRINT_D(GENERIC_DBG, "mac addr = %x:%x:%x\n", pu8MacAddress[0], pu8MacAddress[1], pu8MacAddress[2]);
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_MAC_ADDRESS;
- memcpy(msg.body.set_mac_info.u8MacAddress, pu8MacAddress, ETH_ALEN);
+ memcpy(msg.body.set_mac_info.mac_addr, pu8MacAddress, ETH_ALEN);
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Failed to send message queue: Set mac address\n");
- return s32Error;
-
+ return result;
}
s32 host_int_get_RSNAConfigPSKPassPhrase(struct host_if_drv *hif_drv,
u8 *pu8PassPhrase, u8 u8Psklength)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_11I_PSK;
- strWID.type = WID_STR;
- strWID.size = u8Psklength;
- strWID.val = pu8PassPhrase;
+ wid.id = (u16)WID_11I_PSK;
+ wid.type = WID_STR;
+ wid.size = u8Psklength;
+ wid.val = pu8PassPhrase;
return 0;
}
s32 host_int_set_start_scan_req(struct host_if_drv *hif_drv, u8 scanSource)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_START_SCAN_REQ;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&scanSource;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_START_SCAN_REQ;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&scanSource;
+ wid.size = sizeof(char);
return 0;
}
s32 host_int_get_start_scan_req(struct host_if_drv *hif_drv, u8 *pu8ScanSource)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_START_SCAN_REQ;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)pu8ScanSource;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_START_SCAN_REQ;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)pu8ScanSource;
+ wid.size = sizeof(char);
return 0;
}
u8 u8security, enum AUTHTYPE tenuAuth_type,
u8 u8channel, void *pJoinParams)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
- if (!hif_drv || pfConnectResult == NULL) {
- s32Error = -EFAULT;
+ if (!hif_drv || !pfConnectResult) {
PRINT_ER("Driver is null\n");
- return s32Error;
+ return -EFAULT;
}
- if (pJoinParams == NULL) {
+ if (!pJoinParams) {
PRINT_ER("Unable to Join - JoinParams is NULL\n");
return -EFAULT;
}
msg.body.con_info.params = pJoinParams;
msg.drv = hif_drv ;
- if (pu8bssid != NULL) {
+ if (pu8bssid) {
msg.body.con_info.bssid = kmalloc(6, GFP_KERNEL);
memcpy(msg.body.con_info.bssid, pu8bssid, 6);
}
- if (pu8ssid != NULL) {
+ if (pu8ssid) {
msg.body.con_info.ssid_len = ssidLen;
msg.body.con_info.ssid = kmalloc(ssidLen, GFP_KERNEL);
memcpy(msg.body.con_info.ssid, pu8ssid, ssidLen);
}
- if (pu8IEs != NULL) {
+ if (pu8IEs) {
msg.body.con_info.ies_len = IEsLen;
msg.body.con_info.ies = kmalloc(IEsLen, GFP_KERNEL);
memcpy(msg.body.con_info.ies, pu8IEs, IEsLen);
else
PRINT_D(GENERIC_DBG, "Don't set state to 'connecting' as state is %d\n", hif_drv->enuHostIFstate);
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send message queue: Set join request\n");
return -EFAULT;
}
mod_timer(&hif_drv->hConnectTimer,
jiffies + msecs_to_jiffies(HOST_IF_CONNECT_TIMEOUT));
- return s32Error;
+ return result;
}
s32 host_int_flush_join_req(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
- if (!gu8FlushedJoinReq) {
- s32Error = -EFAULT;
- return s32Error;
- }
-
+ if (!join_req)
+ return -EFAULT;
if (!hif_drv) {
- s32Error = -EFAULT;
PRINT_ER("Driver is null\n");
- return s32Error;
+ return -EFAULT;
}
msg.id = HOST_IF_MSG_FLUSH_CONNECT;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send message queue: Flush join request\n");
return -EFAULT;
}
- return s32Error;
+ return result;
}
s32 host_int_disconnect(struct host_if_drv *hif_drv, u16 u16ReasonCode)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.id = HOST_IF_MSG_DISCONNECT;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Failed to send message queue: disconnect\n");
down(&hif_drv->hSemTestDisconnectBlock);
- return s32Error;
+ return result;
}
s32 host_int_disconnect_station(struct host_if_drv *hif_drv, u8 assoc_id)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_DISCONNECT;
- strWID.type = WID_CHAR;
- strWID.val = (s8 *)&assoc_id;
- strWID.size = sizeof(char);
+ wid.id = (u16)WID_DISCONNECT;
+ wid.type = WID_CHAR;
+ wid.val = (s8 *)&assoc_id;
+ wid.size = sizeof(char);
return 0;
}
-s32 host_int_get_assoc_req_info(struct host_if_drv *hif_drv, u8 *pu8AssocReqInfo,
- u32 u32AssocReqInfoLen)
+s32 host_int_get_assoc_req_info(struct host_if_drv *hif_drv,
+ u8 *pu8AssocReqInfo,
+ u32 u32AssocReqInfoLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_ASSOC_REQ_INFO;
- strWID.type = WID_STR;
- strWID.val = pu8AssocReqInfo;
- strWID.size = u32AssocReqInfoLen;
+ wid.id = (u16)WID_ASSOC_REQ_INFO;
+ wid.type = WID_STR;
+ wid.val = pu8AssocReqInfo;
+ wid.size = u32AssocReqInfoLen;
return 0;
}
-s32 host_int_get_assoc_res_info(struct host_if_drv *hif_drv, u8 *pu8AssocRespInfo,
- u32 u32MaxAssocRespInfoLen, u32 *pu32RcvdAssocRespInfoLen)
+s32 host_int_get_assoc_res_info(struct host_if_drv *hif_drv,
+ u8 *pu8AssocRespInfo,
+ u32 u32MaxAssocRespInfoLen,
+ u32 *pu32RcvdAssocRespInfoLen)
{
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
if (!hif_drv) {
PRINT_ER("Driver is null\n");
return -EFAULT;
}
- strWID.id = (u16)WID_ASSOC_RES_INFO;
- strWID.type = WID_STR;
- strWID.val = pu8AssocRespInfo;
- strWID.size = u32MaxAssocRespInfoLen;
+ wid.id = (u16)WID_ASSOC_RES_INFO;
+ wid.type = WID_STR;
+ wid.val = pu8AssocRespInfo;
+ wid.size = u32MaxAssocRespInfoLen;
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
- if (s32Error) {
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
+ if (result) {
*pu32RcvdAssocRespInfoLen = 0;
PRINT_ER("Failed to send association response config packet\n");
return -EINVAL;
} else {
- *pu32RcvdAssocRespInfoLen = strWID.size;
+ *pu32RcvdAssocRespInfoLen = wid.size;
}
- return s32Error;
+ return result;
}
-s32 host_int_get_rx_power_level(struct host_if_drv *hif_drv, u8 *pu8RxPowerLevel,
- u32 u32RxPowerLevelLen)
+s32 host_int_get_rx_power_level(struct host_if_drv *hif_drv,
+ u8 *pu8RxPowerLevel,
+ u32 u32RxPowerLevelLen)
{
- struct wid strWID;
+ struct wid wid;
- strWID.id = (u16)WID_RX_POWER_LEVEL;
- strWID.type = WID_STR;
- strWID.val = pu8RxPowerLevel;
- strWID.size = u32RxPowerLevelLen;
+ wid.id = (u16)WID_RX_POWER_LEVEL;
+ wid.type = WID_STR;
+ wid.val = pu8RxPowerLevel;
+ wid.size = u32RxPowerLevelLen;
return 0;
}
int host_int_wait_msg_queue_idle(void)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_Q_IDLE;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
int host_int_set_wfi_drv_handler(struct host_if_drv *hif_drv)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_WFIDRV_HANDLER;
- msg.body.drv.u32Address = get_id_from_handler(hif_drv);
+ msg.body.drv.handler = get_id_from_handler(hif_drv);
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
int host_int_set_operation_mode(struct host_if_drv *hif_drv, u32 mode)
{
int result = 0;
-
struct host_if_msg msg;
+
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_SET_OPERATION_MODE;
- msg.body.mode.u32Mode = mode;
+ msg.body.mode.mode = mode;
msg.drv = hif_drv;
result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
s32 host_int_get_host_chnl_num(struct host_if_drv *hif_drv, u8 *pu8ChNo)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.id = HOST_IF_MSG_GET_CHNL;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc mq send fail\n");
down(&hif_drv->hSemGetCHNL);
- *pu8ChNo = gu8Chnl;
-
- return s32Error;
-
+ *pu8ChNo = ch_no;
+ return result;
}
s32 host_int_get_inactive_time(struct host_if_drv *hif_drv,
const u8 *mac, u32 *pu32InactiveTime)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
}
memset(&msg, 0, sizeof(struct host_if_msg));
-
-
- memcpy(msg.body.mac_info.mac,
- mac, ETH_ALEN);
+ memcpy(msg.body.mac_info.mac, mac, ETH_ALEN);
msg.id = HOST_IF_MSG_GET_INACTIVETIME;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("Failed to send get host channel param's message queue ");
down(&hif_drv->hSemInactiveTime);
- *pu32InactiveTime = gu32InactiveTime;
+ *pu32InactiveTime = inactive_time;
- return s32Error;
+ return result;
}
s32 host_int_test_get_int_wid(struct host_if_drv *hif_drv, u32 *pu32TestMemAddr)
{
-
- s32 s32Error = 0;
- struct wid strWID;
+ s32 result = 0;
+ struct wid wid;
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
}
- strWID.id = (u16)WID_MEMORY_ADDRESS;
- strWID.type = WID_INT;
- strWID.val = (s8 *)pu32TestMemAddr;
- strWID.size = sizeof(u32);
+ wid.id = (u16)WID_MEMORY_ADDRESS;
+ wid.type = WID_INT;
+ wid.val = (s8 *)pu32TestMemAddr;
+ wid.size = sizeof(u32);
- s32Error = send_config_pkt(GET_CFG, &strWID, 1,
- get_id_from_handler(hif_drv));
+ result = send_config_pkt(GET_CFG, &wid, 1,
+ get_id_from_handler(hif_drv));
- if (s32Error) {
+ if (result) {
PRINT_ER("Failed to get wid value\n");
return -EINVAL;
} else {
PRINT_D(HOSTINF_DBG, "Successfully got wid value\n");
-
}
- return s32Error;
+ return result;
}
s32 host_int_get_rssi(struct host_if_drv *hif_drv, s8 *ps8Rssi)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_RSSI;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send get host channel param's message queue ");
return -EFAULT;
}
down(&hif_drv->hSemGetRSSI);
-
- if (ps8Rssi == NULL) {
+ if (!ps8Rssi) {
PRINT_ER("RSS pointer value is null");
return -EFAULT;
}
+ *ps8Rssi = rssi;
- *ps8Rssi = gs8Rssi;
-
-
- return s32Error;
+ return result;
}
s32 host_int_get_link_speed(struct host_if_drv *hif_drv, s8 *ps8lnkspd)
{
struct host_if_msg msg;
- s32 s32Error = 0;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ s32 result = 0;
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_LINKSPEED;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send GET_LINKSPEED to message queue ");
return -EFAULT;
}
down(&hif_drv->hSemGetLINKSPEED);
-
- if (ps8lnkspd == NULL) {
+ if (!ps8lnkspd) {
PRINT_ER("LINKSPEED pointer value is null");
return -EFAULT;
}
+ *ps8lnkspd = link_speed;
- *ps8lnkspd = gs8lnkspd;
-
-
- return s32Error;
+ return result;
}
s32 host_int_get_statistics(struct host_if_drv *hif_drv, struct rf_info *pstrStatistics)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
- memset(&msg, 0, sizeof(struct host_if_msg));
+ memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_STATISTICS;
msg.body.data = (char *)pstrStatistics;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send get host channel param's message queue ");
return -EFAULT;
}
down(&hif_sema_wait_response);
- return s32Error;
+ return result;
}
s32 host_int_scan(struct host_if_drv *hif_drv, u8 u8ScanSource,
size_t IEsLen, wilc_scan_result ScanResult,
void *pvUserArg, struct hidden_network *pstrHiddenNetwork)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
- if (!hif_drv || ScanResult == NULL) {
+ if (!hif_drv || !ScanResult) {
PRINT_ER("hif_drv or ScanResult = NULL\n");
return -EFAULT;
}
msg.id = HOST_IF_MSG_SCAN;
- if (pstrHiddenNetwork != NULL) {
+ if (pstrHiddenNetwork) {
msg.body.scan_info.hidden_network.pstrHiddenNetworkInfo = pstrHiddenNetwork->pstrHiddenNetworkInfo;
msg.body.scan_info.hidden_network.u8ssidnum = pstrHiddenNetwork->u8ssidnum;
msg.body.scan_info.ies = kmalloc(IEsLen, GFP_KERNEL);
memcpy(msg.body.scan_info.ies, pu8IEs, IEsLen);
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Error in sending message queue\n");
return -EINVAL;
}
mod_timer(&hif_drv->hScanTimer,
jiffies + msecs_to_jiffies(HOST_IF_SCAN_TIMEOUT));
- return s32Error;
-
+ return result;
}
s32 hif_set_cfg(struct host_if_drv *hif_drv,
struct cfg_param_val *pstrCfgParamVal)
{
-
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
-
if (!hif_drv) {
PRINT_ER("hif_drv NULL\n");
return -EFAULT;
msg.body.cfg_info.cfg_attr_info = *pstrCfgParamVal;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
-
- return s32Error;
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ return result;
}
s32 hif_get_cfg(struct host_if_drv *hif_drv, u16 u16WID, u16 *pu16WID_Value)
{
- s32 s32Error = 0;
+ s32 result = 0;
down(&hif_drv->gtOsCfgValuesSem);
}
PRINT_D(HOSTINF_DBG, "Getting configuration parameters\n");
switch (u16WID) {
-
case WID_BSS_TYPE:
*pu16WID_Value = (u16)hif_drv->strCfgValues.bss_type;
break;
up(&hif_drv->gtOsCfgValuesSem);
- return s32Error;
-
-}
-
-void host_int_send_join_leave_info_to_host
- (u16 assocId, u8 *stationAddr, bool joining)
-{
+ return result;
}
static void GetPeriodicRSSI(unsigned long arg)
}
if (hif_drv->enuHostIFstate == HOST_IF_CONNECTED) {
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_GET_RSSI;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error) {
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result) {
PRINT_ER("Failed to send get host channel param's message queue ");
return;
}
}
- g_hPeriodicRSSI.data = (unsigned long)hif_drv;
- mod_timer(&g_hPeriodicRSSI, jiffies + msecs_to_jiffies(5000));
+ periodic_rssi.data = (unsigned long)hif_drv;
+ mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
}
-
-void host_int_send_network_info_to_host
- (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi)
-{
-}
-
-static u32 clients_count;
-
-s32 host_int_init(struct host_if_drv **hif_drv_handler)
+s32 host_int_init(struct net_device *dev, struct host_if_drv **hif_drv_handler)
{
s32 result = 0;
struct host_if_drv *hif_drv;
int err;
+ perInterface_wlan_t *nic;
+ struct wilc *wilc;
+
+ nic = netdev_priv(dev);
+ wilc = nic->wilc;
PRINT_D(HOSTINF_DBG, "Initializing host interface for client %d\n", clients_count + 1);
- gbScanWhileConnected = false;
+ scan_while_connected = false;
sema_init(&hif_sema_wait_response, 0);
goto _fail_;
}
- hif_thread_handler = kthread_run(hostIFthread, NULL, "WILC_kthread");
+ hif_thread_handler = kthread_run(hostIFthread, wilc,
+ "WILC_kthread");
if (IS_ERR(hif_thread_handler)) {
PRINT_ER("Failed to creat Thread\n");
result = -EFAULT;
goto _fail_mq_;
}
- setup_timer(&g_hPeriodicRSSI, GetPeriodicRSSI,
+ setup_timer(&periodic_rssi, GetPeriodicRSSI,
(unsigned long)hif_drv);
- mod_timer(&g_hPeriodicRSSI, jiffies + msecs_to_jiffies(5000));
+ mod_timer(&periodic_rssi, jiffies + msecs_to_jiffies(5000));
}
setup_timer(&hif_drv->hScanTimer, TimerCB_Scan, 0);
setup_timer(&hif_drv->hRemainOnChannel, ListenTimerCB, 0);
- sema_init(&(hif_drv->gtOsCfgValuesSem), 1);
+ sema_init(&hif_drv->gtOsCfgValuesSem, 1);
down(&hif_drv->gtOsCfgValuesSem);
hif_drv->enuHostIFstate = HOST_IF_IDLE;
s32 host_int_deinit(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
int ret;
terminated_handle = hif_drv;
PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count);
- if (del_timer_sync(&hif_drv->hScanTimer)) {
+ if (del_timer_sync(&hif_drv->hScanTimer))
PRINT_D(HOSTINF_DBG, ">> Scan timer is active\n");
- }
- if (del_timer_sync(&hif_drv->hConnectTimer)) {
+ if (del_timer_sync(&hif_drv->hConnectTimer))
PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
- }
-
- if (del_timer_sync(&g_hPeriodicRSSI)) {
+ if (del_timer_sync(&periodic_rssi))
PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
- }
del_timer_sync(&hif_drv->hRemainOnChannel);
host_int_set_wfi_drv_handler(NULL);
down(&hif_sema_driver);
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
- hif_drv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
- hif_drv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
+ hif_drv->usr_scan_req.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
+ hif_drv->usr_scan_req.u32UserScanPvoid, NULL);
- hif_drv->strWILC_UsrScanReq.pfUserScanResult = NULL;
+ hif_drv->usr_scan_req.pfUserScanResult = NULL;
}
hif_drv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = false;
+ scan_while_connected = false;
memset(&msg, 0, sizeof(struct host_if_msg));
if (clients_count == 1) {
- if (del_timer_sync(&g_hPeriodicRSSI)) {
+ if (del_timer_sync(&periodic_rssi))
PRINT_D(HOSTINF_DBG, ">> Connect timer is active\n");
- }
+
msg.id = HOST_IF_MSG_EXIT;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error != 0)
- PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error);
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result != 0)
+ PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", result);
down(&hif_sema_thread);
wilc_mq_destroy(&hif_msg_q);
}
- down(&(hif_drv->gtOsCfgValuesSem));
+ down(&hif_drv->gtOsCfgValuesSem);
ret = remove_handler_in_list(hif_drv);
if (ret)
- s32Error = -ENOENT;
+ result = -ENOENT;
kfree(hif_drv);
clients_count--;
terminated_handle = NULL;
up(&hif_sema_deinit);
- return s32Error;
+ return result;
}
void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
int id;
struct host_if_drv *hif_drv = NULL;
id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
hif_drv = get_handler_from_id(id);
-
-
-
if (!hif_drv || hif_drv == terminated_handle) {
PRINT_ER("NetworkInfo received but driver not init[%p]\n", hif_drv);
return;
msg.body.net_info.buffer = kmalloc(u32Length, GFP_KERNEL);
memcpy(msg.body.net_info.buffer, pu8Buffer, u32Length);
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
- PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error);
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
+ PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", result);
}
void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
int id;
struct host_if_drv *hif_drv = NULL;
hif_drv = get_handler_from_id(id);
PRINT_D(HOSTINF_DBG, "General asynchronous info packet received\n");
-
if (!hif_drv || hif_drv == terminated_handle) {
PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n");
up(&hif_sema_deinit);
memset(&msg, 0, sizeof(struct host_if_msg));
-
msg.id = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO;
msg.drv = hif_drv;
msg.body.async_info.buffer = kmalloc(u32Length, GFP_KERNEL);
memcpy(msg.body.async_info.buffer, pu8Buffer, u32Length);
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
- PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error);
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
+ PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", result);
up(&hif_sema_deinit);
}
void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
int id;
struct host_if_drv *hif_drv = NULL;
id = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
hif_drv = get_handler_from_id(id);
-
PRINT_D(GENERIC_DBG, "Scan notification received %p\n", hif_drv);
if (!hif_drv || hif_drv == terminated_handle)
return;
- if (hif_drv->strWILC_UsrScanReq.pfUserScanResult) {
+ if (hif_drv->usr_scan_req.pfUserScanResult) {
memset(&msg, 0, sizeof(struct host_if_msg));
msg.id = HOST_IF_MSG_RCVD_SCAN_COMPLETE;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
- PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error);
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
+ PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", result);
}
-
return;
-
}
s32 host_int_remain_on_channel(struct host_if_drv *hif_drv, u32 u32SessionID,
wilc_remain_on_chan_ready RemainOnChanReady,
void *pvUserArg)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.body.remain_on_ch.u32ListenSessionID = u32SessionID;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc mq send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_ListenStateExpired(struct host_if_drv *hif_drv, u32 u32SessionID)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.drv = hif_drv;
msg.body.remain_on_ch.u32ListenSessionID = u32SessionID;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc mq send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_frame_register(struct host_if_drv *hif_drv, u16 u16FrameType, bool bReg)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.body.reg_frame.bReg = bReg;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc mq send fail\n");
- return s32Error;
-
-
+ return result;
}
s32 host_int_add_beacon(struct host_if_drv *hif_drv, u32 u32Interval,
u32 u32DTIMPeriod, u32 u32HeadLen, u8 *pu8Head,
u32 u32TailLen, u8 *pu8Tail)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct beacon_attr *pstrSetBeaconParam = &msg.body.beacon_info;
pstrSetBeaconParam->interval = u32Interval;
pstrSetBeaconParam->dtim_period = u32DTIMPeriod;
pstrSetBeaconParam->head_len = u32HeadLen;
- pstrSetBeaconParam->head = kmalloc(u32HeadLen, GFP_KERNEL);
- if (pstrSetBeaconParam->head == NULL) {
- s32Error = -ENOMEM;
+ pstrSetBeaconParam->head = kmemdup(pu8Head, u32HeadLen, GFP_KERNEL);
+ if (!pstrSetBeaconParam->head) {
+ result = -ENOMEM;
goto ERRORHANDLER;
}
- memcpy(pstrSetBeaconParam->head, pu8Head, u32HeadLen);
pstrSetBeaconParam->tail_len = u32TailLen;
if (u32TailLen > 0) {
- pstrSetBeaconParam->tail = kmalloc(u32TailLen, GFP_KERNEL);
- if (pstrSetBeaconParam->tail == NULL) {
- s32Error = -ENOMEM;
+ pstrSetBeaconParam->tail = kmemdup(pu8Tail, u32TailLen,
+ GFP_KERNEL);
+ if (!pstrSetBeaconParam->tail) {
+ result = -ENOMEM;
goto ERRORHANDLER;
}
- memcpy(pstrSetBeaconParam->tail, pu8Tail, u32TailLen);
} else {
pstrSetBeaconParam->tail = NULL;
}
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc mq send fail\n");
ERRORHANDLER:
- if (s32Error) {
+ if (result) {
kfree(pstrSetBeaconParam->head);
kfree(pstrSetBeaconParam->tail);
}
- return s32Error;
-
+ return result;
}
s32 host_int_del_beacon(struct host_if_drv *hif_drv)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.drv = hif_drv;
PRINT_D(HOSTINF_DBG, "Setting deleting beacon message queue params\n");
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_add_station(struct host_if_drv *hif_drv,
struct add_sta_param *pstrStaParams)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct add_sta_param *pstrAddStationMsg = &msg.body.add_sta_info;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
pstrAddStationMsg->pu8Rates = rates;
}
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_del_station(struct host_if_drv *hif_drv, const u8 *pu8MacAddr)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct del_sta *pstrDelStationMsg = &msg.body.del_sta_info;
msg.id = HOST_IF_MSG_DEL_STATION;
msg.drv = hif_drv;
- if (pu8MacAddr == NULL)
+ if (!pu8MacAddr)
memset(pstrDelStationMsg->mac_addr, 255, ETH_ALEN);
else
memcpy(pstrDelStationMsg->mac_addr, pu8MacAddr, ETH_ALEN);
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_del_allstation(struct host_if_drv *hif_drv,
u8 pu8MacAddr[][ETH_ALEN])
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct del_all_sta *pstrDelAllStationMsg = &msg.body.del_all_sta_info;
u8 au8Zero_Buff[ETH_ALEN] = {0};
u32 i;
u8 u8AssocNumb = 0;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
}
if (!u8AssocNumb) {
PRINT_D(CFG80211_DBG, "NO ASSOCIATED STAS\n");
- return s32Error;
+ return result;
}
pstrDelAllStationMsg->assoc_sta = u8AssocNumb;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
down(&hif_sema_wait_response);
- return s32Error;
-
+ return result;
}
s32 host_int_edit_station(struct host_if_drv *hif_drv,
struct add_sta_param *pstrStaParams)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct add_sta_param *pstrAddStationMsg = &msg.body.add_sta_info;
pstrAddStationMsg->pu8Rates = rates;
}
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_set_power_mgmt(struct host_if_drv *hif_drv,
bool bIsEnabled,
u32 u32Timeout)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct power_mgmt_param *pstrPowerMgmtParam = &msg.body.pwr_mgmt_info;
pstrPowerMgmtParam->enabled = bIsEnabled;
pstrPowerMgmtParam->timeout = u32Timeout;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
s32 host_int_setup_multicast_filter(struct host_if_drv *hif_drv,
bool bIsEnabled,
u32 u32count)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct set_multicast *pstrMulticastFilterParam = &msg.body.multicast_info;
-
if (!hif_drv) {
PRINT_ER("driver is null\n");
return -EFAULT;
pstrMulticastFilterParam->enabled = bIsEnabled;
pstrMulticastFilterParam->cnt = u32count;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
+ return result;
}
static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo)
u16IEsLen = ptstrNetworkInfo->u16IEsLen;
pNewJoinBssParam = kzalloc(sizeof(struct join_bss_param), GFP_KERNEL);
- if (pNewJoinBssParam != NULL) {
+ if (pNewJoinBssParam) {
pNewJoinBssParam->dtim_period = ptstrNetworkInfo->u8DtimPeriod;
pNewJoinBssParam->beacon_period = ptstrNetworkInfo->u16BeaconPeriod;
pNewJoinBssParam->cap_info = ptstrNetworkInfo->u16CapInfo;
pNewJoinBssParam->supp_rates[0] = suppRatesNo;
index += 2;
- for (i = 0; i < suppRatesNo; i++) {
+ for (i = 0; i < suppRatesNo; i++)
pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i];
- }
+
index += suppRatesNo;
continue;
} else if (pu8IEs[index] == EXT_SUPP_RATES_IE) {
else
pNewJoinBssParam->supp_rates[0] += extSuppRatesNo;
index += 2;
- for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++) {
+ for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++)
pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i];
- }
+
index += extSuppRatesNo;
continue;
} else if (pu8IEs[index] == HT_CAPABILITY_IE) {
memcpy(pNewJoinBssParam->interval, pu8IEs + u16P2P_count, 4);
u16P2P_count += 4;
- memcpy(pNewJoinBssParam->au8StartTime, pu8IEs + u16P2P_count, 4);
+ memcpy(pNewJoinBssParam->start_time, pu8IEs + u16P2P_count, 4);
index += pu8IEs[index + 1] + 2;
continue;
pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
rsnIndex += 2;
- for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++) {
+ for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++)
pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
- }
+
pcipherTotalCount += pcipherCount;
rsnIndex += jumpOffset;
authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex];
rsnIndex += 2;
- for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++) {
+ for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++)
pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1];
- }
+
authTotalCount += authCount;
rsnIndex += jumpOffset;
continue;
} else
index += pu8IEs[index + 1] + 2;
-
}
-
-
}
return (void *)pNewJoinBssParam;
-
}
void host_int_freeJoinParams(void *pJoinParams)
{
- if ((struct bss_param *)pJoinParams != NULL)
+ if ((struct bss_param *)pJoinParams)
kfree((struct bss_param *)pJoinParams);
else
PRINT_ER("Unable to FREE null pointer\n");
s32 host_int_delBASession(struct host_if_drv *hif_drv, char *pBSSID, char TID)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct ba_session_info *pBASessionInfo = &msg.body.session_info;
pBASessionInfo->u8Ted = TID;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
down(&hif_sema_wait_response);
- return s32Error;
+ return result;
}
s32 host_int_del_All_Rx_BASession(struct host_if_drv *hif_drv,
char *pBSSID,
char TID)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
struct ba_session_info *pBASessionInfo = &msg.body.session_info;
pBASessionInfo->u8Ted = TID;
msg.drv = hif_drv;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
down(&hif_sema_wait_response);
- return s32Error;
+ return result;
}
s32 host_int_setup_ipaddress(struct host_if_drv *hif_drv, u8 *u16ipadd, u8 idx)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
return 0;
msg.drv = hif_drv;
msg.body.ip_info.idx = idx;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
-
-
+ return result;
}
s32 host_int_get_ipaddress(struct host_if_drv *hif_drv, u8 *u16ipadd, u8 idx)
{
- s32 s32Error = 0;
+ s32 result = 0;
struct host_if_msg msg;
if (!hif_drv) {
msg.drv = hif_drv;
msg.body.ip_info.idx = idx;
- s32Error = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
- if (s32Error)
+ result = wilc_mq_send(&hif_msg_q, &msg, sizeof(struct host_if_msg));
+ if (result)
PRINT_ER("wilc_mq_send fail\n");
- return s32Error;
-
-
+ return result;
}
projects / firefly-linux-kernel-4.4.55.git / blobdiff