#include "host_interface.h" #include "coreconfigurator.h" extern s32 TransportInit(void); extern s32 TransportDeInit(void); extern u8 connecting; #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP extern WILC_TimerHandle hDuringIpTimer; #endif extern bool bEnablePS; /*BugID_5137*/ extern u8 g_wilc_initialized; /*****************************************************************************/ /* Macros */ /*****************************************************************************/ /* Message types of the Host IF Message Queue*/ #define HOST_IF_MSG_SCAN 0 #define HOST_IF_MSG_CONNECT 1 #define HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO 2 #define HOST_IF_MSG_KEY 3 #define HOST_IF_MSG_RCVD_NTWRK_INFO 4 #define HOST_IF_MSG_RCVD_SCAN_COMPLETE 5 #define HOST_IF_MSG_CFG_PARAMS 6 #define HOST_IF_MSG_SET_CHANNEL 7 #define HOST_IF_MSG_DISCONNECT 8 #define HOST_IF_MSG_GET_RSSI 9 #define HOST_IF_MSG_GET_CHNL 10 #define HOST_IF_MSG_ADD_BEACON 11 #define HOST_IF_MSG_DEL_BEACON 12 #define HOST_IF_MSG_ADD_STATION 13 #define HOST_IF_MSG_DEL_STATION 14 #define HOST_IF_MSG_EDIT_STATION 15 #define HOST_IF_MSG_SCAN_TIMER_FIRED 16 #define HOST_IF_MSG_CONNECT_TIMER_FIRED 17 #define HOST_IF_MSG_POWER_MGMT 18 #define HOST_IF_MSG_GET_INACTIVETIME 19 #define HOST_IF_MSG_REMAIN_ON_CHAN 20 #define HOST_IF_MSG_REGISTER_FRAME 21 #define HOST_IF_MSG_LISTEN_TIMER_FIRED 22 #define HOST_IF_MSG_GET_LINKSPEED 23 #define HOST_IF_MSG_SET_WFIDRV_HANDLER 24 #define HOST_IF_MSG_SET_MAC_ADDRESS 25 #define HOST_IF_MSG_GET_MAC_ADDRESS 26 #define HOST_IF_MSG_SET_OPERATION_MODE 27 #define HOST_IF_MSG_SET_IPADDRESS 28 #define HOST_IF_MSG_GET_IPADDRESS 29 #define HOST_IF_MSG_FLUSH_CONNECT 30 #define HOST_IF_MSG_GET_STATISTICS 31 #define HOST_IF_MSG_SET_MULTICAST_FILTER 32 #define HOST_IF_MSG_ADD_BA_SESSION 33 #define HOST_IF_MSG_DEL_BA_SESSION 34 #define HOST_IF_MSG_Q_IDLE 35 #define HOST_IF_MSG_DEL_ALL_STA 36 #define HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS 34 #define HOST_IF_MSG_EXIT 100 #define HOST_IF_SCAN_TIMEOUT 4000 #define HOST_IF_CONNECT_TIMEOUT 9500 #define BA_SESSION_DEFAULT_BUFFER_SIZE 16 #define BA_SESSION_DEFAULT_TIMEOUT 1000 #define BLOCK_ACK_REQ_SIZE 0x14 /*****************************************************************************/ /* Type Definitions */ /*****************************************************************************/ /*! * @struct tstrHostIFCfgParamAttr * @brief Structure to hold Host IF CFG Params Attributes * @details * @todo * @sa * @author Mai Daftedar * @date 02 April 2012 * @version 1.0 */ typedef struct _tstrHostIFCfgParamAttr { tstrCfgParamVal pstrCfgParamVal; } tstrHostIFCfgParamAttr; /*! * @struct tstrHostIFwpaAttr * @brief Structure to hold Host IF Scan Attributes * @details * @todo * @sa * @author Mai Daftedar * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFwpaAttr { u8 *pu8key; const u8 *pu8macaddr; u8 *pu8seq; u8 u8seqlen; u8 u8keyidx; u8 u8Keylen; u8 u8Ciphermode; } tstrHostIFwpaAttr; /*! * @struct tstrHostIFwepAttr * @brief Structure to hold Host IF Scan Attributes * @details * @todo * @sa * @author Mai Daftedar * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFwepAttr { u8 *pu8WepKey; u8 u8WepKeylen; u8 u8Wepidx; u8 u8mode; AUTHTYPE_T tenuAuth_type; } tstrHostIFwepAttr; /*! * @struct tuniHostIFkeyAttr * @brief Structure to hold Host IF Scan Attributes * @details * @todo * @sa * @author Mai Daftedar * @date 25 March 2012 * @version 1.0 */ typedef union _tuniHostIFkeyAttr { tstrHostIFwepAttr strHostIFwepAttr; tstrHostIFwpaAttr strHostIFwpaAttr; tstrHostIFpmkidAttr strHostIFpmkidAttr; } tuniHostIFkeyAttr; /*! * @struct tstrHostIFkeyAttr * @brief Structure to hold Host IF Scan Attributes * @details * @todo * @sa * @author Mai Daftedar * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFkeyAttr { tenuKeyType enuKeyType; u8 u8KeyAction; tuniHostIFkeyAttr uniHostIFkeyAttr; } tstrHostIFkeyAttr; /*! * @struct tstrHostIFscanAttr * @brief Structure to hold Host IF Scan Attributes * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFscanAttr { u8 u8ScanSource; u8 u8ScanType; u8 *pu8ChnlFreqList; u8 u8ChnlListLen; u8 *pu8IEs; size_t IEsLen; tWILCpfScanResult pfScanResult; void *pvUserArg; /*BugID_4189*/ tstrHiddenNetwork strHiddenNetwork; } tstrHostIFscanAttr; /*! * @struct tstrHostIFconnectAttr * @brief Structure to hold Host IF Connect Attributes * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFconnectAttr { u8 *pu8bssid; u8 *pu8ssid; size_t ssidLen; u8 *pu8IEs; size_t IEsLen; u8 u8security; tWILCpfConnectResult pfConnectResult; void *pvUserArg; AUTHTYPE_T tenuAuth_type; u8 u8channel; void *pJoinParams; } tstrHostIFconnectAttr; /*! * @struct tstrRcvdGnrlAsyncInfo * @brief Structure to hold Received General Asynchronous info * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrRcvdGnrlAsyncInfo { u8 *pu8Buffer; u32 u32Length; } tstrRcvdGnrlAsyncInfo; /*! * @struct tstrHostIFSetChan * @brief Set Channel message body * @details * @todo * @sa * @author Mai Daftedar * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFSetChan { u8 u8SetChan; } tstrHostIFSetChan; /*! * @struct tstrHostIFSetChan * @brief Get Channel message body * @details * @todo * @sa * @author Mai Daftedar * @date 01 Jule 2012 * @version 1.0 */ typedef struct _tstrHostIFGetChan { u8 u8GetChan; } tstrHostIFGetChan; /*bug3819: Add Scan acomplete notification to host*/ /*! * @struct tstrScanComplete * @brief hold received Async. Scan Complete message body * @details * @todo * @sa * @author zsalah * @date 25 March 2012 * @version 1.0 */ /*typedef struct _tstrScanComplete * { * u8* pu8Buffer; * u32 u32Length; * } tstrScanComplete;*/ /*! * @struct tstrHostIFSetBeacon * @brief Set Beacon message body * @details * @todo * @sa * @author Adham Abozaeid * @date 10 July 2012 * @version 1.0 */ typedef struct _tstrHostIFSetBeacon { u32 u32Interval; /*!< Beacon Interval. Period between two successive beacons on air */ u32 u32DTIMPeriod; /*!< DTIM Period. Indicates how many Beacon frames * (including the current frame) appear before the next DTIM */ u32 u32HeadLen; /*!< Length of the head buffer in bytes */ u8 *pu8Head; /*!< Pointer to the beacon's head buffer. Beacon's head is the part * from the beacon's start till the TIM element, NOT including the TIM */ u32 u32TailLen; /*!< Length of the tail buffer in bytes */ u8 *pu8Tail; /*!< Pointer to the beacon's tail buffer. Beacon's tail starts just * after the TIM inormation element */ } tstrHostIFSetBeacon; /*! * @struct tstrHostIFDelBeacon * @brief Del Beacon message body * @details * @todo * @sa * @author Adham Abozaeid * @date 15 July 2012 * @version 1.0 */ typedef struct _tstrHostIFDelBeacon { u8 u8dummy; } tstrHostIFDelBeacon; /*! * @struct tstrHostIFSetMulti * @brief set Multicast filter Address * @details * @todo * @sa * @author Abdelrahman Sobhy * @date 30 August 2013 * @version 1.0 Description */ typedef struct { bool bIsEnabled; u32 u32count; } tstrHostIFSetMulti; /*! * @struct tstrHostIFDelAllSta * @brief Deauth station message body * @details * @todo * @sa * @author Mai Daftedar * @date 09 April 2014 * @version 1.0 Description */ typedef struct { u8 au8Sta_DelAllSta[MAX_NUM_STA][ETH_ALEN]; u8 u8Num_AssocSta; } tstrHostIFDelAllSta; /*! * @struct tstrHostIFDelSta * @brief Delete station message body * @details * @todo * @sa * @author Adham Abozaeid * @date 15 July 2012 * @version 1.0 Description */ typedef struct { u8 au8MacAddr[ETH_ALEN]; } tstrHostIFDelSta; /*! * @struct tstrTimerCb * @brief Timer callback message body * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrTimerCb { void *pvUsrArg; /*!< Private data passed at timer start */ } tstrTimerCb; /*! * @struct tstrHostIfPowerMgmtParam * @brief Power management message body * @details * @todo * @sa * @author Adham Abozaeid * @date 24 November 2012 * @version 1.0 */ typedef struct { bool bIsEnabled; u32 u32Timeout; } tstrHostIfPowerMgmtParam; /*! * @struct tstrHostIFSetIPAddr * @brief set IP Address message body * @details * @todo * @sa * @author Abdelrahman Sobhy * @date 30 August 2013 * @version 1.0 Description */ typedef struct { u8 *au8IPAddr; u8 idx; } tstrHostIFSetIPAddr; /*! * @struct tstrHostIfStaInactiveT * @brief Get station message body * @details * @todo * @sa * @author Mai Daftedar * @date 16 April 2013 * @version 1.0 */ typedef struct { u8 mac[6]; } tstrHostIfStaInactiveT; /**/ /*! * @union tuniHostIFmsgBody * @brief Message body for the Host Interface message_q * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef union _tuniHostIFmsgBody { tstrHostIFscanAttr strHostIFscanAttr; /*!< Host IF Scan Request Attributes message body */ tstrHostIFconnectAttr strHostIFconnectAttr; /*!< Host IF Connect Request Attributes message body */ tstrRcvdNetworkInfo strRcvdNetworkInfo; /*!< Received Asynchronous Network Info message body */ tstrRcvdGnrlAsyncInfo strRcvdGnrlAsyncInfo; /*!< Received General Asynchronous Info message body */ tstrHostIFkeyAttr strHostIFkeyAttr; /*!<>*/ tstrHostIFCfgParamAttr strHostIFCfgParamAttr; /*! */ tstrHostIFSetChan strHostIFSetChan; tstrHostIFGetChan strHostIFGetChan; tstrHostIFSetBeacon strHostIFSetBeacon; /*!< Set beacon message body */ tstrHostIFDelBeacon strHostIFDelBeacon; /*!< Del beacon message body */ tstrWILC_AddStaParam strAddStaParam; /*!< Add station message body */ tstrHostIFDelSta strDelStaParam; /*!< Del Station message body */ tstrWILC_AddStaParam strEditStaParam; /*!< Edit station message body */ /* tstrScanComplete strScanComplete; / *Received Async. Scan Complete message body* / */ tstrTimerCb strTimerCb; /*!< Timer callback message body */ tstrHostIfPowerMgmtParam strPowerMgmtparam; /*!< Power Management message body */ tstrHostIfStaInactiveT strHostIfStaInactiveT; tstrHostIFSetIPAddr strHostIfSetIP; tstrHostIfSetDrvHandler strHostIfSetDrvHandler; tstrHostIFSetMulti strHostIfSetMulti; tstrHostIfSetOperationMode strHostIfSetOperationMode; tstrHostIfSetMacAddress strHostIfSetMacAddress; tstrHostIfGetMacAddress strHostIfGetMacAddress; tstrHostIfBASessionInfo strHostIfBASessionInfo; #ifdef WILC_P2P tstrHostIfRemainOnChan strHostIfRemainOnChan; tstrHostIfRegisterFrame strHostIfRegisterFrame; #endif char *pUserData; tstrHostIFDelAllSta strHostIFDelAllSta; } tuniHostIFmsgBody; /*! * @struct tstrHostIFmsg * @brief Host Interface message * @details * @todo * @sa * @author Mostafa Abu Bakr * @date 25 March 2012 * @version 1.0 */ typedef struct _tstrHostIFmsg { u16 u16MsgId; /*!< Message ID */ tuniHostIFmsgBody uniHostIFmsgBody; /*!< Message body */ void *drvHandler; } tstrHostIFmsg; #ifdef CONNECT_DIRECT typedef struct _tstrWidJoinReqExt { char SSID[MAX_SSID_LEN]; u8 u8channel; u8 BSSID[6]; } tstrWidJoinReqExt; #endif /*Bug4218: Parsing Join Param*/ #ifdef WILC_PARSE_SCAN_IN_HOST /*Struct containg joinParam of each AP*/ typedef struct _tstrJoinBssParam { BSSTYPE_T bss_type; u8 dtim_period; u16 beacon_period; u16 cap_info; u8 au8bssid[6]; char ssid[MAX_SSID_LEN]; u8 ssidLen; u8 supp_rates[MAX_RATES_SUPPORTED + 1]; u8 ht_capable; u8 wmm_cap; u8 uapsd_cap; bool rsn_found; u8 rsn_grp_policy; u8 mode_802_11i; u8 rsn_pcip_policy[3]; u8 rsn_auth_policy[3]; u8 rsn_cap[2]; struct _tstrJoinParam *nextJoinBss; #ifdef WILC_P2P u32 tsf; u8 u8NoaEnbaled; u8 u8OppEnable; u8 u8CtWindow; u8 u8Count; u8 u8Index; u8 au8Duration[4]; u8 au8Interval[4]; u8 au8StartTime[4]; #endif } tstrJoinBssParam; /*Bug4218: Parsing Join Param*/ /*a linked list table containing needed join parameters entries for each AP found in most recent scan*/ typedef struct _tstrBssTable { u8 u8noBssEntries; tstrJoinBssParam *head; tstrJoinBssParam *tail; } tstrBssTable; #endif /*WILC_PARSE_SCAN_IN_HOST*/ typedef enum { SCAN_TIMER = 0, CONNECT_TIMER = 1, SCAN_CONNECT_TIMER_FORCE_32BIT = 0xFFFFFFFF } tenuScanConnTimer; /*****************************************************************************/ /* */ /* Global Variabls */ /* */ /*****************************************************************************/ tstrWILC_WFIDrv *terminated_handle = NULL; tstrWILC_WFIDrv *gWFiDrvHandle = NULL; #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP bool g_obtainingIP = false; #endif u8 P2P_LISTEN_STATE; static struct task_struct *HostIFthreadHandler; static WILC_MsgQueueHandle gMsgQHostIF; static struct semaphore hSemHostIFthrdEnd; struct semaphore hSemDeinitDrvHandle; static struct semaphore hWaitResponse; struct semaphore hSemHostIntDeinit; WILC_TimerHandle g_hPeriodicRSSI; u8 gau8MulticastMacAddrList[WILC_MULTICAST_TABLE_SIZE][ETH_ALEN]; #ifndef CONNECT_DIRECT static u8 gapu8RcvdSurveyResults[2][MAX_SURVEY_RESULT_FRAG_SIZE]; #endif static u8 gapu8RcvdAssocResp[MAX_ASSOC_RESP_FRAME_SIZE]; bool gbScanWhileConnected = false; static s8 gs8Rssi; static s8 gs8lnkspd; static u8 gu8Chnl; static u8 gs8SetIP[2][4]; static u8 gs8GetIP[2][4]; #ifdef WILC_AP_EXTERNAL_MLME static u32 gu32InactiveTime; static u8 gu8DelBcn; #endif #ifndef SIMULATION static u32 gu32WidConnRstHack; #endif /*BugID_5137*/ u8 *gu8FlushedJoinReq; u8 *gu8FlushedInfoElemAsoc; u8 gu8Flushed11iMode; u8 gu8FlushedAuthType; u32 gu32FlushedJoinReqSize; u32 gu32FlushedInfoElemAsocSize; u32 gu8FlushedJoinReqDrvHandler; #define REAL_JOIN_REQ 0 #define FLUSHED_JOIN_REQ 1 #define FLUSHED_BYTE_POS 79 /* Position the byte indicating flushing in the flushed request */ /*Bug4218: Parsing Join Param*/ #ifdef WILC_PARSE_SCAN_IN_HOST /*Bug4218: Parsing Join Param*/ static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo); #endif /*WILC_PARSE_SCAN_IN_HOST*/ extern void chip_sleep_manually(u32 u32SleepTime); extern int linux_wlan_get_num_conn_ifcs(void); /** * @brief Handle_SetChannel * @details Sending config packet to firmware to set channel * @param[in] tstrHostIFSetChan* pstrHostIFSetChan * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_SetChannel(void *drvHandler, tstrHostIFSetChan *pstrHostIFSetChan) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (char *)&(pstrHostIFSetChan->u8SetChan); strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Setting channel\n"); /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to set channel\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_SetWfiDrvHandler * @details Sending config packet to firmware to set driver handler * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_SetWfiDrvHandler(tstrHostIfSetDrvHandler *pstrHostIfSetDrvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)((pstrHostIfSetDrvHandler->u32Address)); /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_SET_DRV_HANDLER; strWID.enuWIDtype = WID_INT; strWID.ps8WidVal = (s8 *)&(pstrHostIfSetDrvHandler->u32Address); strWID.s32ValueSize = sizeof(u32); /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if ((pstrHostIfSetDrvHandler->u32Address) == (u32)NULL) { up(&hSemDeinitDrvHandle); } if (s32Error) { PRINT_ER("Failed to set driver handler\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_SetWfiAPDrvHandler * @details Sending config packet to firmware to set driver handler * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_SetOperationMode(void *drvHandler, tstrHostIfSetOperationMode *pstrHostIfSetOperationMode) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_SET_OPERATION_MODE; strWID.enuWIDtype = WID_INT; strWID.ps8WidVal = (s8 *)&(pstrHostIfSetOperationMode->u32Mode); strWID.s32ValueSize = sizeof(u32); /*Sending Cfg*/ PRINT_INFO(HOSTINF_DBG, "pstrWFIDrv= %p \n", pstrWFIDrv); s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if ((pstrHostIfSetOperationMode->u32Mode) == (u32)NULL) { up(&hSemDeinitDrvHandle); } if (s32Error) { PRINT_ER("Failed to set driver handler\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_set_IPAddress * @details Setting IP address params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr * @return Error code. * @author * @date * @version 1.0 */ s32 Handle_set_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; char firmwareIPAddress[4] = {0}; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; if (pu8IPAddr[0] < 192) pu8IPAddr[0] = 0; PRINT_INFO(HOSTINF_DBG, "Indx = %d, Handling set IP = %d.%d.%d.%d \n", idx, pu8IPAddr[0], pu8IPAddr[1], pu8IPAddr[2], pu8IPAddr[3]); WILC_memcpy(gs8SetIP[idx], pu8IPAddr, IP_ALEN); /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_IP_ADDRESS; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (u8 *)pu8IPAddr; strWID.s32ValueSize = IP_ALEN; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); host_int_get_ipaddress((WILC_WFIDrvHandle)drvHandler, firmwareIPAddress, idx); if (s32Error) { PRINT_D(HOSTINF_DBG, "Failed to set IP address\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { PRINT_INFO(HOSTINF_DBG, "IP address set\n"); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_get_IPAddress * @details Setting IP address params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8IPAddr * @return Error code. * @author * @date * @version 1.0 */ s32 Handle_get_IPAddress(void *drvHandler, u8 *pu8IPAddr, u8 idx) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_IP_ADDRESS; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (u8 *)WILC_MALLOC(IP_ALEN); strWID.s32ValueSize = IP_ALEN; 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])); WILC_memcpy(gs8GetIP[idx], strWID.ps8WidVal, IP_ALEN); /*get the value by searching the local copy*/ WILC_FREE(strWID.ps8WidVal); if (WILC_memcmp(gs8GetIP[idx], gs8SetIP[idx], IP_ALEN) != 0) host_int_setup_ipaddress((WILC_WFIDrvHandle)pstrWFIDrv, gs8SetIP[idx], idx); if (s32Error != WILC_SUCCESS) { PRINT_ER("Failed to get IP address\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { PRINT_INFO(HOSTINF_DBG, "IP address retrieved:: u8IfIdx = %d \n", idx); PRINT_INFO(HOSTINF_DBG, "%d.%d.%d.%d\n", gs8GetIP[idx][0], gs8GetIP[idx][1], gs8GetIP[idx][2], gs8GetIP[idx][3]); PRINT_INFO(HOSTINF_DBG, "\n"); } WILC_CATCH(s32Error) { } return s32Error; } /*BugId_5077*/ /** * @brief Handle_SetMacAddress * @details Setting mac address * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler * @return Error code. * @author Amr Abdel-Moghny * @date November 2013 * @version 7.0 */ static s32 Handle_SetMacAddress(void *drvHandler, tstrHostIfSetMacAddress *pstrHostIfSetMacAddress) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; u8 *mac_buf = (u8 *)WILC_MALLOC(ETH_ALEN); if (mac_buf == NULL) { PRINT_ER("No buffer to send mac address\n"); return WILC_FAIL; } WILC_memcpy(mac_buf, pstrHostIfSetMacAddress->u8MacAddress, ETH_ALEN); /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_MAC_ADDR; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = mac_buf; 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, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to set mac address\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } WILC_FREE(mac_buf); return s32Error; } /*BugID_5213*/ /** * @brief Handle_GetMacAddress * @details Getting mac address * @param[in] void * drvHandler,tstrHostIfSetDrvHandler* pstrHostIfSetDrvHandler * @return Error code. * @author Amr Abdel-Moghny * @date JAN 2013 * @version 8.0 */ static s32 Handle_GetMacAddress(void *drvHandler, tstrHostIfGetMacAddress *pstrHostIfGetMacAddress) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_MAC_ADDR; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = pstrHostIfGetMacAddress->u8MacAddress; strWID.s32ValueSize = ETH_ALEN; /*Sending Cfg*/ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, false, (u32)drvHandler); if (s32Error) { PRINT_ER("Failed to get mac address\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } up(&hWaitResponse); return s32Error; } /** * @brief Handle_CfgParam * @details Sending config packet to firmware to set CFG params * @param[in] tstrHostIFCfgParamAttr* strHostIFCfgParamAttr * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_CfgParam(void *drvHandler, tstrHostIFCfgParamAttr *strHostIFCfgParamAttr) { s32 s32Error = WILC_SUCCESS; tstrWID strWIDList[32]; u8 u8WidCnt = 0; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; down(&(pstrWFIDrv->gtOsCfgValuesSem)); PRINT_D(HOSTINF_DBG, "Setting CFG params\n"); if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & BSS_TYPE) { /*----------------------------------------------------------*/ /*Input Value: INFRASTRUCTURE = 1, */ /* INDEPENDENT= 2, */ /* ANY_BSS= 3 */ /*----------------------------------------------------------*/ /* 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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.bss_type; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.bss_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.bss_type; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & AUTH_TYPE) { /*------------------------------------------------------*/ /*Input Values: OPEN_SYSTEM = 0, */ /* SHARED_KEY = 1, */ /* ANY = 2 */ /*------------------------------------------------------*/ /*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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_type; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.auth_type = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.auth_type; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & AUTHEN_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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout; strWIDList[u8WidCnt].enuWIDtype = WID_SHORT; strWIDList[u8WidCnt].s32ValueSize = sizeof(u16); pstrWFIDrv->strCfgValues.auth_timeout = strHostIFCfgParamAttr->pstrCfgParamVal.auth_timeout; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & POWER_MANAGEMENT) { /*-----------------------------------------------------------*/ /*Input Values: NO_POWERSAVE = 0, */ /* MIN_FAST_PS = 1, */ /* MAX_FAST_PS = 2, */ /* MIN_PSPOLL_PS = 3, */ /* MAX_PSPOLL_PS = 4 */ /*----------------------------------------------------------*/ if (strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode < 5) { strWIDList[u8WidCnt].u16WIDid = WID_POWER_MANAGEMENT; strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.power_mgmt_mode = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.power_mgmt_mode; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & RETRY_SHORT) { /* 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 = (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; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & RETRY_LONG) { /* 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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit; strWIDList[u8WidCnt].enuWIDtype = WID_SHORT; strWIDList[u8WidCnt].s32ValueSize = sizeof(u16); pstrWFIDrv->strCfgValues.long_retry_limit = strHostIFCfgParamAttr->pstrCfgParamVal.long_retry_limit; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & FRAG_THRESHOLD) { if (strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold > 255 && strHostIFCfgParamAttr->pstrCfgParamVal.frag_threshold < 7937) { strWIDList[u8WidCnt].u16WIDid = WID_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; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & 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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold; strWIDList[u8WidCnt].enuWIDtype = WID_SHORT; strWIDList[u8WidCnt].s32ValueSize = sizeof(u16); pstrWFIDrv->strCfgValues.rts_threshold = strHostIFCfgParamAttr->pstrCfgParamVal.rts_threshold; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & PREAMBLE) { /*-----------------------------------------------------*/ /*Input Values: Short= 0, */ /* Long= 1, */ /* Auto= 2 */ /*------------------------------------------------------*/ if (strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type < 3) { strWIDList[u8WidCnt].u16WIDid = WID_PREAMBLE; strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.preamble_type = strHostIFCfgParamAttr->pstrCfgParamVal.preamble_type; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SHORT_SLOT_ALLOWED) { if (strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed < 2) { strWIDList[u8WidCnt].u16WIDid = WID_SHORT_SLOT_ALLOWED; strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.short_slot_allowed = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.short_slot_allowed; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & TXOP_PROT_DISABLE) { /*Description: used to Disable RTS-CTS protection for TXOP burst*/ /*transmission when the acknowledgement policy is No-Ack or Block-Ack */ /* this information is useful for external supplicant */ /*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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.txop_prot_disabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.txop_prot_disabled; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & 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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval; strWIDList[u8WidCnt].enuWIDtype = WID_SHORT; strWIDList[u8WidCnt].s32ValueSize = sizeof(u16); pstrWFIDrv->strCfgValues.beacon_interval = strHostIFCfgParamAttr->pstrCfgParamVal.beacon_interval; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & 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 = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.dtim_period = strHostIFCfgParamAttr->pstrCfgParamVal.dtim_period; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & SITE_SURVEY) { /*----------------------------------------------------------------------*/ /*Input Values: SITE_SURVEY_1CH = 0, i.e.: currently set channel */ /* SITE_SURVEY_ALL_CH = 1, */ /* SITE_SURVEY_OFF = 2 */ /*----------------------------------------------------------------------*/ if (strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled < 3) { strWIDList[u8WidCnt].u16WIDid = WID_SITE_SURVEY; strWIDList[u8WidCnt].ps8WidVal = (s8 *)&strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled; strWIDList[u8WidCnt].enuWIDtype = WID_CHAR; strWIDList[u8WidCnt].s32ValueSize = sizeof(char); pstrWFIDrv->strCfgValues.site_survey_enabled = (u8)strHostIFCfgParamAttr->pstrCfgParamVal.site_survey_enabled; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & 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 = (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; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & ACTIVE_SCANTIME) { /* 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 = (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; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & PASSIVE_SCANTIME) { /* 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 = (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; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } if (strHostIFCfgParamAttr->pstrCfgParamVal.u32SetCfgFlag & CURRENT_TX_RATE) { CURRENT_TX_RATE_T curr_tx_rate = strHostIFCfgParamAttr->pstrCfgParamVal.curr_tx_rate; /*----------------------------------------------------------------------*/ /*Rates: 1 2 5.5 11 6 9 12 18 24 36 48 54 Auto */ /*InputValues: 1 2 3 4 5 6 7 8 9 10 11 12 0 */ /*----------------------------------------------------------------------*/ /* validate rate */ if (curr_tx_rate == AUTORATE || curr_tx_rate == MBPS_1 || curr_tx_rate == MBPS_2 || curr_tx_rate == MBPS_5_5 || curr_tx_rate == MBPS_11 || curr_tx_rate == MBPS_6 || curr_tx_rate == MBPS_9 || curr_tx_rate == MBPS_12 || 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 = (s8 *)&curr_tx_rate; strWIDList[u8WidCnt].enuWIDtype = WID_SHORT; strWIDList[u8WidCnt].s32ValueSize = sizeof(u16); pstrWFIDrv->strCfgValues.curr_tx_rate = (u8)curr_tx_rate; } else { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8WidCnt++; } s32Error = SendConfigPkt(SET_CFG, strWIDList, u8WidCnt, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Error in setting CFG params\n"); } WILC_CATCH(s32Error) { } up(&(pstrWFIDrv->gtOsCfgValuesSem)); return s32Error; } /** * @brief Handle_wait_msg_q_empty * @details this should be the last msg and then the msg Q becomes idle * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_wait_msg_q_empty(void) { s32 s32Error = WILC_SUCCESS; g_wilc_initialized = 0; up(&hWaitResponse); return s32Error; } /** * @brief Handle_Scan * @details Sending config packet to firmware to set the scan params * @param[in] tstrHostIFscanAttr* pstrHostIFscanAttr * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_Scan(void *drvHandler, tstrHostIFscanAttr *pstrHostIFscanAttr) { s32 s32Error = WILC_SUCCESS; tstrWID strWIDList[5]; u32 u32WidsCount = 0; u32 i; u8 *pu8Buffer; u8 valuesize = 0; u8 *pu8HdnNtwrksWidVal = NULL; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; PRINT_D(HOSTINF_DBG, "Setting SCAN params\n"); PRINT_D(HOSTINF_DBG, "Scanning: In [%d] state \n", pstrWFIDrv->enuHostIFstate); pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = pstrHostIFscanAttr->pfScanResult; pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid = pstrHostIFscanAttr->pvUserArg; #ifdef WILC_P2P #endif if ((pstrWFIDrv->enuHostIFstate >= HOST_IF_SCANNING) && (pstrWFIDrv->enuHostIFstate < HOST_IF_CONNECTED)) { /* here we either in HOST_IF_SCANNING, HOST_IF_WAITING_CONN_REQ or HOST_IF_WAITING_CONN_RESP */ PRINT_D(GENERIC_DBG, "Don't scan we are already in [%d] state\n", pstrWFIDrv->enuHostIFstate); WILC_ERRORREPORT(s32Error, WILC_BUSY); } #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP if (g_obtainingIP || connecting) { PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n"); WILC_ERRORREPORT(s32Error, WILC_BUSY); } #endif PRINT_D(HOSTINF_DBG, "Setting SCAN params\n"); pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount = 0; /*BugID_4189*/ strWIDList[u32WidsCount].u16WIDid = (u16)WID_SSID_PROBE_REQ; strWIDList[u32WidsCount].enuWIDtype = WID_STR; for (i = 0; i < pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum; i++) { valuesize += ((pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen) + 1); } pu8HdnNtwrksWidVal = WILC_MALLOC(valuesize + 1); strWIDList[u32WidsCount].ps8WidVal = pu8HdnNtwrksWidVal; if (strWIDList[u32WidsCount].ps8WidVal != NULL) { pu8Buffer = strWIDList[u32WidsCount].ps8WidVal; *pu8Buffer++ = pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum; PRINT_D(HOSTINF_DBG, "In Handle_ProbeRequest number of ssid %d\n", pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum); for (i = 0; i < pstrHostIFscanAttr->strHiddenNetwork.u8ssidnum; i++) { *pu8Buffer++ = pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen; WILC_memcpy(pu8Buffer, pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].pu8ssid, pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen); pu8Buffer += pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo[i].u8ssidlen; } strWIDList[u32WidsCount].s32ValueSize = (s32)(valuesize + 1); u32WidsCount++; } /*filling cfg param array*/ /* if((pstrHostIFscanAttr->pu8IEs != NULL) && (pstrHostIFscanAttr->IEsLen != 0)) */ { /* IEs to be inserted in Probe Request */ strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_PROBE; strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA; strWIDList[u32WidsCount].ps8WidVal = pstrHostIFscanAttr->pu8IEs; strWIDList[u32WidsCount].s32ValueSize = pstrHostIFscanAttr->IEsLen; u32WidsCount++; } /*Scan Type*/ strWIDList[u32WidsCount].u16WIDid = WID_SCAN_TYPE; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanType)); u32WidsCount++; /*list of channels to be scanned*/ strWIDList[u32WidsCount].u16WIDid = WID_SCAN_CHANNEL_LIST; strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA; /* Bug 4648: Convert channel numbers to start from 0 not 1. */ if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL && pstrHostIFscanAttr->u8ChnlListLen > 0) { int i; for (i = 0; i < pstrHostIFscanAttr->u8ChnlListLen; i++) { if (pstrHostIFscanAttr->pu8ChnlFreqList[i] > 0) { pstrHostIFscanAttr->pu8ChnlFreqList[i] = pstrHostIFscanAttr->pu8ChnlFreqList[i] - 1; } } } strWIDList[u32WidsCount].ps8WidVal = pstrHostIFscanAttr->pu8ChnlFreqList; strWIDList[u32WidsCount].s32ValueSize = pstrHostIFscanAttr->u8ChnlListLen; u32WidsCount++; /*Scan Request*/ strWIDList[u32WidsCount].u16WIDid = WID_START_SCAN_REQ; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrHostIFscanAttr->u8ScanSource)); u32WidsCount++; /*keep the state as is , no need to change it*/ /* gWFiDrvHandle->enuHostIFstate = HOST_IF_SCANNING; */ if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) { gbScanWhileConnected = true; } else if (pstrWFIDrv->enuHostIFstate == HOST_IF_IDLE) { gbScanWhileConnected = false; } s32Error = SendConfigPkt(SET_CFG, strWIDList, u32WidsCount, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send scan paramters config packet\n"); WILC_ERRORREPORT(s32Error, s32Error); } else { PRINT_D(HOSTINF_DBG, "Successfully sent SCAN params config packet\n"); } WILC_CATCH(s32Error) { WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL); /*if there is an ongoing scan request*/ Handle_ScanDone(drvHandler, SCAN_EVENT_ABORTED); } /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */ if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL) { WILC_FREE(pstrHostIFscanAttr->pu8ChnlFreqList); pstrHostIFscanAttr->pu8ChnlFreqList = NULL; } /* Deallocate pstrHostIFscanAttr->pu8IEs which was previously allocated by the sending thread */ if (pstrHostIFscanAttr->pu8IEs != NULL) { WILC_FREE(pstrHostIFscanAttr->pu8IEs); pstrHostIFscanAttr->pu8IEs = NULL; } if (pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo != NULL) { WILC_FREE(pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo); pstrHostIFscanAttr->strHiddenNetwork.pstrHiddenNetworkInfo = NULL; } /* Deallocate pstrHostIFscanAttr->u8ChnlListLen which was prevoisuly allocated by the sending thread */ if (pstrHostIFscanAttr->pu8ChnlFreqList != NULL) { WILC_FREE(pstrHostIFscanAttr->pu8ChnlFreqList); pstrHostIFscanAttr->pu8ChnlFreqList = NULL; } if (pu8HdnNtwrksWidVal != NULL) { WILC_FREE(pu8HdnNtwrksWidVal); } return s32Error; } /** * @brief Handle_ScanDone * @details Call scan notification callback function * @param[in] NONE * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_ScanDone(void *drvHandler, tenuScanEvent enuEvent) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; u8 u8abort_running_scan; tstrWID strWID; PRINT_D(HOSTINF_DBG, "in Handle_ScanDone()\n"); /*BugID_4978*/ /*Ask FW to abort the running scan, if any*/ if (enuEvent == SCAN_EVENT_ABORTED) { PRINT_D(GENERIC_DBG, "Abort running scan\n"); u8abort_running_scan = 1; strWID.u16WIDid = (u16)WID_ABORT_RUNNING_SCAN; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&u8abort_running_scan; strWID.s32ValueSize = sizeof(char); /*Sending Cfg*/ 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); } WILC_CATCH(s32Error) { } } if (pstrWFIDrv == NULL) { PRINT_ER("Driver handler is NULL\n"); return s32Error; } /*if there is an ongoing scan request*/ if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(enuEvent, NULL, pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL); /*delete current scan request*/ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL; } return s32Error; } /** * @brief Handle_Connect * @details Sending config packet to firmware to starting connection * @param[in] tstrHostIFconnectAttr* pstrHostIFconnectAttr * @return Error code. * @author * @date * @version 1.0 */ u8 u8ConnectedSSID[6] = {0}; static s32 Handle_Connect(void *drvHandler, tstrHostIFconnectAttr *pstrHostIFconnectAttr) { tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; s32 s32Error = WILC_SUCCESS; tstrWID strWIDList[8]; u32 u32WidsCount = 0, dummyval = 0; /* char passphrase[] = "12345678"; */ #ifndef CONNECT_DIRECT s32 s32Err = WILC_SUCCESS; u32 i; u8 u8bssDscListIndex; wid_site_survey_reslts_s *pstrSurveyResults = NULL; #else u8 *pu8CurrByte = NULL; /*Bug4218: Parsing Join Param*/ #ifdef WILC_PARSE_SCAN_IN_HOST tstrJoinBssParam *ptstrJoinBssParam; #endif /*WILC_PARSE_SCAN_IN_HOST*/ #endif PRINT_D(GENERIC_DBG, "Handling connect request\n"); #ifndef CONNECT_DIRECT WILC_memset(gapu8RcvdSurveyResults[0], 0, MAX_SURVEY_RESULT_FRAG_SIZE); WILC_memset(gapu8RcvdSurveyResults[1], 0, MAX_SURVEY_RESULT_FRAG_SIZE); PRINT_D(HOSTINF_DBG, "Getting site survey results\n"); s32Err = host_int_get_site_survey_results((WILC_WFIDrvHandle)pstrWFIDrv, gapu8RcvdSurveyResults, MAX_SURVEY_RESULT_FRAG_SIZE); if (s32Err) { PRINT_ER("Failed to get site survey results\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } s32Err = ParseSurveyResults(gapu8RcvdSurveyResults, &pstrSurveyResults, &pstrWFIDrv->u32SurveyResultsCount); if (s32Err == WILC_SUCCESS) { /* use the parsed info in pstrSurveyResults, then deallocate it */ PRINT_D(HOSTINF_DBG, "Copying site survey results in global structure, then deallocate\n"); for (i = 0; i < pstrWFIDrv->u32SurveyResultsCount; i++) { WILC_memcpy(&pstrWFIDrv->astrSurveyResults[i], &pstrSurveyResults[i], sizeof(wid_site_survey_reslts_s)); } DeallocateSurveyResults(pstrSurveyResults); } else { WILC_ERRORREPORT(s32Error, WILC_FAIL); PRINT_ER("ParseSurveyResults() Error(%d) \n", s32Err); } for (i = 0; i < pstrWFIDrv->u32SurveyResultsCount; i++) { if (WILC_memcmp(pstrWFIDrv->astrSurveyResults[i].SSID, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen) == 0) { PRINT_INFO(HOSTINF_DBG, "Network with required SSID is found %s\n", pstrHostIFconnectAttr->pu8ssid); if (pstrHostIFconnectAttr->pu8bssid == NULL) { /* BSSID is not passed from the user, so decision of matching * is done by SSID only */ PRINT_INFO(HOSTINF_DBG, "BSSID is not passed from the user\n"); break; } else { /* BSSID is also passed from the user, so decision of matching * should consider also this passed BSSID */ if (WILC_memcmp(pstrWFIDrv->astrSurveyResults[i].BSSID, pstrHostIFconnectAttr->pu8bssid, 6) == 0) { PRINT_INFO(HOSTINF_DBG, "BSSID is passed from the user and matched\n"); break; } } } } if (i < pstrWFIDrv->u32SurveyResultsCount) { u8bssDscListIndex = i; PRINT_INFO(HOSTINF_DBG, "Connecting to network of Bss Idx %d and SSID %s and channel %d \n", u8bssDscListIndex, pstrWFIDrv->astrSurveyResults[u8bssDscListIndex].SSID, pstrWFIDrv->astrSurveyResults[u8bssDscListIndex].Channel); PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n"); if (pstrHostIFconnectAttr->pu8bssid != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6); } pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen; if (pstrHostIFconnectAttr->pu8ssid != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0'; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen; if (pstrHostIFconnectAttr->pu8IEs != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs, pstrHostIFconnectAttr->IEsLen); } pstrWFIDrv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->u8security; pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->tenuAuth_type; pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->pfConnectResult; pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->pvUserArg; /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */ /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */ { /* IEs to be inserted in Association Request */ strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE; strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA; strWIDList[u32WidsCount].ps8WidVal = pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs; strWIDList[u32WidsCount].s32ValueSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen; u32WidsCount++; } strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(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(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&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].ps8WidVal = (s8*)(passphrase); * u32WidsCount++; */ strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)&u8bssDscListIndex; u32WidsCount++; #ifndef SIMULATION /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the * firmware at chip reset when processing the WIDs of the Connect Request. * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */ /* ////////////////////// */ gu32WidConnRstHack = 0; /* ////////////////////// */ #endif 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); } else { pstrWFIDrv->enuHostIFstate = HOST_IF_WAITING_CONN_RESP; } } else { PRINT_ER("Required BSSID not found\n"); WILC_ERRORREPORT(s32Error, WILC_NOT_FOUND); } #else /* if we try to connect to an already connected AP then discard the request */ if (WILC_memcmp(pstrHostIFconnectAttr->pu8bssid, u8ConnectedSSID, ETH_ALEN) == 0) { s32Error = WILC_SUCCESS; PRINT_ER("Trying to connect to an already connected AP, Discard connect request\n"); return s32Error; } PRINT_INFO(HOSTINF_DBG, "Saving connection parameters in global structure\n"); /*Bug4218: Parsing Join Param*/ #ifdef WILC_PARSE_SCAN_IN_HOST ptstrJoinBssParam = (tstrJoinBssParam *)pstrHostIFconnectAttr->pJoinParams; if (ptstrJoinBssParam == NULL) { PRINT_ER("Required BSSID not found\n"); WILC_ERRORREPORT(s32Error, WILC_NOT_FOUND); } #endif /*WILC_PARSE_SCAN_IN_HOST*/ if (pstrHostIFconnectAttr->pu8bssid != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = (u8 *)WILC_MALLOC(6); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, pstrHostIFconnectAttr->pu8bssid, 6); } pstrWFIDrv->strWILC_UsrConnReq.ssidLen = pstrHostIFconnectAttr->ssidLen; if (pstrHostIFconnectAttr->pu8ssid != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->ssidLen + 1); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid[pstrHostIFconnectAttr->ssidLen] = '\0'; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = pstrHostIFconnectAttr->IEsLen; if (pstrHostIFconnectAttr->pu8IEs != NULL) { pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen); WILC_memcpy(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrHostIFconnectAttr->pu8IEs, pstrHostIFconnectAttr->IEsLen); } pstrWFIDrv->strWILC_UsrConnReq.u8security = pstrHostIFconnectAttr->u8security; pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type = pstrHostIFconnectAttr->tenuAuth_type; pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult = pstrHostIFconnectAttr->pfConnectResult; pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid = pstrHostIFconnectAttr->pvUserArg; strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(dummyval)); u32WidsCount++; /* if((gWFiDrvHandle->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) && */ /* (gWFiDrvHandle->strWILC_UsrConnReq.ConnReqIEsLen != 0)) */ { /* IEs to be inserted in Association Request */ strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE; strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA; strWIDList[u32WidsCount].ps8WidVal = pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs; strWIDList[u32WidsCount].s32ValueSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen; u32WidsCount++; /*BugID_5137*/ if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) { gu32FlushedInfoElemAsocSize = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen; gu8FlushedInfoElemAsoc = WILC_MALLOC(gu32FlushedInfoElemAsocSize); memcpy(gu8FlushedInfoElemAsoc, pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, gu32FlushedInfoElemAsocSize); } } strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrWFIDrv->strWILC_UsrConnReq.u8security)); u32WidsCount++; /*BugID_5137*/ if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) gu8Flushed11iMode = pstrWFIDrv->strWILC_UsrConnReq.u8security; 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(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type); u32WidsCount++; /*BugID_5137*/ if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) gu8FlushedAuthType = (u8)pstrWFIDrv->strWILC_UsrConnReq.tenuAuth_type; 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].ps8WidVal = (s8*)(passphrase); * u32WidsCount++; */ PRINT_D(HOSTINF_DBG, "Connecting to network of SSID %s on channel %d\n", pstrWFIDrv->strWILC_UsrConnReq.pu8ssid, pstrHostIFconnectAttr->u8channel); #ifndef WILC_PARSE_SCAN_IN_HOST strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED; strWIDList[u32WidsCount].enuWIDtype = WID_STR; strWIDList[u32WidsCount].s32ValueSize = MAX_SSID_LEN + 7; strWIDList[u32WidsCount].ps8WidVal = WILC_MALLOC(strWIDList[u32WidsCount].s32ValueSize); if (strWIDList[u32WidsCount].ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal; if (pstrHostIFconnectAttr->pu8ssid != NULL) { WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen); pu8CurrByte[pstrHostIFconnectAttr->ssidLen] = '\0'; } pu8CurrByte += MAX_SSID_LEN; if ((pstrHostIFconnectAttr->u8channel >= 1) && (pstrHostIFconnectAttr->u8channel <= 14)) { *(pu8CurrByte++) = pstrHostIFconnectAttr->u8channel; } else { PRINT_ER("Channel out of range\n"); *(pu8CurrByte++) = 0xFF; } if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6); } pu8CurrByte += 6; /* keep the buffer at the start of the allocated pointer to use it with the free*/ pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal; #else strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED; strWIDList[u32WidsCount].enuWIDtype = WID_STR; /*Sending NoA attributes during connection*/ strWIDList[u32WidsCount].s32ValueSize = 112; /* 79; */ strWIDList[u32WidsCount].ps8WidVal = WILC_MALLOC(strWIDList[u32WidsCount].s32ValueSize); /*BugID_5137*/ if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) { gu32FlushedJoinReqSize = strWIDList[u32WidsCount].s32ValueSize; gu8FlushedJoinReq = WILC_MALLOC(gu32FlushedJoinReqSize); } if (strWIDList[u32WidsCount].ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal; if (pstrHostIFconnectAttr->pu8ssid != NULL) { WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8ssid, pstrHostIFconnectAttr->ssidLen); pu8CurrByte[pstrHostIFconnectAttr->ssidLen] = '\0'; } pu8CurrByte += MAX_SSID_LEN; /* BSS type*/ *(pu8CurrByte++) = INFRASTRUCTURE; /* Channel*/ if ((pstrHostIFconnectAttr->u8channel >= 1) && (pstrHostIFconnectAttr->u8channel <= 14)) { *(pu8CurrByte++) = pstrHostIFconnectAttr->u8channel; } else { PRINT_ER("Channel out of range\n"); *(pu8CurrByte++) = 0xFF; } /* Cap Info*/ *(pu8CurrByte++) = (ptstrJoinBssParam->cap_info) & 0xFF; *(pu8CurrByte++) = ((ptstrJoinBssParam->cap_info) >> 8) & 0xFF; PRINT_D(HOSTINF_DBG, "* Cap Info %0x*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8))); /* sa*/ if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6); } pu8CurrByte += 6; /* bssid*/ if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_memcpy(pu8CurrByte, pstrHostIFconnectAttr->pu8bssid, 6); } pu8CurrByte += 6; /* Beacon Period*/ *(pu8CurrByte++) = (ptstrJoinBssParam->beacon_period) & 0xFF; *(pu8CurrByte++) = ((ptstrJoinBssParam->beacon_period) >> 8) & 0xFF; PRINT_D(HOSTINF_DBG, "* Beacon Period %d*\n", (*(pu8CurrByte - 2) | ((*(pu8CurrByte - 1)) << 8))); /* DTIM Period*/ *(pu8CurrByte++) = ptstrJoinBssParam->dtim_period; PRINT_D(HOSTINF_DBG, "* DTIM Period %d*\n", (*(pu8CurrByte - 1))); /* Supported rates*/ WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->supp_rates, MAX_RATES_SUPPORTED + 1); pu8CurrByte += (MAX_RATES_SUPPORTED + 1); /* wmm cap*/ *(pu8CurrByte++) = ptstrJoinBssParam->wmm_cap; PRINT_D(HOSTINF_DBG, "* wmm cap%d*\n", (*(pu8CurrByte - 1))); /* uapsd cap*/ *(pu8CurrByte++) = ptstrJoinBssParam->uapsd_cap; /* ht cap*/ *(pu8CurrByte++) = ptstrJoinBssParam->ht_capable; /* copy this information to the user request */ pstrWFIDrv->strWILC_UsrConnReq.IsHTCapable = ptstrJoinBssParam->ht_capable; /* rsn found*/ *(pu8CurrByte++) = ptstrJoinBssParam->rsn_found; PRINT_D(HOSTINF_DBG, "* rsn found %d*\n", *(pu8CurrByte - 1)); /* rsn group policy*/ *(pu8CurrByte++) = ptstrJoinBssParam->rsn_grp_policy; PRINT_D(HOSTINF_DBG, "* rsn group policy %0x*\n", (*(pu8CurrByte - 1))); /* mode_802_11i*/ *(pu8CurrByte++) = ptstrJoinBssParam->mode_802_11i; PRINT_D(HOSTINF_DBG, "* mode_802_11i %d*\n", (*(pu8CurrByte - 1))); /* rsn pcip policy*/ WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_pcip_policy, sizeof(ptstrJoinBssParam->rsn_pcip_policy)); pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_pcip_policy); /* rsn auth policy*/ WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_auth_policy, sizeof(ptstrJoinBssParam->rsn_auth_policy)); pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_auth_policy); /* rsn auth policy*/ WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->rsn_cap, sizeof(ptstrJoinBssParam->rsn_cap)); pu8CurrByte += sizeof(ptstrJoinBssParam->rsn_cap); /*BugID_5137*/ *(pu8CurrByte++) = REAL_JOIN_REQ; #ifdef WILC_P2P *(pu8CurrByte++) = ptstrJoinBssParam->u8NoaEnbaled; if (ptstrJoinBssParam->u8NoaEnbaled) { PRINT_D(HOSTINF_DBG, "NOA present\n"); *(pu8CurrByte++) = (ptstrJoinBssParam->tsf) & 0xFF; *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 8) & 0xFF; *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 16) & 0xFF; *(pu8CurrByte++) = ((ptstrJoinBssParam->tsf) >> 24) & 0xFF; *(pu8CurrByte++) = ptstrJoinBssParam->u8Index; *(pu8CurrByte++) = ptstrJoinBssParam->u8OppEnable; if (ptstrJoinBssParam->u8OppEnable) *(pu8CurrByte++) = ptstrJoinBssParam->u8CtWindow; *(pu8CurrByte++) = ptstrJoinBssParam->u8Count; WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8Duration, sizeof(ptstrJoinBssParam->au8Duration)); pu8CurrByte += sizeof(ptstrJoinBssParam->au8Duration); WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8Interval, sizeof(ptstrJoinBssParam->au8Interval)); pu8CurrByte += sizeof(ptstrJoinBssParam->au8Interval); WILC_memcpy(pu8CurrByte, ptstrJoinBssParam->au8StartTime, sizeof(ptstrJoinBssParam->au8StartTime)); pu8CurrByte += sizeof(ptstrJoinBssParam->au8StartTime); } else PRINT_D(HOSTINF_DBG, "NOA not present\n"); #endif /* keep the buffer at the start of the allocated pointer to use it with the free*/ pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal; #endif /* #ifdef WILC_PARSE_SCAN_IN_HOST*/ u32WidsCount++; #ifndef SIMULATION /* A temporary workaround to avoid handling the misleading MAC_DISCONNECTED raised from the * firmware at chip reset when processing the WIDs of the Connect Request. * (This workaround should be removed in the future when the Chip reset of the Connect WIDs is disabled) */ /* ////////////////////// */ gu32WidConnRstHack = 0; /* ////////////////////// */ #endif /*BugID_5137*/ if (WILC_memcmp("DIRECT-", pstrHostIFconnectAttr->pu8ssid, 7)) { memcpy(gu8FlushedJoinReq, pu8CurrByte, gu32FlushedJoinReqSize); gu8FlushedJoinReqDrvHandler = (u32)pstrWFIDrv; } PRINT_D(GENERIC_DBG, "send HOST_IF_WAITING_CONN_RESP\n"); if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_memcpy(u8ConnectedSSID, pstrHostIFconnectAttr->pu8bssid, ETH_ALEN); PRINT_D(GENERIC_DBG, "save Bssid = %x:%x:%x:%x:%x:%x\n", (pstrHostIFconnectAttr->pu8bssid[0]), (pstrHostIFconnectAttr->pu8bssid[1]), (pstrHostIFconnectAttr->pu8bssid[2]), (pstrHostIFconnectAttr->pu8bssid[3]), (pstrHostIFconnectAttr->pu8bssid[4]), (pstrHostIFconnectAttr->pu8bssid[5])); 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, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Handle_Connect()] failed to send config packet\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { PRINT_D(GENERIC_DBG, "set HOST_IF_WAITING_CONN_RESP\n"); pstrWFIDrv->enuHostIFstate = HOST_IF_WAITING_CONN_RESP; } #endif WILC_CATCH(s32Error) { tstrConnectInfo strConnectInfo; WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL); PRINT_D(HOSTINF_DBG, "could not start connecting to the required network\n"); WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo)); if (pstrHostIFconnectAttr->pfConnectResult != NULL) { if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_memcpy(strConnectInfo.au8bssid, pstrHostIFconnectAttr->pu8bssid, 6); } if (pstrHostIFconnectAttr->pu8IEs != NULL) { strConnectInfo.ReqIEsLen = pstrHostIFconnectAttr->IEsLen; strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrHostIFconnectAttr->IEsLen); WILC_memcpy(strConnectInfo.pu8ReqIEs, pstrHostIFconnectAttr->pu8IEs, pstrHostIFconnectAttr->IEsLen); } pstrHostIFconnectAttr->pfConnectResult(CONN_DISCONN_EVENT_CONN_RESP, &strConnectInfo, MAC_DISCONNECTED, NULL, pstrHostIFconnectAttr->pvUserArg); /*Change state to idle*/ pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; /* Deallocation */ if (strConnectInfo.pu8ReqIEs != NULL) { WILC_FREE(strConnectInfo.pu8ReqIEs); strConnectInfo.pu8ReqIEs = NULL; } } else { PRINT_ER("Connect callback function pointer is NULL \n"); } } PRINT_D(HOSTINF_DBG, "Deallocating connection parameters\n"); /* Deallocate pstrHostIFconnectAttr->pu8bssid which was prevoisuly allocated by the sending thread */ if (pstrHostIFconnectAttr->pu8bssid != NULL) { WILC_FREE(pstrHostIFconnectAttr->pu8bssid); pstrHostIFconnectAttr->pu8bssid = NULL; } /* Deallocate pstrHostIFconnectAttr->pu8ssid which was prevoisuly allocated by the sending thread */ if (pstrHostIFconnectAttr->pu8ssid != NULL) { WILC_FREE(pstrHostIFconnectAttr->pu8ssid); pstrHostIFconnectAttr->pu8ssid = NULL; } /* Deallocate pstrHostIFconnectAttr->pu8IEs which was prevoisuly allocated by the sending thread */ if (pstrHostIFconnectAttr->pu8IEs != NULL) { WILC_FREE(pstrHostIFconnectAttr->pu8IEs); pstrHostIFconnectAttr->pu8IEs = NULL; } if (pu8CurrByte != NULL) { WILC_FREE(pu8CurrByte); } return s32Error; } /** * @brief Handle_FlushConnect * @details Sending config packet to firmware to flush an old connection * after switching FW from station one to hybrid one * @param[in] void * drvHandler * @return Error code. * @author Amr Abdel-Moghny * @date 19 DEC 2013 * @version 8.0 */ static s32 Handle_FlushConnect(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWIDList[5]; u32 u32WidsCount = 0; u8 *pu8CurrByte = NULL; /* IEs to be inserted in Association Request */ strWIDList[u32WidsCount].u16WIDid = WID_INFO_ELEMENT_ASSOCIATE; strWIDList[u32WidsCount].enuWIDtype = WID_BIN_DATA; strWIDList[u32WidsCount].ps8WidVal = gu8FlushedInfoElemAsoc; strWIDList[u32WidsCount].s32ValueSize = gu32FlushedInfoElemAsocSize; u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = (u16)WID_11I_MODE; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(gu8Flushed11iMode)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = (u16)WID_AUTH_TYPE; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&gu8FlushedAuthType); u32WidsCount++; #ifdef WILC_PARSE_SCAN_IN_HOST strWIDList[u32WidsCount].u16WIDid = (u16)WID_JOIN_REQ_EXTENDED; strWIDList[u32WidsCount].enuWIDtype = WID_STR; strWIDList[u32WidsCount].s32ValueSize = gu32FlushedJoinReqSize; strWIDList[u32WidsCount].ps8WidVal = (s8 *)gu8FlushedJoinReq; pu8CurrByte = strWIDList[u32WidsCount].ps8WidVal; pu8CurrByte += FLUSHED_BYTE_POS; *(pu8CurrByte) = FLUSHED_JOIN_REQ; u32WidsCount++; #endif 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); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_ConnectTimeout * @details Call connect notification callback function indicating connection failure * @param[in] NONE * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_ConnectTimeout(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrConnectInfo strConnectInfo; tstrWID strWID; u16 u16DummyReasonCode = 0; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; if (pstrWFIDrv == NULL) { PRINT_ER("Driver handler is NULL\n"); return s32Error; } pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; gbScanWhileConnected = false; WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo)); /* First, we will notify the upper layer with the Connection failure {through the Connect Callback function}, * then we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying * WID_DISCONNECT} */ if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) { if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { WILC_memcpy(strConnectInfo.au8bssid, pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, 6); } if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen; strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen); WILC_memcpy(strConnectInfo.pu8ReqIEs, pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen); } pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP, &strConnectInfo, MAC_DISCONNECTED, NULL, pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid); /* Deallocation of strConnectInfo.pu8ReqIEs */ if (strConnectInfo.pu8ReqIEs != NULL) { WILC_FREE(strConnectInfo.pu8ReqIEs); strConnectInfo.pu8ReqIEs = NULL; } } else { PRINT_ER("Connect callback function pointer is NULL \n"); } /* Here we will notify our firmware also with the Connection failure {through sending to it Cfg packet carrying * WID_DISCONNECT} */ strWID.u16WIDid = (u16)WID_DISCONNECT; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&u16DummyReasonCode; strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Sending disconnect request\n"); s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send dissconect config packet\n"); } /* Deallocation of the Saved Connect Request in the global Handle */ pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL; } if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid); pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs); pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL; } WILC_memset(u8ConnectedSSID, 0, ETH_ALEN); /*BugID_5213*/ /*Freeing flushed join request params on connect timeout*/ if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedJoinReq); gu8FlushedJoinReq = NULL; } if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedInfoElemAsoc); gu8FlushedInfoElemAsoc = NULL; } return s32Error; } /** * @brief Handle_RcvdNtwrkInfo * @details Handling received network information * @param[in] tstrRcvdNetworkInfo* pstrRcvdNetworkInfo * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_RcvdNtwrkInfo(void *drvHandler, tstrRcvdNetworkInfo *pstrRcvdNetworkInfo) { u32 i; bool bNewNtwrkFound; s32 s32Error = WILC_SUCCESS; tstrNetworkInfo *pstrNetworkInfo = NULL; void *pJoinParams = NULL; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; bNewNtwrkFound = true; PRINT_INFO(HOSTINF_DBG, "Handling received network info\n"); /*if there is a an ongoing scan request*/ if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { PRINT_D(HOSTINF_DBG, "State: Scanning, parsing network information received\n"); ParseNetworkInfo(pstrRcvdNetworkInfo->pu8Buffer, &pstrNetworkInfo); if ((pstrNetworkInfo == NULL) || (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult == NULL)) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* check whether this network is discovered before */ for (i = 0; i < pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount; i++) { if ((pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid != NULL) && (pstrNetworkInfo->au8bssid != NULL)) { if (WILC_memcmp(pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].au8bssid, pstrNetworkInfo->au8bssid, 6) == 0) { if (pstrNetworkInfo->s8rssi <= pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[i].s8rssi) { /*we have already found this network with better rssi, so keep the old cached one and don't * send anything to the upper layer */ PRINT_D(HOSTINF_DBG, "Network previously discovered\n"); goto done; } else { /* here the same already found network is found again but with a better rssi, so just update * 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 = false; break; } } } } if (bNewNtwrkFound == true) { /* here it is confirmed that it is a new discovered network, * so add its record then call the User CallBack function */ PRINT_D(HOSTINF_DBG, "New network found\n"); if (pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount < MAX_NUM_SCANNED_NETWORKS) { pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].s8rssi = pstrNetworkInfo->s8rssi; if ((pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid != NULL) && (pstrNetworkInfo->au8bssid != NULL)) { WILC_memcpy(pstrWFIDrv->strWILC_UsrScanReq.astrFoundNetworkInfo[pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount].au8bssid, pstrNetworkInfo->au8bssid, 6); pstrWFIDrv->strWILC_UsrScanReq.u32RcvdChCount++; pstrNetworkInfo->bNewNetwork = true; /*Bug4218: Parsing Join Param*/ /* add new BSS to JoinBssTable */ #ifdef WILC_PARSE_SCAN_IN_HOST pJoinParams = host_int_ParseJoinBssParam(pstrNetworkInfo); #endif /*WILC_PARSE_SCAN_IN_HOST*/ pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_NETWORK_FOUND, pstrNetworkInfo, pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, pJoinParams); } } else { PRINT_WRN(HOSTINF_DBG, "Discovered networks exceeded max. limit \n"); } } else { 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); } } WILC_CATCH(s32Error) { } done: /* Deallocate pstrRcvdNetworkInfo->pu8Buffer which was prevoisuly allocated by the sending thread */ if (pstrRcvdNetworkInfo->pu8Buffer != NULL) { WILC_FREE(pstrRcvdNetworkInfo->pu8Buffer); pstrRcvdNetworkInfo->pu8Buffer = NULL; } /*free structure allocated*/ if (pstrNetworkInfo != NULL) { DeallocateNetworkInfo(pstrNetworkInfo); pstrNetworkInfo = NULL; } return s32Error; } /** * @brief Handle_RcvdGnrlAsyncInfo * @details Handling received asynchrous general network information * @param[in] tstrRcvdGnrlAsyncInfo* pstrRcvdGnrlAsyncInfo * @return Error code. * @author * @date * @version 1.0 */ static s32 Handle_RcvdGnrlAsyncInfo(void *drvHandler, tstrRcvdGnrlAsyncInfo *pstrRcvdGnrlAsyncInfo) { /* TODO: mostafa: till now, this function just handles only the received mac status msg, */ /* which carries only 1 WID which have WID ID = WID_STATUS */ s32 s32Error = WILC_SUCCESS; u8 u8MsgType = 0; u8 u8MsgID = 0; u16 u16MsgLen = 0; u16 u16WidID = (u16)WID_NIL; u8 u8WidLen = 0; u8 u8MacStatus; u8 u8MacStatusReasonCode; u8 u8MacStatusAdditionalInfo; tstrConnectInfo strConnectInfo; tstrDisconnectNotifInfo strDisconnectNotifInfo; s32 s32Err = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; if (pstrWFIDrv == NULL) { PRINT_ER("Driver handler is NULL\n"); } PRINT_D(GENERIC_DBG, "Current State = %d,Received state = %d\n", pstrWFIDrv->enuHostIFstate, pstrRcvdGnrlAsyncInfo->pu8Buffer[7]); if ((pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) || (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) || pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { if ((pstrRcvdGnrlAsyncInfo->pu8Buffer == NULL) || (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL)) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } u8MsgType = pstrRcvdGnrlAsyncInfo->pu8Buffer[0]; /* Check whether the received message type is 'I' */ if ('I' != u8MsgType) { PRINT_ER("Received Message format incorrect.\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } /* Extract message ID */ u8MsgID = pstrRcvdGnrlAsyncInfo->pu8Buffer[1]; /* Extract message Length */ u16MsgLen = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->pu8Buffer[2], pstrRcvdGnrlAsyncInfo->pu8Buffer[3]); /* Extract WID ID [expected to be = WID_STATUS] */ u16WidID = MAKE_WORD16(pstrRcvdGnrlAsyncInfo->pu8Buffer[4], pstrRcvdGnrlAsyncInfo->pu8Buffer[5]); /* Extract WID Length [expected to be = 1] */ u8WidLen = pstrRcvdGnrlAsyncInfo->pu8Buffer[6]; /* get the WID value [expected to be one of two values: either MAC_CONNECTED = (1) or MAC_DISCONNECTED = (0)] */ u8MacStatus = pstrRcvdGnrlAsyncInfo->pu8Buffer[7]; u8MacStatusReasonCode = pstrRcvdGnrlAsyncInfo->pu8Buffer[8]; u8MacStatusAdditionalInfo = pstrRcvdGnrlAsyncInfo->pu8Buffer[9]; PRINT_INFO(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Info = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo); if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) { /* our station had sent Association Request frame, so here it will get the Association Response frame then parse it */ u32 u32RcvdAssocRespInfoLen; tstrConnectRespInfo *pstrConnectRespInfo = NULL; PRINT_D(HOSTINF_DBG, "Recieved MAC status = %d with Reason = %d , Code = %d\n", u8MacStatus, u8MacStatusReasonCode, u8MacStatusAdditionalInfo); WILC_memset(&strConnectInfo, 0, sizeof(tstrConnectInfo)); if (u8MacStatus == MAC_CONNECTED) { WILC_memset(gapu8RcvdAssocResp, 0, MAX_ASSOC_RESP_FRAME_SIZE); host_int_get_assoc_res_info((WILC_WFIDrvHandle)pstrWFIDrv, gapu8RcvdAssocResp, MAX_ASSOC_RESP_FRAME_SIZE, &u32RcvdAssocRespInfoLen); PRINT_INFO(HOSTINF_DBG, "Received association response with length = %d\n", u32RcvdAssocRespInfoLen); if (u32RcvdAssocRespInfoLen != 0) { PRINT_D(HOSTINF_DBG, "Parsing association response\n"); s32Err = ParseAssocRespInfo(gapu8RcvdAssocResp, u32RcvdAssocRespInfoLen, &pstrConnectRespInfo); if (s32Err) { PRINT_ER("ParseAssocRespInfo() returned error %d \n", s32Err); } else { /* use the necessary parsed Info from the Received Association Response */ strConnectInfo.u16ConnectStatus = pstrConnectRespInfo->u16ConnectStatus; if (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE) { PRINT_INFO(HOSTINF_DBG, "Association response received : Successful connection status\n"); if (pstrConnectRespInfo->pu8RespIEs != NULL) { strConnectInfo.u16RespIEsLen = pstrConnectRespInfo->u16RespIEsLen; strConnectInfo.pu8RespIEs = (u8 *)WILC_MALLOC(pstrConnectRespInfo->u16RespIEsLen); WILC_memcpy(strConnectInfo.pu8RespIEs, pstrConnectRespInfo->pu8RespIEs, pstrConnectRespInfo->u16RespIEsLen); } } /* deallocate the Assoc. Resp. parsed structure as it is not needed anymore */ if (pstrConnectRespInfo != NULL) { DeallocateAssocRespInfo(pstrConnectRespInfo); pstrConnectRespInfo = NULL; } } } } /* The station has just received mac status and it also received assoc. response which * it was waiting for. * So check first the matching between the received mac status and the received status code in Asoc Resp */ if ((u8MacStatus == MAC_CONNECTED) && (strConnectInfo.u16ConnectStatus != SUCCESSFUL_STATUSCODE)) { PRINT_ER("Received MAC status is MAC_CONNECTED while the received status code in Asoc Resp is not SUCCESSFUL_STATUSCODE \n"); WILC_memset(u8ConnectedSSID, 0, ETH_ALEN); } else if (u8MacStatus == MAC_DISCONNECTED) { PRINT_ER("Received MAC status is MAC_DISCONNECTED\n"); WILC_memset(u8ConnectedSSID, 0, ETH_ALEN); } /* TODO: mostafa: correct BSSID should be retrieved from actual BSSID received from AP */ /* through a structure of type tstrConnectRespInfo */ if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { PRINT_D(HOSTINF_DBG, "Retrieving actual BSSID from AP\n"); WILC_memcpy(strConnectInfo.au8bssid, pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, 6); if ((u8MacStatus == MAC_CONNECTED) && (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) { WILC_memcpy(pstrWFIDrv->au8AssociatedBSSID, pstrWFIDrv->strWILC_UsrConnReq.pu8bssid, ETH_ALEN); } } if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { strConnectInfo.ReqIEsLen = pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen; strConnectInfo.pu8ReqIEs = (u8 *)WILC_MALLOC(pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen); WILC_memcpy(strConnectInfo.pu8ReqIEs, pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs, pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen); } WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL); pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_CONN_RESP, &strConnectInfo, u8MacStatus, NULL, pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid); /* if received mac status is MAC_CONNECTED and * received status code in Asoc Resp is SUCCESSFUL_STATUSCODE, change state to CONNECTED * else change state to IDLE */ if ((u8MacStatus == MAC_CONNECTED) && (strConnectInfo.u16ConnectStatus == SUCCESSFUL_STATUSCODE)) { #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0); #endif PRINT_D(HOSTINF_DBG, "MAC status : CONNECTED and Connect Status : Successful\n"); pstrWFIDrv->enuHostIFstate = HOST_IF_CONNECTED; #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP PRINT_D(GENERIC_DBG, "Obtaining an IP, Disable Scan\n"); g_obtainingIP = true; WILC_TimerStart(&hDuringIpTimer, 10000, NULL, NULL); #endif #ifdef WILC_PARSE_SCAN_IN_HOST /* open a BA session if possible */ /* if(pstrWFIDrv->strWILC_UsrConnReq.IsHTCapable) */ #endif /* host_int_addBASession(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid,0, */ /* BA_SESSION_DEFAULT_BUFFER_SIZE,BA_SESSION_DEFAULT_TIMEOUT); */ } else { PRINT_D(HOSTINF_DBG, "MAC status : %d and Connect Status : %d\n", u8MacStatus, strConnectInfo.u16ConnectStatus); pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; gbScanWhileConnected = false; } /* Deallocation */ if (strConnectInfo.pu8RespIEs != NULL) { WILC_FREE(strConnectInfo.pu8RespIEs); strConnectInfo.pu8RespIEs = NULL; } if (strConnectInfo.pu8ReqIEs != NULL) { WILC_FREE(strConnectInfo.pu8ReqIEs); strConnectInfo.pu8ReqIEs = NULL; } pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL; } if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid); pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs); pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL; } } else if ((u8MacStatus == MAC_DISCONNECTED) && (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED)) { /* Disassociation or Deauthentication frame has been received */ PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW\n"); WILC_memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo)); if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running OBSS Scan >> \n\n"); WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL); Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED); } strDisconnectNotifInfo.u16reason = 0; strDisconnectNotifInfo.ie = NULL; strDisconnectNotifInfo.ie_len = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) { #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP g_obtainingIP = false; host_int_set_power_mgmt((WILC_WFIDrvHandle)pstrWFIDrv, 0, 0); #endif pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL, 0, &strDisconnectNotifInfo, pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid); } else { PRINT_ER("Connect result callback function is NULL \n"); } WILC_memset(pstrWFIDrv->au8AssociatedBSSID, 0, ETH_ALEN); /* Deallocation */ /* if Information Elements were retrieved from the Received deauth/disassoc frame, then they * should be deallocated here */ /* * if(strDisconnectNotifInfo.ie != NULL) * { * WILC_FREE(strDisconnectNotifInfo.ie); * strDisconnectNotifInfo.ie = NULL; * } */ pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL; } if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid); pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs); pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL; } /*BugID_5213*/ /*Freeing flushed join request params on receiving*/ /*MAC_DISCONNECTED while connected*/ if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedJoinReq); gu8FlushedJoinReq = NULL; } if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedInfoElemAsoc); gu8FlushedInfoElemAsoc = NULL; } pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; gbScanWhileConnected = false; } else if ((u8MacStatus == MAC_DISCONNECTED) && (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL)) { PRINT_D(HOSTINF_DBG, "Received MAC_DISCONNECTED from the FW while scanning\n"); PRINT_D(HOSTINF_DBG, "\n\n<< Abort the running Scan >> \n\n"); /*Abort the running scan*/ WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL); if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { Handle_ScanDone((void *)pstrWFIDrv, SCAN_EVENT_ABORTED); } } } WILC_CATCH(s32Error) { } /* Deallocate pstrRcvdGnrlAsyncInfo->pu8Buffer which was prevoisuly allocated by the sending thread */ if (pstrRcvdGnrlAsyncInfo->pu8Buffer != NULL) { WILC_FREE(pstrRcvdGnrlAsyncInfo->pu8Buffer); pstrRcvdGnrlAsyncInfo->pu8Buffer = NULL; } return s32Error; } /** * @brief Handle_Key * @details Sending config packet to firmware to set key * @param[in] tstrHostIFkeyAttr* pstrHostIFkeyAttr * @return Error code. * @author * @date * @version 1.0 */ static int Handle_Key(void *drvHandler, tstrHostIFkeyAttr *pstrHostIFkeyAttr) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; #ifdef WILC_AP_EXTERNAL_MLME tstrWID strWIDList[5]; #endif u8 i; u8 *pu8keybuf; s8 s8idxarray[1]; s8 ret = 0; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; switch (pstrHostIFkeyAttr->enuKeyType) { case WEP: #ifdef WILC_AP_EXTERNAL_MLME if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) { PRINT_D(HOSTINF_DBG, "Handling WEP key\n"); PRINT_D(GENERIC_DBG, "ID Hostint is %d\n", (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx)); strWIDList[0].u16WIDid = (u16)WID_11I_MODE; strWIDList[0].enuWIDtype = WID_CHAR; strWIDList[0].s32ValueSize = sizeof(char); strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8mode)); strWIDList[1].u16WIDid = WID_AUTH_TYPE; strWIDList[1].enuWIDtype = WID_CHAR; strWIDList[1].s32ValueSize = sizeof(char); strWIDList[1].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type)); strWIDList[2].u16WIDid = (u16)WID_KEY_ID; strWIDList[2].enuWIDtype = WID_CHAR; strWIDList[2].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx)); strWIDList[2].s32ValueSize = sizeof(char); pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send Key\n"); return -1; } WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen); WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey); strWIDList[3].u16WIDid = (u16)WID_WEP_KEY_VALUE; strWIDList[3].enuWIDtype = WID_STR; strWIDList[3].s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen; strWIDList[3].ps8WidVal = (s8 *)pu8keybuf; s32Error = SendConfigPkt(SET_CFG, strWIDList, 4, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); } #endif if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) { PRINT_D(HOSTINF_DBG, "Handling WEP key\n"); pu8keybuf = (u8 *)WILC_MALLOC(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send Key\n"); return -1; } pu8keybuf[0] = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx; WILC_memcpy(pu8keybuf + 1, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen, 1); WILC_memcpy(pu8keybuf + 2, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen); WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey); strWID.u16WIDid = (u16)WID_ADD_WEP_KEY; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (s8 *)pu8keybuf; strWID.s32ValueSize = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen + 2; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); } else if (pstrHostIFkeyAttr->u8KeyAction & REMOVEKEY) { PRINT_D(HOSTINF_DBG, "Removing key\n"); strWID.u16WIDid = (u16)WID_REMOVE_WEP_KEY; strWID.enuWIDtype = WID_STR; s8idxarray[0] = (s8)pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx; strWID.ps8WidVal = s8idxarray; strWID.s32ValueSize = 1; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); } else { strWID.u16WIDid = (u16)WID_KEY_ID; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx)); strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Setting default key index\n"); s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); } up(&(pstrWFIDrv->hSemTestKeyBlock)); break; case WPARxGtk: #ifdef WILC_AP_EXTERNAL_MLME if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) { pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send RxGTK Key\n"); ret = -1; goto _WPARxGtk_end_case_; } WILC_memset(pu8keybuf, 0, RX_MIC_KEY_MSG_LEN); /*|----------------------------------------------------------------------------| * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key | * |------------|---------|-------|------------|---------------|----------------| | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/ if (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq != NULL) WILC_memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq, 8); WILC_memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1); WILC_memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1); WILC_memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen); /* pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = 0X51; */ strWIDList[0].u16WIDid = (u16)WID_11I_MODE; strWIDList[0].enuWIDtype = WID_CHAR; strWIDList[0].s32ValueSize = sizeof(char); strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode)); strWIDList[1].u16WIDid = (u16)WID_ADD_RX_GTK; strWIDList[1].enuWIDtype = WID_STR; strWIDList[1].ps8WidVal = (s8 *)pu8keybuf; strWIDList[1].s32ValueSize = RX_MIC_KEY_MSG_LEN; s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); /* ////////////////////////// */ up(&(pstrWFIDrv->hSemTestKeyBlock)); /* ///////////////////////// */ } #endif if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) { PRINT_D(HOSTINF_DBG, "Handling group key(Rx) function\n"); pu8keybuf = (u8 *)WILC_MALLOC(RX_MIC_KEY_MSG_LEN); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send RxGTK Key\n"); ret = -1; goto _WPARxGtk_end_case_; } WILC_memset(pu8keybuf, 0, RX_MIC_KEY_MSG_LEN); /*|----------------------------------------------------------------------------| * |Sta Address | Key RSC | KeyID | Key Length | Temporal Key | Rx Michael Key | * |------------|---------|-------|------------|---------------|----------------| | 6 bytes | 8 byte |1 byte | 1 byte | 16 bytes | 8 bytes |*/ if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) { WILC_memcpy(pu8keybuf, pstrWFIDrv->au8AssociatedBSSID, ETH_ALEN); } else { PRINT_ER("Couldn't handle WPARxGtk while enuHostIFstate is not HOST_IF_CONNECTED \n"); } WILC_memcpy(pu8keybuf + 6, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq, 8); WILC_memcpy(pu8keybuf + 14, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1); WILC_memcpy(pu8keybuf + 15, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1); WILC_memcpy(pu8keybuf + 16, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen); strWID.u16WIDid = (u16)WID_ADD_RX_GTK; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (s8 *)pu8keybuf; strWID.s32ValueSize = RX_MIC_KEY_MSG_LEN; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); /* ////////////////////////// */ up(&(pstrWFIDrv->hSemTestKeyBlock)); /* ///////////////////////// */ } _WPARxGtk_end_case_: WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key); WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq); if (ret == -1) return ret; break; case WPAPtk: #ifdef WILC_AP_EXTERNAL_MLME if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY_AP) { pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN + 1); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send PTK Key\n"); ret = -1; goto _WPAPtk_end_case_; } /*|-----------------------------------------------------------------------------| * |Station address | keyidx |Key Length |Temporal Key | Rx Michael Key |Tx Michael Key | * |----------------|------------ |--------------|----------------|---------------| | 6 bytes | 1 byte | 1byte | 16 bytes | 8 bytes | 8 bytes | |-----------------------------------------------------------------------------|*/ WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr, 6); /*1 bytes Key Length */ WILC_memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx, 1); WILC_memcpy(pu8keybuf + 7, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1); /*16 byte TK*/ WILC_memcpy(pu8keybuf + 8, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen); strWIDList[0].u16WIDid = (u16)WID_11I_MODE; strWIDList[0].enuWIDtype = WID_CHAR; strWIDList[0].s32ValueSize = sizeof(char); strWIDList[0].ps8WidVal = (s8 *)(&(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode)); strWIDList[1].u16WIDid = (u16)WID_ADD_PTK; strWIDList[1].enuWIDtype = WID_STR; strWIDList[1].ps8WidVal = (s8 *)pu8keybuf; strWIDList[1].s32ValueSize = PTK_KEY_MSG_LEN + 1; s32Error = SendConfigPkt(SET_CFG, strWIDList, 2, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); /* ////////////////////////// */ up(&(pstrWFIDrv->hSemTestKeyBlock)); /* ///////////////////////// */ } #endif if (pstrHostIFkeyAttr->u8KeyAction & ADDKEY) { pu8keybuf = (u8 *)WILC_MALLOC(PTK_KEY_MSG_LEN); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send PTK Key\n"); ret = -1; goto _WPAPtk_end_case_; } /*|-----------------------------------------------------------------------------| * |Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key | * |----------------|------------|--------------|----------------|---------------| | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes | |-----------------------------------------------------------------------------|*/ WILC_memcpy(pu8keybuf, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr, 6); /*1 bytes Key Length */ WILC_memcpy(pu8keybuf + 6, &pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen, 1); /*16 byte TK*/ WILC_memcpy(pu8keybuf + 7, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen); strWID.u16WIDid = (u16)WID_ADD_PTK; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (s8 *)pu8keybuf; strWID.s32ValueSize = PTK_KEY_MSG_LEN; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); /* ////////////////////////// */ up(&(pstrWFIDrv->hSemTestKeyBlock)); /* ///////////////////////// */ } _WPAPtk_end_case_: WILC_FREE(pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFwpaAttr.pu8key); if (ret == -1) return ret; break; case PMKSA: PRINT_D(HOSTINF_DBG, "Handling PMKSA key\n"); pu8keybuf = (u8 *)WILC_MALLOC((pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1); if (pu8keybuf == NULL) { PRINT_ER("No buffer to send PMKSA Key\n"); return -1; } pu8keybuf[0] = pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid; for (i = 0; i < pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid; i++) { WILC_memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + 1), pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].bssid, ETH_ALEN); WILC_memcpy(pu8keybuf + ((PMKSA_KEY_LEN * i) + ETH_ALEN + 1), pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].pmkid, PMKID_LEN); } strWID.u16WIDid = (u16)WID_PMKID_INFO; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (s8 *)pu8keybuf; strWID.s32ValueSize = (pstrHostIFkeyAttr->uniHostIFkeyAttr.strHostIFpmkidAttr.numpmkid * PMKSA_KEY_LEN) + 1; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); WILC_FREE(pu8keybuf); break; } if (s32Error) PRINT_ER("Failed to send key config packet\n"); return s32Error; } /** * @brief Handle_Disconnect * @details Sending config packet to firmware to disconnect * @param[in] NONE * @return NONE * @author * @date * @version 1.0 */ static void Handle_Disconnect(void *drvHandler) { tstrWID strWID; s32 s32Error = WILC_SUCCESS; u16 u16DummyReasonCode = 0; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_DISCONNECT; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&u16DummyReasonCode; strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Sending disconnect request\n"); #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP 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, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send dissconect config packet\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } else { tstrDisconnectNotifInfo strDisconnectNotifInfo; WILC_memset(&strDisconnectNotifInfo, 0, sizeof(tstrDisconnectNotifInfo)); strDisconnectNotifInfo.u16reason = 0; strDisconnectNotifInfo.ie = NULL; strDisconnectNotifInfo.ie_len = 0; if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL); pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL, pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL); pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL; } if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult != NULL) { /*BugID_5193*/ /*Stop connect timer, if connection in progress*/ if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) { PRINT_D(HOSTINF_DBG, "Upper layer requested termination of connection\n"); WILC_TimerStop(&(pstrWFIDrv->hConnectTimer), NULL); } pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult(CONN_DISCONN_EVENT_DISCONN_NOTIF, NULL, 0, &strDisconnectNotifInfo, pstrWFIDrv->strWILC_UsrConnReq.u32UserConnectPvoid); } else { PRINT_ER("strWILC_UsrConnReq.pfUserConnectResult = NULL \n"); } gbScanWhileConnected = false; pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; WILC_memset(pstrWFIDrv->au8AssociatedBSSID, 0, ETH_ALEN); /* Deallocation */ pstrWFIDrv->strWILC_UsrConnReq.ssidLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ssid); pstrWFIDrv->strWILC_UsrConnReq.pu8ssid = NULL; } if (pstrWFIDrv->strWILC_UsrConnReq.pu8bssid != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8bssid); pstrWFIDrv->strWILC_UsrConnReq.pu8bssid = NULL; } pstrWFIDrv->strWILC_UsrConnReq.ConnReqIEsLen = 0; if (pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs != NULL) { WILC_FREE(pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs); pstrWFIDrv->strWILC_UsrConnReq.pu8ConnReqIEs = NULL; } /*BugID_5137*/ if (gu8FlushedJoinReq != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedJoinReq); gu8FlushedJoinReq = NULL; } if (gu8FlushedInfoElemAsoc != NULL && gu8FlushedJoinReqDrvHandler == (u32)drvHandler) { WILC_FREE(gu8FlushedInfoElemAsoc); gu8FlushedInfoElemAsoc = NULL; } } WILC_CATCH(s32Error) { } /* ////////////////////////// */ up(&(pstrWFIDrv->hSemTestDisconnectBlock)); /* ///////////////////////// */ } void resolve_disconnect_aberration(void *drvHandler) { tstrWILC_WFIDrv *pstrWFIDrv; pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; if (pstrWFIDrv == NULL) return; if ((pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) || (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTING)) { PRINT_D(HOSTINF_DBG, "\n\n<< correcting Supplicant state machine >>\n\n"); host_int_disconnect((WILC_WFIDrvHandle)pstrWFIDrv, 1); } } static s32 Switch_Log_Terminal(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; static char dummy = 9; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_LOGTerminal_Switch; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = &dummy; strWID.s32ValueSize = sizeof(char); s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_D(HOSTINF_DBG, "Failed to switch log terminal\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { PRINT_INFO(HOSTINF_DBG, "MAC address set :: \n"); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_GetChnl * @details Sending config packet to get channel * @param[in] NONE * @return NONE * * @author * @date * @version 1.0 */ static s32 Handle_GetChnl(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_CURRENT_CHANNEL; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&gu8Chnl; strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Getting channel value\n"); 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"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } up(&(pstrWFIDrv->hSemGetCHNL)); return s32Error; } /** * @brief Handle_GetRssi * @details Sending config packet to get RSSI * @param[in] NONE * @return NONE * @author * @date * @version 1.0 */ static void Handle_GetRssi(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_RSSI; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = &gs8Rssi; strWID.s32ValueSize = sizeof(char); /*Sending Cfg*/ PRINT_D(HOSTINF_DBG, "Getting RSSI value\n"); s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to get RSSI value\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } up(&(pstrWFIDrv->hSemGetRSSI)); } static void Handle_GetLinkspeed(void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; gs8lnkspd = 0; strWID.u16WIDid = (u16)WID_LINKSPEED; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = &gs8lnkspd; strWID.s32ValueSize = sizeof(char); /*Sending Cfg*/ PRINT_D(HOSTINF_DBG, "Getting LINKSPEED value\n"); s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to get LINKSPEED value\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } up(&(pstrWFIDrv->hSemGetLINKSPEED)); } s32 Handle_GetStatistics(void *drvHandler, tstrStatistics *pstrStatistics) { tstrWID strWIDList[5]; uint32_t u32WidsCount = 0, s32Error = 0; strWIDList[u32WidsCount].u16WIDid = WID_LINKSPEED; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u8LinkSpeed)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_RSSI; strWIDList[u32WidsCount].enuWIDtype = WID_CHAR; strWIDList[u32WidsCount].s32ValueSize = sizeof(char); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->s8RSSI)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_SUCCESS_FRAME_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxCount)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_RECEIVED_FRAGMENT_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32RxCount)); u32WidsCount++; strWIDList[u32WidsCount].u16WIDid = WID_FAILED_COUNT; strWIDList[u32WidsCount].enuWIDtype = WID_INT; strWIDList[u32WidsCount].s32ValueSize = sizeof(u32); strWIDList[u32WidsCount].ps8WidVal = (s8 *)(&(pstrStatistics->u32TxFailureCount)); u32WidsCount++; s32Error = SendConfigPkt(GET_CFG, strWIDList, u32WidsCount, false, (u32)drvHandler); if (s32Error) { PRINT_ER("Failed to send scan paramters config packet\n"); /* WILC_ERRORREPORT(s32Error, s32Error); */ } up(&hWaitResponse); return 0; } #ifdef WILC_AP_EXTERNAL_MLME /** * @brief Handle_Get_InActiveTime * @details Sending config packet to set mac adddress for station and * get inactive time * @param[in] NONE * @return NONE * * @author * @date * @version 1.0 */ static s32 Handle_Get_InActiveTime(void *drvHandler, tstrHostIfStaInactiveT *strHostIfStaInactiveT) { s32 s32Error = WILC_SUCCESS; u8 *stamac; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_SET_STA_MAC_INACTIVE_TIME; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = ETH_ALEN; strWID.ps8WidVal = (u8 *)WILC_MALLOC(strWID.s32ValueSize); stamac = strWID.ps8WidVal; WILC_memcpy(stamac, strHostIfStaInactiveT->mac, ETH_ALEN); PRINT_D(CFG80211_DBG, "SETING STA inactive time\n"); 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"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } strWID.u16WIDid = (u16)WID_GET_INACTIVE_TIME; strWID.enuWIDtype = WID_INT; strWID.ps8WidVal = (s8 *)&gu32InactiveTime; strWID.s32ValueSize = sizeof(u32); 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"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } PRINT_D(CFG80211_DBG, "Getting inactive time : %d\n", gu32InactiveTime); up(&(pstrWFIDrv->hSemInactiveTime)); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_AddBeacon * @details Sending config packet to add beacon * @param[in] tstrHostIFSetBeacon* pstrSetBeaconParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_AddBeacon(void *drvHandler, tstrHostIFSetBeacon *pstrSetBeaconParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(HOSTINF_DBG, "Adding BEACON\n"); strWID.u16WIDid = (u16)WID_ADD_BEACON; strWID.enuWIDtype = WID_BIN; strWID.s32ValueSize = pstrSetBeaconParam->u32HeadLen + pstrSetBeaconParam->u32TailLen + 16; strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; *pu8CurrByte++ = (pstrSetBeaconParam->u32Interval & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 8) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 16) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32Interval >> 24) & 0xFF); *pu8CurrByte++ = (pstrSetBeaconParam->u32DTIMPeriod & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 8) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 16) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32DTIMPeriod >> 24) & 0xFF); *pu8CurrByte++ = (pstrSetBeaconParam->u32HeadLen & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 8) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 16) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32HeadLen >> 24) & 0xFF); memcpy(pu8CurrByte, pstrSetBeaconParam->pu8Head, pstrSetBeaconParam->u32HeadLen); pu8CurrByte += pstrSetBeaconParam->u32HeadLen; *pu8CurrByte++ = (pstrSetBeaconParam->u32TailLen & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 8) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 16) & 0xFF); *pu8CurrByte++ = ((pstrSetBeaconParam->u32TailLen >> 24) & 0xFF); /* Bug 4599 : if tail length = 0 skip copying */ if (pstrSetBeaconParam->pu8Tail > 0) memcpy(pu8CurrByte, pstrSetBeaconParam->pu8Tail, pstrSetBeaconParam->u32TailLen); pu8CurrByte += pstrSetBeaconParam->u32TailLen; /*Sending Cfg*/ 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); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(strWID.ps8WidVal); WILC_FREE_IF_TRUE(pstrSetBeaconParam->pu8Head); WILC_FREE_IF_TRUE(pstrSetBeaconParam->pu8Tail); } /** * @brief Handle_AddBeacon * @details Sending config packet to delete beacon * @param[in] tstrHostIFDelBeacon* pstrDelBeacon * @return NONE * @author * @date * @version 1.0 */ static void Handle_DelBeacon(void *drvHandler, tstrHostIFDelBeacon *pstrDelBeacon) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_DEL_BEACON; strWID.enuWIDtype = WID_CHAR; strWID.s32ValueSize = sizeof(char); strWID.ps8WidVal = &gu8DelBcn; if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; PRINT_D(HOSTINF_DBG, "Deleting BEACON\n"); /* TODO: build del beacon message*/ /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send delete beacon config packet\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } } /** * @brief WILC_HostIf_PackStaParam * @details Handling packing of the station params in a buffer * @param[in] u8* pu8Buffer, tstrWILC_AddStaParam* pstrStationParam * @return NONE * @author * @date * @version 1.0 */ static u32 WILC_HostIf_PackStaParam(u8 *pu8Buffer, tstrWILC_AddStaParam *pstrStationParam) { u8 *pu8CurrByte; pu8CurrByte = pu8Buffer; PRINT_D(HOSTINF_DBG, "Packing STA params\n"); WILC_memcpy(pu8CurrByte, pstrStationParam->au8BSSID, ETH_ALEN); pu8CurrByte += ETH_ALEN; *pu8CurrByte++ = pstrStationParam->u16AssocID & 0xFF; *pu8CurrByte++ = (pstrStationParam->u16AssocID >> 8) & 0xFF; *pu8CurrByte++ = pstrStationParam->u8NumRates; if (pstrStationParam->u8NumRates > 0) { WILC_memcpy(pu8CurrByte, pstrStationParam->pu8Rates, pstrStationParam->u8NumRates); } pu8CurrByte += pstrStationParam->u8NumRates; *pu8CurrByte++ = pstrStationParam->bIsHTSupported; *pu8CurrByte++ = pstrStationParam->u16HTCapInfo & 0xFF; *pu8CurrByte++ = (pstrStationParam->u16HTCapInfo >> 8) & 0xFF; *pu8CurrByte++ = pstrStationParam->u8AmpduParams; WILC_memcpy(pu8CurrByte, pstrStationParam->au8SuppMCsSet, WILC_SUPP_MCS_SET_SIZE); pu8CurrByte += WILC_SUPP_MCS_SET_SIZE; *pu8CurrByte++ = pstrStationParam->u16HTExtParams & 0xFF; *pu8CurrByte++ = (pstrStationParam->u16HTExtParams >> 8) & 0xFF; *pu8CurrByte++ = pstrStationParam->u32TxBeamformingCap & 0xFF; *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 8) & 0xFF; *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 16) & 0xFF; *pu8CurrByte++ = (pstrStationParam->u32TxBeamformingCap >> 24) & 0xFF; *pu8CurrByte++ = pstrStationParam->u8ASELCap; *pu8CurrByte++ = pstrStationParam->u16FlagsMask & 0xFF; *pu8CurrByte++ = (pstrStationParam->u16FlagsMask >> 8) & 0xFF; *pu8CurrByte++ = pstrStationParam->u16FlagsSet & 0xFF; *pu8CurrByte++ = (pstrStationParam->u16FlagsSet >> 8) & 0xFF; return pu8CurrByte - pu8Buffer; } /** * @brief Handle_AddStation * @details Sending config packet to add station * @param[in] tstrWILC_AddStaParam* pstrStationParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_AddStation(void *drvHandler, tstrWILC_AddStaParam *pstrStationParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(HOSTINF_DBG, "Handling add station\n"); strWID.u16WIDid = (u16)WID_ADD_STA; strWID.enuWIDtype = WID_BIN; strWID.s32ValueSize = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates; strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam); /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv); if (s32Error != WILC_SUCCESS) { PRINT_ER("Failed to send add station config packet\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(pstrStationParam->pu8Rates); WILC_FREE_IF_TRUE(strWID.ps8WidVal); } /** * @brief Handle_DelAllSta * @details Sending config packet to delete station * @param[in] tstrHostIFDelSta* pstrDelStaParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_DelAllSta(void *drvHandler, tstrHostIFDelAllSta *pstrDelAllStaParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; u8 i; u8 au8Zero_Buff[6] = {0}; strWID.u16WIDid = (u16)WID_DEL_ALL_STA; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = (pstrDelAllStaParam->u8Num_AssocSta * ETH_ALEN) + 1; PRINT_D(HOSTINF_DBG, "Handling delete station \n"); strWID.ps8WidVal = WILC_MALLOC((pstrDelAllStaParam->u8Num_AssocSta * ETH_ALEN) + 1); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; *(pu8CurrByte++) = pstrDelAllStaParam->u8Num_AssocSta; for (i = 0; i < MAX_NUM_STA; i++) { if (memcmp(pstrDelAllStaParam->au8Sta_DelAllSta[i], au8Zero_Buff, ETH_ALEN)) WILC_memcpy(pu8CurrByte, pstrDelAllStaParam->au8Sta_DelAllSta[i], ETH_ALEN); else continue; pu8CurrByte += ETH_ALEN; } /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send add station config packe\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(strWID.ps8WidVal); up(&hWaitResponse); } /** * @brief Handle_DelStation * @details Sending config packet to delete station * @param[in] tstrHostIFDelSta* pstrDelStaParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_DelStation(void *drvHandler, tstrHostIFDelSta *pstrDelStaParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_REMOVE_STA; strWID.enuWIDtype = WID_BIN; strWID.s32ValueSize = ETH_ALEN; PRINT_D(HOSTINF_DBG, "Handling delete station \n"); strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; WILC_memcpy(pu8CurrByte, pstrDelStaParam->au8MacAddr, ETH_ALEN); /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send add station config packe\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(strWID.ps8WidVal); } /** * @brief Handle_EditStation * @details Sending config packet to edit station * @param[in] tstrWILC_AddStaParam* pstrStationParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_EditStation(void *drvHandler, tstrWILC_AddStaParam *pstrStationParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_EDIT_STA; strWID.enuWIDtype = WID_BIN; strWID.s32ValueSize = WILC_ADD_STA_LENGTH + pstrStationParam->u8NumRates; PRINT_D(HOSTINF_DBG, "Handling edit station\n"); strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; pu8CurrByte += WILC_HostIf_PackStaParam(pu8CurrByte, pstrStationParam); /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, false, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send edit station config packet\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(pstrStationParam->pu8Rates); WILC_FREE_IF_TRUE(strWID.ps8WidVal); } #endif /*WILC_AP_EXTERNAL_MLME*/ #ifdef WILC_P2P /** * @brief Handle_RemainOnChan * @details Sending config packet to edit station * @param[in] tstrWILC_AddStaParam* pstrStationParam * @return NONE * @author * @date * @version 1.0 */ static int Handle_RemainOnChan(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan) { s32 s32Error = WILC_SUCCESS; u8 u8remain_on_chan_flag; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; /*If it's a pendig remain-on-channel, don't overwrite gWFiDrvHandle values (since incoming msg is garbbage)*/ if (!pstrWFIDrv->u8RemainOnChan_pendingreq) { pstrWFIDrv->strHostIfRemainOnChan.pVoid = pstrHostIfRemainOnChan->pVoid; pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired = pstrHostIfRemainOnChan->pRemainOnChanExpired; pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady = pstrHostIfRemainOnChan->pRemainOnChanReady; pstrWFIDrv->strHostIfRemainOnChan.u16Channel = pstrHostIfRemainOnChan->u16Channel; pstrWFIDrv->strHostIfRemainOnChan.u32ListenSessionID = pstrHostIfRemainOnChan->u32ListenSessionID; } else { /*Set the channel to use it as a wid val*/ pstrHostIfRemainOnChan->u16Channel = pstrWFIDrv->strHostIfRemainOnChan.u16Channel; } if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL) { PRINT_INFO(GENERIC_DBG, "Required to remain on chan while scanning return\n"); pstrWFIDrv->u8RemainOnChan_pendingreq = 1; WILC_ERRORREPORT(s32Error, WILC_BUSY); } if (pstrWFIDrv->enuHostIFstate == HOST_IF_WAITING_CONN_RESP) { PRINT_INFO(GENERIC_DBG, "Required to remain on chan while connecting return\n"); WILC_ERRORREPORT(s32Error, WILC_BUSY); } #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP if (g_obtainingIP || connecting) { PRINT_D(GENERIC_DBG, "[handle_scan]: Don't do obss scan until IP adresss is obtained\n"); WILC_ERRORREPORT(s32Error, WILC_BUSY); } #endif PRINT_D(HOSTINF_DBG, "Setting channel :%d\n", pstrHostIfRemainOnChan->u16Channel); u8remain_on_chan_flag = true; strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = 2; strWID.ps8WidVal = (s8 *)WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } strWID.ps8WidVal[0] = u8remain_on_chan_flag; strWID.ps8WidVal[1] = (s8)pstrHostIfRemainOnChan->u16Channel; /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error != WILC_SUCCESS) { PRINT_ER("Failed to set remain on channel\n"); } WILC_CATCH(-1) { P2P_LISTEN_STATE = 1; WILC_TimerStart(&(pstrWFIDrv->hRemainOnChannel), pstrHostIfRemainOnChan->u32duration, (void *)pstrWFIDrv, NULL); /*Calling CFG ready_on_channel*/ if (pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady) { pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanReady(pstrWFIDrv->strHostIfRemainOnChan.pVoid); } if (pstrWFIDrv->u8RemainOnChan_pendingreq) pstrWFIDrv->u8RemainOnChan_pendingreq = 0; } return s32Error; } /** * @brief Handle_RegisterFrame * @details * @param[in] * @return NONE * @author * @date * @version 1.0 */ static int Handle_RegisterFrame(void *drvHandler, tstrHostIfRegisterFrame *pstrHostIfRegisterFrame) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(HOSTINF_DBG, "Handling frame register Flag : %d FrameType: %d\n", pstrHostIfRegisterFrame->bReg, pstrHostIfRegisterFrame->u16FrameType); /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_REGISTER_FRAME; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = WILC_MALLOC(sizeof(u16) + 2); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; *pu8CurrByte++ = pstrHostIfRegisterFrame->bReg; *pu8CurrByte++ = pstrHostIfRegisterFrame->u8Regid; WILC_memcpy(pu8CurrByte, &(pstrHostIfRegisterFrame->u16FrameType), sizeof(u16)); strWID.s32ValueSize = sizeof(u16) + 2; /*Sending Cfg*/ 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); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Handle_ListenStateExpired * @details Handle of listen state expiration * @param[in] NONE * @return Error code. * @author * @date * @version 1.0 */ #define FALSE_FRMWR_CHANNEL 100 static u32 Handle_ListenStateExpired(void *drvHandler, tstrHostIfRemainOnChan *pstrHostIfRemainOnChan) { u8 u8remain_on_chan_flag; tstrWID strWID; s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *) drvHandler; PRINT_D(HOSTINF_DBG, "CANCEL REMAIN ON CHAN\n"); /*BugID_5477*/ /*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 = false; strWID.u16WIDid = (u16)WID_REMAIN_ON_CHAN; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = 2; strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { PRINT_ER("Failed to allocate memory\n"); } strWID.ps8WidVal[0] = u8remain_on_chan_flag; strWID.ps8WidVal[1] = FALSE_FRMWR_CHANNEL; /*Sending Cfg*/ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error != WILC_SUCCESS) { PRINT_ER("Failed to set remain on channel\n"); goto _done_; } if (pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired) { pstrWFIDrv->strHostIfRemainOnChan.pRemainOnChanExpired(pstrWFIDrv->strHostIfRemainOnChan.pVoid , pstrHostIfRemainOnChan->u32ListenSessionID); } P2P_LISTEN_STATE = 0; } else { PRINT_D(GENERIC_DBG, "Not in listen state\n"); s32Error = WILC_FAIL; } _done_: return s32Error; } /** * @brief ListenTimerCB * @details Callback function of remain-on-channel timer * @param[in] NONE * @return Error code. * @author * @date * @version 1.0 */ static void ListenTimerCB(void *pvArg) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)pvArg; /*Stopping remain-on-channel timer*/ WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL); /* prepare the Timer Callback message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_LISTEN_TIMER_FIRED; strHostIFmsg.drvHandler = pstrWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = pstrWFIDrv->strHostIfRemainOnChan.u32ListenSessionID; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } } #endif /** * @brief Handle_EditStation * @details Sending config packet to edit station * @param[in] tstrWILC_AddStaParam* pstrStationParam * @return NONE * @author * @date * @version 1.0 */ static void Handle_PowerManagement(void *drvHandler, tstrHostIfPowerMgmtParam *strPowerMgmtParam) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; s8 s8PowerMode; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; strWID.u16WIDid = (u16)WID_POWER_MANAGEMENT; if (strPowerMgmtParam->bIsEnabled == true) { s8PowerMode = MIN_FAST_PS; } else { s8PowerMode = NO_POWERSAVE; } PRINT_D(HOSTINF_DBG, "Handling power mgmt to %d\n", s8PowerMode); strWID.ps8WidVal = &s8PowerMode; strWID.s32ValueSize = sizeof(char); PRINT_D(HOSTINF_DBG, "Handling Power Management\n"); /*Sending Cfg*/ 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); } WILC_CATCH(s32Error) { } } /** * @brief Handle_SetMulticastFilter * @details Set Multicast filter in firmware * @param[in] tstrHostIFSetMulti* strHostIfSetMulti * @return NONE * @author asobhy * @date * @version 1.0 */ static void Handle_SetMulticastFilter(void *drvHandler, tstrHostIFSetMulti *strHostIfSetMulti) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; u8 *pu8CurrByte; PRINT_D(HOSTINF_DBG, "Setup Multicast Filter\n"); strWID.u16WIDid = (u16)WID_SETUP_MULTICAST_FILTER; strWID.enuWIDtype = WID_BIN; strWID.s32ValueSize = sizeof(tstrHostIFSetMulti) + ((strHostIfSetMulti->u32count) * ETH_ALEN); strWID.ps8WidVal = WILC_MALLOC(strWID.s32ValueSize); if (strWID.ps8WidVal == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } pu8CurrByte = strWID.ps8WidVal; *pu8CurrByte++ = (strHostIfSetMulti->bIsEnabled & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 8) & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 16) & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->bIsEnabled >> 24) & 0xFF); *pu8CurrByte++ = (strHostIfSetMulti->u32count & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 8) & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 16) & 0xFF); *pu8CurrByte++ = ((strHostIfSetMulti->u32count >> 24) & 0xFF); if ((strHostIfSetMulti->u32count) > 0) memcpy(pu8CurrByte, gau8MulticastMacAddrList, ((strHostIfSetMulti->u32count) * ETH_ALEN)); /*Sending Cfg*/ 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); } WILC_CATCH(s32Error) { } WILC_FREE_IF_TRUE(strWID.ps8WidVal); } /*BugID_5222*/ /** * @brief Handle_AddBASession * @details Add block ack session * @param[in] tstrHostIFSetMulti* strHostIfSetMulti * @return NONE * @author Amr Abdel-Moghny * @date Feb. 2014 * @version 9.0 */ static s32 Handle_AddBASession(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; int AddbaTimeout = 100; char *ptr = NULL; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(HOSTINF_DBG, "Opening Block Ack session with\nBSSID = %.2x:%.2x:%.2x \nTID=%d \nBufferSize == %d \nSessionTimeOut = %d\n", strHostIfBASessionInfo->au8Bssid[0], strHostIfBASessionInfo->au8Bssid[1], strHostIfBASessionInfo->au8Bssid[2], strHostIfBASessionInfo->u16BufferSize, strHostIfBASessionInfo->u16SessionTimeout, strHostIfBASessionInfo->u8Ted); strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE); strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE; ptr = strWID.ps8WidVal; /* *ptr++ = 0x14; */ *ptr++ = 0x14; *ptr++ = 0x3; *ptr++ = 0x0; WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN); ptr += ETH_ALEN; *ptr++ = strHostIfBASessionInfo->u8Ted; /* BA Policy*/ *ptr++ = 1; /* Buffer size*/ *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF); *ptr++ = ((strHostIfBASessionInfo->u16BufferSize >> 16) & 0xFF); /* BA timeout*/ *ptr++ = (strHostIfBASessionInfo->u16SessionTimeout & 0xFF); *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF); /* ADDBA timeout*/ *ptr++ = (AddbaTimeout & 0xFF); *ptr++ = ((AddbaTimeout >> 16) & 0xFF); /* Group Buffer Max Frames*/ *ptr++ = 8; /* Group Buffer Timeout */ *ptr++ = 0; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) PRINT_D(HOSTINF_DBG, "Couldn't open BA Session\n"); strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = 15; ptr = strWID.ps8WidVal; /* *ptr++ = 0x14; */ *ptr++ = 15; *ptr++ = 7; *ptr++ = 0x2; WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN); ptr += ETH_ALEN; /* TID*/ *ptr++ = strHostIfBASessionInfo->u8Ted; /* Max Num MSDU */ *ptr++ = 8; /* BA timeout*/ *ptr++ = (strHostIfBASessionInfo->u16BufferSize & 0xFF); *ptr++ = ((strHostIfBASessionInfo->u16SessionTimeout >> 16) & 0xFF); /*Ack-Policy */ *ptr++ = 3; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (strWID.ps8WidVal != NULL) WILC_FREE(strWID.ps8WidVal); return s32Error; } /*BugID_5222*/ /** * @brief Handle_DelBASession * @details Delete block ack session * @param[in] tstrHostIFSetMulti* strHostIfSetMulti * @return NONE * @author Amr Abdel-Moghny * @date Feb. 2013 * @version 9.0 */ static s32 Handle_DelBASession(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; char *ptr = NULL; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x \nTID=%d\n", strHostIfBASessionInfo->au8Bssid[0], strHostIfBASessionInfo->au8Bssid[1], strHostIfBASessionInfo->au8Bssid[2], strHostIfBASessionInfo->u8Ted); strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE); strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE; ptr = strWID.ps8WidVal; /* *ptr++ = 0x14; */ *ptr++ = 0x14; *ptr++ = 0x3; *ptr++ = 0x2; WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN); ptr += ETH_ALEN; *ptr++ = strHostIfBASessionInfo->u8Ted; /* BA direction = recipent*/ *ptr++ = 0; /* Delba Reason */ *ptr++ = 32; /* Unspecific QOS reason */ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n"); strWID.u16WIDid = (u16)WID_11E_P_ACTION_REQ; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = 15; ptr = strWID.ps8WidVal; /* *ptr++ = 0x14; */ *ptr++ = 15; *ptr++ = 7; *ptr++ = 0x3; WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN); ptr += ETH_ALEN; /* TID*/ *ptr++ = strHostIfBASessionInfo->u8Ted; s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (strWID.ps8WidVal != NULL) WILC_FREE(strWID.ps8WidVal); /*BugID_5222*/ up(&hWaitResponse); return s32Error; } /** * @brief Handle_DelAllRxBASessions * @details Delete all Rx BA sessions * @param[in] tstrHostIFSetMulti* strHostIfSetMulti * @return NONE * @author Abdelrahman Sobhy * @date Feb. 2013 * @version 9.0 */ static s32 Handle_DelAllRxBASessions(void *drvHandler, tstrHostIfBASessionInfo *strHostIfBASessionInfo) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; char *ptr = NULL; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(GENERIC_DBG, "Delete Block Ack session with\nBSSID = %.2x:%.2x:%.2x \nTID=%d\n", strHostIfBASessionInfo->au8Bssid[0], strHostIfBASessionInfo->au8Bssid[1], strHostIfBASessionInfo->au8Bssid[2], strHostIfBASessionInfo->u8Ted); strWID.u16WIDid = (u16)WID_DEL_ALL_RX_BA; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (u8 *)WILC_MALLOC(BLOCK_ACK_REQ_SIZE); strWID.s32ValueSize = BLOCK_ACK_REQ_SIZE; ptr = strWID.ps8WidVal; *ptr++ = 0x14; *ptr++ = 0x3; *ptr++ = 0x2; WILC_memcpy(ptr, strHostIfBASessionInfo->au8Bssid, ETH_ALEN); ptr += ETH_ALEN; *ptr++ = strHostIfBASessionInfo->u8Ted; /* BA direction = recipent*/ *ptr++ = 0; /* Delba Reason */ *ptr++ = 32; /* Unspecific QOS reason */ s32Error = SendConfigPkt(SET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) PRINT_D(HOSTINF_DBG, "Couldn't delete BA Session\n"); if (strWID.ps8WidVal != NULL) WILC_FREE(strWID.ps8WidVal); /*BugID_5222*/ up(&hWaitResponse); return s32Error; } /** * @brief hostIFthread * @details Main thread to handle message queue requests * @param[in] void* pvArg * @return NONE * @author * @date * @version 1.0 */ static int hostIFthread(void *pvArg) { u32 u32Ret; tstrHostIFmsg strHostIFmsg; tstrWILC_WFIDrv *pstrWFIDrv; WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); while (1) { WILC_MsgQueueRecv(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), &u32Ret, NULL); pstrWFIDrv = (tstrWILC_WFIDrv *)strHostIFmsg.drvHandler; if (strHostIFmsg.u16MsgId == HOST_IF_MSG_EXIT) { PRINT_D(GENERIC_DBG, "THREAD: Exiting HostIfThread\n"); break; } /*Re-Queue HIF message*/ if ((!g_wilc_initialized)) { PRINT_D(GENERIC_DBG, "--WAIT--"); WILC_Sleep(200); WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); continue; } if (strHostIFmsg.u16MsgId == HOST_IF_MSG_CONNECT && pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult != NULL) { PRINT_D(HOSTINF_DBG, "Requeue connect request till scan done received\n"); WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); WILC_Sleep(2); continue; } switch (strHostIFmsg.u16MsgId) { case HOST_IF_MSG_Q_IDLE: Handle_wait_msg_q_empty(); break; case HOST_IF_MSG_SCAN: Handle_Scan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr); break; case HOST_IF_MSG_CONNECT: Handle_Connect(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr); break; /*BugID_5137*/ case HOST_IF_MSG_FLUSH_CONNECT: Handle_FlushConnect(strHostIFmsg.drvHandler); break; case HOST_IF_MSG_RCVD_NTWRK_INFO: Handle_RcvdNtwrkInfo(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo); break; case HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO: Handle_RcvdGnrlAsyncInfo(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo); break; case HOST_IF_MSG_KEY: Handle_Key(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr); break; case HOST_IF_MSG_CFG_PARAMS: Handle_CfgParam(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFCfgParamAttr); break; case HOST_IF_MSG_SET_CHANNEL: Handle_SetChannel(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFSetChan); break; case HOST_IF_MSG_DISCONNECT: Handle_Disconnect(strHostIFmsg.drvHandler); break; case HOST_IF_MSG_RCVD_SCAN_COMPLETE: WILC_TimerStop(&(pstrWFIDrv->hScanTimer), NULL); PRINT_D(HOSTINF_DBG, "scan completed successfully\n"); /*BugID_5213*/ /*Allow chip sleep, only if both interfaces are not connected*/ if (!linux_wlan_get_num_conn_ifcs()) { chip_sleep_manually(INFINITE_SLEEP_TIME); } Handle_ScanDone(strHostIFmsg.drvHandler, SCAN_EVENT_DONE); #ifdef WILC_P2P if (pstrWFIDrv->u8RemainOnChan_pendingreq) Handle_RemainOnChan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan); #endif break; case HOST_IF_MSG_GET_RSSI: Handle_GetRssi(strHostIFmsg.drvHandler); break; case HOST_IF_MSG_GET_LINKSPEED: Handle_GetLinkspeed(strHostIFmsg.drvHandler); break; case HOST_IF_MSG_GET_STATISTICS: Handle_GetStatistics(strHostIFmsg.drvHandler, (tstrStatistics *)strHostIFmsg.uniHostIFmsgBody.pUserData); break; case HOST_IF_MSG_GET_CHNL: Handle_GetChnl(strHostIFmsg.drvHandler); break; #ifdef WILC_AP_EXTERNAL_MLME case HOST_IF_MSG_ADD_BEACON: Handle_AddBeacon(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFSetBeacon); break; case HOST_IF_MSG_DEL_BEACON: Handle_DelBeacon(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFDelBeacon); break; case HOST_IF_MSG_ADD_STATION: Handle_AddStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strAddStaParam); break; case HOST_IF_MSG_DEL_STATION: Handle_DelStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strDelStaParam); break; case HOST_IF_MSG_EDIT_STATION: Handle_EditStation(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strEditStaParam); break; case HOST_IF_MSG_GET_INACTIVETIME: Handle_Get_InActiveTime(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfStaInactiveT); break; #endif /*WILC_AP_EXTERNAL_MLME*/ case HOST_IF_MSG_SCAN_TIMER_FIRED: PRINT_D(HOSTINF_DBG, "Scan Timeout\n"); Handle_ScanDone(strHostIFmsg.drvHandler, SCAN_EVENT_ABORTED); break; case HOST_IF_MSG_CONNECT_TIMER_FIRED: PRINT_D(HOSTINF_DBG, "Connect Timeout \n"); Handle_ConnectTimeout(strHostIFmsg.drvHandler); break; case HOST_IF_MSG_POWER_MGMT: Handle_PowerManagement(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strPowerMgmtparam); break; case HOST_IF_MSG_SET_WFIDRV_HANDLER: Handle_SetWfiDrvHandler(&strHostIFmsg.uniHostIFmsgBody.strHostIfSetDrvHandler); break; case HOST_IF_MSG_SET_OPERATION_MODE: Handle_SetOperationMode(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetOperationMode); break; case HOST_IF_MSG_SET_IPADDRESS: PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n"); Handle_set_IPAddress(strHostIFmsg.drvHandler, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx); break; case HOST_IF_MSG_GET_IPADDRESS: PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_IPADDRESS\n"); Handle_get_IPAddress(strHostIFmsg.drvHandler, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr, strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx); break; /*BugID_5077*/ case HOST_IF_MSG_SET_MAC_ADDRESS: Handle_SetMacAddress(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMacAddress); break; /*BugID_5213*/ case HOST_IF_MSG_GET_MAC_ADDRESS: Handle_GetMacAddress(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfGetMacAddress); break; #ifdef WILC_P2P case HOST_IF_MSG_REMAIN_ON_CHAN: PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REMAIN_ON_CHAN\n"); Handle_RemainOnChan(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan); break; case HOST_IF_MSG_REGISTER_FRAME: PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_REGISTER_FRAME\n"); Handle_RegisterFrame(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame); break; case HOST_IF_MSG_LISTEN_TIMER_FIRED: Handle_ListenStateExpired(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan); break; #endif case HOST_IF_MSG_SET_MULTICAST_FILTER: PRINT_D(HOSTINF_DBG, "HOST_IF_MSG_SET_MULTICAST_FILTER\n"); Handle_SetMulticastFilter(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMulti); break; /*BugID_5222*/ case HOST_IF_MSG_ADD_BA_SESSION: Handle_AddBASession(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo); break; case HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS: Handle_DelAllRxBASessions(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo); break; case HOST_IF_MSG_DEL_ALL_STA: Handle_DelAllSta(strHostIFmsg.drvHandler, &strHostIFmsg.uniHostIFmsgBody.strHostIFDelAllSta); break; default: PRINT_ER("[Host Interface] undefined Received Msg ID \n"); break; } } PRINT_D(HOSTINF_DBG, "Releasing thread exit semaphore\n"); up(&hSemHostIFthrdEnd); return 0; } static void TimerCB_Scan(void *pvArg) { tstrHostIFmsg strHostIFmsg; /* prepare the Timer Callback message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.drvHandler = pvArg; strHostIFmsg.u16MsgId = HOST_IF_MSG_SCAN_TIMER_FIRED; /* send the message */ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); } static void TimerCB_Connect(void *pvArg) { tstrHostIFmsg strHostIFmsg; /* prepare the Timer Callback message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.drvHandler = pvArg; strHostIFmsg.u16MsgId = HOST_IF_MSG_CONNECT_TIMER_FIRED; /* send the message */ WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); } /** * @brief removes wpa/wpa2 keys * @details only in BSS STA mode if External Supplicant support is enabled. * removes all WPA/WPA2 station key entries from MAC hardware. * @param[in,out] handle to the wifi driver * @param[in] 6 bytes of Station Adress in the station entry table * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ /* Check implementation in core adding 9 bytes to the input! */ s32 host_int_remove_key(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8StaAddress) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_REMOVE_KEY; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = (s8 *)pu8StaAddress; strWID.s32ValueSize = 6; return s32Error; } /** * @brief removes WEP key * @details valid only in BSS STA mode if External Supplicant support is enabled. * remove a WEP key entry from MAC HW. * The BSS Station automatically finds the index of the entry using its * BSS ID and removes that entry from the MAC hardware. * @param[in,out] handle to the wifi driver * @param[in] 6 bytes of Station Adress in the station entry table * @return Error code indicating success/failure * @note NO need for the STA add since it is not used for processing * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_remove_wep_key(WILC_WFIDrvHandle hWFIDrv, u8 u8keyIdx) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Remove Wep Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = REMOVEKEY; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8keyIdx; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue : Request to remove WEP key \n"); down(&(pstrWFIDrv->hSemTestKeyBlock)); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief sets WEP default key * @details Sets the index of the WEP encryption key in use, * in the key table * @param[in,out] handle to the wifi driver * @param[in] key index ( 0, 1, 2, 3) * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_WEPDefaultKeyID(WILC_WFIDrvHandle hWFIDrv, u8 u8Index) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = DEFAULTKEY; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Index; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue : Default key index\n"); down(&(pstrWFIDrv->hSemTestKeyBlock)); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief sets WEP deafault key * @details valid only in BSS STA mode if External Supplicant support is enabled. * sets WEP key entry into MAC hardware when it receives the * corresponding request from NDIS. * @param[in,out] handle to the wifi driver * @param[in] message containing WEP Key in the following format *|---------------------------------------| *|Key ID Value | Key Length | Key | *|-------------|------------|------------| | 1byte | 1byte | Key Length | ||---------------------------------------| | * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_add_wep_key_bss_sta(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC(u8WepKeylen); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey, pu8WepKey, u8WepKeylen); strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen = (u8WepKeylen); strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Keyidx; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue :WEP Key\n"); down(&(pstrWFIDrv->hSemTestKeyBlock)); WILC_CATCH(s32Error) { } return s32Error; } #ifdef WILC_AP_EXTERNAL_MLME /** * * @brief host_int_add_wep_key_bss_ap * @details valid only in BSS AP mode if External Supplicant support is enabled. * sets WEP key entry into MAC hardware when it receives the * * corresponding request from NDIS. * @param[in,out] handle to the wifi driver * * * @return Error code indicating success/failure * @note * @author mdaftedar * @date 28 FEB 2013 * @version 1.0 */ s32 host_int_add_wep_key_bss_ap(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8WepKey, u8 u8WepKeylen, u8 u8Keyidx, u8 u8mode, AUTHTYPE_T tenuAuth_type) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; u8 i; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); if (INFO) { for (i = 0; i < u8WepKeylen; i++) PRINT_INFO(HOSTAPD_DBG, "KEY is %x\n", pu8WepKey[i]); } strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WEP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey = (u8 *)WILC_MALLOC((u8WepKeylen)); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwepAttr.pu8WepKey, pu8WepKey, (u8WepKeylen)); strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8WepKeylen = (u8WepKeylen); strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8Wepidx = u8Keyidx; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.u8mode = u8mode; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwepAttr.tenuAuth_type = tenuAuth_type; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue :WEP Key\n"); down(&(pstrWFIDrv->hSemTestKeyBlock)); WILC_CATCH(s32Error) { } return s32Error; } #endif /** * @brief adds ptk Key * @details * @param[in,out] handle to the wifi driver * @param[in] message containing PTK Key in the following format *|-----------------------------------------------------------------------------| *|Station address | Key Length | Temporal Key | Rx Michael Key |Tx Michael Key | *|----------------|------------|--------------|----------------|---------------| | 6 bytes | 1byte | 16 bytes | 8 bytes | 8 bytes | ||-----------------------------------------------------------------------------| * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_add_ptk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8Ptk, u8 u8PtkKeylen, const u8 *mac_addr, const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode, u8 u8Idx) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; u8 u8KeyLen = u8PtkKeylen; u32 i; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } if (pu8RxMic != NULL) { u8KeyLen += RX_MIC_KEY_LEN; } if (pu8TxMic != NULL) { u8KeyLen += TX_MIC_KEY_LEN; } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WPAPtk; #ifdef WILC_AP_EXTERNAL_MLME if (mode == AP_MODE) { strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx = u8Idx; } #endif if (mode == STATION_MODE) strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8PtkKeylen); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pu8Ptk, u8PtkKeylen); if (pu8RxMic != NULL) { WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 16, pu8RxMic, RX_MIC_KEY_LEN); if (INFO) { for (i = 0; i < RX_MIC_KEY_LEN; i++) PRINT_INFO(CFG80211_DBG, "PairwiseRx[%d] = %x\n", i, pu8RxMic[i]); } } if (pu8TxMic != NULL) { WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 24, pu8TxMic, TX_MIC_KEY_LEN); if (INFO) { for (i = 0; i < TX_MIC_KEY_LEN; i++) PRINT_INFO(CFG80211_DBG, "PairwiseTx[%d] = %x\n", i, pu8TxMic[i]); } } strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen = u8KeyLen; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = u8Ciphermode; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.pu8macaddr = mac_addr; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue: PTK Key\n"); /* ////////////// */ down(&(pstrWFIDrv->hSemTestKeyBlock)); /* WILC_Sleep(100); */ /* /////// */ WILC_CATCH(s32Error) { } return s32Error; } /** * @brief adds Rx GTk Key * @details * @param[in,out] handle to the wifi driver * @param[in] pu8RxGtk : contains temporal key | Rx Mic | Tx Mic * u8GtkKeylen :The total key length * * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_add_rx_gtk(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8RxGtk, u8 u8GtkKeylen, u8 u8KeyIdx, u32 u32KeyRSClen, const u8 *KeyRSC, const u8 *pu8RxMic, const u8 *pu8TxMic, u8 mode, u8 u8Ciphermode) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; u8 u8KeyLen = u8GtkKeylen; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); if (pu8RxMic != NULL) { u8KeyLen += RX_MIC_KEY_LEN; } if (pu8TxMic != NULL) { u8KeyLen += TX_MIC_KEY_LEN; } if (KeyRSC != NULL) { strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq = (u8 *)WILC_MALLOC(u32KeyRSClen); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8seq, KeyRSC, u32KeyRSClen); } strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = WPARxGtk; strHostIFmsg.drvHandler = hWFIDrv; #ifdef WILC_AP_EXTERNAL_MLME if (mode == AP_MODE) { strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY_AP; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.u8Ciphermode = u8Ciphermode; } #endif if (mode == STATION_MODE) strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.pu8key = (u8 *)WILC_MALLOC(u8KeyLen); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key, pu8RxGtk, u8GtkKeylen); if (pu8RxMic != NULL) { WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 16, pu8RxMic, RX_MIC_KEY_LEN); } if (pu8TxMic != NULL) { WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFwpaAttr.pu8key + 24, pu8TxMic, TX_MIC_KEY_LEN); } strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8keyidx = u8KeyIdx; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8Keylen = u8KeyLen; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr. uniHostIFkeyAttr.strHostIFwpaAttr.u8seqlen = u32KeyRSClen; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Error in sending message queue: RX GTK\n"); /* ////////////// */ down(&(pstrWFIDrv->hSemTestKeyBlock)); /* WILC_Sleep(100); */ /* /////// */ WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_set_pmkid_info * @details caches the pmkid valid only in BSS STA mode if External Supplicant * support is enabled. This Function sets the PMKID in firmware * when host drivr receives the corresponding request from NDIS. * The firmware then includes theset PMKID in the appropriate * management frames * @param[in,out] handle to the wifi driver * @param[in] message containing PMKID Info in the following format *|-----------------------------------------------------------------| *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] | *|-----------|------------|----------|-------|----------|----------| | 1 | 6 | 16 | ... | 6 | 16 | ||-----------------------------------------------------------------| * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_pmkid_info(WILC_WFIDrvHandle hWFIDrv, tstrHostIFpmkidAttr *pu8PmkidInfoArray) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; u32 i; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Key Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_KEY; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.enuKeyType = PMKSA; strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.u8KeyAction = ADDKEY; strHostIFmsg.drvHandler = hWFIDrv; for (i = 0; i < pu8PmkidInfoArray->numpmkid; i++) { WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].bssid, &pu8PmkidInfoArray->pmkidlist[i].bssid, ETH_ALEN); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFkeyAttr.uniHostIFkeyAttr.strHostIFpmkidAttr.pmkidlist[i].pmkid, &pu8PmkidInfoArray->pmkidlist[i].pmkid, PMKID_LEN); } /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER(" Error in sending messagequeue: PMKID Info\n"); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief gets the cached the pmkid info * @details valid only in BSS STA mode if External Supplicant * support is enabled. This Function sets the PMKID in firmware * when host drivr receives the corresponding request from NDIS. * The firmware then includes theset PMKID in the appropriate * management frames * @param[in,out] handle to the wifi driver, * message containing PMKID Info in the following format *|-----------------------------------------------------------------| *|NumEntries | BSSID[1] | PMKID[1] | ... | BSSID[K] | PMKID[K] | *|-----------|------------|----------|-------|----------|----------| | 1 | 6 | 16 | ... | 6 | 16 | ||-----------------------------------------------------------------| * @param[in] * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_pmkid_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PmkidInfoArray, u32 u32PmkidInfoLen) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_PMKID_INFO; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = u32PmkidInfoLen; strWID.ps8WidVal = pu8PmkidInfoArray; return s32Error; } /** * @brief sets the pass phrase * @details AP/STA mode. This function gives the pass phrase used to * generate the Pre-Shared Key when WPA/WPA2 is enabled * The length of the field can vary from 8 to 64 bytes, * the lower layer should get the * @param[in,out] handle to the wifi driver, * @param[in] String containing PSK * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PassPhrase, u8 u8Psklength) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ /* u8 u8Psklength = WILC_strlen(pu8PassPhrase); */ /*validating psk length*/ if ((u8Psklength > 7) && (u8Psklength < 65)) { strWID.u16WIDid = (u16)WID_11I_PSK; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = pu8PassPhrase; strWID.s32ValueSize = u8Psklength; } return s32Error; } /** * @brief host_int_get_MacAddress * @details gets mac address * @param[in,out] handle to the wifi driver, * * @return Error code indicating success/failure * @note * @author mdaftedar * @date 19 April 2012 * @version 1.0 */ s32 host_int_get_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_MAC_ADDRESS; strHostIFmsg.uniHostIFmsgBody.strHostIfGetMacAddress.u8MacAddress = pu8MacAddress; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send get mac address\n"); return WILC_FAIL; } down(&hWaitResponse); return s32Error; } /** * @brief host_int_set_MacAddress * @details sets mac address * @param[in,out] handle to the wifi driver, * * @return Error code indicating success/failure * @note * @author mabubakr * @date 16 July 2012 * @version 1.0 */ s32 host_int_set_MacAddress(WILC_WFIDrvHandle hWFIDrv, u8 *pu8MacAddress) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; PRINT_D(GENERIC_DBG, "mac addr = %x:%x:%x\n", pu8MacAddress[0], pu8MacAddress[1], pu8MacAddress[2]); /* prepare setting mac address message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_MAC_ADDRESS; WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIfSetMacAddress.u8MacAddress, pu8MacAddress, ETH_ALEN); strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send message queue: Set mac address\n"); WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_get_RSNAConfigPSKPassPhrase * @details gets the pass phrase:AP/STA mode. This function gets the pass phrase used to * generate the Pre-Shared Key when WPA/WPA2 is enabled * The length of the field can vary from 8 to 64 bytes, * the lower layer should get the * @param[in,out] handle to the wifi driver, * String containing PSK * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_RSNAConfigPSKPassPhrase(WILC_WFIDrvHandle hWFIDrv, u8 *pu8PassPhrase, u8 u8Psklength) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_11I_PSK; strWID.enuWIDtype = WID_STR; strWID.s32ValueSize = u8Psklength; strWID.ps8WidVal = pu8PassPhrase; return s32Error; } /** * @brief host_int_get_site_survey_results * @details gets the site survey results * @param[in,out] handle to the wifi driver, * Message containing site survey results in the * following format *|---------------------------------------------------| | MsgLength | fragNo. | MsgBodyLength | MsgBody | ||-----------|-----------|---------------|-----------| | 1 | 1 | 1 | 1 | | ----------------------------------------- | ---------------- | ||---------------------------------------| | Network1 | Netweork2 | ... | Network5 | ||---------------------------------------| | 44 | 44 | ... | 44 | | -------------------------- | --------------------------------------- | ||---------------------------------------------------------------------| | SSID | BSS Type | Channel | Security Status| BSSID | RSSI |Reserved | | | ||------|----------|---------|----------------|-------|------|---------| | 33 | 1 | 1 | 1 | 6 | 1 | 1 | ||---------------------------------------------------------------------| * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ #ifndef CONNECT_DIRECT s32 host_int_get_site_survey_results(WILC_WFIDrvHandle hWFIDrv, u8 ppu8RcvdSiteSurveyResults[][MAX_SURVEY_RESULT_FRAG_SIZE], u32 u32MaxSiteSrvyFragLen) { s32 s32Error = WILC_SUCCESS; tstrWID astrWIDList[2]; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; astrWIDList[0].u16WIDid = (u16)WID_SITE_SURVEY_RESULTS; astrWIDList[0].enuWIDtype = WID_STR; astrWIDList[0].ps8WidVal = ppu8RcvdSiteSurveyResults[0]; astrWIDList[0].s32ValueSize = u32MaxSiteSrvyFragLen; astrWIDList[1].u16WIDid = (u16)WID_SITE_SURVEY_RESULTS; astrWIDList[1].enuWIDtype = WID_STR; astrWIDList[1].ps8WidVal = ppu8RcvdSiteSurveyResults[1]; astrWIDList[1].s32ValueSize = u32MaxSiteSrvyFragLen; s32Error = SendConfigPkt(GET_CFG, astrWIDList, 2, true, (u32)pstrWFIDrv); /*get the value by searching the local copy*/ if (s32Error) { PRINT_ER("Failed to send config packet to get survey results\n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } WILC_CATCH(s32Error) { } return s32Error; } #endif /** * @brief sets a start scan request * @details * @param[in,out] handle to the wifi driver, * @param[in] Scan Source one of the following values * DEFAULT_SCAN 0 * USER_SCAN BIT0 * OBSS_PERIODIC_SCAN BIT1 * OBSS_ONETIME_SCAN BIT2 * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 scanSource) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_START_SCAN_REQ; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&scanSource; strWID.s32ValueSize = sizeof(char); return s32Error; } /** * @brief host_int_get_start_scan_req * @details gets a start scan request * @param[in,out] handle to the wifi driver, * @param[in] Scan Source one of the following values * DEFAULT_SCAN 0 * USER_SCAN BIT0 * OBSS_PERIODIC_SCAN BIT1 * OBSS_ONETIME_SCAN BIT2 * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_start_scan_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ScanSource) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_START_SCAN_REQ; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)pu8ScanSource; strWID.s32ValueSize = sizeof(char); return s32Error; } /** * @brief host_int_set_join_req * @details sets a join request * @param[in,out] handle to the wifi driver, * @param[in] Index of the bss descriptor * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_join_req(WILC_WFIDrvHandle hWFIDrv, u8 *pu8bssid, const u8 *pu8ssid, size_t ssidLen, const u8 *pu8IEs, size_t IEsLen, tWILCpfConnectResult pfConnectResult, void *pvUserArg, u8 u8security, AUTHTYPE_T tenuAuth_type, u8 u8channel, void *pJoinParams) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tenuScanConnTimer enuScanConnTimer; if (pstrWFIDrv == NULL || pfConnectResult == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } if (hWFIDrv == NULL) { PRINT_ER("Driver not initialized: gWFiDrvHandle = NULL\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } if (pJoinParams == NULL) { PRINT_ER("Unable to Join - JoinParams is NULL\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } /* * if(gWFiDrvHandle->strWILC_UsrScanReq.u32RcvdChCount == 0) * { * PRINT_ER("No scan results exist: Scanning should be done\n"); * WILC_ERRORREPORT(s32Error, WILC_FAIL); * } */ /* prepare the Connect Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_CONNECT; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.u8security = u8security; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.tenuAuth_type = tenuAuth_type; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.u8channel = u8channel; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pfConnectResult = pfConnectResult; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pvUserArg = pvUserArg; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pJoinParams = pJoinParams; strHostIFmsg.drvHandler = hWFIDrv; if (pu8bssid != NULL) { strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid = (u8 *)WILC_MALLOC(6); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8bssid, pu8bssid, 6); } if (pu8ssid != NULL) { strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.ssidLen = ssidLen; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid = (u8 *)WILC_MALLOC(ssidLen); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8ssid, pu8ssid, ssidLen); } if (pu8IEs != NULL) { strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.IEsLen = IEsLen; strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFconnectAttr.pu8IEs, pu8IEs, IEsLen); } if (pstrWFIDrv->enuHostIFstate < HOST_IF_CONNECTING) { pstrWFIDrv->enuHostIFstate = HOST_IF_CONNECTING; } else PRINT_D(GENERIC_DBG, "Don't set state to 'connecting' as state is %d\n", pstrWFIDrv->enuHostIFstate); /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send message queue: Set join request\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } enuScanConnTimer = CONNECT_TIMER; WILC_TimerStart(&(pstrWFIDrv->hConnectTimer), HOST_IF_CONNECT_TIMEOUT, (void *) hWFIDrv, NULL); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief Flush a join request parameters to FW, but actual connection * @details The function is called in situation where WILC is connected to AP and * required to switch to hybrid FW for P2P connection * @param[in] handle to the wifi driver, * @return Error code indicating success/failure * @note * @author Amr Abdel-Moghny * @date 19 DEC 2013 * @version 8.0 */ s32 host_int_flush_join_req(WILC_WFIDrvHandle hWFIDrv) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; if (!gu8FlushedJoinReq) { s32Error = WILC_FAIL; return s32Error; } if (hWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } strHostIFmsg.u16MsgId = HOST_IF_MSG_FLUSH_CONNECT; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send message queue: Flush join request\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_disconnect * @details disconnects from the currently associated network * @param[in,out] handle to the wifi driver, * @param[in] Reason Code of the Disconnection * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_disconnect(WILC_WFIDrvHandle hWFIDrv, u16 u16ReasonCode) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } if (pstrWFIDrv == NULL) { PRINT_ER("gWFiDrvHandle = NULL\n"); WILC_ERRORREPORT(s32Error, WILC_FAIL); } /* prepare the Disconnect Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_DISCONNECT; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Failed to send message queue: disconnect\n"); /* ////////////// */ down(&(pstrWFIDrv->hSemTestDisconnectBlock)); /* /////// */ WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_disconnect_station * @details disconnects a sta * @param[in,out] handle to the wifi driver, * @param[in] Association Id of the station to be disconnected * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_disconnect_station(WILC_WFIDrvHandle hWFIDrv, u8 assoc_id) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_DISCONNECT; strWID.enuWIDtype = WID_CHAR; strWID.ps8WidVal = (s8 *)&assoc_id; strWID.s32ValueSize = sizeof(char); return s32Error; } /** * @brief host_int_get_assoc_req_info * @details gets a Association request info * @param[in,out] handle to the wifi driver, * Message containg assoc. req info in the following format * ------------------------------------------------------------------------ | Management Frame Format | ||-------------------------------------------------------------------| ||Frame Control|Duration|DA|SA|BSSID|Sequence Control|Frame Body|FCS | ||-------------|--------|--|--|-----|----------------|----------|----| | 2 |2 |6 |6 |6 | 2 |0 - 2312 | 4 | ||-------------------------------------------------------------------| | | | Association Request Frame - Frame Body | ||-------------------------------------------------------------------| | Capability Information | Listen Interval | SSID | Supported Rates | ||------------------------|-----------------|------|-----------------| | 2 | 2 | 2-34 | 3-10 | | --------------------------------------------------------------------- * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_assoc_req_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocReqInfo, u32 u32AssocReqInfoLen) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_ASSOC_REQ_INFO; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = pu8AssocReqInfo; strWID.s32ValueSize = u32AssocReqInfoLen; return s32Error; } /** * @brief gets a Association Response info * @details * @param[in,out] handle to the wifi driver, * Message containg assoc. resp info * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_assoc_res_info(WILC_WFIDrvHandle hWFIDrv, u8 *pu8AssocRespInfo, u32 u32MaxAssocRespInfoLen, u32 *pu32RcvdAssocRespInfoLen) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } strWID.u16WIDid = (u16)WID_ASSOC_RES_INFO; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = pu8AssocRespInfo; strWID.s32ValueSize = u32MaxAssocRespInfoLen; /* Sending Configuration packet */ s32Error = SendConfigPkt(GET_CFG, &strWID, 1, true, (u32)pstrWFIDrv); if (s32Error) { PRINT_ER("Failed to send association response config packet\n"); *pu32RcvdAssocRespInfoLen = 0; WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { *pu32RcvdAssocRespInfoLen = strWID.s32ValueSize; } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief gets a Association Response info * @details Valid only in STA mode. This function gives the RSSI * values observed in all the channels at the time of scanning. * The length of the field is 1 greater that the total number of * channels supported. Byte 0 contains the number of channels while * each of Byte N contains the observed RSSI value for the channel index N. * @param[in,out] handle to the wifi driver, * array of scanned channels' RSSI * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_rx_power_level(WILC_WFIDrvHandle hWFIDrv, u8 *pu8RxPowerLevel, u32 u32RxPowerLevelLen) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; /* tstrWILC_WFIDrv * pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; */ strWID.u16WIDid = (u16)WID_RX_POWER_LEVEL; strWID.enuWIDtype = WID_STR; strWID.ps8WidVal = pu8RxPowerLevel; strWID.s32ValueSize = u32RxPowerLevelLen; return s32Error; } /** * @brief sets a channel * @details * @param[in,out] handle to the wifi driver, * @param[in] Index of the channel to be set *|-------------------------------------------------------------------| | CHANNEL1 CHANNEL2 .... CHANNEL14 | | Input: 1 2 14 | ||-------------------------------------------------------------------| * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_set_mac_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 u8ChNum) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the set channel message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_CHANNEL; strHostIFmsg.uniHostIFmsgBody.strHostIFSetChan.u8SetChan = u8ChNum; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } s32 host_int_wait_msg_queue_idle(void) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the set driver handler message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_Q_IDLE; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } /* wait untill MSG Q is empty */ down(&hWaitResponse); return s32Error; } s32 host_int_set_wfi_drv_handler(u32 u32address) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the set driver handler message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_WFIDRV_HANDLER; strHostIFmsg.uniHostIFmsgBody.strHostIfSetDrvHandler.u32Address = u32address; /* strHostIFmsg.drvHandler=hWFIDrv; */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } s32 host_int_set_operation_mode(WILC_WFIDrvHandle hWFIDrv, u32 u32mode) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the set driver handler message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_OPERATION_MODE; strHostIFmsg.uniHostIFmsgBody.strHostIfSetOperationMode.u32Mode = u32mode; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief gets the current channel index * @details * @param[in,out] handle to the wifi driver, * current channel index *|-----------------------------------------------------------------------| | CHANNEL1 CHANNEL2 .... CHANNEL14 | | Input: 1 2 14 | ||-----------------------------------------------------------------------| * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_host_chnl_num(WILC_WFIDrvHandle hWFIDrv, u8 *pu8ChNo) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Get Channel Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_CHNL; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Failed to send get host channel param's message queue "); down(&(pstrWFIDrv->hSemGetCHNL)); /* gu8Chnl = 11; */ *pu8ChNo = gu8Chnl; WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_test_set_int_wid * @details Test function for setting wids * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32 u32TestMemAddr * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_test_set_int_wid(WILC_WFIDrvHandle hWFIDrv, u32 u32TestMemAddr) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /*prepare configuration packet*/ strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS; strWID.enuWIDtype = WID_INT; strWID.ps8WidVal = (char *)&u32TestMemAddr; strWID.s32ValueSize = sizeof(u32); /*Sending Cfg*/ 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); } else { PRINT_D(HOSTINF_DBG, "Successfully set wid value\n"); } WILC_CATCH(s32Error) { } return s32Error; } #ifdef WILC_AP_EXTERNAL_MLME /** * @brief host_int_get_inactive_time * @details * @param[in,out] handle to the wifi driver, * current sta macaddress, inactive_time * @return * @note * @author * @date * @version 1.0 */ s32 host_int_get_inactive_time(WILC_WFIDrvHandle hWFIDrv, const u8 *mac, u32 *pu32InactiveTime) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIfStaInactiveT.mac, mac, ETH_ALEN); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_INACTIVETIME; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) PRINT_ER("Failed to send get host channel param's message queue "); down(&(pstrWFIDrv->hSemInactiveTime)); *pu32InactiveTime = gu32InactiveTime; WILC_CATCH(s32Error) { } return s32Error; } #endif /** * @brief host_int_test_get_int_wid * @details Test function for getting wids * @param[in,out] WILC_WFIDrvHandle hWFIDrv, u32* pu32TestMemAddr * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_test_get_int_wid(WILC_WFIDrvHandle hWFIDrv, u32 *pu32TestMemAddr) { s32 s32Error = WILC_SUCCESS; tstrWID strWID; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } strWID.u16WIDid = (u16)WID_MEMORY_ADDRESS; strWID.enuWIDtype = WID_INT; strWID.ps8WidVal = (s8 *)pu32TestMemAddr; strWID.s32ValueSize = sizeof(u32); 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"); WILC_ERRORREPORT(s32Error, WILC_INVALID_STATE); } else { PRINT_D(HOSTINF_DBG, "Successfully got wid value\n"); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_get_rssi * @details gets the currently maintained RSSI value for the station. * The received signal strength value in dB. * The range of valid values is -128 to 0. * @param[in,out] handle to the wifi driver, * rssi value in dB * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_get_rssi(WILC_WFIDrvHandle hWFIDrv, s8 *ps8Rssi) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; /* prepare the Get RSSI Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_RSSI; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send get host channel param's message queue "); return WILC_FAIL; } down(&(pstrWFIDrv->hSemGetRSSI)); if (ps8Rssi == NULL) { PRINT_ER("RSS pointer value is null"); return WILC_FAIL; } *ps8Rssi = gs8Rssi; return s32Error; } s32 host_int_get_link_speed(WILC_WFIDrvHandle hWFIDrv, s8 *ps8lnkspd) { tstrHostIFmsg strHostIFmsg; s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; /* prepare the Get LINKSPEED Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_LINKSPEED; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send GET_LINKSPEED to message queue "); return WILC_FAIL; } down(&(pstrWFIDrv->hSemGetLINKSPEED)); if (ps8lnkspd == NULL) { PRINT_ER("LINKSPEED pointer value is null"); return WILC_FAIL; } *ps8lnkspd = gs8lnkspd; return s32Error; } s32 host_int_get_statistics(WILC_WFIDrvHandle hWFIDrv, tstrStatistics *pstrStatistics) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the Get RSSI Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_STATISTICS; strHostIFmsg.uniHostIFmsgBody.pUserData = (char *)pstrStatistics; strHostIFmsg.drvHandler = hWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send get host channel param's message queue "); return WILC_FAIL; } down(&hWaitResponse); return s32Error; } /** * @brief host_int_scan * @details scans a set of channels * @param[in,out] handle to the wifi driver, * @param[in] Scan source * Scan Type PASSIVE_SCAN = 0, * ACTIVE_SCAN = 1 * Channels Array * Channels Array length * Scan Callback function * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_scan(WILC_WFIDrvHandle hWFIDrv, u8 u8ScanSource, u8 u8ScanType, u8 *pu8ChnlFreqList, u8 u8ChnlListLen, const u8 *pu8IEs, size_t IEsLen, tWILCpfScanResult ScanResult, void *pvUserArg, tstrHiddenNetwork *pstrHiddenNetwork) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tenuScanConnTimer enuScanConnTimer; if (pstrWFIDrv == NULL || ScanResult == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the Scan Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_SCAN; if (pstrHiddenNetwork != NULL) { strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.strHiddenNetwork.pstrHiddenNetworkInfo = pstrHiddenNetwork->pstrHiddenNetworkInfo; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.strHiddenNetwork.u8ssidnum = pstrHiddenNetwork->u8ssidnum; } else PRINT_D(HOSTINF_DBG, "pstrHiddenNetwork IS EQUAL TO NULL\n"); strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ScanSource = u8ScanSource; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ScanType = u8ScanType; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pfScanResult = ScanResult; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pvUserArg = pvUserArg; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.u8ChnlListLen = u8ChnlListLen; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList = (u8 *)WILC_MALLOC(u8ChnlListLen); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8ChnlFreqList, pu8ChnlFreqList, u8ChnlListLen); strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.IEsLen = IEsLen; strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs = (u8 *)WILC_MALLOC(IEsLen); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strHostIFscanAttr.pu8IEs, pu8IEs, IEsLen); /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Error in sending message queue scanning parameters: Error(%d)\n", s32Error); WILC_ERRORREPORT(s32Error, WILC_FAIL); } enuScanConnTimer = SCAN_TIMER; PRINT_D(HOSTINF_DBG, ">> Starting the SCAN timer\n"); WILC_TimerStart(&(pstrWFIDrv->hScanTimer), HOST_IF_SCAN_TIMEOUT, (void *) hWFIDrv, NULL); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief hif_set_cfg * @details sets configuration wids values * @param[in,out] handle to the wifi driver, * @param[in] WID, WID value * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 hif_set_cfg(WILC_WFIDrvHandle hWFIDrv, tstrCfgParamVal *pstrCfgParamVal) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the WiphyParams Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_CFG_PARAMS; strHostIFmsg.uniHostIFmsgBody.strHostIFCfgParamAttr.pstrCfgParamVal = *pstrCfgParamVal; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief hif_get_cfg * @details gets configuration wids values * @param[in,out] handle to the wifi driver, * WID value * @param[in] WID, * @return Error code indicating success/failure * @note * @author zsalah * * @date 8 March 2012 * @version 1.0 */ s32 hif_get_cfg(WILC_WFIDrvHandle hWFIDrv, u16 u16WID, u16 *pu16WID_Value) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; down(&(pstrWFIDrv->gtOsCfgValuesSem)); if (pstrWFIDrv == NULL) { PRINT_ER("Driver not initialized: pstrWFIDrv = NULL \n"); WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } PRINT_D(HOSTINF_DBG, "Getting configuration parameters\n"); switch (u16WID) { case WID_BSS_TYPE: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.bss_type; break; case WID_AUTH_TYPE: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.auth_type; break; case WID_AUTH_TIMEOUT: *pu16WID_Value = pstrWFIDrv->strCfgValues.auth_timeout; break; case WID_POWER_MANAGEMENT: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.power_mgmt_mode; break; case WID_SHORT_RETRY_LIMIT: *pu16WID_Value = pstrWFIDrv->strCfgValues.short_retry_limit; break; case WID_LONG_RETRY_LIMIT: *pu16WID_Value = pstrWFIDrv->strCfgValues.long_retry_limit; break; case WID_FRAG_THRESHOLD: *pu16WID_Value = pstrWFIDrv->strCfgValues.frag_threshold; break; case WID_RTS_THRESHOLD: *pu16WID_Value = pstrWFIDrv->strCfgValues.rts_threshold; break; case WID_PREAMBLE: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.preamble_type; break; case WID_SHORT_SLOT_ALLOWED: *pu16WID_Value = (u16) pstrWFIDrv->strCfgValues.short_slot_allowed; break; case WID_11N_TXOP_PROT_DISABLE: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.txop_prot_disabled; break; case WID_BEACON_INTERVAL: *pu16WID_Value = pstrWFIDrv->strCfgValues.beacon_interval; break; case WID_DTIM_PERIOD: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.dtim_period; break; case WID_SITE_SURVEY: *pu16WID_Value = (u16)pstrWFIDrv->strCfgValues.site_survey_enabled; break; case WID_SITE_SURVEY_SCAN_TIME: *pu16WID_Value = pstrWFIDrv->strCfgValues.site_survey_scan_time; break; case WID_ACTIVE_SCAN_TIME: *pu16WID_Value = pstrWFIDrv->strCfgValues.active_scan_time; break; case WID_PASSIVE_SCAN_TIME: *pu16WID_Value = pstrWFIDrv->strCfgValues.passive_scan_time; break; case WID_CURRENT_TX_RATE: *pu16WID_Value = pstrWFIDrv->strCfgValues.curr_tx_rate; break; default: break; } up(&(pstrWFIDrv->gtOsCfgValuesSem)); WILC_CATCH(s32Error) { } return s32Error; } /*****************************************************************************/ /* Notification Functions */ /*****************************************************************************/ /** * @brief notifies host with join and leave requests * @details This function prepares an Information frame having the * information about a joining/leaving station. * @param[in,out] handle to the wifi driver, * @param[in] 6 byte Sta Adress * Join or leave flag: * Join = 1, * Leave =0 * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ void host_int_send_join_leave_info_to_host (u16 assocId, u8 *stationAddr, bool joining) { } /** * @brief notifies host with stations found in scan * @details sends the beacon/probe response from scan * @param[in,out] handle to the wifi driver, * @param[in] Sta Address, * Frame length, * Rssi of the Station found * @return Error code indicating success/failure * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ void GetPeriodicRSSI(void *pvArg) { tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)pvArg; if (pstrWFIDrv == NULL) { PRINT_ER("Driver handler is NULL\n"); return; } if (pstrWFIDrv->enuHostIFstate == HOST_IF_CONNECTED) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /* prepare the Get RSSI Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_RSSI; strHostIFmsg.drvHandler = pstrWFIDrv; /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Failed to send get host channel param's message queue "); return; } } WILC_TimerStart(&(g_hPeriodicRSSI), 5000, (void *)pstrWFIDrv, NULL); } void host_int_send_network_info_to_host (u8 *macStartAddress, u16 u16RxFrameLen, s8 s8Rssi) { } /** * @brief host_int_init * @details host interface initialization function * @param[in,out] handle to the wifi driver, * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ static u32 u32Intialized; static u32 msgQ_created; static u32 clients_count; s32 host_int_init(WILC_WFIDrvHandle *phWFIDrv) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv; /*if(u32Intialized == 1) * { * PRINT_D(HOSTINF_DBG,"Host interface is previously initialized\n"); * *phWFIDrv = (WILC_WFIDrvHandle)gWFiDrvHandle; //Will be adjusted later for P2P * return 0; * } */ PRINT_D(HOSTINF_DBG, "Initializing host interface for client %d\n", clients_count + 1); gbScanWhileConnected = false; sema_init(&hWaitResponse, 0); /*Allocate host interface private structure*/ pstrWFIDrv = (tstrWILC_WFIDrv *)WILC_MALLOC(sizeof(tstrWILC_WFIDrv)); if (pstrWFIDrv == NULL) { /* WILC_ERRORREPORT(s32Error,WILC_NO_MEM); */ s32Error = WILC_NO_MEM; PRINT_ER("Failed to allocate memory\n"); goto _fail_timer_2; } WILC_memset(pstrWFIDrv, 0, sizeof(tstrWILC_WFIDrv)); /*return driver handle to user*/ *phWFIDrv = (WILC_WFIDrvHandle)pstrWFIDrv; /*save into globl handle*/ #ifdef DISABLE_PWRSAVE_AND_SCAN_DURING_IP g_obtainingIP = false; #endif PRINT_D(HOSTINF_DBG, "Global handle pointer value=%p\n", pstrWFIDrv); /* /////////////////////////////////////// */ if (clients_count == 0) { sema_init(&hSemHostIFthrdEnd, 0); sema_init(&hSemDeinitDrvHandle, 0); /*BugID_5348*/ sema_init(&hSemHostIntDeinit, 1); } sema_init(&(pstrWFIDrv->hSemTestKeyBlock), 0); sema_init(&(pstrWFIDrv->hSemTestDisconnectBlock), 0); sema_init(&(pstrWFIDrv->hSemGetRSSI), 0); sema_init(&(pstrWFIDrv->hSemGetLINKSPEED), 0); sema_init(&(pstrWFIDrv->hSemGetCHNL), 0); sema_init(&(pstrWFIDrv->hSemInactiveTime), 0); /* /////////////////////////////////////// */ PRINT_D(HOSTINF_DBG, "INIT: CLIENT COUNT %d\n", clients_count); if (clients_count == 0) { s32Error = WILC_MsgQueueCreate(&gMsgQHostIF, NULL); if (s32Error < 0) { PRINT_ER("Failed to creat MQ\n"); goto _fail_; } msgQ_created = 1; HostIFthreadHandler = kthread_run(hostIFthread, NULL, "WILC_kthread"); if (IS_ERR(HostIFthreadHandler)) { PRINT_ER("Failed to creat Thread\n"); s32Error = WILC_FAIL; goto _fail_mq_; } s32Error = WILC_TimerCreate(&(g_hPeriodicRSSI), GetPeriodicRSSI, NULL); if (s32Error < 0) { PRINT_ER("Failed to creat Timer\n"); goto _fail_timer_1; } WILC_TimerStart(&(g_hPeriodicRSSI), 5000, (void *)pstrWFIDrv, NULL); } s32Error = WILC_TimerCreate(&(pstrWFIDrv->hScanTimer), TimerCB_Scan, NULL); if (s32Error < 0) { PRINT_ER("Failed to creat Timer\n"); goto _fail_thread_; } s32Error = WILC_TimerCreate(&(pstrWFIDrv->hConnectTimer), TimerCB_Connect, NULL); if (s32Error < 0) { PRINT_ER("Failed to creat Timer\n"); goto _fail_timer_1; } #ifdef WILC_P2P /*Remain on channel timer*/ s32Error = WILC_TimerCreate(&(pstrWFIDrv->hRemainOnChannel), ListenTimerCB, NULL); if (s32Error < 0) { PRINT_ER("Failed to creat Remain-on-channel Timer\n"); goto _fail_timer_3; } #endif sema_init(&(pstrWFIDrv->gtOsCfgValuesSem), 1); down(&(pstrWFIDrv->gtOsCfgValuesSem)); #ifdef SIMULATION TransportInit(); #endif pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; /* gWFiDrvHandle->bPendingConnRequest = false; */ /*Initialize CFG WIDS Defualt Values*/ pstrWFIDrv->strCfgValues.site_survey_enabled = SITE_SURVEY_OFF; pstrWFIDrv->strCfgValues.scan_source = DEFAULT_SCAN; pstrWFIDrv->strCfgValues.active_scan_time = ACTIVE_SCAN_TIME; pstrWFIDrv->strCfgValues.passive_scan_time = PASSIVE_SCAN_TIME; pstrWFIDrv->strCfgValues.curr_tx_rate = AUTORATE; #ifdef WILC_P2P pstrWFIDrv->u64P2p_MgmtTimeout = 0; #endif PRINT_INFO(HOSTINF_DBG, "Initialization values, Site survey value: %d\n Scan source: %d\n Active scan time: %d\n Passive scan time: %d\nCurrent tx Rate = %d\n", pstrWFIDrv->strCfgValues.site_survey_enabled, pstrWFIDrv->strCfgValues.scan_source, pstrWFIDrv->strCfgValues.active_scan_time, pstrWFIDrv->strCfgValues.passive_scan_time, pstrWFIDrv->strCfgValues.curr_tx_rate); up(&(pstrWFIDrv->gtOsCfgValuesSem)); /*TODO Code to setup simulation to be removed later*/ /*Intialize configurator module*/ s32Error = CoreConfiguratorInit(); if (s32Error < 0) { PRINT_ER("Failed to initialize core configurator\n"); goto _fail_mem_; } #ifdef SIMULATION /*Initialize Simulaor*/ CoreConfigSimulatorInit(); #endif u32Intialized = 1; clients_count++; /* increase number of created entities */ return s32Error; _fail_mem_: if (pstrWFIDrv != NULL) WILC_FREE(pstrWFIDrv); #ifdef WILC_P2P _fail_timer_3: WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL); #endif _fail_timer_2: up(&(pstrWFIDrv->gtOsCfgValuesSem)); WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL); _fail_timer_1: WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL); _fail_thread_: kthread_stop(HostIFthreadHandler); _fail_mq_: WILC_MsgQueueDestroy(&gMsgQHostIF, NULL); _fail_: return s32Error; } /** * @brief host_int_deinit * @details host interface initialization function * @param[in,out] handle to the wifi driver, * @note * @author zsalah * @date 8 March 2012 * @version 1.0 */ s32 host_int_deinit(WILC_WFIDrvHandle hWFIDrv) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; /*obtain driver handle*/ tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; /*if(u32Intialized == 0) * { * PRINT_ER("Host Interface is not initialized\n"); * return 0; * }*/ /*BugID_5348*/ if (pstrWFIDrv == NULL) { PRINT_ER("pstrWFIDrv = NULL\n"); return 0; } down(&hSemHostIntDeinit); terminated_handle = pstrWFIDrv; PRINT_D(HOSTINF_DBG, "De-initializing host interface for client %d\n", clients_count); /*BugID_5348*/ /*Destroy all timers before acquiring hSemDeinitDrvHandle*/ /*to guarantee handling all messages befor proceeding*/ if (WILC_TimerDestroy(&(pstrWFIDrv->hScanTimer), NULL)) { PRINT_D(HOSTINF_DBG, ">> Scan timer is active \n"); /* msleep(HOST_IF_SCAN_TIMEOUT+1000); */ } if (WILC_TimerDestroy(&(pstrWFIDrv->hConnectTimer), NULL)) { PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n"); /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */ } if (WILC_TimerDestroy(&(g_hPeriodicRSSI), NULL)) { PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n"); /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */ } #ifdef WILC_P2P /*Destroy Remain-onchannel Timer*/ WILC_TimerDestroy(&(pstrWFIDrv->hRemainOnChannel), NULL); #endif host_int_set_wfi_drv_handler((u32)NULL); down(&hSemDeinitDrvHandle); /*Calling the CFG80211 scan done function with the abort flag set to true*/ if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult(SCAN_EVENT_ABORTED, NULL, pstrWFIDrv->strWILC_UsrScanReq.u32UserScanPvoid, NULL); pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult = NULL; } /*deinit configurator and simulator*/ #ifdef SIMULATION CoreConfigSimulatorDeInit(); #endif CoreConfiguratorDeInit(); #ifdef SIMULATION TransportDeInit(); #endif pstrWFIDrv->enuHostIFstate = HOST_IF_IDLE; gbScanWhileConnected = false; WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); if (clients_count == 1) { if (WILC_TimerDestroy(&g_hPeriodicRSSI, NULL)) { PRINT_D(HOSTINF_DBG, ">> Connect timer is active \n"); /* msleep(HOST_IF_CONNECT_TIMEOUT+1000); */ } strHostIFmsg.u16MsgId = HOST_IF_MSG_EXIT; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error != WILC_SUCCESS) { PRINT_ER("Error in sending deinit's message queue message function: Error(%d)\n", s32Error); } down(&hSemHostIFthrdEnd); WILC_MsgQueueDestroy(&gMsgQHostIF, NULL); msgQ_created = 0; } down(&(pstrWFIDrv->gtOsCfgValuesSem)); /*Setting the gloabl driver handler with NULL*/ u32Intialized = 0; /* gWFiDrvHandle = NULL; */ if (pstrWFIDrv != NULL) { WILC_FREE(pstrWFIDrv); /* pstrWFIDrv=NULL; */ } clients_count--; /* Decrease number of created entities */ terminated_handle = NULL; up(&hSemHostIntDeinit); return s32Error; } /** * @brief NetworkInfoReceived * @details function to to be called when network info packet is received * @param[in] pu8Buffer the received packet * @param[in] u32Length length of the received packet * @return none * @note * @author * @date 1 Mar 2012 * @version 1.0 */ void NetworkInfoReceived(u8 *pu8Buffer, u32 u32Length) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; u32 drvHandler; tstrWILC_WFIDrv *pstrWFIDrv = NULL; drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24)); pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) { PRINT_ER("NetworkInfo received but driver not init[%p]\n", pstrWFIDrv); return; } /* prepare the Asynchronous Network Info message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_NTWRK_INFO; strHostIFmsg.drvHandler = pstrWFIDrv; strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.u32Length = u32Length; strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdNetworkInfo.pu8Buffer, pu8Buffer, u32Length); /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Error in sending network info message queue message parameters: Error(%d)\n", s32Error); } return; } /** * @brief GnrlAsyncInfoReceived * @details function to be called when general Asynchronous info packet is received * @param[in] pu8Buffer the received packet * @param[in] u32Length length of the received packet * @return none * @note * @author * @date 15 Mar 2012 * @version 1.0 */ void GnrlAsyncInfoReceived(u8 *pu8Buffer, u32 u32Length) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; u32 drvHandler; tstrWILC_WFIDrv *pstrWFIDrv = NULL; /*BugID_5348*/ down(&hSemHostIntDeinit); drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24)); pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(HOSTINF_DBG, "General asynchronous info packet received \n"); if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) { PRINT_D(HOSTINF_DBG, "Wifi driver handler is equal to NULL\n"); /*BugID_5348*/ up(&hSemHostIntDeinit); return; } if (pstrWFIDrv->strWILC_UsrConnReq.pfUserConnectResult == NULL) { /* received mac status is not needed when there is no current Connect Request */ PRINT_ER("Received mac status is not needed when there is no current Connect Reques\n"); /*BugID_5348*/ up(&hSemHostIntDeinit); return; } /* prepare the General Asynchronous Info message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_GNRL_ASYNC_INFO; strHostIFmsg.drvHandler = pstrWFIDrv; strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.u32Length = u32Length; strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer = (u8 *)WILC_MALLOC(u32Length); /* will be deallocated by the receiving thread */ WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strRcvdGnrlAsyncInfo.pu8Buffer, pu8Buffer, u32Length); /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Error in sending message queue asynchronous message info: Error(%d)\n", s32Error); } /*BugID_5348*/ up(&hSemHostIntDeinit); return; } /** * @brief host_int_ScanCompleteReceived * @details Setting scan complete received notifcation in message queue * @param[in] u8* pu8Buffer, u32 u32Length * @return Error code. * @author * @date * @version 1.0 */ void host_int_ScanCompleteReceived(u8 *pu8Buffer, u32 u32Length) { s32 s32Error = WILC_SUCCESS; tstrHostIFmsg strHostIFmsg; u32 drvHandler; tstrWILC_WFIDrv *pstrWFIDrv = NULL; drvHandler = ((pu8Buffer[u32Length - 4]) | (pu8Buffer[u32Length - 3] << 8) | (pu8Buffer[u32Length - 2] << 16) | (pu8Buffer[u32Length - 1] << 24)); pstrWFIDrv = (tstrWILC_WFIDrv *)drvHandler; PRINT_D(GENERIC_DBG, "Scan notification received %p\n", pstrWFIDrv); if (pstrWFIDrv == NULL || pstrWFIDrv == terminated_handle) { return; } /*if there is an ongoing scan request*/ if (pstrWFIDrv->strWILC_UsrScanReq.pfUserScanResult) { /* prepare theScan Done message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_RCVD_SCAN_COMPLETE; strHostIFmsg.drvHandler = pstrWFIDrv; /* will be deallocated by the receiving thread */ /*no need to send message body*/ /*strHostIFmsg.uniHostIFmsgBody.strScanComplete.u32Length = u32Length; * strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer = (u8*)WILC_MALLOC(u32Length); * WILC_memcpy(strHostIFmsg.uniHostIFmsgBody.strScanComplete.pu8Buffer, * pu8Buffer, u32Length); */ /* send the message */ s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { PRINT_ER("Error in sending message queue scan complete parameters: Error(%d)\n", s32Error); } } return; } #ifdef WILC_P2P /** * @brief host_int_remain_on_channel * @details * @param[in] Handle to wifi driver * Duration to remain on channel * Channel to remain on * Pointer to fn to be called on receive frames in listen state * Pointer to remain-on-channel expired fn * Priv * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_remain_on_channel(WILC_WFIDrvHandle hWFIDrv, u32 u32SessionID, u32 u32duration, u16 chan, tWILCpfRemainOnChanExpired RemainOnChanExpired, tWILCpfRemainOnChanReady RemainOnChanReady, void *pvUserArg) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the remainonchan Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_REMAIN_ON_CHAN; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u16Channel = chan; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pRemainOnChanExpired = RemainOnChanExpired; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pRemainOnChanReady = RemainOnChanReady; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.pVoid = pvUserArg; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32duration = u32duration; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_ListenStateExpired * @details * @param[in] Handle to wifi driver * Duration to remain on channel * Channel to remain on * Pointer to fn to be called on receive frames in listen state * Pointer to remain-on-channel expired fn * Priv * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_ListenStateExpired(WILC_WFIDrvHandle hWFIDrv, u32 u32SessionID) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /*Stopping remain-on-channel timer*/ WILC_TimerStop(&(pstrWFIDrv->hRemainOnChannel), NULL); /* prepare the timer fire Message */ WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); strHostIFmsg.u16MsgId = HOST_IF_MSG_LISTEN_TIMER_FIRED; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIfRemainOnChan.u32ListenSessionID = u32SessionID; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_frame_register * @details * @param[in] Handle to wifi driver * @return Error code. * @author * @date * @version 1.0*/ s32 host_int_frame_register(WILC_WFIDrvHandle hWFIDrv, u16 u16FrameType, bool bReg) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_REGISTER_FRAME; switch (u16FrameType) { case ACTION: PRINT_D(HOSTINF_DBG, "ACTION\n"); strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u8Regid = ACTION_FRM_IDX; break; case PROBE_REQ: PRINT_D(HOSTINF_DBG, "PROBE REQ\n"); strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u8Regid = PROBE_REQ_IDX; break; default: PRINT_D(HOSTINF_DBG, "Not valid frame type\n"); break; } strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.u16FrameType = u16FrameType; strHostIFmsg.uniHostIFmsgBody.strHostIfRegisterFrame.bReg = bReg; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } #endif #ifdef WILC_AP_EXTERNAL_MLME /** * @brief host_int_add_beacon * @details Setting add beacon params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, u32 u32Interval, * u32 u32DTIMPeriod,u32 u32HeadLen, u8* pu8Head, * u32 u32TailLen, u8* pu8Tail * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_add_beacon(WILC_WFIDrvHandle hWFIDrv, u32 u32Interval, u32 u32DTIMPeriod, u32 u32HeadLen, u8 *pu8Head, u32 u32TailLen, u8 *pu8Tail) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIFSetBeacon *pstrSetBeaconParam = &strHostIFmsg.uniHostIFmsgBody.strHostIFSetBeacon; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); PRINT_D(HOSTINF_DBG, "Setting adding beacon message queue params\n"); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_BEACON; strHostIFmsg.drvHandler = hWFIDrv; pstrSetBeaconParam->u32Interval = u32Interval; pstrSetBeaconParam->u32DTIMPeriod = u32DTIMPeriod; pstrSetBeaconParam->u32HeadLen = u32HeadLen; pstrSetBeaconParam->pu8Head = (u8 *)WILC_MALLOC(u32HeadLen); if (pstrSetBeaconParam->pu8Head == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } WILC_memcpy(pstrSetBeaconParam->pu8Head, pu8Head, u32HeadLen); pstrSetBeaconParam->u32TailLen = u32TailLen; /* Bug 4599 : if tail length = 0 skip allocating & copying */ if (u32TailLen > 0) { pstrSetBeaconParam->pu8Tail = (u8 *)WILC_MALLOC(u32TailLen); if (pstrSetBeaconParam->pu8Tail == NULL) { WILC_ERRORREPORT(s32Error, WILC_NO_MEM); } WILC_memcpy(pstrSetBeaconParam->pu8Tail, pu8Tail, u32TailLen); } else { pstrSetBeaconParam->pu8Tail = NULL; } s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { if (pstrSetBeaconParam->pu8Head != NULL) { WILC_FREE(pstrSetBeaconParam->pu8Head); } if (pstrSetBeaconParam->pu8Tail != NULL) { WILC_FREE(pstrSetBeaconParam->pu8Tail); } } return s32Error; } /** * @brief host_int_del_beacon * @details Setting add beacon params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_del_beacon(WILC_WFIDrvHandle hWFIDrv) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_BEACON; strHostIFmsg.drvHandler = hWFIDrv; PRINT_D(HOSTINF_DBG, "Setting deleting beacon message queue params\n"); s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); WILC_ERRORCHECK(s32Error); WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_add_station * @details Setting add station params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_add_station(WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam *pstrStaParams) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); PRINT_D(HOSTINF_DBG, "Setting adding station message queue params\n"); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_STATION; strHostIFmsg.drvHandler = hWFIDrv; WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam)); if (pstrAddStationMsg->u8NumRates > 0) { u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates); WILC_NULLCHECK(s32Error, rates); WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates); pstrAddStationMsg->pu8Rates = rates; } s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_del_station * @details Setting delete station params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, u8* pu8MacAddr * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_del_station(WILC_WFIDrvHandle hWFIDrv, const u8 *pu8MacAddr) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIFDelSta *pstrDelStationMsg = &strHostIFmsg.uniHostIFmsgBody.strDelStaParam; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); PRINT_D(HOSTINF_DBG, "Setting deleting station message queue params\n"); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_STATION; strHostIFmsg.drvHandler = hWFIDrv; /*BugID_4795: Handling situation of deleting all stations*/ if (pu8MacAddr == NULL) WILC_memset(pstrDelStationMsg->au8MacAddr, 255, ETH_ALEN); else WILC_memcpy(pstrDelStationMsg->au8MacAddr, pu8MacAddr, ETH_ALEN); s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_del_allstation * @details Setting del station params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN]s * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_del_allstation(WILC_WFIDrvHandle hWFIDrv, u8 pu8MacAddr[][ETH_ALEN]) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIFDelAllSta *pstrDelAllStationMsg = &strHostIFmsg.uniHostIFmsgBody.strHostIFDelAllSta; u8 au8Zero_Buff[ETH_ALEN] = {0}; u32 i; u8 u8AssocNumb = 0; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); PRINT_D(HOSTINF_DBG, "Setting deauthenticating station message queue params\n"); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_ALL_STA; strHostIFmsg.drvHandler = hWFIDrv; /* Handling situation of deauthenticing all associated stations*/ for (i = 0; i < MAX_NUM_STA; i++) { if (memcmp(pu8MacAddr[i], au8Zero_Buff, ETH_ALEN)) { WILC_memcpy(pstrDelAllStationMsg->au8Sta_DelAllSta[i], pu8MacAddr[i], ETH_ALEN); PRINT_D(CFG80211_DBG, "BSSID = %x%x%x%x%x%x\n", pstrDelAllStationMsg->au8Sta_DelAllSta[i][0], pstrDelAllStationMsg->au8Sta_DelAllSta[i][1], pstrDelAllStationMsg->au8Sta_DelAllSta[i][2], pstrDelAllStationMsg->au8Sta_DelAllSta[i][3], pstrDelAllStationMsg->au8Sta_DelAllSta[i][4], pstrDelAllStationMsg->au8Sta_DelAllSta[i][5]); u8AssocNumb++; } } if (!u8AssocNumb) { PRINT_D(CFG80211_DBG, "NO ASSOCIATED STAS\n"); return s32Error; } pstrDelAllStationMsg->u8Num_AssocSta = u8AssocNumb; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } down(&hWaitResponse); return s32Error; } /** * @brief host_int_edit_station * @details Setting edit station params in message queue * @param[in] WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam* pstrStaParams * @return Error code. * @author * @date * @version 1.0 */ s32 host_int_edit_station(WILC_WFIDrvHandle hWFIDrv, tstrWILC_AddStaParam *pstrStaParams) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrWILC_AddStaParam *pstrAddStationMsg = &strHostIFmsg.uniHostIFmsgBody.strAddStaParam; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } PRINT_D(HOSTINF_DBG, "Setting editing station message queue params\n"); WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_EDIT_STATION; strHostIFmsg.drvHandler = hWFIDrv; WILC_memcpy(pstrAddStationMsg, pstrStaParams, sizeof(tstrWILC_AddStaParam)); if (pstrAddStationMsg->u8NumRates > 0) { u8 *rates = WILC_MALLOC(pstrAddStationMsg->u8NumRates); WILC_NULLCHECK(s32Error, rates); WILC_memcpy(rates, pstrStaParams->pu8Rates, pstrAddStationMsg->u8NumRates); pstrAddStationMsg->pu8Rates = rates; } s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } #endif /*WILC_AP_EXTERNAL_MLME*/ uint32_t wilc_get_chipid(uint8_t); s32 host_int_set_power_mgmt(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32Timeout) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIfPowerMgmtParam *pstrPowerMgmtParam = &strHostIFmsg.uniHostIFmsgBody.strPowerMgmtparam; PRINT_INFO(HOSTINF_DBG, "\n\n>> Setting PS to %d << \n\n", bIsEnabled); if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } PRINT_D(HOSTINF_DBG, "Setting Power management message queue params\n"); WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_POWER_MGMT; strHostIFmsg.drvHandler = hWFIDrv; pstrPowerMgmtParam->bIsEnabled = bIsEnabled; pstrPowerMgmtParam->u32Timeout = u32Timeout; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } s32 host_int_setup_multicast_filter(WILC_WFIDrvHandle hWFIDrv, bool bIsEnabled, u32 u32count) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIFSetMulti *pstrMulticastFilterParam = &strHostIFmsg.uniHostIFmsgBody.strHostIfSetMulti; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } PRINT_D(HOSTINF_DBG, "Setting Multicast Filter params\n"); WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_MULTICAST_FILTER; strHostIFmsg.drvHandler = hWFIDrv; pstrMulticastFilterParam->bIsEnabled = bIsEnabled; pstrMulticastFilterParam->u32count = u32count; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /*Bug4218: Parsing Join Param*/ #ifdef WILC_PARSE_SCAN_IN_HOST /*Bug4218: Parsing Join Param*/ /** * @brief host_int_ParseJoinBssParam * @details Parse Needed Join Parameters and save it in a new JoinBssParam entry * @param[in] tstrNetworkInfo* ptstrNetworkInfo * @return * @author zsalah * @date * @version 1.0**/ static void *host_int_ParseJoinBssParam(tstrNetworkInfo *ptstrNetworkInfo) { tstrJoinBssParam *pNewJoinBssParam = NULL; u8 *pu8IEs; u16 u16IEsLen; u16 index = 0; u8 suppRatesNo = 0; u8 extSuppRatesNo; u16 jumpOffset; u8 pcipherCount; u8 authCount; u8 pcipherTotalCount = 0; u8 authTotalCount = 0; u8 i, j; pu8IEs = ptstrNetworkInfo->pu8IEs; u16IEsLen = ptstrNetworkInfo->u16IEsLen; pNewJoinBssParam = WILC_MALLOC(sizeof(tstrJoinBssParam)); if (pNewJoinBssParam != NULL) { WILC_memset(pNewJoinBssParam, 0, sizeof(tstrJoinBssParam)); pNewJoinBssParam->dtim_period = ptstrNetworkInfo->u8DtimPeriod; pNewJoinBssParam->beacon_period = ptstrNetworkInfo->u16BeaconPeriod; pNewJoinBssParam->cap_info = ptstrNetworkInfo->u16CapInfo; WILC_memcpy(pNewJoinBssParam->au8bssid, ptstrNetworkInfo->au8bssid, 6); /*for(i=0; i<6;i++) * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->au8bssid[i]);*/ WILC_memcpy((u8 *)pNewJoinBssParam->ssid, ptstrNetworkInfo->au8ssid, ptstrNetworkInfo->u8SsidLen + 1); pNewJoinBssParam->ssidLen = ptstrNetworkInfo->u8SsidLen; WILC_memset(pNewJoinBssParam->rsn_pcip_policy, 0xFF, 3); WILC_memset(pNewJoinBssParam->rsn_auth_policy, 0xFF, 3); /*for(i=0; issidLen;i++) * PRINT_D(HOSTINF_DBG,"%c",pNewJoinBssParam->ssid[i]);*/ /* parse supported rates: */ while (index < u16IEsLen) { /* supportedRates IE */ if (pu8IEs[index] == SUPP_RATES_IE) { /* PRINT_D(HOSTINF_DBG, "Supported Rates\n"); */ suppRatesNo = pu8IEs[index + 1]; pNewJoinBssParam->supp_rates[0] = suppRatesNo; index += 2; /* skipping ID and length bytes; */ for (i = 0; i < suppRatesNo; i++) { pNewJoinBssParam->supp_rates[i + 1] = pu8IEs[index + i]; /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[i+1]); */ } index += suppRatesNo; continue; } /* Ext SupportedRates IE */ else if (pu8IEs[index] == EXT_SUPP_RATES_IE) { /* PRINT_D(HOSTINF_DBG, "Extended Supported Rates\n"); */ /* checking if no of ext. supp and supp rates < max limit */ extSuppRatesNo = pu8IEs[index + 1]; if (extSuppRatesNo > (MAX_RATES_SUPPORTED - suppRatesNo)) pNewJoinBssParam->supp_rates[0] = MAX_RATES_SUPPORTED; else pNewJoinBssParam->supp_rates[0] += extSuppRatesNo; index += 2; /* pNewJoinBssParam.supp_rates[0] contains now old number not the ext. no */ for (i = 0; i < (pNewJoinBssParam->supp_rates[0] - suppRatesNo); i++) { pNewJoinBssParam->supp_rates[suppRatesNo + i + 1] = pu8IEs[index + i]; /* PRINT_D(HOSTINF_DBG,"%0x ",pNewJoinBssParam->supp_rates[suppRatesNo+i+1]); */ } index += extSuppRatesNo; continue; } /* HT Cap. IE */ else if (pu8IEs[index] == HT_CAPABILITY_IE) { /* if IE found set the flag */ pNewJoinBssParam->ht_capable = true; index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */ /* PRINT_D(HOSTINF_DBG,"HT_CAPABALE\n"); */ continue; } else if ((pu8IEs[index] == WMM_IE) && /* WMM Element ID */ (pu8IEs[index + 2] == 0x00) && (pu8IEs[index + 3] == 0x50) && (pu8IEs[index + 4] == 0xF2) && /* OUI */ (pu8IEs[index + 5] == 0x02) && /* OUI Type */ ((pu8IEs[index + 6] == 0x00) || (pu8IEs[index + 6] == 0x01)) && /* OUI Sub Type */ (pu8IEs[index + 7] == 0x01)) { /* Presence of WMM Info/Param element indicates WMM capability */ pNewJoinBssParam->wmm_cap = true; /* Check if Bit 7 is set indicating U-APSD capability */ if (pu8IEs[index + 8] & (1 << 7)) { pNewJoinBssParam->uapsd_cap = true; } index += pu8IEs[index + 1] + 2; continue; } #ifdef WILC_P2P else if ((pu8IEs[index] == P2P_IE) && /* P2P Element ID */ (pu8IEs[index + 2] == 0x50) && (pu8IEs[index + 3] == 0x6f) && (pu8IEs[index + 4] == 0x9a) && /* OUI */ (pu8IEs[index + 5] == 0x09) && (pu8IEs[index + 6] == 0x0c)) { /* OUI Type */ u16 u16P2P_count; pNewJoinBssParam->tsf = ptstrNetworkInfo->u32Tsf; pNewJoinBssParam->u8NoaEnbaled = 1; pNewJoinBssParam->u8Index = pu8IEs[index + 9]; /* Check if Bit 7 is set indicating Opss capability */ if (pu8IEs[index + 10] & (1 << 7)) { pNewJoinBssParam->u8OppEnable = 1; pNewJoinBssParam->u8CtWindow = pu8IEs[index + 10]; } else pNewJoinBssParam->u8OppEnable = 0; /* HOSTINF_DBG */ PRINT_D(GENERIC_DBG, "P2P Dump \n"); for (i = 0; i < pu8IEs[index + 7]; i++) PRINT_D(GENERIC_DBG, " %x \n", pu8IEs[index + 9 + i]); pNewJoinBssParam->u8Count = pu8IEs[index + 11]; u16P2P_count = index + 12; WILC_memcpy(pNewJoinBssParam->au8Duration, pu8IEs + u16P2P_count, 4); u16P2P_count += 4; WILC_memcpy(pNewJoinBssParam->au8Interval, pu8IEs + u16P2P_count, 4); u16P2P_count += 4; WILC_memcpy(pNewJoinBssParam->au8StartTime, pu8IEs + u16P2P_count, 4); index += pu8IEs[index + 1] + 2; continue; } #endif else if ((pu8IEs[index] == RSN_IE) || ((pu8IEs[index] == WPA_IE) && (pu8IEs[index + 2] == 0x00) && (pu8IEs[index + 3] == 0x50) && (pu8IEs[index + 4] == 0xF2) && (pu8IEs[index + 5] == 0x01))) { u16 rsnIndex = index; /*PRINT_D(HOSTINF_DBG,"RSN IE Length:%d\n",pu8IEs[rsnIndex+1]); * for(i=0; imode_802_11i = 2; /* PRINT_D(HOSTINF_DBG,"\nRSN_IE\n"); */ } else { /* check if rsn was previously parsed */ if (pNewJoinBssParam->mode_802_11i == 0) pNewJoinBssParam->mode_802_11i = 1; /* PRINT_D(HOSTINF_DBG,"\nWPA_IE\n"); */ rsnIndex += 4; } rsnIndex += 7; /* skipping id, length, version(2B) and first 3 bytes of gcipher */ pNewJoinBssParam->rsn_grp_policy = pu8IEs[rsnIndex]; rsnIndex++; /* PRINT_D(HOSTINF_DBG,"Group Policy: %0x \n",pNewJoinBssParam->rsn_grp_policy); */ /* initialize policies with invalid values */ jumpOffset = pu8IEs[rsnIndex] * 4; /* total no.of bytes of pcipher field (count*4) */ /*parsing pairwise cipher*/ /* saving 3 pcipher max. */ pcipherCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex]; rsnIndex += 2; /* jump 2 bytes of pcipher count */ /* PRINT_D(HOSTINF_DBG,"\npcipher:%d \n",pcipherCount); */ for (i = pcipherTotalCount, j = 0; i < pcipherCount + pcipherTotalCount && i < 3; i++, j++) { /* each count corresponds to 4 bytes, only last byte is saved */ pNewJoinBssParam->rsn_pcip_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1]; /* PRINT_D(HOSTINF_DBG,"PAIR policy = [%0x,%0x]\n",pNewJoinBssParam->rsn_pcip_policy[i],i); */ } pcipherTotalCount += pcipherCount; rsnIndex += jumpOffset; jumpOffset = pu8IEs[rsnIndex] * 4; /*parsing AKM suite (auth_policy)*/ /* saving 3 auth policies max. */ authCount = (pu8IEs[rsnIndex] > 3) ? 3 : pu8IEs[rsnIndex]; rsnIndex += 2; /* jump 2 bytes of pcipher count */ for (i = authTotalCount, j = 0; i < authTotalCount + authCount; i++, j++) { /* each count corresponds to 4 bytes, only last byte is saved */ pNewJoinBssParam->rsn_auth_policy[i] = pu8IEs[rsnIndex + ((j + 1) * 4) - 1]; } authTotalCount += authCount; rsnIndex += jumpOffset; /*pasring rsn cap. only if rsn IE*/ if (pu8IEs[index] == RSN_IE) { pNewJoinBssParam->rsn_cap[0] = pu8IEs[rsnIndex]; pNewJoinBssParam->rsn_cap[1] = pu8IEs[rsnIndex + 1]; rsnIndex += 2; } pNewJoinBssParam->rsn_found = true; index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */ continue; } else index += pu8IEs[index + 1] + 2; /* ID,Length bytes and IE body */ } } return (void *)pNewJoinBssParam; } void host_int_freeJoinParams(void *pJoinParams) { if ((tstrJoinBssParam *)pJoinParams != NULL) WILC_FREE((tstrJoinBssParam *)pJoinParams); else PRINT_ER("Unable to FREE null pointer\n"); } #endif /*WILC_PARSE_SCAN_IN_HOST*/ /** * @brief host_int_addBASession * @details Open a block Ack session with the given parameters * @param[in] tstrNetworkInfo* ptstrNetworkInfo * @return * @author anoureldin * @date * @version 1.0**/ static int host_int_addBASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID, short int BufferSize, short int SessionTimeout, void *drvHandler) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_ADD_BA_SESSION; memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN); pBASessionInfo->u8Ted = TID; pBASessionInfo->u16BufferSize = BufferSize; pBASessionInfo->u16SessionTimeout = SessionTimeout; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } s32 host_int_delBASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_BA_SESSION; memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN); pBASessionInfo->u8Ted = TID; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } /*BugID_5222*/ down(&hWaitResponse); return s32Error; } s32 host_int_del_All_Rx_BASession(WILC_WFIDrvHandle hWFIDrv, char *pBSSID, char TID) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; tstrHostIfBASessionInfo *pBASessionInfo = &strHostIFmsg.uniHostIFmsgBody.strHostIfBASessionInfo; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_DEL_ALL_RX_BA_SESSIONS; memcpy(pBASessionInfo->au8Bssid, pBSSID, ETH_ALEN); pBASessionInfo->u8Ted = TID; strHostIFmsg.drvHandler = hWFIDrv; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } /*BugID_5222*/ down(&hWaitResponse); return s32Error; } /** * @brief host_int_setup_ipaddress * @details setup IP in firmware * @param[in] Handle to wifi driver * @return Error code. * @author Abdelrahman Sobhy * @date * @version 1.0*/ s32 host_int_setup_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; /* TODO: Enable This feature on softap firmware */ return 0; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_SET_IPADDRESS; strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr = u16ipadd; strHostIFmsg.drvHandler = hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx = idx; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; } /** * @brief host_int_get_ipaddress * @details Get IP from firmware * @param[in] Handle to wifi driver * @return Error code. * @author Abdelrahman Sobhy * @date * @version 1.0*/ s32 host_int_get_ipaddress(WILC_WFIDrvHandle hWFIDrv, u8 *u16ipadd, u8 idx) { s32 s32Error = WILC_SUCCESS; tstrWILC_WFIDrv *pstrWFIDrv = (tstrWILC_WFIDrv *)hWFIDrv; tstrHostIFmsg strHostIFmsg; if (pstrWFIDrv == NULL) { WILC_ERRORREPORT(s32Error, WILC_INVALID_ARGUMENT); } WILC_memset(&strHostIFmsg, 0, sizeof(tstrHostIFmsg)); /* prepare the WiphyParams Message */ strHostIFmsg.u16MsgId = HOST_IF_MSG_GET_IPADDRESS; strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.au8IPAddr = u16ipadd; strHostIFmsg.drvHandler=hWFIDrv; strHostIFmsg.uniHostIFmsgBody.strHostIfSetIP.idx= idx; s32Error = WILC_MsgQueueSend(&gMsgQHostIF, &strHostIFmsg, sizeof(tstrHostIFmsg), NULL); if (s32Error) { WILC_ERRORREPORT(s32Error, s32Error); } WILC_CATCH(s32Error) { } return s32Error; }