#include <Copyright.h>

/********************************************************************************
* gtPortCtrl.c
*
* DESCRIPTION:
*       API implementation for switch port status.
*
* DEPENDENCIES:
*
* FILE REVISION NUMBER:
*       $Revision: 3 $
*******************************************************************************/

#include <msApi.h>
#include <gtHwCntl.h>
#include <gtDrvSwRegs.h>
#include <gtDrvConfig.h>

typedef struct _GT_Px_MODE
{
	GT_BOOL miiEn;
	GT_BOOL portMode;
	GT_BOOL phyMode;
	GT_PORT_SPEED_MODE speed;
	GT_BOOL duplex;
} GT_Px_MODE;

/*******************************************************************************
* procPx_Mode
*
* DESCRIPTION:
*       This routine retrieves Px_MODE and analize it.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       mode - Px_MODE structure
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
*******************************************************************************/
GT_STATUS procPx_Mode
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_Px_MODE   *mode
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("procPx_Mode Called.\n"));

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,7,5,&data);
	if (retVal != GT_OK)
		return retVal;

	if(data & 0x1)
	{
		/* MII Interface Enabled. */
		mode->miiEn = GT_TRUE;		/* Mii Interface Enabled */

		switch(data >> 1)
		{
			case 0:
			case 1:
			case 4:
			case 5:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_FALSE;	/* not standard Mii, either SNI or 200 Mii */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 2:
			case 6:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_FALSE;	/* not standard Mii, either SNI or 200 Mii */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 3:
				mode->speed = PORT_SPEED_200_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_FALSE;	/* not standard Mii, either SNI or 200 Mii */
				mode->phyMode = GT_FALSE;	/* MAC Mode */
				break;
			case 7:
				mode->speed = PORT_SPEED_200_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_FALSE;	/* not standard Mii, either SNI or 200 Mii */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 8:
				mode->speed = PORT_SPEED_UNKNOWN;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_FALSE;	/* MAC Mode */
				break;
			case 9:
				mode->speed = PORT_SPEED_UNKNOWN;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* RMii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 10:
				mode->speed = PORT_SPEED_UNKNOWN;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_FALSE;	/* MAC Mode */
				break;
			case 11:
				mode->speed = PORT_SPEED_UNKNOWN;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* RMii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 12:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 13:
				mode->speed = PORT_SPEED_100_MBPS;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 14:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 15:
				mode->speed = PORT_SPEED_100_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* Mii Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			default:
				return GT_FAIL;
		}
	}
	else
	{
		/* MII Interface Disabled. */
		mode->miiEn = GT_FALSE;

		switch((data >> 1) & 0x3)
		{
			case 0:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* MII Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 1:
				mode->speed = PORT_SPEED_100_MBPS;
				mode->duplex = GT_FALSE;	/* half duplex */
				mode->portMode = GT_TRUE;	/* MII Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 2:
				mode->speed = PORT_SPEED_10_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* MII Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			case 3:
				mode->speed = PORT_SPEED_100_MBPS;
				mode->duplex = GT_TRUE;		/* full duplex */
				mode->portMode = GT_TRUE;	/* MII Mode */
				mode->phyMode = GT_TRUE;	/* PHY Mode */
				break;
			default:
				return GT_FAIL;
		}
	}

    /* return */
    return GT_OK;
}


/*******************************************************************************
* gprtGetPartnerLinkPause
*
* DESCRIPTION:
*       This routine retrives the link partner pause state.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       state - GT_TRUE for enable  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*       GT_NOT_SUPPORTED - if current device does not support this feature.
*		
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPartnerLinkPause
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetPartnerLinkPause Called.\n"));

	/* Gigabit Switch does not support this status. gprtGetPauseEn is supported instead. */
	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,15,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetPauseEn
*
* DESCRIPTION:
*		This routine retrives the link pause state.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE for enable or GT_FALSE otherwise
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*		If set MAC Pause (for Full Duplex flow control) is implemented in the
*		link partner and in MyPause
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPauseEn
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_BOOL 	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetPauseEn Called.\n"));

	/* Only Gigabit Switch supports this status. */
	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,15,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetSelfLinkPause
