hi_vda.c

华为 HI3510 BOOTLOADER HIBOOT 源码包

#include <config.h>

#if defined(CONFIG_HI3560_LOGO)

#include <common.h>
#include "hi_i2c.h"

#include "hi_video.h"
#include "hi_vda.h"

#define I2C_ADV7171     0x56 
#define ADV7171_NUM_REGISTERS   128

struct adv7171 {
	
     /* struct i2c_client *client; */
    	int addr;
	
	unsigned char reg[ADV7171_NUM_REGISTERS];

	int norm;	
	int master;	
	int ccir;
	
	int input;
	int enable;
	int bright;
	int contrast;
	int hue;
	int sat;
};


/* ----------------------------------------------------------------------- */
// Output filter:  S-Video  Composite

#define MR050       0x11	//0x09
#define MR060       0x14	//0x0c

//---------------------------------------------------------------------------
#define TR0MODE_656  0x08  //added by yuanyabin 05/1/27
#define TR0MODE_601  0x04  //modified by yuanyabin 05/1/27


#define TR0RST      0x80

#define TR1CAPT	    0x00
#define TR1PLAY	    0x00


static const unsigned char init_656_NTSC[] = {
	0x00, 0xb4,		// MR0
	0x01, 0x00,		// MR1
	0x02, 0x00,		// MR2 RTC control: bits 2 and 1 
	0x03, 0x00,		// MR3
	0x04, 0x15,		// MR4
	0x05, 0x00,		// Reserved
	0x06, 0x00,		// Reserved
	0x07, TR0MODE_656,	// TM0
	0x08, TR1CAPT,		// TM1
	0x09, 0x16,		// Fsc0
	0x0a, 0x7c,		// Fsc1
	0x0b, 0xf0,		// Fsc2
	0x0c, 0x21,		// Fsc3
	0x0d, 0x00,		// Subcarrier Phase
	0x0e, 0x00,		// Closed Capt. Ext 0
	0x0f, 0x00,		// Closed Capt. Ext 1
	0x10, 0x00,		// Closed Capt. 0
	0x11, 0x00,		// Closed Capt. 1
	0x12, 0x00,		// Pedestal Ctl 0
	0x13, 0x00,		// Pedestal Ctl 1
	0x14, 0x00,		// Pedestal Ctl 2
	0x15, 0x00,		// Pedestal Ctl 3
	0x16, 0x00,		// CGMS_WSS_0
	0x17, 0x00,		// CGMS_WSS_1
	0x18, 0x00,		// CGMS_WSS_2
	0x19, 0x00,		// Teletext Ctl 
};


static const unsigned char init_656_PAL[] = {

	0x00, 0xb5,		// MR0, CIF, PAL BDGHI
	0x01, 0x00,		// MR1, 
	0x02, 0x00,		// MR2 RTC control: bits 2 and 1,
	0x03, 0x00,		// MR3
	0x04, 0x15,		// MR4, RGB OUTPUT
	0x05, 0x00,		// Reserved
	0x06, 0x00,		// Reserved
	0x07, TR0MODE_656,	// TM0
	0x08, TR1CAPT,		// TM1
	0x09, 0xcb,		// Fsc0
	0x0a, 0x8a,		// Fsc1
	0x0b, 0x09,		// Fsc2
	0x0c, 0x2a,		// Fsc3
	0x0d, 0x00,		// Subcarrier Phase
	0x0e, 0x00,		// Closed Capt. Ext 0
	0x0f, 0x00,		// Closed Capt. Ext 1
	0x10, 0x00,		// Closed Capt. 0
	0x11, 0x00,		// Closed Capt. 1
	0x12, 0x00,		// Pedestal Ctl 0
	0x13, 0x00,		// Pedestal Ctl 1
	0x14, 0x00,		// Pedestal Ctl 2
	0x15, 0x00,		// Pedestal Ctl 3
	0x16, 0x00,		// CGMS_WSS_0
	0x17, 0x00,		// CGMS_WSS_1
	0x18, 0x00,		// CGMS_WSS_2
	0x19, 0x00,		// Teletext Ctl     	
};




