sfli2310.c

Fil2310.c De-interlace芯片源码

/*------------------------------------------------------------------------
--  Copyright 2003 by Silicon Optix Inc.  All rights reserved. 
--
--  This document contains proprietary and confidential information of
--  Silicon Optix Inc. Distribution, copying, disclosure, or incorporation
--  in other material in whole, in part, or modified form is strictly 
--  prohibited without written permission from Silicon Optix Inc. 
--  Use of this information must be in accordance with the Silicon Optix
--  Software Licensing Agreement. If this information is received in error, 
--  please delete and notify us immediately.
--
------------------------------------------------------------------------
-- File Name  : sFli2310.c
-- Purpose    : 
--            :
------------------------------------------------------------------------
-- Revision History:
------------------------------------------------------------------------
-- <See $Log at end for detailed CVS history>
-- 
-- Creator's Name : Hung Nguyen
-- Creation Date  : Nov. 28, 2003
-- Comment        : 
--
-- Revision   : 
-- Name       : 
-- Date       :
-- Comment    :
--                                                                   
*-------------------------------------------------------------------------
$Id: sFli2310.c,v 1.2 2003/10/16 17:39:16 Hung Exp $
*/

#define SFLI2310_C
/****************************************************************************/
/*  I N C L U D E    F I L E S                                                       */
/****************************************************************************/

#include "main/aConfig.h"
#include "main/aGlobal.h"
#ifdef uI_NUCLEUS
#include	"nucleus.h"
#include	"Tc_defs.h"
#endif
#include "sd_defs.h"
#include "sd_extr.h"
#include "main/uItron/uI_types.h"
#include "main/uItron/uI_setm.h"
#include "main/uItron/uI_nplus.h"
#include "main/aInit.h"


#include "Driver.h"
#include "Driver/vdi/dvdi.h"
//#include "Driver/vdi/dvdi2.h"
#include "Driver/common/aDrvTsk.h"
#include "Driver/Uart/dUart.h"
#include "Driver/Uart/dUart1.h"
#include "Driver/Uart/dUart2.h"
#include "aLogTsk.h"

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "Image/Detect/sMode.h"
#include "Image/Detect/sPort.h"
#include "Image/Detect/sDetect.h"
#include "sFli2310.h"




#define DEFINE_APP_GLOBALS
#define DEFINE_APP_CFG_DATA
#define DEFINE_FLI2300_DRV_GLOBALS
#define DEFINE_FLI2300_CFG_DATA



#define     FIRMWARE_VERSION    "V1.1REL\n"
BYTE byWriteBurstDataFli2310(UWORD32 u32_reg_addr, VP vp_data,UWORD32 w32_len)
{
	tst_VDI_WRITE_CONFIG st_vdi_write_config;

	#ifdef Use_DRV_NONBLOCKING_OPTION
	st_vdi_write_config.t_blocking = BLOCKING;
	#endif
	
	st_vdi_write_config.t_change_priority = PRI_NO_CHANGE;
	st_vdi_write_config.u32_delay = 0;
	st_vdi_write_config.u32_max_count = 5;
	st_vdi_write_config.u32_reg_address = u32_reg_addr;
	st_vdi_write_config.u32_length = w32_len;
#if VDI_OPTION == VDI_2310
	return st_vdi_driver.Write(vp_data, &st_vdi_write_config, &st_vdi_driver);
#elif VDI2_OPTION == VDI_2310
	return st_vdi2_driver.Write(vp_data, &st_vdi_write_config, &st_vdi2_driver);
#else
	return ERR;
#endif
}
BYTE byWriteSingleDataFli2310(UWORD32 u32_reg_addr, BYTE by_data)
{
	return byWriteBurstDataFli2310(u32_reg_addr,&by_data,1);
}
BYTE byReadBurstDataFli2310(UWORD32 u32_reg_addr,VP vp_data,UWORD32 w32_len)
{
	tst_VDI_READ_CONFIG st_vdi_read_config;

	#ifdef Use_DRV_NONBLOCKING_OPTION
	st_vdi_read_config.t_blocking = BLOCKING;
	#endif

	st_vdi_read_config.t_change_priority = PRI_NO_CHANGE;
	st_vdi_read_config.u32_delay = 0;
	st_vdi_read_config.u32_max_count = 5;
	st_vdi_read_config.u32_reg_address = u32_reg_addr;
	st_vdi_read_config.u32_length = w32_len;
#if VDI_OPTION == VDI_2310
	return st_vdi_driver.Read(vp_data, &st_vdi_read_config, &st_vdi_driver);
#elif VDI2_OPTION == VDI_2310
	return st_vdi2_driver.Read(vp_data, &st_vdi_read_config, &st_vdi2_driver);
#else
	return ERR;
#endif
}
BYTE byReadSingleDataFli2310(UWORD32 u32_reg_addr, BYTE *byp_data)
{
	return byReadBurstDataFli2310(u32_reg_addr,byp_data,1);
}


