/drivers/net/wireless/tiwlan1251/common/src/TNETW_Driver/FW_Transfer/Rx_Xfer/RxXfer.c

/****************************************************************************
**+-----------------------------------------------------------------------+**
**|                                                                       |**
**| Copyright(c) 1998 - 2008 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.  |**
**|                                                                       |**
**+-----------------------------------------------------------------------+**
****************************************************************************/

/****************************************************************************
 *
 *   MODULE:  rxXfer.c
 *
 *   PURPOSE: Rx Xfer module implementation.Responsible for reading Rx from the FW
 *              and forward it to the upper layers.
 * 
 ****************************************************************************/

#include "RxXfer.h"
#include "utils.h"
#include "report.h"
#include "shmUtils.h"
#include "FwEvent_api.h"
#include "tnetwCommon.h"
#include "whalBus_Defs.h"

#define PLCP_HEADER_LENGTH 8

/************************ static function declaration *****************************/

static void      rxXfer_StateMachine (TI_HANDLE hRxXfer, UINT8 module_id, TI_STATUS status);
static TI_STATUS rxXfer_ReadHeader (RxXfer_t *pRxXfer);
static TI_STATUS rxXfer_ReadBody (RxXfer_t *pRxXfer);
static void      rxXfer_ForwardCB (RxXfer_t *pRxXfer);
static TI_STATUS rxXfer_AckRx (RxXfer_t *pRxXfer);
static void      rxXfer_ConvertDescFlagsToAppFlags (UINT16 descRxFlags, UINT32 *aFlags, TI_STATUS *pPacketStatus);


/****************************************************************************
 *                      RxXfer_Create()
 ****************************************************************************
 * DESCRIPTION: Create the RxXfer module object 
 * 
 * INPUTS:  None
 * 
 * OUTPUT:  None
 * 
 * RETURNS: The Created object
 ****************************************************************************/
TI_HANDLE rxXfer_Create (TI_HANDLE hOs)
{
    RxXfer_t *pRxXfer;

    pRxXfer = os_memoryAlloc (hOs, sizeof(RxXfer_t));
    if (pRxXfer == NULL)
        return NULL;

    /* For all the counters */
    os_memoryZero (hOs, pRxXfer, sizeof(RxXfer_t));

    pRxXfer->hOs = hOs;

    return (TI_HANDLE)pRxXfer;
}


/****************************************************************************
 *                      RxXfer_Destroy()
 ****************************************************************************
 * DESCRIPTION: Destroy the RxXfer module object 
 * 
 * INPUTS:  hRxXfer - The object to free
 * 
 * OUTPUT:  None
 * 
 * RETURNS: 
 ****************************************************************************/
void rxXfer_Destroy (TI_HANDLE hRxXfer)
{
    RxXfer_t *pRxXfer = (RxXfer_t *)hRxXfer;

    if (pRxXfer)
    {
        os_memoryFree (pRxXfer->hOs, pRxXfer, sizeof(RxXfer_t));
    }
} /* RxXfer_Destroy() */


/****************************************************************************
 *                      RxXfer_Config()
 ****************************************************************************
 * DESCRIPTION: Destroy the FwEvent module object 
 * 
 * INPUTS:      hRxXfer       - FwEvent handle;
 * 
 * OUTPUT:  None
 * 
 * RETURNS: None
 ****************************************************************************/
void rxXfer_Config(TI_HANDLE hRxXfer,
                   TI_HANDLE hFwEvent, 
                   TI_HANDLE hMemMgr,
                   TI_HANDLE hReport,
                   TI_HANDLE hTNETWIF)
{
    RxXfer_t  *pRxXfer      = (RxXfer_t *)hRxXfer;

    pRxXfer->hFwEvent       = hFwEvent;
    pRxXfer->hMemMgr        = hMemMgr;
    pRxXfer->hReport        = hReport;
    pRxXfer->hTNETWIF       = hTNETWIF;

    pRxXfer->state          = RX_XFER_STATE_IDLE;
    pRxXfer->currBuffer     = 0;        /* first buffer to read from */
    pRxXfer->lastPacketId   = 0;

    FwEvent_Enable (pRxXfer->hFwEvent, ACX_INTR_RX0_DATA);
    FwEvent_Enable (pRxXfer->hFwEvent, ACX_INTR_RX1_DATA);
    
#ifdef TI_DBG   
    rxXfer_ClearStats (pRxXfer);
#endif
}