*
* DESCRIPTION:
*       This routine retrives the link pause state.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       state - GT_TRUE for enable  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetSelfLinkPause
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetSelfLinkPause Called.\n"));
    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,14,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetResolve
*
* DESCRIPTION:
*       This routine retrives the resolve state.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       state - GT_TRUE for Done  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*       GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetResolve
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetResolve Called.\n"));

	/* Gigabit Switch does not support this status. */
	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,13,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetHdFlow
*
* DESCRIPTION:
*		This routine retrives the half duplex flow control value.
*		If set, Half Duplex back pressure will be used on this port if this port
*		is in a half duplex mode.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE for enable or GT_FALSE otherwise
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetHdFlow
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL 	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetHdFlow Called.\n"));

	/* Only Gigabit Switch supports this status. */
	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,13,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetPHYDetect
*
* DESCRIPTION:
*		This routine retrives the information regarding PHY detection.
*		If set, An 802.3 PHY is attached to this port.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if connected or GT_FALSE otherwise
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*		
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPHYDetect
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL 	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetPHYDetect Called.\n"));

	/* Only Gigabit Switch supports this status. */
	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,12,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    /* return */
    return retVal;
}

/*******************************************************************************
* gprtSetPHYDetect
*
* DESCRIPTION:
*		This routine sets PHYDetect bit which make PPU change its polling.
*		PPU's pool routine uses these bits to determine which port's to poll
*		PHYs on for Link, Duplex, Speed, and Flow Control.
*
* INPUTS:
*		port - the logical port number.
*		state - GT_TRUE or GT_FALSE
*
* OUTPUTS:
*		None.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*		This function should not be called if gsysGetPPUState returns 
*		PPU_STATE_ACTIVE.
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtSetPHYDetect
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	IN  GT_BOOL  	state
)
{
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtSetPHYDetect Called.\n"));

	/* Only Gigabit Switch supports this status. */
	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Set the PHY Detect bit.  */
    retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,12,1,(GT_U16)state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetLinkState
