ixhssaccpktrx.c

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

    ixHssAccPktRxStats.rxQWriteOverflows = 0;
    ixHssAccPktRxStats.rxFreeReplenishs = 0;
    ixHssAccPktRxStats.maxEntriesInRxQ = 0;
    ixHssAccPktRxStats.rxInvalidDesc = 0;
}


/*
 *Function :ixHssAccPktRxFreeReplenish
 */
IX_STATUS 
ixHssAccPktRxFreeReplenish (IxHssAccHssPort hssPortId, 
			    IxHssAccHdlcPort hdlcPortId, 
			    IX_OSAL_MBUF *buffer)
{
    /* This function may be called from within an ISR */
    IX_STATUS status = IX_SUCCESS;
    IxHssAccPDMDescriptor *desc = NULL, *physDesc = NULL;
    UINT32 pPhysDesc = 0; 

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Entering "
		      "ixHssAccPktRxFreeReplenish \n");

    /* Check that the port is connected */
    if (ixHssAccPCMCheckReplenishOk (hssPortId, hdlcPortId))
    {
	/* Get a desc to attach the client supplied mbuf to*/
	status = ixHssAccPDMDescGet (hssPortId, hdlcPortId, 
				     IX_HSSACC_PDM_RX_POOL, &desc);
	if (status != IX_SUCCESS)
	{
	    return status;
	}
	
	/* Set up the desc as supplied by the NPE */
	desc->npeDesc.pRootMbuf     = ixHssAccPDMMbufToNpeFormatConvert (buffer);
	desc->npeDesc.status        = IX_HSSACC_PKT_OK;
	desc->npeDesc.chainCount    = 0;
	desc->npeDesc.packetLength  = 0;
	desc->npeDesc.pMbufData     = (UINT8 *) IX_OSAL_MBUF_MDATA(buffer);
	desc->npeDesc.mbufLength    = IX_OSAL_MBUF_MLEN(buffer);
	desc->npeDesc.pNextMbuf     = NULL;
	desc->npeDesc.errorCount    = 0;

        /* endian conversion for the NpePacket Descriptor */
	desc->npeDesc.pRootMbuf = (IX_OSAL_MBUF *)(IX_OSAL_SWAP_BE_SHARED_LONG (
	    (UINT32) desc->npeDesc.pRootMbuf));
	desc->npeDesc.pNextMbuf = (IX_OSAL_MBUF *)(IX_OSAL_SWAP_BE_SHARED_LONG (
	    (UINT32) desc->npeDesc.pNextMbuf)); 
	
	IX_HSSACC_PKT_DATA_CACHE_FLUSH (desc, sizeof(IxHssAccPDMDescriptor));
	physDesc  = (IxHssAccPDMDescriptor *) IX_HSSACC_PKT_MMU_VIRT_TO_PHY (desc);

	/* Write the desc to the appropiate RxFree Q*/
        pPhysDesc = (UINT32) physDesc;
	status = ixQMgrQWrite (ixHssAccPCMRxFreeQIdGet (hssPortId, hdlcPortId),
			       &pPhysDesc);

	if (status != IX_SUCCESS)
	{
	    if (status == IX_FAIL)
	    {
		IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxFreeReplenish:"
					"Writing an RX descriptor to the RXFREE"
					" Queue failed\n");
		ixHssAccPktRxStats.rxFreeQWriteFails++;
		status = IX_FAIL;
	    }
	    else if (status == IX_QMGR_Q_OVERFLOW)
	    {
		ixHssAccPktRxStats.rxQWriteOverflows++;
		status = IX_HSSACC_Q_WRITE_OVERFLOW;
	    }

            /* endian conversion for the NpePacket Descriptor */
	    desc->npeDesc.pRootMbuf = (IX_OSAL_MBUF *)(IX_OSAL_SWAP_BE_SHARED_LONG (
	        (UINT32) desc->npeDesc.pRootMbuf));

	    /* we need to restore the buffer to the original (virtual) address
	     * before we return
	     */
	    ixHssAccPDMMbufFromNpeFormatConvert(desc->npeDesc.pRootMbuf, FALSE);

	    ixHssAccPDMDescFree (desc, IX_HSSACC_PDM_RX_POOL);
	    return status;
	}
	ixHssAccPktRxStats.rxFreeReplenishs++;
    }
    else
    {
	IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxFreeReplenish:"
				"Called ixHssAccPktRxInternalFreeBufReplenish "
				"on a port that is not connected\n");
	return IX_FAIL;
    }
   
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, "Exiting "
		      "ixHssAccPktRxFreeReplenish \n");
    return status;
}

/**
 * Function definition: ixHssAccPktRxInit
 */
