X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_output.c;h=e73de5b61716967c26e5cde93537e4c3f2df0c67;hb=9a64cd40fd535def8143e3a1490bf2f5e548459c;hp=19dfc4fc70b4c952798577ba593f79eea6c898b3;hpb=adc84dc2bdaeedfc198dc3328e0614beda9771af;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_output.c b/src/tdm_output.c
index 19dfc4f..e73de5b 100644
--- a/src/tdm_output.c
+++ b/src/tdm_output.c
@@ -64,11 +64,16 @@ static tdm_error
 _tdm_output_vblank_timeout_cb(void *user_data)
 {
 	tdm_private_output *private_output = user_data;
-	tdm_private_vblank_handler *v = NULL;
+	tdm_private_output_vblank_handler *v = NULL;
 
 	TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OPERATION_FAILED);
 
-	TDM_ERR("TDM output(%d) vblank TIMEOUT!!", private_output->pipe);
+	private_output->vblank_timeout_timer_expired++;
+
+	TDM_ERR("TDM output(%d) vblank TIMEOUT!! (%d time%s)",
+			private_output->pipe,
+			private_output->vblank_timeout_timer_expired,
+			(private_output->vblank_timeout_timer_expired > 1) ? "s" : "");
 
 	LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
 		TDM_ERR("vblank_handler(%p) interval(%d) sync(%d) sent_to_frontend(%u) owner_tid(%d)",
@@ -81,7 +86,7 @@ _tdm_output_vblank_timeout_cb(void *user_data)
 INTERN void
 tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data)
 {
-	tdm_private_vblank_handler *v = NULL;
+	tdm_private_output_vblank_handler *v = NULL;
 
 	TDM_RETURN_IF_FAIL(private_output != NULL);
 	TDM_RETURN_IF_FAIL(user_data != NULL);
@@ -112,6 +117,7 @@ _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_del
 			return;
 		}
 		TDM_INFO("output(%d) create vblank timeout timer", private_output->pipe);
+		private_output->vblank_timeout_timer_expired = 0;
 	}
 
 	ret = tdm_event_loop_source_timer_update(private_output->vblank_timeout_timer, ms_delay);
@@ -135,6 +141,35 @@ _tdm_output_find_private_hwc_window(tdm_private_output *private_output,
 	return NULL;
 }
 
+INTERN tdm_error
+tdm_output_init(tdm_private_display *private_display)
+{
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp);
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp);
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_CHANGE, tdm_display_find_output_stamp);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_backend *
+tdm_output_get_backend(tdm_output *output, tdm_error *error)
+{
+	tdm_private_backend *private_backend;
+
+	OUTPUT_FUNC_ENTRY_ERROR();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	private_backend = private_output->private_backend;
+
+	if (error)
+		*error = TDM_ERROR_NONE;
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return private_backend;
+}
+
 EXTERN tdm_error
 tdm_output_get_model_info(tdm_output *output, const char **maker,
 						  const char **model, const char **name)
@@ -187,87 +222,108 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
 	return ret;
 }
 
-/* LCOV_EXCL_START */
-static void
-_tdm_output_update(tdm_output *output_backend, void *user_data)
+INTERN void
+tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 {
-	tdm_private_display *private_display;
-	tdm_private_output *private_output = user_data;
+	tdm_private_output *private_output = object;
+	tdm_thread_cb_output_change *output_change = (tdm_thread_cb_output_change *)cb_base;
+	tdm_private_output_change_handler *change_handler = user_data;
+
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+	assert(change_handler->owner_tid == syscall(SYS_gettid));
+
+	_pthread_mutex_unlock(&private_display->lock);
+	change_handler->func(private_output, output_change->type, output_change->value, change_handler->user_data);
+	_pthread_mutex_lock(&private_display->lock);
+}
+
+static tdm_error
+_tdm_output_call_thread_cb_change(tdm_private_output *private_output, tdm_output_change_type type, tdm_value value)
+{
+	tdm_thread_cb_output_change output_change;
 	tdm_error ret;
 
-	TDM_RETURN_IF_FAIL(private_output);
+	memset(&output_change, 0, sizeof output_change);
+	output_change.base.type = TDM_THREAD_CB_OUTPUT_CHANGE;
+	output_change.base.length = sizeof output_change;
+	output_change.base.object_stamp = private_output->stamp;
+	output_change.base.data = NULL;
+	output_change.base.sync = 1;
+	output_change.type = type;
+	output_change.value = value;
 
-	private_display = private_output->private_display;
+	ret = tdm_thread_cb_call(private_output, &output_change.base);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-	ret = tdm_display_update_output(private_display, output_backend, private_output->pipe);
-	TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+	return TDM_ERROR_NONE;
 }
 
 INTERN void
-tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
-					 void *user_data)
+tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data)
 {
-	tdm_private_display *private_display;
 	tdm_private_output *private_output = user_data;
 	tdm_value value;
+	tdm_error ret;
 
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 	TDM_RETURN_IF_FAIL(private_output);
 
-	private_display = private_output->private_display;
-
-	if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
-		tdm_thread_cb_output_status output_status;
-		tdm_error ret;
-
-		TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
+	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
 
-		_tdm_output_update(output_backend, user_data);
+	if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
+		(private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) {
+		ret = tdm_display_update_output(private_output->private_backend, output_backend, private_output->pipe, 1);
+		TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+	} else {
+		private_output->caps.status = status;
+	}
 
-		output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
-		output_status.base.length = sizeof output_status;
-		output_status.output_stamp = private_output->stamp;
-		output_status.status = status;
-		output_status.user_data = user_data;
+	value.u32 = status;
 
-		value.u32 = status;
-		tdm_output_call_change_handler_internal(private_output,
-												&private_output->change_handler_list_sub,
-												TDM_OUTPUT_CHANGE_CONNECTION,
-												value, 0);
+	ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_CONNECTION, value);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_status.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+INTERN void
+tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data)
+{
+	tdm_private_output *private_output = user_data;
+	tdm_value value;
+	tdm_error ret;
 
-		return;
-	}
+	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms));
 
-	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
+	private_output->current_dpms_value = dpms;
+	private_output->waiting_dpms_change = 0;
+	TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms));
 
-	if (!tdm_thread_is_running())
-		_tdm_output_update(output_backend, user_data);
+	value.u32 = dpms;
 
-	value.u32 = status;
-	tdm_output_call_change_handler_internal(private_output,
-											&private_output->change_handler_list_main,
-											TDM_OUTPUT_CHANGE_CONNECTION,
-											value, 0);
+	ret = _tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 }
-/* LCOV_EXCL_STOP */
 
 EXTERN tdm_error
 tdm_output_add_change_handler(tdm_output *output,
 							  tdm_output_change_handler func,
 							  void *user_data)
 {
-	tdm_private_change_handler *change_handler;
+	tdm_private_output_change_handler *change_handler = NULL;
 	OUTPUT_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	change_handler = calloc(1, sizeof(tdm_private_change_handler));
+	LIST_FOR_EACH_ENTRY(change_handler, &private_output->change_handler_list, link) {
+		if (change_handler->func == func && change_handler->user_data == user_data) {
+			TDM_ERR("can't add twice");
+			_pthread_mutex_unlock(&private_display->lock);
+			return TDM_ERROR_BAD_REQUEST;
+		}
+	}
+
+	change_handler = calloc(1, sizeof(tdm_private_output_change_handler));
 	if (!change_handler) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("failed: alloc memory");
@@ -276,15 +332,22 @@ tdm_output_add_change_handler(tdm_output *output,
 		/* LCOV_EXCL_STOP */
 	}
 
+	ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		TDM_ERR("tdm_thread_cb_add failed");
+		free(change_handler);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OPERATION_FAILED;
+		/* LCOV_EXCL_STOP */
+	}
+
 	change_handler->private_output = private_output;
 	change_handler->func = func;
 	change_handler->user_data = user_data;
 	change_handler->owner_tid = syscall(SYS_gettid);
 