/****************************************************************************
 *                      rxXfer_Register_CB()
 ****************************************************************************
 * DESCRIPTION: Register the function to be called for received Rx
 *              or the function to be called for request for buffer
 * 
 * INPUTS:      hRxXfer       - RxXfer handle;
 * 
 * OUTPUT:  None
 * 
 * RETURNS: None
 ****************************************************************************/
void rxXfer_Register_CB (TI_HANDLE hRxXfer, tiUINT32 CallBackID, void *CBFunc, TI_HANDLE CBObj)
{
    RxXfer_t* pRxXfer = (RxXfer_t *)hRxXfer;

    WLAN_REPORT_INFORMATION (pRxXfer->hReport, HAL_RX_MODULE_LOG, ("rxXfer_Register_CB (Value = 0x%x)\n", CallBackID));

    switch(CallBackID)
    {
    case HAL_INT_RECEIVE_PACKET:
        pRxXfer->ReceivePacketCB = (packetReceiveCB_t)CBFunc;
        pRxXfer->ReceivePacketCB_handle = CBObj;
        break;

    case HAL_INT_REQUEST_FOR_BUFFER:       
        pRxXfer->RequestForBufferCB = (requestForBufferCB_t)CBFunc;
        pRxXfer->RequestForBufferCB_handle = CBObj;
        break;

    default:
        WLAN_REPORT_ERROR(pRxXfer->hReport, HAL_RX_MODULE_LOG, ("rxXfer_Register_CB - Illegal value\n"));
        return;
    }
}


/****************************************************************************
 *                      rxXfer_SetDoubleBufferAddr()
 ****************************************************************************
 * DESCRIPTION: Store the addresses of the Double Buffer 
 * 
 * INPUTS:      hRxXfer       - RxXfer handle;
 * 
 * OUTPUT:  None
 * 
 * RETURNS: None
 ****************************************************************************/
void rxXfer_SetDoubleBufferAddr (TI_HANDLE hRxXfer, ACXDataPathParamsResp_t *pDataPathParams)
{
    RxXfer_t* pRxXfer = (RxXfer_t *)hRxXfer;

    pRxXfer->doubleBuffer[0] = pDataPathParams->rxPacketRingAddr;
    pRxXfer->doubleBuffer[1] = pDataPathParams->rxPacketRingAddr + pDataPathParams->rxPacketRingChunkSize;
} 


/****************************************************************************
 *                      rxXfer_RxEvent()
 ****************************************************************************
 * DESCRIPTION: Called upon Rx event from the FW.calls the SM  
 * 
 * INPUTS:      hRxXfer       - RxXfer handle;
 * 
 * OUTPUT:  None
 * 
 * RETURNS: TNETWIF_OK in case of Synch mode, or TNETWIF_PENDING in case of Asynch mode
 *          (when returning TNETWIF_PENDING, FwEvent module expects the FwEvent_EventComplete()
 *          function call to finish the Rx Client handling 
 *
 ****************************************************************************/
TI_STATUS rxXfer_RxEvent (TI_HANDLE hRxXfer)
{
    RxXfer_t* pRxXfer = (RxXfer_t *)hRxXfer;

    if (RX_XFER_STATE_IDLE != pRxXfer->state)
    {
        WLAN_REPORT_ERROR(pRxXfer->hReport,HAL_RX_MODULE_LOG,
            ("rxXfer_RxEvent called in state %d !!!\n",pRxXfer->state));
        return TNETWIF_ERROR;
    }

    WLAN_REPORT_INFORMATION (pRxXfer->hReport, HAL_RX_MODULE_LOG,
        ("rxXfer_RxEvent Calling rxXfer_StateMachine : currBuffer = %d \n",
        pRxXfer->currBuffer));

  #ifdef TI_DBG
    if (pRxXfer->currBuffer == 0)     
        pRxXfer->DbgStats.numIrq0 ++;
    else
        pRxXfer->DbgStats.numIrq1 ++;
  #endif

    /* Assume that we are in synch bus until otherwise is proven */
    pRxXfer->bSync = TRUE;
    /* The packet status is OK unless we receive error */
    pRxXfer->packetStatus = OK;

    rxXfer_StateMachine (hRxXfer, 0, OK);
    
    return pRxXfer->returnValue;
}


