API tools faq
paste
sconosciuto

panel-NT35510.c froyo

sconosciuto
Jun 11th, 2012
30
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 34.69 KB | None | 0 0
raw download clone embed print report
  1. /*
  2.  * nt35510 LDI support
  3.  *
  4.  * Copyright (C) 2009 Samsung Corporation
  5.  * Author: Samsung Electronics..
  6.  *
  7.  * This program is free software; you can redistribute it and/or modify it
  8.  * under the terms of the GNU General Public License version 2 as published by
  9.  * the Free Software Foundation.
  10.  *
  11.  * This program is distributed in the hope that it will be useful, but WITHOUT
  12.  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13.  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14.  * more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License along with
  17.  * this program.  If not, see <http://www.gnu.org/licenses/>.
  18.  */
  19.  
  20. #include <linux/module.h>
  21. #include <linux/delay.h>
  22. #include <linux/platform_device.h>
  23. #include <linux/i2c/twl.h>
  24. #include <linux/spi/spi.h>
  25. #include <linux/regulator/consumer.h>
  26. #include <linux/err.h>
  27. /*
  28. #include <mach/gpio.h>
  29. #include <mach/hardware.h>
  30. #include <mach/mux.h>
  31. #include <asm/mach-types.h>
  32. #include <mach/control.h>
  33.  
  34. #include <mach/display.h>
  35. */
  36. #include <plat/gpio.h>
  37. #include <plat/hardware.h>
  38. #include <plat/mux.h>
  39. #include <asm/mach-types.h>
  40. #include <plat/control.h>
  41.  
  42. #include <plat/display.h>
  43.  
  44. //#include <linux/leds.h>
  45. #include <linux/backlight.h>
  46.  
  47.  
  48. #define LCD_XRES        480
  49. #define LCD_YRES        800
  50.  
  51. static int current_panel = -1;  // 0:sony, 1:Hitachi , 2:Hydis
  52.  
  53. // default setting : sony panel.
  54. static u16 LCD_HBP =    10;//20;
  55. static u16 LCD_HFP =    10;
  56. static u16 LCD_HSW =    10;
  57. static u16 LCD_VBP =    9;// 10;//8;
  58. static u16 LCD_VFP =    4;// 14;//6;
  59. static u16 LCD_VSW =    2;
  60.  
  61. #define LCD_PIXCLOCK_MAX            24000 // 26000
  62.  
  63.  
  64. #define GPIO_LEVEL_LOW   0
  65. #define GPIO_LEVEL_HIGH  1
  66.  
  67. #define POWER_OFF   0   // set in lcd_poweroff function.
  68. #define POWER_ON    1   // set in lcd_poweron function
  69.  
  70. static struct spi_device *nt35510lcd_spi;
  71.    
  72.  
  73. static atomic_t lcd_power_state = ATOMIC_INIT(POWER_ON);    // default is power on because bootloader already turn on LCD.
  74. static atomic_t ldi_power_state = ATOMIC_INIT(POWER_ON);    // ldi power state
  75.  
  76. int g_lcdlevel = 0x6C;
  77.  
  78. // ------------------------------------------ //
  79. //          For Regulator Framework                            //
  80. // ------------------------------------------ //
  81.  
  82. struct regulator *vaux3;
  83. struct regulator *vaux4;
  84.  
  85. #define MAX_NOTIFICATION_HANDLER    10
  86.  
  87. void nt35510_lcd_poweron(void);
  88. void nt35510_lcd_poweroff(void);
  89. void nt35510_lcd_LDO_on(void);
  90. void nt35510_lcd_LDO_off(void);
  91. void nt35510_ldi_poweron_sony(void);
  92. void nt35510_ldi_poweroff_sony(void);
  93. void nt35510_ldi_poweron_hitachi(void);
  94. void nt35510_ldi_poweroff_hitachi(void);
  95.  
  96.  
  97. // paramter : POWER_ON or POWER_OFF
  98. typedef void (*notification_handler)(const int);
  99. typedef struct
  100. {
  101.     int  state;
  102.     spinlock_t vib_lock;
  103. }timer_state_t;
  104. timer_state_t timer_state;
  105.  
  106.  
  107. notification_handler power_state_change_handler[MAX_NOTIFICATION_HANDLER];
  108.  
  109. int nt35510_add_power_state_monitor(notification_handler handler);
  110. void nt35510_remove_power_state_monitor(notification_handler handler);
  111.  
  112. EXPORT_SYMBOL(nt35510_add_power_state_monitor);
  113. EXPORT_SYMBOL(nt35510_remove_power_state_monitor);
  114.  
  115. static void nt35510_notify_power_state_changed(void);
  116. static void aat1402_set_brightness(void);
  117. //extern int omap34xx_pad_set_configs(struct pin_config *pin_configs, int n);
  118. extern int omap34xx_pad_set_config_lcd(u16,u16);
  119.  
  120. #define PM_RECEIVER                     TWL4030_MODULE_PM_RECEIVER
  121.  
  122. #define ENABLE_VPLL2_DEDICATED          0x05
  123. #define ENABLE_VPLL2_DEV_GRP            0x20
  124. #define TWL4030_VPLL2_DEV_GRP           0x33
  125. #define TWL4030_VPLL2_DEDICATED         0x36
  126.  
  127.  
  128. static struct pin_config  omap34xx_lcd_pins[] = {
  129. /*
  130.  *      Name, reg-offset,
  131.  *      mux-mode | [active-mode | off-mode]
  132.  */
  133.  
  134.     // MCSPI1 AND MCSPI2 PIN CONFIGURATION
  135.     // FOR ALL SPI, SPI_CS0 IS I/O AND OTHER SPI CS ARE PURE OUT.
  136.     // CLK AND SIMO/SOMI LINES ARE I/O.
  137.  
  138.     // 206 (AB3, L, MCSPI1_CLK, DISPLAY_CLK, O)
  139.     MUX_CFG_34XX("AB3_MCSPI1_CLK", 0x01C8,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
  140.     // 207 (AB4, L, MCSPI1_SIMO, DISLPAY_SI, I)
  141.     MUX_CFG_34XX("AB4_MCSPI1_SIMO", 0x01CA,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLDOWN)
  142.     // 208 (AA4, L, MCSPI1_SOMI, DISLPAY_SO, O)
  143.     MUX_CFG_34XX("AA4_MCSPI1_SOMI", 0x01CC,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLDOWN)
  144.     // 209 (AC2, H, MCSPI1_CS0, DISPLAY_CS, O)
  145.     MUX_CFG_34XX("AC2_MCSPI1_CS0", 0x01CE,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP)
  146.    
  147. };
  148.  
  149. static struct pin_config  omap34xx_lcd_off_pins[] = {
  150. /*
  151.  *      Name, reg-offset,
  152.  *      mux-mode | [active-mode | off-mode]
  153.  */
  154.  
  155.     // MCSPI1 AND MCSPI2 PIN CONFIGURATION
  156.     // FOR ALL SPI, SPI_CS0 IS I/O AND OTHER SPI CS ARE PURE OUT.
  157.     // CLK AND SIMO/SOMI LINES ARE I/O.
  158.  
  159.     // 206 (AB3, L, MCSPI1_CLK, DISPLAY_CLK, O)
  160.     MUX_CFG_34XX("AB3_MCSPI1_CLK", 0x01C8,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN)
  161.     // 207 (AB4, L, MCSPI1_SIMO, DISLPAY_SI, I)
  162.     MUX_CFG_34XX("AB4_MCSPI1_SIMO", 0x01CA,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN)
  163.     // 208 (AA4, L, MCSPI1_SOMI, DISLPAY_SO, O)
  164.     MUX_CFG_34XX("AA4_MCSPI1_SOMI", 0x01CC,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN)
  165.     // 209 (AC2, H, MCSPI1_CS0, DISPLAY_CS, O)
  166.     MUX_CFG_34XX("AC2_MCSPI1_CS0", 0x01CE,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN)
  167.    
  168. };
  169.  
  170. /*  Manual
  171.  * defines HFB, HSW, HBP, VFP, VSW, VBP as shown below
  172.  */
  173.  
  174. static struct omap_video_timings panel_timings = {0,};
  175. #if 0
  176. = {
  177.     /* 800 x 480 @ 60 Hz  Reduced blanking VESA CVT 0.31M3-R */
  178.     .x_res          = LCD_XRES,
  179.     .y_res          = LCD_YRES,
  180.     .pixel_clock    = LCD_PIXCLOCK_MAX,
  181.     .hfp            = LCD_HFP,
  182.     .hsw            = LCD_HSW,
  183.     .hbp            = LCD_HBP,
  184.     .vfp            = LCD_VFP,
  185.     .vsw            = LCD_VSW,
  186.     .vbp            = LCD_VBP,
  187. };
  188. #endif
  189. int nt35510_add_power_state_monitor(notification_handler handler)
  190. {
  191.     int index = 0;
  192.     if(handler == NULL)
  193.     {
  194.         printk(KERN_ERR "[LCD][%s] param is null\n", __func__);
  195.         return -EINVAL;
  196.     }
  197.  
  198.     for(; index < MAX_NOTIFICATION_HANDLER; index++)
  199.     {
  200.         if(power_state_change_handler[index] == NULL)
  201.         {
  202.             power_state_change_handler[index] = handler;
  203.             return 0;
  204.         }
  205.     }
  206.  
  207.     // there is no space this time
  208.     printk(KERN_INFO "[LCD][%s] No spcae\n", __func__);
  209.  
  210.     return -ENOMEM;
  211. }
  212.  
  213. void nt35510_remove_power_state_monitor(notification_handler handler)
  214. {
  215.     int index = 0;
  216.     if(handler == NULL)
  217.     {
  218.         printk(KERN_ERR "[LCD][%s] param is null\n", __func__);
  219.         return;
  220.     }
  221.    
  222.     for(; index < MAX_NOTIFICATION_HANDLER; index++)
  223.     {
  224.         if(power_state_change_handler[index] == handler)
  225.         {
  226.             power_state_change_handler[index] = NULL;
  227.         }
  228.     }
  229. }
  230.    
  231. static void nt35510_notify_power_state_changed(void)
  232. {
  233.     int index = 0;
  234.     for(; index < MAX_NOTIFICATION_HANDLER; index++)
  235.     {
  236.         if(power_state_change_handler[index] != NULL)
  237.         {
  238.             power_state_change_handler[index](atomic_read(&lcd_power_state));
  239.         }
  240.     }
  241.  
  242. }
  243.  
  244. static __init int setup_current_panel(char *opt)
  245. {
  246.     current_panel = (u32)memparse(opt, &opt);
  247.     return 0;
  248. }
  249. __setup("androidboot.current_panel=", setup_current_panel);
  250.  
  251. static int nt35510_panel_probe(struct omap_dss_device *dssdev)
  252. {
  253.     int lcd_id1, lcd_id2;
  254.     printk(KERN_INFO " **** nt35510_panel_probe.\n");
  255.    
  256.     vaux4 = regulator_get( &dssdev->dev, "vaux4" );
  257.     if( IS_ERR( vaux4 ) )
  258.         printk( "Fail to register vaux4 using regulator framework!\n" );   
  259.  
  260.     vaux3 = regulator_get( &dssdev->dev, "vaux3" );
  261.     if( IS_ERR( vaux3 ) )
  262.         printk( "Fail to register vaux3 using regulator framework!\n" );   
  263.  
  264.     nt35510_lcd_LDO_on();
  265.  
  266.     //MLCD pin set to OUTPUT.
  267.     if (gpio_request(OMAP_GPIO_MLCD_RST, "MLCD_RST") < 0) {
  268.         printk(KERN_ERR "\n FAILED TO REQUEST GPIO %d \n", OMAP_GPIO_MLCD_RST);
  269.         return;
  270.     }
  271.     gpio_direction_output(OMAP_GPIO_MLCD_RST, 1);
  272. /*
  273.     lcd_id1=gpio_get_value(OMAP_GPIO_LCD_ID1);
  274.     lcd_id2=gpio_get_value(OMAP_GPIO_LCD_ID2);
  275.  
  276.     if(lcd_id1==0 && lcd_id2==1)
  277.         current_panel=0;    // Sony
  278.     else if(lcd_id1==1 && lcd_id2==0)
  279.         current_panel=1;    // Hitachi
  280.     else
  281.         current_panel=2;    // Hydis
  282. */
  283.     printk("[LCD] %s() : current_panel=%d(0:sony, 1:Hitachi , 2:Hydis, 3:SMD)\n", __func__, current_panel);
  284.  
  285.     if(current_panel == 1) // if hitachi
  286.     {
  287.         LCD_HBP=    2;
  288.         LCD_HFP=    100;
  289.         LCD_HSW=    2; 
  290.         LCD_VBP=    10;    
  291.         LCD_VFP=    8;
  292.         LCD_VSW=    2;  
  293.     }
  294.     else if(current_panel == 3) // if SMD
  295.     {
  296.         LCD_HBP=    40;
  297.         LCD_HFP =   10;
  298.         LCD_HSW =   4;
  299.         LCD_VBP =   7;
  300.         LCD_VFP =   6;
  301.         LCD_VSW =   1;
  302.     }
  303.  
  304.     /* 800 x 480 @ 60 Hz  Reduced blanking VESA CVT 0.31M3-R */
  305.     panel_timings.x_res          = LCD_XRES,
  306.     panel_timings.y_res          = LCD_YRES,
  307.     panel_timings.pixel_clock    = LCD_PIXCLOCK_MAX,
  308.     panel_timings.hfp            = LCD_HFP,
  309.     panel_timings.hsw            = LCD_HSW,
  310.     panel_timings.hbp            = LCD_HBP,
  311.     panel_timings.vfp            = LCD_VFP,
  312.     panel_timings.vsw            = LCD_VSW,
  313.     panel_timings.vbp            = LCD_VBP;
  314.  
  315.     if(current_panel==0 || current_panel==2 || current_panel==3) // Sony || Hydis || SMD
  316.     {
  317.     dssdev->panel.config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS |  OMAP_DSS_LCD_IPC |
  318.                         OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_ONOFF | OMAP_DSS_LCD_IEO;
  319.     }
  320.  
  321.     else if(current_panel==1) // Hitachi
  322.     {
  323.     dssdev->panel.config = OMAP_DSS_LCD_TFT | OMAP_DSS_LCD_IVS | OMAP_DSS_LCD_IPC |
  324.                         OMAP_DSS_LCD_IHS | OMAP_DSS_LCD_ONOFF ;
  325.     }
  326.  
  327.     dssdev->panel.recommended_bpp= 32;
  328.     dssdev->panel.acb = 0;
  329.     dssdev->panel.timings = panel_timings;
  330.    
  331.     return 0;
  332. }
  333.  
  334. static void nt35510_panel_remove(struct omap_dss_device *dssdev)
  335. {
  336.     regulator_put( vaux4 );
  337.     regulator_put( vaux3 );
  338. }
  339.  
  340. static int nt35510_panel_enable(struct omap_dss_device *dssdev)
  341. {
  342.     int r = 0;
  343.     mdelay(4);
  344.     if (dssdev->platform_enable)
  345.         r = dssdev->platform_enable(dssdev);
  346.  
  347.     return r;
  348. }
  349.  
  350. static void nt35510_panel_disable(struct omap_dss_device *dssdev)
  351. {
  352.     if (dssdev->platform_disable)
  353.         dssdev->platform_disable(dssdev);
  354.     mdelay(4);
  355. }
  356.  
  357. static int nt35510_panel_suspend(struct omap_dss_device *dssdev)
  358. {
  359.     printk(KERN_INFO " **** nt35510_panel_suspend\n");
  360.     spi_setup(nt35510lcd_spi);
  361.  
  362.     gpio_set_value(OMAP_GPIO_LCD_EN_SET, GPIO_LEVEL_LOW);
  363.     mdelay(1);
  364.  
  365.     #if 1
  366.     nt35510_lcd_poweroff();
  367.     #else
  368.     nt35510_ldi_standby();
  369.     nt35510_panel_disable(dssdev);
  370.     #endif
  371.    
  372.     return 0;
  373. }
  374.  
  375. static int nt35510_panel_resume(struct omap_dss_device *dssdev)
  376. {
  377.     printk(KERN_INFO " **** nt35510_panel_resume\n");
  378.  
  379.     spi_setup(nt35510lcd_spi);
  380.    
  381. //      msleep(150);
  382.  
  383.     #if 1
  384.     nt35510_lcd_poweron();
  385.     #else
  386.     nt35510_ldi_wakeup();
  387.     nt35510_panel_enable(dssdev);
  388.     #endif
  389.  
  390.     gpio_set_value(OMAP_GPIO_LCD_EN_SET, GPIO_LEVEL_LOW);
  391.     mdelay(1);
  392.     gpio_set_value(OMAP_GPIO_LCD_EN_SET, GPIO_LEVEL_HIGH);
  393.  
  394.     return 0;
  395. }
  396.  
  397. static struct omap_dss_driver nt35510_driver = {
  398.     .probe          = nt35510_panel_probe,
  399.     .remove         = nt35510_panel_remove,
  400.  
  401.     .enable         = nt35510_panel_enable,
  402.     .disable        = nt35510_panel_disable,
  403.     .suspend        = nt35510_panel_suspend,
  404.     .resume         = nt35510_panel_resume,
  405.  
  406.     .driver     = {
  407.         .name   = "nt35510_panel",
  408.         .owner  = THIS_MODULE,
  409.     },
  410. };
  411.  
  412. static void spi1writeindex(u8 index)
  413. {
  414.     volatile unsigned short cmd = 0;
  415.     cmd= 0x0000|index;
  416.  
  417.     spi_write(nt35510lcd_spi,(unsigned char*)&cmd,2);
  418.  
  419.     udelay(100);
  420.     udelay(100);
  421. }
  422.  
  423. static void spi1writedata(u8 data)
  424. {
  425.     volatile unsigned short datas = 0;
  426.     datas= 0x0100|data;
  427.     spi_write(nt35510lcd_spi,(unsigned char*)&datas,2);
  428.  
  429.     udelay(100);
  430.     udelay(100);
  431. }
  432.  
  433.  
  434. static void spi1write(u8 index, u8 data)
  435. {
  436.     volatile unsigned short cmd = 0;
  437.     volatile unsigned short datas=0;
  438.  
  439.     cmd = 0x0000 | index;
  440.     datas = 0x0100 | data;
  441.    
  442.     spi_write(nt35510lcd_spi,(unsigned char*)&cmd,2);
  443.     udelay(100);
  444.     spi_write(nt35510lcd_spi,(unsigned char *)&datas,2);
  445.     udelay(100);
  446.     udelay(100);
  447. }
  448.  
  449. void nt35510_ldi_poweron_hitachi(void)
  450. {
  451.     printk("[LCD] %s() + \n", __func__);
  452.  
  453.     spi1writeindex(0x36);
  454.     spi1writedata(0x00);
  455.    
  456.     spi1writeindex(0x3A);
  457.     spi1writedata(0x77);
  458.  
  459.     spi1writeindex(0x11);
  460.  
  461.     msleep(150);
  462.  
  463.    
  464.     spi1writeindex(0xB0);
  465.     spi1writedata(0x04);
  466.  
  467.     spi1writeindex(0xC1);
  468.     spi1writedata(0x42);
  469.     spi1writedata(0x31);
  470.     spi1writedata(0x04);
  471.    
  472.     spi1writeindex(0xB0);
  473.     spi1writedata(0x03);
  474.  
  475.     aat1402_set_brightness();
  476.  
  477.     spi1writeindex(0x29);  
  478.    
  479.     atomic_set(&ldi_power_state, POWER_ON);
  480.     printk("[LCD] %s() -\n", __func__);
  481. }
  482.  
  483.  
  484. void nt35510_ldi_poweroff_hitachi(void)
  485. {
  486.     printk(" **** %s\n", __func__);
  487.  
  488.     // Display Off
  489. //  spi1writeindex(0x28);   // SEQ_DISPOFF_SET
  490.     spi1writeindex(0xB0);
  491.     spi1writedata(0x04);
  492.     spi1writeindex(0xB1);
  493.     spi1writedata(0x01);
  494.     msleep(2);
  495.    
  496.     // SLEEP IN
  497.     spi1writeindex(0x10);   // SEQ_SLEEP IN_SET
  498.  
  499.     //Wait 120ms
  500.     msleep(150);   
  501.    
  502.     atomic_set(&ldi_power_state, POWER_OFF);
  503. }
  504.  
  505. void nt35510_ldi_poweron_sony(void)
  506. {
  507.     printk("[LCD] %s() + \n", __func__);
  508. #if 0  
  509.     printk("[LCD] %s() current_panel=%d \n", __func__, current_panel);
  510.  
  511.     if(0) // Hydis
  512.     {
  513.         /* Test Commands */
  514.         spi1writeindex(0xFF);  
  515.         spi1writedata(0xAA);
  516.         spi1writedata(0x55);
  517.         spi1writedata(0x25);
  518.         spi1writedata(0x01);
  519.        
  520.         spi1writeindex(0xFA);  
  521.         spi1writedata(0x00);
  522.         spi1writedata(0x80);
  523.         spi1writedata(0x00);
  524.         spi1writedata(0x00);       
  525.         spi1writedata(0x00);
  526.         spi1writedata(0x00);
  527.         spi1writedata(0x30);
  528.         spi1writedata(0x02);                   
  529.         spi1writedata(0x20);
  530.         spi1writedata(0x84);
  531.         spi1writedata(0x0F);
  532.         spi1writedata(0x0F);               
  533.         spi1writedata(0x20);
  534.         spi1writedata(0x40);
  535.         spi1writedata(0x40);       
  536.         spi1writedata(0x00);
  537.         spi1writedata(0x00);       
  538.         spi1writedata(0x00);
  539.         spi1writedata(0x00);                   
  540.         spi1writedata(0x00);
  541.         spi1writedata(0x00);
  542.         spi1writedata(0x00);       
  543.         spi1writedata(0x00);
  544.         spi1writedata(0x00);
  545.         spi1writedata(0x00);
  546.         spi1writedata(0x00);
  547.         spi1writedata(0x00);       
  548.         spi1writedata(0x00);
  549.         spi1writedata(0x3F);                   
  550.         spi1writedata(0xA0);
  551.         spi1writedata(0x30);
  552.        
  553.         spi1writeindex(0xF3);
  554.         spi1writedata(0x00);
  555.         spi1writedata(0x32);
  556.         spi1writedata(0x00);
  557.         spi1writedata(0x38);       
  558.         spi1writedata(0x00);
  559.         spi1writedata(0x08);
  560.         spi1writedata(0x11);
  561.         spi1writedata(0x00);
  562.  
  563.         /* Enable CMD2_Page1 */
  564.         spi1writeindex(0xF0);
  565.         spi1writedata(0x55);
  566.         spi1writedata(0xAA);
  567.         spi1writedata(0x52);
  568.         spi1writedata(0x08);       
  569.         spi1writedata(0x01);   
  570.  
  571.         /* AVDD */
  572.         spi1writeindex(0xB6);
  573.         spi1writedata(0x04);
  574.         spi1writedata(0x04);
  575.         spi1writedata(0x04);
  576.  
  577.         spi1writeindex(0xB0);      
  578.         spi1writedata(0x05);             
  579.         spi1writedata(0x0A); //VBP 10
  580.         spi1writedata(0x08); //VFP  8
  581.         spi1writedata(0x1D); //HBP 29
  582.         spi1writedata(0x02); //HFP  2
  583.        
  584.         /* ### VGH */
  585.         spi1writeindex(0xBF);
  586.         spi1writedata(0x01);
  587.                
  588.         spi1writeindex(0xB9);          
  589.         spi1writedata(0x34);
  590.         spi1writedata(0x34);       
  591.         spi1writedata(0x34);
  592.                
  593.         spi1writeindex(0xB3);              
  594.         spi1writedata(0x0A);
  595.         spi1writedata(0x0A);       
  596.         spi1writedata(0x0A);
  597.        
  598.         /* ### VGL */
  599.         spi1writeindex(0xBA);
  600.         spi1writedata(0x24);
  601.         spi1writedata(0x24);
  602.         spi1writedata(0x24);
  603.        
  604.         spi1writeindex(0xB5);              
  605.         spi1writedata(0x08);
  606.         spi1writedata(0x08);       
  607.         spi1writedata(0x08);
  608.  
  609.         /* ### VCOM */
  610.         spi1writeindex(0xBE);
  611.         spi1writedata(0x00);               
  612.         spi1writedata(0x50);       
  613.        
  614.         /* ### Enable CMD2_Page0 */
  615.         spi1writeindex(0xF0);      
  616.         spi1writedata(0x55);
  617.         spi1writedata(0xAA);
  618.         spi1writedata(0x52);
  619.         spi1writedata(0x08);
  620.         spi1writedata(0x00);
  621.        
  622.         /*  Hydis Initial */
  623.         spi1writeindex(0xB1);
  624.         spi1writedata(0xCC);               
  625.         spi1writedata(0x00);
  626.                
  627.         spi1writeindex(0xBC);
  628.         spi1writedata(0x00);
  629.         spi1writedata(0x00);                       
  630.         spi1writedata(0x00);
  631.                
  632.         spi1writeindex(0xB8);
  633.         spi1writedata(0x01);       
  634.         spi1writedata(0x07);       
  635.         spi1writedata(0x07);
  636.         spi1writedata(0x07);
  637.        
  638.         spi1writeindex(0xCC);
  639.         spi1writedata(0x01);           
  640.         spi1writedata(0x3F);       
  641.         spi1writedata(0x3F);
  642.        
  643.         spi1writeindex(0xB3);
  644.         spi1writedata(0x00);
  645.         spi1writeindex(0x36);   // reverse display
  646.         spi1writedata(0x03);
  647.  
  648.         spi1writeindex(0x51);   // PWM
  649.         spi1writedata(0x7F);    // Default brightness.
  650.         spi1writeindex(0x53);
  651.         spi1writedata(0x24);
  652.  
  653.         spi1writeindex(0x11);   // SLPOUT
  654.         mdelay(120);
  655.         spi1writeindex(0x29);   // DISPON
  656.  
  657.     }
  658.     else // Sony
  659. #else      
  660.     {
  661.         msleep(145);
  662.         spi1writeindex(0x3A);
  663.         spi1writedata(0x77);
  664.        
  665.         spi1writeindex(0x3B);
  666.         spi1writedata(0x07);   
  667.         spi1writedata(0x0A);
  668.         spi1writedata(0x0E);
  669.         spi1writedata(0x0A);
  670.         spi1writedata(0x0A);
  671.  
  672.         spi1writeindex(0x2A);
  673.         spi1writedata(0x00);
  674.         spi1writedata(0x00);
  675.         spi1writedata(0x01);
  676.         spi1writedata(0xDF);
  677.  
  678.         spi1writeindex(0x2B);
  679.         spi1writedata(0x00);
  680.         spi1writedata(0x00);
  681.         spi1writedata(0x03);
  682.         spi1writedata(0x1F);
  683.  
  684.         spi1writeindex(0x36);
  685.         spi1writedata(0xD4);
  686.  
  687.         msleep(25);
  688.        
  689.         spi1writeindex(0x11);
  690.  
  691.         msleep(200);
  692.  
  693.         spi1writeindex(0x51);
  694.         spi1writedata(0x0); // default brightness : 0
  695. //      spi1writedata(0x6C); // default brightness : 108
  696.         aat1402_set_brightness();
  697.  
  698.         spi1writeindex(0x55);
  699.         spi1writedata(0x01); // CABC Off, 01:User interface mode, 02:still image mode, 03:moving image mode
  700.  
  701.         spi1writeindex(0x5E);
  702.         spi1writedata(0x00); // example value. *3)
  703.  
  704.         spi1writeindex(0x53);
  705.         spi1writedata(0x2C);
  706.  
  707. //      msleep(200);
  708.  
  709.         spi1writeindex(0x29);  
  710.  
  711.     }  
  712. #endif
  713.     atomic_set(&ldi_power_state, POWER_ON);
  714.     printk("[LCD] %s() -\n", __func__);
  715. }
  716.  
  717.  
  718. void nt35510_ldi_poweroff_sony(void)
  719. {
  720.     printk(" **** %s\n", __func__);
  721.        
  722.     // Display Off
  723.     spi1writeindex(0x28);   // SEQ_DISPOFF_SET
  724.  
  725. //  if(current_panel==0) // sony
  726.     {
  727.         msleep(25);
  728.     }
  729.  
  730.     // SLEEP IN
  731.     spi1writeindex(0x10);   // SEQ_SLEEP IN_SET
  732.  
  733.     //Wait 120ms
  734.     msleep(150);   
  735.    
  736.     atomic_set(&ldi_power_state, POWER_OFF);
  737. }
  738.  
  739. void lcd_hydis_gamma1(void)
  740. {
  741.     spi1writedata(0x00);
  742.     spi1writedata(0x37);
  743.     spi1writedata(0x00);
  744.     spi1writedata(0x61);
  745.     spi1writedata(0x00);
  746.     spi1writedata(0x92);
  747.     spi1writedata(0x00);
  748.     spi1writedata(0xB4);
  749.     spi1writedata(0x00);
  750.     spi1writedata(0xCF);
  751.     spi1writedata(0x00);
  752.     spi1writedata(0xF6);
  753.     spi1writedata(0x01);
  754.     spi1writedata(0x2F);
  755.     spi1writedata(0x01);
  756.     spi1writedata(0x7F);
  757.     spi1writedata(0x01);
  758.     spi1writedata(0x97);
  759.     spi1writedata(0x01);
  760.     spi1writedata(0xC0);
  761.     spi1writedata(0x01);
  762.     spi1writedata(0xE5);
  763.     spi1writedata(0x02);
  764.     spi1writedata(0x25);
  765.     spi1writedata(0x02);
  766.     spi1writedata(0x5E);
  767.     spi1writedata(0x02);
  768.     spi1writedata(0x60);
  769.     spi1writedata(0x02);
  770.     spi1writedata(0x87);
  771.     spi1writedata(0x02);
  772.     spi1writedata(0xBE);
  773.     spi1writedata(0x02);
  774.     spi1writedata(0xE2);
  775.     spi1writedata(0x03);
  776.     spi1writedata(0x0F);
  777.     spi1writedata(0x03);
  778.     spi1writedata(0x30);
  779.     spi1writedata(0x03);
  780.     spi1writedata(0x5C);
  781.     spi1writedata(0x03);
  782.     spi1writedata(0x77);
  783.     spi1writedata(0x03);
  784.     spi1writedata(0x94);
  785.     spi1writedata(0x03);
  786.     spi1writedata(0x9F);
  787.     spi1writedata(0x03);
  788.     spi1writedata(0xAC);
  789.     spi1writedata(0x03);
  790.     spi1writedata(0xBA);
  791.     spi1writedata(0x03);
  792.     spi1writedata(0xF1);
  793. }
  794. void lcd_hydis_gamma2(void)
  795. {
  796.     spi1writedata(0x00);
  797.     spi1writedata(0x37);
  798.     spi1writedata(0x00);
  799.     spi1writedata(0x50);
  800.     spi1writedata(0x00);
  801.     spi1writedata(0x89);
  802.     spi1writedata(0x00);
  803.     spi1writedata(0xA9);
  804.     spi1writedata(0x00);
  805.     spi1writedata(0xC0);
  806.     spi1writedata(0x00);
  807.     spi1writedata(0xF6);
  808.     spi1writedata(0x01);
  809.     spi1writedata(0x14);
  810.     spi1writedata(0x01);
  811.     spi1writedata(0x48);
  812.     spi1writedata(0x01);
  813.     spi1writedata(0x6B);
  814.     spi1writedata(0x01);
  815.     spi1writedata(0xA7);
  816.     spi1writedata(0x01);
  817.     spi1writedata(0xD3);
  818.     spi1writedata(0x02);
  819.     spi1writedata(0x17);
  820.     spi1writedata(0x02);
  821.     spi1writedata(0x4F);
  822.     spi1writedata(0x02);
  823.     spi1writedata(0x51);
  824.     spi1writedata(0x02);
  825.     spi1writedata(0x86);
  826.     spi1writedata(0x02);
  827.     spi1writedata(0xBD);
  828.     spi1writedata(0x02);
  829.     spi1writedata(0xE2);
  830.     spi1writedata(0x03);
  831.     spi1writedata(0x0F);
  832.     spi1writedata(0x03);
  833.     spi1writedata(0x30);
  834.     spi1writedata(0x03);
  835.     spi1writedata(0x5C);
  836.     spi1writedata(0x03);
  837.     spi1writedata(0x77);
  838.     spi1writedata(0x03);
  839.     spi1writedata(0x94);
  840.     spi1writedata(0x03);
  841.     spi1writedata(0x9F);
  842.     spi1writedata(0x03);
  843.     spi1writedata(0xAC);
  844.     spi1writedata(0x03);
  845.     spi1writedata(0xBA);
  846.     spi1writedata(0x03);
  847.     spi1writedata(0xF1);
  848.  
  849. }
  850.  
  851. void nt35510_ldi_poweron_hydis(void)
  852. {
  853.     printk("[LCD] %s() + \n", __func__);
  854.  
  855. // [[ User Set
  856.     /* Test Commands */
  857.     spi1writeindex(0xFF);  
  858.     spi1writedata(0xAA);
  859.     spi1writedata(0x55);
  860.     spi1writedata(0x25);
  861.     spi1writedata(0x01);   
  862.  
  863.     /* Test Commands */
  864.     spi1writeindex(0xF3);
  865.     spi1writedata(0x00);
  866.     spi1writedata(0x32);
  867.     spi1writedata(0x00);
  868.     spi1writedata(0x38);       
  869.     spi1writedata(0x31);
  870.     spi1writedata(0x08);
  871.     spi1writedata(0x11);
  872.     spi1writedata(0x00);
  873.  
  874.     /* Manufacture Command Set Selection */
  875.     spi1writeindex(0xF0);
  876.     spi1writedata(0x55);
  877.     spi1writedata(0xAA);
  878.     spi1writedata(0x52);
  879.     spi1writedata(0x08);       
  880.     spi1writedata(0x00);   
  881.  
  882.     /* SEC Setting */  
  883.     spi1writeindex(0xB0);      
  884.     spi1writedata(0x04); // 0x00  //DE Mode/Rising Edge for PCLK         
  885.     spi1writedata(0x0A); //VBP 10
  886.     spi1writedata(0x0E); //VFP 14
  887.     spi1writedata(0x09); //HBP 10
  888.     spi1writedata(0x04); //HFP 10
  889.  
  890.     /*  */ 
  891.     spi1writeindex(0xB1);      
  892.     spi1writedata(0xCC); // Backward for Gate
  893.     spi1writedata(0x04); // "04 : Backward / 00 : Forward
  894.  
  895.     /* data */
  896.     spi1writeindex(0x36);  
  897.     spi1writedata(0x02); // 00 : Forward / 02 : Backward
  898.  
  899.     /* Display Clock in RGB Interface */
  900.     spi1writeindex(0xB3);  
  901.     spi1writedata(0x00);
  902.  
  903.     /* Source Output Data Hold Time */
  904.     spi1writeindex(0xB6);  
  905.     spi1writedata(0x03);
  906.  
  907.     /* GATE EQ */
  908.     spi1writeindex(0xB7);  
  909.     spi1writedata(0x70);
  910.     spi1writedata(0x70);
  911.  
  912.     /* SOURCE EQ */
  913.     spi1writeindex(0xB8);
  914.     spi1writedata(0x00);       
  915.     spi1writedata(0x06);       
  916.     spi1writedata(0x06);
  917.     spi1writedata(0x06);
  918.  
  919.     /* Inversion Type */
  920.     spi1writeindex(0xBC);
  921.     spi1writedata(0x00);
  922.     spi1writedata(0x00);
  923.     spi1writedata(0x00);
  924.  
  925.     /* Display Timing Control */
  926.     spi1writeindex(0xBD);
  927.     spi1writedata(0x01);           
  928.     spi1writedata(0x84);       
  929.     spi1writedata(0x06);
  930.     spi1writedata(0x50);
  931.     spi1writedata(0x00);
  932.  
  933.     /* aRD(Gateless) Setting */
  934.     spi1writeindex(0xCC);
  935.     spi1writedata(0x01);           
  936.     spi1writedata(0x01);       
  937.     spi1writedata(0x06);
  938. // ]] User Set
  939.    
  940. // [[ Power Set
  941.     spi1writeindex(0xF0);
  942.     spi1writedata(0x55);
  943.     spi1writedata(0xAA);
  944.     spi1writedata(0x52);
  945.     spi1writedata(0x08);
  946.     spi1writedata(0x01);
  947.  
  948.     spi1writeindex(0xB0);
  949.     spi1writedata(0x05);
  950.     spi1writedata(0x05);
  951.     spi1writedata(0x05);
  952.  
  953.     spi1writeindex(0xB1);
  954.     spi1writedata(0x05);
  955.     spi1writedata(0x05);
  956.     spi1writedata(0x05);
  957.  
  958.     spi1writeindex(0xB2);
  959.     spi1writedata(0x03);
  960.     spi1writedata(0x03);
  961.     spi1writedata(0x03);
  962.  
  963.     spi1writeindex(0xB8);
  964.     spi1writedata(0x25);
  965.     spi1writedata(0x25);
  966.     spi1writedata(0x25);
  967.  
  968.     spi1writeindex(0xB3);
  969.     spi1writedata(0x0B);
  970.     spi1writedata(0x0B);
  971.     spi1writedata(0x0B);
  972.  
  973.     spi1writeindex(0xB9);
  974.     spi1writedata(0x34);
  975.     spi1writedata(0x34);
  976.     spi1writedata(0x34);
  977.  
  978.     spi1writeindex(0xBF);
  979.     spi1writedata(0x01);
  980.  
  981.     spi1writeindex(0xB5);
  982.     spi1writedata(0x09);
  983.     spi1writedata(0x09);
  984.     spi1writedata(0x09);
  985.  
  986.     spi1writeindex(0xBA);
  987.     spi1writedata(0x24);
  988.     spi1writedata(0x24);
  989.     spi1writedata(0x24);
  990.  
  991.     spi1writeindex(0xB4);
  992.     spi1writedata(0x24);
  993.     spi1writedata(0x24);
  994.     spi1writedata(0x24);
  995.  
  996.     spi1writeindex(0xBC);
  997.     spi1writedata(0x00);
  998.     spi1writedata(0x68);
  999.     spi1writedata(0x00);
  1000.  
  1001.     spi1writeindex(0xBD);
  1002.     spi1writedata(0x00);
  1003.     spi1writedata(0x7C);
  1004.     spi1writedata(0x00);
  1005.  
  1006.     spi1writeindex(0xBE);
  1007.     spi1writedata(0x00);
  1008.     spi1writedata(0x45);
  1009. // ]] P S
  1010.  
  1011. // [[ Gamma Control
  1012.     spi1writeindex(0xD0);
  1013.     spi1writedata(0x0A);
  1014.     spi1writedata(0x14);
  1015.     spi1writedata(0x0A);
  1016.     spi1writedata(0x0E);
  1017.  
  1018.     spi1writeindex(0xD1);
  1019.     lcd_hydis_gamma1();
  1020.     spi1writeindex(0xD2);
  1021.     lcd_hydis_gamma1();
  1022.     spi1writeindex(0xD3);
  1023.     lcd_hydis_gamma1();
  1024.     spi1writeindex(0xD4);
  1025.     lcd_hydis_gamma2();
  1026.     spi1writeindex(0xD5);
  1027.     lcd_hydis_gamma2();
  1028.     spi1writeindex(0xD6);
  1029.     lcd_hydis_gamma2();
  1030.  
  1031. // ]] Gamma Control
  1032.  
  1033. // [[
  1034. /* Manufacture Command Set Selection */
  1035.     spi1writeindex(0xF0);
  1036.     spi1writedata(0x55);
  1037.     spi1writedata(0xAA);
  1038.     spi1writedata(0x52);
  1039.     spi1writedata(0x08);       
  1040.     spi1writedata(0x00);   
  1041.  
  1042. // ]]
  1043.     spi1writeindex(0x11);   // SLPOUT
  1044.  
  1045.     spi1writeindex(0x51);
  1046.     spi1writedata(0x0); // default brightness : 0
  1047. //  spi1writedata(0x6C); // default brightness : 108
  1048.     aat1402_set_brightness();
  1049.  
  1050.     spi1writeindex(0x53);
  1051.     spi1writedata(0x2C);
  1052.  
  1053.     msleep(240);    // 120ms
  1054.     spi1writeindex(0x29);   // DISPON
  1055.  
  1056.     atomic_set(&ldi_power_state, POWER_ON);
  1057.     printk("[LCD] %s() -- \n", __func__);
  1058. }
  1059.  
  1060. void nt35510_ldi_poweroff_hydis(void)
  1061. {
  1062.     printk(" **** %s\n", __func__);
  1063.        
  1064.     // Display Off
  1065.     spi1writeindex(0x28);   // SEQ_DISPOFF_SET
  1066.  
  1067. //  if(current_panel==0) // sony
  1068.     {
  1069.         msleep(25);
  1070.     }
  1071.  
  1072.     // SLEEP IN
  1073.     spi1writeindex(0x10);   // SEQ_SLEEP IN_SET
  1074.  
  1075.     //Wait 120ms
  1076.     msleep(150);   
  1077.    
  1078.     atomic_set(&ldi_power_state, POWER_OFF);
  1079. }
  1080.  
  1081. void nt35510_ldi_poweron_smd(void)
  1082. {
  1083.     printk("[LCD] %s() + \n", __func__);
  1084.  
  1085.     /* Initializing Sequence */
  1086.     spi1writeindex(0x36);
  1087.     spi1writedata(0x09); // 0A
  1088.  
  1089.     spi1writeindex(0xB0);
  1090.     spi1writedata(0x00);   
  1091.    
  1092.     spi1writeindex(0xC0);
  1093.     spi1writedata(0x28);   
  1094.     spi1writedata(0x08);
  1095.  
  1096.     spi1writeindex(0xC1);
  1097.     spi1writedata(0x01);
  1098.     spi1writedata(0x32);
  1099.     spi1writedata(0x15);
  1100.     spi1writedata(0x05);
  1101.     spi1writedata(0x22);
  1102.  
  1103.     spi1writeindex(0xC4);
  1104.     spi1writedata(0x10);
  1105.     spi1writedata(0x01);
  1106.     spi1writedata(0x00);
  1107.  
  1108.     spi1writeindex(0xC5);
  1109.     spi1writedata(0x06);
  1110.     spi1writedata(0x55);
  1111.     spi1writedata(0x03);
  1112.     spi1writedata(0x07);
  1113.     spi1writedata(0x07);
  1114.     spi1writedata(0x33);
  1115.     spi1writedata(0x00);
  1116.     spi1writedata(0x01);
  1117.     spi1writedata(0x04);
  1118.  
  1119.     spi1writeindex(0xC6); // RGB Sync option
  1120.     spi1writedata(0x00);
  1121.    
  1122.     spi1writeindex(0xC8);
  1123.     spi1writedata(0x01);
  1124.     spi1writedata(0x10);
  1125.     spi1writedata(0x18);
  1126.     spi1writedata(0x24);
  1127.     spi1writedata(0x39);
  1128.     spi1writedata(0x44);
  1129.     spi1writedata(0x45);
  1130.     spi1writedata(0x4C);
  1131.     spi1writedata(0x48);
  1132.     spi1writedata(0x50);
  1133.     spi1writedata(0x52);
  1134.     spi1writedata(0x51);
  1135.     spi1writedata(0x50);
  1136.     spi1writedata(0x4B);
  1137.     spi1writedata(0x4A);
  1138.     spi1writedata(0x61);
  1139.     spi1writedata(0x62);
  1140.     spi1writedata(0x63);
  1141.     spi1writedata(0x10);
  1142.    
  1143.     spi1writedata(0x01);
  1144.     spi1writedata(0x10);
  1145.     spi1writedata(0x18);
  1146.     spi1writedata(0x24);
  1147.     spi1writedata(0x39);
  1148.     spi1writedata(0x44);
  1149.     spi1writedata(0x45);
  1150.     spi1writedata(0x4C);
  1151.     spi1writedata(0x48);
  1152.     spi1writedata(0x50);
  1153.     spi1writedata(0x52);
  1154.     spi1writedata(0x51);
  1155.     spi1writedata(0x50);
  1156.     spi1writedata(0x4B);
  1157.     spi1writedata(0x4A);
  1158.     spi1writedata(0x61);
  1159.     spi1writedata(0x62);
  1160.     spi1writedata(0x63);
  1161.     spi1writedata(0x10);
  1162.  
  1163.     spi1writeindex(0xD1);
  1164.     spi1writedata(0x33);
  1165.     spi1writedata(0x13);
  1166.  
  1167.     spi1writeindex(0xD2);
  1168.     spi1writedata(0x11);
  1169.     spi1writedata(0x00);
  1170.     spi1writedata(0x00);
  1171.  
  1172.     spi1writeindex(0xD3);
  1173.     spi1writedata(0x50);
  1174.     spi1writedata(0x50);
  1175.  
  1176.     spi1writeindex(0xD5);
  1177.     spi1writedata(0x2F);
  1178.     spi1writedata(0x11);
  1179.     spi1writedata(0x1E);
  1180.     spi1writedata(0x46);
  1181.  
  1182.     spi1writeindex(0xD6);
  1183.     spi1writedata(0x11);
  1184.     spi1writedata(0x02);
  1185.  
  1186. ////
  1187.     // Set PWM 
  1188.     spi1writeindex(0xB4);
  1189.     spi1writedata(0x0F);
  1190.     spi1writedata(0x00);
  1191.     spi1writedata(0x50);
  1192.  
  1193.     spi1writeindex(0xB5);
  1194.     spi1writedata(0x00);
  1195. //  spi1writedata(0x6C); // default brightness : 108
  1196.     aat1402_set_brightness();
  1197.  
  1198.     spi1writeindex(0xB7);
  1199.     spi1writedata(0x24);
  1200.  
  1201.     spi1writeindex(0xB8);
  1202.     spi1writedata(0x01);
  1203.    
  1204. ////   
  1205.  
  1206.     /* Sleep Out */
  1207.     spi1writeindex(0x11);
  1208.     msleep(40); // 20ms
  1209.  
  1210.     /* NVM Load Sequence */
  1211.     spi1writeindex(0xD4);
  1212.     spi1writedata(0x54);
  1213.     spi1writedata(0x54);
  1214.  
  1215.     spi1writeindex(0xF8);
  1216.     spi1writedata(0x01);
  1217.     spi1writedata(0xF5);
  1218.     spi1writedata(0xF2);
  1219.     spi1writedata(0x81);
  1220.  
  1221.     spi1writeindex(0xFC);
  1222.     spi1writedata(0x00);
  1223.     spi1writedata(0x08);
  1224.     msleep(300); // 150ms
  1225.  
  1226.     /* Display On */   
  1227.     spi1writeindex(0x29);  
  1228.  
  1229.     atomic_set(&ldi_power_state, POWER_ON);
  1230.     printk("[LCD] %s() -- \n", __func__);
  1231. }
  1232.  
  1233. void nt35510_ldi_poweroff_smd(void)
  1234. {
  1235.     printk(" **** %s\n", __func__);
  1236.  
  1237.     // Sleep In
  1238.     spi1writeindex(0x10);
  1239.     msleep(240); // 120 ms
  1240.    
  1241.     //Display Off Command
  1242.     spi1writeindex(0x28);
  1243.  
  1244.     atomic_set(&ldi_power_state, POWER_OFF);
  1245. }
  1246.  
  1247. void nt35510_lcd_LDO_on(void)
  1248. {
  1249.     int ret;
  1250.     printk("+++ %s\n", __func__);
  1251. //  twl_i2c_read_regdump();
  1252. #if 1  
  1253.     ret = regulator_enable( vaux3 ); //VAUX3 - 1.8V
  1254.     if ( ret )
  1255.         printk("Regulator vaux3 error!!\n");
  1256. #else
  1257.     twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00, 0x1F);
  1258.     twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x1, 0x22);
  1259.     twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0xe0, 0x1F);
  1260. #endif
  1261.    
  1262.     mdelay(1);
  1263.     ret = regulator_enable( vaux4 ); //VAUX4 - 2.8V
  1264.     if ( ret )
  1265.         printk("Regulator vaux4 error!!\n");
  1266.    
  1267.     mdelay(1);
  1268.     printk("--- %s\n", __func__);
  1269. }
  1270.  
  1271. void nt35510_lcd_LDO_off(void)
  1272. {
  1273.     int ret;
  1274.     printk("+++ %s\n", __func__);
  1275.  
  1276.     // Reset Release (reset = L)
  1277.     gpio_set_value(OMAP_GPIO_MLCD_RST, GPIO_LEVEL_LOW);
  1278.     mdelay(10);
  1279.  
  1280.     // VCI 2.8V OFF
  1281.     ret = regulator_disable( vaux4 );
  1282.     if ( ret )
  1283.         printk("Regulator vaux4 error!!\n");
  1284.     mdelay(1);
  1285.  
  1286.     // VDD3 1.8V OFF
  1287. #if 1
  1288.     ret = regulator_disable( vaux3 );
  1289.     if ( ret )
  1290.         printk("Regulator vaux3 error!!\n");
  1291. #else
  1292.     twl_i2c_write_u8(TWL4030_MODULE_PM_RECEIVER, 0x00, 0x1F);
  1293. #endif 
  1294.  
  1295.     printk("--- %s\n", __func__);
  1296. }
  1297.  
  1298. void nt35510_lcd_poweroff(void)
  1299. {
  1300.     if(current_panel==0) // Sony
  1301.         nt35510_ldi_poweroff_sony();
  1302.     else if(current_panel==1) // Hitachi
  1303.         nt35510_ldi_poweroff_hitachi();
  1304.     else if(current_panel==2) // Hydis
  1305.         nt35510_ldi_poweroff_hydis();
  1306.     else if(current_panel==3) // SMD
  1307.         nt35510_ldi_poweroff_smd();
  1308.  
  1309.     // turn OFF VCI (2.8V)
  1310.     // turn OFF VDD3 (1.8V)
  1311.     nt35510_lcd_LDO_off();
  1312.  
  1313.  
  1314.  
  1315.     // OMAP MCSPI1 PIN NC
  1316. //  omap34xx_pad_set_configs(omap34xx_lcd_off_pins, ARRAY_SIZE(omap34xx_lcd_off_pins));
  1317.        omap34xx_pad_set_config_lcd(0x01C8,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1318.         omap34xx_pad_set_config_lcd(0x01CA,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1319.         omap34xx_pad_set_config_lcd(0x01CC,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1320.         omap34xx_pad_set_config_lcd(0x01CE,  OMAP34XX_MUX_MODE7 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1321.     return;
  1322. }
  1323.  
  1324. void nt35510_lcd_poweron(void)
  1325. {
  1326.     // OMAP MCSPI1 PIN PAD CONFIG
  1327. //  omap34xx_pad_set_configs(omap34xx_lcd_pins, ARRAY_SIZE(omap34xx_lcd_pins));
  1328.     omap34xx_pad_set_config_lcd(0x01C8,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP);
  1329.     omap34xx_pad_set_config_lcd(0x01CA,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1330.     omap34xx_pad_set_config_lcd(0x01CC,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLDOWN);
  1331.     omap34xx_pad_set_config_lcd(0x01CE,  OMAP34XX_MUX_MODE0 | OMAP34XX_PIN_INPUT_PULLUP);
  1332.  
  1333.  
  1334.     nt35510_lcd_LDO_on();
  1335.  
  1336.     // Activate Reset
  1337.     gpio_set_value(OMAP_GPIO_MLCD_RST, GPIO_LEVEL_LOW);
  1338.  
  1339.     mdelay(1);
  1340.     gpio_set_value(OMAP_GPIO_MLCD_RST, GPIO_LEVEL_HIGH);
  1341.     mdelay(5);
  1342.    
  1343.     //MLCD pin set to InputPulldown.
  1344.     omap_ctrl_writew(0x010C, 0x1c6);
  1345.  
  1346.     if(current_panel==0)    // Sony
  1347.         nt35510_ldi_poweron_sony();
  1348.     else if(current_panel==1) // Hitachi
  1349.         nt35510_ldi_poweron_hitachi();
  1350.     else if(current_panel==2) // Hydis
  1351.         nt35510_ldi_poweron_hydis();
  1352.     else if(current_panel==3) // SMD
  1353.         nt35510_ldi_poweron_smd();
  1354.  
  1355.     aat1402_set_brightness();
  1356.  
  1357.     return;
  1358. }
  1359.  
  1360. // [[ backlight control
  1361. static int current_intensity = 108; // DEFAULT BRIGHTNESS
  1362. static DEFINE_SPINLOCK(aat1402_bl_lock);
  1363.  
  1364. static void aat1402_set_brightness(void)
  1365. {
  1366.     printk(KERN_DEBUG" *** aat1402_set_brightness : %d\n", current_intensity);
  1367.     //spin_lock_irqsave(&aat1402_bl_lock, flags);
  1368.     //spin_lock(&aat1402_bl_lock);
  1369.  
  1370.     if(current_panel==1)    // if Hitachi
  1371.     {
  1372.         spi1writeindex(0xB0);
  1373.         spi1writedata(0x02);
  1374.  
  1375.         spi1writeindex(0xB9);
  1376.         spi1writedata(0x00);
  1377.         spi1writedata(current_intensity);   // PWM control. default brightness : 108
  1378.         spi1writedata(0x02);
  1379.         spi1writedata(0x08);
  1380.        
  1381.         spi1writeindex(0xB0);
  1382.         spi1writedata(0x03);
  1383.     }
  1384.     else if(current_panel==3) // if SMD
  1385.     {
  1386.         spi1writeindex(0xB4);
  1387.         spi1writedata(0x0F);
  1388.         spi1writedata(0x00);
  1389.         spi1writedata(0x50);
  1390.  
  1391.         spi1writeindex(0xB5);
  1392.         spi1writedata(current_intensity);
  1393.  
  1394.         spi1writeindex(0xB7);
  1395.         spi1writedata(0x24);
  1396.  
  1397.         spi1writeindex(0xB8);
  1398.         spi1writedata(0x01);
  1399.     }
  1400.     else // Sony, Hydis
  1401.     {
  1402.             spi1writeindex(0x51);
  1403.         spi1writedata(current_intensity);
  1404.     }
  1405.     //spin_unlock_irqrestore(&aat1402_bl_lock, flags);
  1406.     //spin_unlock(&aat1402_bl_lock);
  1407.  
  1408. }
  1409.  
  1410. static int aat1402_bl_get_intensity(struct backlight_device *bd)
  1411. {
  1412.     return current_intensity;
  1413. }
  1414.  
  1415. static int aat1402_bl_set_intensity(struct backlight_device *bd)
  1416. {
  1417.     //unsigned long flags;
  1418.     int intensity = bd->props.brightness;
  1419. //  int retry_count=10;
  1420.    
  1421.     if( intensity < 0 || intensity > 255 )
  1422.         return;
  1423. /*
  1424.     while(atomic_read(&ldi_power_state)==POWER_OFF)
  1425.     {
  1426.         if(--retry_count == 0)
  1427.             break;
  1428.         mdelay(5);
  1429.     }
  1430. */ 
  1431.     current_intensity = intensity;
  1432.     if(atomic_read(&ldi_power_state)==POWER_OFF)
  1433.         return;
  1434.     aat1402_set_brightness();
  1435.  
  1436.     return 0;
  1437. }
  1438.  
  1439. static struct backlight_ops aat1402_bl_ops = {
  1440.     .get_brightness = aat1402_bl_get_intensity,
  1441.     .update_status  = aat1402_bl_set_intensity,
  1442. };
  1443. // ]] backlight control
  1444.  
  1445. static int nt35510_spi_probe(struct spi_device *spi)
  1446. {
  1447.     printk(KERN_INFO " **** nt35510_spi_probe.\n");
  1448.     nt35510lcd_spi = spi;
  1449.     nt35510lcd_spi->mode = SPI_MODE_0;
  1450.     nt35510lcd_spi->bits_per_word = 9 ;
  1451.     spi_setup(nt35510lcd_spi);
  1452.    
  1453.     omap_dss_register_driver(&nt35510_driver);
  1454. //  led_classdev_register(&spi->dev, &nt35510_backlight_led);
  1455.     struct backlight_device *bd;
  1456.     bd = backlight_device_register("omap_bl", &spi->dev, NULL, &aat1402_bl_ops);
  1457.     bd->props.max_brightness = 255;
  1458.     bd->props.brightness = 125;
  1459.    
  1460. #ifndef CONFIG_FB_OMAP_BOOTLOADER_INIT
  1461.     nt35510_lcd_poweron();
  1462. #endif
  1463.  
  1464.     return 0;
  1465. }
  1466.  
  1467. static int nt35510_spi_remove(struct spi_device *spi)
  1468. {
  1469. //  led_classdev_unregister(&nt35510_backlight_led);
  1470.     omap_dss_unregister_driver(&nt35510_driver);
  1471.  
  1472.     return 0;
  1473. }
  1474. static void nt35510_spi_shutdown(struct spi_device *spi)
  1475. {
  1476.     printk("*** First power off LCD.\n");
  1477.     nt35510_lcd_poweroff();
  1478.     printk("*** power off - backlight.\n");
  1479.     gpio_set_value(OMAP_GPIO_LCD_EN_SET, GPIO_LEVEL_LOW);
  1480. }
  1481.  
  1482. static int nt35510_spi_suspend(struct spi_device *spi, pm_message_t mesg)
  1483. {
  1484.     //spi_send(spi, 2, 0x01);  /* R2 = 01h */
  1485.     //mdelay(40);
  1486.  
  1487. #if 0
  1488.     nt35510lcd_spi = spi;
  1489.     nt35510lcd_spi->mode = SPI_MODE_0;
  1490.     nt35510lcd_spi->bits_per_word = 16 ;
  1491.     spi_setup(nt35510lcd_spi);
  1492.  
  1493.     lcd_poweroff();
  1494.     zeus_panel_power_enable(0);
  1495. #endif
  1496.  
  1497.     return 0;
  1498. }
  1499.  
  1500. static int nt35510_spi_resume(struct spi_device *spi)
  1501. {
  1502.     /* reinitialize the panel */
  1503. #if 0
  1504.     zeus_panel_power_enable(1);
  1505.     nt35510lcd_spi = spi;
  1506.     nt35510lcd_spi->mode = SPI_MODE_0;
  1507.     nt35510lcd_spi->bits_per_word = 16 ;
  1508.     spi_setup(nt35510lcd_spi);
  1509.  
  1510.     lcd_poweron();
  1511. #endif
  1512.     return 0;
  1513. }
  1514.  
  1515. static struct spi_driver nt35510_spi_driver = {
  1516.     .probe    = nt35510_spi_probe,
  1517.     .remove   = nt35510_spi_remove,
  1518.     .shutdown = nt35510_spi_shutdown,
  1519.     .suspend  = nt35510_spi_suspend,
  1520.     .resume   = nt35510_spi_resume,
  1521.     .driver   = {
  1522.         .name   = "nt35510_disp_spi",
  1523.         .bus    = &spi_bus_type,
  1524.         .owner  = THIS_MODULE,
  1525.     },
  1526. };
  1527.  
  1528. static int __init nt35510_lcd_init(void)
  1529. {
  1530.     return spi_register_driver(&nt35510_spi_driver);
  1531. }
  1532.  
  1533. static void __exit nt35510_lcd_exit(void)
  1534. {
  1535.     return spi_unregister_driver(&nt35510_spi_driver);
  1536. }
  1537.  
  1538. module_init(nt35510_lcd_init);
  1539. module_exit(nt35510_lcd_exit);
  1540. MODULE_LICENSE("GPL");
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!