📄 hal_int.c

📁 一款SmartPhone的驱动代码
💻 C
字号:
/************************************************************************
;  	HAL_INT.C
;
;	The routines in this file comprise the interrupt handle
;
;	The Function is basic operation of LCDC
;
; 	Copyright (c) 2002 Epson Research and Development, Inc.
;
;  	All Rights Reserved.
;	2002.11.12	D Eric 		Start.					
;														
;************************************************************************/
#include "sysLCDC.h"

/**********************************************************************************
; Function:	set camera interrupt enable status
; Input:	enable	TRUE means interrupt enabled
;					FALSE means interrupt disabled
; Output:	n/a
; Format:	void CamIntEnSet( BOOL enable )
;**********************************************************************************/
void CamIntEnSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	interruptCtl &= (~0x0008);
	interruptCtl |= (unsigned short)(enable << 3);
	halWriteReg16( REG0A02_INTERRUPT_CTRL0, interruptCtl );
}

/**********************************************************************************
; Function:	get camera interrupt enable status
; Input:	n/a
; Output:	TRUE means interrupt enabled
;			FALSE means interrtup disabled
; Format:	BOOL CamIntEnGet( void )
**********************************************************************************/
BOOL CamIntEnGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	BOOL enable = (BOOL)((interruptCtl >> 3) & TRUE);
	return ( enable );
}



/**********************************************************************************
; Function:	set camera interrupt manual status
; Input:	enable	TRUE means interrupt set
;					FALSE means interrupt cleared
; Output:	n/a
; Format:	void CamIntManualSet( BOOL enable )
;**********************************************************************************/
void CamIntManualSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	interruptCtl &= (~0x0008);
	interruptCtl |= (unsigned short)(enable << 3);
	halWriteReg16( REG0A04_INTERRUPT_CTRL1, interruptCtl );
}

