txc_envoy_mac_real.c

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

                                                                             
   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_GetMacHalfDuplexReal(TXC_U16BIT handle, TXC_U16BIT port,
                                      TXC_IfMAC_HALF_DUPLEX_STRUCT *macHalfDuplexDataPtr)
{

    TXC_U16BIT error;
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT macBatchData;
    TXC_REG_ACCESS_32BIT_STRUCT macRegData[3];
    TXC_REG_32 * macBaseAddr;
    ENVOY_MAC_CONFIG_STRUCT * macCfgPtr;

    /* First read the two MAC addresses containing the half-duplex info */
    memset (&macRegData[0], 0, (3 * sizeof(TXC_REG_ACCESS_32BIT_STRUCT) ) );
    macBatchData.regDataPtr = &macRegData[0];
    macBatchData.writeVerifyFlag = TXC_WRITE_VERIFY_FLAG;
    macBatchData.semId = ENVOY_DbGetSemId();
    macBatchData.regCount = 3;

    /* determine the base address of the device */
    macBaseAddr = (TXC_REG_32 *) ENVOY_DbGetDeviceAddr (handle);
    macBaseAddr += macCfgOffset[port];
    macCfgPtr = (ENVOY_MAC_CONFIG_STRUCT *) macBaseAddr;

    /* Setup the addresses and masks to read for MAC interface */
    macRegData[0].addr = (TXC_REG_32 *) &(macCfgPtr->ipgIfgReg);
    macRegData[1].addr = (TXC_REG_32 *) &(macCfgPtr->halfDplxReg);
    macRegData[2].addr = (TXC_REG_32 *) &(macCfgPtr->cfg2Reg);
    macRegData[0].mask = 0x7F7F0000;
    macRegData[1].mask = 0x00FFF3FF;
    macRegData[2].mask = 0x00000001;

    /* Read the registers and return the data */    
    error = TXC_BatchReg32BitRead (&macBatchData);
    if (error == TXC_NO_ERR)
    {
        macHalfDuplexDataPtr->nonB2bIPGpart1 = (macRegData[0].data >> 24) & 0x007F;
        macHalfDuplexDataPtr->nonB2bIPGpart2 = (macRegData[0].data >> 16) & 0x007F;
            
        macHalfDuplexDataPtr->excessiveDeferEnable = (TXC_BOOL)((macRegData[1].data >> 16) & 0x01);
        macHalfDuplexDataPtr->noBackoffEnable = (TXC_BOOL)((macRegData[1].data >> 17) & 0x01);
        macHalfDuplexDataPtr->backPressureNoBackoffEnable = (TXC_BOOL)((macRegData[1].data >> 18) & 0x01);
        macHalfDuplexDataPtr->altBinExpBackoffEnable = (TXC_BOOL)((macRegData[1].data >> 19) & 0x01);
        macHalfDuplexDataPtr->altBinExpBackoffTrunc = (macRegData[1].data >> 20) & 0x000F;
        macHalfDuplexDataPtr->collisionWindow = macRegData[1].data & 0x03FF;
        macHalfDuplexDataPtr->retranMax = (macRegData[1].data >> 12) & 0x000F;
    }
    return error;
}




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

   FUNCTION:    ENVOY_SetMacIngressFlowCtrlReal

   DESCRIPTION: This function actually processess the TXC_ENVOY_MacIngressFlowCtrlSet

   INPUTS:  Same as TXC_ENVOY_MacIngressFlowCtrlSet

   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_SetMacIngressFlowCtrlReal
