i2cphysi.c

stv0299资料

#include "st_tuner.h"
#include "qpsk0299.h"


/* i2cbridge.c */
#ifdef  ENABLE_STAPI_ENVIRONMENT
#include "stddefs.h"
#include "stpio.h"
#include "sti2c.h"                      /* I2C access */
#include "sttbx.h"

extern unsigned char I2cGetSTVAddress (void);
static STI2C_Handle_t DemodHandle,TunerHandle;

void I2cSetDemodHandle(int Handle)
{
   DemodHandle = (STI2C_Handle_t) Handle;  
}

void I2cSetTunerHandle(int Handle)
{
   TunerHandle = (STI2C_Handle_t) Handle;  
}

/*****************************************************
 **FUNCTION ::  I2cReadWrite
 **ACTION   ::  Read/write data from/to the slave
 **PARAMS IN::  mode    ->  READ_DEMOD, WRITE_DEMOD, READ_TUNER, WRITE_TUNER
 **             ChipAddress ->  I2C address of the chip
 **             Data    ->  Buffer containing data to send
 **             NbData  ->  Number of data to write/read
 **PARAMS OUT:: Data    ->  Buffer containing data received  
 **RETURN   ::  if error -1 else communication state
 *****************************************************/

int I2cReadWrite(int mode,unsigned char ChipAddress,unsigned char *Data,int NbData)
{
    ST_ErrorCode_t Error = ST_NO_ERROR;
    int NbRW;
    int retries = 10;
   int   iLocMode;

    do
    {
#if   0
        switch(mode)
        {
            case WRITE_DEMOD:
                Error = STI2C_Write ( DemodHandle,
                                    (U8 *) Data,
                                    (U32) NbData, 
#ifdef   __STAPI_V1_1__
                                    10,
#endif
                                    (U32 *) &NbRW);
                break;

            case READ_DEMOD:
                Error = STI2C_Read ( DemodHandle,
                                    (U8 *)Data,
                                    (U32) NbData, 
#ifdef   __STAPI_V1_1__
                                    10,
#endif
                                    (U32 *) &NbRW);
                break;

            case WRITE_TUNER:
                Error = STI2C_Write ( TunerHandle,
                                       (U8 *)Data,
                                       (U32) NbData, 
#ifdef   __STAPI_V1_1__
                                       10,
#endif
                                       (U32 *) &NbRW); 
                break;

            case READ_TUNER:
                Error = STI2C_Read ( TunerHandle,
                                    (U8 *)Data,
                                    (U32) NbData, 
#ifdef   __STAPI_V1_1__
                                    10,
#endif
                                    (U32 *) &NbRW);  
                break;
            default:
                break;
        }
#else
        switch ( mode )
        {
            case WRITE:
               if ( ChipAddress == I2cGetSTVAddress () )
               {
                  iLocMode = WRITE_DEMOD;
                  Error = STI2C_Write ( DemodHandle,
                                    (U8 *) Data,
                                    (U32) NbData, 
                                    5000,
                                    (U32 *) &NbRW);
               }
               else
               {
                  iLocMode = WRITE_TUNER;
                  Error = STI2C_Write ( TunerHandle,
                                    (U8 *) Data,
                                    (U32) NbData, 
                                    5000,
                                    (U32 *) &NbRW);
               }
               break;

            case READ:
               if ( ChipAddress == I2cGetSTVAddress () )
               {
                  iLocMode = READ_DEMOD;
                  Error = STI2C_Read ( DemodHandle,
                                    (U8 *) Data,
                                    (U32) NbData, 
                                    5000,
                                    (U32 *) &NbRW);
               }
               else
               {
                  iLocMode = READ_TUNER;
                  Error = STI2C_Read ( TunerHandle,
                                    (U8 *) Data,
                                    (U32) NbData, 
                                    5000,
                                    (U32 *) &NbRW);
               }
               break;

            default:
                iLocMode = -1;
                break;
        }
#endif

      if ( Error != ST_NO_ERROR )
      {
        #ifdef PRINT_I2C_ERROR 
            printf ( "<ERR_%03d> (%d) M[%d] L[%d] Dev[%02X]\n",
               retries,
               Error,
               mode,
               iLocMode,
               ChipAddress );            
        #endif
      }
 #if  0
      else
      {
         int   iTemp;
         
         printf ( "<%s_%02X> ",
                  iLocMode == READ_DEMOD ? "LR" : \
                  iLocMode == WRITE_DEMOD ? "LW" : \
                  iLocMode == WRITE_TUNER ? "TW" : \
                  iLocMode == READ_TUNER ? "TR" : "KO",
            ChipAddress );

         for ( iTemp = 0; iTemp < NbData; ++iTemp )
            printf ( " %02X", Data [ iTemp ] );

         printf ( "\n" );
         
      }
 #endif
    } while (Error != ST_NO_ERROR && --retries > 0 );

    return 0;
}
#else

