md.c

dvr

/*
	Vineyard Technologies, Inc.

	*	MD header file
		file name:	md.c
		Author:		Owen Kwon
		history:	12/31/03	initial, start

	*	Introduction
		Implementation of MD

	*	compile option
		VY_MD
			include MD module
		VY_MD_DEBUG_AREA
			print coordinates of one block area
		VY_MD_DEBUG_INT
			print interrupt service status
*/

#include "types.h"

#ifdef	VY_MD

///////////////////////////////////////////////////////////////////////////////
//	includes
#include "md.h"
#include "absacc.h"
#include "gio.h"
#include "eprom.h"
#include "stdio.h"
#include "tw2804.h"
#ifdef USE_4954_GP
#include "cs4954.h"
#endif

#ifdef G1PMD

WORD g1p_md_get_block_count(u8 *ch_num);
u8 g1p_md_get_max_difference(void);
u8 g1p_conv_16x24_to_16x32(u8 y);
u8 g1pMDreg_read(u8 addr);
void g1pMDreg_write(u8 addr, u8 value);
void g1p_md_reg_set_area(BYTE ch);
void g1p_md_enable(BOOL enable);
BOOL g1p_md_is_detected(u8 cmd);

//
//	G1P MD indirect mode address and data registers
//	assuming the G1P base register address base is 0x8000
//
#define	MD_ADDRESS_REGISTER	XBYTE[0x8016]
#define	MD_DATA_REGISTER	XBYTE[0x8017]

//	G1P MD registers
//	general
#define	MD_BCL				0x0A
#define	MD_BCH				0x0B
#define	MD_DMAXL			0x0C
#define	MD_DMAXH			0x0D
	
#endif // G1PMD


///////////////////////////////////////////////////////////////////////////////
//	extern variables
extern xdata BYTE gv_NTSC_PAL;

///////////////////////////////////////////////////////////////////////////////
//	Global Variables: public

//	md levels
xdata BYTE	mdgv_md_sensitivity_levels[4] = {0,0,0,0};
	//	sensitivity level set indexes

//	md area : value unit is based on 16 x 24 font and saved into EPROM directly 
xdata BYTE mdgv_md_areas[4][2][4] = {
					{{0,0,0,0},{0,0,0,0}},	//	channel 0
					{{0,0,0,0},{0,0,0,0}},	//	channel 1
					{{0,0,0,0},{0,0,0,0}},	//	channel 2
					{{0,0,0,0},{0,0,0,0}}};	//	channel 3
	//	{	0:block 0, upper-left point x,
	//		1:block 0, upper-left point y,
	//		2:block 0, lower-right point x,
	//		3:block 0, lower-right point y,
	//		4:block 1, upper-left point x,
	//		5:block 1, upper-left point y,
	//		6:block 1, lower-right point x,
	//		7:block 1, lower-right point y}
	//	set for each channel

//	md detected channel
xdata BYTE	mdgv_channel_detected = 0; // "default No Channel"
	//		bit[0]:	channel 0
	//		bit[1]:	channel 1
	//		bit[2]:	channel 2
	//		bit[3]:	channel 3
	//		bit[7~4]: don't care

//	md enable/disable status
xdata BYTE	mdgv_md_active_ch_stat = 0;
	//	indicates md enable/disable status
	//		bit[0]:	channel 0
	//		bit[1]:	channel 1
	//		bit[2]:	channel 2
	//		bit[3]:	channel 3
	//		bit[7~4]: don't care

xdata BYTE	mdgv_md_enabled = 0;

///////////////////////////////////////////////////////////////////////////////
//	Global Variables: private
#ifdef G1PMD
static xdata BYTE mdgvp_md_sensitivity_level_set[MD_SENSITIVITY_LEVEL_MAX] 
	= {0x00,0x99,0x77,0x56,0x55,0x46,0x45,0x44,0x34,0x33};
