/*******************************************************************************
* gprtGetVlanTunnel
*
* DESCRIPTION:
* This routine get the vlan tunnel mode.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* mode - the vlan tunnel mode..
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetVlanTunnel
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_BOOL *mode
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
DBG_INFO(("gprtGetVlanTunnel Called.\n"));
if(mode == NULL)
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
phyPort = GT_LPORT_2_PORT(port);
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PORT_CONTROL,7,1,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
BIT_2_BOOL(data,*mode);
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gstpGetPortState
*
* DESCRIPTION:
* This routine returns the port state.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* state - the current port state.
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
*
* COMMENTS:
* None.
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gstpGetPortState
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_PORT_STP_STATE *state
)
{
GT_U8 phyPort; /* Physical port */
GT_U16 data; /* Data read from register. */
GT_STATUS retVal; /* Functions return value. */
DBG_INFO(("gstpGetPortState Called.\n"));
phyPort = GT_LPORT_2_PORT(port);
/* Get the port state bits. */
retVal = hwGetPortRegField(dev,phyPort, QD_REG_PORT_CONTROL,0,2,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
*state = data & 0x3;
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gvlnGetPortVid
*
* DESCRIPTION:
* This routine Get the port default vlan id.
*
* INPUTS:
* port - logical port number to set.
*
* OUTPUTS:
* vid - the port vlan id.
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gvlnGetPortVid
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_U16 *vid
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
DBG_INFO(("gvlnGetPortVid Called.\n"));
if(vid == NULL)
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
phyPort = GT_LPORT_2_PORT(port);
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PVID,0,12, &data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
*vid = data;
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpcsGetPCSAnEn
*
* DESCRIPTION:
* This routine retrieves Enable mode of PCS Inband Auto-Negotiation.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* mode - GT_TRUE if PCS AN is enabled 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 gpcsGetPCSAnEn
(
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 */
DBG_INFO(("gpcsGetPCSAnEn Called.\n"));
/* check if the given Switch supports this feature. */
if (!IS_IN_DEV_GROUP(dev,DEV_PCS))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
/* check if the given port supports PCS */
if (!DOES_DEVPORT_SUPPORT_PCS(dev,hwPort))
{
if (!IS_IN_DEV_GROUP(dev, DEV_INTERNAL_GPHY))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
if ((hwPort < 4) || (hwPort > 7))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
}
/* Get the PCSAnEn bit. */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PCS_CONTROL,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;
}
/*******************************************************************************
* gprtGetEgressMode
*
* DESCRIPTION:
* This routine get the egress mode.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* mode - the egress mode.
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
* None.
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetEgressMode
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_EGRESS_MODE *mode
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
if(mode == NULL)
return GT_BAD_PARAM;
DBG_INFO(("gprtGetEgressMode Called.\n"));
phyPort = GT_LPORT_2_PORT(port);
/* check if device supports this feature */
if((retVal = IS_VALID_API_CALL(dev,phyPort, DEV_TAGGING)) != GT_OK )
return retVal;
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PORT_CONTROL,12,2,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
switch (data)
{
case (0):
*mode = GT_UNMODIFY_EGRESS;
break;
case (2):
*mode = GT_TAGGED_EGRESS;
break;
case (1):
*mode = GT_UNTAGGED_EGRESS;
break;
case (3):
*mode = GT_ADD_TAG;
break;
}
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpcsGetRGMIITimingDelay
*
* DESCRIPTION:
* RGMII receive/transmit Timing Control. This api adds delay to RXCLK for
* IND inputs and GTXCLK for OUTD outputs when port is in RGMII mode.
* Change to this bit are disruptive to normal operation. Hence any changes
* to this register must be done only while the port's link is down.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* rxmode - GT_FALSE for default setup, GT_TRUE for adding delay to rxclk
* txmode - GT_FALSE for default setup, GT_TRUE for adding delay to txclk
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS gpcsGetRGMIITimingDelay
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_BOOL *rxmode,
OUT GT_BOOL *txmode
)
{
GT_U16 data;
GT_STATUS retVal; /* Functions return value. */
GT_U8 hwPort; /* the physical port number */
DBG_INFO(("gpcsGetRGMIITimingDelay Called.\n"));
if (!IS_IN_DEV_GROUP(dev,DEV_RGMII_TIMING))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
if (hwPort < (dev->maxPorts - 2))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* Get the register bit(s). */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PCS_CONTROL,14,2,&data);
*rxmode = (data & 0x2)?GT_TRUE:GT_FALSE;
*txmode = (data & 0x1)?GT_TRUE:GT_FALSE;
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
}
else
{
DBG_INFO(("OK.\n"));
}
/* return */
return retVal;
}
/*******************************************************************************
* gvlnGetPortVlanPorts
*
* DESCRIPTION:
* This routine gets the port VLAN group port membership list.
*
* INPUTS:
* port - logical port number to set.
*
* OUTPUTS:
* memPorts - array of logical ports in the same vlan.
* memPortsLen - number of members in memPorts array
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gvlnGetPortVlanPorts
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_LPORT memPorts[],
OUT GT_U8 *memPortsLen
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
GT_U8 i;
DBG_INFO(("gvlnGetPortVlanPorts Called.\n"));
if((memPorts == NULL) || (memPortsLen == NULL))
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
phyPort = GT_LPORT_2_PORT(port);
/* memPortsLen = 3 for fullsail, =7 for others */
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PORT_VLAN_MAP,0,dev->maxPorts,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
i = 0;
for(phyPort = 0; phyPort < dev->maxPorts; phyPort++)
{
if(!GT_IS_PORT_SET(dev->validPortVec, phyPort))
continue;
if(((1 << phyPort) & data) != 0)
{
memPorts[i] = GT_PORT_2_LPORT(phyPort);
i++;
}
}
*memPortsLen = i;
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpcsGetCommaDet
*
* DESCRIPTION:
* This routine retrieves Comma Detection status in PCS
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* state - GT_TRUE for Comma Detected 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 gpcsGetCommaDet
(
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(("gpcsGetCommaDet Called.\n"));
/* check if the given Switch supports this feature. */
if (!IS_IN_DEV_GROUP(dev,DEV_PCS))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
if (IS_IN_DEV_GROUP(dev,DEV_PCS_LINK))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
/* Get the CommaDet bit. */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PCS_CONTROL,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;
}
/*******************************************************************************
* gvlnGetPortUserPriLsb
*
* DESCRIPTION:
* This routine gets the user priority (VPT) LSB bit.
*
* INPUTS:
* port - logical port number to set.
*
* OUTPUTS:
* userPriLsb - GT_TRUE for 1, GT_FALSE for 0.
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gvlnGetPortUserPriLsb
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_BOOL *userPriLsb
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
DBG_INFO(("gvlnGetPortUserPriLsb Called.\n"));
/* Gigabit Switch does not support this status. */
if ((IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH)) ||
(IS_IN_DEV_GROUP(dev,DEV_ENHANCED_FE_SWITCH)) ||
(IS_IN_DEV_GROUP(dev,DEV_FE_AVB_FAMILY)))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
if(userPriLsb == NULL)
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
phyPort = GT_LPORT_2_PORT(port);
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PVID,13,1,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
BIT_2_BOOL(data,*userPriLsb);
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpavGetIngressMonitor
*
* DESCRIPTION:
* This routine gets the Ingress Monitor bit in the PAV.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* mode - the ingress monitor bit in the PAV
* GT_FALSE: Ingress Monitor enabled
* GT_TRUE: Ingress Monitor disabled
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* COMMENTS:
*
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gpavGetIngressMonitor
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_BOOL *mode
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
DBG_INFO(("grcGetIngressMonitor Called.\n"));
if(mode == NULL)
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
phyPort = GT_LPORT_2_PORT(port);
/* check if device supports this feature */
if((retVal = IS_VALID_API_CALL(dev,phyPort, DEV_PORT_MONITORING)) != GT_OK )
return retVal;
if (!IS_IN_DEV_GROUP(dev,DEV_ENABLE_MONITORING))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
retVal = hwGetPortRegField(dev,phyPort,QD_REG_PORT_ASSOCIATION,15,1,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
BIT_2_BOOL(data,*mode);
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpcsGetForceSpeed
*
* DESCRIPTION:
* This routine retrieves Force Speed value
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* state - GT_PORT_FORCED_SPEED_MODE (10, 100, 1000, or no force speed)
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gpcsGetForceSpeed
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_PORT_FORCED_SPEED_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(("gpcsGetForceSpeed Called.\n"));
/* check if the given Switch supports this feature. */
if (!IS_IN_DEV_GROUP(dev,DEV_FORCE_WITH_VALUE))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
/* Get the ForceSpeed bits. */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PCS_CONTROL,0,2,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
}
else
{
DBG_INFO(("OK.\n"));
}
*mode = data;
/* return */
return retVal;
}
/*******************************************************************************
* gpavGetPAV
*
* DESCRIPTION:
* This routine gets the Port Association Vector
*
* INPUTS:
* port - logical port number.
*
* OUTPUTS:
* pav - Port Association Vector
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gpavGetPAV
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_U16 *pav
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U16 data; /* The register's read data. */
GT_U8 phyPort; /* Physical port. */
DBG_INFO(("gpavGetPAV Called.\n"));
phyPort = GT_LPORT_2_PORT(port);
/* check if device supports this feature */
if((retVal = IS_VALID_API_CALL(dev,phyPort, DEV_PORT_MONITORING)) != GT_OK )
return retVal;
if(pav == NULL)
{
DBG_INFO(("Failed.\n"));
return GT_BAD_PARAM;
}
retVal = hwGetPortRegField(dev,phyPort,(GT_U8)QD_REG_PORT_ASSOCIATION,0,dev->maxPorts,&data );
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
/*
* translate Physical Port Vector to Logical Port Vector.
*/
*pav = (GT_U16)GT_PORTVEC_2_LPORTVEC(data);
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* geventGetAgeIntEn
*
* DESCRIPTION:
* This routine gets Age Interrupt Enable for the port.
* When it's enabled, ATU Age Violation interrupts from this port are enabled.
* An Age Violation will occur anytime a port is Locked(gprtSetLockedPort)
* and the ingressing frame's SA is contained in the ATU as a non-Static
* entry with a EntryState less than 0x4.
*
* INPUTS:
* port - the logical port number
* mode - GT_TRUE to enable Age Interrupt,
* GT_FALUSE to disable
*
* OUTPUTS:
* None.
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS geventGetAgeIntEn
(
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 */
DBG_INFO(("geventGetAgeIntEn Called.\n"));
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
if (!IS_IN_DEV_GROUP(dev,DEV_PORT_BASED_AGE_INT))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* Get Age Interrupt Enable Mode. */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_ASSOCIATION,11,1,&data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
}
else
{
DBG_INFO(("OK.\n"));
}
BIT_2_BOOL(data, *mode);
return retVal;
}
/*******************************************************************************
* gprtGetPolicy
*
* DESCRIPTION:
* This routine gets the Policy of the given policy type.
* Supported Policies are defined as GT_FRAME_POLICY as follows:
* FRAME_POLICY_NONE - normal frame switching
* FRAME_POLICY_MIRROR - mirror (copy) frame to MirrorDest port
* FRAME_POLICY_TRAP - trap(re-direct) frame to the CPUDest port
* FRAME_POLICY_DISCARD - discard(filter) the frame
* Supported Policy types are defined as GT_POLICY_TYPE:
* POLICY_TYPE_DA - DA Policy Mapping
* DA Policy Mapping occurs when the DA of a frame is contained in
* the ATU address database with an Entry State that indicates Policy.
* POLICY_TYPE_SA - SA Policy Mapping
* SA Policy Mapping occurs when the SA of a frame is contained in
* the ATU address database with an Entry State that indicates Policy.
* POLICY_TYPE_VTU - VTU Policy Mapping
* VTU Policy Mapping occurs when the VID of a frame is contained in
* the VTU database with the VidPolicy is enabled.
* POLICY_TYPE_ETYPE - EtherType Policy Mapping
* EType Policy Mapping occurs when the EtherType of a frame matches
* the PortEType (see gprtSetPortEType API)
* POLICY_TYPE_PPPoE - PPPoE Policy Mapping
* PPPoE Policy Mapping occurs when the EtherType of a frame matches 0x8863
* POLICY_TYPE_VBAS - VBAS Policy Mapping
* VBAS Policy Mapping occurs when the EtherType of a frame matches 0x8200
* POLICY_TYPE_OPT82 - DHCP Option 82 Policy Mapping
* DHCP Option 82 Policy Mapping occurs when the ingressing frame is an
* IPv4 UDP with a UDP Destination port = 0x0043 or 0x0044, or an
* IPv6 UDP with a UDP Destination port = 0x0223 or 0x0222
* POLICY_TYPE_UDP - UDP Policy Mapping
* UDP Policy Mapping occurs when the ingressing frame is
* a Broadcast IPv4 UDP or a Multicast IPv6 UDP.
*
* INPUTS:
* port - logical port number.
* type - policy type (GT_POLICY_TYPE)
*
* OUTPUTS:
* policy - policy (GT_FRAME_POLICY)
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_BAD_PARAM - on bad parameters
* GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
* GalTis:
*
*******************************************************************************/
GT_STATUS gprtGetPolicy
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
IN GT_POLICY_TYPE type,
OUT GT_FRAME_POLICY *policy
)
{
GT_STATUS retVal; /* Functions return value. */
GT_U8 hwPort; /* Physical port. */
GT_U8 offset;
GT_U16 data;
DBG_INFO(("gprtGetPolicy Called.\n"));
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
/* check if device supports this feature */
if (!IS_IN_DEV_GROUP(dev,DEV_POLICY))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
switch (type)
{
case POLICY_TYPE_DA:
offset = 14;
break;
case POLICY_TYPE_SA:
offset = 12;
break;
case POLICY_TYPE_VTU:
offset = 10;
break;
case POLICY_TYPE_ETYPE:
offset = 8;
break;
case POLICY_TYPE_PPPoE:
offset = 6;
break;
case POLICY_TYPE_VBAS:
offset = 4;
break;
case POLICY_TYPE_OPT82:
offset = 2;
break;
case POLICY_TYPE_UDP:
offset = 0;
break;
default:
DBG_INFO(("Bad Parameter\n"));
return GT_BAD_PARAM;
}
retVal = hwGetPortRegField(dev,hwPort, QD_REG_POLICY_CONTROL, offset, 2, &data);
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
return retVal;
}
*policy = (GT_FRAME_POLICY)data;
DBG_INFO(("OK.\n"));
return GT_OK;
}
/*******************************************************************************
* gpcsGetRGMIITimingDelay
*
* DESCRIPTION:
* RGMII receive/transmit Timing Control. This api adds delay to RXCLK for
* IND inputs and GTXCLK for OUTD outputs when port is in RGMII mode.
* Change to this bit are disruptive to normal operation. Hence any changes
* to this register must be done only while the port's link is down.
*
* INPUTS:
* port - the logical port number.
*
* OUTPUTS:
* rxmode - GT_FALSE for default setup, GT_TRUE for adding delay to rxclk
* txmode - GT_FALSE for default setup, GT_TRUE for adding delay to txclk
*
* RETURNS:
* GT_OK - on success
* GT_FAIL - on error
* GT_NOT_SUPPORTED - if current device does not support this feature.
*
* COMMENTS:
*
*******************************************************************************/
GT_STATUS gpcsGetRGMIITimingDelay
(
IN GT_QD_DEV *dev,
IN GT_LPORT port,
OUT GT_BOOL *rxmode,
OUT GT_BOOL *txmode
)
{
GT_U16 data;
GT_STATUS retVal; /* Functions return value. */
GT_U8 hwPort; /* the physical port number */
DBG_INFO(("gpcsGetRGMIITimingDelay Called.\n"));
if (!IS_IN_DEV_GROUP(dev,DEV_RGMII_TIMING))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
/* translate LPORT to hardware port */
hwPort = GT_LPORT_2_PORT(port);
if (hwPort < (dev->maxPorts - 2))
{
DBG_INFO(("GT_NOT_SUPPORTED\n"));
return GT_NOT_SUPPORTED;
}
if(((dev->devName==DEV_88E6165)||(dev->devName==DEV_88E6161))&&
((hwPort==4)||((hwPort==5)&&(dev->revision==2)))) /* 88E6123 revision A2 */
{
if(hwWritePortReg(dev,4,0x1A,0x81E7) != GT_OK)
{
DBG_INFO(("Failed.\n"));
return GT_FAIL;
}
if(hwReadPortReg(dev,5,0x1A,&data) != GT_OK)
{
DBG_INFO(("Failed.\n"));
return GT_FAIL;
}
if((hwPort==5)&&(dev->revision==2)) /* 88E6123 revision A2 */
{
*rxmode = (data & 0x2)?GT_TRUE:GT_FALSE;
*txmode = (data & 0x1)?GT_TRUE:GT_FALSE;
}
else
{
*rxmode = (data & 0x10)?GT_TRUE:GT_FALSE;
*txmode = (data & 0x8)?GT_TRUE:GT_FALSE;
}
}
else
{
/* Get the register bit(s). */
retVal = hwGetPortRegField(dev,hwPort, QD_REG_PCS_CONTROL,14,2,&data);
*rxmode = (data & 0x2)?GT_TRUE:GT_FALSE;
*txmode = (data & 0x1)?GT_TRUE:GT_FALSE;
if(retVal != GT_OK)
{
DBG_INFO(("Failed.\n"));
}
else
{
DBG_INFO(("OK.\n"));
}
}
/* return */
return retVal;
}