/**********************************************************************************
; Function:	get camera interrupt manual status
; Input:	n/a
; Output:	TRUE means interrupt set
;			FALSE means interrtup cleared
; Format:	BOOL CamIntManualGet( void )
;**********************************************************************************/
BOOL CamIntManualGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	BOOL enable = (BOOL)((interruptCtl >> 3) & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set camera interrupt status
; Input:	enable	TRUE means interrupt exists
;					FALSE means interrtup does not currently exist
; Output:	n/a
; Format:	void JpegCamIntStatusSet( BOOL enable )
;**********************************************************************************/
void CamIntStatusSet( BOOL enable )
{
	unsigned short interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	interruptStatus &= (~0x0008);
	interruptStatus |= (unsigned short )(enable << 3);
	halWriteReg16( REG0A00_INTERRUPT_STATUS, interruptStatus );
}

/**********************************************************************************
; Function:	get camera interrupt status
; Input:	n/a
; Output:	TRUE means interrupt exists
;			FALSE means interrtup does not currently exist
; Format:	BOOL JpegCamIntStatusGet( void )
;**********************************************************************************/
BOOL CamIntStatusGet( void )
{
	unsigned short interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	BOOL enable = (BOOL)((interruptStatus >> 3) & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set debug interrupt enable status
; Input:	enable	TRUE means interrupt enabled
;					FALSE means interrtup disabled
; Output:	n/a
; Format:	void DebugIntEnSet( BOOL enable )
;**********************************************************************************/
void DebugIntEnSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	interruptCtl &= (~TRUE);
	interruptCtl |= (unsigned short )enable;
	halWriteReg16( REG0A02_INTERRUPT_CTRL0, interruptCtl );
}

/**********************************************************************************
; Function:	get debug interrupt enable status
; Input:	n/a
; Output:	TRUE means interrupt enabled
;			FALSE means interrupt disabled
; Format:	BOOL DebugIntEnGet( void )
;**********************************************************************************/
BOOL DebugIntEnGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	BOOL enable = (BOOL)(interruptCtl & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set debug interrupt manual status
; Input:	enable	TRUE means interrupt set
;					FALSE means interrupt cleared
; Output:	n/a
; Format:	void DebugIntManualSet( BOOL enable )
;**********************************************************************************/
void DebugIntManualSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	interruptCtl &= (~TRUE);
	interruptCtl |= (unsigned short)enable;
	halWriteReg16( REG0A04_INTERRUPT_CTRL1, interruptCtl );
}

/**********************************************************************************
; Function:	get debug interrupt manual status
; Input:	n/a
; Output:	TRUE means interrupt set
;			FALSE means interrtup cleared
; Format:	BOOL DebugIntManualGet( void )
;**********************************************************************************/
BOOL DebugIntManualGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	BOOL enable = (BOOL)(interruptCtl & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set debug interrupt status
; Input:	enable	TRUE means interrupt exists
;					FALSE means interrtup does not currently exist
; Output:	n/a
; Format:	void DebugIntStatusSet( BOOL enable )
;**********************************************************************************/
void DebugIntStatusSet( BOOL enable )
{
	unsigned short interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	interruptStatus &= (~TRUE);
	interruptStatus |= (unsigned short )enable;
	halWriteReg16( REG0A00_INTERRUPT_STATUS, interruptStatus );
}

/**********************************************************************************
; Function:	get debug interrupt status
; Input:	n/a
; Output:	TRUE means interrupt exists
;			FALSE means interrtup does not currently exist
; Format:	BOOL DebugIntStatusGet( void )
;**********************************************************************************/
BOOL DebugIntStatusGet( void )
{
	unsigned short  interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	BOOL enable = (BOOL)(interruptStatus & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set JPEG interrupt enable status
; Input:	enable	TRUE means interrupt enabled
;					FALSE means interrupt disabled
; Output:	n/a
; Format:	void JpegIntEnSet( BOOL enable )
;**********************************************************************************/
void JpegIntEnSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	interruptCtl &= (~0x0004);
	interruptCtl |= (unsigned short)(enable << 2);
	halWriteReg16( REG0A02_INTERRUPT_CTRL0, interruptCtl );
}

/**********************************************************************************
; Function:	get JPEG interrupt enable status
; Input:	n/a
; Output:	TRUE means interrupt enabled
;			FALSE means interrtup disabled
; Format:	BOOL JpegIntEnGet( void )
;**********************************************************************************/
BOOL JpegIntEnGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A02_INTERRUPT_CTRL0 );
	BOOL enable = (BOOL)((interruptCtl >> 2) & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set JPEG interrupt manual status
; Input:	enable	TRUE means interrupt set
;					FALSE means interrupt cleared
; Output:	n/a
; Format:	void JpegIntManualSet( BOOL enable )
;**********************************************************************************/
void JpegIntManualSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	interruptCtl &= (~0x0004);
	interruptCtl |= (unsigned short)(enable << 2);
	halWriteReg16( REG0A04_INTERRUPT_CTRL1, interruptCtl );
}

/**********************************************************************************
; Function:	get JPEG interrupt manual status
; Input:	n/a
; Output:	TRUE means interrupt set
;			FALSE means interrtup cleared
; Format:	BOOL JpegIntManualGet( void )
;**********************************************************************************/
BOOL JpegIntManualGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A04_INTERRUPT_CTRL1 );
	BOOL enable = (BOOL)((interruptCtl >> 2) & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set JPEG interrupt status
; Input:	enable	TRUE means interrupt exists
;					FALSE means interrtup does not currently exist
; Output:	n/a
; Format:	void JpegIntStatusSet( BOOL enable )
;**********************************************************************************/
void JpegIntStatusSet( BOOL enable )
{
	unsigned short interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	interruptStatus &= (~0x0004);
	interruptStatus |= (unsigned short )(enable << 2);
	halWriteReg16( REG0A00_INTERRUPT_STATUS, interruptStatus );
}

/**********************************************************************************
; Function:	get JPEG interrupt status
; Input:	n/a
; Output:	TRUE means interrupt exists
;			FALSE means interrtup does not currently exist
; Format:	BOOL JpegIntStatusGet( void )
;**********************************************************************************/
BOOL JpegIntStatusGet( void )
{
	unsigned short interruptStatus = halReadReg16( REG0A00_INTERRUPT_STATUS );
	BOOL enable = (BOOL)((interruptStatus >> 2) & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set YUV/RGB write buffer overflow
; Input:	enable	TRUE means flag is cleared
; Output:	n/a
; Format:	void YUVRGBWrBufOvFlSet( BOOL enable )
;**********************************************************************************/
void YUVRGBWrBufOvFlSet( BOOL enable )
{
	unsigned short debugStatus = halReadReg16( REG0A06_DEBUG_STATUS );
	debugStatus &= (~TRUE);
	debugStatus |= (unsigned short)enable;
	halWriteReg16( REG0A06_DEBUG_STATUS, debugStatus );
}

/**********************************************************************************
; Function:	get YUV/RGB write buffer overflow
; Input:	n/a
; Output:	TRUE means write buffer overflow
; Format:	BOOL YUVRGBWrBufOvFlGet( void )
;**********************************************************************************/
BOOL YUVRGBWrBufOvFlGet( void )
{
	unsigned short debugStatus = halReadReg16( REG0A06_DEBUG_STATUS );
	BOOL enable = (BOOL)(debugStatus & TRUE);
	return ( enable );
}

/**********************************************************************************
; Function:	set YUV/RGB write buffer overflow enable
; Input:	enable	TRUE means flag is cleared
; Output:	n/a
; Format:	void YUVRGBWrBufOvFlEnSet( BOOL enable )
;**********************************************************************************/
void YUVRGBWrBufOvFlEnSet( BOOL enable )
{
	unsigned short interruptCtl = halReadReg16( REG0A08_INTERRUPT_CTRL_DEBUG );
	interruptCtl &= (~TRUE);
	interruptCtl |= (unsigned short)enable;
	halWriteReg16( REG0A08_INTERRUPT_CTRL_DEBUG, interruptCtl );
}

/**********************************************************************************
; Function:	get YUV/RGB write buffer overflow enable
; Input:	n/a
; Output:	TRUE means write buffer overflow
; Format:	BOOL YUVRGBWrBufOvFlEnGet( void )
;**********************************************************************************/
BOOL YUVRGBWrBufOvFlEnGet( void )
{
	unsigned short interruptCtl = halReadReg16( REG0A08_INTERRUPT_CTRL_DEBUG );
	BOOL enable = (BOOL)(interruptCtl & TRUE);
	return ( enable );
}
⌨️ 快捷键说明

复制代码 Ctrl + C
搜索代码 Ctrl + F
全屏模式 F11
切换主题 Ctrl + Shift + D
显示快捷键 ?
增大字号 Ctrl + =
减小字号 Ctrl + -