(
TXC_U16BIT handle,
TXC_U16BIT port,
TXC_IfMAC_INGRESS_FLOW_CTRL_MODE_STRUCT *macIngressFlowCtrlModeDataPtr
)
{   TXC_U16BIT error = TXC_NO_ERR;
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT batchData;
    TXC_REG_ACCESS_32BIT_STRUCT regData[3];
    TXC_REG_32 *baseAddr;
    TXC_REG_32 *portAddr;
    TXC_REG_32 *genAddr;
    TXC_U16BIT portIdx;
    TXC_U16BIT endPort;
    TXC_U16BIT startPort;
    TXC_U16BIT portInc;
    TXC_U32BIT tmpData;
    ENVOY_MAC_CONFIG_STRUCT * macCfgPtr;
    ENVOY_MAC_PKT_CTRL_STRUCT *macCtrlPtr;  /* reg0:4080:cfptCfepReg   reg1:4084:frameCtrlReg */
    TXC_IfMAC_CONFIG_STRUCT *macIfaceDataPtr;
    
    /* determine if one MAC port is being configured or all ports */
    GetMacPortRange(handle, port, &startPort, &endPort, &portInc); 

    /* initialize the structure with 0 */
    memset ((void *) &macIfaceDataPtr, 0, sizeof (macIfaceDataPtr));

    /* 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 = 3; 

    /* configure Reg. 4080 CFPT and CFEP */
    tmpData = macIngressFlowCtrlModeDataPtr->ingressFlowCtrlFrameExtendedParameter;
    tmpData <<= 16;
    tmpData |=  macIngressFlowCtrlModeDataPtr->ingressFlowCtrlFramePauseTime;
    regData[2].data = tmpData;
    regData[2].mask = -1;  /* mask all bits */

/*    reg0: 4000
      reg1: 4084
      reg2: 4080
*/
    /* loop thru all ports setting */
    for (portIdx = startPort; portIdx < endPort; )
    {
        switch (macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode)
        {
            case TXC_IfMAC_NO_FLOW_CTRL:
                regData[1].mask = 0x30000;
                regData[1].data = 0x0;
                break;


            case TXC_IfMAC_INTERMITTENT_RAISE_CARRIER_FLOW_CTRL:
                /* First, check if MAC port is in half-duplex mode, otherwise return an error */
                error = ENVOY_GetMacIfaceReal (handle, port, macIfaceDataPtr);
                if (macIfaceDataPtr->fullDuplexEnable == TXC_TRUE)
                {
                    return TXC_INCOMPATIBLE_FULL_DPLX_ERR;
                }
                regData[0].mask = 0x10;  /* reg 4000: bit4="0" */
                regData[0].data = 0x0;
                regData[1].mask = 0xC0030000;
                regData[1].data = 0x20000;    /* reg 4084: bit16="0", bit17="1", bit30="0, bit31="0" */
                break;


            case TXC_IfMAC_CONTINUOUS_RAISE_CARRIER_FLOW_CTRL:
                /* First, check if MAC port is in half-duplex mode, otherwise return an error */
                error = ENVOY_GetMacIfaceReal (handle, port, macIfaceDataPtr);
                if (macIfaceDataPtr->fullDuplexEnable == TXC_TRUE)
                {
                    return TXC_INCOMPATIBLE_FULL_DPLX_ERR;
                }
                regData[0].mask = 0x10;
                regData[0].data = 0x0;           /* reg 4000: bit4="0" */
                regData[1].mask = 0xC0030000;
                regData[1].data = 0x80020000;    /* reg 4084: bit16="0", bit17="1", bit30="0", bit31="1" */
                break;


            case TXC_IfMAC_AUTO_PAUSE_FRAME_FLOW_CTRL:
                /* First, check if MAC port is in half-duplex mode, otherwise return an error */
                error = ENVOY_GetMacIfaceReal (handle, port, macIfaceDataPtr);
                if (macIfaceDataPtr->fullDuplexEnable == TXC_FALSE)
                {
                    return TXC_INCOMPATIBLE_HALF_DPLX_ERR;
                }
                regData[0].mask = 0x10;
                regData[0].data = 0x10;          /* reg 4000: bit4="1" */
                regData[1].mask = 0x40030000;
                regData[1].data = 0x40020000;    /* reg 4084: bit16="0", bit17="1", bit30="1"*/
                break;


            case TXC_IfMAC_HOST_INITIATED_PAUSE_FRAME_FLOW_CTRL:
                error = ENVOY_GetMacIfaceReal (handle, port, macIfaceDataPtr);
                if (macIfaceDataPtr->fullDuplexEnable == TXC_FALSE)
                {
                    return TXC_INCOMPATIBLE_HALF_DPLX_ERR;
                }
                regData[0].mask = 0x10;
                regData[0].data = 0x10;          /* reg 4000: bit4="1" */
                regData[1].mask = 0x40030000;
                regData[1].data = 0x40010000;    /* reg 4084: bit16="1", bit17="0", bit30="1"*/
                break;

            default:
                error = TXC_INVALID_PARM_ERR; /* should never occur */
                break;
        } /* end of switch */

        portAddr = baseAddr + macPktCtrlOffset[portIdx];
        macCtrlPtr = (ENVOY_MAC_PKT_CTRL_STRUCT *) portAddr;
        regData[2].addr = (TXC_REG_32 *)&(macCtrlPtr->cfptCfepReg); /* reg 4080 */
        regData[1].addr = (TXC_REG_32 *)&(macCtrlPtr->frameCtrlReg); /* reg 4084 */

        genAddr = baseAddr + macCfgOffset[portIdx];
        macCfgPtr = (ENVOY_MAC_CONFIG_STRUCT *) genAddr;
        regData[0].addr = (TXC_REG_32 *)&(macCfgPtr->cfg1Reg);  /* reg 4000 */

        /* call the batch write to set the bit */
        error = TXC_BatchReg32BitWrite (&batchData);
        if (error != TXC_NO_ERR)
        {
            break;
        }
        portIdx = portIdx + portInc;
    }
    return error;
}



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

   FUNCTION:    ENVOY_GetMacIngressFlowCtrlReal

   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_GetMacIngressFlowCtrlReal  (TXC_U16BIT handle, TXC_U16BIT port,
         TXC_IfMAC_INGRESS_FLOW_CTRL_MODE_STRUCT *macIngressFlowCtrlModeDataPtr)
{
    ENVOY_MAC_PKT_CTRL_STRUCT *macCtrlPtr;
    ENVOY_MAC_CONFIG_STRUCT * macCfgPtr;
    TXC_BATCH_REG_ACCESS_32BIT_STRUCT batchData;
    TXC_REG_ACCESS_32BIT_STRUCT       regData[4];
    TXC_REG_32 *baseAddr;
    TXC_REG_32 *portAddr;
    TXC_REG_32 *genAddr;
    TXC_U32BIT tmpData0;
    TXC_U32BIT tmpData1;
    TXC_U32BIT tmpData2;
    TXC_U16BIT portIdx;
    TXC_U16BIT error = TXC_NO_ERR;
    
    /* set up batch request structure header */
    batchData.regDataPtr = regData;
    batchData.writeVerifyFlag = TXC_FALSE;
    batchData.semId = TXC_FALSE;
    batchData.regCount = 3;
    
    memset(regData, 0, sizeof(regData)); /* init to all zero */

    portIdx = port;

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

    /* Set up Registers 1100, 1101 */
    portAddr = baseAddr + macPktCtrlOffset[portIdx];
    macCtrlPtr = (ENVOY_MAC_PKT_CTRL_STRUCT *) portAddr;
    regData[2].addr = (TXC_REG_32 *)&(macCtrlPtr->cfptCfepReg);
    regData[1].addr = (TXC_REG_32 *)&(macCtrlPtr->frameCtrlReg);

    regData[2].mask = -1; /* all bits */
    /* regData[1].mask = -1; */
    regData[1].mask = 0xC0030000;

    genAddr = baseAddr + macCfgOffset[portIdx];
    macCfgPtr = (ENVOY_MAC_CONFIG_STRUCT *) genAddr;
    regData[0].addr = (TXC_REG_32 *)&(macCfgPtr->cfg1Reg);  /* reg 4000 */
    regData[0].mask = 0x10; /* isolate bit 4 of register 4000 */

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

    /* format the return structure */
    memset((char *)macIngressFlowCtrlModeDataPtr, 0, sizeof(TXC_IfMAC_INGRESS_FLOW_CTRL_MODE_STRUCT));


/* new: below */
    /* Reg 4080 */
    tmpData2= regData[2].data;
    macIngressFlowCtrlModeDataPtr->ingressFlowCtrlFramePauseTime = tmpData2 & 0xFFFF;
    macIngressFlowCtrlModeDataPtr->ingressFlowCtrlFrameExtendedParameter = tmpData2 >> 16;

    tmpData0 = regData[0].data;  /* reg 4000 */
    tmpData1 = regData[1].data;  /* reg 4084 */

    switch (tmpData1 & 0x30000)
    {
        case 0:
            macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode = TXC_IfMAC_NO_FLOW_CTRL;
            break;

        case 0x10000:  /* potential host-initiated case */
            if (!(tmpData0 & 0x10)) /* isolate bit 4 */
            {
                error = TXC_INVALID_FLOW_CTRL_MODE;
            }
            else if (!(tmpData1 & 0x40000000))  /* isolate bit 30 */
            {
                error = TXC_INVALID_FLOW_CTRL_MODE;
            }
            else
            {
                macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode = TXC_IfMAC_HOST_INITIATED_PAUSE_FRAME_FLOW_CTRL;
            }
            break;

        case 0x20000: /* three possible cases */
            if (((tmpData0 & 0x10) == 0) && ((tmpData1 & 0x40000000) == 0))
            {
                if (tmpData1 & 0x80000000)
                {
                    macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode = TXC_IfMAC_CONTINUOUS_RAISE_CARRIER_FLOW_CTRL;
                }
                else
                {
                    macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode = TXC_IfMAC_INTERMITTENT_RAISE_CARRIER_FLOW_CTRL;
                }
            }
            else if (((tmpData0 & 0x10) == 0x10) && ((tmpData1 & 0x40000000) == 0x40000000))
            {
                macIngressFlowCtrlModeDataPtr->ingressFlowCtrlMode = TXC_IfMAC_AUTO_PAUSE_FRAME_FLOW_CTRL;