/****************************************************************************
 *                      rxXfer_StateMachine()
 ****************************************************************************
 * DESCRIPTION: SM for handling Synch & Asynch read of RX from the HW.
 *              The flow of the SM is by that order:
 *              IDLE -> READING_HDR -> READING_PKT -> EXIT
 *              On synch mode - each state is called in the same context in the while loop.
 *              On Asynch mode - each state returns TNETWIF_PENDING and exits the SM.The CB of
 *              each Asynch is the SM, that will continue the Rx handling.
 *
 * INPUTS:      hRxXfer       - RxXfer handle;
 * 
 * OUTPUT:      pRxXfer->returnValue is TNETWIF_OK in synch mode and TNETWIF_PENDING in Asynch mode.
 * 
 * RETURNS: 
 ****************************************************************************/
static void rxXfer_StateMachine (TI_HANDLE hRxXfer, UINT8 module_id, TI_STATUS status)
{
    RxXfer_t* pRxXfer = (RxXfer_t *)hRxXfer;

    pRxXfer->returnValue = OK;
    
    /*
     * This while loop will continue till the exit or when waiting for the CB due to
     * memory transfer operation pending for DMA to complete   
     */
    while (TNETWIF_PENDING != pRxXfer->returnValue)
    {
        WLAN_REPORT_DEBUG_RX (pRxXfer->hReport, ("Rx SM: state = %d, rc = %d\n",
            pRxXfer->state, pRxXfer->returnValue));
    
        switch(pRxXfer->state) 
        {
        case RX_XFER_STATE_IDLE:
            pRxXfer->state = RX_XFER_STATE_READING_HDR;
            pRxXfer->returnValue = rxXfer_ReadHeader (pRxXfer);
            break;

        case RX_XFER_STATE_READING_HDR:
            pRxXfer->state = RX_XFER_STATE_READING_PKT;
            pRxXfer->returnValue = rxXfer_ReadBody (pRxXfer);
            break;

        case RX_XFER_STATE_READING_PKT:
            pRxXfer->state = RX_XFER_STATE_EXITING;
            rxXfer_ForwardCB(pRxXfer);
            pRxXfer->returnValue = rxXfer_AckRx (pRxXfer);
            break;

        case RX_XFER_STATE_EXITING:
            pRxXfer->state = RX_XFER_STATE_IDLE;
            if (FALSE == pRxXfer->bSync)
            {   
                /* Async bus - call FwEvent for notifying the completion */
                FwEvent_EventComplete (pRxXfer->hFwEvent, TNETWIF_OK);
            }
            else    
            {
                /* This is the sync case - we should return TNETWIF_OK */
                pRxXfer->returnValue = TNETWIF_OK;
            }

            return;

        default:
            WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
                               ("rxXfer_StateMachine Unknown state = %d\n",
                               pRxXfer->state));
        }

        if (TNETWIF_ERROR == pRxXfer->returnValue)
        {   
            WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
                ("rxXfer_StateMachine returning TNETWIF_ERROR in state %d. Next packet will be discarded!!!\n",pRxXfer->state));

            /* Next packet will be marked as NOK and will be discarded */
            pRxXfer->packetStatus = NOK;
        }
    }

    /* If we are here - we got TNETWIF_PENDING, so we are in Async mode */
    pRxXfer->bSync = FALSE;
}


/****************************************************************************
 *                      rxXfer_ReadHeader()
 ****************************************************************************
 * DESCRIPTION: Read the packet header (descriptor)
 *
 * INPUTS:      pRxXfer       - RxXfer handle;
 * 
 * OUTPUT:      
 * 
 * RETURNS:     TNETWIF_OK in synch mode and TNETWIF_PENDING in Asynch mode.
 ****************************************************************************/
TI_STATUS rxXfer_ReadHeader(RxXfer_t *pRxXfer)
{
    WLAN_REPORT_DEBUG_RX(pRxXfer->hReport, 
                        ("rxXfer_readHeader: Before Read Memory Addr from DB No %d Addr %x !!!! \n",pRxXfer->currBuffer,pRxXfer->doubleBuffer[pRxXfer->currBuffer]));

    return TNETWIF_ReadMemOpt (pRxXfer->hTNETWIF, 
                               pRxXfer->doubleBuffer[pRxXfer->currBuffer], 
                               PADREAD (&pRxXfer->rxDescriptor),
                               RX_DESCRIPTOR_SIZE,
                               FW_EVENT_MODULE_ID,
                               rxXfer_StateMachine,
                               (TI_HANDLE)pRxXfer);
}


