extern WILC_Sint32 TransportInit(void);
extern WILC_Sint32 TransportDeInit(void);
-extern WILC_Uint8 connecting;
+extern u8 connecting;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
extern WILC_TimerHandle hDuringIpTimer;
extern WILC_Bool bEnablePS;
/*BugID_5137*/
-extern WILC_Uint8 g_wilc_initialized;
+extern u8 g_wilc_initialized;
/*****************************************************************************/
/* Macros */
/*****************************************************************************/
* @version 1.0
*/
typedef struct _tstrHostIFwpaAttr {
- WILC_Uint8 *pu8key;
- const WILC_Uint8 *pu8macaddr;
- WILC_Uint8 *pu8seq;
- WILC_Uint8 u8seqlen;
- WILC_Uint8 u8keyidx;
- WILC_Uint8 u8Keylen;
- WILC_Uint8 u8Ciphermode;
+ u8 *pu8key;
+ const u8 *pu8macaddr;
+ u8 *pu8seq;
+ u8 u8seqlen;
+ u8 u8keyidx;
+ u8 u8Keylen;
+ u8 u8Ciphermode;
} tstrHostIFwpaAttr;
* @version 1.0
*/
typedef struct _tstrHostIFwepAttr {
- WILC_Uint8 *pu8WepKey;
- WILC_Uint8 u8WepKeylen;
- WILC_Uint8 u8Wepidx;
- WILC_Uint8 u8mode;
+ u8 *pu8WepKey;
+ u8 u8WepKeylen;
+ u8 u8Wepidx;
+ u8 u8mode;
AUTHTYPE_T tenuAuth_type;
} tstrHostIFwepAttr;
*/
typedef struct _tstrHostIFkeyAttr {
tenuKeyType enuKeyType;
- WILC_Uint8 u8KeyAction;
+ u8 u8KeyAction;
tuniHostIFkeyAttr uniHostIFkeyAttr;
} tstrHostIFkeyAttr;
* @version 1.0
*/
typedef struct _tstrHostIFscanAttr {
- WILC_Uint8 u8ScanSource;
- WILC_Uint8 u8ScanType;
- WILC_Uint8 *pu8ChnlFreqList;
- WILC_Uint8 u8ChnlListLen;
- WILC_Uint8 *pu8IEs;
+ u8 u8ScanSource;
+ u8 u8ScanType;
+ u8 *pu8ChnlFreqList;
+ u8 u8ChnlListLen;
+ u8 *pu8IEs;
size_t IEsLen;
tWILCpfScanResult pfScanResult;
void *pvUserArg;
* @version 1.0
*/
typedef struct _tstrHostIFconnectAttr {
- WILC_Uint8 *pu8bssid;
- WILC_Uint8 *pu8ssid;
+ u8 *pu8bssid;
+ u8 *pu8ssid;
size_t ssidLen;
- WILC_Uint8 *pu8IEs;
+ u8 *pu8IEs;
size_t IEsLen;
- WILC_Uint8 u8security;
+ u8 u8security;
tWILCpfConnectResult pfConnectResult;
void *pvUserArg;
AUTHTYPE_T tenuAuth_type;
- WILC_Uint8 u8channel;
+ u8 u8channel;
void *pJoinParams;
} tstrHostIFconnectAttr;
* @version 1.0
*/
typedef struct _tstrRcvdGnrlAsyncInfo {
- WILC_Uint8 *pu8Buffer;
+ u8 *pu8Buffer;
WILC_Uint32 u32Length;
} tstrRcvdGnrlAsyncInfo;
* @version 1.0
*/
typedef struct _tstrHostIFSetChan {
- WILC_Uint8 u8SetChan;
+ u8 u8SetChan;
} tstrHostIFSetChan;
/*!
* @version 1.0
*/
typedef struct _tstrHostIFGetChan {
- WILC_Uint8 u8GetChan;
+ u8 u8GetChan;
} tstrHostIFGetChan;
/*bug3819: Add Scan acomplete notification to host*/
*/
/*typedef struct _tstrScanComplete
* {
- * WILC_Uint8* pu8Buffer;
+ * u8* pu8Buffer;
* WILC_Uint32 u32Length;
* } tstrScanComplete;*/
WILC_Uint32 u32DTIMPeriod; /*!< DTIM Period. Indicates how many Beacon frames
* (including the current frame) appear before the next DTIM */
WILC_Uint32 u32HeadLen; /*!< Length of the head buffer in bytes */
- WILC_Uint8 *pu8Head; /*!< Pointer to the beacon's head buffer. Beacon's head is the part
+ u8 *pu8Head; /*!< Pointer to the beacon's head buffer. Beacon's head is the part
* from the beacon's start till the TIM element, NOT including the TIM */
WILC_Uint32 u32TailLen; /*!< Length of the tail buffer in bytes */
- WILC_Uint8 *pu8Tail; /*!< Pointer to the beacon's tail buffer. Beacon's tail starts just
+ u8 *pu8Tail; /*!< Pointer to the beacon's tail buffer. Beacon's tail starts just
* after the TIM inormation element */
} tstrHostIFSetBeacon;
* @version 1.0
*/
typedef struct _tstrHostIFDelBeacon {
- WILC_Uint8 u8dummy;
+ u8 u8dummy;
} tstrHostIFDelBeacon;
/*!
*/
typedef struct {
- WILC_Uint8 au8Sta_DelAllSta[MAX_NUM_STA][ETH_ALEN];
- WILC_Uint8 u8Num_AssocSta;
+ u8 au8Sta_DelAllSta[MAX_NUM_STA][ETH_ALEN];
+ u8 u8Num_AssocSta;
} tstrHostIFDelAllSta;
/*!
*/
typedef struct {
- WILC_Uint8 au8MacAddr[ETH_ALEN];
+ u8 au8MacAddr[ETH_ALEN];
} tstrHostIFDelSta;
/*!
*/
typedef struct {
- WILC_Uint8 *au8IPAddr;
- WILC_Uint8 idx;
+ u8 *au8IPAddr;
+ u8 idx;
} tstrHostIFSetIPAddr;
/*!
* @version 1.0
*/
typedef struct {
- WILC_Uint8 mac[6];
+ u8 mac[6];
} tstrHostIfStaInactiveT;
/**/
#ifdef CONNECT_DIRECT
typedef struct _tstrWidJoinReqExt {
WILC_Char SSID[MAX_SSID_LEN];
- WILC_Uint8 u8channel;
- WILC_Uint8 BSSID[6];
+ u8 u8channel;
+ u8 BSSID[6];
} tstrWidJoinReqExt;
#endif
/*Struct containg joinParam of each AP*/
typedef struct _tstrJoinBssParam {
BSSTYPE_T bss_type;
- WILC_Uint8 dtim_period;
+ u8 dtim_period;
WILC_Uint16 beacon_period;
WILC_Uint16 cap_info;
- WILC_Uint8 au8bssid[6];
+ u8 au8bssid[6];
WILC_Char ssid[MAX_SSID_LEN];
- WILC_Uint8 ssidLen;
- WILC_Uint8 supp_rates[MAX_RATES_SUPPORTED + 1];
- WILC_Uint8 ht_capable;
- WILC_Uint8 wmm_cap;
- WILC_Uint8 uapsd_cap;
+ u8 ssidLen;
+ u8 supp_rates[MAX_RATES_SUPPORTED + 1];
+ u8 ht_capable;
+ u8 wmm_cap;
+ u8 uapsd_cap;
WILC_Bool rsn_found;
- WILC_Uint8 rsn_grp_policy;
- WILC_Uint8 mode_802_11i;
- WILC_Uint8 rsn_pcip_policy[3];
- WILC_Uint8 rsn_auth_policy[3];
- WILC_Uint8 rsn_cap[2];
+ u8 rsn_grp_policy;
+ u8 mode_802_11i;
+ u8 rsn_pcip_policy[3];
+ u8 rsn_auth_policy[3];
+ u8 rsn_cap[2];
struct _tstrJoinParam *nextJoinBss;
#ifdef WILC_P2P
WILC_Uint32 tsf;
- WILC_Uint8 u8NoaEnbaled;
- WILC_Uint8 u8OppEnable;
- WILC_Uint8 u8CtWindow;
- WILC_Uint8 u8Count;
- WILC_Uint8 u8Index;
- WILC_Uint8 au8Duration[4];
- WILC_Uint8 au8Interval[4];
- WILC_Uint8 au8StartTime[4];
+ u8 u8NoaEnbaled;
+ u8 u8OppEnable;
+ u8 u8CtWindow;
+ u8 u8Count;
+ u8 u8Index;
+ u8 au8Duration[4];
+ u8 au8Interval[4];
+ u8 au8StartTime[4];
#endif
} tstrJoinBssParam;
/*Bug4218: Parsing Join Param*/
/*a linked list table containing needed join parameters entries for each AP found in most recent scan*/
typedef struct _tstrBssTable {
- WILC_Uint8 u8noBssEntries;
+ u8 u8noBssEntries;
tstrJoinBssParam *head;
tstrJoinBssParam *tail;
} tstrBssTable;
/*****************************************************************************/
-tstrWILC_WFIDrv *terminated_handle = WILC_NULL;
-tstrWILC_WFIDrv *gWFiDrvHandle = WILC_NULL;
+tstrWILC_WFIDrv *terminated_handle = NULL;
+tstrWILC_WFIDrv *gWFiDrvHandle = NULL;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
WILC_Bool g_obtainingIP = WILC_FALSE;
#endif
-WILC_Uint8 P2P_LISTEN_STATE;
-static WILC_ThreadHandle HostIFthreadHandler;
+u8 P2P_LISTEN_STATE;
+static struct task_struct *HostIFthreadHandler;
static WILC_MsgQueueHandle gMsgQHostIF;
-static WILC_SemaphoreHandle hSemHostIFthrdEnd;
+static struct semaphore hSemHostIFthrdEnd;
-WILC_SemaphoreHandle hSemDeinitDrvHandle;
-static WILC_SemaphoreHandle hWaitResponse;
-WILC_SemaphoreHandle hSemHostIntDeinit;
+struct semaphore hSemDeinitDrvHandle;
+static struct semaphore hWaitResponse;
+struct semaphore hSemHostIntDeinit;
WILC_TimerHandle g_hPeriodicRSSI;
-WILC_Uint8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
+u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
#ifndef CONNECT_DIRECT
-static WILC_Uint8 gapu8RcvdSurveyResults[2][MAX_SURVEY_RESULT_FRAG_SIZE];
+static u8 gapu8RcvdSurveyResults[2][MAX_SURVEY_RESULT_FRAG_SIZE];
#endif
-static WILC_Uint8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
+static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
WILC_Bool gbScanWhileConnected = WILC_FALSE;
static WILC_Sint8 gs8Rssi;
static WILC_Sint8 gs8lnkspd;
-static WILC_Uint8 gu8Chnl;
-static WILC_Uint8 gs8SetIP[2][4];
-static WILC_Uint8 gs8GetIP[2][4];
+static u8 gu8Chnl;
+static u8 gs8SetIP[2][4];
+static u8 gs8GetIP[2][4];
#ifdef WILC_AP_EXTERNAL_MLME
static WILC_Uint32 gu32InactiveTime;
-static WILC_Uint8 gu8DelBcn;
+static u8 gu8DelBcn;
#endif
#ifndef SIMULATION
static WILC_Uint32 gu32WidConnRstHack;
#endif
/*BugID_5137*/
-WILC_Uint8 *gu8FlushedJoinReq;
-WILC_Uint8 *gu8FlushedInfoElemAsoc;
-WILC_Uint8 gu8Flushed11iMode;
-WILC_Uint8 gu8FlushedAuthType;
+u8 *gu8FlushedJoinReq;
+u8 *gu8FlushedInfoElemAsoc;
+u8 gu8Flushed11iMode;
+u8 gu8FlushedAuthType;
WILC_Uint32 gu32FlushedJoinReqSize;
WILC_Uint32 gu32FlushedInfoElemAsocSize;
WILC_Uint32 gu8FlushedJoinReqDrvHandler;
if ((pstrHostIfSetDrvHandler->u32Address) == (WILC_Uint32)NULL) {
- WILC_SemaphoreRelease(&hSemDeinitDrvHandle, WILC_NULL);
+ up(&hSemDeinitDrvHandle);
}
if ((pstrHostIfSetOperationMode->u32Mode) == (WILC_Uint32)NULL) {
- WILC_SemaphoreRelease(&hSemDeinitDrvHandle, WILC_NULL);
+ up(&hSemDeinitDrvHandle);
}
/**
* @brief host_int_set_IPAddress
* @details Setting IP address params in message queue
- * @param[in] WILC_WFIDrvHandle hWFIDrv, WILC_Uint8* pu8IPAddr
+ * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
* @return Error code.
* @author
* @date
* @version 1.0
*/
-WILC_Sint32 Handle_set_IPAddress(void *drvHandler, WILC_Uint8 *pu8IPAddr, WILC_Uint8 idx)
+WILC_Sint32 Handle_set_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
/*prepare configuration packet*/
strWID.u16WIDid = (WILC_Uint16)WID_IP_ADDRESS;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Uint8 *)pu8IPAddr;
+ strWID.ps8WidVal = (u8 *)pu8IPAddr;
strWID.s32ValueSize = IP_ALEN;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (WILC_Uint32)pstrWFIDrv);
/**
* @brief Handle_get_IPAddress
* @details Setting IP address params in message queue
- * @param[in] WILC_WFIDrvHandle hWFIDrv, WILC_Uint8* pu8IPAddr
+ * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr
* @return Error code.
* @author
* @date
* @version 1.0
*/
-WILC_Sint32 Handle_get_IPAddress(void *drvHandler, WILC_Uint8 *pu8IPAddr, WILC_Uint8 idx)
+WILC_Sint32 Handle_get_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
/*prepare configuration packet*/
strWID.u16WIDid = (WILC_Uint16)WID_IP_ADDRESS;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Uint8 *)WILC_MALLOC(IP_ALEN);
+ strWID.ps8WidVal = (u8 *)WILC_MALLOC(IP_ALEN);
strWID.s32ValueSize = IP_ALEN;
s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (WILC_Uint32)pstrWFIDrv);
- PRINT_INFO(HOSTINF_DBG, "%d.%d.%d.%d\n", (WILC_Uint8)(strWID.ps8WidVal[0]), (WILC_Uint8)(strWID.ps8WidVal[1]), (WILC_Uint8)(strWID.ps8WidVal[2]), (WILC_Uint8)(strWID.ps8WidVal[3]));
+ PRINT_INFO(HOSTINF_DBG, "%d.%d.%d.%d\n", (u8)(strWID.ps8WidVal[0]), (u8)(strWID.ps8WidVal[1]), (u8)(strWID.ps8WidVal[2]), (u8)(strWID.ps8WidVal[3]));
WILC_memcpy(gs8GetIP[idx], strWID.ps8WidVal, IP_ALEN);
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- WILC_Uint8 *mac_buf = (WILC_Uint8 *)WILC_MALLOC(ETH_ALEN);
+ u8 *mac_buf = (u8 *)WILC_MALLOC(ETH_ALEN);
if (mac_buf == NULL) {
PRINT_ER("No buffer to send mac address\n");
return WILC_FAIL;
{
}
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
return s32Error;
}
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWIDList[32];
- WILC_Uint8 u8WidCnt = 0;
+ u8 u8WidCnt = 0;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- WILC_SemaphoreAcquire(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ down(&(pstrWFIDrv->gtOsCfgValuesSem));
PRINT_D(HOSTINF_DBG, "Setting CFG params\n");
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.bss_type = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
+ pstrWFIDrv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.auth_type = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
+ pstrWFIDrv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.power_mgmt_mode = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
+ pstrWFIDrv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.short_slot_allowed = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
+ pstrWFIDrv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.txop_prot_disabled = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
+ pstrWFIDrv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
- pstrWFIDrv->strCfgValues.site_survey_enabled = (WILC_Uint8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
+ pstrWFIDrv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&curr_tx_rate;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Uint16);
- pstrWFIDrv->strCfgValues.curr_tx_rate = (WILC_Uint8)curr_tx_rate;
+ pstrWFIDrv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
} else {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
WILC_CATCH(s32Error)
{
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ up(&(pstrWFIDrv->gtOsCfgValuesSem));
return s32Error;
}
{
WILC_Sint32 s32Error = WILC_SUCCESS;
g_wilc_initialized = 0;
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
return s32Error;
}
tstrWID strWIDList[5];
WILC_Uint32 u32WidsCount = 0;
WILC_Uint32 i;
- WILC_Uint8 *pu8Buffer;
- WILC_Uint8 valuesize = 0;
- WILC_Uint8 *pu8HdnNtwrksWidVal = NULL;
+ u8 *pu8Buffer;
+ u8 valuesize = 0;
+ u8 *pu8HdnNtwrksWidVal = NULL;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
PRINT_D(HOSTINF_DBG, "Setting SCAN params\n");
}
pu8HdnNtwrksWidVal = WILC_MALLOC(valuesize + 1);
strWIDList[u32WidsCount].ps8WidVal = pu8HdnNtwrksWidVal;
- if (strWIDList[u32WidsCount].ps8WidVal != WILC_NULL) {
+ if (strWIDList[u32WidsCount].ps8WidVal != NULL) {
pu8Buffer = strWIDList[u32WidsCount].ps8WidVal;
*pu8Buffer++ = pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum;
WILC_CATCH(s32Error)
{
- WILC_TimerStop(&(pstrWFIDrv->hScanTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
/*if there is an ongoing scan request*/
Handle_ScanDone(drvHandler, SCAN_EVENT_ABORTED);
}
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- WILC_Uint8 u8abort_running_scan;
+ u8 u8abort_running_scan;
tstrWID strWID;
/*if there is an ongoing scan request*/
if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
- pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, WILC_NULL,
+ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL,
pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
/*delete current scan request*/
pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
* @date
* @version 1.0
*/
-WILC_Uint8 u8ConnectedSSID[6] = {0};
+u8 u8ConnectedSSID[6] = {0};
static WILC_Sint32 Handle_Connect(void *drvHandler, tstrHostIFconnectAttr *pstrHostIFconnectAttr)
{
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
#ifndef CONNECT_DIRECT
WILC_Sint32 s32Err = WILC_SUCCESS;
WILC_Uint32 i;
- WILC_Uint8 u8bssDscListIndex;
- wid_site_survey_reslts_s *pstrSurveyResults = WILC_NULL;
+ u8 u8bssDscListIndex;
+ wid_site_survey_reslts_s *pstrSurveyResults = NULL;
#else
- WILC_Uint8 *pu8CurrByte = WILC_NULL;
+ u8 *pu8CurrByte = NULL;
/*Bug4218: Parsing Join Param*/
#ifdef WILC_PARSE_SCAN_IN_HOST
tstrJoinBssParam *ptstrJoinBssParam;
PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n");
if (pstrHostIFconnectAttr->pu8bssid != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (WILC_Uint8 *)WILC_MALLOC(6);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6);
}
pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen;
if (pstrHostIFconnectAttr->pu8ssid != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid,
pstrHostIFconnectAttr->ssidLen);
pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0';
pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen;
if (pstrHostIFconnectAttr->pu8IEs != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs,
pstrHostIFconnectAttr->IEsLen);
}
#endif
if (pstrHostIFconnectAttr->pu8bssid != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (WILC_Uint8 *)WILC_MALLOC(6);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6);
}
pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen;
if (pstrHostIFconnectAttr->pu8ssid != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid,
pstrHostIFconnectAttr->ssidLen);
pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0';
pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen;
if (pstrHostIFconnectAttr->pu8IEs != NULL) {
- pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
+ pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs,
pstrHostIFconnectAttr->IEsLen);
}
/*BugID_5137*/
if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7))
- gu8FlushedAuthType = (WILC_Uint8)pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type;
+ gu8FlushedAuthType = (u8)pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type;
PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
/*
strWIDList[u32WidsCount].s32ValueSize = MAX_SSID_LEN + 7;
strWIDList[u32WidsCount].ps8WidVal = WILC_MALLOC(strWIDList[u32WidsCount].s32ValueSize);
- if (strWIDList[u32WidsCount].ps8WidVal == WILC_NULL) {
+ if (strWIDList[u32WidsCount].ps8WidVal == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
gu32FlushedJoinReqSize = strWIDList[u32WidsCount].s32ValueSize;
gu8FlushedJoinReq = WILC_MALLOC(gu32FlushedJoinReqSize);
}
- if (strWIDList[u32WidsCount].ps8WidVal == WILC_NULL) {
+ if (strWIDList[u32WidsCount].ps8WidVal == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
{
tstrConnectInfo strConnectInfo;
- WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
PRINT_D(HOSTINF_DBG, "could not start connecting to the required network\n");
if (pstrHostIFconnectAttr->pu8IEs != NULL) {
strConnectInfo.ReqIEsLen = pstrHostIFconnectAttr->IEsLen;
- strConnectInfo.pu8ReqIEs = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
+ strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen);
WILC_memcpy(strConnectInfo.pu8ReqIEs,
pstrHostIFconnectAttr->pu8IEs,
pstrHostIFconnectAttr->IEsLen);
pstrHostIFconnectAttr->pu8IEs = NULL;
}
- if (pu8CurrByte != WILC_NULL) {
+ if (pu8CurrByte != NULL) {
WILC_FREE(pu8CurrByte);
}
return s32Error;
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWIDList[5];
WILC_Uint32 u32WidsCount = 0;
- WILC_Uint8 *pu8CurrByte = WILC_NULL;
+ u8 *pu8CurrByte = NULL;
/* IEs to be inserted in Association Request */
if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
- strConnectInfo.pu8ReqIEs = (WILC_Uint8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
+ strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
WILC_memcpy(strConnectInfo.pu8ReqIEs,
pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs,
pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n");
ParseNetworkInfo(pstrRcvdNetworkInfo->pu8Buffer, &pstrNetworkInfo);
if ((pstrNetworkInfo == NULL)
- || (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult == WILC_NULL)) {
+ || (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult == NULL)) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
}
/*free structure allocated*/
- if (pstrNetworkInfo != WILC_NULL) {
+ if (pstrNetworkInfo != NULL) {
DeallocateNetworkInfo(pstrNetworkInfo);
- pstrNetworkInfo = WILC_NULL;
+ pstrNetworkInfo = NULL;
}
return s32Error;
/* TODO: mostafa: till now, this function just handles only the received mac status msg, */
/* which carries only 1 WID which have WID ID = WID_STATUS */
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 u8MsgType = 0;
- WILC_Uint8 u8MsgID = 0;
+ u8 u8MsgType = 0;
+ u8 u8MsgID = 0;
WILC_Uint16 u16MsgLen = 0;
WILC_Uint16 u16WidID = (WILC_Uint16)WID_NIL;
- WILC_Uint8 u8WidLen = 0;
- WILC_Uint8 u8MacStatus;
- WILC_Uint8 u8MacStatusReasonCode;
- WILC_Uint8 u8MacStatusAdditionalInfo;
+ u8 u8WidLen = 0;
+ u8 u8MacStatus;
+ u8 u8MacStatusReasonCode;
+ u8 u8MacStatusAdditionalInfo;
tstrConnectInfo strConnectInfo;
tstrDisconnectNotifInfo strDisconnectNotifInfo;
WILC_Sint32 s32Err = WILC_SUCCESS;
(pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) ||
pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
if ((pstrRcvdGnrlAsyncInfo->pu8Buffer == NULL) ||
- (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == WILC_NULL)) {
+ (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL)) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen;
- strConnectInfo.pu8RespIEs = (WILC_Uint8 *)WILC_MALLOC(pstrConnectRespInfo->u16RespIEsLen);
+ strConnectInfo.pu8RespIEs = (u8 *)WILC_MALLOC(pstrConnectRespInfo->u16RespIEsLen);
WILC_memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs,
pstrConnectRespInfo->u16RespIEsLen);
}
if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) {
strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen;
- strConnectInfo.pu8ReqIEs = (WILC_Uint8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
+ strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
WILC_memcpy(strConnectInfo.pu8ReqIEs,
pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs,
pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen);
}
- WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP,
&strConnectInfo,
u8MacStatus,
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
PRINT_D(GENERIC_DBG, "Obtaining an IP, Disable Scan\n");
g_obtainingIP = WILC_TRUE;
- WILC_TimerStart(&hDuringIpTimer, 10000, WILC_NULL, WILC_NULL);
+ WILC_TimerStart(&hDuringIpTimer, 10000, NULL, NULL);
#endif
#ifdef WILC_PARSE_SCAN_IN_HOST
if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >> \n\n");
- WILC_TimerStop(&(pstrWFIDrv->hScanTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED);
}
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");
/*Abort the running scan*/
- WILC_TimerStop(&(pstrWFIDrv->hScanTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED);
#ifdef WILC_AP_EXTERNAL_MLME
tstrWID strWIDList[5];
#endif
- WILC_Uint8 i;
- WILC_Uint8 *pu8keybuf;
+ u8 i;
+ u8 *pu8keybuf;
WILC_Sint8 s8idxarray[1];
WILC_Sint8 ret = 0;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWIDList[2].s32ValueSize = sizeof(WILC_Char);
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen);
+ pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen);
if (pu8keybuf == NULL) {
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
PRINT_D(HOSTINF_DBG, "Handling WEP key\n");
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2);
+ pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send Key\n");
return -1;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (WILC_Uint32)pstrWFIDrv);
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestKeyBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestKeyBlock));
break;
case WPARxGtk:
#ifdef WILC_AP_EXTERNAL_MLME
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
+ pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send RxGTK Key\n");
ret = -1;
WILC_FREE(pu8keybuf);
/* ////////////////////////// */
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestKeyBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestKeyBlock));
/* ///////////////////////// */
}
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
PRINT_D(HOSTINF_DBG, "Handling group key(Rx) function\n");
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
+ pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send RxGTK Key\n");
ret = -1;
WILC_FREE(pu8keybuf);
/* ////////////////////////// */
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestKeyBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestKeyBlock));
/* ///////////////////////// */
}
_WPARxGtk_end_case_:
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1);
+ pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1);
WILC_FREE(pu8keybuf);
/* ////////////////////////// */
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestKeyBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestKeyBlock));
/* ///////////////////////// */
}
#endif
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(PTK_KEY_MSG_LEN);
+ pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN);
WILC_FREE(pu8keybuf);
/* ////////////////////////// */
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestKeyBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestKeyBlock));
/* ///////////////////////// */
}
PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n");
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC((pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1);
+ pu8keybuf = (u8 *)WILC_MALLOC((pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1);
if (pu8keybuf == NULL) {
PRINT_ER("No buffer to send PMKSA Key\n");
return -1;
strDisconnectNotifInfo.ie_len = 0;
if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
- WILC_TimerStop(&(pstrWFIDrv->hScanTimer), WILC_NULL);
- pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, WILC_NULL,
+ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
+ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
- pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = WILC_NULL;
+ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
}
if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
/*Stop connect timer, if connection in progress*/
if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) {
PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n");
- WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL);
}
pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL,
}
/* ////////////////////////// */
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemTestDisconnectBlock), WILC_NULL);
+ up(&(pstrWFIDrv->hSemTestDisconnectBlock));
/* ///////////////////////// */
}
tstrWILC_WFIDrv *pstrWFIDrv;
pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- if (pstrWFIDrv == WILC_NULL)
+ if (pstrWFIDrv == NULL)
return;
if ((pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) || (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTING)) {
PRINT_D(HOSTINF_DBG, "\n\n<< correcting Supplicant state machine >>\n\n");
{
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemGetCHNL), WILC_NULL);
+ up(&(pstrWFIDrv->hSemGetCHNL));
return s32Error;
{
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemGetRSSI), WILC_NULL);
+ up(&(pstrWFIDrv->hSemGetRSSI));
}
{
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemGetLINKSPEED), WILC_NULL);
+ up(&(pstrWFIDrv->hSemGetLINKSPEED));
}
PRINT_ER("Failed to send scan paramters config packet\n");
/* WILC_ERRORREPORT(s32Error, s32Error); */
}
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
return 0;
}
{
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 *stamac;
+ u8 *stamac;
tstrWID strWID;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (WILC_Uint16)WID_SET_STA_MAC_INACTIVE_TIME;
strWID.enuWIDtype = WID_STR;
strWID.s32ValueSize = ETH_ALEN;
- strWID.ps8WidVal = (WILC_Uint8 *)WILC_MALLOC(strWID.s32ValueSize);
+ strWID.ps8WidVal = (u8 *)WILC_MALLOC(strWID.s32ValueSize);
stamac = strWID.ps8WidVal;
PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", gu32InactiveTime);
- WILC_SemaphoreRelease(&(pstrWFIDrv->hSemInactiveTime), WILC_NULL);
+ up(&(pstrWFIDrv->hSemInactiveTime));
WILC_CATCH(s32Error)
{
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
PRINT_D(HOSTINF_DBG, "Adding BEACON\n");
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (WILC_Uint16)WID_DEL_BEACON;
strWID.enuWIDtype = WID_CHAR;
/**
* @brief WILC_HostIf_PackStaParam
* @details Handling packing of the station params in a buffer
- * @param[in] WILC_Uint8* pu8Buffer, tstrWILC_AddStaParam* pstrStationParam
+ * @param[in] u8* pu8Buffer, tstrWILC_AddStaParam* pstrStationParam
* @return NONE
* @author
* @date
* @version 1.0
*/
-static WILC_Uint32 WILC_HostIf_PackStaParam(WILC_Uint8 *pu8Buffer, tstrWILC_AddStaParam *pstrStationParam)
+static WILC_Uint32 WILC_HostIf_PackStaParam(u8 *pu8Buffer, tstrWILC_AddStaParam *pstrStationParam)
{
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
pu8CurrByte = pu8Buffer;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
PRINT_D(HOSTINF_DBG, "Handling add station\n");
strWID.u16WIDid = (WILC_Uint16)WID_ADD_STA;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- WILC_Uint8 i;
+ u8 i;
UWORD8 au8Zero_Buff[6] = {0};
strWID.u16WIDid = (WILC_Uint16)WID_DEL_ALL_STA;
strWID.enuWIDtype = WID_STR;
}
WILC_FREE_IF_TRUE(strWID.ps8WidVal);
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
}
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (WILC_Uint16)WID_REMOVE_STA;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (WILC_Uint16)WID_EDIT_STA;
static int Handle_RemainOnChan(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 u8remain_on_chan_flag;
+ u8 u8remain_on_chan_flag;
tstrWID strWID;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
strWID.s32ValueSize = 2;
strWID.ps8WidVal = (WILC_Sint8 *)WILC_MALLOC(strWID.s32ValueSize);
- if (strWID.ps8WidVal == WILC_NULL) {
+ if (strWID.ps8WidVal == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
WILC_CATCH(-1)
{
P2P_LISTEN_STATE = 1;
- WILC_TimerStart(&(pstrWFIDrv->hRemainOnChannel), pstrHostIfRemainOnChan->u32duration, (void *)pstrWFIDrv, WILC_NULL);
+ WILC_TimerStart(&(pstrWFIDrv->hRemainOnChannel), pstrHostIfRemainOnChan->u32duration, (void *)pstrWFIDrv, NULL);
/*Calling CFG ready_on_channel*/
if (pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady) {
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType);
#define FALSE_FRMWR_CHANNEL 100
static WILC_Uint32 Handle_ListenStateExpired(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan)
{
- WILC_Uint8 u8remain_on_chan_flag;
+ u8 u8remain_on_chan_flag;
tstrWID strWID;
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler;
strWID.s32ValueSize = 2;
strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize);
- if (strWID.ps8WidVal == WILC_NULL) {
+ if (strWID.ps8WidVal == NULL) {
PRINT_ER("Failed to allocate memory\n");
}
tstrHostIFmsg strHostIFmsg;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)pvArg;
/*Stopping remain-on-channel timer*/
- WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL);
/* prepare the Timer Callback message */
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = pstrWFIDrv->strHostIfRemainOnChan.u32ListenSessionID;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Uint8 *pu8CurrByte;
+ u8 *pu8CurrByte;
PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n");
strWID.u16WIDid = (WILC_Uint16)WID_11E_P_ACTION_REQ;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Uint8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
+ strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
ptr = strWID.ps8WidVal;
/* *ptr++ = 0x14; */
strWID.u16WIDid = (WILC_Uint16)WID_11E_P_ACTION_REQ;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Uint8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
+ strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
ptr = strWID.ps8WidVal;
/* *ptr++ = 0x14; */
WILC_FREE(strWID.ps8WidVal);
/*BugID_5222*/
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
return s32Error;
strWID.u16WIDid = (WILC_Uint16)WID_DEL_ALL_RX_BA;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Uint8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
+ strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE);
strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE;
ptr = strWID.ps8WidVal;
*ptr++ = 0x14;
WILC_FREE(strWID.ps8WidVal);
/*BugID_5222*/
- WILC_SemaphoreRelease(&hWaitResponse, NULL);
+ up(&hWaitResponse);
return s32Error;
* @date
* @version 1.0
*/
-static void hostIFthread(void *pvArg)
+static int hostIFthread(void *pvArg)
{
WILC_Uint32 u32Ret;
tstrHostIFmsg strHostIFmsg;
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
while (1) {
- WILC_MsgQueueRecv(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), &u32Ret, WILC_NULL);
+ WILC_MsgQueueRecv(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), &u32Ret, NULL);
pstrWFIDrv = (tstrWILC_WFIDrv *)strHostIFmsg.drvHandler;
if (strHostIFmsg.u16MsgId == HOST_IF_MSG_EXIT) {
PRINT_D(GENERIC_DBG, "THREAD: Exiting HostIfThread\n");
if ((!g_wilc_initialized)) {
PRINT_D(GENERIC_DBG, "--WAIT--");
WILC_Sleep(200);
- WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
continue;
}
if (strHostIFmsg.u16MsgId == HOST_IF_MSG_CONNECT && pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL) {
PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n");
- WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
WILC_Sleep(2);
continue;
}
break;
case HOST_IF_MSG_RCVD_SCAN_COMPLETE:
- WILC_TimerStop(&(pstrWFIDrv->hScanTimer), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL);
PRINT_D(HOSTINF_DBG, "scan completed successfully\n");
/*BugID_5213*/
}
PRINT_D(HOSTINF_DBG, "Releasing thread exit semaphore\n");
- WILC_SemaphoreRelease(&hSemHostIFthrdEnd, WILC_NULL);
- return;
- /* do_exit(error); */
- /* PRINT_D(HOSTINF_DBG,"do_exit error code %d\n",error); */
-
+ up(&hSemHostIFthrdEnd);
+ return 0;
}
static void TimerCB_Scan(void *pvArg)
strHostIFmsg.u16MsgId = HOST_IF_MSG_SCAN_TIMER_FIRED;
/* send the message */
- WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
}
static void TimerCB_Connect(void *pvArg)
strHostIFmsg.u16MsgId = HOST_IF_MSG_CONNECT_TIMER_FIRED;
/* send the message */
- WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
}
* @version 1.0
*/
/* Check implementation in core adding 9 bytes to the input! */
-WILC_Sint32 host_int_remove_key(WILC_WFIDrvHandle hWFIDrv, const WILC_Uint8 *pu8StaAddress)
+WILC_Sint32 host_int_remove_key(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8StaAddress)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8keyIdx)
+WILC_Sint32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, u8 u8keyIdx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8keyIdx;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue : Request to remove WEP key \n");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
WILC_CATCH(s32Error)
{
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_WEPDefaultKeyID(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8Index)
+WILC_Sint32 host_int_set_WEPDefaultKeyID(WILC_WFIDrvHandle hWFIDrv, u8 u8Index)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Index;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue : Default key index\n");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
WILC_CATCH(s32Error)
{
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_wep_key_bss_sta(WILC_WFIDrvHandle hWFIDrv, const WILC_Uint8 *pu8WepKey, WILC_Uint8 u8WepKeylen, WILC_Uint8 u8Keyidx)
+WILC_Sint32 host_int_add_wep_key_bss_sta(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (WILC_Uint8 *)WILC_MALLOC(u8WepKeylen);
+ uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC(u8WepKeylen);
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
pu8WepKey, u8WepKeylen);
uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Keyidx;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue :WEP Key\n");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
WILC_CATCH(s32Error)
{
* @date 28 FEB 2013
* @version 1.0
*/
-WILC_Sint32 host_int_add_wep_key_bss_ap(WILC_WFIDrvHandle hWFIDrv, const WILC_Uint8 *pu8WepKey, WILC_Uint8 u8WepKeylen, WILC_Uint8 u8Keyidx, WILC_Uint8 u8mode, AUTHTYPE_T tenuAuth_type)
+WILC_Sint32 host_int_add_wep_key_bss_ap(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx, u8 u8mode, AUTHTYPE_T tenuAuth_type)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- WILC_Uint8 i;
+ u8 i;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (WILC_Uint8 *)WILC_MALLOC((u8WepKeylen));
+ uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC((u8WepKeylen));
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey,
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type = tenuAuth_type;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue :WEP Key\n");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
WILC_CATCH(s32Error)
{
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8Ptk, WILC_Uint8 u8PtkKeylen,
- const WILC_Uint8 *mac_addr, WILC_Uint8 *pu8RxMic, WILC_Uint8 *pu8TxMic, WILC_Uint8 mode, WILC_Uint8 u8Ciphermode, WILC_Uint8 u8Idx)
+WILC_Sint32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8Ptk, u8 u8PtkKeylen,
+ const u8 *mac_addr, const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode, u8 u8Idx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- WILC_Uint8 u8KeyLen = u8PtkKeylen;
+ u8 u8KeyLen = u8PtkKeylen;
WILC_Uint32 i;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
if (pu8RxMic != NULL) {
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (WILC_Uint8 *)WILC_MALLOC(u8PtkKeylen);
+ uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8PtkKeylen);
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue: PTK Key\n");
/* ////////////// */
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
/* WILC_Sleep(100); */
/* /////// */
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8RxGtk, WILC_Uint8 u8GtkKeylen,
- WILC_Uint8 u8KeyIdx, WILC_Uint32 u32KeyRSClen, WILC_Uint8 *KeyRSC,
- WILC_Uint8 *pu8RxMic, WILC_Uint8 *pu8TxMic, WILC_Uint8 mode, WILC_Uint8 u8Ciphermode)
+WILC_Sint32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8RxGtk, u8 u8GtkKeylen,
+ u8 u8KeyIdx, WILC_Uint32 u32KeyRSClen, const u8 *KeyRSC,
+ const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- WILC_Uint8 u8KeyLen = u8GtkKeylen;
+ u8 u8KeyLen = u8GtkKeylen;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
/* prepare the Key Message */
}
if (KeyRSC != NULL) {
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq = (WILC_Uint8 *)WILC_MALLOC(u32KeyRSClen);
+ uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq = (u8 *)WILC_MALLOC(u32KeyRSClen);
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq,
KeyRSC, u32KeyRSClen);
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (WILC_Uint8 *)WILC_MALLOC(u8KeyLen);
+ uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8KeyLen);
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
pu8RxGtk, u8GtkKeylen);
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue: RX GTK\n");
/* ////////////// */
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestKeyBlock));
/* WILC_Sleep(100); */
/* /////// */
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_tx_gtk(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8KeyLen, WILC_Uint8 *pu8TxGtk, WILC_Uint8 u8KeyIdx)
+WILC_Sint32 host_int_add_tx_gtk(WILC_WFIDrvHandle hWFIDrv, u8 u8KeyLen, u8 *pu8TxGtk, u8 u8KeyIdx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY;
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.
- uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (WILC_Uint8 *)WILC_MALLOC(u8KeyLen);
+ uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8KeyLen);
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key,
pu8TxGtk, u8KeyLen);
strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen = u8KeyLen;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Error in sending message queue: TX GTK\n");
/* ////////////// */
- WILC_SemaphoreAcquire(&hSemTestKeyBlock, NULL);
+ down(&hSemTestKeyBlock);
WILC_Sleep(100);
/* /////// */
WILC_Uint32 i;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
}
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER(" Error in sending messagequeue: PMKID Info\n");
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_pmkid_info(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8PmkidInfoArray,
+WILC_Sint32 host_int_get_pmkid_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PmkidInfoArray,
WILC_Uint32 u32PmkidInfoLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8PassPhrase,
- WILC_Uint8 u8Psklength)
+WILC_Sint32 host_int_set_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PassPhrase,
+ u8 u8Psklength)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
/* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */
- /* WILC_Uint8 u8Psklength = WILC_strlen(pu8PassPhrase); */
+ /* u8 u8Psklength = WILC_strlen(pu8PassPhrase); */
/*validating psk length*/
if ((u8Psklength > 7) && (u8Psklength < 65)) {
strWID.u16WIDid = (WILC_Uint16)WID_11I_PSK;
* @date 19 April 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_MacAddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8MacAddress)
+WILC_Sint32 host_int_get_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
strHostIFmsg.uniHostIFmsgBody.strHostIfGetMacAddress.u8MacAddress = pu8MacAddress;
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send get mac address\n");
return WILC_FAIL;
}
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
}
* @date 16 July 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_MacAddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8MacAddress)
+WILC_Sint32 host_int_set_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIfSetMacAddress.u8MacAddress, pu8MacAddress, ETH_ALEN);
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send message queue: Set mac address\n");
WILC_ERRORREPORT(s32Error, s32Error);
* @version 1.0
*/
WILC_Sint32 host_int_get_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv,
- WILC_Uint8 *pu8PassPhrase, WILC_Uint8 u8Psklength)
+ u8 *pu8PassPhrase, u8 u8Psklength)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
*/
#ifndef CONNECT_DIRECT
WILC_Sint32 host_int_get_site_survey_results(WILC_WFIDrvHandle hWFIDrv,
- WILC_Uint8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
+ u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
WILC_Uint32 u32MaxSiteSrvyFragLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_start_scan_req(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 scanSource)
+WILC_Sint32 host_int_set_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 scanSource)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
* @version 1.0
*/
-WILC_Sint32 host_int_get_start_scan_req(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8ScanSource)
+WILC_Sint32 host_int_get_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ScanSource)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8bssid,
- WILC_Uint8 *pu8ssid, size_t ssidLen,
- const WILC_Uint8 *pu8IEs, size_t IEsLen,
+WILC_Sint32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8bssid,
+ const u8 *pu8ssid, size_t ssidLen,
+ const u8 *pu8IEs, size_t IEsLen,
tWILCpfConnectResult pfConnectResult, void *pvUserArg,
- WILC_Uint8 u8security, AUTHTYPE_T tenuAuth_type,
- WILC_Uint8 u8channel,
+ u8 u8security, AUTHTYPE_T tenuAuth_type,
+ u8 u8channel,
void *pJoinParams)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
tenuScanConnTimer enuScanConnTimer;
- if (pstrWFIDrv == WILC_NULL || pfConnectResult == WILC_NULL) {
+ if (pstrWFIDrv == NULL || pfConnectResult == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
if (pu8bssid != NULL) {
- strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid = (WILC_Uint8 *)WILC_MALLOC(6); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid = (u8 *)WILC_MALLOC(6); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid,
pu8bssid, 6);
}
if (pu8ssid != NULL) {
strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.ssidLen = ssidLen;
- strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid = (WILC_Uint8 *)WILC_MALLOC(ssidLen); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid = (u8 *)WILC_MALLOC(ssidLen); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid,
pu8ssid, ssidLen);
if (pu8IEs != NULL) {
strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.IEsLen = IEsLen;
- strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs = (WILC_Uint8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs,
pu8IEs, IEsLen);
}
PRINT_D(GENERIC_DBG, "Don't set state to 'connecting' as state is %d\n", pstrWFIDrv->enuHostIFstate);
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send message queue: Set join request\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
}
enuScanConnTimer = CONNECT_TIMER;
- WILC_TimerStart(&(pstrWFIDrv->hConnectTimer), HOST_IF_CONNECT_TIMEOUT, (void *) hWFIDrv, WILC_NULL);
+ WILC_TimerStart(&(pstrWFIDrv->hConnectTimer), HOST_IF_CONNECT_TIMEOUT, (void *) hWFIDrv, NULL);
WILC_CATCH(s32Error)
{
}
- if (hWFIDrv == WILC_NULL) {
+ if (hWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send message queue: Flush join request\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
tstrHostIFmsg strHostIFmsg;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Failed to send message queue: disconnect\n");
/* ////////////// */
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemTestDisconnectBlock), NULL);
+ down(&(pstrWFIDrv->hSemTestDisconnectBlock));
/* /////// */
WILC_CATCH(s32Error)
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_disconnect_station(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 assoc_id)
+WILC_Sint32 host_int_disconnect_station(WILC_WFIDrvHandle hWFIDrv, u8 assoc_id)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
* @version 1.0
*/
-WILC_Sint32 host_int_get_assoc_req_info(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8AssocReqInfo,
+WILC_Sint32 host_int_get_assoc_req_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocReqInfo,
WILC_Uint32 u32AssocReqInfoLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_assoc_res_info(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8AssocRespInfo,
+WILC_Sint32 host_int_get_assoc_res_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocRespInfo,
WILC_Uint32 u32MaxAssocRespInfoLen, WILC_Uint32 *pu32RcvdAssocRespInfoLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_rx_power_level(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8RxPowerLevel,
+WILC_Sint32 host_int_get_rx_power_level(WILC_WFIDrvHandle hWFIDrv, u8 *pu8RxPowerLevel,
WILC_Uint32 u32RxPowerLevelLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_set_mac_chnl_num(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8ChNum)
+WILC_Sint32 host_int_set_mac_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 u8ChNum)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIFSetChan.u8SetChan = u8ChNum;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
strHostIFmsg.u16MsgId = HOST_IF_MSG_Q_IDLE;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
}
/* wait untill MSG Q is empty */
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
strHostIFmsg.uniHostIFmsgBody.strHostIfSetDrvHandler.u32Address = u32address;
/* strHostIFmsg.drvHandler=hWFIDrv; */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
strHostIFmsg.uniHostIFmsgBody.strHostIfSetOperationMode.u32Mode = u32mode;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_host_chnl_num(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8ChNo)
+WILC_Sint32 host_int_get_host_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ChNo)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Failed to send get host channel param's message queue ");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemGetCHNL), NULL);
+ down(&(pstrWFIDrv->hSemGetCHNL));
/* gu8Chnl = 11; */
*pu8ChNo = gu8Chnl;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
* @date
* @version 1.0
*/
-WILC_Sint32 host_int_get_inactive_time(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *mac, WILC_Uint32 *pu32InactiveTime)
+WILC_Sint32 host_int_get_inactive_time(WILC_WFIDrvHandle hWFIDrv, const u8 *mac, WILC_Uint32 *pu32InactiveTime)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error)
PRINT_ER("Failed to send get host channel param's message queue ");
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemInactiveTime), NULL);
+ down(&(pstrWFIDrv->hSemInactiveTime));
*pu32InactiveTime = gu32InactiveTime;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send get host channel param's message queue ");
return WILC_FAIL;
}
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemGetRSSI), NULL);
+ down(&(pstrWFIDrv->hSemGetRSSI));
if (ps8Rssi == NULL) {
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send GET_LINKSPEED to message queue ");
return WILC_FAIL;
}
- WILC_SemaphoreAcquire(&(pstrWFIDrv->hSemGetLINKSPEED), NULL);
+ down(&(pstrWFIDrv->hSemGetLINKSPEED));
if (ps8lnkspd == NULL) {
strHostIFmsg.uniHostIFmsgBody.pUserData = (WILC_Char *)pstrStatistics;
strHostIFmsg.drvHandler = hWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send get host channel param's message queue ");
return WILC_FAIL;
}
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
}
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_scan(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8ScanSource,
- WILC_Uint8 u8ScanType, WILC_Uint8 *pu8ChnlFreqList,
- WILC_Uint8 u8ChnlListLen, const WILC_Uint8 *pu8IEs,
+WILC_Sint32 host_int_scan(WILC_WFIDrvHandle hWFIDrv, u8 u8ScanSource,
+ u8 u8ScanType, u8 *pu8ChnlFreqList,
+ u8 u8ChnlListLen, const u8 *pu8IEs,
size_t IEsLen, tWILCpfScanResult ScanResult,
void *pvUserArg, tstrHiddenNetwork *pstrHiddenNetwork)
{
tstrHostIFmsg strHostIFmsg;
tenuScanConnTimer enuScanConnTimer;
- if (pstrWFIDrv == WILC_NULL || ScanResult == WILC_NULL) {
+ if (pstrWFIDrv == NULL || ScanResult == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pvUserArg = pvUserArg;
strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ChnlListLen = u8ChnlListLen;
- strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList = (WILC_Uint8 *)WILC_MALLOC(u8ChnlListLen); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList = (u8 *)WILC_MALLOC(u8ChnlListLen); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList,
pu8ChnlFreqList, u8ChnlListLen);
strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.IEsLen = IEsLen;
- strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs = (WILC_Uint8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs,
pu8IEs, IEsLen);
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Error in sending message queue scanning parameters: Error(%d)\n", s32Error);
WILC_ERRORREPORT(s32Error, WILC_FAIL);
enuScanConnTimer = SCAN_TIMER;
PRINT_D(HOSTINF_DBG, ">> Starting the SCAN timer\n");
- WILC_TimerStart(&(pstrWFIDrv->hScanTimer), HOST_IF_SCAN_TIMEOUT, (void *) hWFIDrv, WILC_NULL);
+ WILC_TimerStart(&(pstrWFIDrv->hScanTimer), HOST_IF_SCAN_TIMEOUT, (void *) hWFIDrv, NULL);
WILC_CATCH(s32Error)
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
/* prepare the WiphyParams Message */
strHostIFmsg.uniHostIFmsgBody.strHostIFCfgParamAttr.pstrCfgParamVal = *pstrCfgParamVal;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
WILC_CATCH(s32Error)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
- WILC_SemaphoreAcquire(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ down(&(pstrWFIDrv->gtOsCfgValuesSem));
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
break;
}
- WILC_SemaphoreRelease(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ up(&(pstrWFIDrv->gtOsCfgValuesSem));
WILC_CATCH(s32Error)
{
* @version 1.0
*/
void host_int_send_join_leave_info_to_host
- (WILC_Uint16 assocId, WILC_Uint8 *stationAddr, WILC_Bool joining)
+ (WILC_Uint16 assocId, u8 *stationAddr, WILC_Bool joining)
{
}
/**
strHostIFmsg.drvHandler = pstrWFIDrv;
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Failed to send get host channel param's message queue ");
return;
void host_int_send_network_info_to_host
- (WILC_Uint8 *macStartAddress, WILC_Uint16 u16RxFrameLen, WILC_Sint8 s8Rssi)
+ (u8 *macStartAddress, WILC_Uint16 u16RxFrameLen, WILC_Sint8 s8Rssi)
{
}
/**
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv;
- tstrWILC_SemaphoreAttrs strSemaphoreAttrs;
-
/*if(u32Intialized == 1)
* {
gbScanWhileConnected = WILC_FALSE;
- WILC_SemaphoreFillDefault(&strSemaphoreAttrs);
-
-
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&hWaitResponse, &strSemaphoreAttrs);
+ sema_init(&hWaitResponse, 0);
/*Allocate host interface private structure*/
pstrWFIDrv = (tstrWILC_WFIDrv *)WILC_MALLOC(sizeof(tstrWILC_WFIDrv));
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
/* WILC_ERRORREPORT(s32Error,WILC_NO_MEM); */
s32Error = WILC_NO_MEM;
PRINT_ER("Failed to allocate memory\n");
PRINT_D(HOSTINF_DBG, "Global handle pointer value=%x\n", (WILC_Uint32)pstrWFIDrv);
/* /////////////////////////////////////// */
if (clients_count == 0) {
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&hSemHostIFthrdEnd, &strSemaphoreAttrs);
-
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&hSemDeinitDrvHandle, &strSemaphoreAttrs);
-
+ sema_init(&hSemHostIFthrdEnd, 0);
+ sema_init(&hSemDeinitDrvHandle, 0);
/*BugID_5348*/
- strSemaphoreAttrs.u32InitCount = 1;
- WILC_SemaphoreCreate(&hSemHostIntDeinit, &strSemaphoreAttrs);
- }
-
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemTestKeyBlock), &strSemaphoreAttrs);
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemTestDisconnectBlock), &strSemaphoreAttrs);
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemGetRSSI), &strSemaphoreAttrs);
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemGetLINKSPEED), &strSemaphoreAttrs);
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemGetCHNL), &strSemaphoreAttrs);
- strSemaphoreAttrs.u32InitCount = 0;
- WILC_SemaphoreCreate(&(pstrWFIDrv->hSemInactiveTime), &strSemaphoreAttrs);
+ sema_init(&hSemHostIntDeinit, 1);
+ }
+
+ sema_init(&(pstrWFIDrv->hSemTestKeyBlock), 0);
+ sema_init(&(pstrWFIDrv->hSemTestDisconnectBlock), 0);
+ sema_init(&(pstrWFIDrv->hSemGetRSSI), 0);
+ sema_init(&(pstrWFIDrv->hSemGetLINKSPEED), 0);
+ sema_init(&(pstrWFIDrv->hSemGetCHNL), 0);
+ sema_init(&(pstrWFIDrv->hSemInactiveTime), 0);
/* /////////////////////////////////////// */
if (clients_count == 0) {
- s32Error = WILC_MsgQueueCreate(&gMsgQHostIF, WILC_NULL);
+ s32Error = WILC_MsgQueueCreate(&gMsgQHostIF, NULL);
if (s32Error < 0) {
goto _fail_;
}
msgQ_created = 1;
- s32Error = WILC_ThreadCreate(&HostIFthreadHandler, hostIFthread, WILC_NULL, WILC_NULL);
- if (s32Error < 0) {
+ HostIFthreadHandler = kthread_run(hostIFthread, NULL, "WILC_kthread");
+ if (IS_ERR(HostIFthreadHandler)) {
PRINT_ER("Failed to creat Thread\n");
+ s32Error = WILC_FAIL;
goto _fail_mq_;
}
- s32Error = WILC_TimerCreate(&(g_hPeriodicRSSI), GetPeriodicRSSI, WILC_NULL);
+ s32Error = WILC_TimerCreate(&(g_hPeriodicRSSI), GetPeriodicRSSI, NULL);
if (s32Error < 0) {
PRINT_ER("Failed to creat Timer\n");
goto _fail_timer_1;
}
- s32Error = WILC_TimerCreate(&(pstrWFIDrv->hScanTimer), TimerCB_Scan, WILC_NULL);
+ s32Error = WILC_TimerCreate(&(pstrWFIDrv->hScanTimer), TimerCB_Scan, NULL);
if (s32Error < 0) {
PRINT_ER("Failed to creat Timer\n");
goto _fail_thread_;
}
- s32Error = WILC_TimerCreate(&(pstrWFIDrv->hConnectTimer), TimerCB_Connect, WILC_NULL);
+ s32Error = WILC_TimerCreate(&(pstrWFIDrv->hConnectTimer), TimerCB_Connect, NULL);
if (s32Error < 0) {
PRINT_ER("Failed to creat Timer\n");
goto _fail_timer_1;
#ifdef WILC_P2P
/*Remain on channel timer*/
- s32Error = WILC_TimerCreate(&(pstrWFIDrv->hRemainOnChannel), ListenTimerCB, WILC_NULL);
+ s32Error = WILC_TimerCreate(&(pstrWFIDrv->hRemainOnChannel), ListenTimerCB, NULL);
if (s32Error < 0) {
PRINT_ER("Failed to creat Remain-on-channel Timer\n");
goto _fail_timer_3;
}
#endif
- WILC_SemaphoreCreate(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
- WILC_SemaphoreAcquire(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ sema_init(&(pstrWFIDrv->gtOsCfgValuesSem), 1);
+ down(&(pstrWFIDrv->gtOsCfgValuesSem));
pstrWFIDrv->strCfgValues.curr_tx_rate);
- WILC_SemaphoreRelease(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ up(&(pstrWFIDrv->gtOsCfgValuesSem));
/*TODO Code to setup simulation to be removed later*/
/*Intialize configurator module*/
_fail_mem_:
- if (pstrWFIDrv != WILC_NULL)
+ if (pstrWFIDrv != NULL)
WILC_FREE(pstrWFIDrv);
#ifdef WILC_P2P
_fail_timer_3:
- WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), WILC_NULL);
+ WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL);
#endif
_fail_timer_2:
- WILC_SemaphoreRelease(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
- WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), WILC_NULL);
+ up(&(pstrWFIDrv->gtOsCfgValuesSem));
+ WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL);
_fail_timer_1:
- WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), WILC_NULL);
+ WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL);
_fail_thread_:
- WILC_ThreadDestroy(&HostIFthreadHandler, WILC_NULL);
+ kthread_stop(HostIFthreadHandler);
_fail_mq_:
- WILC_MsgQueueDestroy(&gMsgQHostIF, WILC_NULL);
+ WILC_MsgQueueDestroy(&gMsgQHostIF, NULL);
_fail_:
return s32Error;
return 0;
}
- WILC_SemaphoreAcquire(&hSemHostIntDeinit, NULL);
+ down(&hSemHostIntDeinit);
terminated_handle = pstrWFIDrv;
PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count);
/*BugID_5348*/
/*Destroy all timers before acquiring hSemDeinitDrvHandle*/
/*to guarantee handling all messages befor proceeding*/
- if (WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), WILC_NULL)) {
+ if (WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL)) {
PRINT_D(HOSTINF_DBG, ">> Scan timer is active \n");
/* msleep(HOST_IF_SCAN_TIMEOUT+1000); */
}
- if (WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), WILC_NULL)) {
+ if (WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL)) {
PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n");
/* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
}
- if (WILC_TimerDestroy(&(g_hPeriodicRSSI), WILC_NULL)) {
+ if (WILC_TimerDestroy(&(g_hPeriodicRSSI), NULL)) {
PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n");
/* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
}
#ifdef WILC_P2P
/*Destroy Remain-onchannel Timer*/
- WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), WILC_NULL);
+ WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL);
#endif
- host_int_set_wfi_drv_handler((WILC_Uint32)WILC_NULL);
- WILC_SemaphoreAcquire(&hSemDeinitDrvHandle, NULL);
+ host_int_set_wfi_drv_handler((WILC_Uint32)NULL);
+ down(&hSemDeinitDrvHandle);
/*Calling the CFG80211 scan done function with the abort flag set to true*/
if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) {
- pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, WILC_NULL,
+ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL,
pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
- pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = WILC_NULL;
+ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL;
}
/*deinit configurator and simulator*/
#ifdef SIMULATION
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
if (clients_count == 1) {
- if (WILC_TimerDestroy(&g_hPeriodicRSSI, WILC_NULL)) {
+ if (WILC_TimerDestroy(&g_hPeriodicRSSI, NULL)) {
PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n");
/* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */
}
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error != WILC_SUCCESS) {
PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error);
}
- WILC_SemaphoreAcquire(&hSemHostIFthrdEnd, NULL);
+ down(&hSemHostIFthrdEnd);
- WILC_MsgQueueDestroy(&gMsgQHostIF, WILC_NULL);
+ WILC_MsgQueueDestroy(&gMsgQHostIF, NULL);
msgQ_created = 0;
-
-
- WILC_SemaphoreDestroy(&hSemHostIFthrdEnd, NULL);
- WILC_SemaphoreDestroy(&hSemDeinitDrvHandle, NULL);
-
}
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemTestKeyBlock), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemTestDisconnectBlock), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemGetRSSI), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemGetLINKSPEED), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemGetCHNL), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->hSemInactiveTime), NULL);
- WILC_SemaphoreDestroy(&hWaitResponse, NULL);
-
- WILC_SemaphoreAcquire(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
- WILC_SemaphoreDestroy(&(pstrWFIDrv->gtOsCfgValuesSem), NULL);
+ down(&(pstrWFIDrv->gtOsCfgValuesSem));
/*Setting the gloabl driver handler with NULL*/
u32Intialized = 0;
/* gWFiDrvHandle = NULL; */
- if (pstrWFIDrv != WILC_NULL) {
+ if (pstrWFIDrv != NULL) {
WILC_FREE(pstrWFIDrv);
- /* pstrWFIDrv=WILC_NULL; */
+ /* pstrWFIDrv=NULL; */
}
clients_count--; /* Decrease number of created entities */
- terminated_handle = WILC_NULL;
- WILC_SemaphoreRelease(&hSemHostIntDeinit, NULL);
+ terminated_handle = NULL;
+ up(&hSemHostIntDeinit);
return s32Error;
}
* @date 1 Mar 2012
* @version 1.0
*/
-void NetworkInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length)
+void NetworkInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
WILC_Uint32 drvHandler;
- tstrWILC_WFIDrv *pstrWFIDrv = WILC_NULL;
+ tstrWILC_WFIDrv *pstrWFIDrv = NULL;
drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- if (pstrWFIDrv == WILC_NULL || pstrWFIDrv == terminated_handle) {
+ if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) {
PRINT_ER("NetworkInfo received but driver not init[%x]\n", (WILC_Uint32)pstrWFIDrv);
return;
}
strHostIFmsg.drvHandler = pstrWFIDrv;
strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.u32Length = u32Length;
- strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer = (WILC_Uint8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer,
pu8Buffer, u32Length);
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error);
}
* @date 15 Mar 2012
* @version 1.0
*/
-void GnrlAsyncInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length)
+void GnrlAsyncInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
WILC_Uint32 drvHandler;
- tstrWILC_WFIDrv *pstrWFIDrv = WILC_NULL;
+ tstrWILC_WFIDrv *pstrWFIDrv = NULL;
/*BugID_5348*/
- WILC_SemaphoreAcquire(&hSemHostIntDeinit, NULL);
+ down(&hSemHostIntDeinit);
drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) {
PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n");
/*BugID_5348*/
- WILC_SemaphoreRelease(&hSemHostIntDeinit, NULL);
+ up(&hSemHostIntDeinit);
return;
}
- if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == WILC_NULL) {
+ if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL) {
/* received mac status is not needed when there is no current Connect Request */
PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n");
/*BugID_5348*/
- WILC_SemaphoreRelease(&hSemHostIntDeinit, NULL);
+ up(&hSemHostIntDeinit);
return;
}
strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.u32Length = u32Length;
- strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer = (WILC_Uint8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
+ strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */
WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer,
pu8Buffer, u32Length);
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error);
}
/*BugID_5348*/
- WILC_SemaphoreRelease(&hSemHostIntDeinit, NULL);
+ up(&hSemHostIntDeinit);
return;
}
/**
* @brief host_int_ScanCompleteReceived
* @details Setting scan complete received notifcation in message queue
- * @param[in] WILC_Uint8* pu8Buffer, WILC_Uint32 u32Length
+ * @param[in] u8* pu8Buffer, WILC_Uint32 u32Length
* @return Error code.
* @author
* @date
* @version 1.0
*/
-void host_int_ScanCompleteReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length)
+void host_int_ScanCompleteReceived(u8 *pu8Buffer, WILC_Uint32 u32Length)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
WILC_Uint32 drvHandler;
- tstrWILC_WFIDrv *pstrWFIDrv = WILC_NULL;
+ tstrWILC_WFIDrv *pstrWFIDrv = NULL;
drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24));
pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
/*no need to send message body*/
/*strHostIFmsg.uniHostIFmsgBody.strScanComplete.u32Length = u32Length;
- * strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer = (WILC_Uint8*)WILC_MALLOC(u32Length);
+ * strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer = (u8*)WILC_MALLOC(u32Length);
* WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer,
* pu8Buffer, u32Length); */
/* send the message */
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error);
}
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
/*Stopping remain-on-channel timer*/
- WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), WILC_NULL);
+ WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL);
/* prepare the timer fire Message */
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
strHostIFmsg.drvHandler = hWFIDrv;
strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.bReg = bReg;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
* @brief host_int_add_beacon
* @details Setting add beacon params in message queue
* @param[in] WILC_WFIDrvHandle hWFIDrv, WILC_Uint32 u32Interval,
- * WILC_Uint32 u32DTIMPeriod,WILC_Uint32 u32HeadLen, WILC_Uint8* pu8Head,
- * WILC_Uint32 u32TailLen, WILC_Uint8* pu8Tail
+ * WILC_Uint32 u32DTIMPeriod,WILC_Uint32 u32HeadLen, u8* pu8Head,
+ * WILC_Uint32 u32TailLen, u8* pu8Tail
* @return Error code.
* @author
* @date
*/
WILC_Sint32 host_int_add_beacon(WILC_WFIDrvHandle hWFIDrv, WILC_Uint32 u32Interval,
WILC_Uint32 u32DTIMPeriod,
- WILC_Uint32 u32HeadLen, WILC_Uint8 *pu8Head,
- WILC_Uint32 u32TailLen, WILC_Uint8 *pu8Tail)
+ WILC_Uint32 u32HeadLen, u8 *pu8Head,
+ WILC_Uint32 u32TailLen, u8 *pu8Tail)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
tstrHostIFSetBeacon *pstrSetBeaconParam = &strHostIFmsg.uniHostIFmsgBody.strHostIFSetBeacon;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pstrSetBeaconParam->u32Interval = u32Interval;
pstrSetBeaconParam->u32DTIMPeriod = u32DTIMPeriod;
pstrSetBeaconParam->u32HeadLen = u32HeadLen;
- pstrSetBeaconParam->pu8Head = (WILC_Uint8 *)WILC_MALLOC(u32HeadLen);
+ pstrSetBeaconParam->pu8Head = (u8 *)WILC_MALLOC(u32HeadLen);
if (pstrSetBeaconParam->pu8Head == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
/* Bug 4599 : if tail length = 0 skip allocating & copying */
if (u32TailLen > 0) {
- pstrSetBeaconParam->pu8Tail = (WILC_Uint8 *)WILC_MALLOC(u32TailLen);
+ pstrSetBeaconParam->pu8Tail = (u8 *)WILC_MALLOC(u32TailLen);
if (pstrSetBeaconParam->pu8Tail == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
pstrSetBeaconParam->pu8Tail = NULL;
}
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
PRINT_D(HOSTINF_DBG, "Setting deleting beacon message queue params\n");
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
WILC_ERRORCHECK(s32Error);
WILC_CATCH(s32Error)
tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam));
if (pstrAddStationMsg->u8NumRates > 0) {
- pstrAddStationMsg->pu8Rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
- WILC_NULLCHECK(s32Error, pstrAddStationMsg->pu8Rates);
+ u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
+ WILC_NULLCHECK(s32Error, rates);
- WILC_memcpy(pstrAddStationMsg->pu8Rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
+ WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
+ pstrAddStationMsg->pu8Rates = rates;
}
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
/**
* @brief host_int_del_station
* @details Setting delete station params in message queue
- * @param[in] WILC_WFIDrvHandle hWFIDrv, WILC_Uint8* pu8MacAddr
+ * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8MacAddr
* @return Error code.
* @author
* @date
* @version 1.0
*/
-WILC_Sint32 host_int_del_station(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8MacAddr)
+WILC_Sint32 host_int_del_station(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8MacAddr)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
tstrHostIFDelSta *pstrDelStationMsg = &strHostIFmsg.uniHostIFmsgBody.strDelStaParam;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
/*BugID_4795: Handling situation of deleting all stations*/
- if (pu8MacAddr == WILC_NULL)
+ if (pu8MacAddr == NULL)
WILC_memset(pstrDelStationMsg->au8MacAddr, 255, ETH_ALEN);
else
WILC_memcpy(pstrDelStationMsg->au8MacAddr, pu8MacAddr, ETH_ALEN);
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
/**
* @brief host_int_del_allstation
* @details Setting del station params in message queue
- * @param[in] WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 pu8MacAddr[][ETH_ALEN]s
+ * @param[in] WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN]s
* @return Error code.
* @author
* @date
* @version 1.0
*/
-WILC_Sint32 host_int_del_allstation(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 pu8MacAddr[][ETH_ALEN])
+WILC_Sint32 host_int_del_allstation(WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN])
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
tstrHostIFDelAllSta *pstrDelAllStationMsg = &strHostIFmsg.uniHostIFmsgBody.strHostIFDelAllSta;
- WILC_Uint8 au8Zero_Buff[ETH_ALEN] = {0};
+ u8 au8Zero_Buff[ETH_ALEN] = {0};
WILC_Uint32 i;
- WILC_Uint8 u8AssocNumb = 0;
+ u8 u8AssocNumb = 0;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
}
pstrDelAllStationMsg->u8Num_AssocSta = u8AssocNumb;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
{
}
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
tstrHostIFmsg strHostIFmsg;
tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam));
if (pstrAddStationMsg->u8NumRates > 0) {
- pstrAddStationMsg->pu8Rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
- WILC_memcpy(pstrAddStationMsg->pu8Rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
- WILC_NULLCHECK(s32Error, pstrAddStationMsg->pu8Rates);
+ u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates);
+ WILC_NULLCHECK(s32Error, rates);
+ WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates);
+ pstrAddStationMsg->pu8Rates = rates;
}
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
PRINT_INFO(HOSTINF_DBG, "\n\n>> Setting PS to %d << \n\n", bIsEnabled);
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pstrPowerMgmtParam->u32Timeout = u32Timeout;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
tstrHostIFSetMulti *pstrMulticastFilterParam = &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMulti;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pstrMulticastFilterParam->bIsEnabled = bIsEnabled;
pstrMulticastFilterParam->u32count = u32count;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo)
{
tstrJoinBssParam *pNewJoinBssParam = NULL;
- WILC_Uint8 *pu8IEs;
+ u8 *pu8IEs;
WILC_Uint16 u16IEsLen;
WILC_Uint16 index = 0;
- WILC_Uint8 suppRatesNo = 0;
- WILC_Uint8 extSuppRatesNo;
+ u8 suppRatesNo = 0;
+ u8 extSuppRatesNo;
WILC_Uint16 jumpOffset;
- WILC_Uint8 pcipherCount;
- WILC_Uint8 authCount;
- WILC_Uint8 pcipherTotalCount = 0;
- WILC_Uint8 authTotalCount = 0;
- WILC_Uint8 i, j;
+ u8 pcipherCount;
+ u8 authCount;
+ u8 pcipherTotalCount = 0;
+ u8 authTotalCount = 0;
+ u8 i, j;
pu8IEs = ptstrNetworkInfo->pu8IEs;
u16IEsLen = ptstrNetworkInfo->u16IEsLen;
WILC_memcpy(pNewJoinBssParam->au8bssid, ptstrNetworkInfo->au8bssid, 6);
/*for(i=0; i<6;i++)
* PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->au8bssid[i]);*/
- WILC_memcpy((WILC_Uint8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->au8ssid, ptstrNetworkInfo->u8SsidLen + 1);
+ WILC_memcpy((u8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->au8ssid, ptstrNetworkInfo->u8SsidLen + 1);
pNewJoinBssParam->ssidLen = ptstrNetworkInfo->u8SsidLen;
WILC_memset(pNewJoinBssParam->rsn_pcip_policy, 0xFF, 3);
WILC_memset(pNewJoinBssParam->rsn_auth_policy, 0xFF, 3);
tstrHostIFmsg strHostIFmsg;
tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pBASessionInfo->u16SessionTimeout = SessionTimeout;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
tstrHostIFmsg strHostIFmsg;
tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pBASessionInfo->u8Ted = TID;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
}
/*BugID_5222*/
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
}
tstrHostIFmsg strHostIFmsg;
tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
pBASessionInfo->u8Ted = TID;
strHostIFmsg.drvHandler = hWFIDrv;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
}
/*BugID_5222*/
- WILC_SemaphoreAcquire(&hWaitResponse, NULL);
+ down(&hWaitResponse);
return s32Error;
}
* @author Abdelrahman Sobhy
* @date
* @version 1.0*/
-WILC_Sint32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *u16ipadd, WILC_Uint8 idx)
+WILC_Sint32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
/* TODO: Enable This feature on softap firmware */
return 0;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler = hWFIDrv;
strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx = idx;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
* @author Abdelrahman Sobhy
* @date
* @version 1.0*/
-WILC_Sint32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *u16ipadd, WILC_Uint8 idx)
+WILC_Sint32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
tstrHostIFmsg strHostIFmsg;
- if (pstrWFIDrv == WILC_NULL) {
+ if (pstrWFIDrv == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
strHostIFmsg.drvHandler=hWFIDrv;
strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx= idx;
- s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), WILC_NULL);
+ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL);
if (s32Error) {
WILC_ERRORREPORT(s32Error, s32Error);
}
projects / firefly-linux-kernel-4.4.55.git / blobdiff