| /* |
| * SdioBusDrv.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 SdioBusDrv.c |
| * \brief The SDIO bus driver upper layer. Platform independent. |
| * Uses the SdioAdapter API. |
| * Introduces a generic bus-independent API upwards. |
| * |
| * \see BusDrv.h, SdioAdapter.h, SdioAdapter.c |
| */ |
| |
| #define __FILE_ID__ FILE_ID_122 |
| #include "tidef.h" |
| #include "report.h" |
| #include "osApi.h" |
| #include "TxnDefs.h" |
| #include "SdioAdapter.h" |
| #include "BusDrv.h" |
| #include "bmtrace_api.h" |
| |
| |
| /* remove the chipID check when WL6-PG1.0 becomes obsolete (temporary global variable!!) */ |
| extern TI_BOOL bChipIs1273Pg10; |
| |
| |
| /************************************************************************ |
| * Defines |
| ************************************************************************/ |
| #define MAX_TXN_PARTS MAX_XFER_BUFS * 2 /* Max number of txn parts derived from one TxnStruct */ |
| |
| |
| /************************************************************************ |
| * Types |
| ************************************************************************/ |
| |
| /* A single SDIO bus transaction which is a part of a complete transaction (TTxnStruct) */ |
| typedef struct |
| { |
| TI_BOOL bBlkMode; /* If TRUE this is a block-mode SDIO transaction */ |
| TI_UINT32 uLength; /* Length in byte */ |
| TI_UINT32 uHwAddr; /* The device address to write to or read from */ |
| void * pHostAddr; /* The host buffer address to write from or read into */ |
| TI_BOOL bMore; /* If TRUE, indicates the lower driver to keep awake for more transactions */ |
| } TTxnPart; |
| |
| |
| /* The busDrv module Object */ |
| typedef struct _TBusDrvObj |
| { |
| TI_HANDLE hOs; |
| TI_HANDLE hReport; |
| |
| TBusDrvTxnDoneCb fTxnDoneCb; /* The callback to call upon full transaction completion. */ |
| TI_HANDLE hCbHandle; /* The callback handle */ |
| TTxnStruct * pCurrTxn; /* The transaction currently being processed */ |
| ETxnStatus eCurrTxnStatus; /* COMPLETE, PENDING or ERROR */ |
| TTxnPart aTxnParts[MAX_TXN_PARTS]; /* The actual bus transactions of current transaction */ |
| TI_UINT32 uCurrTxnPartsNum; /* Number of transaction parts composing the current transaction */ |
| TI_UINT32 uCurrTxnPartsCount; /* Number of transaction parts already executed */ |
| TI_UINT32 uCurrTxnPartsCountSync; /* Number of transaction parts completed in Sync mode (returned COMPLETE) */ |
| TI_UINT32 uBlkSizeShift; /* In block-mode: uBlkSize = (1 << uBlkSizeShift) = 512 bytes */ |
| TI_UINT32 uBlkSize; /* In block-mode: uBlkSize = (1 << uBlkSizeShift) = 512 bytes */ |
| TI_UINT32 uBlkSizeMask; /* In block-mode: uBlkSizeMask = uBlkSize - 1 = 0x1FF*/ |
| TI_UINT8 * pDmaBuffer; /* DMA-able buffer for buffering all write transactions */ |
| |
| } TBusDrvObj; |
| |
| |
| /************************************************************************ |
| * Internal functions prototypes |
| ************************************************************************/ |
| static void busDrv_PrepareTxnParts (TBusDrvObj *pBusDrv, TTxnStruct *pTxn); |
| static void busDrv_SendTxnParts (TBusDrvObj *pBusDrv); |
| static void busDrv_TxnDoneCb (TI_HANDLE hBusDrv, TI_INT32 status); |
| |
| |
| |
| /************************************************************************ |
| * |
| * Module functions implementation |
| * |
| ************************************************************************/ |
| |
| /** |
| * \fn busDrv_Create |
| * \brief Create the module |
| * |
| * Create and clear the bus driver's object, and the SDIO-adapter. |
| * |
| * \note |
| * \param hOs - Handle to Os Abstraction Layer |
| * \return Handle of the allocated object, NULL if allocation failed |
| * \sa busDrv_Destroy |
| */ |
| TI_HANDLE busDrv_Create (TI_HANDLE hOs) |
| { |
| TI_HANDLE hBusDrv; |
| TBusDrvObj *pBusDrv; |
| |
| hBusDrv = os_memoryAlloc(hOs, sizeof(TBusDrvObj)); |
| if (hBusDrv == NULL) |
| { |
| return NULL; |
| } |
| |
| pBusDrv = (TBusDrvObj *)hBusDrv; |
| |
| os_memoryZero(hOs, hBusDrv, sizeof(TBusDrvObj)); |
| |
| pBusDrv->hOs = hOs; |
| |
| return pBusDrv; |
| } |
| |
| |
| /** |
| * \fn busDrv_Destroy |
| * \brief Destroy the module. |
| * |
| * Close SDIO lower bus driver and free the module's object. |
| * |
| * \note |
| * \param The module's object |
| * \return TI_OK on success or TI_NOK on failure |
| * \sa busDrv_Create |
| */ |
| TI_STATUS busDrv_Destroy (TI_HANDLE hBusDrv) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*)hBusDrv; |
| |
| if (pBusDrv) |
| { |
| os_memoryFree (pBusDrv->hOs, pBusDrv, sizeof(TBusDrvObj)); |
| } |
| return TI_OK; |
| } |
| |
| |
| /** |
| * \fn busDrv_Init |
| * \brief Init bus driver |
| * |
| * Init module parameters. |
| |
| * \note |
| * \param hBusDrv - The module's handle |
| * \param hReport - report module handle |
| * \return void |
| * \sa |
| */ |
| void busDrv_Init (TI_HANDLE hBusDrv, TI_HANDLE hReport) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*) hBusDrv; |
| |
| pBusDrv->hReport = hReport; |
| } |
| |
| |
| /** |
| * \fn busDrv_ConnectBus |
| * \brief Configure bus driver |
| * |
| * Called by TxnQ. |
| * Configure the bus driver with its connection configuration (such as baud-rate, bus width etc) |
| * and establish the physical connection. |
| * Done once upon init (and not per functional driver startup). |
| * |
| * \note |
| * \param hBusDrv - The module's object |
| * \param pBusDrvCfg - A union used for per-bus specific configuration. |
| * \param fCbFunc - CB function for Async transaction completion (after all txn parts are completed). |
| * \param hCbArg - The CB function handle |
| * \return TI_OK / TI_NOK |
| * \sa |
| */ |
| TI_STATUS busDrv_ConnectBus (TI_HANDLE hBusDrv, |
| TBusDrvCfg *pBusDrvCfg, |
| TBusDrvTxnDoneCb fCbFunc, |
| TI_HANDLE hCbArg, |
| TBusDrvTxnDoneCb fConnectCbFunc) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*)hBusDrv; |
| int iStatus; |
| |
| /* Save the parameters (TxnQ callback for TxnDone events, and block-size) */ |
| pBusDrv->fTxnDoneCb = fCbFunc; |
| pBusDrv->hCbHandle = hCbArg; |
| pBusDrv->uBlkSizeShift = pBusDrvCfg->tSdioCfg.uBlkSizeShift; |
| pBusDrv->uBlkSize = 1 << pBusDrv->uBlkSizeShift; |
| pBusDrv->uBlkSizeMask = pBusDrv->uBlkSize - 1; |
| /* This should cover stop send Txn parts in recovery */ |
| pBusDrv->uCurrTxnPartsCount = 0; |
| pBusDrv->uCurrTxnPartsNum = 0; |
| pBusDrv->uCurrTxnPartsCountSync = 0; |
| |
| |
| /* |
| * Configure the SDIO driver parameters and handle SDIO enumeration. |
| * |
| * Note: The DMA-able buffer address to use for write transactions is provided from the |
| * SDIO driver into pBusDrv->pDmaBuffer. |
| */ |
| iStatus = sdioAdapt_ConnectBus (busDrv_TxnDoneCb, |
| hBusDrv, |
| pBusDrv->uBlkSizeShift, |
| pBusDrvCfg->tSdioCfg.uBusDrvThreadPriority, |
| &pBusDrv->pDmaBuffer); |
| |
| if (pBusDrv->pDmaBuffer == NULL) |
| { |
| TRACE0(pBusDrv->hReport, REPORT_SEVERITY_ERROR, "busDrv_ConnectBus: Didn't get DMA buffer from SDIO driver!!"); |
| return TI_NOK; |
| } |
| |
| |
| if (iStatus == 0) |
| { |
| return TI_OK; |
| } |
| else |
| { |
| TRACE2(pBusDrv->hReport, REPORT_SEVERITY_ERROR, "busDrv_ConnectBus: Status = 0x%x, BlkSize = %d\n", iStatus, pBusDrv->uBlkSize); |
| return TI_NOK; |
| } |
| } |
| |
| |
| /** |
| * \fn busDrv_DisconnectBus |
| * \brief Disconnect SDIO driver |
| * |
| * Called by TxnQ. Disconnect the SDIO driver. |
| * |
| * \note |
| * \param hBusDrv - The module's object |
| * \return TI_OK / TI_NOK |
| * \sa |
| */ |
| TI_STATUS busDrv_DisconnectBus (TI_HANDLE hBusDrv) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*)hBusDrv; |
| |
| TRACE0(pBusDrv->hReport, REPORT_SEVERITY_INFORMATION, "busDrv_DisconnectBus()\n"); |
| |
| /* Disconnect SDIO driver */ |
| return sdioAdapt_DisconnectBus (); |
| } |
| |
| |
| /** |
| * \fn busDrv_Transact |
| * \brief Process transaction |
| * |
| * Called by the TxnQ module to initiate a new transaction. |
| * Prepare the transaction parts (lower layer single transactions), |
| * and send them one by one to the lower layer. |
| * |
| * \note It's assumed that this function is called only when idle (i.e. previous Txn is done). |
| * \param hBusDrv - The module's object |
| * \param pTxn - The transaction object |
| * \return COMPLETE if Txn completed in this context, PENDING if not, ERROR if failed |
| * \sa busDrv_PrepareTxnParts, busDrv_SendTxnParts |
| */ |
| ETxnStatus busDrv_Transact (TI_HANDLE hBusDrv, TTxnStruct *pTxn) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*)hBusDrv; |
| CL_TRACE_START_L4(); |
| |
| pBusDrv->pCurrTxn = pTxn; |
| pBusDrv->uCurrTxnPartsCount = 0; |
| pBusDrv->uCurrTxnPartsCountSync = 0; |
| |
| /* Prepare the transaction parts in a table. */ |
| busDrv_PrepareTxnParts (pBusDrv, pTxn); |
| |
| /* Send the prepared transaction parts. */ |
| busDrv_SendTxnParts (pBusDrv); |
| |
| TRACE1(pBusDrv->hReport, REPORT_SEVERITY_INFORMATION, "busDrv_Transact: Status = %d\n", pBusDrv->eCurrTxnStatus); |
| |
| CL_TRACE_END_L4("tiwlan_drv.ko", "INHERIT", "TXN", ".Transact"); |
| |
| /* return transaction status - COMPLETE, PENDING or ERROR */ |
| /* The status is updated in busDrv_SendTxnParts(). It is Async (pending) if not completed in this context */ |
| return pBusDrv->eCurrTxnStatus; |
| } |
| |
| |
| /** |
| * \fn busDrv_PrepareTxnParts |
| * \brief Prepare write or read transaction parts |
| * |
| * Called by busDrv_Transact(). |
| * Prepares the actual sequence of SDIO bus transactions in a table. |
| * Use a DMA-able buffer for the bus transaction, so all data is copied |
| * to it from the host buffer(s) before write transactions, |
| * or copied from it to the host buffers after read transactions. |
| * |
| * \note |
| * \param pBusDrv - The module's object |
| * \param pTxn - The transaction object |
| * \return void |
| * \sa busDrv_Transact, busDrv_SendTxnParts, |
| */ |
| static void busDrv_PrepareTxnParts (TBusDrvObj *pBusDrv, TTxnStruct *pTxn) |
| { |
| TI_UINT32 uPartNum = 0; |
| TI_UINT32 uTxnLength = 0; |
| TI_UINT8 *pHostBuf = pBusDrv->pDmaBuffer; /* Host buffer to use for actual transaction is the DMA buffer */ |
| TI_UINT32 uCurrHwAddr = pTxn->uHwAddr; |
| TI_BOOL bFixedHwAddr = TXN_PARAM_GET_FIXED_ADDR(pTxn); |
| TI_UINT32 uBufNum; |
| TI_UINT32 uBufLen; |
| TI_UINT32 uRemainderLen; |
| |
| /* Go over the transaction buffers */ |
| for (uBufNum = 0; uBufNum < MAX_XFER_BUFS; uBufNum++) |
| { |
| uBufLen = pTxn->aLen[uBufNum]; |
| |
| /* If no more buffers, exit the loop */ |
| if (uBufLen == 0) |
| { |
| break; |
| } |
| |
| /* For write transaction, copy the data to the DMA buffer */ |
| if (TXN_PARAM_GET_DIRECTION(pTxn) == TXN_DIRECTION_WRITE) |
| { |
| os_memoryCopy (pBusDrv->hOs, pHostBuf + uTxnLength, pTxn->aBuf[uBufNum], uBufLen); |
| } |
| |
| /* Add buffer length to total transaction length */ |
| uTxnLength += uBufLen; |
| } |
| |
| /* If current buffer has a remainder, prepare its transaction part */ |
| uRemainderLen = uTxnLength & pBusDrv->uBlkSizeMask; |
| if (uRemainderLen > 0) |
| { |
| pBusDrv->aTxnParts[uPartNum].bBlkMode = TI_FALSE; |
| pBusDrv->aTxnParts[uPartNum].uLength = uRemainderLen; |
| pBusDrv->aTxnParts[uPartNum].uHwAddr = uCurrHwAddr; |
| pBusDrv->aTxnParts[uPartNum].pHostAddr = (void *)pHostBuf; |
| pBusDrv->aTxnParts[uPartNum].bMore = TI_TRUE; |
| |
| /* If not fixed HW address, increment it by this part's size */ |
| if (!bFixedHwAddr) |
| { |
| uCurrHwAddr += uRemainderLen; |
| } |
| |
| uPartNum++; |
| } |
| |
| /* SDIO block-mode doesn't work on PG1.0 so split to 512 bytes blocks! |
| Remove when PG1.0 is obsolete! */ |
| if (bChipIs1273Pg10) |
| { |
| TI_UINT32 uLen; |
| |
| for (uLen = uRemainderLen; uLen < uTxnLength; uLen += pBusDrv->uBlkSize) |
| { |
| pBusDrv->aTxnParts[uPartNum].bBlkMode = TI_FALSE; |
| pBusDrv->aTxnParts[uPartNum].uLength = pBusDrv->uBlkSize; |
| pBusDrv->aTxnParts[uPartNum].uHwAddr = uCurrHwAddr; |
| pBusDrv->aTxnParts[uPartNum].pHostAddr = (void *)(pHostBuf + uLen); |
| pBusDrv->aTxnParts[uPartNum].bMore = TI_TRUE; |
| |
| /* If not fixed HW address, increment it by this part's size */ |
| if (!bFixedHwAddr) |
| { |
| uCurrHwAddr += pBusDrv->uBlkSize; |
| } |
| |
| uPartNum++; |
| } |
| } |
| |
| |
| /* For PG2.0, use SDIO block mode */ |
| else |
| { |
| /* If current buffer has full SDIO blocks, prepare a block-mode transaction part */ |
| if (uTxnLength >= pBusDrv->uBlkSize) |
| { |
| pBusDrv->aTxnParts[uPartNum].bBlkMode = TI_TRUE; |
| pBusDrv->aTxnParts[uPartNum].uLength = uTxnLength - uRemainderLen; |
| pBusDrv->aTxnParts[uPartNum].uHwAddr = uCurrHwAddr; |
| pBusDrv->aTxnParts[uPartNum].pHostAddr = (void *)(pHostBuf + uRemainderLen); |
| pBusDrv->aTxnParts[uPartNum].bMore = TI_TRUE; |
| |
| uPartNum++; |
| } |
| } |
| |
| /* Set last More flag as specified for the whole Txn */ |
| pBusDrv->aTxnParts[uPartNum - 1].bMore = TXN_PARAM_GET_MORE(pTxn); |
| pBusDrv->uCurrTxnPartsNum = uPartNum; |
| } |
| |
| |
| /** |
| * \fn busDrv_SendTxnParts |
| * \brief Send prepared transaction parts |
| * |
| * Called first by busDrv_Transact(), and also from TxnDone CB after Async completion. |
| * Sends the prepared transaction parts in a loop. |
| * If a transaction part is Async, the loop continues later in the TxnDone ISR context. |
| * When all parts are done, the upper layer TxnDone CB is called. |
| * |
| * \note |
| * \param pBusDrv - The module's object |
| * \return void |
| * \sa busDrv_Transact, busDrv_PrepareTxnParts |
| */ |
| static void busDrv_SendTxnParts (TBusDrvObj *pBusDrv) |
| { |
| ETxnStatus eStatus; |
| TTxnPart *pTxnPart; |
| TTxnStruct *pTxn = pBusDrv->pCurrTxn; |
| |
| /* While there are transaction parts to send */ |
| while (pBusDrv->uCurrTxnPartsCount < pBusDrv->uCurrTxnPartsNum) |
| { |
| pTxnPart = &(pBusDrv->aTxnParts[pBusDrv->uCurrTxnPartsCount]); |
| pBusDrv->uCurrTxnPartsCount++; |
| |
| /* Assume pending to be ready in case we are preempted by the TxnDon CB !! */ |
| pBusDrv->eCurrTxnStatus = TXN_STATUS_PENDING; |
| |
| /* If single step, send ELP byte */ |
| if (TXN_PARAM_GET_SINGLE_STEP(pTxn)) |
| { |
| /* Overwrite the function id with function 0 - for ELP register !!!! */ |
| eStatus = sdioAdapt_TransactBytes (TXN_FUNC_ID_CTRL, |
| pTxnPart->uHwAddr, |
| pTxnPart->pHostAddr, |
| pTxnPart->uLength, |
| TXN_PARAM_GET_DIRECTION(pTxn), |
| pTxnPart->bMore); |
| |
| /* If first write failed try once again (may happen once upon chip wakeup) */ |
| if (eStatus == TXN_STATUS_ERROR) |
| { |
| /* Overwrite the function id with function 0 - for ELP register !!!! */ |
| eStatus = sdioAdapt_TransactBytes (TXN_FUNC_ID_CTRL, |
| pTxnPart->uHwAddr, |
| pTxnPart->pHostAddr, |
| pTxnPart->uLength, |
| TXN_PARAM_GET_DIRECTION(pTxn), |
| pTxnPart->bMore); |
| TRACE0(pBusDrv->hReport, REPORT_SEVERITY_WARNING, "busDrv_SendTxnParts: SDIO Single-Step transaction failed once so try again"); |
| } |
| } |
| else |
| { |
| eStatus = sdioAdapt_Transact (TXN_PARAM_GET_FUNC_ID(pTxn), |
| pTxnPart->uHwAddr, |
| pTxnPart->pHostAddr, |
| pTxnPart->uLength, |
| TXN_PARAM_GET_DIRECTION(pTxn), |
| pTxnPart->bBlkMode, |
| ((TXN_PARAM_GET_FIXED_ADDR(pTxn) == 1) ? 0 : 1), |
| pTxnPart->bMore); |
| } |
| |
| TRACE7(pBusDrv->hReport, REPORT_SEVERITY_INFORMATION, "busDrv_SendTxnParts: PartNum = %d, SingleStep = %d, Direction = %d, HwAddr = 0x%x, HostAddr = 0x%x, Length = %d, BlkMode = %d\n", pBusDrv->uCurrTxnPartsCount-1, TXN_PARAM_GET_SINGLE_STEP(pTxn), TXN_PARAM_GET_DIRECTION(pTxn), pTxnPart->uHwAddr, pTxnPart->pHostAddr, pTxnPart->uLength, pTxnPart->bBlkMode); |
| |
| /* If pending TxnDone (Async), continue this loop in the next TxnDone interrupt */ |
| if (eStatus == TXN_STATUS_PENDING) |
| { |
| return; |
| } |
| |
| /* Update current transaction status to deduce if it is all finished in the original context (Sync) or not. */ |
| pBusDrv->eCurrTxnStatus = eStatus; |
| pBusDrv->uCurrTxnPartsCountSync++; |
| |
| /* If error, set error in Txn struct, call TxnDone CB if not fully sync, and exit */ |
| if (eStatus == TXN_STATUS_ERROR) |
| { |
| TXN_PARAM_SET_STATUS(pTxn, TXN_PARAM_STATUS_ERROR); |
| if (pBusDrv->uCurrTxnPartsCountSync != pBusDrv->uCurrTxnPartsCount) |
| { |
| pBusDrv->fTxnDoneCb (pBusDrv->hCbHandle, pTxn); |
| } |
| return; |
| } |
| } |
| |
| /* If we got here we sent all buffers and we don't pend transaction end */ |
| TRACE3(pBusDrv->hReport, REPORT_SEVERITY_INFORMATION, "busDrv_SendTxnParts: Txn finished successfully, Status = %d, PartsCount = %d, SyncCount = %d\n", pBusDrv->eCurrTxnStatus, pBusDrv->uCurrTxnPartsCount, pBusDrv->uCurrTxnPartsCountSync); |
| |
| /* For read transaction, copy the data from the DMA-able buffer to the host buffer(s) */ |
| if (TXN_PARAM_GET_DIRECTION(pTxn) == TXN_DIRECTION_READ) |
| { |
| TI_UINT32 uBufNum; |
| TI_UINT32 uBufLen; |
| TI_UINT8 *pDmaBuf = pBusDrv->pDmaBuffer; /* After the read transaction the data is in the DMA buffer */ |
| |
| for (uBufNum = 0; uBufNum < MAX_XFER_BUFS; uBufNum++) |
| { |
| uBufLen = pTxn->aLen[uBufNum]; |
| |
| /* If no more buffers, exit the loop */ |
| if (uBufLen == 0) |
| { |
| break; |
| } |
| |
| os_memoryCopy (pBusDrv->hOs, pTxn->aBuf[uBufNum], pDmaBuf, uBufLen); |
| pDmaBuf += uBufLen; |
| } |
| } |
| |
| /* Set status OK in Txn struct, and call TxnDone CB if not fully sync */ |
| TXN_PARAM_SET_STATUS(pTxn, TXN_PARAM_STATUS_OK); |
| if (pBusDrv->uCurrTxnPartsCountSync != pBusDrv->uCurrTxnPartsCount) |
| { |
| pBusDrv->fTxnDoneCb (pBusDrv->hCbHandle, pTxn); |
| } |
| } |
| |
| |
| /** |
| * \fn busDrv_TxnDoneCb |
| * \brief Continue async transaction processing (CB) |
| * |
| * Called back by the lower (BSP) bus-driver upon Async transaction completion (TxnDone ISR). |
| * Call busDrv_SendTxnParts to continue sending the remained transaction parts. |
| * |
| * \note |
| * \param hBusDrv - The module's object |
| * \param status - The last transaction result - 0 = OK, else Error |
| * \return void |
| * \sa busDrv_SendTxnParts |
| */ |
| static void busDrv_TxnDoneCb (TI_HANDLE hBusDrv, int iStatus) |
| { |
| TBusDrvObj *pBusDrv = (TBusDrvObj*)hBusDrv; |
| CL_TRACE_START_L1(); |
| |
| /* If last transaction part failed, set error in Txn struct, call TxnDone CB and exit. */ |
| if (iStatus != 0) |
| { |
| TRACE1(pBusDrv->hReport, REPORT_SEVERITY_ERROR, "busDrv_TxnDoneCb: Status = 0x%x\n", iStatus); |
| |
| TXN_PARAM_SET_STATUS(pBusDrv->pCurrTxn, TXN_PARAM_STATUS_ERROR); |
| pBusDrv->fTxnDoneCb (pBusDrv->hCbHandle, pBusDrv->pCurrTxn); |
| CL_TRACE_END_L1("tiwlan_drv.ko", "TXN_DONE", "BusDrvCB", ""); |
| return; |
| } |
| |
| TRACE0(pBusDrv->hReport, REPORT_SEVERITY_INFORMATION, "busDrv_TxnDoneCb()\n"); |
| |
| /* Continue sending the remained transaction parts. */ |
| busDrv_SendTxnParts (pBusDrv); |
| |
| CL_TRACE_END_L1("tiwlan_drv.ko", "TXN_DONE", "BusDrvCB", ""); |
| } |
