/*

 * 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);