/*
\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 );
}