*
* DESCRIPTION:
*       This routine retrives the link state.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       state - GT_TRUE for Up  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetLinkState
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_U8			bitNumber;

    DBG_INFO(("gprtGetLinkState Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
		bitNumber = 11;
	}
	else
	{
		bitNumber = 12;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,bitNumber,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetPortMode
*
* DESCRIPTION:
*       This routine retrives the port mode.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       mode - GT_TRUE for MII 10/100 or RMII 100,
*			   GT_FALSE for SNI 10 or MII 200
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*       GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPortMode
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *mode
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_Px_MODE		pxMode;

    DBG_INFO(("gprtGetPortMode Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

	if (IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
		retVal = procPx_Mode(dev,port,&pxMode);
		if (retVal != GT_OK)
		{
	        DBG_INFO(("procPx_Mode return Fail\n"));
			return retVal;
		}
		*mode = pxMode.portMode;
		return GT_OK;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,11,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *mode);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetPhyMode
*
* DESCRIPTION:
*       This routine retrives the PHY mode.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       mode - GT_TRUE for MII PHY Mode, 
*			   GT_FALSE for MII MAC Mode
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*       GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPhyMode
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *mode
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_Px_MODE		pxMode;

    DBG_INFO(("gprtGetPhyMode Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

	if (IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
		retVal = procPx_Mode(dev,port,&pxMode);
		if (retVal != GT_OK)
		{
	        DBG_INFO(("procPx_Mode return Fail\n"));
			return retVal;
		}
		*mode = pxMode.phyMode;
		return GT_OK;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,10,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *mode);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetDuplex
*
* DESCRIPTION:
*       This routine retrives the port duplex mode.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       mode - GT_TRUE for Full  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetDuplex
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *mode
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_U8			bitNumber;
	GT_Px_MODE		pxMode;

    DBG_INFO(("gprtGetDuplex Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
		retVal = procPx_Mode(dev,port,&pxMode);
		if (retVal != GT_OK)
		{
	        DBG_INFO(("procPx_Mode return Fail\n"));
			return retVal;
		}
		*mode = pxMode.duplex;
		return GT_OK;
	}

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
		bitNumber = 10;
	}
	else
	{
		bitNumber = 9;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,bitNumber,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *mode);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetSpeed
*
* DESCRIPTION:
*       This routine retrives the port speed.
*
* INPUTS:
*       speed - the logical port number.
*
* OUTPUTS:
*       mode - GT_TRUE for 100Mb/s  or GT_FALSE otherwise
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetSpeed
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_BOOL   *speed
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_Px_MODE		pxMode;

    DBG_INFO(("gprtGetSpeed Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

	if (IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
		retVal = procPx_Mode(dev,port,&pxMode);
		if (retVal != GT_OK)
		{
	        DBG_INFO(("procPx_Mode return Fail\n"));
			return retVal;
		}
		*speed = (pxMode.speed==PORT_SPEED_100_MBPS)?GT_TRUE:GT_FALSE;
		return GT_OK;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);
    /* Get the force flow control bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,8,1,&data);
    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *speed);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetSpeedMode
*
* DESCRIPTION:
*       This routine retrives the port speed.
*
* INPUTS:
*       port - the logical port number.
*
* OUTPUTS:
*       mode - GT_PORT_SPEED_MODE type.
*				(PORT_SPEED_1000_MBPS,PORT_SPEED_100_MBPS, PORT_SPEED_10_MBPS, 
*				etc.)
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetSpeedMode
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    OUT GT_PORT_SPEED_MODE   *speed
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */
	GT_Px_MODE		pxMode;

    DBG_INFO(("gprtGetSpeed Called.\n"));

	if (IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
		retVal = procPx_Mode(dev,port,&pxMode);
		if (retVal != GT_OK)
		{
	        DBG_INFO(("procPx_Mode return Fail\n"));
			return retVal;
		}
		*speed = pxMode.speed;
		return GT_OK;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

	if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
	    /* Get the force flow control bit.  */
    	retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,8,2,&data);
	}
	else
	{
    	retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,8,1,&data);
	}

	*speed = (GT_PORT_SPEED_MODE)data;

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtSetDuplex
*
* DESCRIPTION:
*       This routine sets the duplex mode of MII/SNI/RMII ports.
*
* INPUTS:
*       port - 	the logical port number.
*				(for FullSail, it will be port 2, and for ClipperShip, 
*				it could be either port 5 or port 6.)
*       mode -  GT_TRUE for Full Duplex,
*				GT_FALSE for Half Duplex.
*
* OUTPUTS: None
*
* RETURNS:
*       GT_OK   - on success
*       GT_FAIL - on error
*       GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtSetDuplex
(
    IN  GT_QD_DEV *dev,
    IN  GT_LPORT  port,
    IN  GT_BOOL   mode
)
{
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtSetDuplex Called.\n"));

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* check if device supports this feature */
	if((retVal = IS_VALID_API_CALL(dev,hwPort, DEV_MII_DUPLEX_CONFIG)) != GT_OK)
	{
		return retVal;
	}

	/* check if phy is not configurable. */
	if(IS_CONFIGURABLE_PHY(dev, hwPort))
	{
		/* 
		 * phy is configurable. this function is not for the port where phy 
		 * can be configured.
		 */
		return GT_NOT_SUPPORTED;
	}

    /* Set the duplex mode. */
    retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,9,1,(GT_U16)mode);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetHighErrorRate
*
* DESCRIPTION:
*		This routine retrives the PCS High Error Rate.
*		This routine returns GT_TRUE if the rate of invalid code groups seen by
*		PCS has exceeded 10 to the power of -11.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE or GT_FALSE
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetHighErrorRate
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetHighErrorRate Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

	if (IS_IN_DEV_GROUP(dev,DEV_MGMII_STATUS) || IS_IN_DEV_GROUP(dev,DEV_200BASE_CFG))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the high error rate bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,6,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetMGMII
*
* DESCRIPTION:
*		SERDES Interface mode. When this bit is cleared to a zero and a PHY is 
*		detected connected to this port, the SERDES interface between this port
*		and the PHY will be SGMII.  When this bit is set to a one and a PHY is
*		detected connected to this port, the SERDES interface between this port 
*		and the PHY will be MGMII. When no PHY is detected on this port and the 
*		SERDES interface is being used, it will be configured in 1000Base-X mode.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE or GT_FALSE
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetMGMII
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetMGMII Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_MGMII_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the high error rate bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,6,1,&data);

    /* translate binary to BOOL  */
	if (IS_IN_DEV_GROUP(dev,DEV_MGMII_REVERSE_STATUS))
	{
    	BIT_2_BOOL_R(data, *state);
	}
	else
	{
    	BIT_2_BOOL(data, *state);
	}

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtSetMGMII
*
* DESCRIPTION:
*		SERDES Interface mode. When this bit is cleared to a zero and a PHY is 
*		detected connected to this port, the SERDES interface between this port
*		and the PHY will be SGMII.  When this bit is set toa one and a PHY is
*		detected connected to this port, the SERDES interface between this port 
*		and the PHY will be MGMII. When no PHY is detected on this port and the 
*		SERDES interface is being used, it will be configured in 1000Base-X mode.
*
* INPUTS:
*		port - the logical port number.
*		state - GT_TRUE or GT_FALSE
*
* OUTPUTS:
*		None
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtSetMGMII
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	IN  GT_BOOL  	state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtSetMGMII Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_MGMII_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

	if (IS_IN_DEV_GROUP(dev,DEV_MGMII_REVERSE_STATUS))
	{
	    BOOL_2_BIT_R(state,data);
	}
	else
	{
	    BOOL_2_BIT(state,data);
	}

    /* Get the high error rate bit.  */
    retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,6,1,data);
    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetTxPaused
*
* DESCRIPTION:
*		This routine retrives Transmit Pause state.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if Rx MAC receives a PAUSE frame with none-zero Puase Time
*				  GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetTxPaused
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetTxPaused Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_FC_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the TxPaused bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,5,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetFlowCtrl
*
* DESCRIPTION:
*		This routine retrives Flow control state.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if Rx MAC determines that no more data should be 
*					entering this port.
*				  GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetFlowCtrl
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetFlowCtrl Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_FC_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the FlowCtrl bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,4,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}


/*******************************************************************************
* gprtGetFdFlowDis
*
* DESCRIPTION:
*		This routine retrives the read time value of the Full Duplex Flow Disable.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if Full Duplex Flow Disable.
*	   		    GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS gprtGetFdFlowDis
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetFdFlowDis Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_FC_DIS_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the FdFlowDis bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,3,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetHdFlowDis
*
* DESCRIPTION:
*		This routine retrives the read time value of the Half Duplex Flow Disable.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if Half Duplex Flow Disable.
*	   		    GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS gprtGetHdFlowDis
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetHdFlowDis Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_FC_DIS_STATUS))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the HdFlowDis bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,2,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetPxMode
*
* DESCRIPTION:
*		This routine retrives 4 bits of Px_MODE Configuration value.
*		If speed and duplex modes are forced, the returned mode value would be
*		different from the configuration pin values.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		mode - Px_MODE configuration value
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPxMode
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_U32  	*mode
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetPxMode Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the Px_Mode bits.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,8,4,&data);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

	*mode = (GT_U32) data;

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetMiiInterface
*
* DESCRIPTION:
*		This routine retrives Mii Interface Mode.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if Mii Interface is enabled,
*				  GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS gprtGetMiiInterface
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetMiiInterface Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_Px_MODE))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the Mii bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,7,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetOutQSize
*
* DESCRIPTION:
*		This routine gets egress queue size counter value.
*		This counter reflects the current number of Egress buffers switched to 
*		this port. This is the total number of buffers across all four priority 
*		queues.
*
* INPUTS:
*		port - the logical port number
*
* OUTPUTS:
*		count - egress queue size counter value
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS: 
*
*******************************************************************************/
GT_STATUS gprtGetOutQSize
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_U16		*count
)
{
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetOutQSize Called.\n"));

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

	if (!IS_IN_DEV_GROUP(dev,DEV_OUT_Q_SIZE))
    {
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
    }

    /* Get OutQ_Size.            */
	if (IS_IN_DEV_GROUP(dev,DEV_Q_COUNTER_TABLE))
	{
		if((retVal = hwWritePortReg(dev,hwPort, QD_REG_Q_COUNTER, 0x8000)) != GT_OK)
			return retVal;
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,count);
	}
	else if (IS_IN_DEV_GROUP(dev,DEV_OUT_Q_512))
	{
	    retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,7,9,count);
	}
	else
	{
	    retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,8,8,count);
	}

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}
    return retVal;
}