-	if (!tdm_thread_in_display_thread(change_handler->owner_tid))
-		LIST_ADDTAIL(&change_handler->link, &private_output->change_handler_list_sub);
-	else
-		LIST_ADDTAIL(&change_handler->link, &private_output->change_handler_list_main);
+	LIST_ADDTAIL(&change_handler->link, &private_output->change_handler_list);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -298,7 +361,7 @@ tdm_output_remove_change_handler(tdm_output *output,
 {
 	tdm_private_display *private_display;
 	tdm_private_output *private_output;
-	tdm_private_change_handler *h = NULL, *hh = NULL;
+	tdm_private_output_change_handler *change_handler = NULL, *hh = NULL;
 
 	TDM_RETURN_IF_FAIL(tdm_output_is_valid(output));
 	TDM_RETURN_IF_FAIL(func != NULL);
@@ -308,24 +371,14 @@ tdm_output_remove_change_handler(tdm_output *output,
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) {
-		if (h->func != func || h->user_data != user_data)
+	LIST_FOR_EACH_ENTRY_SAFE(change_handler, hh, &private_output->change_handler_list, link) {
+		if (change_handler->func != func || change_handler->user_data != user_data)
 			continue;
 
-		LIST_DEL(&h->link);
-		free(h);
-
-		_pthread_mutex_unlock(&private_display->lock);
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_CHANGE, NULL, tdm_output_thread_cb_change, change_handler);
 
-		return;
-	}
-
-	LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) {
-		if (h->func != func || h->user_data != user_data)
-			continue;
-
-		LIST_DEL(&h->link);
-		free(h);
+		LIST_DEL(&change_handler->link);
+		free(change_handler);
 
 		_pthread_mutex_unlock(&private_display->lock);
 
@@ -485,22 +538,9 @@ tdm_output_get_cursor_available_size(tdm_output *output, int *min_w, int *min_h,
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!tdm_display_check_module_abi(private_display, 1, 5)) {
-
-		if (min_w)
-			*min_w = -1;
-		if (min_h)
-			*min_h = -1;
-		if (max_w)
-			*max_w = -1;
-		if (max_h)
-			*max_h = -1;
-		if (preferred_align)
-			*preferred_align = -1;
-
+	if (!tdm_backend_check_module_abi(private_output->private_backend, 1, 5)) {
 		_pthread_mutex_unlock(&private_display->lock);
-
-		return TDM_ERROR_BAD_MODULE;
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
 	if (min_w)
@@ -592,17 +632,19 @@ tdm_output_get_primary_index(tdm_output *output, int *index)
 EXTERN tdm_error
 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_set_property) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -618,6 +660,7 @@ tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
 EXTERN tdm_error
 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -625,12 +668,13 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_get_property) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -643,50 +687,26 @@ tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
 	return ret;
 }
 
-INTERN void
-tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
-					 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+static void
+_tdm_output_thread_cb_vblank(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 {
-	tdm_private_vblank_handler *vblank_handler = user_data;
-	tdm_private_vblank_handler *v = NULL, *vv = NULL;
-	tdm_private_output *private_output;
-	tdm_private_display *private_display;
+	tdm_thread_cb_output_vblank *output_vblank = (tdm_thread_cb_output_vblank *)cb_base;
+	tdm_private_output_vblank_handler *vblank_handler = output_vblank->base.data;
+	tdm_private_output_vblank_handler *v = NULL, *vv = NULL;
+	tdm_private_output *private_output = object;
 	struct list_head clone_list;
 	int interval, sync;
 	pid_t tid = syscall(SYS_gettid);
 
 	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(vblank_handler);
-
-	private_output = vblank_handler->private_output;
-	private_display = private_output->private_display;
-
-	if (vblank_handler->owner_tid != tid) {
-		tdm_thread_cb_output_vblank output_vblank;
-		tdm_error ret;
 
-		vblank_handler->sent_to_frontend = 1;
-
-		output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
-		output_vblank.base.length = sizeof output_vblank;
-		output_vblank.output_stamp = vblank_handler->private_output->stamp;
-		output_vblank.sequence = sequence;
-		output_vblank.tv_sec = tv_sec;
-		output_vblank.tv_usec = tv_usec;
-		output_vblank.user_data = user_data;
-
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
-		return;
-	}
+	assert(vblank_handler->owner_tid == tid);
 
 	vblank_handler->sent_to_frontend = 0;
 
 	_tdm_output_vblank_timeout_update(private_output, 0);
 
-	if (vblank_handler->owner_tid != tid)
-		TDM_NEVER_GET_HERE();
+	tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
 
 	interval = vblank_handler->interval;
 	sync = vblank_handler->sync;
@@ -712,7 +732,11 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 		LIST_DEL(&v->link);
 
 		if (v->func)
-			v->func(v->private_output, sequence, tv_sec, tv_usec, v->user_data);
+			v->func(v->private_output,
+					output_vblank->sequence,
+					output_vblank->tv_sec,
+					output_vblank->tv_usec,
+					v->user_data);
 
 		free(v);
 	}
@@ -722,13 +746,36 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 		TDM_INFO("-----------------------------------------...");
 }
 
-INTERN void
-tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
-					 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+static void
+_tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
+					  unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 {
-	tdm_private_output_commit_handler *output_commit_handler = user_data;
-	tdm_private_display *private_display;
-	tdm_private_output *private_output;
+	tdm_private_output_vblank_handler *vblank_handler = user_data;
+	tdm_thread_cb_output_vblank output_vblank;
+	tdm_error ret;
+
+	memset(&output_vblank, 0, sizeof output_vblank);
+	output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
+	output_vblank.base.length = sizeof output_vblank;
+	output_vblank.base.object_stamp = vblank_handler->private_output->stamp;
+	output_vblank.base.data = vblank_handler;
+	output_vblank.base.sync = 0;
+	output_vblank.sequence = sequence;
+	output_vblank.tv_sec = tv_sec;
+	output_vblank.tv_usec = tv_usec;
+
+	vblank_handler->sent_to_frontend = 1;
+
+	ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
+static void
+_tdm_output_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
+{
+	tdm_thread_cb_output_commit *output_commit = (tdm_thread_cb_output_commit *)cb_base;
+	tdm_private_output_commit_handler *output_commit_handler = output_commit->base.data;
+	tdm_private_output *private_output = object;
 	tdm_private_layer *private_layer = NULL;
 
 	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
@@ -736,26 +783,9 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 	if (!output_commit_handler)
 		return;
 
-	private_output = output_commit_handler->private_output;
-	private_display = private_output->private_display;
-
-	if (output_commit_handler->owner_tid != syscall(SYS_gettid)) {
-		tdm_thread_cb_output_commit output_commit;
-		tdm_error ret;
-
-		output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
-		output_commit.base.length = sizeof output_commit;
-		output_commit.output_stamp = private_output->stamp;
-		output_commit.sequence = sequence;
-		output_commit.tv_sec = tv_sec;
-		output_commit.tv_usec = tv_usec;
-		output_commit.user_data = user_data;
+	assert(output_commit_handler->owner_tid == syscall(SYS_gettid));
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
-		return;
-	}
+	tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
 
 	LIST_DEL(&output_commit_handler->link);
 
@@ -774,8 +804,11 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 
 	if (output_commit_handler->func) {
 		_pthread_mutex_unlock(&private_display->lock);
-		output_commit_handler->func(private_output, sequence,
-									tv_sec, tv_usec, output_commit_handler->user_data);
+		output_commit_handler->func(private_output,
+									output_commit->sequence,
+									output_commit->tv_sec,
+									output_commit->tv_usec,
+									output_commit_handler->user_data);
 		_pthread_mutex_lock(&private_display->lock);
 	}
 
@@ -785,23 +818,52 @@ tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
 		TDM_INFO("-----------------------------------------...");
 }
 
+static void
+_tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
+					  unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+	tdm_private_output_commit_handler *output_commit_handler = user_data;
+	tdm_private_output *private_output;
+	tdm_thread_cb_output_commit output_commit;
+	tdm_error ret;
+
+	if (output_commit_handler)
+		private_output = output_commit_handler->private_output;
+	else
+		private_output = tdm_display_find_private_output(tdm_display_get(), output_backend);
+
+	memset(&output_commit, 0, sizeof output_commit);
+	output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
+	output_commit.base.length = sizeof output_commit;
+	output_commit.base.object_stamp = private_output->stamp;
+	output_commit.base.data = output_commit_handler;
+	output_commit.base.sync = 0;
+	output_commit.sequence = sequence;
+	output_commit.tv_sec = tv_sec;
+	output_commit.tv_usec = tv_usec;
+
+	ret = tdm_thread_cb_call(private_output, &output_commit.base);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
 /* add_front: To distinguish between the user vblank handlers and the layer
  *            commit vblank handlers. The layer commit handlers will be called
  *            before calling the user vblank handlers.
  */
 static tdm_error
-_tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
+_tdm_output_wait_vblank(tdm_private_output *private_output, int interval, int sync,
 						tdm_output_vblank_handler func, void *user_data,
 						unsigned int add_front)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
-	tdm_private_vblank_handler *vblank_handler = NULL, *v = NULL;
+	tdm_private_output_vblank_handler *vblank_handler = NULL, *v = NULL;
 	unsigned int skip_request = 0;
 	pid_t tid = syscall(SYS_gettid);
+	tdm_error ret = TDM_ERROR_NONE;
 
-	OUTPUT_FUNC_ENTRY();
-
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	/* interval SHOULD be at least 1 */
 	if (interval <= 0)
@@ -809,7 +871,7 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 
 	if (!func_output->output_wait_vblank) {
 		/* LCOV_EXCL_START */
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -817,10 +879,10 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 	if (!private_output->regist_vblank_cb) {
 		private_output->regist_vblank_cb = 1;
 		ret = func_output->output_set_vblank_handler(private_output->output_backend,
-				tdm_output_cb_vblank);
+				_tdm_output_cb_vblank);
 	}
 
-	vblank_handler = calloc(1, sizeof(tdm_private_vblank_handler));
+	vblank_handler = calloc(1, sizeof(tdm_private_output_vblank_handler));
 	if (!vblank_handler) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("failed: alloc memory");
@@ -852,6 +914,12 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 
 	/* If there is the previous request, we can skip to call output_wait_vblank() */
 	if (!skip_request) {
+		ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
+		if (ret != TDM_ERROR_NONE) {
+			TDM_ERR("tdm_thread_cb_add failed");
+			goto wait_failed;
+		}
+
 		ret = func_output->output_wait_vblank(private_output->output_backend, interval,
 											  sync, vblank_handler);
 		TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
@@ -867,6 +935,7 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 wait_failed:
 	/* LCOV_EXCL_START */
 	if (vblank_handler) {
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
 		LIST_DEL(&vblank_handler->link);
 		free(vblank_handler);
 	}
@@ -879,6 +948,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 					   tdm_output_vblank_handler func, void *user_data)
 {
 	OUTPUT_FUNC_ENTRY();
+	TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 
 	_pthread_mutex_lock(&private_display->lock);
 
@@ -889,7 +959,7 @@ tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 		return TDM_ERROR_DPMS_OFF;
 	}
 
-	ret = _tdm_output_wait_vblank(output, interval, sync, func, user_data, 0);
+	ret = _tdm_output_wait_vblank(private_output, interval, sync, func, user_data, 0);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -912,7 +982,7 @@ tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync,
 		return TDM_ERROR_DPMS_OFF;
 	}
 
-	ret = _tdm_output_wait_vblank(output, interval, sync, func, user_data, 1);
+	ret = _tdm_output_wait_vblank(private_output, interval, sync, func, user_data, 1);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -924,7 +994,7 @@ INTERN void
 tdm_output_remove_vblank_handler_internal(tdm_output *output, tdm_output_vblank_handler func, void *user_data)
 {
 	tdm_private_output *private_output = (tdm_private_output*)output;
-	tdm_private_vblank_handler *v = NULL;
+	tdm_private_output_vblank_handler *v = NULL;
 
 	TDM_RETURN_IF_FAIL(private_output != NULL);
 	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
@@ -989,18 +1059,23 @@ tdm_output_remove_commit_handler(tdm_output *output, tdm_output_commit_handler f
 INTERN tdm_error
 tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
 {
+	tdm_private_output *private_output;
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	tdm_private_output_commit_handler *output_commit_handler = NULL;
 	tdm_private_layer *private_layer = NULL;
 	tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_ON;
+	tdm_error ret = TDM_ERROR_NONE;
 
-	OUTPUT_FUNC_ENTRY();
+	TDM_RETURN_VAL_IF_FAIL(tdm_output_is_valid(output), TDM_ERROR_INVALID_PARAMETER);
 
-	func_output = &private_display->func_output;
+	private_output = (tdm_private_output*)output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_commit) {
 		/* LCOV_EXCL_START */
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1012,8 +1087,7 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 		if (func) {
 			if (!private_output->regist_commit_cb) {
 				private_output->regist_commit_cb = 1;
-				ret = func_output->output_set_commit_handler(private_output->output_backend,
-							tdm_output_cb_commit);
+				ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit);
 				TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 			}
 
@@ -1025,6 +1099,13 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 				/* LCOV_EXCL_STOP */
 			}
 
+			ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
+			if (ret != TDM_ERROR_NONE) {
+				TDM_ERR("tdm_thread_cb_add failed");
+				free(output_commit_handler);
+				return ret;
+			}
+
 			LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list);
 			output_commit_handler->private_output = private_output;
 			output_commit_handler->func = func;
@@ -1067,6 +1148,7 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 commit_failed:
 	/* LCOV_EXCL_START */
 	if (output_commit_handler) {
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
 		LIST_DEL(&output_commit_handler->link);
 		free(output_commit_handler);
 	}
@@ -1123,6 +1205,7 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 EXTERN tdm_error
 tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -1130,12 +1213,13 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_set_mode) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1143,6 +1227,7 @@ tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
 	ret = func_output->output_set_mode(private_output->output_backend, mode);
 	if (ret == TDM_ERROR_NONE) {
 		private_output->current_mode = mode;
+		private_output->need_set_target_info = 1;
 		TDM_INFO("mode: %dx%d %dhz", mode->hdisplay, mode->vdisplay, mode->vrefresh);
 	}
 
@@ -1167,113 +1252,10 @@ tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
 	return ret;
 }
 
