Merge "fbdev: msm: Avoid creation of extra retire timeline" (3abeaf8a) · Commits · e / devices / android_kernel_fairphone_FP3

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);