/*******************************************************************************
* gprtGetBufHigh
*
* DESCRIPTION:
*		Output from QC telling the MAC that it should perform Flow Control.
*
* INPUTS:
*		port - the logical port number
*
* OUTPUTS:
*		bufHigh - GT_TRUE, if Flow control required
*				  GT_FALSE, otherwise
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS: 
*
*******************************************************************************/
GT_STATUS gprtGetBufHigh
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_BOOL		*bufHigh
)
{
	GT_STATUS       retVal;         /* Functions return value.      */
	GT_U8           hwPort;         /* the physical port number     */
	GT_U16			data;

	DBG_INFO(("gprtGetBufHigh Called.\n"));

	/* translate LPORT to hardware port */
	hwPort = GT_LPORT_2_PORT(port);

	if (!IS_IN_DEV_GROUP(dev,DEV_FULL_Q_COUNTER))
	{
		DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* Get BufHigh.            */
	if (IS_IN_DEV_GROUP(dev,DEV_Q_COUNTER_TABLE))
	{
		if((retVal = hwWritePortReg(dev,hwPort, QD_REG_Q_COUNTER, 0x9000)) != GT_OK)
			return retVal;
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,1,1,&data);
	}
	else
	{
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,6,1,&data);
	}

	if(retVal != GT_OK)
	{
		DBG_INFO(("Failed.\n"));
	}
	else
	{
		DBG_INFO(("OK.\n"));
	}

	/* translate binary to BOOL  */
	BIT_2_BOOL(data, *bufHigh);

	return retVal;
}

