chip.c

STV0299 Minituner driver, for ST chipset

	}
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	CreateMask
**ACTION	::	Create a mask according to its number of bits and position 
**PARAMS IN	::	field	==> Id of the field
**PARAMS OUT::	NONE
**RETURN	::	mask of the field
*****************************************************/
unsigned char CreateMask(char NbBits, char Pos)
{
	int i;
	unsigned char mask=0;
	
	
	/*	Create mask	*/
	for (i = 0; i < NbBits; i++)
	{
		mask <<= 1 ;
		mask +=  1 ;
	}
	  
	mask = mask << Pos;
	
	return mask;
}

/*****************************************************
**FUNCTION	::	ChipAddField
**ACTION	::	Add a field to the field map 
**PARAMS IN	::	hChip	==> Handle to the chip
**				RegId	==> Id of the register which contains the field
**				FieldId	==> Id of the field
**				Name	==> Name of the field
**				Pos		==> Position (number of left shifts from LSB position) in the register 
**				NbBits	==> Size (in bits) of the field
**				Type	==> SIGNED or UNSIGNED
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipAddField(STCHIP_Handle_t hChip,U16 RegId, U32 FieldId,char * Name, char Pos, char NbBits, STCHIP_FieldType_t Type)
{
	STCHIP_Field_t *pField; 
	
	if(hChip != NULL)
	{
		if(RegId < hChip->NbRegs)
		{
			if(FieldId < hChip->NbFields)
			{
				pField=&hChip->pFieldMap[FieldId];
	
				strcpy(pField->Name,Name);	
				pField->Reg = RegId;
				pField->Pos = Pos;
				pField->Bits = NbBits;
				pField->Type = Type;
				if(NbBits)
					pField->Mask = CreateMask(NbBits,Pos);
				else
					hChip->Error = CHIPERR_INVALID_FIELD_SIZE;
			}
			else
				hChip->Error = CHIPERR_INVALID_FIELD_ID;
		}
		else
			hChip->Error = CHIPERR_INVALID_REG_ID;
	}
	else 
		return CHIPERR_INVALID_HANDLE;
	
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipSetOneRegister
**ACTION	::	Set the value of one register 
**PARAMS IN	::	hChip	==> Handle to the chip
**				reg_id	==> Id of the register
**				Data	==> Data to store in the register
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipSetOneRegister(STCHIP_Handle_t hChip,U16 RegId, unsigned char Data)   
{
//	unsigned char data[2];
	
	if(hChip)
	{
		if(RegId < hChip->NbRegs)
		{
			hChip->pRegMap[RegId].Value = Data;
			
			if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)
				ChipSetRegisters(hChip,RegId,1);
			else
				ChipSetRegisters(hChip,hChip->WrStart,hChip->WrSize);
		}
		else
			hChip->Error = CHIPERR_INVALID_REG_ID;
	}
	else
		return CHIPERR_INVALID_HANDLE;
	
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipGetOneRegister
**ACTION	::	Get the value of one register 
**PARAMS IN	::	hChip	==> Handle to the chip
**				reg_id	==> Id of the register
**PARAMS OUT::	NONE
**RETURN	::	Register's value
*****************************************************/
int ChipGetOneRegister(STCHIP_Handle_t hChip, U16 RegId)         
{
	unsigned char data = 0xFF;
	
	if(hChip)
	{
		if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)
		{
			if(ChipGetRegisters(hChip,RegId,1) == CHIPERR_NO_ERROR)
				data = hChip->pRegMap[RegId].Value;
		}
		else
		{
			if(ChipGetRegisters(hChip,hChip->RdStart,hChip->RdSize) == CHIPERR_NO_ERROR)  
				data = hChip->pRegMap[RegId].Value;
		}
	}
		
	return data;
}

