txc_envoy_mac_real.c

TranSwitch Envoy CE2 & Envoy CE4 设备驱动及编程指南

    }
    

    return error;
}




/*--------------------------------------------------------------------------*

   FUNCTION:    ENVOY_GetMacLoopbackReal

   DESCRIPTION: This function actually processess the TXC_ENVOY_MacIngressFlowCtrlGet

   INPUTS:  Same as TXC_ENVOY_MacIngressFlowCtrlGet

   RETURNS:  TXC_NO_ERR or an appropriate specific error code listed in appendix.

   REVISION HISTORY:

    Rev       Date          Author               Description
   -----    -------      ------------         -----------------
   0.5.0    6/03/04      F. Giannella         Initial release (beta)
 *--------------------------------------------------------------------------*/

TXC_U16BIT
ENVOY_GetMacLoopbackReal
(
TXC_U16BIT handle,
TXC_U16BIT port,
TXC_IfMAC_LOOPBACK_STRUCT *macLoopbackDataPtr
)
{
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT macBatchData;
    TXC_REG_ACCESS_32BIT_STRUCT macRegData[4];
    TXC_REG_32 * macBaseAddr;
    TXC_REG_32 * macPortAddr;
    ENVOY_MAC_CONFIG_STRUCT * macCfgPtr;
    ENVOY_IFIFO_LOOPBACK_STRUCT * iFifoCfgPtr;

    TXC_U32BIT tmpData;
    TXC_U16BIT portIdx;
    TXC_U16BIT error = TXC_NO_ERR;
    
    /* set up batch request structure header */
    macBatchData.regDataPtr = &macRegData[0];
    macBatchData.writeVerifyFlag = TXC_FALSE;
    macBatchData.semId = TXC_FALSE;
    macBatchData.regCount = 3;
    
    memset (& macRegData[0], 0, (3* sizeof(TXC_REG_ACCESS_32BIT_STRUCT)));

    portIdx = port;

    /* determine the base address of the device */
    macBaseAddr = (TXC_REG_32 *) ENVOY_DbGetDeviceAddr (handle);

    /* Setup the masks to get the loopback mode */
    macRegData[0].mask = 0x100;  /* reg[0] = 4000, bit 8 */
    macRegData[1].mask = 0x1;    /* reg[1] = 2784, bit 0 */
    macRegData[2].mask = 0x1;    /* reg[2] = 2788, bit 0 (only if egress-to-ingress loopback is enabled) */


    macPortAddr = macBaseAddr + macCfgOffset[portIdx];
    macCfgPtr = (ENVOY_MAC_CONFIG_STRUCT *) macPortAddr;

    iFifoCfgPtr = (ENVOY_IFIFO_LOOPBACK_STRUCT *) (macBaseAddr + ENVOY_IFIFO_LOOPBACK_OFFSET); 

    macRegData[0].addr = (TXC_REG_32 *) &(macCfgPtr->cfg1Reg);
    macRegData[1].addr = (TXC_REG_32 *) &(iFifoCfgPtr->iFifoLbkEnableReg);
    macRegData[2].addr = (TXC_REG_32 *) &(iFifoCfgPtr->iFifoNonTransparentLbkEnableReg);

    error = TXC_BatchReg32BitRead (&macBatchData); /* read all registers */
    if (error != TXC_NO_ERR)
        return(error);

    /* format the return structure */
    memset((char *)macLoopbackDataPtr, 0, sizeof(TXC_IfMAC_LOOPBACK_STRUCT));

    tmpData= macRegData[0].data;
    if ((macRegData[0].data == macRegData[0].mask) && (macRegData[1].data != macRegData[1].mask))
    {
        macLoopbackDataPtr->macLpbkMode = TXC_IfMAC_EGR_TO_INGR_LPBK;
    }
    else if ((macRegData[0].data != macRegData[0].mask) && (macRegData[1].data != macRegData[1].mask))
    {
        macLoopbackDataPtr->macLpbkMode = TXC_IfMAC_LPBK_NONE;
    }
    else if ((macRegData[0].data != macRegData[0].mask) && (macRegData[1].data == macRegData[1].mask))
    {
        if (macRegData[2].data == macRegData[2].mask)
        {
            macLoopbackDataPtr->macLpbkMode = TXC_IfMAC_INGR_TO_EGR_NON_TRANSPARENT_LPBK;
        }
        else
        {
            macLoopbackDataPtr->macLpbkMode = TXC_IfMAC_INGR_TO_EGR_TRANSPARENT_LPBK;
        }
    }
    else
    {
        error = TXC_INVALID_CFG_ERR;
        macLoopbackDataPtr->macLpbkMode = TXC_IfMAC_LPBK_ENUM_ERR;
    }

    return(error);
}




