/*
* txResult.c
*
* Copyright(c) 1998 - 2010 Texas Instruments. All rights reserved.
* All rights reserved.
*
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 or BSD License which accompanies
* this distribution. The Eclipse Public License is available at
* http://www.eclipse.org/legal/epl-v10.html and the BSD License is as below.
*
* 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: txResult.c
*
* PURPOSE: Handle packets Tx results upon Tx-complete from the FW.
*
* DESCRIPTION:
* ============
* This module is called upon Tx-complete from FW.
* It retrieves the transmitted packets results from the FW TxResult table and
* calls the upper layer callback function for each packet with its results.
*
****************************************************************************/
#define __FILE_ID__ FILE_ID_107
#include "tidef.h"
#include "osApi.h"
#include "report.h"
#include "TwIf.h"
#include "txCtrlBlk_api.h"
#include "txResult_api.h"
#include "TWDriver.h"
#include "FwEvent_api.h"
#define TX_RESULT_QUEUE_DEPTH_MASK (TRQ_DEPTH - 1)
#if (TX_RESULT_QUEUE_DEPTH_MASK & TRQ_DEPTH)
#error TRQ_DEPTH should be a power of 2 !!
#endif
/* Callback function definition for Tx sendPacketComplete */
typedef void (* TSendPacketCompleteCb)(TI_HANDLE hCbObj, TxResultDescriptor_t *pTxResultInfo);
/* Tx-Result SM states */
typedef enum
{
TX_RESULT_STATE_IDLE,
TX_RESULT_STATE_READING
} ETxResultState;
/* The host Tx-results counter write transaction structure. */
typedef struct
{
TTxnStruct tTxnStruct;
TI_UINT8 *pCounter;
} THostCounterWriteTxn;
/* The Tx-results counters and table read transaction structure. */
typedef struct
{
TTxnStruct tTxnStruct;
TI_UINT8 *pTxResultInfo;
} TResultsInfoReadTxn;
/* The TxResult module object. */
typedef struct
{
TI_HANDLE hOs;
TI_HANDLE hReport;
TI_HANDLE hTwIf;
TI_UINT32 uTxResultInfoAddr; /* The HW Tx-Result Table address */
TI_UINT32 uTxResultHostCounterAddr;/* The Tx-Result host counter address in SRAM */
TI_UINT32 uHostResultsCounter; /* Number of results read by host from queue since FW-init (updated to FW) */
ETxResultState eState; /* Current eState of SM */
TSendPacketCompleteCb fSendPacketCompleteCb; /* Tx-Complete callback function */
TI_HANDLE hSendPacketCompleteHndl; /* Tx-Complete callback function handle */
THostCounterWriteTxn tHostCounterWriteTxn; /* The structure used for writing host results counter to FW */
TResultsInfoReadTxn tResultsInfoReadTxn; /* The structure used for reading Tx-results counters and table from FW */
#ifdef TI_DBG
TI_UINT32 uInterruptsCounter; /* Count number of Tx-results */
#endif
} TTxResultObj;
static void txResult_Restart (TTxResultObj *pTxResult);
static void txResult_HandleNewResults (TTxResultObj *pTxResult);
static void txResult_StateMachine (TI_HANDLE hTxResult);
/****************************************************************************
* txResult_Create()
****************************************************************************
* DESCRIPTION: Create the Tx-Result object
*
* INPUTS: hOs
*
* OUTPUT: None
*
* RETURNS: The Created object
****************************************************************************/
TI_HANDLE txResult_Create(TI_HANDLE hOs)
{
TTxResultObj *pTxResult;
pTxResult = os_memoryAlloc(hOs, sizeof(TTxResultObj),MemoryNormal);
if (pTxResult == NULL)
return NULL;
os_memoryZero(hOs, pTxResult, sizeof(TTxResultObj));
pTxResult->tResultsInfoReadTxn.pTxResultInfo = os_memoryAlloc(hOs, sizeof(TxResultInterface_t) + WSPI_PAD_LEN_READ,MemoryDMA);
if (pTxResult->tResultsInfoReadTxn.pTxResultInfo == NULL)
{
return NULL;
}
os_memoryZero (hOs,pTxResult->tResultsInfoReadTxn.pTxResultInfo, sizeof(TxResultInterface_t) + WSPI_PAD_LEN_READ);
pTxResult->tResultsInfoReadTxn.pTxResultInfo += WSPI_PAD_LEN_READ;
pTxResult->tHostCounterWriteTxn.pCounter = os_memoryAlloc(hOs, sizeof(TI_UINT32) + WSPI_PAD_LEN_READ,MemoryDMA);
if (pTxResult->tHostCounterWriteTxn.pCounter == NULL)
{
return NULL;
}
os_memoryZero (hOs,pTxResult->tHostCounterWriteTxn.pCounter, sizeof(TI_UINT32) + WSPI_PAD_LEN_READ);
pTxResult->tHostCounterWriteTxn.pCounter += WSPI_PAD_LEN_READ;
pTxResult->hOs = hOs;
return( (TI_HANDLE)pTxResult );
}
/****************************************************************************
* txResult_Destroy()
****************************************************************************
* DESCRIPTION: Destroy the Tx-Result object
*
* INPUTS: hTxResult - The object to free
*
* OUTPUT: None
*
* RETURNS: TI_OK or TI_NOK
****************************************************************************/
TI_STATUS txResult_Destroy(TI_HANDLE hTxResult)
{
TTxResultObj *pTxResult = (TTxResultObj *)hTxResult;
if (pTxResult)
{
if (pTxResult->tResultsInfoReadTxn.pTxResultInfo)
{
os_memoryFree (pTxResult->hOs, pTxResult->tResultsInfoReadTxn.pTxResultInfo - WSPI_PAD_LEN_READ, sizeof(TI_UINT32) + WSPI_PAD_LEN_READ);
}
if (pTxResult->tHostCounterWriteTxn.pCounter)
{
os_memoryFree (pTxResult->hOs, pTxResult->tHostCounterWriteTxn.pCounter - WSPI_PAD_LEN_READ, sizeof(TI_UINT32) + WSPI_PAD_LEN_READ);
}
os_memoryFree(pTxResult->hOs, pTxResult, sizeof(TTxResultObj));
}
return TI_OK;
}
/****************************************************************************
* txResult_Init()
****************************************************************************
DESCRIPTION:
============
Initialize the txResult module.
****************************************************************************/
TI_STATUS txResult_Init(TI_HANDLE hTxResult, TI_HANDLE hReport, TI_HANDLE hTwIf)
{
TTxResultObj *pTxResult = (TTxResultObj *)hTxResult;
TTxnStruct *pTxn;
pTxResult->hReport = hReport;
pTxResult->hTwIf = hTwIf;
/* Prepare Host-Results-Counter write transaction (HwAddr is filled before each transaction) */
pTxn = &pTxResult->tHostCounterWriteTxn.tTxnStruct;
TXN_PARAM_SET(pTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_WRITE, TXN_INC_ADDR)
BUILD_TTxnStruct(pTxn, 0, pTxResult->tHostCounterWriteTxn.pCounter, REGISTER_SIZE, NULL, NULL)
/* Prepare Tx-Result counter and table read transaction (HwAddr is filled before each transaction) */
pTxn = &pTxResult->tResultsInfoReadTxn.tTxnStruct;
TXN_PARAM_SET(pTxn, TXN_LOW_PRIORITY, TXN_FUNC_ID_WLAN, TXN_DIRECTION_READ, TXN_INC_ADDR)
BUILD_TTxnStruct(pTxn,
0,
pTxResult->tResultsInfoReadTxn.pTxResultInfo,
sizeof(TxResultInterface_t),
(TTxnDoneCb)txResult_StateMachine,
hTxResult)
txResult_Restart (pTxResult);
return TI_OK;
}
/****************************************************************************
* txResult_Restart()
****************************************************************************
DESCRIPTION:
============
Restarts the Tx-Result module.
Called upon init and recovery.
Shouldn't be called upon disconnect, since the FW provides Tx-Complete
for all pending packets in FW!!
****************************************************************************/
static void txResult_Restart (TTxResultObj *pTxResult)
{
pTxResult->uHostResultsCounter = 0;
pTxResult->eState = TX_RESULT_STATE_IDLE;
}
/****************************************************************************
* txResult_setHwInfo()
****************************************************************************
* DESCRIPTION:
* Called after the HW configuration upon init or recovery.
* Store the Tx-result table HW address.
****************************************************************************/
void txResult_setHwInfo(TI_HANDLE hTxResult, TDmaParams *pDmaParams)
{
TTxResultObj *pTxResult = (TTxResultObj *)hTxResult;
pTxResult->uTxResultInfoAddr = (TI_UINT32)(pDmaParams->fwTxResultInterface);
pTxResult->uTxResultHostCounterAddr = pTxResult->uTxResultInfoAddr +
TI_FIELD_OFFSET(TxResultControl_t, TxResultHostCounter);
txResult_Restart (pTxResult);
}
/****************************************************************************
* txResult_TxCmpltIntrCb()
****************************************************************************
* DESCRIPTION:
* ============
* Called upon DATA interrupt from the FW.
* If new Tx results are available, start handling them.
*
* INPUTS: hTxResult - the txResult object handle.
* pFwStatus - The FW status registers read by the FwEvent
*
* OUTPUT: None
*
* RETURNS: void
***************************************************************************/
void txResult_TxCmpltIntrCb (TI_HANDLE hTxResult, FwStatus_t *pFwStatus)
{
TTxResultObj *pTxResult = (TTxResultObj *)hTxResult;
TI_UINT32 uTempCounters;
FwStatCntrs_t *pFwStatusCounters;
#ifdef TI_DBG
pTxResult->uInterruptsCounter++;
if (pTxResult->eState != TX_RESULT_STATE_IDLE)
{
TRACE1(pTxResult->hReport, REPORT_SEVERITY_INFORMATION, ": called in eState %d, so exit\n", pTxResult->eState);
return;
}
#endif
/* If no new results - exit (may happen since Data interrupt is common to all Tx&Rx events) */
uTempCounters = ENDIAN_HANDLE_LONG(pFwStatus->counters);
pFwStatusCounters = (FwStatCntrs_t *)&uTempCounters;
if (pFwStatusCounters->txResultsCntr == (TI_UINT8)pTxResult->uHostResultsCounter)
{
TRACE0(pTxResult->hReport, REPORT_SEVERITY_INFORMATION, ": No new Tx results\n");
return;
}
/* Call the SM to handle the new Tx results */
txResult_StateMachine (hTxResult);
}
/****************************************************************************
* txResult_StateMachine()
****************************************************************************
* DESCRIPTION:
*
* The main SM of the module. Called in IDLE eState by txResult_TxCmpltIntrCb() on
* Data interrupt from the FW.
* If no new results - exit (may happen since Data interrupt is common to all Tx&Rx events)
* Read all Tx-Result cyclic table.
* Go over the new Tx-results and call the upper layer callback function for each packet result.
* At the end - write the new host counter to the FW.
*
* INPUTS:
*
* OUTPUT:
*
* RETURNS: None
****************************************************************************/
static void txResult_StateMachine (TI_HANDLE hTxResult)
{
TTxResultObj *pTxResult = (TTxResultObj *)hTxResult;
ETxnStatus eTwifStatus = TXN_STATUS_COMPLETE; /* Last bus operation status: Complete (Sync) or Pending (Async). */
TTxnStruct *pTxn = &(pTxResult->tResultsInfoReadTxn.tTxnStruct);
/* Loop while processing is completed in current context (sync), or until fully completed */
while (eTwifStatus == TXN_STATUS_COMPLETE)
{
TRACE2(pTxResult->hReport, REPORT_SEVERITY_INFORMATION, ": eState = %d, eTwifStatus = %d\n", pTxResult->eState, eTwifStatus);
switch(pTxResult->eState)
{
case TX_RESULT_STATE_IDLE:
/* Read Tx-Result queue and counters. */
pTxn->uHwAddr = pTxResult->uTxResultInfoAddr;
eTwifStatus = twIf_Transact (pTxResult->hTwIf, pTxn);
pTxResult->eState = TX_RESULT_STATE_READING;
break;
case TX_RESULT_STATE_READING:
/* Process new Tx results, call upper layers to handle them and update host-index in the FW. */
txResult_HandleNewResults (pTxResult);
pTxResult->eState = TX_RESULT_STATE_IDLE;
return; /********* Exit after all processing is finished **********/
default:
TRACE1(pTxResult->hReport, REPORT_SEVERITY_ERROR, ": Unknown eState = %d\n", pTxResult->eState);
return;
}
}
if (eTwifStatus == TXN_STATUS_ERROR)
{
TRACE2(pTxResult->hReport, REPORT_SEVERITY_ERROR, ": returning ERROR in eState %d, eTwifStatus=%d !!!\n", pTxResult->eState, eTwifStatus);
}
}
/****************************************************************************
* txResult_HandleNewResults()
****************************************************************************
* DESCRIPTION:
* ============
* We now have the Tx Result table info from the FW so do as follows:
* 1. Find the number of new results (FW counter minus host counter), and if 0 exit.
* 2. Call the upper layers callback per Tx result.
* 3. Update Host-Counter to be equal to the FW-Counter, and write it to the FW.
***************************************************************************/
static void txResult_HandleNewResults (TTxResultObj *pTxResult)
{
TI_UINT32 uNumNewResults; /* The number of new Tx-Result entries to be processed. */
TI_UINT32 uFwResultsCounter; /* The FW current results counter (accumulated). */
TI_UINT32 uTableIndex;
TI_UINT32 i;
TxResultDescriptor_t *pCurrentResult;
TTxnStruct *pTxn = &(pTxResult->tHostCounterWriteTxn.tTxnStruct);
/* The uFwResultsCounter is the accumulated number of Tx-Results provided by the FW, and the
* uHostResultsCounter is the accumulated number of Tx-Results processed by the host.
* The delta is the number of new Tx-results in the queue, waiting for host processing.
* Since the difference is always a small positive number, a simple subtraction is good
* also for wrap around case.
*/
uFwResultsCounter = ENDIAN_HANDLE_LONG(((TxResultInterface_t*)(pTxResult->tResultsInfoReadTxn.pTxResultInfo))->TxResultControl.TxResultFwCounter);
uNumNewResults = uFwResultsCounter - pTxResult->uHostResultsCounter;
#ifdef TI_DBG
/* Verify there are new entries (was already checked in txResult_TxCmpltIntrCb) */
if (uNumNewResults == 0)
{
TRACE2(pTxResult->hReport, REPORT_SEVERITY_WARNING, ": No New Results although indicated by FwStatus!! HostCount=%d, FwCount=%d\n", pTxResult->uHostResultsCounter, uFwResultsCounter);
return;
}
#endif
/* Update host results-counter in FW to be equal to the FW counter (all new results were processed). */
*((TI_UINT32*)(pTxResult->tHostCounterWriteTxn.pCounter)) = ENDIAN_HANDLE_LONG(uFwResultsCounter);
pTxn->uHwAddr = pTxResult->uTxResultHostCounterAddr;
twIf_Transact(pTxResult->hTwIf, pTxn);
TRACE3(pTxResult->hReport, REPORT_SEVERITY_INFORMATION, ": NumResults=%d, OriginalHostCount=%d, FwCount=%d\n", uNumNewResults, pTxResult->uHostResultsCounter, uFwResultsCounter);
/* Loop over all new Tx-results and call Tx-complete callback with current entry pointer. */
/* NOTE: THIS SHOULD COME LAST because it may lead to driver-stop process!! */
for (i = 0; i < uNumNewResults; i++)
{
uTableIndex = pTxResult->uHostResultsCounter & TX_RESULT_QUEUE_DEPTH_MASK;
pCurrentResult = &(((TxResultInterface_t*)(pTxResult->tResultsInfoReadTxn.pTxResultInfo))->TxResultQueue[uTableIndex]);
pTxResult->uHostResultsCounter++;
TRACE1(pTxResult->hReport, REPORT_SEVERITY_INFORMATION , ": call upper layer CB, Status = %d\n", pCurrentResult->status);
pTxResult->fSendPacketCompleteCb (pTxResult->hSendPacketCompleteHndl, pCurrentResult);
}
}
/****************************************************************************
* txResult_RegisterCb()
****************************************************************************
* DESCRIPTION: Register the upper driver Tx-Result callback functions.
****************************************************************************/
void txResult_RegisterCb (TI_HANDLE hTxResult, TI_UINT32 uCallBackId, void *CBFunc, TI_HANDLE hCbObj)
{
TTxResultObj* pTxResult = (TTxResultObj*)hTxResult;
switch (uCallBackId)
{
/* Set Tx-Complete callback */
case TWD_INT_SEND_PACKET_COMPLETE:
pTxResult->fSendPacketCompleteCb = (TSendPacketCompleteCb)CBFunc;
pTxResult->hSendPacketCompleteHndl = hCbObj;
break;
default:
TRACE0(pTxResult->hReport, REPORT_SEVERITY_ERROR, ": Illegal value\n");
return;
}
}
#ifdef TI_DBG /* Debug Functions */
/****************************************************************************
* txResult_PrintInfo()
****************************************************************************
* DESCRIPTION: Prints TX result debug information.
****************************************************************************/
void txResult_PrintInfo (TI_HANDLE hTxResult)
{
TTxResultObj* pTxResult = (TTxResultObj*)hTxResult;
WLAN_OS_REPORT(("Tx-Result Module Information:\n"));
WLAN_OS_REPORT(("=============================\n"));
WLAN_OS_REPORT(("uInterruptsCounter: %d\n", pTxResult->uInterruptsCounter));
WLAN_OS_REPORT(("uHostResultsCounter: %d\n", pTxResult->uHostResultsCounter));
WLAN_OS_REPORT(("=============================\n"));
}
/****************************************************************************
* txResult_ClearInfo()
****************************************************************************
* DESCRIPTION: Clears TX result debug information.
****************************************************************************/
void txResult_ClearInfo (TI_HANDLE hTxResult)
{
TTxResultObj* pTxResult = (TTxResultObj*)hTxResult;
pTxResult->uInterruptsCounter = 0;
}
#endif /* TI_DBG */