[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / lcm / a080ean01_dsi_vdo / a080ean01_dsi_vdo.c

#ifdef BUILD_LK
#include <string.h>
//Evan add
#include <debug.h>
#include <sys/types.h>
#include <platform/mt_i2c.h>
//Evan add end
#else
#include <linux/string.h>
#endif

#ifdef BUILD_LK
#include <platform/mt_gpio.h>
#include <platform/mt_pmic.h>
#else
#include <mach/mt_gpio.h>
#include <mach/mt_pm_ldo.h>
#include <mach/upmu_common.h>
#endif
#include "lcm_drv.h"
#include "a080ean01_dsi_vdo.h"
#ifdef BUILD_LK
//#define TPS_I2C_BUS 2  //0
#define TPS_I2C_ID I2C2
#define TPS_SLAVE_ADDR 0x74
#define TPS_data_size 13 //1024
static const uint8_t e2prom_data[TPS_data_size] = {0xFA,0x3c,0x08,0x09,0x09,0x08,0x23,0x0a,0x01,0x06,0x01,0x7D,0x7D};
#endif

// ---------------------------------------------------------------------------
//  Local Constants
// ---------------------------------------------------------------------------
#define FRAME_WIDTH  (800) //(1024)
#define FRAME_HEIGHT (1280) //(600)

#define LCM_ID 0x00    //Trust+AUO
#define LCM_DSI_CMD_MODE    0

// ---------------------------------------------------------------------------
//  Local Variables
// ---------------------------------------------------------------------------
static LCM_UTIL_FUNCS lcm_util = {
    .set_gpio_out = NULL,
};

#define SET_RESET_PIN(v)    								(lcm_util.set_reset_pin((v)))

#define UDELAY(n) 											(lcm_util.udelay(n))
#define MDELAY(n) 											(lcm_util.mdelay(n))

// ---------------------------------------------------------------------------
//  Local Functions
// ---------------------------------------------------------------------------
#define dsi_set_cmdq_V2(cmd, count, ppara, force_update)    lcm_util.dsi_set_cmdq_V2(cmd, count, ppara, force_update)
#define dsi_set_cmdq(pdata, queue_size, force_update)		lcm_util.dsi_set_cmdq(pdata, queue_size, force_update)
#define wrtie_cmd(cmd)										lcm_util.dsi_write_cmd(cmd)
#define write_regs(addr, pdata, byte_nums)					lcm_util.dsi_write_regs(addr, pdata, byte_nums)
#define read_reg											lcm_util.dsi_read_reg()
#define read_reg_v2(cmd, buffer, buffer_size)               lcm_util.dsi_dcs_read_lcm_reg_v2(cmd, buffer, buffer_size)    

#ifdef BUILD_LK
/*----------------------------------------*/
/*--------------TPS65640------------------*/
static int tps65640_read_id(void)
{
	printf("Evan:%s\n",__func__);
	int ret=0;
	U8 id=0;
	mt_i2c i2c = {0};
	i2c.id = TPS_I2C_ID;
	i2c.addr = TPS_SLAVE_ADDR;
	i2c.mode = ST_MODE;
	i2c.speed = 100;
	i2c.dma_en = 0;

	u8 buf1[2];
	buf1[0]=0xFF;
	buf1[1]=0x01;
	ret = i2c_write(&i2c, buf1, 2);
	if(ret)
		{
			printf("--------Evan:%s step1 error---------\n",__func__);
			//return ret;
		}


	uint8_t buf2=0x07;
	ret = i2c_write(&i2c, &buf2, 1);
	if(ret)
		{
			printf("--------Evan:%s step2-1 error---------\n",__func__);
			//return ret;
		}
	//uint8_t buf3[TPS_data_size];
	ret=i2c_read(&i2c, &id, 1);
	if(ret)
		{
			printf("--------Evan:%s step2-2 error---------\n",__func__);
			//return ret;
		}
	printf("-------Evan:id=%d--------",id);
	return ret;
}

static int tps65640_write_data(void)
{
	printf("Evan:%s\n",__func__);
	int ret=0;
	mt_i2c i2c = {0};
    i2c.id = TPS_I2C_ID;
    i2c.addr = TPS_SLAVE_ADDR;
    i2c.mode = ST_MODE;
    i2c.speed = 100;
    i2c.dma_en = 0;

	/*write  step1*/
	u8 buf1[8];
	u8 buf11[8];
	buf1[0] = 0x00;
	buf11[0]=0x07;
	//lens=TPS_data_size+1;
	int i=0;
	for(i=0;i<7;i++)  //TPS_data_size
		buf1[i+1]=e2prom_data[i];
	for(i=0;i<6;i++)  //TPS_data_size
		buf11[i+1]=e2prom_data[i+7];
		
	ret = i2c_write(&i2c, buf1, 8); //TPS_data_size+1
	if(ret)
		{
			printf("--------Evan:%s step1 error---------\n",__func__);
			return ret;
		}
	
	ret = i2c_write(&i2c, buf11, 7); //TPS_data_size+1
	if(ret)
		{
			printf("--------Evan:%s step1 error---------\n",__func__);
			return ret;
		}
	
	/*write  step2*/
	u8 buf2[2];
	buf2[0]=0xFF;
	buf2[1]=0x80;
	ret = i2c_write(&i2c, buf2, 2);
	if(ret)
		{
			printf("--------Evan:%s step2 error---------\n",__func__);
			return ret;
		}
	
	return ret;
}

static int tps65640_read_data(uint8_t *data)
{
	printf("Evan:%s\n",__func__);
	int ret=0;
	mt_i2c i2c = {0};
    i2c.id = TPS_I2C_ID;
    i2c.addr = TPS_SLAVE_ADDR;
    i2c.mode = ST_MODE;
    i2c.speed = 100;
    i2c.dma_en = 0;
	
	/*read step1*/
	u8 buf1[2];
	buf1[0]=0xFF;
	buf1[1]=0x01;
	ret = i2c_write(&i2c, buf1, 2);
	if(ret)
		{
			printf("--------Evan:%s step1 error---------\n",__func__);
			return ret;
		}
	
	/*read step2*/
	uint8_t buf2=0x00;
	ret = i2c_write(&i2c, &buf2, 1);
	if(ret)
		{
			printf("--------Evan:%s step2-1 error---------\n",__func__);
			return ret;
		}
	//uint8_t buf3[TPS_data_size];
	ret=i2c_read(&i2c, data, 8);//TPS_data_size
	if(ret)
		{
			printf("--------Evan:%s step2-2 error---------\n",__func__);
			return ret;
		}

	/*read step2*/
	buf2=0x08;
	ret = i2c_write(&i2c, &buf2, 1);
	if(ret)
		{
			printf("--------Evan:%s step2-2-1 error---------\n",__func__);
			return ret;
		}
	//uint8_t buf3[TPS_data_size];
	ret=i2c_read(&i2c, &data[8], (TPS_data_size-8));//TPS_data_size
	if(ret)
		{
			printf("--------Evan:%s step2-2-2 error---------\n",__func__);
			return ret;
		}

	
	int i=0;
	for(i=0;i<TPS_data_size;i++)
			printf("------------Evan:read data%d : 0x%x --------\n",i,data[i]);
	return ret;
}


static int tps65640_e2prom_data_check(void)
{
	printf("Evan:%s\n",__func__);
	int i=0,ret=1;
	uint8_t data[TPS_data_size];
	//read e2prom data
	tps65640_read_data(data);
	//check e2prom data
	for(i=0;i<TPS_data_size;i++)
		if(data[i]!=e2prom_data[i])
			{
				ret=0;
				printf("---------Evan:e2prom_data need update--------\n");
				break;
			}
	if(ret)
		printf("---------Evan:e2prom_data is OK--------\n");
	else
		{
			ret=tps65640_write_data();
			MDELAY(100);
		}
	
	tps65640_read_data(data);
	return ret; 
}

static int tps65640_enable()
{
	printf("Evan:%s\n",__func__);
	//todo:IC power on, 
}

/*----------------------------------------*/   
#endif


static void lcd_power_en(unsigned char enabled)
{
    if (enabled) {      
#ifdef BUILD_LK
		upmu_set_rg_vgp1_vosel(0x7);//3.3V
		upmu_set_rg_vgp1_en(0x1);
		upmu_set_rg_vgp3_vosel(0x3);//1.8V
		upmu_set_rg_vgp3_en(0x1);
#else
		upmu_set_rg_vgp1_vosel(0x7);//3.3V
		upmu_set_rg_vgp1_en(0x1);
		upmu_set_rg_vgp3_vosel(0x3);//1.8V
		upmu_set_rg_vgp3_en(0x1);
#endif
    } else {      
#ifdef BUILD_LK
		upmu_set_rg_vgp1_en(0);
		upmu_set_rg_vgp1_vosel(0);
		upmu_set_rg_vgp3_en(0);
		upmu_set_rg_vgp3_vosel(0);
#else
		upmu_set_rg_vgp1_en(0);
		upmu_set_rg_vgp1_vosel(0);
		upmu_set_rg_vgp3_en(0);
		upmu_set_rg_vgp3_vosel(0);
#endif
    }
}


static void lcd_reset(unsigned char enabled)
{
    if (enabled)
    {
        mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ONE);
    }
    else
    {	
        mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ZERO);    	
    }
}


