stb0899_chip.c

DVB-S STB0899 source code

	
	if(hChip)
	{	
		if((hChip->ChipMode != STCHIP_MODE_NOSUBADR) && (hChip->ChipMode != STCHIP_MODE_NO_R_SUBADR))
		{
			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[100],nbdata = 0;
    int i,j;

    if(hChip)
    {
	if(!hChip->ChipError)
	{
	    if(NbRegs < 20)
	    {
		if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
		{
		    if(hChip->pRegMap[FirstReg].Pointed == STCHIP_POINTED)
		    {
			if((hChip->pRegMap[FirstReg].PointerRegAddr != LastPointer) || (hChip->pRegMap[FirstReg].BaseAdress != LastBaseAdress))
			{
			    /* Write pointer register (4x8bits read access) */
			    nbdata=0;
			    data[nbdata++] = MSB(hChip->pRegMap[FirstReg].PointerRegAddr);
			    data[nbdata++] = LSB(hChip->pRegMap[FirstReg].PointerRegAddr);

			    for(i=0;i<4;i++) 
				data[nbdata++] = (unsigned char)((hChip->pRegMap[FirstReg].BaseAdress>>(8*i))&0xFF);

			    /* write base adress value */		
			    if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
				hChip->ChipError = CHIPERR_I2C_NO_ACK;

			    LastPointer = hChip->pRegMap[FirstReg].PointerRegAddr;
			    LastBaseAdress = hChip->pRegMap[FirstReg].BaseAdress;
			}			
			/* Write pointed register (4x8bits read access) */ 
			nbdata = 0;
			data[nbdata++] = MSB(hChip->pRegMap[FirstReg].Addr);	
			data[nbdata++] = LSB(hChip->pRegMap[FirstReg].Addr);	
						
			for(j=0; j<NbRegs; j++)
			    for(i=0;i<4;i++) 
				data[nbdata++] = (unsigned char)((hChip->pRegMap[FirstReg+j].Value>>(8*i))&0xFF);

			/* write base adress value */
			if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;
		    }
		    else
		    {	
			nbdata = 0;
			switch(hChip->ChipMode)
			{
			    case STCHIP_MODE_SUBADR_16:
				data[nbdata++] = MSB(hChip->pRegMap[FirstReg].Addr);
			    case STCHIP_MODE_SUBADR_8:
			    case STCHIP_MODE_NO_R_SUBADR:
				data[nbdata++] = LSB(hChip->pRegMap[FirstReg].Addr);
			    case STCHIP_MODE_NOSUBADR:
				for(i=0;i<NbRegs;i++) /* fill data buffer */
				    data[nbdata++] = (unsigned char)((hChip->pRegMap[FirstReg+i].Value)&0xFF);
			    break;
			}

			if(hChip->Repeater)
			    hChip->RepeaterFn(hChip->RepeaterHost, TRUE);

			if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
			{
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;
			}

			if(hChip->Repeater)
			    hChip->RepeaterFn(hChip->RepeaterHost,FALSE);
		    }
		}
		else
		{
		    hChip->ChipError = CHIPERR_INVALID_REG_ID;
		}
	    }
	    else
	    {
	    	hChip->ChipError = CHIPERR_I2C_BURST;
	    }
	}
    }
    else
    {
	return CHIPERR_INVALID_HANDLE;
    }

    return hChip->ChipError;
}

/*****************************************************
**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)
{
    u8 data[100],dataread[100],dummy[4],nbdata =0;
    u16 address;
    u8 dum;
    int i,j=0;
	
    if(hChip)
    {
	if(!hChip->ChipError)
	{
	    if(NbRegs < 20)
	    {
		if((FirstReg >= 0) && ((FirstReg + NbRegs - 1) < hChip->NbRegs))
		{
		    if(hChip->pRegMap[FirstReg].Pointed == STCHIP_POINTED)
		    {
			if((hChip->pRegMap[FirstReg].PointerRegAddr != LastPointer) || (hChip->pRegMap[FirstReg].BaseAdress != LastBaseAdress))
			{
			    /* Write pointer register (4x8bits write access) */
			    nbdata = 0;
			    data[nbdata++] = MSB(hChip->pRegMap[FirstReg].PointerRegAddr);
			    data[nbdata++] = LSB(hChip->pRegMap[FirstReg].PointerRegAddr);

			    for(i=0; i<4; i++)
				data[nbdata++] = (unsigned char)((hChip->pRegMap[FirstReg].BaseAdress>>(8*i))&0xFF);

			    if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
			    	hChip->ChipError = CHIPERR_I2C_NO_ACK;

			    LastPointer = hChip->pRegMap[FirstReg].PointerRegAddr;
			    LastBaseAdress = hChip->pRegMap[FirstReg].BaseAdress;
			}	
			nbdata = 0;
			if((LSB(hChip->pRegMap[FirstReg].Addr) & 0x08) == 0)
			    dum = 0x20;
			else
			    dum = 0;
			dummy[nbdata++] = MSB(hChip->pRegMap[FirstReg].Addr);
			dummy[nbdata++] = dum;

			/* write register adress+20 value */
			if(STI2C_Combined(I2C_READ, hChip->I2cAddr, dummy, nbdata) < 0)
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;

			if(STI2C_Combined(I2C_WRITE, hChip->I2cAddr, dummy, 4) < 0)
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;
	
			/* Read pointed register (4x8bits read access) */
			nbdata = 0;
			address = hChip->pRegMap[FirstReg].Addr;
			data[nbdata++] = MSB(address);
			data[nbdata++] = LSB(address);
					
			if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;
	
			if(STI2C_Combined(I2C_WRITE, hChip->I2cAddr, dataread, (4*NbRegs)) < 0)
			    hChip->ChipError = CHIPERR_I2C_NO_ACK;

			memcpy(data, dataread, (4*NbRegs));
		    }
		    else
		    {
			nbdata = 0;
			switch(hChip->ChipMode)
			{	
			    case STCHIP_MODE_SUBADR_16:
				data[nbdata++] = MSB(hChip->pRegMap[FirstReg].Addr);
			    case STCHIP_MODE_SUBADR_8:
				data[nbdata++]=LSB(hChip->pRegMap[FirstReg].Addr);

			    if(hChip->Repeater)
				hChip->RepeaterFn(hChip->RepeaterHost, TRUE);	

			    /* Write sub address */
			    if(STI2C_Combined(I2C_READ, hChip->I2cAddr, data, nbdata) < 0)
				hChip->ChipError = CHIPERR_I2C_NO_ACK;

			    if(hChip->Repeater)
				hChip->RepeaterFn(hChip->RepeaterHost, FALSE);

			    case STCHIP_MODE_NOSUBADR:
			    case STCHIP_MODE_NO_R_SUBADR:
				if(hChip->Repeater)
				    hChip->RepeaterFn(hChip->RepeaterHost, TRUE);
	
				nbdata = 0;
				if(hChip->pRegMap[FirstReg].Pointed == STCHIP_POINTED)
				    for(i=0; i<NbRegs; i++)
					nbdata += 4;
				else
					nbdata = (unsigned char)NbRegs;

				if(STI2C_Combined(I2C_WRITE, hChip->I2cAddr, data, nbdata) < 0)
				    hChip->ChipError = CHIPERR_I2C_NO_ACK;

				if(hChip->Repeater)
				    hChip->RepeaterFn(hChip->RepeaterHost, FALSE);

				/*only for inbuf and packet delin registers*/
				if((MSB(hChip->pRegMap[FirstReg].Addr) == 0xf6) || (MSB(hChip->pRegMap[FirstReg].Addr) == 0xf2))
				{
				    dummy[0] = MSB(hChip->pRegMap[FirstReg].Addr);
				    dummy[1] = 0xff;

				    if(STI2C_Combined(I2C_READ, dummy, 2) < 0)
					hChip->ChipError = CHIPERR_I2C_NO_ACK;

				    if(STI2C_Combined(I2C_WRITE, dummy, 1) < 0)
					hChip->ChipError = CHIPERR_I2C_NO_ACK;
				}
			    break;
			}
		    }

		    /*Update RegMap structure	*/

		    for(i = 0; i < NbRegs; i++)
		    if(!hChip->ChipError)
		    {
			hChip->pRegMap[FirstReg+i].Value = data[j++];

			if(hChip->pRegMap[FirstReg+i].Size >= STCHIP_REG_16)
			    hChip->pRegMap[FirstReg+i].Value += data[j++]<<8;
	
			if(hChip->pRegMap[FirstReg+i].Size >= STCHIP_REG_24)
			    hChip->pRegMap[FirstReg+i].Value += data[j++]<<16;

			if(hChip->pRegMap[FirstReg+i].Size >= STCHIP_REG_32)
			    hChip->pRegMap[FirstReg+i].Value += data[j++]<<24;
		    }
		    else
		    hChip->pRegMap[FirstReg+i].Value = 0xFFFFFFFF;
		}
		else
		{
		    hChip->ChipError = CHIPERR_INVALID_REG_ID;
		}
	    }
	    else 
	    {
		hChip->ChipError = CHIPERR_I2C_BURST;
	    }
	}
    }
    else
    {
	return CHIPERR_INVALID_HANDLE;
    }

    return hChip->ChipError;
}