-static tdm_error
-_tdm_output_dpms_changed_timeout(void *user_data)
-{
-	tdm_private_output *private_output = user_data;
-	tdm_value value;
-
-	value.u32 = private_output->current_dpms_value;
-	tdm_output_call_change_handler_internal(private_output,
-											&private_output->change_handler_list_sub,
-											TDM_OUTPUT_CHANGE_DPMS,
-											value, 0);
-
-	return TDM_ERROR_NONE;
-}
-
-static tdm_error
-tdm_output_call_dpms_change_handler(tdm_output *output)
-{
-	tdm_private_output *private_output = (tdm_private_output*)output;
-	tdm_value value;
-
-	/** Use timer to call the output change callback of the sub-thread.
-	 * The output change callback of tdm_server and tdm_vblank was called
-	 * in the main thread. And it made the multi thread issue. If we use
-	 * the timer, we can call the sub-thread's output change callback in
-	 * sub-thread.
-	 */
-	if (!private_output->dpms_changed_timer) {
-		private_output->dpms_changed_timer =
-			tdm_event_loop_add_timer_handler(private_output->private_display,
-											 _tdm_output_dpms_changed_timeout, private_output, NULL);
-		if (!private_output->dpms_changed_timer) {
-			/* LCOV_EXCL_START */
-			TDM_ERR("can't create dpms timer!!");
-			return TDM_ERROR_OUT_OF_MEMORY;
-			/* LCOV_EXCL_STOP */
-		}
-	}
-
-	value.u32 = private_output->current_dpms_value;
-	tdm_output_call_change_handler_internal(private_output,
-											&private_output->change_handler_list_main,
-											TDM_OUTPUT_CHANGE_DPMS,
-											value, 0);
-
-	if (!LIST_IS_EMPTY(&private_output->change_handler_list_sub)) {
-		tdm_error ret = tdm_event_loop_source_timer_update(private_output->dpms_changed_timer, 1);
-		if (ret != TDM_ERROR_NONE)
-			TDM_NEVER_GET_HERE();
-	}
-
-	return TDM_ERROR_NONE;
-}
-
-/* LCOV_EXCL_START */
-INTERN void
-tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data)
-{
-	tdm_private_display *private_display;
-	tdm_private_output *private_output = user_data;
-	tdm_value value;
-
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(private_output);
-
-	private_display = private_output->private_display;
-
-	if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
-		tdm_thread_cb_output_dpms output_dpms;
-		tdm_error ret;
-
-		_tdm_output_update(output_backend, user_data);
-
-		output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS;
-		output_dpms.base.length = sizeof output_dpms;
-		output_dpms.output_stamp = private_output->stamp;
-		output_dpms.dpms = dpms;
-		output_dpms.user_data = user_data;
-
-		value.u32 = dpms;
-		tdm_output_call_change_handler_internal(private_output,
-												&private_output->change_handler_list_sub,
-												TDM_OUTPUT_CHANGE_DPMS,
-												value, 0);
-
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_dpms.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
-		return;
-	}
-
-	private_output->current_dpms_value = dpms;
-	private_output->waiting_dpms_change = 0;
-
-	TDM_INFO("output(%d) dpms async '%s' done", private_output->pipe, tdm_dpms_str(dpms));
-
-	value.u32 = dpms;
-	tdm_output_call_change_handler_internal(private_output,
-											&private_output->change_handler_list_main,
-											TDM_OUTPUT_CHANGE_DPMS,
-											value, 0);
-}
-/* LCOV_EXCL_STOP */
-
 EXTERN tdm_error
 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -1298,7 +1280,8 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	TDM_INFO("output(%d) dpms '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
 
@@ -1315,9 +1298,11 @@ tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 done:
 	if (ret == TDM_ERROR_NONE) {
 		if (private_output->current_dpms_value != dpms_value) {
+			tdm_value value;
 			private_output->current_dpms_value = dpms_value;
+			value.u32 = dpms_value;
+			_tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value);
 			TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value));