/*******************************************************************************
* gprtGetFcEn
*
* DESCRIPTION:
*		Input into the QC telling it that Flow Control is enabled on this port.
*
* INPUTS:
*		port - the logical port number
*
* OUTPUTS:
*		fcEn - GT_TRUE, if Flow control is enabled
*			   GT_FALSE, otherwise
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS: 
*
*******************************************************************************/
GT_STATUS gprtGetFcEn
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_BOOL		*fcEn
)
{
	GT_STATUS       retVal;         /* Functions return value.      */
	GT_U8           hwPort;         /* the physical port number     */
	GT_U16			data;

	DBG_INFO(("gprtGetFcEn Called.\n"));

	/* translate LPORT to hardware port */
	hwPort = GT_LPORT_2_PORT(port);

	if (!IS_IN_DEV_GROUP(dev,DEV_FULL_Q_COUNTER))
	{
		DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* Get FcEn.            */
	if (IS_IN_DEV_GROUP(dev,DEV_Q_COUNTER_TABLE))
	{
		if((retVal = hwWritePortReg(dev,hwPort, QD_REG_Q_COUNTER, 0xa000)) != GT_OK)
			return retVal;
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,1,&data);
	}
	else
	{
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,5,1,&data);
	}

	if(retVal != GT_OK)
	{
		DBG_INFO(("Failed.\n"));
	}
	else
	{
		DBG_INFO(("OK.\n"));
	}

	/* translate binary to BOOL  */
	BIT_2_BOOL(data, *fcEn);
	
	return retVal;
}

/*******************************************************************************
* gprtGetRsvSize
*
* DESCRIPTION:
*		This routine gets Ingress reserved queue size counter.
*		This counter reflects the current number of reserved ingress buffers 
*		assigned to this port.
*
* INPUTS:
*		port - the logical port number
*
* OUTPUTS:
*		count - reserved ingress queue size counter value
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS: 
*
*******************************************************************************/
GT_STATUS gprtGetRsvSize
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_U16		*count
)
{
	GT_STATUS       retVal;         /* Functions return value.      */
	GT_U8           hwPort;         /* the physical port number     */

	DBG_INFO(("gprtGetRsvSize Called.\n"));

	/* translate LPORT to hardware port */
	hwPort = GT_LPORT_2_PORT(port);

	if (!IS_IN_DEV_GROUP(dev,DEV_OUT_Q_SIZE))
	{
		DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* Get Rsv_Size.            */
	if (IS_IN_DEV_GROUP(dev,DEV_Q_COUNTER_TABLE))
	{
		if((retVal = hwWritePortReg(dev,hwPort, QD_REG_Q_COUNTER, 0x9000)) != GT_OK)
			return retVal;
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,count);
	}
	else
	{
		retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,5,count);
	}

	if(retVal != GT_OK)
	{
		DBG_INFO(("Failed.\n"));
	}
	else
	{
		DBG_INFO(("OK.\n"));
	}
	return retVal;
}


