hw_api.c

在freescale 的ne64上开发的源代码

	{
		regVal |= QD_RATECTRL_LMT_BCAST;
	}
	else if(type == STORM_TYPE_MBCAST)
	{
		regVal |= QD_RATECTRL_LMT_MBCAST;
	}
	else
	{
		regVal |= QD_RATECTRL_LMT_MBDCAST;
	}
	MIIwrite(phyAddr, QD_REG_EGRESS_RATE_CTRL, regVal);
		
	MIIread(phyAddr, QD_REG_INGRESS_RATE_CTRL, &regVal);
	regVal &= (~QD_RATECTRL_LMT_RATEf);
	regVal += (UINT16)(hwRateLmtValGet(rateTmp));
	MIIwrite(phyAddr, QD_REG_INGRESS_RATE_CTRL, regVal);

	return OK;
}

/*
 * Function:
 *   hwGetPortStorm()
 * Purpose:
 *   Get the port RX storm control limit
 * Parameters:
 *   port -- port number,1-2
 *   type -- storm limit type, 0:Bcast;1:M-Bcast;2:M-B-DlfCast
 *   rate -- rate value, 0 to disable, n*64K
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwGetPortStorm(UINT8 port, UINT8 *type, UINT16 *rate)
{
	UINT8 phyAddr,portTmp;
	UINT16 regVal;
	UINT32 rateTmp;
	
	if(portInvalid(port,&portTmp))
		return ERROR;
	
	phyAddr = portTmp + 0x10;

	MIIread(phyAddr, QD_REG_EGRESS_RATE_CTRL, &regVal);

	switch(regVal & QD_RATECTRL_LMT_MODEf)
	{
		case QD_RATECTRL_LMT_BCAST:
			*type = STORM_TYPE_BCAST;			
			break;
		case QD_RATECTRL_LMT_MBCAST:
			*type = STORM_TYPE_MBCAST;
			break;
		case QD_RATECTRL_LMT_MBDCAST:
			*type = STORM_TYPE_MBDCAST;
			break;
		default:
			*type = STORM_TYPE_ALL;
			break;
	}

	MIIread(phyAddr, QD_REG_INGRESS_RATE_CTRL, &regVal);
 	if((regVal & QD_RATECTRL_LMT_RATEf) == 0)
		*rate = 0;
	else
	{	
		rateTmp = (regVal & QD_RATECTRL_LMT_RATEf);	
		rateTmp = hwRateLmtValGet(rateTmp);
		rateTmp = (rateTmp/64 + ((rateTmp%64)?1:0));			
		*rate = (UINT16)rateTmp;
	}
	return OK;
}

/*
 * Function:
 *   hwSetPortFlowCtrl()
 * Purpose:
 *   Set the port flow control
 * Parameters:
 *   port   -- port number,1-2
 *   enable -- 1-enable; 0-disable 
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwSetPortFlowCtrl(UINT8 port, UINT8 enable)
{
	UINT8 phyAddr,portTmp;
	UINT16 regVal;

	if(portInvalid(port,&portTmp))
		return ERROR;
	phyAddr = portTmp + 0x10;
	
	MIIread(phyAddr, QD_REG_PCS_CONTROL, &regVal);

	if(enable)
		regVal |= (QD_PCS_FL_FORCE | QD_PCS_FL_ENABLE);
	else
	{
		regVal |= QD_PCS_FL_FORCE;
		regVal &= (~QD_PCS_FL_ENABLE);
	}
	
	MIIwrite(phyAddr, QD_REG_PCS_CONTROL, regVal);
	
	if(localDTEType == OL100CR_X4X_V5)
	{
		if(portTmp == PORT_NUM_TP)
		{
			disPPU(SWITCH_GLOBAL1_ADDRESS);
			/*set auto advertise*/
			MIIread(EXTL_PHY_ADDRESS, MII_ANA_REG, &regVal);
			if(enable)
				regVal |= MII_ANA_PAUSE;
			else
				regVal &= (~MII_ANA_PAUSE);
			MIIwrite(EXTL_PHY_ADDRESS, MII_ANA_REG, regVal);
			/*restart the auto-negotiation*/
			MIIread(EXTL_PHY_ADDRESS, MII_CTRL_REG, &regVal);
			if(regVal & MII_CTRL_AE)
			{
				regVal |= MII_CTRL_RAN;
				MIIwrite(EXTL_PHY_ADDRESS, MII_CTRL_REG, regVal);
			}
			enPPU(SWITCH_GLOBAL1_ADDRESS);
		}
	}
	else
	{
		/*restart the auto-negotiation*/
		if(regVal & QD_PCS_AN_ENABLE)
		{
			regVal |= QD_PCS_AN_RESTART;
			MIIwrite(phyAddr, QD_REG_PCS_CONTROL, regVal);
		}
	}

	return OK;
}

