Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit eb1e8c29 authored by Adrian Salido-Moreno's avatar Adrian Salido-Moreno Committed by Gerrit - the friendly Code Review server
Browse files

msm: mdss: add support dynamic resolution switch 



Provide support for panel drivers to expose multiple panel timings
supported and expose this through existing fb sysfs mode nodes.
When switching between resolutions allow seamless transition between the
modes.

Change-Id: Iad660a47ea0a63ca0d2332339727b8fcd005dac6
Signed-off-by: default avatarAdrian Salido-Moreno <adrianm@codeaurora.org>
Signed-off-by: default avatarChandan Uddaraju <chandanu@codeaurora.org>
parent c1e43c5b

drivers/video/msm/mdss/mdss_fb.c

+179 −7
Original line number Diff line number Diff line
@@ -326,7 +326,7 @@ static int mdss_fb_get_panel_xres(struct mdss_panel_info *pinfo) 
	pdata = container_of(pinfo, struct mdss_panel_data, panel_info);



	xres = pinfo->xres;

	if (pdata->next)

	if (pdata->next && pdata->next->active)

		xres += mdss_fb_get_panel_xres(&pdata->next->panel_info);



	return xres;
@@ -810,6 +810,82 @@ static void mdss_fb_shutdown(struct platform_device *pdev) 
	unlock_fb_info(mfd->fbi);

}



static void mdss_fb_videomode_from_panel_timing(struct fb_videomode *videomode,

		struct mdss_panel_timing *pt)

{

	videomode->name = pt->name;

	videomode->xres = pt->xres;

	videomode->yres = pt->yres;

	videomode->left_margin = pt->h_back_porch;

	videomode->right_margin = pt->h_front_porch;

	videomode->hsync_len = pt->h_pulse_width;

	videomode->upper_margin = pt->v_back_porch;

	videomode->lower_margin = pt->v_front_porch;

	videomode->vsync_len = pt->v_pulse_width;

	videomode->pixclock = pt->clk_rate;

	videomode->refresh = pt->frame_rate;

	videomode->flag = 0;

	videomode->vmode = 0;

	videomode->sync = 0;

}



static int mdss_fb_init_panel_modes(struct msm_fb_data_type *mfd,

		struct mdss_panel_data *pdata)

{

	struct fb_info *fbi = mfd->fbi;

	struct fb_videomode *modedb;

	struct mdss_panel_timing *pt;

	struct list_head *pos;

	int num_timings = 0;

	int i = 0;



	if (!fbi || !pdata->current_timing)

		return 0;



	list_for_each(pos, &pdata->timings_list)

		num_timings++;



	modedb = devm_kzalloc(fbi->dev, num_timings * sizeof(*modedb),

			GFP_KERNEL);

	if (!modedb) {

		pr_err("unable to allocate mem for modedb\n");

		return -ENOMEM;

	}



	list_for_each_entry(pt, &pdata->timings_list, list) {

		struct mdss_panel_timing *spt = NULL;

		mdss_fb_videomode_from_panel_timing(modedb + i, pt);

		if (pdata->next) {

			spt = mdss_panel_get_timing_by_name(pdata->next,

					modedb[i].name);

			if (!IS_ERR_OR_NULL(spt))

				modedb[i].xres += spt->xres;

			else

				pr_debug("no matching split config for %s\n",

						modedb[i].name);



			/*

			 * if no panel timing found for current, need to

			 * disable it otherwise mark it as active

			 */

			if (pt == pdata->current_timing)

				pdata->next->active = !IS_ERR_OR_NULL(spt);

		}



		if (pt == pdata->current_timing) {

			pr_debug("found current mode: %s\n", pt->name);

			fbi->mode = modedb + i;

		}

		i++;

	}



	fbi->monspecs.modedb = modedb;

	fbi->monspecs.modedb_len = num_timings;

	fb_videomode_to_modelist(modedb, num_timings, &fbi->modelist);



	return 0;

}



static int mdss_fb_probe(struct platform_device *pdev)

{

	struct msm_fb_data_type *mfd = NULL;
@@ -905,6 +981,8 @@ static int mdss_fb_probe(struct platform_device *pdev) 
			lcd_backlight_registered = 1;

	}



	mdss_fb_init_panel_modes(mfd, pdata);



	mdss_fb_create_sysfs(mfd);

	mdss_fb_send_panel_event(mfd, MDSS_EVENT_FB_REGISTERED, fbi);