//	{bit[7~4]:mean, bit[3~0]:mean variant} pair for each channel
//	level description
//				mean	mean variant	remark
//	-----------+-------+---------------+-----------
//	level 0:	0		0				disable
//	level 1:	9		9				
//	level 2:	7		7
//	level 3:	5		6
//	level 4:	5		5
//	level 5:	4		6
//	level 6:	4		5
//	level 7:	4		4
//	level 8:	3		4
//	level 9:	3		3				most sensitive

#endif

#ifdef TW2804
static xdata BYTE mdgvp_md_sensitivity_level_set[MD_SENSITIVITY_LEVEL_MAX] =
		// Field Description
		// bit[7~4]:LVLSENS, bit[3~2]:TMPSENS, bit[1~0]:SPTSENS
/*		
		//				Level		Temp	Special
		//				-----		----	-------
		//				0000 		00 		00
		{	0x00,	// 	Off			Off		Off
			0x5B,	//	1010		10		11
			0x4B,	//	1000		10		11
			0x3B,	//	0110		10		11
			0x2B,	//	0100		10		11
			0x1B	//	0010		10		11
		};	// TechWell's recommended value
*/

		//				Level		Temp	Special
		//				-----		----	-------
		//				0000 		00 		00
		{	0x00,	// 	Off			Off		Off
			0x5E,	//	1010		11		10
			0x4E,	//	1000		11		10
			0x3E,	//	0110		11		10
			0x2E,	//	0100		11		10
			0x1E	//	0010		11		10
		};	// Owen's value - 1

/*

		//				Level		Temp	Special
		//				-----		----	-------
		//				0000 		00 		00
		{	0x00,	// 	Off			Off		Off
			0xa7,	//	1010		01		11
			0x87,	//	1000		01		11
			0x67,	//	0110		01		11
			0x47,	//	0100		01		11
			0x27	//	0010		01		11
		}; // Steve's value
*/		

#define MD_MPERIOD 5
//	md enable channel status
static xdata BYTE	mdgvp_channel_enable_mask = 0x0F;
void tw2804_md_reg_set_area(BYTE ch);
void tw2804_md_enable(BOOL enable);
BOOL tw2804_md_is_detected(void);
#endif

/*/////////////////////////////////////////////////////////
	void md_eprom_write(BYTE ch)

	* save md info. at the eprom for a channel specified
		ch		:	BYTE, channel number [0~3]
	* remark
		writes md info. of the specified channel
		area : mdgv_md_areas will be saved
		level: mdgv_md_sensitivity_levels will be saved
/////////////////////////////////////////////////////////*/
void md_eprom_write(BYTE ch)
{
	xdata BYTE offset_base = ch*0x09 + EPROM_MD_OFFSET;
	xdata BYTE i,j;
	// write area info.
	for(i=0;i<2;i++)
		{
		for(j=0;j<4;j++)
			{
			EPROM_SetUp_data_Write(offset_base+i*4+j, mdgv_md_areas[ch][i][j]);
			}
		}
	// write sensitivity level
	EPROM_SetUp_data_Write(offset_base+8, mdgv_md_sensitivity_levels[ch]);
}

/*/////////////////////////////////////////////////////////
	void md_eprom_read(BYTE ch)

	* retrieve md info. from the eprom for a channel specified
		ch		:	BYTE, channel number [0~3]
	* remark
		writes md info. of the specified channel
		area info will be copied to mdgv_md_areas
		level will be copied to mdgv_md_sensitivity_levels
/////////////////////////////////////////////////////////*/
void md_eprom_read(BYTE ch)
{
	xdata BYTE offset_base = ch*0x09 + EPROM_MD_OFFSET;
	xdata BYTE i,j;
	// write area info.
	for(i=0;i<2;i++)
		{
		for(j=0;j<4;j++)
			{
			mdgv_md_areas[ch][i][j] = EPROM_SetUp_data_Read(offset_base+i*4+j);
			}
		}
	// read sensitivity level
	mdgv_md_sensitivity_levels[ch] = EPROM_SetUp_data_Read(offset_base+8);
}

