| /* |
| * 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 */ |
