Merge "msm: mdss: add capability to parse multiple panel roi alignment" (d383ae0b) · Commits · e / devices / android_kernel_xiaomi_markw

Documentation/devicetree/bindings/fb/mdss-dsi-panel.txt

+18 −0

Original line number	Diff line number	Diff line
		@@ -397,6 +397,10 @@ Optional properties:
		- qcom,cmd-to-video-mode-switch-commands: List of commands that need to be sent
		to panel in order to switch from command mode to video mode dynamically.
		Refer to "qcom,mdss-dsi-on-command" section for adding commands.
		- qcom,send-pps-before-switch: Boolean propety to indicate when PPS commands should be sent,
		either before or after switch commands during dynamic resolution
		switch in DSC panels. If the property is not present, the default
		behavior is to send PPS commands after the switch commands.
		- qcom,mdss-dsi-panel-orientation: String used to indicate orientation of panel
		"180" = panel is flipped in both horizontal and vertical directions
		"hflip" = panel is flipped in horizontal direction
		@@ -620,6 +624,7 @@ Example:
		qcom,video-to-cmd-mode-switch-commands = [15 01 00 00 00 00 02 C2 0B
		15 01 00 00 00 00 02 C2 08];
		qcom,cmd-to-video-mode-switch-commands = [15 01 00 00 00 00 02 C2 03];
		qcom,send-pps-before-switch;
		qcom,panel-ack-disabled;
		qcom,mdss-dsi-horizontal-line-idle = <0 40 256>,
		<40 120 128>,
		@@ -651,6 +656,19 @@ Example:
		29 00 00 00 00 00 02 B0 04
		29 00 00 00 00 00 02 F1 00];
		qcom,mdss-dsi-timing-switch-command-state = "dsi_lp_mode";

		qcom,config-select = <&dsi_sim_vid_config0>;
		dsi_sim_vid_config0: config0 {
		qcom,lm-split = <360 360>;
		qcom,mdss-dsc-encoders = <2>;
		qcom,mdss-dsc-slice-height = <16>;
		qcom,mdss-dsc-slice-width = <360>;
		qcom,mdss-dsc-slice-per-pkt = <2>;
		qcom,mdss-dsc-bit-per-component = <8>;
		qcom,mdss-dsc-bit-per-pixel = <8>;
		qcom,mdss-dsc-block-prediction-enable;
		qcom,mdss-dsc-config-by-manufacture-cmd;
		};
		};
		};
		qcom,panel-supply-entries {

drivers/video/msm/mdss/mdss_dsi.c

+4 −10

Original line number	Diff line number	Diff line
		@@ -2652,6 +2652,7 @@ static struct device_node *mdss_dsi_find_panel_of_node(
		struct mdss_panel_info *pinfo = &ctrl_pdata->panel_data.panel_info;

		len = strlen(panel_cfg);
		ctrl_pdata->panel_data.dsc_cfg_np_name[0] = '\0';
		if (!len) {
		/* no panel cfg chg, parse dt */
		pr_debug("%s:%d: no cmd line cfg present\n",
		@@ -2735,18 +2736,11 @@ static struct device_node *mdss_dsi_find_panel_of_node(
		strlcpy(cfg_np_name, str2,
		MDSS_MAX_PANEL_LEN);
		}
		}

		pr_debug("%s: cfg_np_name:%s\n", __func__, cfg_np_name);
		if (str2) {
		ctrl_pdata->panel_data.cfg_np =
		of_get_child_by_name(dsi_pan_node,
		cfg_np_name);
		if (!ctrl_pdata->panel_data.cfg_np)
		pr_warn("%s: can't find config node:%s. either no such node or bad name\n",
		__func__, cfg_np_name);
		strlcpy(ctrl_pdata->panel_data.dsc_cfg_np_name,
		cfg_np_name, MDSS_MAX_PANEL_LEN);
		}
		}

		return dsi_pan_node;
		}
		end:

drivers/video/msm/mdss/mdss_dsi_panel.c

+76 −31

Original line number	Diff line number	Diff line
		@@ -624,12 +624,21 @@ static void mdss_dsi_panel_switch_mode(struct mdss_panel_data *pdata,
		pr_debug("%s: sending switch commands\n", __func__);
		pcmds = &pt->switch_cmds;
		flags \|= CMD_REQ_DMA_TPG;
		flags \|= CMD_REQ_COMMIT;
		} else {
		pr_warn("%s: Invalid mode switch attempted\n", __func__);
		return;
		}

		if ((pdata->panel_info.compression_mode == COMPRESSION_DSC) &&
		(pdata->panel_info.send_pps_before_switch))
		mdss_dsi_panel_dsc_pps_send(ctrl_pdata, &pdata->panel_info);

		mdss_dsi_panel_cmds_send(ctrl_pdata, pcmds, flags);

		if ((pdata->panel_info.compression_mode == COMPRESSION_DSC) &&
		(!pdata->panel_info.send_pps_before_switch))
		mdss_dsi_panel_dsc_pps_send(ctrl_pdata, &pdata->panel_info);
		}

		static void mdss_dsi_panel_bl_ctrl(struct mdss_panel_data *pdata,
		@@ -1262,8 +1271,39 @@ end:
		return rc;
		}

		static struct device_node *mdss_dsi_panel_get_dsc_cfg_np(
		struct device_node np, struct mdss_panel_data panel_data,
		bool default_timing)
		{
		struct device_node *dsc_cfg_np = NULL;


		/* Read the dsc config node specified by command line */
		if (default_timing) {
		dsc_cfg_np = of_get_child_by_name(np,
		panel_data->dsc_cfg_np_name);
		if (!dsc_cfg_np)
		pr_warn_once("%s: cannot find dsc config node:%s\n",
		__func__, panel_data->dsc_cfg_np_name);
		}

		/*
		* Fall back to default from DT as nothing is specified
		* in command line.
		*/
		if (!dsc_cfg_np && of_find_property(np, "qcom,config-select", NULL)) {
		dsc_cfg_np = of_parse_phandle(np, "qcom,config-select", 0);
		if (!dsc_cfg_np)
		pr_warn_once("%s:err parsing qcom,config-select\n",
		__func__);
		}

		return dsc_cfg_np;
		}

		static int mdss_dsi_parse_topology_config(struct device_node *np,
		struct dsi_panel_timing pt, struct mdss_panel_data panel_data)
		struct dsi_panel_timing pt, struct mdss_panel_data panel_data,
		bool default_timing)
		{
		int rc = 0;
		bool is_split_display = panel_data->panel_info.is_split_display;
		@@ -1271,19 +1311,14 @@ static int mdss_dsi_parse_topology_config(struct device_node *np,
		struct mdss_panel_timing *timing = &pt->timing;
		struct mdss_dsi_ctrl_pdata *ctrl_pdata = NULL;
		struct mdss_panel_info *pinfo;
		struct device_node *cfg_np;
		struct device_node *cfg_np = NULL;

		ctrl_pdata = container_of(panel_data, struct mdss_dsi_ctrl_pdata,
		panel_data);
		cfg_np = ctrl_pdata->panel_data.cfg_np;
		pinfo = &ctrl_pdata->panel_data.panel_info;

		if (!cfg_np && of_find_property(np, "qcom,config-select", NULL)) {
		cfg_np = of_parse_phandle(np, "qcom,config-select", 0);
		if (!cfg_np)
		pr_err("%s:err parsing qcom,config-select\n", __func__);
		ctrl_pdata->panel_data.cfg_np = cfg_np;
		}
		cfg_np = mdss_dsi_panel_get_dsc_cfg_np(np,
		&ctrl_pdata->panel_data, default_timing);

		if (cfg_np) {
		if (!of_property_read_u32_array(cfg_np, "qcom,lm-split",
		@@ -1325,6 +1360,10 @@ static int mdss_dsi_parse_topology_config(struct device_node *np,
		if (rc)
		goto end;

		pinfo->send_pps_before_switch =
		of_property_read_bool(np,
		"qcom,mdss-dsi-send-pps-before-switch");

		rc = mdss_dsi_parse_dsc_params(cfg_np, &pt->timing,
		is_split_display);
		} else if (!strcmp(data, "fbc")) {
		@@ -1474,11 +1513,13 @@ static int mdss_dsi_nt35596_read_status(struct mdss_dsi_ctrl_pdata *ctrl_pdata)
		}

		static void mdss_dsi_parse_roi_alignment(struct device_node *np,
		struct mdss_panel_info *pinfo)
		struct dsi_panel_timing *pt)
		{
		int len = 0;
		u32 value[6];
		struct property *data;
		struct mdss_panel_timing *timing = &pt->timing;

		data = of_find_property(np, "qcom,panel-roi-alignment", &len);
		len /= sizeof(u32);
		if (!data \|\| (len != 6)) {
		@@ -1490,19 +1531,21 @@ static void mdss_dsi_parse_roi_alignment(struct device_node *np,
		pr_debug("%s: Error reading panel roi alignment values",
		__func__);
		else {
		pinfo->xstart_pix_align = value[0];
		pinfo->ystart_pix_align = value[1];
		pinfo->width_pix_align = value[2];
		pinfo->height_pix_align = value[3];
		pinfo->min_width = value[4];
		pinfo->min_height = value[5];
		timing->roi_alignment.xstart_pix_align = value[0];
		timing->roi_alignment.ystart_pix_align = value[1];
		timing->roi_alignment.width_pix_align = value[2];
		timing->roi_alignment.height_pix_align = value[3];
		timing->roi_alignment.min_width = value[4];
		timing->roi_alignment.min_height = value[5];
		}

		pr_debug("%s: ROI alignment: [%d, %d, %d, %d, %d, %d]",
		__func__, pinfo->xstart_pix_align,
		pinfo->width_pix_align, pinfo->ystart_pix_align,
		pinfo->height_pix_align, pinfo->min_width,
		pinfo->min_height);
		__func__, timing->roi_alignment.xstart_pix_align,
		timing->roi_alignment.width_pix_align,
		timing->roi_alignment.ystart_pix_align,
		timing->roi_alignment.height_pix_align,
		timing->roi_alignment.min_width,
		timing->roi_alignment.min_height);
		}
		}

		@@ -2154,10 +2197,13 @@ static int mdss_dsi_panel_timing_from_dt(struct device_node *np,

		static int mdss_dsi_panel_config_res_properties(struct device_node *np,
		struct dsi_panel_timing *pt,
		struct mdss_panel_data *panel_data)
		struct mdss_panel_data *panel_data,
		bool default_timing)
		{
		int rc = 0;

		mdss_dsi_parse_roi_alignment(np, pt);

		mdss_dsi_parse_dcs_cmds(np, &pt->on_cmds,
		"qcom,mdss-dsi-on-command",
		"qcom,mdss-dsi-on-command-state");
		@@ -2169,7 +2215,7 @@ static int mdss_dsi_panel_config_res_properties(struct device_node *np,
		"qcom,mdss-dsi-timing-switch-command",
		"qcom,mdss-dsi-timing-switch-command-state");

		rc = mdss_dsi_parse_topology_config(np, pt, panel_data);
		rc = mdss_dsi_parse_topology_config(np, pt, panel_data, default_timing);
		if (rc) {
		pr_err("%s: parsing compression params failed. rc:%d\n",
		__func__, rc);
		@@ -2189,6 +2235,7 @@ static int mdss_panel_parse_display_timings(struct device_node *np,
		struct device_node *entry;
		int num_timings, rc;
		int i = 0, active_ndx = 0;
		bool default_timing = false;

		ctrl = container_of(panel_data, struct mdss_dsi_ctrl_pdata, panel_data);

		@@ -2207,7 +2254,7 @@ static int mdss_panel_parse_display_timings(struct device_node *np,
		rc = mdss_dsi_panel_timing_from_dt(np, &pt, panel_data);
		if (!rc) {
		mdss_dsi_panel_config_res_properties(np, &pt,
		panel_data);
		panel_data, true);
		rc = mdss_dsi_panel_timing_switch(ctrl, &pt.timing);
		}
		return rc;
		@@ -2234,14 +2281,14 @@ static int mdss_panel_parse_display_timings(struct device_node *np,
		goto exit;
		}

		mdss_dsi_panel_config_res_properties(entry, (modedb + i),
		panel_data);

		/* if default is set, use it otherwise use first as default */
		if (of_property_read_bool(entry,
		"qcom,mdss-dsi-timing-default"))
		default_timing = of_property_read_bool(entry,
		"qcom,mdss-dsi-timing-default");
		if (default_timing)
		active_ndx = i;

		mdss_dsi_panel_config_res_properties(entry, (modedb + i),
		panel_data, default_timing);

		list_add(&modedb[i].timing.list,
		&panel_data->timings_list);
		i++;
		@@ -2442,8 +2489,6 @@ static int mdss_panel_parse_dt(struct device_node *np,
		rc = of_property_read_u32(np, "qcom,mdss-dsi-post-init-delay", &tmp);
		pinfo->mipi.post_init_delay = (!rc ? tmp : 0);

		mdss_dsi_parse_roi_alignment(np, pinfo);

		mdss_dsi_parse_trigger(np, &(pinfo->mipi.mdp_trigger),
		"qcom,mdss-dsi-mdp-trigger");

drivers/video/msm/mdss/mdss_fb.c

+71 −58

Original line number	Diff line number	Diff line
		@@ -551,10 +551,14 @@ static ssize_t mdss_fb_get_panel_info(struct device *dev,
		"min_fps=%d\nmax_fps=%d\npanel_name=%s\n"
		"primary_panel=%d\nis_pluggable=%d\ndisplay_id=%s\n"
		"is_cec_supported=%d\nis_pingpong_split=%d\n",
		pinfo->partial_update_enabled, pinfo->xstart_pix_align,
		pinfo->width_pix_align, pinfo->ystart_pix_align,
		pinfo->height_pix_align, pinfo->min_width,
		pinfo->min_height, pinfo->partial_update_roi_merge,
		pinfo->partial_update_enabled,
		pinfo->roi_alignment.xstart_pix_align,
		pinfo->roi_alignment.width_pix_align,
		pinfo->roi_alignment.ystart_pix_align,
		pinfo->roi_alignment.height_pix_align,
		pinfo->roi_alignment.min_width,
		pinfo->roi_alignment.min_height,
		pinfo->partial_update_roi_merge,
		pinfo->dynamic_fps, pinfo->min_fps, pinfo->max_fps,
		pinfo->panel_name, pinfo->is_prim_panel,
		pinfo->is_pluggable, pinfo->display_id,
		@@ -975,6 +979,30 @@ static void mdss_fb_videomode_from_panel_timing(struct fb_videomode *videomode,
		}
		}

		static void mdss_fb_set_split_mode(struct msm_fb_data_type *mfd,
		struct mdss_panel_data *pdata)
		{
		if (pdata->panel_info.is_split_display) {
		struct mdss_panel_data *pnext = pdata->next;

		mfd->split_fb_left = pdata->panel_info.lm_widths[0];
		if (pnext)
		mfd->split_fb_right = pnext->panel_info.lm_widths[0];

		if (pdata->panel_info.use_pingpong_split)
		mfd->split_mode = MDP_PINGPONG_SPLIT;
		else
		mfd->split_mode = MDP_DUAL_LM_DUAL_DISPLAY;
		} else if ((pdata->panel_info.lm_widths[0] != 0)
		&& (pdata->panel_info.lm_widths[1] != 0)) {
		mfd->split_fb_left = pdata->panel_info.lm_widths[0];
		mfd->split_fb_right = pdata->panel_info.lm_widths[1];
		mfd->split_mode = MDP_DUAL_LM_SINGLE_DISPLAY;
		} else {
		mfd->split_mode = MDP_SPLIT_MODE_NONE;
		}
		}

		static int mdss_fb_init_panel_modes(struct msm_fb_data_type *mfd,
		struct mdss_panel_data *pdata)
		{
		@@ -1095,25 +1123,8 @@ static int mdss_fb_probe(struct platform_device *pdev)
		mfd->pdev = pdev;

		mfd->split_fb_left = mfd->split_fb_right = 0;
		mfd->split_mode = MDP_SPLIT_MODE_NONE;
		if (pdata->panel_info.is_split_display) {
		struct mdss_panel_data *pnext = pdata->next;

		mfd->split_fb_left = pdata->panel_info.lm_widths[0];
		if (pnext)
		mfd->split_fb_right = pnext->panel_info.lm_widths[0];

		if (pdata->panel_info.use_pingpong_split)
		mfd->split_mode = MDP_PINGPONG_SPLIT;
		else
		mfd->split_mode = MDP_DUAL_LM_DUAL_DISPLAY;
		} else if ((pdata->panel_info.lm_widths[0] != 0) &&
		(pdata->panel_info.lm_widths[1] != 0)) {
		mfd->split_fb_left = pdata->panel_info.lm_widths[0];
		mfd->split_fb_right = pdata->panel_info.lm_widths[1];
		mfd->split_mode = MDP_DUAL_LM_SINGLE_DISPLAY;
		}

		mdss_fb_set_split_mode(mfd, pdata);
		pr_info("fb%d: split_mode:%d left:%d right:%d\n", mfd->index,
		mfd->split_mode, mfd->split_fb_left, mfd->split_fb_right);

		@@ -3087,38 +3098,27 @@ u32 mdss_fb_get_mode_switch(struct msm_fb_data_type *mfd)
		* panel mode being switching into.
		*/
		static int __ioctl_transition_dyn_mode_state(struct msm_fb_data_type *mfd,
		unsigned int cmd, int validate)
		unsigned int cmd, bool validate, bool null_commit)
		{
		if (mfd->switch_state == MDSS_MDP_NO_UPDATE_REQUESTED)
		return 0;

		mutex_lock(&mfd->switch_lock);
		switch (cmd) {
		case MSMFB_BUFFER_SYNC:
		if (mfd->switch_state == MDSS_MDP_WAIT_FOR_SYNC) {
		if (mfd->switch_new_mode != SWITCH_RESOLUTION)
		mdss_fb_set_mdp_sync_pt_threshold(mfd,
		mfd->switch_new_mode);
		mfd->switch_state = MDSS_MDP_WAIT_FOR_COMMIT;
		}
		break;
		case MSMFB_OVERLAY_PREPARE:
		if (mfd->switch_state == MDSS_MDP_WAIT_FOR_PREP) {
		if (mfd->switch_new_mode != SWITCH_RESOLUTION)
		mfd->pending_switch = true;
		mfd->switch_state = MDSS_MDP_WAIT_FOR_SYNC;
		}
		break;
		case MSMFB_ATOMIC_COMMIT:
		if ((mfd->switch_state == MDSS_MDP_WAIT_FOR_PREP) && validate) {
		if ((mfd->switch_state == MDSS_MDP_WAIT_FOR_VALIDATE)
		&& validate) {
		if (mfd->switch_new_mode != SWITCH_RESOLUTION)
		mfd->pending_switch = true;
		mfd->switch_state = MDSS_MDP_WAIT_FOR_SYNC;
		} else if (mfd->switch_state == MDSS_MDP_WAIT_FOR_SYNC) {
		mfd->switch_state = MDSS_MDP_WAIT_FOR_COMMIT;
		} else if (mfd->switch_state == MDSS_MDP_WAIT_FOR_COMMIT) {
		if (mfd->switch_new_mode != SWITCH_RESOLUTION)
		mdss_fb_set_mdp_sync_pt_threshold(mfd,
		mfd->switch_new_mode);
		mfd->switch_state = MDSS_MDP_WAIT_FOR_COMMIT;
		mfd->switch_state = MDSS_MDP_WAIT_FOR_KICKOFF;
		} else if ((mfd->switch_state == MDSS_MDP_WAIT_FOR_VALIDATE)
		&& null_commit) {
		mfd->switch_state = MDSS_MDP_WAIT_FOR_KICKOFF;
		}
		break;
		}
		@@ -3212,7 +3212,7 @@ int mdss_fb_atomic_commit(struct fb_info *info,
		pr_err("wait for kickoff failed\n");
		} else {
		__ioctl_transition_dyn_mode_state(mfd,
		MSMFB_ATOMIC_COMMIT, 1);
		MSMFB_ATOMIC_COMMIT, true, false);
		if (mfd->panel.type == WRITEBACK_PANEL) {
		output_layer = commit_v1->output_layer;
		wb_change = !mdss_fb_is_wb_config_same(mfd,
		@@ -3238,6 +3238,9 @@ int mdss_fb_atomic_commit(struct fb_info *info,
		pr_err("pan display idle call failed\n");
		goto end;
		}
		__ioctl_transition_dyn_mode_state(mfd,
		MSMFB_ATOMIC_COMMIT, false,
		(commit_v1->input_layer_cnt ? 0 : 1));

		ret = mfd->mdp.pre_commit(mfd, file, commit_v1);
		if (ret) {
		@@ -3429,13 +3432,19 @@ static int __mdss_fb_perform_commit(struct msm_fb_data_type *mfd)
		sync_pt_data->flushed = false;

		mutex_lock(&mfd->switch_lock);
		if (mfd->switch_state == MDSS_MDP_WAIT_FOR_COMMIT) {
		if (mfd->switch_state == MDSS_MDP_WAIT_FOR_KICKOFF) {
		dynamic_dsi_switch = 1;
		new_dsi_mode = mfd->switch_new_mode;
		} else if (mfd->switch_state != MDSS_MDP_NO_UPDATE_REQUESTED) {
		pr_err("invalid commit on fb%d with state = %d\n",
		mfd->index, mfd->switch_state);
		mutex_unlock(&mfd->switch_lock);
		goto skip_commit;
		}
		mutex_unlock(&mfd->switch_lock);

		if (dynamic_dsi_switch) {
		MDSS_XLOG(mfd->index, mfd->split_mode, new_dsi_mode,
		XLOG_FUNC_ENTRY);
		pr_debug("Triggering dyn mode switch to %d\n", new_dsi_mode);
		ret = mfd->mdp.mode_switch(mfd, new_dsi_mode);
		if (ret)
		@@ -3465,6 +3474,8 @@ static int __mdss_fb_perform_commit(struct msm_fb_data_type *mfd)
		pr_err("pan display failed %x on fb%d\n", ret,
		mfd->index);
		}

		skip_commit:
		if (!ret)
		mdss_fb_update_backlight(mfd);

		@@ -3474,6 +3485,8 @@ static int __mdss_fb_perform_commit(struct msm_fb_data_type *mfd)
		}

		if (dynamic_dsi_switch) {
		MDSS_XLOG(mfd->index, mfd->split_mode, new_dsi_mode,
		XLOG_FUNC_EXIT);
		mfd->mdp.mode_switch_post(mfd, new_dsi_mode);
		mutex_lock(&mfd->switch_lock);
		mfd->switch_state = MDSS_MDP_NO_UPDATE_REQUESTED;
		@@ -3662,7 +3675,10 @@ static int mdss_fb_videomode_switch(struct msm_fb_data_type *mfd,
		mdss_fb_wait_for_kickoff(mfd);

		pr_debug("fb%d: changing display mode to %s\n", mfd->index, mode->name);

		MDSS_XLOG(mfd->index, mode->name,
		mdss_fb_get_panel_xres(mfd->panel_info),
		mfd->panel_info->yres, mfd->split_mode,
		XLOG_FUNC_ENTRY);
		tmp = pdata;
		do {
		if (!tmp->event_handler) {
		@@ -3677,13 +3693,16 @@ static int mdss_fb_videomode_switch(struct msm_fb_data_type *mfd,
		tmp = tmp->next;
		} while (tmp && !ret);

		if (!ret)
		mdss_fb_set_split_mode(mfd, pdata);

		if (!ret && mfd->mdp.configure_panel) {
		int dest_ctrl = 1;

		/* todo: currently assumes no changes in video/cmd mode */
		if (!mdss_fb_is_power_off(mfd)) {
		mutex_lock(&mfd->switch_lock);
		mfd->switch_state = MDSS_MDP_WAIT_FOR_PREP;
		mfd->switch_state = MDSS_MDP_WAIT_FOR_VALIDATE;
		mfd->switch_new_mode = SWITCH_RESOLUTION;
		mutex_unlock(&mfd->switch_lock);
		dest_ctrl = 0;
		@@ -3692,14 +3711,10 @@ static int mdss_fb_videomode_switch(struct msm_fb_data_type *mfd,
		pdata->panel_info.mipi.mode, dest_ctrl);
		}

		if (!ret) {
		if (pdata->next && pdata->next->active)
		mfd->split_mode = MDP_DUAL_LM_DUAL_DISPLAY;
		else
		mfd->split_mode = MDP_SPLIT_MODE_NONE;
		mdss_fb_validate_split(0, 0, mfd);
		}

		MDSS_XLOG(mfd->index, mode->name,
		mdss_fb_get_panel_xres(mfd->panel_info),
		mfd->panel_info->yres, mfd->split_mode,
		XLOG_FUNC_EXIT);
		pr_debug("fb%d: %s mode change complete\n", mfd->index, mode->name);

		return ret;
		@@ -4455,7 +4470,7 @@ static int mdss_fb_immediate_mode_switch(struct msm_fb_data_type *mfd, u32 mode)
		ret = -EAGAIN;
		goto exit;
		}
		mfd->switch_state = MDSS_MDP_WAIT_FOR_PREP;
		mfd->switch_state = MDSS_MDP_WAIT_FOR_VALIDATE;
		mfd->switch_new_mode = tranlated_mode;

		exit:
		@@ -4559,8 +4574,6 @@ int mdss_fb_do_ioctl(struct fb_info *info, unsigned int cmd,
		if (ret)
		goto exit;

		__ioctl_transition_dyn_mode_state(mfd, cmd, 0);

		switch (cmd) {
		case MSMFB_CURSOR:
		ret = mdss_fb_cursor(info, argp);

drivers/video/msm/mdss/mdss_fb.h

+5 −5

Original line number	Diff line number	Diff line
		@@ -129,15 +129,15 @@ enum mdp_mmap_type {
		* enum dyn_mode_switch_state - Lists next stage for dynamic mode switch work
		*
		* @MDSS_MDP_NO_UPDATE_REQUESTED: incoming frame is processed normally
		* @MDSS_MDP_WAIT_FOR_PREP: Waiting for OVERLAY_PREPARE to be called
		* @MDSS_MDP_WAIT_FOR_SYNC: Waiting for BUFFER_SYNC to be called
		* @MDSS_MDP_WAIT_FOR_COMMIT: Waiting for COMMIT to be called
		* @MDSS_MDP_WAIT_FOR_VALIDATE: Waiting for ATOMIC_COMMIT-validate to be called
		* @MDSS_MDP_WAIT_FOR_COMMIT: Waiting for ATOMIC_COMMIT-commit to be called
		* @MDSS_MDP_WAIT_FOR_KICKOFF: Waiting for KICKOFF to be called
		*/
		enum dyn_mode_switch_state {
		MDSS_MDP_NO_UPDATE_REQUESTED,
		MDSS_MDP_WAIT_FOR_PREP,
		MDSS_MDP_WAIT_FOR_SYNC,
		MDSS_MDP_WAIT_FOR_VALIDATE,
		MDSS_MDP_WAIT_FOR_COMMIT,
		MDSS_MDP_WAIT_FOR_KICKOFF,
		};

		/**