/*/////////////////////////////////////////////////////////
	void md_reg_set_area(BYTE ch)

	* set md area for each channel
		ch		:	BYTE, channel number [0~3]
	* scope	public
	* remark
		global variable mdgv_md_areas[ch][..] should be set
		before calling this function
/////////////////////////////////////////////////////////*/
void md_reg_set_area(BYTE ch)
{
	#ifdef TW2804
	tw2804_md_reg_set_area(ch);
	#endif

	#ifdef G1PMD
	g1p_md_reg_set_area(ch);
	#endif
}


/*/////////////////////////////////////////////////////////
	BOOL md_init(void)

	* load md area data from eprom and write md registers
	* remark
		n/a
/////////////////////////////////////////////////////////*/
void md_init(void)
{
	xdata BYTE i;
	for(i=0;i<4;i++)
	{
		md_eprom_read(i);
		md_reg_set_area(i);
	}
}

/*/////////////////////////////////////////////////////////
	BOOL md_reset(void)

	* reset md
	* remark
		all md configuration set to 0
/////////////////////////////////////////////////////////*/
void md_reset(void)
{
	xdata	BYTE	ch;
	for(ch=0;ch<4;ch++)
	{
		mdgv_md_sensitivity_levels[ch] = 0;
		mdgv_md_areas[ch][0][0] =	9;
		mdgv_md_areas[ch][0][1] =	5;
		mdgv_md_areas[ch][0][2] =	18;
		mdgv_md_areas[ch][0][3] =	9;
		mdgv_md_areas[ch][1][0] =	27;
		mdgv_md_areas[ch][1][1] =	10;
		mdgv_md_areas[ch][1][2] =	36;
		mdgv_md_areas[ch][1][3] = 	14;
		md_eprom_write(ch);
		md_reg_set_area(ch);
	}
}

BOOL md_is_enabled(void)
{
	return mdgv_md_enabled;
}

/*/////////////////////////////////////////////////////////
	void md_enable(BOOL enable)

	* enable/disable md
		enable	:	BOOL, 1: enable md, 0: disable md
	* remark
		global variable mdgv_md_sensitivity_levels[ch] should
		be set properly before calling this function
/////////////////////////////////////////////////////////*/
void md_enable(BOOL enable)
{
#ifdef DEBUG_MD_DETECT
	printf("\n\rmd_enable: %s", (enable)?"TRUE":"----");
#endif	
#ifdef TW2804
	tw2804_md_enable(enable);
#endif
#ifdef G1PMD
	g1p_md_enable(enable);
#endif	
}

/*/////////////////////////////////////////////////////////
	BOOL md_is_detected(u8 cmd)

	* check see if MD is detected or not
	* return value
		TRUE:	there's detected channel
		FALSE:	no MD detected
	* remark
		after calling this function, the global variable
		mdgv_channel_detected will be set
/////////////////////////////////////////////////////////*/
BOOL md_is_detected(u8 cmd)
{
	BOOL ret;
#ifdef TW2804
	cmd++;
	ret = tw2804_md_is_detected();
#endif
	
#ifdef G1PMD
	ret = g1p_md_is_detected(cmd);
#endif
	return ret;
}






//=============================================================================
//
//=============================================================================
//
//=============================================================================






#ifdef G1PMD


//=============================================================================
//	* retrieve the number of blocks detected
//=============================================================================
WORD g1p_md_get_block_count(u8 *ch_num)
{
	xdata BYTE temp;
	xdata WORD detected_blk_cnt;

	// block count of the detected
	detected_blk_cnt = g1pMDreg_read(MD_BCL);
	temp = g1pMDreg_read(MD_BCH);
	detected_blk_cnt |= ((WORD)(temp&0x03))<<8;

	// channel id of detect block (bit4 and bit5)
	*ch_num = (temp&0x30)>>4;
	
	return detected_blk_cnt;

}

//=============================================================================
//	* retrieve the maximum differences
//		maximum difference for mean
//		maximum difference for mean variant
//=============================================================================