/* **************************************************************************************
 *  Copyright (c) 2004 ZORAN Corporation, All Rights Reserved
 *  THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF ZORAN CORPORATION
 *
 *  File: $Workfile: .c $             
 *
 * Description:
 * ============
 * 
 * 
 * Log:
 * ====
 * $Revision: $
 * Last Modified by $Author:  $ at $Modtime: $ 
 **************************************************************************************** */
#include "Config.h"		// Global Configuration - do not remove!

#ifdef FTA_SUPPORT

#ifdef SATELLITE_299

#include "Devices\Demodulator\0299\def.h"
#include "Devices\Demodulator\0299\0229.h"
#include "Devices\Demodulator\0299\reg0299.h"
#include "Devices\I2C\i2c.h"
#include "Kernel\Ker_API.h"
#include "Services\Include\_heap.h"

/******** AddReg  ************************************************************/
/*	Add a new register to the register map									 */
/*****************************************************************************/
void AddReg(DEMOD_HANDLE handle, int Id,char * Name,char Address,char Reset)
{
	REGISTER *pReg;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	
	pReg = &(sDemodData->RegMap[Id]);
	
	pReg->Addr	= Address;
	pReg->Reset	= Reset;
	pReg->Value	= 0x00;
}

/******** FieldCreateMask ****************************************************/
/*	Create the mask of the field according the informations store in the  	 */
/*	FIELD structure															 */
/*****************************************************************************/
unsigned char FieldCreateMask(DEMOD_HANDLE handle, int field)
{
	int i;
	unsigned char mask=0;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	
	/*	Create mask	*/
	for (i = 0; i < sDemodData->FieldMap[field].Bits; i++)
	{
		mask <<= 1 ;
		mask +=  1 ;
	}
	  
	mask = mask << sDemodData->FieldMap[field].Pos;
	
	return mask;
}

/******** AddField  **********************************************************/
/*	Add a field to the field map											 */
/*****************************************************************************/
void AddField(DEMOD_HANDLE handle, int RegId, int FieldId,char * Name, char Pos, char NbBits, char Type)
{
	FIELD *pField; 
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	
	pField = &(sDemodData->FieldMap[FieldId]);
	
	pField->Reg=	RegId;
	pField->Pos=	Pos;
	pField->Bits=	NbBits;
	pField->Type=	Type;
	pField->Mask=	FieldCreateMask(handle, FieldId);
}

/******** RegSetOneRegister **************************************************/
/*	Set Register value													  	 */
/*	INPUT :  data, register id												 */
/*****************************************************************************/
void RegSetOneRegister(DEMOD_HANDLE handle, int reg_id, unsigned char Data)   
{
	UINT8 i = 5;
	BOOL bRes = FALSE;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	while ( (FALSE == bRes) && (i != 0) )
	{
		bRes = i2c_write(DEMOD_WRITE_ID, sDemodData->RegMap[reg_id].Addr, Data);

		if (TRUE == bRes)
		{
			break;
		}

		Ker_SleepUs(10000UL);
		i--;
	} 

#ifdef _DEBUG
	if (FALSE == bRes)
	{
		tr_printf(("WARNING: RegSetOneRegister(%04x, %04x) FAILED!\n",
				   sDemodData->RegMap[reg_id].Addr, Data));
	}
#endif
	
	sDemodData->RegMap[reg_id].Value=Data;  
}

/******** RegGetOneRegister **************************************************/
/*	Get Register value													  	 */
/*	INPUT :  register id													 */
/*	RETURN :  data															 */     
/*****************************************************************************/
int RegGetOneRegister(DEMOD_HANDLE handle, int reg_id)         
{
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	UINT8 i = 5;
	BOOL bRes = FALSE;

	while ( (FALSE == bRes) && (i != 0) )
	{
		bRes = i2c_read(DEMOD_WRITE_ID, sDemodData->RegMap[reg_id].Addr, &(sDemodData->RegMap[reg_id].Value));

		if (TRUE == bRes)
		{
			break;
		}

		Ker_SleepUs(10000UL);
		i--;
	}

#ifdef _DEBUG
	if (FALSE == bRes)
	{
		tr_printf(("WARNING: RegGetOneRegister(%04x) FAILED!\n",
				   sDemodData->RegMap[reg_id].Addr));
	}
#endif
	
	return sDemodData->RegMap[reg_id].Value;
}

