static void sending_tune_cmd(char *src, int len)
{
int data_pos;
int cmd_step = 0;
int cmd_pos = 0;
if (!get_panel_power_state()) {
pr_info("%s : Panel is off state", __func__);
return;
}
pr_info(" %s : len = %d\n", __func__, len);
for (data_pos = 0; data_pos < len;) {
if (*(src + data_pos) == '0') {
if (*(src + data_pos + 1) == 'x') {
if (!cmd_step) {
cabc_tuning[cmd_pos] =
char_to_dec(*(src + data_pos + 2),
*(src + data_pos + 3));
}
data_pos += 3;
cmd_pos++;
} else
data_pos++;
} else {
data_pos++;
}
}
pr_info(" =================== START ==================\n");
for (data_pos = 0; data_pos <cmd_pos; data_pos++)
printk(KERN_INFO "0x%x ", cabc_tuning[data_pos]);
pr_info(" =================== END ==================\n");
}
/* Using for CABC Key String */
static ssize_t store_cabc(struct device *dev,
struct device_attribute *dev_attr,
const char *buf, size_t count)
{
int ret;
unsigned int value;
ret = kstrtouint(buf, 10, &value);
if (ret)
return ret;
if (!get_panel_power_state()) {
pr_info("%s : Panel is off state", __func__);
return count;
}
if (value == CABC_OFF) {
cabc_tun_state.auto_br = CABC_AUTO_BR_OFF;
} else if (value == CABC_ON) {
cabc_tun_state.auto_br = CABC_AUTO_BR_ON;
cabc_tun_state.luxvalue = CABC_LUX_1;
} else {
pr_err("Undefied CABC On/Off value : %d\n\n", value);
return count;
}
CABC_Set_Mode();
return count;
}
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;
}
static void mdss_dsi_panel_bl_ctrl(struct mdss_panel_data *pdata,
u32 bl_level)
{
struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
if (pdata == NULL) {
pr_err("%s: Invalid input data\n", __func__);
return;
}
ctrl_pdata = container_of(pdata, struct mdss_dsi_ctrl_pdata,
panel_data);
if (!get_panel_power_state()) {
pr_info("%s : get_panel_power_state off", __func__);
return;
}
pr_info("%s : bl_level = %d\n", __func__, bl_level);
if(bl_level)
bl_backup = bl_level;
bl_level = (DOWN_COEF_VALUE * bl_level) / left_back_up_data->bklt_max;
pr_info("%s : Actual bl_level = %d\n", __func__, bl_level);
switch (left_back_up_data->bklt_ctrl) {
case BL_WLED:
led_trigger_event(bl_led_trigger, bl_level);
break;
case BL_PWM:
mdss_dsi_panel_bklt_pwm(left_back_up_data, bl_level);
break;
case BL_DCS_CMD:
pr_debug("%s : dsi index = %d\n", __func__, ctrl_pdata->ndx);
mdss_dsi_panel_bklt_dcs(ctrl_pdata, bl_level);
break;
default:
pr_err("%s: Unknown bl_ctrl configuration\n",
__func__);
break;
}
}
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;
}
void CABC_Set_Mode(void)
{
if (!cabc_tun_state.cabc_enable) {
DPRINT("[ERROR] CABC engine is OFF.\n");
return;
}
if (!get_panel_power_state()) {
pr_info("%s : get_panel_power_state off", __func__);
return;
}
DPRINT("CABC_Set_Mode start , mode(%d), negative(%d), lux(%d)\n",
cabc_tun_state.mode, cabc_tun_state.negative,
cabc_tun_state.luxvalue);
switch (cabc_tun_state.mode) {
case CABC_MODE_UI:
DPRINT(" = UI MODE =\n");
INPUT_PAYLOAD1(CABC_NORMAL_1);
INPUT_PAYLOAD2(CABC_NORMAL_2);
INPUT_PAYLOAD3(CABC_NORMAL_3);
INPUT_PAYLOAD4(CABC_NORMAL_4);
break;
case CABC_MODE_VIDEO:
DPRINT(" = VIDEO MODE =\n");
INPUT_PAYLOAD1(CABC_NORMAL_1);
INPUT_PAYLOAD2(CABC_NORMAL_2);
INPUT_PAYLOAD3(CABC_NORMAL_3);
INPUT_PAYLOAD4(CABC_NORMAL_4);
break;
default:
DPRINT("[%s] no option for mode (%d)\n", __func__,
cabc_tun_state.mode);
return;
}
switch (cabc_tun_state.negative) {
case CABC_NEGATIVE_OFF:
DPRINT(" = Negative Disabled =\n");
INPUT_PAYLOAD5(CABC_NORMAL_5);
break;
case CABC_NEGATIVE_ON:
DPRINT(" = Negative Enabled =\n");
INPUT_PAYLOAD5(CABC_NEGATIVE_5);
break;
default:
DPRINT("[%s] no option for Negative (%d)\n", __func__,
cabc_tun_state.negative);
return;
}
if(cabc_tun_state.auto_br) {
DPRINT(" = Auto Br Enabled =\n");
switch (cabc_tun_state.luxvalue) {
case CABC_LUX_0:
DPRINT(" = LUX 0 ~ 150 =\n");
INPUT_SELECT(CABC_SELECT_2);
break;
case CABC_LUX_1:
DPRINT(" = LUX 150 ~ 5000 =\n");
if(cabc_tun_state.mode == CABC_MODE_VIDEO)
INPUT_SELECT(CABC_SELECT_2);
else
INPUT_SELECT(CABC_SELECT_1);
break;
case CABC_LUX_2:
DPRINT(" = LUX 5000 ~ =\n");
INPUT_SELECT(CABC_SELECT_0);
break;
default:
DPRINT("[%s] no option (%d)\n", __func__,
cabc_tun_state.mode);
INPUT_SELECT(CABC_SELECT_0);
return;
}
} else {
DPRINT(" = Auto Br Disabled =\n");
INPUT_SELECT(CABC_SELECT_0);
}
sending_tuning_cmd();
free_tun_cmd();
DPRINT("CABC_Set_Mode end , mode(%d), negative(%d), lux(%d)\n",
cabc_tun_state.mode, cabc_tun_state.negative,
cabc_tun_state.luxvalue);
}
