main.c

汤姆逊公司的高频头872x系列的驱动 C语言编写

        STTUNER_J83_ALL    = 0xFF,
        STTUNER_J83_A      = 1,
        STTUNER_J83_B      = (1 << 1),
        STTUNER_J83_C      = (1 << 2)
    }
STTUNER_J83_t;

typedef struct
{
    D0297_SignalType_t      State;

    long Frequency;
    long SymbolRate;
    long RollOff;   
    long TunerOffset;
    long TunerBW;
    long TunerIF;

    short int Direction;
}
D0297_SearchParams_t;

typedef struct
{
    D0297_SignalType_t      SignalType;
    long                    Frequency;
    long                    SymbolRate; 
    STTUNER_Modulation_t    QAMSize;
}
D0297_Searchresult_t;

typedef struct
{
    int                     CarrierOffset;
    int                     TimingOffset;
    int                     lastAGC2Coef;
    int                     ScanMode;
    /**/
    STTUNER_Modulation_t    QAMSize;
    STTUNER_Spectrum_t      SpectrumInversion;
    STTUNER_J83_t           J83;
    int                     SweepRate;
    long                    InitDemodOffset;
    /**/

    D0297_SearchParams_t Params;
    D0297_Searchresult_t Result;

    /**/
    int                     Ber[3];             /* 0 : Ber Cnt
                                                   1 : Ber Saturation en %
                                                   2 : Ber
                                                   */
    int                     CNdB;               /* In dB */
    int                     SignalQuality;      /* SignalQuality from 0 to 100 % */

    U16                     BlkCounter;
    U16                     CorrBlk;
    U16                     UncorrBlk;

} 
D0297_StateBlockb_t;


#if 0
/*####################################################*/
/* defined by Li */
/* 读取MT2040的一个寄存器，基地址0xC0,address 为子地址*/
void STI2C2040_READ(unsigned char address,unsigned char* data,unsigned char number);
/*写MT2040的一个寄存器*/
void STI2C2040_WRITE(unsigned char address,,unsigned char* data,unsigned char number);
/*写ST0297的一个寄存器，该寄存器索引为index,在DeviceMap中
找到其对应的子地址，基地址为0x38*/
void STI2C0297_WRITE(int index,unsigned char data);
/*读取0297的一个寄存器，该寄存器索引为index*/
unsigned  char STI2C0297_READ(int index);
/*读取0297的某个域，该域索引为field,在DeviceMap中定义了该域的
所在寄存器，位数及位置*/
int STI2C0297_GETFIELD(int field);
/*设置0297的一个域*/
void STI2C0297_SETFIELD(int field,unsigned char data);
/*将0297中的所有寄存器用其对应的reset value全写一遍*/
void STI2C0297_Reload(void);/*reload all 0297 registers by reset value */
/*延时函数，以毫秒为单位*/
void DAVINCIEVM_waitusec(long time);/*unit by millisecond*/
/*#################################################*/
#endif
/*Globel variables*/
//static STI2C_Handle_t I2CHandle0297;
//static STI2C_Handle_t I2CHandle2040;
 D0297_StateBlockb_t *StateBlock;
//const unsigned int TCDRV_MT_VCO_FREQSb[5] = { 1890000,    /*  VCO 1 lower limit*/
//                                    1720000,    /*  VCO 2 lower limit*/
//                                    1530000,    /*  VCO 3 lower limit*/
//                                    1370000,    /*  VCO 4 lower limit*/
 //                                   0   };      /*  VCO 5 lower limit*/
static U8 IOBuffer[4];
STTUNER_IOREG_DeviceMapb_t *DeviceMap;
const long TCDRV_MT_PKENRANGEb = 400000;     /* 400 MHz */
const int acQAMSizeMapConstb [ 5 ] =
	{
        STTUNER_MOD_16QAM  /*= (1 << 3)*/,
        STTUNER_MOD_32QAM  /*= (1 << 4)*/,
        STTUNER_MOD_64QAM  /*= (1 << 5)*/,
        STTUNER_MOD_128QAM /*= (1 << 6)*/,
        STTUNER_MOD_256QAM /*= (1 << 7)*/
 	 };


//extern ST_Partition_t    *SystemPartition;
//extern ST_ErrorCode_t I2C_ReadWrite   (void *I2CHandle, STTUNER_IOARCH_Operation_t Operation, U16 SubAddr, U8 *Data, U32 TransferSize, U32 Timeout);
//void task_lock (void);

/* debug */
/* Function definition */

void STI2C0297_WRITE(U8 RegIndex, U8 Value)
{
      U8 cmd[2];

	  int i; 
	  
	  cmd[0] =DeviceMap->RegMap[RegIndex].Address ;	// 8-bit Register Address
	  
	  cmd[1] = Value;	// 8-bit Register Data 
	  
	  i=DAVINCIEVM_I2C_write1( STV0297_I2C_ADDR, cmd, 2 );

      //i= DAVINCIEVM_I2C_write( 0x20, cmd, 1 );

      printf("0297_write_is %d     0x%x = 0x%x    \n",i,cmd[0],cmd[1]);
	  
      DeviceMap->RegMap[RegIndex].Value = Value;   /* update local copy as well */
    
}


