/*
* TxnQueue.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.
*/
/** \file TxnQueue.c
* \brief The transaction-queue module.
*
* The Transaction Queue encapsulates the bus access from a functional driver (WLAN, BT).
* This TI proprietary module presents the same interface and same behavior for different
* bus configuration: SDIO (multi or single function) or SPI and for different modes
* of operation: Synchronous, a-synchronous or combination of both.
* It will also be used over the RS232 interface (using wUART protocol) which is applicable
* for RS applications (on PC).
*
* The TxnQ module provides the following requirements:
* Inter process protection on queue's internal database and synchronization between
* functional drivers that share the bus.
* Support multiple queues per function, handled by priority.
* Support the TTxnStruct API (as the Bus Driver) with the ability to manage commands
* queuing of multiple functions on top of the Bus Driver.
* The TxnQ (as well as the layers above it) is agnostic to the bus driver used beneath it
* (SDIO, WSPI or wUART), since all bus drivers introduce the same API and hide bus details.
* The TxnQ has no OS dependencies. It supports access from multiple OS threads.
* Note: It is assumed that any transaction forwarded to the TxnQ has enough resources in HW.
*
* \see TxnQueue.h
*/
#define __FILE_ID__ FILE_ID_123
#include "tidef.h"
#include "report.h"
#include "context.h"
#include "osApi.h"
#include "TxnDefs.h"
#include "BusDrv.h"
#include "TxnQueue.h"
/************************************************************************
* Defines
************************************************************************/
#define MAX_FUNCTIONS 4 /* Maximum 4 functional drivers (including Func 0 which is for bus control) */
#define MAX_PRIORITY 2 /* Maximum 2 prioritys per functional driver */
#define TXN_QUE_SIZE QUE_UNLIMITED_SIZE
#define TXN_DONE_QUE_SIZE QUE_UNLIMITED_SIZE
/************************************************************************
* Types
************************************************************************/
/* Functional driver's SM States */
typedef enum
{
FUNC_STATE_NONE, /* Function not registered */
FUNC_STATE_STOPPED, /* Queues are stopped */
FUNC_STATE_RUNNING, /* Queues are running */
FUNC_STATE_RESTART /* Wait for current Txn to finish before restarting queues */
} EFuncState;
/* The functional drivers registered to TxnQ */
typedef struct
{
EFuncState eState; /* Function crrent state */
TI_UINT32 uNumPrios; /* Number of queues (priorities) for this function */
TTxnQueueDoneCb fTxnQueueDoneCb; /* The CB called by the TxnQueue upon full transaction completion. */
TI_HANDLE hCbHandle; /* The callback handle */
TTxnStruct * pSingleStep; /* A single step transaction waiting to be sent */
} TFuncInfo;
/* The TxnQueue module Object */
typedef struct _TTxnQObj
{
TI_HANDLE hOs;
TI_HANDLE hReport;
TI_HANDLE hContext;
TI_HANDLE hBusDrv;
TFuncInfo aFuncInfo[MAX_FUNCTIONS]; /* Registered functional drivers - see above */
TI_HANDLE aTxnQueues[MAX_FUNCTIONS][MAX_PRIORITY]; /* Handle of the Transactions-Queue */
TI_HANDLE hTxnDoneQueue; /* Queue for completed transactions not reported to yet to the upper layer */
TTxnStruct * pCurrTxn; /* The transaction currently processed in the bus driver (NULL if none) */
TI_UINT32 uMinFuncId; /* The minimal function ID actually registered (through txnQ_Open) */
TI_UINT32 uMaxFuncId; /* The maximal function ID actually registered (through txnQ_Open) */
TI_BOOL bSchedulerBusy; /* If set, the scheduler is currently running so it shouldn't be reentered */
TI_BOOL bSchedulerPend; /* If set, a call to the scheduler was postponed because it was busy */
/* Environment dependent: TRUE if needed and allowed to protect TxnDone in critical section */
TTxnDoneCb fConnectCb;
TI_HANDLE hConnectCb;
#ifdef TI_DBG
TI_HANDLE pAggregQueue; /* While Tx aggregation in progress, saves its queue pointer to ensure continuity */
#endif
} TTxnQObj;
/************************************************************************
* Internal functions prototypes
************************************************************************/
static void txnQ_TxnDoneCb (TI_HANDLE hTxnQ, void *hTxn);
static ETxnStatus txnQ_RunScheduler (TTxnQObj *pTxnQ, TTxnStruct *pInputTxn);
static ETxnStatus txnQ_Scheduler (TTxnQObj *pTxnQ, TTxnStruct *pInputTxn);
static TTxnStruct *txnQ_SelectTxn (TTxnQObj *pTxnQ);
static void txnQ_ConnectCB (TI_HANDLE hTxnQ, void *hTxn);
/************************************************************************
*
* Module functions implementation
*
************************************************************************/
TI_HANDLE txnQ_Create (TI_HANDLE hOs)
{
TI_HANDLE hTxnQ;
TTxnQObj *pTxnQ;
TI_UINT32 i;
hTxnQ = os_memoryAlloc(hOs, sizeof(TTxnQObj),MemoryNormal);
if (hTxnQ == NULL)
return NULL;
pTxnQ = (TTxnQObj *)hTxnQ;
os_memoryZero(hOs, hTxnQ, sizeof(TTxnQObj));
pTxnQ->hOs = hOs;
pTxnQ->pCurrTxn = NULL;
pTxnQ->uMinFuncId = MAX_FUNCTIONS; /* Start at maximum and save minimal value in txnQ_Open */
pTxnQ->uMaxFuncId = 0; /* Start at minimum and save maximal value in txnQ_Open */
#ifdef TI_DBG
pTxnQ->pAggregQueue = NULL;
#endif
for (i = 0; i < MAX_FUNCTIONS; i++)
{
pTxnQ->aFuncInfo[i].eState = FUNC_STATE_NONE;
pTxnQ->aFuncInfo[i].uNumPrios = 0;
pTxnQ->aFuncInfo[i].pSingleStep = NULL;
pTxnQ->aFuncInfo[i].fTxnQueueDoneCb = NULL;
pTxnQ->aFuncInfo[i].hCbHandle = NULL;
}
/* Create the Bus-Driver module */
pTxnQ->hBusDrv = busDrv_Create (hOs);
if (pTxnQ->hBusDrv == NULL)
{
WLAN_OS_REPORT(("%s: Error - failed to create BusDrv\n", __FUNCTION__));
txnQ_Destroy (hTxnQ);
return NULL;
}
return pTxnQ;
}
TI_STATUS txnQ_Destroy (TI_HANDLE hTxnQ)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
if (pTxnQ)
{
if (pTxnQ->hBusDrv)
{
busDrv_Destroy (pTxnQ->hBusDrv);
}
if (pTxnQ->hTxnDoneQueue)
{
que_Destroy (pTxnQ->hTxnDoneQueue);
}
os_memoryFree (pTxnQ->hOs, pTxnQ, sizeof(TTxnQObj));
}
return TI_OK;
}
void txnQ_Init (TI_HANDLE hTxnQ, TI_HANDLE hOs, TI_HANDLE hReport, TI_HANDLE hContext)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
TI_UINT32 uNodeHeaderOffset;
pTxnQ->hOs = hOs;
pTxnQ->hReport = hReport;
pTxnQ->hContext = hContext;
/* Create the TxnDone queue. */
uNodeHeaderOffset = TI_FIELD_OFFSET(TTxnStruct, tTxnQNode);
pTxnQ->hTxnDoneQueue = que_Create (pTxnQ->hOs, pTxnQ->hReport, TXN_DONE_QUE_SIZE, uNodeHeaderOffset);
if (pTxnQ->hTxnDoneQueue == NULL)
{
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_ERROR, ": TxnDone queue creation failed!\n");
}
busDrv_Init (pTxnQ->hBusDrv, hReport);
}
TI_STATUS txnQ_ConnectBus (TI_HANDLE hTxnQ,
TBusDrvCfg *pBusDrvCfg,
TTxnDoneCb fConnectCb,
TI_HANDLE hConnectCb,
TI_UINT32 *pRxDmaBufLen,
TI_UINT32 *pTxDmaBufLen)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_ConnectBus()\n");
pTxnQ->fConnectCb = fConnectCb;
pTxnQ->hConnectCb = hConnectCb;
return busDrv_ConnectBus (pTxnQ->hBusDrv, pBusDrvCfg, txnQ_TxnDoneCb, hTxnQ, txnQ_ConnectCB);
}
TI_STATUS txnQ_DisconnectBus (TI_HANDLE hTxnQ)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
return busDrv_DisconnectBus (pTxnQ->hBusDrv);
}
TI_STATUS txnQ_Open (TI_HANDLE hTxnQ,
TI_UINT32 uFuncId,
TI_UINT32 uNumPrios,
TTxnQueueDoneCb fTxnQueueDoneCb,
TI_HANDLE hCbHandle)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
TI_UINT32 uNodeHeaderOffset;
TI_UINT32 i;
if (uFuncId >= MAX_FUNCTIONS || uNumPrios > MAX_PRIORITY)
{
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_ERROR, ": Invalid Params! uFuncId = %d, uNumPrios = %d\n", uFuncId, uNumPrios);
return TI_NOK;
}
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
/* Save functional driver info */
pTxnQ->aFuncInfo[uFuncId].uNumPrios = uNumPrios;
pTxnQ->aFuncInfo[uFuncId].fTxnQueueDoneCb = fTxnQueueDoneCb;
pTxnQ->aFuncInfo[uFuncId].hCbHandle = hCbHandle;
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_STOPPED;
/* Create the functional driver's queues. */
uNodeHeaderOffset = TI_FIELD_OFFSET(TTxnStruct, tTxnQNode);
for (i = 0; i < uNumPrios; i++)
{
pTxnQ->aTxnQueues[uFuncId][i] = que_Create (pTxnQ->hOs, pTxnQ->hReport, TXN_QUE_SIZE, uNodeHeaderOffset);
if (pTxnQ->aTxnQueues[uFuncId][i] == NULL)
{
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_ERROR, ": Queues creation failed!\n");
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
return TI_NOK;
}
}
/* Update functions actual range (to optimize Txn selection loops - see txnQ_SelectTxn) */
if (uFuncId < pTxnQ->uMinFuncId)
{
pTxnQ->uMinFuncId = uFuncId;
}
if (uFuncId > pTxnQ->uMaxFuncId)
{
pTxnQ->uMaxFuncId = uFuncId;
}
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, ": Function %d registered successfully, uNumPrios = %d\n", uFuncId, uNumPrios);
return TI_OK;
}
void txnQ_Close (TI_HANDLE hTxnQ, TI_UINT32 uFuncId)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
TI_UINT32 i;
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
/* Destroy the functional driver's queues */
for (i = 0; i < pTxnQ->aFuncInfo[uFuncId].uNumPrios; i++)
{
que_Destroy (pTxnQ->aTxnQueues[uFuncId][i]);
}
/* Clear functional driver info */
pTxnQ->aFuncInfo[uFuncId].uNumPrios = 0;
pTxnQ->aFuncInfo[uFuncId].fTxnQueueDoneCb = NULL;
pTxnQ->aFuncInfo[uFuncId].hCbHandle = NULL;
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_NONE;
/* Update functions actual range (to optimize Txn selection loops - see txnQ_SelectTxn) */
pTxnQ->uMinFuncId = MAX_FUNCTIONS;
pTxnQ->uMaxFuncId = 0;
for (i = 0; i < MAX_FUNCTIONS; i++)
{
if (pTxnQ->aFuncInfo[i].eState != FUNC_STATE_NONE)
{
if (i < pTxnQ->uMinFuncId)
{
pTxnQ->uMinFuncId = i;
}
if (i > pTxnQ->uMaxFuncId)
{
pTxnQ->uMaxFuncId = i;
}
}
}
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
TRACE1(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, ": Function %d Unregistered\n", uFuncId);
}
ETxnStatus txnQ_Restart (TI_HANDLE hTxnQ, TI_UINT32 uFuncId)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Restart()\n");
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
/* If a Txn from the calling function is in progress, set state to RESTART return PENDING */
if (pTxnQ->pCurrTxn)
{
if (TXN_PARAM_GET_FUNC_ID(pTxnQ->pCurrTxn) == uFuncId)
{
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_RESTART;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Restart(): pCurrTxn pending\n");
/* Return PENDING to indicate that the restart will be completed later (in TxnDone) */
return TXN_STATUS_PENDING;
}
}
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
/* Clear the calling function's queues (call function CB with status=RECOVERY) */
txnQ_ClearQueues (hTxnQ, uFuncId);
/* Return COMPLETE to indicate that the restart was completed */
return TXN_STATUS_COMPLETE;
}
void txnQ_Run (TI_HANDLE hTxnQ, TI_UINT32 uFuncId)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
#ifdef TI_DBG
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Run()\n");
if (pTxnQ->aFuncInfo[uFuncId].eState != FUNC_STATE_STOPPED)
{
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_WARNING, "txnQ_Run(): Called while func %d state is %d!\n", uFuncId, pTxnQ->aFuncInfo[uFuncId].eState);
}
#endif
/* Enable function's queues */
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_RUNNING;
/* Send queued transactions as possible */
txnQ_RunScheduler (pTxnQ, NULL);
}
void txnQ_Stop (TI_HANDLE hTxnQ, TI_UINT32 uFuncId)
{
TTxnQObj *pTxnQ = (TTxnQObj*) hTxnQ;
#ifdef TI_DBG
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Stop()\n");
if (pTxnQ->aFuncInfo[uFuncId].eState != FUNC_STATE_RUNNING)
{
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_Stop(): Called while func %d state is %d!\n", uFuncId, pTxnQ->aFuncInfo[uFuncId].eState);
}
#endif
/* Enable function's queues */
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_STOPPED;
}
ETxnStatus txnQ_Transact (TI_HANDLE hTxnQ, TTxnStruct *pTxn)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
TI_UINT32 uFuncId = TXN_PARAM_GET_FUNC_ID(pTxn);
ETxnStatus rc;
if (TXN_PARAM_GET_SINGLE_STEP(pTxn))
{
pTxnQ->aFuncInfo[uFuncId].pSingleStep = pTxn;
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Transact(): Single step Txn\n");
}
else
{
TI_STATUS eStatus;
TI_HANDLE hQueue = pTxnQ->aTxnQueues[uFuncId][TXN_PARAM_GET_PRIORITY(pTxn)];
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
eStatus = que_Enqueue (hQueue, (TI_HANDLE)pTxn);
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
if (eStatus != TI_OK)
{
TRACE3(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_Transact(): Enqueue failed, pTxn=0x%x, HwAddr=0x%x, Len0=%d\n", pTxn, pTxn->uHwAddr, pTxn->aLen[0]);
return TXN_STATUS_ERROR;
}
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Transact(): Regular Txn\n");
}
/* Send queued transactions as possible */
rc = txnQ_RunScheduler (pTxnQ, pTxn);
return rc;
}
/**
* \fn txnQ_ConnectCB
* \brief Pending Connection completion CB
*
* txnQ_ConnectBus CB
*
* \note
* \param hTxnQ - The module's object
* \param pTxn - The completed transaction object
* \return void
* \sa
*/
static void txnQ_ConnectCB (TI_HANDLE hTxnQ, void *hTxn)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
/* Call the Client Connect CB */
pTxnQ->fConnectCb (pTxnQ->hConnectCb, NULL);
}
/**
* \fn txnQ_TxnDoneCb
* \brief Pending Transaction completion CB
*
* Called back by bus-driver upon pending transaction completion in TxnDone context (external!).
* Enqueue completed transaction in TxnDone queue and call scheduler to send queued transactions.
*
* \note
* \param hTxnQ - The module's object
* \param pTxn - The completed transaction object
* \return void
* \sa
*/
static void txnQ_TxnDoneCb (TI_HANDLE hTxnQ, void *hTxn)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
TTxnStruct *pTxn = (TTxnStruct *)hTxn;
TI_UINT32 uFuncId = TXN_PARAM_GET_FUNC_ID(pTxn);
#ifdef TI_DBG
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_TxnDoneCb()\n");
if (pTxn != pTxnQ->pCurrTxn)
{
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_TxnDoneCb(): CB returned pTxn 0x%x while pCurrTxn is 0x%x !!\n", pTxn, pTxnQ->pCurrTxn);
}
#endif
/* If the function of the completed Txn is waiting for restart */
if (pTxnQ->aFuncInfo[uFuncId].eState == FUNC_STATE_RESTART)
{
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_TxnDoneCb(): Handling restart\n");
/* First, Clear the restarted function queues */
txnQ_ClearQueues (hTxnQ, uFuncId);
/* Call function CB for current Txn with restart indication */
TXN_PARAM_SET_STATUS(pTxn, TXN_PARAM_STATUS_RECOVERY);
pTxnQ->aFuncInfo[uFuncId].fTxnQueueDoneCb (pTxnQ->aFuncInfo[uFuncId].hCbHandle, pTxn);
}
/* In the normal case (no restart), enqueue completed transaction in TxnDone queue */
else
{
TI_STATUS eStatus;
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
eStatus = que_Enqueue (pTxnQ->hTxnDoneQueue, (TI_HANDLE)pTxn);
if (eStatus != TI_OK)
{
TRACE3(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_TxnDoneCb(): Enqueue failed, pTxn=0x%x, HwAddr=0x%x, Len0=%d\n", pTxn, pTxn->uHwAddr, pTxn->aLen[0]);
}
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
}
/* Indicate that no transaction is currently processed in the bus-driver */
pTxnQ->pCurrTxn = NULL;
/* Send queued transactions as possible (TRUE indicates we are in external context) */
txnQ_RunScheduler (pTxnQ, NULL);
}
/**
* \fn txnQ_RunScheduler
* \brief Send queued transactions
*
* Run the scheduler, which issues transactions as long as possible.
* Since this function is called from either internal or external (TxnDone) context,
* it handles reentry by setting a bSchedulerPend flag, and running the scheduler again
* when its current iteration is finished.
*
* \note
* \param pTxnQ - The module's object
* \param pInputTxn - The transaction inserted in the current context (NULL if none)
* \return COMPLETE if pCurrTxn completed in this context, PENDING if not, ERROR if failed
* \sa
*/
static ETxnStatus txnQ_RunScheduler (TTxnQObj *pTxnQ, TTxnStruct *pInputTxn)
{
TI_BOOL bFirstIteration;
ETxnStatus eStatus = TXN_STATUS_NONE;
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_RunScheduler()\n");
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
/* If the scheduler is currently busy, set bSchedulerPend flag and exit */
if (pTxnQ->bSchedulerBusy)
{
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_RunScheduler(): Scheduler is busy\n");
pTxnQ->bSchedulerPend = TI_TRUE;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
return TXN_STATUS_PENDING;
}
/* Indicate that the scheduler is currently busy */
pTxnQ->bSchedulerBusy = TI_TRUE;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
bFirstIteration = TI_TRUE;
/*
* Run the scheduler while it has work to do
*/
while (1)
{
/* If first scheduler iteration, save its return code to return the original Txn result */
if (bFirstIteration)
{
eStatus = txnQ_Scheduler (pTxnQ, pInputTxn);
bFirstIteration = TI_FALSE;
}
/* This is for handling pending calls when the scheduler was busy (see above) */
else
{
TRACE0(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_RunScheduler(): Handle pending scheduler call\n");
txnQ_Scheduler (pTxnQ, NULL);
}
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
/* If no pending calls, clear the busy flag and return the original caller Txn status */
if (!pTxnQ->bSchedulerPend)
{
pTxnQ->bSchedulerBusy = TI_FALSE;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
return eStatus;
}
pTxnQ->bSchedulerPend = TI_FALSE;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
}
}
/**
* \fn txnQ_Scheduler
* \brief Send queued transactions
*
* Issue transactions as long as they are available and the bus is not occupied.
* Call CBs of completed transactions, except completion of pInputTxn (covered by the return value).
* Note that this function is called from either internal or external (TxnDone) context.
* However, the txnQ_RunScheduler which calls it, prevents scheduler reentry.
*
* \note
* \param pTxnQ - The module's object
* \param pInputTxn - The transaction inserted in the current context (NULL if none)
* \return COMPLETE if pInputTxn completed in this context, PENDING if not, ERROR if failed
* \sa txnQ_RunScheduler
*/
static ETxnStatus txnQ_Scheduler (TTxnQObj *pTxnQ, TTxnStruct *pInputTxn)
{
ETxnStatus eInputTxnStatus;
/* Use as return value the status of the input transaction (PENDING unless sent and completed here) */
eInputTxnStatus = TXN_STATUS_PENDING;
/* if a previous transaction is in progress, return PENDING */
if (pTxnQ->pCurrTxn)
{
TRACE1(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Scheduler(): pCurrTxn isn't null (0x%x) so exit\n", pTxnQ->pCurrTxn);
return TXN_STATUS_PENDING;
}
/* Loop while transactions are available and can be sent to bus driver */
while (1)
{
TTxnStruct *pSelectedTxn;
ETxnStatus eStatus;
/* Get next enabled transaction by priority. If none, exit loop. */
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
pSelectedTxn = txnQ_SelectTxn (pTxnQ);
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
if (pSelectedTxn == NULL)
{
break;
}
/* Save transaction in case it will be async (to indicate that the bus driver is busy) */
pTxnQ->pCurrTxn = pSelectedTxn;
/* Send selected transaction to bus driver */
eStatus = busDrv_Transact (pTxnQ->hBusDrv, pSelectedTxn);
/* If we've just sent the input transaction, use the status as the return value */
if (pSelectedTxn == pInputTxn)
{
eInputTxnStatus = eStatus;
}
TRACE3(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Scheduler(): Txn 0x%x sent, status = %d, eInputTxnStatus = %d\n", pSelectedTxn, eStatus, eInputTxnStatus);
/* If transaction completed */
if (eStatus != TXN_STATUS_PENDING)
{
pTxnQ->pCurrTxn = NULL;
/* If it's not the input transaction, enqueue it in TxnDone queue */
if (pSelectedTxn != pInputTxn)
{
TI_STATUS eStatus;
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
eStatus = que_Enqueue (pTxnQ->hTxnDoneQueue, (TI_HANDLE)pSelectedTxn);
if (eStatus != TI_OK)
{
TRACE3(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_Scheduler(): Enqueue failed, pTxn=0x%x, HwAddr=0x%x, Len0=%d\n", pSelectedTxn, pSelectedTxn->uHwAddr, pSelectedTxn->aLen[0]);
}
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
}
}
/* If pending Exit loop! */
else
{
break;
}
}
/* Dequeue completed transactions and call their functional driver CB */
/* Note that it's the functional driver CB and not the specific CB in the Txn! */
while (1)
{
TTxnStruct *pCompletedTxn;
TI_UINT32 uFuncId;
TTxnQueueDoneCb fTxnQueueDoneCb;
TI_HANDLE hCbHandle;
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
pCompletedTxn = (TTxnStruct *) que_Dequeue (pTxnQ->hTxnDoneQueue);
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
if (pCompletedTxn == NULL)
{
/* Return the status of the input transaction (PENDING unless sent and completed here) */
return eInputTxnStatus;
}
TRACE1(pTxnQ->hReport, REPORT_SEVERITY_INFORMATION, "txnQ_Scheduler(): Calling TxnDone for Txn 0x%x\n", pCompletedTxn);
uFuncId = TXN_PARAM_GET_FUNC_ID(pCompletedTxn);
fTxnQueueDoneCb = pTxnQ->aFuncInfo[uFuncId].fTxnQueueDoneCb;
hCbHandle = pTxnQ->aFuncInfo[uFuncId].hCbHandle;
fTxnQueueDoneCb (hCbHandle, pCompletedTxn);
}
}
/**
* \fn txnQ_SelectTxn
* \brief Select transaction to send
*
* Called from txnQ_RunScheduler() which is protected in critical section.
* Select the next enabled transaction by priority.
*
* \note
* \param pTxnQ - The module's object
* \return The selected transaction to send (NULL if none available)
* \sa
*/
static TTxnStruct *txnQ_SelectTxn (TTxnQObj *pTxnQ)
{
TTxnStruct *pSelectedTxn;
TI_UINT32 uFunc;
TI_UINT32 uPrio;
#ifdef TI_DBG
/* If within Tx aggregation, dequeue Txn from same queue, and if not NULL return it */
if (pTxnQ->pAggregQueue)
{
pSelectedTxn = (TTxnStruct *) que_Dequeue (pTxnQ->pAggregQueue);
if (pSelectedTxn != NULL)
{
/* If aggregation ended, reset the aggregation-queue pointer */
if (TXN_PARAM_GET_AGGREGATE(pSelectedTxn) == TXN_AGGREGATE_OFF)
{
if ((TXN_PARAM_GET_FIXED_ADDR(pSelectedTxn) != TXN_FIXED_ADDR) ||
(TXN_PARAM_GET_DIRECTION(pSelectedTxn) != TXN_DIRECTION_WRITE))
{
TRACE2(pTxnQ->hReport, REPORT_SEVERITY_ERROR, "txnQ_SelectTxn: Mixed transaction during aggregation, HwAddr=0x%x, TxnParams=0x%x\n", pSelectedTxn->uHwAddr, pSelectedTxn->uTxnParams);
}
pTxnQ->pAggregQueue = NULL;
}
return pSelectedTxn;
}
return NULL;
}
#endif
/* For all functions, if single-step Txn waiting, return it (sent even if function is stopped) */
for (uFunc = pTxnQ->uMinFuncId; uFunc <= pTxnQ->uMaxFuncId; uFunc++)
{
pSelectedTxn = pTxnQ->aFuncInfo[uFunc].pSingleStep;
if (pSelectedTxn != NULL)
{
pTxnQ->aFuncInfo[uFunc].pSingleStep = NULL;
return pSelectedTxn;
}
}
/* For all priorities from high to low */
for (uPrio = 0; uPrio < MAX_PRIORITY; uPrio++)
{
/* For all functions */
for (uFunc = pTxnQ->uMinFuncId; uFunc <= pTxnQ->uMaxFuncId; uFunc++)
{
/* If function running and uses this priority */
if (pTxnQ->aFuncInfo[uFunc].eState == FUNC_STATE_RUNNING &&
pTxnQ->aFuncInfo[uFunc].uNumPrios > uPrio)
{
/* Dequeue Txn from current func and priority queue, and if not NULL return it */
pSelectedTxn = (TTxnStruct *) que_Dequeue (pTxnQ->aTxnQueues[uFunc][uPrio]);
if (pSelectedTxn != NULL)
{
#ifdef TI_DBG
/* If aggregation begins, save the aggregation-queue pointer to ensure continuity */
if (TXN_PARAM_GET_AGGREGATE(pSelectedTxn) == TXN_AGGREGATE_ON)
{
pTxnQ->pAggregQueue = pTxnQ->aTxnQueues[uFunc][uPrio];
}
#endif
return pSelectedTxn;
}
}
}
}
/* If no transaction was selected, return NULL */
return NULL;
}
void txnQ_ClearQueues (TI_HANDLE hTxnQ, TI_UINT32 uFuncId)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
TTxnStruct *pTxn;
TI_UINT32 uPrio;
CONTEXT_ENTER_CRITICAL_SECTION (pTxnQ->hContext);
pTxnQ->aFuncInfo[uFuncId].pSingleStep = NULL;
/* For all function priorities */
for (uPrio = 0; uPrio < pTxnQ->aFuncInfo[uFuncId].uNumPrios; uPrio++)
{
while (1)
{
/* Dequeue Txn from current priority queue */
pTxn = (TTxnStruct *) que_Dequeue (pTxnQ->aTxnQueues[uFuncId][uPrio]);
/* If NULL Txn (queue empty), exit while loop */
if (pTxn == NULL)
{
break;
}
/*
* Drop on Restart
* do not call fTxnQueueDoneCb (hCbHandle, pTxn) callback
*/
}
}
/* Clear state - for restart (doesn't call txnQ_Open) */
pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_RUNNING;
CONTEXT_LEAVE_CRITICAL_SECTION (pTxnQ->hContext);
}
#ifdef TI_DBG
void txnQ_PrintQueues (TI_HANDLE hTxnQ)
{
TTxnQObj *pTxnQ = (TTxnQObj*)hTxnQ;
WLAN_OS_REPORT(("Print TXN queues\n"));
WLAN_OS_REPORT(("================\n"));
que_Print(pTxnQ->aTxnQueues[TXN_FUNC_ID_WLAN][TXN_LOW_PRIORITY]);
que_Print(pTxnQ->aTxnQueues[TXN_FUNC_ID_WLAN][TXN_HIGH_PRIORITY]);
}
#endif /* TI_DBG */