static  unsigned char init_601_NTSC[] = {
	0x00, 0xb4,		// MR0
	0x01, 0x00,  		// MR1
	0x02, 0x08,  //0x00,		// MR2 RTC control: bits 2 and 1 
	0x03, 0x04,  //0x00,		// MR3
	0x04, 0x0C,  //0x15,		// MR4
	0x05, 0x00,		// Reserved
	0x06, 0x00,		// Reserved
	0x07, TR0MODE_601,		// TM0
	0x08, TR1CAPT,		// TM1
	0x09, 0x16,		// Fsc0
	0x0a, 0x7c,		// Fsc1
	0x0b, 0xf0,		// Fsc2
	0x0c, 0x21,		// Fsc3
	0x0d, 0x00,		// Subcarrier Phase
	0x0e, 0x00,		// Closed Capt. Ext 0
	0x0f, 0x00,		// Closed Capt. Ext 1
	0x10, 0x00,		// Closed Capt. 0
	0x11, 0x00,		// Closed Capt. 1
	0x12, 0x00,		// Pedestal Ctl 0
	0x13, 0x00,		// Pedestal Ctl 1
	0x14, 0x00,		// Pedestal Ctl 2
	0x15, 0x00,		// Pedestal Ctl 3
	0x16, 0x00,		// CGMS_WSS_0
	0x17, 0x00,		// CGMS_WSS_1
	0x18, 0x00,		// CGMS_WSS_2
	0x19, 0x00,		// Teletext Ctl 
};



static  unsigned char init_601_PAL[] = {
	


	0x00, 0xb5,		// MR0, CIF, PAL BDGHI
	0x01, 0x00,		// MR1, 
	0x02, 0x08,  //0x00,		// MR2 RTC control: bits 2 and 1,
	0x03, 0x04,  //0x00,		// MR3
	0x04, 0x1C,  //0x15,		// MR4, RGB OUTPUT
	0x05, 0x00,		// Reserved
	0x06, 0x00,		// Reserved
	0x07, TR0MODE_601,	// TM0
	0x08, TR1CAPT,		// TM1
	0x09, 0xcb,		// Fsc0
	0x0a, 0x8a,		// Fsc1
	0x0b, 0x09,		// Fsc2
	0x0c, 0x2a,		// Fsc3
	0x0d, 0x00,		// Subcarrier Phase
	0x0e, 0x00,		// Closed Capt. Ext 0
	0x0f, 0x00,		// Closed Capt. Ext 1
	0x10, 0x00,		// Closed Capt. 0
	0x11, 0x00,		// Closed Capt. 1
	0x12, 0x00,		// Pedestal Ctl 0
	0x13, 0x00,		// Pedestal Ctl 1
	0x14, 0x00,		// Pedestal Ctl 2
	0x15, 0x00,		// Pedestal Ctl 3
	0x16, 0x00,		// CGMS_WSS_0
	0x17, 0x00,		// CGMS_WSS_1
	0x18, 0x00,		// CGMS_WSS_2
	0x19, 0x00,		// Teletext Ctl     	
};

static struct i2c_client client_template = {
        "ADV7171",
        0,
        0,
        I2C_ADV7171,      
        NULL
};

static int adv7171_i2c_id = 0;

/***********************************************************************************/
static unsigned long writeReg( struct i2c_client *pstClient,  unsigned char u8Reg,  unsigned char u8Data)
{
	struct adv7171 *dev = (struct adv7171 *)(pstClient->data);

	dev->reg[u8Reg] = u8Data;

    	I2C_Write(pstClient, u8Reg, u8Data);
        
    	return 0;
}


/***********************************************************************************/
static unsigned long writeRegs( struct i2c_client *pstClient,  unsigned char *pu8Data,  unsigned int u32Len)
{
	struct adv7171 *dev = (struct adv7171 *)(pstClient->data);
	int i = 0;
              
    	while (i < u32Len) 
    	{
        	I2C_Write(pstClient, pu8Data[i], pu8Data[i+1]);     
    		dev->reg[i] = pu8Data[i+1];
        	i += 2;
	}	
	return 0;
}


/***********************************************************************************/
static unsigned char readReg( struct i2c_client *pstClient,  unsigned char u8Reg)
{
    	return I2C_Read(pstClient, u8Reg);
}

static struct i2c_client *client = NULL;
static struct i2c_client vadClient ;