//*******************************************************************************
// FUNCTION:	BYTE fli2300_SetRegisterPage(WORD regAddr)
//
// USAGE:		Sets the register page address
//
// DESCRIPTION:	extract page number from Reg addr and write to page selection
//				register
//				
// INPUT:		regAddr - register address
//
// OUTPUT:		0 - success
//				1 - failure
//
// GLOBALS:
//
// USED_REGS:
//*******************************************************************************
BYTE fli2300_SetRegisterPage(WORD regAddr)
{
	BYTE newPage,err;

	newPage = (regAddr >> 8) & 0x03;
	if (newPage != gB_Fli2300LastSelectedPage)
	{
		gB_Fli2300LastSelectedPage = newPage;
		err =byWriteSingleDataFli2310(FLI2300_PAGE_SEL_REGS, gB_Fli2300LastSelectedPage);
//		err = I2C_WriteArray(gB_Fli2300I2CId,0xFF,1,(BYTE *)&gB_Fli2300LastSelectedPage);
		return err;
	}
	return 0;

} // end - fli2300_SetRegisterPage

//*******************************************************************************
// FUNCTION:	BYTE fli2300_Read(WORD regAddr, BYTE nob, BYTE *value)
//
// USAGE:		Read given number of bytes from given regsiter address
//
// DESCRIPTION:	Set page
//				invoke register read
//
// INPUT:		regAddr - register address
//				nob		- number of bytes to be read (register length in bytes)
//				value	- address holding value read
//
// OUTPUT:		0 - success
//				1 - failure
//
// GLOBALS:
//
// USED_REGS:
//*******************************************************************************
BYTE fli2300_Read(WORD regAddr, BYTE nob, BYTE *value)
{
	BYTE err;

	err = fli2300_SetRegisterPage(regAddr);
	if (err != OK)
		return err;
	regAddr &= 0xFF;
	err = byReadSingleDataFli2310((UWORD32) regAddr, value);
	return err;

} // end - fli2300_Read


BYTE fli2300_Read08(WORD regAddr)
{
	BYTE value,err;

	if (fli2300_SetRegisterPage(regAddr) != OK)
		return ERR;
	regAddr &= 0xFF;
	err = byReadSingleDataFli2310((UWORD32) regAddr, &value);
	return value;

} // end - fli2300_Read08

WORD fli2300_Read16(WORD regAddr)
{
	WORD value;
	BYTE bya_data[2];
	if (fli2300_SetRegisterPage(regAddr) != OK)
		return ERR;
	regAddr &= 0xFF;
	byReadBurstDataFli2310((UWORD32) regAddr,bya_data,2);
	value =(WORD)( bya_data[1]<<8) |bya_data[0];
	return value;

} // end - fli2300_Read16



//*******************************************************************************
// FUNCTION:	BYTE fli2300_Write08(WORD regAddr,BYTE value)
//
// USAGE:		Write 8bit value to given register address
//
// DESCRIPTION:	Set page
//				invoke register write
//
// INPUT:		regAddr - register address
//				value	- value to be written
//
// OUTPUT:		0 - success
//				1 - failure
//
// GLOBALS:
//
// USED_REGS:
//*******************************************************************************
BYTE fli2300_Write08(WORD regAddr,BYTE value)
{
	BYTE err;

	err = fli2300_SetRegisterPage(regAddr);
	if (err != OK)
		return err;
	regAddr &= 0xFF;
	err = byWriteSingleDataFli2310((UWORD32)regAddr,value);
	return err;
} // end - fli2300_Write08


BYTE fli2300_Write16(WORD regAddr,WORD value)
{
	BYTE err;
	BYTE bya_data[2];

	bya_data[1] = (BYTE)((WORD)(value>>8));
	bya_data[0] = (BYTE)((WORD)(value));
	err = fli2300_SetRegisterPage(regAddr);
	if (err != OK)
		return err;

	regAddr &= 0xFF;
	err = byWriteBurstDataFli2310((UWORD32) regAddr, bya_data, 2);
	return err;

} // end - fli2300_Write16

BYTE fli2300_Write24(WORD regAddr,DWORD value)
{
	BYTE err;
	BYTE bya_data[3];

	bya_data[2] = (BYTE)((WORD)(value>>16));
	bya_data[1] = (BYTE)((WORD)(value>>8));
	bya_data[0] = (BYTE)((WORD)(value));

	err = fli2300_SetRegisterPage(regAddr);
	if (err != OK)
		return err;

	regAddr &= 0xFF;
	err = byWriteBurstDataFli2310((UWORD32) regAddr, bya_data, 3);
	return err;

} // end - fli2300_Write24