/*****************************************************
**FUNCTION	::	ChipSetRegisters
**ACTION	::	Set values of consecutive's registers (values are taken in RegMap)
**PARAMS IN	::	hChip		==> Handle to the chip
**				FirstReg	==> Id of the first register
**				NbRegs		==> Number of register to write		
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t  ChipSetRegisters(STCHIP_Handle_t hChip,int FirstReg, int NbRegs)
{
	unsigned char data[22],nbdata = 0;
//	char Tstat,Dstat;
	int i;
	
	#ifndef NO_GUI
		Tstat=TraceGetState();
		Dstat=ApplGetState();
	#endif

	if(hChip)
	{
		if(!hChip->Error)
		{
			if(NbRegs < 20)
			{
				if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
				{
					switch(hChip->ChipMode)
					{
						case STCHIP_MODE_SUBADR_16:
							data[nbdata++]=MSB(hChip->pRegMap[FirstReg].Addr);	/* 16 bits sub addresses */
						case STCHIP_MODE_SUBADR_8:
							data[nbdata++]=LSB(hChip->pRegMap[FirstReg].Addr);	/* 8 bits sub addresses */
						case STCHIP_MODE_NOSUBADR:
							for(i=0;i<NbRegs;i++)
								data[nbdata++]=hChip->pRegMap[FirstReg+i].Value;	/* fill data buffer */
						break;
					}	
					
					#ifndef NO_GUI
						if(Tstat&&Dstat)
							TraceWriteFile(TRACE_OUT,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,&data[1],NbRegs);
					#endif
						
					#ifndef NO_I2C
							#ifndef NO_GUI
								if(!(Tstat&&TraceGetMode()&&Dstat))
								{
									if(WaitForSingleObject(ChipMutex,2000) == WAIT_OBJECT_0)	/* Wait for other I2C access termination */ 
									{
							#endif
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,TRUE);	/* Set repeater ON */
								
										if(I2cReadWrite(I2C_WRITE,hChip->I2cAddr,data,nbdata) != I2C_OK)	/* write data buffer */
											hChip->Error = CHIPERR_I2C_NO_ACK;
								
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,FALSE);	/* Set repeater OFF */
							#ifndef NO_GUI
										ReleaseMutex(ChipMutex);								/*	Allow other I2C access */  
									}	
								}
							#endif
					#endif  
				}
				else
					hChip->Error = CHIPERR_INVALID_REG_ID;
			}
			else
				hChip->Error = CHIPERR_I2C_BURST;
		}
	}
	else
		return CHIPERR_INVALID_HANDLE;
	
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipGetRegisters
**ACTION	::	Get values of consecutive's registers (values are writen in RegMap)
**PARAMS IN	::	hChip		==> Handle to the chip
**				FirstReg	==> Id of the first register
**				NbRegs		==> Number of register to read		
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipGetRegisters(STCHIP_Handle_t hChip, int FirstReg, int NbRegs)
{
	unsigned char data[22],nbdata =0;
//	char Tstat,Tmode,Dstat;
	int i;
	
	#ifndef NO_GUI
		Tstat=TraceGetState();
		Tmode=TraceGetMode();
		Dstat=ApplGetState();
	#endif

	if(hChip)
	{
		if(!hChip->Error)
		{
			if(NbRegs < 20)
			{
				if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
				{
				#ifndef NO_I2C
					#ifndef NO_GUI
						if(!(Tstat&&Tmode&&Dstat))
						{
							if(WaitForSingleObject(ChipMutex,2000) == WAIT_OBJECT_0)	/* Wait for other I2C access termination */ 
							{
					#endif
								switch(hChip->ChipMode)
								{
									case STCHIP_MODE_SUBADR_16:	
										data[nbdata++]=MSB(hChip->pRegMap[FirstReg].Addr);	/* for 16 bits sub addresses */
									case STCHIP_MODE_SUBADR_8:
										data[nbdata++]=LSB(hChip->pRegMap[FirstReg].Addr);  /* for 8 bits sub addresses	*/
								
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,TRUE);	/* Set repeater ON */
							
										if(I2cReadWrite(I2C_WRITE,hChip->I2cAddr,data,nbdata) != I2C_OK)	/* Write sub address */
											hChip->Error = CHIPERR_I2C_NO_ACK;	
									
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,FALSE);	/* Set repeater OFF */
							
									case STCHIP_MODE_NOSUBADR:
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,TRUE);	/* Set repeater ON */
							
										if(I2cReadWrite(I2C_READ,hChip->I2cAddr,data,NbRegs) != I2C_OK)	/* Read data buffer */ 
											hChip->Error = CHIPERR_I2C_NO_ACK;	
								
										if(hChip->Repeater)
											hChip->RepeaterFn(hChip->RepeaterHost,FALSE);	/* Set repeater OFF */
									break;
								}
					#ifndef NO_GUI
								ReleaseMutex(ChipMutex);								/*	Allow other I2C access */          	
							}
						}
					#endif

					#ifndef NO_GUI
						if((Tstat == TRACE_ON) && (Dstat == APPL_STANDBY))
						{		
							/*	Trace ON and Driver RUNNING	*/
							if(Tmode == TRACE_PLAY)
							/*	Playback mode	*/
								TraceReadFile(TRACE_IN,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,data,NbRegs);
							else 
								/*	Record mode	*/
								TraceWriteFile(TRACE_IN,hChip->I2cAddr,hChip->pRegMap[FirstReg].Addr,data,NbRegs);  
						}
					#endif
					
					/*	Update RegMap structure	*/
					for(i=0;i<NbRegs;i++)
						if(!hChip->Error)
							hChip->pRegMap[FirstReg+i].Value = data[i];
						else
							hChip->pRegMap[FirstReg+i].Value = 0xFF; 
				#endif			
				}
				else
					hChip->Error = CHIPERR_INVALID_REG_ID;  
			}
			else 
				hChip->Error = CHIPERR_I2C_BURST;
		}
	}
	else
		return CHIPERR_INVALID_HANDLE;
	
	return hChip->Error;
}


