Use s8 instead of WILC_Sint8.
Signed-off-by: Chaehyun Lim <chaehyun.lim@gmail.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
/*****************************************************************************/
/* Extern Function Declarations */
/*****************************************************************************/
/*****************************************************************************/
/* Extern Function Declarations */
/*****************************************************************************/
-extern WILC_Sint32 SendRawPacket(WILC_Sint8 *ps8Packet, WILC_Sint32 s32PacketLen);
+extern WILC_Sint32 SendRawPacket(s8 *ps8Packet, WILC_Sint32 s32PacketLen);
extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
extern void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
extern void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
extern void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
extern void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
static struct semaphore SemHandleSendPkt;
static struct semaphore SemHandlePktResp;
static struct semaphore SemHandleSendPkt;
static struct semaphore SemHandlePktResp;
-static WILC_Sint8 *gps8ConfigPacket;
+static s8 *gps8ConfigPacket;
static tstrConfigPktInfo gstrConfigPktInfo;
static tstrConfigPktInfo gstrConfigPktInfo;
sema_init(&SemHandleSendPkt, 1);
sema_init(&SemHandlePktResp, 0);
sema_init(&SemHandleSendPkt, 1);
sema_init(&SemHandlePktResp, 0);
- gps8ConfigPacket = (WILC_Sint8 *)WILC_MALLOC(MAX_PACKET_BUFF_SIZE);
+ gps8ConfigPacket = (s8 *)WILC_MALLOC(MAX_PACKET_BUFF_SIZE);
if (gps8ConfigPacket == NULL) {
PRINT_ER("failed in gps8ConfigPacket allocation\n");
s32Error = WILC_NO_MEM;
if (gps8ConfigPacket == NULL) {
PRINT_ER("failed in gps8ConfigPacket allocation\n");
s32Error = WILC_NO_MEM;
/*****************************************************************************/
void ProcessCharWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
/*****************************************************************************/
void ProcessCharWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
+ tstrWID *pstrWID, s8 *ps8WidVal)
{
u8 *pu8val = (u8 *)ps8WidVal;
u8 u8val = 0;
{
u8 *pu8val = (u8 *)ps8WidVal;
u8 u8val = 0;
/*****************************************************************************/
void ProcessShortWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
/*****************************************************************************/
void ProcessShortWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
+ tstrWID *pstrWID, s8 *ps8WidVal)
{
u16 *pu16val = (u16 *)ps8WidVal;
u16 u16val = 0;
{
u16 *pu16val = (u16 *)ps8WidVal;
u16 u16val = 0;
/*****************************************************************************/
void ProcessIntWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
/*****************************************************************************/
void ProcessIntWid(WILC_Char *pcPacket, WILC_Sint32 *ps32PktLen,
- tstrWID *pstrWID, WILC_Sint8 *ps8WidVal)
+ tstrWID *pstrWID, s8 *ps8WidVal)
{
u32 *pu32val = (u32 *)ps8WidVal;
u32 u32val = 0;
{
u32 *pu32val = (u32 *)ps8WidVal;
u32 u32val = 0;
u16 *pu16val = (u16 *)(pstrWIDresult->ps8WidVal);
cfg_sht = MAKE_WORD16(resp[idx], resp[idx + 1]);
/*Set local copy of WID*/
u16 *pu16val = (u16 *)(pstrWIDresult->ps8WidVal);
cfg_sht = MAKE_WORD16(resp[idx], resp[idx + 1]);
/*Set local copy of WID*/
- /* pstrWIDresult->ps8WidVal = (WILC_Sint8*)(WILC_Sint32)cfg_sht; */
+ /* pstrWIDresult->ps8WidVal = (s8*)(WILC_Sint32)cfg_sht; */
*pu16val = cfg_sht;
break;
}
*pu16val = cfg_sht;
break;
}
MAKE_WORD16(resp[idx + 2], resp[idx + 3])
);
/*Set local copy of WID*/
MAKE_WORD16(resp[idx + 2], resp[idx + 3])
);
/*Set local copy of WID*/
- /* pstrWIDresult->ps8WidVal = (WILC_Sint8*)cfg_int; */
+ /* pstrWIDresult->ps8WidVal = (s8*)cfg_int; */
*pu32val = cfg_int;
break;
}
*pu32val = cfg_int;
break;
}
-WILC_Sint32 CreateConfigPacket(WILC_Sint8 *ps8packet, WILC_Sint32 *ps32PacketLength,
+WILC_Sint32 CreateConfigPacket(s8 *ps8packet, WILC_Sint32 *ps32PacketLength,
tstrWID *pstrWIDs, u32 u32WIDsCount)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID *pstrWIDs, u32 u32WIDsCount)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
u16 u16WIDid;
tenuWIDtype enuWIDtype;
WILC_Sint32 s32ValueSize;
u16 u16WIDid;
tenuWIDtype enuWIDtype;
WILC_Sint32 s32ValueSize;
} tstrWID;
typedef struct {
u8 u8Full;
u8 u8Index;
} tstrWID;
typedef struct {
u8 u8Full;
u8 u8Index;
- WILC_Sint8 as8RSSI[NUM_RSSI];
} tstrRSSI;
/* This structure is used to support parsing of the received 'N' message */
typedef struct {
} tstrRSSI;
/* This structure is used to support parsing of the received 'N' message */
typedef struct {
u16 u16CapInfo;
u8 au8ssid[MAX_SSID_LEN];
u8 u8SsidLen;
u16 u16CapInfo;
u8 au8ssid[MAX_SSID_LEN];
u8 u8SsidLen;
extern WILC_Sint32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults);
#endif
extern WILC_Sint32 DeallocateSurveyResults(wid_site_survey_reslts_s *pstrSurveyResults);
#endif
-extern WILC_Sint32 SendRawPacket(WILC_Sint8 *pspacket, WILC_Sint32 s32PacketLen);
+extern WILC_Sint32 SendRawPacket(s8 *pspacket, WILC_Sint32 s32PacketLen);
extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
extern void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length);
void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length);
void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length);
WILC_Bool gbScanWhileConnected = WILC_FALSE;
WILC_Bool gbScanWhileConnected = WILC_FALSE;
-static WILC_Sint8 gs8Rssi;
-static WILC_Sint8 gs8lnkspd;
+static s8 gs8Rssi;
+static s8 gs8lnkspd;
static u8 gu8Chnl;
static u8 gs8SetIP[2][4];
static u8 gs8GetIP[2][4];
static u8 gu8Chnl;
static u8 gs8SetIP[2][4];
static u8 gs8GetIP[2][4];
/*prepare configuration packet*/
strWID.u16WIDid = (u16)WID_SET_DRV_HANDLER;
strWID.enuWIDtype = WID_INT;
/*prepare configuration packet*/
strWID.u16WIDid = (u16)WID_SET_DRV_HANDLER;
strWID.enuWIDtype = WID_INT;
- strWID.ps8WidVal = (WILC_Sint8 *)&(pstrHostIfSetDrvHandler->u32Address);
+ strWID.ps8WidVal = (s8 *)&(pstrHostIfSetDrvHandler->u32Address);
strWID.s32ValueSize = sizeof(u32);
/*Sending Cfg*/
strWID.s32ValueSize = sizeof(u32);
/*Sending Cfg*/
/*prepare configuration packet*/
strWID.u16WIDid = (u16)WID_SET_OPERATION_MODE;
strWID.enuWIDtype = WID_INT;
/*prepare configuration packet*/
strWID.u16WIDid = (u16)WID_SET_OPERATION_MODE;
strWID.enuWIDtype = WID_INT;
- strWID.ps8WidVal = (WILC_Sint8 *)&(pstrHostIfSetOperationMode->u32Mode);
+ strWID.ps8WidVal = (s8 *)&(pstrHostIfSetOperationMode->u32Mode);
strWID.s32ValueSize = sizeof(u32);
/*Sending Cfg*/
strWID.s32ValueSize = sizeof(u32);
/*Sending Cfg*/
/* validate input then copy>> need to check value 4 and 5 */
if (strHostIFCfgParamAttr->pstrCfgParamVal.bss_type < 6) {
strWIDList[u8WidCnt].u16WIDid = WID_BSS_TYPE;
/* validate input then copy>> need to check value 4 and 5 */
if (strHostIFCfgParamAttr->pstrCfgParamVal.bss_type < 6) {
strWIDList[u8WidCnt].u16WIDid = WID_BSS_TYPE;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type;
/*validate Possible values*/
if ((strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 1 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 2 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 5) {
strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TYPE;
/*validate Possible values*/
if ((strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 1 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 2 || (strHostIFCfgParamAttr->pstrCfgParamVal.auth_type) == 5) {
strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TYPE;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TIMEOUT;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_AUTH_TIMEOUT;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout;
/*----------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode < 5) {
strWIDList[u8WidCnt].u16WIDid = WID_POWER_MANAGEMENT;
/*----------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode < 5) {
strWIDList[u8WidCnt].u16WIDid = WID_POWER_MANAGEMENT;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode;
/* range from 1 to 256 */
if ((strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit < 256)) {
strWIDList[u8WidCnt].u16WIDid = WID_SHORT_RETRY_LIMIT;
/* range from 1 to 256 */
if ((strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit < 256)) {
strWIDList[u8WidCnt].u16WIDid = WID_SHORT_RETRY_LIMIT;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.short_retry_limit = strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.short_retry_limit = strHostIFCfgParamAttr->pstrCfgParamVal.short_retry_limit;
/* range from 1 to 256 */
if ((strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit < 256)) {
strWIDList[u8WidCnt].u16WIDid = WID_LONG_RETRY_LIMIT;
/* range from 1 to 256 */
if ((strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit > 0) && (strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit < 256)) {
strWIDList[u8WidCnt].u16WIDid = WID_LONG_RETRY_LIMIT;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
if (strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold < 7937) {
strWIDList[u8WidCnt].u16WIDid = WID_FRAG_THRESHOLD;
if (strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold < 7937) {
strWIDList[u8WidCnt].u16WIDid = WID_FRAG_THRESHOLD;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.frag_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.frag_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold;
/* range 256 to 65535 */
if (strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_RTS_THRESHOLD;
/* range 256 to 65535 */
if (strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_RTS_THRESHOLD;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold;
/*------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type < 3) {
strWIDList[u8WidCnt].u16WIDid = WID_PREAMBLE;
/*------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type < 3) {
strWIDList[u8WidCnt].u16WIDid = WID_PREAMBLE;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.preamble_type = strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.preamble_type = strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type;
if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SHORT_SLOT_ALLOWED) {
if (strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed < 2) {
strWIDList[u8WidCnt].u16WIDid = WID_SHORT_SLOT_ALLOWED;
if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SHORT_SLOT_ALLOWED) {
if (strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed < 2) {
strWIDList[u8WidCnt].u16WIDid = WID_SHORT_SLOT_ALLOWED;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed;
/*Input Values: 1 for enable and 0 for disable. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled < 2) {
strWIDList[u8WidCnt].u16WIDid = WID_11N_TXOP_PROT_DISABLE;
/*Input Values: 1 for enable and 0 for disable. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled < 2) {
strWIDList[u8WidCnt].u16WIDid = WID_11N_TXOP_PROT_DISABLE;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_BEACON_INTERVAL;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_BEACON_INTERVAL;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval;
/* range is 1 to 255. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period < 256) {
strWIDList[u8WidCnt].u16WIDid = WID_DTIM_PERIOD;
/* range is 1 to 255. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period < 256) {
strWIDList[u8WidCnt].u16WIDid = WID_DTIM_PERIOD;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.dtim_period = strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.dtim_period = strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period;
/*----------------------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled < 3) {
strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY;
/*----------------------------------------------------------------------*/
if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled < 3) {
strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
strWIDList[u8WidCnt].enuWIDtype = WID_CHAR;
strWIDList[u8WidCnt].s32ValueSize = sizeof(WILC_Char);
pstrWFIDrv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY_SCAN_TIME;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY_SCAN_TIME;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.site_survey_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.site_survey_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_scan_time;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_ACTIVE_SCAN_TIME;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_ACTIVE_SCAN_TIME;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.active_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.active_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.active_scan_time;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_PASSIVE_SCAN_TIME;
/* range is 1 to 65535. */
if (strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time > 0 && strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time < 65536) {
strWIDList[u8WidCnt].u16WIDid = WID_PASSIVE_SCAN_TIME;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.passive_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.passive_scan_time = strHostIFCfgParamAttr->pstrCfgParamVal.passive_scan_time;
|| curr_tx_rate == MBPS_18 || curr_tx_rate == MBPS_24
|| curr_tx_rate == MBPS_36 || curr_tx_rate == MBPS_48 || curr_tx_rate == MBPS_54) {
strWIDList[u8WidCnt].u16WIDid = WID_CURRENT_TX_RATE;
|| curr_tx_rate == MBPS_18 || curr_tx_rate == MBPS_24
|| curr_tx_rate == MBPS_36 || curr_tx_rate == MBPS_48 || curr_tx_rate == MBPS_54) {
strWIDList[u8WidCnt].u16WIDid = WID_CURRENT_TX_RATE;
- strWIDList[u8WidCnt].ps8WidVal = (WILC_Sint8 *)&curr_tx_rate;
+ strWIDList[u8WidCnt].ps8WidVal = (s8 *)&curr_tx_rate;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
strWIDList[u8WidCnt].enuWIDtype = WID_SHORT;
strWIDList[u8WidCnt].s32ValueSize = sizeof(u16);
pstrWFIDrv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate;
strWIDList[u32WidsCount].u16WIDid = WID_SCAN_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = WID_SCAN_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFscanAttr->u8ScanType));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanType));
u32WidsCount++;
/*list of channels to be scanned*/
u32WidsCount++;
/*list of channels to be scanned*/
strWIDList[u32WidsCount].u16WIDid = WID_START_SCAN_REQ;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = WID_START_SCAN_REQ;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFscanAttr->u8ScanSource));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanSource));
u32WidsCount++;
/*keep the state as is , no need to change it*/
u32WidsCount++;
/*keep the state as is , no need to change it*/
u8abort_running_scan = 1;
strWID.u16WIDid = (u16)WID_ABORT_RUNNING_SCAN;
strWID.enuWIDtype = WID_CHAR;
u8abort_running_scan = 1;
strWID.u16WIDid = (u16)WID_ABORT_RUNNING_SCAN;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&u8abort_running_scan;
+ strWID.ps8WidVal = (s8 *)&u8abort_running_scan;
strWID.s32ValueSize = sizeof(WILC_Char);
/*Sending Cfg*/
strWID.s32ValueSize = sizeof(WILC_Char);
/*Sending Cfg*/
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
u32WidsCount++;
PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", pstrWFIDrv->strWILC_UsrConnReq.u8security);
u32WidsCount++;
PRINT_INFO(HOSTINF_DBG, "Encrypt Mode = %x\n", pstrWFIDrv->strWILC_UsrConnReq.u8security);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
u32WidsCount++;
PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
u32WidsCount++;
PRINT_INFO(HOSTINF_DBG, "Authentication Type = %x\n", pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
* strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
* strWIDList[u32WidsCount].enuWIDtype = WID_STR;
* strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
* strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
* strWIDList[u32WidsCount].enuWIDtype = WID_STR;
* strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
- * strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8*)(passphrase);
+ * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
* u32WidsCount++;
*/
strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
* u32WidsCount++;
*/
strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)&u8bssDscListIndex;
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)&u8bssDscListIndex;
u32WidsCount++;
#ifndef SIMULATION
u32WidsCount++;
#ifndef SIMULATION
strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(dummyval));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(dummyval));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(dummyval));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval));
u32WidsCount++;
/* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
u32WidsCount++;
/* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security));
u32WidsCount++;
/*BugID_5137*/
u32WidsCount++;
/*BugID_5137*/
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type);
u32WidsCount++;
/*BugID_5137*/
u32WidsCount++;
/*BugID_5137*/
* strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
* strWIDList[u32WidsCount].enuWIDtype = WID_STR;
* strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
* strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_PSK;
* strWIDList[u32WidsCount].enuWIDtype = WID_STR;
* strWIDList[u32WidsCount].s32ValueSize = sizeof(passphrase);
- * strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8*)(passphrase);
+ * strWIDList[u32WidsCount].ps8WidVal = (s8*)(passphrase);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(gu8Flushed11iMode));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(gu8Flushed11iMode));
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&gu8FlushedAuthType);
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&gu8FlushedAuthType);
strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED;
strWIDList[u32WidsCount].enuWIDtype = WID_STR;
strWIDList[u32WidsCount].s32ValueSize = gu32FlushedJoinReqSize;
strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED;
strWIDList[u32WidsCount].enuWIDtype = WID_STR;
strWIDList[u32WidsCount].s32ValueSize = gu32FlushedJoinReqSize;
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)gu8FlushedJoinReq;
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)gu8FlushedJoinReq;
pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
pu8CurrByte += FLUSHED_BYTE_POS;
pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal;
pu8CurrByte += FLUSHED_BYTE_POS;
* WID_DISCONNECT} */
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
* WID_DISCONNECT} */
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&u16DummyReasonCode;
+ strWID.ps8WidVal = (s8 *)&u16DummyReasonCode;
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
#endif
u8 i;
u8 *pu8keybuf;
#endif
u8 i;
u8 *pu8keybuf;
- WILC_Sint8 s8idxarray[1];
- WILC_Sint8 ret = 0;
+ s8 s8idxarray[1];
+ s8 ret = 0;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
- strWIDList[0].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8mode));
+ strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8mode));
strWIDList[1].u16WIDid = WID_AUTH_TYPE;
strWIDList[1].enuWIDtype = WID_CHAR;
strWIDList[1].s32ValueSize = sizeof(WILC_Char);
strWIDList[1].u16WIDid = WID_AUTH_TYPE;
strWIDList[1].enuWIDtype = WID_CHAR;
strWIDList[1].s32ValueSize = sizeof(WILC_Char);
- strWIDList[1].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type));
+ strWIDList[1].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type));
strWIDList[2].u16WIDid = (u16)WID_KEY_ID;
strWIDList[2].enuWIDtype = WID_CHAR;
strWIDList[2].u16WIDid = (u16)WID_KEY_ID;
strWIDList[2].enuWIDtype = WID_CHAR;
- strWIDList[2].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
+ strWIDList[2].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
strWIDList[2].s32ValueSize = sizeof(WILC_Char);
strWIDList[2].s32ValueSize = sizeof(WILC_Char);
strWIDList[3].u16WIDid = (u16)WID_WEP_KEY_VALUE;
strWIDList[3].enuWIDtype = WID_STR;
strWIDList[3].s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen;
strWIDList[3].u16WIDid = (u16)WID_WEP_KEY_VALUE;
strWIDList[3].enuWIDtype = WID_STR;
strWIDList[3].s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen;
- strWIDList[3].ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWIDList[3].ps8WidVal = (s8 *)pu8keybuf;
s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, WILC_TRUE, (u32)pstrWFIDrv);
s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_ADD_WEP_KEY;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_ADD_WEP_KEY;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_REMOVE_WEP_KEY;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_REMOVE_WEP_KEY;
strWID.enuWIDtype = WID_STR;
- s8idxarray[0] = (WILC_Sint8)pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx;
+ s8idxarray[0] = (s8)pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx;
strWID.ps8WidVal = s8idxarray;
strWID.s32ValueSize = 1;
strWID.ps8WidVal = s8idxarray;
strWID.s32ValueSize = 1;
} else {
strWID.u16WIDid = (u16)WID_KEY_ID;
strWID.enuWIDtype = WID_CHAR;
} else {
strWID.u16WIDid = (u16)WID_KEY_ID;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
+ strWID.ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx));
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Setting default key index\n");
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Setting default key index\n");
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
- strWIDList[0].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
+ strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
strWIDList[1].u16WIDid = (u16)WID_ADD_RX_GTK;
strWIDList[1].enuWIDtype = WID_STR;
strWIDList[1].u16WIDid = (u16)WID_ADD_RX_GTK;
strWIDList[1].enuWIDtype = WID_STR;
- strWIDList[1].ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
strWIDList[1].s32ValueSize = RX_MIC_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
strWIDList[1].s32ValueSize = RX_MIC_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_ADD_RX_GTK;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_ADD_RX_GTK;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = RX_MIC_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.s32ValueSize = RX_MIC_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
strWIDList[0].u16WIDid = (u16)WID_11I_MODE;
strWIDList[0].enuWIDtype = WID_CHAR;
strWIDList[0].s32ValueSize = sizeof(WILC_Char);
- strWIDList[0].ps8WidVal = (WILC_Sint8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
+ strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode));
strWIDList[1].u16WIDid = (u16)WID_ADD_PTK;
strWIDList[1].enuWIDtype = WID_STR;
strWIDList[1].u16WIDid = (u16)WID_ADD_PTK;
strWIDList[1].enuWIDtype = WID_STR;
- strWIDList[1].ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
strWIDList[1].s32ValueSize = PTK_KEY_MSG_LEN + 1;
s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
strWIDList[1].s32ValueSize = PTK_KEY_MSG_LEN + 1;
s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_ADD_PTK;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_ADD_PTK;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = PTK_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.s32ValueSize = PTK_KEY_MSG_LEN;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_PMKID_INFO;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_PMKID_INFO;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8keybuf;
+ strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.s32ValueSize = (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1;
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&u16DummyReasonCode;
+ strWID.ps8WidVal = (s8 *)&u16DummyReasonCode;
strWID.s32ValueSize = sizeof(WILC_Char);
strWID.s32ValueSize = sizeof(WILC_Char);
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL;
strWID.enuWIDtype = WID_CHAR;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&gu8Chnl;
+ strWID.ps8WidVal = (s8 *)&gu8Chnl;
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Getting channel value\n");
strWID.s32ValueSize = sizeof(WILC_Char);
PRINT_D(HOSTINF_DBG, "Getting channel value\n");
strWIDList[u32WidsCount].u16WIDid = WID_LINKSPEED;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
strWIDList[u32WidsCount].u16WIDid = WID_LINKSPEED;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrStatistics->u8LinkSpeed));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u8LinkSpeed));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RSSI;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RSSI;
strWIDList[u32WidsCount].enuWIDtype = WID_CHAR;
strWIDList[u32WidsCount].s32ValueSize = sizeof(WILC_Char);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrStatistics->s8RSSI));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->s8RSSI));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrStatistics->u32TxCount));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxCount));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrStatistics->u32RxCount));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32RxCount));
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
u32WidsCount++;
strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT;
strWIDList[u32WidsCount].enuWIDtype = WID_INT;
strWIDList[u32WidsCount].s32ValueSize = sizeof(u32);
- strWIDList[u32WidsCount].ps8WidVal = (WILC_Sint8 *)(&(pstrStatistics->u32TxFailureCount));
+ strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxFailureCount));
u32WidsCount++;
s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)drvHandler);
u32WidsCount++;
s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)drvHandler);
strWID.u16WIDid = (u16)WID_GET_INACTIVE_TIME;
strWID.enuWIDtype = WID_INT;
strWID.u16WIDid = (u16)WID_GET_INACTIVE_TIME;
strWID.enuWIDtype = WID_INT;
- strWID.ps8WidVal = (WILC_Sint8 *)&gu32InactiveTime;
+ strWID.ps8WidVal = (s8 *)&gu32InactiveTime;
strWID.s32ValueSize = sizeof(u32);
strWID.s32ValueSize = sizeof(u32);
strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
strWID.enuWIDtype = WID_STR;
strWID.s32ValueSize = 2;
strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
strWID.enuWIDtype = WID_STR;
strWID.s32ValueSize = 2;
- strWID.ps8WidVal = (WILC_Sint8 *)WILC_MALLOC(strWID.s32ValueSize);
+ strWID.ps8WidVal = (s8 *)WILC_MALLOC(strWID.s32ValueSize);
if (strWID.ps8WidVal == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
strWID.ps8WidVal[0] = u8remain_on_chan_flag;
if (strWID.ps8WidVal == NULL) {
WILC_ERRORREPORT(s32Error, WILC_NO_MEM);
}
strWID.ps8WidVal[0] = u8remain_on_chan_flag;
- strWID.ps8WidVal[1] = (WILC_Sint8)pstrHostIfRemainOnChan->u16Channel;
+ strWID.ps8WidVal[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
/*Sending Cfg*/
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
/*Sending Cfg*/
s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrWID strWID;
- WILC_Sint8 s8PowerMode;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (u16)WID_POWER_MANAGEMENT;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (u16)WID_POWER_MANAGEMENT;
strWID.u16WIDid = (u16)WID_REMOVE_KEY;
strWID.enuWIDtype = WID_STR;
strWID.u16WIDid = (u16)WID_REMOVE_KEY;
strWID.enuWIDtype = WID_STR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8StaAddress;
+ strWID.ps8WidVal = (s8 *)pu8StaAddress;
strWID.s32ValueSize = 6;
return s32Error;
strWID.s32ValueSize = 6;
return s32Error;
strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
strWID.enuWIDtype = WID_CHAR;
strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&scanSource;
+ strWID.ps8WidVal = (s8 *)&scanSource;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
strWID.enuWIDtype = WID_CHAR;
strWID.u16WIDid = (u16)WID_START_SCAN_REQ;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)pu8ScanSource;
+ strWID.ps8WidVal = (s8 *)pu8ScanSource;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
strWID.u16WIDid = (u16)WID_DISCONNECT;
strWID.enuWIDtype = WID_CHAR;
- strWID.ps8WidVal = (WILC_Sint8 *)&assoc_id;
+ strWID.ps8WidVal = (s8 *)&assoc_id;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.s32ValueSize = sizeof(WILC_Char);
return s32Error;
strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS;
strWID.enuWIDtype = WID_INT;
strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS;
strWID.enuWIDtype = WID_INT;
- strWID.ps8WidVal = (WILC_Sint8 *)pu32TestMemAddr;
+ strWID.ps8WidVal = (s8 *)pu32TestMemAddr;
strWID.s32ValueSize = sizeof(u32);
s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
strWID.s32ValueSize = sizeof(u32);
s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
* @date 8 March 2012
* @version 1.0
*/
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, WILC_Sint8 *ps8Rssi)
+WILC_Sint32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, s8 *ps8Rssi)
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
{
WILC_Sint32 s32Error = WILC_SUCCESS;
tstrHostIFmsg strHostIFmsg;
-WILC_Sint32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, WILC_Sint8 *ps8lnkspd)
+WILC_Sint32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, s8 *ps8lnkspd)
{
tstrHostIFmsg strHostIFmsg;
WILC_Sint32 s32Error = WILC_SUCCESS;
{
tstrHostIFmsg strHostIFmsg;
WILC_Sint32 s32Error = WILC_SUCCESS;
void host_int_send_network_info_to_host
void host_int_send_network_info_to_host
- (u8 *macStartAddress, u16 u16RxFrameLen, WILC_Sint8 s8Rssi)
+ (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi)
typedef struct {
u16 cfg_wid;
WID_TYPE_T cfg_type;
typedef struct {
u16 cfg_wid;
WID_TYPE_T cfg_type;
} cfg_param_t;
typedef struct _tstrStatistics {
u8 u8LinkSpeed;
} cfg_param_t;
typedef struct _tstrStatistics {
u8 u8LinkSpeed;
u32 u32TxCount;
u32 u32RxCount;
u32 u32TxFailureCount;
u32 u32TxCount;
u32 u32RxCount;
u32 u32TxFailureCount;
typedef struct {
u8 au8bssid[6];
typedef struct {
u8 au8bssid[6];
} tstrFoundNetworkInfo;
typedef enum {SCAN_EVENT_NETWORK_FOUND = 0,
} tstrFoundNetworkInfo;
typedef enum {SCAN_EVENT_NETWORK_FOUND = 0,
* @date 8 March 2012
* @version 1.0
*/
* @date 8 March 2012
* @version 1.0
*/
-WILC_Sint32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, WILC_Sint8 *ps8Rssi);
-WILC_Sint32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, WILC_Sint8 *ps8lnkspd);
+WILC_Sint32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, s8 *ps8Rssi);
+WILC_Sint32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, s8 *ps8lnkspd);
/**
* @brief scans a set of channels
* @details
/**
* @brief scans a set of channels
* @details
* @version 1.0
*/
void host_int_send_network_info_to_host
* @version 1.0
*/
void host_int_send_network_info_to_host
- (u8 *macStartAddress, u16 u16RxFrameLen, WILC_Sint8 s8Rssi);
+ (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi);
/**
* @brief host interface initialization function
/**
* @brief host interface initialization function
u32 size = 0, length = 0;
perInterface_wlan_t *nic;
struct WILC_WFI_priv *priv;
u32 size = 0, length = 0;
perInterface_wlan_t *nic;
struct WILC_WFI_priv *priv;
#define WILC_OSW_INTERFACE_VER 2
/* Integer Types */
#define WILC_OSW_INTERFACE_VER 2
/* Integer Types */
-typedef signed char WILC_Sint8;
typedef signed short WILC_Sint16;
typedef signed int WILC_Sint32;
typedef signed long long WILC_Sint64;
typedef signed short WILC_Sint16;
typedef signed int WILC_Sint32;
typedef signed long long WILC_Sint64;