@@ -2891,6 +2969,21 @@ static int mdss_fb_pan_display(struct fb_var_screeninfo *var, 
		struct fb_info *info)

{

	struct mdp_display_commit disp_commit;

	struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par;



	/*

	 * during mode switch through mode sysfs node, it will trigger a

	 * pan_display after switch. This assumes that fb has been adjusted,

	 * however when using overlays we may not have the right size at this

	 * point, so it needs to go through PREPARE first. Abort pan_display

	 * operations until that happens

	 */

	if (mfd->switch_state != MDSS_MDP_NO_UPDATE_REQUESTED) {

		pr_debug("fb%d: pan_display skipped during switch\n",

				mfd->index);

		return 0;

	}



	memset(&disp_commit, 0, sizeof(disp_commit));

	disp_commit.wait_for_finish = true;

	memcpy(&disp_commit.var, var, sizeof(struct fb_var_screeninfo));
@@ -3176,7 +3269,13 @@ static int mdss_fb_check_var(struct fb_var_screeninfo *var, 
	if (var->yoffset > (var->yres_virtual - var->yres))

		return -EINVAL;



	if (mfd->panel_info) {

	if (info->mode) {

		const struct fb_videomode *mode;



		mode = fb_match_mode(var, &info->modelist);

		if (mode == NULL)

			return -EINVAL;

	} else if (mfd->panel_info && !(var->activate & FB_ACTIVATE_TEST)) {

		int rc;



		memcpy(&mfd->reconfig_panel_info, mfd->panel_info,
@@ -3192,6 +3291,66 @@ static int mdss_fb_check_var(struct fb_var_screeninfo *var, 
	return 0;

}



static int mdss_fb_videomode_switch(struct msm_fb_data_type *mfd,

		const struct fb_videomode *mode)

{

	int ret;

	struct mdss_panel_data *pdata, *tmp;

	struct mdss_panel_timing *timing;



	pdata = dev_get_platdata(&mfd->pdev->dev);

	if (!pdata) {

		pr_err("no panel connected\n");

		return -ENODEV;

	}



	/* make sure that we are idle while switching */

	mdss_fb_wait_for_kickoff(mfd);



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



	tmp = pdata;

	do {

		if (!tmp->event_handler) {

			pr_warn("no event handler for panel\n");

			continue;

		}

		timing = mdss_panel_get_timing_by_name(tmp, mode->name);

		ret = tmp->event_handler(tmp,

				MDSS_EVENT_PANEL_TIMING_SWITCH, timing);



		tmp->active = timing != NULL;

		tmp = tmp->next;

	} while (tmp && !ret);



	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_new_mode = SWITCH_RESOLUTION;

			mutex_unlock(&mfd->switch_lock);

			dest_ctrl = 0;

		}

		ret = mfd->mdp.configure_panel(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);

	}



	pr_debug("fb%d: %s mode change complete\n", mfd->index, mode->name);



	return ret;

}



static int mdss_fb_set_par(struct fb_info *info)

{

	struct msm_fb_data_type *mfd = (struct msm_fb_data_type *)info->par;
@@ -3248,6 +3407,17 @@ static int mdss_fb_set_par(struct fb_info *info) 
		return -EINVAL;

	}



	if (info->mode) {

		const struct fb_videomode *mode;



		mode = fb_match_mode(var, &info->modelist);

		if (!mode)

			return -EINVAL;



		ret = mdss_fb_videomode_switch(mfd, mode);

		if (ret)

			return ret;

	}



	if (mfd->mdp.fb_stride)

		mfd->fbi->fix.line_length = mfd->mdp.fb_stride(mfd->index,
@@ -3689,14 +3859,14 @@ static int __ioctl_wait_idle(struct msm_fb_data_type *mfd, u32 cmd) 
int __ioctl_transition_dyn_mode_state(struct msm_fb_data_type *mfd,

		unsigned int cmd)

{



	if (cmd == MDSS_MDP_NO_UPDATE_REQUESTED)

	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;
@@ -3704,6 +3874,7 @@ int __ioctl_transition_dyn_mode_state(struct msm_fb_data_type *mfd, 
		break;

	case MSMFB_OVERLAY_PREPARE:

		if (mfd->switch_state == MDSS_MDP_WAIT_FOR_PREP) {

			if (mfd->switch_new_mode != SWITCH_RESOLUTION)

				mfd->mdp.pend_mode_switch(mfd, true);

			mfd->switch_state = MDSS_MDP_WAIT_FOR_SYNC;

		}
@@ -3908,6 +4079,7 @@ int mdss_register_panel(struct platform_device *pdev, 
		goto mdss_notfound;

	}



	pdata->active = true;

	fb_pdev = of_find_device_by_node(node);

	if (fb_pdev) {

		rc = mdss_fb_register_extra_panel(fb_pdev, pdata);

drivers/video/msm/mdss/mdss_mdp.h

+8 −1
Original line number Diff line number Diff line
@@ -220,6 +220,13 @@ struct mdss_mdp_ctl_intfs_ops { 
	int (*config_fps_fnc)(struct mdss_mdp_ctl *ctl,

				struct mdss_mdp_ctl *sctl, int new_fps);

	int (*restore_fnc)(struct mdss_mdp_ctl *ctl);



	/*

	 * reconfigure interface for new resolution, called before (pre=1)

	 * and after interface has been reconfigured (pre=0)

	 */

	int (*reconfigure)(struct mdss_mdp_ctl *ctl,

			enum dynamic_switch_modes mode, bool pre);

};



struct mdss_mdp_ctl {
@@ -294,7 +301,7 @@ struct mdss_mdp_ctl { 
	void *intf_ctx[2];

	u32 wb_type;

	u32 prg_fet;

	bool force_ctl_start;

	int pending_mode_switch;

};



struct mdss_mdp_mixer {

drivers/video/msm/mdss/mdss_mdp_ctl.c

+25 −17
Original line number Diff line number Diff line
@@ -1927,11 +1927,6 @@ static int mdss_mdp_ctl_fbc_enable(int enable, 


	fbc = &pdata->fbc;



	if (!fbc || !fbc->enabled) {

		pr_err("Invalid FBC structure\n");

		return -EINVAL;

	}



	if (mixer->num == MDSS_MDP_INTF_LAYERMIXER0 ||

			mixer->num == MDSS_MDP_INTF_LAYERMIXER1) {

		pr_debug("Mixer supports FBC.\n");
@@ -2166,7 +2161,7 @@ static int mdss_mdp_ctl_setup_wfd(struct mdss_mdp_ctl *ctl) 
int mdss_mdp_ctl_reconfig(struct mdss_mdp_ctl *ctl,

		struct mdss_panel_data *pdata)

{

	int (*stop_fnc)(struct mdss_mdp_ctl *ctl, int panel_power_state);

	void *tmp;

	int ret;



	/*
@@ -2179,13 +2174,17 @@ int mdss_mdp_ctl_reconfig(struct mdss_mdp_ctl *ctl, 
		return -EINVAL;

	}



	/* if only changing resolution there is no need for intf reconfig */

	if (!ctl->is_video_mode == (pdata->panel_info.type == MIPI_CMD_PANEL))

		goto skip_intf_reconfig;



	/*

	 * Intentionally not clearing stop function, as stop will

	 * be called after panel is instructed mode switch is happening

	 */

	stop_fnc = ctl->ops.stop_fnc;

	tmp = ctl->ops.stop_fnc;

	memset(&ctl->ops, 0, sizeof(ctl->ops));

	ctl->ops.stop_fnc = stop_fnc;

	ctl->ops.stop_fnc = tmp;



	switch (pdata->panel_info.type) {

	case MIPI_VIDEO_PANEL:
@@ -2209,6 +2208,16 @@ int mdss_mdp_ctl_reconfig(struct mdss_mdp_ctl *ctl, 


	ctl->opmode |= (ctl->intf_num << 4);



skip_intf_reconfig:

	ctl->width = get_panel_xres(&pdata->panel_info);

	ctl->height = get_panel_yres(&pdata->panel_info);

	if (ctl->mixer_left) {

		ctl->mixer_left->width = ctl->width;

		ctl->mixer_left->height = ctl->height;

	}

	ctl->border_x_off = pdata->panel_info.lcdc.border_left;

	ctl->border_y_off = pdata->panel_info.lcdc.border_top;



	return ret;

}
@@ -2509,7 +2518,7 @@ int mdss_mdp_ctl_intf_event(struct mdss_mdp_ctl *ctl, int event, void *arg) 
		if (pdata->event_handler)

			rc = pdata->event_handler(pdata, event, arg);

		pdata = pdata->next;

	} while (rc == 0 && pdata);

	} while (rc == 0 && pdata && pdata->active);



	return rc;

}
@@ -2629,7 +2638,7 @@ int mdss_mdp_ctl_start(struct mdss_mdp_ctl *ctl, bool handoff) 
	pr_debug("ctl_num=%d, power_state=%d\n", ctl->num, ctl->power_state);



	if (mdss_mdp_ctl_is_power_on_interactive(ctl)

			&& !(ctl->force_ctl_start)) {

			&& !(ctl->pending_mode_switch)) {

		pr_debug("%d: panel already on!\n", __LINE__);

		return 0;

	}
@@ -2655,7 +2664,7 @@ int mdss_mdp_ctl_start(struct mdss_mdp_ctl *ctl, bool handoff) 
	 * keep power_on false during handoff to avoid unexpected

	 * operations to overlay.

	 */

	if (!handoff || ctl->force_ctl_start)

	if (!handoff || ctl->pending_mode_switch)

		ctl->power_state = MDSS_PANEL_POWER_ON;



	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);
@@ -2715,7 +2724,6 @@ int mdss_mdp_ctl_stop(struct mdss_mdp_ctl *ctl, int power_state) 


	if (ctl->ops.stop_fnc) {

		ret = ctl->ops.stop_fnc(ctl, power_state);

		if (ctl->panel_data->panel_info.fbc.enabled)

		mdss_mdp_ctl_fbc_enable(0, ctl->mixer_left,

				&ctl->panel_data->panel_info);

	} else {
@@ -2724,7 +2732,6 @@ int mdss_mdp_ctl_stop(struct mdss_mdp_ctl *ctl, int power_state) 


	if (sctl && sctl->ops.stop_fnc) {

		ret = sctl->ops.stop_fnc(sctl, power_state);

		if (ctl->panel_data->panel_info.fbc.enabled)

		mdss_mdp_ctl_fbc_enable(0, sctl->mixer_left,

				&sctl->panel_data->panel_info);

	}
@@ -2760,6 +2767,7 @@ int mdss_mdp_ctl_stop(struct mdss_mdp_ctl *ctl, int power_state) 
end:

	if (!ret) {

		ctl->power_state = power_state;

		if (!ctl->pending_mode_switch)

			mdss_mdp_ctl_perf_update(ctl, 0);

	}

	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF);
@@ -3902,7 +3910,7 @@ int mdss_mdp_display_commit(struct mdss_mdp_ctl *ctl, void *arg, 
	ctl->valid_roi = 0;



	if (ret)

		pr_warn("error displaying frame\n");

		pr_warn("ctl %d error displaying frame\n", ctl->num);



	ctl->play_cnt++;

	ATRACE_END("flush_kickoff");

drivers/video/msm/mdss/mdss_mdp_intf_cmd.c

+95 −42
Original line number Diff line number Diff line
@@ -24,8 +24,6 @@ 
#define MAX_SESSIONS 2



#define SPLIT_MIXER_OFFSET 0x800

/* wait for at most 2 vsync for lowest refresh rate (24hz) */

#define KOFF_TIMEOUT msecs_to_jiffies(84)



#define STOP_TIMEOUT(hz) msecs_to_jiffies((1000 / hz) * (VSYNC_EXPIRE_TICK + 2))

#define POWER_COLLAPSE_TIME msecs_to_jiffies(100)
@@ -62,7 +60,6 @@ struct mdss_mdp_cmd_ctx { 
	struct mdss_mdp_cmd_ctx *sync_ctx; /* for partial update */

	u32 pp_timeout_report_cnt;

	int pingpong_split_slave;

	bool pending_mode_switch; /* Used to prevent powering down in stop */

};



struct mdss_mdp_cmd_ctx mdss_mdp_cmd_ctx_list[MAX_SESSIONS];
@@ -276,11 +273,37 @@ err: 
	return rc;

}



static void mdss_mdp_cmd_clocks_enable(struct mdss_mdp_ctl *ctl)

{

	int rc;



	pr_debug("%s: %pS\n", __func__, __builtin_return_address(0));



	mdss_bus_bandwidth_ctrl(true);



	rc = mdss_iommu_ctrl(1);

	if (IS_ERR_VALUE(rc))

		pr_err("IOMMU attach failed\n");



	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);

	mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)1);

}



static void mdss_mdp_cmd_clocks_disable(struct mdss_mdp_ctl *ctl)

{

	pr_debug("%s: %pS\n", __func__, __builtin_return_address(0));



	mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)0);

	mdss_iommu_ctrl(0);

	mdss_bus_bandwidth_ctrl(false);

	mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF);

}



static inline void mdss_mdp_cmd_clk_on(struct mdss_mdp_cmd_ctx *ctx)

{

	unsigned long flags;

	struct mdss_data_type *mdata = mdss_mdp_get_mdata();

	int irq_en, rc;

	int irq_en;



	if (__mdss_mdp_cmd_is_panel_power_off(ctx))

		return;
@@ -289,16 +312,9 @@ static inline void mdss_mdp_cmd_clk_on(struct mdss_mdp_cmd_ctx *ctx) 
	MDSS_XLOG(ctx->pp_num, atomic_read(&ctx->koff_cnt), ctx->clk_enabled,

						ctx->rdptr_enabled);

	if (!ctx->clk_enabled) {

		mdss_bus_bandwidth_ctrl(true);

		mdss_mdp_cmd_clocks_enable(ctx->ctl);

		ctx->clk_enabled = 1;



		rc = mdss_iommu_ctrl(1);

		if (IS_ERR_VALUE(rc))

			pr_err("IOMMU attach failed\n");



		mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_ON);

		mdss_mdp_ctl_intf_event

			(ctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)1);

		mdss_mdp_hist_intr_setup(&mdata->hist_intr, MDSS_IRQ_RESUME);

	}

	spin_lock_irqsave(&ctx->clk_lock, flags);
@@ -336,11 +352,7 @@ static inline void mdss_mdp_cmd_clk_off(struct mdss_mdp_cmd_ctx *ctx) 
	if (ctx->clk_enabled && set_clk_off) {

		ctx->clk_enabled = 0;

		mdss_mdp_hist_intr_setup(&mdata->hist_intr, MDSS_IRQ_SUSPEND);

		mdss_mdp_ctl_intf_event

			(ctx->ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)0);

		mdss_iommu_ctrl(0);

		mdss_bus_bandwidth_ctrl(false);

		mdss_mdp_clk_ctrl(MDP_BLOCK_POWER_OFF);

		mdss_mdp_cmd_clocks_disable(ctx->ctl);

	}