/****************************************************************************
 *                      rxXfer_ReadBody()
 ****************************************************************************
 * DESCRIPTION: Read the packet body
 *
 * INPUTS:      pRxXfer       - RxXfer handle;
 * 
 * OUTPUT:      
 * 
 * RETURNS:     TNETWIF_OK in synch mode and TNETWIF_PENDING in Asynch mode.
 ****************************************************************************/
TI_STATUS rxXfer_ReadBody (RxXfer_t *pRxXfer)
{
    UINT32  uCurrPacketId;             /* Current packet ID */
    UINT32  uLastPacketIdIncremented;  /* The last received packet-ID incremented with modulo */
    UINT32  uAlignToWord;              /* Used to align the length of the packet to a WORD */ 

	/* Check for correct length of Rx Descriptor */
    if (pRxXfer->rxDescriptor.length <= PLCP_HEADER_LENGTH || 
        pRxXfer->rxDescriptor.length > (MAX_DATA_BODY_LENGTH + PLCP_HEADER_LENGTH))
    {
        WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
             ("rxXfer_ReadBody: RxLength not correct! rxDescriptor.length=%d\n",         
             pRxXfer->rxDescriptor.length));
        return TNETWIF_ERROR;
    }

    pRxXfer->rxDescriptor.length = pRxXfer->rxDescriptor.length - PLCP_HEADER_LENGTH;

    uCurrPacketId = (pRxXfer->rxDescriptor.flags & RX_DESC_SEQNUM_MASK) >> RX_DESC_PACKETID_SHIFT;

    uLastPacketIdIncremented = (pRxXfer->lastPacketId + 1) % (RX_MAX_PACKET_ID + 1);

    if (uCurrPacketId == uLastPacketIdIncremented)
    {
        pRxXfer->lastPacketId = uLastPacketIdIncremented;

#ifdef GWSI_RECORDING
        WLAN_REPORT_GWSI_RECORDING(pRxXfer->hReport, ("GWSI Recording, rxXfer_ReadBody (request for buffer), Length = 0x%x\n", pRxXfer->rxDescriptor.length));
#endif /* GWSI_RECORDING */
    }
    else
    {
       WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
            ("rxXfer_ReadBody: Packet ID mismatch! CurrPacketId=%d, lastPacketId=%d\n",         
            uCurrPacketId, pRxXfer->lastPacketId));
#ifdef TI_DBG
        pRxXfer->DbgStats.numPacketsDroppedPacketIDMismatch++;
        rxXfer_PrintStats ((TI_HANDLE)pRxXfer);
#endif
        /* Reset the lastPacketId to be synchronized on the Current Packet ID read from the FW */
        pRxXfer->lastPacketId = uCurrPacketId;
    }

    /*
     * Add uAlignToWord to the body length since we have to read buffers from the FW in 4 bytes chunks.
     * NOTE: The size of the buffer is aligned to 4, but the packet itself is not.
     * Releasing the memory must be done with the actual size allocated and not the size of the packet 
     */
    uAlignToWord = 4 - (pRxXfer->rxDescriptor.length & 0x3); /* (&0x3) is equal to (% 4) */
    uAlignToWord = (uAlignToWord == 4) ? 0 : uAlignToWord;

    /* 
     * Requesting buffer from the upper layer memory manager. 
     * Add the align to word and offset for the access to the bus 
	 * Also send the encryption status of the packet. It is used only for GWSI alignment.
     */
    pRxXfer->pPacketBuffer = (void *)pRxXfer->RequestForBufferCB (
        pRxXfer->RequestForBufferCB_handle,
        pRxXfer->rxDescriptor.length + uAlignToWord + TNETWIF_READ_OFFSET_BYTES,
		((pRxXfer->rxDescriptor.flags & RX_DESC_ENCRYPTION_MASK) >> RX_DESC_FLAGS_ENCRYPTION));

    if (pRxXfer->pPacketBuffer != NULL)
    {
        WLAN_REPORT_DEBUG_RX (pRxXfer->hReport,
            (" rxXfer_ReadBody() : packetLength %d uAligntoWord = %d\n",
			  pRxXfer->rxDescriptor.length, uAlignToWord));

#ifdef TI_DBG
        pRxXfer->DbgStats.numPacketsRead++;
        pRxXfer->DbgStats.numBytesRead += pRxXfer->rxDescriptor.length;
#endif

        /* Read the packet and return TNETWIF_OK or TNETWIF_PENDING */
        return TNETWIF_ReadMemOpt (pRxXfer->hTNETWIF,
                                   pRxXfer->doubleBuffer[pRxXfer->currBuffer] + RX_DESCRIPTOR_SIZE + 20,
                                   (UINT8 *)pRxXfer->pPacketBuffer,
                                   (UINT32)pRxXfer->rxDescriptor.length + uAlignToWord,
                                   FW_EVENT_MODULE_ID,
                                   rxXfer_StateMachine,
                                   (TI_HANDLE)pRxXfer);
    
    }
    /* If no buffer could be allocated */
    else   
    {
        WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
            ("rxXfer_RecvOnePacket:  pRxXfer->rxDescriptor %x NULL !!!! \n",pRxXfer->pPacketBuffer));