BYTE fli2300_Write32(WORD regAddr,DWORD value)
{
	BYTE err;

	BYTE bya_data[4];

	bya_data[3] = (BYTE)((WORD)(value>>24));
	bya_data[2] = (BYTE)((WORD)(value>>16));
	bya_data[1] = (BYTE)((WORD)(value>>8));
	bya_data[0] = (BYTE)((WORD)(value));

	err = fli2300_SetRegisterPage(regAddr);
	if (err != OK)
		return err;


	regAddr &= 0xFF;
	err = byWriteBurstDataFli2310((UWORD32) regAddr, bya_data, 4);
	return err;

} // end - fli2300_Write32

//*******************************************************************************
// FUNCTION:	void fli2300_InitDriver(void)
//
// USAGE:		Initializes all Fli2300 control register shadows to a known state
//				This function should be called before calling any driver routine
//
// DESCRIPTION:
//
// INPUT:		None
//
// OUTPUT:		None
//
// GLOBALS:
//
// USED_REGS:	None
//*******************************************************************************
void fli2300_InitDriver(void)
{
	gB_Fli2300FECtrl1Shadow = 0x00; 
	gB_Fli2300FECtrl2Shadow = 0x00;

	gB_Fli2300NRDCtrl0Shadow = 0x76;
	gB_Fli2300NRDCtrl1Shadow = 0x28;
	gB_Fli2300NRDCtrl2Shadow = 0x1B;
	gB_Fli2300NRDCtrl3Shadow = 0x68;
	gB_Fli2300NRDCtrl4Shadow = 0x47;
	gB_Fli2300NRDCtrl5Shadow = 0x0D;
	gB_Fli2300NRDCtrl7Shadow = 0x5D;
	gB_Fli2300NRDCtrl10Shadow = 0xE3;
	gB_Fli2300NRDCtrl11Shadow = 0x02;

	gB_Fli2300SDICtrl0Shadow = 0x00;

	gB_Fli2300ClkCtrl10Shadow = 0x00;
	gB_Fli2300ClkCtrl11Shadow = 0x00;
	gB_Fli2300ClkCtrl12Shadow = 0x00;

	gB_Fli2300BECtrl0Shadow = 0x09; // 0x00SOI change to 16bit YCrCb
	gB_Fli2300BECtrl1Shadow = 0x80;
	gB_Fli2300BECtrl2Shadow = 0x36;
	gB_Fli2300BECtrl5Shadow = 0x07;
	gB_Fli2300BECtrl7Shadow = 0x00;
	gB_Fli2300BECtrl9Shadow = 0x00;
	gB_Fli2300BECtrl11Shadow = 0x00;

	gB_Fli2300HECtrl0Shadow = 0x07;
	gB_Fli2300HECtrl1Shadow = 0x1F;
	gB_Fli2300HECtrl2Shadow = 0x00;

	gB_Fli2300VECtrl1Shadow = 0x08;

	gB_Fli2300VSCModeRegShadow = 0x00;

	gB_Fli2300HSCCtrl1Shadow = 0x02;

	gB_Fli2300SncCtrl0Shadow = 0x80;
	gB_Fli2300SncCtrl1Shadow = 0x1F;
	gB_Fli2300SncCtrl2Shadow = 0x00;

#ifdef _FLI2300_REV_BC_
	gB_Fli2300FieldFixCtrlShadow = 0x04 ; 
	gB_Fli2300PixLineDropCtrlShadow = 0x03 ; 
	gB_Fli2300FepMcvCtrl2Shadow = 0x18 ; 

	gB_Fli2300IntMaskCtrlShadow = 0x000000 ; 
	gB_Fli2300IntEdgeCtrlShadow = 0x000000 ; 
#endif //_FLI2300_REV_BC_
	g_CurrentAspectSetting =Aspect_Full2Full;
} // end - fli2300_InitDriver


//*******************************************************************************
// FUNCTION:	void fli2300_SetDeepSleepMode(void)
//
// USAGE:		This function puts the FLI2300 in deep sleep mode
//				Disable clock to all blocks, disables DAC, PLL
//
// DESCRIPTION:
//
// INPUT:		None
//
// OUTPUT:		None
//
// GLOBALS:
//
// USED_REGS:	None
// NOTE:
// To recover from Deep sleep mode the system needs a reset.
//*******************************************************************************
void fli2300_SetDeepSleepMode(void)
{
	// Disable all clocks