	mutex_unlock(&ctx->clk_mtx);

}
@@ -798,14 +810,23 @@ static int mdss_mdp_cmd_panel_on(struct mdss_mdp_ctl *ctl, 
		sctx = (struct mdss_mdp_cmd_ctx *) sctl->intf_ctx[MASTER_CTX];



	if (!__mdss_mdp_cmd_is_panel_power_on_interactive(ctx)) {

		rc = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_LINK_READY, NULL);

		WARN(rc, "intf %d link ready error (%d)\n", ctl->intf_num, rc);

		if (ctl->pending_mode_switch != SWITCH_RESOLUTION) {

			rc = mdss_mdp_ctl_intf_event(ctl,

					MDSS_EVENT_LINK_READY, NULL);

			WARN(rc, "intf %d link ready error (%d)\n",

					ctl->intf_num, rc);



			rc = mdss_mdp_ctl_intf_event(ctl,

					MDSS_EVENT_UNBLANK, NULL);

			WARN(rc, "intf %d unblank error (%d)\n",

					ctl->intf_num, rc);



		rc = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_UNBLANK, NULL);

		WARN(rc, "intf %d unblank error (%d)\n", ctl->intf_num, rc);

			rc = mdss_mdp_ctl_intf_event(ctl,

					MDSS_EVENT_PANEL_ON, NULL);

			WARN(rc, "intf %d panel on error (%d)\n",

					ctl->intf_num, rc);



		rc = mdss_mdp_ctl_intf_event(ctl, MDSS_EVENT_PANEL_ON, NULL);

		WARN(rc, "intf %d panel on error (%d)\n", ctl->intf_num, rc);

		}



		rc = mdss_mdp_tearcheck_enable(ctl, true);

		WARN(rc, "intf %d tearcheck enable error (%d)\n",
@@ -1046,8 +1067,7 @@ int mdss_mdp_cmd_restore(struct mdss_mdp_ctl *ctl) 
}