#ifdef TI_DBG
        pRxXfer->DbgStats.numPacketsDroppedNoMem++;
#endif
    }
    
    return TNETWIF_ERROR;
}


/****************************************************************************
 *                      rxXfer_ForwardCB()
 ****************************************************************************
 * DESCRIPTION: Parse the Packet with the descriptor and forward the results and
 *              the packet to the registered CB
 *
 * INPUTS:      pRxXfer       - RxXfer handle;
 * 
 * OUTPUT:      
 * 
 * RETURNS:     
 ****************************************************************************/
void rxXfer_ForwardCB (RxXfer_t *pRxXfer)
{
    UINT32            aFlags = 0;
    rate_e            eRate = DRV_RATE_AUTO;
    rxXfer_Reserved_t Reserved;
    RxIfDescriptor_t *pRxParams = &pRxXfer->rxDescriptor;

    WLAN_REPORT_DEBUG_RX (pRxXfer->hReport, ("rxXfer_ForwardCB ENTERING\n"));
   
    eRate = ConvertHwRateToDrvRate(pRxParams->rate, (BOOL)(OFDM_RATE_BIT & pRxParams->modPre));

    WLAN_REPORT_DEBUG_RX (pRxXfer->hReport,
        (" rxXfer_ForwardCB() HwRate = %d, modPre = %d eRate = %d:\n",pRxParams->rate,pRxParams->modPre,eRate));

    if ( eRate == DRV_RATE_AUTO)
    {
        WLAN_REPORT_ERROR (pRxXfer->hReport, HAL_RX_MODULE_LOG,
            ("rxXfer_ForwardCB:  Received wrong rate from Hw = 0x%x, modPre = 0x%x\n",
            pRxParams->rate,pRxParams->modPre));
    }
    
    Reserved.packetType = (rxPacketType_e)pRxParams->type;
    Reserved.rssi       = pRxParams->rssi;
    Reserved.SNR        = pRxParams->snr;
    Reserved.band       = pRxParams->band;
    Reserved.TimeStamp  = pRxParams->timestamp;

    if (pRxXfer->packetStatus == OK)
    {
        /* Get the mac header from the TNETWIF_READ_OFFSET_BYTES in the packet Buffer */
        dot11_header_t *pMacHdr = (dot11_header_t *)((UINT8*)pRxXfer->pPacketBuffer + TNETWIF_READ_OFFSET_BYTES);
      #ifdef GWSI_RECORDING
        static  char TempString[(1600 * 2) + 1];
      #endif /* GWSI_RECORDING */

        /* Handle endian for the frame control fields */
        pMacHdr->fc       = ENDIAN_HANDLE_WORD(pMacHdr->fc);
        pMacHdr->duration = ENDIAN_HANDLE_WORD(pMacHdr->duration);
        pMacHdr->seqCtrl  = ENDIAN_HANDLE_WORD(pMacHdr->seqCtrl);

        rxXfer_ConvertDescFlagsToAppFlags (pRxParams->flags, &aFlags, &pRxXfer->packetStatus);

      #ifdef GWSI_RECORDING
        convert_hex_to_string ((UINT8*)pRxXfer->pPacketBuffer + TNETWIF_READ_OFFSET_BYTES, TempString, pRxParams->length);

        WLAN_REPORT_GWSI_RECORDING (pRxXfer->hReport, 
                                    ("GWSI Recording, rxXfer_RecvPacketCB, aStatus = 0x%x, aRate = 0x%x, aRCPI = 0x%x, aFlags = 0x%x\n", 
                                    pRxXfer->packetStatus, aRate, pRxParams->rcpi, aFlags));
        WLAN_REPORT_GWSI_RECORDING (pRxXfer->hReport, 
                                    ("GWSI Recording, rxXfer_RecvPacketCB, aLength = 0x%x, aFrame = %s\n", 
                                    pRxParams->length, TempString));    
      #endif /* GWSI_RECORDING */
    }

    /* Set the packet to upper layer. packet is starting after TNETWIF_READ_OFFSET_BYTES bytes */
    pRxXfer->ReceivePacketCB (pRxXfer->ReceivePacketCB_handle,
                              pRxXfer->packetStatus,
                              (const void*)pRxXfer->pPacketBuffer,
                              pRxParams->length,
                              (UINT32)eRate,
                              pRxParams->rcpi,
                              pRxParams->chanNum,
                              (void *)&Reserved,
                              aFlags);
}