-			tdm_output_call_dpms_change_handler(output);
 		}
 	} else {
 		tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
@@ -1337,6 +1322,7 @@ done:
 EXTERN tdm_error
 tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -1366,15 +1352,16 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 	if (!func_output->output_set_dpms_handler) {
-		TDM_ERR("not implemented: output_set_dpms_handler");
+		TDM_WRN("not implemented: output_set_dpms_handler");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
 
 	if (!func_output->output_set_dpms_async) {
-		TDM_ERR("not implemented: output_set_dpms_async");
+		TDM_WRN("not implemented: output_set_dpms_async");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
@@ -1415,10 +1402,14 @@ tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 INTERN tdm_error
 tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 {
+	tdm_private_output *private_output;
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
-	OUTPUT_FUNC_ENTRY();
+	tdm_error ret = TDM_ERROR_NONE;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_output_is_valid(output), TDM_ERROR_INVALID_PARAMETER);
 
-	TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
+	private_output = (tdm_private_output*)output;
 
 	/* TODO: this is ugly. But before calling backend's output_get_dpms(), we have
 	 * to check if all backends's DPMS operation has no problem. In future, we'd
@@ -1430,7 +1421,8 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 		return TDM_ERROR_NONE;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_get_dpms) {
 		/* LCOV_EXCL_START */
@@ -1450,11 +1442,13 @@ tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 
 	/* checking with backend's value */
 	if (*dpms_value != private_output->current_dpms_value) {
+		tdm_value value;
 		TDM_ERR("output(%d) dpms changed suddenly: %s -> %s",
 				private_output->pipe, private_output->current_dpms_value,
 				tdm_dpms_str(*dpms_value));
 		private_output->current_dpms_value = *dpms_value;
-		tdm_output_call_dpms_change_handler(output);
+		value.u32 = *dpms_value;
+		_tdm_output_call_thread_cb_change(private_output, TDM_OUTPUT_CHANGE_DPMS, value);
 	}
 
 	return ret;
@@ -1560,6 +1554,7 @@ EXTERN tdm_error
 tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds,
 									uint32_t num_wnds, uint32_t *num_types)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output = NULL;
 	tdm_private_hwc_window **composited_wnds_frontend = NULL;
 	tdm_hwc_window **composited_wnds_backend = NULL;
@@ -1577,12 +1572,13 @@ tdm_output_hwc_validate(tdm_output *output, tdm_hwc_window **composited_wnds,
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_validate) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1653,6 +1649,7 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output,
 										 tdm_hwc_window **hwc_window,
 										 tdm_hwc_window_composition *composition_types)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output = NULL;
 	tdm_private_hwc_window * private_hwc_window = NULL;
 	int i = 0;
@@ -1669,12 +1666,13 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output,
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_get_changed_composition_types) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1718,6 +1716,7 @@ tdm_output_hwc_get_changed_composition_types(tdm_output *output,
 tdm_error
 tdm_output_hwc_accept_changes(tdm_output *output)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output = NULL;
 
 	OUTPUT_FUNC_ENTRY();
@@ -1730,12 +1729,13 @@ tdm_output_hwc_accept_changes(tdm_output *output)
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_validate) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1750,6 +1750,7 @@ tdm_output_hwc_accept_changes(tdm_output *output)
 tbm_surface_queue_h
 tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output = NULL;
 	tbm_surface_queue_h queue = NULL;
 
