diff options
Diffstat (limited to 'wilink_6_1/Txn/TxnQueue.c')
| -rw-r--r-- | wilink_6_1/Txn/TxnQueue.c | 798 |
1 files changed, 798 insertions, 0 deletions
diff --git a/wilink_6_1/Txn/TxnQueue.c b/wilink_6_1/Txn/TxnQueue.c new file mode 100644 index 0000000..d455e3d --- /dev/null +++ b/wilink_6_1/Txn/TxnQueue.c @@ -0,0 +1,798 @@ +/* + * TxnQueue.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 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 64 /* Txn-queue size */ +#define TXN_DONE_QUE_SIZE 64 /* TxnDone-queue 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; + +} 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_ClearQueues (TTxnQObj *pTxnQ, TI_UINT32 uFuncId); +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)); + 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 */ + + 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) +{ + 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_EnterCriticalSection (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_LeaveCriticalSection (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_LeaveCriticalSection (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_EnterCriticalSection (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_LeaveCriticalSection (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_EnterCriticalSection (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_LeaveCriticalSection (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_LeaveCriticalSection (pTxnQ->hContext); + + /* Clear the calling function's queues (call function CB with status=RECOVERY) */ + txnQ_ClearQueues (pTxnQ, 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_HANDLE hQueue = pTxnQ->aTxnQueues[uFuncId][TXN_PARAM_GET_PRIORITY(pTxn)]; + context_EnterCriticalSection (pTxnQ->hContext); + que_Enqueue (hQueue, (TI_HANDLE)pTxn); + context_LeaveCriticalSection (pTxnQ->hContext); + 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 (pTxnQ, 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 + { + context_EnterCriticalSection (pTxnQ->hContext); + que_Enqueue (pTxnQ->hTxnDoneQueue, (TI_HANDLE)pTxn); + context_LeaveCriticalSection (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_EnterCriticalSection (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_LeaveCriticalSection (pTxnQ->hContext); + return TXN_STATUS_PENDING; + } + + /* Indicate that the scheduler is currently busy */ + pTxnQ->bSchedulerBusy = TI_TRUE; + + context_LeaveCriticalSection (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_EnterCriticalSection (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_LeaveCriticalSection (pTxnQ->hContext); + return eStatus; + } + pTxnQ->bSchedulerPend = TI_FALSE; + + context_LeaveCriticalSection (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_EnterCriticalSection (pTxnQ->hContext); + pSelectedTxn = txnQ_SelectTxn (pTxnQ); + context_LeaveCriticalSection (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) + { + context_EnterCriticalSection (pTxnQ->hContext); + que_Enqueue (pTxnQ->hTxnDoneQueue, (TI_HANDLE)pSelectedTxn); + context_LeaveCriticalSection (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_EnterCriticalSection (pTxnQ->hContext); + pCompletedTxn = (TTxnStruct *) que_Dequeue (pTxnQ->hTxnDoneQueue); + context_LeaveCriticalSection (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; + + /* 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) + { + return pSelectedTxn; + } + } + } + } + + /* If no transaction was selected, return NULL */ + return NULL; +} + + +/** + * \fn txnQ_ClearQueues + * \brief Clear the function queues + * + * Clear the specified function queues and call its CB for each Txn with status=RECOVERY. + * + * \note Called in critical section. + * \param pTxnQ - The module's object + * \param uFuncId - The calling functional driver + * \return void + * \sa + */ +static void txnQ_ClearQueues (TTxnQObj *pTxnQ, TI_UINT32 uFuncId) +{ + TTxnStruct *pTxn; + TI_UINT32 uPrio; + + pTxnQ->aFuncInfo[uFuncId].pSingleStep = NULL; + + /* For all function priorities */ + for (uPrio = 0; uPrio < pTxnQ->aFuncInfo[uFuncId].uNumPrios; uPrio++) + { + do + { + context_EnterCriticalSection (pTxnQ->hContext); + /* Dequeue Txn from current priority queue */ + pTxn = (TTxnStruct *) que_Dequeue (pTxnQ->aTxnQueues[uFuncId][uPrio]); + context_LeaveCriticalSection (pTxnQ->hContext); + + /* + * Drop on Restart + * do not call fTxnQueueDoneCb (hCbHandle, pTxn) callback + */ + } while (pTxn != NULL); + } + + /* Clear state - for restart (doesn't call txnQ_Open) */ + pTxnQ->aFuncInfo[uFuncId].eState = FUNC_STATE_RUNNING; +} + +#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 */ |