// ---------------------------------------------------------------------------
//  LCM Driver Implementations
// ---------------------------------------------------------------------------
static void lcm_set_util_funcs(const LCM_UTIL_FUNCS *util)
{
    memcpy(&lcm_util, util, sizeof(LCM_UTIL_FUNCS));
}


static void lcm_get_params(LCM_PARAMS *params)
{
    memset(params, 0, sizeof(LCM_PARAMS));

    params->type     = LCM_TYPE_DSI;
    params->width    = FRAME_WIDTH;
    params->height   = FRAME_HEIGHT;
    params->dsi.mode = SYNC_EVENT_VDO_MODE; //BURST_VDO_MODE;BURST_VDO_MODE;

    // DSI
    /* Command mode setting */
    params->dsi.LANE_NUM				= LCM_FOUR_LANE;
    //The following defined the fomat for data coming from LCD engine.
    params->dsi.data_format.format		= LCM_DSI_FORMAT_RGB888;  //LCM_DSI_FORMAT_RGB666;

    // Video mode setting		
    params->dsi.PS = LCM_PACKED_PS_24BIT_RGB888;  //LCM_PACKED_PS_18BIT_RGB666;

    params->dsi.vertical_sync_active				= 4;//10;//0;
    params->dsi.vertical_backporch				= 8;//13;//23;
    params->dsi.vertical_frontporch 				= 8;//12;
    params->dsi.vertical_active_line				= FRAME_HEIGHT; 

    params->dsi.horizontal_sync_active				= 4;//120;//0;
    params->dsi.horizontal_backporch				= 132;//100;//160;
    params->dsi.horizontal_frontporch				= 24;//100;//160;
    params->dsi.horizontal_active_pixel 			= FRAME_WIDTH;

    params->dsi.PLL_CLOCK = 250;//148;
}


static void init_lcm_registers(void)
{
#ifdef BUILD_LK
    printf("%s, LK \n", __func__);
#else
    printk("%s, kernel", __func__);
#endif
}

//extern void tps65640_en(void);