/*--------------------------------------------------------------------------*

   FUNCTION:    ENVOY_SetMacRmonCtrlReal

   DESCRIPTION: This function actually processess the TXC_ENVOY_MacRmonCtrlSet

   INPUTS:  Same as TXC_ENVOY_MacRmonCtrlSet

   RETURNS:  TXC_NO_ERR or an appropriate specific error code listed in appendix.

   REVISION HISTORY:

    Rev       Date          Author               Description
   -----    -------      ------------         -----------------
   0.5.0    6/03/04      F. Giannella         Initial release (beta)
 *--------------------------------------------------------------------------*/

TXC_U16BIT
ENVOY_SetMacRmonCtrlReal(
TXC_U16BIT handle,
ENVOY_MAC_RMON_CTRL_STRUCT *macRmonCtrlDataPtr)
{
    TXC_U16BIT error = TXC_NO_ERR;
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT batchData;
    TXC_REG_ACCESS_32BIT_STRUCT regData[2];
    TXC_REG_32 *baseAddr;
    TXC_U32BIT tmpData;
    ENVOY_HOST_PIN_RMONCTRL_STRUCT * rmonCfgPtr;

    /* determine the base address of the device */
    baseAddr = (TXC_REG_32 *) ENVOY_DbGetDeviceAddr (handle);

    batchData.regDataPtr = regData;
    batchData.writeVerifyFlag = TXC_FALSE;
    batchData.semId = ENVOY_DbGetSemId();

    memset(regData, 0, sizeof(regData)); /* init to all zero */

    batchData.regCount = 1; 

    /* configure Reg. 0030 (rmonCtrlReg) */
    tmpData = macRmonCtrlDataPtr->rmonSaturateEnable;
    tmpData |=  (macRmonCtrlDataPtr->rbytCntMode << 1);
    regData[0].data = tmpData;
    regData[0].mask = 0x3;  /* bits 0 and 1 */

    rmonCfgPtr = (ENVOY_HOST_PIN_RMONCTRL_STRUCT *) (baseAddr + ENVOY_HOST_PIN_OFFSET);
    regData[0].addr = (TXC_REG_32 *)&(rmonCfgPtr->rmonCtrlReg); /* reg 0030 */

    /* call the batch write to set the bit */
    error = TXC_BatchReg32BitWrite (&batchData);
    return error;
}




/*--------------------------------------------------------------------------*

   FUNCTION:    ENVOY_GetMacLoopbackReal

   DESCRIPTION: This function actually processess the TXC_ENVOY_MacIngressFlowCtrlGet

   INPUTS:  Same as TXC_ENVOY_MacIngressFlowCtrlGet

   RETURNS:  TXC_NO_ERR or an appropriate specific error code listed in appendix.

   REVISION HISTORY:

    Rev       Date          Author               Description
   -----    -------      ------------         -----------------
   0.5.0    6/03/04      F. Giannella         Initial release (beta)
 *--------------------------------------------------------------------------*/

