cpudma_if.c

epson usb2.0 控制芯片 S1R72V05 固件程序。

			CLR_BIT(CPU_IntEnb, CPUDMA_IF_DMA1_CMP);
		}

		if( event & CPUDMA_IF_DMA0_COUNTUP )
		{
			/* Make DMA1 Countup be invalid */
			RegClear(REG08_MainIntEnb,BIT_EnCPU_IntStat);
			CLR_BIT(CPU_IntEnb, CPUDMA_IF_DMA0_COUNTUP);
		}

		if( event & CPUDMA_IF_DMA0_CMP )
		{
			/* Make DMA1 Countup be invalid */
			RegClear(REG08_MainIntEnb,BIT_EnCPU_IntStat);
			CLR_BIT(CPU_IntEnb, CPUDMA_IF_DMA0_CMP);
		}
	}

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFRegisterCBRDMA1_Countup
// description	: Carry out registration of DMA1_Countup interrupt.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNABLE_TO_REGISTER
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFRegisterCBRDMA1_Countup ( const CALLBACK_PROC pfnCallback )
{
	/* Confirm whether it can be registered */
	if( CallbackTable[CBINF_DMA1_COUNTUP] != NULL )
	{
		return STATUS_UNABLE_TO_REGISTER;
	}

	/* Registration of call back function */
	CallbackTable[CBINF_DMA1_COUNTUP] = pfnCallback;

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFUnregisterCBRDMA1_Countup
// description	: Delete call back registered by CPUDMA_IFRegisterCBRDMA1_Countup.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNREGISTERED
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFUnregisterCBRDMA1_Countup ( const CALLBACK_PROC pfnCallback )
{
	RegClear(REG08_CPU_IntEnb,BIT_EnDMA1_CountUp);

	if( CallbackTable[CBINF_DMA1_COUNTUP] == pfnCallback )
	{
		/* Deleting of call back function */
		CallbackTable[CBINF_DMA1_COUNTUP] = NULL;
	}
	else
	{
		/* Can not delete */
		return STATUS_UNREGISTERED;
	}

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFRegisterCBRDMA0_Countup
// description	: Carry out registration of DMA0_Countup interrupt.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNABLE_TO_REGISTER
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFRegisterCBRDMA0_Countup ( const CALLBACK_PROC pfnCallback )
{
	/* Confirm whether it can be registered */
	if( CallbackTable[CBINF_DMA0_COUNTUP] != NULL )
	{
		return STATUS_UNABLE_TO_REGISTER;
	}

	/* Registration of call back function */
	CallbackTable[CBINF_DMA0_COUNTUP] = pfnCallback;

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFUnregisterCBRDMA0_Countup
// description	: Delete call back registered by CPUDMA_IFRegisterCBRDMA0_Countup.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNREGISTERED
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFUnregisterCBRDMA0_Countup ( const CALLBACK_PROC pfnCallback )
{
	RegClear(REG08_CPU_IntEnb,BIT_EnDMA0_CountUp);

	if( CallbackTable[CBINF_DMA0_COUNTUP] == pfnCallback )
	{
		/* Deleting of call back function */
		CallbackTable[CBINF_DMA0_COUNTUP] = NULL;
	}
	else
	{
		/* Can not delete */
		return STATUS_UNREGISTERED;
	}

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFRegisterCBRDMA1_Cmp
// description	: Carry out registration of DMA1_Cmp interrupt.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNABLE_TO_REGISTER
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFRegisterCBRDMA1_Cmp ( const CALLBACK_PROC pfnCallback )
{
	/* Confirm whether it can be registered */
	if( CallbackTable[CBINF_DMA1_CMP] != NULL )
	{
		return STATUS_UNABLE_TO_REGISTER;
	}

	/* Registration of call back function */
	CallbackTable[CBINF_DMA1_CMP] = pfnCallback;

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFUnregisterCBRDMA1_Cmp
// description	: Delete call back registered by CPUDMA_IFRegisterCBRDMA1_Cmp.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNREGISTERED
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFUnregisterCBRDMA1_Cmp ( const CALLBACK_PROC pfnCallback )
{
	RegClear(REG08_CPU_IntEnb,BIT_EnDMA1_Cmp);

	if( CallbackTable[CBINF_DMA1_CMP] == pfnCallback )
	{
		/* Deleting of call back function */
		CallbackTable[CBINF_DMA1_CMP] = NULL;
	}
	else
	{
		/* Can not delete */
		return STATUS_UNREGISTERED;
	}

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFRegisterCBRDMA0_Cmp
// description	: Carry out registration of DMA0_Cmp interrupt.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNABLE_TO_REGISTER
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFRegisterCBRDMA0_Cmp ( const CALLBACK_PROC pfnCallback )
{
	/* Confirm whether it can be registered */
	if( CallbackTable[CBINF_DMA0_CMP] != NULL )
	{
		return STATUS_UNABLE_TO_REGISTER;
	}

	/* Registration of call back function */
	CallbackTable[CBINF_DMA0_CMP] = pfnCallback;

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// description	: Delete call back function registered by CPUDMA_IFRegisterCBRDMA0_Cmp.
// argument 	: CALLBACK_PROC	pfnCallback	Call back function
//
// return		: LONG
//				  STATUS_SUCCESS
//				  STATUS_UNREGISTERED
////////////////////////////////////////////////////////////////////////
*/
LONG CPUDMA_IFUnregisterCBRDMA0_Cmp ( const CALLBACK_PROC pfnCallback )
{
	RegClear(REG08_CPU_IntEnb,BIT_EnDMA0_Cmp);

	if( CallbackTable[CBINF_DMA0_CMP] == pfnCallback )
	{
		/* Deleting of call back function */
		CallbackTable[CBINF_DMA0_CMP] = NULL;
	}
	else
	{
		/* Can not delete */
		return STATUS_UNREGISTERED;
	}

	return STATUS_SUCCESS;
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFInterruptProc
// description	: Interrupt function
// argument 	: UCHAR cpuIntEnb	Interrupt enable variable
//
// return		: none
////////////////////////////////////////////////////////////////////////
*/
void CPUDMA_IFInterruptProc ( UCHAR cpuIntEnb )
{
	/* Save interrupt status related to USB. */
	tempCPU_IntStat = (RegRead(REG08_CPU_IntStat) & ( CPU_IntEnb | RegRead(REG08_CPU_IntEnb)) );

	IntStat[IS_CPU_INT_STAT] |= tempCPU_IntStat;
	/* Elimination of interrupt status */
	RegWrite(REG08_CPU_IntStat,tempCPU_IntStat);

	/* Permision of interrupt enable */
	RegSet(REG08_CPU_IntEnb,cpuIntEnb | CPU_IntEnb);

	/* Carry out call back notification */
	CPUDMA_IFISRProcess();
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: CPUDMA_IFISRProcess
// description	:
//				: Initialize internal variable of Stream Interface Module, carry out hardware
//				  initialization.
// argument 	: none
//
// return		: none
////////////////////////////////////////////////////////////////////////
*/
void CPUDMA_IFISRProcess ( void )
{
	if( IntStat[IS_CPU_INT_STAT] != 0x00 )
	{
		/* DMA0 Cmp */
		if( CallbackTable[CBINF_DMA0_CMP] != NULL )
		{
			if( (IntStat[IS_CPU_INT_STAT] & MASK_DMA0_Cmp))
			{
				/* Interrupt status clearence */
				CLR_BIT( IntStat[IS_CPU_INT_STAT], BIT_DMA0_Cmp );
				CallbackTable[CBINF_DMA0_CMP]( 0, 0, NULL );
			}
		}

		/* DMA1 Cmp */
		if( CallbackTable[CBINF_DMA1_CMP] != NULL )
		{
			if( (IntStat[IS_CPU_INT_STAT] & MASK_DMA1_Cmp))
			{
				/* Interrupt status clearence */
				CLR_BIT( IntStat[IS_CPU_INT_STAT], BIT_DMA1_Cmp );
				CallbackTable[CBINF_DMA1_CMP]( 0, 0, NULL );
			}
		}

		/* DMA0 Countup */
		if( CallbackTable[CBINF_DMA0_COUNTUP] != NULL )
		{
			if( (IntStat[IS_CPU_INT_STAT] & MASK_DMA0_CountUp) != 0 )
			{
				/* Interrupt status clearence */
				CLR_BIT( IntStat[IS_CPU_INT_STAT], BIT_DMA0_CountUp );
				CallbackTable[CBINF_DMA0_COUNTUP]( 0, 0, NULL );
			}
		}

		/* DMA1 Countup */
		if( CallbackTable[CBINF_DMA1_COUNTUP] != NULL )
		{
			if( (IntStat[IS_CPU_INT_STAT] & MASK_DMA1_CountUp) != 0 )
			{
				/* Interrupt status clearence */
				CLR_BIT( IntStat[IS_CPU_INT_STAT], BIT_DMA1_CountUp );
				CallbackTable[CBINF_DMA1_COUNTUP]( 0, 0, NULL );
			}
		}
	}
}

/*
////////////////////////////////////////////////////////////////////////
// Function_Name: ModuleInit
// description	: Initialize this module.
//				: Initialize internal variable of this module,
//				  carry out hardware initialization.
// argument 	: none
//
// return		: none
////////////////////////////////////////////////////////////////////////
*/
void ModuleInit ( void )
{
	OS_BOOL bLocSts;
	// IC initialization

	RegWrite(REG08_CPU_IntStat,BIT_DMA0_Cmp | BIT_DMA1_Cmp | BIT_DMA0_CountUp | BIT_DMA1_CountUp);	// Clear interrupt
	RegClear(REG08_CPU_IntEnb,BIT_DMA0_Cmp | BIT_DMA1_Cmp | BIT_DMA0_CountUp | BIT_DMA1_CountUp);	// Clear interrupt enable

	bLocSts = OS_SnsLoc();	// Refer to CPU lock state
	if( bLocSts != TRUE )
	{
		OS_LocCpu();
	}

	// In case of DMA is acting, stop it.
	if((RegRead(REG08_DMA0_Control) & MASK_DMA_Running))
	{
		RegWrite(REG08_DMA0_Control,BIT_DMA_Stop);
		while((RegRead(REG08_CPU_IntStat) & MASK_DMA0_Cmp) == 0)
		{
			// Wait until DMA_Cmp bit raising
		}
	}
	if((RegRead(REG08_DMA1_Control) & MASK_DMA_Running))
	{
		RegWrite(REG08_DMA1_Control,BIT_DMA_Stop);
		while((RegRead(REG08_CPU_IntStat) & MASK_DMA1_Cmp) == 0)
		{
			// Wait until DMA_Cmp bit raising
		}
	}

	// Clear interrupt factor
	RegWrite(REG08_CPU_IntStat,BIT_DMA0_Cmp | BIT_DMA1_Cmp | BIT_DMA0_CountUp | BIT_DMA1_CountUp);	// Clear interrupt

	// Permision of main interrupt
	RegSet(REG08_MainIntEnb,BIT_EnCPU_IntStat);

	if( bLocSts != TRUE )
	{
		OS_UnlCpu();
	}

	RegWrite(REG08_DMA0_Control,BIT_CounterClr);
	RegWrite(REG08_DMA1_Control,BIT_CounterClr);

	RegWrite(REG08_D_DMA0_FIFO_Control,R8_ALLZERO);
	RegWrite(REG08_D_DMA1_FIFO_Control,R8_ALLZERO);

	RegWrite(REG08_DMA0_Config,R8_ALLZERO);
	RegWrite(REG08_DMA1_Config,R8_ALLZERO);


}