| #include <Copyright.h> |
| |
| /******************************************************************************** |
| * gtEvents.c |
| * |
| * DESCRIPTION: |
| * API definitions for system interrupt events handling. |
| * |
| * DEPENDENCIES: |
| * |
| * FILE REVISION NUMBER: |
| * $Revision: 3 $ |
| *******************************************************************************/ |
| |
| #include <msApi.h> |
| #include <gtHwCntl.h> |
| #include <gtDrvSwRegs.h> |
| |
| /******************************************************************************* |
| * eventSetActive |
| * |
| * DESCRIPTION: |
| * This routine enables/disables the receive of an hardware driven event. |
| * |
| * INPUTS: |
| * eventType - the event type. any combination of the folowing: |
| * GT_STATS_DONE, GT_VTU_PROB, GT_VTU_DONE, GT_ATU_FULL(or GT_ATU_PROB), |
| * GT_ATU_DONE, GT_PHY_INTERRUPT, GT_EE_INTERRUPT, GT_DEVICE_INT, |
| * and GT_AVB_INTERRUPT |
| * |
| * OUTPUTS: |
| * None. |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * |
| * COMMENTS: |
| * Each switch device has its own set of event Types. Please refer to the |
| * device datasheet for the list of event types that the device supports. |
| * |
| *******************************************************************************/ |
| GT_STATUS eventSetActive |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_U32 eventType |
| ) |
| { |
| GT_STATUS retVal; |
| GT_U16 data; |
| GT_U16 intMask; |
| GT_U8 len; |
| |
| DBG_INFO(("eventSetActive Called.\n")); |
| |
| data = (GT_U16) eventType; |
| len = 9; |
| |
| if ((IS_IN_DEV_GROUP(dev,DEV_EXTERNAL_PHY_ONLY)) || |
| (IS_IN_DEV_GROUP(dev,DEV_DEV_PHY_INTERRUPT))) |
| { |
| intMask = GT_NO_INTERNAL_PHY_INT_MASK; |
| } |
| else |
| { |
| intMask = GT_INT_MASK; |
| } |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_AVB_INTERRUPT)) |
| { |
| intMask &= ~GT_AVB_INT; |
| len = 8; |
| } |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_DEVICE_INTERRUPT)) |
| { |
| intMask &= ~GT_DEVICE_INT; |
| len = 7; |
| } |
| |
| |
| if(data & ~intMask) |
| { |
| DBG_INFO(("Invalid event type.\n")); |
| return GT_FAIL; |
| } |
| |
| /* Set the IntEn bit. */ |
| retVal = hwSetGlobalRegField(dev,QD_REG_GLOBAL_CONTROL,0,len,data); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| DBG_INFO(("OK.\n")); |
| return GT_OK; |
| } |
| |
| |
| /******************************************************************************* |
| * eventGetIntStatus |
| * |
| * DESCRIPTION: |
| * This routine reads an hardware driven event status. |
| * |
| * INPUTS: |
| * None. |
| * |
| * OUTPUTS: |
| * intCause - It provides the source of interrupt of the following: |
| * GT_STATS_DONE, GT_VTU_PROB, GT_VTU_DONE, GT_ATU_FULL, |
| * GT_ATU_DONE, GT_PHY_INTERRUPT, GT_EE_INTERRUPT, GT_DEVICE_INT, |
| * and GT_AVB_INTERRUPT |
| * For Gigabit Switch, GT_ATU_FULL is replaced with GT_ATU_PROB and |
| * if there is no internal phy, GT_PHY_INTERRUPT is not supported. |
| * |
| * RETURNS: |
| * GT_OK - read success. |
| * GT_FAIL - otherwise |
| * |
| * COMMENTS: |
| * Each switch device has its own set of event Types. Please refer to the |
| * device datasheet for the list of event types that the device supports. |
| * |
| *******************************************************************************/ |
| GT_STATUS eventGetIntStatus |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_U16 *intCause |
| ) |
| { |
| GT_STATUS retVal; /* Function calls return value. */ |
| GT_U8 len; |
| |
| if (IS_IN_DEV_GROUP(dev,DEV_AVB_INTERRUPT)) |
| len = 9; |
| else if (IS_IN_DEV_GROUP(dev,DEV_DEVICE_INTERRUPT)) |
| len = 8; |
| else |
| len = 7; |
| |
| retVal = hwGetGlobalRegField(dev,QD_REG_GLOBAL_STATUS,0,len,intCause); |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gvtuGetIntStatus |
| * |
| * DESCRIPTION: |
| * Check to see if a specific type of VTU interrupt occured |
| * |
| * INPUTS: |
| * intType - the type of interrupt which causes an interrupt. |
| * any combination of |
| * GT_MEMEBER_VIOLATION, |
| * GT_MISS_VIOLATION, |
| * GT_FULL_VIOLATION |
| * |
| * OUTPUTS: |
| * None. |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * |
| * COMMENTS: |
| * FULL_VIOLATION is not supported by all switch devices. |
| * Please refer to the device datasheet. |
| * |
| *******************************************************************************/ |
| GT_STATUS gvtuGetIntStatus |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_VTU_INT_STATUS *vtuIntStatus |
| ) |
| { |
| GT_STATUS retVal; |
| |
| DBG_INFO(("gvtuGetIntStatus Called.\n")); |
| |
| /* check if device supports this feature */ |
| if((IS_VALID_API_CALL(dev,1, DEV_802_1Q)) != GT_OK ) |
| return GT_FAIL; |
| |
| if (IS_IN_DEV_GROUP(dev,DEV_GIGABIT_SWITCH)) |
| { |
| retVal = gvtuGetViolation2(dev,vtuIntStatus); |
| } |
| else if (IS_IN_DEV_GROUP(dev,DEV_ENHANCED_FE_SWITCH)) |
| { |
| retVal = gvtuGetViolation3(dev,vtuIntStatus); |
| } |
| else |
| { |
| retVal = gvtuGetViolation(dev,vtuIntStatus); |
| } |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| * gatuGetIntStatus |
| * |
| * DESCRIPTION: |
| * Check to see if a specific type of ATU interrupt occured |
| * |
| * INPUTS: |
| * intType - the type of interrupt which causes an interrupt. |
| * any combination of |
| * GT_AGE_OUT_VIOLATION, |
| * GT_AGE_VIOLATION, |
| * GT_MEMEBER_VIOLATION, |
| * GT_MISS_VIOLATION, |
| * GT_FULL_VIOLATION |
| * |
| * OUTPUTS: |
| * None. |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| |
| GT_STATUS gatuGetIntStatus |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_ATU_INT_STATUS *atuIntStatus |
| ) |
| { |
| GT_STATUS retVal; |
| |
| DBG_INFO(("gatuGetIntStatus Called.\n")); |
| |
| /* check if device supports this feature */ |
| if (!IS_IN_DEV_GROUP(dev,DEV_GIGABIT_MANAGED_SWITCH|DEV_ENHANCED_FE_SWITCH)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| retVal = gatuGetViolation(dev,atuIntStatus); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * geventGetDevIntStatus |
| * |
| * DESCRIPTION: |
| * Check to see which device interrupts (WatchDog, JamLimit, Duplex Mismatch, |
| * SERDES Link Int, and Phy Int) have occurred. |
| * |
| * INPUTS: |
| * intType - the type of interrupt which causes an interrupt. |
| * any combination of |
| * GT_DEV_INT_WATCHDOG, |
| * GT_DEV_INT_JAMLIMIT, |
| * GT_DEV_INT_DUPLEX_MISMATCH, |
| * GT_DEV_INT_SERDES_LINK |
| * GT_DEV_INT_PHY |
| * port - logical port where GT_DEV_INT_DUPLEX_MISMATCH occurred. |
| * valid only if GT_DEV_INT_DUPLEX_MISMATCH is set in intType. |
| * linkInt - SERDES port list where GT_DEV_INT_SERDES_LINK interrupt is |
| * asserted. It's in vector format, Bit 10 is for port 10, |
| * Bit 9 is for port 9, etc. |
| * valid only if GT_DEV_INT_SERDES_LINK bit is set in intType. |
| * These bits are only valid of the port that is in 1000Base-X mode. |
| * phyInt - port list where GT_DEV_INT_PHY interrupt is asserted. |
| * It's in vector format, Bit 0 is for port 0, Bit 1 is for port 1, etc. |
| * valid only if GT_DEV_INT_PHY bit is set in intType. |
| * |
| * OUTPUTS: |
| * None. |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| |
| GT_STATUS geventGetDevIntStatus |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_DEV_INT_STATUS *devIntStatus |
| ) |
| { |
| GT_STATUS retVal; |
| GT_U16 data, hwPort; |
| |
| DBG_INFO(("geventGetDevIntStatus Called.\n")); |
| |
| /* check if device supports this feature */ |
| if (!IS_IN_DEV_GROUP(dev,DEV_DEVICE_INTERRUPT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| devIntStatus->devIntCause = 0; |
| |
| retVal = hwReadGlobal2Reg(dev,QD_REG_DEVINT_SOURCE,&data); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| |
| /* check SERDES Link Int and Phy Int, if applicable */ |
| if (IS_IN_DEV_GROUP(dev,DEV_DEVICE_INT_TYPE1)) |
| { |
| /* check SERDES Link Int */ |
| if (data & (0x7 << 8)) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_SERDES_LINK; |
| devIntStatus->linkInt = GT_PORTVEC_2_LPORTVEC((data & (7<<8))); |
| } |
| } |
| else /* DEV_DEVICE_INT_TYPE2 */ |
| { |
| if (data & (0x3 << 11)) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_SERDES_LINK; |
| devIntStatus->linkInt = GT_PORTVEC_2_LPORTVEC((data & (0x3 << 11)) >> 7); |
| } |
| |
| if (data & 0x1F) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_PHY; |
| devIntStatus->phyInt = GT_PORTVEC_2_LPORTVEC((data & 0x1F)); |
| } |
| } |
| |
| if (data & QD_DEV_INT_DUPLEX_MISMATCH) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_DUPLEX_MISMATCH; |
| |
| /* read port that causes the interrupt */ |
| retVal = hwGetGlobal2RegField(dev, QD_REG_WD_CONTROL, 12, 4, &hwPort); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| |
| /* re-arm the interrupt event */ |
| retVal = hwSetGlobal2RegField(dev, QD_REG_WD_CONTROL, 12, 4, 0xF); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| |
| devIntStatus->port = GT_PORT_2_LPORT((GT_U8)hwPort); |
| } |
| |
| if (data & QD_DEV_INT_WATCHDOG) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_WATCHDOG; |
| } |
| |
| if (data & QD_DEV_INT_JAMLIMIT) |
| { |
| devIntStatus->devIntCause |= GT_DEV_INT_JAMLIMIT; |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * geventSetAgeIntEn |
| * |
| * DESCRIPTION: |
| * This routine enables/disables Age Interrupt for a 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 geventSetAgeIntEn |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_LPORT port, |
| IN GT_BOOL mode |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| GT_U8 hwPort; /* the physical port number */ |
| |
| DBG_INFO(("geventSetAgeIntEn 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; |
| } |
| |
| /* translate BOOL to binary */ |
| BOOL_2_BIT(mode, data); |
| |
| /* Set Age Interrupt Enable Mode. */ |
| retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_ASSOCIATION,11,1,data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| * 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; |
| } |
| |
| |
| /******************************************************************************* |
| * geventSetAgeOutIntEn |
| * |
| * DESCRIPTION: |
| * Interrupt on Age Out. When aging is enabled, all non-static address |
| * entries in the ATU's address database are periodically aged. |
| * When this feature is set to GT_TRUE and an entry associated with this |
| * port is aged out, an AgeOutViolation will be captured for that entry. |
| * |
| * INPUTS: |
| * port - the logical port number |
| * mode - GT_TRUE to enable Age Out 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 geventSetAgeOutIntEn |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_LPORT port, |
| IN GT_BOOL mode |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| GT_U8 hwPort; /* the physical port number */ |
| |
| DBG_INFO(("geventSetAgeOutIntEn Called.\n")); |
| |
| /* translate LPORT to hardware port */ |
| hwPort = GT_LPORT_2_PORT(port); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_AGE_OUT_INT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* translate BOOL to binary */ |
| BOOL_2_BIT(mode, data); |
| |
| /* Set Age Out Interrupt Enable Mode. */ |
| retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_ASSOCIATION,14,1,data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| * geventGetAgeOutIntEn |
| * |
| * DESCRIPTION: |
| * Interrupt on Age Out. When aging is enabled, all non-static address |
| * entries in the ATU's address database are periodically aged. |
| * When this feature is set to GT_TRUE and an entry associated with this |
| * port is aged out, an AgeOutViolation will be captured for that entry. |
| * |
| * INPUTS: |
| * port - the logical port number |
| * |
| * OUTPUTS: |
| * mode - GT_TRUE, if Age Out Interrupt is enabled |
| * GT_FALUSE, otherwise |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS geventGetAgeOutIntEn |
| ( |
| 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(("geventGetAgeOutIntEn Called.\n")); |
| |
| /* translate LPORT to hardware port */ |
| hwPort = GT_LPORT_2_PORT(port); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_AGE_OUT_INT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get Age Out Interrupt Enable Mode. */ |
| retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_ASSOCIATION,14,1,&data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| BIT_2_BOOL(data, *mode); |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * geventSetOverLimitInt |
| * |
| * DESCRIPTION: |
| * This routine enables/disables Over Limit Interrupt for a port. |
| * If it's enabled, an ATU Miss violation will be generated when port auto |
| * learn reached the limit(refer to gfdbGetPortAtuLimitReached API). |
| * |
| * INPUTS: |
| * port - the logical port number |
| * mode - GT_TRUE to enable Over Limit 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 geventSetOverLimitInt |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_LPORT port, |
| IN GT_BOOL mode |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| GT_U8 hwPort; /* the physical port number */ |
| |
| DBG_INFO(("geventSetOverLimitInt Called.\n")); |
| |
| /* translate LPORT to hardware port */ |
| hwPort = GT_LPORT_2_PORT(port); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_ATU_LIMIT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* translate BOOL to binary */ |
| BOOL_2_BIT(mode, data); |
| |
| /* Set Over Limit Interrupt Enable Mode. */ |
| retVal = hwSetPortRegField(dev,hwPort, QD_REG_PORT_ATU_CONTROL, 13, 1, data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| * geventGetOverLimitInt |
| * |
| * DESCRIPTION: |
| * This routine enables/disables Over Limit Interrupt for a port. |
| * If it's enabled, an ATU Miss violation will be generated when port auto |
| * learn reached the limit(refer to gfdbSetPortAtuLearnLimit API). |
| * |
| * INPUTS: |
| * port - the logical port number |
| * |
| * OUTPUTS: |
| * mode - GT_TRUE to enable Over Limit Interrupt, |
| * GT_FALUSE to disable |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS geventGetOverLimitInt |
| ( |
| 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(("geventGetOverLimitInt Called.\n")); |
| |
| /* translate LPORT to hardware port */ |
| hwPort = GT_LPORT_2_PORT(port); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_ATU_LIMIT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Set Over Limit Interrupt Enable Mode. */ |
| retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_ATU_CONTROL, 13, 1, &data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| BIT_2_BOOL(data, *mode); |
| |
| return retVal; |
| } |
| |
| /******************************************************************************* |
| * geventGetPortAtuLimitReached |
| * |
| * DESCRIPTION: |
| * This routine checks if learn limit has been reached. |
| * When it reached, the port can no longer auto learn any more MAC addresses |
| * because the address learn limit set on this port has been reached. |
| * |
| * INPUTS: |
| * port - logical port number |
| * |
| * OUTPUTS: |
| * limit - GT_TRUE, if limit has been reached |
| * GT_FALSE, otherwise |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * None. |
| * |
| * |
| *******************************************************************************/ |
| GT_STATUS geventGetPortAtuLimitReached |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_LPORT port, |
| IN GT_BOOL *limit |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| GT_U8 hwPort; /* the physical port number */ |
| |
| DBG_INFO(("geventGetPortAtuLimitReached Called.\n")); |
| |
| /* translate LPORT to hardware port */ |
| hwPort = GT_LPORT_2_PORT(port); |
| |
| /* Check device if this feature is supported. */ |
| if (!IS_IN_DEV_GROUP(dev,DEV_ATU_LIMIT)) |
| { |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get the LimitReached bit. */ |
| retVal = hwGetPortRegField(dev,hwPort, QD_REG_PORT_ATU_CONTROL, 14, 1, &data); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| |
| BIT_2_BOOL(data, *limit); |
| |
| DBG_INFO(("OK.\n")); |
| return GT_OK; |
| } |
| |
| /******************************************************************************* |
| * eventSetDevInt |
| * |
| * DESCRIPTION: |
| * Device Interrupt. |
| * The following device interrupts are supported: |
| * GT_DEV_INT_WATCHDOG - |
| * WatchDog event interrupt (WatchDog event can be configured with |
| * gwdSetEvent API) |
| * GT_DEV_INT_JAMLIMIT - |
| * any of the ports detect an Ingress Jam Limit violation |
| * (see gprtSetPauseLimitIn API) |
| * GT_DEV_INT_DUPLEX_MISMATCH - |
| * any of the ports detect a duplex mismatch (i.e., the local port is |
| * in half duplex mode while the link partner is in full duplex mode) |
| * GT_DEV_INT_SERDES_LINK - |
| * SERDES link change interrupt. |
| * An interrupt occurs when a SERDES port changes link status |
| * (link up or link down) |
| * GT_DEV_INT_PHY - Phy interrupt. |
| * |
| * If any of the above events is enabled, GT_DEVICE_INT interrupt will |
| * be asserted by the enabled event when GT_DEV_INT is enabled with |
| * eventSetActive API. |
| * |
| * INPUTS: |
| * devInt - GT_DEV_INT |
| * |
| * 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 eventSetDevInt |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_DEV_EVENT *devInt |
| ) |
| { |
| GT_U16 data, event; |
| GT_U16 serdesMask, phyMask, mask; |
| GT_U32 pList; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("eventSetDevInt Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_DEVICE_INTERRUPT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| event = (GT_U16)devInt->event; |
| |
| if (IS_IN_DEV_GROUP(dev,DEV_DEVICE_INT_TYPE1)) |
| { |
| serdesMask = mask = 7 << 8; /* SERDES Port List */ |
| phyMask = 0; |
| } |
| else |
| { |
| serdesMask = mask = 3 << 11; /* SERDES Port List */ |
| mask |= 0x1F; /* Phy list */ |
| phyMask = 0x1F; |
| } |
| mask |= QD_DEV_INT_WATCHDOG | QD_DEV_INT_JAMLIMIT | QD_DEV_INT_DUPLEX_MISMATCH; |
| |
| data = 0; |
| |
| if (event & GT_DEV_INT_SERDES_LINK) |
| { |
| /* check for valid SERDES Port List */ |
| if (IS_IN_DEV_GROUP(dev,DEV_DEVICE_INT_TYPE1)) |
| { |
| pList = GT_LPORTVEC_2_PORTVEC(devInt->portList); |
| if ((GT_U16)pList & (~serdesMask)) |
| { |
| DBG_INFO(("GT_BAD_PARAM portList\n")); |
| return GT_BAD_PARAM; |
| } |
| data = (GT_U16)pList; |
| } |
| else |
| { |
| pList = GT_LPORTVEC_2_PORTVEC(devInt->portList); |
| pList <<= 7; |
| if ((GT_U16)pList & (~serdesMask)) |
| { |
| DBG_INFO(("GT_BAD_PARAM portList\n")); |
| return GT_BAD_PARAM; |
| } |
| data = (GT_U16)pList; |
| } |
| } |
| |
| if (event & GT_DEV_INT_PHY) |
| { |
| /* check for valid Phy List */ |
| if (IS_IN_DEV_GROUP(dev,DEV_DEVICE_INT_TYPE1)) |
| { |
| DBG_INFO(("GT_BAD_PARAM: PHY Int not supported.\n")); |
| return GT_BAD_PARAM; |
| } |
| else |
| { |
| pList = GT_LPORTVEC_2_PORTVEC(devInt->phyList); |
| if ((GT_U16)pList & (~phyMask)) |
| { |
| DBG_INFO(("GT_BAD_PARAM phyList\n")); |
| return GT_BAD_PARAM; |
| } |
| |
| data |= (GT_U16)pList; |
| } |
| } |
| |
| if (event & GT_DEV_INT_WATCHDOG) |
| { |
| data |= QD_DEV_INT_WATCHDOG; |
| } |
| |
| if (event & GT_DEV_INT_JAMLIMIT) |
| { |
| data |= QD_DEV_INT_JAMLIMIT; |
| } |
| |
| if (event & GT_DEV_INT_DUPLEX_MISMATCH) |
| { |
| data |= QD_DEV_INT_DUPLEX_MISMATCH; |
| } |
| |
| if (data & (~mask)) |
| { |
| DBG_INFO(("GT_BAD_PARAM portList\n")); |
| return GT_BAD_PARAM; |
| } |
| |
| if (data & GT_DEV_INT_DUPLEX_MISMATCH) |
| { |
| retVal = hwSetGlobal2RegField(dev, QD_REG_WD_CONTROL, 12, 4, 0xF); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| } |
| |
| /* Set the related bit. */ |
| retVal = hwSetGlobal2RegBits(dev,QD_REG_DEVINT_MASK, mask, data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdSetEvent |
| * |
| * DESCRIPTION: |
| * Watch Dog Event. |
| * The following Watch Dog events are supported: |
| * GT_WD_QC - Queue Controller Watch Dog enable. |
| * When enabled, the QC's watch dog circuit checks for link |
| * list errors and any errors found in the QC. |
| * GT_WD_EGRESS - Egress Watch Dog enable. |
| * When enabled, each port's egress circuit checks for problems |
| * between the port and the Queue Controller. |
| * GT_WD_FORCE - Force a Watch Dog event. |
| * |
| * If any of the above events is enabled, GT_DEVICE_INT interrupt will |
| * be asserted by the enabled WatchDog event when GT_DEV_INT_WATCHDOG is |
| * enabled with eventSetDevActive API and GT_DEV_INT is enabled with |
| * eventSetActive API. |
| * |
| * INPUTS: |
| * wdEvent - Watch Dog Events |
| * |
| * 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 gwdSetEvent |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_U32 wdEvent |
| ) |
| { |
| GT_U16 data, mask; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdSetEvent Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| mask = (1 << 5) | (1 << 3) | (1 << 2); |
| data = 0; |
| |
| if (wdEvent & GT_WD_QC) |
| { |
| data |= (1 << 5); |
| } |
| |
| if (wdEvent & GT_WD_EGRESS) |
| { |
| data |= (1 << 3); |
| } |
| |
| if (wdEvent & GT_WD_FORCE) |
| { |
| data |= (1 << 2); |
| } |
| |
| /* Set the related bit. */ |
| retVal = hwSetGlobal2RegBits(dev,QD_REG_WD_CONTROL, mask, data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdSetSWResetOnWD |
| * |
| * DESCRIPTION: |
| * SWReset on Watch Dog Event. |
| * When this feature is enabled, any enabled watch dog event (gwdSetEvent API) |
| * will automatically reset the switch core's datapath just as if gsysSwReset |
| * API is called. |
| * |
| * The Watch Dog History (gwdGetHistory API) won't be cleared by this |
| * automatic SWReset. This allows the user to know if any watch dog event |
| * ever occurred even if the swich is configured to automatically recover |
| * from a watch dog. |
| * |
| * When this feature is disabled, enabled watch dog events will not cause a |
| * SWReset. |
| * |
| * INPUTS: |
| * en - GT_TRUE to enable SWReset on WD |
| * 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 gwdSetSWResetOnWD |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_BOOL en |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdSetSWResetOnWD Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| BOOL_2_BIT(en,data); |
| |
| /* Set the related bit. */ |
| retVal = hwSetGlobal2RegField(dev,QD_REG_WD_CONTROL, 0, 1, data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdGetSWResetOnWD |
| * |
| * DESCRIPTION: |
| * SWReset on Watch Dog Event. |
| * When this feature is enabled, any enabled watch dog event (gwdSetEvent API) |
| * will automatically reset the switch core's datapath just as if gsysSwReset |
| * API is called. |
| * |
| * The Watch Dog History (gwdGetHistory API) won't be cleared by this |
| * automatic SWReset. This allows the user to know if any watch dog event |
| * ever occurred even if the swich is configured to automatically recover |
| * from a watch dog. |
| * |
| * When this feature is disabled, enabled watch dog events will not cause a |
| * SWReset. |
| * |
| * INPUTS: |
| * None. |
| * |
| * OUTPUTS: |
| * en - GT_TRUE, if SWReset on WD is enabled |
| * GT_FALUSE, otherwise |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS gwdGetSWResetOnWD |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_BOOL *en |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdSetSWResetOnWD Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get the related bit. */ |
| retVal = hwGetGlobal2RegField(dev,QD_REG_WD_CONTROL, 0, 1, &data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| BIT_2_BOOL(data, *en); |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdGetHistory |
| * |
| * DESCRIPTION: |
| * This routine retrieves Watch Dog history. They are |
| * |
| * wdEvent - |
| * When it's set to GT_TRUE, some enabled Watch Dog event occurred. |
| * The following events are possible: |
| * QC WatchDog Event (GT_WD_QC) |
| * Egress WatchDog Event (GT_WD_EGRESS) |
| * Forced WatchDog Event (GT_WD_FORCE) |
| * egressEvent - |
| * If any port's egress logic detects an egress watch dog issue, |
| * this field is set to GT_TRUE, regardless of the enabling GT_WD_EGRESS |
| * event. |
| * |
| * INPUTS: |
| * None. |
| * |
| * OUTPUTS: |
| * history - GT_WD_EVENT_HISTORY structure |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS gwdGetHistory |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_WD_EVENT_HISTORY *history |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdSetSWResetOnWD Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get the related bit. */ |
| retVal = hwReadGlobal2Reg(dev,QD_REG_WD_CONTROL,&data); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| return retVal; |
| } |
| |
| if (data & (1 << 4)) |
| { |
| history->egressEvent = GT_TRUE; |
| } |
| else |
| { |
| history->egressEvent = GT_FALSE; |
| } |
| |
| if (data & (1 << 1)) |
| { |
| history->wdEvent = GT_TRUE; |
| } |
| else |
| { |
| history->wdEvent = GT_FALSE; |
| } |
| |
| DBG_INFO(("OK.\n")); |
| return GT_OK; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdSetRMUTimeOut |
| * |
| * DESCRIPTION: |
| * Remote Management Timeout. When this bit is set to a one the Remote |
| * Management Unit(RMU) will timeout on Wait on Bit commands. If the bit that |
| * is being tested has not gone to the specified value after 1 sec. has elapsed |
| * the Wait on Bit command will be terminated and the Response frame will be |
| * sent without any further processing. |
| * |
| * When this bit is cleared to a zero the Wait on Bit command will wait |
| * until the bit that is being tested has changed to the specified value. |
| * |
| * INPUTS: |
| * en - GT_TRUE to enable RMU Timeout |
| * 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 gwdSetRMUTimeOut |
| ( |
| IN GT_QD_DEV *dev, |
| IN GT_BOOL en |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdSetRMUTimeOut Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| BOOL_2_BIT(en,data); |
| |
| /* Set the related bit. */ |
| retVal = hwSetGlobal2RegField(dev,QD_REG_WD_CONTROL, 6, 1, data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdGetRMUTimeOut |
| * |
| * DESCRIPTION: |
| * Remote Management Timeout. When this bit is set to a one the Remote |
| * Management Unit(RMU) will timeout on Wait on Bit commands. If the bit that |
| * is being tested has not gone to the specified value after 1 sec. has elapsed |
| * the Wait on Bit command will be terminated and the Response frame will be |
| * sent without any further processing. |
| * |
| * When this bit is cleared to a zero the Wait on Bit command will wait |
| * until the bit that is being tested has changed to the specified value. |
| * |
| * INPUTS: |
| * None. |
| * |
| * OUTPUTS: |
| * en - GT_TRUE to enable RMU Timeout |
| * GT_FALUSE, otherwise |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS gwdGetRMUTimeOut |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_BOOL *en |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdGetRMUTimeOut Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get the related bit. */ |
| retVal = hwGetGlobal2RegField(dev,QD_REG_WD_CONTROL, 6, 1, &data); |
| |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| BIT_2_BOOL(data, *en); |
| |
| return retVal; |
| } |
| |
| |
| /******************************************************************************* |
| * gwdGetEgressWDEvent |
| * |
| * DESCRIPTION: |
| * If any port's egress logic detects an egress watch dog issue, this bit |
| * will be set to a one, regardless of the setting of the GT_WD_EGRESS in |
| * gwdSetEvent function. |
| * |
| * INPUTS: |
| * None. |
| * |
| * OUTPUTS: |
| * event - GT_TRUE, if egress logic has detected any egress watch dog issue |
| * GT_FALUSE, otherwise |
| * |
| * |
| * RETURNS: |
| * GT_OK - on success |
| * GT_FAIL - on error |
| * GT_NOT_SUPPORTED - if current device does not support this feature. |
| * |
| * COMMENTS: |
| * |
| *******************************************************************************/ |
| GT_STATUS gwdGetEgressWDEvent |
| ( |
| IN GT_QD_DEV *dev, |
| OUT GT_BOOL *event |
| ) |
| { |
| GT_U16 data; |
| GT_STATUS retVal; /* Functions return value. */ |
| |
| DBG_INFO(("gwdGetEgressWDEvent Called.\n")); |
| |
| if (!IS_IN_DEV_GROUP(dev,DEV_WATCHDOG_EVENT)) |
| { |
| DBG_INFO(("GT_NOT_SUPPORTED\n")); |
| return GT_NOT_SUPPORTED; |
| } |
| |
| /* Get the related bit. */ |
| retVal = hwGetGlobal2RegField(dev,QD_REG_WD_CONTROL, 7, 1, &data); |
| if(retVal != GT_OK) |
| { |
| DBG_INFO(("Failed.\n")); |
| } |
| else |
| { |
| DBG_INFO(("OK.\n")); |
| } |
| |
| BIT_2_BOOL(data, *event); |
| |
| return retVal; |
| } |
| |
| |
