ixethaal5app.c

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

    ixEAAAtmBufferRecycle( atmVcRxId[ bufDestination ], mbufPtr );
}

/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/


/*>>>>>>>>>>>>>>>>> ATM HARDWARE INITIALIZATION FUNCTIONS <<<<<<<<<<<<<<<<<<<*/
IX_STATUS ixEAAUtopiaInit( void )
{
    int cnt;
    int retval;

    /* Clear portCfgs */
    ixOsalMemSet(portCfgs, 0, sizeof(portCfgs));

    for (cnt = 0; cnt < atmNumPortsEnabled; cnt++)
    {
        portCfgs[ cnt ].UtopiaTxPhyAddr = IX_UTOPIA_PHY_ADDR + cnt;
        portCfgs[ cnt ].UtopiaRxPhyAddr = IX_UTOPIA_PHY_ADDR + cnt;
    }

    /* Initialize Utopia with current config */
    retval = ixAtmmUtopiaInit(atmNumPortsEnabled,
                              phyMode,
                              portCfgs,
                              IX_ATMM_UTOPIA_LOOPBACK_DISABLED);
    
    if (retval != IX_SUCCESS)
    {
        printf ("AtmmUtopia Initialization failed\n");
        return IX_FAIL;
    }

    /* Initialize Ports */
    for (cnt = 0;  cnt < atmNumPortsEnabled;  cnt++)
    {
        /* Last two parameters state maximum upload and download rates
           available on utopia phy, assuming all enabled phys saturate
           their bandwidth. Because this application doesn't use realtime
           protocols (VBR), those rates doesn't have any effect on real
           throughput. Moreover real data rates can be limited by type
           of media connected to Utopia (like Adsl) */
        retval = ixAtmmPortInitialize (cnt,
                                       IX_EAA_UPLOAD_RATE,
                                       IX_EAA_DOWNLOAD_RATE);
        if (retval != IX_SUCCESS)
        {
            printf ("Port Initialization failed for port %d\n", cnt);
            return IX_FAIL;
        }

        /* Enable the port in Atmm (AtmdAcc and AtmSch will be notified) */
        retval = ixAtmmPortEnable(cnt);
        if (retval != IX_SUCCESS)
        {
            printf ("Port Enable failed for port %d\n", cnt);
            return IX_FAIL;
        }
    }

    return IX_SUCCESS;
}

IX_STATUS ixEAAATMInit( void )
{
    int           retval;

    /* Initialize AtmSch */
    retval = ixAtmSchInit();

    if (retval != IX_SUCCESS)
    {
        printf ("AtmSch Initialization failed\n");
        return IX_FAIL;
    }

    /* Initialize AtmdAcc */
    retval = ixAtmdAccInit();

    if (retval != IX_SUCCESS)
    {
        printf ("AtmdAcc Initialization failed\n");
        return IX_FAIL;
    }
    
    printf( "\n");

    /* If not IXP42X A0 stepping, proceed to check for existence of coprocessors */ 
    if ((IX_FEATURE_CTRL_SILICON_TYPE_A0 != 
        (ixFeatureCtrlProductIdRead() & IX_FEATURE_CTRL_SILICON_STEPPING_MASK))
        || (IX_FEATURE_CTRL_DEVICE_TYPE_IXP42X != ixFeatureCtrlDeviceRead ()))
    {
	if ((ixFeatureCtrlComponentCheck(IX_FEATURECTRL_AAL) == 
	     IX_FEATURE_CTRL_COMPONENT_ENABLED) &&
	    (ixFeatureCtrlComponentCheck(IX_FEATURECTRL_UTOPIA) == 
	     IX_FEATURE_CTRL_COMPONENT_ENABLED)	 
	    )
	{
#if IX_UTOPIAMODE == 1
	    retval = ixNpeDlNpeInitAndStart (NPE_A_IMAGE_ID_SINGLE_PORT_SPHY);
#else
	    retval = ixNpeDlNpeInitAndStart (NPE_A_IMAGE_ID_MULTI_PORT_MPHY);
#endif
	}
    }
    else
    {
#if IX_UTOPIAMODE == 1
	retval = ixNpeDlNpeInitAndStart (NPE_A_IMAGE_ID_SINGLE_PORT_SPHY);
#else
	retval = ixNpeDlNpeInitAndStart (NPE_A_IMAGE_ID_MULTI_PORT_MPHY);
#endif
    }
        
    if (retval != IX_SUCCESS)
    {
        printf ("NPE download failed\n");
        return IX_FAIL;
    }

    /* Initialize Atmm */
    retval = ixAtmmInit();
    if (retval != IX_SUCCESS)
    {
        printf ("Atmm Initialization failed\n");
        return IX_FAIL;
    }

    return IX_SUCCESS;
}

/* This function contains the setup for various VC settings
 * with various ATM service. The VC setup is based on the number
 * of VCs and ATM ports */