/******** RegSetRegisters *****************************************************/
/*	Set Registers values in burst mode 									  	 */
/*	INPUT : a buffer for data, first register address, last register address */
/*****************************************************************************/
void RegSetRegisters(DEMOD_HANDLE handle, int FirstReg, int NbRegs)
{
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	unsigned char *Data;
	UINT8 i = 5;
	BOOL bRes = FALSE;
		
	Data = (unsigned char *)MEM_Allocate(DEFAULT_HEAP, (NbRegs));
	
	/*	Read sDemodData->RegMap structure	*/
	for (i=0;i<NbRegs;i++)
	{
		Data[i]=sDemodData->RegMap[FirstReg+i].Value;
	}

	while ( (FALSE == bRes) && (i != 0) )
	{
		bRes = i2c_write_string(DEMOD_WRITE_ID, sDemodData->RegMap[FirstReg].Addr, NbRegs, Data, NbRegs);

		if (TRUE == bRes)
		{
			break;
		}

		Ker_SleepUs(10000UL);
		i--;
	} 

#ifdef _DEBUG
	if (FALSE == bRes)
	{
		tr_printf(("WARNING: RegSetRegisters(%04x) FAILED!\n",
				   sDemodData->RegMap[FirstReg].Addr));
	}
#endif

	MEM_Free(DEFAULT_HEAP, Data);
}

/******** RegGetRegisters ***************************************************/
/*	Get Registers values in burst mode 									  	*/
/*	INPUT : first register address, last register address 					*/
/****************************************************************************/
void RegGetRegisters(DEMOD_HANDLE handle, int FirstReg, int NbRegs)
{
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	unsigned char Data[16];
	UINT8 i = 5;
	BOOL bRes = FALSE;
	
    if (NbRegs > 16)
    {
        tr_printf(("RegGetRegisters: unexpected number of registers!!!\n"));
        return;
    }

	/* I2C access */
	while ( (FALSE == bRes) && (i != 0) )
	{
		bRes = i2c_read_string(DEMOD_WRITE_ID, sDemodData->RegMap[FirstReg].Addr, NbRegs, Data);

		if (TRUE == bRes)
		{
			break;
		}

		Ker_SleepUs(10000UL);
		i--;
	} 

#ifdef _DEBUG
	if (FALSE == bRes)
	{
		tr_printf(("WARNING: RegGetRegisters(%04x) FAILED!\n",
				   sDemodData->RegMap[FirstReg].Addr));
	}
#endif

	/* Update sDemodData->RegMap structure */
	for (i=0; i<NbRegs; i++)
	{
		sDemodData->RegMap[FirstReg+i].Value = Data[i];
	}
}

/******** RegReset ***********************************************************/
/*	Set Chip register values according Default Values stored in ValRegReset	 */
/*																			 */
/*****************************************************************************/
void RegReset( DEMOD_HANDLE handle )
{
	int reg ;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	for ( reg = 0 ; reg < NBREG ; reg++ )
	{
		RegSetOneRegister(handle, reg,sDemodData->RegMap[reg].Reset);
	}
}
  
/******** FieldSetVal ***************************************************************/
/*	Compute the new value of the register with the value of the field				*/
/*	Input : index of the field, value of the field			        				*/
/*	Output: NONE								  				      				*/
/************************************************************************************/
void FieldSetVal(DEMOD_HANDLE handle,int field, long fieldval)
{
	FIELD *pfield;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	
	pfield=&(sDemodData->FieldMap[field]);						/*	Just for code simplification	*/
	
	if(pfield->Type == DEMOD_SIGNED)
		fieldval = (fieldval > 0 ) ? fieldval : fieldval + (1<<pfield->Bits);	/*	compute signed fieldval	*/
  
	fieldval = pfield->Mask & (fieldval << pfield->Pos);	/*	Shift and mask value	*/
	sDemodData->RegMap[pfield->Reg].Value = (sDemodData->RegMap[pfield->Reg].Value & (~pfield->Mask)) + fieldval;	/*	Concat register value and fieldval	*/
}

/******** RegSetField ***********************************************************/
/*	Set Chip register bits of the field "field" to the value "value"			*/
/*	Input : index of the field and value to write						    	*/
/********************************************************************************/
void RegSetField(DEMOD_HANDLE handle, int field,int value)
{
	FIELD *pfield;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;
	
	pfield=&(sDemodData->FieldMap[field]);						/*	Just for code simplification   */
	RegGetOneRegister(handle,pfield->Reg);					/*	Read the register	*/
	FieldSetVal(handle,field,value);						/*	Compute new sDemodData->RegMap value */
	RegSetOneRegister(handle,pfield->Reg,sDemodData->RegMap[pfield->Reg].Value);      	/*	Write the register */
}

