apcoam.c

Lucent的ATM处理套片APC驱动DEMO

 * Returns valid PMX (Performance Monitoring to set the LUT3 entry.
 *
 ******************************************************************************/

INT
apcGetPMX(u8 devNum)
{
	INT pmx;

	/* get a pmx for the PM process */
	if (pmx_index[devNum] < APC_PMPROCESSES_MAX)
	{
		pmx = apcPMX[devNum][pmx_index[devNum]];
		pmx_index[devNum]++;
	} else {
		return (-1);
	}
#ifdef	UNIT_TEST
	printf("****PMX==== %d  ****\n", pmx);
#endif
	return (pmx);
}

/*******************************************************************************
 *
 * Returns PMX (Performance Monitoring Index) to the Pool
 *
 ******************************************************************************/

ApcRtn_t
apcReturnPMX(u8 devNum, INT pmx)
{

	if (pmx_index[devNum] < APC_PMPROCESSES_MAX)
	{
		apcPMX[devNum][--pmx_index[devNum]]= pmx;
	} else {
		return (APC_ERRORGENERIC);
	}

	return (APC_SUCCESS);
}

/*******************************************************************************
 *
 * Function Name:	ApcRtn_t apcPrgPM_Table(OAMPrgPMTbl_t *pmInfo, u32 vcx )
 *
 * Description:		This API is called to configure the PM Table
 *			when OAM Performance Monitoring is enabled.
 *
 * Return Value:	Error/Success flag.
 *
 * Side Effects:	None.
 *
 ******************************************************************************/

ApcRtn_t
apcPrgPM_Table(OAMPrgPMTbl_t *pmInfo, VCIndex_t vcEntry)
{
	u8	devNum = pmInfo->devNum;
	u8	connType;
	INT	pmx, pmxsrc, pmxsnk;
	u32	lut2Entry, lut2Addr;
	rPMTbl_t	pmTbl;

	/* apcWriteRegister(devNum, rPMTA_0+4*i, APC_NULL); */

	lut2Addr = APC_LUT2_INDEX(devNum,pmInfo->mphy,pmInfo->vpi);
	lut2Entry = APC_RD_LUT2_ENTRY(devNum,pmInfo->mphy,pmInfo->vpi);
	/* connection type - if S == 0 -> VC switched */
	connType = ((lut2Entry & APC_LUT2_S_VPC) ? APC_VP_FLAG : APC_VC_FLAG);
	if (connType == APC_VC_FLAG && (pmInfo->vci == F4_SEG_VCI || pmInfo->vci == F4_E2E_VCI))
	{
		/* case A in the Arch spec. */

		if (pmInfo->pFlow_seg == 1)
		{
			pmTbl.PMFlow = LUTOAMSeg;
		} else {
			pmTbl.PMFlow = LUTOAME2E;
		}
		/* prg pmBackRep, pmDataEN, pmBlkSize */
		pmTbl.PMBackRep = pmInfo->BackRep;
		pmTbl.PMDataEn = pmInfo->DataEn;
		pmTbl.PMBlkSize = pmInfo->BlkSize;
		pmTbl.PMAltProc = (u8)NULL;

		if (pmInfo->sink)
		{
			pmTbl.PMMode = 0; /* mode is sink */
			pmxsnk = pmInfo->pmx_sink;
			apcSetPMTbl(devNum, SET_ALL, pmxsnk, &pmTbl);
		}

		if (pmInfo->source)
		{
			pmTbl.PMMode = 1; /* mode is source */
			pmxsrc = pmInfo->pmx_src;
			apcSetPMTbl(devNum, SET_ALL, pmxsrc, &pmTbl);
			apcWriteConnInfo_Eg(devNum, vcEntry, pmInfo->pmx_src, EPMX);
		}

		return APC_SUCCESS;
	}
	if(pmInfo->oamSeg)
	{
		if(pmInfo->sink && pmInfo->source)
		{
			/* case b & h */
			pmTbl.PMMode = 0; /* set the mode to sink for this process */
			pmTbl.PMFlow = LUTOAMSeg;
			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			if(pmInfo->pFlow_seg && pmInfo->pFlow_end)
			{
				/* case h */
				pmTbl.PMAltProc = pmInfo->pmx_src;
			} else {
				if(pmInfo->pFlow_seg && (pmInfo->pFlow_end == 0))
				{
					/* case b */
					pmTbl.PMAltProc = pmInfo->pmx_src;
				}
			}
			pmx = pmInfo->pmx_sink;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			pmTbl.PMMode = 1; /* set the mode to source for this process */
			pmx = pmInfo->pmx_src;
			if(pmInfo->pFlow_end)
			{
				/* program for case h */
				pmTbl.PMFlow = LUTOAME2E;
				pmTbl.PMBackRep = 1; /* always on */
				pmTbl.PMDataEn = 1; /* always on */
			} else {
				if(pmInfo->pFlow_seg)
				{
					pmTbl.PMFlow = LUTOAMSeg;
					pmTbl.PMBackRep = pmInfo->BackRep;
					pmTbl.PMDataEn = pmInfo->DataEn;
				}
			}
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmTbl.PMAltProc = (u8)NULL;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			/* configure the PMX in the EVT to start OAM PM processing */
			if(pmInfo->pFlow_seg && (pmInfo->pFlow_end == 0))
			{
				apcWriteConnInfo_Eg(devNum, vcEntry, pmInfo->pmx_src, EPMX);
			} else if(pmInfo->pFlow_seg && pmInfo->pFlow_end)
			{
				apcWriteConnInfo_Eg(devNum, vcEntry, (u32)NULL, EPMX);
			}
			return APC_SUCCESS;
		}
		if(pmInfo->sink == 1 && pmInfo->source == 0)
		{
			/* case c */
			pmTbl.PMMode = 0; /* set the mode to sink */
			pmTbl.PMFlow = LUTOAMSeg;
			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmTbl.PMAltProc = (u8)NULL;
			pmx = pmInfo->pmx;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			/* configure the PMX in the EVT to start OAM PM processing */
			apcWriteConnInfo_Eg(devNum, vcEntry,(u32) NULL, EPMX);
			return APC_SUCCESS;
		}
		if(pmInfo->sink == 0 && pmInfo->source == 1)
		{
			/* case d & g */
			pmTbl.PMMode = 1;
			if (pmInfo->pFlow_seg)
			{
				pmTbl.PMFlow = LUTOAMSeg;
			} else {
				if (pmInfo->pFlow_end)
				{
					pmTbl.PMFlow = LUTOAME2E;
				}
			}
			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmTbl.PMAltProc = pmInfo->pmx;
			pmx = pmInfo->pmx;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			/* configure the PMX in the EVT to start OAM PM processing */
			if (pmInfo->pFlow_seg)
			{
				apcWriteConnInfo_Eg(devNum, vcEntry, pmx, EPMX);
			} else {
				if (pmInfo->pFlow_end)
				{
					apcWriteConnInfo_Eg(devNum, vcEntry, (u32)NULL, EPMX);
				}
			}
			return APC_SUCCESS;
		}
	}
	/* case e, f and g */
	if(pmInfo->source == 1)
	{
		if(pmInfo->pFlow_seg && pmInfo->pFlow_end)

		{
			pmTbl.PMMode = 1; /* set the mode to source */
			pmTbl.PMFlow = 0; /* Flow set to Segment */
			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmTbl.PMAltProc = pmInfo->pmx_end;
			pmx = pmInfo->pmx_seg;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			/* configure the PMX in the EVT to start OAM PM processing */
			pmTbl.PMMode = 1; /* set the mode to source */
			pmTbl.PMFlow = 1; /* Flow set to End */
			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmTbl.PMAltProc = (u8)NULL;
			pmx = pmInfo->pmx_end;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			apcWriteConnInfo_Eg(devNum, vcEntry, (u32)NULL, EPMX);
			return APC_SUCCESS;
		} else {
			/* only one source process to program - case f & g */
			pmTbl.PMMode = 1; /* set the mode to source */
			if (pmInfo->pFlow_seg)
			{
				pmTbl.PMFlow = LUTOAMSeg;
				pmTbl.PMAltProc = (u8)NULL;
			} else if (pmInfo->pFlow_end)
			{
				pmTbl.PMFlow = LUTOAME2E;
				pmTbl.PMAltProc = pmInfo->pmx;
			}

			pmTbl.PMBackRep = pmInfo->BackRep;
			pmTbl.PMDataEn = pmInfo->DataEn;
			pmTbl.PMBlkSize = pmInfo->BlkSize;
			pmx = pmInfo->pmx;
			apcSetPMTbl(devNum, SET_ALL, pmx, &pmTbl);
			/* configure the PMX in the EVT to start OAM PM processing */
			apcWriteConnInfo_Eg(devNum, vcEntry, (u32)NULL, EPMX);
			return APC_SUCCESS;
		}
	}
	return APC_ERRORGENERIC;
}

/*******************************************************************************
 *
 * Description:	Read PM Table Field information from PM Table.
 *
 * Input:	devNum, PMX, Field
 *
 * Output:	Value of PMTbl_Field in u32
 *
 ******************************************************************************/

u32
apcReadPMTblField(u8 devNum, INT pmx, u32 PMTbl_Field)
{

	u32	data[1];
	u32	wordnum, mask, pos;

	data[0] = apcReadRegister(devNum, rPMTA_0+4*pmx);

	wordnum = PMTblFields[PMTbl_Field].wordnum;
	pos = PMTblFields[PMTbl_Field].position;
	mask = PMTblFields[PMTbl_Field].mask;

	return((data[wordnum] & mask) >> pos);

} /* End of Function apcReadPMTblField() */

/*******************************************************************************
 *
 * Description:	Write PM Table Field information to the PM Table.
 *
 * Input:	pmx, value to be written
 *
 * Output:	none
 *
 ******************************************************************************/

ApcRtn_t
apcWritePMTblField(u8 devNum, INT pmx, u32 value, u32 PMTbl_Field)
{

	u32	data[1];
	u32	wordnum, mask, pos;

	data[0] = apcReadRegister(devNum, rPMTA_0+4*pmx);

	wordnum = PMTblFields[PMTbl_Field].wordnum;
	pos = PMTblFields[PMTbl_Field].position;
	mask = PMTblFields[PMTbl_Field].mask;

	data[wordnum] = (data[wordnum] & ~mask) | (value<<pos);
	apcWriteRegister(devNum, rPMTA_0+4*pmx, data[0]);


	return (APC_SUCCESS);

} /* End of function apcWritePMTblField() */

/*******************************************************************************
 *
 * Function Name:	INT apcGetLUX3OAMField(u8 devNum, int oam_field, u32 lut3Addr)
 *
 * Description:		Call to get the value of the OAM_Field in the LUT3 OAM
 *			entry
 *
 * Return:		LUT3OAMField
 *
 ******************************************************************************/

INT
apcGetLUX3OAMField( u8 devNum, int oam_field, u32 lut3Addr)
{
	int	lux3OAMfield;
	u32	lut3OamEntry;
	LUT3_OAM_t	lut3oam;

	lut3OamEntry = apcReadCRAM(devNum, apcLUT3BaseAddr[devNum]+lut3Addr);
#ifdef	APC_PRINT_LUX3OAM
	printf("lut3oamEntry = 0x%08x \n", lut3OamEntry);
#endif	/*APC_PRINT_LUX3OAM*/
	APC_GET_LUT3_OAM(lut3oam, lut3OamEntry);

	switch (oam_field)
	{
	case LUX3_OAMSEG:
		lux3OAMfield = lut3oam.oam_seg;
		break;

	case LUX3_PMXSINK:
		lux3OAMfield = lut3oam.pmx_sink;
		break;

	case LUX3_FMSTATE:
		lux3OAMfield = lut3oam.fm_state;
		break;

	case LUX3_FMDEFTYP:
		lux3OAMfield = lut3oam.fm_deftype;
		break;

	case LUX3_CCSRC:
		lux3OAMfield = lut3oam.cc_src;
		break;

	case LUX3_CCSINK:
		lux3OAMfield = lut3oam.cc_sink;
		break;

	case LUX3_CCFLOWTYP:
		lux3OAMfield = lut3oam.cc_ftype;
		break;

	case LUX3_TIMER:
		lux3OAMfield = lut3oam.timer;
		break;

	case LUX3_OAME2ECAP:
		lux3OAMfield = lut3oam.oam_e2e;
		break;

	case LUX3_PMXSRC:
		lux3OAMfield = lut3oam.pmx_src;
		break;

	case LUX3_CCXMT:
		lux3OAMfield = lut3oam.cc_xmit;
		break;

	default:
		lux3OAMfield = -1;
		break;

	}

	return lux3OAMfield;
}

/******************************************************************************/