/*****************************************************
**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->ChipError)
		{
			if(FieldId < (u32)(hChip->NbFields))
			{
				pfield = &hChip->pFieldMap[FieldId];

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

				/*Shift and mask value*/
				Value = pfield->Mask & (Value << pfield->Pos);

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

	return hChip->ChipError;
}

/*****************************************************
**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->ChipError)
		{
			if(FieldId < (u32)(hChip->NbFields))
			{
				/*Just for code simplification*/
				pfield = &hChip->pFieldMap[FieldId];

				/*Read the register*/
				ChipGetOneRegister(hChip,pfield->Reg);

				/*Compute new RegMap value */
				ChipSetFieldImage(hChip,FieldId,Value);

				/*Write the register */
				ChipSetOneRegister(hChip, pfield->Reg, hChip->pRegMap[pfield->Reg].Value);
			}
			else
			{
				hChip->ChipError = CHIPERR_INVALID_FIELD_ID;
			}
		}
	}
	else
	{
		return CHIPERR_INVALID_HANDLE;
	}
		
	return hChip->ChipError;
}

/*****************************************************
**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 = 0xFFFFFFFF;
	STCHIP_Field_t *pfield;
	
	if(hChip)
	{
		if(FieldId < (u32)(hChip->NbFields))
		{
			pfield = &hChip->pFieldMap[FieldId];
			if(!hChip->ChipError)
				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->ChipError = 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 = 0xFFFFFFFF;
	
	if(hChip)
	{
		if(FieldId < (u32)(hChip->NbFields))
		{
			ChipGetOneRegister(hChip, hChip->pFieldMap[FieldId].Reg);
			value = ChipGetFieldImage(hChip, FieldId);
		}
		else
			hChip->ChipError = CHIPERR_INVALID_FIELD_ID;
	}
	
	return value;
}

/*****************************************************
**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->ChipError) && (reg < hChip->NbRegs))
			{
				ChipSetOneRegister(hChip,(u16)reg,hChip->pRegMap[reg].Default);
				reg++;
			}
		}
		else
		{
			ChipSetOneRegister(hChip,(u16)reg,hChip->pRegMap[reg].Default);
		}
	}
	else
	{
		return CHIPERR_INVALID_HANDLE;
	}

	return hChip->ChipError;
}