@@ -1765,12 +1766,13 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error)
 		return NULL;
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_get_target_buffer_queue) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return NULL;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1783,14 +1785,10 @@ tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error)
 }
 
 EXTERN tdm_error
-tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer,
-									tdm_hwc_region damage, tdm_hwc_window **composited_wnds,
-									uint32_t num_wnds)
+tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output = NULL;
-	tdm_private_hwc_window **composited_wnds_frontend = NULL;
-	tdm_hwc_window **composited_wnds_backend = NULL;
-	int i;
 
 	OUTPUT_FUNC_ENTRY();
 
@@ -1812,42 +1810,187 @@ tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target
 		/* LCOV_EXCL_STOP */
 	}
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_set_client_target_buffer) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
+		TDM_WRN("not implemented!!");
+		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
+	}
+
+	ret = func_output->output_hwc_set_client_target_buffer(private_output->output_backend, target_buffer, damage);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+EXTERN tdm_error
+tdm_output_hwc_unset_client_target_buffer(tdm_output *output)
+{
+	tdm_private_backend *private_backend;
+	tdm_func_output *func_output = NULL;
+
+	OUTPUT_FUNC_ENTRY();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) {
+		TDM_ERR("output(%p) not support HWC", private_output);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
+
+	if (!func_output->output_hwc_unset_client_target_buffer) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
 		TDM_ERR("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
 
-	if (num_wnds == 0) {
-		ret = func_output->output_hwc_set_client_target_buffer(private_output->output_backend, target_buffer,
-					damage, NULL, 0);
+	ret = func_output->output_hwc_unset_client_target_buffer(private_output->output_backend);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+static void
+_tdm_output_hwc_layer_commit_handler(tdm_layer *layer, unsigned int sequence,
+										 unsigned int tv_sec, unsigned int tv_usec,
+										 void *user_data)
+{
+	tdm_private_output_hwc_target_buffer_commit_handler *output_hwc_target_buffer_commit_handler = (tdm_private_output_hwc_target_buffer_commit_handler *)user_data;
+	tdm_output_hwc_target_buffer_commit_handler func = output_hwc_target_buffer_commit_handler->func;
+	tdm_output *output = (tdm_output *)output_hwc_target_buffer_commit_handler->private_output;
+	void *data = output_hwc_target_buffer_commit_handler->user_data;
+
+	func(output, sequence, tv_sec, tv_usec, data);
+
+	free(output_hwc_target_buffer_commit_handler);
+}
+
+tdm_error
+tdm_output_hwc_commit_client_target_buffer(tdm_output *output, tdm_output_hwc_target_buffer_commit_handler func, void *user_data)
+{
+	tdm_private_backend *private_backend;
+	tdm_func_output *func_output;
+	tdm_private_output_hwc_target_buffer_commit_handler *output_hwc_target_buffer_commit_handler;
+	tdm_layer *layer = NULL;
+	tdm_private_layer *private_layer;
+	const tdm_output_mode *mode;
+	tbm_surface_h buffer;
+
+	OUTPUT_FUNC_ENTRY();
+
+	_pthread_mutex_lock(&private_display->lock);
 
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) {
+		TDM_ERR("output(%p) not support HWC", private_output);
 		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
 
-		return ret;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
+
+	if (!func_output->output_hwc_get_client_target_buffer_layer) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		TDM_ERR("not implemented!!");
+		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
 	}
 
-	composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *));
-	if (!composited_wnds_backend) {
+	layer = func_output->output_hwc_get_client_target_buffer_layer(private_output->output_backend,
+														   &ret);
+	if (!layer) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		return TDM_ERROR_OUT_OF_MEMORY;
+		TDM_ERR("no assigned layer!!");
+		return TDM_ERROR_INVALID_PARAMETER;
 		/* LCOV_EXCL_STOP */
 	}
 
-	composited_wnds_frontend = (tdm_private_hwc_window **)composited_wnds;
+	private_layer = (tdm_private_layer*)layer;
 
-	for (i = 0; i < num_wnds; i++)
-		composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend;
+	if (!func_output->output_hwc_get_client_target_buffer) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		TDM_ERR("not implemented!!");
+		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
+	}
 