/*
 * Function:
 *   hwGetPortFlowCtrl()
 * Purpose:
 *   Get the port flow control
 * Parameters:
 *   port   -- port number,1-2
 *   enable -- 1-enable; 0-disable 
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwGetPortFlowCtrl(UINT8 port, UINT8 *enable)
{
	UINT8 phyAddr,portTmp;
	UINT16 regVal;
	
	if(portInvalid(port,&portTmp))
		return ERROR;
	
	phyAddr = portTmp + 0x10;	
	MIIread(phyAddr, QD_REG_PCS_CONTROL, &regVal);
	if(regVal & QD_PCS_FL_ENABLE)
		*enable = 1;
	else
		*enable = 0;
	return OK;
}

/*
 * Function:
 *   hwSetCos()
 * Purpose:
 *   Set the device cos status
 * Parameters:
 *   enable -- 1-enable; 0-disable 
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwSetCos(UINT8 enable)
{
	return OK;
}

/*
 * Function:
 *   hwGetCos()
 * Purpose:
 *   Get the device cos status
 * Parameters:
 *   enable -- 1-enable; 0-disable 
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwGetCos(UINT8 *enable)
{
	*enable = 0;
	return OK;
}

/*
 * Function:
 *   hwGetPortCounter()
 * Purpose:
 *   Get the port statistics
 * Parameters:
 *   port -- port number,1-2
 *   type -- statistics type
 *   val  -- value
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwGetPortCounter(UINT8 port, GT_STATS_COUNTERS type, UINT32 *val)
{
	UINT8 portTmp;
	UINT16 regVal;

	if(portInvalid(port,&portTmp))
		return ERROR;
	
	/*capture the port's counter*/
	/*wait if busy*/
	MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, &regVal);
	while(regVal & GT_STATS_BUSY)
	MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, &regVal);
		
	regVal = 0x0000;
	regVal = (GT_STATS_BUSY | (GT_STATS_CAPTURE_PORT<<12) | (GT_STATS_HSTGRM_RX<<10) | (portTmp&0x3F));
	MIIwrite(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, regVal);

	/*read the port's counter*/
	/*wait if busy*/
	while(regVal & GT_STATS_BUSY)
		MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, &regVal);

	regVal = 0x0000;
	regVal = (GT_STATS_BUSY | (GT_STATS_READ_COUNTER<<12) | (GT_STATS_HSTGRM_RX<<10) | (type&0x3F));
	MIIwrite(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, regVal);

	/*wait if busy*/
	while(regVal & GT_STATS_BUSY)
		MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_OPERATION, &regVal);

	MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_COUNTER3_2, &regVal);
	*val = regVal;
	*val <<= 16;
	MIIread(SWITCH_GLOBAL1_ADDRESS, QD_REG_STATS_COUNTER1_0, &regVal);
	*val += regVal;
	
	return OK;
}

