ixatmdutil.c

有关ARM开发板上的IXP400网络驱动程序的源码以。

    }

    return (fcs);
}

/*------------------------------------------------------------------------
*  Compute a Hash value from a port/vpi/vci
*/
unsigned int
ixAtmdAccUtilHashVc (IxAtmLogicalPort port,
                     unsigned int vpi,
                     unsigned int vci)
{
    unsigned char hashData[5];

    /* endianness storage in an array of bytes */
    hashData[0] = 0;                           /* gfc / vpi */
    hashData[1] = (unsigned char) vpi;         /* vpi LSB */
    hashData[2] = (unsigned char) (vci >> 8);  /* vci MSB */
    hashData[3] = (unsigned char) vci;         /* vci LSB */
    hashData[4] = (unsigned char) port;        /* logical port */

   /* compute the crc of this array : the UTOPIA2 coprocessor is implementing
    * the same standard
    */
    return crc16 (0xffff, hashData, sizeof (hashData));

}

/*------------------------------------------------------------------------
* Allocate a unique ID used for connections security and sanity checks
*/
unsigned int
ixAtmdAccUtilUniqueIdGet (void)
{
    unsigned int result = 0;

    IX_ATMDACC_UTIL_LOCK ();

    /* grab a lock and increment the number by IX_ATMDACC_UNIQUEID_INCR
    to provide a part of a connection ID.
    */
    uniqueId += IX_ATMDACC_UNIQUEID_INCR;

    /* test for wrap around */
    if (uniqueId >= IX_ATMDACC_UNIQUEID_WRAP_LIMIT)
    {
        uniqueId = IX_ATMDACC_UNIQUEID_SEED;
    }

    result = uniqueId;

    IX_ATMDACC_UTIL_UNLOCK ();

    return result;
}

/*------------------------------------------------------------------------
* convert chained mbufs to BIG endian (npe format)
*/
IX_OSAL_MBUF *
ixAtmdAccUtilMbufToNpeFormatConvert (IX_OSAL_MBUF *mbufPtr)
{
    IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufPtr));
    IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (UINT8 *,IX_OSAL_MBUF_MDATA(mbufPtr));
    IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufPtr));

    /* quick check for unchained mbufs */
    if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr) == NULL)
    {
        /* force data to be stored in physical memory */
        IX_ATMDACC_DATA_CACHE_FLUSH(mbufPtr, sizeof(IX_OSAL_MBUF));

        /* convert the pointer to the first mbuf */
        IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (mbufPtr);
        IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (IX_OSAL_MBUF *,mbufPtr);
    }
    else
    {
        IX_OSAL_MBUF *mbufChainPtr;
        IX_OSAL_MBUF *mbufTempPtr;
        int iterationCount = 1;
        
        mbufChainPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr);

        IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));
        IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));
        
        /* force data to be stored in physical memory */
        IX_ATMDACC_DATA_CACHE_FLUSH(mbufPtr, sizeof(IX_OSAL_MBUF));

        /* iterate through the mbuf chain */
        while (mbufChainPtr)
        {
            iterationCount++;
            
            /* check about possible  mbuf infinite chain or loop */
            IX_ATMDACC_ENSURE (iterationCount <= IX_NPE_A_CHAIN_DESC_COUNT_MAX, "Infinite mbuf chain");
            IX_ATMDACC_ENSURE (IX_OSAL_MBUF_MLEN(mbufChainPtr) != 0, "Null length mbuf");
            
            /* save the next pointer */
            mbufTempPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr);
            
            /* convert the current mbuf header */
            IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufChainPtr));
            IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (UINT8 *,IX_OSAL_MBUF_MDATA(mbufChainPtr));
            IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufChainPtr));

            if (mbufTempPtr)
            {
                IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
                IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
            }

            /* force data to be stored in physical memory */
            IX_ATMDACC_DATA_CACHE_FLUSH(mbufChainPtr, sizeof(IX_OSAL_MBUF));
            
            /* next element */
            mbufChainPtr = mbufTempPtr;
        } /* end of while(mbufChainPtr) */

        /* convert the pointer to the first mbuf */
        IX_ATMDACC_CONVERT_TO_PHYSICAL_ADDRESS (mbufPtr);
        IX_ATMDACC_CONVERT_TO_BIG_ENDIAN (IX_OSAL_MBUF *,mbufPtr);
    }
    return (mbufPtr);
}

