chip.c

STV0299 Minituner driver, for ST chipset

/*****************************************************
**FUNCTION	::	ChipGetError
**ACTION	::	Return the current error of the chip
**PARAMS IN	::	hChip	==> Handle of the chip
**PARAMS OUT::	NONE
**RETURN	::	Current error, CHIPERR_INVALID_HANDLE otherwise
*****************************************************/
STCHIP_Error_t ChipGetError(STCHIP_Handle_t hChip)
{
	if(hChip != NULL)     
		return hChip->Error;
	else
		return CHIPERR_INVALID_HANDLE;
}

/*****************************************************
**FUNCTION	::	ChipResetError
**ACTION	::	Reset the error of the chip
**PARAMS IN	::	hChip	==> Handle of the chip
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipResetError(STCHIP_Handle_t hChip)    
{
	if(hChip != NULL) 
		hChip->Error = CHIPERR_NO_ERROR;
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}
  
/*****************************************************
**FUNCTION	::	ChipSetFieldImage
**ACTION	::	Set value of a field in RegMap
**PARAMS IN	::	hChip	==> Handle to the chip
**				FieldId	==> Id of the field
**				Value	==> Value of the field
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipSetFieldImage(STCHIP_Handle_t hChip,U32 FieldId, int Value)
{
	STCHIP_Field_t *pfield;
	
	if(hChip != NULL)
	{
		if(!hChip->Error)
		{
			if(FieldId < hChip->NbFields)
			{
				pfield=&hChip->pFieldMap[FieldId];						/*	Just for code simplification	*/

				if(pfield->Type == CHIP_SIGNED)
					Value = (Value > 0 ) ? Value : Value + (1<<pfield->Bits);	/*	compute signed fieldval	*/

				Value = pfield->Mask & (Value << pfield->Pos);	/*	Shift and mask value	*/
				hChip->pRegMap[pfield->Reg].Value = (hChip->pRegMap[pfield->Reg].Value & (~pfield->Mask)) + Value;	/*	Concat register value and fieldval	*/
			}
			else
				hChip->Error = CHIPERR_INVALID_FIELD_ID;
		}
	}
	else
		return CHIPERR_INVALID_HANDLE;
	
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipSetField
**ACTION	::	Set value of a field in the chip
**PARAMS IN	::	hChip	==> Handle to the chip
**				FieldId	==> Id of the field
**				Value	==> Value to write
**PARAMS OUT::	NONE
**RETURN	::	Error
*****************************************************/
STCHIP_Error_t ChipSetField(STCHIP_Handle_t hChip,U32 FieldId,int Value)
{
	STCHIP_Field_t *pfield;
	
	if(hChip)
	{
		if(!hChip->Error)
		{
			if(FieldId < hChip->NbFields)
			{
				pfield=&hChip->pFieldMap[FieldId];		/*	Just for code simplification   */
	
				ChipGetOneRegister(hChip,pfield->Reg);			/*	Read the register	*/
				ChipSetFieldImage(hChip,FieldId,Value);					/*	Compute new RegMap value */
				ChipSetOneRegister(hChip,pfield->Reg,hChip->pRegMap[pfield->Reg].Value);		/*	Write the register */
			}
			else
				hChip->Error = CHIPERR_INVALID_FIELD_ID;
		}
	}
	else
		return CHIPERR_INVALID_HANDLE;
		
	return hChip->Error;
}

/*****************************************************
**FUNCTION	::	ChipGetFieldImage
**ACTION	::	get the value of a field from RegMap
**PARAMS IN	::	hChip	==>	Handle of the chip
**				FieldId	==> Id of the field
**PARAMS OUT::	NONE
**RETURN	::	field's value
*****************************************************/
int ChipGetFieldImage(STCHIP_Handle_t hChip,U32 FieldId)
{
	int value = 0xFF;
	STCHIP_Field_t *pfield;
	
	if(hChip)
	{
		if(FieldId < hChip->NbFields)
		{
			pfield=&hChip->pFieldMap[FieldId];				/*	Just for code simplification	*/
			
			if(!hChip->Error)
				value = hChip->pRegMap[pfield->Reg].Value;
				
			value=(value & pfield->Mask) >> pfield->Pos;	/*	Extract field	*/

			if((pfield->Type == CHIP_SIGNED)&&(value & (1<<(pfield->Bits-1))))
				value = value - (1<<pfield->Bits);			/*	Compute signed value	*/
		}
		else
			hChip->Error = CHIPERR_INVALID_FIELD_ID;
	}
	
	return value;
}

