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

Commit b296a2b1 authored by Krishna Manikandan's avatar Krishna Manikandan
Browse files

fbdev: msm: Avoid creation of extra retire timeline 



Add support to avoid creation of extra timeline
for retire fences. Also, use the commit count
instead of pending commits for calculation of
value of release fence.

Change-Id: I07e4f68d89df7852d012b3a0508b76f51c29a511
Signed-off-by: default avatarKrishna Manikandan <mkrishn@codeaurora.org>
parent 463d8c28

drivers/video/fbdev/msm/mdss_fb.c

+19 −14
Original line number Diff line number Diff line
@@ -1320,14 +1320,7 @@ static int mdss_fb_probe(struct platform_device *pdev) 
			pr_err("cannot create release fence time line\n");

			return -ENOMEM;

		}

		snprintf(timeline_name, sizeof(timeline_name),

			"mdss_fb_%d_retire", mfd->index);

		 mfd->mdp_sync_pt_data.timeline_retire =

				mdss_create_timeline(timeline_name);

		if (mfd->mdp_sync_pt_data.timeline == NULL) {

			pr_err("cannot create release fence time line\n");

			return -ENOMEM;

		}



		mfd->mdp_sync_pt_data.notifier.notifier_call =

			__mdss_fb_sync_buf_done_callback;

	}
@@ -2979,15 +2972,26 @@ int mdss_fb_wait_for_fence(struct msm_sync_pt_data *sync_pt_data) 
 */

void mdss_fb_signal_timeline(struct msm_sync_pt_data *sync_pt_data)

