VOS_STATUS vos_preStart( v_CONTEXT_t vosContext )
{
VOS_STATUS vStatus = VOS_STATUS_SUCCESS;
pVosContextType pVosContext = (pVosContextType)vosContext;
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"vos prestart");
VOS_ASSERT(gpVosContext == pVosContext);
VOS_ASSERT( NULL != pVosContext->pMACContext);
VOS_ASSERT( NULL != pVosContext->pWDAContext);
vStatus = macPreStart(gpVosContext->pMACContext);
if ( !VOS_IS_STATUS_SUCCESS(vStatus) )
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_FATAL,
"Failed at macPreStart ");
return VOS_STATUS_E_FAILURE;
}
ccmStart(gpVosContext->pMACContext);
vos_event_reset(&gpVosContext->wdaCompleteEvent);
vStatus = WDA_preStart(gpVosContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_FATAL,
"Failed to WDA prestart");
macStop(gpVosContext->pMACContext, HAL_STOP_TYPE_SYS_DEEP_SLEEP);
ccmStop(gpVosContext->pMACContext);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
vStatus = vos_wait_single_event( &gpVosContext->wdaCompleteEvent,
VOS_WDA_TIMEOUT );
if ( vStatus != VOS_STATUS_SUCCESS )
{
if ( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Timeout occurred before WDA complete\n", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA_preStart 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();
macStop(gpVosContext->pMACContext, HAL_STOP_TYPE_SYS_DEEP_SLEEP);
ccmStop(gpVosContext->pMACContext);
VOS_ASSERT( 0 );
return VOS_STATUS_E_FAILURE;
}
return VOS_STATUS_SUCCESS;
}
VOS_STATUS vos_start( v_CONTEXT_t vosContext )
{
VOS_STATUS vStatus = VOS_STATUS_SUCCESS;
tSirRetStatus sirStatus = eSIR_SUCCESS;
pVosContextType pVosContext = (pVosContextType)vosContext;
tHalMacStartParameters halStartParams;
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: Starting Libra SW", __func__);
if (gpVosContext != pVosContext)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: mismatch in context", __func__);
return VOS_STATUS_E_FAILURE;
}
if (( pVosContext->pWDAContext == NULL) || ( pVosContext->pMACContext == NULL)
|| ( pVosContext->pTLContext == NULL))
{
if (pVosContext->pWDAContext == NULL)
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA NULL context", __func__);
else if (pVosContext->pMACContext == NULL)
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: MAC NULL context", __func__);
else
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: TL NULL context", __func__);
return VOS_STATUS_E_FAILURE;
}
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
vStatus = WDA_NVDownload_Start(pVosContext);
if ( vStatus != VOS_STATUS_SUCCESS )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to start NV Download", __func__);
return VOS_STATUS_E_FAILURE;
}
vStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent),
VOS_WDA_TIMEOUT );
if ( vStatus != VOS_STATUS_SUCCESS )
{
if ( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Timeout occurred before WDA_NVDownload_start complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: WDA_NVDownload_start reporting other error", __func__);
}
VOS_ASSERT(0);
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
if (vos_is_logp_in_progress(VOS_MODULE_ID_VOSS, NULL))
{
VOS_BUG(0);
}
WDA_setNeedShutdown(vosContext);
return VOS_STATUS_E_FAILURE;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: WDA_NVDownload_start correctly started", __func__);
vStatus = WDA_start(pVosContext);
if ( vStatus != VOS_STATUS_SUCCESS )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to start WDA", __func__);
return VOS_STATUS_E_FAILURE;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: WDA correctly started", __func__);
vos_mem_zero((v_PVOID_t)&halStartParams, sizeof(tHalMacStartParameters));
sirStatus = macStart(pVosContext->pMACContext,(v_PVOID_t)&halStartParams);
if (eSIR_SUCCESS != sirStatus)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start MAC", __func__);
goto err_wda_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: MAC correctly started", __func__);
vStatus = sme_Start(pVosContext->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start SME", __func__);
goto err_mac_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: SME correctly started", __func__);
vStatus = WLANTL_Start(pVosContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to start TL", __func__);
goto err_sme_stop;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"TL correctly started");
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"%s: VOSS Start is successful!!", __func__);
return VOS_STATUS_SUCCESS;
err_sme_stop:
sme_Stop(pVosContext->pMACContext, HAL_STOP_TYPE_SYS_RESET);
err_mac_stop:
macStop( pVosContext->pMACContext, HAL_STOP_TYPE_SYS_RESET );
err_wda_stop:
vos_event_reset( &(gpVosContext->wdaCompleteEvent) );
vStatus = WDA_stop( pVosContext, HAL_STOP_TYPE_RF_KILL);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to stop WDA", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vStatus ) );
WDA_setNeedShutdown(vosContext);
}
else
{
vStatus = vos_wait_single_event( &(gpVosContext->wdaCompleteEvent),
VOS_WDA_TIMEOUT );
if( vStatus != VOS_STATUS_SUCCESS )
{
if( vStatus == VOS_STATUS_E_TIMEOUT )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Timeout occurred before WDA_stop complete", __func__);
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: WDA_stop reporting other error", __func__);
}
VOS_ASSERT( 0 );
WDA_setNeedShutdown(vosContext);
}
}
return VOS_STATUS_E_FAILURE;
}
VOS_STATUS vos_open( v_CONTEXT_t *pVosContext, v_SIZE_t hddContextSize )
{
VOS_STATUS vStatus = VOS_STATUS_SUCCESS;
int iter = 0;
tSirRetStatus sirStatus = eSIR_SUCCESS;
tMacOpenParameters macOpenParms;
WLANTL_ConfigInfoType TLConfig;
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
"%s: Opening VOSS", __func__);
if (NULL == gpVosContext)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Trying to open VOSS without a PreOpen", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
vos_timer_module_init();
if (vos_event_init(&gpVosContext->ProbeEvent) != VOS_STATUS_SUCCESS)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Unable to init probeEvent", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
if (vos_event_init( &(gpVosContext->wdaCompleteEvent) ) != VOS_STATUS_SUCCESS )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Unable to init wdaCompleteEvent", __func__);
VOS_ASSERT(0);
goto err_probe_event;
}
vStatus = vos_mq_init(&gpVosContext->freeVosMq);
if (! VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to initialize VOS free message queue", __func__);
VOS_ASSERT(0);
goto err_wda_complete_event;
}
for (iter = 0; iter < VOS_CORE_MAX_MESSAGES; iter++)
{
(gpVosContext->aMsgWrappers[iter]).pVosMsg =
&(gpVosContext->aMsgBuffers[iter]);
INIT_LIST_HEAD(&gpVosContext->aMsgWrappers[iter].msgNode);
vos_mq_put(&gpVosContext->freeVosMq, &(gpVosContext->aMsgWrappers[iter]));
}
vStatus= vos_sched_open(gpVosContext, &gpVosContext->vosSched,
sizeof(VosSchedContext));
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open VOS Scheduler", __func__);
VOS_ASSERT(0);
goto err_msg_queue;
}
vos_mem_set(&macOpenParms, sizeof(macOpenParms), 0);
macOpenParms.frameTransRequired = 1;
macOpenParms.driverType = eDRIVER_TYPE_PRODUCTION;
vStatus = WDA_open( gpVosContext, gpVosContext->pHDDContext, &macOpenParms );
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open WDA module", __func__);
VOS_ASSERT(0);
goto err_sched_close;
}
vStatus = vos_packet_open( gpVosContext, &gpVosContext->vosPacket,
sizeof( vos_pkt_context_t ) );
if ( !VOS_IS_STATUS_SUCCESS( vStatus ) )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open VOS Packet Module", __func__);
VOS_ASSERT(0);
goto err_wda_close;
}
vStatus = sysOpen(gpVosContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open SYS module", __func__);
VOS_ASSERT(0);
goto err_packet_close;
}
#ifndef CONFIG_ENABLE_LINUX_REG
vStatus = vos_nv_open();
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to initialize the NV module", __func__);
goto err_sys_close;
}
#endif
macOpenParms.frameTransRequired = 1;
sirStatus = macOpen(&(gpVosContext->pMACContext), gpVosContext->pHDDContext,
&macOpenParms);
if (eSIR_SUCCESS != sirStatus)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open MAC", __func__);
VOS_ASSERT(0);
goto err_nv_close;
}
vStatus = sme_Open(gpVosContext->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open SME", __func__);
VOS_ASSERT(0);
goto err_mac_close;
}
vos_fetch_tl_cfg_parms ( &TLConfig,
((hdd_context_t*)(gpVosContext->pHDDContext))->cfg_ini);
vStatus = WLANTL_Open(gpVosContext, &TLConfig);
if (!VOS_IS_STATUS_SUCCESS(vStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to open TL", __func__);
VOS_ASSERT(0);
goto err_sme_close;
}
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
"%s: VOSS successfully Opened", __func__);
*pVosContext = gpVosContext;
return VOS_STATUS_SUCCESS;
err_sme_close:
sme_Close(gpVosContext->pMACContext);
err_mac_close:
macClose(gpVosContext->pMACContext);
err_nv_close:
#ifndef CONFIG_ENABLE_LINUX_REG
vos_nv_close();
err_sys_close:
#endif
sysClose(gpVosContext);
err_packet_close:
vos_packet_close( gpVosContext );
err_wda_close:
WDA_close(gpVosContext);
err_sched_close:
vos_sched_close(gpVosContext);
err_msg_queue:
vos_mq_deinit(&gpVosContext->freeVosMq);
err_wda_complete_event:
vos_event_destroy( &gpVosContext->wdaCompleteEvent );
err_probe_event:
vos_event_destroy(&gpVosContext->ProbeEvent);
return VOS_STATUS_E_FAILURE;
}
VOS_STATUS vos_shutdown(v_CONTEXT_t vosContext)
{
VOS_STATUS vosStatus;
#ifdef WLAN_BTAMP_FEATURE
vosStatus = WLANBAP_Close(vosContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close BAP", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
#endif
vosStatus = WLANTL_Close(vosContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close TL", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = sme_Close( ((pVosContextType)vosContext)->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close SME", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = macClose( ((pVosContextType)vosContext)->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close MAC", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
((pVosContextType)vosContext)->pMACContext = NULL;
vosStatus = sysClose( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close SYS", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = vos_packet_close( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close VOSS Packet", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vos_mq_deinit(&((pVosContextType)vosContext)->freeVosMq);
vosStatus = vos_event_destroy(&gpVosContext->wdaCompleteEvent);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: failed to destroy wdaCompleteEvent", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = vos_event_destroy(&gpVosContext->ProbeEvent);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: failed to destroy ProbeEvent", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
return VOS_STATUS_SUCCESS;
}
void vos_timer_module_init( void )
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"Initializing the VOSS timer module");
vos_lock_init( &persistentTimerCountLock );
}
/**
* aniEapolParse
*
* FUNCTION:
* Parses an EAPoL frame to the first level of headers (no EAP
* headers are parsed).
*
* NOTE: This is a non-destructive read, that is the
* headers are not stripped off the packet. However, any additional
* data at the end of the packet, beyond what the EAPoL headers encode
* will be stripped off.
*
* @param packet the packet containing the EAPoL frame to parse
* @param dstMac a pointer to set to the location of the destination
* MAC address
* @param srcMac a pointer to set to the location of the source
* MAC address
* @param type a pointer to set to the location of the EAPOL type
* field.
*
* @return the non-negative length of the EAPOL payload if the operation
* succeeds
*/
int
aniEapolParse(tAniPacket *packet,
v_U8_t **dstMac,
v_U8_t **srcMac,
v_U8_t **type)
{
v_U16_t frameType;
v_U8_t *ptr;
int retVal;
int tmp;
if (aniAsfPacketGetLen(packet) < EAPOL_BODY_POS)
return ANI_E_ILLEGAL_ARG;
retVal = aniAsfPacketGetBytes(packet, &ptr);
if( !ANI_IS_STATUS_SUCCESS( retVal ) )
{
return retVal;
}
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"Supp parsing EAPOL packet of len %d: \n",
retVal);
frameType = (ptr[ETHER_PROTO_POS] << 8) + ptr[ETHER_PROTO_POS+1];
/*
* Validate the EAPOL-FRAME
*/
if (frameType != ANI_ETH_P_EAPOL)
return ANI_E_ILLEGAL_ARG;
*dstMac = ptr + DST_MAC_POS;
*srcMac = ptr + SRC_MAC_POS;
// if (ptr[EAPOL_VERSION_POS] != EAPOL_VERSION_1)
// return ANI_E_ILLEGAL_ARG;
*type = ptr + ANI_EAPOL_TYPE_POS;
retVal = (ptr[EAPOL_BODY_LEN_POS] << 8) + ptr[EAPOL_BODY_LEN_POS + 1];
/*
* Validate the length of the body. Allow for longer
* packets than encoded, but encoding should not be larger than
* packet.
* Note: EAPOL body len does not include headers
*/
tmp = aniAsfPacketGetLen(packet) - EAPOL_RX_HEADER_SIZE;
if (retVal > tmp)
{
retVal = ANI_E_ILLEGAL_ARG;
}
else {
if (retVal < tmp)
{
retVal = aniAsfPacketTruncateFromRear(packet, tmp - retVal);
}
}
return retVal;
}
eHalStatus tdlsMsgProcessor(tpAniSirGlobal pMac, v_U16_t msgType,
void *pMsgBuf)
{
switch(msgType)
{
case eWNI_SME_TDLS_SEND_MGMT_RSP:
{
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsSendMgmt) ;
}
break;
case eWNI_SME_TDLS_ADD_STA_RSP:
{
tSirTdlsAddStaRsp *addStaRsp = (tSirTdlsAddStaRsp *) pMsgBuf ;
eCsrRoamResult roamResult ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, addStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = addStaRsp->staId ;
roamInfo.ucastSig = addStaRsp->ucastSig ;
roamInfo.bcastSig = addStaRsp->bcastSig ;
roamInfo.statusCode = addStaRsp->statusCode ;
if (addStaRsp->tdlsAddOper == TDLS_OPER_ADD)
roamResult = eCSR_ROAM_RESULT_ADD_TDLS_PEER;
else
roamResult = eCSR_ROAM_RESULT_UPDATE_TDLS_PEER;
csrRoamCallCallback(pMac, addStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
roamResult);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsAddPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_RSP:
{
tSirTdlsDelStaRsp *delStaRsp = (tSirTdlsDelStaRsp *) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
csrRoamCallCallback(pMac, delStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_TDLS_PEER);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDelPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_IND:
{
tpSirTdlsDelStaInd pSirTdlsDelStaInd = (tpSirTdlsDelStaInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, pSirTdlsDelStaInd->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = pSirTdlsDelStaInd->staId ;
roamInfo.reasonCode = pSirTdlsDelStaInd->reasonCode ;
csrRoamCallCallback(pMac, pSirTdlsDelStaInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TEARDOWN_TDLS_PEER_IND);
break ;
}
case eWNI_SME_TDLS_DEL_ALL_PEER_IND:
{
tpSirTdlsDelAllPeerInd pSirTdlsDelAllPeerInd = (tpSirTdlsDelAllPeerInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND);
break ;
}
case eWNI_SME_MGMT_FRM_TX_COMPLETION_IND:
{
tpSirMgmtTxCompletionInd pSirTdlsDelAllPeerInd = (tpSirMgmtTxCompletionInd) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
roamInfo.reasonCode = pSirTdlsDelAllPeerInd->txCompleteStatus;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo,
0, eCSR_ROAM_RESULT_MGMT_TX_COMPLETE_IND, 0);
break;
}
case eWNI_SME_TDLS_LINK_ESTABLISH_RSP:
{
tSirTdlsLinkEstablishReqRsp *linkEstablishReqRsp = (tSirTdlsLinkEstablishReqRsp *) pMsgBuf ;
tCsrRoamInfo roamInfo = {0} ;
#if 0
palCopyMemory(pMac->hHdd, &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
#endif
csrRoamCallCallback(pMac, linkEstablishReqRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_LINK_ESTABLISH_REQ_RSP);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsLinkEstablish);
break;
}
#ifdef FEATURE_WLAN_TDLS_INTERNAL
case eWNI_SME_TDLS_DISCOVERY_START_RSP:
{
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDiscovery) ;
}
case eWNI_SME_TDLS_DISCOVERY_START_IND:
{
tSirTdlsDisRsp *disRsp = (tSirTdlsDisRsp *)pMsgBuf ;
if(eSIR_SME_SUCCESS == disRsp->statusCode)
{
tCsrTdlsCtxStruct *disInfo = &pMac->tdlsCtx ;
tANI_U16 disStaCount = disRsp->numDisSta ;
tCsrTdlsPeerLinkinfo *peerLinkInfo = NULL ;
tANI_U8 i = 0 ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("DIS START RSP/IND recieved sta count = %d"), disStaCount) ;
for( ; i < disStaCount ; i++)
{
tSirTdlsPeerInfo *peerInfo = &disRsp->tdlsDisPeerInfo[i] ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("SME, peer MAC: "MAC_ADDRESS_STR),
MAC_ADDR_ARRAY(peerInfo->peerMac));
peerLinkInfo = findTdlsPeer(pMac,
&disInfo->tdlsPotentialPeerList,
peerInfo->peerMac) ;
if(NULL == peerLinkInfo)
{
tdlsSaveTdlsPeerInfo(pMac, peerInfo) ;
}
else
{
tSirTdlsPeerInfo *newPeerInfo =
&peerLinkInfo->tdlsDisPeerInfo ;
newPeerInfo->tdlsPeerRssi = peerInfo->tdlsPeerRssi ;
}
}
if(0 == i)
{
smsLog( pMac, LOGW, "there is no tdls client \
discovered .." ) ;
}
}
else
{
VOS_STATUS vos_alloc_context( v_VOID_t *pVosContext, VOS_MODULE_ID moduleID,
v_VOID_t **ppModuleContext, v_SIZE_t size )
{
v_VOID_t ** pGpModContext = NULL;
if ( pVosContext == NULL) {
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: vos context is null", __func__);
return VOS_STATUS_E_FAILURE;
}
if (( gpVosContext != pVosContext) || ( ppModuleContext == NULL)) {
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: context mismatch or null param passed", __func__);
return VOS_STATUS_E_FAILURE;
}
switch(moduleID)
{
case VOS_MODULE_ID_TL:
{
pGpModContext = &(gpVosContext->pTLContext);
break;
}
#ifdef WLAN_BTAMP_FEATURE
case VOS_MODULE_ID_BAP:
{
pGpModContext = &(gpVosContext->pBAPContext);
break;
}
#endif
case VOS_MODULE_ID_SAP:
{
pGpModContext = &(gpVosContext->pSAPContext);
break;
}
case VOS_MODULE_ID_WDA:
{
pGpModContext = &(gpVosContext->pWDAContext);
break;
}
case VOS_MODULE_ID_SME:
case VOS_MODULE_ID_PE:
case VOS_MODULE_ID_PMC:
case VOS_MODULE_ID_HDD:
case VOS_MODULE_ID_HDD_SOFTAP:
default:
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Module ID %i "
"does not have its context allocated by VOSS", __func__, moduleID);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
}
if ( NULL != *pGpModContext)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Module ID %i context has already been allocated",
__func__, moduleID);
return VOS_STATUS_E_EXISTS;
}
*ppModuleContext = kmalloc(size, GFP_KERNEL);
if ( *ppModuleContext == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,"%s: Failed to "
"allocate Context for module ID %i", __func__, moduleID);
VOS_ASSERT(0);
return VOS_STATUS_E_NOMEM;
}
if (moduleID==VOS_MODULE_ID_TL)
{
vos_mem_zero(*ppModuleContext, size);
}
*pGpModContext = *ppModuleContext;
return VOS_STATUS_SUCCESS;
}
/*==========================================================================
FUNCTION WLANBAP_SendCompletedDataBlksEvent
DESCRIPTION
Utility function for sending the NUM_OF_COMPLETED_DATA_BLOCKS_EVENT to HCI
DEPENDENCIES
PARAMETERS
IN
pBtampCtx: pointer to the BAP control block
RETURN VALUE
None
SIDE EFFECTS
============================================================================*/
v_VOID_t
WLANBAP_SendCompletedDataBlksEvent
(
ptBtampContext pBtampCtx
)
{
v_U8_t i, j;
tBtampHCI_Event bapHCIEvent; /* This now encodes ALL event types */
v_U32_t uTxCompleted = 0;
tpBtampLogLinkCtx pLogLinkContext = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/* Format the Number of completed data blocks event */
bapHCIEvent.bapHCIEventCode = BTAMP_TLV_HCI_NUM_OF_COMPLETED_DATA_BLOCKS_EVENT;
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.num_handles = 0;
/*---------------------------------------------------------------------
Check if LL still exists, if TRUE generate num_data_blocks_event and
restart the timer
---------------------------------------------------------------------*/
for (i = 0, j = 0; i < WLANBAP_MAX_LOG_LINKS ; i++)
{
pLogLinkContext = &pBtampCtx->btampLogLinkCtx[i];
if ( pLogLinkContext->present )
{
uTxCompleted = pLogLinkContext->uTxPktCompleted;
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.conn_handles[j] =
pLogLinkContext->log_link_handle;
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.num_completed_pkts[j] =
uTxCompleted;
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.num_completed_blocks[j] =
uTxCompleted;
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.total_num_data_blocks = 16;
j++;
vos_atomic_decrement_U32_by_value((v_U32_t *) &pLogLinkContext->uTxPktCompleted,
(v_U32_t) uTxCompleted);
if (uTxCompleted) {
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"wlan bap: %s Log Link handle - %d No Of Pkts - %d", __func__,
pLogLinkContext->log_link_handle, uTxCompleted);
}
}
}
/* Indicate only if at least one logical link is present and number of
completed data blocks is non zero */
if (j && uTxCompleted)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"WLAN BAP: Indicating Num Completed Data Blocks Event");
/*issue num_data_blocks_event for uTxCompleted*/
bapHCIEvent.u.btampNumOfCompletedDataBlocksEvent.num_handles = j;
(*pBtampCtx->pBapHCIEventCB)
(
pBtampCtx->pHddHdl, /* this refers the BSL per application context */
&bapHCIEvent, /* This now encodes ALL event types */
VOS_TRUE /* Flag to indicate assoc-specific event */
);
}
}
eHalStatus csrTdlsProcessCmd(tpAniSirGlobal pMac, tSmeCmd *cmd)
{
eSmeCommandType cmdType = cmd->command ;
#ifdef FEATURE_WLAN_TDLS_INTERNAL
tTdlsCmd tdlsCmd = cmd->u.tdlsCmd ;
#endif
tANI_BOOLEAN status = eANI_BOOLEAN_TRUE;
switch(cmdType)
{
case eSmeCommandTdlsSendMgmt:
{
status = csrTdlsProcessSendMgmt( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break ;
case eSmeCommandTdlsAddPeer:
{
status = csrTdlsProcessAddSta( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break;
case eSmeCommandTdlsDelPeer:
{
status = csrTdlsProcessDelSta( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break;
case eSmeCommandTdlsLinkEstablish:
{
status = csrTdlsProcessLinkEstablish( pMac, cmd );
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
}
break;
#ifdef FEATURE_WLAN_TDLS_INTERNAL
case eSmeCommandTdlsDiscovery:
{
tTdlsDisReqCmdinfo *disReqCmdInfo = &tdlsCmd.u.tdlsDisReqCmdInfo ;
tSirTdlsDisReq *disReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&disReq,
sizeof(tSirTdlsDisReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "dis Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
disReq->sessionId = cmd->sessionId;
disReq->transactionId = 0;
disReq->reqType = disReqCmdInfo->tdlsDisType ;
palCopyMemory(pMac->hHdd, disReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, disReq->peerMac,
disReqCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
smsLog( pMac, LOGE, "sending TDLS discovery to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_DISCOVERY_START_REQ,
(void *)disReq , sizeof(tSirTdlsDisReq)) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
break ;
}
case eSmeCommandTdlsLinkSetup:
{
tTdlsLinkSetupReqCmdinfo *linkSetupReqCmdInfo =
&tdlsCmd.u.tdlsLinkSetupReqCmdInfo ;
tSirTdlsSetupReq *setupReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&setupReq,
sizeof(tSirTdlsSetupReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "dis Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
setupReq->sessionId = cmd->sessionId;
setupReq->transactionId = 0;
palCopyMemory(pMac->hHdd, setupReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, setupReq->peerMac,
linkSetupReqCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("sending TDLS link setup to PE "));
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_LINK_START_REQ,
(void *)setupReq , sizeof(tSirTdlsSetupReq) ) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
break ;
}
case eSmeCommandTdlsLinkTear:
{
tTdlsLinkTeardownCmdinfo *linkTeardownCmdInfo =
&tdlsCmd.u.tdlsLinkTeardownCmdInfo ;
tSirTdlsTeardownReq *teardownReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
status = palAllocateMemory( pMac->hHdd, (void **)&teardownReq,
sizeof(tSirTdlsTeardownReq));
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, "teardown Req alloc failed " );
VOS_ASSERT(0) ;
break ;
}
teardownReq->sessionId = cmd->sessionId;
teardownReq->transactionId = 0;
palCopyMemory(pMac->hHdd, teardownReq->bssid, pSession->pConnectBssDesc->bssId,
sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, &teardownReq->peerMac,
linkTeardownCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
("teardown request..")) ;
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_TEARDOWN_REQ,
(void *)teardownReq , sizeof(tSirTdlsTeardownReq)) ;
if(HAL_STATUS_SUCCESS( status ) )
{
status = eANI_BOOLEAN_FALSE ;
}
break ;
}
#endif
default:
{
break ;
}
}
return status ;
}
/*==========================================================================
FUNCTION WLANBAP_LinkSupervisionTimerHandler
DESCRIPTION
Callback function registered with vos timer for the LinkSupervision timer
DEPENDENCIES
PARAMETERS
IN
userData: pointer can be used to retrive the BT-AMP context
RETURN VALUE
None
SIDE EFFECTS
============================================================================*/
v_VOID_t
WLANBAP_LinkSupervisionTimerHandler
(
v_PVOID_t userData
)
{
ptBtampContext pBtampCtx = (ptBtampContext)userData;
VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
ptBtampHandle btampHandle = (ptBtampHandle)userData;
tWLAN_BAPEvent bapEvent; /* State machine event */
v_U8_t phy_link_handle;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/*-----------------------------------------------------------------------
Sanity check
-----------------------------------------------------------------------*/
if ( NULL == pBtampCtx )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"WLAN BAP: Fatal error in %s", __func__ );
VOS_ASSERT(0);
return;
}
phy_link_handle = pBtampCtx->phy_link_handle;
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"WLAN BAP:In LinkSupervision Timer handler %s", __func__ );
if(pBtampCtx->dataPktPending == VOS_TRUE)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"%s: Data seen. Do nothing", __func__ );
pBtampCtx->dataPktPending = VOS_FALSE;
pBtampCtx->lsReqPktPending = VOS_FALSE;
pBtampCtx->retries = 0;
vosStatus = WLANBAP_StopLinkSupervisionTimer(pBtampCtx);
vosStatus = WLANBAP_StartLinkSupervisionTimer (pBtampCtx,
pBtampCtx->bapLinkSupervisionTimerInterval * WLANBAP_BREDR_BASEBAND_SLOT_TIME);
//Data is seen. or our previous packet is not yet fetched by TL.Don't do any thing.Just return;
return;
}
else if((pBtampCtx->lsReqPktPending == VOS_TRUE )
&& (pBtampCtx->retries == WLANBAP_LINK_SUPERVISION_RETRIES))
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"#########WLAN BAP: LinkSupervision Timed OUT######## %s", __func__ );
/*---------------------------------------------------------------------
Feed this timeout to the BTAMP FSM
---------------------------------------------------------------------*/
/* Fill in the event structure */
/* JEZ110307: Which should this be? */
//bapEvent.event =eWLAN_BAP_HCI_PHYSICAL_LINK_DISCONNECT;
bapEvent.event =eWLAN_BAP_MAC_INDICATES_MEDIA_DISCONNECTION;
bapEvent.params = NULL;
/* Handle event */
vosStatus = btampFsm(pBtampCtx, &bapEvent, (v_U8_t *)&vosStatus);
}
else
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"%s: Resend the LS packet", __func__ );
/* If we have transmit pkt pending and the time out occurred,resend the ls packet */
WLANBAP_StopLinkSupervisionTimer(pBtampCtx);
pBtampCtx->pPacket = pBtampCtx->lsReqPacket;
vosStatus = WLANBAP_TxLinkSupervision( btampHandle,
phy_link_handle,
pBtampCtx->pPacket ,
WLANTL_BT_AMP_TYPE_LS_REQ);
}
}/*WLANBAP_LinkSupervisionTimerHandler*/
static int
writeRsnKeyMic(v_U32_t cryptHandle,
tAniPacket *eapolFrame,
tAniEapolRsnKeyDesc *rsnDesc,
v_U8_t *micKey,
v_U32_t micKeyLen)
{
int retVal = ANI_OK;
int len;
v_U8_t *ptr = NULL;
v_U8_t *micPos = NULL;
v_U8_t result[VOS_DIGEST_SHA1_SIZE]; // Larger of the two
// Sanity check the arguments and return if no MIC generation is
// needed
if (micKey != NULL)
{
if (micKeyLen == 0 || !rsnDesc->info.micFlag)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Supp MIC key provided but micKeyLen or micFlag is not set!\n");
VOS_ASSERT( 0 );
return ANI_E_ILLEGAL_ARG;
}
}
else {
if (rsnDesc->info.micFlag)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Supp micFlag is set but MIC key not provided!\n");
VOS_ASSERT( 0 );
return ANI_E_ILLEGAL_ARG;
}
// Normal condition where MIC is not desired by the caller
return ANI_OK;
}
len = aniAsfPacketGetBytes(eapolFrame, &ptr);
if( !ANI_IS_STATUS_SUCCESS( len ) )
{
return len;
}
micPos = ptr + ANI_SSM_RSN_KEY_MIC_OFFSET + SNAP_HEADER_SIZE;
// Clear the MIC field in the packet before the MIC computation
vos_mem_zero( micPos, VOS_DIGEST_MD5_SIZE);
// Skip to the EAPOL version field for MIC computation
ptr += EAPOL_VERSION_POS + SNAP_HEADER_SIZE;
len -= (EAPOL_VERSION_POS + SNAP_HEADER_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
{
retVal = ANI_ERROR;
}
}
else {
VOS_ASSERT( 0 );
retVal = ANI_E_ILLEGAL_ARG;
}
if (retVal == ANI_OK)
{
// Copy only 16B which is the smaller of the two and the same as
// ANI_EAPOL_KEY_RSN_MIC_SIZE
vos_mem_copy(micPos, result, VOS_DIGEST_MD5_SIZE);
}
return retVal;
}
static int
parseRsnKeyDesc(tAniPacket *packet,
tAniEapolRsnKeyDesc **rsnDescPtr)
{
int retVal = ANI_OK;
int len;
v_U8_t *bytes;
tAniEapolRsnKeyDesc *rsnDesc = NULL;
do
{
aniAsfPacketTruncateFromFront(packet, 1); // Desc-Type
rsnDesc = (tAniEapolRsnKeyDesc *)
vos_mem_malloc( sizeof(tAniEapolRsnKeyDesc) );
if (rsnDesc == NULL)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Supp could not malloc EAPOL-Key Descriptor for RSN\n");
retVal = ANI_E_MALLOC_FAILED;
break;
}
retVal = parseRsnKeyInfo(packet, &rsnDesc->info);
if (retVal != ANI_OK) break;
retVal = aniAsfPacketGet16(packet, &rsnDesc->keyLen);
if (retVal != ANI_OK)
{
break;
}
len = sizeof(rsnDesc->replayCounter);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->replayCounter, bytes, len);
len = sizeof(rsnDesc->keyNonce);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->keyNonce, bytes, len);
len = sizeof(rsnDesc->keyIv);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->keyIv, bytes, len);
len = sizeof(rsnDesc->keyRecvSeqCounter);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->keyRecvSeqCounter, bytes, len);
len = sizeof(rsnDesc->keyId);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->keyId, bytes, len);
len = sizeof(rsnDesc->keyMic);
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
vos_mem_copy(rsnDesc->keyMic, bytes, len);
retVal = aniAsfPacketGet16(packet, &rsnDesc->keyDataLen);
if (retVal != ANI_OK)
{
break;
}
len = rsnDesc->keyDataLen;
if (len > 0) {
// We have a key
retVal = aniAsfPacketGetN(packet, len, &bytes);
if (retVal != ANI_OK)
{
break;
}
rsnDesc->keyData = (v_U8_t*)vos_mem_malloc(len);
if (rsnDesc->keyData == NULL)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, "Could not allocate RSN key bytes!\n");
VOS_ASSERT( 0 );
retVal = ANI_E_MALLOC_FAILED;
break;
}
vos_mem_copy(rsnDesc->keyData, bytes, len);
}
else {
rsnDesc->keyData = NULL;
}
*rsnDescPtr = rsnDesc;
}while( 0 );
if( !ANI_IS_STATUS_SUCCESS( retVal ) )
{
vos_mem_free(rsnDesc);
}
return retVal;
}
VOS_STATUS vos_close( v_CONTEXT_t vosContext )
{
VOS_STATUS vosStatus;
#ifdef WLAN_BTAMP_FEATURE
vosStatus = WLANBAP_Close(vosContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close BAP", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
#endif
vosStatus = WLANTL_Close(vosContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close TL", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = sme_Close( ((pVosContextType)vosContext)->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close SME", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = macClose( ((pVosContextType)vosContext)->pMACContext);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close MAC", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
((pVosContextType)vosContext)->pMACContext = NULL;
#ifndef CONFIG_ENABLE_LINUX_REG
vosStatus = vos_nv_close();
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close NV", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
#endif
vosStatus = sysClose( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close SYS", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
if ( TRUE == WDA_needShutdown(vosContext ))
{
vosStatus = WDA_shutdown( vosContext, VOS_TRUE );
if (VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
hdd_set_ssr_required( HDD_SSR_REQUIRED );
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to shutdown WDA", __func__ );
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
}
else
{
vosStatus = WDA_close( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close WDA", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
}
vosStatus = vos_packet_close( vosContext );
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Failed to close VOSS Packet", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vos_mq_deinit(&((pVosContextType)vosContext)->freeVosMq);
vosStatus = vos_event_destroy(&gpVosContext->wdaCompleteEvent);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: failed to destroy wdaCompleteEvent", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
vosStatus = vos_event_destroy(&gpVosContext->ProbeEvent);
if (!VOS_IS_STATUS_SUCCESS(vosStatus))
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: failed to destroy ProbeEvent", __func__);
VOS_ASSERT( VOS_IS_STATUS_SUCCESS( vosStatus ) );
}
return VOS_STATUS_SUCCESS;
}
/*
* TDLS Message processor, will be called after TDLS message received from
* PE
*/
eHalStatus tdlsMsgProcessor(tpAniSirGlobal pMac, v_U16_t msgType,
void *pMsgBuf)
{
tCsrRoamInfo roamInfo = {0} ;
switch(msgType)
{
case eWNI_SME_TDLS_SEND_MGMT_RSP:
{
/* remove pending eSmeCommandTdlsDiscovery command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsSendMgmt) ;
}
break;
case eWNI_SME_TDLS_ADD_STA_RSP:
{
tSirTdlsAddStaRsp *addStaRsp = (tSirTdlsAddStaRsp *) pMsgBuf ;
eCsrRoamResult roamResult ;
vos_mem_copy( &roamInfo.peerMac, addStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = addStaRsp->staId ;
roamInfo.ucastSig = addStaRsp->ucastSig ;
roamInfo.bcastSig = addStaRsp->bcastSig ;
roamInfo.statusCode = addStaRsp->statusCode ;
/*
* register peer with TL, we have to go through HDD as this is
* the only way to register any STA with TL.
*/
if (addStaRsp->tdlsAddOper == TDLS_OPER_ADD)
roamResult = eCSR_ROAM_RESULT_ADD_TDLS_PEER;
else /* addStaRsp->tdlsAddOper must be TDLS_OPER_UPDATE */
roamResult = eCSR_ROAM_RESULT_UPDATE_TDLS_PEER;
csrRoamCallCallback(pMac, addStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
roamResult);
/* remove pending eSmeCommandTdlsDiscovery command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsAddPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_RSP:
{
tSirTdlsDelStaRsp *delStaRsp = (tSirTdlsDelStaRsp *) pMsgBuf ;
vos_mem_copy( &roamInfo.peerMac, delStaRsp->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = delStaRsp->staId ;
roamInfo.statusCode = delStaRsp->statusCode ;
/*
* register peer with TL, we have to go through HDD as this is
* the only way to register any STA with TL.
*/
csrRoamCallCallback(pMac, delStaRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_TDLS_PEER);
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsDelPeer) ;
}
break;
case eWNI_SME_TDLS_DEL_STA_IND:
{
tpSirTdlsDelStaInd pSirTdlsDelStaInd = (tpSirTdlsDelStaInd) pMsgBuf ;
vos_mem_copy( &roamInfo.peerMac, pSirTdlsDelStaInd->peerMac,
sizeof(tSirMacAddr)) ;
roamInfo.staId = pSirTdlsDelStaInd->staId ;
roamInfo.reasonCode = pSirTdlsDelStaInd->reasonCode ;
/* Sending the TEARDOWN indication to HDD. */
csrRoamCallCallback(pMac, pSirTdlsDelStaInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TEARDOWN_TDLS_PEER_IND);
break ;
}
case eWNI_SME_TDLS_DEL_ALL_PEER_IND:
{
tpSirTdlsDelAllPeerInd pSirTdlsDelAllPeerInd = (tpSirTdlsDelAllPeerInd) pMsgBuf ;
/* Sending the TEARDOWN indication to HDD. */
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_DELETE_ALL_TDLS_PEER_IND);
break ;
}
case eWNI_SME_MGMT_FRM_TX_COMPLETION_IND:
{
tpSirMgmtTxCompletionInd pSirTdlsDelAllPeerInd = (tpSirMgmtTxCompletionInd) pMsgBuf ;
roamInfo.reasonCode = pSirTdlsDelAllPeerInd->txCompleteStatus;
csrRoamCallCallback(pMac, pSirTdlsDelAllPeerInd->sessionId, &roamInfo,
0, eCSR_ROAM_RESULT_MGMT_TX_COMPLETE_IND, 0);
break;
}
case eWNI_SME_TDLS_LINK_ESTABLISH_RSP:
{
tSirTdlsLinkEstablishReqRsp *linkEstablishReqRsp = (tSirTdlsLinkEstablishReqRsp *) pMsgBuf ;
vos_mem_copy(&roamInfo.peerMac, linkEstablishReqRsp->peerMac,
sizeof(tSirMacAddr));
roamInfo.staId = (uint8_t)linkEstablishReqRsp->sta_idx;
roamInfo.statusCode = linkEstablishReqRsp->statusCode;
csrRoamCallCallback(pMac, linkEstablishReqRsp->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_LINK_ESTABLISH_REQ_RSP);
/* remove pending eSmeCommandTdlsLinkEstablish command */
csrTdlsRemoveSmeCmd(pMac, eSmeCommandTdlsLinkEstablish);
break;
}
case eWNI_SME_TDLS_SHOULD_DISCOVER:
{
tSirTdlsEventNotify *tevent = (tSirTdlsEventNotify *) pMsgBuf;
vos_mem_copy(&roamInfo.peerMac, tevent->peerMac,
sizeof(tSirMacAddr));
roamInfo.reasonCode = tevent->peer_reason;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
"%s: eWNI_SME_TDLS_SHOULD_DISCOVER for peer mac: "
MAC_ADDRESS_STR " peer_reason: %d",
__func__, MAC_ADDR_ARRAY(tevent->peerMac),
tevent->peer_reason);
csrRoamCallCallback(pMac, tevent->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TDLS_SHOULD_DISCOVER);
break;
}
case eWNI_SME_TDLS_SHOULD_TEARDOWN:
{
tSirTdlsEventNotify *tevent = (tSirTdlsEventNotify *) pMsgBuf;
vos_mem_copy(&roamInfo.peerMac, tevent->peerMac,
sizeof(tSirMacAddr));
roamInfo.reasonCode = tevent->peer_reason;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
"%s: eWNI_SME_TDLS_SHOULD_TEARDOWN for peer mac: "
MAC_ADDRESS_STR " peer_reason: %d",
__func__, MAC_ADDR_ARRAY(tevent->peerMac),
tevent->peer_reason);
csrRoamCallCallback(pMac, tevent->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TDLS_SHOULD_TEARDOWN);
break;
}
case eWNI_SME_TDLS_PEER_DISCONNECTED:
{
tSirTdlsEventNotify *tevent = (tSirTdlsEventNotify *) pMsgBuf;
vos_mem_copy(&roamInfo.peerMac, tevent->peerMac,
sizeof(tSirMacAddr));
roamInfo.reasonCode = tevent->peer_reason;
VOS_TRACE(VOS_MODULE_ID_SME, VOS_TRACE_LEVEL_INFO,
"%s: eWNI_SME_TDLS_PEER_DISCONNECTED for peer mac: "
MAC_ADDRESS_STR " peer_reason: %d",
__func__, MAC_ADDR_ARRAY(tevent->peerMac),
tevent->peer_reason);
csrRoamCallCallback(pMac, tevent->sessionId, &roamInfo, 0,
eCSR_ROAM_TDLS_STATUS_UPDATE,
eCSR_ROAM_RESULT_TDLS_SHOULD_PEER_DISCONNECTED);
break;
}
default:
{
break ;
}
}
return eHAL_STATUS_SUCCESS ;
}
v_VOID_t* vos_get_context( VOS_MODULE_ID moduleId,
v_CONTEXT_t pVosContext )
{
v_PVOID_t pModContext = NULL;
if (pVosContext == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: vos context pointer is null", __func__);
return NULL;
}
if (gpVosContext != pVosContext)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: pVosContext != gpVosContext", __func__);
return NULL;
}
switch(moduleId)
{
case VOS_MODULE_ID_TL:
{
pModContext = gpVosContext->pTLContext;
break;
}
#ifdef WLAN_BTAMP_FEATURE
case VOS_MODULE_ID_BAP:
{
pModContext = gpVosContext->pBAPContext;
break;
}
#endif
case VOS_MODULE_ID_SAP:
{
pModContext = gpVosContext->pSAPContext;
break;
}
case VOS_MODULE_ID_HDD_SOFTAP:
{
pModContext = gpVosContext->pHDDSoftAPContext;
break;
}
case VOS_MODULE_ID_HDD:
{
pModContext = gpVosContext->pHDDContext;
break;
}
case VOS_MODULE_ID_SME:
case VOS_MODULE_ID_PE:
case VOS_MODULE_ID_PMC:
{
pModContext = gpVosContext->pMACContext;
break;
}
case VOS_MODULE_ID_WDA:
{
pModContext = gpVosContext->pWDAContext;
break;
}
case VOS_MODULE_ID_VOSS:
{
pModContext = gpVosContext;
break;
}
default:
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,"%s: Module ID %i "
"does not have its context maintained by VOSS", __func__, moduleId);
VOS_ASSERT(0);
return NULL;
}
}
if (pModContext == NULL )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,"%s: Module ID %i "
"context is Null", __func__, moduleId);
}
return pModContext;
}
VOS_STATUS vos_free_context( v_VOID_t *pVosContext, VOS_MODULE_ID moduleID,
v_VOID_t *pModuleContext )
{
v_VOID_t ** pGpModContext = NULL;
if (( pVosContext == NULL) || ( gpVosContext != pVosContext) ||
( pModuleContext == NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null params or context mismatch", __func__);
return VOS_STATUS_E_FAILURE;
}
switch(moduleID)
{
case VOS_MODULE_ID_TL:
{
pGpModContext = &(gpVosContext->pTLContext);
break;
}
#ifdef WLAN_BTAMP_FEATURE
case VOS_MODULE_ID_BAP:
{
pGpModContext = &(gpVosContext->pBAPContext);
break;
}
#endif
case VOS_MODULE_ID_SAP:
{
pGpModContext = &(gpVosContext->pSAPContext);
break;
}
case VOS_MODULE_ID_WDA:
{
pGpModContext = &(gpVosContext->pWDAContext);
break;
}
case VOS_MODULE_ID_HDD:
case VOS_MODULE_ID_SME:
case VOS_MODULE_ID_PE:
case VOS_MODULE_ID_PMC:
case VOS_MODULE_ID_HDD_SOFTAP:
default:
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s: Module ID %i "
"does not have its context allocated by VOSS", __func__, moduleID);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
}
if ( NULL == *pGpModContext)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,"%s: Module ID %i "
"context has not been allocated or freed already", __func__,moduleID);
return VOS_STATUS_E_FAILURE;
}
if (*pGpModContext != pModuleContext)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: pGpModContext != pModuleContext", __func__);
return VOS_STATUS_E_FAILURE;
}
if(pModuleContext != NULL)
kfree(pModuleContext);
*pGpModContext = NULL;
return VOS_STATUS_SUCCESS;
}
static void vos_linux_timer_callback (unsigned long data)
{
vos_timer_t *timer = ( vos_timer_t *)data;
vos_msg_t msg;
VOS_STATUS vStatus;
unsigned long flags;
vos_timer_callback_t callback=NULL;
v_PVOID_t userData=NULL;
int threadId;
VOS_TIMER_TYPE type=VOS_TIMER_TYPE_SW;
VOS_ASSERT(timer);
if (timer == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR, "%s Null pointer passed in!",__func__);
return;
}
threadId = timer->platformInfo.threadID;
spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
switch ( timer->state )
{
case VOS_TIMER_STATE_STARTING:
// we are in this state because someone just started the timer, MM timer
// got started and expired, but the time content have not bee updated
// this is a rare race condition!
timer->state = VOS_TIMER_STATE_STOPPED;
vStatus = VOS_STATUS_E_ALREADY;
break;
case VOS_TIMER_STATE_STOPPED:
vStatus = VOS_STATUS_E_ALREADY;
break;
case VOS_TIMER_STATE_UNUSED:
vStatus = VOS_STATUS_E_EXISTS;
break;
case VOS_TIMER_STATE_RUNNING:
// need to go to stop state here because the call-back function may restart
// timer (to emulate periodic timer)
timer->state = VOS_TIMER_STATE_STOPPED;
// copy the relevant timer information to local variables;
// once we exist from this critical section, the timer content may be modified
// by other tasks
callback = timer->callback;
userData = timer->userData;
threadId = timer->platformInfo.threadID;
type = timer->type;
vStatus = VOS_STATUS_SUCCESS;
break;
default:
VOS_ASSERT(0);
vStatus = VOS_STATUS_E_FAULT;
break;
}
spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
if ( VOS_STATUS_SUCCESS != vStatus )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"TIMER callback called in a wrong state=%d", timer->state);
return;
}
tryAllowingSleep( type );
if (callback == NULL)
{
VOS_ASSERT(0);
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: No TIMER callback, Could not enqueue timer to any queue",
__func__);
return;
}
// If timer has expired then call vos_client specific callback
if ( vos_sched_is_tx_thread( threadId ) )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"TIMER callback: running on TX thread");
//Serialize to the Tx thread
sysBuildMessageHeader( SYS_MSG_ID_TX_TIMER, &msg );
msg.callback = callback;
msg.bodyptr = userData;
msg.bodyval = 0;
if(vos_tx_mq_serialize( VOS_MQ_ID_SYS, &msg ) == VOS_STATUS_SUCCESS)
return;
}
else if ( vos_sched_is_rx_thread( threadId ) )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"TIMER callback: running on RX thread");
//Serialize to the Rx thread
sysBuildMessageHeader( SYS_MSG_ID_RX_TIMER, &msg );
msg.callback = callback;
msg.bodyptr = userData;
msg.bodyval = 0;
if(vos_rx_mq_serialize( VOS_MQ_ID_SYS, &msg ) == VOS_STATUS_SUCCESS)
return;
}
else
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO,
"TIMER callback: running on MC thread");
// Serialize to the MC thread
sysBuildMessageHeader( SYS_MSG_ID_MC_TIMER, &msg );
msg.callback = callback;
msg.bodyptr = userData;
msg.bodyval = 0;
if(vos_mq_post_message( VOS_MQ_ID_SYS, &msg ) == VOS_STATUS_SUCCESS)
return;
}
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Could not enqueue timer to any queue", __func__);
VOS_ASSERT(0);
}
VOS_STATUS vos_rx_mq_serialize( VOS_MQ_ID msgQueueId, vos_msg_t *pMsg )
{
pVosMqType pTargetMq = NULL;
pVosMsgWrapper pMsgWrapper = NULL;
if ((gpVosContext == NULL) || (pMsg == NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null params or global vos context is null", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
switch (msgQueueId)
{
case VOS_MQ_ID_SYS:
{
pTargetMq = &(gpVosContext->vosSched.sysRxMq);
break;
}
case VOS_MQ_ID_WDI:
{
pTargetMq = &(gpVosContext->vosSched.wdiRxMq);
break;
}
default:
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Trying to queue msg into unknown Rx Msg queue ID %d",
__func__, msgQueueId);
return VOS_STATUS_E_FAILURE;
}
if (pTargetMq == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: pTargetMq == NULL", __func__);
return VOS_STATUS_E_FAILURE;
}
pMsgWrapper = vos_mq_get(&gpVosContext->freeVosMq);
if (NULL == pMsgWrapper)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: VOS Core run out of message wrapper", __func__);
return VOS_STATUS_E_RESOURCES;
}
vos_mem_copy( (v_VOID_t*)pMsgWrapper->pVosMsg,
(v_VOID_t*)pMsg, sizeof(vos_msg_t));
vos_mq_put(pTargetMq, pMsgWrapper);
set_bit(RX_POST_EVENT_MASK, &gpVosContext->vosSched.rxEventFlag);
wake_up_interruptible(&gpVosContext->vosSched.rxWaitQueue);
return VOS_STATUS_SUCCESS;
}
VOS_STATUS vos_timer_destroy ( vos_timer_t *timer )
{
VOS_STATUS vStatus=VOS_STATUS_SUCCESS;
unsigned long flags;
// Check for invalid pointer
if ( NULL == timer )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null timer pointer being passed",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// Check if timer refers to an uninitialized object
if ( LINUX_TIMER_COOKIE != timer->platformInfo.cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Cannot destroy uninitialized timer",__func__);
return VOS_STATUS_E_INVAL;
}
spin_lock_irqsave(&vosTimerList.lock, flags);
vStatus = hdd_list_remove_node(&vosTimerList, &timer->ptimerNode->pNode);
spin_unlock_irqrestore(&vosTimerList.lock, flags);
if(vStatus != VOS_STATUS_SUCCESS)
{
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
vos_mem_free(timer->ptimerNode);
spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
switch ( timer->state )
{
case VOS_TIMER_STATE_STARTING:
vStatus = VOS_STATUS_E_BUSY;
break;
case VOS_TIMER_STATE_RUNNING:
/* Stop the timer first */
del_timer(&(timer->platformInfo.Timer));
vStatus = VOS_STATUS_SUCCESS;
break;
case VOS_TIMER_STATE_STOPPED:
vStatus = VOS_STATUS_SUCCESS;
break;
case VOS_TIMER_STATE_UNUSED:
vStatus = VOS_STATUS_E_ALREADY;
break;
default:
vStatus = VOS_STATUS_E_FAULT;
break;
}
if ( VOS_STATUS_SUCCESS == vStatus )
{
timer->platformInfo.cookie = LINUX_INVALID_TIMER_COOKIE;
timer->state = VOS_TIMER_STATE_UNUSED;
spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
return vStatus;
}
spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Cannot destroy timer in state = %d",__func__, timer->state);
VOS_ASSERT(0);
return vStatus;
}
int bapRsnFormPktFromVosPkt( tAniPacket **ppPacket, vos_pkt_t *pVosPacket )
{
int retVal = ANI_ERROR;
VOS_STATUS status;
v_U16_t uPktLen;
#define BAP_RSN_SNAP_TYPE_OFFSET 20
#define BAP_RSN_ETHERNET_3_HEADER_LEN 22
v_U8_t *pFrame;
tAniPacket *pAniPacket = NULL;
do
{
status = vos_pkt_get_packet_length( pVosPacket, &uPktLen );
if( !VOS_IS_STATUS_SUCCESS(status) ) break;
if( (uPktLen < BAP_RSN_ETHERNET_3_HEADER_LEN) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
" authRsnRxFrameHandler receive eapol packet size (%d) too small (%d)\n",
uPktLen, BAP_RSN_ETHERNET_3_HEADER_LEN );
break;
}
status = vos_pkt_peek_data( pVosPacket, 0, (v_VOID_t *)&pFrame, uPktLen );
if( !VOS_IS_STATUS_SUCCESS(status) ) break;
retVal = aniAsfPacketAllocateExplicit(&pAniPacket, uPktLen, 0 );
if( !ANI_IS_STATUS_SUCCESS( retVal ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
" authRsnRxFrameHandler failed to get buffer size (%d) \n",
uPktLen );
break;
}
aniAsfPacketEmptyExplicit( pAniPacket, 0 );
pFrame[ETHER_PROTO_POS] = pFrame[BAP_RSN_SNAP_TYPE_OFFSET];
pFrame[ETHER_PROTO_POS + 1] = pFrame[BAP_RSN_SNAP_TYPE_OFFSET + 1];
//push ethernet II header in
retVal = aniAsfPacketAppendBuffer( pAniPacket, pFrame, ETHER_PROTO_POS + 2 );
if( !ANI_IS_STATUS_SUCCESS( retVal ) ) break;
//Get the rest of the data in
uPktLen -= BAP_RSN_ETHERNET_3_HEADER_LEN;
VOS_ASSERT( uPktLen > 0 );
retVal = aniAsfPacketAppendBuffer( pAniPacket, pFrame + BAP_RSN_ETHERNET_3_HEADER_LEN,
uPktLen );
if( !ANI_IS_STATUS_SUCCESS( retVal ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
" authRsnRxFrameHandler cannot retrieve eapol payload size (%d)\n",
uPktLen );
break;
}
}while( 0 );
if( ANI_IS_STATUS_SUCCESS( retVal ) )
{
*ppPacket = pAniPacket;
}
else if( pAniPacket )
{
aniAsfPacketFree( pAniPacket );
}
return retVal;
}
