WILC_Char *pcRespBuffer;
s32 s32MaxRespBuffLen;
s32 s32BytesRead;
- WILC_Bool bRespRequired;
+ bool bRespRequired;
} tstrConfigPktInfo;
s32 further_process_response(u8 *resp,
u16 u16WIDid,
u16 cfg_len,
- WILC_Bool process_wid_num,
+ bool process_wid_num,
u32 cnt,
tstrWID *pstrWIDresult)
{
u16 u16WIDid = 0;
u16 cfg_len = 0;
tenuWIDtype enuWIDtype = WID_UNDEF;
- WILC_Bool num_wid_processed = WILC_FALSE;
+ bool num_wid_processed = false;
u32 cnt = 0;
u32 idx = 0;
u32 ResCnt = 0;
idx++;
}
idx += 3;
- if ((u16WIDid == g_wid_num) && (num_wid_processed == WILC_FALSE)) {
- num_wid_processed = WILC_TRUE;
+ if ((u16WIDid == g_wid_num) && (num_wid_processed == false)) {
+ num_wid_processed = true;
- if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, WILC_TRUE, 0, &pstrWIDcfgResult[ResCnt])) {
+ if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, true, 0, &pstrWIDcfgResult[ResCnt])) {
return -2;
}
ResCnt++;
} else {
for (cnt = 0; cnt < g_num_total_switches; cnt++) {
if (gastrWIDs[cnt].u16WIDid == u16WIDid) {
- if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, WILC_FALSE, cnt,
+ if (-2 == further_process_response(&resp[idx], u16WIDid, cfg_len, false, cnt,
&pstrWIDcfgResult[ResCnt])) {
return -2;
}
}
s32 ConfigWaitResponse(WILC_Char *pcRespBuffer, s32 s32MaxRespBuffLen, s32 *ps32BytesRead,
- WILC_Bool bRespRequired)
+ bool bRespRequired)
{
s32 s32Error = WILC_SUCCESS;
/*bug 3878*/
* gstrConfigPktInfo.bRespRequired = bRespRequired;*/
- if (gstrConfigPktInfo.bRespRequired == WILC_TRUE) {
+ if (gstrConfigPktInfo.bRespRequired == true) {
down(&SemHandlePktResp);
*ps32BytesRead = gstrConfigPktInfo.s32BytesRead;
*/
#ifdef SIMULATION
s32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
- u32 u32WIDsCount, WILC_Bool bRespRequired, u32 drvHandler)
+ u32 u32WIDsCount, bool bRespRequired, u32 drvHandler)
{
s32 s32Error = WILC_SUCCESS;
s32 err = WILC_SUCCESS;
ConfigWaitResponse(gps8ConfigPacket, MAX_PACKET_BUFF_SIZE, &s32RcvdRespLen, bRespRequired);
- if (bRespRequired == WILC_TRUE) {
+ if (bRespRequired == true) {
/* If the operating Mode is GET, then we expect a response frame from */
/* the driver. Hence start listening to the port for response */
if (g_oper_mode == GET_CFG) {
{
s32 s32Error = WILC_SUCCESS;
- if (gstrConfigPktInfo.bRespRequired == WILC_TRUE) {
+ if (gstrConfigPktInfo.bRespRequired == true) {
if (s32RespLen <= gstrConfigPktInfo.s32MaxRespBuffLen) {
WILC_memcpy(gstrConfigPktInfo.pcRespBuffer, pcRespBuffer, s32RespLen);
gstrConfigPktInfo.s32BytesRead = s32RespLen;
* @version 1.0
*/
s32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
- u32 u32WIDsCount, WILC_Bool bRespRequired, u32 drvHandler)
+ u32 u32WIDsCount, bool bRespRequired, u32 drvHandler)
{
s32 counter = 0, ret = 0;
if (gpstrWlanOps == NULL) {
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;
+ bool bNewNetwork;
#ifdef AGING_ALG
u8 u8Found;
#endif
extern s32 CoreConfiguratorDeInit(void);
extern s32 SendConfigPkt(u8 u8Mode, tstrWID *pstrWIDs,
- u32 u32WIDsCount, WILC_Bool bRespRequired, u32 drvHandler);
+ u32 u32WIDsCount, bool bRespRequired, u32 drvHandler);
extern s32 ParseNetworkInfo(u8 *pu8MsgBuffer, tstrNetworkInfo **ppstrNetworkInfo);
extern s32 DeallocateNetworkInfo(tstrNetworkInfo *pstrNetworkInfo);
return u32Error;
}
-u32 FIFO_WriteBytes(tHANDLE hFifo, u8 *pu8Buffer, u32 u32BytesToWrite, WILC_Bool bForceOverWrite)
+u32 FIFO_WriteBytes(tHANDLE hFifo, u8 *pu8Buffer, u32 u32BytesToWrite, bool bForceOverWrite)
{
u32 u32Error = 0;
tstrFifoHandler *pstrFifoHandler = (tstrFifoHandler *) hFifo;
extern u32 FIFO_ReadBytes(tHANDLE hFifo, u8 *pu8Buffer,
u32 u32BytesToRead, u32 *pu32BytesRead);
extern u32 FIFO_WriteBytes(tHANDLE hFifo, u8 *pu8Buffer,
- u32 u32BytesToWrite, WILC_Bool bForceOverWrite);
+ u32 u32BytesToWrite, bool bForceOverWrite);
extern WILC_TimerHandle hDuringIpTimer;
#endif
-extern WILC_Bool bEnablePS;
+extern bool bEnablePS;
/*BugID_5137*/
extern u8 g_wilc_initialized;
/*****************************************************************************/
*/
typedef struct {
- WILC_Bool bIsEnabled;
+ bool bIsEnabled;
u32 u32count;
} tstrHostIFSetMulti;
*/
typedef struct {
- WILC_Bool bIsEnabled;
+ bool bIsEnabled;
u32 u32Timeout;
} tstrHostIfPowerMgmtParam;
u8 ht_capable;
u8 wmm_cap;
u8 uapsd_cap;
- WILC_Bool rsn_found;
+ bool rsn_found;
u8 rsn_grp_policy;
u8 mode_802_11i;
u8 rsn_pcip_policy[3];
tstrWILC_WFIDrv *terminated_handle = NULL;
tstrWILC_WFIDrv *gWFiDrvHandle = NULL;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
-WILC_Bool g_obtainingIP = WILC_FALSE;
+bool g_obtainingIP = false;
#endif
u8 P2P_LISTEN_STATE;
static struct task_struct *HostIFthreadHandler;
static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE];
-WILC_Bool gbScanWhileConnected = WILC_FALSE;
+bool gbScanWhileConnected = false;
static s8 gs8Rssi;
static s8 gs8lnkspd;
PRINT_D(HOSTINF_DBG, "Setting channel\n");
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to set channel\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if ((pstrHostIfSetDrvHandler->u32Address) == (u32)NULL) {
/*Sending Cfg*/
PRINT_INFO(HOSTINF_DBG, "pstrWFIDrv= %p \n", pstrWFIDrv);
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if ((pstrHostIfSetOperationMode->u32Mode) == (u32)NULL) {
strWID.ps8WidVal = (u8 *)pu8IPAddr;
strWID.s32ValueSize = IP_ALEN;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
strWID.ps8WidVal = (u8 *)WILC_MALLOC(IP_ALEN);
strWID.s32ValueSize = IP_ALEN;
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
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]));
strWID.s32ValueSize = ETH_ALEN;
PRINT_D(GENERIC_DBG, "mac addr = :%x:%x:%x:%x:%x:%x\n", strWID.ps8WidVal[0], strWID.ps8WidVal[1], strWID.ps8WidVal[2], strWID.ps8WidVal[3], strWID.ps8WidVal[4], strWID.ps8WidVal[5]);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to set mac address\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
strWID.s32ValueSize = ETH_ALEN;
/*Sending Cfg*/
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_FALSE, (u32)drvHandler);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, false, (u32)drvHandler);
if (s32Error) {
PRINT_ER("Failed to get mac address\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
}
u8WidCnt++;
}
- s32Error = SendConfigPkt(SET_CFG, strWIDList, u8WidCnt, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, u8WidCnt, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Error in setting CFG params\n");
/* gWFiDrvHandle->enuHostIFstate = HOST_IF_SCANNING; */
if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) {
- gbScanWhileConnected = WILC_TRUE;
+ gbScanWhileConnected = true;
} else if (pstrWFIDrv->enuHostIFstate == HOST_IF_IDLE) {
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
}
- s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send scan paramters config packet\n");
strWID.s32ValueSize = sizeof(WILC_Char);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error != WILC_SUCCESS) {
PRINT_ER("Failed to set abort running scan\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
/* ////////////////////// */
#endif
- s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Handle_Connect()] failed to send config packet\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
PRINT_D(GENERIC_DBG, "save bssid = %x:%x:%x:%x:%x:%x\n", (u8ConnectedSSID[0]), (u8ConnectedSSID[1]), (u8ConnectedSSID[2]), (u8ConnectedSSID[3]), (u8ConnectedSSID[4]), (u8ConnectedSSID[5]));
}
- s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Handle_Connect()] failed to send config packet\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
#endif
- s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, WILC_FALSE, gu8FlushedJoinReqDrvHandler);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, gu8FlushedJoinReqDrvHandler);
if (s32Error) {
PRINT_ER("Handle_Flush_Connect()] failed to send config packet\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo));
PRINT_D(HOSTINF_DBG, "Sending disconnect request\n");
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send dissconect config packet\n");
}
static s32 Handle_RcvdNtwrkInfo(void *drvHandler, tstrRcvdNetworkInfo *pstrRcvdNetworkInfo)
{
u32 i;
- WILC_Bool bNewNtwrkFound;
+ bool bNewNtwrkFound;
- bNewNtwrkFound = WILC_TRUE;
+ bNewNtwrkFound = true;
PRINT_INFO(HOSTINF_DBG, "Handling received network info\n");
/*if there is a an ongoing scan request*/
* the rssi for this cached network and send this updated network to the upper layer but
* don't add a new record for it */
pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi = pstrNetworkInfo->s8rssi;
- bNewNtwrkFound = WILC_FALSE;
+ bNewNtwrkFound = false;
break;
}
}
}
}
- if (bNewNtwrkFound == WILC_TRUE) {
+ if (bNewNtwrkFound == true) {
/* here it is confirmed that it is a new discovered network,
* so add its record then call the User CallBack function */
pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount++;
- pstrNetworkInfo->bNewNetwork = WILC_TRUE;
+ pstrNetworkInfo->bNewNetwork = true;
/*Bug4218: Parsing Join Param*/
/* add new BSS to JoinBssTable */
#ifdef WILC_PARSE_SCAN_IN_HOST
PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit \n");
}
} else {
- pstrNetworkInfo->bNewNetwork = WILC_FALSE;
+ pstrNetworkInfo->bNewNetwork = false;
/* just call the User CallBack function to send the same discovered network with its updated RSSI */
pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo,
pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL);
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
PRINT_D(GENERIC_DBG, "Obtaining an IP, Disable Scan\n");
- g_obtainingIP = WILC_TRUE;
+ g_obtainingIP = true;
WILC_TimerStart(&hDuringIpTimer, 10000, NULL, NULL);
#endif
} else {
PRINT_D(HOSTINF_DBG, "MAC status : %d and Connect Status : %d\n", u8MacStatus, strConnectInfo.u16ConnectStatus);
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
}
/* Deallocation */
if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) {
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0);
#endif
}
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
} else if ((u8MacStatus == MAC_DISCONNECTED) &&
(pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL)) {
strWIDList[3].ps8WidVal = (s8 *)pu8keybuf;
- s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
} else if (pstrHostIFkeyAttr->u8KeyAction & REMOVEKEY) {
strWID.ps8WidVal = s8idxarray;
strWID.s32ValueSize = 1;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
} else {
strWID.u16WIDid = (u16)WID_KEY_ID;
strWID.enuWIDtype = WID_CHAR;
PRINT_D(HOSTINF_DBG, "Setting default key index\n");
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
}
up(&(pstrWFIDrv->hSemTestKeyBlock));
break;
strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
strWIDList[1].s32ValueSize = RX_MIC_KEY_MSG_LEN;
- s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = RX_MIC_KEY_MSG_LEN;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
strWIDList[1].ps8WidVal = (s8 *)pu8keybuf;
strWIDList[1].s32ValueSize = PTK_KEY_MSG_LEN + 1;
- s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
/* ////////////////////////// */
strWID.ps8WidVal = (s8 *)pu8keybuf;
strWID.s32ValueSize = PTK_KEY_MSG_LEN;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
WILC_FREE(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);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
WILC_FREE(pu8keybuf);
break;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0);
#endif
WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send dissconect config packet\n");
PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL \n");
}
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
strWID.ps8WidVal = &dummy;
strWID.s32ValueSize = sizeof(WILC_Char);
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_D(HOSTINF_DBG, "Getting channel value\n");
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
/*get the value by searching the local copy*/
if (s32Error) {
PRINT_ER("Failed to get channel number\n");
/*Sending Cfg*/
PRINT_D(HOSTINF_DBG, "Getting RSSI value\n");
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to get RSSI value\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
/*Sending Cfg*/
PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n");
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to get LINKSPEED value\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxFailureCount));
u32WidsCount++;
- s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, WILC_FALSE, (u32)drvHandler);
+ s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, false, (u32)drvHandler);
if (s32Error) {
PRINT_ER("Failed to send scan paramters config packet\n");
PRINT_D(CFG80211_DBG, "SETING STA inactive time\n");
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
/*get the value by searching the local copy*/
if (s32Error) {
PRINT_ER("Failed to SET incative time\n");
strWID.s32ValueSize = sizeof(u32);
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
/*get the value by searching the local copy*/
if (s32Error) {
PRINT_ER("Failed to get incative time\n");
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send add beacon config packet\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
/* TODO: build del beacon message*/
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send delete beacon config packet\n");
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error != WILC_SUCCESS) {
PRINT_ER("Failed to send add station config packet\n");
}
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send add station config packe\n");
WILC_memcpy(pu8CurrByte, pstrDelStaParam->au8MacAddr, ETH_ALEN);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send add station config packe\n");
pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send edit station config packet\n");
PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel);
- u8remain_on_chan_flag = WILC_TRUE;
+ u8remain_on_chan_flag = true;
strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
strWID.enuWIDtype = WID_STR;
strWID.s32ValueSize = 2;
strWID.ps8WidVal[1] = (s8)pstrHostIfRemainOnChan->u16Channel;
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error != WILC_SUCCESS) {
PRINT_ER("Failed to set remain on channel\n");
}
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to frame register config packet\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
/*Make sure we are already in listen state*/
/*This is to handle duplicate expiry messages (listen timer fired and supplicant called cancel_remain_on_channel())*/
if (P2P_LISTEN_STATE) {
- u8remain_on_chan_flag = WILC_FALSE;
+ u8remain_on_chan_flag = false;
strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN;
strWID.enuWIDtype = WID_STR;
strWID.s32ValueSize = 2;
strWID.ps8WidVal[1] = FALSE_FRMWR_CHANNEL;
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error != WILC_SUCCESS) {
PRINT_ER("Failed to set remain on channel\n");
goto _done_;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler;
strWID.u16WIDid = (u16)WID_POWER_MANAGEMENT;
- if (strPowerMgmtParam->bIsEnabled == WILC_TRUE) {
+ if (strPowerMgmtParam->bIsEnabled == true) {
s8PowerMode = MIN_FAST_PS;
} else {
s8PowerMode = NO_POWERSAVE;
PRINT_D(HOSTINF_DBG, "Handling Power Management\n");
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send power management config packet\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->u32count) * ETH_ALEN));
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_FALSE, (u32)drvHandler);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)drvHandler);
if (s32Error) {
PRINT_ER("Failed to send setup multicast config packet\n");
WILC_ERRORREPORT(s32Error, WILC_FAIL);
/* Group Buffer Timeout */
*ptr++ = 0;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error)
PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n");
*ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF);
/*Ack-Policy */
*ptr++ = 3;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (strWID.ps8WidVal != NULL)
WILC_FREE(strWID.ps8WidVal);
/* Delba Reason */
*ptr++ = 32; /* Unspecific QOS reason */
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error)
PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
/* TID*/
*ptr++ = strHostIfBASessionInfo->u8Ted;
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (strWID.ps8WidVal != NULL)
WILC_FREE(strWID.ps8WidVal);
/* Delba Reason */
*ptr++ = 32; /* Unspecific QOS reason */
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error)
PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n");
astrWIDList[1].ps8WidVal = ppu8RcvdSiteSurveyResults[1];
astrWIDList[1].s32ValueSize = u32MaxSiteSrvyFragLen;
- s32Error = SendConfigPkt(GET_CFG, astrWIDList, 2, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, astrWIDList, 2, true, (u32)pstrWFIDrv);
/*get the value by searching the local copy*/
if (s32Error) {
/* Sending Configuration packet */
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Failed to send association response config packet\n");
*pu32RcvdAssocRespInfoLen = 0;
strWID.s32ValueSize = sizeof(u32);
/*Sending Cfg*/
- s32Error = SendConfigPkt(SET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
if (s32Error) {
PRINT_ER("Test Function: Failed to set wid value\n");
WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE);
strWID.ps8WidVal = (s8 *)pu32TestMemAddr;
strWID.s32ValueSize = sizeof(u32);
- s32Error = SendConfigPkt(GET_CFG, &strWID, 1, WILC_TRUE, (u32)pstrWFIDrv);
+ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv);
/*get the value by searching the local copy*/
if (s32Error) {
PRINT_ER("Test Function: Failed to get wid value\n");
* @version 1.0
*/
void host_int_send_join_leave_info_to_host
- (u16 assocId, u8 *stationAddr, WILC_Bool joining)
+ (u16 assocId, u8 *stationAddr, bool joining)
{
}
/**
* } */
PRINT_D(HOSTINF_DBG, "Initializing host interface for client %d\n", clients_count + 1);
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
sema_init(&hWaitResponse, 0);
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
#endif
PRINT_D(HOSTINF_DBG, "Global handle pointer value=%p\n", pstrWFIDrv);
#endif
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
- /* gWFiDrvHandle->bPendingConnRequest = WILC_FALSE; */
+ /* gWFiDrvHandle->bPendingConnRequest = false; */
/*Initialize CFG WIDS Defualt Values*/
pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE;
- gbScanWhileConnected = WILC_FALSE;
+ gbScanWhileConnected = false;
WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg));
* @author
* @date
* @version 1.0*/
-s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, WILC_Bool bReg)
+s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, bool bReg)
{
s32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
#endif /*WILC_AP_EXTERNAL_MLME*/
uint32_t wilc_get_chipid(uint8_t);
-s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, WILC_Bool bIsEnabled, u32 u32Timeout)
+s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32Timeout)
{
s32 s32Error = WILC_SUCCESS;
tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv;
return s32Error;
}
-s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, WILC_Bool bIsEnabled, u32 u32count)
+s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32count)
{
s32 s32Error = WILC_SUCCESS;
size_t ConnReqIEsLen;
/* Connect user call back function */
tWILCpfConnectResult pfUserConnectResult;
- WILC_Bool IsHTCapable;
+ bool IsHTCapable;
/* User specific parameter to be delivered through the Connect User Callback function */
void *u32UserConnectPvoid;
} tstrWILC_UsrConnReq;
typedef struct {
- WILC_Bool bReg;
+ bool bReg;
u16 u16FrameType;
u8 u8Regid;
tenuHostIFstate enuHostIFstate;
- /* WILC_Bool bPendingConnRequest; */
+ /* bool bPendingConnRequest; */
#ifndef CONNECT_DIRECT
u32 u32SurveyResultsCount;
WILC_TimerHandle hRemainOnChannel;
#endif
- WILC_Bool IFC_UP;
+ bool IFC_UP;
} tstrWILC_WFIDrv;
/*!
u16 u16AssocID;
u8 u8NumRates;
const u8 *pu8Rates;
- WILC_Bool bIsHTSupported;
+ bool bIsHTSupported;
u16 u16HTCapInfo;
u8 u8AmpduParams;
u8 au8SuppMCsSet[16];
* @version 1.0
*/
void host_int_send_join_leave_info_to_host
- (u16 assocId, u8 *stationAddr, WILC_Bool joining);
+ (u16 assocId, u8 *stationAddr, bool joining);
/**
* @brief notifies host with stations found in scan
s32 host_int_edit_station(WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam *pstrStaParams);
/*!
- * @fn s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, WILC_Bool bIsEnabled, u32 u32Timeout)
+ * @fn s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32Timeout)
* @brief Set the power management mode to enabled or disabled
* @details
* @param[in,out] hWFIDrv handle to the wifi driver
* @date 24 November 2012
* @version 1.0 Description
*/
-s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, WILC_Bool bIsEnabled, u32 u32Timeout);
+s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32Timeout);
/* @param[in,out] hWFIDrv handle to the wifi driver
* @param[in] bIsEnabled TRUE if enabled, FALSE otherwise
* @param[in] u8count count of mac address entries in the filter table
* @date 24 November 2012
* @version 1.0 Description
*/
-s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, WILC_Bool bIsEnabled, u32 u32count);
+s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32count);
/**
* @brief host_int_setup_ipaddress
* @details set IP address on firmware
* @date
* @version 1.0
*/
-s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, WILC_Bool bReg);
+s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, bool bReg);
#endif
/**
* @brief host_int_set_wfi_drv_handler
memcpy((mgmt_tx->buff) + (len - sizeof(struct tx_complete_mon_data *)), &mgmt_tx, sizeof(struct tx_complete_mon_data *));
/* filter data frames to handle it's PS */
- if (filter_monitor_data_frames((mgmt_tx->buff), len) == WILC_TRUE) {
+ if (filter_monitor_data_frames((mgmt_tx->buff), len) == true) {
return;
}
* @date 9 May 2013
* @version 1.0
*/
-void WILC_mgm_HOSTAPD_ACK(void *priv, WILC_Bool bStatus)
+void WILC_mgm_HOSTAPD_ACK(void *priv, bool bStatus)
{
struct sk_buff *skb;
struct wilc_wfi_radiotap_cb_hdr *cb_hdr;
cb_hdr->rate = 5; /* txrate->bitrate / 5; */
- if (WILC_TRUE == bStatus) {
+ if (true == bStatus) {
/* success */
cb_hdr->tx_flags = IEEE80211_RADIOTAP_F_TX_RTS;
} else {
#endif
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
-extern WILC_Bool g_obtainingIP;
+extern bool g_obtainingIP;
#endif
-extern u16 Set_machw_change_vir_if(WILC_Bool bValue);
+extern u16 Set_machw_change_vir_if(bool bValue);
extern void resolve_disconnect_aberration(void *drvHandler);
extern u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN];
void wilc1000_wlan_deinit(linux_wlan_t *nic);
*/
linux_wlan_t *g_linux_wlan;
wilc_wlan_oup_t *gpstrWlanOps;
-WILC_Bool bEnablePS = WILC_TRUE;
+bool bEnablePS = true;
static const struct net_device_ops wilc_netdev_ops = {
.ndo_init = mac_init_fn,
/*If we are in station mode or client mode*/
if (nic->iftype == STATION_MODE || nic->iftype == CLIENT_MODE) {
pstrWFIDrv->IFC_UP = 1;
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
WILC_TimerStop(&hDuringIpTimer, NULL);
PRINT_D(GENERIC_DBG, "IP obtained , enable scan\n");
}
- if (bEnablePS == WILC_TRUE)
+ if (bEnablePS == true)
host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 1, 0);
PRINT_D(GENERIC_DBG, "[%s] Up IP\n", dev_iface->ifa_label);
PRINT_INFO(GENERIC_DBG, "\n ============== IP Address Released ===============\n\n");
if (nic->iftype == STATION_MODE || nic->iftype == CLIENT_MODE) {
pstrWFIDrv->IFC_UP = 0;
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
}
if (memcmp(dev_iface->ifa_label, wlan_dev_name, 5) == 0)
return ret;
}
- Set_machw_change_vir_if(WILC_FALSE);
+ Set_machw_change_vir_if(false);
host_int_get_MacAddress(priv->hWILCWFIDrv, mac_add);
PRINT_D(INIT_DBG, "Mac address: %x:%x:%x:%x:%x:%x\n", mac_add[0], mac_add[1], mac_add[2],
if ((dev->flags & IFF_ALLMULTI) || (dev->mc.count) > WILC_MULTICAST_TABLE_SIZE) {
PRINT_D(INIT_DBG, "Disable multicast filter, retrive all multicast packets\n");
/* get all multicast packets */
- host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, WILC_FALSE, 0);
+ host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, false, 0);
return;
}
/* No multicast? Just get our own stuff */
if ((dev->mc.count) == 0) {
PRINT_D(INIT_DBG, "Enable multicast filter, retrive directed packets only.\n");
- host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, WILC_TRUE, 0);
+ host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, true, 0);
return;
}
i++;
}
- host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, WILC_TRUE, (dev->mc.count));
+ host_int_setup_multicast_filter((WILC_WFIDrvHandle)pstrWFIDrv, true, (dev->mc.count));
return;
sema_init(&pHandle->hSem, 0);
pHandle->pstrMessageList = NULL;
pHandle->u32ReceiversCount = 0;
- pHandle->bExiting = WILC_FALSE;
+ pHandle->bExiting = false;
return WILC_SUCCESS;
}
tstrWILC_MsgQueueAttrs *pstrAttrs)
{
- pHandle->bExiting = WILC_TRUE;
+ pHandle->bExiting = true;
/* Release any waiting receiver thread. */
while (pHandle->u32ReceiversCount > 0) {
WILC_ERRORREPORT(s32RetStatus, WILC_INVALID_ARGUMENT);
}
- if (pHandle->bExiting == WILC_TRUE) {
+ if (pHandle->bExiting == true) {
WILC_ERRORREPORT(s32RetStatus, WILC_FAIL);
}
WILC_ERRORREPORT(s32RetStatus, WILC_INVALID_ARGUMENT);
}
- if (pHandle->bExiting == WILC_TRUE) {
+ if (pHandle->bExiting == true) {
WILC_ERRORREPORT(s32RetStatus, WILC_FAIL);
}
/* OS Wrapper interface version */
#define WILC_OSW_INTERFACE_VER 2
-/* Boolean type */
-typedef enum {
- WILC_FALSE = 0,
- WILC_TRUE = 1
-} WILC_Bool;
-
/* Character types */
typedef char WILC_Char;
typedef struct __MessageQueue_struct {
struct semaphore hSem;
spinlock_t strCriticalSection;
- WILC_Bool bExiting;
+ bool bExiting;
u32 u32ReceiversCount;
Message *pstrMessageList;
} WILC_MsgQueueHandle;
spi_max_bus_speed,
spi_default_bus_speed,
};
-
* @details This function will move the timer to the PENDING state until the
* given time expires (in msec) then the callback function will be
* executed (timer in EXECUTING state) after execution is dene the
- * timer either goes to IDLE (if bPeriodicTimer==WILC_FALSE) or
- * PENDING with same timeout value (if bPeriodicTimer==WILC_TRUE)
+ * timer either goes to IDLE (if bPeriodicTimer==false) or
+ * PENDING with same timeout value (if bPeriodicTimer==true)
* @param[in] pHandle handle to the timer object
* @param[in] u32Timeout timeout value in msec after witch the callback
* function will be executed. Timeout value of 0 is not allowed for
extern void linux_wlan_free(void *vp);
extern int linux_wlan_get_firmware(perInterface_wlan_t *p_nic);
extern void linux_wlan_unlock(void *vp);
-extern u16 Set_machw_change_vir_if(WILC_Bool bValue);
+extern u16 Set_machw_change_vir_if(bool bValue);
extern int mac_open(struct net_device *ndev);
extern int mac_close(struct net_device *ndev);
u8 g_wilc_initialized = 1;
extern linux_wlan_t *g_linux_wlan;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
-extern WILC_Bool g_obtainingIP;
+extern bool g_obtainingIP;
#endif
#define CHAN2G(_channel, _freq, _flags) { \
u8 u8P2Plocalrandom = 0x01;
u8 u8P2Precvrandom = 0x00;
u8 u8P2P_vendorspec[] = {0xdd, 0x05, 0x00, 0x08, 0x40, 0x03};
-WILC_Bool bWilc_ie = WILC_FALSE;
+bool bWilc_ie = false;
#endif
static struct ieee80211_supported_band WILC_WFI_band_2ghz = {
struct wilc_wfi_key g_key_ptk_params;
struct wilc_wfi_wep_key g_key_wep_params;
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;
+bool g_ptk_keys_saved = false;
+bool g_gtk_keys_saved = false;
+bool g_wep_keys_saved = false;
#define AGING_TIME (9 * 1000)
#define duringIP_TIME 15000
return rssi_v;
}
-void refresh_scan(void *pUserVoid, uint8_t all, WILC_Bool bDirectScan)
+void refresh_scan(void *pUserVoid, uint8_t all, bool bDirectScan)
{
struct WILC_WFI_priv *priv;
struct wiphy *wiphy;
void clear_duringIP(void *pUserVoid)
{
PRINT_D(GENERIC_DBG, "GO:IP Obtained , enable scan\n");
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
}
#endif
struct cfg80211_bss *bss = NULL;
priv = (struct WILC_WFI_priv *)pUserVoid;
- if (priv->bCfgScanning == WILC_TRUE) {
+ if (priv->bCfgScanning == true) {
if (enuScanEvent == SCAN_EVENT_NETWORK_FOUND) {
wiphy = priv->dev->ieee80211_ptr->wiphy;
WILC_NULLCHECK(s32Error, wiphy);
"BeaconPeriod: %d \n", channel->center_freq, (((s32)pstrNetworkInfo->s8rssi) * 100),
pstrNetworkInfo->u16CapInfo, pstrNetworkInfo->u16BeaconPeriod);
- if (pstrNetworkInfo->bNewNetwork == WILC_TRUE) {
+ if (pstrNetworkInfo->bNewNetwork == true) {
if (priv->u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) { /* TODO: mostafa: to be replaced by */
/* max_scan_ssids */
PRINT_D(CFG80211_DBG, "Network %s found\n", pstrNetworkInfo->au8ssid);
} else if (enuScanEvent == SCAN_EVENT_DONE) {
PRINT_D(CFG80211_DBG, "Scan Done[%p] \n", priv->dev);
PRINT_D(CFG80211_DBG, "Refreshing Scan ... \n");
- refresh_scan(priv, 1, WILC_FALSE);
+ refresh_scan(priv, 1, false);
if (priv->u32RcvdChCount > 0) {
PRINT_D(CFG80211_DBG, "%d Network(s) found \n", priv->u32RcvdChCount);
down(&(priv->hSemScanReq));
if (priv->pstrScanReq != NULL) {
- cfg80211_scan_done(priv->pstrScanReq, WILC_FALSE);
+ cfg80211_scan_done(priv->pstrScanReq, false);
priv->u32RcvdChCount = 0;
- priv->bCfgScanning = WILC_FALSE;
+ priv->bCfgScanning = false;
priv->pstrScanReq = NULL;
}
up(&(priv->hSemScanReq));
if (priv->pstrScanReq != NULL) {
update_scan_time(priv);
- refresh_scan(priv, 1, WILC_FALSE);
+ refresh_scan(priv, 1, false);
- cfg80211_scan_done(priv->pstrScanReq, WILC_FALSE);
- priv->bCfgScanning = WILC_FALSE;
+ cfg80211_scan_done(priv->pstrScanReq, false);
+ priv->bCfgScanning = false;
priv->pstrScanReq = NULL;
}
up(&(priv->hSemScanReq));
}
if (u16ConnectStatus == WLAN_STATUS_SUCCESS) {
- WILC_Bool bNeedScanRefresh = WILC_FALSE;
+ bool bNeedScanRefresh = false;
u32 i;
PRINT_INFO(CFG80211_DBG, "Connection Successful:: BSSID: %x%x%x%x%x%x\n", pstrConnectInfo->au8bssid[0],
if (time_after(now,
astrLastScannedNtwrksShadow[i].u32TimeRcvdInScanCached + (unsigned long)(nl80211_SCAN_RESULT_EXPIRE - (1 * HZ)))) {
- bNeedScanRefresh = WILC_TRUE;
+ bNeedScanRefresh = true;
}
break;
}
}
- if (bNeedScanRefresh == WILC_TRUE) {
+ if (bNeedScanRefresh == true) {
/*BugID_5418*/
/*Also, refrsh DIRECT- results if */
- refresh_scan(priv, 1, WILC_TRUE);
+ refresh_scan(priv, 1, true);
}
/* be replaced by pstrConnectInfo->u16ConnectStatus */
} else if (enuConnDisconnEvent == CONN_DISCONN_EVENT_DISCONN_NOTIF) {
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
#endif
PRINT_ER("Received MAC_DISCONNECTED from firmware with reason %d on dev [%p]\n",
pstrDisconnectNotifInfo->u16reason, priv->dev);
u8P2Plocalrandom = 0x01;
u8P2Precvrandom = 0x00;
- bWilc_ie = WILC_FALSE;
+ bWilc_ie = false;
WILC_memset(priv->au8AssociatedBss, 0, ETH_ALEN);
linux_wlan_set_bssid(priv->dev, NullBssid);
WILC_memset(u8ConnectedSSID, 0, ETH_ALEN);
reset_shadow_found(priv);
- priv->bCfgScanning = WILC_TRUE;
+ priv->bCfgScanning = true;
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++) {
g_key_wep_params.key = WILC_MALLOC(sme->key_len);
memcpy(g_key_wep_params.key, sme->key, sme->key_len);
g_key_wep_params.key_idx = sme->key_idx;
- g_wep_keys_saved = WILC_TRUE;
+ g_wep_keys_saved = true;
host_int_set_WEPDefaultKeyID(priv->hWILCWFIDrv, sme->key_idx);
host_int_add_wep_key_bss_sta(priv->hWILCWFIDrv, sme->key, sme->key_len, sme->key_idx);
g_key_wep_params.key = WILC_MALLOC(sme->key_len);
memcpy(g_key_wep_params.key, sme->key, sme->key_len);
g_key_wep_params.key_idx = sme->key_idx;
- g_wep_keys_saved = WILC_TRUE;
+ g_wep_keys_saved = true;
host_int_set_WEPDefaultKeyID(priv->hWILCWFIDrv, sme->key_idx);
host_int_add_wep_key_bss_sta(priv->hWILCWFIDrv, sme->key, sme->key_len, sme->key_idx);
u8P2Plocalrandom = 0x01;
u8P2Precvrandom = 0x00;
- bWilc_ie = WILC_FALSE;
+ bWilc_ie = false;
#ifdef WILC_P2P
pstrWFIDrv->u64P2p_MgmtTimeout = 0;
#endif
PRINT_D(CFG80211_DBG, "key %x %x %x\n", g_key_gtk_params.key[0],
g_key_gtk_params.key[1],
g_key_gtk_params.key[2]);
- g_gtk_keys_saved = WILC_TRUE;
+ g_gtk_keys_saved = true;
}
host_int_add_rx_gtk(priv->hWILCWFIDrv, params->key, KeyLen,
PRINT_D(CFG80211_DBG, "key %x %x %x\n", g_key_ptk_params.key[0],
g_key_ptk_params.key[1],
g_key_ptk_params.key[2]);
- g_ptk_keys_saved = WILC_TRUE;
+ g_ptk_keys_saved = true;
}
host_int_add_ptk(priv->hWILCWFIDrv, params->key, KeyLen, mac_addr,
/*BugID_5137*/
/*delete saved keys, if any*/
if (netdev == g_linux_wlan->strInterfaceInfo[0].wilc_netdev) {
- g_ptk_keys_saved = WILC_FALSE;
- g_gtk_keys_saved = WILC_FALSE;
- g_wep_keys_saved = WILC_FALSE;
+ g_ptk_keys_saved = false;
+ g_gtk_keys_saved = false;
+ g_wep_keys_saved = false;
/*Delete saved WEP keys params, if any*/
if (g_key_wep_params.key != NULL) {
}
/*Reset WILC_CHANGING_VIR_IF register to allow adding futrue keys to CE H/W*/
- Set_machw_change_vir_if(WILC_FALSE);
+ Set_machw_change_vir_if(false);
}
if (key_index >= 0 && key_index <= 3) {
#ifdef TCP_ENHANCEMENTS
if ((strStatistics.u8LinkSpeed > TCP_ACK_FILTER_LINK_SPEED_THRESH) && (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED)) {
- Enable_TCP_ACK_Filter(WILC_TRUE);
+ Enable_TCP_ACK_Filter(true);
} else if (strStatistics.u8LinkSpeed != DEFAULT_LINK_SPEED) {
- Enable_TCP_ACK_Filter(WILC_FALSE);
+ Enable_TCP_ACK_Filter(false);
}
#endif
#ifdef USE_SUPPLICANT_GO_INTENT
u8 intent;
u8 tie_breaker;
- WILC_Bool is_wilc_go = WILC_TRUE;
+ bool is_wilc_go = true;
#endif
u8 op_channel_attr_index = 0;
u8 channel_list_attr_index = 0;
if (intent > SUPPLICANT_GO_INTENT
|| (intent == SUPPLICANT_GO_INTENT && tie_breaker == 1)) {
PRINT_D(GENERIC_DBG, "WILC will be client (intent %d tie breaker %d)\n", intent, tie_breaker);
- is_wilc_go = WILC_FALSE;
+ is_wilc_go = false;
} else {
PRINT_D(GENERIC_DBG, "WILC will be GO (intent %d tie breaker %d)\n", intent, tie_breaker);
- is_wilc_go = WILC_TRUE;
+ is_wilc_go = true;
}
#else /* USE_SUPPLICANT_GO_INTENT */
PRINT_D(GENERIC_DBG, "Group BSSID: %2x:%2x:%2x\n", buf[index + 3]
, buf[index + 4]
, buf[index + 5]);
- is_wilc_go = WILC_FALSE;
+ is_wilc_go = false;
}
#endif /* USE_SUPPLICANT_GO_INTENT */
* @date 12 DEC 2012
* @version
*/
-void WILC_WFI_CfgParseTxAction(u8 *buf, u32 len, WILC_Bool bOperChan, u8 iftype)
+void WILC_WFI_CfgParseTxAction(u8 *buf, u32 len, bool bOperChan, u8 iftype)
{
u32 index = 0;
u32 i = 0, j = 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;
+ bool is_wilc_go = false;
/*BugID_5460*/
/*Case 1: If we are already p2p client, no need to modify channels attributes*/
PRINT_D(GENERIC_DBG, "Group BSSID: %2x:%2x:%2x\n", buf[index + 3]
, buf[index + 4]
, buf[index + 5]);
- is_wilc_go = WILC_TRUE;
+ is_wilc_go = true;
}
#else /* USE_SUPPLICANT_GO_INTENT */
if (ieee80211_is_action(buff[FRAME_TYPE_ID])) {
PRINT_D(GENERIC_DBG, "Rx Action Frame Type: %x %x\n", buff[ACTION_SUBTYPE_ID], buff[P2P_PUB_ACTION_SUBTYPE]);
- if (priv->bCfgScanning == WILC_TRUE && time_after_eq(jiffies, (unsigned long)pstrWFIDrv->u64P2p_MgmtTimeout)) {
+ if (priv->bCfgScanning == true && time_after_eq(jiffies, (unsigned long)pstrWFIDrv->u64P2p_MgmtTimeout)) {
PRINT_D(GENERIC_DBG, "Receiving action frames from wrong channels\n");
return;
}
for (i = P2P_PUB_ACTION_SUBTYPE; i < size; i++) {
if (!WILC_memcmp(u8P2P_vendorspec, &buff[i], 6)) {
u8P2Precvrandom = buff[i + 6];
- bWilc_ie = WILC_TRUE;
+ bWilc_ie = true;
PRINT_D(GENERIC_DBG, "WILC Vendor specific IE:%02x\n", u8P2Precvrandom);
break;
}
PRINT_D(HOSTINF_DBG, "Remain on channel ready \n");
- priv->bInP2PlistenState = WILC_TRUE;
+ priv->bInP2PlistenState = true;
cfg80211_ready_on_channel(priv->wdev,
priv->strRemainOnChanParams.u64ListenCookie,
if (u32SessionID == priv->strRemainOnChanParams.u32ListenSessionID) {
PRINT_D(GENERIC_DBG, "Remain on channel expired \n");
- priv->bInP2PlistenState = WILC_FALSE;
+ priv->bInP2PlistenState = false;
/*Inform wpas of remain-on-channel expiration*/
cfg80211_remain_on_channel_expired(priv->wdev,
* @version
*/
extern linux_wlan_t *g_linux_wlan;
-extern WILC_Bool bEnablePS;
+extern bool bEnablePS;
int WILC_WFI_mgmt_tx(struct wiphy *wiphy,
struct wireless_dev *wdev,
struct cfg80211_mgmt_tx_params *params,
for (i = P2P_PUB_ACTION_SUBTYPE + 2; i < len; i++) {
if (buf[i] == P2PELEM_ATTR_ID && !(WILC_memcmp(u8P2P_oui, &buf[i + 2], 4))) {
if (buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_REQ || buf[P2P_PUB_ACTION_SUBTYPE] == P2P_INV_RSP)
- WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), WILC_TRUE, nic->iftype);
+ WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), true, nic->iftype);
/*BugID_5460*/
/*If using supplicant go intent, no need at all*/
/*to parse transmitted negotiation frames*/
#ifndef USE_SUPPLICANT_GO_INTENT
else
- WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), WILC_FALSE, nic->iftype);
+ WILC_WFI_CfgParseTxAction(&mgmt_tx->buff[i + 6], len - (i + 6), false, nic->iftype);
#endif
break;
}
PRINT_D(GENERIC_DBG, "Tx Cancel wait :%lu\n", jiffies);
pstrWFIDrv->u64P2p_MgmtTimeout = jiffies;
- if (priv->bInP2PlistenState == WILC_FALSE) {
+ if (priv->bInP2PlistenState == false) {
/* Bug 5504: This is just to avoid connection failure when getting stuck when the supplicant
* considers the driver falsely that it is in Listen state */
cfg80211_remain_on_channel_expired(priv->wdev,
return -EIO;
}
- if (bEnablePS == WILC_TRUE)
+ if (bEnablePS == true)
host_int_set_power_mgmt(priv->hWILCWFIDrv, enabled, timeout);
u8P2Plocalrandom = 0x01;
u8P2Precvrandom = 0x00;
- bWilc_ie = WILC_FALSE;
+ bWilc_ie = false;
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_FALSE;
+ g_obtainingIP = false;
WILC_TimerStop(&hDuringIpTimer, NULL);
PRINT_D(GENERIC_DBG, "Changing virtual interface, enable scan\n");
#endif
/*BugID_5137*/
/*Set WILC_CHANGING_VIR_IF register to disallow adding futrue keys to CE H/W*/
if (g_ptk_keys_saved && g_gtk_keys_saved) {
- Set_machw_change_vir_if(WILC_TRUE);
+ Set_machw_change_vir_if(true);
}
switch (type) {
}
}
- bEnablePS = WILC_TRUE;
+ bEnablePS = true;
host_int_set_power_mgmt(priv->hWILCWFIDrv, 1, 0);
}
#endif
break;
case NL80211_IFTYPE_P2P_CLIENT:
- bEnablePS = WILC_FALSE;
+ bEnablePS = false;
host_int_set_power_mgmt(priv->hWILCWFIDrv, 0, 0);
connecting = 0;
PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_P2P_CLIENT\n");
}
/*Refresh scan, to refresh the scan results to the wpa_supplicant. Set MachHw to false to enable further key installments*/
- refresh_scan(priv, 1, WILC_TRUE);
- Set_machw_change_vir_if(WILC_FALSE);
+ refresh_scan(priv, 1, true);
+ Set_machw_change_vir_if(false);
/*BugID_4847: registered frames in firmware are now lost
* due to mac close. So re-register those frames */
break;
case NL80211_IFTYPE_AP:
- bEnablePS = WILC_FALSE;
+ bEnablePS = false;
PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_AP %d\n", type);
dev->ieee80211_ptr->iftype = type;
priv->wdev->iftype = type;
PRINT_D(GENERIC_DBG, "start duringIP timer\n");
#ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP
- g_obtainingIP = WILC_TRUE;
+ g_obtainingIP = true;
WILC_TimerStart(&hDuringIpTimer, duringIP_TIME, NULL, NULL);
#endif
host_int_set_power_mgmt(priv->hWILCWFIDrv, 0, 0);
/*hWaitResponse semaphore, which allows previous config*/
/*packets to actually take action on old FW*/
host_int_del_All_Rx_BASession(priv->hWILCWFIDrv, g_linux_wlan->strInterfaceInfo[0].aBSSID, TID);
- bEnablePS = WILC_FALSE;
+ bEnablePS = false;
PRINT_D(HOSTAPD_DBG, "Interface type = NL80211_IFTYPE_GO\n");
dev->ieee80211_ptr->iftype = type;
priv->wdev->iftype = type;
PRINT_D(HOSTAPD_DBG, "Number of supported rates = %d\n", strStaParams.u8NumRates);
if (params->ht_capa == NULL) {
- strStaParams.bIsHTSupported = WILC_FALSE;
+ strStaParams.bIsHTSupported = false;
} else {
- strStaParams.bIsHTSupported = WILC_TRUE;
+ strStaParams.bIsHTSupported = true;
strStaParams.u16HTCapInfo = params->ht_capa->cap_info;
strStaParams.u8AmpduParams = params->ht_capa->ampdu_params_info;
WILC_memcpy(strStaParams.au8SuppMCsSet, ¶ms->ht_capa->mcs, WILC_SUPP_MCS_SET_SIZE);
PRINT_D(HOSTAPD_DBG, "Number of supported rates = %d\n", strStaParams.u8NumRates);
if (params->ht_capa == NULL) {
- strStaParams.bIsHTSupported = WILC_FALSE;
+ strStaParams.bIsHTSupported = false;
} else {
- strStaParams.bIsHTSupported = WILC_TRUE;
+ strStaParams.bIsHTSupported = true;
strStaParams.u16HTCapInfo = params->ht_capa->cap_info;
strStaParams.u8AmpduParams = params->ht_capa->ampdu_params_info;
WILC_memcpy(strStaParams.au8SuppMCsSet, ¶ms->ht_capa->mcs, WILC_SUPP_MCS_SET_SIZE);
return s32Error;
}
- priv->gbAutoRateAdjusted = WILC_FALSE;
+ priv->gbAutoRateAdjusted = false;
- priv->bInP2PlistenState = WILC_FALSE;
+ priv->bInP2PlistenState = false;
sema_init(&(priv->hSemScanReq), 1);
s32Error = host_int_init(&priv->hWILCWFIDrv);
struct WILC_WFI_priv *priv;
priv = wdev_priv(net->ieee80211_ptr);
- priv->gbAutoRateAdjusted = WILC_FALSE;
+ priv->gbAutoRateAdjusted = false;
- priv->bInP2PlistenState = WILC_FALSE;
+ priv->bInP2PlistenState = false;
op_ifcs--;
#ifdef TCP_ENHANCEMENTS
#define TCP_ACK_FILTER_LINK_SPEED_THRESH 54
#define DEFAULT_LINK_SPEED 72
-extern void Enable_TCP_ACK_Filter(WILC_Bool value);
+extern void Enable_TCP_ACK_Filter(bool value);
#endif
#endif
/* priv[1]->monitor_flag = 1; */
}
- priv[0]->bCfgScanning = WILC_FALSE;
+ priv[0]->bCfgScanning = false;
priv[0]->u32RcvdChCount = 0;
WILC_memset(priv[0]->au8AssociatedBss, 0xFF, ETH_ALEN);
#endif
- WILC_Bool bCfgScanning;
+ bool bCfgScanning;
u32 u32RcvdChCount;
struct semaphore SemHandleUpdateStats;
struct semaphore hSemScanReq;
/* */
- WILC_Bool gbAutoRateAdjusted;
+ bool gbAutoRateAdjusted;
- WILC_Bool bInP2PlistenState;
+ bool bInP2PlistenState;
};
typedef struct {
u16 frame_type;
- WILC_Bool reg;
+ bool reg;
} struct_frame_reg;
extern void frmw_to_linux(uint8_t *buff, uint32_t size);
int sdio_xfer_cnt(void);
uint32_t wilc_get_chipid(uint8_t update);
-u16 Set_machw_change_vir_if(WILC_Bool bValue);
+u16 Set_machw_change_vir_if(bool bValue);
#endif
#ifdef TCP_ENHANCEMENTS
-WILC_Bool EnableTCPAckFilter = WILC_FALSE;
+bool EnableTCPAckFilter = false;
-void Enable_TCP_ACK_Filter(WILC_Bool value)
+void Enable_TCP_ACK_Filter(bool value)
{
EnableTCPAckFilter = value;
}
-WILC_Bool is_TCP_ACK_Filter_Enabled(void)
+bool is_TCP_ACK_Filter_Enabled(void)
{
return EnableTCPAckFilter;
}
#ifdef TCP_ACK_FILTER
tqe->tcp_PendingAck_index = NOT_TCP_ACK;
#ifdef TCP_ENHANCEMENTS
- if (is_TCP_ACK_Filter_Enabled() == WILC_TRUE)
+ if (is_TCP_ACK_Filter_Enabled() == true)
#endif
tcp_process(tqe);
#endif
WILC_Sleep(2);
/* Make sure chip is awake. This is an extra step that can be removed */
/* later to avoid the bus access overhead */
- if ((wilc_get_chipid(WILC_TRUE) == 0)) {
+ if ((wilc_get_chipid(true) == 0)) {
wilc_debug(N_ERR, "Couldn't read chip id. Wake up failed\n");
}
- } while ((wilc_get_chipid(WILC_TRUE) == 0) && ((++trials % 3) == 0));
+ } while ((wilc_get_chipid(true) == 0) && ((++trials % 3) == 0));
- } while (wilc_get_chipid(WILC_TRUE) == 0);
+ } while (wilc_get_chipid(true) == 0);
} else if ((g_wlan.io_func.io_type & 0x1) == HIF_SDIO) {
g_wlan.hif_func.hif_read_reg(0xf0, ®);
do {
reg &= ~(1 << 0);
g_wlan.hif_func.hif_write_reg(0x1C0C, reg);
- if (wilc_get_chipid(WILC_FALSE) >= 0x1002b0) {
+ if (wilc_get_chipid(false) >= 0x1002b0) {
/* Enable PALDO back right after wakeup */
uint32_t val32;
g_wlan.hif_func.hif_read_reg(0x1e1c, &val32);
/* Make sure chip is awake. This is an extra step that can be removed */
/* later to avoid the bus access overhead */
- if ((wilc_get_chipid(WILC_TRUE) == 0)) {
+ if ((wilc_get_chipid(true) == 0)) {
wilc_debug(N_ERR, "Couldn't read chip id. Wake up failed\n");
}
- } while ((wilc_get_chipid(WILC_TRUE) == 0) && ((++trials % 3) == 0));
+ } while ((wilc_get_chipid(true) == 0) && ((++trials % 3) == 0));
- } while (wilc_get_chipid(WILC_TRUE) == 0);
+ } while (wilc_get_chipid(true) == 0);
if (genuChipPSstate == CHIP_SLEEPING_MANUAL) {
g_wlan.hif_func.hif_read_reg(0x1C0C, ®);
reg &= ~(1 << 0);
g_wlan.hif_func.hif_write_reg(0x1C0C, reg);
- if (wilc_get_chipid(WILC_FALSE) >= 0x1002b0) {
+ if (wilc_get_chipid(false) >= 0x1002b0) {
/* Enable PALDO back right after wakeup */
uint32_t val32;
g_wlan.hif_func.hif_read_reg(0x1e1c, &val32);
g_wlan.os_func.os_atomic_sleep(WILC_PLL_TO);
/* poll till read a valid data */
- while (!(ISWILC1000(wilc_get_chipid(WILC_TRUE)) && --trials)) {
+ while (!(ISWILC1000(wilc_get_chipid(true)) && --trials)) {
PRINT_D(TX_DBG, "PLL update retrying\n");
g_wlan.os_func.os_atomic_sleep(1);
}
acquire_bus(ACQUIRE_ONLY);
#endif
- chipid = wilc_get_chipid(WILC_TRUE);
+ chipid = wilc_get_chipid(true);
}
#define BIT31 (1 << 31)
-u16 Set_machw_change_vir_if(WILC_Bool bValue)
+u16 Set_machw_change_vir_if(bool bValue)
{
u16 ret;
u32 reg;
PRINT_ER("Error while Reading reg WILC_CHANGING_VIR_IF\n");
}
- if (bValue == WILC_TRUE) {
+ if (bValue == true) {
reg |= (BIT31);
} else {
reg &= ~(BIT31);
#ifdef WILC_FULLY_HOSTING_AP
#include "wilc_host_ap.h"
-void WILC_mgm_HOSTAPD_ACK(void *priv, WILC_Bool bStatus);
+void WILC_mgm_HOSTAPD_ACK(void *priv, bool bStatus);
#endif
/********************************************
uint16_t msg_len;
#ifdef WILC_FULLY_HOSTING_AP
u32 *ptru32Frame;
- WILC_Bool bStatus = frame[2];
+ bool bStatus = frame[2];
#ifdef BIG_ENDIAN
ptru32Frame = (frame[4] << 24) | (frame[5] << 16) | (frame[6] << 8) | frame[7];
projects / platform / kernel / linux-rpi.git / commitdiff