static void extra_cmd(void)
{
	unsigned int data_array[16];
	//--------------LCM tmp start------------//
		
		data_array[0] = 0x00033902;
		data_array[1] = 0x005A5AF1;
		dsi_set_cmdq(data_array, 2, 1);
		MDELAY(30);
	
		data_array[0] = 0x00033902;
		data_array[1] = 0x00A5A5FC;
		dsi_set_cmdq(data_array, 2, 1);
		MDELAY(30);
	
		data_array[0] = 0x00033902;
		data_array[1] = 0x001000D0;
		dsi_set_cmdq(data_array, 2, 1);
		MDELAY(30);
	
		data_array[0] = 0x00043902;
		data_array[1] = 0xA04E01BC;
		dsi_set_cmdq(data_array, 2, 1);
		MDELAY(30);
	
		data_array[0] = 0x00063902;
		data_array[1] = 0x1C1003E1;
		data_array[2] = 0x00000782;
		dsi_set_cmdq(data_array, 3, 1);
		MDELAY(30);
	
		data_array[0] = 0x10B11500;
		dsi_set_cmdq(data_array, 1, 1);
		MDELAY(30);
	
		data_array[0] = 0x00053902;
		data_array[1] = 0x2F2214B2;
		data_array[2] = 0x00000004;
		dsi_set_cmdq(data_array, 3, 1);
		MDELAY(30);
	
		data_array[0] = 0x00063902;
		data_array[1] = 0x080C02F2;
		data_array[2] = 0x00001888;
		dsi_set_cmdq(data_array, 3, 1);
		MDELAY(30);
	
		data_array[0] = 0x1EB51500;
		dsi_set_cmdq(data_array, 1, 1);
		MDELAY(30);
	
		data_array[0] = 0x04B01500;
		dsi_set_cmdq(data_array, 1, 1);
		MDELAY(30);
	
		data_array[0] = 0x09FD1500;
		dsi_set_cmdq(data_array, 1, 1);
		MDELAY(30);
	
		data_array[0] = 0x00073902;
		data_array[1] = 0x862163F6;
		data_array[2] = 0x00000000;
		dsi_set_cmdq(data_array, 3, 1);
		MDELAY(30);
	
		data_array[0] = 0x00043902;
		data_array[1] = 0x104C5ED8;
		dsi_set_cmdq(data_array, 2, 1);
		MDELAY(30);
		//
		data_array[0] = 0x000C3902;
		data_array[1] = 0xE0C001F3;
		data_array[2] = 0x3581D062;
		data_array[3] = 0x002430F3;
		dsi_set_cmdq(data_array, 4, 1);
		MDELAY(30);
		
		data_array[0] = 0x002E3902;
		data_array[1] = 0x030200F4;
		data_array[2] = 0x09020326;
		data_array[3] = 0x16160700;
		data_array[4] = 0x08080003;
		data_array[5] = 0x12000003;
		data_array[6] = 0x011E1D1C;
		data_array[7] = 0x02040109;
		data_array[8] = 0x72757461;
		data_array[9] = 0x00808083;
		data_array[10] = 0x28010100;
		data_array[11] = 0x01280304;
		data_array[12] = 0x000032D1;
		dsi_set_cmdq(data_array, 13, 1);
		MDELAY(30);
	
		//
		data_array[0] = 0x001B3902;
		data_array[1] = 0x42429DF5;
		data_array[2] = 0x4F98AB5F;
		data_array[3] = 0x0443330F;
		data_array[4] = 0x05525459;
		data_array[5] = 0x60406040;
		data_array[6] = 0x52262740;
		data_array[7] = 0x00186D25;
		dsi_set_cmdq(data_array, 8, 1);
		MDELAY(30);
	//
		data_array[0] = 0x000B3902;
		data_array[1] = 0x3F3F3FEE;
		data_array[2] = 0x3F3F3F00;
		data_array[3] = 0x00221100;
		dsi_set_cmdq(data_array, 4, 1);
		MDELAY(30); 
	
		data_array[0] = 0x00123902;
		data_array[1] = 0x431212EF;
		data_array[2] = 0x24849043;
		data_array[3] = 0x21210081;
		data_array[4] = 0x80400303;
		data_array[5] = 0x00000082;
		dsi_set_cmdq(data_array, 6, 1);
		MDELAY(30);
	
		data_array[0] = 0x00123902;
		data_array[1] = 0x10350CFA;
		data_array[2] = 0x1A141C14;
		data_array[3] = 0x2C271F1E;
		data_array[4] = 0x30383B33;
		data_array[5] = 0x00003030;
		dsi_set_cmdq(data_array, 6, 1);
		MDELAY(30);
	
		data_array[0] = 0x00123902;
		data_array[1] = 0x10350CFB;
		data_array[2] = 0x1A141C14;
		data_array[3] = 0x2C271F1E;
		data_array[4] = 0x30383B33;
		data_array[5] = 0x00003030;
		dsi_set_cmdq(data_array, 6, 1);
		MDELAY(30);
	
		data_array[0] = 0x00213902;
		data_array[1] = 0x090B0BF7;
		data_array[2] = 0x080A0A09;
		data_array[3] = 0x16160108;
		data_array[4] = 0x01071717;
		data_array[5] = 0x090B0B01;
		data_array[6] = 0x080A0A09;
		data_array[7] = 0x16160108;
		data_array[8] = 0x01071717;
		data_array[9] = 0x00000001;
		dsi_set_cmdq(data_array, 10, 1);
		MDELAY(30);
		//--------------LCM tmp end------------//


}

static void set_reg_for_ESD(void)
{
	unsigned int data_array[16];
	data_array[0] = 0x00033902;
	data_array[1] = 0x5A5AF1;
	dsi_set_cmdq(data_array, 2, 1);
	MDELAY(10);

	data_array[0] = 0x00053902;
	data_array[1] = 0x1C1003E1;
	data_array[2] = 0x00;
	dsi_set_cmdq(data_array, 3, 1);
	MDELAY(10);	

	data_array[0] = 0x00033902;
	data_array[1] = 0x1000D0;
	dsi_set_cmdq(data_array, 2, 1);
	MDELAY(10);
}

static void lcm_init(void)
{
    unsigned int data_array[16];

#ifdef BUILD_LK
    printf("CDT+AUO %s, LK \n", __func__);
#else
    printk("CDT+AUO %s, kernel", __func__);
#endif
	//tps65640_en();
    //mt_set_gpio_out(GPIO118, GPIO_OUT_ONE);
    lcd_reset(0);
    lcd_power_en(0);
    lcd_power_en(1);
    lcd_reset(1);
    MDELAY(20);
	lcd_reset(0);
	MDELAY(20);
	lcd_reset(1);
	MDELAY(20);

    /* software reset */
    //data_array[0] = 0x00010500;
   // dsi_set_cmdq(data_array, 1, 1);

//    MDELAY(80);
	
	/* customer */
	//data_array[0] = 0xFEA11500;
	//dsi_set_cmdq(data_array, 1, 1);
	//MDELAY(80);
    /* set display on */
    //data_array[0] = 0x00290500; 
   // dsi_set_cmdq(data_array, 1, 1);
	data_array[0] = 0x00033902;
	data_array[1] = 0x005A5AF0;
	dsi_set_cmdq(data_array, 2, 1);
	MDELAY(30);

	//add extra cmd ,remove later
	//extra_cmd();
	set_reg_for_ESD();
	
	data_array[0] = 0x00110500;
	dsi_set_cmdq(data_array, 1, 1);

	MDELAY(30);
	//data_array[0] = 0x00290500;
	//dsi_set_cmdq(data_array, 1, 1);
	//MDELAY(10);

	data_array[0] = 0x00043902;
	data_array[1] = 0x280040c3;
	dsi_set_cmdq(data_array, 2, 1);
	MDELAY(20);

	mt_set_gpio_out(GPIO_LCM_PWR_EN, GPIO_OUT_ONE); 
#ifdef BUILD_LK
//	tps65640_e2prom_data_check();	
#endif
	MDELAY(170);
	data_array[0] = 0x00290500;
	dsi_set_cmdq(data_array, 1, 1);
	MDELAY(30);
}


