Ejemplo n.º 1
0
/* **************************************************** */
DMD_ERROR_t DMD_TCB_WriteRead(DMD_u8_t	slvadr , DMD_u8_t adr , DMD_u8_t* wdata , DMD_u32_t wlen , DMD_u8_t* rdata , DMD_u32_t rlen , DMD_PARAMETER_t* param )
{
	DMD_ERROR_t ret = DMD_E_OK;

	//------ Set to bypass Mode
	//ret |= DMD_I2C_Write( DMD_BANK_T2_ , DMD_TCBSET , 0xe3 );
	ret |= DMD_I2C_Write( DMD_BANK_T2_ , DMD_TCBCOM , 0x1 );
	
    //Example. Customer can communicate Tuner directly.
    //####################################################################
    #error "Pls. add I2C function here! you can refer to function in <MN_I2C.c>\n "
	 //####################################################################

	//------ bypass mode off
	ret |= DMD_I2C_Write( DMD_BANK_T2_ , DMD_TCBCOM , 0x0 );// need off everytime, after off, SoC can communicate with Demod 
	
	return ret;
}	
/* **************************************************** */
DMD_u32_t	DMD_con_i2c_test( DMD_PARAMETER *param )
{

	DMD_s8_t	buf[20];
	DMD_s8_t	com[10];
	DMD_s32_t	slv,adr,data;
	DMD_s32_t	exitFlag=0;
	DMD_u8_t	rd,rdd[257];
	int i;
	while(!exitFlag)
	{
		printf("I2C Test : (r/w/d) (slave) (address) [data]>");
		fgets( buf , 20 , stdin );
		sscanf(buf , "%s %x %x %x" , com , &slv , &adr , &data);
		switch( com[0] )
		{
		case 'w':
			DMD_I2C_Write( (DMD_u8_t)slv ,(DMD_u8_t)adr ,(DMD_u8_t)data );
			printf("Write: %02x %02x %02x\n",slv,adr,data);
			break;
		case 'r':
			DMD_I2C_Read( (DMD_u8_t) slv, (DMD_u8_t) adr,&rd);
			printf("Read: %02x %02x %02x\n",slv,adr,rd);
			break;
		case 'd':
			printf("       _0 _1 _2 _3 _4 _5 _6 _7 _8 _9 _a _b _c _d _e _f");
			for( i=0;i<256;i++ )
			{
				if( (i%16) == 0 )
				{
					DMD_I2C_WriteRead( ( DMD_u8_t) slv , (DMD_u8_t) i , 0 , 0, rdd , 16 );
					printf("\n0x%x_ : " , i/16 );

				}
				printf("%02x ",rdd[i%16] );
			}
			printf("\n");
			break;
		case 'q':
			exitFlag = 1;
			break;
		}

	}

	return DMD_E_OK;
}
Ejemplo n.º 3
0
HI_S32 MN88472_Connect(HI_U32 u32TunerPort,TUNER_ACC_QAM_PARAMS_S *pstChannel)
{
    DMD_PARAMETER_t * pstParaMeter;
    HI_U8 enI2cChan;
    DMD_ERROR_t enRet;
    DMD_u32_t     i2caddr;

    HI_TUNER_CHECKPOINTER( pstChannel);
    /* Check tuner port and init. */
    if (u32TunerPort >= MAX_TUNER)
    {
        HI_ERR_TUNER("Bad u32TunerPort\n");
        return HI_FAILURE;
    }

    pstParaMeter = g_stMN88472Demod + u32TunerPort;
    enI2cChan = g_stTunerOps[u32TunerPort].enI2cChannel;
    i2caddr = g_stTunerOps[u32TunerPort].u32DemodAddress;

    pstParaMeter->freq = pstChannel->u32Frequency;

    switch(g_stTunerOps[u32TunerPort].enSigType)
    {
    case HI_UNF_TUNER_SIG_TYPE_CAB:
        pstParaMeter->system = DMD_E_DVBC;
        break;
    case HI_UNF_TUNER_SIG_TYPE_DVB_T:
        pstParaMeter->system = DMD_E_DVBT;
        break;
    case HI_UNF_TUNER_SIG_TYPE_DVB_T2:
        pstParaMeter->system = DMD_E_DVBT2;
        break;
    default:
    	HI_ERR_TUNER("Signal type not supported!\n");
       return HI_FAILURE;
    }

    if (HI_UNF_TUNER_SIG_TYPE_CAB != g_stTunerOps[u32TunerPort].enSigType)
    {
        switch(pstChannel->unSRBW.u32BandWidth)
        {
            case 5000:
                pstParaMeter->bw = DMD_E_BW_5MHZ;
                break;
            case 6000:
                pstParaMeter->bw = DMD_E_BW_6MHZ;
                break;
            case 7000:
                pstParaMeter->bw = DMD_E_BW_7MHZ;
                break;
            case 8000:
                pstParaMeter->bw = DMD_E_BW_8MHZ;
                break;
            case 1700:
                pstParaMeter->bw = DMD_E_BW_1_7MHZ;
                break;
            default:
                return HI_FAILURE;
               
        }
    }    

#if 1
    enRet =  g_stTunerOps[u32TunerPort].set_tuner(u32TunerPort, enI2cChan, pstParaMeter->freq);
    if (HI_SUCCESS != enRet)
    {
        HI_ERR_TUNER("MN88472 set tuner not ok\n");
        return enRet;
    }
    HI_ERR_TUNER("MN88472 set tuner ok\n");
#endif

    /*set ts interface to parallel or serial*/
    if(DMD_TS_PARALLEL == pstParaMeter->tstype)
    {
        if (DMD_E_ERROR == DMD_I2C_Write(enI2cChan, DMD_BANK_1st + i2caddr, DMD_TSSET1, 0))
        {
            return HI_FAILURE;
        }

        if (DMD_E_ERROR == DMD_I2C_Write(enI2cChan, DMD_BANK_2nd + i2caddr, DMD_FIFOSET, 0xE3))
        {
            return HI_FAILURE;
        }
        
    }
    else
    {
        if (DMD_E_ERROR == DMD_I2C_Write(enI2cChan, DMD_BANK_1st + i2caddr, DMD_TSSET1, 1))
        {
            return HI_FAILURE;
        }

        if (DMD_E_ERROR == DMD_I2C_Write(enI2cChan, DMD_BANK_2nd + i2caddr, DMD_FIFOSET, 0xE3))
        {
            return HI_FAILURE;
        }
    }
	
    enRet = DMD_set_system(pstParaMeter);
    if (DMD_E_OK != enRet)
    {
        return HI_FAILURE;
    }
    
    DMD_device_post_tune(pstParaMeter);
   
    return HI_SUCCESS;
}
MXL_STATUS MxLWare603_OEM_WriteRegister(UINT8 devId, UINT8 RegAddr, UINT8 RegData)
{
  // OEM should implement I2C write protocol that complies with MxL603 I2C
  // format.

  // 8 bit Register Write Protocol:
  // +------+-+-----+-+-+----------+-+----------+-+-+
  // |MASTER|S|SADDR|W| |RegAddr   | |RegData(L)| |P|
  // +------+-+-----+-+-+----------+-+----------+-+-+
  // |SLAVE |         |A|          |A|          |A| |
  // +------+---------+-+----------+-+----------+-+-+
  // Legends: SADDR (I2c slave address), S (Start condition), A (Ack), N(NACK), 
  // P(Stop condition)

  MXL_STATUS status = MXL_FALSE;
  
/* If OEM data is implemented, customer needs to use OEM data structure related operation 
   Following code should be used as a reference. 
   For more information refer to sections 2.5 & 2.6 of MxL603_mxLWare_API_UserGuide document.

  UINT8 i2cSlaveAddr;
  UINT8 i2c_bus;
  user_data_t * user_data = (user_data_t *) MxL603_OEM_DataPtr[devId];
 
  if (user_data)
  {
    i2cSlaveAddr = user_data->i2c_address;           // get device i2c address
    i2c_bus = user_data->i2c_bus;                   // get device i2c bus  
  
    sem_up(user_data->sem);                         // up semaphore if needed

    // I2C Write operation 
    status = USER_I2C_WRITE_FUNCTION(i2cSlaveAddr, i2c_bus, RegAddr, RegData);
    
    sem_down(user_data->sem);                       // down semaphore
    user_data->i2c_cnt++;                           // user statistics
  }

*/
  /* If OEM data is not required, customer should treat devId as I2C slave Address */
	//sony_i2c_CommonWriteOneRegister
	//sony_i2c_CommonWriteRegister
	//result = pTuner->pI2c->WriteOneRegister(pTuner->pI2c, pTuner->i2cAddress, 0x44, 0x07);
       // result = pTuner->pI2c->WriteRegister(pTuner->pI2c, pTuner->i2cAddress, 0x01, data, sizeof(data));
#if 1
	//status = Mxl603_Write_With_CXD2837(devId, RegAddr, RegData);
	status = DMD_I2C_Write(devId,RegAddr,RegData);
#else
#ifndef CONFIG_EDA31924_31804_MN88436_MXL603
	devId = devId;
	RegAddr = RegAddr;
	RegData = RegData;

	printf(" Tuner write in , devid[%x], regaddr[%x], data[%x] \n", devId, RegAddr,RegData);

	//status = DMD_TCB_WriteRead(devId, RegAddr, &RegData, 1, 0, 0);

	status = DMD_I2C_Write(devId,RegAddr,RegData);
#else
	unsigned char buf[20];
	if(DemMode==39)
	{//MN88436

		//	printf(" Tuner write in , devid[%x], regaddr[%x], data[%x] \n", devId, RegAddr,RegData);

		//	status = DMD_MN88436_TCB_Write(0xc0,RegAddr, RegData);
		buf[0]=0x15;
		buf[1]=0x53;
		I2CWrite(0x18,buf,2);

		buf[0]=0x17;
		buf[1]=0x00;
		I2CWrite(0x18,buf,2);
		//
		buf[0] = 0x18;
		buf[1] = 0x20;
		buf[2] = 0xc0;
		buf[3] = RegAddr;
		buf[4] = RegData;

		status = I2CWrite(buf[0],&buf[1],4);
		if(status)
		status = MXL_TRUE;
		else
		status = MXL_FALSE;
		if(status)
		printf("MN88436 write Tuner err   %x\n",devId);
		// DMD_MN88436_TCB_Read(UINT8	slvadr , UINT8 adr , UINT8 *data);

	}
#endif
#endif
  return status;
}