drivers/misc/mediatek/lcm/ili9806c_dsi_vdo_djn/ili9806c_dsi_vdo_djn.c

   1 #ifndef BUILD_LK
   2 #include <linux/string.h>
   3 #endif
   4 #include "lcm_drv.h"
   5
   6 #ifdef BUILD_LK
   7     #include <platform/mt_gpio.h>
   8     #include <string.h>
   9 #elif defined(BUILD_UBOOT)
  10     #include <asm/arch/mt_gpio.h>
  11 #else
  12     #include <mach/mt_gpio.h>
  13 #endif
  14
  15 // ---------------------------------------------------------------------------
  16 //RGK add
  17 // ---------------------------------------------------------------------------
  18 //#include <cust_adc.h>        // zhoulidong  add for lcm detect
  19 #define AUXADC_LCM_VOLTAGE_CHANNEL     0
  20 #define AUXADC_ADC_FDD_RF_PARAMS_DYNAMIC_CUSTOM_CH_CHANNEL     1
  21
  22 #define MIN_VOLTAGE (800)     // zhoulidong  add for lcm detect
  23 #define MAX_VOLTAGE (1000)     // zhoulidong  add for lcm detect
  24
  25
  26 // ---------------------------------------------------------------------------
  27 //  Local Constants
  28 // ---------------------------------------------------------------------------
  29
  30 #define FRAME_WIDTH                                          (480)
  31 #define FRAME_HEIGHT                                         (800)
  32
  33
  34 #define LCM_ID_ILI9806                                    0x9816  //D3
  35
  36
  37 #ifndef TRUE
  38     #define   TRUE     1
  39 #endif
  40
  41 #ifndef FALSE
  42     #define   FALSE    0
  43 #endif
  44
  45  unsigned static int lcm_esd_test = FALSE;      ///only for ESD test
  46
  47 // ---------------------------------------------------------------------------
  48 //  Local Variables
  49 // ---------------------------------------------------------------------------
  50
  51 static LCM_UTIL_FUNCS lcm_util ;
  52
  53 #define SET_RESET_PIN(v)                                    (lcm_util.set_reset_pin((v)))
  54
  55 #define UDELAY(n)                                             (lcm_util.udelay(n))
  56 #define MDELAY(n)                                             (lcm_util.mdelay(n))
  57
  58
  59 // ---------------------------------------------------------------------------
  60 //  Local Functions
  61 // ---------------------------------------------------------------------------
  62 #define dsi_set_cmdq_V3(para_tbl,size,force_update)        lcm_util.dsi_set_cmdq_V3(para_tbl,size,force_update)
  63 #define dsi_set_cmdq_V2(cmd, count, ppara, force_update)            lcm_util.dsi_set_cmdq_V2(cmd, count, ppara, force_update)
  64 #define dsi_set_cmdq(pdata, queue_size, force_update)        lcm_util.dsi_set_cmdq(pdata, queue_size, force_update)
  65 #define wrtie_cmd(cmd)                                        lcm_util.dsi_write_cmd(cmd)
  66 #define write_regs(addr, pdata, byte_nums)                    lcm_util.dsi_write_regs(addr, pdata, byte_nums)
  67 #define read_reg(cmd)                                            lcm_util.dsi_dcs_read_lcm_reg(cmd)
  68 #define read_reg_v2(cmd, buffer, buffer_size)                   lcm_util.dsi_dcs_read_lcm_reg_v2(cmd, buffer, buffer_size)
  69
  70 #define   LCM_DSI_CMD_MODE                            0
  71
  72 // zhoulidong  add for lcm detect ,read adc voltage
  73 extern int IMM_GetOneChannelValue(int dwChannel, int data[4], int* rawdata);
  74
  75
  76 static LCM_setting_table_V3 lcm_initialization_setting[] = {
  77
  78
  79
  80
  81     {0x39,  0XFF,    3,    {0XFF, 0X98, 0X16}},
  82         {0x15,  0XBA,    1,    {0X60}},
  83     {0x15,  0XB0,    1,    {0X01}},
  84     {0x39,  0XBC,    18,    {0X03, 0X0D, 0X63, 0X33, 0X16, 0X16, 0X1B, 0X11, 0X38, 0X00, 0X00, 0X00, 0X16, 0X16, 0X08, 0X00, 0XFF, 0XF0}},
  85     {0x39,  0xBD,    8,    {0X01, 0X45, 0X45, 0X67, 0X01, 0X23, 0X45, 0X67}},
  86     {0x39,  0XBE,    17,    {0X13, 0X22, 0X11, 0X00, 0X66, 0X77, 0x22, 0x22, 0xAA, 0XCC, 0XBB, 0XDD, 0X22, 0X22, 0X22, 0X22, 0X22}},
  87     {0x39,  0xED,    2,    {0X7F, 0X0F}},
  88     {0x15,  0xF3,    1,    {0X70}},
  89     {0x15,  0xB4,    1,    {0X02}},
  90     {0x39,  0xC0,    3,    {0X0F,0X0B, 0X0A}},
  91     {0x39,  0xC1,    4,    {0X17, 0x8E, 0X87, 0X20}},
  92     {0x15,  0xD8,    1,    {0X50}},
  93     {0x15,  0xFC,    1,    {0X07}},
  94     {0x39,  0xE0,    16,    {0X00, 0X19, 0X22, 0X0F, 0X11, 0X17, 0XC6, 0X09, 0X06, 0X0A, 0X05, 0X10, 0X0E, 0X2D, 0X2A, 0X00}},
  95     {0x39,  0xE1,    16,    {0X00, 0X0C, 0X1A, 0X11, 0X11, 0X16, 0X79, 0X06, 0X02, 0X07, 0X09, 0X0B, 0X0B, 0X23, 0X1C, 0X00}},
  96     {0x39,  0xD5,    8,    {0X10, 0X08, 0X08, 0X07, 0XCB, 0XA5, 0X01, 0X04}},
  97     {0x15,  0XF7,    1,    {0X8A}},
  98     {0x15,  0XC7,    1,    {0X55}},//61  65  70
  99     {0x15,  0x11,    1,    {0x00}},
 100
 101     {0x05,0x11,0,{}},
 102     {REGFLAG_ESCAPE_ID,REGFLAG_DELAY_MS_V3, 120, {}},
 103
 104     {0x39, 0xEE, 9, {0x0A,0x1B,0x5F,0x40,0x00,0x00,0X10,0x00,0x58}},
 105
 106     {0x05, 0x29,0,{}},
 107     {REGFLAG_ESCAPE_ID,REGFLAG_DELAY_MS_V3, 10, {}},
 108
 109 };
 110
 111
 112 // ---------------------------------------------------------------------------
 113 //  LCM Driver Implementations
 114 // ---------------------------------------------------------------------------
 115 static void lcm_set_util_funcs(const LCM_UTIL_FUNCS *util)
 116 {
 117     memcpy(&lcm_util, util, sizeof(LCM_UTIL_FUNCS));
 118 }
 119
 120
 121 static void lcm_get_params(LCM_PARAMS *params)
 122 {
 123
 124         memset(params, 0, sizeof(LCM_PARAMS));
 125
 126         params->type   = LCM_TYPE_DSI;
 127
 128         params->width  = FRAME_WIDTH;
 129         params->height = FRAME_HEIGHT;
 130
 131         #if (LCM_DSI_CMD_MODE)
 132         params->dsi.mode   = CMD_MODE;
 133         #else
 134         params->dsi.mode   = SYNC_PULSE_VDO_MODE; //SYNC_PULSE_VDO_MODE;//BURST_VDO_MODE;
 135         #endif
 136
 137         // DSI
 138         /* Command mode setting */
 139         //1 Three lane or Four lane
 140         params->dsi.LANE_NUM                = LCM_TWO_LANE;
 141         //The following defined the fomat for data coming from LCD engine.
 142         params->dsi.data_format.format      = LCM_DSI_FORMAT_RGB888;
 143
 144         // Video mode setting
 145         params->dsi.PS=LCM_PACKED_PS_24BIT_RGB888;
 146
 147     params->dsi.vertical_sync_active                =4;
 148     params->dsi.vertical_backporch                    = 16;
 149     params->dsi.vertical_frontporch                    = 10;
 150     params->dsi.vertical_active_line                = FRAME_HEIGHT;
 151
 152
 153     params->dsi.horizontal_sync_active                = 10;///////////////20 20 4  20  14  6
 154      params->dsi.horizontal_backporch                = 80;
 155     params->dsi.horizontal_frontporch                = 80;
 156     params->dsi.horizontal_active_pixel                = FRAME_WIDTH;
 157
 158         //params->dsi.LPX=8;
 159
 160         // Bit rate calculation
 161         //1 Every lane speed
 162         //params->dsi.pll_select=1;
 163         //params->dsi.PLL_CLOCK  = LCM_DSI_6589_PLL_CLOCK_377;
 164         params->dsi.PLL_CLOCK=234;
 165         params->dsi.pll_div1=0;        // div1=0,1,2,3;div1_real=1,2,4,4 ----0: 546Mbps  1:273Mbps
 166         params->dsi.pll_div2=0;        // div2=0,1,2,3;div1_real=1,2,4,4
 167 #if (LCM_DSI_CMD_MODE)
 168         params->dsi.fbk_div =7;
 169 #else
 170         params->dsi.fbk_div =7;    // fref=26MHz, fvco=fref*(fbk_div+1)*2/(div1_real*div2_real)
 171 #endif
 172         //params->dsi.compatibility_for_nvk = 1;        // this parameter would be set to 1 if DriverIC is NTK's and when force match DSI clock for NTK's
 173
 174 }
 175
 176
 177 static void lcm_init(void)
 178 {
 179     SET_RESET_PIN(1);
 180     SET_RESET_PIN(0);
 181     MDELAY(10);
 182     SET_RESET_PIN(1);
 183     MDELAY(120);
 184
 185         dsi_set_cmdq_V3(lcm_initialization_setting,sizeof(lcm_initialization_setting)/sizeof(lcm_initialization_setting[0]),1);
 186
 187 }
 188
 189
 190 static LCM_setting_table_V3  lcm_deep_sleep_mode_in_setting[] = {
 191     // Display off sequence
 192     {0x05, 0x28, 0, {}},
 193     {REGFLAG_ESCAPE_ID,REGFLAG_DELAY_MS_V3, 10, {}},
 194
 195     // Sleep Mode On
 196     {0x05, 0x10, 0, {}},
 197     {REGFLAG_ESCAPE_ID,REGFLAG_DELAY_MS_V3, 120, {}},
 198 };
 199 static void lcm_suspend(void)
 200 {
 201
 202     dsi_set_cmdq_V3(lcm_deep_sleep_mode_in_setting, sizeof(lcm_deep_sleep_mode_in_setting)/sizeof(lcm_deep_sleep_mode_in_setting[0]), 1);
 203     SET_RESET_PIN(1);
 204     SET_RESET_PIN(0);
 205     MDELAY(20); // 1ms
 206
 207     SET_RESET_PIN(1);
 208     MDELAY(120);
 209 }
 210
 211
 212 static void lcm_resume(void)
 213 {
 214     lcm_init();
 215
 216 }
 217
 218 #if (LCM_DSI_CMD_MODE)
 219 static void lcm_update(unsigned int x, unsigned int y,
 220                        unsigned int width, unsigned int height)
 221 {
 222     unsigned int x0 = x;
 223     unsigned int y0 = y;
 224     unsigned int x1 = x0 + width - 1;
 225     unsigned int y1 = y0 + height - 1;
 226
 227     unsigned char x0_MSB = ((x0>>8)&0xFF);
 228     unsigned char x0_LSB = (x0&0xFF);
 229     unsigned char x1_MSB = ((x1>>8)&0xFF);
 230     unsigned char x1_LSB = (x1&0xFF);
 231     unsigned char y0_MSB = ((y0>>8)&0xFF);
 232     unsigned char y0_LSB = (y0&0xFF);
 233     unsigned char y1_MSB = ((y1>>8)&0xFF);
 234     unsigned char y1_LSB = (y1&0xFF);
 235
 236     unsigned int data_array[16];
 237
 238     data_array[0]= 0x00053902;
 239     data_array[1]= (x1_MSB<<24)|(x0_LSB<<16)|(x0_MSB<<8)|0x2a;
 240     data_array[2]= (x1_LSB);
 241     dsi_set_cmdq(data_array, 3, 1);
 242
 243     data_array[0]= 0x00053902;
 244     data_array[1]= (y1_MSB<<24)|(y0_LSB<<16)|(y0_MSB<<8)|0x2b;
 245     data_array[2]= (y1_LSB);
 246     dsi_set_cmdq(data_array, 3, 1);
 247
 248     data_array[0]= 0x002c3909;
 249     dsi_set_cmdq(data_array, 1, 0);
 250
 251 }
 252 #endif
 253
 254
 255
 256
 257 // zhoulidong  add for lcm detect (start)
 258
 259 static unsigned int lcm_compare_id(void)
 260 {
 261     int array[4];
 262     char buffer[4]={0,0,0,0};
 263     char id_high=0;
 264     char id_low=0;
 265     int id=0;
 266
 267     SET_RESET_PIN(1);
 268     SET_RESET_PIN(0);
 269     MDELAY(10);
 270     SET_RESET_PIN(1);
 271     MDELAY(200);
 272
 273
 274     array[0]=0x00043902;
 275     array[1]=0x0698ffff;
 276     dsi_set_cmdq(array, 2, 1);
 277
 278     MDELAY(10);
 279     array[0] = 0x00083700;
 280     dsi_set_cmdq(array, 1, 1);
 281
 282     MDELAY(10);
 283     read_reg_v2(0xD3, buffer, 4);//    NC 0x00  0x98 0x16
 284
 285     id_high = buffer[1];
 286     id_low = buffer[2];
 287     id = (id_high<<8) | id_low;
 288
 289     #ifdef BUILD_LK
 290
 291         printf("ILI9806 uboot %s \n", __func__);
 292         printf("%s id = 0x%08x \n", __func__, id);
 293
 294     #else
 295         printk("ILI9806 kernel %s \n", __func__);
 296         printk("%s id = 0x%08x \n", __func__, id);
 297
 298     #endif
 299
 300
 301     return (LCM_ID_ILI9806 == id)?1:0;
 302
 303 }
 304
 305 // zhoulidong  add for lcm detect (start)
 306 static unsigned int rgk_lcm_compare_id(void)
 307 {
 308     int data[4] = {0,0,0,0};
 309     int res = 0;
 310     int rawdata = 0;
 311     int lcm_vol = 0;
 312
 313 #ifdef AUXADC_LCM_VOLTAGE_CHANNEL
 314     res = IMM_GetOneChannelValue(AUXADC_LCM_VOLTAGE_CHANNEL,data,&rawdata);
 315     if(res < 0)
 316     {
 317     #ifdef BUILD_LK
 318     printf("[adc_uboot]: get data error\n");
 319     #endif
 320     return 0;
 321
 322     }
 323 #endif
 324     lcm_vol = data[0]*1000+data[1]*10;
 325
 326
 327     #ifdef BUILD_LK
 328     printf("[adc_uboot]: lcm_vol= %d\n",lcm_vol);
 329     #endif
 330 #if 0
 331     if (lcm_vol>=MIN_VOLTAGE &&lcm_vol <= MAX_VOLTAGE &&lcm_compare_id())
 332 #else
 333     if (lcm_vol>=MIN_VOLTAGE &&lcm_vol <= MAX_VOLTAGE)  // remove compare_id func for mt6582 temply by xiaoanxiang 2013-09-05
 334 #endif
 335     {
 336     return 1;
 337     }
 338
 339     return 0;
 340
 341 }
 342 // zhoulidong add for eds(start)
 343 static unsigned int lcm_esd_check(void)
 344 {
 345     #ifdef BUILD_LK
 346         //printf("lcm_esd_check()\n");
 347     #else
 348         //printk("lcm_esd_check()\n");
 349     #endif
 350  #ifndef BUILD_LK
 351     char  buffer[3];
 352     int   array[4];
 353
 354     if(lcm_esd_test)
 355     {
 356         lcm_esd_test = FALSE;
 357         return TRUE;
 358     }
 359
 360     array[0] = 0x00013700;
 361     dsi_set_cmdq(array, 1, 1);
 362
 363     read_reg_v2(0x0a, buffer, 1);
 364     if(buffer[0]==0x9c)
 365     {
 366         //#ifdef BUILD_LK
 367         //printf("%s %d\n FALSE", __func__, __LINE__);
 368         //#else
 369         //printk("%s %d\n FALSE", __func__, __LINE__);
 370         //#endif
 371         return FALSE;
 372     }
 373     else
 374     {
 375         //#ifdef BUILD_LK
 376         //printf("%s %d\n FALSE", __func__, __LINE__);
 377         //#else
 378         //printk("%s %d\n FALSE", __func__, __LINE__);
 379         //#endif
 380         return TRUE;
 381     }
 382  #endif
 383
 384 }
 385
 386 static unsigned int lcm_esd_recover(void)
 387 {
 388
 389     #ifdef BUILD_LK
 390         printf("lcm_esd_recover()\n");
 391     #else
 392         printk("lcm_esd_recover()\n");
 393     #endif
 394
 395     lcm_init();
 396
 397     return TRUE;
 398 }
 399 // zhoulidong add for eds(end)
 400 LCM_DRIVER ili9806c_dsi_vdo_djn_lcm_drv =
 401 {
 402     .name            = "ili9806c_dsi_vdo_djn",
 403     .set_util_funcs = lcm_set_util_funcs,
 404     .get_params     = lcm_get_params,
 405     .init           = lcm_init,
 406     .suspend        = lcm_suspend,
 407     .resume         = lcm_resume,
 408     .compare_id    =  rgk_lcm_compare_id,
 409 //    .esd_check = lcm_esd_check,
 410 //    .esd_recover = lcm_esd_recover,
 411 #if (LCM_DSI_CMD_MODE)
 412     .update         = lcm_update,
 413 #endif
 414 };
 415