IX_STATUS 
ixHssAccPktRxInit (void)
{
    IX_STATUS status = IX_SUCCESS;
    IxHssAccHssPort hssPortIndex;
    IxHssAccHdlcPort hdlcPortIndex;
    unsigned hssHdlcPortIdAsCbId;

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Entering ixHssAccPktRxInit\n");

    /* initialise stats */
    ixHssAccPktRxStatsInit ();

    /* Set the Callback for the RxFree Q for this client */
    for (hssPortIndex = IX_HSSACC_HSS_PORT_0; 
	 hssPortIndex < hssPortMax; 
	 hssPortIndex++)
    {
	for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0; 
	     hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX; 
	     hdlcPortIndex++)
	{
	    hssHdlcPortIdAsCbId = (hssPortIndex << IX_HSSACC_PKT_CBID_HSS_OFFSET) | 
		hdlcPortIndex;
	    
	    status = ixQMgrNotificationCallbackSet (
		ixHssAccPCMRxFreeQIdGet (hssPortIndex, hdlcPortIndex),
		ixHssAccPktRxFreeLowCallback,
		hssHdlcPortIdAsCbId);

	    if (status != IX_SUCCESS)
	    {
		IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxInit:"
					"ixQMgrNotificationCallbackSet failed\n");
		return IX_FAIL;
	    }
	}
    }

    for (hssPortIndex = IX_HSSACC_HSS_PORT_0; 
	 hssPortIndex < hssPortMax; 
	 hssPortIndex++)
    {
        /* Set the callback for the HSS Port 0/1 Rx Q */
        status = ixQMgrNotificationCallbackSet (
	    ixHssAccPktRxQId[hssPortIndex],
	    ixHssAccPktRxCallback,
	    hssPortIndex);
        if (status != IX_SUCCESS)
        {
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR_WITH_ARG ("ixHssAccPktRxInit:"
	        "Setting callback for the HSS%d PktRx Q failed\n",
		hssPortIndex,
		0, 0, 0, 0, 0);
            /* return error */
            return IX_FAIL;
        }
    
        /* Enable notification for the HSS Port 0/1 Rx Q */
        status =  ixQMgrNotificationEnable (ixHssAccPktRxQId[hssPortIndex],
	                                    IX_QMGR_Q_SOURCE_ID_NOT_E);
        if (status != IX_SUCCESS)
        {
	    /* report the error */
	    IX_HSSACC_REPORT_ERROR_WITH_ARG ("ixHssAccPktRxInit:"
	        "Notification enable for the HSS%d PktRx Q failed\n",
		hssPortIndex,
		0, 0, 0, 0, 0);
            /* return error */
	    return IX_FAIL;
        }
    }
	
    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT, 
		      "Exiting ixHssAccPktRxInit\n");
    return status;
}


/*
 * Function definition: ixHssAccPktRxUninit
 */
IX_STATUS
ixHssAccPktRxUninit (void)
{
    IX_STATUS        status = IX_SUCCESS;
    IxHssAccHssPort  hssPortIndex;
    IxHssAccHdlcPort hdlcPortIndex;
    UINT32           hssHdlcPortIdAsCbId;
    INT8             errorString[80];

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT,
                      "Entering ixHssAccPktRxUninit\n");

    for (hssPortIndex = IX_HSSACC_HSS_PORT_0;
         hssPortIndex < hssPortMax;
         hssPortIndex++)
    {  /* Disable notification for the HSS Port 0/1 Rx Q */
        status =  ixQMgrNotificationDisable (ixHssAccPktRxQId[hssPortIndex]);
        if (IX_SUCCESS != status)
        {
            sprintf (errorString, "ixHssAccPktRxUninit:"
                     "Notification disable for the HSS %d PktRx Q failed\n",
                     hssPortIndex);
            /* report the error */
            IX_HSSACC_REPORT_ERROR (errorString);
            /* return error */
            return IX_FAIL;
        }
        /* Set the callback for the HSS Port 0/1 Rx Q */
        status = ixQMgrNotificationCallbackSet (
            ixHssAccPktRxQId[hssPortIndex],
            NULL,
            hssPortIndex);
        if (IX_SUCCESS != status)
        {
            sprintf (errorString, "ixHssAccPktRxUninit:"
                     "Setting dummy callback for the HSS%d PktRx Q failed\n",
                     hssPortIndex);
            /* report the error */
            IX_HSSACC_REPORT_ERROR (errorString);
            /* return error */
            return IX_FAIL;
        }
    }
    /* Set the Callback for the RxFree Q  */
    for (hssPortIndex = IX_HSSACC_HSS_PORT_0;
         hssPortIndex < hssPortMax;
         hssPortIndex++)
    {
        for (hdlcPortIndex = IX_HSSACC_HDLC_PORT_0;
             hdlcPortIndex < IX_HSSACC_HDLC_PORT_MAX;
             hdlcPortIndex++)
        {
            hssHdlcPortIdAsCbId = (hssPortIndex << IX_HSSACC_PKT_CBID_HSS_OFFSET) |
                hdlcPortIndex;

            status = ixQMgrNotificationCallbackSet (
                ixHssAccPCMRxFreeQIdGet (hssPortIndex, hdlcPortIndex),
                NULL,
                hssHdlcPortIdAsCbId);

            if (IX_SUCCESS != status)
            {
                IX_HSSACC_REPORT_ERROR ("ixHssAccPktRxUninit:"
                                        "ixQMgrNotificationCallbackSet (dummy callback) failed\n");
                return IX_FAIL;
             }
        }
    }

    IX_HSSACC_TRACE0 (IX_HSSACC_FN_ENTRY_EXIT,
                     "Exiting ixHssAccPktRxUninit\n");
    return status;
}