/*------------------------------------------------------------------------
* convert chained mbufs from BIG endian (npe format)
*/
IX_OSAL_MBUF *
ixAtmdAccUtilMbufFromNpeFormatConvert (IX_OSAL_MBUF *mbufPtr,
                                       BOOL invalidateCache)
{
    if (invalidateCache)
    {
        /* force data to be read from physical memory */
        IX_ATMDACC_DATA_CACHE_INVALIDATE(mbufPtr, sizeof(IX_OSAL_MBUF));
    }
    
    /* convert the current mbuf header */
    IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufPtr));
    IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (UINT8 *,IX_OSAL_MBUF_MDATA(mbufPtr));
    IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufPtr));
    
    /* quick check for unchained mbufs */
    if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr) != NULL)
    {
        IX_OSAL_MBUF *mbufChainPtr;
        int iterationCount = 1;

        IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));
        IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));

        mbufChainPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr);

        /* iterate through the mbuf chain */
        while (mbufChainPtr)
        {
            /* update the mbuf count */
            iterationCount++;
            
            /* check about possible  mbuf infinite chain or loop */
            IX_ATMDACC_ABORT (iterationCount <= IX_NPE_A_CHAIN_DESC_COUNT_MAX, 
                "Infinite mbuf chain");
            
            if (invalidateCache)
            {
                /* force data to be read from physical memory */
                IX_ATMDACC_DATA_CACHE_INVALIDATE(mbufChainPtr, sizeof(IX_OSAL_MBUF));
            }
            
            /* convert the next mbuf pointer */
            if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr))
            {
                IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
                IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
            }
            
            /* convert the current mbuf header */
            IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufChainPtr));
            IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (UINT8 *, IX_OSAL_MBUF_MDATA(mbufChainPtr));
            IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufChainPtr));
            
            mbufChainPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr);
        } /* end of while(mbufChainPtr) */
    }

    return (mbufPtr);
}

/*------------------------------------------------------------------------
* convert RX chained mbufs from BIG endian (npe format)
*/
IX_OSAL_MBUF *
ixAtmdAccUtilRxMbufFromNpeFormatConvert (IX_OSAL_MBUF *mbufPtr, 
                                         unsigned int pduLength,
                                         unsigned int *mbufCount)
{
    /* no PFU can be 0 bytes long, because there is always a 
    * AAL5 trailer or a cell
    */
    IX_OSAL_ENSURE(pduLength >= IX_ATM_CELL_PAYLOAD_SIZE, 
        "Wrong pdu length in RX direction");

    /* force data to be read from physical memory */
    IX_ATMDACC_DATA_CACHE_INVALIDATE(mbufPtr, sizeof(IX_OSAL_MBUF));
    
    /* convert the current mbuf header */
    IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (UINT8 *,IX_OSAL_MBUF_MDATA(mbufPtr));
    IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufPtr));
    
    /* quick check for unchained mbufs */
    if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr) == NULL)
    {
        /* the last mbuf length is not uipdated by the NPE, and
        * the pdu length is not updated by the NPE in the first mbuf 
        */
        IX_OSAL_MBUF_MLEN(mbufPtr) = (int)pduLength;
        IX_OSAL_MBUF_PKT_LEN(mbufPtr) = pduLength;
        *mbufCount = 1;
    }
    else
    {
        int mbufChainLength;
        IX_OSAL_MBUF *mbufChainPtr;
        IX_OSAL_MBUF *mbufChainLastPtr = mbufPtr;
        int iterationCount = 1;

        IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufPtr));
        IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));
        IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr));

        IX_OSAL_ENSURE(IX_OSAL_MBUF_MLEN(mbufPtr) != 0, "0 byte mbuf in RX direction");

        mbufChainLength = IX_OSAL_MBUF_MLEN(mbufPtr);
        mbufChainPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufPtr);

        /* iterate through the mbuf chain */
        while (mbufChainPtr)
        {
            /* update the mbuf count */
            iterationCount++;
            
            /* check about possible  mbuf infinite chain or loop */
            IX_ATMDACC_ABORT (iterationCount <= IX_NPE_A_CHAIN_DESC_COUNT_MAX, 
                "Infinite mbuf chain");
            
            /* force data to be read from physical memory */
            IX_ATMDACC_DATA_CACHE_INVALIDATE(mbufChainPtr, sizeof(IX_OSAL_MBUF));
            
            /* convert the next mbuf pointer */
            if (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr))
            {
                IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (IX_OSAL_MBUF *,IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
                IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr));
            }
            else
            {
                /* no mbuf should be 0 bytes long, except the last one where
                * the NPE didn't update the header
                */
                IX_OSAL_ENSURE(IX_OSAL_MBUF_MLEN(mbufPtr) != 0, "0 byte mbuf in RX direction");
            }
            
            /* convert the current mbuf header */
            IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (UINT8 *,IX_OSAL_MBUF_MDATA(mbufChainPtr));
            IX_ATMDACC_CONVERT_FROM_BIG_ENDIAN (int,IX_OSAL_MBUF_MLEN(mbufChainPtr));
            IX_ATMDACC_CONVERT_TO_VIRTUAL_ADDRESS (IX_OSAL_MBUF_MDATA(mbufChainPtr));
            

            mbufChainLength += IX_OSAL_MBUF_MLEN(mbufChainPtr);
            /* keep track of the lst element */
            mbufChainLastPtr = mbufChainPtr;
            /* next element */
            mbufChainPtr = IX_OSAL_MBUF_NEXT_BUFFER_IN_PKT_PTR(mbufChainPtr);
        } /* end of while(mbufChainPtr) */
        
        /* update the number of mbufs found */
        *mbufCount = iterationCount;
        
        /* the last mbuf length is not uipdated by the NPE, and
        * the pdu length is not updated by the NPE in the first mbuf 
        */
        IX_OSAL_MBUF_MLEN(mbufChainLastPtr) += (int)pduLength - mbufChainLength;
        IX_OSAL_MBUF_PKT_LEN(mbufPtr) = pduLength;
    }

    return (mbufPtr);
}