/****************************************************************************
 *                      rxXfer_AckRx()
 ****************************************************************************
 * DESCRIPTION: Set Ack to the FW that the buffer was read
 *
 * INPUTS:      pRxXfer       - RxXfer handle;
 * 
 * OUTPUT:      
 * 
 * RETURNS:     TNETWIF_OK in synch mode and TNETWIF_PENDING in Asynch mode.
 ****************************************************************************/
TI_STATUS rxXfer_AckRx (RxXfer_t *pRxXfer)
{
    TI_STATUS status;

    /* Ack on the opposite buffer since we changed it in rxXfer_ForwardCB() */
    if (pRxXfer->currBuffer == 0)
    {
        WLAN_REPORT_DEBUG_RX (pRxXfer->hReport, ("Ack on Rx 0\n"));
      
      #ifdef TI_DBG
        pRxXfer->DbgStats.numAck0 ++;
      #endif

        status = TNETWIF_WriteRegOpt (pRxXfer->hTNETWIF, 
                                      ACX_REG_INTERRUPT_TRIG, 
                                      INTR_TRIG_RX_PROC0,
                                      FW_EVENT_MODULE_ID,
                                      rxXfer_StateMachine,
                                      (TI_HANDLE)pRxXfer);
    }
    else 
    {
        WLAN_REPORT_DEBUG_RX (pRxXfer->hReport, ("Ack on Rx 1\n"));

      #ifdef TI_DBG
        pRxXfer->DbgStats.numAck1 ++;
      #endif

        status = TNETWIF_WriteRegOpt (pRxXfer->hTNETWIF, 
                                      ACX_REG_INTERRUPT_TRIG_H, 
                                      INTR_TRIG_RX_PROC1,
                                      FW_EVENT_MODULE_ID,
                                      rxXfer_StateMachine,
                                      (TI_HANDLE)pRxXfer);
    }

    /* Calculate the next buffer to read from (0 or 1) */
    pRxXfer->currBuffer = 1 - pRxXfer->currBuffer;

    return status;
}


/****************************************************************************
 *                      rxXfer_ConvertDescFlagsToAppFlags()
 ****************************************************************************
 * DESCRIPTION: Add some spacing before capital letters and you'll figure it out ...
 *
 * INPUTS:      descRxFlags   - Bits as received from Fw
 * 
 * OUTPUT:      aFlags        - converted bits to our definition    
 *              pPacketStatus - changed status if an error was indicated
 * RETURNS:     
 ****************************************************************************/
