static void mddi_r61581_hw_reset(void)
{
RESET(GPIO_LOW_VALUE);
mddi_wait(10);
RESET(GPIO_HIGH_VALUE);
mddi_wait(10);
}
static void sony_lcd_enter_sleep(void)
{
MDDI_DEBUG(LEVEL_TRACE, "%s [%d]\n", __func__, lcd_state);
/* Display off */
write_client_reg_nbr(0x28, 0, 0, 0, 0, 1);
mddi_wait(50); /* >50 ms */
/* Sleep in */
write_client_reg_nbr(0x10, 0, 0, 0, 0, 1);
mddi_wait(120); /* >120 ms */
}
static void sony_lcd_exit_sleep(void)
{
MDDI_DEBUG(LEVEL_TRACE, "%s [%d]\n", __func__, lcd_state);
/* Sleep out */
write_client_reg_nbr(0x11, 0x00000000, 0, 0, 0, 1);
mddi_wait(120); /* >120 ms */
/* Display on */
write_client_reg_nbr(0x29, 0x00000000, 0, 0, 0, 1);
}
static int __init mddi_tpo_nv_init(void)
{
int ret;
struct msm_panel_info *pinfo;
#ifdef CONFIG_FB_MSM_MDDI_AUTO_DETECT
mddi_wait(10); // wait to come completely out of reset
plat_disp_type = mddi_get_client_id();
printk("%s: client_id=0x%X, crc=0x%X, width=%d, height=%d\n",
__FUNCTION__, plat_disp_type, mddi_client_capability_pkt.parameter_CRC,
mddi_client_capability_pkt.Bitmap_Width,
mddi_client_capability_pkt.Bitmap_Height);
if (mddi_client_capability_pkt.Bitmap_Width == 0x00 ||
mddi_client_capability_pkt.Bitmap_Height == 0x00)
{
printk("%s: panel appears to be missing. Exiting\n", __FUNCTION__);
return 0;
}
#endif
ret = platform_driver_register(&mddi_tpo_nv_driver);
if (!ret) {
pinfo = &mddi_tpo_nv_panel_data.panel_info;
pinfo->xres = LCD_WIDTH;
pinfo->yres = LCD_HEIGHT;
pinfo->type = MDDI_PANEL;
pinfo->pdest = DISPLAY_1;
pinfo->wait_cycle = 0;
pinfo->bpp = 18;
pinfo->fb_num = 2;
pinfo->clk_min = TPO_NV_CLK_RATE;
pinfo->clk_max = TPO_NV_CLK_RATE;
pinfo->clk_rate = TPO_NV_CLK_RATE;
pinfo->lcd.vsync_enable = TRUE;
pinfo->lcd.refx100 =
(mddi_tpo_nv_rows_per_second * 100) /
mddi_tpo_nv_rows_per_refresh;
pinfo->lcd.v_back_porch = V_BACK_PORCH;
pinfo->lcd.v_front_porch = V_FRONT_PORCH;
pinfo->lcd.v_pulse_width = V_SYNC_WIDTH;
pinfo->lcd.hw_vsync_mode = TRUE;
pinfo->lcd.vsync_notifier_period = (1 * HZ);
pinfo->bl_max = 7;
pinfo->bl_min = 1;
ret = platform_device_register(&mddi_tpo_nv_device);
if (ret)
{
platform_driver_unregister(&mddi_tpo_nv_driver);
}
}
return ret;
}
static void mddi_r61581_sleep(u32 sleepin)
{
if (sleepin) {
serigo(0x0028, 0, "\x00", TRUE);
serigo(0x0010, 0, "\x00", TRUE);
} else {
serigo(0x0011, 0, "\x00", TRUE);
mddi_wait(120);
serigo(0x0029, 0, "\x00", TRUE);
}
}
static int mddi_r61581_lcd_on(struct platform_device *pdev)
{
MDDI_MSG_DEBUG("[MDDI] turning r61581 on\n");
if (r61581_initialized) {
mddi_r61581_sleep(0);
} else {
mddi_r61581_hw_reset();
mddi_wait(10);
serigo(0x00B0, 1, "\x0", TRUE);
serigo(0x00B3, 4, "\x02\x00\x00\x00", TRUE);
serigo(0x00B4, 1, "\x00", TRUE);
serigo(0x00C0, 8, "\x03\x3B\x00\x02\x00\x01\x00\x43", TRUE);
serigo(0x00C1, 4, "\x08\x17\x08\x08", TRUE);
serigo(0x00C4, 4, "\x22\x02\x00\x00", TRUE);
serigo(0x00C8, 20, "\x09\x08\x10\x85\x07\x08\x16\x05\x00\x32"
"\x05\x16\x08\x88\x09\x10\x09\x04\x32\x00", TRUE);
serigo(0x002A, 4, "\x00\x00\x01\x3F", TRUE);
serigo(0x002B, 4, "\x00\x00\x01\xDF", TRUE);
serigo(0x0035, 1, "\x00", TRUE);
serigo(0x003A, 1, "\x66", TRUE);
serigo(0x0044, 2, "\x00\x01", TRUE);
serigo(0x002C, 0, "\x00", TRUE);
serigo(0x0011, 0, "\x00", TRUE);
mddi_wait(150);
serigo(0x00D0, 4, "\x07\x07\x16\x72", TRUE);
serigo(0x00D1, 3, "\x03\x3A\x0A", TRUE);
serigo(0x00D2, 3, "\x02\x44\x04", TRUE);
serigo(0x0029, 0, "\x00", TRUE);
serigo(0x002C, 0, "\x00", TRUE);
mddi_wait(10);
r61581_initialized = TRUE;
}
return 0;
}
static void mddi_tpo_nv_esd_poll(void* arg)
{
#ifdef MDDI_TPO_NV_ESD_DEBUG
uint32_t val;
#endif
struct platform_device *pdev = (struct platform_device *)arg;
msm_fb_down(pdev);
#ifdef MDDI_TPO_NV_ESD_DEBUG
printk(KERN_ERR "TPO NV - ESD register check START\n");
mddi_queue_register_write(ENTRYMODE2 ,0x00C4, 0, 0);
mddi_wait(20);
for (i = 0;; i++)
{
if (disp_init[i].reg == TABLE_END)
{
break;
}
else if (disp_init[i].reg != MDDI_SLEEP_CMD)
{
mddi_queue_register_read(disp_init[i].reg, &val, 1, 0);
if (disp_init[i].val != val)
{
printk(KERN_ERR "TPO NV reg 0x%X should be 0x%X, found 0x%X\n",
disp_init[i].reg, disp_init[i].val, val);
}
}
}
mddi_queue_register_write(ENTRYMODE2 ,0x00C5, 0, 0);
mddi_wait(30);
printk(KERN_ERR "TPO NV - ESD register check END\n");
#endif /* MDDI_TPO_NV_ESD_DEBUG */
if (disp_esd_recovery)
{
xmit_panel_seq(disp_esd_recovery);
}
msm_fb_up(pdev);
}
static void mddi_toshiba_fwvga_lcd_shutdown(struct platform_device *dev)
{
printk(KERN_INFO "MDDI: mddi_toshiba_fwvga_lcd_shutdown\n");
mddi_queue_register_write( 0x2800, 0x0000, FALSE, 0); // SET_DISPLAY_OFF
mddi_queue_register_write( 0x1000, 0x0000, FALSE, 0); // ENTER_SLEEP_MODE
mddi_wait(70);
// LCM_RESET -> Low
gpio_set_value(GPIO_LCM_RESET, 0);
// PM8058_LVS1_V1P8
vreg_disable(vreg_lvsw1);
// PM8058_L15_V2P85
vreg_disable(vreg_gp6);
}
static boolean serigo(uint32 reg, uint32 len, const char *params, boolean wait)
{
uint32 rv;
uint32 data_list[20];
uint i;
for (i = 0; i < len; ++i)
data_list[i] = (u32)params[i] & 0xFF;
if (len > 0)
rv = mddi_host_register_multiwrite(reg, len, data_list, wait, \
NULL, MDDI_HOST_PRIM);
else
rv = mddi_queue_register_write(reg, 0, TRUE, 0);
mddi_wait(10);
return rv;
}
/*=============================================================================
LOCAL FUNCTIONS
=============================================================================*/
static void xmit_panel_seq(struct init_table const *init_table)
{
unsigned n;
for (n = 0;; n++)
{
if (init_table[n].reg == TABLE_END)
{
break;
}
else if (init_table[n].reg == MDDI_SLEEP_CMD)
{
mddi_wait(init_table[n].val);
}
else
{
mddi_queue_register_write(init_table[n].reg, init_table[n].val, 0, 0);
}
}
}
void panel_init(struct init_table *init_table)
{
unsigned int n;
printk(KERN_INFO "MDDI: panel_init()\n");
n = 0;
while (init_table[n].reg != 0 || init_table[n].val != 0) {
if (init_table[n].reg != 0) {
// printk(KERN_INFO "write Address(0x%08x), Data(0x%08x)\n", init_table[n].reg, init_table[n].val);
mddi_queue_register_write(init_table[n].reg, init_table[n].val, FALSE, 0);
} else {
printk(KERN_INFO "mdelay %d\n", init_table[n].val);
mddi_wait(init_table[n].val);
printk(KERN_INFO "mdelay %d done\n", init_table[n].val);
}
n++;
}
printk(KERN_INFO "MDDI: panel_init() done\n");
}