#define  I2C_COMMAND_LEN                     6
#define  MAX_I2C_WRITE_VERIFY_FAIL_COUNT     5
#define  MAX_I2C_RETRY_COUNT                 11

#ifndef PRINT_I2C_ERROR
  #define TUNER_I2C_ERROR(__command__) __command__
#else
  #define TUNER_I2C_ERROR(__command__)
#endif

/* MILLI_DELAY */
#define MILLI_DELAY(__ms__) task_delay ( __ms__ * ST_GetClocksPerSecondLow() / 1000 );

extern   i2c_handle_t      i2c_ssc0;
extern   semaphore_t       *psemLinkIcAccess;

/*{{{ I2C_ReadByte ()*/
/*
int   I2C_ReadByte ()
*/
int   I2C_ReadByte ( unsigned char  ucSlaveAddr,
                     unsigned char  ucRegAddr,
                     unsigned char  *pucDataValueRead )
{
   /* low level I2C interface for link I/O used by tuning process */
   int   iReturnValue;
   BYTE  aucI2CBuffer [ I2C_COMMAND_LEN ];
   int   iActLen;

   int   iRetryCount;

   semaphore_wait ( psemLinkIcAccess );

   iRetryCount = 0;
   while ( TRUE )
   {
      aucI2CBuffer [ 0 ] = ucRegAddr;
	   /* retry until success */
	   if ( i2c_write ( i2c_ssc0, ucSlaveAddr, aucI2CBuffer, 1, &iActLen ) )
	   {
	      if ( ++iRetryCount > MAX_I2C_RETRY_COUNT )
         {
            iReturnValue = -1;
            break;
         }
         TUNER_I2C_ERROR ( do_report ( severity_info, "I2C_ReadByte -> WRITE_ERR for Slave[%02X] Reg[%02X] Try[%d]\n",
                  ucSlaveAddr,
                  ucRegAddr,
                  iRetryCount ) );
		   MILLI_DELAY ( 30 );
	   }
	   else
	   {
	      if ( i2c_read ( i2c_ssc0, ucSlaveAddr, aucI2CBuffer, 1, &iActLen ) )
         {
	         TUNER_I2C_ERROR ( do_report ( severity_info, "I2C_ReadByte -> Slave[%02X] Reg[%02X]\n",
                  ucSlaveAddr,
                  ucRegAddr ) );
         }
         else
         {
		      *pucDataValueRead = aucI2CBuffer [ 0 ];
            iReturnValue = 0;
            break;
         }
	   }
   }

   semaphore_signal ( psemLinkIcAccess );

   return ( iReturnValue );
}
/*}}}*/

/*{{  I2cReadWrite ()*/
/*
int   I2cReadWrite ()
*/
int   I2cReadWrite ( int            iReadWriteMode,
                     unsigned char  ucDeviceAddress,
                     unsigned char  *paucDataBuffer,
                     int            iNoOfBytes2ReadWrite )
{
   BOOLEAN  bError = FALSE;
   int      iActualLength;
   int      iReturnValue;

   semaphore_wait ( psemLinkIcAccess );

   if ( iReadWriteMode == READ_DEMOD || iReadWriteMode == READ_TUNER )
   {
      bError = i2c_read ( i2c_ssc0,
                     ucDeviceAddress,
                     paucDataBuffer,
                     iNoOfBytes2ReadWrite,
                     &iActualLength );
   }
   else
   {
      bError = i2c_write ( i2c_ssc0,
                     ucDeviceAddress,
                     paucDataBuffer,
                     iNoOfBytes2ReadWrite,
                     &iActualLength );
   }

   if ( bError )
   {
      TUNER_I2C_ERROR ( do_report ( severity_info, "%s %d> QPSK0299_I2C%s = Failed to access [%02X]\n",
                     __FILE__,
                     __LINE__,
                     ( iReadWriteMode == READ_DEMOD || iReadWriteMode == READ_TUNER ) ? "Read" : "Write",
                     ucDeviceAddress ) );
      iReturnValue = -1;
   }
   else
   {
      iReturnValue = 0;
   }

   semaphore_signal ( psemLinkIcAccess );

   return iReturnValue;
}
/*}}}*/


/*{{{ I2cSetDemodHandle ()*/
void  I2cSetDemodHandle ( int Handle )
{
}
/*}}}*/

/*{{{ I2cSetTunerHandle ()*/
void  I2cSetTunerHandle ( int Handle )
{
}
/*}}}*/

#endif