void hwGetPortCntStr(ePORT_STATISTIC type, INT8 *str)
{
	switch(type)
	{
		case RxBytes:
			sprintf(str,"RxBytes");
			break;
		case RxPkts:
			sprintf(str,"RxPkts");
			break;
		case RxUniPkts:
			sprintf(str,"RxUniPkts");
			break;
		case RxMcastPkts:
			sprintf(str,"RxMcastPkts");
			break;
		case RxBcastPkts:
			sprintf(str,"RxBcastPkts");
			break;
		case RxDropPkts:
			sprintf(str,"RxDropPkts");
			break;
		case RxErrPkts:
			sprintf(str,"RxErrPkts");
			break;
		case RxCRCErrPkts:
			sprintf(str,"RxCRCErrPkts");
			break;
		case RxFragmentErrPkts:
			sprintf(str,"RxFragmentErrPkts");
			break;
		case RxOversizePkts:
			sprintf(str,"RxOversizePkts");
			break;
		case RxUndersizePkts:
			sprintf(str,"RxUndersizePkts");
			break;
		case RxJabberPkts:
			sprintf(str,"RxJabberPkts");
			break;
		case RxPausePkts:
			sprintf(str,"RxPausePkts");
			break;
		case Rx64BytesPkts:
			sprintf(str,"Rx64BytesPkts");
			break;
		case Rx65to127BytesPkts:
			sprintf(str,"Rx65to127BytesPkts");
			break;
		case Rx128to255BytesPkts:
			sprintf(str,"Rx128to255BytesPkts");
			break;
		case Rx256to511BytesPkts:
			sprintf(str,"Rx256to511BytesPkts");
			break;
		case Rx512to1023BytesPkts:
			sprintf(str,"Rx512to1023BytesPkts");
			break;
		case Rx1024to1522BytesPkts:
			sprintf(str,"Rx1024to1522BytesPkts");
			break;
		case TxBytes:
			sprintf(str,"TxBytes");
			break;
		case TxPkts:
			sprintf(str,"TxPkts");
			break;
		case TxUniPkts:
			sprintf(str,"TxUniPkts");
			break;
		case TxMcastPkts:
			sprintf(str,"TxMcastPkts");
			break;
		case TxBcastPkts:
			sprintf(str,"TxBcastPkts");
			break;
		case TxPausePkts:
			sprintf(str,"TxPausePkts");
			break;
		case TxCollisionPkts:
			sprintf(str,"TxCollisionPkts");
			break;
		case TxLateColPkts:
			sprintf(str,"TxLateColPkts");
			break;
		case TxExcessiveColPkts:
			sprintf(str,"TxExcessiveColPkts");
			break;
		case TxSingleColPkts:
			sprintf(str,"TxSingleColPkts");
			break;
		case TxMultiColPkts:
			sprintf(str,"TxMultiColPkts");
			break;
		case TxDropPkts:
			sprintf(str,"TxDropPkts");
			break;
		default:
			sprintf(str,"Unknown");
			break;
	}
}