/*******************************************************************************
* gprtGetQSizePerQPri
*
* DESCRIPTION:
*		This routine gets egress queue size for port's each QPri (0 ~ 3).
*
* INPUTS:
*		port - the logical port number
*
* OUTPUTS:
*		counts - egress queue size per QPri (should be 4 * 16bytes)
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS: 
*
*******************************************************************************/
GT_STATUS gprtGetQSizePerQPri
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT	port,
	OUT GT_U16		*counts
)
{
	GT_STATUS       retVal;         /* Functions return value.      */
	GT_U8           hwPort;         /* the physical port number     */

	DBG_INFO(("gprtGetQSizePerQPri Called.\n"));

	/* translate LPORT to hardware port */
	hwPort = GT_LPORT_2_PORT(port);

	if (!IS_IN_DEV_GROUP(dev,DEV_Q_COUNTER_TABLE))
	{
		DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

	if((retVal = hwWritePortReg(dev,hwPort, QD_REG_Q_COUNTER, 0x800)) != GT_OK)
		return retVal;

	if((retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,&counts[0])) != GT_OK)
		return retVal;

	if((retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,&counts[1])) != GT_OK)
		return retVal;

	if((retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,&counts[2])) != GT_OK)
		return retVal;

	if((retVal = hwGetPortRegField(dev,hwPort, QD_REG_Q_COUNTER,0,9,&counts[3])) != GT_OK)
		return retVal;

	DBG_INFO(("OK.\n"));

	return retVal;
}


/*******************************************************************************
* gprtGetC_Duplex
*
* DESCRIPTION:
*		This routine retrives Port 9's duplex configuration mode determined
*		at reset.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - GT_TRUE if configured as Full duplex operation
*				  GT_FALSE otherwise.
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*		Return value is valid only if the given port is 9.
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetC_Duplex
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_BOOL  	*state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetC_Duplex Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the C_Duplex bit.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,3,1,&data);

    /* translate binary to BOOL  */
    BIT_2_BOOL(data, *state);

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}

/*******************************************************************************
* gprtGetC_Mode
*
* DESCRIPTION:
*		This routine retrives port's interface type configuration mode 
*		determined at reset.
*
* INPUTS:
*		port - the logical port number.
*
* OUTPUTS:
*		state - one of value in GT_PORT_CONFIG_MODE enum type
*
* RETURNS:
*		GT_OK   - on success
*		GT_FAIL - on error
*		GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*		Return value is valid only if the given port is 9.
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetC_Mode
(
	IN  GT_QD_DEV	*dev,
	IN  GT_LPORT 	port,
	OUT GT_PORT_CONFIG_MODE   *state
)
{
    GT_U16          data;           /* Used to poll the SWReset bit */
    GT_STATUS       retVal;         /* Functions return value.      */
    GT_U8           hwPort;         /* the physical port number     */

    DBG_INFO(("gprtGetC_Mode Called.\n"));

	if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH))
	{
        DBG_INFO(("GT_NOT_SUPPORTED\n"));
		return GT_NOT_SUPPORTED;
	}

    /* translate LPORT to hardware port */
    hwPort = GT_LPORT_2_PORT(port);

    /* Get the C_Mode bits.  */
    retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_STATUS,0,3,&data);

    /* translate binary to BOOL  */
    *state = (GT_PORT_CONFIG_MODE)data;

    if(retVal != GT_OK)
	{
        DBG_INFO(("Failed.\n"));
	}
    else
	{
        DBG_INFO(("OK.\n"));
	}

    /* return */
    return retVal;
}