static int s6d7aa0x62_displayon(struct dsim_device *dsim)
{
int ret = 0;
dsim_info("MDD : %s was called\n", __func__);
ret = dsim_write_hl_data(dsim, SEQ_DISPLAY_ON, ARRAY_SIZE(SEQ_DISPLAY_ON));
if (ret < 0) {
dsim_err("%s : fail to write CMD : DISPLAY_ON\n", __func__);
goto displayon_err;
}
msleep(20);
ret = dsim_write_hl_data(dsim, SEQ_BRIGHTNESS_1, ARRAY_SIZE(SEQ_BRIGHTNESS_1));
if (ret < 0) {
dsim_err("%s : fail to write CMD : SEQ_BRIGHTNESS_1\n", __func__);
goto displayon_err;
}
ret = dsim_write_hl_data(dsim, SEQ_BRIGHTNESS_2, ARRAY_SIZE(SEQ_BRIGHTNESS_2));
if (ret < 0) {
dsim_err("%s : fail to write CMD : SEQ_BRIGHTNESS_2\n", __func__);
goto displayon_err;
}
ret = dsim_write_hl_data(dsim, SEQ_BRIGHTNESS_3, ARRAY_SIZE(SEQ_BRIGHTNESS_3));
if (ret < 0) {
dsim_err("%s : fail to write CMD : SEQ_BRIGHTNESS_3\n", __func__);
goto displayon_err;
}
displayon_err:
return ret;
}
static int s6e3ha0_wqhd_exit(struct dsim_device *dsim)
{
int ret = 0;
dsim_info("MDD : %s was called\n", __func__);
ret = dsim_write_hl_data(dsim, SEQ_DISPLAY_OFF, ARRAY_SIZE(SEQ_DISPLAY_OFF));
if (ret < 0) {
dsim_err("%s : fail to write CMD : DISPLAY_OFF\n", __func__);
goto exit_err;
}
msleep(10);
ret = dsim_write_hl_data(dsim, SEQ_SLEEP_IN, ARRAY_SIZE(SEQ_SLEEP_IN));
if (ret < 0) {
dsim_err("%s : fail to write CMD : SLEEP_IN\n", __func__);
goto exit_err;
}
msleep(120);
exit_err:
return ret;
}
static void dsim_panel_set_elvss(struct dsim_device *dsim)
{
u8 *elvss = NULL;
unsigned char SEQ_ELVSS[ELVSS_LEN_MAX] = {0, };
struct panel_private *panel = &dsim->priv;
bool bIsHbm = (LEVEL_IS_HBM(panel->auto_brightness) && (panel->bd->props.brightness == panel->bd->props.max_brightness));
SEQ_ELVSS[0] = aid_dimming_dynamic.elvss_reg;
elvss = get_elvss_from_index(dsim, dsim->priv.br_index, dsim->priv.caps_enable);
if (elvss == NULL) {
dsim_err("%s : failed to get elvss value\n", __func__);
return;
}
memcpy(&SEQ_ELVSS[1], dsim->priv.elvss_set, aid_dimming_dynamic.elvss_len - 1);
memcpy(SEQ_ELVSS, elvss, aid_dimming_dynamic.elvss_cmd_cnt);
SEQ_ELVSS[aid_dimming_dynamic.elvss_len - 1] += dsim_panel_get_elvssoffset(dsim);
if(bIsHbm)
SEQ_ELVSS[2] = 0x0A;
if(dynamic_lcd_type == LCD_TYPE_S6E3HA2_WQHD) {
dsim_info("%s elvss ha2\n", __func__);
if (dsim_write_hl_data(dsim, SEQ_ELVSS, aid_dimming_dynamic.elvss_len) < 0)
dsim_err("%s : failed to write elvss \n", __func__);
} else {
dsim_info("%s elvss ha3/hf3\n", __func__);
memcpy(dsim->priv.tset, &SEQ_ELVSS[1], aid_dimming_dynamic.elvss_len - 1);
dsim_panel_set_tset(dsim, 1);
}
}
static int s6d7aa0x62_exit(struct dsim_device *dsim)
{
int ret = 0;
dsim_info("MDD : %s was called\n", __func__);
ret = dsim_write_hl_data(dsim, SEQ_DISPLAY_OFF, ARRAY_SIZE(SEQ_DISPLAY_OFF));
if (ret < 0) {
dsim_err("%s : fail to write CMD : DISPLAY_OFF\n", __func__);
goto exit_err;
}
msleep(10);
ret = dsim_write_hl_data(dsim, SEQ_SLEEP_IN, ARRAY_SIZE(SEQ_SLEEP_IN));
if (ret < 0) {
dsim_err("%s : fail to write CMD : SLEEP_IN\n", __func__);
goto exit_err;
}
msleep(150);
ret = gpio_request_one(backlight_on, GPIOF_OUT_INIT_LOW, "BLIC_ON");
gpio_free(backlight_on);
usleep_range(10000, 11000);
exit_err:
return ret;
}
static int dsim_panel_set_acl(struct dsim_device *dsim, int force)
{
int ret = 0, level = ACL_STATUS_8P;
struct panel_private *panel = &dsim->priv;
if (panel == NULL) {
dsim_err("%s : panel is NULL\n", __func__);
goto exit;
}
if (dsim->priv.siop_enable || LEVEL_IS_HBM(dsim->priv.auto_brightness)) // auto acl or hbm is acl on
goto acl_update;
if (!dsim->priv.acl_enable)
level = ACL_STATUS_0P;
acl_update:
if(force || dsim->priv.current_acl != panel->acl_cutoff_tbl[level][1]) {
if((ret = dsim_write_hl_data(dsim, panel->acl_opr_tbl[level], 2)) < 0) {
dsim_err("fail to write acl opr command.\n");
goto exit;
}
if((ret = dsim_write_hl_data(dsim, panel->acl_cutoff_tbl[level], 2)) < 0) {
dsim_err("fail to write acl command.\n");
goto exit;
}
dsim->priv.current_acl = panel->acl_cutoff_tbl[level][1];
dsim_info("acl: %d, auto_brightness: %d\n", dsim->priv.current_acl, dsim->priv.auto_brightness);
}
exit:
if (!ret)
ret = -EPERM;
return ret;
}
static void dsim_panel_aid_ctrl_for_hmt(struct dsim_device *dsim)
{
u8 *aid = NULL;
aid = get_aid_from_index_for_hmt(dsim, dsim->priv.hmt_br_index);
if (aid == NULL) {
dsim_err("%s : faield to get aid value\n", __func__);
return;
}
if (dsim_write_hl_data(dsim, aid, AID_CMD_CNT + 1) < 0)
dsim_err("%s : failed to write hmt aid \n", __func__);
}
static void dsim_panel_gamma_ctrl_for_hmt(struct dsim_device *dsim)
{
u8 *gamma = NULL;
gamma = get_gamma_from_index_for_hmt(dsim, dsim->priv.hmt_br_index);
if (gamma == NULL) {
dsim_err("%s :faied to get gamma\n", __func__);
return;
}
if (dsim_write_hl_data(dsim, gamma, GAMMA_CMD_CNT) < 0)
dsim_err("%s : failed to write hmt gamma \n", __func__);
}
static int dsim_reg_get_dphy_timing(unsigned long hs_clk, unsigned long esc_clk, struct dphy_timing_value *t)
{
int i = sizeof(dphy_timing) / sizeof(dphy_timing[0]) - 1;
while (i) {
if ((dphy_timing[i][0] * MHZ) < hs_clk) {
i--;
continue;
} else {
t->bps = hs_clk;
t->clk_prepare = dphy_timing[i][1];
t->clk_zero = dphy_timing[i][2];
t->clk_post = dphy_timing[i][3];
t->clk_trail = dphy_timing[i][4];
t->hs_prepare = dphy_timing[i][5];
t->hs_zero = dphy_timing[i][6];
t->hs_trail = dphy_timing[i][7];
t->lpx = dphy_timing[i][8];
t->hs_exit = dphy_timing[i][9];
t->m_pllctl = dphy_timing[i][10];
break;
}
}
if (!i) {
dsim_err("%ld hs clock can't find proper dphy timing values\n", hs_clk);
return -EINVAL;
}
if ((esc_clk > 20 * MHZ) || (esc_clk < 7 * MHZ)) {
dsim_err("%ld can't be used as escape clock\n", esc_clk);
return -EINVAL;
}
i = sizeof(b_dphyctl) / sizeof(b_dphyctl[0]) - 1;
while (i) {
if ((b_dphyctl[i][0] * MHZ) < esc_clk) {
i--;
continue;
} else {
t->b_dphyctl = b_dphyctl[i][1];
break;
}
}
if (!i) {
dsim_err("%ld esc clock can't find proper dphy timing values\n", esc_clk);
return -EINVAL;
}
return 0;
}
static int dsim_panel_probe(struct dsim_device *dsim)
{
int ret = 0;
struct panel_private *panel = &dsim->priv;
#if defined(CONFIG_EXYNOS_DECON_MDNIE_LITE)
u16 coordinate[2] = {0, };
#endif
dsim->lcd = lcd_device_register("panel", dsim->dev, &dsim->priv, NULL);
if (IS_ERR(dsim->lcd)) {
dsim_err("%s : faield to register lcd device\n", __func__);
ret = PTR_ERR(dsim->lcd);
goto probe_err;
}
ret = dsim_backlight_probe(dsim);
if (ret) {
dsim_err("%s : failed to prbe backlight driver\n", __func__);
goto probe_err;
}
panel->lcdConnected = PANEL_CONNECTED;
panel->state = PANEL_STATE_RESUMED;
panel->temperature = NORMAL_TEMPERATURE;
panel->acl_enable = 0;
panel->current_acl = 0;
panel->auto_brightness = 0;
panel->siop_enable = 0;
panel->current_hbm = 0;
panel->current_vint = 0;
mutex_init(&panel->lock);
#ifdef CONFIG_EXYNOS_DECON_LCD_MCD
panel->mcd_on = 0;
#endif
if (panel->ops->probe) {
ret = panel->ops->probe(dsim);
if (ret) {
dsim_err("%s : failed to probe panel\n", __func__);
goto probe_err;
}
}
#if defined(CONFIG_EXYNOS_DECON_LCD_SYSFS)
lcd_init_sysfs(dsim);
#endif
#if defined(CONFIG_EXYNOS_DECON_MDNIE_LITE)
coordinate[0] = (u16)panel->coordinate[0];
coordinate[1] = (u16)panel->coordinate[1];
mdnie_register(&dsim->lcd->dev, dsim, (mdnie_w)mdnie_lite_send_seq, (mdnie_r)mdnie_lite_read, coordinate, &tune_info);
#endif
probe_err:
return ret;
}
static int get_acutal_br_index_for_hmt(struct dsim_device *dsim, int br)
{
int i;
int min;
int gap;
int index = 0;
struct panel_private *panel = &dsim->priv;
struct SmtDimInfo *dimming_info = panel->hmt_dim_info;
if (dimming_info == NULL) {
dsim_err("%s : dimming_info is NULL\n", __func__);
return 0;
}
min = HMT_MAX_BRIGHTNESS;
for (i = 0; i < MAX_BR_INFO; i++) {
if (br > dimming_info[i].br)
gap = br - dimming_info[i].br;
else
gap = dimming_info[i].br - br;
if (gap == 0) {
index = i;
break;
}
if (gap < min) {
min = gap;
index = i;
}
}
return index;
}
void dsim_reg_set_config(u32 mode, u32 data_lane_cnt)
{
u32 val;
u32 mask;
if (mode == VIDEO_MODE) {
val = DSIM_CONFIG_VIDEO_MODE | DSIM_CONFIG_BURST_MODE |
DSIM_CONFIG_HFP_DISABLE | DSIM_CONFIG_MFLUSH_VS;
} else if (mode == COMMAND_MODE) {
val = DSIM_CONFIG_CLKLANE_STOP_START; /* In Command mode Clk lane stop disable */
} else {
dsim_err("This DDI is not MIPI interface.\n");
return;
}
val |= DSIM_CONFIG_EOT_R03_DISABLE |
DSIM_CONFIG_NUM_OF_DATA_LANE(data_lane_cnt - 1) |
DSIM_CONFIG_PIXEL_FORMAT(DSIM_PIXEL_FORMAT_RGB24);
mask = DSIM_CONFIG_CLKLANE_STOP_START | DSIM_CONFIG_MFLUSH_VS | DSIM_CONFIG_EOT_R03_DISABLE |
DSIM_CONFIG_BURST_MODE | DSIM_CONFIG_VIDEO_MODE | DSIM_CONFIG_HFP_DISABLE |
DSIM_CONFIG_PIXEL_FORMAT_MASK | DSIM_CONFIG_NUM_OF_DATA_LANE_MASK;
dsim_write_mask(DSIM_CONFIG, val, mask);
}
void lcd_enable()
{
int id = 0;
if (dsim_wr_data(id, MIPI_DSI_DCS_SHORT_WRITE,
SEQ_DISPLAY_ON[0], 0) < 0)
dsim_err("fail to send SEQ_DISPLAY_ON command.\n");
}
static void dsim_panel_set_elvss(struct dsim_device *dsim)
{
u8 *elvss = NULL;
unsigned char SEQ_ELVSS[ELVSS_LEN] = {ELVSS_REG, };
elvss = get_elvss_from_index(dsim, dsim->priv.br_index, dsim->priv.caps_enable);
if (elvss == NULL) {
dsim_err("%s : failed to get elvss value\n", __func__);
return;
}
memcpy(&SEQ_ELVSS[1], dsim->priv.elvss_set, ELVSS_LEN - 1);
memcpy(SEQ_ELVSS, elvss, ELVSS_CMD_CNT);
SEQ_ELVSS[ELVSS_LEN - 1] += dsim_panel_get_elvssoffset(dsim);
if (dsim_write_hl_data(dsim, SEQ_ELVSS, ELVSS_LEN) < 0)
dsim_err("%s : failed to write elvss \n", __func__);
}
static void dsim_panel_aid_ctrl(struct dsim_device *dsim)
{
u8 *aid = NULL;
unsigned char SEQ_AID[AID_CMD_CNT_MAX] = { 0, };
aid = get_aid_from_index(dsim, dsim->priv.br_index);
if (aid == NULL) {
dsim_err("%s : failed to get elvss value\n", __func__);
return;
}
SEQ_AID[0] = aid[0];
memcpy(&SEQ_AID[1], dsim->priv.aid, aid_dimming_dynamic.aid_cmd_cnt - 1); // HA2/HF3 not read. but no danger
memcpy(&SEQ_AID[aid_dimming_dynamic.aid_reg_offset], aid + 1, aid_dimming_dynamic.aid_cmd_cnt - aid_dimming_dynamic.aid_reg_offset + 1);
if (dsim_write_hl_data(dsim, SEQ_AID, aid_dimming_dynamic.aid_cmd_cnt) < 0)
dsim_err("%s : failed to write aid \n", __func__);
}
u32 dsim_reg_wait_lane_stop_state(u32 id)
{
u32 state;
u32 cnt = 100;
do {
state = dsim_reg_is_lane_stop_state(id);
cnt--;
} while (!state && cnt);
if (!cnt) {
dsim_err("wait timeout DSI Master is not stop state.\n");
dsim_err("check initialization process.\n");
return -EBUSY;
}
return 0;
}
static void dsim_panel_dynamic_aid_ctrl(struct dsim_device *dsim)
{
u8 aid[S6E3HF3_AID_CMD_CNT] = { 0, };
int index = 0;
int current_pbr;
struct panel_private *panel = &dsim->priv;
struct SmtDimInfo *dimming_info = (struct SmtDimInfo *)panel->dim_info;
if (dynamic_lcd_type == LCD_TYPE_S6E3HF3_WQHD) {
memcpy(aid, S6E3HF3_SEQ_AOR, sizeof(S6E3HF3_SEQ_AOR));
} else {
memcpy(aid, S6E3HA3_SEQ_AOR, sizeof(S6E3HA3_SEQ_AOR));
}
if (dimming_info == NULL) {
dsim_err("%s : dimming info is NULL\n", __func__);
goto aid_ctrl_err;
}
current_pbr = panel->bd->props.brightness;
index = dsim->priv.br_index + 1;
if (index > MAX_BR_INFO)
index = MAX_BR_INFO;
if (panel->inter_aor_tbl == NULL)
return;
aid[9] = panel->inter_aor_tbl[current_pbr * 2];
aid[10] = panel->inter_aor_tbl[current_pbr * 2 + 1];
dsim_info("%s %d aid : %x : %x : %x\n", __func__, current_pbr, aid[0], aid[9], aid[10]);
if (dynamic_lcd_type == LCD_TYPE_S6E3HF3_WQHD) {
if (dsim_write_hl_data(dsim, aid, S6E3HF3_AID_CMD_CNT) < 0)
dsim_err("%s : failed to write gamma \n", __func__);
} else {
if (dsim_write_hl_data(dsim, aid, S6E3HA3_AID_CMD_CNT) < 0)
dsim_err("%s : failed to write gamma \n", __func__);
}
aid_ctrl_err:
return;
}
static void dsim_panel_set_elvss_for_hmt(struct dsim_device *dsim)
{
u8 *elvss = NULL;
unsigned char SEQ_ELVSS[ELVSS_LEN] = {ELVSS_REG, };
elvss = get_elvss_from_index_for_hmt(dsim, dsim->priv.hmt_br_index, dsim->priv.acl_enable);
if (elvss == NULL) {
dsim_err("%s : failed to get elvss value\n", __func__);
return;
}
memcpy(&SEQ_ELVSS[1], dsim->priv.elvss_set, ELVSS_LEN - 1);
memcpy(SEQ_ELVSS, elvss, ELVSS_CMD_CNT);
if(UNDER_MINUS_20(dsim->priv.temperature)) // tset
SEQ_ELVSS[ELVSS_LEN - 1] -= TSET_MINUS_OFFSET;
if (dsim_write_hl_data(dsim, SEQ_ELVSS, ELVSS_LEN) < 0)
dsim_err("%s : failed to write elvss \n", __func__);
}
static int dsim_panel_set_acl(struct dsim_device *dsim, int force)
{
int ret = 0, level, enabled;
struct panel_private *panel = &dsim->priv;
if (panel == NULL) {
dsim_err("%s : panel is NULL\n", __func__);
goto exit;
}
level = ACL_OPR_15P;
enabled = ACL_STATUS_ON;
// siop = weak temperature
if (panel->siop_enable) // auto acl or hbm is acl on
goto acl_update;
level = dsim->priv.acl_enable;
enabled = (dsim->priv.acl_enable != ACL_OPR_OFF);
acl_update:
if(force || dsim->priv.current_acl != level) {
// dsim_info("acl : opr_tbl %d %d %02x %02x %02x %02x %02x\n", level, (int) ACL_OPR_LEN, panel->acl_opr_tbl[level][0], panel->acl_opr_tbl[level][1], panel->acl_opr_tbl[level][2], panel->acl_opr_tbl[level][3], panel->acl_opr_tbl[level][4] );
if((ret = dsim_write_hl_data(dsim, panel->acl_opr_tbl[level], ACL_OPR_LEN)) < 0) {
dsim_err("fail to write acl opr command.\n");
goto exit;
}
// dsim_info("acl : cutoff_tbl %d %d %02x %02x \n", enabled, (int) ACL_CMD_LEN, panel->acl_cutoff_tbl[enabled][0], panel->acl_cutoff_tbl[enabled][1] );
if((ret = dsim_write_hl_data(dsim, panel->acl_cutoff_tbl[enabled], ACL_CMD_LEN)) < 0) {
dsim_err("fail to write acl command.\n");
goto exit;
}
dsim->priv.current_acl = level;
dsim_info("acl : %x, opr: %x\n",
panel->acl_cutoff_tbl[enabled][1], panel->acl_opr_tbl[level][ACL_OPR_LEN-1]);
dsim_info("acl: %d(%x), auto_brightness: %d\n", dsim->priv.current_acl, panel->acl_opr_tbl[level][ACL_OPR_LEN-1],dsim->priv.auto_brightness);
}
exit:
if (!ret)
ret = -EPERM;
return ret;
}
int lm3632_array_write(const struct LM3632_rom_data * eprom_ptr, int eprom_size) {
int i = 0;
int ret = 0;
for (i = 0; i < eprom_size; i++) {
ret = i2c_smbus_write_byte_data(backlight_client, eprom_ptr[i].addr, eprom_ptr[i].val);
if (ret < 0)
dsim_err(":%s error : BL DEVICE_CTRL setting fail : %d \n", __func__, ret);
}
return 0;
}
static int dsim_panel_displayon(struct dsim_device *dsim)
{
int ret = 0;
struct panel_private *panel = &dsim->priv;
#ifdef CONFIG_LCD_ALPM
if (variant_edge == IS_EDGE)
mutex_lock(&panel->alpm_lock);
#endif
if (panel->state == PANEL_STATE_SUSPENED) {
if (panel->ops->init) {
ret = panel->ops->init(dsim);
if (ret) {
dsim_err("%s : failed to panel init\n", __func__);
goto displayon_err;
}
}
panel->state = PANEL_STATE_RESUMED;
}
#ifdef CONFIG_LCD_HMT
if(panel->hmt_on == HMT_ON)
hmt_set_mode(dsim, true);
#endif
dsim_panel_set_brightness(dsim, 1);
if (panel->ops->displayon) {
ret = panel->ops->displayon(dsim);
if (ret) {
dsim_err("%s : failed to panel display on\n", __func__);
goto displayon_err;
}
}
displayon_err:
#ifdef CONFIG_LCD_ALPM
if (variant_edge == IS_EDGE)
mutex_unlock(&panel->alpm_lock);
#endif
return ret;
}
static int dsim_panel_set_hbm(struct dsim_device *dsim, int force)
{
int ret = 0, level = LEVEL_IS_HBM(dsim->priv.auto_brightness);
struct panel_private *panel = &dsim->priv;
if (panel == NULL) {
dsim_err("%s : panel is NULL\n", __func__);
goto exit;
}
if(force || dsim->priv.current_hbm != panel->hbm_tbl[level][1]) {
dsim->priv.current_hbm = panel->hbm_tbl[level][1];
if((ret = dsim_write_hl_data(dsim, panel->hbm_tbl[level], ARRAY_SIZE(SEQ_HBM_OFF))) < 0) {
dsim_err("fail to write hbm command.\n");
ret = -EPERM;
}
dsim_info("hbm: %d, auto_brightness: %d\n", dsim->priv.current_hbm, dsim->priv.auto_brightness);
}
exit:
return ret;
}
static int low_level_set_brightness_for_hmt(struct dsim_device *dsim ,int force)
{
if (dsim_write_hl_data(dsim, SEQ_TEST_KEY_ON_F0, ARRAY_SIZE(SEQ_TEST_KEY_ON_F0)) < 0)
dsim_err("%s : fail to write F0 on command.\n", __func__);
if (dsim_write_hl_data(dsim, SEQ_TEST_KEY_ON_FC, ARRAY_SIZE(SEQ_TEST_KEY_ON_FC)) < 0)
dsim_err("%s : fail to write F0 on command.\n", __func__);
dsim_panel_gamma_ctrl_for_hmt(dsim);
dsim_panel_aid_ctrl_for_hmt(dsim);
dsim_panel_set_elvss_for_hmt(dsim);
dsim_panel_set_vint(dsim, force);
if (dsim_write_hl_data(dsim, SEQ_GAMMA_UPDATE, ARRAY_SIZE(SEQ_GAMMA_UPDATE)) < 0)
dsim_err("%s : failed to write gamma \n", __func__);
if (dsim_write_hl_data(dsim, SEQ_GAMMA_UPDATE_L, ARRAY_SIZE(SEQ_GAMMA_UPDATE_L)) < 0)
dsim_err("%s : failed to write gamma \n", __func__);
dsim_panel_set_acl(dsim, force);
dsim_panel_set_tset(dsim, force);
if (dsim_write_hl_data(dsim, SEQ_TEST_KEY_OFF_FC, ARRAY_SIZE(SEQ_TEST_KEY_OFF_FC)) < 0)
dsim_err("%s : fail to write F0 on command.\n", __func__);
if (dsim_write_hl_data(dsim, SEQ_TEST_KEY_OFF_F0, ARRAY_SIZE(SEQ_TEST_KEY_OFF_F0)) < 0)
dsim_err("%s : fail to write F0 on command\n", __func__);
return 0;
}
/*
* Set gamma values
*
* Parameter
* - backlightlevel : It is from 0 to 26.
*/
int lcd_gamma_ctrl(u32 backlightlevel)
{
int ret;
ret = dsim_wr_data(MIPI_DSI_DCS_LONG_WRITE, (u32)gamma22_table[backlightlevel],
GAMMA_PARAM_SIZE);
if (ret) {
dsim_err("fail to write gamma value.\n");
return ret;
}
return 0;
}
int lcd_gamma_update(void)
{
int ret;
ret = dsim_wr_data(MIPI_DSI_DCS_LONG_WRITE, (u32)SEQ_GAMMA_UPDATE,
ARRAY_SIZE(SEQ_GAMMA_UPDATE));
if (ret) {
dsim_err("fail to update gamma value.\n");
return ret;
}
return 0;
}
static void dsim_panel_set_elvss(struct dsim_device *dsim)
{
u8 *elvss = NULL;
unsigned char SEQ_ELVSS[ELVSS_LEN_MAX] = {0, };
struct panel_private *panel = &dsim->priv;
bool bIsHbm = (LEVEL_IS_HBM(panel->auto_brightness) && (panel->bd->props.brightness == panel->bd->props.max_brightness));
SEQ_ELVSS[0] = ELVSS_REG;
elvss = get_elvss_from_index(dsim, dsim->priv.br_index, dsim->priv.caps_enable);
if (elvss == NULL) {
dsim_err("%s : failed to get elvss value\n", __func__);
return;
}
memcpy(&SEQ_ELVSS[1], dsim->priv.elvss_set, ELVSS_LEN - 1);
memcpy(SEQ_ELVSS, elvss, ELVSS_CMD_CNT);
SEQ_ELVSS[ELVSS_LEN - 1] += dsim_panel_get_elvssoffset(dsim);
if(bIsHbm ||
((panel->interpolation) && (panel->weakness_hbm_comp == HBM_COLORBLIND_ON)))
SEQ_ELVSS[2] = 0x0A;
if (dsim_write_hl_data(dsim, SEQ_ELVSS, ELVSS_LEN) < 0)
dsim_err("%s : failed to write elvss \n", __func__);
}
static int dsim_reg_get_dphy_timing(u32 hs_clk, u32 esc_clk, struct dphy_timing_value *t)
{
int i = sizeof(dphy_timing) / sizeof(dphy_timing[0]) - 1;
while (i) {
if (dphy_timing[i][0] < hs_clk) {
i--;
continue;
} else {
t->bps = hs_clk;
t->clk_prepare = dphy_timing[i][1];
t->clk_zero = dphy_timing[i][2];
t->clk_post = dphy_timing[i][3];
t->clk_trail = dphy_timing[i][4];
t->hs_prepare = dphy_timing[i][5];
t->hs_zero = dphy_timing[i][6];
t->hs_trail = dphy_timing[i][7];
t->lpx = dphy_timing[i][8];
t->hs_exit = dphy_timing[i][9];
break;
}
}
if (!i) {
dsim_err("%u Mhz hs clock can't find proper dphy timing values\n", hs_clk);
return -EINVAL;
}
if ((esc_clk > 20) || (esc_clk < 7)) {
dsim_err("%u Mhz cann't be used as escape clock\n", esc_clk);
return -EINVAL;
}
t->b_dphyctl = b_dphyctl[esc_clk - 7];
return 0;
}
int lcd_gamma_update()
{
int id = 0;
int ret;
ret = dsim_wr_data(id, MIPI_DSI_DCS_LONG_WRITE,
(unsigned long)SEQ_GAMMA_UPDATE,
ARRAY_SIZE(SEQ_GAMMA_UPDATE));
if (ret) {
dsim_err("fail to update gamma value.\n");
return ret;
}
return 0;
}
static int s6e3ha0_wqhd_displayon(struct dsim_device *dsim)
{
int ret = 0;
dsim_info("MDD : %s was called\n", __func__);
ret = dsim_write_hl_data(dsim, SEQ_DISPLAY_ON, ARRAY_SIZE(SEQ_DISPLAY_ON));
if (ret < 0) {
dsim_err("%s : fail to write CMD : DISPLAY_ON\n", __func__);
goto displayon_err;
}
displayon_err:
return ret;
}
int dsim_panel_set_brightness_for_hmt(struct dsim_device *dsim, int force)
{
int ret = 0;
#ifndef CONFIG_PANEL_AID_DIMMING
dsim_info("%s:this panel does not support dimming \n", __func__);
#else
struct dim_data *dimming;
struct panel_private *panel = &dsim->priv;
int p_br = panel->hmt_brightness;
int acutal_br = 0;
int prev_index = panel->hmt_br_index;
dimming = (struct dim_data *)panel->hmt_dim_data;
if ((dimming == NULL) || (panel->hmt_br_tbl == NULL)) {
dsim_info("%s : this panel does not support dimming\n", __func__);
return ret;
}
acutal_br = panel->hmt_br_tbl[p_br];
panel->acl_enable = 0;
panel->hmt_br_index = get_acutal_br_index_for_hmt(dsim, acutal_br);
if(panel->siop_enable) // check auto acl
panel->acl_enable = 1;
if (panel->state != PANEL_STATE_RESUMED) {
dsim_info("%s : panel is not active state..\n", __func__);
goto set_br_exit;
}
if (!force && panel->hmt_br_index == prev_index)
goto set_br_exit;
dsim_info("%s : req : %d : nit : %d index : %d\n",
__func__, p_br, acutal_br, panel->hmt_br_index);
if (acutal_br == 0)
goto set_br_exit;
mutex_lock(&panel->lock);
ret = low_level_set_brightness_for_hmt(dsim, force);
if (ret) {
dsim_err("%s failed to hmt set brightness : %d\n", __func__, acutal_br);
}
mutex_unlock(&panel->lock);
set_br_exit:
#endif
return ret;
}
static int dsim_panel_set_vint(struct dsim_device *dsim, int force)
{
int ret = 0;
int nit = 0;
int i, level = 0;
int arraySize = ARRAY_SIZE(VINT_DIM_TABLE);
struct panel_private* panel = &(dsim->priv);
unsigned char SEQ_VINT[VINT_LEN] = {VINT_REG, 0x8B, 0x21};
unsigned char *vint_tbl = (unsigned char *)VINT_TABLE;
#if defined(CONFIG_PANEL_S6E3HF2_DYNAMIC) // edge
unsigned char panelline = panel->id[0] & 0xc0;
if (panel->a3_vint_updated && panelline == S6E3HF2_A3_LINE_ID) {
vint_tbl = panel->a3_vint;
}
#endif
level = arraySize - 1;
if(UNDER_MINUS_20(panel->temperature))
goto set_vint;
#ifdef CONFIG_LCD_HMT
if(panel->hmt_on == HMT_ON)
goto set_vint;
#endif
nit = get_actual_br_value(dsim, panel->br_index);
level = arraySize - 1;
for (i = 0; i < arraySize; i++) {
if (nit <= VINT_DIM_TABLE[i]) {
level = i;
goto set_vint;
}
}
set_vint:
if(force || panel->current_vint != vint_tbl[level]) {
SEQ_VINT[VINT_LEN - 1] = vint_tbl[level];
if ((ret = dsim_write_hl_data(dsim, SEQ_VINT, ARRAY_SIZE(SEQ_VINT))) < 0) {
dsim_err("fail to write vint command.\n");
ret = -EPERM;
}
panel->current_vint = vint_tbl[level];
dsim_info("vint: %02x\n", panel->current_vint);
}
return ret;
}
