/* \brief bapRsnSendEapolFrame To push an eapol frame to TL. \param pAniPkt - a ready eapol frame that is prepared in tAniPacket format */ VOS_STATUS bapRsnSendEapolFrame( v_PVOID_t pvosGCtx, tAniPacket *pAniPkt ) { VOS_STATUS status; vos_pkt_t *pPacket = NULL; v_U8_t *pData, *pSrc; int pktLen = aniAsfPacketGetBytes( pAniPkt, &pSrc ); if( pktLen <= 0 ) { return VOS_STATUS_E_EMPTY; } status = bapRsnAcquirePacket( &pPacket, &pData, pktLen ); if( VOS_IS_STATUS_SUCCESS( status ) && ( NULL != pPacket )) { vos_mem_copy( pData, pSrc, pktLen ); //Send the packet, need to check whether we have an outstanding packet first. status = bapRsnTxFrame( pvosGCtx, pPacket ); if( !VOS_IS_STATUS_SUCCESS( status ) ) { vos_pkt_return_packet( pPacket ); } } return ( status ); }
/*---------------------------------------------------------------------------- @brief Un-Register function Un-Register Thermal Mitigation Level Changed handle callback function @param hdd_context_t pHddCtx Global hdd context @return General status code VOS_STATUS_SUCCESS Un-Registration Success VOS_STATUS_E_FAILURE Un-Registration Fail ----------------------------------------------------------------------------*/ VOS_STATUS hddDevTmUnregisterNotifyCallback(hdd_context_t *pHddCtx) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; wcnss_unregister_thermal_mitigation(hddDevTmLevelChangedHandler); if(VOS_TIMER_STATE_RUNNING == vos_timer_getCurrentState(&pHddCtx->tmInfo.txSleepTimer)) { vosStatus = vos_timer_stop(&pHddCtx->tmInfo.txSleepTimer); if(!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR, "%s: Timer stop fail", __func__); } } // Destroy the vos timer... vosStatus = vos_timer_destroy(&pHddCtx->tmInfo.txSleepTimer); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE(VOS_MODULE_ID_HDD,VOS_TRACE_LEVEL_ERROR, "%s: Fail to destroy timer", __func__); } return VOS_STATUS_SUCCESS; }
//To reserve a vos_packet for Tx eapol frame //If success, pPacket is the packet and pData points to the head. static VOS_STATUS bapRsnAcquirePacket( vos_pkt_t **ppPacket, v_U8_t **ppData, v_U16_t size ) { VOS_STATUS status; vos_pkt_t *pPacket; status = vos_pkt_get_packet( &pPacket, VOS_PKT_TYPE_TX_802_11_MGMT, size, 1, VOS_TRUE, NULL, NULL ); if( VOS_IS_STATUS_SUCCESS( status ) ) { status = vos_pkt_reserve_head( pPacket, (v_VOID_t **)ppData, size ); if( !VOS_IS_STATUS_SUCCESS( status ) ) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "bapRsnAcquirePacket failed to reserve size = %d\n", size ); vos_pkt_return_packet( pPacket ); } else { *ppPacket = pPacket; } } else { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "bapRsnAcquirePacket failed to get vos_pkt\n" ); } return ( status ); }
static int suppRsnTxCompleteHandler( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket, VOS_STATUS retStatus ) { tBtampContext *ctx = (tBtampContext *)VOS_GET_BAP_CB( pvosGCtx ); tAuthRsnFsm *fsm; vos_pkt_return_packet( pPacket ); if (pvosGCtx == NULL) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "param is NULL in %s", __func__); return ANI_ERROR; } if (NULL == ctx) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "ctx is NULL in %s", __func__); return ANI_ERROR; } fsm = &ctx->uFsm.authFsm; if (NULL == fsm) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "fsm is NULL in %s", __func__); return ANI_ERROR; } //Synchronization needed if(!VOS_IS_STATUS_SUCCESS( retStatus ) ) { //This is bad. VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "Supp: TL Tx complete with error %d current state is %d\n", retStatus, fsm->currentState ); if( fsm->numTries <= suppConsts.maxTries ) { //retransmit fsm->numTries++; if( !VOS_IS_STATUS_SUCCESS( bapRsnSendEapolFrame( fsm->ctx->pvosGCtx, fsm->lastEapol ) ) ) { bapSuppDisconnect( fsm->ctx->pvosGCtx ); } } else { bapSuppDisconnect( fsm->ctx->pvosGCtx ); } } return ANI_OK; }
VOS_STATUS vos_wda_shutdown(v_CONTEXT_t vosContext) { VOS_STATUS vosStatus; vosStatus = WDA_shutdown(vosContext, VOS_FALSE); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: failed to shutdown WDA", __func__); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); } return vosStatus; }
/**============================================================================ @brief hdd_tx_complete_cbk() - Callback function invoked by TL to indicate that a packet has been transmitted across the SDIO bus succesfully. OS packet resources can be released after this cbk. @param vosContext : [in] pointer to VOS context @param pVosPacket : [in] pointer to VOS packet (containing skb) @param vosStatusIn : [in] status of the transmission @return : VOS_STATUS_E_FAILURE if any errors encountered : VOS_STATUS_SUCCESS otherwise ===========================================================================*/ VOS_STATUS hdd_tx_complete_cbk( v_VOID_t *vosContext, vos_pkt_t *pVosPacket, VOS_STATUS vosStatusIn ) { VOS_STATUS status = VOS_STATUS_SUCCESS; hdd_adapter_t *pAdapter = NULL; hdd_context_t *pHddCtx = NULL; void* pOsPkt = NULL; if( ( NULL == vosContext ) || ( NULL == pVosPacket ) ) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Null params being passed", __FUNCTION__); return VOS_STATUS_E_FAILURE; } //Return the skb to the OS status = vos_pkt_get_os_packet( pVosPacket, &pOsPkt, VOS_TRUE ); if(!VOS_IS_STATUS_SUCCESS( status )) { //This is bad but still try to free the VOSS resources if we can VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure extracting skb from vos pkt", __FUNCTION__); vos_pkt_return_packet( pVosPacket ); return VOS_STATUS_E_FAILURE; } //Get the HDD context. pHddCtx = (hdd_context_t *)vos_get_context( VOS_MODULE_ID_HDD, vosContext ); //Get the Adapter context. pAdapter = hdd_get_adapter(pHddCtx,WLAN_HDD_INFRA_STATION); if(pAdapter == NULL) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO,"%s: HDD adapter context is Null", __FUNCTION__); } else { ++pAdapter->hdd_stats.hddTxRxStats.txCompleted; } kfree_skb((struct sk_buff *)pOsPkt); //Return the VOS packet resources. status = vos_pkt_return_packet( pVosPacket ); if(!VOS_IS_STATUS_SUCCESS( status )) { VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Could not return VOS packet to the pool", __FUNCTION__); } return status; }
void palPktFree( tHddHandle hHdd, eFrameType frmType, void* buf, void *pPacket) { vos_pkt_t *pVosPacket = (vos_pkt_t *)pPacket; VOS_STATUS vosStatus; do { VOS_ASSERT( pVosPacket ); if ( !pVosPacket ) break; VOS_ASSERT( HAL_TXRX_FRM_802_11_MGMT == frmType ); if ( HAL_TXRX_FRM_802_11_MGMT != frmType ) break; vosStatus = vos_pkt_return_packet( pVosPacket ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); } while( 0 ); return; }
/*--------------------------------------------------------------------------- wpalPostTxMsg - Post a message to TX context so it can be processed in that context. Param: pPalContext - A PAL context PAL pMsg - a pointer to called allocated opaque object; ---------------------------------------------------------------------------*/ wpt_status wpalPostTxMsg(void *pPalContext, wpt_msg *pMsg) { wpt_status status = eWLAN_PAL_STATUS_E_FAILURE; vos_msg_t msg; if (NULL == pMsg) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s: NULL message pointer", __FUNCTION__); WPAL_ASSERT(0); return status; } msg.type = 0; //This field is not used because VOSS doesn't check it. msg.reserved = 0; msg.bodyval = 0; msg.bodyptr = pMsg; if(VOS_IS_STATUS_SUCCESS(vos_tx_mq_serialize(VOS_MQ_ID_WDI, &msg))) { status = eWLAN_PAL_STATUS_SUCCESS; } else { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s fail to post msg %d\n", __FUNCTION__, pMsg->type); } return status; }
wpt_status wpalPostRxMsg(void *pPalContext, wpt_msg *pMsg) { wpt_status status = eWLAN_PAL_STATUS_E_FAILURE; vos_msg_t msg; if (NULL == pMsg) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s: NULL message pointer", __func__); WPAL_ASSERT(0); return status; } msg.type = 0; msg.reserved = 0; msg.bodyval = 0; msg.bodyptr = pMsg; if(VOS_IS_STATUS_SUCCESS(vos_rx_mq_serialize(VOS_MQ_ID_WDI, &msg))) { status = eWLAN_PAL_STATUS_SUCCESS; } else { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s fail to post msg %d", __func__, pMsg->type); } return status; }
eHalStatus csrLLOpen( tHddHandle hHdd, tDblLinkList *pList ) { eHalStatus status = eHAL_STATUS_SUCCESS; VOS_STATUS vosStatus; if( !pList) { VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_FATAL,"%s: Error!! pList is Null", __func__); return eHAL_STATUS_FAILURE ; } if ( LIST_FLAG_OPEN != pList->Flag ) { pList->Count = 0; pList->cmdTimeoutTimer = NULL; vosStatus = vos_lock_init(&pList->Lock); if(VOS_IS_STATUS_SUCCESS(vosStatus)) { csrListInit( &pList->ListHead ); pList->Flag = LIST_FLAG_OPEN; pList->hHdd = hHdd; } else { status = eHAL_STATUS_FAILURE; } } return (status); }
eHalStatus palSpinLockAlloc( tHddHandle hHdd, tPalSpinLockHandle *pHandle ) { eHalStatus halStatus = eHAL_STATUS_FAILURE; VOS_STATUS vosStatus; vos_lock_t *pLock; do { pLock = vos_mem_malloc( sizeof( vos_lock_t ) ); if ( NULL == pLock ) break; vos_mem_set(pLock, sizeof( vos_lock_t ), 0); vosStatus = vos_lock_init( pLock ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) { vos_mem_free( pLock ); break; } *pHandle = (tPalSpinLockHandle)pLock; halStatus = eHAL_STATUS_SUCCESS; } while( 0 ); return( halStatus ); }
/*--------------------------------------------------------------------------- wpalPacketGetLength – Get number of bytes in a wpt_packet. It include the bytes in a BD if it exist. Param: pPkt - pointer to a packet to be freed. Return: Length of the data include layer-2 headers. For example, if the frame is 802.3, the length includes the ethernet header. ---------------------------------------------------------------------------*/ wpt_uint32 wpalPacketGetLength(wpt_packet *pPkt) { v_U16_t len = 0, pktLen = 0; // Validate the parameter pointers if (unlikely(NULL == pPkt)) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s : NULL packet pointer", __func__); return eWLAN_PAL_STATUS_E_INVAL; } if( WPAL_PACKET_GET_BD_POINTER(pPkt) ) { len = WPAL_PACKET_GET_BD_LENGTH(pPkt); } if( VOS_IS_STATUS_SUCCESS(vos_pkt_get_packet_length(WPAL_TO_VOS_PKT(pPkt), &pktLen)) ) { len += pktLen; } else { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s failed", __func__); } return ((wpt_uint32)len); }/*wpalPacketGetLength*/
void palPktFree( tHddHandle hHdd, eFrameType frmType, void* buf, void *pPacket) { vos_pkt_t *pVosPacket = (vos_pkt_t *)pPacket; VOS_STATUS vosStatus; do { VOS_ASSERT( pVosPacket ); if ( !pVosPacket ) break; // we are only handling the 802_11_MGMT frame type for PE/LIM. All other frame types should be // ported to use the VOSS APIs directly and should not be using this palPktAlloc API. VOS_ASSERT( HAL_TXRX_FRM_802_11_MGMT == frmType ); if ( HAL_TXRX_FRM_802_11_MGMT != frmType ) break; // return the vos packet to Voss. Nothing to do if this fails since the palPktFree does not // have a return code. vosStatus = vos_pkt_return_packet( pVosPacket ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); } while( 0 ); return; }
/*--------------------------------------------------------------------------- wpalPacketRawTrimTail – reduce the length of the packet. Param: pPkt - pointer to a wpt_packet. size – number of bytes to take of the packet length Return: eWLAN_PAL_STATUS_SUCCESS – success. Otherwise fail. ---------------------------------------------------------------------------*/ wpt_status wpalPacketRawTrimTail(wpt_packet *pPkt, wpt_uint32 size) { wpt_status status = eWLAN_PAL_STATUS_SUCCESS; // Validate the parameter pointers if (unlikely(NULL == pPkt)) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s : NULL packet pointer", __func__); return eWLAN_PAL_STATUS_E_INVAL; } if ((eWLAN_PAL_PKT_TYPE_TX_802_11_MGMT == WPAL_PACKET_GET_TYPE(pPkt)) || (eWLAN_PAL_PKT_TYPE_RX_RAW == WPAL_PACKET_GET_TYPE(pPkt))) { // Continue to trim the packet } else { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s : neither 80211 managment packet nor RAW packet", __func__); VOS_ASSERT(0); return eWLAN_PAL_STATUS_E_INVAL; } if( !VOS_IS_STATUS_SUCCESS(vos_pkt_trim_tail(WPAL_TO_VOS_PKT(pPkt), (v_SIZE_t)size)) ) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s Invalid trim(%d)", __func__, size); status = eWLAN_PAL_STATUS_E_INVAL; } return status; }/*wpalPacketRawTrimTail*/
/*--------------------------------------------------------------------------- wpalPacketSetRxLength – Set the valid data length on a RX packet. This function must be called once per RX packet per receiving. It indicates the available data length from the start of the buffer. Param: pPkt - pointer to a wpt_packet. Return: NULL - fail. Otherwise the address of the starting of the buffer ---------------------------------------------------------------------------*/ wpt_status wpalPacketSetRxLength(wpt_packet *pPkt, wpt_uint32 len) { // Validate the parameter pointers if (unlikely(NULL == pPkt)) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s : NULL packet pointer", __func__); return eWLAN_PAL_STATUS_E_INVAL; } /*Only allowed for RX Raw packets */ if( (eWLAN_PAL_PKT_TYPE_RX_RAW != WPAL_PACKET_GET_TYPE(pPkt))) { WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR, "%s Invalid packet type(%d)", __func__, WPAL_PACKET_GET_TYPE(pPkt)); return eWLAN_PAL_STATUS_E_INVAL; } if(VOS_IS_STATUS_SUCCESS(vos_pkt_set_rx_length(WPAL_TO_VOS_PKT(pPkt), len))) { return eWLAN_PAL_STATUS_SUCCESS; } else { return eWLAN_PAL_STATUS_E_INVAL; } }/*wpalPacketSetRxLength*/
eHalStatus palTimerStart(tHddHandle hHdd, tPalTimerHandle hPalTimer, tANI_U32 uExpireTime, tANI_BOOLEAN fRestart) { eHalStatus status = eHAL_STATUS_INVALID_PARAMETER; VOS_STATUS vosStatus; tANI_U32 expireTimeInMS = 0; tPalTimer *pPalTimer = (tPalTimer *)hPalTimer; do { if ( NULL == pPalTimer ) break; pPalTimer->fRestart = fRestart; pPalTimer->uTimerInterval = uExpireTime; // vos Timer takes expiration time in milliseconds. palTimerStart and // the uTimerIntervl in tPalTimer struct have expiration tiem in // microseconds. Make and adjustment from microseconds to milliseconds // before calling the vos_timer_start(). expireTimeInMS = uExpireTime / 1000; vosStatus = vos_timer_start( &pPalTimer->vosTimer, expireTimeInMS ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) { status = eHAL_STATUS_FAILURE; break; } status = eHAL_STATUS_SUCCESS; } while( 0 ); return( status ); }
/** * sysBbtProcessMessageCore * * FUNCTION: * Process BBT messages * * LOGIC: * * ASSUMPTIONS: * * NOTE: * * @param tpAniSirGlobal A pointer to MAC params instance * @param pMsg message pointer * @param tANI_U32 type * @param tANI_U32 sub type * @return None */ tSirRetStatus sysBbtProcessMessageCore(tpAniSirGlobal pMac, tpSirMsgQ pMsg, tANI_U32 type, tANI_U32 subType) { static tANI_U32 lastDeauthPacketTime = 0; tSirRetStatus ret; void* pBd; tMgmtFrmDropReason dropReason; vos_pkt_t *pVosPkt = (vos_pkt_t *)pMsg->bodyptr; VOS_STATUS vosStatus = WDA_DS_PeekRxPacketInfo( pVosPkt, (v_PVOID_t *)&pBd, VOS_FALSE ); #ifdef WLAN_FEATURE_11W tANI_U8 sessionId; tpPESession psessionEntry; tpSirMacMgmtHdr pMacHdr; #endif /* WLAN_FEATURE_11W */ pMac->sys.gSysBbtReceived++; if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) { goto fail; } PELOG3(sysLog(pMac, LOG3, FL("Rx Mgmt Frame Subtype: %d\n"), subType); sirDumpBuf(pMac, SIR_SYS_MODULE_ID, LOG3, (tANI_U8 *)WDA_GET_RX_MAC_HEADER(pBd), WDA_GET_RX_MPDU_LEN(pBd)); sirDumpBuf(pMac, SIR_SYS_MODULE_ID, LOG3, WDA_GET_RX_MPDU_DATA(pBd), WDA_GET_RX_PAYLOAD_LEN(pBd));)
static int checkRsnKeyMic(v_U32_t cryptHandle, tAniPacket *eapolFrame, tAniEapolRsnKeyDesc *rsnDesc, v_U8_t *micKey, v_U32_t micKeyLen) { int retVal = ANI_ERROR; int len; v_U8_t *ptr = NULL; v_U8_t *micPos = NULL; v_U8_t result[VOS_DIGEST_SHA1_SIZE]; // Larger of the two v_U8_t incomingMic[ANI_EAPOL_KEY_RSN_MIC_SIZE]; if (!rsnDesc->info.micFlag) { VOS_ASSERT( 0 ); return ANI_E_ILLEGAL_ARG; } len = aniAsfPacketGetBytes(eapolFrame, &ptr); if( ANI_IS_STATUS_SUCCESS( len ) ) { micPos = ptr + ANI_SSM_RSN_KEY_MIC_OFFSET; // Skip to the EAPOL version field for MIC computation ptr += EAPOL_VERSION_POS; len -= EAPOL_VERSION_POS; // Copy existing MIC to temporary location and zero it out vos_mem_copy( incomingMic, micPos, ANI_EAPOL_KEY_RSN_MIC_SIZE ); vos_mem_zero( micPos, ANI_EAPOL_KEY_RSN_MIC_SIZE ); if (rsnDesc->info.keyDescVers == ANI_EAPOL_KEY_DESC_VERS_AES) { if( VOS_IS_STATUS_SUCCESS( vos_sha1_hmac_str(cryptHandle, ptr, len, micKey, micKeyLen, result) ) ) { retVal = ANI_OK; } } else { VOS_ASSERT( 0 ); retVal = ANI_E_ILLEGAL_ARG; } if (retVal == ANI_OK) { if ( !vos_mem_compare(incomingMic, result, ANI_EAPOL_KEY_RSN_MIC_SIZE)) { retVal = ANI_E_MIC_FAILED; } } } return retVal; }
/*---------------------------------------------------------------------------- \brief vos_get_binary_blob() - get binary data from platform This API allows components to get binary data from the platform independent of where the data is stored on the device. <ul> <li> Firmware <li> Configuration Data \param binaryId - identifies the binary data to return to the caller. raw binary data and update the *pBufferSize with the exact size of the data that has been retreived. the size of the binary data in *pBufferSize. size of the data buffer available at pBuffer. Upon success, this retreived and written to the buffer at pBuffer. Input value of 0 is valid and will cause the API to return the size of the binary data in *pBufferSize. retreived and written to the buffer. refer to a valid VOS Binary ID. variable that the API can write to. *pBufferSize is not big enough to contain the binary. \sa --------------------------------------------------------------------------*/ VOS_STATUS vos_get_binary_blob( VOS_BINARY_ID binaryId, v_VOID_t *pBuffer, v_SIZE_t *pBufferSize ) { VOS_STATUS VosSts = VOS_STATUS_SUCCESS; char *pFileName; v_CONTEXT_t pVosContext = vos_get_global_context(VOS_MODULE_ID_SYS,NULL); switch (binaryId) { case VOS_BINARY_ID_CONFIG: pFileName = WLAN_CFG_FILE; break; case VOS_BINARY_ID_COUNTRY_INFO: pFileName = WLAN_COUNTRY_INFO_FILE; break; case VOS_BINARY_ID_HO_CONFIG: pFileName = WLAN_HO_CFG_FILE; break; case VOS_BINARY_ID_DICT_CONFIG: pFileName = WLAN_DICT_FILE; break; default: VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "Invalid binaryID"); return VosSts; } if(0 == *pBufferSize ) { VosSts = hdd_get_cfg_file_size(((VosContextType*)(pVosContext))->pHDDContext,pFileName,pBufferSize); if ( !VOS_IS_STATUS_SUCCESS( VosSts )) { VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s : vos_open failed\n",__func__); return VOS_STATUS_E_FAILURE; } VosSts = VOS_STATUS_E_NOMEM; } else { if(NULL != pBuffer) { VosSts = hdd_read_cfg_file(((VosContextType*)(pVosContext))->pHDDContext,pFileName,pBuffer,pBufferSize); } else { VosSts = VOS_STATUS_E_FAILURE; } } return VosSts; }
v_VOID_t sysStopCompleteCb ( v_VOID_t *pUserData ) { vos_event_t* pStopEvt = (vos_event_t *) pUserData; VOS_STATUS vosStatus; vosStatus = vos_event_set( pStopEvt ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); }
eHalStatus palPktAlloc(tHddHandle hHdd, eFrameType frmType, tANI_U16 size, void **data, void **ppPacket) { eHalStatus halStatus = eHAL_STATUS_FAILURE; VOS_STATUS vosStatus; vos_pkt_t *pVosPacket; do { VOS_ASSERT( HAL_TXRX_FRM_802_11_MGMT == frmType ); if ( HAL_TXRX_FRM_802_11_MGMT != frmType ) break; vosStatus = vos_pkt_get_packet( &pVosPacket, VOS_PKT_TYPE_TX_802_11_MGMT, size, 1, VOS_TRUE, NULL, NULL ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) break; vosStatus = vos_pkt_reserve_head( pVosPacket, data, size ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) { vos_pkt_return_packet( pVosPacket ); break; } *ppPacket = (void *)pVosPacket; halStatus = eHAL_STATUS_SUCCESS; } while( 0 ); return( halStatus ); }
eHalStatus palPktAlloc(tHddHandle hHdd, eFrameType frmType, tANI_U16 size, void **data, void **ppPacket) { eHalStatus halStatus = eHAL_STATUS_FAILURE; VOS_STATUS vosStatus; vos_pkt_t *pVosPacket; do { // we are only handling the 802_11_MGMT frame type for PE/LIM. All other frame types should be // ported to use the VOSS APIs directly and should not be using this palPktAlloc API. VOS_ASSERT( HAL_TXRX_FRM_802_11_MGMT == frmType ); if ( HAL_TXRX_FRM_802_11_MGMT != frmType ) break; // allocate one 802_11_MGMT VOS packet, zero the packet and fail the call if nothing is available. // if we cannot get this vos packet, fail. vosStatus = vos_pkt_get_packet( &pVosPacket, VOS_PKT_TYPE_TX_802_11_MGMT, size, 1, VOS_TRUE, NULL, NULL ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) break; // Reserve the space at the head of the packet for the caller. If we cannot reserve the space // then we have to fail (return the packet to voss first!) vosStatus = vos_pkt_reserve_head( pVosPacket, data, size ); if ( !VOS_IS_STATUS_SUCCESS( vosStatus ) ) { vos_pkt_return_packet( pVosPacket ); break; } // Everything went well if we get here. Return the packet pointer to the caller and indicate // success to the caller. *ppPacket = (void *)pVosPacket; halStatus = eHAL_STATUS_SUCCESS; } while( 0 ); return( halStatus ); }
VOS_STATUS vos_stop( v_CONTEXT_t vosContext ) { VOS_STATUS vosStatus; vos_event_reset( &(gpVosContext->wdaCompleteEvent) ); vosStatus = WDA_stop( vosContext, HAL_STOP_TYPE_RF_KILL ); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Failed to stop WDA", __func__); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); WDA_setNeedShutdown(vosContext); } else { vosStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent), VOS_WDA_STOP_TIMEOUT ); if ( vosStatus != VOS_STATUS_SUCCESS ) { if ( vosStatus == VOS_STATUS_E_TIMEOUT ) { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Timeout occurred before WDA complete", __func__); } else { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: WDA_stop reporting other error", __func__ ); } VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Test MC thread by posting a probe message to SYS", __func__); wlan_sys_probe(); WDA_setNeedShutdown(vosContext); } } vosStatus = sysStop( vosContext); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Failed to stop SYS", __func__); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); } vosStatus = WLANTL_Stop( vosContext ); if (!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Failed to stop TL", __func__); VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) ); } return VOS_STATUS_SUCCESS; }
v_VOID_t sysStopCompleteCb ( v_VOID_t *pUserData ) { vos_event_t* pStopEvt = (vos_event_t *) pUserData; VOS_STATUS vosStatus; /*-------------------------------------------------------------------------*/ vosStatus = vos_event_set( pStopEvt ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); } /* vos_sys_stop_complete_cback() */
/*========================================================================== FUNCTION WLANBAP_Start DESCRIPTION Called as part of the overall start procedure (vos_start). BAP will use this call to register with TL as the BAP entity for BT-AMP RSN frames. DEPENDENCIES PARAMETERS IN pvosGCtx: pointer to the global vos context; a handle to BAP's control block can be extracted from its context RETURN VALUE The result code associated with performing the operation VOS_STATUS_E_FAULT: pointer to BAP cb is NULL ; access would cause a page fault VOS_STATUS_SUCCESS: Everything is good :) Other codes can be returned as a result of a BAL failure; SIDE EFFECTS ============================================================================*/ VOS_STATUS WLANBAP_Start ( v_PVOID_t pvosGCtx ) { ptBtampContext pBtampCtx = NULL; VOS_STATUS vosStatus; /*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/ /*------------------------------------------------------------------------ Sanity check Extract BAP control block ------------------------------------------------------------------------*/ pBtampCtx = VOS_GET_BAP_CB(pvosGCtx); if ( NULL == pBtampCtx ) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "Invalid BAP pointer from pvosGCtx on WLANBAP_Start"); return VOS_STATUS_E_FAULT; } /*------------------------------------------------------------------------ Register with TL as an BT-AMP RSN client ------------------------------------------------------------------------*/ VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO_HIGH, "WLANBAP_Start TL register"); /*------------------------------------------------------------------------ Register with CSR for Roam (connection status) Events ------------------------------------------------------------------------*/ VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO_HIGH, "WLANBAP_Start CSR Register"); /* Initialize the BAP Tx packet monitor timer */ WLANBAP_InitConnectionAcceptTimer (pBtampCtx ); WLANBAP_InitLinkSupervisionTimer(pBtampCtx); vosStatus = vos_timer_init( &pBtampCtx->bapTxPktMonitorTimer, VOS_TIMER_TYPE_SW, /* use this type */ WLANBAP_TxPacketMonitorHandler, pBtampCtx); vosStatus = vos_lock_init(&pBtampCtx->bapLock); if(!VOS_IS_STATUS_SUCCESS(vosStatus)) { VOS_TRACE(VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,"Lock Init Fail"); } return vosStatus; }/* WLANBAP_Start */
VOS_STATUS sysStop( v_CONTEXT_t pVosContext ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; vos_msg_t sysMsg; v_U8_t evtIndex; /* Initialize the stop event */ vosStatus = vos_event_init( &gStopEvt ); if(! VOS_IS_STATUS_SUCCESS( vosStatus )) { return vosStatus; } /* post a message to SYS module in MC to stop SME and MAC */ sysBuildMessageHeader( SYS_MSG_ID_MC_STOP, &sysMsg ); // Save the user callback and user data to callback in the body pointer // and body data portion of the message. // finished. sysMsg.bodyptr = (void *)sysStopCompleteCb; sysMsg.bodyval = (v_U32_t) &gStopEvt; // post the message.. vosStatus = vos_mq_post_message( VOS_MQ_ID_SYS, &sysMsg ); if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) { vosStatus = VOS_STATUS_E_BADMSG; } vosStatus = vos_wait_events( &gStopEvt, 1, 0, &evtIndex ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); vosStatus = vos_event_destroy( &gStopEvt ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); return( vosStatus ); }
VOS_STATUS sysStop( v_CONTEXT_t pVosContext ) { VOS_STATUS vosStatus = VOS_STATUS_SUCCESS; vos_msg_t sysMsg; v_U8_t evtIndex; vosStatus = vos_event_init( &gStopEvt ); if(! VOS_IS_STATUS_SUCCESS( vosStatus )) { return vosStatus; } sysBuildMessageHeader( SYS_MSG_ID_MC_STOP, &sysMsg ); sysMsg.bodyptr = (void *)sysStopCompleteCb; sysMsg.bodyval = (v_U32_t) &gStopEvt; vosStatus = vos_mq_post_message( VOS_MQ_ID_SYS, &sysMsg ); if ( !VOS_IS_STATUS_SUCCESS(vosStatus) ) { vosStatus = VOS_STATUS_E_BADMSG; } vosStatus = vos_wait_events( &gStopEvt, 1, SYS_STOP_TIMEOUT, &evtIndex ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); vosStatus = vos_event_destroy( &gStopEvt ); VOS_ASSERT( VOS_IS_STATUS_SUCCESS ( vosStatus ) ); return( vosStatus ); }
static int authRsnTxCompleteHandler( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket, VOS_STATUS retStatus ) { tBtampContext *ctx = (tBtampContext *)VOS_GET_BAP_CB( pvosGCtx ); tAuthRsnFsm *fsm; vos_pkt_return_packet( pPacket ); if (NULL == ctx) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "ctx is NULL in %s", __func__); return ANI_ERROR; } fsm = &ctx->uFsm.authFsm; if (NULL == fsm) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "fsm is NULL in %s", __func__); return ANI_ERROR; } if(!VOS_IS_STATUS_SUCCESS( retStatus ) ) { //No need to do anything. Retransmit is handled by timeout VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "Auth: TL Tx complete with error %d current state is %d \n", retStatus, fsm->currentState ); } if( PTK_START == fsm->currentState ) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO, " Auth: start msg2 timer\n" ); //Start msg2Timer fsm->numTries++; vos_timer_stop( &fsm->msg2Timer ); vos_timer_start(&fsm->msg2Timer, authConsts.timeoutPeriod); } else if( ( PTK_INIT_NEGO == fsm->currentState ) || ( PTK_INIT_NEGO_TX == fsm->currentState ) ) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO, " Auth: start msg4 timer\n" ); fsm->numTries++; vos_timer_stop( &fsm->msg4Timer ); vos_timer_start(&fsm->msg4Timer, authConsts.timeoutPeriod); } return ANI_OK; }
int aagPrf(v_U32_t cryptHandle, v_U8_t result[AAG_PRF_MAX_OUTPUT_SIZE], v_U8_t *key, v_U8_t keyLen, v_U8_t *a, v_U8_t aLen, v_U8_t *b, v_U8_t bLen, v_U32_t prfLen) { static v_U8_t y; v_U8_t *hmacText = NULL; v_U8_t *resultOffset = result; int numLoops; int loopCtrPos; int i, retVal=0; hmacText = vos_mem_malloc( aLen + bLen + 2 ); if( NULL == hmacText ) { return ANI_E_NULL_VALUE; } vos_mem_copy(hmacText + 0, a, aLen); hmacText[aLen] = y; vos_mem_copy(hmacText + aLen + 1, b, bLen); loopCtrPos = aLen + 1 + bLen; numLoops = prfLen + AAG_PTK_PRF_ADD_PARAM; numLoops /= AAG_PTK_PRF_DIV_PARAM; for (i = 0; i < numLoops; i++) { VOS_ASSERT((resultOffset - result + VOS_DIGEST_SHA1_SIZE) <= AAG_PRF_MAX_OUTPUT_SIZE); hmacText[loopCtrPos] = i; if( VOS_IS_STATUS_SUCCESS( vos_sha1_hmac_str(cryptHandle, hmacText, loopCtrPos + 1, key, keyLen, resultOffset) ) ) { resultOffset += VOS_DIGEST_SHA1_SIZE; retVal = ANI_OK; } else { retVal = ANI_ERROR; } } vos_mem_free(hmacText); return retVal; }
static VOS_STATUS bapRsnTxFrame( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket ) { VOS_STATUS status; WLANTL_MetaInfoType metaInfo; vos_mem_zero( &metaInfo, sizeof( WLANTL_MetaInfoType ) ); metaInfo.ucIsEapol = 1; //only send eapol frame status = WLANTL_TxBAPFrm( pvosGCtx, pPacket, &metaInfo, bapRsnTxCompleteCallback ); if( !VOS_IS_STATUS_SUCCESS( status ) ) { VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "bapRsnTxFrame failed to send vos_pkt status = %d\n", status ); } return ( status ); }