static void  rxXfer_ConvertDescFlagsToAppFlags (UINT16 descRxFlags, UINT32 *aFlags, TI_STATUS *pPacketStatus)
{
    UINT32 flags = 0;

    if (descRxFlags & RX_DESC_MATCH_RXADDR1)
    {
        flags |= RX_PACKET_FLAGS_MATCH_RXADDR1;
    }

    if (descRxFlags & RX_DESC_MCAST)
    {
        flags |= RX_PACKET_FLAGS_GROUP_ADDR;
    }

    if (descRxFlags & RX_DESC_STAINTIM)
    {
        flags |= RX_PACKET_FLAGS_STAINTIM;
    }

    if (descRxFlags & RX_DESC_VIRTUAL_BM)
    {
        flags |= RX_PACKET_FLAGS_VIRTUAL_BM;
    }

    if (descRxFlags & RX_DESC_BCAST)
    {
        flags |= RX_PACKET_FLAGS_BCAST;
    }

    if (descRxFlags & RX_DESC_MATCH_SSID)
    {
        flags |= RX_PACKET_FLAGS_MATCH_SSID;
    }

    if (descRxFlags & RX_DESC_MATCH_BSSID)
    {
        flags |= RX_PACKET_FLAGS_MATCH_BSSID;
    }

    flags |= (descRxFlags & RX_DESC_ENCRYPTION_MASK) << RX_PACKET_FLAGS_ENCRYPTION_SHIFT_FROM_DESC;

    if (descRxFlags & RX_DESC_MEASURMENT)
    {
        flags |= RX_PACKET_FLAGS_MEASURMENT;
    }

    if (descRxFlags & RX_DESC_MIC_FAIL)
    {
        *pPacketStatus = RX_MIC_FAILURE_ERROR;
    }

    if (descRxFlags & RX_DESC_DECRYPT_FAIL)
    {
        *pPacketStatus = RX_DECRYPT_FAILURE;
    }

    *aFlags = flags;
}

#ifdef TI_DBG
/****************************************************************************
 *                      rxXfer_ClearStats()
 ****************************************************************************
 * DESCRIPTION: 
 *
 * INPUTS:  
 *          pRxXfer The object
 * 
 * OUTPUT:  None
 * 
 * RETURNS: OK. 
 ****************************************************************************/
void rxXfer_ClearStats (TI_HANDLE hRxXfer)
{
    RxXfer_t * pRxXfer = (RxXfer_t *)hRxXfer;

    os_memoryZero (pRxXfer->hOs, &pRxXfer->DbgStats, sizeof(RxXferStats_T));
}


/****************************************************************************
 *                      rxXfer_PrintStats()
 ****************************************************************************
 * DESCRIPTION: .
 *
 * INPUTS:  
 *          pRxXfer The object
 * 
 * OUTPUT:  None
 * 
 * RETURNS: OK. 
 ****************************************************************************/
void rxXfer_PrintStats (TI_HANDLE hRxXfer)
{
    RxXfer_t * pRxXfer = (RxXfer_t *)hRxXfer;
    
    WLAN_OS_REPORT(("Number of packets read: %d, number of bytes read:%d\n",
                    pRxXfer->DbgStats.numPacketsRead, pRxXfer->DbgStats.numBytesRead));
    WLAN_OS_REPORT(("Number of frames dropped due to no memory:%d, Number of frames dropped due to packet ID mismatch:%d\n",
                    pRxXfer->DbgStats.numPacketsDroppedNoMem, pRxXfer->DbgStats.numPacketsDroppedPacketIDMismatch));
    WLAN_OS_REPORT(("Number of irq0:%u, ack0:%d\n",
                    pRxXfer->DbgStats.numIrq0, pRxXfer->DbgStats.numAck0));
    WLAN_OS_REPORT(("Number of irq1:%u, ack1:%d\n",
                    pRxXfer->DbgStats.numIrq1, pRxXfer->DbgStats.numAck1));
}
#endif

/****************************************************************************
 *                      RxXfer_ReStart()
 ****************************************************************************
 * DESCRIPTION:	RxXfer_ReStart the RxXfer module object (called by the recovery)
 * 
 * INPUTS:	hRxXfer - The object to free
 * 
 * OUTPUT:	None
 * 
 * RETURNS:	NONE 
 ****************************************************************************/

VOID RxXfer_ReStart(TI_HANDLE hRxXfer)
{
	RxXfer_t * pRxXfer = (RxXfer_t *)hRxXfer;

	pRxXfer->state          = RX_XFER_STATE_IDLE;
	pRxXfer->currBuffer     = 0;        /* first buffer to read from */
	pRxXfer->lastPacketId   = 0;
	
} /* RxXfer_ReStart() */