static void lcm_suspend(void)
{
    unsigned int data_array[16];

#ifdef BUILD_LK
    printf("%s, LK \n", __func__);
#else
    printk("%s, kernel", __func__);
#endif
	//mt_set_gpio_out(GPIO118, GPIO_OUT_ZERO);//set standby LOW
    /* set display off */
    //data_array[0] = 0x00280500;
   // dsi_set_cmdq(data_array, 1, 1);

    /* enter sleep mode */
   // data_array[0] = 0x00100500;
    //dsi_set_cmdq(data_array, 1, 1);

	data_array[0] = 0x00280500;
	dsi_set_cmdq(data_array, 1, 1);
	MDELAY(2);

	mt_set_gpio_out(GPIO_LCM_PWR_EN, GPIO_OUT_ZERO);
	MDELAY(2);

	data_array[0] = 0x00043902;
	data_array[1] = 0x200040c3;
	dsi_set_cmdq(data_array, 2, 1);
	MDELAY(20);
	
	data_array[0] = 0x00100500;
	dsi_set_cmdq(data_array, 1, 1);
    MDELAY(200);
	
    lcd_reset(0);
    lcd_power_en(0);
    MDELAY(10);
}


static void lcm_resume(void)
{
    unsigned int data_array[16];

#ifdef BUILD_LK
    printf("%s, LK \n", __func__);
#else
    printk("%s, kernel", __func__);
#endif
	lcm_init();
}

static unsigned int lcm_esd_test = FALSE;

static unsigned int lcm_esd_check(void)
{
	
  #ifndef BUILD_LK

	char  buffer[1];
	int   array[4];
	int ret = 0;

	if(lcm_esd_test)
	{
		lcm_esd_test = FALSE;
		return TRUE;
	}

	array[0] = 0x00013700;
	dsi_set_cmdq(array, 1, 1);	
	read_reg_v2(0x0A, buffer, 1);
	//printk("[LCM ERROR] [0x0A]=0x%02x\n", buffer[0]);
	if((buffer[0]&0x80)!=0x80)
	{
	//	printk("[LCM ERROR] [0x0A]=0x%02x\n", buffer[0]);
		ret++;
	}

	// return TRUE: need recovery
	// return FALSE: No need recovery
	if(ret)
	{
		return TRUE;
	}
	else
	{			 
		return FALSE;
	}
 #endif
}

static unsigned int lcm_esd_recover(void)
{
#ifdef BUILD_LK
    printf("%s, LK \n", __func__);
#else
    printk("%s, KERNEL \n", __func__);
#endif
	lcm_init();
	return TRUE;
}

static unsigned int lcm_compare_id(void)
{
    unsigned int id1 = 0, id2 = 0, id = 0;

#ifdef BUILD_LK
	printf("%s, LK \n", __func__);
#endif
    lcd_reset(0);
    lcd_power_en(0);
    lcd_power_en(1);
    lcd_reset(1);
    MDELAY(20);
	lcd_reset(0);
	MDELAY(20);
	lcd_reset(1);
	MDELAY(20);

	mt_set_gpio_mode(GPIO_HALL_2_PIN, GPIO_HALL_2_PIN_M_GPIO);	
	mt_set_gpio_dir(GPIO_HALL_2_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_HALL_2_PIN, GPIO_PULL_DISABLE);
	mt_set_gpio_mode(GPIO_HALL_1_PIN, GPIO_HALL_1_PIN_M_GPIO);	
	mt_set_gpio_dir(GPIO_HALL_1_PIN, GPIO_DIR_IN);
	mt_set_gpio_pull_enable(GPIO_HALL_1_PIN, GPIO_PULL_DISABLE);
	MDELAY(2);

	id1 = mt_get_gpio_in(GPIO_HALL_2_PIN);
    id2 = mt_get_gpio_in(GPIO_HALL_1_PIN);
	id = (id1<<1)|(id2);
#ifdef BUILD_LK
    printf("CDT+AUO id1=%d,id2=%d,id=0x%x\n",id1,id2,id);
#else
    printk("CDT+AUO id1=%d,id2=%d,id=0x%x\n",id1,id2,id);
#endif
	lcd_reset(0);
    lcd_power_en(0);
    MDELAY(10);
    return (LCM_ID == id)?1:0;
}

LCM_DRIVER a080ean01_dsi_vdo_lcm_drv = 
{
    .name           = "a080ean01_dsi_vdo",
    .set_util_funcs = lcm_set_util_funcs,
    .get_params     = lcm_get_params,
    .init           = lcm_init,
    .suspend        = lcm_suspend,
    .resume         = lcm_resume,
    .esd_check   	= lcm_esd_check,
	.esd_recover    = lcm_esd_recover,
	.compare_id    = lcm_compare_id,
};
Commit	Line	Data
6fa3eb70 S	1	#ifdef BUILD_LK
	2	#include <string.h>
	3	//Evan add
	4	#include <debug.h>
	5	#include <sys/types.h>
	6	#include <platform/mt_i2c.h>
	7	//Evan add end
	8	#else
	9	#include <linux/string.h>
	10	#endif
	11
	12	#ifdef BUILD_LK
	13	#include <platform/mt_gpio.h>
	14	#include <platform/mt_pmic.h>
	15	#else
	16	#include <mach/mt_gpio.h>
	17	#include <mach/mt_pm_ldo.h>
	18	#include <mach/upmu_common.h>
	19	#endif
	20	#include "lcm_drv.h"
	21	#include "a080ean01_dsi_vdo.h"
	22	#ifdef BUILD_LK
	23	//#define TPS_I2C_BUS 2 //0
	24	#define TPS_I2C_ID I2C2
	25	#define TPS_SLAVE_ADDR 0x74
	26	#define TPS_data_size 13 //1024
	27	static const uint8_t e2prom_data[TPS_data_size] = {0xFA,0x3c,0x08,0x09,0x09,0x08,0x23,0x0a,0x01,0x06,0x01,0x7D,0x7D};
	28	#endif
	29
	30	// ---------------------------------------------------------------------------
	31	// Local Constants
	32	// ---------------------------------------------------------------------------
	33	#define FRAME_WIDTH (800) //(1024)
	34	#define FRAME_HEIGHT (1280) //(600)
	35
	36	#define LCM_ID 0x00 //Trust+AUO
	37	#define LCM_DSI_CMD_MODE 0
	38
	39	// ---------------------------------------------------------------------------
	40	// Local Variables
	41	// ---------------------------------------------------------------------------
	42	static LCM_UTIL_FUNCS lcm_util = {
	43	.set_gpio_out = NULL,
	44	};
	45
	46	#define SET_RESET_PIN(v) (lcm_util.set_reset_pin((v)))
	47
	48	#define UDELAY(n) (lcm_util.udelay(n))
	49	#define MDELAY(n) (lcm_util.mdelay(n))
	50
	51	// ---------------------------------------------------------------------------
	52	// Local Functions
	53	// ---------------------------------------------------------------------------
	54	#define dsi_set_cmdq_V2(cmd, count, ppara, force_update) lcm_util.dsi_set_cmdq_V2(cmd, count, ppara, force_update)
	55	#define dsi_set_cmdq(pdata, queue_size, force_update) lcm_util.dsi_set_cmdq(pdata, queue_size, force_update)
	56	#define wrtie_cmd(cmd) lcm_util.dsi_write_cmd(cmd)
	57	#define write_regs(addr, pdata, byte_nums) lcm_util.dsi_write_regs(addr, pdata, byte_nums)
	58	#define read_reg lcm_util.dsi_read_reg()
	59	#define read_reg_v2(cmd, buffer, buffer_size) lcm_util.dsi_dcs_read_lcm_reg_v2(cmd, buffer, buffer_size)
	60
	61	#ifdef BUILD_LK
	62	/----------------------------------------/
	63	/--------------TPS65640------------------/
	64	static int tps65640_read_id(void)