/*****************************************************
**FUNCTION	::	ChipGetField
**ACTION	::	get the value of a field from the chip
**PARAMS IN	::	hChip	==>	Handle of the chip
**				FieldId	==> Id of the field
**PARAMS OUT::	NONE
**RETURN	::	field's value
*****************************************************/
int	 ChipGetField(STCHIP_Handle_t hChip,U32 FieldId)
{
	int value = 0xFF;   
	
	if(hChip)
	{
		if(FieldId < hChip->NbFields)
		{
			/* I2C Read : register address set-up */
			ChipGetOneRegister(hChip,hChip->pFieldMap[FieldId].Reg);					/*	Read the register	*/     
			value = ChipGetFieldImage(hChip,FieldId);
		}
		else
			hChip->Error = CHIPERR_INVALID_FIELD_ID;
	}
	
	return value;
}

/*****************************************************
**FUNCTION	::	ChipSearchFieldName
**ACTION	::	Search a field name in FieldMap and return the corresponding field Id
**PARAMS IN	::	hChip	==> Handle of the chip
**				FieldName	==> Name of the field
**PARAMS OUT::	NONE
**RETURN	::	field's Id, -1 if not found
*****************************************************/
int  ChipSearchFieldName(STCHIP_Handle_t hChip,char * FieldName)
{
	int Index = 0;
	
	if(hChip)  
	{
		while((Index < hChip->NbFields)&&(strcmp(hChip->pFieldMap[Index].Name,FieldName)!= 0)) 
			Index++;
			
		if(Index >= hChip->NbFields)
			Index = -1;
	}
	else
		Index = -1;
	
	return Index;
}

/*****************************************************
**FUNCTION	::	ChipSearchRegName
**ACTION	::	Search a register name in RegMap and return the corresponding register Id
**PARAMS IN	::	hChip	==> Handle of the chip
**				RegName	==> Name of the register
**PARAMS OUT::	NONE
**RETURN	::	register's Id, -1 if not found
*****************************************************/
int  ChipSearchRegName(STCHIP_Handle_t hChip,char * RegName)
{
	int Index = 0;									  

	if(hChip)  
	{
			while((Index < hChip->NbRegs)&&(strcmp(hChip->pRegMap[Index].Name,RegName)!= 0))
				Index++;
				
			if(Index>= hChip->NbRegs)
				Index = -1;
    }
    else
    	Index = -1;
    
	return Index;
}

/*****************************************************
**FUNCTION	::	ChipCheckAck
**ACTION	::	Test if the chip acknowledge at its supposed address
**PARAMS IN	::	ChipId	==> Id of the chip
**PARAMS OUT::	NONE
**RETURN	::	ACK if acknowledge is OK, NOACK otherwise
*****************************************************/
int ChipCheckAck(STCHIP_Handle_t hChip)
{
	I2C_RESULT status = I2C_NOACK;
	U8 data = 0;
	
	if(hChip)  
	{
		hChip->Error = CHIPERR_NO_ERROR;

		#ifndef NO_I2C
			#ifndef NO_GUI
			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 */
			
				status = I2cReadWrite(I2C_READ,hChip->I2cAddr,&data,1);
		
				if(hChip->Repeater)
					hChip->RepeaterFn(hChip->RepeaterHost,FALSE);	/* Set repeater OFF */
			}
			#ifndef NO_GUI
			ReleaseMutex(ChipMutex);
			#endif
			/*	Allow other I2C access */
		#else
		status = I2C_OK;
	#endif
	
		if(status != I2C_OK)
			hChip->Error = CHIPERR_I2C_NO_ACK;
	}
	
	return status;  
}

