/*
* txCtrlParams.c
*
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
* * Neither the name Texas Instruments nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*******************************************************************************/
/* */
/* MODULE: txCtrlParams.c */
/* PURPOSE: The txCtrl module parameters handling. */
/* This is a part of the txCtrl module (using the same object). */
/* */
/*******************************************************************************/
#define __FILE_ID__ FILE_ID_57
#include "tidef.h"
#include "report.h"
#include "paramOut.h"
#include "osApi.h"
#include "timer.h"
#include "EvHandler.h"
#include "txCtrl.h"
/***********************************************************************
* calcCreditFromTimer
***********************************************************************
DESCRIPTION: This function is called when credit calculation timer
is expired. it calculate the credit for the admission ctrl
credit algorithm
INPUT: hTxCtrl - handle to the ts data object
bTwdInitOccured - Indicates if TWDriver recovery occured since timer started
OUTPUT: None
RETURN: void
************************************************************************/
static void calcCreditFromTimer(TI_HANDLE hTxCtrl, TI_BOOL bTwdInitOccured)
{
OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS mediumTimeCross;
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
TI_UINT32 ac;
TI_INT32 prevCredit;
TI_INT32 highCreditThreshold;
TI_INT32 lowCreditThreshold;
TI_INT32 usageRatio;
TI_INT32 currUsage;
TI_INT32 prevUsage;
TI_UINT32 currentTimeStamp = os_timeStampMs(pTxCtrl->hOs); /* get current time stamp */
/*
* For each AC under admission control calculate the new usage and credit time,
* and send events if a threshold is crossed.
*/
for(ac = 0 ; ac < MAX_NUM_OF_AC ; ac++)
{
/* check if this queue is under admission ctrl operation */
if(pTxCtrl->mediumTime[ac] == 0)
{
TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, ": ac = %d mediumTime = 0 \n", ac);
continue;
}
/* in case of wraparound */
if(currentTimeStamp < pTxCtrl->lastCreditCalcTimeStamp[ac])
pTxCtrl->lastCreditCalcTimeStamp[ac] = 0;
/* store prev credit */
prevCredit = pTxCtrl->credit[ac];
/* Calculate the medium usage ratio: totalUsedTime / mediumTime * 1000
Note that since the totalUsedTime is in usec and not msec we don't multiply by 1000. */
usageRatio = pTxCtrl->totalUsedTime[ac] / pTxCtrl->mediumTime[ac];
/* calculate credit */
pTxCtrl->credit[ac] += (currentTimeStamp - pTxCtrl->lastCreditCalcTimeStamp[ac]) - usageRatio;
/* update last time stamp */
pTxCtrl->lastCreditCalcTimeStamp[ac] = currentTimeStamp;
/* in case credit is bigger than mediumTime -> set credit to medium time */
if (pTxCtrl->credit[ac] > (TI_INT32)(pTxCtrl->mediumTime[ac]) )
pTxCtrl->credit[ac] = pTxCtrl->mediumTime[ac];
TRACE2(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "credit = %d | TotalUsedTime = %d\n", pTxCtrl->credit[ac], pTxCtrl->totalUsedTime[ac]/1000);
/* Check medium-usage threshold cross events */
/*********************************************/
/*
* The medium-usage events are defined as follows:
* The high threshold triggers event only when crossed upward (traffic increased above threshold).
* The low threshold triggers event only when crossed downward (traffic decreased below threshold).
* Thus, the two thresholds provide hysteresis and prevent multiple triggering.
* The high threshold should be greater than the low threshold.
*
* Note: The driver doesn't delay traffic even if violating the usage limit!
* It only indicates the user application about the thresholds crossing.
*/
highCreditThreshold = (TI_INT32)((pTxCtrl->mediumTime[ac])*(pTxCtrl->highMediumUsageThreshold[ac])/100);
lowCreditThreshold = (TI_INT32)((pTxCtrl->mediumTime[ac])*(pTxCtrl->lowMediumUsageThreshold[ac])/100);
/* The credit is getting more negative as we get closer to the medium usage limit, so we invert
it before comparing to the thresholds (lower credit means higher usage). */
currUsage = -pTxCtrl->credit[ac];
prevUsage = -prevCredit;
/* crossing below the low threshold */
if ( (currUsage < lowCreditThreshold) && (prevUsage >= lowCreditThreshold) )
{
/* send event */
mediumTimeCross.uAC = ac;
mediumTimeCross.uHighOrLowThresholdFlag = (TI_UINT32)LOW_THRESHOLD_CROSS;
mediumTimeCross.uAboveOrBelowFlag = (TI_UINT32)CROSS_BELOW;
EvHandlerSendEvent(pTxCtrl->hEvHandler, IPC_EVENT_MEDIUM_TIME_CROSS,
(TI_UINT8 *)&mediumTimeCross, sizeof(OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS));
TRACE3(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "crossed below low threshold !!! prevUsage = %d, currUsage = %d, lowCreditThreshold = %d\n", prevUsage, currUsage, lowCreditThreshold);
}
/* crossing above the high threshold */
else if ( (currUsage > highCreditThreshold) && (prevUsage <= highCreditThreshold) )
{
/* send event */
mediumTimeCross.uAC = ac;
mediumTimeCross.uHighOrLowThresholdFlag = (TI_UINT32)HIGH_THRESHOLD_CROSS;
mediumTimeCross.uAboveOrBelowFlag = (TI_UINT32)CROSS_ABOVE;
EvHandlerSendEvent(pTxCtrl->hEvHandler, IPC_EVENT_MEDIUM_TIME_CROSS,
(TI_UINT8 *)&mediumTimeCross, sizeof(OS_802_11_THRESHOLD_CROSS_INDICATION_PARAMS));
TRACE3(pTxCtrl->hReport, REPORT_SEVERITY_INFORMATION, "crossed above high threshold !!! prevUsage = %d, currUsage = %d, highCreditThreshold = %d\n", prevUsage, currUsage, highCreditThreshold);
}
/* reset totalUsedTime */
pTxCtrl->totalUsedTime[ac] = 0;
}
}
/****************************************************************************
* updateDataPktPrototype()
****************************************************************************
* DESCRIPTION: Updates the data packet prototype values according to
changed parameters (e.g. rate policy change).
****************************************************************************/
static void updateDataPktPrototype(txCtrl_t *pTxCtrl)
{
pTxCtrl->dataPktDescAttrib = pTxCtrl->txSessionCount << TX_ATTR_OFST_SESSION_COUNTER;
}
/***************************************************************************
* txCtrlParams_resetCounters
****************************************************************************
* DESCRIPTION: Reset the tx data module counters
*
* INPUTS: hTxCtrl - the object
*
* OUTPUT:
*
* RETURNS:
***************************************************************************/
void txCtrlParams_resetCounters(TI_HANDLE hTxCtrl)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
os_memoryZero(pTxCtrl->hOs, &pTxCtrl->txDataCounters, sizeof(TTxDataCounters) * MAX_NUM_OF_AC);
os_memoryZero(pTxCtrl->hOs, &pTxCtrl->SumTotalDelayUs, sizeof(pTxCtrl->SumTotalDelayUs));
pTxCtrl->currentConsecutiveRetryFail = 0;
}
/***************************************************************************
* txCtrlParams_RegNotif *
****************************************************************************/
TI_HANDLE txCtrlParams_RegNotif(TI_HANDLE hTxCtrl, TI_UINT16 EventMask, GeneralEventCall_t CallBack,
TI_HANDLE context, TI_UINT32 Cookie)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
if (!hTxCtrl)
return NULL;
return DistributorMgr_Reg(pTxCtrl->TxEventDistributor,EventMask,(TI_HANDLE)CallBack,context,Cookie);
}
/***************************************************************************
* txCtrlParams_AddToNotifMask *
****************************************************************************/
TI_STATUS txCtrlParams_AddToNotifMask(TI_HANDLE hTxCtrl, TI_HANDLE Notifh, TI_UINT16 EventMask)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
if (!hTxCtrl)
return TI_NOK;
return DistributorMgr_AddToMask(pTxCtrl->TxEventDistributor, Notifh, EventMask);
}
/***************************************************************************
* txCtrlParams_UnRegNotif *
****************************************************************************/
TI_STATUS txCtrlParams_UnRegNotif(TI_HANDLE hTxCtrl, TI_HANDLE RegEventHandle)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
if (!hTxCtrl)
return TI_NOK;
return (DistributorMgr_UnReg(pTxCtrl->TxEventDistributor,RegEventHandle));
}
/***********************************************************************
* txCtrlParams_setAdmissionCtrlParams
***********************************************************************
DESCRIPTION: This function is called for add/delete a tspec in order
to update parameters.
INPUT: hTxCtrl - handale to the ts data object
acId - the AC of the tspec
mediumTime - tha alocated medium time for this UP
minimumPHYRate - the min phy rate to send a packet of this UP
admFlag - indicate if the its addition or deletion of tspec
OUTPUT: None
RETURN: void
************************************************************************/
TI_STATUS txCtrlParams_setAdmissionCtrlParams(TI_HANDLE hTxCtrl, TI_UINT8 acId, TI_UINT16 mediumTime,
TI_UINT32 minimumPHYRate, TI_BOOL admFlag)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
TI_UINT32 i;
if(admFlag == TI_TRUE)
{
/* tspec added */
pTxCtrl->mediumTime[acId] = mediumTime;
pTxCtrl->admissionState[acId] = AC_ADMITTED;
pTxCtrl->useAdmissionAlgo[acId] = TI_TRUE;
pTxCtrl->lastCreditCalcTimeStamp[acId] = os_timeStampMs(pTxCtrl->hOs);
pTxCtrl->credit[acId] = mediumTime;
}
else
{
/* tspaec deleted */
pTxCtrl->mediumTime[acId] = 0;
pTxCtrl->admissionState[acId] = AC_NOT_ADMITTED;
pTxCtrl->useAdmissionAlgo[acId] = TI_FALSE;
pTxCtrl->lastCreditCalcTimeStamp[acId] = 0;
pTxCtrl->credit[acId] = 0;
}
/* Update the Tx queues mapping after admission change. */
txCtrl_UpdateQueuesMapping (hTxCtrl);
/* If the timer was not enabled in registry than we will never set it */
if (pTxCtrl->bCreditCalcTimerEnabled)
{
/* enable disable credit calculation timer */
for (i = 0; i < MAX_NUM_OF_AC; i++)
{
if (pTxCtrl->useAdmissionAlgo[i])
{
if (!pTxCtrl->bCreditCalcTimerRunning)
{
pTxCtrl->bCreditCalcTimerRunning = TI_TRUE;
tmr_StartTimer (pTxCtrl->hCreditTimer,
calcCreditFromTimer,
(TI_HANDLE)pTxCtrl,
pTxCtrl->creditCalculationTimeout,
TI_TRUE);
}
return TI_OK;
}
}
/* in all queues useAdmissionAlgo is not TRUE, so stop timer if running */
if (pTxCtrl->bCreditCalcTimerRunning)
{
tmr_StopTimer (pTxCtrl->hCreditTimer);
pTxCtrl->bCreditCalcTimerRunning = TI_FALSE;
}
}
return TI_OK;
}
/***************************************************************************
* txCtrlParams_getParam
****************************************************************************
* DESCRIPTION: Get a specific parameter by an external user application.
*
* OUTPUT: pParamInfo - structure which include the value of
* the requested parameter
***************************************************************************/
TI_STATUS txCtrlParams_getParam(TI_HANDLE hTxCtrl, paramInfo_t *pParamInfo)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
TI_UINT32 ac;
if(pTxCtrl == NULL) /* check handle validity */
{
return TI_NOK;
}
switch (pParamInfo->paramType)
{
case TX_CTRL_COUNTERS_PARAM:
/* Convert total-delays units from usec to mSec. */
for(ac = 0 ; ac < MAX_NUM_OF_AC ; ac++)
{
pTxCtrl->txDataCounters[ac].SumTotalDelayMs = pTxCtrl->SumTotalDelayUs[ac] / 1000;
}
os_memoryCopy( pTxCtrl->hOs, pParamInfo->content.pTxDataCounters, &(pTxCtrl->txDataCounters[0]),
sizeof(TTxDataCounters) * MAX_NUM_OF_AC);
pParamInfo->paramLength = sizeof(TTxDataCounters) * MAX_NUM_OF_AC;
break;
case TX_CTRL_GET_DATA_FRAME_COUNTER:
pParamInfo->content.txPacketsCount = 0;
for (ac = 0; ac < MAX_NUM_OF_AC; ac++)
pParamInfo->content.txPacketsCount += pTxCtrl->txDataCounters[ac].XmitOk;
break;
case TX_CTRL_REPORT_TS_STATISTICS:
ac = pParamInfo->content.tsMetricsCounters.acID;
os_memoryCopy(pTxCtrl->hOs,
pParamInfo->content.tsMetricsCounters.pTxDataCounters,
&(pTxCtrl->txDataCounters[ac]),
sizeof(TTxDataCounters));
os_memoryZero(pTxCtrl->hOs, &(pTxCtrl->txDataCounters[ac]), sizeof(TTxDataCounters));
break;
case TX_CTRL_GENERIC_ETHERTYPE:
pParamInfo->content.txGenericEthertype = pTxCtrl->genericEthertype;
break;
default:
TRACE0(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, ": PARAMETER NOT SUPPORTED\n");
return PARAM_NOT_SUPPORTED;
}
return TI_OK;
}
/***************************************************************************
* txCtrlParams_setParam
****************************************************************************
* DESCRIPTION: Set a specific parameter by an external user application.
*
* INPUTS: hTxCtrl - the object
* pParamInfo - structure which include the value to set for
* the requested parameter
***************************************************************************/
TI_STATUS txCtrlParams_setParam(TI_HANDLE hTxCtrl, paramInfo_t *pParamInfo)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
TI_UINT8 acID;
if(pTxCtrl == NULL) /* check handle validity */
{
return TI_NOK;
}
switch (pParamInfo->paramType)
{
case TX_CTRL_SET_MEDIUM_USAGE_THRESHOLD:
acID = (TI_UINT8)pParamInfo->content.txDataMediumUsageThreshold.uAC;
if(acID < MAX_NUM_OF_AC)
{
pTxCtrl->highMediumUsageThreshold[acID] =
pParamInfo->content.txDataMediumUsageThreshold.uHighThreshold;
pTxCtrl->lowMediumUsageThreshold[acID] =
pParamInfo->content.txDataMediumUsageThreshold.uLowThreshold;
}
else
TRACE1(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, ": Wrong AC (AC=%d > 3)\n", acID);
break;
case TX_CTRL_GET_MEDIUM_USAGE_THRESHOLD:
/* Note: SET operation is used for GET, because AC parameter should be supplied from Utility-
Adapter to driver (copy of user supplied block of data is only performed in SetParam calls). */
acID = (TI_UINT8)pParamInfo->content.txDataMediumUsageThreshold.uAC;
pParamInfo->content.txDataMediumUsageThreshold.uHighThreshold = pTxCtrl->highMediumUsageThreshold[acID];
pParamInfo->content.txDataMediumUsageThreshold.uLowThreshold = pTxCtrl->lowMediumUsageThreshold[acID];
break;
case TX_CTRL_POLL_AP_PACKETS_FROM_AC:
TRACE0(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, ": Poll-AP is not supported in this version!!\n");
return PARAM_NOT_SUPPORTED;
case TX_CTRL_RESET_COUNTERS_PARAM:
txCtrlParams_resetCounters(hTxCtrl);
break;
case TX_CTRL_GENERIC_ETHERTYPE:
pTxCtrl->genericEthertype = pParamInfo->content.txGenericEthertype;
{
paramInfo_t param;
param.paramType = RX_DATA_GENERIC_ETHERTYPE_PARAM;
param.content.rxGenericEthertype = pTxCtrl->genericEthertype;
rxData_setParam(pTxCtrl->hRxData, ¶m);
}
break;
default:
TRACE0(pTxCtrl->hReport, REPORT_SEVERITY_ERROR, ": PARAMETER NOT SUPPORTED\n");
return PARAM_NOT_SUPPORTED;
}
return TI_OK;
}
/***********************************************************************
* txCtrlParams_setBssId
***********************************************************************
DESCRIPTION: Update the BSS-ID.
************************************************************************/
void txCtrlParams_setBssId (TI_HANDLE hTxCtrl, TMacAddr *pCurrBssId)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
MAC_COPY (pTxCtrl->currBssId, *pCurrBssId);
}
/***********************************************************************
* txCtrlParams_setBssType
***********************************************************************
DESCRIPTION: Update the BSS type.
************************************************************************/
void txCtrlParams_setBssType (TI_HANDLE hTxCtrl, ScanBssType_e currBssType)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->currBssType = currBssType;
}
/***********************************************************************
* txCtrlParams_setQosHeaderConverMode
***********************************************************************
DESCRIPTION: Update the BSS type.
************************************************************************/
void txCtrlParams_setQosHeaderConverMode (TI_HANDLE hTxCtrl, EHeaderConvertMode headerConverMode)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->headerConverMode = headerConverMode;
updateDataPktPrototype(pTxCtrl); /* Needed due to QoS mode change. */
}
/**
* \fn txCtrlParams_SetHtControl()
* \brief Update The HT Control Field on txCtrl module.
*
* \note
* \param hTxCtrl - the hTxCtrl handle.
* \param pHtCapabilitiesIe - input structure.
* \return TI_OK on success or TI_NOK on failure
* \sa
*/
TI_STATUS txCtrlParams_SetHtControl (TI_HANDLE hTxCtrl, TtxCtrlHtControl *pHtControl)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->tTxCtrlHtControl.bHtEnable = pHtControl->bHtEnable;
return TI_OK;
}
/***********************************************************************
* txCtrlParams_setCurrentPrivacyInvokedMode
***********************************************************************
DESCRIPTION: Update the current privacy invoked mode.
************************************************************************/
void txCtrlParams_setCurrentPrivacyInvokedMode (TI_HANDLE hTxCtrl, TI_BOOL currentPrivacyInvokedMode)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->currentPrivacyInvokedMode = currentPrivacyInvokedMode;
}
/***********************************************************************
* txCtrlParams_setEapolEncryptionStatus
***********************************************************************
DESCRIPTION: Update the Eapol Encryption Status.
************************************************************************/
void txCtrlParams_setEapolEncryptionStatus (TI_HANDLE hTxCtrl, TI_BOOL eapolEncryptionStatus)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->eapolEncryptionStatus = eapolEncryptionStatus;
}
/***********************************************************************
* txCtrlParams_setEncryptionFieldSizes
***********************************************************************
DESCRIPTION: Update the encryption field size for the header padding.
************************************************************************/
void txCtrlParams_setEncryptionFieldSizes (TI_HANDLE hTxCtrl, TI_UINT8 encryptionFieldSize)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->encryptionFieldSize = encryptionFieldSize;
}
/***********************************************************************
* txCtrlParams_getCurrentEncryptionInfo
***********************************************************************
DESCRIPTION: Provide the current encryption mode and padding size.
************************************************************************/
void txCtrlParams_getCurrentEncryptionInfo (TI_HANDLE hTxCtrl,
TI_BOOL *pCurrentPrivacyInvokedMode,
TI_UINT8 *pEncryptionFieldSize)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
*pCurrentPrivacyInvokedMode = pTxCtrl->currentPrivacyInvokedMode;
*pEncryptionFieldSize = pTxCtrl->encryptionFieldSize;
}
/***********************************************************************
* txCtrlParams_GetTxRate
***********************************************************************
DESCRIPTION: Provide the last successfull data packet Tx rate.
************************************************************************/
ERate txCtrlParams_GetTxRate (TI_HANDLE hTxCtrl)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
return pTxCtrl->eCurrentTxRate;
}
/***********************************************************************
* txCtrlParams_setAcAdmissionStatus
***********************************************************************
DESCRIPTION: Update the AC admission status - required or not and admitted or not.
Update also the queues mapping in case it should change.
************************************************************************/
void txCtrlParams_setAcAdmissionStatus (TI_HANDLE hTxCtrl,
TI_UINT8 ac,
EAdmissionState admissionRequired,
ETrafficAdmState admissionState)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->admissionRequired[ac] = admissionRequired;
pTxCtrl->admissionState[ac] = admissionState;
/* Update the Tx queues mapping after admission change. */
txCtrl_UpdateQueuesMapping (hTxCtrl);
}
/***********************************************************************
* txCtrlParams_setAcMsduLifeTime
***********************************************************************
DESCRIPTION: Update the AC MSDU lifetime. The units are TUs (1024 usec).
************************************************************************/
void txCtrlParams_setAcMsduLifeTime (TI_HANDLE hTxCtrl, TI_UINT8 ac, TI_UINT32 uMsduLifeTimeTu)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->aMsduLifeTimeTu[ac] = (TI_UINT16)uMsduLifeTimeTu;
}
/***********************************************************************
* txCtrlParams_setAcAckPolicy
***********************************************************************
DESCRIPTION: Update the AC Ack policy.
************************************************************************/
void txCtrlParams_setAcAckPolicy (TI_HANDLE hTxCtrl, TI_UINT8 ac, AckPolicy_e ackPolicy)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->ackPolicy[ac] = ackPolicy;
}
/***********************************************************************
* txCtrlParams_updateMgmtRateAttributes
***********************************************************************
DESCRIPTION: Update per AC the rate policy for Mgmnt packets or IBSS BCAST packets.
************************************************************************/
void txCtrlParams_updateMgmtRateAttributes(TI_HANDLE hTxCtrl, TI_UINT8 ratePolicyId, TI_UINT8 ac)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->mgmtRatePolicy[ac] = ratePolicyId;
}
/***********************************************************************
* txCtrlParams_updateDataRateAttributes
***********************************************************************
DESCRIPTION: Update per AC the rate policy for regular data packets (excluding IBSS BCAST packets).
************************************************************************/
void txCtrlParams_updateDataRateAttributes(TI_HANDLE hTxCtrl, TI_UINT8 ratePolicyId, TI_UINT8 ac)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->dataRatePolicy[ac] = ratePolicyId;
}
/***********************************************************************
* txCtrlParams_updateTxSessionCount
***********************************************************************
DESCRIPTION: Update the current Tx-session index configured to FW.
************************************************************************/
void txCtrlParams_updateTxSessionCount(TI_HANDLE hTxCtrl, TI_UINT16 txSessionCount)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
pTxCtrl->txSessionCount = txSessionCount;
updateDataPktPrototype(pTxCtrl);
}
/********************************************************************************
* *
* DEBUG FUNCTIONS IMPLEMENTATION *
* *
*********************************************************************************/
#ifdef TI_DBG
/***********************************************************************
* txCtrlParams_printInfo
***********************************************************************
DESCRIPTION: Print module internal information.
************************************************************************/
void txCtrlParams_printInfo(TI_HANDLE hTxCtrl)
{
#ifdef REPORT_LOG
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
WLAN_OS_REPORT(("-------------- Tx-Ctrl Module Information --------------\n"));
WLAN_OS_REPORT(("========================================================\n"));
WLAN_OS_REPORT(("ACs Mapping:\n"));
WLAN_OS_REPORT(("------------\n"));
WLAN_OS_REPORT(("admissionRequired[3,2,1,0] = %d, %d, %d, %d\n",
pTxCtrl->admissionRequired[3], pTxCtrl->admissionRequired[2],
pTxCtrl->admissionRequired[1], pTxCtrl->admissionRequired[0]));
WLAN_OS_REPORT(("admissionState[3,2,1,0] = %d, %d, %d, %d\n",
pTxCtrl->admissionState[3], pTxCtrl->admissionState[2],
pTxCtrl->admissionState[1], pTxCtrl->admissionState[0]));
WLAN_OS_REPORT(("highestAdmittedAc[3,2,1,0] = %d, %d, %d, %d\n",
pTxCtrl->highestAdmittedAc[3], pTxCtrl->highestAdmittedAc[2],
pTxCtrl->highestAdmittedAc[1], pTxCtrl->highestAdmittedAc[0]));
WLAN_OS_REPORT(("admittedAcToTidMap[3,2,1,0] = 0x%x, 0x%x, 0x%x, 0x%x\n",
pTxCtrl->admittedAcToTidMap[3], pTxCtrl->admittedAcToTidMap[2],
pTxCtrl->admittedAcToTidMap[1], pTxCtrl->admittedAcToTidMap[0]));
WLAN_OS_REPORT(("busyAcBitmap = 0x%x\n", pTxCtrl->busyAcBitmap));
WLAN_OS_REPORT(("busyTidBitmap = 0x%x\n", pTxCtrl->busyTidBitmap));
WLAN_OS_REPORT(("--------------------------------------------------------\n"));
WLAN_OS_REPORT(("Tx Attributes:\n"));
WLAN_OS_REPORT(("--------------\n"));
WLAN_OS_REPORT(("mgmtRatePolicy[3,2,1,0] = %d, %d, %d, %d\n",
pTxCtrl->mgmtRatePolicy[3], pTxCtrl->mgmtRatePolicy[2],
pTxCtrl->mgmtRatePolicy[1], pTxCtrl->mgmtRatePolicy[0]));
WLAN_OS_REPORT(("dataRatePolicy[3,2,1,0] = %d, %d, %d, %d\n",
pTxCtrl->dataRatePolicy[3], pTxCtrl->dataRatePolicy[2],
pTxCtrl->dataRatePolicy[1], pTxCtrl->dataRatePolicy[0]));
WLAN_OS_REPORT(("dataPktDescAttrib = 0x%x\n", pTxCtrl->dataPktDescAttrib));
WLAN_OS_REPORT(("--------------------------------------------------------\n"));
WLAN_OS_REPORT(("Parameters:\n"));
WLAN_OS_REPORT(("----------\n"));
WLAN_OS_REPORT(("headerConverMode = %d\n", pTxCtrl->headerConverMode));
WLAN_OS_REPORT(("currentPrivacyInvokedMode = %d\n", pTxCtrl->currentPrivacyInvokedMode));
WLAN_OS_REPORT(("eapolEncryptionStatus = %d\n", pTxCtrl->eapolEncryptionStatus));
WLAN_OS_REPORT(("encryptionFieldSize = %d\n", pTxCtrl->encryptionFieldSize));
WLAN_OS_REPORT(("currBssType = %d\n", pTxCtrl->currBssType));
WLAN_OS_REPORT(("========================================================\n\n"));
#endif
}
/***********************************************************************
* txCtrlParams_printDebugCounters
***********************************************************************
DESCRIPTION: Print Tx statistics debug counters.
************************************************************************/
void txCtrlParams_printDebugCounters(TI_HANDLE hTxCtrl)
{
#ifdef REPORT_LOG
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
TI_UINT32 ac;
WLAN_OS_REPORT(("-------------- Tx-Ctrl Statistics Per AC ---------------\n"));
WLAN_OS_REPORT(("========================================================\n"));
WLAN_OS_REPORT(("---------- Packets Sent To Tx-Ctrl ---------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsSent[ac]));
WLAN_OS_REPORT(("---------- Number of Queue-Stop (BP) -------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsBackpressure[ac]));
WLAN_OS_REPORT(("---------- Number of AC Busy (Requeue pkt) -------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsBusy[ac]));
WLAN_OS_REPORT(("---------- Packets Sent to Xfer ------------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsXfered[ac]));
WLAN_OS_REPORT(("----------- Xfer rc = Success --------------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsSuccess[ac]));
WLAN_OS_REPORT(("----------- Xfer rc = Pending --------------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsPending[ac]));
WLAN_OS_REPORT(("----------- Xfer rc = Error ----------------------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumPktsError[ac]));
WLAN_OS_REPORT(("----------- Number of Tx-Complete Packets --------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumTxCmplt[ac]));
WLAN_OS_REPORT(("----------- Number of Tx-Complete Packets TI_OK -----------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumTxCmpltOk[ac]));
WLAN_OS_REPORT(("----------- Number of Tx-Complete Packets Fails --------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumTxCmpltError[ac]));
WLAN_OS_REPORT(("----------- Number of Tx-Complete Bytes TI_OK -------------\n"));
for(ac = 0; ac < MAX_NUM_OF_AC; ac++)
WLAN_OS_REPORT(("AC %d = %d\n", ac, pTxCtrl->dbgCounters.dbgNumTxCmpltOkBytes[ac]));
WLAN_OS_REPORT(("--------------------------------------------------------\n"));
WLAN_OS_REPORT(("Total Number of Xfer-Complete Events = %d\n", pTxCtrl->dbgCounters.dbgNumXferCmplt));
WLAN_OS_REPORT(("Total Number of Xfer-Pending Events = %d\n",
pTxCtrl->dbgCounters.dbgNumPktsPending[0] + pTxCtrl->dbgCounters.dbgNumPktsPending[1] +
pTxCtrl->dbgCounters.dbgNumPktsPending[2] + pTxCtrl->dbgCounters.dbgNumPktsPending[3]));
WLAN_OS_REPORT(("========================================================\n\n"));
#endif
}
/***************************************************************************
* txCtrlParams_resetDbgCounters
****************************************************************************
* DESCRIPTION: Reset the tx data module debug counters
***************************************************************************/
void txCtrlParams_resetDbgCounters(TI_HANDLE hTxCtrl)
{
txCtrl_t *pTxCtrl = (txCtrl_t *)hTxCtrl;
os_memoryZero(pTxCtrl->hOs, &pTxCtrl->dbgCounters, sizeof(txDataDbgCounters_t));
}
#endif /* TI_DBG */