65	{
66	printf("Evan:%s\n",__func__);
67	int ret=0;
68	U8 id=0;
69	mt_i2c i2c = {0};
70	i2c.id = TPS_I2C_ID;
71	i2c.addr = TPS_SLAVE_ADDR;
72	i2c.mode = ST_MODE;
73	i2c.speed = 100;
74	i2c.dma_en = 0;
75
76	u8 buf1[2];
77	buf1[0]=0xFF;
78	buf1[1]=0x01;
79	ret = i2c_write(&i2c, buf1, 2);
80	if(ret)
81	{
82	printf("--------Evan:%s step1 error---------\n",__func__);
83	//return ret;
84	}
85
86
87
88	uint8_t buf2=0x07;
89	ret = i2c_write(&i2c, &buf2, 1);
90	if(ret)
91	{
92	printf("--------Evan:%s step2-1 error---------\n",__func__);
93	//return ret;
94	}
95	//uint8_t buf3[TPS_data_size];
96	ret=i2c_read(&i2c, &id, 1);
97	if(ret)
98	{
99	printf("--------Evan:%s step2-2 error---------\n",__func__);
100	//return ret;
101	}
102	printf("-------Evan:id=%d--------",id);
103	return ret;
104	}
105
106	static int tps65640_write_data(void)
107	{
108	printf("Evan:%s\n",__func__);
109	int ret=0;
110	mt_i2c i2c = {0};
111	i2c.id = TPS_I2C_ID;
112	i2c.addr = TPS_SLAVE_ADDR;
113	i2c.mode = ST_MODE;
114	i2c.speed = 100;
115	i2c.dma_en = 0;
116
117	/write step1/
118	u8 buf1[8];
119	u8 buf11[8];
120	buf1[0] = 0x00;
121	buf11[0]=0x07;
122	//lens=TPS_data_size+1;
123	int i=0;
124	for(i=0;i<7;i++) //TPS_data_size
125	buf1[i+1]=e2prom_data[i];
126	for(i=0;i<6;i++) //TPS_data_size
127	buf11[i+1]=e2prom_data[i+7];
128
129	ret = i2c_write(&i2c, buf1, 8); //TPS_data_size+1
130	if(ret)
131	{
132	printf("--------Evan:%s step1 error---------\n",__func__);
133	return ret;
134	}
135
136	ret = i2c_write(&i2c, buf11, 7); //TPS_data_size+1
137	if(ret)
138	{
139	printf("--------Evan:%s step1 error---------\n",__func__);
140	return ret;
141	}
142
143	/write step2/
144	u8 buf2[2];
145	buf2[0]=0xFF;
146	buf2[1]=0x80;
147	ret = i2c_write(&i2c, buf2, 2);
148	if(ret)
149	{
150	printf("--------Evan:%s step2 error---------\n",__func__);
151	return ret;
152	}
153
154	return ret;
155	}
156
157	static int tps65640_read_data(uint8_t *data)
158	{
159	printf("Evan:%s\n",__func__);
160	int ret=0;
161	mt_i2c i2c = {0};
162	i2c.id = TPS_I2C_ID;
163	i2c.addr = TPS_SLAVE_ADDR;
164	i2c.mode = ST_MODE;
165	i2c.speed = 100;
166	i2c.dma_en = 0;
167
168	/read step1/
169	u8 buf1[2];
170	buf1[0]=0xFF;
171	buf1[1]=0x01;
172	ret = i2c_write(&i2c, buf1, 2);
173	if(ret)
174	{
175	printf("--------Evan:%s step1 error---------\n",__func__);
176	return ret;
177	}
178
179	/read step2/
180	uint8_t buf2=0x00;
181	ret = i2c_write(&i2c, &buf2, 1);
182	if(ret)
183	{
184	printf("--------Evan:%s step2-1 error---------\n",__func__);
185	return ret;
186	}
187	//uint8_t buf3[TPS_data_size];
188	ret=i2c_read(&i2c, data, 8);//TPS_data_size
189	if(ret)
190	{
191	printf("--------Evan:%s step2-2 error---------\n",__func__);
192	return ret;
193	}
194
195	/read step2/
196	buf2=0x08;
197	ret = i2c_write(&i2c, &buf2, 1);
198	if(ret)
199	{
200	printf("--------Evan:%s step2-2-1 error---------\n",__func__);
201	return ret;
202	}
203	//uint8_t buf3[TPS_data_size];
204	ret=i2c_read(&i2c, &data[8], (TPS_data_size-8));//TPS_data_size
205	if(ret)
206	{
207	printf("--------Evan:%s step2-2-2 error---------\n",__func__);
208	return ret;
209	}
210
211
212	int i=0;
213	for(i=0;i<TPS_data_size;i++)
214	printf("------------Evan:read data%d : 0x%x --------\n",i,data[i]);
215	return ret;
216	}
217
218
219
220	static int tps65640_e2prom_data_check(void)
221	{
222	printf("Evan:%s\n",__func__);
223	int i=0,ret=1;
224	uint8_t data[TPS_data_size];
225	//read e2prom data
226	tps65640_read_data(data);
227	//check e2prom data
228	for(i=0;i<TPS_data_size;i++)
229	if(data[i]!=e2prom_data[i])
230	{
231	ret=0;
232	printf("---------Evan:e2prom_data need update--------\n");
233	break;
234	}
235	if(ret)
236	printf("---------Evan:e2prom_data is OK--------\n");
237	else
238	{
239	ret=tps65640_write_data();
240	MDELAY(100);
241	}
242
243	tps65640_read_data(data);
244	return ret;
245	}
246
247	static int tps65640_enable()
248	{
249	printf("Evan:%s\n",__func__);
250	//todo:IC power on,
251	}
252
253	/----------------------------------------/
254	#endif
255
256
257	static void lcd_power_en(unsigned char enabled)
258	{
259	if (enabled) {
260	#ifdef BUILD_LK
261	upmu_set_rg_vgp1_vosel(0x7);//3.3V
262	upmu_set_rg_vgp1_en(0x1);
263	upmu_set_rg_vgp3_vosel(0x3);//1.8V
264	upmu_set_rg_vgp3_en(0x1);
265	#else
266	upmu_set_rg_vgp1_vosel(0x7);//3.3V
267	upmu_set_rg_vgp1_en(0x1);
268	upmu_set_rg_vgp3_vosel(0x3);//1.8V
269	upmu_set_rg_vgp3_en(0x1);
270	#endif
271	} else {
272	#ifdef BUILD_LK
273	upmu_set_rg_vgp1_en(0);
274	upmu_set_rg_vgp1_vosel(0);
275	upmu_set_rg_vgp3_en(0);
276	upmu_set_rg_vgp3_vosel(0);
277	#else
278	upmu_set_rg_vgp1_en(0);
279	upmu_set_rg_vgp1_vosel(0);
280	upmu_set_rg_vgp3_en(0);
281	upmu_set_rg_vgp3_vosel(0);
282	#endif
283	}
284	}
285
286
287	static void lcd_reset(unsigned char enabled)
288	{
289	if (enabled)
290	{
291	mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ONE);
292	}
293	else
294	{
295	mt_set_gpio_out(GPIO_LCM_RST, GPIO_OUT_ZERO);
296	}
297	}
298
299
300	// ---------------------------------------------------------------------------
301	// LCM Driver Implementations
302	// ---------------------------------------------------------------------------
303	static void lcm_set_util_funcs(const LCM_UTIL_FUNCS *util)
304	{
305	memcpy(&lcm_util, util, sizeof(LCM_UTIL_FUNCS));
306	}
307
308
309	static void lcm_get_params(LCM_PARAMS *params)
310	{
311	memset(params, 0, sizeof(LCM_PARAMS));
312
313	params->type = LCM_TYPE_DSI;
314	params->width = FRAME_WIDTH;
315	params->height = FRAME_HEIGHT;
316	params->dsi.mode = SYNC_EVENT_VDO_MODE; //BURST_VDO_MODE;BURST_VDO_MODE;
317
318	// DSI
319	/* Command mode setting */
320	params->dsi.LANE_NUM = LCM_FOUR_LANE;
321	//The following defined the fomat for data coming from LCD engine.
322	params->dsi.data_format.format = LCM_DSI_FORMAT_RGB888; //LCM_DSI_FORMAT_RGB666;
323
324	// Video mode setting
325	params->dsi.PS = LCM_PACKED_PS_24BIT_RGB888; //LCM_PACKED_PS_18BIT_RGB666;
326
327	params->dsi.vertical_sync_active = 4;//10;//0;
328	params->dsi.vertical_backporch = 8;//13;//23;
329	params->dsi.vertical_frontporch = 8;//12;
330	params->dsi.vertical_active_line = FRAME_HEIGHT;
331
332	params->dsi.horizontal_sync_active = 4;//120;//0;
333	params->dsi.horizontal_backporch = 132;//100;//160;
334	params->dsi.horizontal_frontporch = 24;//100;//160;
335	params->dsi.horizontal_active_pixel = FRAME_WIDTH;
336
337	params->dsi.PLL_CLOCK = 250;//148;
338	}
339
340
341	static void init_lcm_registers(void)
342	{
343	#ifdef BUILD_LK
344	printf("%s, LK \n", __func__);
345	#else
346	printk("%s, kernel", __func__);
347	#endif
348	}
349
350	//extern void tps65640_en(void);
351
352	static void extra_cmd(void)
353	{
354	unsigned int data_array[16];
355	//--------------LCM tmp start------------//
356
357	data_array[0] = 0x00033902;
358	data_array[1] = 0x005A5AF1;
359	dsi_set_cmdq(data_array, 2, 1);
360	MDELAY(30);
361
362	data_array[0] = 0x00033902;
363	data_array[1] = 0x00A5A5FC;
364	dsi_set_cmdq(data_array, 2, 1);
365	MDELAY(30);
366
367	data_array[0] = 0x00033902;
368	data_array[1] = 0x001000D0;
369	dsi_set_cmdq(data_array, 2, 1);
370	MDELAY(30);
371
372	data_array[0] = 0x00043902;
373	data_array[1] = 0xA04E01BC;
374	dsi_set_cmdq(data_array, 2, 1);
375	MDELAY(30);
376
377	data_array[0] = 0x00063902;
378	data_array[1] = 0x1C1003E1;
379	data_array[2] = 0x00000782;
380	dsi_set_cmdq(data_array, 3, 1);
381	MDELAY(30);
382
383	data_array[0] = 0x10B11500;
384	dsi_set_cmdq(data_array, 1, 1);
385	MDELAY(30);
386
387	data_array[0] = 0x00053902;
388	data_array[1] = 0x2F2214B2;
389	data_array[2] = 0x00000004;
390	dsi_set_cmdq(data_array, 3, 1);
391	MDELAY(30);
392
393	data_array[0] = 0x00063902;
394	data_array[1] = 0x080C02F2;
395	data_array[2] = 0x00001888;
396	dsi_set_cmdq(data_array, 3, 1);
397	MDELAY(30);
398
399	data_array[0] = 0x1EB51500;
400	dsi_set_cmdq(data_array, 1, 1);
401	MDELAY(30);
402
403	data_array[0] = 0x04B01500;
404	dsi_set_cmdq(data_array, 1, 1);
405	MDELAY(30);
406
407	data_array[0] = 0x09FD1500;
408	dsi_set_cmdq(data_array, 1, 1);
409	MDELAY(30);
410
411	data_array[0] = 0x00073902;
412	data_array[1] = 0x862163F6;
413	data_array[2] = 0x00000000;
414	dsi_set_cmdq(data_array, 3, 1);
415	MDELAY(30);
416
417	data_array[0] = 0x00043902;
418	data_array[1] = 0x104C5ED8;
419	dsi_set_cmdq(data_array, 2, 1);
420	MDELAY(30);
421	//
422	data_array[0] = 0x000C3902;
423	data_array[1] = 0xE0C001F3;
424	data_array[2] = 0x3581D062;
425	data_array[3] = 0x002430F3;
426	dsi_set_cmdq(data_array, 4, 1);
427	MDELAY(30);
428
429	data_array[0] = 0x002E3902;
430	data_array[1] = 0x030200F4;
431	data_array[2] = 0x09020326;
432	data_array[3] = 0x16160700;
433	data_array[4] = 0x08080003;
434	data_array[5] = 0x12000003;
435	data_array[6] = 0x011E1D1C;
436	data_array[7] = 0x02040109;
437	data_array[8] = 0x72757461;
438	data_array[9] = 0x00808083;
439	data_array[10] = 0x28010100;
440	data_array[11] = 0x01280304;
441	data_array[12] = 0x000032D1;
442	dsi_set_cmdq(data_array, 13, 1);
443	MDELAY(30);
444
445	//
446	data_array[0] = 0x001B3902;
447	data_array[1] = 0x42429DF5;
448	data_array[2] = 0x4F98AB5F;
449	data_array[3] = 0x0443330F;
450	data_array[4] = 0x05525459;
451	data_array[5] = 0x60406040;
452	data_array[6] = 0x52262740;
453	data_array[7] = 0x00186D25;
454	dsi_set_cmdq(data_array, 8, 1);
455	MDELAY(30);
456	//
457	data_array[0] = 0x000B3902;
458	data_array[1] = 0x3F3F3FEE;
459	data_array[2] = 0x3F3F3F00;
460	data_array[3] = 0x00221100;
461	dsi_set_cmdq(data_array, 4, 1);
462	MDELAY(30);
463
464	data_array[0] = 0x00123902;
465	data_array[1] = 0x431212EF;
466	data_array[2] = 0x24849043;
467	data_array[3] = 0x21210081;
468	data_array[4] = 0x80400303;
469	data_array[5] = 0x00000082;
470	dsi_set_cmdq(data_array, 6, 1);
471	MDELAY(30);
472
473	data_array[0] = 0x00123902;
474	data_array[1] = 0x10350CFA;
475	data_array[2] = 0x1A141C14;
476	data_array[3] = 0x2C271F1E;
477	data_array[4] = 0x30383B33;
478	data_array[5] = 0x00003030;
479	dsi_set_cmdq(data_array, 6, 1);
480	MDELAY(30);
481
482	data_array[0] = 0x00123902;
483	data_array[1] = 0x10350CFB;
484	data_array[2] = 0x1A141C14;
485	data_array[3] = 0x2C271F1E;
486	data_array[4] = 0x30383B33;
487	data_array[5] = 0x00003030;
488	dsi_set_cmdq(data_array, 6, 1);
489	MDELAY(30);
490
491	data_array[0] = 0x00213902;
492	data_array[1] = 0x090B0BF7;
493	data_array[2] = 0x080A0A09;
494	data_array[3] = 0x16160108;
495	data_array[4] = 0x01071717;
496	data_array[5] = 0x090B0B01;
497	data_array[6] = 0x080A0A09;
498	data_array[7] = 0x16160108;
499	data_array[8] = 0x01071717;
500	data_array[9] = 0x00000001;
501	dsi_set_cmdq(data_array, 10, 1);
502	MDELAY(30);
503	//--------------LCM tmp end------------//
504
505
506	}
507
508	static void set_reg_for_ESD(void)
509	{
510	unsigned int data_array[16];
511	data_array[0] = 0x00033902;
512	data_array[1] = 0x5A5AF1;
513	dsi_set_cmdq(data_array, 2, 1);
514	MDELAY(10);
515
516	data_array[0] = 0x00053902;
517	data_array[1] = 0x1C1003E1;
518	data_array[2] = 0x00;
519	dsi_set_cmdq(data_array, 3, 1);
520	MDELAY(10);
521
522	data_array[0] = 0x00033902;
523	data_array[1] = 0x1000D0;
524	dsi_set_cmdq(data_array, 2, 1);
525	MDELAY(10);
526	}
527
528	static void lcm_init(void)
529	{
530	unsigned int data_array[16];
531
532	#ifdef BUILD_LK
533	printf("CDT+AUO %s, LK \n", __func__);
534	#else
535	printk("CDT+AUO %s, kernel", __func__);
536	#endif
537	//tps65640_en();
538	//mt_set_gpio_out(GPIO118, GPIO_OUT_ONE);
539	lcd_reset(0);
540	lcd_power_en(0);
541	lcd_power_en(1);
542	lcd_reset(1);
543	MDELAY(20);
544	lcd_reset(0);
545	MDELAY(20);
546	lcd_reset(1);
547	MDELAY(20);
548
549	/* software reset */
550	//data_array[0] = 0x00010500;
551	// dsi_set_cmdq(data_array, 1, 1);
552
553	// MDELAY(80);
554
555	/* customer */
556	//data_array[0] = 0xFEA11500;
557	//dsi_set_cmdq(data_array, 1, 1);
558	//MDELAY(80);
559	/* set display on */
560	//data_array[0] = 0x00290500;
561	// dsi_set_cmdq(data_array, 1, 1);
562	data_array[0] = 0x00033902;
563	data_array[1] = 0x005A5AF0;
564	dsi_set_cmdq(data_array, 2, 1);
565	MDELAY(30);
566
567	//add extra cmd ,remove later
568	//extra_cmd();
569	set_reg_for_ESD();
570
571	data_array[0] = 0x00110500;
572	dsi_set_cmdq(data_array, 1, 1);
573
574	MDELAY(30);
575	//data_array[0] = 0x00290500;
576	//dsi_set_cmdq(data_array, 1, 1);
577	//MDELAY(10);
578
579	data_array[0] = 0x00043902;
580	data_array[1] = 0x280040c3;
581	dsi_set_cmdq(data_array, 2, 1);
582	MDELAY(20);
583
584	mt_set_gpio_out(GPIO_LCM_PWR_EN, GPIO_OUT_ONE);
585	#ifdef BUILD_LK
586	// tps65640_e2prom_data_check();
587	#endif
588	MDELAY(170);
589	data_array[0] = 0x00290500;
590	dsi_set_cmdq(data_array, 1, 1);
591	MDELAY(30);
592	}
593
594
595	static void lcm_suspend(void)
596	{
597	unsigned int data_array[16];
598
599	#ifdef BUILD_LK
600	printf("%s, LK \n", __func__);
601	#else
602	printk("%s, kernel", __func__);
603	#endif
604	//mt_set_gpio_out(GPIO118, GPIO_OUT_ZERO);//set standby LOW
605	/* set display off */
606	//data_array[0] = 0x00280500;
607	// dsi_set_cmdq(data_array, 1, 1);
608
609	/* enter sleep mode */
610	// data_array[0] = 0x00100500;
611	//dsi_set_cmdq(data_array, 1, 1);
612
613	data_array[0] = 0x00280500;
614	dsi_set_cmdq(data_array, 1, 1);
615	MDELAY(2);
616
617	mt_set_gpio_out(GPIO_LCM_PWR_EN, GPIO_OUT_ZERO);
618	MDELAY(2);
619
620	data_array[0] = 0x00043902;
621	data_array[1] = 0x200040c3;
622	dsi_set_cmdq(data_array, 2, 1);
623	MDELAY(20);
624
625	data_array[0] = 0x00100500;
626	dsi_set_cmdq(data_array, 1, 1);
627	MDELAY(200);
628
629	lcd_reset(0);
630	lcd_power_en(0);
631	MDELAY(10);
632	}
633
634
635	static void lcm_resume(void)
636	{
637	unsigned int data_array[16];
638
639	#ifdef BUILD_LK
640	printf("%s, LK \n", __func__);
641	#else
642	printk("%s, kernel", __func__);
643	#endif
644	lcm_init();
645	}
4b9e9796	646
6fa3eb70 S	647	static unsigned int lcm_esd_test = FALSE;
	648
	649	static unsigned int lcm_esd_check(void)
	650	{
	651
	652	#ifndef BUILD_LK
	653
	654	char buffer[1];
	655	int array[4];
	656	int ret = 0;
4b9e9796	657
6fa3eb70 S	658	if(lcm_esd_test)
	659	{
	660	lcm_esd_test = FALSE;
	661	return TRUE;
	662	}
	663
	664	array[0] = 0x00013700;
	665	dsi_set_cmdq(array, 1, 1);
	666	read_reg_v2(0x0A, buffer, 1);
	667	//printk("[LCM ERROR] [0x0A]=0x%02x\n", buffer[0]);
	668	if((buffer[0]&0x80)!=0x80)
	669	{
	670	// printk("[LCM ERROR] [0x0A]=0x%02x\n", buffer[0]);
	671	ret++;
	672	}
	673
	674	// return TRUE: need recovery
	675	// return FALSE: No need recovery
	676	if(ret)
	677	{
	678	return TRUE;
	679	}
	680	else
	681	{
	682	return FALSE;
	683	}
	684	#endif
	685	}
	686
	687	static unsigned int lcm_esd_recover(void)
	688	{
	689	#ifdef BUILD_LK
	690	printf("%s, LK \n", __func__);
	691	#else
	692	printk("%s, KERNEL \n", __func__);
	693	#endif
	694	lcm_init();
	695	return TRUE;
	696	}