TXC_U16BIT
ENVOY_GetMacRmonCtrlReal(
TXC_U16BIT handle,
ENVOY_MAC_RMON_CTRL_STRUCT *macRmonCtrlDataPtr)
{
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT batchData;
    TXC_REG_ACCESS_32BIT_STRUCT regData[2];
    TXC_REG_32 * baseAddr;
    ENVOY_HOST_PIN_RMONCTRL_STRUCT * rmonCfgPtr;

    TXC_U16BIT error = TXC_NO_ERR;
    
    /* set up batch request structure header */
    batchData.regDataPtr = &regData[0];
    batchData.writeVerifyFlag = TXC_FALSE;
    batchData.semId = TXC_FALSE;
    batchData.regCount = 1;
    
    memset (& regData[0], 0, (sizeof(TXC_REG_ACCESS_32BIT_STRUCT)));

    /* determine the base address of the device */
    baseAddr = (TXC_REG_32 *) ENVOY_DbGetDeviceAddr (handle);

    /* Setup the masks to read register 0x0030 */
    regData[0].mask = 0x3;  /* bits 0 and 1 */


    rmonCfgPtr = (ENVOY_HOST_PIN_RMONCTRL_STRUCT *) (baseAddr + ENVOY_HOST_PIN_OFFSET);
    regData[0].addr = (TXC_REG_32 *)&(rmonCfgPtr->rmonCtrlReg); /* reg 0030 */

    error = TXC_BatchReg32BitRead (&batchData); /* read all registers */
    if (error != TXC_NO_ERR)
        return(error);

    /* format the return structure */
    memset((char *)macRmonCtrlDataPtr, 0, sizeof(ENVOY_MAC_RMON_CTRL_STRUCT));

    switch(regData[0].data)
    {
        case 0:
            macRmonCtrlDataPtr->rmonSaturateEnable = TXC_FALSE;
            macRmonCtrlDataPtr->rbytCntMode = ENVOY_CNT_GOOD_AND_BAD_PKTS;
            break;

        case 1:
            macRmonCtrlDataPtr->rmonSaturateEnable = TXC_TRUE;
            macRmonCtrlDataPtr->rbytCntMode = ENVOY_CNT_GOOD_AND_BAD_PKTS;
            break;

        case 2:
            macRmonCtrlDataPtr->rmonSaturateEnable = TXC_FALSE;
            macRmonCtrlDataPtr->rbytCntMode = ENVOY_CNT_GOOD_PKTS_ONLY;
            break;

        case 3:
            macRmonCtrlDataPtr->rmonSaturateEnable = TXC_TRUE;
            macRmonCtrlDataPtr->rbytCntMode = ENVOY_CNT_GOOD_PKTS_ONLY;
            break;

        default:
            error = TXC_INVALID_CFG_ERR; /* it should never happen */
            break;
    }
    return(error);
}




/*--------------------------------------------------------------------------*
                                                                             
   FUNCTION:  ENVOY_RtrvMacTxStatisticsReal                                                                 
                                                                             
   DESCRIPTION: This function actually processess the ENVOY_RtrvMacTxStatistics                                          
                                                                             
   INPUTS:  Same as ENVOY_RtrvMacTxStatistics                                                                   
                                                                             
   RETURNS:  TXC_NO_ERR or an appropriate specific error code listed in appendix.                                                                  
                                                                             
   CAVEATS:  None.                                                           
                                                                             
   REVISION HISTORY:

    Rev       Date          Author               Description
   -----    -------      ------------         -----------------
   0.5.0    6/03/04      F. Giannella         Initial release (beta)
 *--------------------------------------------------------------------------*/