/*****************************************************
**FUNCTION	::	ChipGetFieldIdFromName
**ACTION	::	Search a field name in FieldMap and return the corresponding field Id
**PARAMS IN	::	FieldName	==> Name of the field
**PARAMS OUT::	NONE
**RETURN	::	field's Id, -1 if not found
*****************************************************/
int ChipGetFieldIdFromName(STCHIP_Handle_t hChip,char * FieldName)
{
	int Index = 0;
	
	if(hChip)
	{
		while((Index < hChip->NbFields)&&(strcmp(hChip->pFieldMap[Index].Name,FieldName)!= 0)) 
			Index++;
			
		if(Index >= hChip->NbFields)
			Index = -1;
	}
	else
		Index = -1;
	
	return Index;
}

/*****************************************************
**FUNCTION	::	ChipGetRegIdFromName
**ACTION	::	Search a register name in RegMap and return the corresponding register Id
**PARAMS IN	::	RegName	==> Name of the register
**PARAMS OUT::	NONE
**RETURN	::	register's Id, -1 if not found
*****************************************************/
int ChipGetRegIdFromName(STCHIP_Handle_t hChip,char * RegName)
{
	int Index = 0;									  

	if(hChip)
	{
			while((Index < hChip->NbRegs)&&(strcmp(hChip->pRegMap[Index].Name,RegName)!= 0))
				Index++;
				
			if(Index>= hChip->NbRegs)
				Index = -1;
    }
    else
    	Index = -1;
    
	return Index;
}


/*****************************************************
**FUNCTION	::	ChipGetRegIdFromAdd
**ACTION	::	Search a register adress in RegMap and return the corresponding register Id
**PARAMS IN	::	RegName	==> Adress of the register
**PARAMS OUT::	NONE
**RETURN	::	register's Id, -1 if not found
*****************************************************/
U16	ChipGetRegIdFromAdd(STCHIP_Handle_t hChip,U16 Add)
{
	int Index = 0;									  

	if(hChip)
	{
			while((Index < hChip->NbRegs)&&(hChip->pRegMap[Index].Addr!=Add))
				Index++;
				
			if(Index>= hChip->NbRegs)
				Index = -1;
    }
    else
    	Index = -1;
    
	return Index;
}
#if (0)
//****************************************************
//FUNCTION	::	ChipSaveRegisterFields
//ACTION	::	update the list of the current register's fields
//PARAMS IN	::	RegId	->	register id
//PARAMS OUT::	NONE
//RETURN	::	NONE
//****************************************************
void ChipSaveRegisterFields(FILE *hFile,STCHIP_Handle_t hChip,int RegId)
{
	int fieldId,
		pos = 7;
		
	STCHIP_Field_t *pField;
	
	if(hChip)
	{
		/* Save all fields */
		for(fieldId=0;fieldId < hChip->NbFields;fieldId++)
		{
			pField = &hChip->pFieldMap[fieldId];
			if(pField->Reg == RegId)
			{
				while(pos != pField->Pos+pField->Bits-1)
				{
					fprintf(hFile, "\tNA");
					pos--;
				}
				
				if(pField->Type == CHIP_UNSIGNED)
					fprintf(hFile, "\t%s",pField->Name);
				else
					fprintf(hFile, "\t+%s",pField->Name);
				
				if(pField->Bits > 1)
				{
					fprintf(hFile,"[%d:%d]",pField->Pos+pField->Bits-1,pField->Pos);		
					pos -= pField->Bits;
				}
				else
				{
					pos--;
				}
			}
		}
		fprintf(hFile,"\n"); 
	}
}

void ChipSaveMap(STCHIP_Handle_t hChip)
{
	int regId;
	STCHIP_Register_t *pReg;
	char filename[200],access[100];
	FILE *hFile;

	if(hChip)
	{
		sprintf(filename,"%s_%02x.Map",hChip->Name,hChip->I2cAddr);
		hFile = fopen (filename, "w");
		
		/* Save all registers */
		for(regId=0;regId < hChip->NbRegs;regId++)
		{
			pReg = &hChip->pRegMap[regId];      
			switch(pReg->Access)
			{
				case STCHIP_ACCESS_WR:
					strcpy(access,"WR");
				break;
				case STCHIP_ACCESS_W:
					strcpy(access,"W");
				break;
				
				case STCHIP_ACCESS_R:
					strcpy(access,"R");
				break;
				
			}
			fprintf(hFile, "%s\t%s\t$%02x", access, pReg->Name, pReg->Addr);
			ChipSaveRegisterFields(hFile,hChip,regId);
		}
		
		fclose(hFile);
	}
}
#endif