/*------------------------------------------------------------------------
* Atmd stream Id check and conversion to QMgr id enum
*/
IX_STATUS
ixAtmdAccUtilQmgrQIdGet (IxAtmRxQueueId atmdQueueId,
                         IxQMgrQId *qMgrQueueIdPtr)
{
    IX_STATUS returnStatus = IX_SUCCESS;

    switch (atmdQueueId)
    {
    case IX_ATM_RX_A:
        *qMgrQueueIdPtr = IX_NPE_A_QMQ_ATM_RX_HI;
        break;
    case IX_ATM_RX_B:
        *qMgrQueueIdPtr = IX_NPE_A_QMQ_ATM_RX_LO;
        break;
    default:
        returnStatus = IX_FAIL;
        break;
    } /* end of switch(atmdQueueId) */
    return returnStatus;
}

/*------------------------------------------------------------------------
* QMgr Id check and conversion to IxAtmdAcc enum
*/
IX_STATUS
ixAtmdAccUtilAtmdQIdGet (IxQMgrQId qMgrQueueId,
                         IxAtmRxQueueId *atmdQueueIdPtr)
{
    IX_STATUS returnStatus = IX_SUCCESS;

    switch (qMgrQueueId)
    {
    case IX_NPE_A_QMQ_ATM_RX_HI :
        *atmdQueueIdPtr = IX_ATM_RX_A;
        break;
    case IX_NPE_A_QMQ_ATM_RX_LO:
        *atmdQueueIdPtr = IX_ATM_RX_B;
        break;
    default:
        returnStatus = IX_FAIL;
        break;
    } /* end of switch(atmdQueueId) */
    return returnStatus;
}

/* ----------------------------------------------------
* send a message to the NPE
*/
IX_STATUS
ixAtmdAccUtilNpeMsgSend(unsigned int msgType,
                        unsigned int param0,
                        unsigned int param1)
{
    IxNpeMhMessage npeMhMessage;
    IX_STATUS returnStatus;

    npeMhMessage.data[0] = (msgType << NPE_MSG_COMMAND_BIT_OFFSET) | param0;
    npeMhMessage.data[1] = param1;


    /* send msg to NPE */
    returnStatus = ixNpeMhMessageSend (IX_NPEMH_NPEID_NPEA, 
        npeMhMessage, 
        IX_ATMDACC_SEND_RETRIES_DEFAULT);

    /* map status error */
    if (returnStatus != IX_SUCCESS)
    {
        returnStatus = IX_FAIL;
    }
    return returnStatus;
}

/* ----------------------------------------------------
* send a message to the NPE, wait for a response
*/
IX_STATUS
ixAtmdAccUtilNpeMsgWithResponseSend(unsigned int msgType,
                                    unsigned int param0,
                                    unsigned int param1,
                                    IxNpeMhCallback callback)
{
    IxNpeMhMessage npeMhMessage;
    IX_STATUS returnStatus;

    npeMhMessage.data[0] = (msgType << NPE_MSG_COMMAND_BIT_OFFSET) | param0;
    npeMhMessage.data[1] = param1;


    /* send msg to NPE */
    returnStatus = ixNpeMhMessageWithResponseSend (IX_NPEMH_NPEID_NPEA,
        npeMhMessage,
        msgType,
        callback,
        IX_ATMDACC_SEND_RETRIES_DEFAULT);

    /* map status error */
    if (returnStatus != IX_SUCCESS)
    {
        returnStatus = IX_FAIL;
    }
    return returnStatus;
}

/* --------------------------------------------------
* Query a queue size
*/
IX_STATUS
ixAtmdAccUtilQueueSizeQuery (IxQMgrQId qmgrQueueId,
                             unsigned int *queueSizePtr)
{
    IX_STATUS returnStatus;

    /* get the queue size */
    returnStatus = ixQMgrQSizeInEntriesGet(qmgrQueueId, queueSizePtr);

    /* map the error */
    if (returnStatus != IX_SUCCESS)
    {
        returnStatus = IX_FAIL;
    }

    return returnStatus;
}