/*
|
* Allwinner SoCs display driver.
|
*
|
* Copyright (C) 2016 Allwinner.
|
*
|
* This file is licensed under the terms of the GNU General Public
|
* License version 2. This program is licensed "as is" without any
|
* warranty of any kind, whether express or implied.
|
*/
|
|
#include "disp_lcd.h"
|
|
struct disp_lcd_private_data {
|
struct disp_lcd_flow open_flow;
|
struct disp_lcd_flow close_flow;
|
struct disp_panel_para panel_info;
|
struct panel_extend_para panel_extend_info;
|
struct panel_extend_para panel_extend_info_set;
|
u32 panel_extend_dirty;
|
struct disp_lcd_cfg lcd_cfg;
|
struct disp_lcd_panel_fun lcd_panel_fun;
|
bool is_bridge;
|
bool enabling;
|
bool disabling;
|
bool bl_enabled;
|
u32 irq_no;
|
u32 irq_no_dsi;
|
u32 irq_no_edp;
|
u32 enabled;
|
u32 power_enabled;
|
u32 bl_need_enabled;
|
u32 frame_per_sec;
|
u32 usec_per_line;
|
u32 judge_line;
|
u32 tri_finish_fail;
|
s32 color_temperature;
|
u32 color_inverse;
|
/*0:reset all module, 1:reset panel only*/
|
u32 esd_reset_level;
|
struct {
|
uintptr_t dev;
|
u32 channel;
|
u32 polarity;
|
u32 period_ns;
|
u32 duty_ns;
|
u32 enabled;
|
} pwm_info;
|
struct clk *clk;
|
struct clk *lvds_clk;
|
struct clk *dsi_clk[CLK_DSI_NUM];
|
struct clk *clk_parent;
|
struct clk *dsi_clk_parent[CLK_DSI_NUM];
|
struct clk *lvds_clk_parent;
|
/*0:no reset process;1:reset request;2:resetting*/
|
atomic_t lcd_resetting;
|
struct work_struct reflush_work;
|
struct disp_lcd_esd_info esd_inf;
|
struct mutex enable_lock;
|
struct plist_head timing_head;
|
struct disp_bridge_fun *bridge;
|
enum disp_tv_mode mode_using;
|
};
|
static spinlock_t lcd_data_lock;
|
|
static struct disp_device *lcds;
|
static struct disp_lcd_private_data *lcd_private;
|
|
struct disp_device *disp_get_lcd(u32 disp)
|
{
|
u32 num_screens;
|
|
num_screens = bsp_disp_feat_get_num_screens();
|
if (disp >= num_screens
|
|| !bsp_disp_feat_is_supported_output_types(disp,
|
DISP_OUTPUT_TYPE_LCD)) {
|
DE_INF("disp %d not support lcd output\n", disp);
|
return NULL;
|
}
|
|
return &lcds[disp];
|
}
|
static struct disp_lcd_private_data *disp_lcd_get_priv(struct disp_device *lcd)
|
{
|
if (lcd == NULL) {
|
DE_WRN("param is NULL!\n");
|
return NULL;
|
}
|
|
return (struct disp_lcd_private_data *)lcd->priv_data;
|
}
|
|
static s32 disp_lcd_is_used(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
s32 ret = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL))
|
ret = 0;
|
else
|
ret = (s32)lcdp->lcd_cfg.lcd_used;
|
|
return ret;
|
}
|
|
static s32 lcd_parse_panel_para(u32 disp, struct disp_panel_para *info)
|
{
|
s32 ret = 0;
|
char primary_key[25];
|
s32 value = 0;
|
|
sprintf(primary_key, "lcd%d", disp);
|
memset(info, 0, sizeof(struct disp_panel_para));
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_x", &value, 1);
|
if (ret == 1)
|
info->lcd_x = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_y", &value, 1);
|
if (ret == 1)
|
info->lcd_y = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_width", &value, 1);
|
if (ret == 1)
|
info->lcd_width = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_height", &value, 1);
|
if (ret == 1)
|
info->lcd_height = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dclk_freq", &value, 1);
|
if (ret == 1)
|
info->lcd_dclk_freq = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_pwm_used", &value, 1);
|
if (ret == 1)
|
info->lcd_pwm_used = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_pwm_ch", &value, 1);
|
if (ret == 1)
|
info->lcd_pwm_ch = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_pwm_freq", &value, 1);
|
if (ret == 1)
|
info->lcd_pwm_freq = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_pwm_pol", &value, 1);
|
if (ret == 1)
|
info->lcd_pwm_pol = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_if", &value, 1);
|
if (ret == 1)
|
info->lcd_if = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_tcon_div", &value, 1);
|
if (ret == 1)
|
info->lcd_tcon_div = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_hbp", &value, 1);
|
if (ret == 1)
|
info->lcd_hbp = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_ht", &value, 1);
|
if (ret == 1)
|
info->lcd_ht = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_vbp", &value, 1);
|
if (ret == 1)
|
info->lcd_vbp = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_vt", &value, 1);
|
if (ret == 1)
|
info->lcd_vt = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_hv_if", &value, 1);
|
if (ret == 1)
|
info->lcd_hv_if = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_vspw", &value, 1);
|
if (ret == 1)
|
info->lcd_vspw = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_hspw", &value, 1);
|
if (ret == 1)
|
info->lcd_hspw = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_lvds_if", &value, 1);
|
if (ret == 1)
|
info->lcd_lvds_if = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_lvds_mode", &value, 1);
|
if (ret == 1)
|
info->lcd_lvds_mode = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_lvds_colordepth", &value,
|
1);
|
if (ret == 1)
|
info->lcd_lvds_colordepth = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_lvds_io_polarity",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_lvds_io_polarity = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_cpu_if", &value, 1);
|
if (ret == 1)
|
info->lcd_cpu_if = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_cpu_te", &value, 1);
|
if (ret == 1)
|
info->lcd_cpu_te = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_cpu_mode", &value, 1);
|
if (ret == 1)
|
info->lcd_cpu_mode = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_frm", &value, 1);
|
if (ret == 1)
|
info->lcd_frm = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dsi_if", &value, 1);
|
if (ret == 1)
|
info->lcd_dsi_if = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dsi_lane", &value, 1);
|
if (ret == 1)
|
info->lcd_dsi_lane = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_dsi_format", &value, 1);
|
if (ret == 1)
|
info->lcd_dsi_format = value;
|
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dsi_eotp", &value, 1);
|
if (ret == 1)
|
info->lcd_dsi_eotp = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dsi_te", &value, 1);
|
if (ret == 1)
|
info->lcd_dsi_te = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_dsi_port_num",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_dsi_port_num = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_tcon_mode", &value, 1);
|
if (ret == 1)
|
info->lcd_tcon_mode = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_slave_tcon_num",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_slave_tcon_num = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_slave_stop_pos",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_slave_stop_pos = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_sync_pixel_num",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_sync_pixel_num = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_sync_line_num",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_sync_line_num = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_tcon_en_odd_even_div",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_tcon_en_odd_even = value;
|
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_fsync_en", &value, 1);
|
if (ret == 1)
|
info->lcd_fsync_en = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_fsync_act_time", &value, 1);
|
if (ret == 1)
|
info->lcd_fsync_act_time = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_fsync_dis_time", &value, 1);
|
if (ret == 1)
|
info->lcd_fsync_dis_time = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_fsync_pol", &value,
|
1);
|
if (ret == 1)
|
info->lcd_fsync_pol = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_hv_clk_phase", &value,
|
1);
|
if (ret == 1)
|
info->lcd_hv_clk_phase = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_hv_sync_polarity",
|
&value, 1);
|
if (ret == 1)
|
info->lcd_hv_sync_polarity = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_hv_srgb_seq", &value, 1);
|
if (ret == 1)
|
info->lcd_hv_srgb_seq = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_rb_swap", &value, 1);
|
if (ret == 1)
|
info->lcd_rb_swap = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_hv_syuv_seq", &value, 1);
|
if (ret == 1)
|
info->lcd_hv_syuv_seq = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_hv_syuv_fdly", &value,
|
1);
|
if (ret == 1)
|
info->lcd_hv_syuv_fdly = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_gamma_en", &value, 1);
|
if (ret == 1)
|
info->lcd_gamma_en = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_cmap_en", &value, 1);
|
if (ret == 1)
|
info->lcd_cmap_en = value;
|
|
ret = disp_sys_script_get_item(primary_key, "lcd_xtal_freq", &value, 1);
|
if (ret == 1)
|
info->lcd_xtal_freq = value;
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_size",
|
(int *)info->lcd_size, 2);
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_model_name",
|
(int *)info->lcd_model_name, 2);
|
|
return 0;
|
}
|
|
static void lcd_get_sys_config(u32 disp, struct disp_lcd_cfg *lcd_cfg)
|
{
|
struct disp_gpio_set_t *gpio_info;
|
int value = 1;
|
char primary_key[20], sub_name[25];
|
int i = 0;
|
int ret;
|
|
sprintf(primary_key, "lcd%d", disp);
|
/* lcd_used */
|
ret = disp_sys_script_get_item(primary_key, "lcd_used", &value, 1);
|
if (ret == 1)
|
lcd_cfg->lcd_used = value;
|
|
if (lcd_cfg->lcd_used == 0)
|
return;
|
|
/* lcd_bl_en */
|
lcd_cfg->lcd_bl_en_used = 0;
|
gpio_info = &(lcd_cfg->lcd_bl_en);
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_bl_en", (int *)gpio_info,
|
3);
|
if (ret == 3)
|
lcd_cfg->lcd_bl_en_used = 1;
|
|
sprintf(sub_name, "lcd_bl_en_power");
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)lcd_cfg->lcd_bl_en_power, 2);
|
|
/* lcd fix power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (i == 0)
|
sprintf(sub_name, "lcd_fix_power");
|
else
|
sprintf(sub_name, "lcd_fix_power%d", i);
|
lcd_cfg->lcd_power_used[i] = 0;
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)(lcd_cfg->lcd_fix_power[i]),
|
2);
|
if (ret == 2)
|
/* str */
|
lcd_cfg->lcd_fix_power_used[i] = 1;
|
}
|
|
/* lcd_power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (i == 0)
|
sprintf(sub_name, "lcd_power");
|
else
|
sprintf(sub_name, "lcd_power%d", i);
|
lcd_cfg->lcd_power_used[i] = 0;
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)(lcd_cfg->lcd_power[i]), 2);
|
if (ret == 2)
|
/* str */
|
lcd_cfg->lcd_power_used[i] = 1;
|
}
|
|
/* lcd_gpio */
|
for (i = 0; i < 6; i++) {
|
sprintf(sub_name, "lcd_gpio_%d", i);
|
|
gpio_info = &(lcd_cfg->lcd_gpio[i]);
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)gpio_info, 3);
|
if (ret == 3)
|
lcd_cfg->lcd_gpio_used[i] = 1;
|
}
|
|
/* lcd_gpio_scl,lcd_gpio_sda */
|
gpio_info = &(lcd_cfg->lcd_gpio[LCD_GPIO_SCL]);
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_gpio_scl",
|
(int *)gpio_info, 3);
|
if (ret == 3)
|
lcd_cfg->lcd_gpio_used[LCD_GPIO_SCL] = 1;
|
gpio_info = &(lcd_cfg->lcd_gpio[LCD_GPIO_SDA]);
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_gpio_sda",
|
(int *)gpio_info, 3);
|
if (ret == 3)
|
lcd_cfg->lcd_gpio_used[LCD_GPIO_SDA] = 1;
|
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
sprintf(sub_name, "lcd_gpio_power%d", i);
|
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)lcd_cfg->lcd_gpio_power[i],
|
2);
|
}
|
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
if (i == 0)
|
sprintf(sub_name, "lcd_pin_power");
|
else
|
sprintf(sub_name, "lcd_pin_power%d", i);
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name,
|
(int *)lcd_cfg->lcd_pin_power[i],
|
2);
|
}
|
|
sprintf(sub_name, "lcd_pwm_max_limit");
|
ret = disp_sys_script_get_item(primary_key, sub_name, &value, 1);
|
if (ret == 1) {
|
lcd_cfg->lcd_pwm_max_limit = value;
|
} else {
|
lcd_cfg->lcd_pwm_max_limit = 255;
|
}
|
|
/* backlight adjust */
|
for (i = 0; i < 101; i++) {
|
sprintf(sub_name, "lcd_bl_%d_percent", i);
|
lcd_cfg->backlight_curve_adjust[i] = 0;
|
|
if (i == 100)
|
lcd_cfg->backlight_curve_adjust[i] = lcd_cfg->lcd_pwm_max_limit;
|
|
ret =
|
disp_sys_script_get_item(primary_key, sub_name, &value, 1);
|
if (ret == 1) {
|
value = (value > 100) ? 100 : value;
|
value = value * lcd_cfg->lcd_pwm_max_limit / 100;
|
lcd_cfg->backlight_curve_adjust[i] = value;
|
}
|
}
|
|
sprintf(sub_name, "lcd_backlight");
|
ret = disp_sys_script_get_item(primary_key, sub_name, &value, 1);
|
if (ret == 1) {
|
value = (value > lcd_cfg->lcd_pwm_max_limit) ? lcd_cfg->lcd_pwm_max_limit : value;
|
lcd_cfg->backlight_bright = value;
|
} else {
|
lcd_cfg->backlight_bright = 197;
|
}
|
|
}
|
|
static s32 lcd_clk_init(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
s32 i = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
DE_INF("lcd %d clk init\n", lcd->disp);
|
|
lcdp->clk_parent = clk_get_parent(lcdp->clk);
|
lcdp->lvds_clk_parent = clk_get_parent(lcdp->lvds_clk);
|
for (i = 0; i < CLK_DSI_NUM; ++i) {
|
lcdp->dsi_clk_parent[i] = clk_get_parent(lcdp->dsi_clk[i]);
|
}
|
|
return DIS_SUCCESS;
|
}
|
|
static s32 lcd_clk_exit(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
if (lcdp->clk_parent)
|
clk_put(lcdp->clk_parent);
|
|
return DIS_SUCCESS;
|
}
|
|
/**
|
* @name :cal_real_frame_period
|
* @brief :set lcd->timings.frame_period (nsec)
|
* ,lcd->timings.start_delay (line)
|
* and lcd->timings.dclk_rate_set(hz)
|
* @param :lcd:pointer of disp_device
|
* @return :0 if success, other fail
|
*/
|
static s32 cal_real_frame_period(struct disp_device *lcd)
|
{
|
s32 ret = -1;
|
struct disp_lcd_private_data *lcdp;
|
struct lcd_clk_info clk_info;
|
unsigned long long temp = 0;
|
|
if (!lcd) {
|
DE_WRN("NULL hdl!\n");
|
goto OUT;
|
}
|
|
lcdp = disp_lcd_get_priv(lcd);
|
|
if (!lcdp) {
|
DE_WRN("NULL hdl!\n");
|
goto OUT;
|
}
|
|
memset(&clk_info, 0, sizeof(struct lcd_clk_info));
|
disp_al_lcd_get_clk_info(lcd->hwdev_index, &clk_info,
|
&lcdp->panel_info);
|
printk("kickpi %s:%d \n", __func__, __LINE__);
|
if (!lcdp->clk || !(&lcdp->panel_info)) {
|
DE_WRN("NULL clk or panel_info!\n");
|
goto OUT;
|
}
|
|
if (lcdp->panel_info.lcd_if == LCD_IF_DSI)
|
lcd->timings.dclk_rate_set =
|
clk_get_rate(lcdp->clk) / clk_info.dsi_div;
|
else
|
lcd->timings.dclk_rate_set =
|
clk_get_rate(lcdp->clk) / clk_info.tcon_div;
|
|
if (lcd->timings.dclk_rate_set == 0) {
|
DE_WRN("lcd dclk_rate_set is 0!\n");
|
ret = -2;
|
goto OUT;
|
}
|
|
temp = ONE_SEC * lcdp->panel_info.lcd_ht * lcdp->panel_info.lcd_vt;
|
|
do_div(temp, lcd->timings.dclk_rate_set);
|
|
lcd->timings.frame_period = temp;
|
|
lcd->timings.start_delay =
|
disp_al_lcd_get_start_delay(lcd->hwdev_index, &lcdp->panel_info);
|
|
DE_INF("lcd frame period:%llu\n", lcd->timings.frame_period);
|
|
ret = 0;
|
OUT:
|
return ret;
|
}
|
|
static s32 lcd_clk_config(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
struct lcd_clk_info clk_info;
|
unsigned long pll_rate = 297000000, lcd_rate = 33000000;
|
unsigned long dclk_rate = 33000000, dsi_rate = 0; /* hz */
|
unsigned long pll_rate_set = 297000000, lcd_rate_set = 33000000;
|
unsigned long dclk_rate_set = 33000000, dsi_rate_set = 0; /* hz */
|
u32 i = 0, j = 0;
|
u32 dsi_num = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
memset(&clk_info, 0, sizeof(struct lcd_clk_info));
|
if (lcdp->panel_info.lcd_tcon_div != 0)
|
clk_info.tcon_div = lcdp->panel_info.lcd_tcon_div;
|
disp_al_lcd_get_clk_info(lcd->hwdev_index, &clk_info,
|
&lcdp->panel_info);
|
printk("kickpi %s:%d \n", __func__, __LINE__);
|
dclk_rate = lcdp->panel_info.lcd_dclk_freq * 1000000; /* Mhz -> hz */
|
if (lcdp->panel_info.lcd_if == LCD_IF_DSI) {
|
lcd_rate = dclk_rate * clk_info.dsi_div;
|
pll_rate = lcd_rate * clk_info.lcd_div;
|
} else {
|
lcd_rate = dclk_rate * clk_info.tcon_div;
|
pll_rate = lcd_rate * clk_info.lcd_div;
|
}
|
dsi_rate = pll_rate / clk_info.dsi_div;
|
|
if (lcdp->clk_parent && lcdp->clk) {
|
clk_set_parent(lcdp->clk, lcdp->clk_parent);
|
clk_set_rate(lcdp->clk_parent, pll_rate);
|
pll_rate_set = clk_get_rate(lcdp->clk_parent);
|
}
|
if (lcdp->lvds_clk_parent && lcdp->lvds_clk)
|
clk_set_parent(lcdp->lvds_clk, lcdp->lvds_clk_parent);
|
for (i = 0; i < CLK_DSI_NUM; ++i) {
|
if (lcdp->dsi_clk_parent[i] && lcdp->dsi_clk[i])
|
clk_set_parent(lcdp->dsi_clk[i],
|
lcdp->dsi_clk_parent[i]);
|
}
|
|
if (clk_info.lcd_div)
|
lcd_rate_set = pll_rate_set / clk_info.lcd_div;
|
else
|
lcd_rate_set = pll_rate_set;
|
|
msleep(100);
|
clk_set_rate(lcdp->clk, lcd_rate_set);
|
lcd_rate_set = clk_get_rate(lcdp->clk);
|
if (lcdp->panel_info.lcd_if == LCD_IF_DSI) {
|
if (lcdp->panel_info.lcd_dsi_if == LCD_DSI_IF_COMMAND_MODE)
|
dsi_rate_set = pll_rate_set;
|
else
|
dsi_rate_set = pll_rate_set / clk_info.dsi_div;
|
dsi_rate_set =
|
(clk_info.dsi_rate == 0) ? dsi_rate_set : clk_info.dsi_rate;
|
dsi_num = (lcdp->panel_info.lcd_tcon_mode == DISP_TCON_DUAL_DSI)
|
? 2
|
: 1;
|
dsi_rate_set /= dsi_num;
|
/* total number of dsi clk for current disp device*/
|
dsi_num *= CLK_NUM_PER_DSI;
|
/*In the case of CLK_NUM_PER_DSI equal to 2*/
|
/*even index mean hs clk which need to be seted*/
|
/*odd index mean lp clk which no need to be seted*/
|
for (i = dsi_num * lcd->disp, j = 0; i < CLK_DSI_NUM;
|
i += CLK_NUM_PER_DSI) {
|
if (lcdp->dsi_clk[i]) {
|
clk_set_rate(lcdp->dsi_clk[i], dsi_rate_set);
|
DE_INF(
|
"clk_set_rate:dsi's %d th clk with %ld\n",
|
i, dsi_rate_set);
|
j += CLK_NUM_PER_DSI;
|
}
|
if (j == dsi_num)
|
break;
|
}
|
/*FIXME, dsi clk0 = dsi clk1(rate)*/
|
/*disp_sys_clk_set_rate(lcdp->dsi_clk[1], dsi_rate_set);*/
|
}
|
dclk_rate_set = lcd_rate_set / clk_info.tcon_div;
|
if ((pll_rate_set != pll_rate) || (lcd_rate_set != lcd_rate)
|
|| (dclk_rate_set != dclk_rate)) {
|
DE_WRN
|
("disp %d, clk: pll(%ld),clk(%ld),dclk(%ld) dsi_rate(%ld)\n clk real:pll(%ld),clk(%ld),dclk(%ld) dsi_rate(%ld)\n",
|
lcd->disp, pll_rate, lcd_rate, dclk_rate, dsi_rate,
|
pll_rate_set, lcd_rate_set, dclk_rate_set, dsi_rate_set);
|
}
|
|
return 0;
|
}
|
|
static s32 lcd_clk_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int ret = 0;
|
u32 i = 0, j = 0;
|
u32 dsi_num = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
lcd_clk_config(lcd);
|
|
|
if (!__clk_get_enable_count(lcdp->clk)) {
|
ret = clk_prepare_enable(lcdp->clk);
|
if (ret != 0) {
|
DE_WRN("fail enable lcd's clock!\n");
|
goto exit;
|
}
|
}
|
|
if (lcdp->panel_info.lcd_if == LCD_IF_LVDS) {
|
if (lcdp->lvds_clk)
|
ret = clk_prepare_enable(lcdp->lvds_clk);
|
if (ret != 0) {
|
DE_WRN("fail enable lvds's clock!\n");
|
goto exit;
|
}
|
#ifdef SUPPORT_COMBO_DPHY
|
if (lcd->hwdev_index == 0)
|
clk_prepare_enable(lcdp->dsi_clk[0]);
|
#endif
|
} else if (lcdp->panel_info.lcd_if == LCD_IF_DSI) {
|
dsi_num = (lcdp->panel_info.lcd_tcon_mode == DISP_TCON_DUAL_DSI)
|
? 2
|
: 1;
|
/*the num of dsi clk to use for current disp*/
|
dsi_num *= CLK_NUM_PER_DSI;
|
|
for (i = dsi_num * lcd->disp, j = 0; i < CLK_DSI_NUM; ++i) {
|
if (lcdp->dsi_clk[i]) {
|
ret = clk_prepare_enable(lcdp->dsi_clk[i]);
|
if (ret != 0) {
|
DE_WRN("fail enable dsi's clock%d!\n",
|
i);
|
goto exit;
|
}
|
++j;
|
} else {
|
DE_WRN("dsi's clock%d is NULL!\n", i);
|
goto exit;
|
}
|
if (j == dsi_num)
|
break;
|
}
|
}
|
|
exit:
|
return ret;
|
}
|
|
static s32 lcd_clk_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
u32 i = 0, j = 0;
|
u32 dsi_num = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
if (lcdp->panel_info.lcd_if == LCD_IF_LVDS) {
|
clk_disable(lcdp->lvds_clk);
|
#ifdef SUPPORT_COMBO_DPHY
|
if (lcd->hwdev_index == 0)
|
clk_disable(lcdp->dsi_clk[0]);
|
#endif
|
} else if (lcdp->panel_info.lcd_if == LCD_IF_DSI) {
|
dsi_num = (lcdp->panel_info.lcd_tcon_mode == DISP_TCON_DUAL_DSI)
|
? 2
|
: 1;
|
/*the num of dsi clk to use for current disp*/
|
dsi_num *= CLK_NUM_PER_DSI;
|
for (i = dsi_num * lcd->disp, j = 0; i < CLK_DSI_NUM; ++i) {
|
if (lcdp->dsi_clk[i])
|
clk_disable(lcdp->dsi_clk[i]);
|
++j;
|
if (j == dsi_num)
|
break;
|
}
|
}
|
|
if (__clk_get_enable_count(lcdp->clk))
|
clk_disable(lcdp->clk);
|
|
return DIS_SUCCESS;
|
}
|
|
static int lcd_calc_judge_line(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
if (lcdp->usec_per_line == 0) {
|
struct disp_panel_para *panel_info = &lcdp->panel_info;
|
/*
|
* usec_per_line = 1 / fps / vt * 1000000
|
* = 1 / (dclk * 1000000 / vt / ht) / vt * 1000000
|
* = ht / dclk(Mhz)
|
*/
|
lcdp->usec_per_line = panel_info->lcd_ht
|
/ panel_info->lcd_dclk_freq;
|
}
|
|
if (lcdp->judge_line == 0) {
|
int start_delay = disp_al_lcd_get_start_delay(lcd->hwdev_index,
|
&lcdp->
|
panel_info);
|
int usec_start_delay = start_delay * lcdp->usec_per_line;
|
int usec_judge_point;
|
|
if (usec_start_delay <= 200)
|
usec_judge_point = usec_start_delay * 3 / 7;
|
else if (usec_start_delay <= 400)
|
usec_judge_point = usec_start_delay / 2;
|
else
|
usec_judge_point = 200;
|
lcdp->judge_line = usec_judge_point / lcdp->usec_per_line;
|
}
|
|
return 0;
|
}
|
|
#ifdef EINK_FLUSH_TIME_TEST
|
struct timeval lcd_start, lcd_mid, lcd_mid1, lcd_mid2, lcd_end, t5_b, t5_e;
|
struct timeval pin_b, pin_e, po_b, po_e, tocn_b, tcon_e;
|
unsigned int lcd_t1 = 0, lcd_t2 = 0, lcd_t3 = 0, lcd_t4 = 0, lcd_t5 = 0;
|
unsigned int lcd_pin, lcd_po, lcd_tcon;
|
#endif
|
|
extern int sunxi_get_soc_chipid_str(char *serial);
|
|
static s32 disp_lcd_speed_limit(struct disp_panel_para *panel, u32 *min_dclk,
|
u32 *max_dclk)
|
{
|
char id[17] = "";
|
unsigned long value = 0;
|
unsigned int qa_val = 0;
|
unsigned int ic_ver = 0, display_cfg_flag = 0;
|
|
/*init unlimit*/
|
*min_dclk = 0;
|
*max_dclk = 9999;
|
|
#if defined(CONFIG_ARCH_SUN50IW10)
|
qa_val = readl(ioremap(0x0300621c, 4));
|
qa_val = (qa_val >> 28) & 0x00000003;
|
ic_ver = readl(ioremap(0x03000024, 4)) & 0x00000007;
|
display_cfg_flag = (readl(ioremap(0x03006218, 4)) >> 12) & 0x00000001;
|
sunxi_get_soc_chipid_str(id);
|
|
if (qa_val >= 2 && panel->lcd_if == LCD_IF_DSI) {
|
/*bad IC not support DSI*/
|
*min_dclk = 9999;
|
*max_dclk = 0;
|
goto OUT;
|
}
|
|
if (!kstrtoul(id, 16, &value)) {
|
|
switch (value) {
|
case 0x3c00: /*A53*/
|
{
|
if (panel->lcd_if == LCD_IF_DSI) {
|
if (qa_val == 0)
|
*min_dclk = 40; /*1024*600@60*/
|
/* normal qa and B/C ic */
|
if (qa_val == 1 && ic_ver == 0) {
|
*min_dclk = 64; /*1280*720@60*/
|
}
|
/*ic version after e*/
|
if (ic_ver >= 4)
|
*min_dclk = 0;
|
}
|
|
*max_dclk = 200; /*1280*720@60*/
|
} break;
|
case 0x0400: /*A100*/
|
{
|
if (panel->lcd_if == LCD_IF_DSI) {
|
if (qa_val == 0)
|
*min_dclk = 40; /*1024*600@60*/
|
/* normal qa and B/C ic */
|
if (qa_val == 1 && ic_ver == 0) {
|
*min_dclk = 64; /*1280*720@60*/
|
}
|
/*ic version after e*/
|
if (ic_ver >= 4)
|
*min_dclk = 0;
|
}
|
|
*max_dclk = 200; /*1280*720@60*/
|
} break;
|
case 0x1400: /*A133*/
|
{
|
if (panel->lcd_if == LCD_IF_DSI) {
|
if ((qa_val == 0 && ic_ver == 0) ||
|
(qa_val == 1 && ic_ver == 3)) {
|
/*D 01 or B/C 00*/
|
*min_dclk = 40;
|
} else if (qa_val == 1 && ic_ver == 0) {
|
/*B/C 01*/
|
*min_dclk = 64; /*1280*720@60*/
|
}
|
/*ic version after e*/
|
if (ic_ver >= 4)
|
*min_dclk = 0;
|
}
|
*max_dclk = 200; /*1920*1200@60*/
|
} break;
|
case 0x1000: /*R818/MR813*/
|
case 0x2000: {
|
/*not bad ic*/
|
*max_dclk = 200; /*1920*1200@60*/
|
} break;
|
case 0x0800: { /*T509*/
|
if (panel->lcd_if == LCD_IF_DSI) {
|
if (qa_val == 0 && ic_ver == 0)
|
*min_dclk = 40;/*1024*600@60*/
|
else
|
*min_dclk = 0;
|
}
|
*max_dclk = 200; /*1920*1200@60*/
|
} break;
|
case 0x4000: { /*not support*/
|
*min_dclk = 9999;
|
*max_dclk = 0;
|
}
|
break;
|
default:
|
break;
|
}
|
}
|
#endif
|
|
OUT:
|
/*unlimit */
|
return 0;
|
}
|
|
static s32 disp_lcd_tcon_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
u32 min_dclk = 0, max_dclk = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
disp_lcd_speed_limit(&lcdp->panel_info, &min_dclk, &max_dclk);
|
|
if (lcdp->panel_info.lcd_dclk_freq < min_dclk ||
|
lcdp->panel_info.lcd_dclk_freq > max_dclk) {
|
return 0;
|
}
|
|
return disp_al_lcd_enable(lcd->hwdev_index, &lcdp->panel_info);
|
}
|
|
s32 disp_lcd_tcon_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
return disp_al_lcd_disable(lcd->hwdev_index, &lcdp->panel_info);
|
}
|
|
static s32 disp_lcd_pin_cfg(struct disp_device *lcd, u32 bon)
|
{
|
int i;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
char dev_name[25];
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
DE_INF("lcd %d pin config, state %s, %d\n", lcd->disp,
|
(bon) ? "on" : "off", bon);
|
|
/* io-pad */
|
if (bon == 1) {
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], ""))
|
||
|
(!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.
|
lcd_pin_power[i]);
|
}
|
}
|
|
sprintf(dev_name, "lcd%d", lcd->disp);
|
disp_sys_pin_set_state(dev_name,
|
(bon == 1) ?
|
DISP_PIN_STATE_ACTIVE : DISP_PIN_STATE_SLEEP);
|
|
disp_al_lcd_io_cfg(lcd->hwdev_index, bon, &lcdp->panel_info);
|
|
if (bon == 0) {
|
for (i = LCD_GPIO_REGU_NUM - 1; i >= 0; i--) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], ""))
|
||
|
(!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], "none"))))
|
disp_sys_power_disable(lcdp->lcd_cfg.
|
lcd_pin_power[i]);
|
}
|
}
|
|
return DIS_SUCCESS;
|
}
|
|
#if defined(CONFIG_FPGA_V4_PLATFORM) && defined(SUPPORT_EINK)
|
static s32 disp_lcd_pwm_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
unsigned long reg = 0;
|
unsigned long val = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_used(lcd) && lcdp->pwm_info.dev) {
|
reg = ((unsigned long)0xf1c20878);
|
val = readl(reg);
|
val = val & 0xfff0ffff;
|
val = val | 0x10000;
|
writel(val, reg);
|
reg = ((unsigned long)0xf1c2087C);
|
val = readl(reg);
|
val = val & 0xefffffff;
|
val = val | 0x10000000;
|
writel(val, reg);
|
return 0;
|
}
|
DE_WRN("pwm device hdl is NULL\n");
|
return DIS_FAIL;
|
}
|
static s32 disp_lcd_pwm_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long reg = 0;
|
unsigned long val = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_used(lcd) && lcdp->pwm_info.dev) {
|
reg = ((unsigned long)0xf1c20878);
|
val = readl(reg);
|
val = val & 0xfff0ffff;
|
val = val | 0x10000;
|
writel(val, reg);
|
reg = ((unsigned long)0xf1c2087C);
|
val = readl(reg);
|
val = val & 0xefffffff;
|
val = val | 0x00000000;
|
writel(val, reg);
|
return 0;
|
}
|
DE_WRN("pwm device hdl is NULL\n");
|
return DIS_FAIL;
|
}
|
#else
|
static s32 disp_lcd_pwm_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
if (disp_lcd_is_used(lcd) && lcdp->pwm_info.dev)
|
return disp_sys_pwm_enable(lcdp->pwm_info.dev);
|
/*DE_WRN("pwm device hdl is NULL\n");*/
|
|
return DIS_FAIL;
|
}
|
|
static s32 disp_lcd_pwm_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
s32 ret = -1;
|
struct pwm_device *pwm_dev;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
if (disp_lcd_is_used(lcd) && lcdp->pwm_info.dev) {
|
ret = disp_sys_pwm_disable(lcdp->pwm_info.dev);
|
pwm_dev = (struct pwm_device *)lcdp->pwm_info.dev;
|
/*following is for reset pwm state purpose*/
|
disp_sys_pwm_config(lcdp->pwm_info.dev,
|
pwm_dev->state.duty_cycle - 1,
|
pwm_dev->state.period);
|
disp_sys_pwm_set_polarity(lcdp->pwm_info.dev,
|
!lcdp->pwm_info.polarity);
|
return ret;
|
}
|
DE_WRN("pwm device hdl is NULL\n");
|
|
return DIS_FAIL;
|
}
|
#endif
|
|
static s32 disp_lcd_backlight_enable(struct disp_device *lcd)
|
{
|
struct disp_gpio_set_t gpio_info[1];
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->bl_enabled) {
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return -EBUSY;
|
}
|
|
lcdp->bl_need_enabled = 1;
|
lcdp->bl_enabled = true;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
if (disp_lcd_is_used(lcd)) {
|
unsigned bl;
|
|
if (lcdp->lcd_cfg.lcd_bl_en_used) {
|
/* io-pad */
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, ""))
|
||
|
(!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.
|
lcd_bl_en_power);
|
|
memcpy(gpio_info, &(lcdp->lcd_cfg.lcd_bl_en),
|
sizeof(struct disp_gpio_set_t));
|
|
lcdp->lcd_cfg.lcd_bl_gpio_hdl =
|
disp_sys_gpio_request(gpio_info, 1);
|
}
|
bl = disp_lcd_get_bright(lcd);
|
disp_lcd_set_bright(lcd, bl);
|
}
|
|
return 0;
|
}
|
|
static s32 disp_lcd_backlight_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (!lcdp->bl_enabled) {
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return -EBUSY;
|
}
|
|
lcdp->bl_enabled = false;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
if (disp_lcd_is_used(lcd)) {
|
if (lcdp->lcd_cfg.lcd_bl_en_used) {
|
disp_sys_gpio_release(lcdp->lcd_cfg.lcd_bl_gpio_hdl, 2);
|
|
/* io-pad */
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, ""))
|
||
|
(!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, "none"))))
|
disp_sys_power_disable(lcdp->lcd_cfg.
|
lcd_bl_en_power);
|
}
|
}
|
|
return 0;
|
}
|
|
#if defined(CONFIG_FPGA_V4_PLATFORM) && defined(SUPPORT_EINK)
|
static s32 disp_lcd_power_enable(struct disp_device *lcd, u32 power_id)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long reg = 0;
|
unsigned long val = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_used(lcd)) {
|
reg = ((unsigned long)0xf1c20878);
|
val = readl(reg);
|
val = val & 0x000fffff;
|
val = val | 0x11100000;
|
writel(val, reg);
|
reg = ((unsigned long)0xf1c2087C);
|
val = readl(reg);
|
val = val & 0x1fffffff;
|
val = val | 0xe0000000;
|
writel(val, reg);
|
return 0;
|
}
|
return DIS_FAIL;
|
}
|
static s32 disp_lcd_power_disable(struct disp_device *lcd, u32 power_id)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long reg = 0;
|
unsigned long val = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_used(lcd)) {
|
reg = ((unsigned long)0xf1c20878);
|
val = readl(reg);
|
val = val & 0x000fffff;
|
val = val | 0x77700000;
|
writel(val, reg);
|
return 0;
|
}
|
return DIS_FAIL;
|
}
|
#else
|
static s32 disp_lcd_power_enable(struct disp_device *lcd, u32 power_id)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
if (disp_lcd_is_used(lcd)) {
|
if (lcdp->lcd_cfg.lcd_power_used[power_id] == 1) {
|
/* regulator type */
|
disp_sys_power_enable(lcdp->lcd_cfg.
|
lcd_power[power_id]);
|
}
|
}
|
|
return 0;
|
}
|
|
static s32 disp_lcd_power_disable(struct disp_device *lcd, u32 power_id)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
if (disp_lcd_is_used(lcd)) {
|
if (lcdp->lcd_cfg.lcd_power_used[power_id] == 1) {
|
/* regulator type */
|
disp_sys_power_disable(lcdp->lcd_cfg.
|
lcd_power[power_id]);
|
}
|
}
|
|
return 0;
|
}
|
#endif
|
|
static s32 disp_lcd_bright_get_adjust_value(struct disp_device *lcd, u32 bright)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
bright = (bright > 255) ? 255 : bright;
|
return lcdp->panel_extend_info.lcd_bright_curve_tbl[bright];
|
}
|
|
static s32 disp_lcd_bright_curve_init(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
u32 i = 0, j = 0;
|
u32 items = 0;
|
u32 lcd_bright_curve_tbl[101][2];
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
for (i = 0; i < 101; i++) {
|
if (lcdp->lcd_cfg.backlight_curve_adjust[i] == 0) {
|
if (i == 0) {
|
lcd_bright_curve_tbl[items][0] = 0;
|
lcd_bright_curve_tbl[items][1] = 0;
|
items++;
|
}
|
} else {
|
lcd_bright_curve_tbl[items][0] = 255 * i / 100;
|
lcd_bright_curve_tbl[items][1] =
|
lcdp->lcd_cfg.backlight_curve_adjust[i];
|
items++;
|
}
|
}
|
|
for (i = 0; i < items - 1; i++) {
|
u32 num =
|
lcd_bright_curve_tbl[i + 1][0] - lcd_bright_curve_tbl[i][0];
|
|
for (j = 0; j < num; j++) {
|
u32 value = 0;
|
|
value =
|
lcd_bright_curve_tbl[i][1] +
|
((lcd_bright_curve_tbl[i + 1][1] -
|
lcd_bright_curve_tbl[i][1]) * j) / num;
|
lcdp->panel_extend_info.
|
lcd_bright_curve_tbl[lcd_bright_curve_tbl[i][0] +
|
j] = value;
|
}
|
}
|
lcdp->panel_extend_info.lcd_bright_curve_tbl[255] =
|
lcd_bright_curve_tbl[items - 1][1];
|
|
return 0;
|
}
|
|
s32 disp_lcd_set_bright(struct disp_device *lcd, u32 bright)
|
{
|
u32 duty_ns;
|
__u64 backlight_bright = bright;
|
__u64 backlight_dimming;
|
__u64 period_ns;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
bool bright_update = false;
|
struct disp_manager *mgr = NULL;
|
struct disp_smbl *smbl = NULL;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
smbl = mgr->smbl;
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
backlight_bright = (backlight_bright > 255) ? 255 : backlight_bright;
|
if (lcdp->lcd_cfg.backlight_bright != backlight_bright) {
|
bright_update = true;
|
lcdp->lcd_cfg.backlight_bright = backlight_bright;
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (bright_update && smbl)
|
smbl->update_backlight(smbl, backlight_bright);
|
|
if (lcdp->pwm_info.dev) {
|
if (backlight_bright != 0)
|
backlight_bright += 1;
|
backlight_bright =
|
disp_lcd_bright_get_adjust_value(lcd, backlight_bright);
|
|
lcdp->lcd_cfg.backlight_dimming =
|
(lcdp->lcd_cfg.backlight_dimming ==
|
0) ? 256 : lcdp->lcd_cfg.backlight_dimming;
|
backlight_dimming = lcdp->lcd_cfg.backlight_dimming;
|
period_ns = lcdp->pwm_info.period_ns;
|
duty_ns =
|
(backlight_bright * backlight_dimming * period_ns / 256 +
|
128) / 256;
|
lcdp->pwm_info.duty_ns = duty_ns;
|
disp_sys_pwm_config(lcdp->pwm_info.dev, duty_ns, period_ns);
|
}
|
|
if (lcdp->lcd_panel_fun.set_bright && lcdp->enabled) {
|
lcdp->lcd_panel_fun.set_bright(lcd->disp,
|
disp_lcd_bright_get_adjust_value
|
(lcd, bright));
|
}
|
|
return DIS_SUCCESS;
|
}
|
|
s32 disp_lcd_get_bright(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
return lcdp->lcd_cfg.backlight_bright;
|
}
|
|
static s32 disp_lcd_set_bright_dimming(struct disp_device *lcd, u32 dimming)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
u32 bl = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
dimming = dimming > 256 ? 256 : dimming;
|
lcdp->lcd_cfg.backlight_dimming = dimming;
|
bl = disp_lcd_get_bright(lcd);
|
disp_lcd_set_bright(lcd, bl);
|
|
return DIS_SUCCESS;
|
}
|
|
static s32 disp_lcd_get_panel_info(struct disp_device *lcd,
|
struct disp_panel_para *info)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
memcpy(info, (struct disp_panel_para *) (&(lcdp->panel_info)),
|
sizeof(struct disp_panel_para));
|
return 0;
|
}
|
|
#if defined(__LINUX_PLAT__)
|
static s32 disp_lcd_event_proc(int irq, void *parg)
|
#else
|
static s32 disp_lcd_event_proc(void *parg)
|
#endif
|
{
|
struct disp_device *lcd = (struct disp_device *)parg;
|
struct disp_lcd_private_data *lcdp = NULL;
|
struct disp_manager *mgr = NULL;
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
struct disp_eink_manager *eink_manager = NULL;
|
#endif
|
u32 hwdev_index;
|
u32 irq_flag = 0;
|
unsigned int panel_extend_dirty;
|
unsigned long flags;
|
|
if (lcd == NULL)
|
return DISP_IRQ_RETURN;
|
|
hwdev_index = lcd->hwdev_index;
|
lcdp = disp_lcd_get_priv(lcd);
|
|
if (lcdp == NULL)
|
return DISP_IRQ_RETURN;
|
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
eink_manager = disp_get_eink_manager(0);
|
if (eink_manager == NULL)
|
return DISP_IRQ_RETURN;
|
#endif
|
|
if (disp_al_lcd_query_irq
|
(hwdev_index, LCD_IRQ_TCON0_VBLK, &lcdp->panel_info)) {
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
|
eink_display_one_frame(eink_manager);
|
#else
|
int cur_line =
|
disp_al_lcd_get_cur_line(hwdev_index, &lcdp->panel_info);
|
int start_delay =
|
disp_al_lcd_get_start_delay(hwdev_index, &lcdp->panel_info);
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
if (lcdp->lcd_panel_fun.esd_check &&
|
lcdp->lcd_panel_fun.reset_panel) {
|
++lcdp->esd_inf.cnt;
|
if (cur_line < 2 &&
|
!atomic_read(&lcdp->lcd_resetting) &&
|
lcdp->esd_inf.cnt >= lcdp->esd_inf.freq) {
|
if (!lcdp->esd_inf.esd_check_func_pos ||
|
lcdp->lcd_panel_fun.esd_check(lcd->disp)) {
|
/*request reset*/
|
atomic_set(&lcdp->lcd_resetting, 1);
|
schedule_work(&lcdp->reflush_work);
|
}
|
lcdp->esd_inf.cnt = 0;
|
}
|
}
|
#endif
|
|
mgr = lcd->manager;
|
if (mgr == NULL)
|
return DISP_IRQ_RETURN;
|
|
if (cur_line <= (start_delay - lcdp->judge_line))
|
sync_event_proc(mgr->disp, false);
|
else
|
sync_event_proc(mgr->disp, true);
|
#endif
|
} else {
|
irq_flag = disp_al_lcd_query_irq(hwdev_index, LCD_IRQ_TCON0_CNTR,
|
&lcdp->panel_info);
|
irq_flag |=
|
disp_al_lcd_query_irq(hwdev_index, LCD_IRQ_TCON0_TRIF,
|
&lcdp->panel_info);
|
|
if (irq_flag == 0)
|
goto exit;
|
|
if (disp_al_lcd_tri_busy(hwdev_index, &lcdp->panel_info)) {
|
/* if lcd is still busy when tri/cnt irq coming,
|
* take it as failture, record failture times,
|
* when it reach 2 times, clear counter
|
*/
|
lcdp->tri_finish_fail++;
|
lcdp->tri_finish_fail = (lcdp->tri_finish_fail == 2) ?
|
0 : lcdp->tri_finish_fail;
|
} else
|
lcdp->tri_finish_fail = 0;
|
|
mgr = lcd->manager;
|
if (mgr == NULL)
|
return DISP_IRQ_RETURN;
|
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
if (lcdp->lcd_panel_fun.esd_check &&
|
lcdp->lcd_panel_fun.reset_panel) {
|
++lcdp->esd_inf.cnt;
|
if (!atomic_read(&lcdp->lcd_resetting) &&
|
lcdp->esd_inf.cnt >= lcdp->esd_inf.freq) {
|
if (!lcdp->esd_inf.esd_check_func_pos ||
|
lcdp->lcd_panel_fun.esd_check(lcd->disp)) {
|
/*request reset*/
|
atomic_set(&lcdp->lcd_resetting, 1);
|
schedule_work(&lcdp->reflush_work);
|
}
|
lcdp->esd_inf.cnt = 0;
|
}
|
}
|
#endif
|
|
if (lcdp->tri_finish_fail == 0) {
|
sync_event_proc(mgr->disp, false);
|
disp_al_lcd_tri_start(hwdev_index, &lcdp->panel_info);
|
} else
|
sync_event_proc(mgr->disp, true);
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
panel_extend_dirty = lcdp->panel_extend_dirty;
|
lcdp->panel_extend_dirty = 0;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (panel_extend_dirty == 1)
|
disp_al_lcd_cfg_ext(lcd->disp, &lcdp->panel_extend_info_set);
|
|
exit:
|
return DISP_IRQ_RETURN;
|
}
|
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
static void disp_lcd_reflush_work(struct work_struct *work)
|
{
|
struct disp_lcd_private_data *lcdp =
|
container_of(work, struct disp_lcd_private_data, reflush_work);
|
struct disp_device *lcd = disp_device_get_from_priv((void *)lcdp);
|
unsigned long flags;
|
|
if (!lcdp || !lcd) {
|
DE_WRN("lcdp is null\n");
|
return;
|
}
|
|
/*lcd is not enabled or is enabling*/
|
if (disp_lcd_is_enabled(lcd) == 0 || lcdp->enabling == 1)
|
return;
|
|
/*lcd is resetting*/
|
if (atomic_read(&lcdp->lcd_resetting) == 2)
|
return;
|
|
if (!lcdp->esd_inf.esd_check_func_pos)
|
if (lcdp->lcd_panel_fun.esd_check)
|
if (!lcdp->lcd_panel_fun.esd_check(lcd->disp)) {
|
atomic_set(&lcdp->lcd_resetting, 0);
|
return; /*everything is just fine*/
|
}
|
|
if (lcdp->esd_inf.level == 1) {
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabled = 0;
|
lcdp->enabling = 1;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
atomic_set(&lcdp->lcd_resetting, 2);
|
|
disp_lcd_tcon_disable(lcd);
|
disp_al_lcd_cfg(lcd->hwdev_index, &lcdp->panel_info,
|
&lcdp->panel_extend_info_set);
|
} else
|
atomic_set(&lcdp->lcd_resetting, 2);
|
|
|
++lcdp->esd_inf.rst_cnt;
|
if (lcdp->lcd_panel_fun.reset_panel)
|
lcdp->lcd_panel_fun.reset_panel(lcd->disp);
|
|
if (lcdp->esd_inf.level == 1) {
|
disp_lcd_tcon_enable(lcd);
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabled = 1;
|
lcdp->enabling = 0;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
}
|
|
disp_delay_ms(300);
|
|
/*lcd reset finish*/
|
atomic_set(&lcdp->lcd_resetting, 0);
|
}
|
#endif
|
|
static s32 disp_lcd_cal_fps(struct disp_device *lcd)
|
{
|
s32 ret = -1;
|
struct disp_lcd_private_data *lcdp = NULL;
|
struct disp_panel_para *panel_info = NULL;
|
|
if (!lcd)
|
goto OUT;
|
lcdp = disp_lcd_get_priv(lcd);
|
if (!lcdp)
|
goto OUT;
|
panel_info = &lcdp->panel_info;
|
|
|
lcdp->frame_per_sec =
|
DIV_ROUND_CLOSEST(panel_info->lcd_dclk_freq * 1000000 *
|
(panel_info->lcd_interlace + 1),
|
panel_info->lcd_ht * panel_info->lcd_vt);
|
|
ret = 0;
|
OUT:
|
return ret;
|
}
|
|
static s32 disp_lcd_panel_open(struct disp_device *lcd, bool skip_open_backlight)
|
{
|
int i;
|
int ret = -1;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return ret;
|
}
|
lcdp->open_flow.func_num = 0;
|
|
if (lcdp->lcd_panel_fun.cfg_open_flow)
|
lcdp->lcd_panel_fun.cfg_open_flow(lcd->disp);
|
else
|
DE_WRN("lcd%d_panel_fun.cfg_open_flow is NULL\n", lcd->disp);
|
|
if (skip_open_backlight) {
|
lcdp->open_flow.func_num = lcdp->open_flow.func_num - 1;
|
}
|
|
for (i = 0; i < lcdp->open_flow.func_num; i++) {
|
if (lcdp->open_flow.func[i].func) {
|
lcdp->open_flow.func[i].func(lcd->disp);
|
DE_INF("open flow:step %d finish, to delay %d\n", i,
|
lcdp->open_flow.func[i].delay);
|
if (lcdp->open_flow.func[i].delay != 0)
|
disp_delay_ms(lcdp->open_flow.func[i].delay);
|
}
|
}
|
|
if (lcdp->is_bridge && lcdp->bridge->enable_bridge)
|
ret = lcdp->bridge->enable_bridge();
|
if (ret)
|
DE_WRN("lcd%d enable_bridge failed\n", lcd->disp);
|
return 0;
|
}
|
|
static s32 disp_lcd_panel_close(struct disp_device *lcd)
|
{
|
int i;
|
int ret = -1;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return ret;
|
}
|
lcdp->close_flow.func_num = 0;
|
|
if (lcdp->lcd_panel_fun.cfg_close_flow)
|
lcdp->lcd_panel_fun.cfg_close_flow(lcd->disp);
|
else
|
DE_WRN("lcd_panel_fun[%d].cfg_close_flow is NULL\n", lcd->disp);
|
|
if (lcdp->is_bridge && lcdp->bridge->disable_bridge) {
|
ret = lcdp->bridge->disable_bridge();
|
if (ret)
|
DE_WRN("lcd%d disable_bridge failed\n", lcd->disp);
|
}
|
for (i = 0; i < lcdp->close_flow.func_num; i++) {
|
if (lcdp->close_flow.func[i].func) {
|
lcdp->close_flow.func[i].func(lcd->disp);
|
DE_INF("close flow:step %d finish, to delay %d\n", i,
|
lcdp->close_flow.func[i].delay);
|
if (lcdp->close_flow.func[i].delay != 0)
|
disp_delay_ms(lcdp->close_flow.func[i].delay);
|
}
|
}
|
return 0;
|
}
|
|
/* lcd enable except for backlight */
|
static s32 disp_lcd_fake_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i, ret = DIS_FAIL;
|
struct disp_manager *mgr = NULL;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return ret;
|
}
|
mutex_lock(&lcdp->enable_lock);
|
DE_INF("lcd %d\n", lcd->disp);
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
goto OUT;
|
}
|
if (disp_lcd_is_enabled(lcd) == 1) {
|
ret = 0;
|
goto OUT;
|
}
|
|
disp_lcd_cal_fps(lcd);
|
if (mgr->enable)
|
mgr->enable(mgr);
|
|
/* init fix power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (lcdp->lcd_cfg.lcd_fix_power_used[i] == 1)
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_fix_power[i]);
|
}
|
|
#if defined(SUPPORT_DSI) && defined(DSI_VERSION_40)
|
if ((lcdp->panel_info.lcd_if == LCD_IF_DSI) &&
|
(lcdp->irq_no_dsi != 0)) {
|
if (lcdp->panel_info.lcd_dsi_if == LCD_DSI_IF_COMMAND_MODE) {
|
disp_sys_register_irq(lcdp->irq_no, 0,
|
disp_lcd_event_proc, (void *)lcd,
|
0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
} else {
|
disp_sys_register_irq(lcdp->irq_no_dsi, 0,
|
disp_lcd_event_proc, (void *)lcd,
|
0, 0);
|
disp_sys_enable_irq(lcdp->irq_no_dsi);
|
}
|
} else
|
#endif
|
{
|
disp_sys_register_irq(lcdp->irq_no, 0, disp_lcd_event_proc,
|
(void *)lcd, 0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
}
|
lcdp->enabling = 1;
|
lcdp->bl_need_enabled = 0;
|
disp_lcd_gpio_init(lcd);
|
lcd_clk_enable(lcd);
|
ret = cal_real_frame_period(lcd);
|
if (ret)
|
DE_WRN("cal_real_frame_period fail:%d\n", ret);
|
disp_sys_pwm_set_polarity(lcdp->pwm_info.dev, lcdp->pwm_info.polarity);
|
disp_al_lcd_cfg(lcd->hwdev_index, &lcdp->panel_info,
|
&lcdp->panel_extend_info_set);
|
disp_lcd_panel_open(lcd, true);
|
lcdp->enabled = 1;
|
lcdp->enabling = 0;
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
atomic_set(&lcdp->lcd_resetting, 0);
|
#endif
|
ret = 0;
|
|
OUT:
|
mutex_unlock(&lcdp->enable_lock);
|
return ret;
|
}
|
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
static s32 disp_lcd_enable(struct disp_device *lcd)
|
{
|
unsigned long flags;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
struct disp_manager *mgr = NULL;
|
int ret;
|
int i;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
flush_work(&lcd->close_eink_panel_work);
|
DE_INF("lcd %d\n", lcd->disp);
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_enabled(lcd) == 1)
|
return 0;
|
|
disp_sys_register_irq(lcdp->irq_no, 0, disp_lcd_event_proc, (void *)lcd,
|
0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabling = 1;
|
lcdp->bl_need_enabled = 0;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (lcdp->lcd_panel_fun.cfg_panel_info)
|
lcdp->lcd_panel_fun.cfg_panel_info(&lcdp->panel_extend_info);
|
else
|
DE_WRN("lcd_panel_fun[%d].cfg_panel_info is NULL\n", lcd->disp);
|
|
disp_lcd_gpio_init(lcd);
|
ret = lcd_clk_enable(lcd);
|
if (ret != 0)
|
return DIS_FAIL;
|
ret = cal_real_frame_period(lcd);
|
if (ret)
|
DE_WRN("cal_real_frame_period fail:%d\n", ret);
|
|
disp_al_lcd_cfg(lcd->hwdev_index, &lcdp->panel_info,
|
&lcdp->panel_extend_info);/* init tcon_lcd regs */
|
disp_lcd_panel_open(lcd, false);
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabled = 1;
|
lcdp->enabling = 0;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
return 0;
|
}
|
|
static s32 disp_lcd_disable(struct disp_device *lcd)
|
{
|
unsigned long flags;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
struct disp_manager *mgr = NULL;
|
int i;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
DE_INF("lcd %d\n", lcd->disp);
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
return DIS_FAIL;
|
}
|
if (disp_lcd_is_enabled(lcd) == 0)
|
return 0;
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabled = 0;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
lcdp->bl_need_enabled = 0;
|
|
disp_lcd_panel_close(lcd);
|
|
lcd_clk_disable(lcd);
|
disp_lcd_gpio_exit(lcd);
|
|
disp_sys_disable_irq(lcdp->irq_no);
|
disp_sys_unregister_irq(lcdp->irq_no, disp_lcd_event_proc, (void *)lcd);
|
|
return 0;
|
}
|
|
#else
|
static s32 disp_lcd_enable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i;
|
struct disp_manager *mgr = NULL;
|
unsigned bl;
|
int ret = DIS_FAIL;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return ret;
|
}
|
|
mutex_lock(&lcdp->enable_lock);
|
__inf("lcd %d\n", lcd->disp);
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
goto OUT;
|
}
|
if (disp_lcd_is_enabled(lcd) == 1) {
|
ret = 0;
|
goto OUT;
|
}
|
|
disp_lcd_cal_fps(lcd);
|
if (mgr->enable)
|
mgr->enable(mgr);
|
|
/* init fix power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (lcdp->lcd_cfg.lcd_fix_power_used[i] == 1)
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_fix_power[i]);
|
}
|
|
#if defined(SUPPORT_DSI) && defined(DSI_VERSION_40)
|
if ((lcdp->panel_info.lcd_if == LCD_IF_DSI)
|
&& (lcdp->irq_no_dsi != 0)) {
|
if (lcdp->panel_info.lcd_dsi_if == LCD_DSI_IF_COMMAND_MODE) {
|
disp_sys_register_irq(lcdp->irq_no, 0, disp_lcd_event_proc,
|
(void *)lcd, 0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
} else {
|
disp_sys_register_irq(lcdp->irq_no_dsi, 0, disp_lcd_event_proc,
|
(void *)lcd, 0, 0);
|
disp_sys_enable_irq(lcdp->irq_no_dsi);
|
}
|
} else
|
#endif
|
{
|
disp_sys_register_irq(lcdp->irq_no, 0, disp_lcd_event_proc,
|
(void *)lcd, 0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
}
|
lcdp->enabling = 1;
|
lcdp->bl_need_enabled = 0;
|
|
lcdp->panel_extend_info.lcd_gamma_en = lcdp->panel_info.lcd_gamma_en;
|
disp_lcd_gpio_init(lcd);
|
ret = lcd_clk_enable(lcd);
|
if (ret != 0)
|
goto OUT;
|
|
ret = cal_real_frame_period(lcd);
|
if (ret)
|
DE_WRN("cal_real_frame_period fail:%d\n", ret);
|
|
disp_sys_pwm_set_polarity(lcdp->pwm_info.dev, lcdp->pwm_info.polarity);
|
disp_al_lcd_cfg(lcd->hwdev_index, &lcdp->panel_info,
|
&lcdp->panel_extend_info_set);
|
lcd_calc_judge_line(lcd);
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
if (lcdp->lcd_panel_fun.set_esd_info) {
|
lcdp->lcd_panel_fun.set_esd_info(&lcdp->esd_inf);
|
} else {
|
/*default value*/
|
lcdp->esd_inf.level = 0;
|
lcdp->esd_inf.freq = 60;
|
lcdp->esd_inf.esd_check_func_pos = 0;
|
lcdp->esd_inf.cnt = 0;
|
}
|
#endif
|
disp_lcd_panel_open(lcd, false);
|
|
lcdp->enabled = 1;
|
lcdp->enabling = 0;
|
bl = disp_lcd_get_bright(lcd);
|
disp_lcd_set_bright(lcd, bl);
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
atomic_set(&lcdp->lcd_resetting, 0);
|
#endif
|
ret = 0;
|
|
OUT:
|
mutex_unlock(&lcdp->enable_lock);
|
return ret;
|
}
|
|
static s32 disp_lcd_disable(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
struct disp_manager *mgr = NULL;
|
int i = 0, ret = DIS_FAIL;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return ret;
|
}
|
mutex_lock(&lcdp->enable_lock);
|
DE_INF("lcd %d\n", lcd->disp);
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
goto OUT;
|
}
|
if (disp_lcd_is_enabled(lcd) == 0) {
|
ret = 0;
|
goto OUT;
|
}
|
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
atomic_set(&lcdp->lcd_resetting, 2);
|
#endif
|
lcdp->enabled = 0;
|
|
lcdp->bl_need_enabled = 0;
|
disp_lcd_panel_close(lcd);
|
disp_lcd_gpio_exit(lcd);
|
|
lcd_clk_disable(lcd);
|
#if defined(SUPPORT_DSI) && defined(DSI_VERSION_40)
|
if ((lcdp->panel_info.lcd_if == LCD_IF_DSI) &&
|
(lcdp->irq_no_dsi != 0)) {
|
if (lcdp->panel_info.lcd_dsi_if == LCD_DSI_IF_COMMAND_MODE) {
|
disp_sys_disable_irq(lcdp->irq_no);
|
disp_sys_unregister_irq(
|
lcdp->irq_no, disp_lcd_event_proc, (void *)lcd);
|
} else {
|
disp_sys_disable_irq(lcdp->irq_no_dsi);
|
disp_sys_unregister_irq(
|
lcdp->irq_no_dsi, disp_lcd_event_proc, (void *)lcd);
|
}
|
} else
|
#endif
|
{
|
disp_sys_disable_irq(lcdp->irq_no);
|
disp_sys_unregister_irq(lcdp->irq_no, disp_lcd_event_proc,
|
(void *)lcd);
|
}
|
|
/* disable fix power */
|
for (i = LCD_POWER_NUM - 1; i >= 0; i--) {
|
if (lcdp->lcd_cfg.lcd_fix_power_used[i] == 1)
|
disp_sys_power_disable(lcdp->lcd_cfg.lcd_fix_power[i]);
|
}
|
|
if (mgr->disable)
|
mgr->disable(mgr);
|
|
ret = 0;
|
OUT:
|
mutex_unlock(&lcdp->enable_lock);
|
return ret;
|
}
|
#endif
|
static s32 disp_lcd_sw_enable(struct disp_device *lcd)
|
{
|
unsigned long flags;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i, ret;
|
struct disp_manager *mgr = NULL;
|
struct disp_gpio_set_t gpio_info[1];
|
struct pwm_device *pwm_dev;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
mgr = lcd->manager;
|
if (mgr == NULL) {
|
DE_WRN("mgr is NULL!\n");
|
return DIS_FAIL;
|
}
|
disp_lcd_cal_fps(lcd);
|
lcd_calc_judge_line(lcd);
|
if (mgr->sw_enable)
|
mgr->sw_enable(mgr);
|
|
#if !defined(CONFIG_COMMON_CLK_ENABLE_SYNCBOOT)
|
if (lcd_clk_enable(lcd) != 0)
|
return DIS_FAIL;
|
#endif
|
ret = cal_real_frame_period(lcd);
|
if (ret)
|
DE_WRN("cal_real_frame_period fail:%d\n", ret);
|
|
/* init fix power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (lcdp->lcd_cfg.lcd_fix_power_used[i] == 1)
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_fix_power[i]);
|
}
|
|
/* init lcd power */
|
for (i = 0; i < LCD_POWER_NUM; i++) {
|
if (lcdp->lcd_cfg.lcd_power_used[i] == 1)
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_power[i]);
|
}
|
|
/* init gpio */
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], ""))
|
|| (!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_gpio_power[i]);
|
}
|
|
for (i = 0; i < LCD_GPIO_NUM; i++) {
|
lcdp->lcd_cfg.gpio_hdl[i] = 0;
|
|
if (lcdp->lcd_cfg.lcd_gpio_used[i]) {
|
memcpy(gpio_info, &(lcdp->lcd_cfg.lcd_gpio[i]),
|
sizeof(struct disp_gpio_set_t));
|
lcdp->lcd_cfg.gpio_hdl[i] =
|
disp_sys_gpio_request(gpio_info, 1);
|
}
|
}
|
|
/* init lcd pin */
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], ""))
|
|| (!strcmp(lcdp->lcd_cfg.lcd_pin_power[i], "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_pin_power[i]);
|
}
|
|
/* init bl */
|
if (lcdp->lcd_cfg.lcd_bl_en_used) {
|
/* io-pad */
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, ""))
|
|| (!strcmp(lcdp->lcd_cfg.lcd_bl_en_power, "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_bl_en_power);
|
lcdp->lcd_cfg.lcd_bl_gpio_hdl =
|
disp_sys_gpio_request(&lcdp->lcd_cfg.lcd_bl_en, 1);
|
}
|
|
if (lcdp->panel_info.lcd_pwm_used && lcdp->pwm_info.dev) {
|
pwm_dev = (struct pwm_device *)lcdp->pwm_info.dev;
|
pwm_dev->state.period = lcdp->pwm_info.period_ns;
|
pwm_dev->state.duty_cycle = lcdp->pwm_info.duty_ns;
|
disp_sys_pwm_set_polarity(lcdp->pwm_info.dev, lcdp->pwm_info.polarity);
|
pwm_dev->state.enabled = true;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->enabled = 1;
|
lcdp->enabling = 0;
|
lcdp->bl_need_enabled = 1;
|
lcdp->bl_enabled = true;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
if (lcdp->lcd_panel_fun.set_esd_info) {
|
lcdp->lcd_panel_fun.set_esd_info(&lcdp->esd_inf);
|
} else {
|
/*default value*/
|
lcdp->esd_inf.level = 0;
|
lcdp->esd_inf.freq = 60;
|
lcdp->esd_inf.esd_check_func_pos = 0;
|
lcdp->esd_inf.cnt = 0;
|
}
|
#endif
|
disp_al_lcd_disable_irq(lcd->hwdev_index, LCD_IRQ_TCON0_VBLK,
|
&lcdp->panel_info);
|
#if defined(SUPPORT_DSI) && defined(DSI_VERSION_40)
|
if ((lcdp->panel_info.lcd_if == LCD_IF_DSI) &&
|
(lcdp->irq_no_dsi != 0)) {
|
if (lcdp->panel_info.lcd_dsi_if == LCD_DSI_IF_COMMAND_MODE) {
|
disp_sys_register_irq(lcdp->irq_no, 0,
|
disp_lcd_event_proc, (void *)lcd,
|
0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
} else {
|
disp_sys_register_irq(lcdp->irq_no_dsi, 0,
|
disp_lcd_event_proc, (void *)lcd,
|
0, 0);
|
disp_sys_enable_irq(lcdp->irq_no_dsi);
|
}
|
} else
|
#endif
|
{
|
disp_sys_register_irq(lcdp->irq_no, 0, disp_lcd_event_proc,
|
(void *)lcd, 0, 0);
|
disp_sys_enable_irq(lcdp->irq_no);
|
}
|
disp_al_lcd_enable_irq(lcd->hwdev_index, LCD_IRQ_TCON0_VBLK,
|
&lcdp->panel_info);
|
|
return 0;
|
}
|
|
s32 disp_lcd_is_enabled(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
return (s32)lcdp->enabled;
|
}
|
|
/**
|
* disp_lcd_check_if_enabled - check lcd if be enabled status
|
*
|
* this function only be used by bsp_disp_sync_with_hw to check
|
* the device enabled status when driver init
|
*/
|
s32 disp_lcd_check_if_enabled(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int ret = 1;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
#if !defined(CONFIG_COMMON_CLK_ENABLE_SYNCBOOT)
|
if (lcdp->clk &&
|
(__clk_get_enable_count(lcdp->clk) == 0))
|
ret = 0;
|
#endif
|
|
return ret;
|
}
|
|
static s32 disp_lcd_set_open_func(struct disp_device *lcd, LCD_FUNC func,
|
u32 delay)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
if (func) {
|
lcdp->open_flow.func[lcdp->open_flow.func_num].func = func;
|
lcdp->open_flow.func[lcdp->open_flow.func_num].delay = delay;
|
lcdp->open_flow.func_num++;
|
}
|
|
return DIS_SUCCESS;
|
}
|
|
static s32 disp_lcd_set_close_func(struct disp_device *lcd, LCD_FUNC func,
|
u32 delay)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
if (func) {
|
lcdp->close_flow.func[lcdp->close_flow.func_num].func = func;
|
lcdp->close_flow.func[lcdp->close_flow.func_num].delay = delay;
|
lcdp->close_flow.func_num++;
|
}
|
|
return DIS_SUCCESS;
|
}
|
|
static s32 disp_lcd_set_panel_funs(struct disp_device *lcd, char *name,
|
struct disp_lcd_panel_fun *lcd_cfg)
|
{
|
char primary_key[20], drv_name[32];
|
s32 ret;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
sprintf(primary_key, "lcd%d", lcd->disp);
|
|
ret =
|
disp_sys_script_get_item(primary_key, "lcd_driver_name",
|
(int *)drv_name, 2);
|
DE_INF("lcd %d, driver_name %s, panel_name %s\n", lcd->disp, drv_name,
|
name);
|
if ((ret == 2) && !strcmp(drv_name, name)) {
|
memset(&lcdp->lcd_panel_fun,
|
0,
|
sizeof(struct disp_lcd_panel_fun));
|
lcdp->lcd_panel_fun.cfg_panel_info = lcd_cfg->cfg_panel_info;
|
lcdp->lcd_panel_fun.cfg_open_flow = lcd_cfg->cfg_open_flow;
|
lcdp->lcd_panel_fun.cfg_close_flow = lcd_cfg->cfg_close_flow;
|
lcdp->lcd_panel_fun.esd_check = lcd_cfg->esd_check;
|
lcdp->lcd_panel_fun.reset_panel = lcd_cfg->reset_panel;
|
lcdp->lcd_panel_fun.set_esd_info = lcd_cfg->set_esd_info;
|
lcdp->lcd_panel_fun.lcd_user_defined_func =
|
lcd_cfg->lcd_user_defined_func;
|
lcdp->lcd_panel_fun.set_bright = lcd_cfg->set_bright;
|
if (lcdp->lcd_panel_fun.cfg_panel_info) {
|
lcdp->lcd_panel_fun.cfg_panel_info(&lcdp->panel_extend_info);
|
memcpy(&lcdp->panel_extend_info_set,
|
&lcdp->panel_extend_info, sizeof(struct panel_extend_para));
|
} else {
|
DE_WRN("lcd_panel_fun[%d].cfg_panel_info is NULL\n", lcd->disp);
|
}
|
|
return 0;
|
}
|
|
return -1;
|
}
|
|
s32 disp_lcd_gpio_init(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
/* io-pad */
|
for (i = 0; i < LCD_GPIO_REGU_NUM; i++) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], ""))
|
|| (!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], "none"))))
|
disp_sys_power_enable(lcdp->lcd_cfg.lcd_gpio_power[i]);
|
}
|
|
for (i = 0; i < LCD_GPIO_NUM; i++) {
|
lcdp->lcd_cfg.gpio_hdl[i] = 0;
|
|
if (lcdp->lcd_cfg.lcd_gpio_used[i]) {
|
struct disp_gpio_set_t gpio_info[1];
|
|
memcpy(gpio_info, &(lcdp->lcd_cfg.lcd_gpio[i]),
|
sizeof(struct disp_gpio_set_t));
|
lcdp->lcd_cfg.gpio_hdl[i] =
|
disp_sys_gpio_request(gpio_info, 1);
|
}
|
}
|
|
return 0;
|
}
|
|
s32 disp_lcd_gpio_exit(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i = 0;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
for (i = 0; i < LCD_GPIO_NUM; i++) {
|
if (lcdp->lcd_cfg.gpio_hdl[i]) {
|
struct disp_gpio_set_t gpio_info[1];
|
|
disp_sys_gpio_release(lcdp->lcd_cfg.gpio_hdl[i], 2);
|
|
memcpy(gpio_info, &(lcdp->lcd_cfg.lcd_gpio[i]),
|
sizeof(struct disp_gpio_set_t));
|
gpio_info->mul_sel = 7;
|
lcdp->lcd_cfg.gpio_hdl[i] =
|
disp_sys_gpio_request(gpio_info, 1);
|
disp_sys_gpio_release(lcdp->lcd_cfg.gpio_hdl[i], 2);
|
lcdp->lcd_cfg.gpio_hdl[i] = 0;
|
}
|
}
|
|
/* io-pad */
|
for (i = LCD_GPIO_REGU_NUM - 1; i >= 0; i--) {
|
if (!
|
((!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], ""))
|
|| (!strcmp(lcdp->lcd_cfg.lcd_gpio_power[i], "none"))))
|
disp_sys_power_disable(lcdp->lcd_cfg.lcd_gpio_power[i]);
|
}
|
|
return 0;
|
}
|
|
/* direction: input(0), output(1) */
|
s32 disp_lcd_gpio_set_direction(struct disp_device *lcd, u32 io_index,
|
u32 direction)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
char gpio_name[20];
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
sprintf(gpio_name, "lcd_gpio_%d", io_index);
|
return disp_sys_gpio_set_direction(lcdp->lcd_cfg.gpio_hdl[io_index],
|
direction, gpio_name);
|
}
|
|
s32 disp_lcd_gpio_get_value(struct disp_device *lcd, u32 io_index)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
char gpio_name[20];
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
sprintf(gpio_name, "lcd_gpio_%d", io_index);
|
return disp_sys_gpio_get_value(lcdp->lcd_cfg.gpio_hdl[io_index],
|
gpio_name);
|
}
|
|
s32 disp_lcd_gpio_set_value(struct disp_device *lcd, u32 io_index, u32 data)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
char gpio_name[20];
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
if (io_index >= LCD_GPIO_NUM) {
|
DE_WRN("gpio num out of range\n");
|
return DIS_FAIL;
|
}
|
sprintf(gpio_name, "lcd_gpio_%d", io_index);
|
return disp_sys_gpio_set_value(lcdp->lcd_cfg.gpio_hdl[io_index], data,
|
gpio_name);
|
}
|
|
static s32 disp_lcd_get_dimensions(struct disp_device *lcd, u32 *width,
|
u32 *height)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
*width = lcdp->panel_info.lcd_width;
|
*height = lcdp->panel_info.lcd_height;
|
return 0;
|
}
|
|
static s32 disp_lcd_get_status(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
return disp_al_lcd_get_status(lcd->hwdev_index, &lcdp->panel_info);
|
}
|
|
static bool disp_lcd_is_in_safe_period(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int start_delay;
|
int cur_line;
|
bool ret = true;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
goto exit;
|
}
|
|
start_delay =
|
disp_al_lcd_get_start_delay(lcd->hwdev_index, &lcdp->panel_info);
|
cur_line =
|
disp_al_lcd_get_cur_line(lcd->hwdev_index, &lcdp->panel_info);
|
if (cur_line >= start_delay)
|
ret = false;
|
|
exit:
|
return ret;
|
}
|
|
static s32 disp_lcd_update_gamma_tbl_set(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i;
|
unsigned int *gamma, *gamma_set;
|
unsigned int r, g, b;
|
s32 color_temperature;
|
u32 color_inverse;
|
|
color_temperature = lcdp->color_temperature;
|
color_inverse = lcdp->color_inverse;
|
memcpy(&lcdp->panel_extend_info_set, &lcdp->panel_extend_info,
|
sizeof(struct panel_extend_para));
|
gamma = lcdp->panel_extend_info.lcd_gamma_tbl;
|
gamma_set = lcdp->panel_extend_info_set.lcd_gamma_tbl;
|
if (color_temperature > 0) {
|
/* warm color */
|
for (i = 0; i < 256; i++) {
|
r = (gamma[i] >> 16) & 0xff;
|
g = (gamma[i] >> 8) & 0xff;
|
b = gamma[i] & 0xff;
|
|
g = g * (512 - color_temperature) / 512;
|
b = b * (256 - color_temperature) / 256;
|
r = r << 16;
|
|
g = g << 8;
|
gamma_set[i] = r | g | b;
|
}
|
} else if (color_temperature < 0) {
|
/* cool color */
|
for (i = 0; i < 256; i++) {
|
r = (gamma[i] >> 16) & 0xff;
|
g = (gamma[i] >> 8) & 0xff;
|
b = gamma[i] & 0xff;
|
|
r = r * (256 + color_temperature) / 256;
|
g = g * (512 + color_temperature) / 512;
|
|
r = r << 16;
|
g = g << 8;
|
|
gamma_set[i] = r | g | b;
|
}
|
}
|
if (color_inverse == 1) {
|
for (i = 0; i < 256; i++)
|
gamma_set[i] = 0xffffffff - gamma_set[i];
|
}
|
if (color_inverse != 0)
|
lcdp->panel_extend_info_set.lcd_gamma_en = 1;
|
if (color_temperature != 0)
|
lcdp->panel_extend_info_set.lcd_gamma_en = 1;
|
|
return 0;
|
}
|
|
|
static s32 disp_lcd_set_gamma_tbl(struct disp_device *lcd,
|
unsigned int *gamma_table, unsigned int size)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)
|
|| (gamma_table == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
size = (size > LCD_GAMMA_TABLE_SIZE) ?
|
LCD_GAMMA_TABLE_SIZE : size;
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
memcpy(lcdp->panel_extend_info.lcd_gamma_tbl, gamma_table, size);
|
disp_lcd_update_gamma_tbl_set(lcd);
|
lcdp->panel_extend_dirty = 1;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
return 0;
|
}
|
|
static s32 disp_lcd_enable_gamma(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->panel_extend_info.lcd_gamma_en == 0) {
|
lcdp->panel_extend_info.lcd_gamma_en = 1;
|
disp_lcd_update_gamma_tbl_set(lcd);
|
lcdp->panel_extend_dirty = 1;
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
return 0;
|
}
|
|
static s32 disp_lcd_disable_gamma(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int ret;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
if (lcdp->panel_extend_info.lcd_gamma_en == 1) {
|
lcdp->panel_extend_info.lcd_gamma_en = 0;
|
ret = disp_al_lcd_cfg_ext(lcd->disp,
|
&lcdp->panel_extend_info);
|
} else {
|
ret = 0;
|
}
|
|
return ret;
|
}
|
|
static s32 disp_lcd_get_fps(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
return lcdp->frame_per_sec;
|
}
|
|
static s32 disp_lcd_set_color_temperature(struct disp_device *lcd,
|
s32 color_temperature)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((NULL == lcd) || (NULL == lcdp)) {
|
DE_WRN("NULL hdl!\n");
|
return -1;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->color_temperature = color_temperature;
|
disp_lcd_update_gamma_tbl_set(lcd);
|
lcdp->panel_extend_dirty = 1;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
return 0;
|
}
|
|
static s32 disp_lcd_get_color_temperature(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
s32 color_temperature = 0;
|
|
if ((NULL == lcd) || (NULL == lcdp)) {
|
DE_WRN("NULL hdl!\n");
|
return 0;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
color_temperature = lcdp->color_temperature;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
return color_temperature;
|
}
|
|
static s32 disp_lcd_init(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
int i;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
DE_INF("lcd %d\n", lcd->disp);
|
|
|
mutex_init(&lcdp->enable_lock);
|
lcd_get_sys_config(lcd->disp, &lcdp->lcd_cfg);
|
if (disp_lcd_is_used(lcd)) {
|
struct disp_video_timings *timmings;
|
struct disp_panel_para *panel_info;
|
|
lcd_parse_panel_para(lcd->disp, &lcdp->panel_info);
|
lcdp->panel_extend_info.lcd_cmap_en = lcdp->panel_info.lcd_cmap_en;
|
lcdp->panel_extend_info.lcd_gamma_en = lcdp->panel_info.lcd_gamma_en;
|
if (lcdp->panel_extend_info.lcd_gamma_en ||
|
lcdp->panel_extend_info.lcd_cmap_en)
|
lcdp->panel_extend_dirty = 1;
|
if (lcdp->panel_info.lcd_if == LCD_IF_DSI &&
|
lcdp->panel_info.lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
|
lcdp->panel_info.lcd_dsi_port_num ==
|
DISP_LCD_DSI_SINGLE_PORT) {
|
lcdp->panel_info.lcd_ht *= 2;
|
lcdp->panel_info.lcd_hspw *= 2;
|
lcdp->panel_info.lcd_x *= 2;
|
lcdp->panel_info.lcd_hbp *= 2;
|
lcdp->panel_info.lcd_dclk_freq *= 2;
|
}
|
timmings = &lcd->timings;
|
panel_info = &lcdp->panel_info;
|
timmings->pixel_clk = panel_info->lcd_dclk_freq * 1000;
|
timmings->x_res = panel_info->lcd_x;
|
timmings->y_res = panel_info->lcd_y;
|
timmings->hor_total_time = panel_info->lcd_ht;
|
timmings->hor_sync_time = panel_info->lcd_hspw;
|
timmings->hor_back_porch =
|
panel_info->lcd_hbp - panel_info->lcd_hspw;
|
timmings->hor_front_porch =
|
panel_info->lcd_ht - panel_info->lcd_hbp -
|
panel_info->lcd_x;
|
timmings->ver_total_time = panel_info->lcd_vt;
|
timmings->ver_sync_time = panel_info->lcd_vspw;
|
timmings->ver_back_porch =
|
panel_info->lcd_vbp - panel_info->lcd_vspw;
|
timmings->ver_front_porch =
|
panel_info->lcd_vt - panel_info->lcd_vbp -
|
panel_info->lcd_y;
|
}
|
disp_lcd_bright_curve_init(lcd);
|
|
if (disp_lcd_is_used(lcd)) {
|
__u64 backlight_bright;
|
__u64 period_ns, duty_ns;
|
|
if (lcdp->panel_info.lcd_pwm_used) {
|
lcdp->pwm_info.channel = lcdp->panel_info.lcd_pwm_ch;
|
lcdp->pwm_info.polarity = lcdp->panel_info.lcd_pwm_pol;
|
lcdp->pwm_info.dev =
|
disp_sys_pwm_request(lcdp->panel_info.lcd_pwm_ch);
|
|
if (lcdp->panel_info.lcd_pwm_freq != 0) {
|
period_ns =
|
1000 * 1000 * 1000 /
|
lcdp->panel_info.lcd_pwm_freq;
|
} else {
|
DE_WRN("lcd%d.lcd_pwm_freq is ZERO\n",
|
lcd->disp);
|
/* default 1khz */
|
period_ns = 1000 * 1000 * 1000 / 1000;
|
}
|
|
backlight_bright = lcdp->lcd_cfg.backlight_bright;
|
|
duty_ns = (backlight_bright * period_ns) / 256;
|
disp_sys_pwm_set_polarity(lcdp->pwm_info.dev,
|
lcdp->pwm_info.polarity);
|
lcdp->pwm_info.duty_ns = duty_ns;
|
lcdp->pwm_info.period_ns = period_ns;
|
disp_sys_pwm_config(lcdp->pwm_info.dev, duty_ns, period_ns);
|
}
|
lcd_clk_init(lcd);
|
for (i = 0; i < 256; i++) {
|
lcdp->panel_extend_info.lcd_gamma_tbl[i] =
|
(i << 24) | (i << 16) | (i << 8) | (i);
|
}
|
}
|
|
/* lcd_panel_parameter_check(lcd->disp, lcd); */
|
return 0;
|
}
|
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
static void disp_close_eink_panel_task(struct work_struct *work)
|
{ /* (unsigned long parg) */
|
struct disp_device *plcd = NULL;
|
|
plcd = disp_device_find(0, DISP_OUTPUT_TYPE_LCD);
|
plcd->disable(plcd);
|
display_finish_flag = 1;
|
}
|
#endif
|
|
static disp_config_update_t disp_lcd_check_config_dirty(struct disp_device *lcd,
|
struct disp_device_config *config)
|
{
|
disp_config_update_t ret = DISP_NOT_UPDATE;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
goto exit;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->enabled == 0 || (lcdp->is_bridge && lcdp->mode_using != config->mode))
|
ret = DISP_NORMAL_UPDATE;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
|
exit:
|
return ret;
|
}
|
|
static int disp_lcd_remove_video_timing(struct disp_device *dispdev, enum disp_tv_mode mode)
|
{
|
unsigned long flags;
|
struct lcd_timing_private *timing;
|
struct lcd_timing_private *timing_tmp;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
int ret = -1;
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
return ret;
|
}
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge == false) {
|
DE_WRN("error: lcd%d is not register as bridge!\n", dispdev->disp);
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return -1;
|
}
|
|
plist_for_each_entry_safe(timing, timing_tmp, &lcd_private[dispdev->disp].timing_head, list) {
|
if (timing->timing.mode == mode) {
|
plist_del(&timing->list, &lcdp->timing_head);
|
kfree(timing);
|
ret = 0;
|
}
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (ret == -1)
|
DE_WRN("remove mode for lcd%d failed, mode not found!\n", dispdev->disp);
|
return ret;
|
}
|
|
static int disp_lcd_get_video_timing(struct disp_device *dispdev, struct disp_lcd_timing *timings, int *num)
|
{
|
unsigned long flags;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
struct lcd_timing_private *timing_list;
|
int ret = 0;
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
return ret;
|
}
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge == false) {
|
DE_WRN("error: lcd%d is not register as bridge!\n", dispdev->disp);
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return -1;
|
}
|
*num = 0;
|
plist_for_each_entry(timing_list, &lcd_private[dispdev->disp].timing_head, list) {
|
if (timings != NULL)
|
memcpy(&timings[*num], &timing_list->timing, sizeof(struct disp_lcd_timing));
|
(*num)++;
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return ret;
|
}
|
|
static int disp_lcd_add_video_timing(struct disp_device *dispdev, struct disp_lcd_timing *timings)
|
{
|
struct lcd_timing_private *timing;
|
struct lcd_timing_private *timing_list;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
unsigned long flags;
|
bool is_replace = false;
|
int ret = 0;
|
int i = 0;
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
return ret;
|
}
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge == false) {
|
DE_WRN("error: lcd%d is not register as bridge!\n", dispdev->disp);
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return -1;
|
}
|
|
plist_for_each_entry(timing_list, &lcd_private[dispdev->disp].timing_head, list) {
|
if (timing_list->timing.mode == timings[0].mode) { /*already exist, replace with new one*/
|
timing_list->timing.mode = timings[0].mode;
|
timing_list->timing.lcd_x = timings[0].lcd_x;
|
timing_list->timing.lcd_y = timings[0].lcd_y;
|
timing_list->timing.lcd_dclk_freq = timings[0].lcd_dclk_freq;
|
timing_list->timing.lcd_hbp = timings[0].lcd_hbp;
|
timing_list->timing.lcd_ht = timings[0].lcd_ht;
|
timing_list->timing.lcd_vbp = timings[0].lcd_vbp;
|
timing_list->timing.lcd_vt = timings[0].lcd_vt;
|
timing_list->timing.lcd_vspw = timings[0].lcd_vspw;
|
timing_list->timing.lcd_hspw = timings[0].lcd_hspw;
|
is_replace = true;
|
DE_WRN("find video mode:0x%x already exist for lcd%d, replace with new one!\n",
|
timing_list->timing.mode, dispdev->disp);
|
break;
|
}
|
}
|
|
if (is_replace == false) {/*add new one*/
|
timing = kmalloc(sizeof(struct lcd_timing_private), GFP_ATOMIC | __GFP_ZERO);
|
timing->timing.mode = timings[i].mode;
|
timing->timing.lcd_x = timings[i].lcd_x;
|
timing->timing.lcd_y = timings[i].lcd_y;
|
timing->timing.lcd_dclk_freq = timings[i].lcd_dclk_freq;
|
timing->timing.lcd_hbp = timings[i].lcd_hbp;
|
timing->timing.lcd_ht = timings[i].lcd_ht;
|
timing->timing.lcd_vbp = timings[i].lcd_vbp;
|
timing->timing.lcd_vt = timings[i].lcd_vt;
|
timing->timing.lcd_vspw = timings[i].lcd_vspw;
|
timing->timing.lcd_hspw = timings[i].lcd_hspw;
|
plist_node_init(&timing->list, timings[i].mode);
|
plist_add(&(timing->list), &lcdp->timing_head);
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
return ret;
|
}
|
|
static int disp_lcd_register_bridge(struct disp_device *dispdev, struct disp_bridge_fun *bridge)
|
{
|
int ret = 0;
|
unsigned long flags;
|
struct lcd_timing_private timing;
|
char primary_key[25];
|
s32 value = 0;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
goto exit;
|
}
|
if (bridge->enable_bridge != NULL &&
|
bridge->disable_bridge != NULL &&
|
bridge->set_video_mode != NULL) {
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge) {
|
ret = -1;
|
DE_WRN("error: lcd%d is already register as bridge!\n", dispdev->disp);
|
} else {
|
lcdp->bridge = bridge;
|
lcdp->is_bridge = true;
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (ret)
|
goto exit;
|
sprintf(primary_key, "lcd%d", dispdev->disp);
|
|
ret = 1;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_x", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_x = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_y", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_y = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_dclk_freq", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_dclk_freq = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_hbp", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_hbp = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_ht", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_ht = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_hspw", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_hspw = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_vbp", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_vbp = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_vt", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_vt = value;
|
ret &= disp_sys_script_get_item(primary_key, "lcd_vspw", &value, 1);
|
if (ret == 1)
|
timing.timing.lcd_vspw = value;
|
if (ret == 1) {
|
timing.timing.mode = DISP_TV_MODE_DEFAULT;
|
ret = disp_lcd_add_video_timing(dispdev, &timing.timing);
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
lcdp->mode_using = DISP_TV_MODE_DEFAULT;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
ret = 0;
|
} else {
|
ret = -1;
|
DE_WRN("fail to get lcd defalut timing!\n");
|
goto exit;
|
}
|
} else {
|
DE_WRN("register_bridge failed, bridge ops NULL!\n");
|
ret = -1;
|
}
|
exit:
|
return ret;
|
}
|
|
static int disp_lcd_unregister_bridge(struct disp_device *dispdev)
|
{
|
int ret = 0;
|
unsigned long flags;
|
struct lcd_timing_private *timing;
|
struct lcd_timing_private *timing_tmp;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
goto exit;
|
}
|
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge == true) {
|
plist_for_each_entry_safe(timing, timing_tmp, &lcd_private[dispdev->disp].timing_head, list) {
|
plist_del(&timing->list, &lcdp->timing_head);
|
kfree(timing);
|
}
|
|
lcdp->mode_using = DISP_TV_MODE_DEFAULT;
|
lcdp->is_bridge = false;
|
}
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
exit:
|
return ret;
|
}
|
static s32 lcd_get_bridge_timing(struct disp_lcd_private_data *lcdp, struct disp_panel_para *info, enum disp_tv_mode mode)
|
{
|
struct lcd_timing_private *timing;
|
bool find = false;
|
plist_for_each_entry(timing, &lcdp->timing_head, list) {
|
if (timing->timing.mode == mode) {
|
find = true;
|
break;
|
}
|
}
|
if (find) {
|
info->lcd_x = timing->timing.lcd_x;
|
info->lcd_y = timing->timing.lcd_y;
|
info->lcd_dclk_freq = timing->timing.lcd_dclk_freq;
|
info->lcd_hbp = timing->timing.lcd_hbp;
|
info->lcd_ht = timing->timing.lcd_ht;
|
info->lcd_vbp = timing->timing.lcd_vbp;
|
info->lcd_vt = timing->timing.lcd_vt;
|
info->lcd_vspw = timing->timing.lcd_vspw;
|
info->lcd_hspw = timing->timing.lcd_hspw;
|
} else {
|
DE_WRN("video mode not found!\n");
|
return -1;
|
}
|
return 0;
|
}
|
|
|
static s32 disp_lcd_set_static_config(struct disp_device *lcd,
|
struct disp_device_config *config)
|
{
|
struct disp_video_timings *timmings;
|
struct disp_panel_para *panel_info;
|
unsigned long flags;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("ERROR hdl!\n");
|
return DIS_FAIL;
|
}
|
|
mutex_lock(&lcdp->enable_lock);
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge) {
|
if (lcd_get_bridge_timing(lcdp, &lcdp->panel_info, config->mode)) {
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
mutex_unlock(&lcdp->enable_lock);
|
return DIS_FAIL;
|
}
|
lcdp->mode_using = config->mode;
|
if (lcdp->panel_info.lcd_if == LCD_IF_DSI &&
|
lcdp->panel_info.lcd_tcon_mode == DISP_TCON_DUAL_DSI &&
|
lcdp->panel_info.lcd_dsi_port_num ==
|
DISP_LCD_DSI_SINGLE_PORT) {
|
lcdp->panel_info.lcd_ht *= 2;
|
lcdp->panel_info.lcd_hspw *= 2;
|
lcdp->panel_info.lcd_x *= 2;
|
lcdp->panel_info.lcd_hbp *= 2;
|
lcdp->panel_info.lcd_dclk_freq *= 2;
|
}
|
|
timmings = &lcd->timings;
|
panel_info = &lcdp->panel_info;
|
timmings->pixel_clk = panel_info->lcd_dclk_freq * 1000;
|
timmings->x_res = panel_info->lcd_x;
|
timmings->y_res = panel_info->lcd_y;
|
timmings->hor_total_time = panel_info->lcd_ht;
|
timmings->hor_sync_time = panel_info->lcd_hspw;
|
timmings->hor_back_porch =
|
panel_info->lcd_hbp - panel_info->lcd_hspw;
|
timmings->hor_front_porch =
|
panel_info->lcd_ht - panel_info->lcd_hbp -
|
panel_info->lcd_x;
|
timmings->ver_total_time = panel_info->lcd_vt;
|
timmings->ver_sync_time = panel_info->lcd_vspw;
|
timmings->ver_back_porch =
|
panel_info->lcd_vbp - panel_info->lcd_vspw;
|
timmings->ver_front_porch =
|
panel_info->lcd_vt - panel_info->lcd_vbp -
|
panel_info->lcd_y;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
if (lcdp->bridge->set_video_mode(config->mode)) {
|
DE_WRN("lcd%d bridge set_video_mode failed!\n", lcd->disp);
|
}
|
} else {
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
}
|
|
mutex_unlock(&lcdp->enable_lock);
|
return 0;
|
}
|
|
static s32 disp_lcd_get_static_config(struct disp_device *lcd,
|
struct disp_device_config *config)
|
{
|
int ret = 0;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
unsigned long flags;
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
ret = -1;
|
goto exit;
|
}
|
|
config->type = lcd->type;
|
spin_lock_irqsave(&lcd_data_lock, flags);
|
if (lcdp->is_bridge == true)
|
config->mode = lcdp->mode_using;
|
config->format = DISP_CSC_TYPE_RGB;
|
spin_unlock_irqrestore(&lcd_data_lock, flags);
|
exit:
|
return ret;
|
}
|
|
static s32 disp_lcd_exit(struct disp_device *lcd)
|
{
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(lcd);
|
|
if ((lcd == NULL) || (lcdp == NULL)) {
|
DE_WRN("NULL hdl!\n");
|
return DIS_FAIL;
|
}
|
|
lcd_clk_exit(lcd);
|
|
return 0;
|
}
|
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
static s32 disp_lcd_get_esd_info(struct disp_device *dispdev,
|
struct disp_lcd_esd_info *p_esd_info)
|
{
|
s32 ret = -1;
|
struct disp_lcd_private_data *lcdp = NULL;
|
|
if (!dispdev || !p_esd_info)
|
goto OUT;
|
lcdp = disp_lcd_get_priv(dispdev);
|
if (!lcdp)
|
goto OUT;
|
|
memcpy(p_esd_info, &lcdp->esd_inf, sizeof(struct disp_lcd_esd_info));
|
ret = 0;
|
OUT:
|
return ret;
|
}
|
#endif
|
|
static u32 disp_lcd_usec_before_vblank(struct disp_device *dispdev)
|
{
|
int cur_line;
|
int start_delay;
|
u32 usec = 0;
|
struct disp_lcd_private_data *lcdp = disp_lcd_get_priv(dispdev);
|
|
if (!dispdev || !lcdp) {
|
DE_WRN("NULL hdl!\n");
|
goto exit;
|
}
|
|
start_delay = disp_al_lcd_get_start_delay(dispdev->hwdev_index,
|
&lcdp->panel_info);
|
cur_line =
|
disp_al_lcd_get_cur_line(dispdev->hwdev_index, &lcdp->panel_info);
|
if (cur_line > (start_delay - lcdp->judge_line)) {
|
usec =
|
(lcdp->panel_info.lcd_vt - cur_line + 1) * lcdp->usec_per_line;
|
}
|
|
exit:
|
return usec;
|
}
|
|
s32 disp_init_lcd(struct disp_bsp_init_para *para)
|
{
|
u32 num_devices;
|
u32 disp = 0;
|
struct disp_device *lcd;
|
struct disp_lcd_private_data *lcdp;
|
u32 hwdev_index = 0;
|
u32 num_devices_support_lcd = 0;
|
#if defined(SUPPORT_DSI)
|
u32 i = 0;
|
#endif
|
char primary_key[20];
|
int ret = 0, value = 1;
|
#if defined(CONFIG_ARCH_SUN8IW17P1)
|
s32 use_dsi_flag = 0;
|
#endif
|
|
DE_INF("disp_init_lcd\n");
|
|
spin_lock_init(&lcd_data_lock);
|
num_devices = bsp_disp_feat_get_num_devices();
|
for (hwdev_index = 0; hwdev_index < num_devices; hwdev_index++) {
|
if (bsp_disp_feat_is_supported_output_types
|
(hwdev_index, DISP_OUTPUT_TYPE_LCD))
|
num_devices_support_lcd++;
|
}
|
lcds =
|
kmalloc_array(num_devices_support_lcd, sizeof(struct disp_device),
|
GFP_KERNEL | __GFP_ZERO);
|
if (lcds == NULL) {
|
DE_WRN("malloc memory(%d bytes) fail!\n",
|
(unsigned int)sizeof(struct disp_device) *
|
num_devices_support_lcd);
|
goto malloc_err;
|
}
|
lcd_private =
|
(struct disp_lcd_private_data *)
|
kmalloc(sizeof(struct disp_lcd_private_data)
|
* num_devices_support_lcd, GFP_KERNEL | __GFP_ZERO);
|
if (lcd_private == NULL) {
|
DE_WRN("malloc memory(%d bytes) fail!\n",
|
(unsigned int)sizeof(struct disp_lcd_private_data) *
|
num_devices_support_lcd);
|
goto malloc_err;
|
}
|
|
disp = 0;
|
for (hwdev_index = 0; hwdev_index < num_devices; hwdev_index++) {
|
if (!bsp_disp_feat_is_supported_output_types
|
(hwdev_index, DISP_OUTPUT_TYPE_LCD)) {
|
continue;
|
}
|
|
sprintf(primary_key, "lcd%d", disp);
|
ret = disp_sys_script_get_item(primary_key, "lcd_used", &value,
|
1);
|
if (ret != 1 || value != 1)
|
continue;
|
lcd = &lcds[disp];
|
lcdp = &lcd_private[disp];
|
lcd->priv_data = (void *)lcdp;
|
|
sprintf(lcd->name, "lcd%d", disp);
|
lcd->disp = disp;
|
#if defined(CONFIG_ARCH_SUN8IW17P1)
|
value = 0;
|
ret = disp_sys_script_get_item(primary_key, "lcd_if", &value,
|
1);
|
if (value == 4) {
|
lcd->hwdev_index = 1;
|
use_dsi_flag = 1;
|
} else
|
lcd->hwdev_index = (use_dsi_flag == 1) ? 0 : hwdev_index;
|
#else
|
lcd->hwdev_index = hwdev_index;
|
#endif
|
lcd->type = DISP_OUTPUT_TYPE_LCD;
|
plist_head_init(&lcdp->timing_head);
|
lcdp->bridge = NULL;
|
lcdp->mode_using = DISP_TV_MODE_NUM;
|
lcdp->irq_no = para->irq_no[DISP_MOD_LCD0 + lcd->hwdev_index];
|
lcdp->clk = para->mclk[DISP_MOD_LCD0 + lcd->hwdev_index];
|
#if DEVICE_LVDS_NUM == 1
|
lcdp->lvds_clk = para->mclk[DISP_MOD_LVDS];
|
#else
|
lcdp->lvds_clk = para->mclk[DISP_MOD_LVDS + lcd->hwdev_index];
|
#endif
|
#if defined(SUPPORT_DSI)
|
lcdp->irq_no_dsi = para->irq_no[DISP_MOD_DSI0 + disp];
|
for (i = 0; i < CLK_DSI_NUM; ++i)
|
lcdp->dsi_clk[i] = para->mclk[DISP_MOD_DSI0 + i];
|
DE_INF("total number of clk in dsi:%d\n", CLK_DSI_NUM);
|
#endif
|
DE_INF("lcd %d, irq_no=%d, irq_no_dsi=%d\n", disp, lcdp->irq_no,
|
lcdp->irq_no_dsi);
|
|
lcd->set_manager = disp_device_set_manager;
|
lcd->unset_manager = disp_device_unset_manager;
|
lcd->get_resolution = disp_device_get_resolution;
|
lcd->get_timings = disp_device_get_timings;
|
lcd->enable = disp_lcd_enable;
|
lcd->sw_enable = disp_lcd_sw_enable;
|
lcd->fake_enable = disp_lcd_fake_enable;
|
lcd->disable = disp_lcd_disable;
|
lcd->is_enabled = disp_lcd_is_enabled;
|
lcd->check_if_enabled = disp_lcd_check_if_enabled;
|
lcd->set_bright = disp_lcd_set_bright;
|
lcd->get_bright = disp_lcd_get_bright;
|
lcd->set_bright_dimming = disp_lcd_set_bright_dimming;
|
lcd->get_panel_info = disp_lcd_get_panel_info;
|
lcd->set_static_config = disp_lcd_set_static_config;
|
lcd->get_static_config = disp_lcd_get_static_config;
|
lcd->check_config_dirty = disp_lcd_check_config_dirty;
|
|
lcd->set_panel_func = disp_lcd_set_panel_funs;
|
lcd->set_open_func = disp_lcd_set_open_func;
|
lcd->set_close_func = disp_lcd_set_close_func;
|
lcd->backlight_enable = disp_lcd_backlight_enable;
|
lcd->backlight_disable = disp_lcd_backlight_disable;
|
lcd->pwm_enable = disp_lcd_pwm_enable;
|
lcd->pwm_disable = disp_lcd_pwm_disable;
|
lcd->power_enable = disp_lcd_power_enable;
|
lcd->power_disable = disp_lcd_power_disable;
|
lcd->pin_cfg = disp_lcd_pin_cfg;
|
lcd->tcon_enable = disp_lcd_tcon_enable;
|
lcd->tcon_disable = disp_lcd_tcon_disable;
|
lcd->gpio_set_value = disp_lcd_gpio_set_value;
|
lcd->gpio_set_direction = disp_lcd_gpio_set_direction;
|
lcd->get_dimensions = disp_lcd_get_dimensions;
|
lcd->get_status = disp_lcd_get_status;
|
lcd->is_in_safe_period = disp_lcd_is_in_safe_period;
|
lcd->usec_before_vblank = disp_lcd_usec_before_vblank;
|
lcd->set_gamma_tbl = disp_lcd_set_gamma_tbl;
|
lcd->enable_gamma = disp_lcd_enable_gamma;
|
lcd->disable_gamma = disp_lcd_disable_gamma;
|
lcd->get_fps = disp_lcd_get_fps;
|
lcd->set_color_temperature = disp_lcd_set_color_temperature;
|
lcd->get_color_temperature = disp_lcd_get_color_temperature;
|
lcd->show_builtin_patten = disp_device_show_builtin_patten;
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
lcd->get_esd_info = disp_lcd_get_esd_info;
|
#endif
|
|
lcd->init = disp_lcd_init;
|
lcd->exit = disp_lcd_exit;
|
|
lcd->add_video_timing = disp_lcd_add_video_timing;
|
lcd->remove_video_timing = disp_lcd_remove_video_timing;
|
lcd->get_video_timing = disp_lcd_get_video_timing;
|
lcd->register_lcd_bridge = disp_lcd_register_bridge;
|
lcd->unregister_lcd_bridge = disp_lcd_unregister_bridge;
|
#if defined(SUPPORT_EINK) && defined(CONFIG_EINK_PANEL_USED)
|
INIT_WORK(&lcd->close_eink_panel_work,
|
disp_close_eink_panel_task);
|
#endif
|
lcd->init(lcd);
|
disp_device_register(lcd);
|
#if defined(CONFIG_DISP2_LCD_ESD_DETECT)
|
INIT_WORK(&lcdp->reflush_work, disp_lcd_reflush_work);
|
atomic_set(&lcdp->lcd_resetting, 0);
|
#endif
|
|
disp++;
|
}
|
|
return 0;
|
|
malloc_err:
|
kfree(lcds);
|
kfree(lcd_private);
|
lcds = NULL;
|
lcd_private = NULL;
|
|
return -1;
|
}
|
|
s32 disp_exit_lcd(void)
|
{
|
u32 num_devices;
|
u32 disp = 0;
|
struct disp_device *lcd;
|
u32 hwdev_index = 0;
|
struct lcd_timing_private *timing;
|
struct lcd_timing_private *timing_tmp;
|
if (!lcds)
|
return 0;
|
|
num_devices = bsp_disp_feat_get_num_devices();
|
|
disp = 0;
|
for (hwdev_index = 0; hwdev_index < num_devices; hwdev_index++) {
|
if (!bsp_disp_feat_is_supported_output_types
|
(hwdev_index, DISP_OUTPUT_TYPE_LCD)) {
|
continue;
|
}
|
plist_for_each_entry_safe(timing, timing_tmp, &lcd_private[disp].timing_head, list) {
|
plist_del(&timing->list, &lcd_private[disp].timing_head);
|
kfree(timing);
|
}
|
lcd = &lcds[disp];
|
disp_device_unregister(lcd);
|
lcd->exit(lcd);
|
disp++;
|
}
|
|
kfree(lcds);
|
kfree(lcd_private);
|
lcds = NULL;
|
lcd_private = NULL;
|
|
return 0;
|
}
|
