static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
#ifdef CONFIG_POWERSUSPEND
set_power_suspend_state_panel_hook(POWER_SUSPEND_INACTIVE);
#endif
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
mipi = &pdata->panel_info.mipi;
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
if (ctrl->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->on_cmds);
pr_info("%s\n", __func__);
return 0;
}
int mdss_dsi_panel_ief_on(void)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata_base == NULL || mfd_base == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
if (mfd_base->panel_power_on == 0) {
pr_err("%s: Panel is off\n", __func__);
return -EPERM;
}
ctrl = container_of(pdata_base, struct mdss_dsi_ctrl_pdata, panel_data);
if(lge_ief_on_cmds.cmd_cnt){
pr_info("sending IEF_ON code\n");
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false);
mdss_dsi_panel_cmds_send(ctrl, &lge_ief_on_cmds);
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false);
}
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
#ifdef CONFIG_SHLCDC_BOARD /* CUST_ID_00007 */
mdss_shdisp_dsi_panel_off();
return 0;
#else
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
pr_debug("%s:-\n", __func__);
return 0;
#endif /* CONFIG_SHLCDC_BOARD */
}
static void send_local_on_cmds(struct work_struct *work)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (cmds_panel_data == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return;
}
ctrl = container_of(cmds_panel_data, struct mdss_dsi_ctrl_pdata,
panel_data);
/* Prevent flicker during continous splash */
if (cmds_panel_data->panel_info.cont_splash_enabled)
return;
mdss_mdp_cmds_send(1);
gpio_set_value((ctrl->rst_gpio), 0);
udelay(200);
gpio_set_value((ctrl->rst_gpio), 1);
msleep(20);
if (ctrl->ctrl_state & CTRL_STATE_PANEL_INIT)
ctrl->ctrl_state &= ~CTRL_STATE_PANEL_INIT;
if (local_pdata->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &local_pdata->on_cmds);
mdss_mdp_cmds_send(0);
pr_info("%s\n", __func__);
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (!gpio_get_value(ctrl->disp_en_gpio))
return 0;
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
mutex_unlock(&panel_cmd_mutex);
#ifdef CONFIG_POWERSUSPEND
set_power_suspend_state_panel_hook(POWER_SUSPEND_ACTIVE);
#endif
pr_info("%s:\n", __func__);
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
panel_power_state = 0;
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_info("%s: ctrl ndx=%d ++ \n", __func__, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (ctrl->ndx == DSI_CTRL_1) {
pwm_backlight_disable();
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
}
pr_info("%s: ctrl ndx=%d -- \n", __func__, ctrl->ndx);
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_info("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
#if defined(CONFIG_MACH_LGE)
if (!gpio_get_value(ctrl->disp_en_gpio)) // we should remove the semi-colon
return 0;
#endif
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
pr_debug("%s:-\n", __func__);
#ifdef CONFIG_OLED_SUPPORT
pr_info("[Zee][OLED] %s success\n", __func__);
#endif
return 0;
}
static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
static int first_boot = 1;
#endif
msd.mfd = (struct msm_fb_data_type *)registered_fb[0]->par;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
msd.mpd = pdata;
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
printk("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
if (ctrl->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->on_cmds);
msd.mfd->resume_state = MIPI_RESUME_STATE;
#if defined(CONFIG_MDNIE_LITE_TUNING) || defined(CONFIG_MDNIE_VIDEO_ENHANCED)
is_negative_on();
#endif
#if defined(CONFIG_BACKLIGHT_IC_KTD2801)
mdelay(2);
if (gpio_is_valid(msd.bl_ap_pwm)) {
gpio_tlmm_config(GPIO_CFG(msd.bl_ap_pwm,3, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_2MA), GPIO_CFG_ENABLE);
}
if((fisrt_boot_bl==1) && (lcd_connected_status ==1)){
#ifdef EXPRESSWIRED
ktd_backlight_set_brightness(BL_MAX_BRIGHTNESS_LEVEL);
#else
mdss_dsi_panel_bklt_pwm(BL_MAX_BRIGHTNESS_LEVEL);
#endif
fisrt_boot_bl=0;
}
#endif
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
if(first_boot) {
int rc;
INIT_WORK(&err_fg_work, err_fg_work_func);
rc = request_threaded_irq(err_fg_gpio, NULL, err_fg_irq_handler,
IRQF_TRIGGER_LOW | IRQF_ONESHOT, "esd_detect", NULL);
if (rc) {
pr_err("%s : Failed to request_irq. :ret=%d", __func__, rc);
}
first_boot = 0;
}
enable_irq(err_fg_gpio);
#endif
pr_err("%s:-\n", __func__);
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (!gpio_get_value(ctrl->disp_en_gpio))
return 0;
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
pr_info("%s:\n", __func__);
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
#ifdef CONFIG_TOUCHSCREEN_PREVENT_SLEEP
#if defined(CONFIG_TOUCHSCREEN_SWEEP2WAKE) || defined(CONFIG_TOUCHSCREEN_DOUBLETAP2WAKE)
bool prevent_sleep = false;
#endif
#if defined(CONFIG_TOUCHSCREEN_SWEEP2WAKE)
prevent_sleep = (s2w_switch > 0);
#endif
#if defined(CONFIG_TOUCHSCREEN_DOUBLETAP2WAKE)
prevent_sleep = prevent_sleep || (dt2w_switch > 0);
#endif
if (prevent_sleep && in_phone_call)
prevent_sleep = false;
#endif
#ifdef CONFIG_PWRKEY_SUSPEND
if (pwrkey_pressed)
prevent_sleep = false;
#endif
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (!gpio_get_value(ctrl->disp_en_gpio))
return 0;
#ifdef CONFIG_TOUCHSCREEN_PREVENT_SLEEP
if (prevent_sleep) {
ctrl->off_cmds.cmds[1].payload[0] = 0x11;
} else {
ctrl->off_cmds.cmds[1].payload[0] = 0x10;
}
#endif
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
#ifdef CONFIG_POWERSUSPEND
set_power_suspend_state_panel_hook(POWER_SUSPEND_ACTIVE);
#endif
pr_info("%s:\n", __func__);
return 0;
}
static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
static int first_boot=1;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
mipi = &pdata->panel_info.mipi;
pr_info("%s: ctrl index=%d ++ \n", __func__, ctrl->ndx);
if (ctrl->ndx == DSI_CTRL_1) {
if (ctrl->on_cmds.cmd_cnt) {
mdss_dsi_panel_cmds_send(ctrl, &ctrl->on_cmds);
}
panel_power_state = 1;
if(bl_backup)
mdss_dsi_panel_bl_ctrl(pdata, bl_backup);
pwm_backlight_enable();
if(first_boot) {
pr_info("%s: first backlight set to 150 level \n",
__func__);
mdss_dsi_panel_bl_ctrl(pdata, 150);
first_boot=0;
}
if (msd.dstat.recovery_boot_mode) {
pr_info("%s: Recovery Mode backlight set to 180 level \n",
__func__);
msd.dstat.bright_level = RECOVERY_BRIGHTNESS;
mdss_dsi_panel_bl_ctrl(pdata, RECOVERY_BRIGHTNESS);
} else {
#if defined(CONFIG_CABC_TUNING)
CABC_Set_Mode();
#endif
}
}
pr_info("%s: ctrl index=%d -- \n", __func__, ctrl->ndx);
return 0;
}
static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
#if defined(CONFIG_MACH_LGE)
if(pdata_base == NULL)
pdata_base = pdata;
#endif
mipi = &pdata->panel_info.mipi;
#ifdef CONFIG_LGE_SUPPORT_LCD_MAKER_ID
pr_info("%s: ctrl=%p ndx=%d maker=%d\n", __func__, ctrl, ctrl->ndx, get_panel_maker_id());
#else
pr_info("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
#endif
if (ctrl->on_cmds.cmd_cnt)
#ifdef CONFIG_LGE_LCD_TUNING
/* LGE_CHANGE
* Implement for LCD init sequence tuning
* 2013-01-25, [email protected]
*/
mdss_dsi_cmds_tx(pdata, &dsi_panel_tx_buf,
tun_dsi_panel_on_cmds,
num_of_on_cmds);
#else
mdss_dsi_panel_cmds_send(ctrl, &ctrl->on_cmds);
#ifdef CONFIG_OLED_SUPPORT
mdss_dsi_panel_img_tune_apply(IMG_TUNE_COUNT);
pr_info("[Zee][OLED] %s success\n", __func__);
#endif
#endif
pr_debug("%s:-\n", __func__);
return 0;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
#ifdef CONFIG_TOUCHSCREEN_PREVENT_SLEEP
#if defined(CONFIG_TOUCHSCREEN_SWEEP2WAKE) || defined(CONFIG_TOUCHSCREEN_DOUBLETAP2WAKE)
bool prevent_sleep = false;
#endif
#if defined(CONFIG_TOUCHSCREEN_SWEEP2WAKE)
prevent_sleep = (s2w_switch > 0);
#endif
#if defined(CONFIG_TOUCHSCREEN_DOUBLETAP2WAKE)
prevent_sleep = prevent_sleep || (dt2w_switch > 0);
#endif
#endif
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
mipi = &pdata->panel_info.mipi;
if (!gpio_get_value(ctrl->disp_en_gpio))
return 0;
#ifdef CONFIG_TOUCHSCREEN_PREVENT_SLEEP
if (prevent_sleep) {
ctrl->off_cmds.cmds[1].payload[0] = 0x11;
} else {
ctrl->off_cmds.cmds[1].payload[0] = 0x10;
}
pr_info("[prevent_touchscreen_sleep]: payload = %x \n", ctrl->off_cmds.cmds[1].payload[0]);
#endif
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
pr_info("%s:\n", __func__);
return 0;
}
static void send_local_on_cmds(struct work_struct *work)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (cmds_panel_data == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return;
}
ctrl = container_of(cmds_panel_data, struct mdss_dsi_ctrl_pdata,
panel_data);
mutex_lock(&panel_cmd_mutex);
if (local_pdata->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &local_pdata->on_cmds);
mutex_unlock(&panel_cmd_mutex);
pr_info("%s\n", __func__);
}
static ssize_t ce_tuning_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size) {
char *pt;
int a;
if (!get_panel_power_state()) {
pr_info("%s : Panel is off state", __func__);
return size;
}
if (sysfs_streq(buf, "1")) {
pr_info(" %s : ce enable\n", __func__);
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->ce_on_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->ce_on_cmds);
return size;
} else if (sysfs_streq(buf, "0")) {
pr_info(" %s : ce disable\n", __func__);
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->ce_off_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->ce_off_cmds);
return size;
}
/* echo "tuning file" */
memset(tuning_file, 0, sizeof(tuning_file));
snprintf(tuning_file, MAX_FILE_NAME, "%s%s", TUNING_FILE_PATH, buf);
pt = tuning_file;
while (*pt) {
if (*pt == '\r' || *pt == '\n') {
*pt = 0;
break;
}
pt++;
}
pr_info("%s:%s\n", __func__, tuning_file);
load_tuning_file(tuning_file);
for (a = 0; a < 33; a++) {
printk(KERN_INFO "0x%x = 0x%x ",
cabc_master_dsi_ctrl->ce_on_cmds.cmds[0].payload[a], cabc_tuning[a]);
cabc_master_dsi_ctrl->ce_on_cmds.cmds[0].payload[a] = cabc_tuning[a];
}
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->ce_on_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->ce_on_cmds);
return size;
}
int mdss_dsi_panel_img_tune_apply(unsigned int screen_mode)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata_base == NULL) {
pr_err("%s: Invalid input data.\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata_base, struct mdss_dsi_ctrl_pdata,
panel_data);
if (pdata_base->panel_info.panel_power_on == 0) {
pr_err("%s: panel off state. This screen mode will not be applied.\n", __func__);
return -EINVAL;
}
/*
if (ctrl->ctrl_state != (CTRL_STATE_PANEL_INIT | CTRL_STATE_MDP_ACTIVE)) {
pr_err("%s: panel is not 'on' state(cur=%d). The screen mode will be applied next time.\n", __func__, ctrl->ctrl_state);
return -EINVAL;
}
*/
if ((screen_mode < 0) || (screen_mode > IMG_TUNE_COUNT)) {
pr_err("%s: invalid input data(%d). Retry(0-5).\n", __func__, screen_mode);
return -EINVAL;
}
if (screen_mode == IMG_TUNE_COUNT) {
pr_info("%s: send the screen mode on(%d) from kernel.\n", __func__, img_tune_mode);
} else {
img_tune_mode = screen_mode;
pr_info("%s: send the screen mode on(%d) from user.\n", __func__, img_tune_mode);
}
if(img_tune_cmds_set->img_tune_cmds[img_tune_mode].cmd_cnt) {
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON, false);
// 0 : CM0 / 1 : CM0 + PLC 60% / 2 : CM1 / 3 : CM1 + PLC 60% / 4 : CM2 / 5 : CM2 + PLC 60%
mdss_dsi_panel_cmds_send(ctrl, &img_tune_cmds_set->img_tune_cmds[img_tune_mode]);
mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF, false);
}
return 0;
}
static int mdss_dsi_panel_on(struct mdss_panel_data *pdata)
{
struct mipi_panel_info *mipi;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
mipi = &pdata->panel_info.mipi;
pr_debug("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
if (local_pdata->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &local_pdata->on_cmds);
pr_info("%s\n", __func__);
return 0;
}
static ssize_t write_kgamma_send(struct device *dev,
struct device_attribute *attr,
const char *buf, size_t count)
{
int rc;
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
if (cmds_panel_data == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(cmds_panel_data, struct mdss_dsi_ctrl_pdata,
panel_data);
if (local_pdata->on_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &local_pdata->on_cmds);
pr_info("%s\n", __func__);
return rc;
}
static int mdss_dsi_panel_off(struct mdss_panel_data *pdata)
{
struct mdss_dsi_ctrl_pdata *ctrl = NULL;
msd.mfd = (struct msm_fb_data_type *)registered_fb[0]->par;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return -EINVAL;
}
ctrl = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
#if defined(CONFIG_ESD_ERR_FG_RECOVERY)
if (!err_fg_working) {
disable_irq_nosync(err_fg_gpio);
cancel_work_sync(&err_fg_work);
}
#endif
printk("%s: ctrl=%p ndx=%d\n", __func__, ctrl, ctrl->ndx);
#if defined(CONFIG_BACKLIGHT_IC_KTD2801)
if (gpio_is_valid(msd.bl_ap_pwm)) {
gpio_tlmm_config(GPIO_CFG(msd.bl_ap_pwm,0, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA), GPIO_CFG_DISABLE);
gpio_set_value(msd.bl_ap_pwm, 0);
}
#ifdef EXPRESSWIRED
ktd_backlight_set_brightness(0);
#endif
#endif
if (ctrl->off_cmds.cmd_cnt)
mdss_dsi_panel_cmds_send(ctrl, &ctrl->off_cmds);
msd.mfd->resume_state = MIPI_SUSPEND_STATE;
pr_debug("%s:-\n", __func__);
return 0;
}
static ssize_t cabc_tuning_store(struct device *dev,
struct device_attribute *attr, const char *buf, size_t size) {
char *pt;
int a, b;
if (!get_panel_power_state()) {
pr_info("%s : Panel is off state", __func__);
return size;
}
if (sysfs_streq(buf, "1")) {
cabc_master_dsi_ctrl->cabc_on_cmds.cmds[0].payload[1] = 0x01;
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->cabc_on_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->cabc_on_cmds);
return size;
} else if (sysfs_streq(buf, "80")) {
cabc_master_dsi_ctrl->cabc_on_cmds.cmds[0].payload[1] = 0x50;
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->cabc_on_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->cabc_on_cmds);
return size;
} else if (sysfs_streq(buf, "81")) {
cabc_master_dsi_ctrl->cabc_on_cmds.cmds[0].payload[1] = 0x51;
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->cabc_on_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->cabc_on_cmds);
return size;
} else if (sysfs_streq(buf, "5")) {
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->cabc_off_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->cabc_off_cmds);
return size;
}
/* echo "tuning file" */
memset(tuning_file, 0, sizeof(tuning_file));
snprintf(tuning_file, MAX_FILE_NAME, "%s%s", TUNING_FILE_PATH, buf);
pt = tuning_file;
while (*pt) {
if (*pt == '\r' || *pt == '\n') {
*pt = 0;
break;
}
pt++;
}
pr_info("%s:%s\n", __func__, tuning_file);
load_tuning_file(tuning_file);
//B8h, B9h
for (b = 0; b < 2; b++) {
for (a = 0; a < 7; a++) {
printk(KERN_INFO "0x%x = 0x%x ", cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[b].payload[a],
cabc_tuning[a + (b*7)]);
cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[b].payload[a] = cabc_tuning[a + (b*7)];
}
}
//53h
for (a = 0; a < 2; a++) {
printk(KERN_INFO "[53h]0x%x = 0x%x ", cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[2].payload[a],
cabc_tuning[14 + a]);
cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[2].payload[a] = cabc_tuning[14 + a];
}
//5Eh
for (a = 0; a < 2; a++) {
printk(KERN_INFO "[5Eh]0x%x = 0x%x ", cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[3].payload[a],
cabc_tuning[16 + a]);
cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[3].payload[a] = cabc_tuning[16 + a];
}
//CEh
for (a = 0; a < 24; a++) {
printk(KERN_INFO "[CEh]0x%x = 0x%x ", cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[4].payload[a],
cabc_tuning[18 + a]);
cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[4].payload[a] = cabc_tuning[18 + a];
}
//C1h
for (a = 0; a < 36; a++) {
printk(KERN_INFO "[C1h]0x%x = 0x%x ", cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[5].payload[a],
cabc_tuning[42 + a]);
cabc_master_dsi_ctrl->cabc_tune_cmds.cmds[5].payload[a] = cabc_tuning[42 + a];
}
mdss_dsi_panel_cmds_send(cabc_slave_dsi_ctrl, &cabc_slave_dsi_ctrl->cabc_tune_cmds);
mdss_dsi_panel_cmds_send(cabc_master_dsi_ctrl, &cabc_master_dsi_ctrl->cabc_tune_cmds);
return size;
}