TXC_U16BIT ENVOY_RtrvMacTxStatisticsReal(TXC_U16BIT handle, TXC_U16BIT port,
    ENVOY_MAC_TX_STATISTICS_STRUCT *macTxStatisticsDataPtr)
{

    TXC_U16BIT error;
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT batchData;
    TXC_REG_ACCESS_32BIT_STRUCT regData[28];
    TXC_REG_32 * baseAddr;
    ENVOY_MAC_TX_RMON_STRUCT * macTxCntPtr;

    /* first fill the batch request info. There are 20 statistics counters  
       to read. Registers are read/write so a semaphore is needed. */
    batchData.regDataPtr = &regData[0];
    batchData.regCount = 27;
    batchData.writeVerifyFlag = TXC_WRITE_VERIFY_FLAG;
    batchData.semId = ENVOY_DbGetSemId();
    memset (&regData[0], 0, (28 * sizeof(TXC_REG_ACCESS_32BIT_STRUCT) ) );
    
    /* determine the base address of the device */
    baseAddr = (TXC_REG_32 *) ENVOY_DbGetDeviceAddr (handle);

    /* Determine register address based on device base, port and register */
    baseAddr += macTxCntOffset[port];
    macTxCntPtr = (ENVOY_MAC_TX_RMON_STRUCT *) baseAddr;

    regData[0].addr = (TXC_REG_32 *) &(macTxCntPtr->tbytloCntReg);
    regData[1].addr = (TXC_REG_32 *) &(macTxCntPtr->tbythiCntReg);
    regData[2].addr = (TXC_REG_32 *) &(macTxCntPtr->tpktCntReg);
    regData[3].addr = (TXC_REG_32 *) &(macTxCntPtr->tundCntReg);
    regData[4].addr = (TXC_REG_32 *) &(macTxCntPtr->t64CntReg);
    regData[5].addr = (TXC_REG_32 *) &(macTxCntPtr->t127CntReg);
    regData[6].addr = (TXC_REG_32 *) &(macTxCntPtr->t255CntReg);
    regData[7].addr = (TXC_REG_32 *) &(macTxCntPtr->t511CntReg);
    regData[8].addr = (TXC_REG_32 *) &(macTxCntPtr->t1023CntReg);
    regData[9].addr = (TXC_REG_32 *) &(macTxCntPtr->t1518CntReg);
    regData[10].addr = (TXC_REG_32 *) &(macTxCntPtr->tpfdCntReg);
    regData[11].addr = (TXC_REG_32 *) &(macTxCntPtr->tovrCntReg);
    regData[12].addr = (TXC_REG_32 *) &(macTxCntPtr->tbcaCntReg);
    regData[13].addr = (TXC_REG_32 *) &(macTxCntPtr->tmcaCntReg);
    regData[14].addr = (TXC_REG_32 *) &(macTxCntPtr->tpfCntReg);
    regData[15].addr = (TXC_REG_32 *) &(macTxCntPtr->tvlnCntReg);
    regData[16].addr = (TXC_REG_32 *) &(macTxCntPtr->tdfrCntReg);
    regData[17].addr = (TXC_REG_32 *) &(macTxCntPtr->tedfCntReg);
    regData[18].addr = (TXC_REG_32 *) &(macTxCntPtr->tsclCntReg);
    regData[19].addr = (TXC_REG_32 *) &(macTxCntPtr->tmclCntReg);
    regData[20].addr = (TXC_REG_32 *) &(macTxCntPtr->tlclCntReg);
    regData[21].addr = (TXC_REG_32 *) &(macTxCntPtr->texclCntReg);
    regData[22].addr = (TXC_REG_32 *) &(macTxCntPtr->tfrgCntReg);
    regData[23].addr = (TXC_REG_32 *) &(macTxCntPtr->tfcsCntReg);
    regData[24].addr = (TXC_REG_32 *) &(macTxCntPtr->tjbrCntReg);
    regData[25].addr = (TXC_REG_32 *) &(macTxCntPtr->tdrpCntReg);
    regData[26].addr = (TXC_REG_32 *) &(macTxCntPtr->tabtCntReg);


    /* Set the masks for each register.*/
    regData[0].mask = 0xFFFFFFFF;
    regData[1].mask = 0xFF;
    regData[2].mask = 0xFFFFFFFF;