UINT8 hwGetPortCnt(UINT8 port, ePORT_STATISTIC type, UINT32 *valHigh, UINT32 *valLow)
{
	UINT32 cntTmp1,cntTmp2;

	*valHigh = 0;
	*valLow = 0;
	
	switch(type)
	{
		case RxBytes:
			hwGetPortCounter(port, InGoodOctetsHi, valHigh);
			hwGetPortCounter(port, InGoodOctetsLo, &cntTmp1);
			hwGetPortCounter(port, InBadOctets, &cntTmp2);
			
			*valLow = cntTmp1 + cntTmp2;
			if((*valLow<cntTmp1) || (*valLow<cntTmp2))			
				*valHigh += 1;
			break;			
		case RxPkts:
			hwGetPortCounter(port, InUnicasts, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, InBroadcasts, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, InMulticasts, &cntTmp1);
			*valLow += cntTmp1;
			break;
		case RxUniPkts:
			hwGetPortCounter(port, InUnicasts, valLow);
			break;
		case RxMcastPkts:
			hwGetPortCounter(port, InMulticasts, valLow);
			break;
		case RxBcastPkts:
			hwGetPortCounter(port, InBroadcasts, valLow);
			break;
		case RxDropPkts:
			return ERROR;
			break;
		case RxErrPkts:
			hwGetPortCounter(port, InFCSErr, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, InFragments, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, InOversize, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, InUndersize, &cntTmp1);
			*valLow += cntTmp1;
			break;
		case RxCRCErrPkts:
			hwGetPortCounter(port, InFCSErr, valLow);
			break;
		case RxFragmentErrPkts:
			hwGetPortCounter(port, InFragments, valLow);
			break;
		case RxOversizePkts:
			hwGetPortCounter(port, InOversize, valLow);
			break;
		case RxUndersizePkts:
			hwGetPortCounter(port, InUndersize, valLow);
			break;
		case RxJabberPkts:
			hwGetPortCounter(port, InJabber, valLow);
			break;
		case RxPausePkts:
			hwGetPortCounter(port, InPause, valLow);
			break;
		case Rx64BytesPkts:
			hwGetPortCounter(port, InOctets64, valLow);
			break;
		case Rx65to127BytesPkts:
			hwGetPortCounter(port, InOctets127, valLow);
			break;
		case Rx128to255BytesPkts:
			hwGetPortCounter(port, InOctets255, valLow);
			break;
		case Rx256to511BytesPkts:
			hwGetPortCounter(port, InOctets511, valLow);
			break;
		case Rx512to1023BytesPkts:
			hwGetPortCounter(port, InOctets1023, valLow);
			break;
		case Rx1024to1522BytesPkts:
			hwGetPortCounter(port, InOctetsMax, valLow);
			break;
		case TxBytes:
			hwGetPortCounter(port, OutOctetsLo, valLow);
			hwGetPortCounter(port, OutOctetsHi, valHigh);
			break;	
		case TxPkts:
			hwGetPortCounter(port, OutUnicasts, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, OutMulticasts, &cntTmp1);
			*valLow += cntTmp1;
			hwGetPortCounter(port, OutBroadcasts, &cntTmp1);
			*valLow += cntTmp1;
			break;
		case TxUniPkts:
			hwGetPortCounter(port, OutUnicasts, valLow);
			break;
		case TxMcastPkts:
			hwGetPortCounter(port, OutMulticasts, valLow);
			break;
		case TxBcastPkts:
			hwGetPortCounter(port, OutBroadcasts, valLow);
			break;
		case TxPausePkts:
			hwGetPortCounter(port, OutPause, valLow);
			break;
		case TxCollisionPkts:
			hwGetPortCounter(port, OutCollisions, valLow);
			break;
		case TxLateColPkts:
			hwGetPortCounter(port, OutLate, valLow);
			break;
		case TxExcessiveColPkts:
			hwGetPortCounter(port, OutExcessive, valLow);
			break;
		case TxSingleColPkts:
			hwGetPortCounter(port, OutSingle, valLow);
			break;
		case TxMultiColPkts:
			hwGetPortCounter(port, OutMultiple, valLow);
			break;
		case TxDropPkts:
			hwGetPortCounter(port, OutFCSErr, valLow);
			break;
		default:
			return ERROR;;
			break;
	}	
	return OK;
}

/*
 * Function:
 *   hwSetReg()
 * Purpose:
 *   Set the device chip register
 * Parameters:
 *   chip -- 0-siwtch chip;1-phy;2-mcu
 *   addr -- address
 *   val  -- wirite value
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwSetReg(UINT8 phyAddr, UINT8 addr, UINT16 val)
{
	if(phyAddr <= EXTL_PHY_ADDRESS)
	{
		disPPU(SWITCH_GLOBAL1_ADDRESS);
		MIIwrite(phyAddr, addr, val);
		enPPU(SWITCH_GLOBAL1_ADDRESS);
	}
	else
	{
		MIIwrite(phyAddr, addr, val);
	}
	
	return OK;
}

/*
 * Function:
 *   hwGetReg()
 * Purpose:
 *   Get the device chip register
 * Parameters:
 *   chip -- 0-siwtch chip;1-phy;2-mcu
 *   addr -- address
 *   val  -- wirite value
 * Returns:
 *   OK or ERROR.
 * Notes:
 *   None.
 */
UINT8 hwGetReg(UINT8 phyAddr, UINT8 addr, UINT16 *val)
{
	if(phyAddr <= EXTL_PHY_ADDRESS)
	{
		disPPU(SWITCH_GLOBAL1_ADDRESS);
		MIIread(phyAddr, addr, val);
		enPPU(SWITCH_GLOBAL1_ADDRESS);
	}
	else
	{
		MIIread(phyAddr, addr, val);
	}
	
	return OK;
}

/*
 * Function: