/* Function Name:
* rtl8367b_getAsicLutLearnLimitNo
* Description:
* Get per-Port auto learning limit number
* Input:
* port - Physical port number (0~7)
* pNumber - ASIC auto learning entries limit number
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PORT_ID - Invalid port number
* Note:
* None
*/
ret_t rtl8367b_getAsicLutLearnLimitNo(rtk_uint32 port, rtk_uint32* pNumber)
{
if(port > RTL8367B_PORTIDMAX)
return RT_ERR_PORT_ID;
return rtl8367b_getAsicReg(RTL8367B_LUT_PORT_LEARN_LIMITNO_REG(port), pNumber);
}
/* Function Name:
* rtl8367b_getAsicRldpLoopStatePara
* Description:
* Get retry count and retry period of loop state
* Input:
* pRetryCount - 0~0xFF (times)
* pRetryPeriod - 0~0xFFFF (ms)
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_OUT_OF_RANGE - input parameter out of range
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpLoopStatePara(rtk_uint32 *pRetryCount, rtk_uint32 *pRetryPeriod)
{
ret_t retVal;
retVal = rtl8367b_getAsicRegBits(RTL8367B_RLDP_RETRY_COUNT_REG, RTL8367B_RLDP_RETRY_COUNT_LOOPSTATE_MASK, pRetryCount);
if(retVal != RT_ERR_OK)
return retVal;
return rtl8367b_getAsicReg(RTL8367B_RLDP_RETRY_PERIOD_LOOPSTATE_REG, pRetryPeriod);
}
/* Function Name:
* rtl8367b_getAsicPortForceLinkExt
* Description:
* Get external interface force linking configuration
* Input:
* id - external interface id (0~1)
* pPortAbility - port ability configuration
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_OUT_OF_RANGE - input parameter out of range
* Note:
* None
*/
ret_t rtl8367b_getAsicPortForceLinkExt(rtk_uint32 id, rtl8367b_port_ability_t *pPortAbility)
{
rtk_uint32 reg_data;
rtk_uint16 ability_data;
ret_t retVal;
/* Invalid input parameter */
if(id >= RTL8367B_EXTNO)
return RT_ERR_OUT_OF_RANGE;
if(0 == id || 1 == id)
retVal = rtl8367b_getAsicReg(RTL8367B_REG_DIGITAL_INTERFACE0_FORCE+id, ®_data);
else
retVal = rtl8367b_getAsicReg(RTL8367B_REG_DIGITAL_INTERFACE2_FORCE, ®_data);
if(retVal != RT_ERR_OK)
return retVal;
ability_data = (rtk_uint16)reg_data;
memcpy(pPortAbility, &ability_data, sizeof(rtl8367b_port_ability_t));
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicMIBsControl
* Description:
* Get MIB control register
* Input:
* pMask - MIB control status mask bit[0]-busy bit[1]
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* Software need to check this control register atfer doing port resetting or global resetting
*/
ret_t rtl8367b_getAsicMIBsControl(rtk_uint32* pMask)
{
ret_t retVal;
rtk_uint32 regData;
retVal = rtl8367b_getAsicReg(RTL8367B_MIB_CTRL_REG, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pMask = regData & (RTL8367B_MIB_CTRL0_BUSY_FLAG_MASK | RTL8367B_RESET_FLAG_MASK);
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicPHYReg
* Description:
* Get PHY registers
* Input:
* phyNo - Physical port number (0~4)
* phyAddr - PHY address (0~31)
* pRegData - Writing data
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PHY_REG_ID - invalid PHY address
* RT_ERR_PHY_ID - invalid PHY no
* RT_ERR_BUSYWAIT_TIMEOUT - PHY access busy
* Note:
* None
*/
ret_t rtl8367b_getAsicPHYReg( rtk_uint32 phyNo, rtk_uint32 phyAddr, rtk_uint32 *value)
{
rtk_uint32 regAddr;
if(phyNo > RTL8367B_PHY_INTERNALNOMAX)
return RT_ERR_PORT_ID;
if(phyAddr > RTL8367B_PHY_REGNOMAX)
return RT_ERR_PHY_REG_ID;
regAddr = 0x2000 + (phyNo << 5) + phyAddr;
return rtl8367b_getAsicReg(regAddr, value);
}
/* Function Name:
* rtl8367b_getAsicMaxLengthAltTxRx
* Description:
* Get per-port Max receiving/transmit packet length in different speed
* Input:
* pMaxLength - 0: 1522 bytes 1:1536 bytes 2:1552 bytes 3:16000bytes
* pPmskGiga - enable port mask in 100Mpbs
* pPmask100M - enable port mask in Giga
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicMaxLengthAltTxRx(rtk_uint32* pMaxLength, rtk_uint32* pPmskGiga, rtk_uint32* pPmask100M)
{
ret_t retVal;
rtk_uint32 regData;
retVal = rtl8367b_getAsicReg(RTL8367B_REG_MAX_LENGTH_CFG, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pPmskGiga = (regData & RTL8367B_MAX_LENGTH_GIGA_MASK) >> RTL8367B_MAX_LENGTH_GIGA_OFFSET;
*pPmask100M = regData & RTL8367B_MAX_LENGTH_10_100M_MASK;
return rtl8367b_getAsicRegBits(RTL8367B_REG_MAX_LEN_RX_TX, RTL8367B_MAX_LEN_RX_TX_MASK, pMaxLength);
}
/* Function Name:
* rtl8367b_getAsicIGMPQueryInterval
* Description:
* Get Query Interval of IGMP/MLD
* Input:
* None
* Output:
* pinterval - Query Interval
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicIGMPQueryInterval(rtk_uint32 *pinterval)
{
ret_t retVal;
rtk_uint32 value;
/* Query Interval */
retVal = rtl8367b_getAsicReg(RTL8367B_REG_IGMP_MLD_CFG2, &value);
if(retVal != RT_ERR_OK)
return retVal;
*pinterval = value;
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicGreenPortPage
* Description:
* Get per-Port ingress page usage per second
* Input:
* port - Physical port number (0~7)
* pPage - page number of ingress packet occuping per second
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PORT_ID - Invalid port number
* Note:
* Ingress traffic occuping page number per second for high layer green feature usage
*/
ret_t rtl8367b_getAsicGreenPortPage(rtk_uint32 port, rtk_uint32* pPage)
{
ret_t retVal;
rtk_uint32 regData;
rtk_uint32 pageMeter;
if(port > RTL8367B_PORTIDMAX)
return RT_ERR_PORT_ID;
retVal = rtl8367b_getAsicReg(RTL8367B_PAGEMETER_PORT_REG(port), ®Data);
if(retVal != RT_ERR_OK)
return retVal;
pageMeter = regData;
retVal = rtl8367b_getAsicReg(RTL8367B_PAGEMETER_PORT_REG(port) + 1, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
pageMeter = pageMeter + (regData << 16);
*pPage = pageMeter;
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicLutAgeTimerSpeed
* Description:
* Get LUT agging out speed
* Input:
* pTimer - Agging out timer 0:Has been aged out
* pSpeed - Agging out speed 0-fastest 3-slowest
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_OUT_OF_RANGE - input parameter out of range
* Note:
* None
*/
ret_t rtl8367b_getAsicLutAgeTimerSpeed(rtk_uint32* pTimer, rtk_uint32* pSpeed)
{
rtk_uint32 regData;
ret_t retVal;
retVal = rtl8367b_getAsicReg(RTL8367B_REG_LUT_CFG, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pTimer = (regData & RTL8367B_AGE_TIMER_MASK) >> RTL8367B_AGE_TIMER_OFFSET;
*pSpeed = (regData & RTL8367B_AGE_SPEED_MASK) >> RTL8367B_AGE_SPEED_OFFSET;
return RT_ERR_OK;
}
void test_smi_signal_and_wait()
{
int i;
for (i=0; i<100; i++)
{
rtk_uint32 data;
rtk_api_ret_t retVal;
if((retVal = rtl8367b_getAsicReg(0x1202, &data)) != RT_ERR_OK)
{
printf("error = %d\n", retVal);
}
printf("data = %x\n", data);
if (data == 0x88a8) break;
CLK_DURATION(50000);
}
}
/* Function Name:
* rtl8367b_getAsicRldpRandomNumber
* Description:
* Get Random number of RLDP
* Input:
* pRandNumber - MAC
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpRandomNumber(ether_addr_t *pRandNumber)
{
ret_t retVal;
rtk_uint32 regData;
rtk_int16 accessPtr[3];
rtk_uint32 i;
for(i = 0; i < 3; i++)
{
retVal = rtl8367b_getAsicReg(RTL8367B_RLDP_RAND_NUM_REG_BASE+ i, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
accessPtr[i] = regData;
}
memcpy(pRandNumber, accessPtr, 6);
return retVal;
}
/* Function Name:
* rtl8367b_getAsicRldpMagicNum
* Description:
* Get Random seed of RLDP
* Input:
* pSeed - MAC
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpMagicNum(ether_addr_t *pSeed)
{
ret_t retVal;
rtk_uint32 regData;
rtk_int16 *accessPtr;
rtk_uint32 i;
accessPtr = (rtk_uint16*)pSeed;
for(i = 0; i < 3; i++)
{
retVal = rtl8367b_getAsicReg(RTL8367B_RLDP_MAGIC_NUM_REG_BASE + i, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*accessPtr = regData;
accessPtr++;
}
return retVal;
}
static int test_smi_signal_and_wait(void)
{
int i, good = 0;
rtk_uint32 data;
for (i = 0; i < 20; i++) {
data = 0;
rtl8367b_getAsicReg(0x1202, &data);
if (data == 0x88a8)
good++;
else
good = 0;
if (good > 2)
return 0;
mdelay(30);
}
return -1;
}
/* Function Name:
* rtl8367b_getAsicMacAddress
* Description:
* Get switch MAC address
* Input:
* pMac - switch mac
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicMacAddress(ether_addr_t *pMac)
{
ret_t retVal;
rtk_uint32 regData;
rtk_uint8 *accessPtr;
rtk_uint32 i;
accessPtr = (rtk_uint8*)pMac;
for(i = 0; i <= 2; i++)
{
retVal = rtl8367b_getAsicReg(RTL8367B_REG_SWITCH_MAC2 - i, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*accessPtr = (regData & 0xFF00) >> 8;
accessPtr ++;
*accessPtr = regData & 0xFF;
accessPtr ++;
}
return retVal;
}
/* Function Name:
* rtl8367b_getAsicPortIngressBandwidth
* Description:
* Get per-port total ingress bandwidth
* Input:
* port - Physical port number (0~7)
* pBandwidth - The total ingress bandwidth (unit: 8Kbps), 0x1FFFF:disable
* pPreifg - Include preamble and IFG, 0:Exclude, 1:Include
* pEnableFC - Action when input rate exceeds. 0: Drop 1: Flow Control
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PORT_ID - Invalid port number
* Note:
* None
*/
ret_t rtl8367b_getAsicPortIngressBandwidth(rtk_uint32 port, rtk_uint32* pBandwidth, rtk_uint32* pPreifg, rtk_uint32* pEnableFC)
{
ret_t retVal;
rtk_uint32 regData;
rtk_uint32 regAddr;
/* Invalid input parameter */
if(port >= RTL8367B_PORTNO)
return RT_ERR_PORT_ID;
regAddr = RTL8367B_INGRESSBW_PORT_RATE_LSB_REG(port);
retVal = rtl8367b_getAsicReg(regAddr, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pBandwidth = regData;
regAddr += 1;
retVal = rtl8367b_getAsicRegBit(regAddr, 0, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pBandwidth |= (regData << RTL8367B_QOS_GRANULARTY_MSB_OFFSET);
regAddr = RTL8367B_PORT_MISC_CFG_REG(port);
retVal = rtl8367b_getAsicRegBit(regAddr, RTL8367B_PORT0_MISC_CFG_INGRESSBW_IFG_OFFSET, pPreifg);
if(retVal != RT_ERR_OK)
return retVal;
regAddr = RTL8367B_PORT_MISC_CFG_REG(port);
retVal = rtl8367b_getAsicRegBit(regAddr, RTL8367B_PORT0_MISC_CFG_INGRESSBW_FLOWCTRL_OFFSET, pEnableFC);
if(retVal != RT_ERR_OK)
return retVal;
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicVlan4kEntry
* Description:
* Get VID mapped entry to 4K VLAN table
* Input:
* pVlan4kEntry - 4K VLAN configuration
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_VLAN_VID - Invalid VID parameter (0~4095)
* RT_ERR_BUSYWAIT_TIMEOUT - LUT is busy at retrieving
* Note:
* None
*/
ret_t rtl8367b_getAsicVlan4kEntry(rtl8367b_user_vlan4kentry *pVlan4kEntry )
{
#if defined(DISABLE_VLAN_SHADOW)
rtl8367b_vlan4kentrysmi vlan_4k_entry;
rtk_uint32 page_idx;
rtk_uint16 *tableAddr;
ret_t retVal;
rtk_uint32 regData;
if(pVlan4kEntry->vid > RTL8367B_VIDMAX)
return RT_ERR_VLAN_VID;
/* Write Address (VLAN_ID) */
regData = pVlan4kEntry->vid;
retVal = rtl8367b_setAsicReg(RTL8367B_TABLE_ACCESS_ADDR_REG, regData);
if(retVal != RT_ERR_OK)
return retVal;
/* Read Command */
retVal = rtl8367b_setAsicRegBits(RTL8367B_TABLE_ACCESS_CTRL_REG, RTL8367B_TABLE_TYPE_MASK | RTL8367B_COMMAND_TYPE_MASK, RTL8367B_TABLE_ACCESS_REG_DATA(TB_OP_READ,TB_TARGET_CVLAN));
if(retVal != RT_ERR_OK)
return retVal;
/* Check ASIC Command */
retVal = rtl8367b_getAsicRegBit(RTL8367B_TABLE_ACCESS_STATUS_REG, RTL8367B_TABLE_LUT_ADDR_BUSY_FLAG_OFFSET,®Data);
if(retVal != RT_ERR_OK)
return RT_ERR_BUSYWAIT_TIMEOUT;
/* Read VLAN data from register */
tableAddr = (rtk_uint16 *)&vlan_4k_entry;
for(page_idx = 0; page_idx < (sizeof(rtl8367b_vlan4kentrysmi) / 2); page_idx++)
{
retVal = rtl8367b_getAsicReg(RTL8367B_TABLE_ACCESS_RDDATA_BASE + page_idx, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*tableAddr = regData;
tableAddr++;
}
_rtl8367b_Vlan4kStSmi2User(&vlan_4k_entry, pVlan4kEntry);
#else
rtk_uint16 vid;
if(pVlan4kEntry->vid > RTL8367B_VIDMAX)
return RT_ERR_VLAN_VID;
vid = pVlan4kEntry->vid;
memcpy(pVlan4kEntry, &user_4kvlan[pVlan4kEntry->vid], sizeof(rtl8367b_user_vlan4kentry));
pVlan4kEntry->vid = vid;
#endif
#if defined(CONFIG_RTL8367B_ASICDRV_TEST)
_rtl8367b_Vlan4kStSmi2User(&Rtl8370sVirtualVlanTable[pVlan4kEntry->vid], pVlan4kEntry);
#endif
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicEeepGigaTxRateTh
* Description:
* Get EEEP detect Tx rate threshold for sleeping in GIGA mode
* Input:
* pThreshold - Threshold of Rx rate for falling sleep
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicEeepGigaTxRateTh(rtk_uint32* pThreshold)
{
return rtl8367b_getAsicReg(RTL8367B_REG_EEEP_TX_RATE_GIGA, pThreshold);
}
/* Function Name:
* rtl8367b_getAsicEeep100mTxRateTh
* Description:
* Get EEEP detect Tx rate threshold for sleeping in 100Mpbs mode
* Input:
* pThreshold - Threshold of Rx rate for falling sleep
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicEeep100mTxRateTh(rtk_uint32* pThreshold)
{
return rtl8367b_getAsicReg(RTL8367B_REG_EEEP_TX_RATE_100M, pThreshold);
}
/* Function Name:
* rtl8367b_getAsicMIBsCounter
* Description:
* Get MIBs counter
* Input:
* port - Physical port number (0~7)
* mibIdx - MIB counter index
* pCounter - MIB retrived counter
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PORT_ID - Invalid port number
* RT_ERR_BUSYWAIT_TIMEOUT - MIB is busy at retrieving
* RT_ERR_STAT_CNTR_FAIL - MIB is resetting
* Note:
* Before MIBs counter retrieving, writting accessing address to ASIC at first and check the MIB
* control register status. If busy bit of MIB control is set, that means MIB counter have been
* waiting for preparing, then software must wait atfer this busy flag reset by ASIC. This driver
* did not recycle reading user desired counter. Software must use driver again to get MIB counter
* if return value is not RT_ERR_OK.
*/
ret_t rtl8367b_getAsicMIBsCounter(rtk_uint32 port, RTL8367B_MIBCOUNTER mibIdx, rtk_uint64* pCounter)
{
ret_t retVal;
rtk_uint32 regAddr;
rtk_uint32 regData;
rtk_uint32 mibAddr;
rtk_uint32 mibOff=0;
/* address offset to MIBs counter */
CONST rtk_uint16 mibLength[RTL8367B_MIBS_NUMBER]= {
4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
4,2,2,2,2,2,2,2,2,
4,2,2,2,2,2,2,2,2,2,2,2,2,2,2,
2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
rtk_uint16 i;
rtk_uint64 mibCounter;
if(port > RTL8367B_PORTIDMAX)
return RT_ERR_PORT_ID;
if(mibIdx >= RTL8367B_MIBS_NUMBER)
return RT_ERR_STAT_INVALID_CNTR;
if(dot1dTpLearnedEntryDiscards == mibIdx)
{
mibAddr = RTL8367B_MIB_LEARNENTRYDISCARD_OFFSET;
}
else
{
i = 0;
mibOff = RTL8367B_MIB_PORT_OFFSET * port;
while(i < mibIdx)
{
mibOff += mibLength[i];
i++;
}
mibAddr = mibOff;
}
/*writing access counter address first*/
/*This address is SRAM address, and SRAM address = MIB register address >> 2*/
/*then ASIC will prepare 64bits counter wait for being retrived*/
/*Write Mib related address to access control register*/
retVal = rtl8367b_setAsicReg(RTL8367B_REG_MIB_ADDRESS, (mibAddr >> 2));
if(retVal != RT_ERR_OK)
return retVal;
/* polling busy flag */
i = 100;
while(i > 0)
{
/*read MIB control register*/
retVal = rtl8367b_getAsicReg(RTL8367B_MIB_CTRL_REG,®Data);
if((regData & RTL8367B_MIB_CTRL0_BUSY_FLAG_MASK) == 0)
{
break;
}
i--;
}
if(regData & RTL8367B_MIB_CTRL0_BUSY_FLAG_MASK)
return RT_ERR_BUSYWAIT_TIMEOUT;
if(regData & RTL8367B_RESET_FLAG_MASK)
return RT_ERR_STAT_CNTR_FAIL;
mibCounter = 0;
i = mibLength[mibIdx];
if(4 == i)
regAddr = RTL8367B_MIB_COUNTER_BASE_REG + 3;
else
regAddr = RTL8367B_MIB_COUNTER_BASE_REG + ((mibOff + 1) % 4);
while(i)
{
retVal = rtl8367b_getAsicReg(regAddr, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
mibCounter = (mibCounter << 16) | (regData & 0xFFFF);
regAddr --;
i --;
}
*pCounter = mibCounter;
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicReg
* Description:
* Get accepted S-VLAN ether type. The default ether type of S-VLAN is 0x88a8
* Input:
* pProtocolType - Ether type of S-tag frame parsing in uplink ports
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicSvlanTpid(rtk_uint32* pProtocolType)
{
return rtl8367b_getAsicReg(RTL8367B_REG_VS_TPID, pProtocolType);
}
/* Function Name:
* rtl8367b_getAsicRldpTxPortmask
* Description:
* Get portmask that send/forward RLDP frame
* Input:
* pPortmask - 0~0xFF
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpTxPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_RLDP_TX_PMSK_REG, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicPortBcastFloodingPortmask
* Description:
* Get Bcast flooding portmask
* Input:
* pPortmask - portmask(0~0xFF)
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicPortBcastFloodingPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_BCAST_FLOADING_PMSK_REG, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicPortUnknownMulticastFloodingPortmask
* Description:
* Get UNMC flooding portmask
* Input:
* pPortmask - portmask(0~0xFF)
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicPortUnknownMulticastFloodingPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_UNMCAST_FLOADING_PMSK_REG, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicRldpLeaveLoopedPortmask
* Description:
* Get leaved looped portmask
* Input:
* pPortmask - 0~0xFF
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpLeaveLoopedPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_REG_RLDP_RELEASED_INDICATOR, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicRldpLoopedPortmask
* Description:
* Get looped portmask
* Input:
* pPortmask - 0~0xFF
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicRldpLoopedPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_RLDP_LOOP_PMSK_REG, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicPHYReg
* Description:
* Get PHY registers
* Input:
* phyNo - Physical port number (0~7)
* phyAddr - PHY address (0~31)
* pRegData - Writing data
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* RT_ERR_PHY_REG_ID - invalid PHY address
* RT_ERR_PHY_ID - invalid PHY no
* RT_ERR_BUSYWAIT_TIMEOUT - PHY access busy
* Note:
* None
*/
ret_t rtl8367b_getAsicPHYReg(rtk_uint32 phyNo, rtk_uint32 phyAddr, rtk_uint32 *pRegData )
{
ret_t retVal;
rtk_uint32 regData;
rtk_uint32 busyFlag,checkCounter;
#ifdef RTK_X86_CLE
#else
if(phyNo > RTL8367B_PHY_INTERNALNOMAX)
return RT_ERR_PHY_ID;
#endif
if(phyAddr > RTL8367B_PHY_REGNOMAX)
return RT_ERR_PHY_REG_ID;
/*Check internal phy access busy or not*/
/*retVal = rtl8367b_getAsicRegBit(RTL8367B_REG_INDRECT_ACCESS_STATUS, RTL8367B_INDRECT_ACCESS_STATUS_OFFSET,&busyFlag);*/
retVal = rtl8367b_getAsicReg(RTL8367B_REG_INDRECT_ACCESS_STATUS,&busyFlag);
if(retVal != RT_ERR_OK)
return retVal;
if(busyFlag)
return RT_ERR_BUSYWAIT_TIMEOUT;
/*prepare access address*/
regData = RTL8367B_PHY_BASE | (phyNo << RTL8367B_PHY_OFFSET) | phyAddr;
retVal = rtl8367b_setAsicReg(RTL8367B_REG_INDRECT_ACCESS_ADDRESS, regData);
if(retVal != RT_ERR_OK)
return retVal;
/*Set READ Command*/
retVal = rtl8367b_setAsicReg(RTL8367B_REG_INDRECT_ACCESS_CTRL, RTL8367B_CMD_MASK );
if(retVal != RT_ERR_OK)
return retVal;
checkCounter = 5;
while(checkCounter)
{
// retVal = rtl8367b_getAsicRegBit(RTL8367B_REG_INDRECT_ACCESS_STATUS, RTL8367B_INDRECT_ACCESS_STATUS_OFFSET,&busyFlag);
retVal = rtl8367b_getAsicReg(RTL8367B_REG_INDRECT_ACCESS_STATUS,&busyFlag);
if((retVal != RT_ERR_OK) || busyFlag)
{
checkCounter --;
if(0 == checkCounter)
return RT_ERR_FAILED;
}
else
{
checkCounter = 0;
}
}
/*get PHY register*/
retVal = rtl8367b_getAsicReg(RTL8367B_REG_INDRECT_ACCESS_READ_DATA, ®Data);
if(retVal != RT_ERR_OK)
return retVal;
*pRegData = regData;
return RT_ERR_OK;
}
/* Function Name:
* rtl8367b_getAsicSvlanUplinkPortMask
* Description:
* Get uplink ports mask
* Input:
* pPortmask - Uplink port mask setting
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicSvlanUplinkPortMask(rtk_uint32* pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_REG_SVLAN_UPLINK_PORTMASK, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicEgressQueueEmptyPortMask
* Description:
* Get queue empty port mask
* Input:
* pPortmask - Queue empty port mask
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicEgressQueueEmptyPortMask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_REG_PORT_QEMPTY, pPortmask);
}
/* Function Name:
* rtl8367b_getAsicCputagPortmask
* Description:
* Get ports that can parse CPU tag
* Input:
* pPortmask - port mask
* Output:
* None
* Return:
* RT_ERR_OK - Success
* RT_ERR_SMI - SMI access error
* Note:
* None
*/
ret_t rtl8367b_getAsicCputagPortmask(rtk_uint32 *pPortmask)
{
return rtl8367b_getAsicReg(RTL8367B_CPU_PORT_MASK_REG, pPortmask);
}