{

	struct msm_fb_data_type *mfd;



	mfd = container_of(sync_pt_data, typeof(*mfd), mdp_sync_pt_data);

	mutex_lock(&sync_pt_data->sync_mutex);

	if (atomic_add_unless(&sync_pt_data->commit_cnt, -1, 0) &&

	if (atomic_read(&sync_pt_data->commit_cnt) &&

			sync_pt_data->timeline) {

		mdss_inc_timeline(sync_pt_data->timeline, 1);



		/*

		 * For Command mode panels, the retire timeline is incremented

		 * whenever we receive a readptr_done. For all other panels,

		 * the retire fence should be signaled along with the release

		 * fence once the frame is done.

		 */

		if (mfd->panel.type != MIPI_CMD_PANEL)

			mdss_inc_timeline(sync_pt_data->timeline_retire, 1);

		MDSS_XLOG(sync_pt_data->timeline_value);

		sync_pt_data->timeline_value++;



		pr_debug("%s: buffer signaled! timeline val=%d remaining=%d\n",

		pr_debug("%s: buffer signaled! timeline val=%d commit_cnt=%d\n",

			sync_pt_data->fence_name, sync_pt_data->timeline_value,

			atomic_read(&sync_pt_data->commit_cnt));

	} else {
@@ -3016,9 +3020,10 @@ static void mdss_fb_release_fences(struct msm_fb_data_type *mfd) 
		val = sync_pt_data->threshold +

			atomic_read(&sync_pt_data->commit_cnt);

		mdss_resync_timeline(sync_pt_data->timeline);

		if (mfd->panel.type != MIPI_CMD_PANEL)

			mdss_resync_timeline(sync_pt_data->timeline_retire);

		sync_pt_data->timeline_value += val;

		atomic_set(&sync_pt_data->commit_cnt, 0);

		sync_pt_data->timeline_value = val;



	}

	mutex_unlock(&sync_pt_data->sync_mutex);

}

drivers/video/fbdev/msm/mdss_mdp.h

+0 −1
Original line number Diff line number Diff line
@@ -1009,7 +1009,6 @@ struct mdss_overlay_private { 
	u32 splash_mem_size;

	u32 sd_enabled;



	struct mdss_timeline *vsync_timeline;

	struct mdss_mdp_vsync_handler vsync_retire_handler;

	int retire_cnt;

	bool kickoff_released;

drivers/video/fbdev/msm/mdss_mdp_layer.c

+5 −4
Original line number Diff line number Diff line
@@ -734,11 +734,12 @@ static struct mdss_fence *__create_fence(struct msm_fb_data_type *mfd, 


	if ((fence_type == MDSS_MDP_RETIRE_FENCE) &&

		(mfd->panel.type == MIPI_CMD_PANEL)) {

		if (mdp5_data->vsync_timeline) {

			value = 1 + mdp5_data->retire_cnt++;

		if (sync_pt_data->timeline_retire) {

			value = sync_pt_data->timeline_retire->value + 1 +

				mdp5_data->retire_cnt++;

			sync_fence = mdss_fb_sync_get_fence(

				mdp5_data->vsync_timeline, fence_name,

				value);

				sync_pt_data->timeline_retire,

				fence_name, value);

		} else {

			return ERR_PTR(-EPERM);

		}

drivers/video/fbdev/msm/mdss_mdp_overlay.c

+35 −30
Original line number Diff line number Diff line
@@ -5939,10 +5939,8 @@ static int mdss_mdp_overlay_on(struct msm_fb_data_type *mfd) 
		rc = mdss_mdp_overlay_start(mfd);

		if (rc)

			goto end;

		if (mfd->panel_info->type != WRITEBACK_PANEL) {

			atomic_inc(&mfd->mdp_sync_pt_data.commit_cnt);

		if (mfd->panel_info->type != WRITEBACK_PANEL)

			rc = mdss_mdp_overlay_kickoff(mfd, NULL);

		}

	} else {

		rc = mdss_mdp_ctl_setup(ctl);

		if (rc)
@@ -6340,10 +6338,11 @@ static void __vsync_retire_signal(struct msm_fb_data_type *mfd, int val) 


	mutex_lock(&mfd->mdp_sync_pt_data.sync_mutex);

	if (mdp5_data->retire_cnt > 0) {

		mdss_inc_timeline(mdp5_data->vsync_timeline, val);

		mdss_inc_timeline(mfd->mdp_sync_pt_data.timeline_retire, val);

		mdp5_data->retire_cnt -= min(val, mdp5_data->retire_cnt);

		pr_debug("Retire signaled! timeline val=%d remaining=%d\n",

			mdss_get_timeline_retire_ts(mdp5_data->vsync_timeline),

			mdss_get_timeline_retire_ts(

			mfd->mdp_sync_pt_data.timeline_retire),

			mdp5_data->retire_cnt);



		if (mdp5_data->retire_cnt == 0) {
@@ -6382,7 +6381,7 @@ __vsync_retire_get_fence(struct msm_sync_pt_data *sync_pt_data) 
	value = 1 + mdp5_data->retire_cnt;

	mdp5_data->retire_cnt++;



	return mdss_fb_sync_get_fence(mdp5_data->vsync_timeline,

	return mdss_fb_sync_get_fence(mfd->mdp_sync_pt_data.timeline_retire,

			"mdp-retire", value);

}
@@ -6420,19 +6419,27 @@ static int __vsync_retire_setup(struct msm_fb_data_type *mfd) 
	struct sched_param param = { .sched_priority = 5 };



	snprintf(name, sizeof(name), "mdss_fb%d_retire", mfd->index);

	mdp5_data->vsync_timeline = mdss_create_timeline(name);

	if (mdp5_data->vsync_timeline == NULL) {

	mfd->mdp_sync_pt_data.timeline_retire = mdss_create_timeline(name);

	if (mfd->mdp_sync_pt_data.timeline_retire == NULL) {

		pr_err("cannot vsync create time line");

		return -ENOMEM;

	}



	/*

	 * vsync_work is required only for command mode panels and for panels

	 * with dynamic mode switch supported. For all other panels the retire

	 * fence is signaled along with the release fence once the frame

	 * transfer is done.

	 */

	if ((mfd->panel_info->mipi.dms_mode) ||

		(mfd->panel_info->type == MIPI_CMD_PANEL)) {

		kthread_init_worker(&mdp5_data->worker);

	kthread_init_work(&mdp5_data->vsync_work, __vsync_retire_work_handler);

		kthread_init_work(&mdp5_data->vsync_work,

			__vsync_retire_work_handler);



		mdp5_data->thread = kthread_run(kthread_worker_fn,

					&mdp5_data->worker,

					"vsync_retire_work");



		if (IS_ERR(mdp5_data->thread)) {

			pr_err("unable to start vsync thread\n");

			mdp5_data->thread = NULL;
@@ -6440,12 +6447,12 @@ static int __vsync_retire_setup(struct msm_fb_data_type *mfd) 
		}



		sched_setscheduler(mdp5_data->thread, SCHED_FIFO, &param);



	mfd->mdp_sync_pt_data.get_retire_fence = __vsync_retire_get_fence;



		mfd->mdp_sync_pt_data.get_retire_fence =

				__vsync_retire_get_fence;

		mdp5_data->vsync_retire_handler.vsync_handler =

				__vsync_retire_handle_vsync;

		mdp5_data->vsync_retire_handler.cmd_post_flush = false;

	}



	return 0;

}
@@ -6715,14 +6722,12 @@ int mdss_mdp_overlay_init(struct msm_fb_data_type *mfd) 
		}

	}



	if (mfd->panel_info->mipi.dms_mode ||

			mfd->panel_info->type == MIPI_CMD_PANEL) {

	rc = __vsync_retire_setup(mfd);

	if (IS_ERR_VALUE((unsigned long)rc)) {

		pr_err("unable to create vsync timeline\n");

		goto init_fail;

	}

	}



	mfd->mdp_sync_pt_data.async_wait_fences = true;



	pm_runtime_set_suspended(&mfd->pdev->dev);

drivers/video/fbdev/msm/mdss_rotator.c

+1 −1
Original line number Diff line number Diff line
@@ -387,7 +387,7 @@ static int mdss_rotator_create_fence(struct mdss_rot_entry *entry) 
	rot_timeline = &entry->queue->timeline;



	mutex_lock(&rot_timeline->lock);

	val = 1;

	val = rot_timeline->next_value + 1;



	fence = mdss_get_sync_fence(rot_timeline->timeline,

					rot_timeline->fence_name, NULL, val);