int wlan_logging_flush_pkt_queue(void)
{
vos_pkt_t *pkt_queue_head;
unsigned long flags;
spin_lock_irqsave(&gwlan_logging.data_mgmt_pkt_lock, flags);
if (NULL != gwlan_logging.data_mgmt_pkt_queue) {
pkt_queue_head = gwlan_logging.data_mgmt_pkt_queue;
gwlan_logging.data_mgmt_pkt_queue = NULL;
gwlan_logging.pkt_drop_cnt = 0;
gwlan_logging.data_mgmt_pkt_qcnt = 0;
spin_unlock_irqrestore(&gwlan_logging.data_mgmt_pkt_lock,
flags);
vos_pkt_return_packet(pkt_queue_head);
} else {
spin_unlock_irqrestore(&gwlan_logging.data_mgmt_pkt_lock,
flags);
}
spin_lock_irqsave(&gwlan_logging.fw_log_pkt_lock, flags);
if (NULL != gwlan_logging.fw_log_pkt_queue) {
pkt_queue_head = gwlan_logging.fw_log_pkt_queue;
gwlan_logging.fw_log_pkt_queue = NULL;
gwlan_logging.fw_log_pkt_drop_cnt = 0;
gwlan_logging.fw_log_pkt_qcnt = 0;
spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock,
flags);
vos_pkt_return_packet(pkt_queue_head);
} else {
spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock,
flags);
}
return 0;
}
int wlan_queue_fw_log_pkt_for_app(vos_pkt_t *pPacket)
{
unsigned long flags;
vos_pkt_t *next_pkt;
vos_pkt_t *free_pkt;
VOS_STATUS status = VOS_STATUS_E_FAILURE;
spin_lock_irqsave(&gwlan_logging.fw_log_pkt_lock, flags);
if (gwlan_logging.fw_log_pkt_qcnt >= LOGGER_MAX_FW_LOG_PKT_Q_LEN) {
status = vos_pkt_walk_packet_chain(
gwlan_logging.fw_log_pkt_queue, &next_pkt, TRUE);
/*both "success" and "empty" are acceptable results*/
if (!((status == VOS_STATUS_SUCCESS) ||
(status == VOS_STATUS_E_EMPTY))) {
++gwlan_logging.fw_log_pkt_drop_cnt;
spin_unlock_irqrestore(
&gwlan_logging.fw_log_pkt_lock, flags);
pr_err("%s: Failure walking packet chain", __func__);
/*keep returning pkts to avoid low resource cond*/
vos_pkt_return_packet(pPacket);
return VOS_STATUS_E_FAILURE;
}
free_pkt = gwlan_logging.fw_log_pkt_queue;
gwlan_logging.fw_log_pkt_queue = next_pkt;
/*returning head of pkt queue. latest pkts are important*/
--gwlan_logging.fw_log_pkt_qcnt;
spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock,
flags);
vos_pkt_return_packet(free_pkt);
} else {
spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock,
flags);
}
spin_lock_irqsave(&gwlan_logging.fw_log_pkt_lock, flags);
if (gwlan_logging.fw_log_pkt_queue) {
vos_pkt_chain_packet(gwlan_logging.fw_log_pkt_queue,
pPacket, TRUE);
} else {
gwlan_logging.fw_log_pkt_queue = pPacket;
}
++gwlan_logging.fw_log_pkt_qcnt;
spin_unlock_irqrestore(&gwlan_logging.fw_log_pkt_lock, flags);
set_bit(LOGGER_FW_LOG_PKT_POST, &gwlan_logging.event_flag);
wake_up_interruptible(&gwlan_logging.wait_queue);
return VOS_STATUS_SUCCESS;
}
/**============================================================================
@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;
// 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 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 );
}
//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 );
}
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;
}
//
//This function alwasy assume the incoming vos_packet is 802_3 frame.
static int authRsnRxFrameHandler( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket )
{
int retVal = ANI_ERROR;
tAniPacket *pAniPacket;
tBtampContext *ctx;
tAuthRsnFsm *fsm;
/* Validate params */
if ((pvosGCtx == NULL) || (NULL == pPacket))
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"param is NULL in %s", __func__);
return retVal;
}
ctx = (tBtampContext *)VOS_GET_BAP_CB( pvosGCtx );
if (NULL == ctx)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"ctx is NULL in %s", __func__);
return retVal;
}
fsm = &ctx->uFsm.authFsm;
if (NULL == fsm)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"fsm is NULL in %s", __func__);
return retVal;
}
do
{
//ToDO: We need to synchronize this. For now, use the simplest form, drop the packet comes later.
if( fsm->fReceiving )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
" ******authRsnRxFrameHandler receive eapol packet while processing. Drop the new comer\n" );
break;
}
fsm->fReceiving = VOS_TRUE;
retVal = bapRsnFormPktFromVosPkt( &pAniPacket, pPacket );
if( !ANI_IS_STATUS_SUCCESS( retVal ) ) break;
//Now we can process the eapol frame
//handler will free the pAniPacket
bapRsnEapolHandler( fsm, pAniPacket, VOS_TRUE );
}while( 0 );
fsm->fReceiving = VOS_FALSE;
vos_pkt_return_packet( pPacket );
return retVal;
}
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;
}
wpt_status wpalPacketFree(wpt_packet *pPkt)
{
VOS_STATUS vosStatus;
if(NULL != pPkt->pInternalData)
{
wpalMemoryFree(pPkt->pInternalData);
}
vosStatus = vos_pkt_return_packet(WPAL_TO_VOS_PKT(pPkt));
//
return (wpt_status)vosStatus;
}/* */
/*---------------------------------------------------------------------------
wpalPacketFree – Free a wpt_packet chain for one particular type.
For our legacy UMAC, it is not needed because vos_packet contains pal_packet.
Param:
pPkt – pointer to a wpt_packet
Return:
eWLAN_PAL_STATUS_SUCCESS - success
---------------------------------------------------------------------------*/
wpt_status wpalPacketFree(wpt_packet *pPkt)
{
VOS_STATUS vosStatus;
if(NULL != pPkt->pInternalData)
{
wpalMemoryFree(pPkt->pInternalData);
}
vosStatus = vos_pkt_return_packet(WPAL_TO_VOS_PKT(pPkt));
//With VOSS support, we can cast between wpt_status and VOS_STATUS
return (wpt_status)vosStatus;
}/*wpalPacketFree*/
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;
}
/*===========================================================================
FUNCTION WLANBAP_DeInitLinkSupervision
DESCRIPTION
This API will be called when Link Supervision module is to be stopped after disconnected at BAP
PARAMETERS
btampHandle: The BT-AMP PAL handle returned in WLANBAP_GetNewHndl.
RETURN VALUE
The result code associated with performing the operation
VOS_STATUS_E_INVAL: Input parameters are invalid
VOS_STATUS_E_FAULT: BAP handle is NULL
VOS_STATUS_SUCCESS: Everything is good :)
SIDE EFFECTS
============================================================================*/
VOS_STATUS
WLANBAP_DeInitLinkSupervision
(
ptBtampHandle btampHandle
)
{
VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
ptBtampContext pBtampCtx = (ptBtampContext) btampHandle;
if ( NULL == pBtampCtx)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Invalid BAP handle value in %s", __FUNCTION__);
return VOS_STATUS_E_FAULT;
}
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"In: %s", __FUNCTION__);
vosStatus = WLANBAP_StopLinkSupervisionTimer(pBtampCtx);
/*Free the vos packet*/
if ( pBtampCtx->lsRepPacket )
{
vosStatus = vos_pkt_return_packet(pBtampCtx->lsRepPacket);
pBtampCtx->lsRepPacket = NULL;
}
if ( pBtampCtx->lsReqPacket )
{
vosStatus = vos_pkt_return_packet(pBtampCtx->lsReqPacket);
pBtampCtx->lsReqPacket = NULL;
}
return vosStatus;
}
//TL call this function on Rx frames, should only be EAPOL frames
VOS_STATUS bapRsnRxCallback( v_PVOID_t pv, vos_pkt_t *pPacket )
{
//Callback to auth or supp FSM's handler
VOS_ASSERT( bapRsnFsmRxFrameHandler );
if( bapRsnFsmRxFrameHandler )
{
bapRsnFsmRxFrameHandler( pv, pPacket );
}
else
{
//done
vos_pkt_return_packet( pPacket );
}
return ( VOS_STATUS_SUCCESS );
}
VOS_STATUS bapRsnRxCallback( v_PVOID_t pv, vos_pkt_t *pPacket )
{
//
VOS_ASSERT( bapRsnFsmRxFrameHandler );
if( bapRsnFsmRxFrameHandler )
{
bapRsnFsmRxFrameHandler( pv, pPacket );
}
else
{
//
vos_pkt_return_packet( pPacket );
}
return ( VOS_STATUS_SUCCESS );
}
/**============================================================================
@brief hdd_tx_low_resource_cbk() - Callback function invoked in the
case where VOS packets are not available at the time of the call to get
packets. This callback function is invoked by VOS when packets are
available.
@param pVosPacket : [in] pointer to VOS packet
@param userData : [in] opaque user data that was passed initially
@return : VOS_STATUS_E_FAILURE if any errors encountered,
: VOS_STATUS_SUCCESS otherwise
=============================================================================*/
VOS_STATUS hdd_tx_low_resource_cbk( vos_pkt_t *pVosPacket,
v_VOID_t *userData )
{
VOS_STATUS status;
v_SINT_t i = 0;
v_SIZE_t size = 0;
hdd_adapter_t* pAdapter = (hdd_adapter_t *)userData;
if(pAdapter == NULL)
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: HDD adapter context is Null", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
//Return the packet to VOS. We just needed to know that VOS is out of low resource
//situation. Here we will only signal TL that there is a pending data for a STA.
//VOS packet will be requested (if needed) when TL comes back to fetch data.
vos_pkt_return_packet( pVosPacket );
pAdapter->isVosOutOfResource = VOS_FALSE;
//Indicate to TL that there is pending data if a queue is non empty
for( i=NUM_TX_QUEUES-1; i>=0; --i )
{
size = 0;
hdd_list_size( &pAdapter->wmm_tx_queue[i], &size );
if ( size > 0 )
{
status = WLANTL_STAPktPending( (WLAN_HDD_GET_CTX(pAdapter))->pvosContext,
(WLAN_HDD_GET_STATION_CTX_PTR(pAdapter))->conn_info.staId [0],
(WLANTL_ACEnumType)i );
if( !VOS_IS_STATUS_SUCCESS( status ) )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure in indicating pkt to TL for ac=%d", __FUNCTION__,i);
}
}
}
return VOS_STATUS_SUCCESS;
}
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 );
}
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 );
}
int wlan_queue_logpkt_for_app(vos_pkt_t *pPacket, uint32 pkt_type)
{
VOS_STATUS status = VOS_STATUS_E_FAILURE;
if (pPacket == NULL) {
pr_err("%s: Null param", __func__);
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
if (gwlan_logging.is_active == false) {
/*return all packets queued*/
wlan_logging_flush_pkt_queue();
/*return currently received pkt*/
vos_pkt_return_packet(pPacket);
return VOS_STATUS_E_FAILURE;
}
switch (pkt_type) {
case LOG_PKT_TYPE_DATA_MGMT:
status = wlan_queue_data_mgmt_pkt_for_app(pPacket);
break;
case LOG_PKT_TYPE_FW_LOG:
status = wlan_queue_fw_log_pkt_for_app(pPacket);
break;
default:
pr_info("%s: Unknown pkt received %d", __func__, pkt_type);
status = VOS_STATUS_E_INVAL;
break;
};
return status;
}
/*---------------------------------------------------------------------------
wpalPacketAlloc – Allocate a wpt_packet from PAL.
Param:
pktType – specify the type of wpt_packet to allocate
nPktSize - packet size
Return:
A pointer to the wpt_packet. NULL means fail.
---------------------------------------------------------------------------*/
wpt_packet * wpalPacketAlloc(wpt_packet_type pktType, wpt_uint32 nPktSize,
wpalPacketLowPacketCB rxLowCB, void *usrData)
{
VOS_STATUS vosStatus = VOS_STATUS_E_FAILURE;
wpt_packet* pPkt = NULL;
vos_pkt_t* pVosPkt = NULL;
void* pData = NULL;
v_U16_t allocLen;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
switch (pktType)
{
case eWLAN_PAL_PKT_TYPE_TX_802_11_MGMT:
vosStatus = vos_pkt_get_packet(&pVosPkt, VOS_PKT_TYPE_TX_802_11_MGMT,
nPktSize, 1, VOS_FALSE,
NULL, NULL /*no callback*/);
break;
case eWLAN_PAL_PKT_TYPE_RX_RAW:
/* Set the wpalPacketAvailableCB before we try to get a VOS
* packet from the 'free list' and reset it if vos_pkt_get_packet()
* returns a valid packet. This order is required to avoid the
* race condition:
* 1. The below call to vos_pkt_get_packet() in RX_Thread determines
* that no more packets are available in the 'free list' and sets
* the low resource callbacks.
* 2. in parallel vos_pkt_return_packet() is called in MC_Thread for a
* Management frame before wpalPacketAlloc() gets a chance to set
* wpalPacketAvailableCB and since the 'low resource callbacks'
* are set the callback function - wpalPacketRXLowResourceCB is
* executed,but since wpalPacketAvailableCB is still NULL the low
* resource recovery fails.
*/
wpalPacketAvailableCB = rxLowCB;
vosStatus = vos_pkt_get_packet(&pVosPkt, VOS_PKT_TYPE_RX_RAW,
nPktSize, 1, VOS_FALSE,
wpalPacketRXLowResourceCB, usrData);
#ifndef FEATURE_R33D
/* Reserve the entire raw rx buffer for DXE */
if( vosStatus == VOS_STATUS_SUCCESS )
{
wpalPacketAvailableCB = NULL;
vosStatus = vos_pkt_reserve_head_fast( pVosPkt, &pData, nPktSize );
}
#endif /* FEATURE_R33D */
if((NULL != pVosPkt) && (VOS_STATUS_E_RESOURCES != vosStatus))
{
vos_pkt_get_packet_length(pVosPkt, &allocLen);
if (nPktSize != allocLen)
{
WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR,
"RX packet alloc has problem, discard this frame, Len %d", allocLen);
vos_pkt_return_packet(pVosPkt);
return NULL;
}
}
break;
default:
WPAL_TRACE(eWLAN_MODULE_PAL, eWLAN_PAL_TRACE_LEVEL_ERROR,
" try to allocate unsupported packet type (%d)", pktType);
break;
}
if(VOS_IS_STATUS_SUCCESS(vosStatus))
{
pPkt = (wpt_packet *)pVosPkt;
}
return pPkt;
}/*wpalPacketAlloc*/
/* Tx callback function for LS packet */
static VOS_STATUS WLANBAP_TxLinkSupervisionCB
(
v_PVOID_t pvosGCtx,
vos_pkt_t *pPacket,
VOS_STATUS retStatus
)
{
VOS_STATUS vosStatus;
ptBtampContext bapContext; /* Holds the btampContext value returned */
vos_pkt_t *pLSPacket;
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"TxCompCB reached for LS Pkt");
/* Get the BT AMP context from the global */
bapContext = gpBtampCtx;
if (!VOS_IS_STATUS_SUCCESS (retStatus))
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"TxCompCB:Transmit status Failure");
}
if ( pPacket == NULL )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"WLANBAP_TxCompCB bad input\n" );
return VOS_STATUS_E_FAILURE;
}
/* Return the packet & reallocate */
if( pPacket == bapContext->lsReqPacket )
{
vosStatus = WLANBAP_AcquireLSPacket( bapContext, &pLSPacket,32, TRUE );
if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
bapContext->lsReqPacket = pLSPacket;
}
else
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"%s:AcquireLSPacket failed\n",__FUNCTION__);
bapContext->lsReqPacket = NULL;
return vosStatus;
}
}
else
{
vosStatus = WLANBAP_AcquireLSPacket( bapContext, &pLSPacket,32, FALSE );
if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
bapContext->lsRepPacket = pLSPacket;
}
else
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"%s:AcquireLSPacket failed\n",__FUNCTION__);
bapContext->lsRepPacket = NULL;
return vosStatus;
}
}
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"%s:Returned Vos Packet:%x\n",__FUNCTION__, pPacket );
vos_pkt_return_packet( pPacket );
return (VOS_STATUS_SUCCESS );
}
static VOS_STATUS bapRsnTxCompleteCallback( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket, VOS_STATUS retStatus )
{
int retVal;
ptBtampContext btampContext; // use btampContext value
tCsrRoamSetKey setKeyInfo;
tSuppRsnFsm *fsm;
if (NULL == pvosGCtx)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"pvosGCtx is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
btampContext = VOS_GET_BAP_CB(pvosGCtx);
if (NULL == btampContext)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"btampContext is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
fsm = &btampContext->uFsm.suppFsm;
if (NULL == fsm)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"fsm is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
//If we get a disconect from upper layer before getting the pkt from TL the
//bapRsnFsmTxCmpHandler could be NULL
//VOS_ASSERT( bapRsnFsmTxCmpHandler );
if( bapRsnFsmTxCmpHandler )
{
//Change the state
//Call auth or supp FSM's handler
bapRsnFsmTxCmpHandler( pvosGCtx, pPacket, retStatus );
}
else
{
vos_pkt_return_packet( pPacket );
return (VOS_STATUS_SUCCESS );
}
//fsm->suppCtx->ptk contains the 3 16-bytes keys. We need the last one.
/*
We will move the Set key to EAPOL Completion handler. We found a race condition betweem
sending EAPOL frame and setting Key */
if (BAP_SET_RSN_KEY == gReadToSetKey) {
vos_mem_zero( &setKeyInfo, sizeof( tCsrRoamSetKey ) );
setKeyInfo.encType = eCSR_ENCRYPT_TYPE_AES;
setKeyInfo.keyDirection = eSIR_TX_RX;
vos_mem_copy( setKeyInfo.peerMac, fsm->suppCtx->authMac, sizeof( tAniMacAddr ) );
setKeyInfo.paeRole = 0; //this is a supplicant
setKeyInfo.keyId = 0; //always
setKeyInfo.keyLength = CSR_AES_KEY_LEN;
vos_mem_copy( setKeyInfo.Key, (v_U8_t *)fsm->suppCtx->ptk + (2 * CSR_AES_KEY_LEN ), CSR_AES_KEY_LEN );
if( !VOS_IS_STATUS_SUCCESS( bapSetKey( fsm->ctx->pvosGCtx, &setKeyInfo ) ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, " Supp: gotoStateStaKeySet fail to set key\n" );
retVal = ANI_ERROR;
}
gReadToSetKey = BAP_RESET_RSN_KEY;
}
return (VOS_STATUS_SUCCESS );
}
static int send_data_mgmt_log_pkt_to_user(void)
{
int ret = -1;
int extra_header_len, nl_payload_len;
struct sk_buff *skb = NULL;
static int nlmsg_seq;
vos_pkt_t *current_pkt;
vos_pkt_t *next_pkt;
VOS_STATUS status = VOS_STATUS_E_FAILURE;
unsigned long flags;
tAniNlLogHdr msg_header;
do {
spin_lock_irqsave(&gwlan_logging.data_mgmt_pkt_lock, flags);
if (!gwlan_logging.data_mgmt_pkt_queue) {
spin_unlock_irqrestore(
&gwlan_logging.data_mgmt_pkt_lock, flags);
return -EIO;
}
/* pick first pkt from queued chain */
current_pkt = gwlan_logging.data_mgmt_pkt_queue;
/* get the pointer to the next packet in the chain */
status = vos_pkt_walk_packet_chain(current_pkt, &next_pkt,
TRUE);
/* both "success" and "empty" are acceptable results */
if (!((status == VOS_STATUS_SUCCESS) ||
(status == VOS_STATUS_E_EMPTY))) {
++gwlan_logging.pkt_drop_cnt;
spin_unlock_irqrestore(
&gwlan_logging.data_mgmt_pkt_lock, flags);
pr_err("%s: Failure walking packet chain", __func__);
return -EIO;
}
/* update queue head with next pkt ptr which could be NULL */
gwlan_logging.data_mgmt_pkt_queue = next_pkt;
--gwlan_logging.data_mgmt_pkt_qcnt;
spin_unlock_irqrestore(&gwlan_logging.data_mgmt_pkt_lock, flags);
status = vos_pkt_get_os_packet(current_pkt, (v_VOID_t **)&skb,
TRUE);
if (!VOS_IS_STATUS_SUCCESS(status)) {
++gwlan_logging.pkt_drop_cnt;
pr_err("%s: Failure extracting skb from vos pkt",
__func__);
return -EIO;
}
/*return vos pkt since skb is already detached */
vos_pkt_return_packet(current_pkt);
extra_header_len = sizeof(msg_header.radio) + sizeof(tAniHdr) +
sizeof(msg_header.frameSize);
nl_payload_len = NLMSG_ALIGN(extra_header_len + skb->len);
msg_header.nlh.nlmsg_type = ANI_NL_MSG_LOG;
msg_header.nlh.nlmsg_len = nl_payload_len;
msg_header.nlh.nlmsg_flags = NLM_F_REQUEST;
msg_header.nlh.nlmsg_pid = 0;
msg_header.nlh.nlmsg_seq = nlmsg_seq++;
msg_header.radio = 0;
msg_header.wmsg.type = ANI_NL_MSG_LOG_PKT_TYPE;
msg_header.wmsg.length = skb->len + sizeof(uint32);
msg_header.frameSize = WLAN_MGMT_LOGGING_FRAMESIZE_128BYTES;
if (unlikely(skb_headroom(skb) < sizeof(msg_header))) {
pr_err("VPKT [%d]: Insufficient headroom, head[%p],"
" data[%p], req[%zu]", __LINE__, skb->head,
skb->data, sizeof(msg_header));
return -EIO;
}
vos_mem_copy(skb_push(skb, sizeof(msg_header)), &msg_header,
sizeof(msg_header));
ret = nl_srv_bcast(skb);
if (ret < 0) {
pr_info("%s: Send Failed %d drop_count = %u\n",
__func__, ret, ++gwlan_logging.pkt_drop_cnt);
} else {
ret = 0;
}
} while (next_pkt);
return ret;
}
/**============================================================================
@brief hdd_tx_fetch_packet_cbk() - Callback function invoked by TL to
fetch a packet for transmission.
@param vosContext : [in] pointer to VOS context
@param staId : [in] Station for which TL is requesting a pkt
@param ac : [in] access category requested by TL
@param pVosPacket : [out] pointer to VOS packet packet pointer
@param pPktMetaInfo : [out] pointer to meta info for the pkt
@return : VOS_STATUS_E_EMPTY if no packets to transmit
: VOS_STATUS_E_FAILURE if any errors encountered
: VOS_STATUS_SUCCESS otherwise
===========================================================================*/
VOS_STATUS hdd_tx_fetch_packet_cbk( v_VOID_t *vosContext,
v_U8_t *pStaId,
WLANTL_ACEnumType ac,
vos_pkt_t **ppVosPacket,
WLANTL_MetaInfoType *pPktMetaInfo )
{
VOS_STATUS status = VOS_STATUS_E_FAILURE;
hdd_adapter_t *pAdapter = NULL;
hdd_context_t *pHddCtx = NULL;
hdd_list_node_t *anchor = NULL;
skb_list_node_t *pktNode = NULL;
struct sk_buff *skb = NULL;
vos_pkt_t *pVosPacket = NULL;
v_MACADDR_t* pDestMacAddress = NULL;
v_TIME_t timestamp;
WLANTL_ACEnumType newAc;
v_SIZE_t size = 0;
tANI_U8 acAdmitted, i;
//Sanity check on inputs
if ( ( NULL == vosContext ) ||
( NULL == pStaId ) ||
( NULL == ppVosPacket ) ||
( NULL == pPktMetaInfo ) )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Null Params being passed", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
//Get the HDD context.
pHddCtx = (hdd_context_t *)vos_get_context( VOS_MODULE_ID_HDD, vosContext );
if(pHddCtx == NULL)
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: HDD adapter context is Null", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
pAdapter = pHddCtx->sta_to_adapter[*pStaId];
if( NULL == pAdapter )
{
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
++pAdapter->hdd_stats.hddTxRxStats.txFetched;
*ppVosPacket = NULL;
//Make sure the AC being asked for is sane
if( ac >= WLANTL_MAX_AC || ac < 0)
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Invalid AC %d passed by TL", __FUNCTION__, ac);
return VOS_STATUS_E_FAILURE;
}
++pAdapter->hdd_stats.hddTxRxStats.txFetchedAC[ac];
#ifdef HDD_WMM_DEBUG
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,"%s: AC %d passed by TL", __FUNCTION__, ac);
#endif // HDD_WMM_DEBUG
// We find an AC with packets
// or we determine we have no more packets to send
// HDD is not allowed to change AC.
// has this AC been admitted? or
// To allow EAPOL packets when not authenticated
if (unlikely((0==pAdapter->hddWmmStatus.wmmAcStatus[ac].wmmAcAccessAllowed) &&
(WLAN_HDD_GET_STATION_CTX_PTR(pAdapter))->conn_info.uIsAuthenticated))
{
++pAdapter->hdd_stats.hddTxRxStats.txFetchEmpty;
#ifdef HDD_WMM_DEBUG
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
"%s: no packets pending", __FUNCTION__);
#endif // HDD_WMM_DEBUG
return VOS_STATUS_E_FAILURE;
}
// do we have any packets pending in this AC?
hdd_list_size( &pAdapter->wmm_tx_queue[ac], &size );
if( size > 0 )
{
// yes, so process it
#ifdef HDD_WMM_DEBUG
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
"%s: AC %d has packets pending", __FUNCTION__, ac);
#endif // HDD_WMM_DEBUG
}
else
{
++pAdapter->hdd_stats.hddTxRxStats.txFetchEmpty;
#ifdef HDD_WMM_DEBUG
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
"%s: no packets pending", __FUNCTION__);
#endif // HDD_WMM_DEBUG
return VOS_STATUS_E_FAILURE;
}
//Get the vos packet. I don't want to dequeue and enqueue again if we are out of VOS resources
//This simplifies the locking and unlocking of Tx queue
status = vos_pkt_wrap_data_packet( &pVosPacket,
VOS_PKT_TYPE_TX_802_3_DATA,
NULL, //OS Pkt is not being passed
hdd_tx_low_resource_cbk,
pAdapter );
if (status == VOS_STATUS_E_ALREADY || status == VOS_STATUS_E_RESOURCES)
{
//Remember VOS is in a low resource situation
pAdapter->isVosOutOfResource = VOS_TRUE;
++pAdapter->hdd_stats.hddTxRxStats.txFetchLowResources;
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,"%s: VOSS in Low Resource scenario", __FUNCTION__);
//TL will now think we have no more packets in this AC
return VOS_STATUS_E_FAILURE;
}
//Remove the packet from the queue
spin_lock_bh(&pAdapter->wmm_tx_queue[ac].lock);
status = hdd_list_remove_front( &pAdapter->wmm_tx_queue[ac], &anchor );
spin_unlock_bh(&pAdapter->wmm_tx_queue[ac].lock);
if(VOS_STATUS_SUCCESS == status)
{
//If success then we got a valid packet from some AC
pktNode = list_entry(anchor, skb_list_node_t, anchor);
skb = pktNode->skb;
}
else
{
++pAdapter->hdd_stats.hddTxRxStats.txFetchDequeueError;
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN, "%s: Error in de-queuing "
"skb from Tx queue status = %d", __FUNCTION__, status );
vos_pkt_return_packet(pVosPacket);
return VOS_STATUS_E_FAILURE;
}
//Attach skb to VOS packet.
status = vos_pkt_set_os_packet( pVosPacket, skb );
if (status != VOS_STATUS_SUCCESS)
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,"%s: Error attaching skb", __FUNCTION__);
vos_pkt_return_packet(pVosPacket);
++pAdapter->stats.tx_dropped;
++pAdapter->hdd_stats.hddTxRxStats.txFetchDequeueError;
kfree_skb(skb);
return VOS_STATUS_E_FAILURE;
}
//Just being paranoid. To be removed later
if(pVosPacket == NULL)
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,"%s: VOS packet returned by VOSS is NULL", __FUNCTION__);
++pAdapter->stats.tx_dropped;
++pAdapter->hdd_stats.hddTxRxStats.txFetchDequeueError;
kfree_skb(skb);
return VOS_STATUS_E_FAILURE;
}
//Return VOS packet to TL;
*ppVosPacket = pVosPacket;
//Fill out the meta information needed by TL
//FIXME This timestamp is really the time stamp of wrap_data_packet
vos_pkt_get_timestamp( pVosPacket, ×tamp );
pPktMetaInfo->usTimeStamp = (v_U16_t)timestamp;
if(pAdapter->sessionCtx.station.conn_info.uIsAuthenticated == VOS_TRUE)
pPktMetaInfo->ucIsEapol = 0;
else
pPktMetaInfo->ucIsEapol = hdd_IsEAPOLPacket( pVosPacket ) ? 1 : 0;
#ifdef FEATURE_WLAN_WAPI
// Override usIsEapol value when its zero for WAPI case
pPktMetaInfo->ucIsWai = hdd_IsWAIPacket( pVosPacket ) ? 1 : 0;
#endif /* FEATURE_WLAN_WAPI */
if ((HDD_WMM_USER_MODE_NO_QOS == pHddCtx->cfg_ini->WmmMode) ||
(!pAdapter->hddWmmStatus.wmmQap))
{
// either we don't want QoS or the AP doesn't support QoS
pPktMetaInfo->ucUP = 0;
pPktMetaInfo->ucTID = 0;
}
else
{
/* 1. Check if ACM is set for this AC
* 2. If set, check if this AC had already admitted
* 3. If not already admitted, downgrade the UP to next best UP */
if(!pAdapter->hddWmmStatus.wmmAcStatus[ac].wmmAcAccessRequired ||
pAdapter->hddWmmStatus.wmmAcStatus[ac].wmmAcTspecValid)
{
pPktMetaInfo->ucUP = pktNode->userPriority;
pPktMetaInfo->ucTID = pPktMetaInfo->ucUP;
}
else
{
//Downgrade the UP
acAdmitted = pAdapter->hddWmmStatus.wmmAcStatus[ac].wmmAcTspecValid;
newAc = WLANTL_AC_BK;
for (i=ac-1; i>0; i--)
{
if (pAdapter->hddWmmStatus.wmmAcStatus[i].wmmAcAccessRequired == 0)
{
newAc = i;
break;
}
}
pPktMetaInfo->ucUP = hddWmmAcToHighestUp[newAc];
pPktMetaInfo->ucTID = pPktMetaInfo->ucUP;
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_INFO_LOW,"Downgrading UP %d to UP %d ", pktNode->userPriority, pPktMetaInfo->ucUP);
}
}
pPktMetaInfo->ucType = 0; //FIXME Don't know what this is
pPktMetaInfo->ucDisableFrmXtl = 0; //802.3 frame so we need to xlate
if ( 1 < size )
{
pPktMetaInfo->bMorePackets = 1; //HDD has more packets to send
}
else
{
pPktMetaInfo->bMorePackets = 0;
}
//Extract the destination address from ethernet frame
pDestMacAddress = (v_MACADDR_t*)skb->data;
pPktMetaInfo->ucBcast = vos_is_macaddr_broadcast( pDestMacAddress ) ? 1 : 0;
pPktMetaInfo->ucMcast = vos_is_macaddr_group( pDestMacAddress ) ? 1 : 0;
// if we are in a backpressure situation see if we can turn the hose back on
if ( (pAdapter->isTxSuspended[ac]) &&
(size <= HDD_TX_QUEUE_LOW_WATER_MARK) )
{
++pAdapter->hdd_stats.hddTxRxStats.txFetchDePressured;
++pAdapter->hdd_stats.hddTxRxStats.txFetchDePressuredAC[ac];
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_WARN,
"%s: TX queue[%d] re-enabled", __FUNCTION__, ac);
pAdapter->isTxSuspended[ac] = VOS_FALSE;
netif_tx_wake_queue(netdev_get_tx_queue(pAdapter->dev,
skb_get_queue_mapping(skb) ));
}
// We're giving the packet to TL so consider it transmitted from
// a statistics perspective. We account for it here instead of
// when the packet is returned for two reasons. First, TL will
// manipulate the skb to the point where the len field is not
// accurate, leading to inaccurate byte counts if we account for
// it later. Second, TL does not provide any feedback as to
// whether or not the packet was successfully sent over the air,
// so the packet counts will be the same regardless of where we
// account for them
pAdapter->stats.tx_bytes += skb->len;
++pAdapter->stats.tx_packets;
++pAdapter->hdd_stats.hddTxRxStats.txFetchDequeued;
++pAdapter->hdd_stats.hddTxRxStats.txFetchDequeuedAC[ac];
if(pHddCtx->cfg_ini->thermalMitigationEnable)
{
if(mutex_lock_interruptible(&pHddCtx->tmInfo.tmOperationLock))
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,
"%s: Tm Lock fail", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
if(WLAN_HDD_TM_LEVEL_1 < pHddCtx->tmInfo.currentTmLevel)
{
if(0 == pHddCtx->tmInfo.txFrameCount)
{
/* Just recovered from sleep timeout */
pHddCtx->tmInfo.lastOpenTs = timestamp;
}
if(((timestamp - pHddCtx->tmInfo.lastOpenTs) > (pHddCtx->tmInfo.tmAction.txOperationDuration / 10)) &&
(pHddCtx->tmInfo.txFrameCount >= pHddCtx->tmInfo.tmAction.txBlockFrameCountThreshold))
{
spin_lock(&pAdapter->wmm_tx_queue[ac].lock);
/* During TX open duration, TX frame count is larger than threshold
* Block TX during Sleep time */
netif_tx_stop_all_queues(pAdapter->dev);
spin_unlock(&pAdapter->wmm_tx_queue[ac].lock);
pHddCtx->tmInfo.lastblockTs = timestamp;
if(VOS_TIMER_STATE_STOPPED == vos_timer_getCurrentState(&pHddCtx->tmInfo.txSleepTimer))
{
vos_timer_start(&pHddCtx->tmInfo.txSleepTimer, pHddCtx->tmInfo.tmAction.txSleepDuration);
}
}
else if(((timestamp - pHddCtx->tmInfo.lastOpenTs) > (pHddCtx->tmInfo.tmAction.txOperationDuration / 10)) &&
(pHddCtx->tmInfo.txFrameCount < pHddCtx->tmInfo.tmAction.txBlockFrameCountThreshold))
{
/* During TX open duration, TX frame count is less than threshold
* Reset count and timestamp to prepare next cycle */
pHddCtx->tmInfo.lastOpenTs = timestamp;
pHddCtx->tmInfo.txFrameCount = 0;
}
else
{
/* Do Nothing */
}
pHddCtx->tmInfo.txFrameCount++;
}
mutex_unlock(&pHddCtx->tmInfo.tmOperationLock);
}
#ifdef HDD_WMM_DEBUG
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,"%s: Valid VOS PKT returned to TL", __FUNCTION__);
#endif // HDD_WMM_DEBUG
return status;
}
/*----------------------------------------------------------------------------
* Function Declarations and Documentation
* -------------------------------------------------------------------------*/
VOS_STATUS
WLANBAP_AcquireLSPacket( ptBtampContext pBtampCtx, vos_pkt_t **ppPacket, v_U16_t size, tANI_BOOLEAN isLsReq )
{
VOS_STATUS vosStatus;
vos_pkt_t *pPacket;
WLANBAP_8023HeaderType w8023Header;
v_U8_t aucLLCHeader[WLANBAP_LLC_HEADER_LEN];
v_U16_t headerLength; /* The 802.3 frame length*/
v_U16_t protoType;
v_U8_t *pData = NULL;
if(isLsReq)
{
protoType = WLANTL_BT_AMP_TYPE_LS_REQ;
}
else
{
protoType = WLANTL_BT_AMP_TYPE_LS_REP;
}
//If success, vosTxLsPacket is the packet and pData points to the head.
vosStatus = vos_pkt_get_packet( &pPacket, VOS_PKT_TYPE_TX_802_11_MGMT,size, 1,
VOS_TRUE, NULL, NULL );
if( VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
vosStatus = vos_pkt_reserve_head( pPacket, (v_VOID_t *)&pData, size );
if( !VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"%s: failed to reserve size = %d\n",__FUNCTION__, size );
vos_pkt_return_packet( pPacket );
}
}
if( !VOS_IS_STATUS_SUCCESS( vosStatus ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"WLANBAP_LinkSupervisionTimerHandler failed to get vos_pkt\n" );
return vosStatus;
}
// Form the 802.3 header
vos_mem_copy( w8023Header.vDA, pBtampCtx->peer_mac_addr, VOS_MAC_ADDR_SIZE);
vos_mem_copy( w8023Header.vSA, pBtampCtx->self_mac_addr, VOS_MAC_ADDR_SIZE);
headerLength = WLANBAP_LLC_HEADER_LEN;
/* Now the 802.3 length field is big-endian?! */
w8023Header.usLenType = vos_cpu_to_be16(headerLength);
/* Now adjust the protocol type bytes*/
protoType = vos_cpu_to_be16( protoType);
/* Now form the LLC header */
vos_mem_copy(aucLLCHeader,
WLANBAP_LLC_HEADER,
sizeof(WLANBAP_LLC_HEADER));
vos_mem_copy(&aucLLCHeader[WLANBAP_LLC_OUI_OFFSET],
WLANBAP_BT_AMP_OUI,
WLANBAP_LLC_OUI_SIZE);
vos_mem_copy(&aucLLCHeader[WLANBAP_LLC_PROTO_TYPE_OFFSET],
&protoType, //WLANBAP_BT_AMP_TYPE_LS_REQ
WLANBAP_LLC_PROTO_TYPE_SIZE);
/* Push on the LLC header */
vos_pkt_push_head(pPacket,
aucLLCHeader,
WLANBAP_LLC_HEADER_LEN);
/* Push on the 802.3 header */
vos_pkt_push_head(pPacket, &w8023Header, sizeof(w8023Header));
*ppPacket = pPacket;
return vosStatus;
}
static VOS_STATUS bapRsnTxCompleteCallback( v_PVOID_t pvosGCtx, vos_pkt_t *pPacket, VOS_STATUS retStatus )
{
int retVal;
ptBtampContext btampContext; //
tCsrRoamSetKey setKeyInfo;
tSuppRsnFsm *fsm;
if (NULL == pvosGCtx)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"pvosGCtx is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
btampContext = VOS_GET_BAP_CB(pvosGCtx);
if (NULL == btampContext)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"btampContext is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
fsm = &btampContext->uFsm.suppFsm;
if (NULL == fsm)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"fsm is NULL in %s", __func__);
return VOS_STATUS_E_FAULT;
}
//
//
//
if( bapRsnFsmTxCmpHandler )
{
//
//
bapRsnFsmTxCmpHandler( pvosGCtx, pPacket, retStatus );
}
else
{
vos_pkt_return_packet( pPacket );
return (VOS_STATUS_SUCCESS );
}
//
/*
*/
if (BAP_SET_RSN_KEY == gReadToSetKey) {
vos_mem_zero( &setKeyInfo, sizeof( tCsrRoamSetKey ) );
setKeyInfo.encType = eCSR_ENCRYPT_TYPE_AES;
setKeyInfo.keyDirection = eSIR_TX_RX;
vos_mem_copy( setKeyInfo.peerMac, fsm->suppCtx->authMac, sizeof( tAniMacAddr ) );
setKeyInfo.paeRole = 0; //
setKeyInfo.keyId = 0; //
setKeyInfo.keyLength = CSR_AES_KEY_LEN;
vos_mem_copy( setKeyInfo.Key, (v_U8_t *)fsm->suppCtx->ptk + (2 * CSR_AES_KEY_LEN ), CSR_AES_KEY_LEN );
if( !VOS_IS_STATUS_SUCCESS( bapSetKey( fsm->ctx->pvosGCtx, &setKeyInfo ) ) )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR, " Supp: gotoStateStaKeySet fail to set key\n" );
retVal = ANI_ERROR;
}
gReadToSetKey = BAP_RESET_RSN_KEY;
}
return (VOS_STATUS_SUCCESS );
}
/*===========================================================================
FUNCTION WLANBAP_RxProcLsPkt
DESCRIPTION
This API will be called when Link Supervision frames are received at BAP
PARAMETERS
btampHandle: The BT-AMP PAL handle returned in WLANBAP_GetNewHndl.
pucAC: Pointer to return the access category
vosDataBuff: The data buffer containing the 802.3 frame to be
translated to BT HCI Data Packet
RETURN VALUE
The result code associated with performing the operation
VOS_STATUS_E_INVAL: Input parameters are invalid
VOS_STATUS_E_FAULT: BAP handle is NULL
VOS_STATUS_SUCCESS: Everything is good :)
SIDE EFFECTS
============================================================================*/
VOS_STATUS
WLANBAP_RxProcLsPkt
(
ptBtampHandle btampHandle,
v_U8_t phy_link_handle, /* Used by BAP to indentify the WLAN assoc. (StaId) */
v_U16_t RxProtoType, /* Protocol Type from the frame received */
vos_pkt_t *vosRxLsBuff
)
{
VOS_STATUS vosStatus;
ptBtampContext pBtampCtx = (ptBtampContext) btampHandle;
WLANBAP_8023HeaderType w8023Header;
v_SIZE_t HeaderLen = sizeof(w8023Header);
/*------------------------------------------------------------------------
Sanity check params
------------------------------------------------------------------------*/
if ( NULL == pBtampCtx)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Invalid BAP handle value in %s", __FUNCTION__);
return VOS_STATUS_E_FAULT;
}
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"In %s Received RxProtoType=%x", __FUNCTION__,RxProtoType);
vos_pkt_extract_data(vosRxLsBuff,0,(v_VOID_t*)&w8023Header,&HeaderLen);
if ( !(vos_mem_compare( w8023Header.vDA, pBtampCtx->self_mac_addr, VOS_MAC_ADDR_SIZE)
&& vos_mem_compare( w8023Header.vSA, pBtampCtx->peer_mac_addr, VOS_MAC_ADDR_SIZE)))
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"MAC address mismatch in %s", __FUNCTION__);
return VOS_STATUS_E_FAULT;
}
/*Free the vos packet*/
vosStatus = vos_pkt_return_packet( vosRxLsBuff );
if ( VOS_STATUS_SUCCESS != vosStatus)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Failed to free VOS packet in %s", __FUNCTION__);
return VOS_STATUS_E_FAULT;
}
/* Reset Link Supervision timer */
if (RxProtoType == WLANTL_BT_AMP_TYPE_LS_REP)
{
pBtampCtx->lsReqPktPending = FALSE;
pBtampCtx->retries = 0;
if (pBtampCtx->bapLinkSupervisionTimerInterval)
{
/* Restart the LS timer */
WLANBAP_StopLinkSupervisionTimer(pBtampCtx);
vosStatus = WLANBAP_StartLinkSupervisionTimer (pBtampCtx,
pBtampCtx->bapLinkSupervisionTimerInterval * WLANBAP_BREDR_BASEBAND_SLOT_TIME);
}
}
else if(RxProtoType == WLANTL_BT_AMP_TYPE_LS_REQ)
{
if (pBtampCtx->bapLinkSupervisionTimerInterval)
{
/* Restart the LS timer */
WLANBAP_StopLinkSupervisionTimer(pBtampCtx);
vosStatus = WLANBAP_StartLinkSupervisionTimer (pBtampCtx,
pBtampCtx->bapLinkSupervisionTimerInterval * WLANBAP_BREDR_BASEBAND_SLOT_TIME);
}
pBtampCtx->pPacket = pBtampCtx->lsRepPacket;
// Handle LS rep frame
vosStatus = WLANBAP_TxLinkSupervision( btampHandle, phy_link_handle, pBtampCtx->pPacket, WLANTL_BT_AMP_TYPE_LS_REP);
}
return vosStatus;
}
/*----------------------------------------------------------------------------
FUNCTION WLANBAP_TxCompCB
DESCRIPTION
The tx complete callback registered with TL.
TL will call this to notify the client when a transmission for a
packet has ended.
PARAMETERS
IN
pvosGCtx: pointer to the global vos context; a handle to
TL/HAL/PE/BAP/HDD control block can be extracted from
its context
vosDataBuff: pointer to the VOSS data buffer that was transmitted
wTxSTAtus: status of the transmission
RETURN VALUE
The result code associated with performing the operation
----------------------------------------------------------------------------*/
VOS_STATUS
WLANBAP_TxCompCB
(
v_PVOID_t pvosGCtx,
vos_pkt_t* vosDataBuff,
VOS_STATUS wTxSTAtus
)
{
VOS_STATUS vosStatus;
ptBtampHandle bapHdl; /* holds ptBtampHandle value returned */
ptBtampContext bapContext; /* Holds the btampContext value returned */
v_PVOID_t pHddHdl; /* Handle to return BSL context in */
v_PVOID_t pvlogLinkHandle = NULL;
v_U32_t value;
WLANBAP_HCIACLHeaderType hciACLHeader;
/* retrieve the BSL and BAP contexts */
/* I don't really know how to do this - in the general case. */
/* So, for now, I will just use something that works. */
/* (In general, I will have to keep a list of the outstanding transmit */
/* buffers, in order to determine which assoc they are with.) */
//vosStatus = WLANBAP_GetCtxFromStaId (
// ucSTAId, /* The StaId (used by TL, PE, and HAL) */
// &bapHdl, /* "handle" to return ptBtampHandle value in */
// &bapContext, /* "handle" to return ptBtampContext value in */
// &pHddHdl); /* "handle" to return BSL context in */
/* Temporarily we do the following*/
//bapHdl = &btampCtx;
bapHdl = (v_PVOID_t)gpBtampCtx;
/* Typecast the handle into a context. Works as we have only one link*/
bapContext = ((ptBtampContext) bapHdl);
/*------------------------------------------------------------------------
Sanity check params
------------------------------------------------------------------------*/
if ( NULL == vosDataBuff)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Invalid vosDataBuff value in %s", __FUNCTION__);
return VOS_STATUS_E_FAULT;
}
if ( NULL == bapContext)
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"Invalid bapContext value in %s", __FUNCTION__);
vos_pkt_return_packet( vosDataBuff );
return VOS_STATUS_E_FAULT;
}
pHddHdl = bapContext->pHddHdl;
vosStatus = VOS_STATUS_SUCCESS;
if ( VOS_STATUS_SUCCESS != vosStatus )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"Unable to retrieve BSL or BAP context from STA Id in WLANBAP_TxCompCB");
vos_pkt_return_packet( vosDataBuff );
return VOS_STATUS_E_FAULT;
}
/*Get the logical link handle from the vos user data*/
vos_pkt_get_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_BAP,
&pvlogLinkHandle);
value = (v_U32_t)pvlogLinkHandle;
hciACLHeader.logLinkHandle = value;
#ifdef BAP_DEBUG
/* Trace the bapContext referenced. */
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN BAP Context Monitor: bapContext value = %p in %s:%d. vosDataBuff=%p", bapContext, __FUNCTION__, __LINE__, vosDataBuff );
#endif //BAP_DEBUG
// Sanity check the log_link_handle value
// JEZ100722: Temporary changes.
if (BTAMP_VALID_LOG_LINK( hciACLHeader.logLinkHandle))
{
vos_atomic_increment_U32(
&bapContext->btampLogLinkCtx[hciACLHeader.logLinkHandle].uTxPktCompleted);
// &bapContext->btampLogLinkCtx[0].uTxPktCompleted);
// vos_atomic_increment_U32(
// &bapContext->btampLogLinkCtx[1].uTxPktCompleted);
} else
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_ERROR,
"In %s:%d: Invalid logical link handle: %d", __FUNCTION__, __LINE__, hciACLHeader.logLinkHandle);
}
/* Invoke the callback that BSL registered with me */
vosStatus = (*bapContext->pfnBtampTxCompCB)(
pHddHdl,
vosDataBuff,
wTxSTAtus);
return vosStatus;
} /* WLANBAP_TxCompCB */
/*----------------------------------------------------------------------------
FUNCTION WLANBAP_STARxCB
DESCRIPTION
The receive callback registered with TL.
TL will call this to notify the client when a packet was received
for a registered STA.
PARAMETERS
IN
pvosGCtx: pointer to the global vos context; a handle to
TL's or HDD's control block can be extracted from
its context
vosDataBuff: pointer to the VOSS data buffer that was received
(it may be a linked list)
ucSTAId: station id
pRxMetaInfo: meta info for the received packet(s)
RETURN VALUE
The result code associated with performing the operation
----------------------------------------------------------------------------*/
VOS_STATUS
WLANBAP_STARxCB
(
v_PVOID_t pvosGCtx,
vos_pkt_t* vosDataBuff,
v_U8_t ucSTAId,
WLANTL_RxMetaInfoType* pRxMetaInfo
)
{
VOS_STATUS vosStatus;
ptBtampHandle bapHdl; /* holds ptBtampHandle value returned */
ptBtampContext bapContext; /* Holds the btampContext value returned */
v_PVOID_t pHddHdl; /* Handle to return BSL context in */
ptBtampHandle btampHandle;
WLANBAP_8023HeaderType w8023Header;
v_U8_t aucLLCHeader[WLANBAP_LLC_HEADER_LEN];
v_U16_t protoType ;
v_SIZE_t llcHeaderLen = WLANBAP_LLC_HEADER_LEN ;
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"In WLANBAP_STARxCB");
/* Lookup the BSL and BAP contexts using the StaId */
vosStatus = WLANBAP_GetCtxFromStaId (
ucSTAId, /* The StaId (used by TL, PE, and HAL) */
&bapHdl, /* "handle" to return ptBtampHandle value in */
&bapContext, /* "handle" to return ptBtampContext value in */
&pHddHdl); /* "handle" to return BSL context in */
if ( VOS_STATUS_SUCCESS != vosStatus )
{
VOS_TRACE( VOS_MODULE_ID_BAP, VOS_TRACE_LEVEL_INFO,
"Unable to retrieve BSL or BAP context from STA Id in WLANBAP_STARxCB");
/* Drop packet */
vos_pkt_return_packet(vosDataBuff);
return VOS_STATUS_E_FAULT;
}
vosStatus = vos_pkt_extract_data( vosDataBuff, sizeof(w8023Header), (v_VOID_t *)aucLLCHeader,
&llcHeaderLen);
if ( NULL == aucLLCHeader/*LLC Header*/ )
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLANBAP_STARxCB:Cannot extract LLC header");
/* Drop packet */
vos_pkt_return_packet(vosDataBuff);
return VOS_STATUS_E_FAULT;
}
vos_mem_copy(&protoType,&aucLLCHeader[WLANBAP_LLC_PROTO_TYPE_OFFSET],WLANBAP_LLC_PROTO_TYPE_SIZE);
protoType = vos_be16_to_cpu(protoType);
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"%s: received : %d, => BAP",__FUNCTION__,
protoType);
if(WLANBAP_BT_AMP_TYPE_DATA == protoType)
{
if (bapContext->bapLinkSupervisionTimerInterval)
{
/* Reset Link Supervision timer */
//vosStatus = WLANBAP_StopLinkSupervisionTimer(bapContext);
//vosStatus = WLANBAP_StartLinkSupervisionTimer(bapContext,7000);
bapContext->dataPktPending = VOS_TRUE;//Indication for LinkSupervision module that data is pending
/* Invoke the callback that BSL registered with me */
vosStatus = (*bapContext->pfnBtamp_STARxCB)(
pHddHdl,
vosDataBuff,
pRxMetaInfo);
}
else
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_FATAL,
"WLANBAP_STARxCB:bapLinkSupervisionTimerInterval is 0");
/* Drop packet */
vos_pkt_return_packet(vosDataBuff);
}
}
else
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"%s: link Supervision packet received over TL: %d, => BAP",
__FUNCTION__,protoType);
btampHandle = (ptBtampHandle)bapContext;
vosStatus = WLANBAP_RxProcLsPkt(
btampHandle,
bapContext->phy_link_handle,
protoType,
vosDataBuff
);
}
return vosStatus;
} /* WLANBAP_STARxCB */
/**============================================================================
@brief hdd_rx_packet_cbk() - Receive callback registered with TL.
TL will call this to notify the HDD when one or more packets were
received for a registered STA.
@param vosContext : [in] pointer to VOS context
@param pVosPacketChain : [in] pointer to VOS packet chain
@param staId : [in] Station Id
@param pRxMetaInfo : [in] pointer to meta info for the received pkt(s)
@return : VOS_STATUS_E_FAILURE if any errors encountered,
: VOS_STATUS_SUCCESS otherwise
===========================================================================*/
VOS_STATUS hdd_rx_packet_cbk( v_VOID_t *vosContext,
vos_pkt_t *pVosPacketChain,
v_U8_t staId,
WLANTL_RxMetaInfoType* pRxMetaInfo )
{
hdd_adapter_t *pAdapter = NULL;
hdd_context_t *pHddCtx = NULL;
VOS_STATUS status = VOS_STATUS_E_FAILURE;
int rxstat;
struct sk_buff *skb = NULL;
vos_pkt_t* pVosPacket;
vos_pkt_t* pNextVosPacket;
//Sanity check on inputs
if ( ( NULL == vosContext ) ||
( NULL == pVosPacketChain ) ||
( NULL == pRxMetaInfo ) )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Null params being passed", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
pHddCtx = (hdd_context_t *)vos_get_context( VOS_MODULE_ID_HDD, vosContext );
if ( NULL == pHddCtx )
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: HDD adapter context is Null", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
pAdapter = pHddCtx->sta_to_adapter[staId];
if( NULL == pAdapter )
{
VOS_ASSERT(0);
return VOS_STATUS_E_FAILURE;
}
++pAdapter->hdd_stats.hddTxRxStats.rxChains;
// walk the chain until all are processed
pVosPacket = pVosPacketChain;
do
{
// get the pointer to the next packet in the chain
// (but don't unlink the packet since we free the entire chain later)
status = vos_pkt_walk_packet_chain( pVosPacket, &pNextVosPacket, VOS_FALSE);
// both "success" and "empty" are acceptable results
if (!((status == VOS_STATUS_SUCCESS) || (status == VOS_STATUS_E_EMPTY)))
{
++pAdapter->hdd_stats.hddTxRxStats.rxDropped;
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure walking packet chain", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
// Extract the OS packet (skb).
// Tell VOS to detach the OS packet from the VOS packet
status = vos_pkt_get_os_packet( pVosPacket, (v_VOID_t **)&skb, VOS_TRUE );
if(!VOS_IS_STATUS_SUCCESS( status ))
{
++pAdapter->hdd_stats.hddTxRxStats.rxDropped;
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure extracting skb from vos pkt", __FUNCTION__);
return VOS_STATUS_E_FAILURE;
}
if (WLAN_HDD_ADAPTER_MAGIC != pAdapter->magic)
{
VOS_TRACE(VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_FATAL,
"Magic cookie(%x) for adapter sanity verification is invalid", pAdapter->magic);
return eHAL_STATUS_FAILURE;
}
skb->dev = pAdapter->dev;
skb->protocol = eth_type_trans(skb, skb->dev);
skb->ip_summed = CHECKSUM_NONE;
++pAdapter->hdd_stats.hddTxRxStats.rxPackets;
++pAdapter->stats.rx_packets;
pAdapter->stats.rx_bytes += skb->len;
#ifdef WLAN_FEATURE_HOLD_RX_WAKELOCK
wake_lock_timeout(&pHddCtx->rx_wake_lock, HDD_WAKE_LOCK_DURATION);
#endif
rxstat = netif_rx_ni(skb);
if (NET_RX_SUCCESS == rxstat)
{
++pAdapter->hdd_stats.hddTxRxStats.rxDelivered;
}
else
{
++pAdapter->hdd_stats.hddTxRxStats.rxRefused;
}
// now process the next packet in the chain
pVosPacket = pNextVosPacket;
} while (pVosPacket);
//Return the entire VOS packet chain to the resource pool
status = vos_pkt_return_packet( pVosPacketChain );
if(!VOS_IS_STATUS_SUCCESS( status ))
{
VOS_TRACE( VOS_MODULE_ID_HDD, VOS_TRACE_LEVEL_ERROR,"%s: Failure returning vos pkt", __FUNCTION__);
}
pAdapter->dev->last_rx = jiffies;
return status;
}
