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( &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;
}
/**
* authRsnFsmProcessEvent
*
* FUNCTION
* Passes an event to the RSN key FSM instance for immediate processing.
*
* @param fsm the RSN Key FSM instance
* @param eventId the AAG event to process
* @param arg an optional argument for this event
*
* @return ANI_OK if the operation succeeds
*/
int
authRsnFsmProcessEvent(tAuthRsnFsm *fsm, tRsnFsmEvent eventId, void *arg)
{
VOS_ASSERT(fsm);
switch (eventId) {
case RSN_FSM_TIMER_EXPIRED:
// Proceed straight to checkTransition
break;
case RSN_FSM_AUTH_START:
fsm->authReq = eANI_BOOLEAN_TRUE;
authRsnAuthStartEventHandler(fsm);
break;
case RSN_FSM_EAPOL_FRAME_AVAILABLE:
fsm->eapolAvail = eANI_BOOLEAN_TRUE;
break;
case RSN_FSM_DISCONNECT:
fsm->disconnect = eANI_BOOLEAN_TRUE;
authRsnAuthDisconEventHandler(fsm);
break;
case RSN_FSM_INTEG_FAILED:
fsm->integFailed = eANI_BOOLEAN_TRUE;
break;
default:
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Unknown event for Auth RSN Key Fsm: %d\n", eventId);
VOS_ASSERT( 0 );
return ANI_E_ILLEGAL_ARG;
break;
}
checkTransition(fsm, arg);
return ANI_OK;
}
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;
}
/*-------------------------------------------------------------------------
\brief vos_event_init() - initializes a vOSS event
The vos_event_init() function initializes the specified event. Upon
successful initialization, the state of the event becomes initialized
and not signaled.
An event must be initialized before it may be used in any other event
functions.
Attempting to initialize an already initialized event results in
a failure.
\param lock - pointer to the opaque event object to initialize
\return VOS_STATUS_SUCCESS - event was successfully initialized and
is ready to be used.
VOS_STATUS_E_BUSY - The implementation has detected an attempt
to reinitialize the object referenced by event, a previously
initialized, but not yet destroyed, event.
VOS_STATUS_E_FAULT - event is an invalid pointer.
VOS_STATUS_E_FAILURE - event could not be created due to
unknown reasons
***VOS_STATUS_E_RESOURCES - System resources (other than memory)
are unavailable to initilize the event
***VOS_STATUS_E_NOMEM - insufficient memory exists to initialize
the event
\sa
( *** indicates return values do NOT exist yet )
-------------------------------------------------------------------------*/
VOS_STATUS vos_event_init ( vos_event_t* event )
{
// Check for null pointer
if ( NULL == event )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"NULL event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check for 'already initialized' event
if ( LINUX_EVENT_COOKIE == event->cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Initialized event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_BUSY;
}
// initialize new event
init_completion(&event->complete);
event->cookie = LINUX_EVENT_COOKIE;
return VOS_STATUS_SUCCESS;
}
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;
}
v_VOID_t vos_core_return_msg
(
v_PVOID_t pVContext,
pVosMsgWrapper pMsgWrapper
)
{
pVosContextType pVosContext = (pVosContextType) pVContext;
VOS_ASSERT( gpVosContext == pVosContext);
if (gpVosContext != pVosContext)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: gpVosContext != pVosContext", __func__);
return;
}
VOS_ASSERT( NULL !=pMsgWrapper );
if (pMsgWrapper == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: pMsgWrapper == NULL in function", __func__);
return;
}
INIT_LIST_HEAD(&pMsgWrapper->msgNode);
vos_mq_put(&pVosContext->freeVosMq, pMsgWrapper);
}
VOS_STATUS vos_event_set ( vos_event_t* event )
{
// Check for null pointer
if ( NULL == event )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"NULL event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check if event refers to an initialized object
if ( LINUX_EVENT_COOKIE != event->cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Uninitialized event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
complete(&event->complete);
return VOS_STATUS_SUCCESS;
}
/*--------------------------------------------------------------------------
\brief vos_event_reset() - resets a vOSS event - This function isn't required
for Linux. Therefore, it doesn't do much.
The state of the specified event is set to 'NOT signalled' by calling
\a vos_event_reset(). The state of the event remains NOT signalled until an
explicit call to vos_event_set().
This function sets the event to a NOT signalled state even if the event was
signalled multiple times before being signaled.
\param event - the event to set to the NOT signalled state
\return VOS_STATUS_SUCCESS - the event state was successfully change to
NOT signalled.
VOS_STATUS_E_INVAL - The value specified by event does not refer
to an initialized event object.
VOS_STATUS_E_FAULT - event is an invalid pointer.
VOS_STATUS_E_FAILURE - event could not be signaled due to
unknown reasons
\sa
-------------------------------------------------------------------------*/
VOS_STATUS vos_event_reset ( vos_event_t* event )
{
// check for null pointer
if ( NULL == event )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"NULL event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check to make sure it is an 'already initialized' event
if ( LINUX_EVENT_COOKIE != event->cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Uninitialized event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
// (re)initialize event
INIT_COMPLETION(event->complete);
return VOS_STATUS_SUCCESS;
}
VOS_STATUS vos_event_destroy ( vos_event_t* event )
{
// check for null pointer
if ( NULL == event )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"NULL event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check to make sure it is an 'already initialized' event
if ( LINUX_EVENT_COOKIE != event->cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Uninitialized event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
// make sure nobody is waiting on the event
complete_all(&event->complete);
// destroy the event
memset(event, 0, sizeof(vos_event_t));
return VOS_STATUS_SUCCESS;
}
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;
}
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;
}
VOS_STATUS vos_timer_init_debug( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
vos_timer_callback_t callback, v_PVOID_t userData,
char* fileName, v_U32_t lineNum )
{
VOS_STATUS vosStatus;
unsigned long flags;
// Check for invalid pointer
if ((timer == NULL) || (callback == NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null params being passed",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
timer->ptimerNode = vos_mem_malloc(sizeof(timer_node_t));
if(timer->ptimerNode == NULL)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Not able to allocate memory for timeNode",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
vos_mem_set(timer->ptimerNode, sizeof(timer_node_t), 0);
timer->ptimerNode->fileName = fileName;
timer->ptimerNode->lineNum = lineNum;
timer->ptimerNode->vosTimer = timer;
spin_lock_irqsave(&vosTimerList.lock, flags);
vosStatus = hdd_list_insert_front(&vosTimerList, &timer->ptimerNode->pNode);
spin_unlock_irqrestore(&vosTimerList.lock, flags);
if(VOS_STATUS_SUCCESS != vosStatus)
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Unable to insert node into List vosStatus %d", __func__, vosStatus);
}
// set the various members of the timer structure
// with arguments passed or with default values
spin_lock_init(&timer->platformInfo.spinlock);
init_timer(&(timer->platformInfo.Timer));
timer->platformInfo.Timer.function = vos_linux_timer_callback;
timer->platformInfo.Timer.data = (unsigned long)timer;
timer->callback = callback;
timer->userData = userData;
timer->type = timerType;
timer->platformInfo.cookie = LINUX_TIMER_COOKIE;
timer->platformInfo.threadID = 0;
timer->state = VOS_TIMER_STATE_STOPPED;
return VOS_STATUS_SUCCESS;
}
/*----------------------------------------------------------------------------
\brief vos_wait_single_event() - Waits for a single event to be set.
This API waits for the event to be set.
\param pEvent - pointer to an event to wait on.
\param timeout - Timeout value (in milliseconds). This function returns
if this interval elapses, regardless if any of the events have
been set. An input value of 0 for this timeout parameter means
to wait infinitely, meaning a timeout will never occur.
\return VOS_STATUS_SUCCESS - the wait was satisifed by the event being
set.
VOS_STATUS_E_TIMEOUT - the timeout interval elapsed before the
event was set.
VOS_STATUS_E_INVAL - The value specified by event is invalid.
VOS_STATUS_E_FAULT - pEvent is an invalid pointer.
\sa vos_wait_multiple_events()
--------------------------------------------------------------------------*/
VOS_STATUS vos_wait_single_event ( vos_event_t* event, v_U32_t timeout)
{
if (in_interrupt())
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s cannot be called from interrupt context!!!", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check for null pointer
if ( NULL == event )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"NULL event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// check if cookie is same as that of initialized event
if ( LINUX_EVENT_COOKIE != event->cookie )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Uninitialized event passed into %s", __FUNCTION__);
VOS_ASSERT(0);
return VOS_STATUS_E_INVAL;
}
if (timeout)
{
long ret;
ret =
wait_for_completion_interruptible_timeout(&event->complete,
msecs_to_jiffies(timeout));
if ( 0 >= ret )
{
// 0 means timed out, negative means interrupted
return VOS_STATUS_E_TIMEOUT;
}
}
else
{
int ret;
ret = wait_for_completion_interruptible(&event->complete);
if ( 0 != ret )
{
// negative means interrupted
return VOS_STATUS_E_TIMEOUT;
}
}
return VOS_STATUS_SUCCESS;
}
/**---------------------------------------------------------------------
* tx_timer_activate()
*
* FUNCTION:
*
* LOGIC:
*
* ASSUMPTIONS:
*
* NOTE:
*
* @param
*
* @return TX_SUCCESS.
*
*/
v_UINT_t tx_timer_activate(TX_TIMER *timer_ptr)
{
VOS_STATUS status;
// Uncomment the asserts, if the intention is to debug the occurence of the
// following anomalous cnditions.
// Assert that the timer structure pointer passed, is not NULL
//dbgAssert(NULL != timer_ptr);
// If the NIC is halting just spoof a successful timer activation, so that all
// the timers can be cleaned up.
if(NULL == timer_ptr)
return TX_TIMER_ERROR;
// Put a check for the free builds
if (TX_AIRGO_TMR_SIGNATURE != timer_ptr->tmrSignature) {
VOS_ASSERT( timer_ptr->tmrSignature == 0 );
return TX_TIMER_ERROR;
}
// Check for an uninitialized timer
VOS_ASSERT(0 != strlen(TIMER_NAME));
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"Timer %s being activated\n", TIMER_NAME);
status = vos_timer_start( &timer_ptr->vosTimer,
timer_ptr->initScheduleTimeInMsecs );
if (VOS_STATUS_SUCCESS == status)
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"Timer %s now activated\n", TIMER_NAME);
return TX_SUCCESS;
}
else if (VOS_STATUS_E_ALREADY == status)
{
// starting timer fails because timer is already started; this is okay
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"Timer %s is already running\n", TIMER_NAME);
return TX_SUCCESS;
}
else
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_ERROR,
"Timer %s fails to activate\n", TIMER_NAME);
return TX_TIMER_ERROR;
}
} /*** tx_timer_activate() ***/
/*--------------------------------------------------------------------------
\brief vos_timer_stop() - Stop a vOSS Timer
The \a vos_timer_stop() function stops a timer that has been started but
has not expired, essentially cancelling the 'start' request.
After a timer is stopped, it goes back to the state it was in after it
was created and can be started again via a call to vos_timer_start().
\param timer - the timer object to be stopped
\return VOS_STATUS_SUCCESS - timer was successfully stopped.
VOS_STATUS_E_INVAL - The value specified by timer is invalid.
VOS_STATUS_E_FAULT - timer is an invalid pointer.
\sa
------------------------------------------------------------------------*/
VOS_STATUS vos_timer_stop ( vos_timer_t *timer )
{
unsigned long flags;
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
"%s: Timer Addr inside voss_stop : 0x%p",__func__,timer );
// 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_INVAL;
}
// 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 stop uninitialized timer",__func__);
if ( LINUX_INVALID_TIMER_COOKIE != timer->platformInfo.cookie )
{
VOS_ASSERT(0);
}
return VOS_STATUS_E_INVAL;
}
// Ensure the timer state is correct
spin_lock_irqsave( &timer->platformInfo.spinlock,flags );
if ( VOS_TIMER_STATE_RUNNING != timer->state )
{
spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_INFO_HIGH,
"%s: Cannot stop timer in state = %d",
__func__, timer->state);
return VOS_STATUS_SUCCESS;
}
timer->state = VOS_TIMER_STATE_STOPPED;
del_timer(&(timer->platformInfo.Timer));
spin_unlock_irqrestore( &timer->platformInfo.spinlock,flags );
tryAllowingSleep( timer->type );
return VOS_STATUS_SUCCESS;
}
void logDebug(tpAniSirGlobal pMac, tANI_U8 modId, tANI_U32 debugLevel, const char *pStr, va_list marker)
{
VOS_TRACE_LEVEL vosDebugLevel;
VOS_MODULE_ID vosModuleId;
char logBuffer[LOG_SIZE];
vosDebugLevel = getVosDebugLevel(debugLevel);
vosModuleId = getVosModuleId(modId);
#ifdef ANI_OS_TYPE_ANDROID
vsnprintf(logBuffer, LOG_SIZE - 1, pStr, marker);
#else
#ifdef WINDOWS_DT
RtlStringCbVPrintfA( &logBuffer[ 0 ], LOG_SIZE - 1, pStr, marker );
#else
_vsnprintf(logBuffer, LOG_SIZE - 1, (char *)pStr, marker);
#endif
#endif
VOS_TRACE(vosModuleId, vosDebugLevel, "%s", logBuffer);
// The caller must check loglevel
VOS_ASSERT( ( debugLevel <= pMac->utils.gLogDbgLevel[LOG_INDEX_FOR_MODULE( modId )] ) && ( LOGP != debugLevel ) );
} /*** end logDebug() ***/
/*
* TDLS request API, called from HDD to send a TDLS frame
* in SME/CSR and send message to PE to trigger TDLS discovery procedure.
*/
eHalStatus csrTdlsSendMgmtReq(tHalHandle hHal, tANI_U8 sessionId, tCsrTdlsSendMgmt *tdlsSendMgmt)
{
tpAniSirGlobal pMac = PMAC_STRUCT( hHal );
tSmeCmd *tdlsSendMgmtCmd ;
eHalStatus status = eHAL_STATUS_FAILURE ;
//If connected and in Infra. Only then allow this
if( CSR_IS_SESSION_VALID( pMac, sessionId ) &&
csrIsConnStateConnectedInfra( pMac, sessionId ) &&
(NULL != tdlsSendMgmt) )
{
tdlsSendMgmtCmd = csrGetCommandBuffer(pMac) ;
if(tdlsSendMgmtCmd)
{
tTdlsSendMgmtCmdInfo *tdlsSendMgmtCmdInfo =
&tdlsSendMgmtCmd->u.tdlsCmd.u.tdlsSendMgmtCmdInfo ;
tdlsSendMgmtCmd->sessionId = sessionId;
tdlsSendMgmtCmdInfo->frameType = tdlsSendMgmt->frameType ;
tdlsSendMgmtCmdInfo->dialog = tdlsSendMgmt->dialog ;
tdlsSendMgmtCmdInfo->statusCode = tdlsSendMgmt->statusCode ;
tdlsSendMgmtCmdInfo->responder = tdlsSendMgmt->responder;
tdlsSendMgmtCmdInfo->peerCapability = tdlsSendMgmt->peerCapability;
vos_mem_copy(tdlsSendMgmtCmdInfo->peerMac,
tdlsSendMgmt->peerMac, sizeof(tSirMacAddr)) ;
if( (0 != tdlsSendMgmt->len) && (NULL != tdlsSendMgmt->buf) )
{
tdlsSendMgmtCmdInfo->buf = vos_mem_malloc(tdlsSendMgmt->len);
if ( NULL == tdlsSendMgmtCmdInfo->buf )
status = eHAL_STATUS_FAILURE;
else
status = eHAL_STATUS_SUCCESS;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Alloc Failed") );
VOS_ASSERT(0) ;
return status ;
}
vos_mem_copy(tdlsSendMgmtCmdInfo->buf,
tdlsSendMgmt->buf, tdlsSendMgmt->len );
tdlsSendMgmtCmdInfo->len = tdlsSendMgmt->len;
}
else
{
tdlsSendMgmtCmdInfo->buf = NULL;
tdlsSendMgmtCmdInfo->len = 0;
}
tdlsSendMgmtCmd->command = eSmeCommandTdlsSendMgmt ;
tdlsSendMgmtCmd->u.tdlsCmd.size = sizeof(tTdlsSendMgmtCmdInfo) ;
smePushCommand(pMac, tdlsSendMgmtCmd, FALSE) ;
status = eHAL_STATUS_SUCCESS ;
}
}
return status ;
}
eHalStatus csrTdlsProcessSendMgmt( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsSendMgmtCmdInfo *tdlsSendMgmtCmdInfo = &cmd->u.tdlsCmd.u.tdlsSendMgmtCmdInfo ;
tSirTdlsSendMgmtReq *tdlsSendMgmtReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS Description is not present") );
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsSendMgmtReq,
(sizeof(tSirTdlsSendMgmtReq) + tdlsSendMgmtCmdInfo->len ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed") );
VOS_ASSERT(0) ;
return status ;
}
tdlsSendMgmtReq->sessionId = cmd->sessionId;
//Using dialog as transactionId. This can be used to match response with request
tdlsSendMgmtReq->transactionId = tdlsSendMgmtCmdInfo->dialog;
tdlsSendMgmtReq->reqType = tdlsSendMgmtCmdInfo->frameType ;
tdlsSendMgmtReq->dialog = tdlsSendMgmtCmdInfo->dialog ;
tdlsSendMgmtReq->statusCode = tdlsSendMgmtCmdInfo->statusCode ;
tdlsSendMgmtReq->responder = tdlsSendMgmtCmdInfo->responder;
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->peerMac,
tdlsSendMgmtCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
if(tdlsSendMgmtCmdInfo->len && tdlsSendMgmtCmdInfo->buf)
{
palCopyMemory(pMac->hHdd, tdlsSendMgmtReq->addIe, tdlsSendMgmtCmdInfo->buf,
tdlsSendMgmtCmdInfo->len);
}
// Send the request to PE.
smsLog( pMac, LOG1, "sending TDLS Mgmt Frame req to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_SEND_MGMT_REQ,
(void *)tdlsSendMgmtReq , sizeof(tSirTdlsSendMgmtReq)+tdlsSendMgmtCmdInfo->len) ;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC"));
}
if(tdlsSendMgmtCmdInfo->len && tdlsSendMgmtCmdInfo->buf)
{
//Done with the buf. Free it.
vos_mem_free( tdlsSendMgmtCmdInfo->buf );
tdlsSendMgmtCmdInfo->buf = NULL;
tdlsSendMgmtCmdInfo->len = 0;
}
return status;
}
eHalStatus csrTdlsProcessAddSta( tpAniSirGlobal pMac, tSmeCmd *cmd )
{
tTdlsAddStaCmdInfo *tdlsAddStaCmdInfo = &cmd->u.tdlsCmd.u.tdlsAddStaCmdInfo ;
tSirTdlsAddStaReq *tdlsAddStaReq = NULL ;
tCsrRoamSession *pSession = CSR_GET_SESSION( pMac, cmd->sessionId );
eHalStatus status = eHAL_STATUS_FAILURE;
if (NULL == pSession->pConnectBssDesc)
{
smsLog( pMac, LOGE, FL("BSS description is not present") );
return eHAL_STATUS_FAILURE;
}
status = palAllocateMemory( pMac->hHdd, (void **)&tdlsAddStaReq,
(sizeof(tSirTdlsAddStaReq) ) );
if (!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("alloc failed") );
VOS_ASSERT(0) ;
return status ;
}
tdlsAddStaReq->sessionId = cmd->sessionId;
tdlsAddStaReq->tdlsAddOper = tdlsAddStaCmdInfo->tdlsAddOper;
//Using dialog as transactionId. This can be used to match response with request
tdlsAddStaReq->transactionId = 0;
palCopyMemory(pMac->hHdd, tdlsAddStaReq->bssid,
pSession->pConnectBssDesc->bssId, sizeof (tSirMacAddr));
palCopyMemory(pMac->hHdd, tdlsAddStaReq->peerMac,
tdlsAddStaCmdInfo->peerMac, sizeof(tSirMacAddr)) ;
tdlsAddStaReq->capability = tdlsAddStaCmdInfo->capability;
tdlsAddStaReq->uapsd_queues = tdlsAddStaCmdInfo->uapsdQueues;
tdlsAddStaReq->max_sp = tdlsAddStaCmdInfo->maxSp;
palCopyMemory(pMac->hHdd, tdlsAddStaReq->extn_capability,
tdlsAddStaCmdInfo->extnCapability,
SIR_MAC_MAX_EXTN_CAP);
tdlsAddStaReq->htcap_present = tdlsAddStaCmdInfo->htcap_present;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->htCap,
&tdlsAddStaCmdInfo->HTCap, sizeof(tdlsAddStaCmdInfo->HTCap));
tdlsAddStaReq->vhtcap_present = tdlsAddStaCmdInfo->vhtcap_present;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->vhtCap,
&tdlsAddStaCmdInfo->VHTCap, sizeof(tdlsAddStaCmdInfo->VHTCap));
tdlsAddStaReq->supported_rates_length = tdlsAddStaCmdInfo->supportedRatesLen;
palCopyMemory(pMac->hHdd, &tdlsAddStaReq->supported_rates,
tdlsAddStaCmdInfo->supportedRates, tdlsAddStaCmdInfo->supportedRatesLen);
// Send the request to PE.
smsLog( pMac, LOGE, "sending TDLS Add Sta req to PE " );
status = tdlsSendMessage(pMac, eWNI_SME_TDLS_ADD_STA_REQ,
(void *)tdlsAddStaReq , sizeof(tSirTdlsAddStaReq)) ;
if(!HAL_STATUS_SUCCESS( status ) )
{
smsLog( pMac, LOGE, FL("Failed to send request to MAC"));
}
return status;
}
VOS_STATUS vos_preOpen ( v_CONTEXT_t *pVosContext )
{
if ( pVosContext == NULL)
return VOS_STATUS_E_FAILURE;
*pVosContext = NULL;
gpVosContext = &gVosContext;
if (NULL == gpVosContext)
{
VOS_TRACE( VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Failed to allocate VOS Context", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_RESOURCES;
}
vos_mem_zero(gpVosContext, sizeof(VosContextType));
*pVosContext = gpVosContext;
vos_trace_spin_lock_init();
#if defined(TRACE_RECORD)
vosTraceInit();
#endif
return VOS_STATUS_SUCCESS;
}
v_VOID_t vos_mem_free( v_VOID_t *ptr )
{
if (ptr != NULL)
{
VOS_STATUS vosStatus;
struct s_vos_mem_struct* memStruct = ((struct s_vos_mem_struct*)ptr) - 1;
spin_lock(&vosMemList.lock);
vosStatus = hdd_list_remove_node(&vosMemList, &memStruct->pNode);
spin_unlock(&vosMemList.lock);
if(VOS_STATUS_SUCCESS == vosStatus)
{
if(0 == vos_mem_compare(memStruct->header, &WLAN_MEM_HEADER[0], sizeof(WLAN_MEM_HEADER)) )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Memory Header is corrupted. MemInfo: Filename %s, LineNum %d",
memStruct->fileName, (int)memStruct->lineNum);
}
if(0 == vos_mem_compare( (v_U8_t*)ptr + memStruct->size, &WLAN_MEM_TAIL[0], sizeof(WLAN_MEM_TAIL ) ) )
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"Memory Trailer is corrupted. MemInfo: Filename %s, LineNum %d",
memStruct->fileName, (int)memStruct->lineNum);
}
kfree((v_VOID_t*)memStruct);
}
else
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_FATAL,
"%s: Unallocated memory (double free?)", __FUNCTION__);
VOS_ASSERT(0);
}
}
}
VOS_STATUS vos_timer_init( vos_timer_t *timer, VOS_TIMER_TYPE timerType,
vos_timer_callback_t callback, v_PVOID_t userData )
{
// Check for invalid pointer
if ((timer == NULL) || (callback == NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s: Null params being passed",__func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAULT;
}
// set the various members of the timer structure
// with arguments passed or with default values
spin_lock_init(&timer->platformInfo.spinlock);
init_timer(&(timer->platformInfo.Timer));
timer->platformInfo.Timer.function = vos_linux_timer_callback;
timer->platformInfo.Timer.data = (unsigned long)timer;
timer->callback = callback;
timer->userData = userData;
timer->type = timerType;
timer->platformInfo.cookie = LINUX_TIMER_COOKIE;
timer->platformInfo.threadID = 0;
timer->state = VOS_TIMER_STATE_STOPPED;
return VOS_STATUS_SUCCESS;
}
GOS_ERROR_CODE tmr_TimerHandleReset(VOS_TIMER_RESET_T* pMsg, VOS_APPL_ID srcAppl)
{
VOS_ASSERT(pMsg);
if (pMsg->timerId >= VOS_TIMER_MAX_NUM)
{
printf("app 0x%08x reset invalid timer[%d]\r\n", srcAppl, pMsg->timerId);
return GOS_ERR_PARAM;
}
VOS_Lock(gTmrTimerLock, 0);
if (gTmrTimers[pMsg->timerId].valid && (gTmrTimers[pMsg->timerId].srcAppl == srcAppl))
{
gTmrTimers[pMsg->timerId].expireMs = gTmrTimerMsCounter + gTmrTimers[pMsg->timerId].interval;
if (0 == gTmrTimers[pMsg->timerId].expireMs)
{
gTmrTimers[pMsg->timerId].expireMs = 1;
}
}
else
{
printf("app 0x%08x reset invalid timer[%d]\r\n", srcAppl, pMsg->timerId);
}
VOS_Unlock(gTmrTimerLock);
return GOS_OK;
}
/*---------------------------------------------------------------------------
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*/
static
int derivePtk(tAuthRsnFsm *fsm, tAniEapolKeyAvailEventData *data)
{
v_U32_t prfLen;
tAniEapolRsnKeyDesc *rxDesc;
VOS_ASSERT(fsm->staCtx->pmk);
switch (fsm->staCtx->pwCipherType)
{
case eCSR_ENCRYPT_TYPE_AES:
prfLen = AAG_RSN_PTK_PRF_LEN_CCMP;
break;
default:
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Auth cannot generate PTK for invalid algorithm %d\n",
fsm->staCtx->pwCipherType);
return ANI_E_ILLEGAL_ARG;
break;
};
rxDesc = (tAniEapolRsnKeyDesc *) data->keyDesc;
return aagPtkPrf(fsm->cryptHandle,
fsm->staCtx->ptk,
prfLen,
fsm->staCtx->pmk,
fsm->staCtx->authMac,
fsm->staCtx->suppMac,
fsm->aNonce,
rxDesc->keyNonce);
}
/**
* aniAsfPacketDuplicate
*
* Duplicates a given packet exactly. That is, the contents, the size
* of the packet, and the positions of the pointers are maintained in
* the new copy.
*
* @param newPacketPtr is set to a newly allocated packet that is a
* duplicate of oldPacket
* @param oldPacket the original packet that should be duplicated
*
* @return ANI_OK if the operation succeeds; ANI_E_NULL if oldPacket
* is NULL;
*/
int
aniAsfPacketDuplicate(tAniPacket **newPacketPtr, tAniPacket *oldPacket)
{
int retVal;
int recordPos;
tAniPacket *packet = NULL;
if (oldPacket == NULL)
return ANI_E_NULL_VALUE;
retVal = aniAsfPacketAllocateExplicit(&packet,
oldPacket->size,
oldPacket->head - oldPacket->buf);
if (retVal != ANI_OK)
return retVal;
retVal = aniAsfPacketAppendBuffer(packet,
oldPacket->head,
oldPacket->len);
if (retVal != ANI_OK)
{
VOS_ASSERT( 0 );
aniAsfPacketFree(packet);
return ANI_E_FAILED;
}
if (oldPacket->recordHeader != NULL)
{
recordPos = oldPacket->recordHeader - oldPacket->buf;
packet->recordHeader = packet->buf + recordPos;
}
*newPacketPtr = packet;
return ANI_OK;
}
tANI_BOOLEAN csrCheckPSReady(void *pv)
{
tpAniSirGlobal pMac = PMAC_STRUCT( pv );
VOS_ASSERT( pMac->roam.sPendingCommands >= 0 );
return (pMac->roam.sPendingCommands == 0);
}
GOS_ERROR_CODE mmr_GetTmpStatus(VOS_APPL_ID srcAppl, MMR_MSG_DEV_HDL* pDev)
{
MMR_GET_SYS_TEMPERATURE_ACK_T status;
GOS_ERROR_CODE eRet = GOS_OK;
INT16 mainTemp;
//INT16 subTemp;
VOS_ASSERT(pDev);
memset(&status, 0 , sizeof(MMR_GET_SYS_TEMPERATURE_ACK_T));
memcpy(&status.devHdl, pDev, sizeof(status.devHdl));
if (GOS_OK != mmr_GetTempreture(status.devHdl.slot, 0, &mainTemp) )
{
mmr_Log(LOG_LEVEL_ERROR, "mmr_GetTmpStatus fail");
//need to return it old value ?
status.eRet = GOS_FAIL;
eRet = GOS_FAIL;
}
else
{
mmr_Log(LOG_LEVEL_NORMAL, "mmr_GetTmpStatus ok, %d C", mainTemp);
status.value = (UINT32)mainTemp;
status.eRet = GOS_OK;
eRet = GOS_OK;
}
// TODO: get the tmp75 current alarm state
// status.curAlarm = MMR_TMP_NO_ALARM;
/* send syn msg response */
mmr_ResponseSyncMsg(srcAppl, MMR_GET_SYS_TEMPERATURE_ACK, &status, sizeof(status));
return eRet;
}
v_BOOL_t vos_mem_compare(
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,0))
const v_VOID_t *pMemory1,
#else
v_VOID_t *pMemory1,
#endif
#if (LINUX_VERSION_CODE >= KERNEL_VERSION(3,18,0))
const v_VOID_t *pMemory2,
#else
v_VOID_t *pMemory2,
#endif
v_U32_t numBytes )
{
if (0 == numBytes)
{
// special case where pMemory1 or pMemory2 can be NULL
return VOS_TRUE;
}
if ((pMemory1 == NULL) || (pMemory2==NULL))
{
VOS_TRACE(VOS_MODULE_ID_VOSS, VOS_TRACE_LEVEL_ERROR,
"%s called with NULL parameter, p1:%p p2:%p",
__func__, pMemory1, pMemory2);
VOS_ASSERT(0);
return VOS_FALSE;
}
return (memcmp(pMemory1, pMemory2, numBytes)?VOS_FALSE:VOS_TRUE);
}
v_UINT_t tx_timer_create_intern( v_PVOID_t pMacGlobal, TX_TIMER *timer_ptr,
char *name_ptr,
v_VOID_t ( *expiration_function )( v_PVOID_t, tANI_U32 ),
tANI_U32 expiration_input, v_ULONG_t initScheduleTimeInTicks,
v_ULONG_t rescheduleTimeInTicks, v_ULONG_t auto_activate )
{
VOS_STATUS status;
VOS_ASSERT((NULL != expiration_function) && (NULL != name_ptr));
if((NULL == name_ptr) || (NULL == expiration_function))
return TX_TIMER_ERROR;
if (!initScheduleTimeInTicks)
return TX_TICK_ERROR;
if (!timer_ptr)
return TX_TIMER_ERROR;
// Initialize timer structure
timer_ptr->pExpireFunc = expiration_function;
timer_ptr->expireInput = expiration_input;
timer_ptr->initScheduleTimeInMsecs =
TX_MSECS_IN_1_TICK * initScheduleTimeInTicks;
timer_ptr->rescheduleTimeInMsecs =
TX_MSECS_IN_1_TICK * rescheduleTimeInTicks;
timer_ptr->pMac = pMacGlobal;
// Set the flag indicating that the timer was created
timer_ptr->tmrSignature = TX_AIRGO_TMR_SIGNATURE;
#ifdef WLAN_DEBUG
// Store the timer name
strlcpy(timer_ptr->timerName, name_ptr, sizeof(timer_ptr->timerName));
#endif // Store the timer name, for Debug build only
status = vos_timer_init( &timer_ptr->vosTimer, VOS_TIMER_TYPE_SW,
tx_main_timer_func, (v_PVOID_t)timer_ptr );
if (VOS_STATUS_SUCCESS != status)
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_ERROR,
"Cannot create timer for %s\n", TIMER_NAME);
return TX_TIMER_ERROR;
}
if(0 != rescheduleTimeInTicks)
{
VOS_TRACE(VOS_MODULE_ID_SYS, VOS_TRACE_LEVEL_INFO,
"Creating periodic timer for %s\n", TIMER_NAME);
}
// Activate this timer if required
if (auto_activate)
{
tx_timer_activate(timer_ptr);
}
return TX_SUCCESS;
} //** tx_timer_create() ***/