int mdss_mdp_cmd_ctx_stop(struct mdss_mdp_ctl *ctl,

		struct mdss_mdp_cmd_ctx *ctx, int panel_power_state,

		bool pend_switch)

		struct mdss_mdp_cmd_ctx *ctx, int panel_power_state)

{

	struct mdss_mdp_cmd_ctx *sctx = NULL;

	struct mdss_mdp_ctl *sctl = NULL;
@@ -1095,7 +1115,7 @@ int mdss_mdp_cmd_ctx_stop(struct mdss_mdp_ctl *ctl, 
	if (cancel_work_sync(&ctx->clk_work))

		pr_debug("no pending clk work\n");



	if (!pend_switch) {

	if (!ctl->pending_mode_switch) {

		mdss_mdp_ctl_intf_event(ctl,

			MDSS_EVENT_REGISTER_RECOVERY_HANDLER,

			NULL);
@@ -1121,7 +1141,7 @@ int mdss_mdp_cmd_ctx_stop(struct mdss_mdp_ctl *ctl, 
}



int mdss_mdp_cmd_intfs_stop(struct mdss_mdp_ctl *ctl, int session,

	int panel_power_state, bool pend_switch)

	int panel_power_state)

{

	struct mdss_mdp_cmd_ctx *ctx;
@@ -1134,7 +1154,7 @@ int mdss_mdp_cmd_intfs_stop(struct mdss_mdp_ctl *ctl, int session, 
		return -ENODEV;

	}



	mdss_mdp_cmd_ctx_stop(ctl, ctx, panel_power_state, pend_switch);

	mdss_mdp_cmd_ctx_stop(ctl, ctx, panel_power_state);



	if (is_pingpong_split(ctl->mfd)) {

		session += 1;
@@ -1147,14 +1167,14 @@ int mdss_mdp_cmd_intfs_stop(struct mdss_mdp_ctl *ctl, int session, 
			pr_err("invalid ctx session: %d\n", session);

			return -ENODEV;

		}

		mdss_mdp_cmd_ctx_stop(ctl, ctx, panel_power_state, pend_switch);

		mdss_mdp_cmd_ctx_stop(ctl, ctx, panel_power_state);

	}

	pr_debug("%s:-\n", __func__);

	return 0;

}



static int mdss_mdp_cmd_stop_sub(struct mdss_mdp_ctl *ctl,

		int panel_power_state, bool pend_switch)

		int panel_power_state)

{

	struct mdss_mdp_cmd_ctx *ctx;

	struct mdss_mdp_vsync_handler *tmp, *handle;
@@ -1173,8 +1193,7 @@ static int mdss_mdp_cmd_stop_sub(struct mdss_mdp_ctl *ctl, 


	/* Command mode is supported only starting at INTF1 */

	session = ctl->intf_num - MDSS_MDP_INTF1;

	return mdss_mdp_cmd_intfs_stop(ctl, session, panel_power_state,

			pend_switch);

	return mdss_mdp_cmd_intfs_stop(ctl, session, panel_power_state);

}



int mdss_mdp_cmd_stop(struct mdss_mdp_ctl *ctl, int panel_power_state)
@@ -1184,7 +1203,6 @@ int mdss_mdp_cmd_stop(struct mdss_mdp_ctl *ctl, int panel_power_state) 
	bool panel_off = false;

	bool turn_off_clocks = false;

	bool send_panel_events = false;

	bool pend_switch = false;

	int ret = 0;



	if (!ctx) {
@@ -1254,14 +1272,11 @@ int mdss_mdp_cmd_stop(struct mdss_mdp_ctl *ctl, int panel_power_state) 
	if (!turn_off_clocks)

		goto panel_events;



	if (ctx->pending_mode_switch) {

		pend_switch = true;

	if (ctl->pending_mode_switch)

		send_panel_events = false;

		ctx->pending_mode_switch = 0;

	}



	pr_debug("%s: turn off interface clocks\n", __func__);

	ret = mdss_mdp_cmd_stop_sub(ctl, panel_power_state, pend_switch);

	ret = mdss_mdp_cmd_stop_sub(ctl, panel_power_state);

	if (IS_ERR_VALUE(ret)) {

		pr_err("%s: unable to stop interface: %d\n",

				__func__, ret);
@@ -1269,7 +1284,7 @@ int mdss_mdp_cmd_stop(struct mdss_mdp_ctl *ctl, int panel_power_state) 
	}



	if (sctl) {

		mdss_mdp_cmd_stop_sub(sctl, panel_power_state, pend_switch);

		mdss_mdp_cmd_stop_sub(sctl, panel_power_state);

		if (IS_ERR_VALUE(ret)) {

			pr_err("%s: unable to stop slave intf: %d\n",

					__func__, ret);
@@ -1303,6 +1318,7 @@ panel_events: 
	ctl->ops.wait_pingpong = NULL;

	ctl->ops.add_vsync_handler = NULL;

	ctl->ops.remove_vsync_handler = NULL;

	ctl->ops.reconfigure = NULL;



end:

	if (!IS_ERR_VALUE(ret))
@@ -1460,7 +1476,6 @@ void mdss_mdp_switch_roi_reset(struct mdss_mdp_ctl *ctl) 


void mdss_mdp_switch_to_vid_mode(struct mdss_mdp_ctl *ctl, int prep)

{

	struct mdss_mdp_cmd_ctx *ctx = ctl->intf_ctx[MASTER_CTX];

	long int mode = MIPI_VIDEO_PANEL;

	int rc = 0;
@@ -1475,7 +1490,6 @@ void mdss_mdp_switch_to_vid_mode(struct mdss_mdp_ctl *ctl, int prep) 
		rc = mdss_mdp_ctl_intf_event

			(ctl, MDSS_EVENT_PANEL_CLK_CTRL, (void *)1);



		ctx->pending_mode_switch = 1;

		return;

	}
@@ -1483,6 +1497,44 @@ void mdss_mdp_switch_to_vid_mode(struct mdss_mdp_ctl *ctl, int prep) 
			(void *) mode);

}



static int mdss_mdp_cmd_reconfigure(struct mdss_mdp_ctl *ctl,

		enum dynamic_switch_modes mode, bool prep)

{

	int ret;



	if (mdss_mdp_ctl_is_power_off(ctl))

		return 0;



	pr_debug("%s: ctl=%d mode=%d prep=%d\n", __func__,

			ctl->num, mode, prep);



	if (mode == SWITCH_TO_VIDEO_MODE) {

		mdss_mdp_switch_to_vid_mode(ctl, prep);

	} else if (mode == SWITCH_RESOLUTION) {

		if (prep) {

			/* make sure any pending transfer is finished */

			ret = mdss_mdp_cmd_wait4pingpong(ctl, NULL);

			if (ret)

				return ret;



			/*

			 * keep a ref count on clocks to prevent them from

			 * being disabled while switch happens

			 */

			mdss_mdp_cmd_clocks_enable(ctl);

			mdss_mdp_ctl_stop(ctl, MDSS_PANEL_POWER_OFF);

			mdss_mdp_ctl_intf_event(ctl,

					MDSS_EVENT_DSI_DYNAMIC_SWITCH,

					(void *) mode);

		} else {

			/* release ref count after switch is complete */

			mdss_mdp_cmd_clocks_disable(ctl);

		}

	}



	return 0;

}



int mdss_mdp_cmd_start(struct mdss_mdp_ctl *ctl)

{

	int ret, session = 0;
@@ -1504,6 +1556,7 @@ int mdss_mdp_cmd_start(struct mdss_mdp_ctl *ctl) 
	ctl->ops.remove_vsync_handler = mdss_mdp_cmd_remove_vsync_handler;

	ctl->ops.read_line_cnt_fnc = mdss_mdp_cmd_line_count;

	ctl->ops.restore_fnc = mdss_mdp_cmd_restore;

	ctl->ops.reconfigure = mdss_mdp_cmd_reconfigure;

	pr_debug("%s:-\n", __func__);



	return 0;

drivers/video/msm/mdss/mdss_mdp_overlay.c

+52 −8
Original line number Diff line number Diff line
@@ -1687,12 +1687,25 @@ int mdss_mode_switch(struct msm_fb_data_type *mfd, u32 mode) 
{

	struct mdss_rect l_roi, r_roi;

	struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);

	struct mdss_mdp_ctl *sctl;

	int rc;



	pr_debug("%s, start\n", __func__);

	pr_debug("fb%d switch to mode=%x\n", mfd->index, mode);

	ATRACE_FUNC();



	ctl->pending_mode_switch = mode;

	sctl = mdss_mdp_get_split_ctl(ctl);

	if (sctl)

		sctl->pending_mode_switch = mode;



	/* No need for mode validation. It has been done in ioctl call */

	if (mode == MIPI_CMD_PANEL) {

	if (mode == SWITCH_RESOLUTION) {

		if (ctl->ops.reconfigure) {

			rc = ctl->ops.reconfigure(ctl, mode, 1);

			if (rc)

				return rc;

		}

	} else if (mode == MIPI_CMD_PANEL) {

		/*

		 * Need to reset roi if there was partial update in previous

		 * Command frame
@@ -1724,17 +1737,16 @@ int mdss_mode_switch(struct msm_fb_data_type *mfd, u32 mode) 
		return -EINVAL;

	}



	ctl->force_ctl_start = 1;

	mdss_mdp_ctl_start(ctl, true);

	ctl->force_ctl_start = 0;

	ATRACE_END(__func__);



	pr_debug("%s, end\n", __func__);

	return 0;

}



int mdss_mode_switch_post(struct msm_fb_data_type *mfd, u32 mode)

{

	struct mdss_mdp_ctl *ctl = mfd_to_ctl(mfd);

	struct mdss_mdp_ctl *sctl;

	int rc = 0;

	u32 frame_rate = 0;
@@ -1764,7 +1776,15 @@ int mdss_mode_switch_post(struct msm_fb_data_type *mfd, u32 mode) 
		 */

		mdss_mdp_ctl_intf_event(ctl,

			MDSS_EVENT_PANEL_CLK_CTRL, (void *)0);

	} else if (mode == SWITCH_RESOLUTION) {

		if (ctl->ops.reconfigure)

			rc = ctl->ops.reconfigure(ctl, mode, 0);

	}

	ctl->pending_mode_switch = 0;

	sctl = mdss_mdp_get_split_ctl(ctl);

	if (sctl)

		sctl->pending_mode_switch = 0;



	return rc;

}
@@ -4896,18 +4916,42 @@ static int mdss_mdp_update_panel_info(struct msm_fb_data_type *mfd, 
		mdss_mdp_ctl_destroy(mdp5_data->ctl);

		mdp5_data->ctl = NULL;

	} else {

		if (is_panel_split(mfd) && mdp5_data->mdata->has_pingpong_split)

			mfd->split_mode = MDP_PINGPONG_SPLIT;

		/*

		 * Dynamic change so we need to reconfig instead of

		 * destroying current ctrl sturcture.

		 */

		pdata = dev_get_platdata(&mfd->pdev->dev);

		mdss_mdp_ctl_reconfig(ctl, pdata);



		sctl = mdss_mdp_get_split_ctl(ctl);

		if (sctl)

		if (sctl) {

			if (mfd->split_mode == MDP_DUAL_LM_DUAL_DISPLAY) {

				mdss_mdp_ctl_reconfig(sctl, pdata->next);

				sctl->border_x_off +=

					pdata->panel_info.lcdc.border_left +

					pdata->panel_info.lcdc.border_right;

			} else {

				/*

				 * todo: need to revisit this and properly

				 * cleanup slave resources

				 */

				mdss_mdp_ctl_destroy(sctl);

				ctl->mixer_right = NULL;

			}

		} else if (mfd->split_mode == MDP_DUAL_LM_DUAL_DISPLAY) {

			/* enable split display for the first time */

			ret = mdss_mdp_ctl_split_display_setup(ctl,

					pdata->next);

			if (ret) {

				mdss_mdp_ctl_destroy(ctl);

				mdp5_data->ctl = NULL;

			}

		}

	}



	return 0;

	return ret;

}



int mdss_mdp_overlay_init(struct msm_fb_data_type *mfd)