unsigned long VDA_Init( int s32Ccir,  int s32Norm,  int s32Master)
{
	int i;
	unsigned long err = 0;
	struct adv7171 *encoder;
	int Arg;
	

	client = &vadClient;
	
	if (client == NULL) 
        {
	  err = 1;
	  goto err_out;
	}
	
	memcpy(client, &client_template, sizeof(struct i2c_client));
	
	client->id = adv7171_i2c_id++;
	
		
	encoder = malloc(sizeof(struct adv7171));
	if (encoder == NULL) 
	{
	  goto err_out;
	}
	
	memset(encoder, 0, sizeof(struct adv7171));
	if(s32Norm == VIDEO_NORM_PAL)
	  encoder->norm = VIDEO_NORM_PAL;	
	else if(s32Norm == VIDEO_NORM_NTSC)
	  encoder->norm = VIDEO_NORM_NTSC;

	
	if(s32Ccir == VIDEO_MODE_CCIR656)
	  {
	    encoder->ccir = VIDEO_MODE_CCIR656;
	    encoder->master = VIDEO_MODE_MASTER;
	  }
	else if(s32Ccir == VIDEO_MODE_CCIR601)
	  {
	    encoder->ccir = VIDEO_MODE_CCIR601;
	    encoder->master = s32Master;
	  }
	
	encoder->input = 0;
	encoder->enable = 1;	
	
        client->data = encoder;


        if((s32Ccir == VIDEO_MODE_CCIR656)&&(s32Norm == VIDEO_NORM_PAL))
        {
          if (writeRegs(client, (unsigned char *)&init_656_PAL, sizeof(init_656_PAL)) != 0)
          {
            err = 1;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR656)&&(s32Norm == VIDEO_NORM_NTSC))
	{
          if (writeRegs(client, (unsigned char *)&init_656_NTSC, sizeof(init_656_NTSC)) != 0)
          {
            err = 1;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR601)&&(s32Norm == VIDEO_NORM_PAL))
	{
	  if(s32Master == VIDEO_MODE_MASTER)
	    {
	      init_601_PAL[15] |= VIDEO_MODE_MASTER;
	    }
	  else if(s32Master == VIDEO_MODE_SLAVER)
	    {
	      init_601_PAL[15] &= ~VIDEO_MODE_MASTER;
	    }
	    
	  if (writeRegs(client, (unsigned char *)&init_601_PAL, sizeof(init_601_PAL))  != 0)
          {
            err = 1;
            goto err_out_free_encoder;
          }
	}
	else if((s32Ccir == VIDEO_MODE_CCIR601)&&(s32Norm == VIDEO_NORM_NTSC))
	{
	  if(s32Master == VIDEO_MODE_MASTER)
	    {
	      init_601_NTSC[15] |= VIDEO_MODE_MASTER;
	    }
	  if(s32Master == VIDEO_MODE_SLAVER)
	    {
	      init_601_NTSC[15] &= ~VIDEO_MODE_MASTER;
	    }
	    
	  if (writeRegs(client, (unsigned char *)&init_601_NTSC, sizeof(init_601_NTSC))  != 0)
          {
            err = 1;
            goto err_out_free_encoder;
          }
	}
	
	if(s32Ccir == VIDEO_MODE_CCIR656)
	  {
	    i = writeReg(client, 0x07, TR0MODE_656 | TR0RST);
	    i = writeReg(client, 0x07, TR0MODE_656);
	  }
	else if(s32Ccir == VIDEO_MODE_CCIR601)
	  {
	    if(s32Master == VIDEO_MODE_MASTER)
	    {
	      i = writeReg(client, 0x07, TR0MODE_601 | TR0RST | VIDEO_MODE_MASTER);
	      i = writeReg(client, 0x07, TR0MODE_601 | VIDEO_MODE_MASTER);
	    }
	    else
	    {
	      i = writeReg(client, 0x07, TR0MODE_601 | TR0RST);
	      i = writeReg(client, 0x07, TR0MODE_601);
	    }
	  }

	return(0);

err_out_free_encoder:
	printf("err_out_free_encoder\n");
	free(encoder);
err_out:
	printf("err_out\n");
	return 1;
}

#endif