static int mecha_sharp_panel_unblank(struct msm_lcdc_panel_ops *ops)
{
struct spi_msg set_brightness = {
.cmd = 0x51,
.len = 1,
.data = (unsigned char *)&last_val,
};
LCMDBG("\n");
if (color_enhancement == 0) {
mecha_mdp_color_enhancement(mdp_pdata.mdp_dev);
color_enhancement = 1;
}
mutex_lock(&panel_lock);
qspi_send_9bit(&set_brightness);
lcm_sharp_write_seq(sharp_turn_on_backlight,
ARRAY_SIZE(sharp_turn_on_backlight));
mutex_unlock(&panel_lock);
return 0;
}
static int mecha_sharp_panel_blank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
lcm_sharp_write_seq(sharp_blank_seq, ARRAY_SIZE(sharp_blank_seq));
hr_msleep(100);
mutex_unlock(&panel_lock);
return 0;
}
/*----------------------------------------------------------------------------*/
int __init mecha_init_panel(void)
{
int ret;
vreg_lcm_1v8 = vreg_get(0, "gp13");
if (IS_ERR(vreg_lcm_1v8))
return PTR_ERR(vreg_lcm_1v8);
vreg_lcm_2v8 = vreg_get(0, "wlan2");
if (IS_ERR(vreg_lcm_2v8))
return PTR_ERR(vreg_lcm_2v8);
LCMDBG("panel_type=%d\n", panel_type);
if (panel_type & 0x8) {
panel_rev = 1;
panel_type &= 0x7;
}
switch (panel_type) {
case PANEL_AUO:
#ifdef CONFIG_PANEL_SELF_REFRESH
mdp_pdata.overrides |= MSM_MDP_RGB_PANEL_SELE_REFRESH;
LCMDBG("MECHA AUO Panel:RGB_PANEL_SELE_REFRESH \n");
mecha_auo_panel_ops.refresh_enable = mecha_auo_panel_refresh_enable;
mecha_auo_panel_ops.refresh_disable = mecha_auo_panel_refresh_disable;
msm_device_mdp.dev.platform_data = &mdp_pdata;
#endif
mecha_lcdc_platform_data.timing = &mecha_auo_timing;
mecha_lcdc_platform_data.panel_ops = &mecha_auo_panel_ops;
break;
case PANEL_SHARP:
case PANEL_SHARP565:
if (panel_type == PANEL_SHARP565)
mdp_pdata.overrides |= MSM_MDP_DMA_PACK_ALIGN_LSB;
msm_device_mdp.dev.platform_data = &mdp_pdata;
mecha_lcdc_platform_data.timing = &mecha_sharp_timing;
mecha_lcdc_platform_data.panel_ops = &mecha_sharp_panel_ops;
break;
default:
return -EINVAL;
}
ret = platform_device_register(&msm_device_mdp);
if (ret != 0)
return ret;
ret = platform_device_register(&mecha_lcdc_device);
if (ret != 0)
return ret;
ret = platform_device_register(&mecha_backlight_pdev);
if (ret)
return ret;
return 0;
}
int __init spade_init_panel(void)
{
int ret;
vreg_lcm_1v8 = vreg_get(0, "gp13");
if (IS_ERR(vreg_lcm_1v8))
return PTR_ERR(vreg_lcm_1v8);
vreg_lcm_2v8 = vreg_get(0, "wlan2");
if (IS_ERR(vreg_lcm_2v8))
return PTR_ERR(vreg_lcm_2v8);
LCMDBG("panel_type=%d\n", panel_type);
switch (panel_type) {
case PANEL_AUO:
#ifdef CONFIG_PANEL_SELF_REFRESH
mdp_pdata.overrides = MSM_MDP_RGB_PANEL_SELE_REFRESH,
LCMDBG("ACE AUO Panel:RGB_PANEL_SELE_REFRESH \n");
spade_auo_panel_ops.refresh_enable = spade_auo_panel_refresh_enable;
spade_auo_panel_ops.refresh_disable = spade_auo_panel_refresh_disable;
#endif
spade_lcdc_platform_data.timing = &spade_auo_timing;
spade_lcdc_platform_data.panel_ops = &spade_auo_panel_ops;
break;
case PANEL_ID_SPADE_AUO_N90:
spade_lcdc_platform_data.timing = &spade_auo_n90_timing;
spade_lcdc_platform_data.panel_ops = &spade_auo_n90_panel_ops;
break;
case PANEL_SHARP:
case PANEL_ID_SPADE_SHA_N90:
spade_lcdc_platform_data.timing = &spade_sharp_timing;
spade_lcdc_platform_data.panel_ops = &spade_sharp_panel_ops;
break;
default:
return -EINVAL;
}
msm_device_mdp.dev.platform_data = &mdp_pdata;
ret = platform_device_register(&msm_device_mdp);
if (ret != 0)
return ret;
ret = platform_device_register(&spade_lcdc_device);
if (ret != 0)
return ret;
ret = platform_device_register(&spade_backlight_pdev);
if (ret)
return ret;
return 0;
}
static int mecha_backlight_probe(struct platform_device *pdev)
{
int rc;
rc = led_classdev_register(&pdev->dev, &mecha_backlight_led);
if (rc)
LCMDBG("backlight: failure on register led_classdev\n");
rc = device_create_file(mecha_backlight_led.dev, &auto_attr);
if (rc)
LCMDBG("backlight: failure on create attr\n");
return 0;
}
static int amoled_panel_unblank(struct msm_lcdc_panel_ops *panel_data)
{
LCMDBG("%s\n", __func__);
wake_lock(&panel_idle_lock);
mutex_lock(&panel_lock);
amoled_set_gamma_val(last_level);
/* Display on */
qspi_send_9bit(&unblank_msg);
mutex_unlock(&panel_lock);
wake_unlock(&panel_idle_lock);
LCMDBG("%s: last_level = %d\n", __func__, last_level);
led_trigger_event(amoled_lcd_backlight, LED_FULL);
return 0;
}
static int spade_sharp_panel_blank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
spade_adjust_backlight(0);
atomic_set(&lcm_init_done, 0);
return 0;
}
static void flyer_panel_power(bool on_off)
{
int gpio_lcm_en, gpio_lvds_on;
if (panel_type != PANEL_ID_FLR_SMD_XB) {
gpio_lcm_en = FLYER_LCM_3V3_EN_XC;
gpio_lvds_on = FLYER_LVDS_ON_XC;
} else {
gpio_lcm_en = FLYER_LCM_3V3_EN;
gpio_lvds_on = FLYER_LVDS_ON;
}
if (!!on_off) {
LCMDBG("%s(%d):\n", __func__, on_off);
vreg_enable(vreg_lcm_1v8);
gpio_set_value(gpio_lcm_en, 1);
if(panel_type == PANEL_ID_FLR_LG_XC || panel_type == PANEL_ID_FLR_LG_WS2)
hr_msleep(50);
else
hr_msleep(90);
gpio_set_value(gpio_lvds_on, 1);
} else {
gpio_set_value(gpio_lcm_en, 0);
if(panel_type == PANEL_ID_FLR_LG_XC || panel_type == PANEL_ID_FLR_LG_WS2)
hr_msleep(50);
else
hr_msleep(60);
gpio_set_value(gpio_lvds_on, 0);
vreg_disable(vreg_lcm_1v8);
}
}
static int sonywvga_panel_blank(struct msm_lcdc_panel_ops *panel_data)
{
uint8_t data[4] = {0, 0, 0, 0};
LCMDBG("%s\n", __func__);
mutex_lock(&panel_lock);
blank_msg.cmd = 0x28;
qspi_send_9bit(&blank_msg);
blank_msg.cmd = 0x10;
qspi_send_9bit(&blank_msg);
hr_msleep(40);
g_unblank_stage = 0;
mutex_unlock(&panel_lock);
sonywvga_panel_power(0);
if (!is_sony_spi()) {
data[0] = 5;
data[1] = 0;
data[3] = 1;
microp_i2c_write(0x25, data, 4);
}
return 0;
}
static int samsung_oled_panel_init(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("%s()\n", __func__);
amoled_panel_power(1);
wake_lock(&panel_idle_lock);
mutex_lock(&panel_lock);
if (machine_is_passionc()) {
/* FIXME: display team will clean up the below codes */
if (system_rev == 0xC0 || system_rev == 0) /* for Passion#C EVT1 */
lcm_write_tb(lcm_init_seq, ARRAY_SIZE(lcm_init_seq));
else
lcm_write_tb(lcm_init_seq, ARRAY_SIZE(lcm_init_666seq));
} else {
if (system_rev < 1)
lcm_write_tb(lcm_init_seq, ARRAY_SIZE(lcm_init_seq));
else
lcm_write_tb(lcm_init_seq, ARRAY_SIZE(lcm_init_666seq));
}
gamma_table_bank_select();
mutex_unlock(&panel_lock);
wake_unlock(&panel_idle_lock);
return 0;
}
static int spade_adjust_backlight(enum led_brightness val)
{
uint8_t data[4] = { /* PWM setting of microp, see p.8 */
0x05, /* Fading time; suggested: 5/10/15/20/25 */
val, /* Duty Cycle */
0x00, /* Channel H byte */
0x20, /* Channel L byte */
};
uint8_t shrink_br;
mutex_lock(&panel_lock);
if (val == 0)
shrink_br = 0;
else if (val <= 30)
shrink_br = 7;
else if ((val > 30) && (val <= 143))
shrink_br = (91 - 7) * (val - 30) / (143 - 30) + 7;
else
shrink_br = (217 - 91) * (val - 143) / (255 - 143) + 91;
data[1] = shrink_br;
LCMDBG("(%d), shrink_br=%d\n", val, shrink_br);
microp_i2c_write(0x25, data, sizeof(data));
last_val = shrink_br ? shrink_br: last_val;
mutex_unlock(&panel_lock);
return shrink_br;
}
/*----------------------------------------------------------------------------*/
int spade_panel_sleep_in(void)
{
int ret;
LCMDBG(", screen=%s\n", screen_on ? "on" : "off");
if (screen_on)
return 0;
mutex_lock(&panel_lock);
switch (panel_type) {
case PANEL_AUO:
spade_auo_panel_power(1);
lcm_auo_write_seq(auo_sleep_in_seq,
ARRAY_SIZE(auo_sleep_in_seq));
ret = 0;
break;
case PANEL_SHARP:
spade_sharp_panel_power(1);
lcm_sharp_write_seq(sharp_uninit_seq,
ARRAY_SIZE(sharp_uninit_seq));
ret = 0;
break;
default:
ret = -EINVAL;
break;
}
mutex_unlock(&panel_lock);
return ret;
}
static int spade_auo_n90_panel_uninit(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
spade_auo_panel_power(0);
mutex_unlock(&panel_lock);
return 0;
}
static int mecha_sharp_panel_uninit(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
mecha_sharp_panel_power(0);
mutex_unlock(&panel_lock);
return 0;
}
static int mecha_auo_panel_blank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
lcm_auo_write_seq(auo_blank_seq, ARRAY_SIZE(auo_blank_seq));
mutex_unlock(&panel_lock);
return 0;
}
static int spade_auo_panel_unblank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
atomic_set(&lcm_init_done, 1);
spade_adjust_backlight(last_val);
return 0;
}
static void mecha_auo_panel_power(bool on_off)
{
if (!!on_off) {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(MECHA_LCD_RSTz, 1);
udelay(500);
gpio_set_value(MECHA_LCD_RSTz, 0);
udelay(500);
gpio_set_value(MECHA_LCD_RSTz, 1);
hr_msleep(20);
panel_gpio_switch(on_off);
} else {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(MECHA_LCD_RSTz, 1);
hr_msleep(70);
panel_gpio_switch(on_off);
}
}
static int amoled_backlight_probe(struct platform_device *pdev)
{
int rc;
amoled_backlight_led.brightness_set = samsung_brightness_set;
rc = led_classdev_register(&pdev->dev, &amoled_backlight_led);
if (rc)
LCMDBG("backlight: failure on register led_classdev\n");
return 0;
}
static int spade_backlight_probe(struct platform_device *pdev)
{
int rc;
rc = led_classdev_register(&pdev->dev, &spade_backlight_led);
if (rc)
LCMDBG("backlight: failure on register led_classdev\n");
return 0;
}
static void spade_brightness_set(struct led_classdev *led_cdev,
enum led_brightness val)
{
if (atomic_read(&lcm_init_done) == 0) {
last_val = val ? val : last_val;
LCMDBG(":lcm not ready, val=%d\n", val);
return;
}
led_cdev->brightness = spade_adjust_backlight(val);
}
static int spade_auo_n90_panel_init(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
spade_auo_panel_power(1);
lcm_auo_write_seq(auo_n90_init_seq, ARRAY_SIZE(auo_n90_init_seq));
mutex_unlock(&panel_lock);
return 0;
}
static int amoled_panel_unblank(struct platform_device *pdev)
{
LCMDBG("%s\n", __func__);
if (samsung_oled_panel_init())
printk(KERN_ERR "samsung_oled_panel_init failed\n");
wake_lock(&panel_idle_lock);
mutex_lock(&panel_lock);
amoled_set_gamma_val(last_level);
/* Display on */
qspi_send_9bit(&unblank_msg);
mutex_unlock(&panel_lock);
wake_unlock(&panel_idle_lock);
LCMDBG("%s: last_level = %d\n", __func__, last_level);
led_trigger_event(amoled_lcd_backlight, LED_FULL);
return 0;
}
static int amoled_panel_blank(struct msm_lcdc_panel_ops *panel_data)
{
LCMDBG("%s\n", __func__);
mutex_lock(&panel_lock);
lcm_write_tb(lcm_standby_seq, ARRAY_SIZE(lcm_standby_seq));
mutex_unlock(&panel_lock);
amoled_panel_power(0);
led_trigger_event(amoled_lcd_backlight, LED_OFF);
return 0;
}
static void spade_auo_panel_power(bool on_off)
{
if (!!on_off) {
LCMDBG("(%d):\n", on_off);
gpio_set_value(SPADE_LCD_RSTz, 1);
udelay(500);
gpio_set_value(SPADE_LCD_RSTz, 0);
udelay(500);
gpio_set_value(SPADE_LCD_RSTz, 1);
hr_msleep(20);
config_gpio_table( display_on_gpio_table,
ARRAY_SIZE(display_on_gpio_table));
} else {
LCMDBG("%s(%d):\n", __func__, on_off);
gpio_set_value(SPADE_LCD_RSTz, 1);
hr_msleep(70);
config_gpio_table( display_off_gpio_table,
ARRAY_SIZE(display_off_gpio_table));
}
}
static int express_smd_panel_uninit(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
express_panel_power(0);
panel_gpio_switch(0);
mutex_unlock(&panel_lock);
return 0;
}
static int spade_sharp_panel_uninit(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
lcm_sharp_write_seq(sharp_uninit_seq, ARRAY_SIZE(sharp_uninit_seq));
spade_sharp_panel_power(0);
screen_on = false;
mutex_unlock(&panel_lock);
return 0;
}
static int amoled_panel_blank(struct msm_lcdc_panel_ops *panel_data)
{
LCMDBG("%s\n", __func__);
mutex_lock(&panel_lock);
qspi_send_9bit(&blank_cmd);
hr_msleep(120);
mutex_unlock(&panel_lock);
amoled_panel_power(0);
led_trigger_event(amoled_lcd_backlight, LED_OFF);
return 0;
}
static int spade_auo_n90_panel_blank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
spade_adjust_backlight(0);
atomic_set(&lcm_init_done, 0);
mutex_lock(&panel_lock);
lcm_auo_write_seq(auo_n90_uninit_seq, ARRAY_SIZE(auo_n90_uninit_seq));
mutex_unlock(&panel_lock);
return 0;
}
static int spade_auo_n90_panel_unblank(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
if (color_enhancement == 0) {
spade_mdp_color_enhancement(mdp_pdata.mdp_dev);
color_enhancement = 1;
}
atomic_set(&lcm_init_done, 1);
spade_adjust_backlight(last_val);
return 0;
}
static int amoled_panel_unblank(struct msm_lcdc_panel_ops *panel_data)
{
LCMDBG("%s\n", __func__);
wake_lock(&panel_idle_lock);
table_sel_idx = 0;
mutex_lock(&panel_lock);
gamma_table_bank_select();
amoled_set_gamma_val(last_val);
qspi_send(0, 0xef);
qspi_send(1, 0xd0);
qspi_send(1, 0xe8);
lcm_write_cmd(0x14, 0x03);
mutex_unlock(&panel_lock);
wake_unlock(&panel_idle_lock);
LCMDBG("%s: last_val = %d\n", __func__,last_val);
led_trigger_event(amoled_lcd_backlight, LED_FULL);
return 0;
}
static int mecha_auo_panel_init(struct msm_lcdc_panel_ops *ops)
{
LCMDBG("\n");
mutex_lock(&panel_lock);
mecha_auo_panel_power(1);
lcm_auo_write_seq(auo_init_seq, ARRAY_SIZE(auo_init_seq));
lcm_auo_write_seq(auo_gamma_normal_seq, ARRAY_SIZE(auo_gamma_normal_seq));
mutex_unlock(&panel_lock);
return 0;
}
