/*
* txXfer.c
*
* Copyright(c) 1998 - 2009 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.
*/
/** \file txXfer.c
* \brief Handle Tx packets transfer to the firmware.
*
* This module gets the upper driver's Tx packets after FW resources were
* allocated for them, aggregates them if possible, and handles their transfer
* to the FW via the host slave (indirect) interface, using the TwIf Transaction API.
* The aggregation processing is completed by the BusDrv where the packets are combined
* and sent to the FW in one transaction.
*
* \see
*/
#define __FILE_ID__ FILE_ID_108
#include "tidef.h"
#include "osApi.h"
#include "report.h"
#include "TwIf.h"
#include "TWDriver.h"
#include "txXfer_api.h"
#ifdef TI_DBG
#define DBG_MAX_AGGREG_PKTS 16
#endif
typedef struct
{
TTxnStruct tTxnStruct;
TI_UINT32 uPktsCntr;
} TPktsCntrTxn;
/* The TxXfer module object. */
typedef struct
{
TI_HANDLE hOs;
TI_HANDLE hReport;
TI_HANDLE hTwIf;
TI_UINT32 uAggregMaxPkts; /* Max number of packets that may be aggregated */
TI_UINT32 uAggregMaxLen; /* Max length in bytes of a single aggregation */
TI_UINT32 uAggregPktsNum; /* Number of packets in current aggregation */
TI_UINT32 uAggregPktsLen; /* Aggregated length of current aggregation */
TTxCtrlBlk * pAggregFirstPkt; /* Pointer to the first packet of current aggregation */
TTxCtrlBlk * pAggregLastPkt; /* Pointer to the last packet of current aggregation */
TSendPacketTranferCb fSendPacketTransferCb; /* Upper layer Xfer-Complete callback */
TI_HANDLE hSendPacketTransferHndl; /* Upper layer Xfer-Complete callback handle */
TTxnDoneCb fXferCompleteLocalCb; /* TxXfer local CB for pkt transfer completion (NULL is not needed!) */
TI_UINT32 uPktsCntr; /* Counts all Tx packets. Written to FW after each packet transaction */
TI_UINT32 uPktsCntrTxnIndex; /* The current indext of the aPktsCntrTxn[] used for the counter workaround transactions */
TPktsCntrTxn aPktsCntrTxn[CTRL_BLK_ENTRIES_NUM]; /* Transaction structures for sending the packets counter */
#ifdef TI_DBG
TI_UINT32 aDbgCountPktAggreg[DBG_MAX_AGGREG_PKTS];
#endif
} TTxXferObj;
static ETxnStatus txXfer_SendAggregatedPkts (TTxXferObj *pTxXfer, TI_BOOL bLastPktSentNow);
static void txXfer_TransferDoneCb (TI_HANDLE hTxXfer, TTxnStruct *pTxn);
/********************************************************************************
* *
* PUBLIC FUNCTIONS IMPLEMENTATION *
* *
*********************************************************************************/
TI_HANDLE txXfer_Create(TI_HANDLE hOs)
{
TTxXferObj *pTxXfer;
pTxXfer = os_memoryAlloc (hOs, sizeof(TTxXferObj));
if (pTxXfer == NULL)
{
return NULL;
}
os_memoryZero (hOs, pTxXfer, sizeof(TTxXferObj));
pTxXfer->hOs = hOs;
return (TI_HANDLE)pTxXfer;
}
TI_STATUS txXfer_Destroy(TI_HANDLE hTxXfer)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
if (pTxXfer)
{
os_memoryFree (pTxXfer->hOs, pTxXfer, sizeof(TTxXferObj));
}
return TI_OK;
}
TI_STATUS txXfer_Init (TI_HANDLE hTxXfer, TI_HANDLE hReport, TI_HANDLE hTwIf)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
TTxnStruct *pTxn;
TI_UINT8 i;
pTxXfer->hReport = hReport;
pTxXfer->hTwIf = hTwIf;
pTxXfer->fSendPacketTransferCb = NULL;
pTxXfer->fXferCompleteLocalCb = NULL;
for (i = 0; i < CTRL_BLK_ENTRIES_NUM; i++)
{
pTxn = &(pTxXfer->aPktsCntrTxn[i].tTxnStruct);
TXN_PARAM_SET(pTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_WRITE, TXN_INC_ADDR)
BUILD_TTxnStruct(pTxn, HOST_WR_ACCESS_REG, &pTxXfer->aPktsCntrTxn[i].uPktsCntr, REGISTER_SIZE, NULL, NULL)
}
return txXfer_Restart(hTxXfer);
}
TI_STATUS txXfer_Restart (TI_HANDLE hTxXfer)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
pTxXfer->uPktsCntr = 0;
pTxXfer->uPktsCntrTxnIndex = 0;
pTxXfer->uAggregPktsNum = 0;
return TI_OK;
}
void txXfer_SetDefaults (TI_HANDLE hTxXfer, TTwdInitParams *pInitParams)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
pTxXfer->uAggregMaxPkts = pInitParams->tGeneral.uTxAggregPktsLimit;
}
void txXfer_SetBusParams (TI_HANDLE hTxXfer, TI_UINT32 uDmaBufLen)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
pTxXfer->uAggregMaxLen = uDmaBufLen;
}
void txXfer_RegisterCb (TI_HANDLE hTxXfer, TI_UINT32 CallBackID, void *CBFunc, TI_HANDLE CBObj)
{
TTxXferObj* pTxXfer = (TTxXferObj*)hTxXfer;
TRACE3(pTxXfer->hReport, REPORT_SEVERITY_INFORMATION, "txXfer_RegisterCb: CallBackID=%d, CBFunc=0x%x, CBObj=0x%x\n", CallBackID, CBFunc, CBObj);
switch(CallBackID)
{
/* Save upper layers Transfer-Done callback */
case TWD_INT_SEND_PACKET_TRANSFER:
pTxXfer->fSendPacketTransferCb = (TSendPacketTranferCb)CBFunc;
pTxXfer->hSendPacketTransferHndl = CBObj;
/* Set also the local CB so we are called upon Async transaction completion to call the upper CB */
pTxXfer->fXferCompleteLocalCb = (TTxnDoneCb)txXfer_TransferDoneCb;
break;
default:
TRACE0(pTxXfer->hReport, REPORT_SEVERITY_ERROR, " - Illegal value\n");
break;
}
}
ETxnStatus txXfer_SendPacket (TI_HANDLE hTxXfer, TTxCtrlBlk *pPktCtrlBlk)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
TI_UINT32 uPktLen = ENDIAN_HANDLE_WORD(pPktCtrlBlk->tTxDescriptor.length << 2); /* swap back for endianess if needed */
ETxnStatus eStatus;
/* If starting a new aggregation, prepare it, and send packet if aggregation is disabled. */
if (pTxXfer->uAggregPktsNum == 0)
{
pTxXfer->uAggregPktsNum = 1;
pTxXfer->uAggregPktsLen = uPktLen;
pTxXfer->pAggregFirstPkt = pPktCtrlBlk;
pTxXfer->pAggregLastPkt = pPktCtrlBlk;
pPktCtrlBlk->pNextAggregEntry = pPktCtrlBlk; /* First packet points to itself */
if (pTxXfer->uAggregMaxPkts <= 1)
{
eStatus = txXfer_SendAggregatedPkts (pTxXfer, TI_TRUE);
pTxXfer->uAggregPktsNum = 0;
}
else
{
eStatus = TXN_STATUS_PENDING;
}
}
/* Else, if new packet can be added to aggregation, add it and set status as Pending. */
else if ((pTxXfer->uAggregPktsNum + 1 <= pTxXfer->uAggregMaxPkts) &&
(pTxXfer->uAggregPktsLen + uPktLen <= pTxXfer->uAggregMaxLen))
{
pTxXfer->uAggregPktsNum++;
pTxXfer->uAggregPktsLen += uPktLen;
pTxXfer->pAggregLastPkt->pNextAggregEntry = pPktCtrlBlk; /* Link new packet to last */
pTxXfer->pAggregLastPkt = pPktCtrlBlk; /* Save new packet as last */
pPktCtrlBlk->pNextAggregEntry = pTxXfer->pAggregFirstPkt; /* Point from last to first */
eStatus = TXN_STATUS_PENDING;
}
/* Else, we can't add the new packet, so send current aggregation and start a new one */
else
{
txXfer_SendAggregatedPkts (pTxXfer, TI_FALSE);
eStatus = TXN_STATUS_PENDING; /* The current packet is not sent yet so return Pending */
pTxXfer->uAggregPktsNum = 1;
pTxXfer->uAggregPktsLen = uPktLen;
pTxXfer->pAggregFirstPkt = pPktCtrlBlk;
pTxXfer->pAggregLastPkt = pPktCtrlBlk;
pPktCtrlBlk->pNextAggregEntry = pPktCtrlBlk; /* First packet points to itself */
}
/* Return the Txn result - COMPLETE or PENDING. */
/* Note: For PENDING, a callback function will be called only if registered (needed for WHA) */
return eStatus;
}
void txXfer_EndOfBurst (TI_HANDLE hTxXfer)
{
TTxXferObj *pTxXfer = (TTxXferObj *)hTxXfer;
if (pTxXfer->uAggregPktsNum > 0)
{
/* No more packets from TxDataQ so send any aggregated packets and clear aggregation */
txXfer_SendAggregatedPkts (pTxXfer, TI_FALSE);
pTxXfer->uAggregPktsNum = 0;
}
}
/********************************************************************************
* *
* INTERNAL FUNCTIONS IMPLEMENTATION *
* *
*********************************************************************************/
/**
* \fn txXfer_SendAggregatedPkts
* \brief Send aggregated Tx packets to bus Txn layer
*
* Send aggregated Tx packets to bus Txn layer one by one.
* Increase the packets counter by the number of packets and send it to the FW (generates an interrupt).
* If xfer completion CB is registered and status is Complete, call CB for all packets (except last one if inseted now).
*
* \note The BusDrv combines the packets and sends them in one transaction.
* \param pTxXfer - The module's object
* \param bLastPktSentNow - If TRUE, last packet in the aggregation was inserted in current call to txXfer_SendPacket.
* \return COMPLETE if transaction completed in this context, PENDING if not, ERROR if failed
* \sa
*/
static ETxnStatus txXfer_SendAggregatedPkts (TTxXferObj *pTxXfer, TI_BOOL bLastPktSentNow)
{
TTxCtrlBlk *pCurrPkt;
TTxnStruct *pTxn;
TPktsCntrTxn *pPktsCntrTxn;
ETxnStatus eStatus = TXN_STATUS_COMPLETE;
TI_UINT32 i;
/* Prepare and send all aggregated packets (combined and sent in one transaction by the BusDrv) */
pCurrPkt = pTxXfer->pAggregFirstPkt;
for (i = 0; i < pTxXfer->uAggregPktsNum; i++)
{
pTxn = (TTxnStruct *)pCurrPkt;
/* If not last packet, set aggregation flag, clear completion CB and progress to next packet */
if (i < pTxXfer->uAggregPktsNum - 1)
{
TXN_PARAM_SET_AGGREGATE(pTxn, TXN_AGGREGATE_ON);
pTxn->fTxnDoneCb = NULL;
pCurrPkt = pCurrPkt->pNextAggregEntry;
}
/* If last packet, clear aggregation flag and set completion CB (exist only if registered) */
else
{
TXN_PARAM_SET_AGGREGATE(pTxn, TXN_AGGREGATE_OFF);
pTxn->fTxnDoneCb = pTxXfer->fXferCompleteLocalCb;
pTxn->hCbHandle = (TI_HANDLE)pTxXfer;
}
/* Send packet */
pTxn->uHwAddr = SLV_MEM_DATA;
eStatus = twIf_Transact (pTxXfer->hTwIf, pTxn);
}
#ifdef TI_DBG
pTxXfer->aDbgCountPktAggreg[pTxXfer->uAggregPktsNum]++;
TRACE5(pTxXfer->hReport, REPORT_SEVERITY_INFORMATION, "txXfer_SendAggregatedPkts: Status=%d, NumPkts=%d, AggregLen=%d, pFirstPkt=0x%x, pLastPkt=0x%x\n", eStatus, pTxXfer->uAggregPktsNum, pTxXfer->uAggregPktsLen, pTxXfer->pAggregFirstPkt, pTxXfer->pAggregLastPkt);
if (eStatus == TXN_STATUS_ERROR)
{
TRACE5(pTxXfer->hReport, REPORT_SEVERITY_ERROR, "txXfer_SendAggregatedPkts: Status=%d, NumPkts=%d, AggregLen=%d, pFirstPkt=0x%x, pLastPkt=0x%x\n", eStatus, pTxXfer->uAggregPktsNum, pTxXfer->uAggregPktsLen, pTxXfer->pAggregFirstPkt, pTxXfer->pAggregLastPkt);
return eStatus;
}
#endif /* TI_DBG */
/* Write packet counter to FW (generates an interrupt).
Note: This may be removed once the host-slave HW counter functionality is verified */
pTxXfer->uPktsCntr += pTxXfer->uAggregPktsNum;
pTxXfer->uPktsCntrTxnIndex++;
if (pTxXfer->uPktsCntrTxnIndex == CTRL_BLK_ENTRIES_NUM)
{
pTxXfer->uPktsCntrTxnIndex = 0;
}
pPktsCntrTxn = &(pTxXfer->aPktsCntrTxn[pTxXfer->uPktsCntrTxnIndex]);
pPktsCntrTxn->uPktsCntr = ENDIAN_HANDLE_LONG(pTxXfer->uPktsCntr);
pPktsCntrTxn->tTxnStruct.uHwAddr = HOST_WR_ACCESS_REG;
twIf_Transact(pTxXfer->hTwIf, &pPktsCntrTxn->tTxnStruct);
/* If xfer completion CB is registered and last packet status is Complete, call the CB for all
* packets except the input one (covered by the return code).
*/
if (pTxXfer->fSendPacketTransferCb && (eStatus == TXN_STATUS_COMPLETE))
{
/* Don't call CB for last packet if inserted in current Tx */
TI_UINT32 uNumCbCalls = bLastPktSentNow ? (pTxXfer->uAggregPktsNum - 1) : pTxXfer->uAggregPktsNum;
pCurrPkt = pTxXfer->pAggregFirstPkt;
for (i = 0; i < uNumCbCalls; i++)
{
pTxXfer->fSendPacketTransferCb (pTxXfer->hSendPacketTransferHndl, pCurrPkt);
pCurrPkt = pCurrPkt->pNextAggregEntry;
}
}
/* Return the Txn result - COMPLETE or PENDING. */
/* Note: For PENDING, a callback function will be called only if registered (needed for WHA) */
return eStatus;
}
/**
* \fn txXfer_TransferDoneCb
* \brief Send aggregated Tx packets to bus Txn layer
*
* Call the upper layers TranferDone CB for all packets of the completed aggregation
* This function is called only if the upper layers registered their CB (used only by WHA)
*
* \note
* \param pTxXfer - The module's object
* \return COMPLETE if completed in this context, PENDING if not, ERROR if failed
* \sa
*/
static void txXfer_TransferDoneCb (TI_HANDLE hTxXfer, TTxnStruct *pTxn)
{
TTxXferObj *pTxXfer = (TTxXferObj*)hTxXfer;
TTxCtrlBlk *pInputPkt = (TTxCtrlBlk *)pTxn; /* This is the last packet of the aggregation */
TTxCtrlBlk *pCurrPkt;
TI_UINT32 i;
/* Call the upper layers TranferDone CB for all packets of the completed aggregation */
/* Note: If this CB was called it means that the upper CB exists */
pCurrPkt = pInputPkt->pNextAggregEntry; /* The last packet of the aggregation point to the first one */
for (i = 0; i < pTxXfer->uAggregMaxPkts; i++)
{
pTxXfer->fSendPacketTransferCb (pTxXfer->hSendPacketTransferHndl, pCurrPkt);
/* If we got back to the input packet we went over all the aggregation */
if (pCurrPkt == pInputPkt)
{
break;
}
pCurrPkt = pCurrPkt->pNextAggregEntry;
}
TRACE3(pTxXfer->hReport, REPORT_SEVERITY_INFORMATION, "txXfer_TransferDoneCb: NumPkts=%d, pInputPkt=0x%x, pCurrPkt=0x%x\n", i + 1, pInputPkt, pCurrPkt);
}
#ifdef TI_DBG
void txXfer_ClearStats (TI_HANDLE hTxXfer)
{
TTxXferObj *pTxXfer = (TTxXferObj*)hTxXfer;
os_memoryZero (pTxXfer->hOs, &pTxXfer->aDbgCountPktAggreg, sizeof(pTxXfer->aDbgCountPktAggreg));
}
void txXfer_PrintStats (TI_HANDLE hTxXfer)
{
#ifdef REPORT_LOG
TTxXferObj *pTxXfer = (TTxXferObj*)hTxXfer;
TI_UINT32 i;
WLAN_OS_REPORT(("Print Tx Xfer module info\n"));
WLAN_OS_REPORT(("=========================\n"));
WLAN_OS_REPORT(("uAggregMaxPkts = %d\n", pTxXfer->uAggregMaxPkts));
WLAN_OS_REPORT(("uAggregMaxLen = %d\n", pTxXfer->uAggregMaxLen));
WLAN_OS_REPORT(("uAggregPktsNum = %d\n", pTxXfer->uAggregPktsNum));
WLAN_OS_REPORT(("uAggregPktsLen = %d\n", pTxXfer->uAggregPktsLen));
WLAN_OS_REPORT(("uPktsCntr = %d\n", pTxXfer->uPktsCntr));
WLAN_OS_REPORT(("uPktsCntrTxnIndex = %d\n", pTxXfer->uPktsCntrTxnIndex));
for (i = 1; i < DBG_MAX_AGGREG_PKTS; i++)
{
WLAN_OS_REPORT(("uCountPktAggreg-%2d = %d\n", i, pTxXfer->aDbgCountPktAggreg[i]));
}
#endif
}
#endif /* TI_DBG */