IX_STATUS ixEAASetupVc(UINT32 numberOfVc, UINT32 numberOfPorts)
{
    UINT32 atmVcCnt = 0;
    UINT32 atmPortCnt = 0;
    UINT32 countCbrVc = 0;
    UINT32 countRtVbrVc = 0;
    IxAtmServiceCategory atmService = IX_ATM_UBR;
    
    const UINT32 atmVpi[ IX_EAA_NUM_PRE_CONFIGURED_ATM_VCS ] =
    { 
	IX_EAA_VC1_VPI, IX_EAA_VC2_VPI, IX_EAA_VC3_VPI, IX_EAA_VC4_VPI,
	IX_EAA_VC5_VPI, IX_EAA_VC6_VPI,IX_EAA_VC7_VPI, IX_EAA_VC8_VPI
    };

    const UINT32 atmVci[ IX_EAA_NUM_PRE_CONFIGURED_ATM_VCS ] =
    { 
	IX_EAA_VC1_VCI, IX_EAA_VC2_VCI, IX_EAA_VC3_VCI, IX_EAA_VC4_VCI,
	IX_EAA_VC5_VCI, IX_EAA_VC6_VCI, IX_EAA_VC7_VCI, IX_EAA_VC8_VCI
    };

    if ((numberOfPorts < 1 || numberOfPorts > IX_UTOPIA_MAX_PORTS) ||
	(numberOfVc < 1 || numberOfVc > IX_EAA_NUM_ATM_VCS))
    {
	return IX_FAIL;
    }

    for (atmVcCnt=0; atmVcCnt < IX_EAA_NUM_ATM_VCS; atmVcCnt++)
    {
	/* Setup for Receive and Transmit VC */
	ixEAAAtmTxVc[atmVcCnt].vpi = 
	    ixEAAAtmRxVc[atmVcCnt].vpi = atmVpi[atmVcCnt];

	ixEAAAtmTxVc[atmVcCnt].vci = 
	    ixEAAAtmRxVc[atmVcCnt].vci = atmVci[atmVcCnt];

	ixEAAAtmTxVc[atmVcCnt].direction = IX_ATMM_VC_DIRECTION_TX;
	ixEAAAtmRxVc[atmVcCnt].direction = IX_ATMM_VC_DIRECTION_RX;

	if (atmVcCnt < 2 )
	{
	    /* Setup for UBR service */
	    atmService = IX_ATM_UBR;

	    ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = IX_EAA_DOWNLOAD_RATE;

	    printf ("\nPort = %d VPI = %d, VCI = %d, IX_ATM_UBR\n",
		    atmPortCnt, atmVpi[atmVcCnt],atmVci[atmVcCnt]);
	}
	else if (atmVcCnt >= 2 && atmVcCnt < 4   )
	{
	    /* Setup for CBR service */
	    atmService = IX_ATM_CBR;

	    if (countCbrVc == 0)
	    {
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = 200 ; 
	    }
	    else
	    {
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = 300;
	    }
	    countCbrVc++;

            printf ("\nPort = %d VPI = %d, VCI = %d, IX_ATM_CBR\n",
                    atmPortCnt, atmVpi[atmVcCnt],atmVci[atmVcCnt]);
	}
	else if (atmVcCnt >= 4 && atmVcCnt < 6)
	{
	    /* Setup for RTVBR service */
	    atmService = IX_ATM_RTVBR;

	    if (countRtVbrVc == 0)
	    {
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = 500; 
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.scr = 300;
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.mbs = 5000;
	    }
	    else
	    {
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = 600;
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.scr = 500;
		ixEAAAtmTxVc[atmVcCnt].trafficDesc.mbs = 6000;
	    }
            countRtVbrVc++;

            printf ("\nPort = %d VPI = %d, VCI = %d, IX_ATM_RTVBR\n",
                    atmPortCnt, atmVpi[atmVcCnt],atmVci[atmVcCnt]);
	}
	else if (atmVcCnt >= 6 && atmVcCnt <8)
	{
	    /* Setup for nrt-VBR*/
	    atmService = IX_ATM_VBR;

	    ixEAAAtmTxVc[atmVcCnt].trafficDesc.pcr = 200; 
	    ixEAAAtmTxVc[atmVcCnt].trafficDesc.scr = 200;
	    ixEAAAtmTxVc[atmVcCnt].trafficDesc.mbs = 0;

            printf ("\nPort = %d VPI = %d, VCI = %d, IX_ATM_VBR\n",
                    atmPortCnt, atmVpi[atmVcCnt],atmVci[atmVcCnt]);

	}

	ixEAAAtmTxVc[atmVcCnt].trafficDesc.atmService =
	    ixEAAAtmRxVc[atmVcCnt].trafficDesc.atmService = atmService;

	atmPortCnt++;
	if (atmPortCnt >= numberOfPorts)
	{
	    atmPortCnt = 0;
	}
    }
    return IX_SUCCESS;
}