/******** FieldGetVal ***************************************************************/
/*	Compute the value of the field with the register value store in  REGMAP			*/
/*	Input : index of the field								        				*/
/*	Output: value of the field								        				*/
/************************************************************************************/
int FieldGetVal(DEMOD_HANDLE handle, int field)
{
	int value;
	FIELD *pfield;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	pfield = &(sDemodData->FieldMap[field]);						 /* Just for code simplification */
	value = (sDemodData->RegMap[pfield->Reg].Value & pfield->Mask) >> pfield->Pos;	/* Extract field */
	
	if ((pfield->Type == DEMOD_SIGNED) && (value & (1<<(pfield->Bits-1))))
	{
		/* Compute signed value */
		value = value - (1<<pfield->Bits);
	}
	
	return value;
}

/******** RegGetField ***************************************************************/
/*	Get Chip register Value (bitwise) then store Value in structure REGMAP			*/
/*	Input : index of the field								        				*/
/*	Output: value of the field								        				*/
/************************************************************************************/
int	 RegGetField(DEMOD_HANDLE handle, int field)
{
	FIELD *pfield;
	DEMOD_SAT_DATA *sDemodData = (DEMOD_SAT_DATA*)handle;

	pfield=&(sDemodData->FieldMap[field]);						/*	Just for code simplification	*/

	/* I2C Read : register address set-up */
	RegGetOneRegister(handle,pfield->Reg);					/*	Read the register	*/     

	return FieldGetVal(handle,field);
}