-	ret = func_output->output_hwc_set_client_target_buffer(private_output->output_backend, target_buffer,
-			damage, composited_wnds_backend, num_wnds);
+	buffer = func_output->output_hwc_get_client_target_buffer(private_output->output_backend,
+													   &ret);
+	if (buffer)
+		ret = tdm_layer_set_buffer_internal(private_layer, buffer);
+	else
+		ret = tdm_layer_unset_buffer_internal(private_layer);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		TDM_ERR("failed: layer set info(window)");
+		_pthread_mutex_unlock(&private_display->lock);
+		/* LCOV_EXCL_STOP */
+		return ret;
+	}
 
-	free(composited_wnds_backend);
+	if (private_output->need_set_target_info) {
+		mode = private_output->current_mode;
+		private_output->target_buffer_info.src_config.size.h = mode->hdisplay;
+		private_output->target_buffer_info.src_config.size.v = mode->vdisplay;
+		private_output->target_buffer_info.src_config.pos.x = 0;
+		private_output->target_buffer_info.src_config.pos.y = 0;
+		private_output->target_buffer_info.src_config.pos.w = mode->hdisplay;
+		private_output->target_buffer_info.src_config.pos.h = mode->vdisplay;
+		private_output->target_buffer_info.dst_pos.x = 0;
+		private_output->target_buffer_info.dst_pos.y = 0;
+		private_output->target_buffer_info.dst_pos.w = mode->hdisplay;
+		private_output->target_buffer_info.dst_pos.h = mode->vdisplay;
+		private_output->target_buffer_info.transform = TDM_TRANSFORM_NORMAL;
+
+		ret = tdm_layer_set_info_internal(private_layer, &private_output->target_buffer_info);
+		if (ret != TDM_ERROR_NONE) {
+			/* LCOV_EXCL_START */
+			TDM_ERR("failed: layer set info(window)");
+			_pthread_mutex_unlock(&private_display->lock);
+			/* LCOV_EXCL_STOP */
+			return ret;
+		}
+
+		private_output->need_set_target_info = 0;
+	}
+
+	output_hwc_target_buffer_commit_handler = calloc(1, sizeof(tdm_private_output_hwc_target_buffer_commit_handler));
+	if (!output_hwc_target_buffer_commit_handler) {
+		/* LCOV_EXCL_START */
+		TDM_ERR("failed: alloc memory");
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OUT_OF_MEMORY;
+		/* LCOV_EXCL_STOP */
+	}
+
+	output_hwc_target_buffer_commit_handler->private_output = private_output;
+	output_hwc_target_buffer_commit_handler->func = func;
+	output_hwc_target_buffer_commit_handler->user_data = user_data;
+
+	ret = tdm_layer_commit_internal(private_layer, _tdm_output_hwc_layer_commit_handler, output_hwc_target_buffer_commit_handler);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		TDM_ERR("failed: commit layer(target buffer)");
+		free(output_hwc_target_buffer_commit_handler);
+		_pthread_mutex_unlock(&private_display->lock);
+		/* LCOV_EXCL_STOP */
+		return ret;
+	}
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -1858,6 +2001,7 @@ tdm_error
 tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format **formats,
 								int *count)
 {
+	tdm_private_backend *private_backend;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -1866,12 +2010,13 @@ tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	func_output = &private_display->func_output;
+	private_backend = private_output->private_backend;
+	func_output = &private_backend->func_output;
 
 	if (!func_output->output_hwc_get_video_supported_formats) {
 		/* LCOV_EXCL_START */
 		_pthread_mutex_unlock(&private_display->lock);
-		TDM_ERR("not implemented!!");
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
 		/* LCOV_EXCL_STOP */
 	}
@@ -1884,53 +2029,13 @@ tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format
 	return ret;
 }
 