IX_STATUS ixEAAVCInit( void )
{
    int portCnt = 0;
    int vcCnt = 0;
    int bufCnt, bufSize;
    int retval;

    /* Setup VC function is responsible to setup VCs depending on the 
     * phy setup with various ATM service*/
    retval = ixEAASetupVc(IX_EAA_NUM_ATM_VCS,IX_EAA_NUM_ATM_PORTS);

    if (retval != IX_SUCCESS)   
    {
	return IX_FAIL;
    }

    /* Initialize ATM VC */
    for (vcCnt = 0;  vcCnt < IX_EAA_NUM_ATM_VCS;  vcCnt++)
    {
	retval = ixEthAal5AppUtilsAtmVcRegisterConnect (
	             portCnt,
		     ixEAAAtmTxVc[vcCnt],
		     ixEAAAtmRxVc[vcCnt],
		     IX_ATMDACC_AAL5,
                     IX_ATM_RX_A,
                     ixEAAAtmRxCallback,
                     IX_EAA_MIN_REPLENISH_COUNT,
                     ixEAAAtmTxDoneCallback,
                     NULL /*ixEAAAtmRxVcFreeLowCallback*/,
                     vcCnt,
                     &atmVcRxId[vcCnt],
                     &atmVcTxId[vcCnt]);
    
	if (retval != IX_SUCCESS)
	{
	    printf ("VC Initialization failed for VC %d\n", 
		    vcCnt);
	    return IX_FAIL;
	}

	/* The port count depends on the PHY mode settings. 
	   If using SPHY, 1 port is enabled else if using MPHY, 
	   8 ports are enabled */ 
	portCnt++;
        if (portCnt >= atmNumPortsEnabled)
        {
            portCnt = 0;
        }

	/* mbuf pool initialisation */
	bufSize = IX_EAA_DEFAULT_MBUF_DATA_SIZE+IX_EAA_MBUF_USER_SPACE;

	mBufAtmPool[vcCnt] = IX_OSAL_MBUF_POOL_INIT(IX_EAA_NUM_BUFFERS_PER_VC,
						    bufSize,
						    "Eth Aal5 Codelet Pool for Atm");

        /* Replenish free buffers to current VC */
        for( bufCnt = 0;  bufCnt < IX_EAA_NUM_BUFFERS_PER_VC;  bufCnt++ )
        {
	    /* get a mbuf from the pool */
	    IX_OSAL_MBUF *mbufPtr;

            mbufPtr = IX_OSAL_MBUF_POOL_GET(mBufAtmPool[vcCnt]);
	    
	    /* initialise the user space part of the mbuf */
	    ixEAABufferInit(mbufPtr, IX_EAA_ATM_MARK | vcCnt);
	    
            /* Replenish bufCnt-th buffer to cnt-th VC (atmVcRxId[ cnt ]).
               Buffer is taken from cnt-th pool from position bufCnt */
            ixEAAAtmBufferRecycle ( atmVcRxId[ vcCnt ], mbufPtr );
#ifdef IXEAA_DEBUG
	    printf("Atm vcCnt = %d. Buf:%p->%p\n", vcCnt+1, mbufPtr, IX_OSAL_MBUF_MDATA(mbufPtr));
#endif
        }
    }

    return IX_SUCCESS;
}

/*^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^*/

/*>>>>>>>>>>>>>>>>> ETH HARDWARE INITIALIZATION FUNCTIONS <<<<<<<<<<<<<<<<<<<*/

IX_STATUS ixEAAEthNpeInit(void)
{

    /* If not IXP42X A0 stepping, proceed to check for existence of coprocessors */ 
    if ((IX_FEATURE_CTRL_SILICON_TYPE_A0 != 
        (ixFeatureCtrlProductIdRead() & IX_FEATURE_CTRL_SILICON_STEPPING_MASK))
        || (IX_FEATURE_CTRL_DEVICE_TYPE_IXP42X != ixFeatureCtrlDeviceRead ()))
    {
	/* When Silicon Type is B0, only initialize and start NPE if
	 * it is available.  This codelet supports silicon with single Eth NPE.  
         */
	if (IX_FEATURE_CTRL_COMPONENT_ENABLED == 
	    ixFeatureCtrlComponentCheck(IX_FEATURECTRL_ETH0))
	{
	    if(ixNpeDlNpeInitAndStart(NPE_B_IMAGE_ID) != IX_SUCCESS)
	    {
		printf("Error initialising NPE B!\n");
		return IX_FAIL;
	    }
	}
	
	if (IX_FEATURE_CTRL_COMPONENT_ENABLED == 
	    ixFeatureCtrlComponentCheck(IX_FEATURECTRL_ETH1))
	{	    
	    if(ixNpeDlNpeInitAndStart(NPE_C_IMAGE_ID) != IX_SUCCESS)
	    {
		printf("Error initialising NPE C!\n");
		return IX_FAIL;
	    }
	}
    }
    else
    {
	if(ixNpeDlNpeInitAndStart(NPE_B_IMAGE_ID) != IX_SUCCESS)
	{
	    printf("Error initialising NPE B!\n");
	    return IX_FAIL;
	}
	
	if(ixNpeDlNpeInitAndStart(NPE_C_IMAGE_ID) != IX_SUCCESS)
	{
	    printf("Error initialising NPE C!\n");
	    return IX_FAIL;
	}
    }


    return IX_SUCCESS;