/********* RegInit ****************************************************************/
/*	This function initializes in memory the STV0197 registers					  */
/*	configure & initialize the REGISTERS : 8bit registers						  */
/*	configure & initialize the FIELD : subset of 8 bit registers				  */
/*  FIELD is for example a bit status, or a coefficient, etc ...				  */
/*	initialize in memory the default registers values of the STV0197			  */ 
/*  STV0197 Default values are stored in ValRegReset array						  */
/*  Define Which Registers to display in the register Map with MemReg array		  */		
/**********************************************************************************/
void RegInit(DEMOD_HANDLE handle)
{
	/* REGISTER INITIALISATION */
	/*	ID	*/
	AddReg(handle,R_ID,"ID",0x00,0xA1);
	AddField(handle,R_ID,ID,"ID",0,8,DEMOD_UNSIGNED);

	/*	RCR	*/
	AddReg(handle,R_RCR,"RCR",0x01,0x13);
	AddField(handle,R_RCR,K,"K",6,2,DEMOD_UNSIGNED);
	AddField(handle,R_RCR,DIRCLK,"DIRCLK",5,1,DEMOD_UNSIGNED);
	AddField(handle,R_RCR,M,"M",0,5,DEMOD_UNSIGNED);

	/*	MCR	*/
	AddReg(handle,R_MCR,"MCR",0x02,0x30);
	AddField(handle,R_MCR,STDBY,"STDBY",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_MCR,VCO,"VCO",6,1,DEMOD_UNSIGNED);
	AddField(handle,R_MCR,SERCLK,"SERCLK",3,1,DEMOD_UNSIGNED);
	AddField(handle,R_MCR,P,"P",0,3,DEMOD_UNSIGNED);

	/*	ACR	*/
	AddReg(handle,R_ACR,"ACR",0x03,0x00);
	AddField(handle,R_ACR,ACR,"ACR",0,8,DEMOD_UNSIGNED);

	/*	F22RR	*/
	AddReg(handle,R_F22FR,"F22RR",0x04,0x72);
	AddField(handle,R_F22FR,F22FR,"F22RR",0,8,DEMOD_UNSIGNED);

	/*	I2CRPT	*/
	AddReg(handle,R_I2CRPT,"I2CRPT",0x05,0x05);
	AddField(handle,R_I2CRPT,I2CT,"I2CT",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_I2CRPT,SCLT,"SCLT",2,1,DEMOD_UNSIGNED);
	AddField(handle,R_I2CRPT,SDAT,"SDAT",0,1,DEMOD_UNSIGNED);

	/*	DACR1	*/
	AddReg(handle,R_DACR1,"DACR1",0x06,0x84);
	AddField(handle,R_DACR1,DACMODE,"DACMODE",5,3,DEMOD_UNSIGNED);
	AddField(handle,R_DACR1,DACMSB,"DACMSB",0,4,DEMOD_UNSIGNED);

	/*	DACR2	*/
	AddReg(handle,R_DACR2,"DACR2",0x07,0xce);
	AddField(handle,R_DACR2,DACLSB,"DACLSB",0,8,DEMOD_UNSIGNED);

	/*	DISEQC	*/
	AddReg(handle,R_DISEQC,"DISEQC",0x08,0xe3);
	AddField(handle,R_DISEQC,LOCKOUTPUT,"LOCKOUTPUT",6,2,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQC,LOCKCONFIGURATION,"LOCKCONFIGURATION",5,1,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQC,UNMODULATEDBURST,"UNMODULATEDBURST",2,1,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQC,DISEQCMODE,"DISEQCMODE",0,2,DEMOD_UNSIGNED);

	/*	DISEQCFIFO	*/
	AddReg(handle,R_DISEQCFIFO,"DISEQCFIFO",0x09,0xFF);
	AddField(handle,R_DISEQCFIFO,DISEQCFIFO,"DISEQCFIFO",0,8,DEMOD_UNSIGNED);

	/*	DISEQCSTATUS	*/
	AddReg(handle,R_DISEQCSTATUS,"DISEQCSTATUS",0x0A,0xC6);
	AddField(handle,R_DISEQCSTATUS,INPORT,"INPUTPORT",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQCSTATUS,SDATINPUTSTATE,"SDATINPUTSTATE",6,1,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQCSTATUS,FIFOEMPTY,"FIFOEMPTY",1,1,DEMOD_UNSIGNED);
	AddField(handle,R_DISEQCSTATUS,FIFOFULL,"FIFOFULL",0,1,DEMOD_UNSIGNED);

	/*	RES	*/
	AddReg(handle,R_RES,"RES",0x0B,0x00);
	AddField(handle,R_RES,DEMOD_0299_RESERVED,"RESERVED",0,8,DEMOD_UNSIGNED);

	/*	IOCFG	*/
	AddReg(handle,R_IOCFG,"IOCFG",0x0C,0xf1);
	AddField(handle,R_IOCFG,OP1CONTROL,"OP1CONTROL",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_IOCFG,OP1VALUE,"OP1VALUE",6,1,DEMOD_UNSIGNED);
	AddField(handle,R_IOCFG,OP0CONTROL,"OP0CONTROL",5,1,DEMOD_UNSIGNED);
	AddField(handle,R_IOCFG,OP0VALUE,"OP0VALUE",4,1,DEMOD_UNSIGNED);
	AddField(handle,R_IOCFG,NYQUISTFILTER,"NYQUISTFILTER",1,2,DEMOD_UNSIGNED);
	AddField(handle,R_IOCFG,IQ,"IQ",0,1,DEMOD_UNSIGNED);

	/*	AGC1C	*/
	AddReg(handle,R_AGC1C,"AGC1C",0x0D,0x81);
	AddField(handle,R_AGC1C,DCADJ,"DCADJ",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_AGC1C,BETA_AGC1,"BETA_AGC1",0,3,DEMOD_UNSIGNED);

	/*	RTC	*/
	AddReg(handle,R_RTC,"RTC",0x0E,0x22);
	AddField(handle,R_RTC,ALPHA_TMG,"ALPHA_TMG",4,3,DEMOD_UNSIGNED);
	AddField(handle,R_RTC,BETA_TMG,"BETA_TMG",0,3,DEMOD_UNSIGNED);

	/*	AGC1R	*/
	AddReg(handle,R_AGC1R,"AGC1R",0x0F,0xd9);
	AddField(handle,R_AGC1R,IAGC,"IAGC",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_AGC1R,AGC1_REF,"AGC1_REF",0,6,DEMOD_UNSIGNED);

	/*	AGC2O	*/
	AddReg(handle,R_AGC2O,"AGC2O",0x10,0x3e);
	AddField(handle,R_AGC2O,AGC2COEF,"AGC2COEF",5,3,DEMOD_UNSIGNED);
	AddField(handle,R_AGC2O,AGC2_REF,"AGC2_REF",0,5,DEMOD_UNSIGNED);

	/*	TLSR	*/
	AddReg(handle,R_TLSR,"TLSR",0x11,0x74);
	AddField(handle,R_TLSR,STEP_MINUS,"STEP_MINUS",4,4,DEMOD_UNSIGNED);
	AddField(handle,R_TLSR,STEP_PLUS,"STEP_PLUS",0,4,DEMOD_UNSIGNED);

	/*	CFD	*/
	AddReg(handle,R_CFD,"CFD",0x12,0x77);
	AddField(handle,R_CFD,CFD_ALGO,"CFD_ALGO",7,1,DEMOD_UNSIGNED);
	AddField(handle,R_CFD,BETA_FC,"BETA_FC",4,3,DEMOD_UNSIGNED);
	AddField(handle,R_CFD,FDTC,"FDTC",2,2,DEMOD_UNSIGNED);
	AddField(handle,R_CFD,LDL,"LDL",0,2,DEMOD_UNSIGNED);

	/*	ACLC	*/