--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/TWD/FW_Transfer/txResult.c Tue Jun 29 12:34:26 2010 +0100
@@ -0,0 +1,494 @@
+/*
+ * 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 */
+
+