Just use u8, as that's what you really want in a kernel driver.
Cc: Johnny Kim <johnny.kim@atmel.com>
Cc: Rachel Kim <rachel.kim@atmel.com>
Cc: Dean Lee <dean.lee@atmel.com>
Cc: Chris Park <chris.park@atmel.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
/* Extern Function Declarations */
/*****************************************************************************/
extern WILC_Sint32 SendRawPacket(WILC_Sint8 *ps8Packet, WILC_Sint32 s32PacketLen);
-extern void NetworkInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
-extern void GnrlAsyncInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
-extern void host_int_ScanCompleteReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
+extern void NetworkInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
+extern void GnrlAsyncInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
+extern void host_int_ScanCompleteReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
/*****************************************************************************/
/* Global Variables */
/*****************************************************************************/
static tstrConfigPktInfo gstrConfigPktInfo;
-static WILC_Uint8 g_seqno;
+static u8 g_seqno;
static WILC_Sint16 g_wid_num = -1;
static WILC_Uint16 Res_Len;
-static WILC_Uint8 g_oper_mode = SET_CFG;
+static u8 g_oper_mode = SET_CFG;
/* WID Switches */
static tstrWID gastrWIDs[] = {
/*****************************************************************************/
/* Functions */
/*****************************************************************************/
-INLINE WILC_Uint8 ascii_hex_to_dec(WILC_Uint8 num)
+INLINE u8 ascii_hex_to_dec(u8 num)
{
if ((num >= '0') && (num <= '9'))
return (num - '0');
return INVALID;
}
-INLINE WILC_Uint8 get_hex_char(WILC_Uint8 inp)
+INLINE u8 get_hex_char(u8 inp)
{
- WILC_Uint8 *d2htab = "0123456789ABCDEF";
+ u8 *d2htab = "0123456789ABCDEF";
return d2htab[inp & 0xF];
}
/* This function extracts the MAC address held in a string in standard format */
/* into another buffer as integers. */
-INLINE WILC_Uint16 extract_mac_addr(WILC_Char *str, WILC_Uint8 *buff)
+INLINE WILC_Uint16 extract_mac_addr(WILC_Char *str, u8 *buff)
{
*buff = 0;
while (*str != '\0') {
/* This function creates MAC address in standard format from a buffer of */
/* integers. */
-INLINE void create_mac_addr(WILC_Uint8 *str, WILC_Uint8 *buff)
+INLINE void create_mac_addr(u8 *str, u8 *buff)
{
WILC_Uint32 i = 0;
WILC_Uint32 j = 0;
for (i = 0; i < MAC_ADDR_LEN; i++) {
- str[j++] = get_hex_char((WILC_Uint8)((buff[i] >> 4) & 0x0F));
- str[j++] = get_hex_char((WILC_Uint8)(buff[i] & 0x0F));
+ str[j++] = get_hex_char((u8)((buff[i] >> 4) & 0x0F));
+ str[j++] = get_hex_char((u8)(buff[i] & 0x0F));
str[j++] = ':';
}
str[--j] = '\0';
/* inet_addr is platform independent. */
/* ips=>IP Address String in dotted decimal format */
/* ipn=>Pointer to IP Address in integer format */
-INLINE WILC_Uint8 conv_ip_to_int(WILC_Uint8 *ips, WILC_Uint32 *ipn)
+INLINE u8 conv_ip_to_int(u8 *ips, WILC_Uint32 *ipn)
{
- WILC_Uint8 i = 0;
- WILC_Uint8 ipb = 0;
+ u8 i = 0;
+ u8 ipb = 0;
*ipn = 0;
/* Integer to string for each component */
while (ips[i] != '\0') {
/* decimal string format. Alternative to std library fn inet_ntoa(). */
/* ips=>Buffer to hold IP Address String dotted decimal format (Min 17B) */
/* ipn=>IP Address in integer format */
-INLINE WILC_Uint8 conv_int_to_ip(WILC_Uint8 *ips, WILC_Uint32 ipn)
+INLINE u8 conv_int_to_ip(u8 *ips, WILC_Uint32 ipn)
{
- WILC_Uint8 i = 0;
- WILC_Uint8 ipb = 0;
- WILC_Uint8 cnt = 0;
- WILC_Uint8 ipbsize = 0;
+ u8 i = 0;
+ u8 ipb = 0;
+ u8 cnt = 0;
+ u8 ipbsize = 0;
for (cnt = 4; cnt > 0; cnt--) {
ipb = (ipn >> (8 * (cnt - 1))) & 0xFF;
/* This function extracts the beacon period field from the beacon or probe */
/* response frame. */
-INLINE WILC_Uint16 get_beacon_period(WILC_Uint8 *data)
+INLINE WILC_Uint16 get_beacon_period(u8 *data)
{
WILC_Uint16 bcn_per = 0;
return bcn_per;
}
-INLINE WILC_Uint32 get_beacon_timestamp_lo(WILC_Uint8 *data)
+INLINE WILC_Uint32 get_beacon_timestamp_lo(u8 *data)
{
WILC_Uint32 time_stamp = 0;
WILC_Uint32 index = MAC_HDR_LEN;
/* This function extracts the 'frame type' bits from the MAC header of the */
/* input frame. */
/* Returns the value in the LSB of the returned value. */
-INLINE tenuBasicFrmType get_type(WILC_Uint8 *header)
+INLINE tenuBasicFrmType get_type(u8 *header)
{
return ((tenuBasicFrmType)(header[0] & 0x0C));
}
/* This function extracts the 'frame type and sub type' bits from the MAC */
/* header of the input frame. */
/* Returns the value in the LSB of the returned value. */
-INLINE tenuFrmSubtype get_sub_type(WILC_Uint8 *header)
+INLINE tenuFrmSubtype get_sub_type(u8 *header)
{
return ((tenuFrmSubtype)(header[0] & 0xFC));
}
/* This function extracts the 'to ds' bit from the MAC header of the input */
/* frame. */
/* Returns the value in the LSB of the returned value. */
-INLINE WILC_Uint8 get_to_ds(WILC_Uint8 *header)
+INLINE u8 get_to_ds(u8 *header)
{
return (header[1] & 0x01);
}
/* This function extracts the 'from ds' bit from the MAC header of the input */
/* frame. */
/* Returns the value in the LSB of the returned value. */
-INLINE WILC_Uint8 get_from_ds(WILC_Uint8 *header)
+INLINE u8 get_from_ds(u8 *header)
{
return ((header[1] & 0x02) >> 1);
}
/* This function extracts the MAC Address in 'address1' field of the MAC */
/* header and updates the MAC Address in the allocated 'addr' variable. */
-INLINE void get_address1(WILC_Uint8 *pu8msa, WILC_Uint8 *addr)
+INLINE void get_address1(u8 *pu8msa, u8 *addr)
{
WILC_memcpy(addr, pu8msa + 4, 6);
}
/* This function extracts the MAC Address in 'address2' field of the MAC */
/* header and updates the MAC Address in the allocated 'addr' variable. */
-INLINE void get_address2(WILC_Uint8 *pu8msa, WILC_Uint8 *addr)
+INLINE void get_address2(u8 *pu8msa, u8 *addr)
{
WILC_memcpy(addr, pu8msa + 10, 6);
}
/* This function extracts the MAC Address in 'address3' field of the MAC */
/* header and updates the MAC Address in the allocated 'addr' variable. */
-INLINE void get_address3(WILC_Uint8 *pu8msa, WILC_Uint8 *addr)
+INLINE void get_address3(u8 *pu8msa, u8 *addr)
{
WILC_memcpy(addr, pu8msa + 16, 6);
}
/* This function extracts the BSSID from the incoming WLAN packet based on */
/* the 'from ds' bit, and updates the MAC Address in the allocated 'addr' */
/* variable. */
-INLINE void get_BSSID(WILC_Uint8 *data, WILC_Uint8 *bssid)
+INLINE void get_BSSID(u8 *data, u8 *bssid)
{
if (get_from_ds(data) == 1)
get_address2(data, bssid);
}
/* This function extracts the SSID from a beacon/probe response frame */
-INLINE void get_ssid(WILC_Uint8 *data, WILC_Uint8 *ssid, WILC_Uint8 *p_ssid_len)
+INLINE void get_ssid(u8 *data, u8 *ssid, u8 *p_ssid_len)
{
- WILC_Uint8 len = 0;
- WILC_Uint8 i = 0;
- WILC_Uint8 j = 0;
+ u8 len = 0;
+ u8 i = 0;
+ u8 j = 0;
len = data[MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN +
CAP_INFO_LEN + 1];
/* This function extracts the capability info field from the beacon or probe */
/* response frame. */
-INLINE WILC_Uint16 get_cap_info(WILC_Uint8 *data)
+INLINE WILC_Uint16 get_cap_info(u8 *data)
{
WILC_Uint16 cap_info = 0;
WILC_Uint16 index = MAC_HDR_LEN;
/* This function extracts the capability info field from the Association */
/* response frame. */
-INLINE WILC_Uint16 get_assoc_resp_cap_info(WILC_Uint8 *data)
+INLINE WILC_Uint16 get_assoc_resp_cap_info(u8 *data)
{
WILC_Uint16 cap_info = 0;
/* This funcion extracts the association status code from the incoming */
/* association response frame and returns association status code */
-INLINE WILC_Uint16 get_asoc_status(WILC_Uint8 *data)
+INLINE WILC_Uint16 get_asoc_status(u8 *data)
{
WILC_Uint16 asoc_status = 0;
/* This function extracts association ID from the incoming association */
/* response frame */
-INLINE WILC_Uint16 get_asoc_id(WILC_Uint8 *data)
+INLINE WILC_Uint16 get_asoc_id(u8 *data)
{
WILC_Uint16 asoc_id = 0;
return s32Error;
}
-WILC_Uint8 *get_tim_elm(WILC_Uint8 *pu8msa, WILC_Uint16 u16RxLen, WILC_Uint16 u16TagParamOffset)
+u8 *get_tim_elm(u8 *pu8msa, WILC_Uint16 u16RxLen, WILC_Uint16 u16TagParamOffset)
{
WILC_Uint16 u16index = 0;
/* This function gets the current channel information from
* the 802.11n beacon/probe response frame */
-WILC_Uint8 get_current_channel_802_11n(WILC_Uint8 *pu8msa, WILC_Uint16 u16RxLen)
+u8 get_current_channel_802_11n(u8 *pu8msa, WILC_Uint16 u16RxLen)
{
WILC_Uint16 index;
return 0; /* no MIB here */
}
-WILC_Uint8 get_current_channel(WILC_Uint8 *pu8msa, WILC_Uint16 u16RxLen)
+u8 get_current_channel(u8 *pu8msa, WILC_Uint16 u16RxLen)
{
#ifdef PHY_802_11n
#ifdef FIVE_GHZ_BAND
* @date 1 Mar 2012
* @version 1.0
*/
-WILC_Sint32 ParseNetworkInfo(WILC_Uint8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo)
+WILC_Sint32 ParseNetworkInfo(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrNetworkInfo *pstrNetworkInfo = NULL;
- 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_Uint16 u16WidLen = 0;
- WILC_Uint8 *pu8WidVal = 0;
+ u8 *pu8WidVal = 0;
u8MsgType = pu8MsgBuffer[0];
/* parse the WID value of the WID "WID_NEWORK_INFO" */
{
- WILC_Uint8 *pu8msa = 0;
+ u8 *pu8msa = 0;
WILC_Uint16 u16RxLen = 0;
- WILC_Uint8 *pu8TimElm = 0;
- WILC_Uint8 *pu8IEs = 0;
+ u8 *pu8TimElm = 0;
+ u8 *pu8IEs = 0;
WILC_Uint16 u16IEsLen = 0;
- WILC_Uint8 u8index = 0;
+ u8 u8index = 0;
WILC_Uint32 u32Tsf_Lo;
WILC_Uint32 u32Tsf_Hi;
u16IEsLen = u16RxLen - (MAC_HDR_LEN + TIME_STAMP_LEN + BEACON_INTERVAL_LEN + CAP_INFO_LEN);
if (u16IEsLen > 0) {
- pstrNetworkInfo->pu8IEs = (WILC_Uint8 *)WILC_MALLOC(u16IEsLen);
+ pstrNetworkInfo->pu8IEs = (u8 *)WILC_MALLOC(u16IEsLen);
WILC_memset((void *)(pstrNetworkInfo->pu8IEs), 0, u16IEsLen);
WILC_memcpy(pstrNetworkInfo->pu8IEs, pu8IEs, u16IEsLen);
* @date 2 Apr 2012
* @version 1.0
*/
-WILC_Sint32 ParseAssocRespInfo(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BufferLen,
+WILC_Sint32 ParseAssocRespInfo(u8 *pu8Buffer, WILC_Uint32 u32BufferLen,
tstrConnectRespInfo **ppstrConnectRespInfo)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrConnectRespInfo *pstrConnectRespInfo = NULL;
WILC_Uint16 u16AssocRespLen = 0;
- WILC_Uint8 *pu8IEs = 0;
+ u8 *pu8IEs = 0;
WILC_Uint16 u16IEsLen = 0;
pstrConnectRespInfo = (tstrConnectRespInfo *)WILC_MALLOC(sizeof(tstrConnectRespInfo));
pu8IEs = &pu8Buffer[CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN];
u16IEsLen = u16AssocRespLen - (CAP_INFO_LEN + STATUS_CODE_LEN + AID_LEN);
- pstrConnectRespInfo->pu8RespIEs = (WILC_Uint8 *)WILC_MALLOC(u16IEsLen);
+ pstrConnectRespInfo->pu8RespIEs = (u8 *)WILC_MALLOC(u16IEsLen);
WILC_memset((void *)(pstrConnectRespInfo->pu8RespIEs), 0, u16IEsLen);
WILC_memcpy(pstrConnectRespInfo->pu8RespIEs, pu8IEs, u16IEsLen);
}
#ifndef CONNECT_DIRECT
-WILC_Sint32 ParseSurveyResults(WILC_Uint8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
+WILC_Sint32 ParseSurveyResults(u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
wid_site_survey_reslts_s **ppstrSurveyResults,
WILC_Uint32 *pu32SurveyResultsCount)
{
wid_site_survey_reslts_s *pstrSurveyResults = NULL;
WILC_Uint32 u32SurveyResultsCount = 0;
WILC_Uint32 u32SurveyBytesLength = 0;
- WILC_Uint8 *pu8BufferPtr;
+ u8 *pu8BufferPtr;
WILC_Uint32 u32RcvdSurveyResultsNum = 2;
- WILC_Uint8 u8ReadSurveyResFragNum;
+ u8 u8ReadSurveyResFragNum;
WILC_Uint32 i;
WILC_Uint32 j;
void ProcessCharWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
{
- WILC_Uint8 *pu8val = (WILC_Uint8 *)ps8WidVal;
- WILC_Uint8 u8val = 0;
+ u8 *pu8val = (u8 *)ps8WidVal;
+ u8 u8val = 0;
WILC_Sint32 s32PktLen = *ps32PktLen;
if (pstrWID == NULL) {
PRINT_WRN(CORECONFIG_DBG, "Can't set CHAR val 0x%x ,NULL structure\n", u8val);
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid >> 8) & 0xFF;
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid >> 8) & 0xFF;
if (g_oper_mode == SET_CFG) {
u8val = *pu8val;
/* Length */
- pcPacket[s32PktLen++] = sizeof(WILC_Uint8);
+ pcPacket[s32PktLen++] = sizeof(u8);
/* Value */
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
u16val = *pu16val;
pcPacket[s32PktLen++] = sizeof(WILC_Uint16);
/* Value */
- pcPacket[s32PktLen++] = (WILC_Uint8)(u16val & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u16val >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(u16val & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u16val >> 8) & 0xFF);
}
*ps32PktLen = s32PktLen;
}
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
u32val = *pu32val;
pcPacket[s32PktLen++] = sizeof(WILC_Uint32);
/* Value */
- pcPacket[s32PktLen++] = (WILC_Uint8)(u32val & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 8) & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 16) & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 24) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
}
*ps32PktLen = s32PktLen;
}
/*****************************************************************************/
void ProcessIPwid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Uint8 *pu8ip)
+ tstrWID *pstrWID, u8 *pu8ip)
{
WILC_Uint32 u32val = 0;
WILC_Sint32 s32PktLen = *ps32PktLen;
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
/* Length */
conv_ip_to_int(pu8ip, &u32val);
/* Value */
- pcPacket[s32PktLen++] = (WILC_Uint8)(u32val & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 8) & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 16) & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u32val >> 24) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(u32val & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 16) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u32val >> 24) & 0xFF);
}
*ps32PktLen = s32PktLen;
}
/*****************************************************************************/
void ProcessStrWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Uint8 *pu8val, WILC_Sint32 s32ValueSize)
+ tstrWID *pstrWID, u8 *pu8val, WILC_Sint32 s32ValueSize)
{
WILC_Uint16 u16MsgLen = 0;
WILC_Uint16 idx = 0;
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
/* Message Length */
u16MsgLen = (WILC_Uint16)s32ValueSize;
/* Length */
- pcPacket[s32PktLen++] = (WILC_Uint8)u16MsgLen;
+ pcPacket[s32PktLen++] = (u8)u16MsgLen;
/* Value */
for (idx = 0; idx < u16MsgLen; idx++)
/*****************************************************************************/
void ProcessAdrWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Uint8 *pu8val)
+ tstrWID *pstrWID, u8 *pu8val)
{
WILC_Uint16 u16MsgLen = 0;
WILC_Sint32 s32PktLen = *ps32PktLen;
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
/* Message Length */
u16MsgLen = MAC_ADDR_LEN;
/* Length */
- pcPacket[s32PktLen++] = (WILC_Uint8)u16MsgLen;
+ pcPacket[s32PktLen++] = (u8)u16MsgLen;
/* Value */
extract_mac_addr(pu8val, pcPacket + s32PktLen);
/*****************************************************************************/
void ProcessBinWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Uint8 *pu8val, WILC_Sint32 s32ValueSize)
+ tstrWID *pstrWID, u8 *pu8val, WILC_Sint32 s32ValueSize)
{
/* WILC_ERROR("processing Binary WIDs is not supported \n"); */
WILC_Uint16 u16MsgLen = 0;
WILC_Uint16 idx = 0;
WILC_Sint32 s32PktLen = *ps32PktLen;
- WILC_Uint8 u8checksum = 0;
+ u8 u8checksum = 0;
if (pstrWID == NULL) {
PRINT_WRN(CORECONFIG_DBG, "Can't set BIN val, NULL structure\n");
}
/* WID */
- pcPacket[s32PktLen++] = (WILC_Uint8)(pstrWID->u16WIDid & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((pstrWID->u16WIDid >> 8) & 0xFF);
+ pcPacket[s32PktLen++] = (u8)(pstrWID->u16WIDid & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((pstrWID->u16WIDid >> 8) & 0xFF);
if (g_oper_mode == SET_CFG) {
/* Message Length */
u16MsgLen = (WILC_Uint16)s32ValueSize;
/* Length */
- /* pcPacket[s32PktLen++] = (WILC_Uint8)u16MsgLen; */
- pcPacket[s32PktLen++] = (WILC_Uint8)(u16MsgLen & 0xFF);
- pcPacket[s32PktLen++] = (WILC_Uint8)((u16MsgLen >> 8) & 0xFF);
+ /* pcPacket[s32PktLen++] = (u8)u16MsgLen; */
+ pcPacket[s32PktLen++] = (u8)(u16MsgLen & 0xFF);
+ pcPacket[s32PktLen++] = (u8)((u16MsgLen >> 8) & 0xFF);
/* Value */
for (idx = 0; idx < u16MsgLen; idx++)
/* */
/*****************************************************************************/
-WILC_Sint32 further_process_response(WILC_Uint8 *resp,
+WILC_Sint32 further_process_response(u8 *resp,
WILC_Uint16 u16WIDid,
WILC_Uint16 cfg_len,
WILC_Bool process_wid_num,
{
WILC_Uint32 retval = 0;
WILC_Uint32 idx = 0;
- WILC_Uint8 cfg_chr = 0;
+ u8 cfg_chr = 0;
WILC_Uint16 cfg_sht = 0;
WILC_Uint32 cfg_int = 0;
- WILC_Uint8 cfg_str[256] = {0};
+ u8 cfg_str[256] = {0};
tenuWIDtype enuWIDtype = WID_UNDEF;
if (process_wid_num) {
case WID_BIN_DATA:
#if 0
/* FILE *fp_bin = NULL; */
- WILC_Uint8 first_bin_wid = 1;
+ u8 first_bin_wid = 1;
if (first_bin_wid) {
/* fp_bin = fopen("wid_response.bin","wb"); */
first_bin_wid = 0;
/* */
/*****************************************************************************/
-WILC_Sint32 ParseResponse(WILC_Uint8 *resp, tstrWID *pstrWIDcfgResult)
+WILC_Sint32 ParseResponse(u8 *resp, tstrWID *pstrWIDcfgResult)
{
WILC_Uint16 u16RespLen = 0;
WILC_Uint16 u16WIDid = 0;
* @version 1.0
*/
-WILC_Sint32 ParseWriteResponse(WILC_Uint8 *pu8RespBuffer)
+WILC_Sint32 ParseWriteResponse(u8 *pu8RespBuffer)
{
WILC_Sint32 s32Error = WILC_FAIL;
WILC_Uint16 u16RespLen = 0;
pcpacket[u16MsgInd++] = g_seqno++;
/* Message Length */
- pcpacket[u16MsgInd++] = (WILC_Uint8)(u16MsgLen & 0xFF);
- pcpacket[u16MsgInd++] = (WILC_Uint8)((u16MsgLen >> 8) & 0xFF);
+ pcpacket[u16MsgInd++] = (u8)(u16MsgLen & 0xFF);
+ pcpacket[u16MsgInd++] = (u8)((u16MsgLen >> 8) & 0xFF);
*ps32PacketLength = u16MsgLen;
* @version 1.0
*/
#ifdef SIMULATION
-WILC_Sint32 SendConfigPkt(WILC_Uint8 u8Mode, tstrWID *pstrWIDs,
+WILC_Sint32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
WILC_Uint32 u32WIDsCount, WILC_Bool bRespRequired, WILC_Uint32 drvHandler)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
* @version 1.0
*/
-WILC_Sint32 ConfigPktReceived(WILC_Uint8 *pu8RxPacket, WILC_Sint32 s32RxPacketLen)
+WILC_Sint32 ConfigPktReceived(u8 *pu8RxPacket, WILC_Sint32 s32RxPacketLen)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 u8MsgType = 0;
+ u8 u8MsgType = 0;
u8MsgType = pu8RxPacket[0];
* @date 1 Mar 2012
* @version 1.0
*/
-WILC_Sint32 SendConfigPkt(WILC_Uint8 u8Mode, tstrWID *pstrWIDs,
+WILC_Sint32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
WILC_Uint32 u32WIDsCount, WILC_Bool bRespRequired, WILC_Uint32 drvHandler)
{
WILC_Sint32 counter = 0, ret = 0;
} tstrWID;
typedef struct {
- WILC_Uint8 u8Full;
- WILC_Uint8 u8Index;
+ u8 u8Full;
+ u8 u8Index;
WILC_Sint8 as8RSSI[NUM_RSSI];
} tstrRSSI;
/* This structure is used to support parsing of the received 'N' message */
typedef struct {
WILC_Sint8 s8rssi;
WILC_Uint16 u16CapInfo;
- WILC_Uint8 au8ssid[MAX_SSID_LEN];
- WILC_Uint8 u8SsidLen;
- WILC_Uint8 au8bssid[6];
+ u8 au8ssid[MAX_SSID_LEN];
+ u8 u8SsidLen;
+ u8 au8bssid[6];
WILC_Uint16 u16BeaconPeriod;
- WILC_Uint8 u8DtimPeriod;
- WILC_Uint8 u8channel;
+ u8 u8DtimPeriod;
+ u8 u8channel;
unsigned long u32TimeRcvdInScanCached; /* of type unsigned long to be accepted by the linux kernel macro time_after() */
unsigned long u32TimeRcvdInScan;
WILC_Bool bNewNetwork;
#ifdef AGING_ALG
- WILC_Uint8 u8Found;
+ u8 u8Found;
#endif
#ifdef WILC_P2P
WILC_Uint32 u32Tsf; /* time-stamp [Low only 32 bit] */
#endif
- WILC_Uint8 *pu8IEs;
+ u8 *pu8IEs;
WILC_Uint16 u16IEsLen;
void *pJoinParams;
tstrRSSI strRssi;
WILC_Uint16 u16capability;
WILC_Uint16 u16ConnectStatus;
WILC_Uint16 u16AssocID;
- WILC_Uint8 *pu8RespIEs;
+ u8 *pu8RespIEs;
WILC_Uint16 u16RespIEsLen;
} tstrConnectRespInfo;
typedef struct {
- WILC_Uint8 au8bssid[6];
- WILC_Uint8 *pu8ReqIEs;
+ u8 au8bssid[6];
+ u8 *pu8ReqIEs;
size_t ReqIEsLen;
- WILC_Uint8 *pu8RespIEs;
+ u8 *pu8RespIEs;
WILC_Uint16 u16RespIEsLen;
WILC_Uint16 u16ConnectStatus;
} tstrConnectInfo;
typedef struct {
WILC_Uint16 u16reason;
- WILC_Uint8 *ie;
+ u8 *ie;
size_t ie_len;
} tstrDisconnectNotifInfo;
#ifndef CONNECT_DIRECT
typedef struct wid_site_survey_reslts {
WILC_Char SSID[MAX_SSID_LEN];
- WILC_Uint8 BssType;
- WILC_Uint8 Channel;
- WILC_Uint8 SecurityStatus;
- WILC_Uint8 BSSID[6];
+ u8 BssType;
+ u8 Channel;
+ u8 SecurityStatus;
+ u8 BSSID[6];
WILC_Char RxPower;
- WILC_Uint8 Reserved;
+ u8 Reserved;
} wid_site_survey_reslts_s;
#endif
extern WILC_Sint32 CoreConfiguratorInit(void);
extern WILC_Sint32 CoreConfiguratorDeInit(void);
-extern WILC_Sint32 SendConfigPkt(WILC_Uint8 u8Mode, tstrWID *pstrWIDs,
+extern WILC_Sint32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
WILC_Uint32 u32WIDsCount, WILC_Bool bRespRequired, WILC_Uint32 drvHandler);
-extern WILC_Sint32 ParseNetworkInfo(WILC_Uint8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo);
+extern WILC_Sint32 ParseNetworkInfo(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo);
extern WILC_Sint32 DeallocateNetworkInfo(tstrNetworkInfo *pstrNetworkInfo);
-extern WILC_Sint32 ParseAssocRespInfo(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BufferLen,
+extern WILC_Sint32 ParseAssocRespInfo(u8 *pu8Buffer, WILC_Uint32 u32BufferLen,
tstrConnectRespInfo **ppstrConnectRespInfo);
extern WILC_Sint32 DeallocateAssocRespInfo(tstrConnectRespInfo *pstrConnectRespInfo);
#ifndef CONNECT_DIRECT
-extern WILC_Sint32 ParseSurveyResults(WILC_Uint8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
+extern WILC_Sint32 ParseSurveyResults(u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE],
wid_site_survey_reslts_s **ppstrSurveyResults, WILC_Uint32 *pu32SurveyResultsCount);
extern WILC_Sint32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults);
#endif
extern WILC_Sint32 SendRawPacket(WILC_Sint8 *pspacket, WILC_Sint32 s32PacketLen);
-extern void NetworkInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
-void GnrlAsyncInfoReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
-void host_int_ScanCompleteReceived(WILC_Uint8 *pu8Buffer, WILC_Uint32 u32Length);
+extern void NetworkInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
+void GnrlAsyncInfoReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
+void host_int_ScanCompleteReceived(u8 *pu8Buffer, WILC_Uint32 u32Length);
#endif
return u32Error;
}
-WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BytesToRead, WILC_Uint32 *pu32BytesRead)
+WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, u8 *pu8Buffer, WILC_Uint32 u32BytesToRead, WILC_Uint32 *pu32BytesRead)
{
WILC_Uint32 u32Error = 0;
tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
return u32Error;
}
-WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer, WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite)
+WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, u8 *pu8Buffer, WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite)
{
WILC_Uint32 u32Error = 0;
tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
#define tHANDLE void *
typedef struct {
- WILC_Uint8 *pu8Buffer;
+ u8 *pu8Buffer;
WILC_Uint32 u32BufferLength;
WILC_Uint32 u32WriteOffset;
WILC_Uint32 u32ReadOffset;
extern WILC_Uint32 FIFO_InitBuffer(tHANDLE *hBuffer,
WILC_Uint32 u32BufferLength);
extern WILC_Uint32 FIFO_DeInit(tHANDLE hFifo);
-extern WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer,
+extern WILC_Uint32 FIFO_ReadBytes(tHANDLE hFifo, u8 *pu8Buffer,
WILC_Uint32 u32BytesToRead, WILC_Uint32 *pu32BytesRead);
-extern WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, WILC_Uint8 *pu8Buffer,
- WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite);
\ No newline at end of file
+extern WILC_Uint32 FIFO_WriteBytes(tHANDLE hFifo, u8 *pu8Buffer,
+ WILC_Uint32 u32BytesToWrite, WILC_Bool bForceOverWrite);
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;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
WILC_Bool g_obtainingIP = WILC_FALSE;
#endif
-WILC_Uint8 P2P_LISTEN_STATE;
+u8 P2P_LISTEN_STATE;
static struct task_struct *HostIFthreadHandler;
static WILC_MsgQueueHandle gMsgQHostIF;
static struct semaphore hSemHostIFthrdEnd;
-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;
/**
* @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_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWIDList[32];
- WILC_Uint8 u8WidCnt = 0;
+ u8 u8WidCnt = 0;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
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);
}
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");
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
- WILC_Uint8 u8abort_running_scan;
+ u8 u8abort_running_scan;
tstrWID strWID;
* @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;
+ u8 u8bssDscListIndex;
wid_site_survey_reslts_s *pstrSurveyResults = NULL;
#else
- WILC_Uint8 *pu8CurrByte = 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);
/*
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);
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWIDList[5];
WILC_Uint32 u32WidsCount = 0;
- WILC_Uint8 *pu8CurrByte = 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);
/* 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;
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);
#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;
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;
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;
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) {
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1);
+ pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1);
if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) {
- pu8keybuf = (WILC_Uint8 *)WILC_MALLOC(PTK_KEY_MSG_LEN);
+ pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN);
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;
{
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;
{
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_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;
{
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;
{
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; */
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;
* @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;
* @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;
* @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;
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);
* @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 == 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,
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8Ptk, WILC_Uint8 u8PtkKeylen,
- const u8 *mac_addr, const u8 *pu8RxMic, const u8 *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 == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
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,
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8RxGtk, WILC_Uint8 u8GtkKeylen,
- WILC_Uint8 u8KeyIdx, WILC_Uint32 u32KeyRSClen, const u8 *KeyRSC,
- const u8 *pu8RxMic, const u8 *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 == NULL) {
WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT);
}
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);
* @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;
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);
* @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;
* @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;
* @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_Sint32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8bssid,
const u8 *pu8ssid, size_t ssidLen,
- const WILC_Uint8 *pu8IEs, size_t IEsLen,
+ 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;
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);
}
* @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;
* @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;
* @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;
* @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)
{
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);
* @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)
{
}
/**
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)
{
}
/**
* @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;
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);
* @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;
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);
/**
* @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;
/*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); */
* @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;
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);
}
/**
* @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
/**
* @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
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 == NULL) {
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);
* @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;
* @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;
} cfg_param_t;
typedef struct _tstrStatistics {
- WILC_Uint8 u8LinkSpeed;
+ u8 u8LinkSpeed;
WILC_Sint8 s8RSSI;
WILC_Uint32 u32TxCount;
WILC_Uint32 u32RxCount;
} tenuHostIFstate;
typedef struct _tstrHostIFpmkid {
- WILC_Uint8 bssid[ETH_ALEN];
- WILC_Uint8 pmkid[PMKID_LEN];
+ u8 bssid[ETH_ALEN];
+ u8 pmkid[PMKID_LEN];
} tstrHostIFpmkid;
typedef struct _tstrHostIFpmkidAttr {
- WILC_Uint8 numpmkid;
+ u8 numpmkid;
tstrHostIFpmkid pmkidlist[WILC_MAX_NUM_PMKIDS];
} tstrHostIFpmkidAttr;
#if 0
typedef struct {
WILC_Uint32 u32SetCfgFlag;
- WILC_Uint8 ht_enable;
- WILC_Uint8 bss_type;
- WILC_Uint8 auth_type;
+ u8 ht_enable;
+ u8 bss_type;
+ u8 auth_type;
WILC_Uint16 auth_timeout;
- WILC_Uint8 power_mgmt_mode;
+ u8 power_mgmt_mode;
WILC_Uint16 short_retry_limit;
WILC_Uint16 long_retry_limit;
WILC_Uint16 frag_threshold;
WILC_Uint16 rts_threshold;
WILC_Uint16 preamble_type;
- WILC_Uint8 short_slot_allowed;
- WILC_Uint8 txop_prot_disabled;
+ u8 short_slot_allowed;
+ u8 txop_prot_disabled;
WILC_Uint16 beacon_interval;
WILC_Uint16 dtim_period;
SITE_SURVEY_T site_survey_enabled;
WILC_Uint16 site_survey_scan_time;
- WILC_Uint8 scan_source;
+ u8 scan_source;
WILC_Uint16 active_scan_time;
WILC_Uint16 passive_scan_time;
CURRENT_TX_RATE_T curr_tx_rate;
} tenuCfgParam;
typedef struct {
- WILC_Uint8 au8bssid[6];
+ u8 au8bssid[6];
WILC_Sint8 s8rssi;
} tstrFoundNetworkInfo;
/*Connect callBack function definition*/
typedef void (*tWILCpfConnectResult)(tenuConnDisconnEvent,
tstrConnectInfo *,
- WILC_Uint8,
+ u8,
tstrDisconnectNotifInfo *,
void *);
* @version 1.0
*/
typedef struct _tstrRcvdNetworkInfo {
- WILC_Uint8 *pu8Buffer;
+ u8 *pu8Buffer;
WILC_Uint32 u32Length;
} tstrRcvdNetworkInfo;
/*BugID_4156*/
typedef struct _tstrHiddenNetworkInfo {
- WILC_Uint8 *pu8ssid;
- WILC_Uint8 u8ssidlen;
+ u8 *pu8ssid;
+ u8 u8ssidlen;
} tstrHiddenNetworkInfo;
typedef struct _tstrHiddenNetwork {
/* MAX_SSID_LEN */
tstrHiddenNetworkInfo *pstrHiddenNetworkInfo;
- WILC_Uint8 u8ssidnum;
+ u8 u8ssidnum;
} tstrHiddenNetwork;
} tstrWILC_UsrScanReq;
typedef struct {
- WILC_Uint8 *pu8bssid;
- WILC_Uint8 *pu8ssid;
- WILC_Uint8 u8security;
+ u8 *pu8bssid;
+ u8 *pu8ssid;
+ u8 u8security;
AUTHTYPE_T tenuAuth_type;
size_t ssidLen;
- WILC_Uint8 *pu8ConnReqIEs;
+ u8 *pu8ConnReqIEs;
size_t ConnReqIEsLen;
/* Connect user call back function */
tWILCpfConnectResult pfUserConnectResult;
/*BugID_5077*/
typedef struct {
- WILC_Uint8 u8MacAddress[ETH_ALEN];
+ u8 u8MacAddress[ETH_ALEN];
} tstrHostIfSetMacAddress;
/*BugID_5213*/
typedef struct {
- WILC_Uint8 *u8MacAddress;
+ u8 *u8MacAddress;
} tstrHostIfGetMacAddress;
/*BugID_5222*/
typedef struct {
- WILC_Uint8 au8Bssid[ETH_ALEN];
- WILC_Uint8 u8Ted;
+ u8 au8Bssid[ETH_ALEN];
+ u8 u8Ted;
WILC_Uint16 u16BufferSize;
WILC_Uint16 u16SessionTimeout;
} tstrHostIfBASessionInfo;
WILC_Bool bReg;
WILC_Uint16 u16FrameType;
- WILC_Uint8 u8Regid;
+ u8 u8Regid;
} tstrHostIfRegisterFrame;
#ifdef WILC_P2P
/*Remain on channel struvture*/
tstrHostIfRemainOnChan strHostIfRemainOnChan;
- WILC_Uint8 u8RemainOnChan_pendingreq;
+ u8 u8RemainOnChan_pendingreq;
WILC_Uint64 u64P2p_MgmtTimeout;
- WILC_Uint8 u8P2PConnect;
+ u8 u8P2PConnect;
#endif
tenuHostIFstate enuHostIFstate;
wid_site_survey_reslts_s astrSurveyResults[MAX_NUM_SCANNED_NETWORKS];
#endif
- WILC_Uint8 au8AssociatedBSSID[ETH_ALEN];
+ u8 au8AssociatedBSSID[ETH_ALEN];
tstrCfgParamVal strCfgValues;
/* semaphores */
struct semaphore gtOsCfgValuesSem;
} tenuWILC_StaFlag;
typedef struct {
- WILC_Uint8 au8BSSID[ETH_ALEN];
+ u8 au8BSSID[ETH_ALEN];
WILC_Uint16 u16AssocID;
- WILC_Uint8 u8NumRates;
+ u8 u8NumRates;
const u8 *pu8Rates;
WILC_Bool bIsHTSupported;
WILC_Uint16 u16HTCapInfo;
- WILC_Uint8 u8AmpduParams;
- WILC_Uint8 au8SuppMCsSet[16];
+ u8 u8AmpduParams;
+ u8 au8SuppMCsSet[16];
WILC_Uint16 u16HTExtParams;
WILC_Uint32 u32TxBeamformingCap;
- WILC_Uint8 u8ASELCap;
+ u8 u8ASELCap;
WILC_Uint16 u16FlagsMask; /*<! Determines which of u16FlagsSet were changed>*/
WILC_Uint16 u16FlagsSet; /*<! Decoded according to tenuWILC_StaFlag */
} tstrWILC_AddStaParam;
-/* extern void CfgDisconnected(void* pUserVoid, WILC_Uint16 u16reason, WILC_Uint8 * ie, size_t ie_len); */
+/* extern void CfgDisconnected(void* pUserVoid, WILC_Uint16 u16reason, u8 * ie, size_t ie_len); */
/*****************************************************************************/
/* */
* @date 8 March 2012
* @version 1.0
*/
-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);
/**
* @brief removes WEP key
* @details valid only in BSS STA mode if External Supplicant support is enabled.
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 u8Index);
+WILC_Sint32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, u8 u8Index);
/**
* @brief sets WEP deafault key
* @details Sets the index of the WEP encryption key in use,
* @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);
/**
* @brief sets WEP deafault key
* @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);
/**
* @brief host_int_add_wep_key_bss_ap
* @details valid only in AP mode if External Supplicant support is enabled.
* @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);
/**
* @brief adds ptk Key
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8Ptk, WILC_Uint8 u8PtkKeylen,
- const u8 *mac_addr, const u8 *pu8RxMic, const u8 *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);
/**
* @brief host_int_get_inactive_time
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8RxGtk, WILC_Uint8 u8GtkKeylen,
- WILC_Uint8 u8KeyIdx, WILC_Uint32 u32KeyRSClen, const u8 *KeyRSC,
- const u8 *pu8RxMic, const u8 *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);
/**
* @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);
/**
* @brief caches the pmkid
* @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);
/**
* @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);
/**
* @brief gets the pass phrase
* @details AP/STA mode. This function gets the pass phrase used to
* @version 1.0
*/
WILC_Sint32 host_int_get_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv,
- WILC_Uint8 *pu8PassPhrase, WILC_Uint8 u8Psklength);
+ u8 *pu8PassPhrase, u8 u8Psklength);
/**
* @brief gets mac address
* @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);
/**
* @brief sets mac address
* @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);
/**
* @brief wait until msg q is empty
*/
#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);
#endif
* @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);
/**
* @brief gets scan source of the last scan
* @details
* @date 8 March 2012
* @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);
/**
* @brief sets a join request
* @version 1.0
*/
-WILC_Sint32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8bssid,
+WILC_Sint32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8bssid,
const u8 *pu8ssid, size_t ssidLen,
- const WILC_Uint8 *pu8IEs, size_t IEsLen,
+ 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);
/**
* @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);
/**
* @brief gets a Association request info
* @details
* @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);
/**
* @brief gets a Association Response info
* @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);
/**
* @brief gets a Association Response info
* @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);
/**
* @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);
/**
* @brief gets the current channel index
* @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);
/**
* @brief gets the sta rssi
* @details gets the currently maintained RSSI value for the station.
* @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);
/**
* @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);
/**
* @brief notifies host with stations found in scan
* @version 1.0
*/
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);
/**
* @brief host interface initialization function
/*!
- * @fn WILC_Sint32 host_int_add_beacon(WILC_WFIDrvHandle hWFIDrv,WILC_Uint8 u8Index)
+ * @fn WILC_Sint32 host_int_add_beacon(WILC_WFIDrvHandle hWFIDrv,u8 u8Index)
* @brief Sends a beacon to the firmware to be transmitted over the air
* @details
* @param[in,out] hWFIDrv handle to the wifi driver
*/
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);
/*!
* @date
* @version 1.0
*/
-WILC_Sint32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8IPAddr, WILC_Uint8 idx);
+WILC_Sint32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8IPAddr, u8 idx);
/**
* @date
* @version 1.0
*/
-WILC_Sint32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, WILC_Uint8 *pu8IPAddr, WILC_Uint8 idx);
+WILC_Sint32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8IPAddr, u8 idx);
#ifdef WILC_P2P
/**
#endif
-WILC_Uint8 srcAdd[6];
-WILC_Uint8 bssid[6];
-WILC_Uint8 broadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+u8 srcAdd[6];
+u8 bssid[6];
+u8 broadcast[] = {0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
/**
* @brief WILC_WFI_monitor_rx
* @details
/* struct wilc_wfi_radiotap_cb_hdr *cb_hdr; */
struct tx_complete_mon_data *pv_data = (struct tx_complete_mon_data *)priv;
- WILC_Uint8 *buf = pv_data->buff;
+ u8 *buf = pv_data->buff;
struct wilc_wfi_radiotap_cb_hdr *cb_hdr;
struct tx_complete_mon_data *pv_data = (struct tx_complete_mon_data *)priv;
- WILC_Uint8 *buf = pv_data->buff;
+ u8 *buf = pv_data->buff;
/* len of the original frame without the added pointer at the tail */
WILC_Uint16 u16len = (pv_data->size) - sizeof(struct tx_complete_mon_data *);
/* u8 * mac_add; */
unsigned char mac_add[] = {0x00, 0x50, 0xc2, 0x5e, 0x10, 0x8f};
/* priv = wiphy_priv(priv->dev->ieee80211_ptr->wiphy); */
- /* mac_add = (WILC_Uint8*)WILC_MALLOC(ETH_ALEN); */
+ /* mac_add = (u8*)WILC_MALLOC(ETH_ALEN); */
/* status = host_int_get_MacAddress(priv->hWILCWFIDrv,mac_add); */
/* mac_add[ETH_ALEN-1]+=1; */
memcpy(dev->dev_addr, mac_add, ETH_ALEN);
#endif
extern WILC_Uint16 Set_machw_change_vir_if(WILC_Bool bValue);
extern void resolve_disconnect_aberration(void *drvHandler);
-extern WILC_Uint8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
+extern u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
void wilc1000_wlan_deinit(linux_wlan_t *nic);
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
extern WILC_TimerHandle hDuringIpTimer;
struct WILC_WFI_priv *priv;
tstrWILC_WFIDrv *pstrWFIDrv;
struct net_device *dev;
- WILC_Uint8 *pIP_Add_buff;
+ u8 *pIP_Add_buff;
WILC_Sint32 s32status = WILC_FAIL;
perInterface_wlan_t *nic;
- WILC_Uint8 null_ip[4] = {0};
+ u8 null_ip[4] = {0};
char wlan_dev_name[5] = "wlan0";
if (dev_iface == NULL || dev_iface->ifa_dev == NULL || dev_iface->ifa_dev->dev == NULL) {
int mac_ioctl(struct net_device *ndev, struct ifreq *req, int cmd)
{
- WILC_Uint8 *buff = NULL;
+ u8 *buff = NULL;
WILC_Sint8 rssi;
WILC_Uint32 size = 0, length = 0;
perInterface_wlan_t *nic;
*/
typedef struct {
/* a dummy member to avoid compiler errors*/
- WILC_Uint8 dummy;
+ u8 dummy;
} tstrWILC_MsgQueueAttrs;
#define WILC_OSW_INTERFACE_VER 2
/* Integer Types */
-typedef unsigned char WILC_Uint8;
typedef unsigned short WILC_Uint16;
typedef unsigned int WILC_Uint32;
typedef unsigned long long WILC_Uint64;
* @date 18 Aug 2010
* @version 1.0
*/
-void *WILC_memset(void *pvTarget, WILC_Uint8 u8SetValue, WILC_Uint32 u32Count)
+void *WILC_memset(void *pvTarget, u8 u8SetValue, WILC_Uint32 u32Count)
{
return memset(pvTarget, u8SetValue, u32Count);
}
static WILC_ErrNo WILC_memcpy(void *pvTarget, const void *pvSource, WILC_Uint32 u32Count)
{
if (
- (((WILC_Uint8 *)pvTarget <= (WILC_Uint8 *)pvSource)
- && (((WILC_Uint8 *)pvTarget + u32Count) > (WILC_Uint8 *)pvSource))
+ (((u8 *)pvTarget <= (u8 *)pvSource)
+ && (((u8 *)pvTarget + u32Count) > (u8 *)pvSource))
- || (((WILC_Uint8 *)pvSource <= (WILC_Uint8 *)pvTarget)
- && (((WILC_Uint8 *)pvSource + u32Count) > (WILC_Uint8 *)pvTarget))
+ || (((u8 *)pvSource <= (u8 *)pvTarget)
+ && (((u8 *)pvSource + u32Count) > (u8 *)pvTarget))
) {
/* ovelapped memory, return Error */
return WILC_FAIL;
* @date 18 Aug 2010
* @version 1.0
*/
-void *WILC_memset(void *pvTarget, WILC_Uint8 u8SetValue, WILC_Uint32 u32Count);
+void *WILC_memset(void *pvTarget, u8 u8SetValue, WILC_Uint32 u32Count);
/*!
* @brief copies the contents of source string into the target string
*/
typedef struct {
/* a dummy member to avoid compiler errors*/
- WILC_Uint8 dummy;
+ u8 dummy;
} tstrWILC_TimerAttrs;
/*!
WILC_TimerHandle hDuringIpTimer;
#endif
WILC_TimerHandle hAgingTimer;
-static WILC_Uint8 op_ifcs;
-extern WILC_Uint8 u8ConnectedSSID[6];
+static u8 op_ifcs;
+extern u8 u8ConnectedSSID[6];
/*BugID_5137*/
-WILC_Uint8 g_wilc_initialized = 1;
+u8 g_wilc_initialized = 1;
extern linux_wlan_t *g_linux_wlan;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
extern WILC_Bool g_obtainingIP;
};
/*Global variable used to state the current connected STA channel*/
-WILC_Uint8 u8WLANChannel = INVALID_CHANNEL;
+u8 u8WLANChannel = INVALID_CHANNEL;
/*BugID_5442*/
-WILC_Uint8 u8CurrChannel;
+u8 u8CurrChannel;
-WILC_Uint8 u8P2P_oui[] = {0x50, 0x6f, 0x9A, 0x09};
-WILC_Uint8 u8P2Plocalrandom = 0x01;
-WILC_Uint8 u8P2Precvrandom = 0x00;
-WILC_Uint8 u8P2P_vendorspec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
+u8 u8P2P_oui[] = {0x50, 0x6f, 0x9A, 0x09};
+u8 u8P2Plocalrandom = 0x01;
+u8 u8P2Precvrandom = 0x00;
+u8 u8P2P_vendorspec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
WILC_Bool bWilc_ie = WILC_FALSE;
#endif
struct add_key_params g_add_ptk_key_params;
struct wilc_wfi_key g_key_ptk_params;
struct wilc_wfi_wep_key g_key_wep_params;
-WILC_Uint8 g_flushing_in_progress;
+u8 g_flushing_in_progress;
WILC_Bool g_ptk_keys_saved = WILC_FALSE;
WILC_Bool g_gtk_keys_saved = WILC_FALSE;
WILC_Bool g_wep_keys_saved = WILC_FALSE;
if (ap_found != -1)
WILC_FREE(astrLastScannedNtwrksShadow[ap_index].pu8IEs);
astrLastScannedNtwrksShadow[ap_index].pu8IEs =
- (WILC_Uint8 *)WILC_MALLOC(pstrNetworkInfo->u16IEsLen); /* will be deallocated by the WILC_WFI_CfgScan() function */
+ (u8 *)WILC_MALLOC(pstrNetworkInfo->u16IEsLen); /* will be deallocated by the WILC_WFI_CfgScan() function */
WILC_memcpy(astrLastScannedNtwrksShadow[ap_index].pu8IEs,
pstrNetworkInfo->pu8IEs, pstrNetworkInfo->u16IEsLen);
* @date 01 MAR 2012
* @version 1.0
*/
-int WILC_WFI_Set_PMKSA(WILC_Uint8 *bssid, struct WILC_WFI_priv *priv)
+int WILC_WFI_Set_PMKSA(u8 *bssid, struct WILC_WFI_priv *priv)
{
WILC_Uint32 i;
WILC_Sint32 s32Error = WILC_SUCCESS;
* @param[in] tenuConnDisconnEvent enuConnDisconnEvent: Type of connection response either
* connection response or disconnection notification.
* tstrConnectInfo* pstrConnectInfo: COnnection information.
- * WILC_Uint8 u8MacStatus: Mac Status from firmware
+ * u8 u8MacStatus: Mac Status from firmware
* tstrDisconnectNotifInfo* pstrDisconnectNotifInfo: Disconnection Notification
* void* pUserVoid: Private data associated with wireless interface
* @return NONE
static void CfgConnectResult(tenuConnDisconnEvent enuConnDisconnEvent,
tstrConnectInfo *pstrConnectInfo,
- WILC_Uint8 u8MacStatus,
+ u8 u8MacStatus,
tstrDisconnectNotifInfo *pstrDisconnectNotifInfo,
void *pUserVoid)
{
#ifdef WILC_P2P
tstrWILC_WFIDrv *pstrWFIDrv;
#endif
- WILC_Uint8 NullBssid[ETH_ALEN] = {0};
+ u8 NullBssid[ETH_ALEN] = {0};
connecting = 0;
priv = (struct WILC_WFI_priv *)pUserVoid;
struct WILC_WFI_priv *priv;
WILC_Uint32 i;
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];
+ u8 au8ScanChanList[MAX_NUM_SCANNED_NETWORKS];
tstrHiddenNetwork strHiddenNetwork;
priv = wiphy_priv(wiphy);
if (request->n_channels <= MAX_NUM_SCANNED_NETWORKS) { /* TODO: mostafa: to be replaced by */
/* max_scan_ssids */
for (i = 0; i < request->n_channels; i++) {
- au8ScanChanList[i] = (WILC_Uint8)ieee80211_frequency_to_channel(request->channels[i]->center_freq);
+ au8ScanChanList[i] = (u8)ieee80211_frequency_to_channel(request->channels[i]->center_freq);
PRINT_INFO(CFG80211_DBG, "ScanChannel List[%d] = %d,", i, au8ScanChanList[i]);
}
PRINT_D(CFG80211_DBG, "Trigger Scan Request \n");
s32Error = host_int_scan(priv->hWILCWFIDrv, USER_SCAN, ACTIVE_SCAN,
au8ScanChanList, request->n_channels,
- (const WILC_Uint8 *)request->ie, request->ie_len,
+ (const u8 *)request->ie, request->ie_len,
CfgScanResult, (void *)priv, &strHiddenNetwork);
} else {
PRINT_D(CFG80211_DBG, "Trigger Scan Request \n");
s32Error = host_int_scan(priv->hWILCWFIDrv, USER_SCAN, ACTIVE_SCAN,
au8ScanChanList, request->n_channels,
- (const WILC_Uint8 *)request->ie, request->ie_len,
+ (const u8 *)request->ie, request->ie_len,
CfgScanResult, (void *)priv, NULL);
}
WILC_Sint32 s32Error = WILC_SUCCESS;
WILC_Uint32 i;
/* SECURITY_T tenuSecurity_t = NO_SECURITY; */
- WILC_Uint8 u8security = NO_ENCRYPT;
+ u8 u8security = NO_ENCRYPT;
AUTHTYPE_T tenuAuth_type = ANY;
WILC_Char *pcgroup_encrypt_val;
WILC_Char *pccipher_group;
struct WILC_WFI_priv *priv;
const u8 *pu8RxMic = NULL;
const u8 *pu8TxMic = NULL;
- WILC_Uint8 u8mode = NO_ENCRYPT;
+ u8 u8mode = NO_ENCRYPT;
#ifdef WILC_AP_EXTERNAL_MLME
- WILC_Uint8 u8gmode = NO_ENCRYPT;
- WILC_Uint8 u8pmode = NO_ENCRYPT;
+ u8 u8gmode = NO_ENCRYPT;
+ u8 u8pmode = NO_ENCRYPT;
AUTHTYPE_T tenuAuth_type = ANY;
#endif
if (priv->wilc_gtk[key_index]->key)
WILC_FREE(priv->wilc_gtk[key_index]->key);
- priv->wilc_gtk[key_index]->key = (WILC_Uint8 *)WILC_MALLOC(params->key_len);
+ priv->wilc_gtk[key_index]->key = (u8 *)WILC_MALLOC(params->key_len);
WILC_memcpy(priv->wilc_gtk[key_index]->key, params->key, params->key_len);
/* if there has been previous allocation for the same index through its seq, free that memory and allocate again*/
WILC_FREE(priv->wilc_gtk[key_index]->seq);
if ((params->seq_len) > 0) {
- priv->wilc_gtk[key_index]->seq = (WILC_Uint8 *)WILC_MALLOC(params->seq_len);
+ priv->wilc_gtk[key_index]->seq = (u8 *)WILC_MALLOC(params->seq_len);
WILC_memcpy(priv->wilc_gtk[key_index]->seq, params->seq, params->seq_len);
}
if (priv->wilc_ptk[key_index]->key)
WILC_FREE(priv->wilc_ptk[key_index]->key);
- priv->wilc_ptk[key_index]->key = (WILC_Uint8 *)WILC_MALLOC(params->key_len);
+ priv->wilc_ptk[key_index]->key = (u8 *)WILC_MALLOC(params->key_len);
if (priv->wilc_ptk[key_index]->seq)
WILC_FREE(priv->wilc_ptk[key_index]->seq);
if ((params->seq_len) > 0)
- priv->wilc_ptk[key_index]->seq = (WILC_Uint8 *)WILC_MALLOC(params->seq_len);
+ priv->wilc_ptk[key_index]->seq = (u8 *)WILC_MALLOC(params->seq_len);
if (INFO) {
for (i = 0; i < params->key_len; i++)
{
WILC_Uint32 i;
WILC_Sint32 s32Error = WILC_SUCCESS;
- WILC_Uint8 flag = 0;
+ u8 flag = 0;
struct WILC_WFI_priv *priv = wiphy_priv(wiphy);
{
WILC_Uint32 i;
- WILC_Uint8 flag = 0;
+ u8 flag = 0;
WILC_Sint32 s32Error = WILC_SUCCESS;
struct WILC_WFI_priv *priv = wiphy_priv(wiphy);
* @version
*/
-void WILC_WFI_CfgParseRxAction(WILC_Uint8 *buf, WILC_Uint32 len)
+void WILC_WFI_CfgParseRxAction(u8 *buf, WILC_Uint32 len)
{
WILC_Uint32 index = 0;
WILC_Uint32 i = 0, j = 0;
/*BugID_5460*/
#ifdef USE_SUPPLICANT_GO_INTENT
- WILC_Uint8 intent;
- WILC_Uint8 tie_breaker;
+ u8 intent;
+ u8 tie_breaker;
WILC_Bool is_wilc_go = WILC_TRUE;
#endif
- WILC_Uint8 op_channel_attr_index = 0;
- WILC_Uint8 channel_list_attr_index = 0;
+ u8 op_channel_attr_index = 0;
+ u8 channel_list_attr_index = 0;
while (index < len) {
if (buf[index] == GO_INTENT_ATTR_ID) {
* @date 12 DEC 2012
* @version
*/
-void WILC_WFI_CfgParseTxAction(WILC_Uint8 *buf, WILC_Uint32 len, WILC_Bool bOperChan, WILC_Uint8 iftype)
+void WILC_WFI_CfgParseTxAction(u8 *buf, WILC_Uint32 len, WILC_Bool bOperChan, u8 iftype)
{
WILC_Uint32 index = 0;
WILC_Uint32 i = 0, j = 0;
- WILC_Uint8 op_channel_attr_index = 0;
- WILC_Uint8 channel_list_attr_index = 0;
+ u8 op_channel_attr_index = 0;
+ u8 channel_list_attr_index = 0;
#ifdef USE_SUPPLICANT_GO_INTENT
WILC_Bool is_wilc_go = WILC_FALSE;
* @brief WILC_WFI_add_wilcvendorspec
* @details Adding WILC information elemet to allow two WILC devices to
* identify each other and connect
- * @param[in] WILC_Uint8 * buf
+ * @param[in] u8 * buf
* @return void
* @author mdaftedar
* @date 01 JAN 2014
* @version 1.0
*/
-void WILC_WFI_add_wilcvendorspec(WILC_Uint8 *buff)
+void WILC_WFI_add_wilcvendorspec(u8 *buff)
{
WILC_memcpy(buff, u8P2P_vendorspec, sizeof(u8P2P_vendorspec));
}
struct WILC_WFI_priv *priv;
/* struct WILC_WFI_mon_priv* mon_priv; */
perInterface_wlan_t *nic;
- WILC_Uint8 interface_type;
+ u8 interface_type;
WILC_Uint16 TID = 0;
#ifdef WILC_P2P
- WILC_Uint8 i;
+ u8 i;
#endif
nic = netdev_priv(dev);
s32Error = host_int_add_beacon(priv->hWILCWFIDrv,
settings->beacon_interval,
settings->dtim_period,
- beacon->head_len, (WILC_Uint8 *)beacon->head,
- beacon->tail_len, (WILC_Uint8 *)beacon->tail);
+ beacon->head_len, (u8 *)beacon->head,
+ beacon->tail_len, (u8 *)beacon->tail);
#else
s32Error = host_add_beacon(priv->hWILCWFIDrv,
settings->beacon_interval,
settings->dtim_period,
- beacon->head_len, (WILC_Uint8 *)beacon->head,
- beacon->tail_len, (WILC_Uint8 *)beacon->tail);
+ beacon->head_len, (u8 *)beacon->head,
+ beacon->tail_len, (u8 *)beacon->tail);
#endif
return s32Error;
s32Error = host_int_add_beacon(priv->hWILCWFIDrv,
0,
0,
- beacon->head_len, (WILC_Uint8 *)beacon->head,
- beacon->tail_len, (WILC_Uint8 *)beacon->tail);
+ beacon->head_len, (u8 *)beacon->head,
+ beacon->tail_len, (u8 *)beacon->tail);
#else
s32Error = host_add_beacon(priv->hWILCWFIDrv,
0,
0,
- beacon->head_len, (WILC_Uint8 *)beacon->head,
- beacon->tail_len, (WILC_Uint8 *)beacon->tail);
+ beacon->head_len, (u8 *)beacon->head,
+ beacon->tail_len, (u8 *)beacon->tail);
#endif
return s32Error;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
struct WILC_WFI_priv *priv;
- WILC_Uint8 NullBssid[ETH_ALEN] = {0};
+ u8 NullBssid[ETH_ALEN] = {0};
WILC_NULLCHECK(s32Error, wiphy);
};
struct sta_info {
- WILC_Uint8 au8Sta_AssociatedBss[MAX_NUM_STA][ETH_ALEN];
+ u8 au8Sta_AssociatedBss[MAX_NUM_STA][ETH_ALEN];
};
#ifdef WILC_P2P
- WILC_Uint8 au8AssociatedBss[ETH_ALEN];
+ u8 au8AssociatedBss[ETH_ALEN];
struct sta_info assoc_stainfo;
struct net_device_stats stats;
- WILC_Uint8 monitor_flag;
+ u8 monitor_flag;
int status;
struct WILC_WFI_packet *ppool;
struct WILC_WFI_packet *rx_queue; /* List of incoming packets */
WILC_WFIDrvHandle hWILCWFIDrv_2;
tstrHostIFpmkidAttr pmkid_list;
struct WILC_WFI_stats netstats;
- WILC_Uint8 WILC_WFI_wep_default;
- WILC_Uint8 WILC_WFI_wep_key[4][WLAN_KEY_LEN_WEP104];
- WILC_Uint8 WILC_WFI_wep_key_len[4];
+ u8 WILC_WFI_wep_default;
+ u8 WILC_WFI_wep_key[4][WLAN_KEY_LEN_WEP104];
+ u8 WILC_WFI_wep_key_len[4];
struct net_device *real_ndev; /* The real interface that the monitor is on */
struct wilc_wfi_key *wilc_gtk[MAX_NUM_STA];
struct wilc_wfi_key *wilc_ptk[MAX_NUM_STA];
- WILC_Uint8 wilc_groupkey;
+ u8 wilc_groupkey;
/* semaphores */
struct semaphore SemHandleUpdateStats;
struct semaphore hSemScanReq;
typedef struct {
uint8_t u8IfIdx;
- WILC_Uint8 iftype;
+ u8 iftype;
int monitor_flag;
int mac_opened;
#ifdef WILC_P2P
extern wilc_hif_func_t hif_spi;
extern wilc_cfg_func_t mac_cfg;
#if defined(PLAT_RK3026_TCHIP)
-extern WILC_Uint8 g_wilc_initialized; /* AMR : 0422 RK3026 Crash issue */
+extern u8 g_wilc_initialized; /* AMR : 0422 RK3026 Crash issue */
#endif
extern void WILC_WFI_mgmt_rx(uint8_t *buff, uint32_t size);
extern void frmw_to_linux(uint8_t *buff, uint32_t size);
projects / openwrt / staging / blogic.git / commitdiff