4b9e9796	697
6fa3eb70 S	698	static unsigned int lcm_compare_id(void)
	699	{
	700	unsigned int id1 = 0, id2 = 0, id = 0;
	701
	702	#ifdef BUILD_LK
	703	printf("%s, LK \n", __func__);
	704	#endif
	705	lcd_reset(0);
	706	lcd_power_en(0);
	707	lcd_power_en(1);
	708	lcd_reset(1);
	709	MDELAY(20);
	710	lcd_reset(0);
	711	MDELAY(20);
	712	lcd_reset(1);
	713	MDELAY(20);
	714
	715	mt_set_gpio_mode(GPIO_HALL_2_PIN, GPIO_HALL_2_PIN_M_GPIO);
	716	mt_set_gpio_dir(GPIO_HALL_2_PIN, GPIO_DIR_IN);
	717	mt_set_gpio_pull_enable(GPIO_HALL_2_PIN, GPIO_PULL_DISABLE);
	718	mt_set_gpio_mode(GPIO_HALL_1_PIN, GPIO_HALL_1_PIN_M_GPIO);
	719	mt_set_gpio_dir(GPIO_HALL_1_PIN, GPIO_DIR_IN);
	720	mt_set_gpio_pull_enable(GPIO_HALL_1_PIN, GPIO_PULL_DISABLE);
	721	MDELAY(2);
	722
	723	id1 = mt_get_gpio_in(GPIO_HALL_2_PIN);
	724	id2 = mt_get_gpio_in(GPIO_HALL_1_PIN);
	725	id = (id1<<1)\|(id2);
	726	#ifdef BUILD_LK
	727	printf("CDT+AUO id1=%d,id2=%d,id=0x%x\n",id1,id2,id);
	728	#else
	729	printk("CDT+AUO id1=%d,id2=%d,id=0x%x\n",id1,id2,id);
	730	#endif
	731	lcd_reset(0);
	732	lcd_power_en(0);
	733	MDELAY(10);
	734	return (LCM_ID == id)?1:0;
	735	}
	736
	737	LCM_DRIVER a080ean01_dsi_vdo_lcm_drv =
	738	{
	739	.name = "a080ean01_dsi_vdo",
	740	.set_util_funcs = lcm_set_util_funcs,
	741	.get_params = lcm_get_params,
	742	.init = lcm_init,
	743	.suspend = lcm_suspend,
	744	.resume = lcm_resume,
4b9e9796 S	745	.esd_check = lcm_esd_check,
4b9e9796 S	746	.esd_recover = lcm_esd_recover,
6fa3eb70 S	747	.compare_id = lcm_compare_id,
	748	};
	749
	750