-INTERN void
-tdm_output_call_change_handler_internal(tdm_private_output *private_output,
-										struct list_head *change_handler_list,
-										tdm_output_change_type type,
-										tdm_value value,
-										int no_check_thread_id)
-{
-	tdm_private_display *private_display;
-	tdm_private_change_handler *change_handler = NULL;
-
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(private_output);
-
-	private_display = private_output->private_display;
-	if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
-		if (type & TDM_OUTPUT_CHANGE_CONNECTION)
-			TDM_INFO("output(%d) changed: %s (%d)",
-					 private_output->pipe, tdm_status_str(value.u32), value.u32);
-		if (type & TDM_OUTPUT_CHANGE_DPMS)
-			TDM_INFO("output(%d) changed: dpms %s (%d)",
-					 private_output->pipe, tdm_dpms_str(value.u32), value.u32);
-	}
-
-	if (LIST_IS_EMPTY(change_handler_list))
-		return;
-
-	LIST_FOR_EACH_ENTRY(change_handler, change_handler_list, link) {
-		if (!no_check_thread_id && change_handler->owner_tid != syscall(SYS_gettid))
-			TDM_NEVER_GET_HERE();
-
-		_pthread_mutex_unlock(&private_display->lock);
-		change_handler->func(private_output, type,
-							 value, change_handler->user_data);
-		_pthread_mutex_lock(&private_display->lock);
-	}
-}
-
 static int
 _is_hwc_output_still_existed(tdm_private_output *private_output)
 {
-	tdm_private_display *dpy;
+	tdm_private_backend *private_backend = private_output->private_backend;
 	tdm_private_output *o = NULL;
 
-	dpy = tdm_display_init(NULL);
-	TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_OPERATION_FAILED);
-
-	LIST_FOR_EACH_ENTRY(o, &dpy->output_list, link) {
+	LIST_FOR_EACH_ENTRY(o, &private_backend->output_list, link) {
 		if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC))
 			continue;
 
@@ -1938,31 +2043,35 @@ _is_hwc_output_still_existed(tdm_private_output *private_output)
 			goto exist;
 	}
 
-	tdm_display_deinit(dpy);
 	return 0;
 
 exist:
-	tdm_display_deinit(dpy);
 	return 1;
 }
 
 /* gets called on behalf of the ecore-main-loop thread */
-INTERN tdm_error
-tdm_output_cb_need_validate(tdm_private_output *private_output)
+INTERN void
+tdm_output_need_validate_handler_thread(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 {
-	TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
+	tdm_private_output *private_output = object;
+
+	TDM_RETURN_IF_FAIL(private_output != NULL);
+
+	_pthread_mutex_lock(&private_display->lock);
 
 	/* as we get 'private_output' within an event, an output this 'private_output'
 	 * points to can be destroyed already */
-	if (!_is_hwc_output_still_existed(private_output))
-		return TDM_ERROR_NONE;
+	if (!_is_hwc_output_still_existed(private_output)) {
+		_pthread_mutex_unlock(&private_display->lock);
+		return;
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
 
 	TDM_INFO("tdm-backend asks for revalidation for the output:%p.", private_output);
 
 	if (private_output->need_validate.hndl)
 		private_output->need_validate.hndl((tdm_output*)private_output);
-
-	return TDM_ERROR_NONE;
 }
 
 /* gets called on behalf of the tdm-thread */
@@ -1981,11 +2090,14 @@ _need_validate_handler(int fd, tdm_event_loop_mask mask, void *user_data)
 		return TDM_ERROR_OPERATION_FAILED;
 	}
 
+	memset(&ev, 0, sizeof ev);
 	ev.base.type = TDM_THREAD_CB_NEED_VALIDATE;
 	ev.base.length = sizeof ev;
-	ev.o = private_output;
+	ev.base.object_stamp = private_output->stamp;
+	ev.base.data = NULL;
+	ev.base.sync = 0;
 
-	ret = tdm_thread_send_cb(private_output->private_display->private_loop, &ev.base);
+	ret = tdm_thread_cb_call(private_output, &ev.base);
 	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
 	TDM_INFO("tdm-thread: get a 'need to revalidate' event for the ouptut:%p.", private_output);