wlan: TL module fix for memory consumption in WLANTLC_CBType module.
Changed the WLANTL_STAClientType to a pointer of WLAN_MAX_STA_COUNT STAs
instead of an array.Memory is allocated dynamically for WLAN_NON32_STA_COUNT
at initialization and thereafter on per STA basis.
Change-Id: I51b4544ba0e7b9f058d53e1be5960c0475142f43
CRs-fixed: 439754
diff --git a/CORE/TL/inc/wlan_qct_tl.h b/CORE/TL/inc/wlan_qct_tl.h
index 81da974..75df0a2 100644
--- a/CORE/TL/inc/wlan_qct_tl.h
+++ b/CORE/TL/inc/wlan_qct_tl.h
@@ -137,7 +137,7 @@
/* Maximum number of station supported by TL, including BC. */
#define WLAN_MAX_STA_COUNT (HAL_NUM_STA)
-
+#define WLAN_NON32_STA_COUNT 14
/* The symbolic station ID return to HDD to specify the packet is bc/mc */
#define WLAN_RX_BCMC_STA_ID (WLAN_MAX_STA_COUNT + 1)
diff --git a/CORE/TL/src/wlan_qct_tl.c b/CORE/TL/src/wlan_qct_tl.c
index 253a593..aa23476 100644
--- a/CORE/TL/src/wlan_qct_tl.c
+++ b/CORE/TL/src/wlan_qct_tl.c
@@ -341,6 +341,8 @@
* -------------------------------------------------------------------------*/
#define WLAN_TL_INVALID_U_SIG 255
#define WLAN_TL_INVALID_B_SIG 255
+#define ENTER() VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO, "Enter:%s", __func__)
+
#define WLAN_TL_AC_ARRAY_2_MASK( _pSTA, _ucACMask, i ) \
do\
@@ -406,6 +408,40 @@
/*----------------------------------------------------------------------------
* Function Declarations and Documentation
* -------------------------------------------------------------------------*/
+/*==========================================================================
+
+ FUNCTION WLANTL_FreeClientMemory
+
+ DESCRIPTION
+ It frees up the memory allocated to all the STA clients in TLCB block
+ Can be called inside Close, Stop or when some FAULT occurs
+
+ DEPENDENCIES
+
+ PARAMETERS
+
+ IN
+ pClientSTA: Pointer to the global client pointer array
+
+ RETURN VALUE
+
+ SIDE EFFECTS
+
+============================================================================*/
+void WLANTL_FreeClientMemory
+(WLANTL_STAClientType* pClientSTA[WLAN_MAX_STA_COUNT])
+{
+ v_U32_t i = 0;
+ for(i =0; i < WLAN_MAX_STA_COUNT; i++)
+ {
+ if( NULL != pClientSTA[i] )
+ {
+ vos_mem_free(pClientSTA[i]);
+ }
+ pClientSTA[i] = NULL;
+ }
+ return;
+}
/*==========================================================================
@@ -445,6 +481,7 @@
WLANTL_CbType* pTLCb = NULL;
v_U8_t ucIndex;
tHalHandle smeContext;
+ v_U32_t i = 0;
#if defined WLAN_FEATURE_NEIGHBOR_ROAMING
VOS_STATUS status = VOS_STATUS_SUCCESS;
#endif
@@ -454,6 +491,7 @@
Sanity check
Extract TL control block
------------------------------------------------------------------------*/
+ ENTER();
vos_alloc_context( pvosGCtx, VOS_MODULE_ID_TL,
(void*)&pTLCb, sizeof(WLANTL_CbType));
@@ -485,24 +523,34 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:WLANTL_Open"));
- pTLCb->atlSTAClients = vos_mem_malloc(sizeof(WLANTL_STAClientType) * WLAN_MAX_STA_COUNT);
- if (NULL == pTLCb->atlSTAClients)
+ for ( i =0; i<WLAN_MAX_STA_COUNT; i++ )
{
- TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: StaClients allocation failed\n"));
- vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb);
- return VOS_STATUS_E_FAULT;
+ if ( i < WLAN_NON32_STA_COUNT )
+ {
+ pTLCb->atlSTAClients[i] = vos_mem_malloc(sizeof(WLANTL_STAClientType));
+ /* Allocating memory for LEGACY STA COUNT so as to avoid regression issues. */
+ if ( NULL == pTLCb->atlSTAClients[i] )
+ {
+ TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: StaClient allocation failed"));
+ WLANTL_FreeClientMemory(pTLCb->atlSTAClients);
+ vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb);
+ return VOS_STATUS_E_FAULT;
+ }
+ vos_mem_zero((v_VOID_t *) pTLCb->atlSTAClients[i], sizeof(WLANTL_STAClientType));
+ }
+ else
+ {
+ pTLCb->atlSTAClients[i] = NULL;
+ }
}
- vos_mem_zero((v_VOID_t *)pTLCb->atlSTAClients, sizeof(WLANTL_STAClientType) * WLAN_MAX_STA_COUNT);
-
pTLCb->reorderBufferPool = vos_mem_malloc(sizeof(WLANTL_REORDER_BUFFER_T) * WLANTL_MAX_BA_SESSION);
if (NULL == pTLCb->reorderBufferPool)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR, "WLAN TL: Reorder buffer allocation failed\n"));
- vos_mem_free(pTLCb->atlSTAClients);
+ WLANTL_FreeClientMemory(pTLCb->atlSTAClients);
vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb);
return VOS_STATUS_E_FAULT;
-
}
vos_mem_zero((v_VOID_t *)pTLCb->reorderBufferPool, sizeof(WLANTL_REORDER_BUFFER_T) * WLANTL_MAX_BA_SESSION);
@@ -511,8 +559,7 @@
for ( ucIndex = 0; ucIndex < WLANTL_MAX_AC ; ucIndex++)
{
- pTLCb->tlConfigInfo.ucAcWeights[ucIndex] =
- pTLConfig->ucAcWeights[ucIndex];
+ pTLCb->tlConfigInfo.ucAcWeights[ucIndex] = pTLConfig->ucAcWeights[ucIndex];
}
#ifdef WLAN_SOFTAP_FEATURE
@@ -555,7 +602,7 @@
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"Handoff support module init fail"));
- vos_mem_free(pTLCb->atlSTAClients);
+ WLANTL_FreeClientMemory(pTLCb->atlSTAClients);
vos_mem_free(pTLCb->reorderBufferPool);
vos_free_context(pvosGCtx, VOS_MODULE_ID_TL, pTLCb);
return status;
@@ -613,6 +660,7 @@
Sanity check
Extract TL control block
------------------------------------------------------------------------*/
+ ENTER();
pTLCb = VOS_GET_TL_CB(pvosGCtx);
if ( NULL == pTLCb )
{
@@ -694,6 +742,7 @@
Sanity check
Extract TL control block
------------------------------------------------------------------------*/
+ ENTER();
pTLCb = VOS_GET_TL_CB(pvosGCtx);
if ( NULL == pTLCb )
{
@@ -734,9 +783,12 @@
/*-------------------------------------------------------------------------
Clean client stations
-------------------------------------------------------------------------*/
- for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT ; ucIndex++)
+ for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT; ucIndex++)
{
- WLANTL_CleanSTA(&pTLCb->atlSTAClients[ucIndex], 1 /*empty all queues*/);
+ if ( NULL != pTLCb->atlSTAClients[ucIndex] )
+ {
+ WLANTL_CleanSTA(pTLCb->atlSTAClients[ucIndex], 1 /*empty all queues*/);
+ }
}
@@ -783,6 +835,7 @@
Sanity check
Extract TL control block
------------------------------------------------------------------------*/
+ ENTER();
pTLCb = VOS_GET_TL_CB(pvosGCtx);
if ( NULL == pTLCb )
{
@@ -820,7 +873,8 @@
"WLAN TL: WLANTL_Close"));
WLANTL_CleanCB(pTLCb, 1 /* empty queues/lists/pkts if any*/);
- vos_mem_free(pTLCb->atlSTAClients);
+ WLANTL_FreeClientMemory(pTLCb->atlSTAClients);
+
vos_mem_free(pTLCb->reorderBufferPool);
/*------------------------------------------------------------------------
@@ -865,7 +919,7 @@
Extract TL control block
------------------------------------------------------------------------*/
WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx);
-
+ WLANTL_STAClientType* pClientSTA = NULL;
if ( NULL == pTLCb )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
@@ -880,7 +934,8 @@
for ( ucIndex = 0; ucIndex < WLAN_MAX_TID; ucIndex++)
{
- if ( 0 != pTLCb->atlSTAClients[ucIndex].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucIndex];
+ if ( NULL != pClientSTA && 0 != pClientSTA->ucExists )
{
#ifdef WLAN_SOFTAP_VSTA_FEATURE
// if this station was not allocated resources to perform HW-based
@@ -888,12 +943,11 @@
// otherwise use the frame translation supplied by the client
if (!WDA_IsHwFrameTxTranslationCapable(pvosGCtx, ucIndex))
{
- pTLCb->atlSTAClients[ucIndex].wSTADesc.ucSwFrameTXXlation = 1;
+ pClientSTA->wSTADesc.ucSwFrameTXXlation = 1;
}
else
#endif
- pTLCb->atlSTAClients[ucIndex].wSTADesc.ucSwFrameTXXlation
- = enableFrameXlation;
+ pClientSTA->wSTADesc.ucSwFrameTXXlation = enableFrameXlation;
}
}
}
@@ -1116,6 +1170,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
#ifdef ANI_CHIPSET_VOLANS
v_U8_t ucTid = 0;/*Local variable to clear previous replay counters of STA on all TIDs*/
#endif
@@ -1124,6 +1179,7 @@
/*------------------------------------------------------------------------
Sanity check
------------------------------------------------------------------------*/
+ ENTER();
if (( NULL == pwSTADescType ) || ( NULL == pfnSTARx ) ||
( NULL == pfnSTAFetchPkt ))
{
@@ -1150,9 +1206,24 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 != pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucExists )
+ //Code for checking and allocating memory for new STA
+ if ( NULL == pTLCb->atlSTAClients[pwSTADescType->ucSTAId] ){
+ pTLCb->atlSTAClients[pwSTADescType->ucSTAId] = vos_mem_malloc(sizeof(WLANTL_STAClientType));
+ if ( NULL == pTLCb->atlSTAClients[pwSTADescType->ucSTAId] ){
+ TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL: STA Client memory allocation failed in WLANTL_RegisterSTAClient"));
+ return VOS_STATUS_E_FAILURE;
+ }
+ TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,
+ "WLAN TL: STA Client memory allocation in WLANTL_RegisterSTAClient"));
+ vos_mem_zero((v_VOID_t *) pTLCb->atlSTAClients[pwSTADescType->ucSTAId],sizeof(WLANTL_STAClientType));
+ }
+
+ //Assigning the pointer to local variable for easy access in future
+ pClientSTA = pTLCb->atlSTAClients[pwSTADescType->ucSTAId];
+ if ( 0 != pClientSTA->ucExists )
{
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucExists++;
+ pClientSTA->ucExists++;
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was already registered on WLANTL_RegisterSTAClient"));
return VOS_STATUS_E_EXISTS;
@@ -1164,42 +1235,35 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Registering STA Client ID: %d", pwSTADescType->ucSTAId ));
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].pfnSTARx = pfnSTARx;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].pfnSTAFetchPkt = pfnSTAFetchPkt;
+ pClientSTA->pfnSTARx = pfnSTARx;
+ pClientSTA->pfnSTAFetchPkt = pfnSTAFetchPkt;
/* Only register if different from NULL - TL default Tx Comp Cb will
release the vos packet */
if ( NULL != pfnSTATxComp )
{
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].pfnSTATxComp = pfnSTATxComp;
+ pClientSTA->pfnSTATxComp = pfnSTATxComp;
}
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].tlState = WLANTL_STA_INIT;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].tlPri =
- WLANTL_STA_PRI_NORMAL;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucSTAId =
- pwSTADescType->ucSTAId;
+ pClientSTA->tlState = WLANTL_STA_INIT;
+ pClientSTA->tlPri = WLANTL_STA_PRI_NORMAL;
+ pClientSTA->wSTADesc.ucSTAId = pwSTADescType->ucSTAId;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Registering STA Client ID: %d with UC %d and BC %d",
pwSTADescType->ucSTAId,
pwSTADescType->ucUcastSig, pwSTADescType->ucBcastSig));
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.wSTAType =
- pwSTADescType->wSTAType;
+ pClientSTA->wSTADesc.wSTAType = pwSTADescType->wSTAType;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucQosEnabled =
- pwSTADescType->ucQosEnabled;
+ pClientSTA->wSTADesc.ucQosEnabled = pwSTADescType->ucQosEnabled;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucAddRmvLLC =
- pwSTADescType->ucAddRmvLLC;
+ pClientSTA->wSTADesc.ucAddRmvLLC = pwSTADescType->ucAddRmvLLC;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucProtectedFrame =
- pwSTADescType->ucProtectedFrame;
+ pClientSTA->wSTADesc.ucProtectedFrame = pwSTADescType->ucProtectedFrame;
#ifdef FEATURE_WLAN_CCX
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucIsCcxSta =
- pwSTADescType->ucIsCcxSta;
+ pClientSTA->wSTADesc.ucIsCcxSta = pwSTADescType->ucIsCcxSta;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Registering STA Client ID: %d QoS %d Add LLC %d ProtFrame %d CcxSta %d",
@@ -1230,34 +1294,27 @@
}
#endif
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucSwFrameTXXlation =
- pwSTADescType->ucSwFrameTXXlation;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucSwFrameRXXlation =
- pwSTADescType->ucSwFrameRXXlation;
+ pClientSTA->wSTADesc.ucSwFrameTXXlation = pwSTADescType->ucSwFrameTXXlation;
+ pClientSTA->wSTADesc.ucSwFrameRXXlation = pwSTADescType->ucSwFrameRXXlation;
#ifdef FEATURE_WLAN_WAPI
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wSTADesc.ucIsWapiSta =
- pwSTADescType->ucIsWapiSta;
+ pClientSTA->wSTADesc.ucIsWapiSta = pwSTADescType->ucIsWapiSta;
#endif /* FEATURE_WLAN_WAPI */
- vos_copy_macaddr( &pTLCb->atlSTAClients[pwSTADescType->ucSTAId].
- wSTADesc.vSTAMACAddress, &pwSTADescType->vSTAMACAddress);
+ vos_copy_macaddr( &pClientSTA->wSTADesc.vSTAMACAddress, &pwSTADescType->vSTAMACAddress);
- vos_copy_macaddr( &pTLCb->atlSTAClients[pwSTADescType->ucSTAId].
- wSTADesc.vBSSIDforIBSS, &pwSTADescType->vBSSIDforIBSS);
+ vos_copy_macaddr( &pClientSTA->wSTADesc.vBSSIDforIBSS, &pwSTADescType->vBSSIDforIBSS);
- vos_copy_macaddr( &pTLCb->atlSTAClients[pwSTADescType->ucSTAId].
- wSTADesc.vSelfMACAddress, &pwSTADescType->vSelfMACAddress);
+ vos_copy_macaddr( &pClientSTA->wSTADesc.vSelfMACAddress, &pwSTADescType->vSelfMACAddress);
#ifdef ANI_CHIPSET_VOLANS
/* In volans release L replay check is done at TL */
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucIsReplayCheckValid =
- pwSTADescType-> ucIsReplayCheckValid;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ulTotalReplayPacketsDetected = 0;
+ pClientSTA->ucIsReplayCheckValid = pwSTADescType->ucIsReplayCheckValid;
+ pClientSTA->ulTotalReplayPacketsDetected = 0;
/*Clear replay counters of the STA on all TIDs*/
for(ucTid = 0; ucTid < WLANTL_MAX_TID ; ucTid++)
{
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ullReplayCounter[ucTid] = 0;
+ pClientSTA->ullReplayCounter[ucTid] = 0;
}
#endif
@@ -1267,50 +1324,48 @@
made in the main TL loop after the supported mask is properly
updated in the pending packets call
--------------------------------------------------------------------*/
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucCurrentAC = WLANTL_AC_VO;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucCurrentWeight = 0;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucServicedAC = WLANTL_AC_BK;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucEapolPktPending = 0;
+ pClientSTA->ucCurrentAC = WLANTL_AC_VO;
+ pClientSTA->ucCurrentWeight = 0;
+ pClientSTA->ucServicedAC = WLANTL_AC_BK;
+ pClientSTA->ucEapolPktPending = 0;
- vos_mem_zero( pTLCb->atlSTAClients[pwSTADescType->ucSTAId].aucACMask,
- sizeof(pTLCb->atlSTAClients[pwSTADescType->ucSTAId].aucACMask));
+ vos_mem_zero( pClientSTA->aucACMask, sizeof(pClientSTA->aucACMask));
- vos_mem_zero( &pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wUAPSDInfo,
- sizeof(pTLCb->atlSTAClients[pwSTADescType->ucSTAId].wUAPSDInfo));
+ vos_mem_zero( &pClientSTA->wUAPSDInfo, sizeof(pClientSTA->wUAPSDInfo));
/*--------------------------------------------------------------------
Reordering info and AMSDU de-aggregation
--------------------------------------------------------------------*/
- vos_mem_zero( pTLCb->atlSTAClients[pwSTADescType->ucSTAId].atlBAReorderInfo,
- sizeof(pTLCb->atlSTAClients[pwSTADescType->ucSTAId].atlBAReorderInfo[0])*
+ vos_mem_zero( pClientSTA->atlBAReorderInfo,
+ sizeof(pClientSTA->atlBAReorderInfo[0])*
WLAN_MAX_TID);
- vos_mem_zero( pTLCb->atlSTAClients[pwSTADescType->ucSTAId].aucMPDUHeader,
+ vos_mem_zero( pClientSTA->aucMPDUHeader,
WLANTL_MPDU_HEADER_LEN);
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucMPDUHeaderLen = 0;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].vosAMSDUChain = NULL;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].vosAMSDUChainRoot = NULL;
+ pClientSTA->ucMPDUHeaderLen = 0;
+ pClientSTA->vosAMSDUChain = NULL;
+ pClientSTA->vosAMSDUChainRoot = NULL;
/*--------------------------------------------------------------------
Stats info
--------------------------------------------------------------------*/
- vos_mem_zero( pTLCb->atlSTAClients[pwSTADescType->ucSTAId].auRxCount,
- sizeof(pTLCb->atlSTAClients[pwSTADescType->ucSTAId].auRxCount[0])*
+ vos_mem_zero( pClientSTA->auRxCount,
+ sizeof(pClientSTA->auRxCount[0])*
WLAN_MAX_TID);
- vos_mem_zero( pTLCb->atlSTAClients[pwSTADescType->ucSTAId].auTxCount,
- sizeof(pTLCb->atlSTAClients[pwSTADescType->ucSTAId].auRxCount[0])*
+ vos_mem_zero( pClientSTA->auTxCount,
+ sizeof(pClientSTA->auRxCount[0])*
WLAN_MAX_TID);
/* Initial RSSI is always reported as zero because TL doesnt have enough
data to calculate RSSI. So to avoid reporting zero, we are initializing
RSSI with RSSI saved in BssDescription during scanning. */
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].rssiAvg = rssi;
+ pClientSTA->rssiAvg = rssi;
/*Tx not suspended and station fully registered*/
vos_atomic_set_U8(
- &pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucTxSuspended, 0);
+ &pClientSTA->ucTxSuspended, 0);
/* Used until multiple station support will be added*/
pTLCb->ucRegisteredStaId = pwSTADescType->ucSTAId;
@@ -1324,31 +1379,31 @@
/*------------------------------------------------------------------------
Statistics info
-----------------------------------------------------------------------*/
- memset(&pTLCb->atlSTAClients[pwSTADescType->ucSTAId].trafficStatistics,
+ memset(&pClientSTA->trafficStatistics,
0, sizeof(WLANTL_TRANSFER_STA_TYPE));
/*------------------------------------------------------------------------
Start with the state suggested by client caller
-----------------------------------------------------------------------*/
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].tlState =
+ pClientSTA->tlState =
pwSTADescType->ucInitState;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucRxBlocked = 1;
+ pClientSTA->ucRxBlocked = 1;
/*-----------------------------------------------------------------------
After all the init is complete we can mark the existance flag
----------------------------------------------------------------------*/
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucExists++;
+ pClientSTA->ucExists++;
#ifdef WLAN_SOFTAP_FEATURE
//flow control fields init
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucLwmModeEnabled = FALSE;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].ucLwmEventReported = FALSE;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].bmuMemConsumed = 0;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].uIngress_length = 0;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].uBuffThresholdMax = WLANTL_STA_BMU_THRESHOLD_MAX;
+ pClientSTA->ucLwmModeEnabled = FALSE;
+ pClientSTA->ucLwmEventReported = FALSE;
+ pClientSTA->bmuMemConsumed = 0;
+ pClientSTA->uIngress_length = 0;
+ pClientSTA->uBuffThresholdMax = WLANTL_STA_BMU_THRESHOLD_MAX;
- pTLCb->atlSTAClients[pwSTADescType->ucSTAId].uLwmThreshold = WLANTL_STA_BMU_THRESHOLD_MAX / 3;
+ pClientSTA->uLwmThreshold = WLANTL_STA_BMU_THRESHOLD_MAX / 3;
//@@@ HDDSOFTAP does not queue unregistered packet for now
if ( WLAN_STA_SOFTAP != pwSTADescType->wSTAType )
@@ -1417,6 +1472,7 @@
v_U8_t ucIndex;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
+ ENTER();
/*------------------------------------------------------------------------
Sanity check
------------------------------------------------------------------------*/
@@ -1426,7 +1482,6 @@
"WLAN TL:Invalid station id requested on WLANTL_ClearSTAClient"));
return VOS_STATUS_E_FAULT;
}
-
/*------------------------------------------------------------------------
Extract TL control block
------------------------------------------------------------------------*/
@@ -1438,7 +1493,14 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_ClearSTAClient"));
@@ -1452,8 +1514,8 @@
}
#ifdef FEATURE_WLAN_TDLS
- /* decrement ucTdlsPeerCount only if it is non-zero */
- if(WLAN_STA_TDLS == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType
+ /* decrement ucTdlsPeerCount only if it is non-zero */
+ if(WLAN_STA_TDLS == pTLCb->atlSTAClients[ucSTAId]->wSTADesc.wSTAType
&& pTLCb->ucTdlsPeerCount)
pTLCb->ucTdlsPeerCount--;
#endif
@@ -1463,7 +1525,7 @@
------------------------------------------------------------------------*/
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Clearing STA Client ID: %d", ucSTAId ));
- WLANTL_CleanSTA(&pTLCb->atlSTAClients[ucSTAId], 1 /*empty packets*/);
+ WLANTL_CleanSTA(pTLCb->atlSTAClients[ucSTAId], 1 /*empty packets*/);
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Clearing STA Reset History RSSI and Region number"));
@@ -1556,7 +1618,14 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_ChangeSTAState"));
@@ -1569,9 +1638,9 @@
------------------------------------------------------------------------*/
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Changing state for STA Client ID: %d from %d to %d",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].tlState, tlSTAState));
+ ucSTAId, pTLCb->atlSTAClients[ucSTAId]->tlState, tlSTAState));
- pTLCb->atlSTAClients[ucSTAId].tlState = tlSTAState;
+ pTLCb->atlSTAClients[ucSTAId]->tlState = tlSTAState;
return VOS_STATUS_SUCCESS;
}/* WLANTL_ChangeSTAState */
@@ -1652,7 +1721,14 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN,
"WLAN TL:Station was not previously registered on WLANTL_GetSTAState"));
@@ -1662,7 +1738,7 @@
/*------------------------------------------------------------------------
Get STA state
------------------------------------------------------------------------*/
- *ptlSTAState = pTLCb->atlSTAClients[ucSTAId].tlState;
+ *ptlSTAState = pTLCb->atlSTAClients[ucSTAId]->tlState;
return VOS_STATUS_SUCCESS;
}/* WLANTL_GetSTAState */
@@ -1715,6 +1791,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
#ifdef WLAN_SOFTAP_FEATURE
vos_msg_t vosMsg;
#endif
@@ -1732,7 +1809,6 @@
"WLAN TL:Invalid station id requested on WLANTL_STAPktPending"));
return VOS_STATUS_E_FAULT;
}
-
/*------------------------------------------------------------------------
Extract TL control block and check existance
------------------------------------------------------------------------*/
@@ -1744,7 +1820,16 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_STAPktPending"));
@@ -1759,17 +1844,17 @@
--------------------------------------------------------------------*/
pTLCb->ucRegisteredStaId = ucSTAId;
- if( WLANTL_STA_CONNECTED == pTLCb->atlSTAClients[ucSTAId].tlState )
+ if( WLANTL_STA_CONNECTED == pClientSTA->tlState )
{ /* EAPOL_HI_PRIORITY : need to find out whether EAPOL is pending before
WLANTL_FetchPacket()/WLANTL_TxConn() is called.
change STA_AUTHENTICATED != tlState to CONNECTED == tlState
to make sure TL is indeed waiting for EAPOL.
Just in the case when STA got disconnected shortly after connectection */
- pTLCb->atlSTAClients[ucSTAId].ucEapolPktPending = 1;
+ pClientSTA->ucEapolPktPending = 1;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Packet pending indication for STA: %d AC: %d State: %d",
- ucSTAId, ucAc, pTLCb->atlSTAClients[ucSTAId].tlState);
+ ucSTAId, ucAc, pClientSTA->tlState);
}
/*-----------------------------------------------------------------------
@@ -1780,20 +1865,20 @@
-----------------------------------------------------------------------*/
#ifdef WLAN_SOFTAP_FEATURE
#ifdef FETURE_WLAN_TDLS
- if ((WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType) &&
+ if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) &&
!(vos_concurrent_sessions_running()) &&
!pTLCb->ucTdlsPeerCount)
{
#else
- if ((WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType) &&
+ if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) &&
!(vos_concurrent_sessions_running()))
{
#endif
#endif
- pTLCb->atlSTAClients[ucSTAId].aucACMask[ucAc] = 1;
+ pClientSTA->aucACMask[ucAc] = 1;
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 1);
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 1);
/*------------------------------------------------------------------------
Check if there are enough resources for transmission and tx is not
@@ -1873,6 +1958,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/*------------------------------------------------------------------------
@@ -1896,7 +1982,16 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_SetSTAPriority"));
@@ -1908,8 +2003,8 @@
------------------------------------------------------------------------*/
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Changing state for STA Pri ID: %d from %d to %d",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].tlPri, tlSTAPri));
- pTLCb->atlSTAClients[ucSTAId].tlPri = tlSTAPri;
+ ucSTAId, pClientSTA->tlPri, tlSTAPri));
+ pClientSTA->tlPri = tlSTAPri;
return VOS_STATUS_SUCCESS;
}/* WLANTL_SetSTAPriority */
@@ -2131,8 +2226,14 @@
Translate 802.3 frame to 802.11
------------------------------------------------------------------------*/
ucStaId = pTLCb->tlBAPClient.ucBAPSTAId;
- if (( 0 == pMetaInfo->ucDisableFrmXtl ) &&
- ( 0 != pTLCb->atlSTAClients[ucStaId].wSTADesc.ucSwFrameTXXlation ))
+ if ( NULL == pTLCb->atlSTAClients[ucStaId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+ if (( 0 == pMetaInfo->ucDisableFrmXtl ) &&
+ ( 0 != pTLCb->atlSTAClients[ucStaId]->wSTADesc.ucSwFrameTXXlation ))
{
vosStatus = WLANTL_Translate8023To80211Header( vosDataBuff, &vosStatus,
pTLCb, &ucStaId,
@@ -2159,9 +2260,9 @@
vosStatus = WDA_DS_BuildTxPacketInfo( pvosGCtx, vosDataBuff ,
&vDestMacAddr, pMetaInfo->ucDisableFrmXtl,
- &usPktLen, pTLCb->atlSTAClients[ucStaId].wSTADesc.ucQosEnabled,
+ &usPktLen, pTLCb->atlSTAClients[ucStaId]->wSTADesc.ucQosEnabled,
ucWDSEnabled, extraHeadSpace, pMetaInfo->ucType,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSelfMACAddress,
+ &pTLCb->atlSTAClients[ucStaId]->wSTADesc.vSelfMACAddress,
pMetaInfo->ucTID, 0 /* No ACK */, pMetaInfo->usTimeStamp,
pMetaInfo->ucIsEapol || pMetaInfo->ucIsWai, pMetaInfo->ucUP );
@@ -2262,6 +2363,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/*------------------------------------------------------------------------
@@ -2292,7 +2394,16 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_GetRssi"));
@@ -2304,19 +2415,19 @@
------------------------------------------------------------------------*/
if(pTLCb->isBMPS)
{
- *pRssi = pTLCb->atlSTAClients[ucSTAId].rssiAvgBmps;
+ *pRssi = pClientSTA->rssiAvgBmps;
/* Check If RSSI is zero because we are reading rssAvgBmps updated by HAL in
previous GetStatsRequest. It may be updated as zero by Hal because EnterBmps
might not have happend by that time. Hence reading the most recent Rssi
calcluated by TL*/
if(0 == *pRssi)
{
- *pRssi = pTLCb->atlSTAClients[ucSTAId].rssiAvg;
+ *pRssi = pClientSTA->rssiAvg;
}
}
else
{
- *pRssi = pTLCb->atlSTAClients[ucSTAId].rssiAvg;
+ *pRssi = pClientSTA->rssiAvg;
}
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
@@ -2374,6 +2485,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*------------------------------------------------------------------------
Sanity check
@@ -2402,8 +2514,16 @@
"Invalid TL pointer from pvosGCtx on WLANTL_GetLinkQuality"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"Station was not previously registered on WLANTL_GetLinkQuality"));
@@ -2413,7 +2533,7 @@
/*------------------------------------------------------------------------
Copy will not be locked; please read restriction
------------------------------------------------------------------------*/
- *puLinkQuality = pTLCb->atlSTAClients[ucSTAId].uLinkQualityAvg;
+ *puLinkQuality = pClientSTA->uLinkQualityAvg;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLANTL_GetLinkQuality for STA: %d LinkQuality: %d", ucSTAId, *puLinkQuality));
@@ -2480,7 +2600,14 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"Station was not previously registered on WLANTL_FlushStaTID"));
@@ -3095,7 +3222,14 @@
continue;
}
/* If this station is Not registered with TL */
- if ( 0 == pTLCb->atlSTAClients[STAId].ucExists )
+ if( NULL == pTLCb->atlSTAClients[STAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Station memory was not previously allocated on WLANTL_SuspendDataTx"));
+ STAId++;
+ continue;
+ }
+ if ( 0 == pTLCb->atlSTAClients[STAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_SuspendDataTx"));
@@ -3105,7 +3239,7 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Suspend request for station: %d", STAId));
- vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId].ucTxSuspended, 1);
+ vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId]->ucTxSuspended, 1);
}
STAId++;
} while ( STAId < WLAN_MAX_STA_COUNT );
@@ -3195,7 +3329,12 @@
/* Set to Resume for all stations */
for (STAId = 0; STAId < WLAN_MAX_STA_COUNT; STAId++)
- vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId].ucTxSuspended, 0);
+ {
+ if( NULL != pTLCb->atlSTAClients[STAId] )
+ {
+ vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId]->ucTxSuspended, 0);
+ }
+ }
}
else
{
@@ -3212,8 +3351,15 @@
STAId++;
continue;
}
+ if ( NULL == pTLCb->atlSTAClients[STAId])
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Station was not allocated memory on WLANTL_ResumeDataTx"));
+ STAId++;
+ continue;
+ }
/* If this station is Not registered with TL */
- if ( 0 == pTLCb->atlSTAClients[STAId].ucExists )
+ if ( 0 == pTLCb->atlSTAClients[STAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_ResumeDataTx"));
@@ -3223,7 +3369,7 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Resume request for station: %d", STAId));
- vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId].ucTxSuspended, 0);
+ vos_atomic_set_U8( &pTLCb->atlSTAClients[STAId]->ucTxSuspended, 0);
}
STAId++;
} while ( STAId < WLAN_MAX_STA_COUNT );
@@ -3394,7 +3540,14 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pTLCb->atlSTAClients[ucSTAId]->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_GetTxPktCount %d",
@@ -3409,7 +3562,7 @@
// "WLAN TL:Requested tx packet count for STA: %d, TID: %d",
// ucSTAId, ucTid);
- *puTxPktCount = pTLCb->atlSTAClients[ucSTAId].auTxCount[ucTid];
+ *puTxPktCount = pTLCb->atlSTAClients[ucSTAId]->auTxCount[ucTid];
return VOS_STATUS_SUCCESS;
}/* WLANTL_GetTxPktCount */
@@ -3457,6 +3610,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
/*------------------------------------------------------------------------
@@ -3487,8 +3641,16 @@
"WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_GetRxPktCount"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not previously registered on WLANTL_GetRxPktCount"));
@@ -3502,7 +3664,7 @@
"WLAN TL:Requested rx packet count for STA: %d, TID: %d",
ucSTAId, ucTid));
- *puRxPktCount = pTLCb->atlSTAClients[ucSTAId].auRxCount[ucTid];
+ *puRxPktCount = pClientSTA->auRxCount[ucTid];
return VOS_STATUS_SUCCESS;
}/* WLANTL_GetRxPktCount */
@@ -3576,6 +3738,7 @@
{
vos_pkt_t** pvosDataBuff = (vos_pkt_t**)ppFrameDataBuff;
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
v_U32_t uRemaining = uSize;
vos_pkt_t* vosRoot;
vos_pkt_t* vosTempBuf;
@@ -3796,9 +3959,10 @@
*--------------------------------------------------------------------*/
for ( i = 0; i < WLAN_MAX_STA_COUNT; i++)
{
- if ((pTLCb->atlSTAClients[i].ucExists) &&
- (0 == pTLCb->atlSTAClients[i].ucTxSuspended) &&
- (pTLCb->atlSTAClients[i].ucEapolPktPending)
+ if ((NULL != pTLCb->atlSTAClients[i]) &&
+ (pTLCb->atlSTAClients[i]->ucExists) &&
+ (0 == pTLCb->atlSTAClients[i]->ucTxSuspended) &&
+ (pTLCb->atlSTAClients[i]->ucEapolPktPending)
)
break;
}
@@ -3811,22 +3975,22 @@
/* Serve EAPOL frame with HI_FLOW_MASK */
ucSTAId = i;
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
wSTAEvent = WLANTL_TX_EVENT;
- pfnSTAFsm = tlSTAFsm[pTLCb->atlSTAClients[ucSTAId].tlState].
+ pfnSTAFsm = tlSTAFsm[pClientSTA->tlState].
pfnSTATbl[wSTAEvent];
if ( NULL != pfnSTAFsm )
{
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 0;
+ pClientSTA->ucNoMoreData = 0;
vosStatus = pfnSTAFsm( pvosGCtx, ucSTAId, &vosTempBuf);
if (( VOS_STATUS_SUCCESS != vosStatus ) &&
( NULL != vosTempBuf ))
{
- pTLCb->atlSTAClients[ucSTAId].pfnSTATxComp( pvosGCtx,
- vosTempBuf,
- vosStatus );
+ pClientSTA->pfnSTATxComp( pvosGCtx, vosTempBuf, vosStatus );
vosTempBuf = NULL;
break;
}/* status success*/
@@ -3852,21 +4016,21 @@
//Check if EAPOL pkt is pending and ULA notification is pending
//if both the condition are met then send the notification to ULA
- if ( pTLCb->atlSTAClients[i].ucEapolPktPending &&
- pTLCb->atlSTAClients[i].ucULANotificationPending )
+ if ( pClientSTA->ucEapolPktPending &&
+ pClientSTA->ucULANotificationPending )
{
//Error check if callback routine is not NULL
- if(pTLCb->atlSTAClients[i].callbackRoutine != NULL )
+ if(pClientSTA->callbackRoutine != NULL )
{
- pTLCb->atlSTAClients[i].callbackRoutine(pTLCb->atlSTAClients[i].callbackContext);
- pTLCb->atlSTAClients[i].ucULANotificationPending = 0;
+ pClientSTA->callbackRoutine(pClientSTA->callbackContext);
+ pClientSTA->ucULANotificationPending = 0;
}
}
- pTLCb->atlSTAClients[i].ucEapolPktPending = 0;
+ pClientSTA->ucEapolPktPending = 0;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:GetFrames STA: %d EAPOLPktPending %d",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].ucEapolPktPending);
+ ucSTAId, pClientSTA->ucEapolPktPending);
/*EAPOL frame cannot be delayed*/
pTLCb->bUrgent = TRUE;
@@ -3881,9 +4045,9 @@
#ifdef WLAN_SOFTAP_FEATURE
//fow control update
- pTLCb->atlSTAClients[ucSTAId].uIngress_length += uResLen;
- pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax = (pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax >= uResLen) ?
- (pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax - uResLen) : 0;
+ pClientSTA->uIngress_length += uResLen;
+ pClientSTA->uBuffThresholdMax = (pClientSTA->uBuffThresholdMax >= uResLen) ?
+ (pClientSTA->uBuffThresholdMax - uResLen) : 0;
#endif
}
}
@@ -3916,7 +4080,15 @@
pTLCb->vosTempBuf = NULL;
ucSTAId = pTLCb->ucCachedSTAId;
ucAC = pTLCb->ucCachedAC;
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 0;
+
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ pTLCb->atlSTAClients[ucSTAId]->ucNoMoreData = 0;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Chaining cached data frame on GetFrame"));
@@ -3935,34 +4107,43 @@
}
/* ucCurrentAC should have correct AC to be served by calling
WLAN_TLGetNextTxIds */
- ucAC = pTLCb->atlSTAClients[ucSTAId].ucCurrentAC;
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ ucAC = pClientSTA->ucCurrentAC;
+
+ pClientSTA->ucNoMoreData = 1;
TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
"WLAN TL: %s get one data frame, station ID %d ", __func__, ucSTAId));
/*-------------------------------------------------------------------
Check to see that STA is valid and tx is not suspended
-------------------------------------------------------------------*/
if ( ( ! WLANTL_STA_ID_INVALID( ucSTAId ) ) &&
- ( 0 == pTLCb->atlSTAClients[ucSTAId].ucTxSuspended ) &&
- ( 0 == pTLCb->atlSTAClients[ucSTAId].fcStaTxDisabled) )
+ ( 0 == pClientSTA->ucTxSuspended ) &&
+ ( 0 == pClientSTA->fcStaTxDisabled) )
{
TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
"WLAN TL: %s sta id valid and not suspended ",__func__));
wSTAEvent = WLANTL_TX_EVENT;
- pfnSTAFsm = tlSTAFsm[pTLCb->atlSTAClients[ucSTAId].tlState].
+ pfnSTAFsm = tlSTAFsm[pClientSTA->tlState].
pfnSTATbl[wSTAEvent];
if ( NULL != pfnSTAFsm )
{
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 0;
+ pClientSTA->ucNoMoreData = 0;
vosStatus = pfnSTAFsm( pvosGCtx, ucSTAId, &vosTempBuf);
if (( VOS_STATUS_SUCCESS != vosStatus ) &&
( NULL != vosTempBuf ))
{
- pTLCb->atlSTAClients[ucSTAId].pfnSTATxComp( pvosGCtx,
+ pClientSTA->pfnSTATxComp( pvosGCtx,
vosTempBuf,
vosStatus );
vosTempBuf = NULL;
@@ -4010,9 +4191,9 @@
#ifdef WLAN_SOFTAP_FEATURE
//fow control update
- pTLCb->atlSTAClients[ucSTAId].uIngress_length += uResLen;
- pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax = (pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax >= uResLen) ?
- (pTLCb->atlSTAClients[ucSTAId].uBuffThresholdMax - uResLen) : 0;
+ pClientSTA->uIngress_length += uResLen;
+ pClientSTA->uBuffThresholdMax = (pClientSTA->uBuffThresholdMax >= uResLen) ?
+ (pClientSTA->uBuffThresholdMax - uResLen) : 0;
#endif
}
@@ -4037,8 +4218,8 @@
{
for ( i = 0; i < WLAN_MAX_STA_COUNT; i++)
{
- if ((pTLCb->atlSTAClients[i].ucExists) &&
- (pTLCb->atlSTAClients[i].ucPktPending))
+ if (NULL != pTLCb->atlSTAClients[i] && (pTLCb->atlSTAClients[i]->ucExists) &&
+ (pTLCb->atlSTAClients[i]->ucPktPending))
{
/* There is station to be Served */
break;
@@ -4266,6 +4447,7 @@
v_U8_t ucUcastSig;
v_U8_t ucBcastSig;
v_BOOL_t bOldSTAPkt;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*-------------------------------------------------------------------------
@@ -4285,12 +4467,20 @@
"WLAN TL:Invalid station id requested on WLANTL_CacheSTAFrame"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Attempting to cache pkt for STA %d, BD DPU Sig: %d with sig UC: %d, BC: %d",
ucSTAId, uDPUSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig));
+ pClientSTA->wSTADesc.ucUcastSig,
+ pClientSTA->wSTADesc.ucBcastSig));
if(WLANTL_IS_CTRL_FRAME(ucFrmType))
{
@@ -4313,15 +4503,15 @@
{
ucBcastSig = (v_U8_t)uDPUSig;
bOldSTAPkt = (( WLAN_TL_INVALID_B_SIG !=
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig ) &&
- ( ucBcastSig == pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig ));
+ pClientSTA->wSTADesc.ucBcastSig ) &&
+ ( ucBcastSig == pClientSTA->wSTADesc.ucBcastSig ));
}
else
{
ucUcastSig = (v_U8_t)uDPUSig;
bOldSTAPkt = (( WLAN_TL_INVALID_U_SIG !=
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig ) &&
- ( ucUcastSig == pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig ));
+ pClientSTA->wSTADesc.ucUcastSig ) &&
+ ( ucUcastSig == pClientSTA->wSTADesc.ucUcastSig ));
}
/*------------------------------------------------------------------------
@@ -4336,24 +4526,24 @@
"WLAN TL:Data packet matches old sig for sig DPU: %d UC: %d, "
"BC: %d - dropping",
uDPUSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig));
+ pClientSTA->wSTADesc.ucUcastSig,
+ pClientSTA->wSTADesc.ucBcastSig));
vos_pkt_return_packet(vosTempBuff);
}
else
{
- if ( NULL == pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame )
+ if ( NULL == pClientSTA->vosBegCachedFrame )
{
/*this is the first frame that we are caching */
- pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame = vosTempBuff;
+ pClientSTA->vosBegCachedFrame = vosTempBuff;
}
else
{
/*this is a subsequent frame that we are caching: chain to the end */
- vos_pkt_chain_packet(pTLCb->atlSTAClients[ucSTAId].vosEndCachedFrame,
+ vos_pkt_chain_packet(pClientSTA->vosEndCachedFrame,
vosTempBuff, VOS_TRUE);
}
- pTLCb->atlSTAClients[ucSTAId].vosEndCachedFrame = vosTempBuff;
+ pClientSTA->vosEndCachedFrame = vosTempBuff;
}/*else new packet*/
return VOS_STATUS_SUCCESS;
@@ -4450,7 +4640,8 @@
v_U8_t ucBcastSig
)
{
- WLANTL_CbType* pTLCb = NULL;
+ WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*-------------------------------------------------------------------------
@@ -4478,11 +4669,20 @@
Check if station has not been registered in the mean while
if not registered, flush cached frames.
------------------------------------------------------------------------*/
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Station has been deleted for STA %d - flushing cache", ucSTAId));
- WLANTL_FlushCachedFrames(pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame);
+ WLANTL_FlushCachedFrames(pClientSTA->vosBegCachedFrame);
goto done;
}
@@ -4500,8 +4700,8 @@
/*-----------------------------------------------------------------------
Save the new signature values
------------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig = ucUcastSig;
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig = ucBcastSig;
+ pClientSTA->wSTADesc.ucUcastSig = ucUcastSig;
+ pClientSTA->wSTADesc.ucBcastSig = ucBcastSig;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Fwd-ing packets for STA %d UC %d BC %d",
@@ -4510,14 +4710,14 @@
/*-------------------------------------------------------------------------
Check to see if we have any cached data to forward
-------------------------------------------------------------------------*/
- if ( NULL != pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame )
+ if ( NULL != pClientSTA->vosBegCachedFrame )
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Fwd-ing Cached packets for station %d", ucSTAId ));
WLANTL_RxCachedFrames( pTLCb,
ucSTAId,
- pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame);
+ pClientSTA->vosBegCachedFrame);
}
else
{
@@ -4529,13 +4729,13 @@
/*-------------------------------------------------------------------------
Clear the station cache
-------------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].vosBegCachedFrame = NULL;
- pTLCb->atlSTAClients[ucSTAId].vosEndCachedFrame = NULL;
+ pClientSTA->vosBegCachedFrame = NULL;
+ pClientSTA->vosEndCachedFrame = NULL;
/*-----------------------------------------------------------------------
After all the init is complete we can mark the existance flag
----------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].ucRxBlocked = 0;
+ pClientSTA->ucRxBlocked = 0;
//WLAN_TL_UNLOCK_STA_CACHE(pTLCb->atlSTAClients[ucSTAId]);
return VOS_STATUS_SUCCESS;
@@ -5064,6 +5264,7 @@
{
vos_pkt_t* vosDataBuff = (vos_pkt_t*)pFrameDataBuff;
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
WLANTL_STAFuncType pfnSTAFsm;
vos_pkt_t* vosTempBuff;
v_U8_t ucSTAId;
@@ -5290,14 +5491,24 @@
- also we need to make sure that the frames in the cache are fwd-ed to
the station before the new incoming ones
-----------------------------------------------------------------------*/
- if ((( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists ) ||
- ( (0 != pTLCb->atlSTAClients[ucSTAId].ucRxBlocked)
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+ if (NULL == pClientSTA)
+ {
+ TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN,
+ "WLAN TL:STA not allocated memory. Dropping packet"));
+ vos_pkt_return_packet(vosTempBuff);
+ vosTempBuff = vosDataBuff;
+ continue;
+ }
+
+ if ((( 0 == pClientSTA->ucExists ) ||
+ ( (0 != pClientSTA->ucRxBlocked)
#ifdef WLAN_SOFTAP_FEATURE
///@@@: xg: no checking in SOFTAP for now, will revisit later
- && (WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType)
+ && (WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType)
#endif
) ||
- ( WLANTL_STA_DISCONNECTED == pTLCb->atlSTAClients[ucSTAId].tlState)) &&
+ ( WLANTL_STA_DISCONNECTED == pClientSTA->tlState)) &&
/*Dont buffer Broadcast/Multicast frames. If AP transmits bursts of Broadcast/Multicast data frames,
* libra buffers all Broadcast/Multicast packets after authentication with AP,
* So it will lead to low resource condition in Rx Data Path.*/
@@ -5312,7 +5523,7 @@
#ifdef FEATURE_WLAN_CCX
- if ((pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucIsCcxSta)|| broadcast)
+ if ((pClientSTA->wSTADesc.ucIsCcxSta)|| broadcast)
{
/*--------------------------------------------------------------------
Filter the IAPP frames for CCX connection;
@@ -5341,7 +5552,7 @@
}
#endif
- if ( WLAN_STA_BT_AMP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType )
+ if ( WLAN_STA_BT_AMP == pClientSTA->wSTADesc.wSTAType )
{
/*--------------------------------------------------------------------
Process the ctrl BAP frame; if data it will return false and it
@@ -5370,7 +5581,7 @@
---------------------------------------------------------------------*/
wSTAEvent = WLANTL_RX_EVENT;
- pfnSTAFsm = tlSTAFsm[pTLCb->atlSTAClients[ucSTAId].tlState].
+ pfnSTAFsm = tlSTAFsm[pClientSTA->tlState].
pfnSTATbl[wSTAEvent];
if ( NULL != pfnSTAFsm )
@@ -5404,7 +5615,7 @@
{
TLLOGW(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN,
"WLAN TL:NULL state function, STA:%d, State: %d- dropping packet",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].tlState));
+ ucSTAId, pClientSTA->tlState));
/* Drop packet */
vos_pkt_return_packet(vosTempBuff);
vosTempBuff = vosDataBuff;
@@ -5416,8 +5627,8 @@
#ifdef WLAN_SOFTAP_FEATURE
/* RX Statistics Data */
/* This is RX UC data frame */
- pTLCb->atlSTAClients[ucSTAId].trafficStatistics.rxUCFcnt++;
- pTLCb->atlSTAClients[ucSTAId].trafficStatistics.rxUCBcnt += usPktLen;
+ pClientSTA->trafficStatistics.rxUCFcnt++;
+ pClientSTA->trafficStatistics.rxUCBcnt += usPktLen;
#endif
#endif /* FEATURE_WLAN_INTEGRATED_SOC */
@@ -5473,6 +5684,7 @@
vos_pkt_t* vosDataBuff
)
{
+ WLANTL_STAClientType* pClientSTA = NULL;
WLANTL_STAFuncType pfnSTAFsm;
vos_pkt_t* vosTempBuff;
VOS_STATUS vosStatus;
@@ -5571,19 +5783,29 @@
Check if the packet that we cached matches the DPU signature of the
newly added station
-------------------------------------------------------------------------*/
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
if ( broadcast )
{
ucBcastSig = (v_U8_t)uDPUSig;
bSigMatch = (( WLAN_TL_INVALID_B_SIG !=
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig ) &&
- ( ucBcastSig == pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucBcastSig ));
+ pClientSTA->wSTADesc.ucBcastSig ) &&
+ ( ucBcastSig == pClientSTA->wSTADesc.ucBcastSig ));
}
else
{
ucUcastSig = (v_U8_t)uDPUSig;
bSigMatch = (( WLAN_TL_INVALID_U_SIG !=
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig ) &&
- ( ucUcastSig == pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig ));
+ pClientSTA->wSTADesc.ucUcastSig ) &&
+ ( ucUcastSig == pClientSTA->wSTADesc.ucUcastSig ));
}
/*-------------------------------------------------------------------------
@@ -5595,8 +5817,8 @@
"WLAN TL: Cached packet does not match DPU Sig of the new STA - drop "
" DPU Sig %d UC %d BC %d B %d",
uDPUSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucUcastSig,
+ pClientSTA->wSTADesc.ucUcastSig,
+ pClientSTA->wSTADesc.ucUcastSig,
broadcast));
/* Drop packet */
@@ -5611,7 +5833,7 @@
- additional processing needed in this case to separate BT-AMP date
from BT-AMP Ctrl path
------------------------------------------------------------------------*/
- if ( WLAN_STA_BT_AMP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType )
+ if ( WLAN_STA_BT_AMP == pClientSTA->wSTADesc.wSTAType )
{
/*--------------------------------------------------------------------
Process the ctrl BAP frame; if data it will return false and it
@@ -5640,7 +5862,7 @@
---------------------------------------------------------------------*/
wSTAEvent = WLANTL_RX_EVENT;
- pfnSTAFsm = tlSTAFsm[pTLCb->atlSTAClients[ucSTAId].tlState].
+ pfnSTAFsm = tlSTAFsm[pClientSTA->tlState].
pfnSTATbl[wSTAEvent];
if ( NULL != pfnSTAFsm )
@@ -5676,7 +5898,7 @@
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:NULL state function, STA:%d, State: %d- dropping packet",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].tlState));
+ ucSTAId, pClientSTA->tlState));
/* Drop packet */
vos_pkt_return_packet(vosTempBuff);
vosTempBuff = vosDataBuff;
@@ -5950,6 +6172,7 @@
v_MACADDR_t vDestMacAddr;
vos_pkt_t* vosDataBuff = NULL;
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
WLANTL_MetaInfoType tlMetaInfo;
v_U8_t ucTypeSubtype = 0;
v_U8_t ucTid;
@@ -5970,6 +6193,14 @@
*pvosDataBuff = NULL;
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
/*-------------------------------------------------------------------
Disable AC temporary - if successfull retrieve re-enable
@@ -5993,16 +6224,16 @@
Fetch packet from HDD
------------------------------------------------------------------------*/
#ifdef FEATURE_WLAN_TDLS
- if ((WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType) &&
+ if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) &&
(!vos_concurrent_sessions_running()) &&
!pTLCb->ucTdlsPeerCount)
{
#else
- if ((WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType) &&
+ if ((WLAN_STA_SOFTAP != pClientSTA->wSTADesc.wSTAType) &&
(!vos_concurrent_sessions_running()))
{
#endif
- ucAC = pTLCb->atlSTAClients[ucSTAId].ucCurrentAC;
+ ucAC = pClientSTA->ucCurrentAC;
/*-------------------------------------------------------------------
Disable AC temporary - if successfull retrieve re-enable
@@ -6017,43 +6248,42 @@
To prevent this the AC will be disabled here and if retrieve
is successfull it will be re-enabled
-------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].aucACMask[ucAC] = 0;
+ pClientSTA->aucACMask[ucAC] = 0;
}
else
{
- //softap case
- ucAC = pTLCb->uCurServedAC;
- pTLCb->atlSTAClients[ucSTAId].aucACMask[ucAC] = 0;
-
+ //softap case
+ ucAC = pTLCb->uCurServedAC;
+ pClientSTA->aucACMask[ucAC] = 0;
}
- /*You make an initial assumption that HDD has no more data and if the
+ /*You make an initial assumption that HDD has no more data and if the
assumption was wrong you reset the flags to their original state
- This will prevent from exposing a race condition between checking with HDD
+ This will prevent from exposing a race condition between checking with HDD
for packets and setting the flags to false*/
- //LTI: vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 0);
- //LTI: pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 0);
- WLAN_TL_AC_ARRAY_2_MASK( &pTLCb->atlSTAClients[ucSTAId], ucACMask, i);
+ //LTI: vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 0);
+ //LTI: pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 0);
+ WLAN_TL_AC_ARRAY_2_MASK( pClientSTA, ucACMask, i);
#ifdef WLAN_SOFTAP_FEATURE
- /*You make an initial assumption that HDD has no more data and if the
- assumption was wrong you reset the flags to their original state
- This will prevent from exposing a race condition between checking with HDD
- for packets and setting the flags to false*/
+ /*You make an initial assumption that HDD has no more data and if the
+ assumption was wrong you reset the flags to their original state
+ This will prevent from exposing a race condition between checking with HDD
+ for packets and setting the flags to false*/
if ( 0 == ucACMask )
{
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
+ pClientSTA->ucNoMoreData = 1;
}
else
{
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 1);
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 1);
}
#endif
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,
"WLAN TL: WLANTL_STATxConn fetching packet from HDD for AC: %d AC Mask: %d Pkt Pending: %d",
- ucAC, ucACMask, pTLCb->atlSTAClients[ucSTAId].ucPktPending);
+ ucAC, ucACMask, pClientSTA->ucPktPending);
/*------------------------------------------------------------------------
Fetch tx packet from HDD
@@ -6085,7 +6315,7 @@
#endif
#endif
- vosStatus = pTLCb->atlSTAClients[ucSTAId].pfnSTAFetchPkt( pvosGCtx,
+ vosStatus = pClientSTA->pfnSTAFetchPkt( pvosGCtx,
&ucSTAId,
ucAC,
&vosDataBuff, &tlMetaInfo );
@@ -6102,8 +6332,8 @@
Even if this AC is not supported by the station, correction will be
made in the main TL loop
--------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].ucCurrentAC = WLANTL_AC_VO;
- pTLCb->atlSTAClients[ucSTAId].ucCurrentWeight = 0;
+ pClientSTA->ucCurrentAC = WLANTL_AC_VO;
+ pClientSTA->ucCurrentWeight = 0;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,
"WLAN TL: WLANTL_STATxConn no more packets in HDD for AC: %d AC Mask: %d",
@@ -6114,9 +6344,9 @@
/*There are still packets in HDD - set back the pending packets and
the no more data assumption*/
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 1);
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 0;
- pTLCb->atlSTAClients[ucSTAId].aucACMask[ucAC] = 1;
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 1);
+ pClientSTA->ucNoMoreData = 0;
+ pClientSTA->aucACMask[ucAC] = 1;
#ifdef WLAN_PERF
vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_BAL,
@@ -6135,7 +6365,7 @@
"WLAN TL:Only EAPOL or WAI packets allowed before authentication"));
/* Fail tx for packet */
- pTLCb->atlSTAClients[ucSTAId].pfnSTATxComp( pvosGCtx, vosDataBuff,
+ pClientSTA->pfnSTATxComp( pvosGCtx, vosDataBuff,
VOS_STATUS_E_BADMSG);
vosDataBuff = NULL;
*pvosDataBuff = NULL;
@@ -6148,7 +6378,7 @@
"WLAN TL:Received non EAPOL packet before authentication"));
/* Fail tx for packet */
- pTLCb->atlSTAClients[ucSTAId].pfnSTATxComp( pvosGCtx, vosDataBuff,
+ pClientSTA->pfnSTATxComp( pvosGCtx, vosDataBuff,
VOS_STATUS_E_BADMSG);
vosDataBuff = NULL;
*pvosDataBuff = NULL;
@@ -6185,7 +6415,7 @@
Translate 802.3 frame to 802.11 if Frame translation is enabled
------------------------------------------------------------------------*/
if ( ( 0 == tlMetaInfo.ucDisableFrmXtl ) &&
- ( 0 != pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucSwFrameTXXlation) )
+ ( 0 != pClientSTA->wSTADesc.ucSwFrameTXXlation) )
#endif //#ifdef FEATURE_WLAN_WAPI
{
vosStatus = WLANTL_Translate8023To80211Header( vosDataBuff, &vosStatus,
@@ -6207,7 +6437,7 @@
-------------------------------------------------------------------------*/
ucTypeSubtype |= (WLANTL_80211_DATA_TYPE << 4);
- if ( pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucQosEnabled )
+ if ( pClientSTA->wSTADesc.ucQosEnabled )
{
ucTypeSubtype |= (WLANTL_80211_DATA_QOS_SUBTYPE);
}
@@ -6215,9 +6445,9 @@
vosStatus = (VOS_STATUS)WDA_DS_BuildTxPacketInfo( pvosGCtx, vosDataBuff , &vDestMacAddr,
tlMetaInfo.ucDisableFrmXtl, &usPktLen,
- pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucQosEnabled, ucWDSEnabled,
+ pClientSTA->wSTADesc.ucQosEnabled, ucWDSEnabled,
extraHeadSpace,
- ucTypeSubtype, &pTLCb->atlSTAClients[ucSTAId].wSTADesc.vSelfMACAddress,
+ ucTypeSubtype, &pClientSTA->wSTADesc.vSelfMACAddress,
ucTid, HAL_TX_NO_ENCRYPTION_MASK,
tlMetaInfo.usTimeStamp, tlMetaInfo.ucIsEapol || tlMetaInfo.ucIsWai, tlMetaInfo.ucUP );
@@ -6233,10 +6463,10 @@
Update tx counter for BA session query for tx side
!1 - should this be done for EAPOL frames?
-----------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].auTxCount[ucTid]++;
+ pClientSTA->auTxCount[ucTid]++;
vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL,
- (v_PVOID_t)pTLCb->atlSTAClients[ucSTAId].pfnSTATxComp );
+ (v_PVOID_t)pClientSTA->pfnSTATxComp );
/*------------------------------------------------------------------------
Save data to input pointer for TL core
@@ -6250,8 +6480,8 @@
if (!(tlMetaInfo.ucBcast || tlMetaInfo.ucMcast))
{
/* This is TX UC frame */
- pTLCb->atlSTAClients[ucSTAId].trafficStatistics.txUCFcnt++;
- pTLCb->atlSTAClients[ucSTAId].trafficStatistics.txUCBcnt += usPktLen;
+ pClientSTA->trafficStatistics.txUCFcnt++;
+ pClientSTA->trafficStatistics.txUCBcnt += usPktLen;
}
#endif
@@ -6309,7 +6539,7 @@
v_U8_t ucTid;
v_U8_t ucSwFrmXtl = 0;
v_U8_t extraHeadSpace = 0;
- WLANTL_STAClientType *pStaClient;
+ WLANTL_STAClientType *pStaClient = NULL;
v_U8_t ucWDSEnabled = 0;
v_U8_t ucTxFlag = 0;
v_U8_t ucACMask, i;
@@ -6331,12 +6561,24 @@
}
if(NULL != pTLCb)
{
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+ pTLCb->atlSTAClients[ucSTAId]->ucNoMoreData = 1;
}
return VOS_STATUS_E_FAULT;
}
+ pStaClient = pTLCb->atlSTAClients[ucSTAId];
- pStaClient = &pTLCb->atlSTAClients[ucSTAId];
+ if ( NULL == pStaClient )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
vos_mem_zero(&tlMetaInfo, sizeof(tlMetaInfo));
/*------------------------------------------------------------------------
@@ -6344,7 +6586,7 @@
------------------------------------------------------------------------*/
#ifdef WLAN_SOFTAP_FEATURE
#ifdef FEATURE_WLAN_TDLS
- if ((WLAN_STA_SOFTAP != pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType) &&
+ if ((WLAN_STA_SOFTAP != pStaClient->wSTADesc.wSTAType) &&
(!vos_concurrent_sessions_running()) &&
!pTLCb->ucTdlsPeerCount)
{
@@ -6474,8 +6716,7 @@
else
{
pStaClient->ucCurrentAC = ucAC;
- pStaClient->ucCurrentWeight =
- pTLCb->tlConfigInfo.ucAcWeights[ucAC] - 1;
+ pStaClient->ucCurrentWeight = pTLCb->tlConfigInfo.ucAcWeights[ucAC] - 1;
pStaClient->aucACMask[pStaClient->ucCurrentAC] = 1;
@@ -6497,8 +6738,7 @@
if ( 0 != pStaClient->aucACMask[ucNextAC] )
{
pStaClient->ucCurrentAC = ucNextAC;
- pStaClient->ucCurrentWeight =
- pTLCb->tlConfigInfo.ucAcWeights[ucNextAC];
+ pStaClient->ucCurrentWeight = pTLCb->tlConfigInfo.ucAcWeights[ucNextAC];
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Changing serviced AC to: %d with Weight: %d",
@@ -6635,7 +6875,7 @@
tlMetaInfo.ucDisableFrmXtl, &usPktLen,
pStaClient->wSTADesc.ucQosEnabled, ucWDSEnabled,
extraHeadSpace,
- ucTypeSubtype, &pTLCb->atlSTAClients[ucSTAId].wSTADesc.vSelfMACAddress,
+ ucTypeSubtype, &pStaClient->wSTADesc.vSelfMACAddress,
ucTid, ucTxFlag, tlMetaInfo.usTimeStamp,
tlMetaInfo.ucIsEapol, tlMetaInfo.ucUP );
@@ -6663,7 +6903,7 @@
-----------------------------------------------------------------------*/
pStaClient->auTxCount[ucTid]++;
#else
- pTLCb->atlSTAClients[ucSTAId].auTxCount[ucTid]++;
+ pTLCb->atlSTAClients[ucSTAId]->auTxCount[ucTid]++;
#endif
/* This code is to send traffic with lower priority AC when we does not
@@ -6746,9 +6986,9 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
/*- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -*/
-
/*------------------------------------------------------------------------
Sanity check
Extract TL control block
@@ -6762,6 +7002,15 @@
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*------------------------------------------------------------------------
Error
------------------------------------------------------------------------*/
@@ -6770,10 +7019,10 @@
" request"));
*pvosDataBuff = NULL;
- pTLCb->atlSTAClients[ucSTAId].ucNoMoreData = 1;
+ pClientSTA->ucNoMoreData = 1;
//Should not be anything pending in disconnect state
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 0);
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 0);
return VOS_STATUS_SUCCESS;
}/* WLANTL_STATxDisc */
@@ -6815,6 +7064,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
v_U16_t usEtherType = 0;
v_U16_t usPktLen;
v_U8_t ucMPDUHOffset;
@@ -6849,6 +7099,14 @@
"WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_ChangeSTAState"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
/*------------------------------------------------------------------------
Extract BD header and check if valid
@@ -6917,7 +7175,7 @@
"WLAN TL:RX Frame EAPOL EtherType %d - processing", usEtherType);
if (( 0 == WDA_GET_RX_FT_DONE(aucBDHeader) ) &&
- ( 0 != pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucSwFrameRXXlation))
+ ( 0 != pClientSTA->wSTADesc.ucSwFrameRXXlation))
{
if (usMPDUDOffset > ucMPDUHOffset)
{
@@ -6941,7 +7199,7 @@
-------------------------------------------------------------------*/
if ( !WLANTL_TID_INVALID( ucTid) )
{
- pTLCb->atlSTAClients[ucSTAId].auRxCount[ucTid]++;
+ pClientSTA->auRxCount[ucTid]++;
}
else
{
@@ -6961,15 +7219,15 @@
#ifdef WLAN_SOFTAP_FEATURE
TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
"WLAN TL %s:Sending data chain to station \n", __func__));
- if ( WLAN_STA_SOFTAP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType )
+ if ( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType )
{
wRxMetaInfo.ucDesSTAId = WLAN_RX_SAP_SELF_STA_ID;
- pTLCb->atlSTAClients[ucSTAId].pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
+ pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
&wRxMetaInfo );
}
else
#endif
- pTLCb->atlSTAClients[ucSTAId].pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
+ pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
&wRxMetaInfo );
}/*EAPOL frame or WAI frame*/
}/*vos status success*/
@@ -7014,18 +7272,18 @@
v_U8_t ucSTAId
)
{
- v_MACADDR_t DestMacAddress;
- v_MACADDR_t *pDestMacAddress = &DestMacAddress;
- v_SIZE_t usMacAddSize = VOS_MAC_ADDR_SIZE;
+ v_MACADDR_t DestMacAddress;
+ v_MACADDR_t *pDestMacAddress = &DestMacAddress;
+ v_SIZE_t usMacAddSize = VOS_MAC_ADDR_SIZE;
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
vos_pkt_t* vosDataBuff ;
VOS_STATUS vosStatus = VOS_STATUS_SUCCESS;
- v_U32_t STAMetaInfo;
- vos_pkt_t* vosNextDataBuff ;
- v_U8_t ucDesSTAId;
+ v_U32_t STAMetaInfo;
+ vos_pkt_t* vosNextDataBuff ;
+ v_U8_t ucDesSTAId;
WLANTL_RxMetaInfoType wRxMetaInfo;
-
/*------------------------------------------------------------------------
Sanity check
------------------------------------------------------------------------*/
@@ -7046,6 +7304,16 @@
"WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_FwdPktToHdd"));
return VOS_STATUS_E_FAULT;
}
+
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/* This the change required for SoftAp to handle Reordered Buffer. Since a STA
may have packets destined to multiple destinations we have to process each packet
at a time and determine its Destination. So the Voschain provided by Reorder code
@@ -7082,14 +7350,14 @@
}
else
{
- if (vos_is_macaddr_equal(pDestMacAddress, &pTLCb->atlSTAClients[ucSTAId].wSTADesc.vSelfMACAddress))
+ if (vos_is_macaddr_equal(pDestMacAddress, &pClientSTA->wSTADesc.vSelfMACAddress))
{
// destination is AP itself
ucDesSTAId = WLAN_RX_SAP_SELF_STA_ID;
TLLOG4(VOS_TRACE( VOS_MODULE_ID_HDD_SOFTAP, VOS_TRACE_LEVEL_INFO_LOW,
"%s: packet to AP itself, id %d\n", __func__, WLAN_RX_SAP_SELF_STA_ID));
}
- else if (( WLAN_MAX_STA_COUNT <= ucDesSTAId ) || (pTLCb->atlSTAClients[ucDesSTAId].ucExists == 0))
+ else if (( WLAN_MAX_STA_COUNT <= ucDesSTAId ) || (pClientSTA->ucExists == 0))
{
// destination station is something else
TLLOG4(VOS_TRACE( VOS_MODULE_ID_HDD_SOFTAP, VOS_TRACE_LEVEL_INFO_LOW,
@@ -7104,7 +7372,7 @@
wRxMetaInfo.ucUP = (v_U8_t)(STAMetaInfo & WLANTL_AC_MASK);
wRxMetaInfo.ucDesSTAId = ucDesSTAId;
- vosStatus = pTLCb->atlSTAClients[ucSTAId].pfnSTARx( pvosGCtx, vosDataBuff, ucDesSTAId,
+ vosStatus = pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucDesSTAId,
&wRxMetaInfo );
if ( VOS_STATUS_SUCCESS != vosStatus )
{
@@ -7156,6 +7424,7 @@
)
{
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
v_U8_t ucAsf; /* AMSDU sub frame */
v_U16_t usMPDUDOffset;
v_U8_t ucMPDUHOffset;
@@ -7205,6 +7474,14 @@
"WLAN TL:Invalid TL pointer from pvosGCtx on WLANTL_STARxAuth"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
/*------------------------------------------------------------------------
Extract BD header and check if valid
@@ -7276,7 +7553,7 @@
}
#ifdef FEATURE_WLAN_WAPI
- if ( pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucIsWapiSta )
+ if ( pClientSTA->wSTADesc.ucIsWapiSta )
{
vosStatus = WLANTL_GetEtherType(aucBDHeader, vosDataBuff, ucMPDUHLen, &usEtherType);
if( VOS_IS_STATUS_SUCCESS(vosStatus) )
@@ -7323,7 +7600,7 @@
------------------------------------------------------------------------*/
if ( !WLANTL_TID_INVALID( ucTid) )
{
- pTLCb->atlSTAClients[ucSTAId].auRxCount[ucTid]++;
+ pClientSTA->auRxCount[ucTid]++;
}
else
{
@@ -7356,7 +7633,7 @@
!! Fix me: rmv comments below
----------------------------------------------------------------------*/
if (( 0 == WDA_GET_RX_FT_DONE(aucBDHeader) ) &&
- ( 0 != pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucSwFrameRXXlation) &&
+ ( 0 != pClientSTA->wSTADesc.ucSwFrameRXXlation) &&
( WLANTL_IS_DATA_FRAME(WDA_GET_RX_TYPE_SUBTYPE(aucBDHeader)) ))
{
if(0 == ucMPDUHLen)
@@ -7383,7 +7660,7 @@
Category. Voschain or Buffer returned by BA would be unchain and this
Meta Data would help in routing the packets to appropriate Destination */
#ifdef WLAN_SOFTAP_FEATURE
- if( WLAN_STA_SOFTAP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType)
+ if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType)
{
STAMetaInfoPtr = (v_U32_t *)(ucTid | (WDA_GET_RX_ADDR3_IDX(aucBDHeader) << WLANTL_STAID_OFFSET));
vos_pkt_set_user_data_ptr( vosDataBuff, VOS_PKT_USER_DATA_ID_TL,
@@ -7394,7 +7671,7 @@
/*------------------------------------------------------------------------
Check to see if re-ordering session is in place
------------------------------------------------------------------------*/
- if ( 0 != pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists )
+ if ( 0 != pClientSTA->atlBAReorderInfo[ucTid].ucExists )
{
WLANTL_MSDUReorder( pTLCb, &vosDataBuff, aucBDHeader, ucSTAId, ucTid );
}
@@ -7407,7 +7684,7 @@
)
{
/* replay check code : check whether replay check is needed or not */
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
/* replay check is needed for the station */
@@ -7429,7 +7706,7 @@
"WLAN TL: AMSDU currentReplayCounter [0x%llX]\n",ullcurrentReplayCounter);
/* Getting 48-bit previous replay counter from TL control block */
- ullpreviousReplayCounter = pTLCb->atlSTAClients[ucSTAId].ullReplayCounter[ucTid];
+ ullpreviousReplayCounter = pClientSTA->ullReplayCounter[ucTid];
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,
"WLAN TL: AMSDU previousReplayCounter [0x%llX]\n",ullpreviousReplayCounter);
@@ -7441,17 +7718,17 @@
if(VOS_FALSE == status)
{
/* Not a replay paket, update previous replay counter in TL CB */
- pTLCb->atlSTAClients[ucSTAId].ullReplayCounter[ucTid] = ullcurrentReplayCounter;
+ pClientSTA->ullReplayCounter[ucTid] = ullcurrentReplayCounter;
}
else
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: AMSDU Drop the replay packet with PN : [0x%llX]\n",ullcurrentReplayCounter);
- pTLCb->atlSTAClients[ucSTAId].ulTotalReplayPacketsDetected++;
+ pClientSTA->ulTotalReplayPacketsDetected++;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: AMSDU total dropped replay packets on STA ID %X is [0x%lX]\n",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].ulTotalReplayPacketsDetected);
+ ucSTAId, pClientSTA->ulTotalReplayPacketsDetected);
/* Drop the packet */
vos_pkt_return_packet(vosDataBuff);
@@ -7470,7 +7747,7 @@
"WLAN TL: Non-AMSDU currentReplayCounter [0x%llX]\n",ullcurrentReplayCounter);
/* Getting 48-bit previous replay counter from TL control block */
- ullpreviousReplayCounter = pTLCb->atlSTAClients[ucSTAId].ullReplayCounter[ucTid];
+ ullpreviousReplayCounter = pClientSTA->ullReplayCounter[ucTid];
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,
"WLAN TL: Non-AMSDU previousReplayCounter [0x%llX]\n",ullpreviousReplayCounter);
@@ -7482,17 +7759,17 @@
if(VOS_FALSE == status)
{
/* Not a replay paket, update previous replay counter in TL CB */
- pTLCb->atlSTAClients[ucSTAId].ullReplayCounter[ucTid] = ullcurrentReplayCounter;
+ pClientSTA->ullReplayCounter[ucTid] = ullcurrentReplayCounter;
}
else
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: Non-AMSDU Drop the replay packet with PN : [0x%llX]\n",ullcurrentReplayCounter);
- pTLCb->atlSTAClients[ucSTAId].ulTotalReplayPacketsDetected++;
+ pClientSTA->ulTotalReplayPacketsDetected++;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: Non-AMSDU total dropped replay packets on STA ID %X is [0x%lX]\n",
- ucSTAId, pTLCb->atlSTAClients[ucSTAId].ulTotalReplayPacketsDetected);
+ ucSTAId, pClientSTA->ulTotalReplayPacketsDetected);
/* Repaly packet, drop the packet */
vos_pkt_return_packet(vosDataBuff);
@@ -7508,7 +7785,7 @@
if ( NULL != vosDataBuff )
{
#ifdef WLAN_SOFTAP_FEATURE
- if( WLAN_STA_SOFTAP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType)
+ if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType)
{
WLANTL_FwdPktToHDD( pvosGCtx, vosDataBuff, ucSTAId );
}
@@ -7516,7 +7793,7 @@
#endif
{
wRxMetaInfo.ucUP = ucTid;
- pTLCb->atlSTAClients[ucSTAId].pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
+ pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
&wRxMetaInfo );
}
}/* if not NULL */
@@ -7872,8 +8149,9 @@
v_U8_t ucBcastSig;
v_U8_t staId;
#ifdef WLAN_SOFTAP_FEATURE
- WLANTL_CbType* pTLCb = NULL;
- WLANTL_ACEnumType ucAC;
+ WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
+ WLANTL_ACEnumType ucAC;
#endif
#if defined( FEATURE_WLAN_INTEGRATED_SOC )
void (*callbackRoutine) (void *callbackContext);
@@ -7933,9 +8211,18 @@
ucAC = message->bodyval & WLANTL_AC_MASK;
ucSTAId = (v_U8_t)(message->bodyval >> WLANTL_STAID_OFFSET);
- pTLCb->atlSTAClients[ucSTAId].aucACMask[ucAC] = 1;
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
- vos_atomic_set_U8( &pTLCb->atlSTAClients[ucSTAId].ucPktPending, 1);
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ pClientSTA->aucACMask[ucAC] = 1;
+
+ vos_atomic_set_U8( &pClientSTA->ucPktPending, 1);
vosStatus = WDA_DS_StartXmit(pvosGCtx);
break;
#endif
@@ -7956,8 +8243,17 @@
return VOS_STATUS_E_FAULT;
}
staId = message->reserved;
+ pClientSTA = pTLCb->atlSTAClients[staId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
//change for ULA
- if ( pTLCb->atlSTAClients[staId].ucEapolPktPending == 0 )
+ if ( pClientSTA->ucEapolPktPending == 0 )
{
//ULA notification done bc no eapol pending
callbackContext = (void *)message->bodyval;
@@ -7970,9 +8266,9 @@
//ULA notification delayed bc eapol pending
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:EAPOL pkt pending. ULA notification has been delayed..."));
- pTLCb->atlSTAClients[staId].ucULANotificationPending = 1;
- pTLCb->atlSTAClients[staId].callbackRoutine = message->bodyptr;
- pTLCb->atlSTAClients[staId].callbackContext = (void *)message->bodyval;
+ pClientSTA->ucULANotificationPending = 1;
+ pClientSTA->callbackRoutine = message->bodyptr;
+ pClientSTA->callbackContext = (void *)message->bodyval;
}
break;
#endif
@@ -8359,6 +8655,7 @@
v_U8_t MandatoryucHeaderSize = WLAN80211_MANDATORY_HEADER_SIZE;
v_U8_t ucHeaderSize = 0;
v_VOID_t *ppvBDHeader = NULL;
+ WLANTL_STAClientType* pClientSTA = NULL;
#ifdef WLAN_SOFTAP_FEATURE
v_U8_t ucQoSOffset = WLAN80211_MANDATORY_HEADER_SIZE;
#endif
@@ -8382,17 +8679,25 @@
return VOS_STATUS_E_INVAL;
}
ucStaId = *pucStaId;
+ pClientSTA = pTLCb->atlSTAClients[ucStaId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
#ifdef FEATURE_WLAN_TDLS
- if( WLAN_STA_INFRA == pTLCb->atlSTAClients[ucStaId].wSTADesc.wSTAType
+ if( WLAN_STA_INFRA == pClientSTA->wSTADesc.wSTAType
&& pTLCb->ucTdlsPeerCount)
{
v_U8_t ucIndex = 0;
for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT ; ucIndex++)
{
- if( ucIndex != ucStaId && pTLCb->atlSTAClients[ucIndex].ucExists &&
- vos_mem_compare( (void*)pTLCb->atlSTAClients[ucIndex].wSTADesc.vSTAMACAddress.bytes,
+ if( ucIndex != ucStaId && pClientSTA->ucExists &&
+ vos_mem_compare( (void*)pClientSTA->wSTADesc.vSTAMACAddress.bytes,
(void*)w8023Header.vDA, 6) )
{
TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
@@ -8406,7 +8711,7 @@
#endif
- if ( 0 != pTLCb->atlSTAClients[ucStaId].wSTADesc.ucAddRmvLLC )
+ if ( 0 != pClientSTA->wSTADesc.ucAddRmvLLC )
{
/* Push the length */
vosStatus = vos_pkt_push_head(vosDataBuff,
@@ -8457,17 +8762,17 @@
}
#ifdef BTAMP_TEST
- pTLCb->atlSTAClients[ucStaId].wSTADesc.wSTAType = WLAN_STA_BT_AMP;
+ pClientSTA->wSTADesc.wSTAType = WLAN_STA_BT_AMP;
#endif
// Find the space required for the 802.11 header format
// based on the frame control fields.
ucHeaderSize = MandatoryucHeaderSize;
- if (pTLCb->atlSTAClients[ucStaId].wSTADesc.ucQosEnabled)
+ if (pClientSTA->wSTADesc.ucQosEnabled)
{
ucHeaderSize += sizeof(pw80211Header->usQosCtrl);
}
- if (pTLCb->atlSTAClients[ucStaId].wSTADesc.wSTAType == WLAN_STA_BT_AMP)
+ if (pClientSTA->wSTADesc.wSTAType == WLAN_STA_BT_AMP)
{
ucHeaderSize += sizeof(pw80211Header->optvA4);
#ifdef WLAN_SOFTAP_FEATURE
@@ -8515,13 +8820,13 @@
#ifdef FEATURE_WLAN_WAPI
- if ( WLANTL_STA_AUTHENTICATED == pTLCb->atlSTAClients[ucStaId].tlState && gUcIsWai != 1 )
+ if ( WLANTL_STA_AUTHENTICATED == pClientSTA->tlState && gUcIsWai != 1 )
#else
- if ( WLANTL_STA_AUTHENTICATED == pTLCb->atlSTAClients[ucStaId].tlState )
+ if ( WLANTL_STA_AUTHENTICATED == pClientSTA->tlState )
#endif
{
pw80211Header->wFrmCtrl.wep =
- pTLCb->atlSTAClients[ucStaId].wSTADesc.ucProtectedFrame;
+ pClientSTA->wSTADesc.ucProtectedFrame;
}
pw80211Header->usDurationId = 0;
@@ -8531,7 +8836,7 @@
- if(pTLCb->atlSTAClients[ucStaId].wSTADesc.ucQosEnabled)
+ if(pClientSTA->wSTADesc.ucQosEnabled)
{
pw80211Header->wFrmCtrl.subType = WLANTL_80211_DATA_QOS_SUBTYPE;
@@ -8552,16 +8857,16 @@
}
- switch( pTLCb->atlSTAClients[ucStaId].wSTADesc.wSTAType )
+ switch( pClientSTA->wSTADesc.wSTAType )
{
case WLAN_STA_IBSS:
pw80211Header->wFrmCtrl.toDS = 0;
pw80211Header->wFrmCtrl.fromDS = 0;
/*Fix me*/
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSTAMACAddress);
+ &pClientSTA->wSTADesc.vSTAMACAddress);
vos_mem_copy( pw80211Header->vA3,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vBSSIDforIBSS ,
+ &pClientSTA->wSTADesc.vBSSIDforIBSS ,
VOS_MAC_ADDR_SIZE);
break;
@@ -8570,11 +8875,11 @@
pw80211Header->wFrmCtrl.toDS = 1;
pw80211Header->wFrmCtrl.fromDS = 1;
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSTAMACAddress);
+ &pClientSTA->wSTADesc.vSTAMACAddress);
vos_mem_copy( pw80211Header->vA2,
w8023Header.vSA, VOS_MAC_ADDR_SIZE);
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA3,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSTAMACAddress);
+ &pClientSTA->wSTADesc.vSTAMACAddress);
/* fill the optional A4 header */
vos_mem_copy( pw80211Header->optvA4,
w8023Header.vSA, VOS_MAC_ADDR_SIZE);
@@ -8591,7 +8896,7 @@
/*Copy the DA to A1*/
vos_mem_copy( pw80211Header->vA1, w8023Header.vDA , VOS_MAC_ADDR_SIZE);
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA2,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSelfMACAddress);
+ &pClientSTA->wSTADesc.vSelfMACAddress);
vos_mem_copy( pw80211Header->vA3,
w8023Header.vSA, VOS_MAC_ADDR_SIZE);
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
@@ -8605,9 +8910,9 @@
pw80211Header->wFrmCtrl.fromDS = 0;
/*Fix me*/
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSTAMACAddress);
+ &pClientSTA->wSTADesc.vSTAMACAddress);
vos_mem_copy( pw80211Header->vA3,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vBSSIDforIBSS ,
+ &pClientSTA->wSTADesc.vBSSIDforIBSS ,
VOS_MAC_ADDR_SIZE);
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
("TL:TDLS CASE NOW ---------staid=%d\n"), ucStaId);
@@ -8618,7 +8923,7 @@
pw80211Header->wFrmCtrl.toDS = 1;
pw80211Header->wFrmCtrl.fromDS = 0;
vos_copy_macaddr( (v_MACADDR_t*)&pw80211Header->vA1,
- &pTLCb->atlSTAClients[ucStaId].wSTADesc.vSTAMACAddress);
+ &pClientSTA->wSTADesc.vSTAMACAddress);
vos_mem_copy( pw80211Header->vA3, w8023Header.vDA , VOS_MAC_ADDR_SIZE);
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"REGULAR INFRA LINK CASE---------staid=%d\n",
@@ -8818,7 +9123,14 @@
}
}
- if ( 0 != pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucAddRmvLLC )
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 != pTLCb->atlSTAClients[ucSTAId]->wSTADesc.ucAddRmvLLC )
{
// Extract the LLC header
vosStatus = vos_pkt_pop_head( vosDataBuff, aucLLCHeader,
@@ -8939,6 +9251,13 @@
return VOS_STATUS_E_INVAL;
}
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*------------------------------------------------------------------------
Extract BD header and check if valid
------------------------------------------------------------------------*/
@@ -8953,7 +9272,7 @@
}
if ((0 == WDA_GET_RX_FT_DONE(aucBDHeader)) &&
- (0 != pTLCb->atlSTAClients[ucSTAId].wSTADesc.ucSwFrameRXXlation))
+ (0 != pTLCb->atlSTAClients[ucSTAId]->wSTADesc.ucSwFrameRXXlation))
{
/* Its an 802.11 frame, extract MAC address 1 */
TLLOG2(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
@@ -9353,21 +9672,28 @@
/* ! walk the STA table and check for :*/
for ( ucIndexSTA = 0; ucIndexSTA < WLAN_MAX_STA_COUNT; ucIndexSTA++ )
{
- WLAN_TL_AC_ARRAY_2_MASK (&pTLCb->atlSTAClients[ucIndexSTA], ucACMask, i);
- if ( ( pTLCb->atlSTAClients[ucIndexSTA].ucExists) &&
- ( WLANTL_STA_CONNECTED == pTLCb->atlSTAClients[ucIndexSTA].tlState) &&
- ((pTLCb->atlSTAClients[ucIndexSTA].ucPktPending) && !(ucACMask)) &&
+ if (NULL == pTLCb->atlSTAClients[ucIndexSTA])
+ {
+ continue;
+ }
+ WLAN_TL_AC_ARRAY_2_MASK (pTLCb->atlSTAClients[ucIndexSTA], ucACMask, i);
+ if ( ( pTLCb->atlSTAClients[ucIndexSTA]->ucExists) &&
+ ( WLANTL_STA_CONNECTED == pTLCb->atlSTAClients[ucIndexSTA]->tlState) &&
+ ((pTLCb->atlSTAClients[ucIndexSTA]->ucPktPending) && !(ucACMask)) &&
(0 != (ucACMask & uFlowMask)) )
{
// Find a station. Weight is updated already.
*pucSTAId = ucNextSTA;
pTLCb->ucCurrentSTA = ucNextSTA;
-
+ if(NULL == pTLCb->atlSTAClients[*pucSTAId])
+ {
+ continue;
+ }
//walk array : aucACMask[i] and pick the 1st one with the highest priority that is non 0
for( j = WLANTL_MAX_AC; j >= 0; j--)
{
- if( 0!= pTLCb->atlSTAClients[*pucSTAId].aucACMask[j] )
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC = pTLCb->atlSTAClients[*pucSTAId].aucACMask[i];
+ if( 0!= pTLCb->atlSTAClients[*pucSTAId]->aucACMask[j] )
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = pTLCb->atlSTAClients[*pucSTAId]->aucACMask[i];
}
TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
@@ -9426,10 +9752,14 @@
for ( ; ucNextSTA < WLAN_MAX_STA_COUNT; ucNextSTA ++ )
{
- WLAN_TL_AC_ARRAY_2_MASK (&pTLCb->atlSTAClients[ucNextSTA], ucACMask, i);
+ if(NULL == pTLCb->atlSTAClients[ucNextSTA])
+ {
+ continue;
+ }
+ WLAN_TL_AC_ARRAY_2_MASK (pTLCb->atlSTAClients[ucNextSTA], ucACMask, i);
- if ( (0 == pTLCb->atlSTAClients[ucNextSTA].ucExists) ||
- ((0 == pTLCb->atlSTAClients[ucNextSTA].ucPktPending) && !(ucACMask)) ||
+ if ( (0 == pTLCb->atlSTAClients[ucNextSTA]->ucExists) ||
+ ((0 == pTLCb->atlSTAClients[ucNextSTA]->ucPktPending) && !(ucACMask)) ||
(0 == (ucACMask & ucACFilter)) )
{
@@ -9441,9 +9771,9 @@
//Station is allowed to send when it is not in LWM mode. When station is in LWM mode,
//station is allowed to send only after FW reports FW memory is below threshold and on-fly
//packets are less then allowed value
- if ( (TRUE == pTLCb->atlSTAClients[ucNextSTA].ucLwmModeEnabled) &&
- ((FALSE == pTLCb->atlSTAClients[ucNextSTA].ucLwmEventReported) ||
- (0 < pTLCb->atlSTAClients[ucNextSTA].uBuffThresholdMax))
+ if ( (TRUE == pTLCb->atlSTAClients[ucNextSTA]->ucLwmModeEnabled) &&
+ ((FALSE == pTLCb->atlSTAClients[ucNextSTA]->ucLwmEventReported) ||
+ (0 < pTLCb->atlSTAClients[ucNextSTA]->uBuffThresholdMax))
)
{
continue;
@@ -9453,7 +9783,7 @@
// Find a station. Weight is updated already.
*pucSTAId = ucNextSTA;
pTLCb->ucCurrentSTA = ucNextSTA;
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC = pTLCb->uCurServedAC;
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC = pTLCb->uCurServedAC;
TLLOG4(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,
" TL serve one station AC: %d W: %d StaId: %d",
@@ -9593,9 +9923,12 @@
ucCount++ )
{
ucNextSTA = ( (ucNextSTA+1) >= WLAN_MAX_STA_COUNT )?0:(ucNextSTA+1);
-
- if (( pTLCb->atlSTAClients[ucNextSTA].ucExists ) &&
- ( pTLCb->atlSTAClients[ucNextSTA].ucPktPending ))
+ if(NULL == pTLCb->atlSTAClients[ucNextSTA])
+ {
+ continue;
+ }
+ if (( pTLCb->atlSTAClients[ucNextSTA]->ucExists ) &&
+ ( pTLCb->atlSTAClients[ucNextSTA]->ucPktPending ))
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"STA ID: %d on WLAN_TLGetNextTxIds", *pucSTAId));
@@ -9616,7 +9949,7 @@
}
/*Convert the array to a mask for easier operation*/
- WLAN_TL_AC_ARRAY_2_MASK( &pTLCb->atlSTAClients[*pucSTAId], ucACMask, i);
+ WLAN_TL_AC_ARRAY_2_MASK( pTLCb->atlSTAClients[*pucSTAId], ucACMask, i);
if ( 0 == ucACMask )
{
@@ -9635,19 +9968,19 @@
weight of such an AC cannot be 0 -> in this case TL is expected to
exit this function at this point during the main Tx loop
-----------------------------------------------------------------------*/
- if ( 0 < pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight )
+ if ( 0 < pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight )
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Maintaining serviced AC to: %d for Weight: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC ,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC ,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
return VOS_STATUS_SUCCESS;
}
/*-----------------------------------------------------------------------
Choose highest priority AC - !!! optimize me
-----------------------------------------------------------------------*/
- ucNextAC = pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC;
+ ucNextAC = pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"Next AC: %d", ucNextAC));
@@ -9659,15 +9992,15 @@
if ( 0 != ( ucACMask & ( 1 << ucNextAC ) & uFlowMask ))
{
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC =
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC =
(WLANTL_ACEnumType)ucNextAC;
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight =
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight =
pTLCb->tlConfigInfo.ucAcWeights[ucNextAC];
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Switching serviced AC to: %d with Weight: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC ,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC ,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
break;
}
@@ -9680,8 +10013,8 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
" C AC: %d C W: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
return VOS_STATUS_SUCCESS;
}/* WLAN_TLGetNextTxIds */
@@ -9749,9 +10082,12 @@
ucCount++ )
{
ucNextSTA = ( (ucNextSTA+1) >= WLAN_MAX_STA_COUNT )?0:(ucNextSTA+1);
-
- if (( pTLCb->atlSTAClients[ucNextSTA].ucExists ) &&
- ( pTLCb->atlSTAClients[ucNextSTA].ucPktPending ))
+ if(NULL == pTLCb->atlSTAClients[ucNextSTA])
+ {
+ continue;
+ }
+ if (( pTLCb->atlSTAClients[ucNextSTA]->ucExists ) &&
+ ( pTLCb->atlSTAClients[ucNextSTA]->ucPktPending ))
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:No station registered with TL at this point or Mask 0"
@@ -9781,19 +10117,19 @@
weight of such an AC cannot be 0 -> in this case TL is expected to
exit this function at this point during the main Tx loop
-----------------------------------------------------------------------*/
- if ( 0 < pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight )
+ if ( 0 < pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight )
{
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Maintaining serviced AC to: %d for Weight: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC ,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC ,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
return VOS_STATUS_SUCCESS;
}
/*-----------------------------------------------------------------------
Choose highest priority AC - !!! optimize me
-----------------------------------------------------------------------*/
- ucNextAC = pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC;
+ ucNextAC = pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"Next AC: %d", ucNextAC));
@@ -9803,17 +10139,17 @@
" AC Mask: %d Next: %d Res : %d",
ucACMask, ( 1 << ucNextAC ), ( ucACMask & ( 1 << ucNextAC ))));
- if ( 0 != pTLCb->atlSTAClients[*pucSTAId].aucACMask[ucNextAC] )
+ if ( 0 != pTLCb->atlSTAClients[*pucSTAId]->aucACMask[ucNextAC] )
{
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC =
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC =
(WLANTL_ACEnumType)ucNextAC;
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight =
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight =
pTLCb->tlConfigInfo.ucAcWeights[ucNextAC];
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Switching serviced AC to: %d with Weight: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC ,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC ,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
break;
}
@@ -9826,8 +10162,8 @@
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
" C AC: %d C W: %d",
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentAC,
- pTLCb->atlSTAClients[*pucSTAId].ucCurrentWeight));
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentAC,
+ pTLCb->atlSTAClients[*pucSTAId]->ucCurrentWeight));
return VOS_STATUS_SUCCESS;
}/* WLAN_TLGetNextTxIds */
@@ -10097,7 +10433,10 @@
-------------------------------------------------------------------------*/
for ( ucIndex = 0; ucIndex < WLAN_MAX_STA_COUNT ; ucIndex++)
{
- WLANTL_CleanSTA( &pTLCb->atlSTAClients[ucIndex], ucEmpty);
+ if(NULL != pTLCb->atlSTAClients[ucIndex])
+ {
+ WLANTL_CleanSTA( pTLCb->atlSTAClients[ucIndex], ucEmpty);
+ }
}
/*-------------------------------------------------------------------------
@@ -10369,8 +10708,15 @@
return VOS_STATUS_E_FAULT;
}
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*Set this flag in order to remember that this is a trigger enabled AC*/
- pTLCb->atlSTAClients[ucSTAId].wUAPSDInfo[ucAC].ucSet = 1;
+ pTLCb->atlSTAClients[ucSTAId]->wUAPSDInfo[ucAC].ucSet = 1;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Enabling U-APSD in FW for STA: %d AC: %d SI: %d SPI: %d "
@@ -10448,8 +10794,15 @@
return VOS_STATUS_E_FAULT;
}
+ if ( NULL == pTLCb->atlSTAClients[ucSTAId] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*Reset this flag as this is no longer a trigger enabled AC*/
- pTLCb->atlSTAClients[ucSTAId].wUAPSDInfo[ucAC].ucSet = 1;
+ pTLCb->atlSTAClients[ucSTAId]->wUAPSDInfo[ucAC].ucSet = 1;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:Disabling U-APSD in FW for STA: %d AC: %d ",
@@ -10664,6 +11017,7 @@
)
{
WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter);
+ WLANTL_STAClientType* pClientSTA = NULL;
VOS_STATUS status = VOS_STATUS_SUCCESS;
WLANTL_TRANSFER_STA_TYPE *statistics = NULL;
@@ -10671,14 +11025,23 @@
Sanity check
Extract TL control block
------------------------------------------------------------------------*/
- if (NULL == pTLCb)
+ if ( NULL == pTLCb )
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Invalid TL pointer on WLANTL_GetStatistics"));
return VOS_STATUS_E_FAULT;
}
- if(0 == pTLCb->atlSTAClients[STAid].ucExists)
+ pClientSTA = pTLCb->atlSTAClients[STAid];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if(0 == pClientSTA->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: %d STA ID does not exist", STAid));
@@ -10692,7 +11055,7 @@
return VOS_STATUS_E_INVAL;
}
- statistics = &pTLCb->atlSTAClients[STAid].trafficStatistics;
+ statistics = &pClientSTA->trafficStatistics;
memcpy(statBuffer, statistics, sizeof(WLANTL_TRANSFER_STA_TYPE));
return status;
@@ -10721,6 +11084,7 @@
)
{
WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter);
+ WLANTL_STAClientType* pClientSTA = NULL;
VOS_STATUS status = VOS_STATUS_SUCCESS;
WLANTL_TRANSFER_STA_TYPE *statistics = NULL;
@@ -10735,14 +11099,23 @@
return VOS_STATUS_E_FAULT;
}
- if(0 == pTLCb->atlSTAClients[STAid].ucExists)
+ pClientSTA = pTLCb->atlSTAClients[STAid];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if(0 == pClientSTA->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: %d STA ID does not exist", STAid));
return VOS_STATUS_E_INVAL;
}
- statistics = &pTLCb->atlSTAClients[STAid].trafficStatistics;
+ statistics = &pClientSTA->trafficStatistics;
vos_mem_zero((v_VOID_t *)statistics, sizeof(WLANTL_TRANSFER_STA_TYPE));
return status;
@@ -10775,6 +11148,7 @@
)
{
WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter);
+ WLANTL_STAClientType* pClientSTA = NULL;
VOS_STATUS status = VOS_STATUS_SUCCESS;
WLANTL_TRANSFER_STA_TYPE *statistics = NULL;
@@ -10788,8 +11162,16 @@
"WLAN TL:Invalid TL pointer on WLANTL_GetStatistics"));
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[STAid];
- if(0 == pTLCb->atlSTAClients[STAid].ucExists)
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if(0 == pClientSTA->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: %d STA ID does not exist", STAid));
@@ -10803,7 +11185,7 @@
return VOS_STATUS_E_INVAL;
}
- statistics = &pTLCb->atlSTAClients[STAid].trafficStatistics;
+ statistics = &pClientSTA->trafficStatistics;
switch(statType)
{
case WLANTL_STATIC_TX_UC_FCNT:
@@ -10902,6 +11284,7 @@
)
{
WLANTL_CbType *pTLCb = VOS_GET_TL_CB(pAdapter);
+ WLANTL_STAClientType* pClientSTA = NULL;
VOS_STATUS status = VOS_STATUS_SUCCESS;
WLANTL_TRANSFER_STA_TYPE *statistics = NULL;
@@ -10916,14 +11299,23 @@
return VOS_STATUS_E_FAULT;
}
- if(0 == pTLCb->atlSTAClients[STAid].ucExists)
+ pClientSTA = pTLCb->atlSTAClients[STAid];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if(0 == pClientSTA->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL: %d STA ID does not exist", STAid));
return VOS_STATUS_E_INVAL;
}
- statistics = &pTLCb->atlSTAClients[STAid].trafficStatistics;
+ statistics = &pClientSTA->trafficStatistics;
switch(statType)
{
case WLANTL_STATIC_TX_UC_FCNT:
@@ -11023,11 +11415,18 @@
return VOS_STATUS_E_INVAL;
}
+ if ( NULL == tlCtxt->atlSTAClients[STAid] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
currentRSSI0 = WLANTL_GETRSSI0(pBDHeader);
currentRSSI1 = WLANTL_GETRSSI1(pBDHeader);
currentRSSI = (currentRSSI0 > currentRSSI1) ? currentRSSI0 : currentRSSI1;
- tlCtxt->atlSTAClients[STAid].rssiAvg = currentRSSI;
+ tlCtxt->atlSTAClients[STAid]->rssiAvg = currentRSSI;
return VOS_STATUS_SUCCESS;
}
@@ -11313,7 +11712,11 @@
// Sum up all the statistics for stations of Soft AP from TL
for (i = 0; i < WLAN_MAX_STA_COUNT; i++)
{
- if (pTLCb->atlSTAClients[i].wSTADesc.wSTAType == WLAN_STA_SOFTAP)
+ if ( NULL == pTLCb->atlSTAClients[i])
+ {
+ continue;
+ }
+ if (pTLCb->atlSTAClients[i]->wSTADesc.wSTAType == WLAN_STA_SOFTAP)
{
vosStatus = WLANTL_GetStatistics(pAdapter, &statBufferTemp, i);// Can include staId 1 because statistics not collected for it
@@ -11570,8 +11973,8 @@
{
WLANTL_CbType* pTLCb = VOS_GET_TL_CB(pvosGCtx);
- if (NULL != pTLCb)
+ if (NULL != pTLCb && NULL != pTLCb->atlSTAClients[staId])
{
- pTLCb->atlSTAClients[staId].rssiAvgBmps = rssi;
+ pTLCb->atlSTAClients[staId]->rssiAvgBmps = rssi;
}
}
diff --git a/CORE/TL/src/wlan_qct_tl_ba.c b/CORE/TL/src/wlan_qct_tl_ba.c
index bf97826..013650c 100644
--- a/CORE/TL/src/wlan_qct_tl_ba.c
+++ b/CORE/TL/src/wlan_qct_tl_ba.c
@@ -127,6 +127,7 @@
WLANTL_TIMER_EXPIER_UDATA_T *expireHandle;
WLANTL_BAReorderType *ReorderInfo;
WLANTL_CbType *pTLHandle;
+ WLANTL_STAClientType* pClientSTA = NULL;
vos_pkt_t *vosDataBuff;
VOS_STATUS status = VOS_STATUS_SUCCESS;
v_U8_t ucSTAID;
@@ -159,7 +160,14 @@
return;
}
- ReorderInfo = &pTLHandle->atlSTAClients[ucSTAID].atlBAReorderInfo[ucTID];
+ pClientSTA = pTLHandle->atlSTAClients[ucSTAID];
+ if( NULL == pClientSTA ){
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated for STA ID: %d on %s", ucSTAID, __func__));
+ return;
+ }
+
+ ReorderInfo = &pClientSTA->atlBAReorderInfo[ucTID];
if(NULL == ReorderInfo)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"Reorder data NULL, this could not happen SID %d, TID %d",
@@ -167,7 +175,7 @@
return;
}
- if(0 == pTLHandle->atlSTAClients[ucSTAID].atlBAReorderInfo[ucTID].ucExists)
+ if(0 == pClientSTA->atlBAReorderInfo[ucTID].ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"Reorder session doesn't exist SID %d, TID %d",
ucSTAID, ucTID));
@@ -180,7 +188,7 @@
return;
}
- if( pTLHandle->atlSTAClients[ucSTAID].atlBAReorderInfo[ucTID].ucExists == 0 )
+ if( 0 == pClientSTA->atlBAReorderInfo[ucTID].ucExists )
{
vos_lock_release(&ReorderInfo->reorderLock);
return;
@@ -213,7 +221,7 @@
#ifdef ANI_CHIPSET_VOLANS
/* Do replay check before giving packets to upper layer
replay check code : check whether replay check is needed or not */
- if(VOS_TRUE == pTLHandle->atlSTAClients[ucSTAID].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
v_U64_t ullpreviousReplayCounter = 0;
v_U64_t ullcurrentReplayCounter = 0;
@@ -224,7 +232,7 @@
for(ucloopCounter = 0; ucloopCounter < WLANTL_MAX_WINSIZE; ucloopCounter++)
{
/*Get previous reply counter*/
- ullpreviousReplayCounter = pTLHandle->atlSTAClients[ucSTAID].ullReplayCounter[ucTID];
+ ullpreviousReplayCounter = pClientSTA->ullReplayCounter[ucTID];
/*Get current replay counter of packet in reorder buffer*/
ullcurrentReplayCounter = ReorderInfo->reorderBuffer->ullReplayCounter[ucloopCounter];
@@ -238,12 +246,12 @@
if(VOS_TRUE == status)
{
/*Increment the debug counter*/
- pTLHandle->atlSTAClients[ucSTAID].ulTotalReplayPacketsDetected++;
+ pClientSTA->ulTotalReplayPacketsDetected++;
/*A replay packet found*/
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLANTL_ReorderingAgingTimerExpierCB: total dropped replay packets on STA ID %X is [0x%lX]\n",
- ucSTAID, pTLHandle->atlSTAClients[ucSTAID].ulTotalReplayPacketsDetected);
+ ucSTAID, pClientSTA->ulTotalReplayPacketsDetected);
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLANTL_ReorderingAgingTimerExpierCB: replay packet found with PN : [0x%llX]\n",
@@ -259,7 +267,7 @@
else
{
/*Not a replay packet update previous replay counter*/
- pTLHandle->atlSTAClients[ucSTAID].ullReplayCounter[ucTID] = ullcurrentReplayCounter;
+ pClientSTA->ullReplayCounter[ucTID] = ullcurrentReplayCounter;
}
}
else
@@ -284,7 +292,7 @@
return;
}
- if(NULL == pTLHandle->atlSTAClients[ucSTAID].pfnSTARx)
+ if(NULL == pClientSTA->pfnSTARx)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"Callback function NULL with STAID %d", ucSTAID));
if(!VOS_IS_STATUS_SUCCESS(vos_lock_release(&ReorderInfo->reorderLock)))
@@ -305,7 +313,7 @@
}
#ifdef WLAN_SOFTAP_FEATURE
- if( WLAN_STA_SOFTAP == pTLHandle->atlSTAClients[ucSTAID].wSTADesc.wSTAType)
+ if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType)
{
WLANTL_FwdPktToHDD( expireHandle->pAdapter, vosDataBuff, ucSTAID);
}
@@ -313,7 +321,7 @@
#endif
{
wRxMetaInfo.ucUP = ucTID;
- pTLHandle->atlSTAClients[ucSTAID].pfnSTARx(expireHandle->pAdapter,
+ pClientSTA->pfnSTARx(expireHandle->pAdapter,
vosDataBuff, ucSTAID, &wRxMetaInfo);
}
if(!VOS_IS_STATUS_SUCCESS(vos_lock_release(&ReorderInfo->reorderLock)))
@@ -421,7 +429,8 @@
v_U32_t SSN
)
{
- WLANTL_CbType *pTLCb = NULL;
+ WLANTL_CbType *pTLCb = NULL;
+ WLANTL_STAClientType *pClientSTA = NULL;
WLANTL_BAReorderType *reorderInfo;
v_U32_t idx;
VOS_STATUS status = VOS_STATUS_SUCCESS;
@@ -455,7 +464,16 @@
return VOS_STATUS_E_FAULT;
}
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists )
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if ( 0 == pClientSTA->ucExists )
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:Station was not yet registered on WLANTL_BaSessionAdd");
@@ -465,9 +483,9 @@
/*------------------------------------------------------------------------
Verify that BA session was not already added
------------------------------------------------------------------------*/
- if ( 0 != pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists )
+ if ( 0 != pClientSTA->atlBAReorderInfo[ucTid].ucExists )
{
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists++;
+ pClientSTA->atlBAReorderInfo[ucTid].ucExists++;
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"WLAN TL:BA session already exists on WLANTL_BaSessionAdd");
return VOS_STATUS_E_EXISTS;
@@ -476,18 +494,18 @@
/*------------------------------------------------------------------------
Initialize new BA session
------------------------------------------------------------------------*/
- reorderInfo = &pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid];
+ reorderInfo = &pClientSTA->atlBAReorderInfo[ucTid];
for(idx = 0; idx < WLANTL_MAX_BA_SESSION; idx++)
{
if(VOS_TRUE == pTLCb->reorderBufferPool[idx].isAvailable)
{
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].reorderBuffer =
+ pClientSTA->atlBAReorderInfo[ucTid].reorderBuffer =
&(pTLCb->reorderBufferPool[idx]);
pTLCb->reorderBufferPool[idx].isAvailable = VOS_FALSE;
TLLOG4(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_LOW,"%dth buffer available, buffer PTR 0x%p",
idx,
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].reorderBuffer
+ pClientSTA->atlBAReorderInfo[ucTid].reorderBuffer
));
break;
}
@@ -495,7 +513,7 @@
#ifdef WLAN_SOFTAP_FEATURE
- if( WLAN_STA_SOFTAP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType)
+ if( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType)
{
if( WLANTL_MAX_BA_SESSION == idx)
{
@@ -531,21 +549,20 @@
return status;
}
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists++;
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].usCount = 0;
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucCIndex = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].ucExists++;
+ pClientSTA->atlBAReorderInfo[ucTid].usCount = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].ucCIndex = 0;
if(0 == winSize)
{
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].winSize =
- WLANTL_MAX_WINSIZE;
+ pClientSTA->atlBAReorderInfo[ucTid].winSize = WLANTL_MAX_WINSIZE;
}
else
{
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].winSize = winSize;
+ pClientSTA->atlBAReorderInfo[ucTid].winSize = winSize;
}
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].SSN = SSN;
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].sessionID = sessionID;
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].pendingFramesCount = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].SSN = SSN;
+ pClientSTA->atlBAReorderInfo[ucTid].sessionID = sessionID;
+ pClientSTA->atlBAReorderInfo[ucTid].pendingFramesCount = 0;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:New BA session added for STA: %d TID: %d",
ucSTAId, ucTid));
@@ -592,7 +609,8 @@
v_U8_t ucTid
)
{
- WLANTL_CbType* pTLCb = NULL;
+ WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType *pClientSTA = NULL;
vos_pkt_t* vosDataBuff = NULL;
VOS_STATUS vosStatus = VOS_STATUS_E_FAILURE;
VOS_STATUS lockStatus = VOS_STATUS_E_FAILURE;
@@ -630,20 +648,29 @@
return VOS_STATUS_E_FAULT;
}
- if (( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists ) &&
- ( 0 == pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists ))
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if (( 0 == pClientSTA->ucExists ) &&
+ ( 0 == pClientSTA->atlBAReorderInfo[ucTid].ucExists ))
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN,
"WLAN TL:Station was not yet registered on WLANTL_BaSessionDel");
return VOS_STATUS_E_EXISTS;
}
- else if(( 0 == pTLCb->atlSTAClients[ucSTAId].ucExists ) &&
- ( 0 != pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists ))
+ else if(( 0 == pClientSTA->ucExists ) &&
+ ( 0 != pClientSTA->atlBAReorderInfo[ucTid].ucExists ))
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_WARN,
"STA was deleted but BA info is still there, just remove BA info");
- reOrderInfo = &pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid];
+ reOrderInfo = &pClientSTA->atlBAReorderInfo[ucTid];
reOrderInfo->reorderBuffer->isAvailable = VOS_TRUE;
memset(&reOrderInfo->reorderBuffer->arrayBuffer[0],
0,
@@ -657,7 +684,7 @@
/*------------------------------------------------------------------------
Verify that BA session was added
------------------------------------------------------------------------*/
- if ( 0 == pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists )
+ if ( 0 == pClientSTA->atlBAReorderInfo[ucTid].ucExists )
{
VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL:BA session does not exists on WLANTL_BaSessionDel");
@@ -668,7 +695,7 @@
/*------------------------------------------------------------------------
Send all pending packets to HDD
------------------------------------------------------------------------*/
- reOrderInfo = &pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid];
+ reOrderInfo = &pClientSTA->atlBAReorderInfo[ucTid];
/*------------------------------------------------------------------------
Invalidate reorder info here. This ensures that no packets are
@@ -681,7 +708,7 @@
"Unable to acquire reorder vos lock in %s\n", __func__));
return lockStatus;
}
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].ucExists = 0;
TLLOG2(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_HIGH,
"WLAN TL: Fwd all packets to HDD on WLANTL_BaSessionDel"));
@@ -709,7 +736,7 @@
vosDataBuff ));
#ifdef WLAN_SOFTAP_FEATURE
- if ( WLAN_STA_SOFTAP == pTLCb->atlSTAClients[ucSTAId].wSTADesc.wSTAType )
+ if ( WLAN_STA_SOFTAP == pClientSTA->wSTADesc.wSTAType )
{
WLANTL_FwdPktToHDD( pvosGCtx, vosDataBuff, ucSTAId);
}
@@ -717,7 +744,7 @@
#endif
{
wRxMetaInfo.ucUP = ucTid;
- pTLCb->atlSTAClients[ucSTAId].pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
+ pClientSTA->pfnSTARx( pvosGCtx, vosDataBuff, ucSTAId,
&wRxMetaInfo );
}
}
@@ -755,8 +782,8 @@
/*------------------------------------------------------------------------
Delete session
------------------------------------------------------------------------*/
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].usCount = 0;
- pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucCIndex = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].usCount = 0;
+ pClientSTA->atlBAReorderInfo[ucTid].ucCIndex = 0;
reOrderInfo->winSize = 0;
reOrderInfo->SSN = 0;
reOrderInfo->sessionID = 0;
@@ -846,6 +873,7 @@
v_U8_t ucFsf; /* First AMSDU sub frame */
v_U8_t ucAef; /* Error in AMSDU sub frame */
WLANTL_CbType* pTLCb = NULL;
+ WLANTL_STAClientType *pClientSTA = NULL;
v_U8_t MPDUHeaderAMSDUHeader[WLANTL_MPDU_HEADER_LEN + TL_AMSDU_SUBFRM_HEADER_LEN];
v_U16_t subFrameLength;
v_U16_t paddingSize;
@@ -878,6 +906,15 @@
return VOS_STATUS_E_FAULT;
}
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*------------------------------------------------------------------------
Check frame
------------------------------------------------------------------------*/
@@ -915,13 +952,13 @@
*ppVosDataBuff = NULL;
return VOS_STATUS_SUCCESS; /*Not a transport error*/
}
- pTLCb->atlSTAClients[ucSTAId].ucMPDUHeaderLen = ucMPDUHLen;
- memcpy(pTLCb->atlSTAClients[ucSTAId].aucMPDUHeader, MPDUHeaderAMSDUHeader, ucMPDUHLen);
- /* AMSDU header stored to handle gabage data within next frame */
+ pClientSTA->ucMPDUHeaderLen = ucMPDUHLen;
+ memcpy(pClientSTA->aucMPDUHeader, MPDUHeaderAMSDUHeader, ucMPDUHLen);
+ /* AMSDU header stored to handle garbage data within next frame */
}
else
{
- /* Trim gabage, size is frameLoop */
+ /* Trim garbage, size is frameLoop */
if(MPDUDataOffset > 0)
{
vStatus = vos_pkt_trim_head(vosDataBuff, MPDUDataOffset);
@@ -946,7 +983,7 @@
} /* End of henalding not first sub frame specific */
/* Put in MPDU header into all the frame */
- vStatus = vos_pkt_push_head(vosDataBuff, pTLCb->atlSTAClients[ucSTAId].aucMPDUHeader, pTLCb->atlSTAClients[ucSTAId].ucMPDUHeaderLen);
+ vStatus = vos_pkt_push_head(vosDataBuff, pClientSTA->aucMPDUHeader, pClientSTA->ucMPDUHeaderLen);
if(!VOS_IS_STATUS_SUCCESS(vStatus))
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"MPDU Header Push back fail"));
@@ -1027,6 +1064,7 @@
)
{
WLANTL_BAReorderType *currentReorderInfo;
+ WLANTL_STAClientType *pClientSTA = NULL;
vos_pkt_t *vosPktIdx;
v_U8_t ucOpCode;
v_U8_t ucSlotIdx;
@@ -1048,7 +1086,16 @@
return VOS_STATUS_E_INVAL;
}
- currentReorderInfo = &pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid];
+ pClientSTA = pTLCb->atlSTAClients[ucSTAId];
+
+ if ( NULL == pClientSTA )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ currentReorderInfo = &pClientSTA->atlBAReorderInfo[ucTid];
lockStatus = vos_lock_acquire(¤tReorderInfo->reorderLock);
if(!VOS_IS_STATUS_SUCCESS(lockStatus))
@@ -1057,7 +1104,7 @@
return lockStatus;
}
- if( pTLCb->atlSTAClients[ucSTAId].atlBAReorderInfo[ucTid].ucExists == 0 )
+ if( pClientSTA->atlBAReorderInfo[ucTid].ucExists == 0 )
{
vos_lock_release(¤tReorderInfo->reorderLock);
return VOS_STATUS_E_INVAL;
@@ -1071,7 +1118,7 @@
#ifdef WLANTL_HAL_VOLANS
/* Replay check code : check whether replay check is needed or not */
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
/* Getting 48-bit replay counter from the RX BD */
ullreplayCounter = WDA_DS_GetReplayCounter(aucBDHeader);
@@ -1110,7 +1157,7 @@
vosDataBuff,
ucSlotIdx);
#ifdef ANI_CHIPSET_VOLANS
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
WLANTL_FillReplayCounter(currentReorderInfo,
ullreplayCounter, ucSlotIdx);
@@ -1213,7 +1260,7 @@
vosDataBuff,
ucSlotIdx);
#ifdef ANI_CHIPSET_VOLANS
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
WLANTL_FillReplayCounter(currentReorderInfo,
ullreplayCounter, ucSlotIdx);
@@ -1276,7 +1323,7 @@
vosDataBuff,
ucSlotIdx);
#ifdef ANI_CHIPSET_VOLANS
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
WLANTL_FillReplayCounter(currentReorderInfo,
ullreplayCounter, ucSlotIdx);
@@ -1413,7 +1460,7 @@
vosDataBuff,
ucSlotIdx);
#ifdef ANI_CHIPSET_VOLANS
- if(VOS_TRUE == pTLCb->atlSTAClients[ucSTAId].ucIsReplayCheckValid)
+ if(VOS_TRUE == pClientSTA->ucIsReplayCheckValid)
{
WLANTL_FillReplayCounter(currentReorderInfo,
ullreplayCounter, ucSlotIdx);
diff --git a/CORE/TL/src/wlan_qct_tl_hosupport.c b/CORE/TL/src/wlan_qct_tl_hosupport.c
index abd3778..6bf8362 100644
--- a/CORE/TL/src/wlan_qct_tl_hosupport.c
+++ b/CORE/TL/src/wlan_qct_tl_hosupport.c
@@ -224,7 +224,14 @@
return;
}
- if(tlCtxt->atlSTAClients[staId].ucExists == 0)
+ if(NULL == tlCtxt->atlSTAClients[staId])
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return;
+ }
+
+ if(0 == tlCtxt->atlSTAClients[staId]->ucExists )
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"WLAN TL: %d STA ID does not exist", staId));
return;
@@ -236,7 +243,7 @@
"flushed rateIdx counters"));
for(ii = 0; ii < MAX_RATE_INDEX; ii++)
- tlCtxt->atlSTAClients[staId].trafficStatistics.pktCounterRateIdx[ii] = 0;
+ tlCtxt->atlSTAClients[staId]->trafficStatistics.pktCounterRateIdx[ii] = 0;
return;
}
@@ -249,7 +256,7 @@
* " rateIndex = pktCount "*/
TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
"%d = %ld", ii+1,
- tlCtxt->atlSTAClients[staId].trafficStatistics.pktCounterRateIdx[ii]));
+ tlCtxt->atlSTAClients[staId]->trafficStatistics.pktCounterRateIdx[ii]));
}
return;
@@ -267,7 +274,14 @@
return;
}
- if(tlCtxt->atlSTAClients[staId].ucExists == 0)
+ if(NULL == tlCtxt->atlSTAClients[staId])
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return;
+ }
+
+ if(0 == tlCtxt->atlSTAClients[staId]->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"WLAN TL: %d STA ID does not exist", staId));
return;
@@ -279,7 +293,7 @@
"flushed rssi counters"));
for(ii = 0; ii < MAX_NUM_RSSI; ii++)
- tlCtxt->atlSTAClients[staId].trafficStatistics.pktCounterRssi[ii] = 0;
+ tlCtxt->atlSTAClients[staId]->trafficStatistics.pktCounterRssi[ii] = 0;
return;
}
@@ -291,7 +305,7 @@
count = 0;
for(jj = ii; jj < (ii + MAX_RSSI_INTERVAL); jj++)
- count += tlCtxt->atlSTAClients[staId].trafficStatistics.pktCounterRssi[jj];
+ count += tlCtxt->atlSTAClients[staId]->trafficStatistics.pktCounterRssi[jj];
/* prints are in the below format
* " fromRSSI - toRSSI = pktCount " */
@@ -299,7 +313,6 @@
" %d - %d = %ld",
ii, ii+(MAX_RSSI_INTERVAL - 1), count));
}
-
return;
}
#endif
@@ -527,19 +540,27 @@
return VOS_STATUS_E_INVAL;
}
+ if ( NULL == tlCtxt->atlSTAClients[STAid] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+
if(NULL == dataBuffer)
{
TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,"Management Frame, not need to handle with Stat"));
return status;
}
- if(0 == tlCtxt->atlSTAClients[STAid].ucExists)
+ if(0 == tlCtxt->atlSTAClients[STAid]->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"WLAN TL: %d STA ID is not exist", STAid));
return VOS_STATUS_E_INVAL;
}
- statistics = &tlCtxt->atlSTAClients[STAid].trafficStatistics;
+ statistics = &tlCtxt->atlSTAClients[STAid]->trafficStatistics;
vos_pkt_get_packet_length(dataBuffer, &packetSize);
if(isBroadcast)
@@ -598,14 +619,13 @@
#ifdef WLANTL_DEBUG
if( (statistics->rxRate - 1) < MAX_RATE_INDEX)
- tlCtxt->atlSTAClients[STAid].trafficStatistics.pktCounterRateIdx[statistics->rxRate - 1]++;
+ tlCtxt->atlSTAClients[STAid]->trafficStatistics.pktCounterRateIdx[statistics->rxRate - 1]++;
/* Check if the +ve value of RSSI is within the valid range.
* And increment pkt counter based on RSSI */
if( (v_U16_t)((WDA_GET_RX_RSSI_DB(pBDHeader)) * (-1)) < MAX_NUM_RSSI)
- tlCtxt->atlSTAClients[STAid].trafficStatistics.pktCounterRssi[(v_U16_t)((WDA_GET_RX_RSSI_DB(pBDHeader)) * (-1))]++;
+ tlCtxt->atlSTAClients[STAid]->trafficStatistics.pktCounterRssi[(v_U16_t)((WDA_GET_RX_RSSI_DB(pBDHeader)) * (-1))]++;
#endif
-
TLLOG1(VOS_TRACE (VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO_MED,
"****Received rate Index = %ld type=%d subtype=%d****\n",
statistics->rxRate,WDA_GET_RX_TYPE(pBDHeader),WDA_GET_RX_SUBTYPE(pBDHeader)));
@@ -652,14 +672,21 @@
return VOS_STATUS_E_INVAL;
}
- if(0 == tlCtxt->atlSTAClients[STAid].ucExists)
+ if ( NULL == tlCtxt->atlSTAClients[STAid] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
+ if(0 == tlCtxt->atlSTAClients[STAid]->ucExists)
{
TLLOGE(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,"WLAN TL: %d STA ID is not exist", STAid));
return VOS_STATUS_E_INVAL;
}
/* TODO : BC/MC/UC have to be determined by MAC address */
- statistics = &tlCtxt->atlSTAClients[STAid].trafficStatistics;
+ statistics = &tlCtxt->atlSTAClients[STAid]->trafficStatistics;
vos_pkt_get_packet_length(dataBuffer, &packetSize);
#ifdef FEATURE_WLAN_INTEGRATED_SOC
if(txMetaInfo->ucBcast)
@@ -837,6 +864,13 @@
return VOS_STATUS_E_INVAL;
}
+ if ( NULL == tlCtxt->atlSTAClients[STAid] )
+ {
+ TLLOGE(VOS_TRACE( VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_ERROR,
+ "WLAN TL:Client Memory was not allocated on %s", __func__));
+ return VOS_STATUS_E_FAILURE;
+ }
+
/*
Compute RSSI only for the last MPDU of an AMPDU.
Only last MPDU carries the Phy Stats Values
@@ -882,7 +916,7 @@
#endif
- tlCtxt->atlSTAClients[STAid].rssiAvg = *currentAvgRSSI;
+ tlCtxt->atlSTAClients[STAid]->rssiAvg = *currentAvgRSSI;
TLLOG1(VOS_TRACE(VOS_MODULE_ID_TL, VOS_TRACE_LEVEL_INFO,"Current new RSSI is %d, averaged RSSI is %d", currentRSSI, *currentAvgRSSI));
return status;
diff --git a/CORE/TL/src/wlan_qct_tli.h b/CORE/TL/src/wlan_qct_tli.h
index 1f0bc7b..f8874a2 100644
--- a/CORE/TL/src/wlan_qct_tli.h
+++ b/CORE/TL/src/wlan_qct_tli.h
@@ -39,8 +39,6 @@
* PERFORMANCE OF THIS SOFTWARE.
*/
-/*
- * */
#ifndef WLAN_QCT_TLI_H
#define WLAN_QCT_TLI_H
@@ -743,7 +741,8 @@
WLANTL_ConfigInfoType tlConfigInfo;
/* list of the active stations */
- WLANTL_STAClientType *atlSTAClients; /*Allocate memory [WLAN_MAX_STA_COUNT] of station */
+ WLANTL_STAClientType* atlSTAClients[WLAN_MAX_STA_COUNT];
+
/* information on the management frame client */
WLANTL_MgmtFrmClientType tlMgmtFrmClient;