/*****************************************************
**FUNCTION	::	ChipGetRegDefault
**ACTION	::	Return the default value of the register
**PARAMS IN	::	hChip	==>	Handle of the chip
**				RegId	==>	Id of the register
**PARAMS OUT::	NONE
**RETURN	::	default value
*****************************************************/
char ChipGetRegDefault(STCHIP_Handle_t hChip,U16 RegId)
{
	char defval = 0;
	
	if(hChip != NULL)
	{
		if(RegId < hChip->NbRegs)
			defval = hChip->pRegMap[RegId].Default;
		else
			hChip->Error = CHIPERR_INVALID_REG_ID;		
	}
	
	return defval;
}


/*****************************************************
**FUNCTION	::	ChipSetRegDefault
**ACTION	::	Set the default value of the register
**PARAMS IN	::	hChip	==>	Handle of the chip
**				RegId	==>	Id of the register
**				Default	==> Default value
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipSetRegDefault(STCHIP_Handle_t hChip,U16 RegId,U8 Default)
{
	if(hChip != NULL)
	{
		if(RegId < hChip->NbRegs)
			hChip->pRegMap[RegId].Default = Default;
		else
			hChip->Error = CHIPERR_INVALID_REG_ID;		
	}
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipUpdateDefaultValues
**ACTION	::	Get default values in all the registers
**PARAMS IN	::	hChip	==> Handle of the chip	
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipUpdateDefaultValues(STCHIP_Handle_t hChip)
{
	int reg = 0;

	if(hChip != NULL) 
	{
		while((!hChip->Error) && (reg < hChip->NbRegs))
		{
			hChip->pRegMap[reg].Default = ChipGetOneRegister(hChip,reg);     
			reg++;
		}
	}
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipApplyDefaultValues
**ACTION	::	Write default values in all the registers
**PARAMS IN	::	hChip	==> Handle of the chip	
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipApplyDefaultValues(STCHIP_Handle_t hChip)
{
	int reg = 0;

	if(hChip != NULL) 
	{
		if(hChip->ChipMode != STCHIP_MODE_NOSUBADR)   
		{
			while((!hChip->Error) && (reg < hChip->NbRegs))
			{
				ChipSetOneRegister(hChip,reg,hChip->pRegMap[reg].Default);     
				reg++;
			}
		}
		else
			ChipSetOneRegister(hChip,reg,hChip->pRegMap[reg].Default); 
	}
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}