U8 STI2C0297_READ(U8 RegIndex)
{  
    U8 cmd[2];
	
	int i;

    cmd[0] = DeviceMap->RegMap[RegIndex].Address;	// 8-bit Register Address
    
    cmd[1] = 0; 		// 8-bit Register Data

	i=DAVINCIEVM_I2C_write1( STV0297_I2C_ADDR, cmd, 1 );
    
	//i=DAVINCIEVM_I2C_write( STV0297_I2C_ADDR, cmd, 0 );

    printf("0297_write_is %d      0x%x  \n",i,cmd[0]);
	
    i=DAVINCIEVM_I2C_read1 ( STV0297_I2C_ADDR, cmd, 1 );

	printf("0297_read_is %d  0x%x   \n",i,cmd[0]);
	
	DeviceMap->RegMap[RegIndex].Value = cmd[0];
	
    return cmd[0];
	
}

void ST0297_FieldSetVal(U8 FieldIndex, U8 Value)
{
    STTUNER_IOREG_Fieldb_t *Field;

    Field = &DeviceMap->FieldMap[FieldIndex];

    if(Field->Type == FIELD_TYPE_SIGNED)
    {
        Value = (Value > 0 ) ? Value : Value + (1 << Field->Bits);	/*	compute signed fieldval	*/
    }
    
    Value = Field->Mask & (Value << Field->Pos);	/*	Shift and mask value */

    /*	Concat register value and fieldval */
    DeviceMap->RegMap[Field->Reg].Value = ( DeviceMap->RegMap[Field->Reg].Value & (~Field->Mask) ) + Value;

}

void  STI2C0297_SETFIELD(U8 FieldIndex, U8 Value)
{

    STTUNER_IOREG_Fieldb_t *Field;
	
    Field = &DeviceMap->FieldMap[FieldIndex];

    STI2C0297_READ(Field->Reg); /* read device register */

    ST0297_FieldSetVal(FieldIndex, Value);    /*	Compute new RegMap value */

    STI2C0297_WRITE(Field->Reg, DeviceMap->RegMap[Field->Reg].Value );  /*	Write the register */

   
}

U8  ST0297_FieldGetVal(U8 FieldIndex)
{

    U8 Value;
    STTUNER_IOREG_Fieldb_t *Field;

    Field = &DeviceMap->FieldMap[FieldIndex];

    /*	Extract field */
    Value = ( (DeviceMap->RegMap[Field->Reg].Value & Field->Mask) >> Field->Pos);

    if( (Field->Type == FIELD_TYPE_SIGNED) && ( Value >= (1 << (Field->Bits-1)) ) )
    {
        Value = Value - (1 << Field->Bits); /* Compute signed values */
    }    
    return(Value);
}

U8 STI2C0297_GETFIELD(U8 FieldIndex)
{

    U8 Value;

    STI2C0297_READ(DeviceMap->FieldMap[FieldIndex].Reg); /* read device register */
    
    Value = ST0297_FieldGetVal(FieldIndex);
	
    return(Value);
}

void STI2C0297_Reload(void)
{   
     U8 index;
     printf ("enter  STI2C0297_Reload....\n");      
     for (index = 0; index < DeviceMap->Registers; index++)
            
                STI2C0297_WRITE(index, DeviceMap->RegMap[index].ResetValue);
                
}

void  TUNER_WRITE(U8 reg1, U8 reg2,U8 reg3,U8 reg4)
	{	
		   U8 cmd[4];

		   int i;
			/* enable repeater */
		   STI2C0297_SETFIELD(F0297_I2CT_EN, 1);
			
		//  i=STI2C0297_GETFIELD(F0297_I2CT_EN);
        //   printf("i=      0x%x    \n",i);
			
		  	cmd[0] = reg1;	// 8-bit Register Address
	     	cmd[1] = reg2;
	    	cmd[2] = reg3;
	    	cmd[3] = reg4;
          // DAVINCIEVM_I2C_write( TUNER_I2C_ADDR, cmd, 2 );
	
           i=DAVINCIEVM_I2C_write1( TUNER_I2C_ADDR, cmd, 4 );

		  printf("2040_write1....%d  0x%x  0x%x  0x%x  0x%x\n",i,cmd[0],cmd[1],cmd[2],cmd[3]);
		  // i=DAVINCIEVM_I2C_write( 0x20, cmd, 1 );

		 // printf("tuner_write2_is  %d     0x%x = 0x%x    \n",i,cmd[0],cmd[1]);
			
	}
 


U8  TUNER_READ(U8 SubAddr)
	{    
	      U8 cmd[2];

		  int i;
	     /* enable repeater  */
		 STI2C0297_SETFIELD(F0297_I2CT_EN, 1);
			
		 cmd[0] = SubAddr ;	 // 8-bit Register Address
		 
		 cmd[1] = 0;		 // 8-bit Register Data

		 //DAVINCIEVM_I2C_write( TUNER_I2C_ADDR, cmd, 1 );
	 
		 //i=DAVINCIEVM_I2C_write( TUNER_I2C_ADDR, cmd, 0 );

		 //printf("tuner_write_is  %d    0x%x \n",i,cmd[0]);
		 
		 i=DAVINCIEVM_I2C_read1 ( TUNER_I2C_ADDR, cmd, 1 );

		 printf("tuner_read_is  %d   0x%x   \n",i,cmd[0]);
	 
		 return cmd[0];
		
	}




void STTUNER_IOREG_AddRegb(U8 RegIndex, U8 Address, U8 ResetValue)
{

    DeviceMap->RegMap[RegIndex].Address    = Address;
    printf("address is  %d   0x%x   0x%x \n",RegIndex,Address,DeviceMap->RegMap[RegIndex].Address   );
    DeviceMap->RegMap[RegIndex].ResetValue = ResetValue;
    DeviceMap->RegMap[RegIndex].Value      = 0;  	
   	  
}

U8 IOREG_FieldCreateMaskb(STTUNER_IOREG_Fieldb_t *Field)
{
    U8 i;