X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_output.c;h=b66c27b1446b2563c57cfe32d1e96f32b04209f3;hb=d5c10eca115610d5b5b85152bccbc22c96e47267;hp=4fae5b0cacb9c1cd83952cdae09a5ee8e75fffe3;hpb=eac85d37abc6cb4190e3fc8be70c10e7b9252b65;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_output.c b/src/tdm_output.c
index 4fae5b0..b66c27b 100644
--- a/src/tdm_output.c
+++ b/src/tdm_output.c
@@ -9,7 +9,7 @@
  *          Taeheon Kim <th908.kim@samsung.com>,
  *          YoungJun Cho <yj44.cho@samsung.com>,
  *          SooChan Lim <sc1.lim@samsung.com>,
- *          Boram Park <sc1.lim@samsung.com>
+ *          Boram Park <boram1288.park@samsung.com>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
  * copy of this software and associated documentation files (the
@@ -37,10 +37,7 @@
 #include "config.h"
 #endif
 
-#include "tdm.h"
-#include "tdm_backend.h"
 #include "tdm_private.h"
-#include "tdm_helper.h"
 
 #define COUNT_MAX   10
 
@@ -60,6 +57,121 @@
 	private_output = (tdm_private_output*)output; \
 	private_display = private_output->private_display
 
+static void
+_tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_delay);
+
+static tdm_error
+_tdm_output_vblank_timeout_cb(void *user_data)
+{
+	tdm_private_output *private_output = user_data;
+	tdm_private_output_vblank_handler *v = NULL;
+
+	TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OPERATION_FAILED);
+
+	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)",
+				v, v->interval, v->sync, v->sent_to_frontend, v->owner_tid);
+	}
+
+	return TDM_ERROR_NONE;
+}
+
+INTERN void
+tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data)
+{
+	tdm_private_output_vblank_handler *v = NULL;
+
+	TDM_RETURN_IF_FAIL(private_output != NULL);
+	TDM_RETURN_IF_FAIL(user_data != NULL);
+
+	TDM_ERR("TDM output(%d) vblank user_data(%p) info!!", private_output->pipe, user_data);
+
+	LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
+		if (v->user_data != user_data)
+			continue;
+		TDM_ERR("vblank_handler(%p) interval(%d) sync(%d) sent_to_frontend(%u) owner_tid(%d)",
+				v, v->interval, v->sync, v->sent_to_frontend, v->owner_tid);
+	}
+}
+
+static void
+_tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_delay)
+{
+	tdm_error ret;
+
+	if (!private_output->vblank_timeout_timer) {
+		private_output->vblank_timeout_timer =
+			tdm_event_loop_add_timer_handler(private_output->private_display,
+											 _tdm_output_vblank_timeout_cb,
+											 private_output,
+											 &ret);
+		if (!private_output->vblank_timeout_timer) {
+			TDM_ERR("output(%d) couldn't add timer", private_output->pipe);
+			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);
+	if (ret != TDM_ERROR_NONE) {
+		TDM_ERR("output(%d) couldn't update timer", private_output->pipe);
+		return;
+	}
+}
+
+static tdm_private_hwc_window *
+_tdm_output_find_private_hwc_window(tdm_private_output *private_output,
+								tdm_hwc_window *hwc_window_backend)
+{
+	tdm_private_hwc_window *private_hwc_window = NULL;
+
+	LIST_FOR_EACH_ENTRY(private_hwc_window, &private_output->hwc_window_list, link) {
+		if (private_hwc_window->hwc_window_backend == hwc_window_backend)
+			return private_hwc_window;
+	}
+
+	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_STATUS, tdm_display_find_output_stamp);
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp);
+
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_module *
+tdm_output_get_backend_module(tdm_output *output, tdm_error *error)
+{
+	tdm_private_module *private_module;
+
+	OUTPUT_FUNC_ENTRY_ERROR();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	private_module = private_output->private_module;
+
+	if (error)
+		*error = TDM_ERROR_NONE;
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return private_module;
+}
+
 EXTERN tdm_error
 tdm_output_get_model_info(tdm_output *output, const char **maker,
 						  const char **model, const char **name)
@@ -112,70 +224,113 @@ tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
 	return ret;
 }
 
-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_error ret;
+	tdm_private_output *private_output = object;
+	tdm_private_output_change_handler *change_handler = user_data;
+	tdm_output_change_type type = TDM_OUTPUT_CHANGE_CONNECTION;
+	tdm_value value = {.u32 = 0 };
 
-	TDM_RETURN_IF_FAIL(private_output);
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 
-	private_display = private_output->private_display;
+	assert(change_handler->owner_tid == syscall(SYS_gettid));
+
+	if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) {
+		tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status *)cb_base;
+		type = TDM_OUTPUT_CHANGE_CONNECTION;
+		value.u32 = output_status->status;
+	} else if (cb_base->type == TDM_THREAD_CB_OUTPUT_DPMS) {
+		tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms *)cb_base;
+		type = TDM_OUTPUT_CHANGE_DPMS;
+		value.u32 = output_dpms->dpms;
+	} else {
+		TDM_NEVER_GET_HERE();
+		return;
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
+	change_handler->func(private_output, type, value, change_handler->user_data);
+	_pthread_mutex_lock(&private_display->lock);
 
-	ret = tdm_display_update_output(private_display, output_backend, private_output->pipe);
-	TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 }
 
-INTERN void
-tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status,
-					 void *user_data)
+static tdm_error
+_tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output_conn_status status)
 {
-	tdm_private_display *private_display;
-	tdm_private_output *private_output = user_data;
-	tdm_value value;
+	tdm_thread_cb_output_status output_status;
+	tdm_error ret;
 
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(private_output);
+	memset(&output_status, 0, sizeof output_status);
+	output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
+	output_status.base.length = sizeof output_status;
+	output_status.base.object_stamp = private_output->stamp;
+	output_status.base.data = NULL;
+	output_status.base.sync = 1;
+	output_status.status = status;
 
-	private_display = private_output->private_display;
+	ret = tdm_thread_cb_call(private_output, &output_status.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+	return TDM_ERROR_NONE;
+}
+
+static tdm_error
+_tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_dpms dpms)
+{
+	tdm_thread_cb_output_dpms output_dpms;
+	tdm_error ret;
 
-	if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
-		tdm_thread_cb_output_status output_status;
-		tdm_error ret;
+	memset(&output_dpms, 0, sizeof output_dpms);
+	output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS;
+	output_dpms.base.length = sizeof output_dpms;
+	output_dpms.base.object_stamp = private_output->stamp;
+	output_dpms.base.data = NULL;
+	output_dpms.base.sync = 0;
+	output_dpms.dpms = dpms;
 
-		TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
+	ret = tdm_thread_cb_call(private_output, &output_dpms.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-		_tdm_output_update(output_backend, user_data);
+	return TDM_ERROR_NONE;
+}
 
-		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;
+INTERN void
+tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data)
+{
+	tdm_private_output *private_output = user_data;
+	tdm_error ret;
 
-		value.u32 = status;
-		tdm_output_call_change_handler_internal(private_output,
-												&private_output->change_handler_list_sub,
-												TDM_OUTPUT_CHANGE_CONNECTION,
-												value, 0);
+	TDM_RETURN_IF_FAIL(private_output);
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_status.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
 
-		return;
+	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_module, output_backend, private_output->pipe, 1);
+		TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+	} else {
+		private_output->caps.status = status;
 	}
 
-	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
+	ret = _tdm_output_call_thread_cb_status(private_output, status);
+	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_error ret;
+
+	TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(dpms));
 
-	if (!tdm_thread_is_running())
-		_tdm_output_update(output_backend, user_data);
+	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 = 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_dpms(private_output, dpms);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 }
 
 EXTERN tdm_error
@@ -183,18 +338,49 @@ 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);
+	_pthread_mutex_lock(&private_display->lock);
+
+	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_change_handler));
+	change_handler = calloc(1, sizeof(tdm_private_output_change_handler));
 	if (!change_handler) {
+		/* LCOV_EXCL_START */
 		TDM_ERR("failed: alloc memory");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_OUT_OF_MEMORY;
+		/* LCOV_EXCL_STOP */
+	}
+
+	ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DPMS, 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 */
+	}
+
+	ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		TDM_ERR("tdm_thread_cb_add failed");
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler);
+		free(change_handler);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OPERATION_FAILED;
+		/* LCOV_EXCL_STOP */
 	}
 
 	change_handler->private_output = private_output;
@@ -202,10 +388,7 @@ tdm_output_add_change_handler(tdm_output *output,
 	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);
 
@@ -219,7 +402,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(output != NULL);
 	TDM_RETURN_IF_FAIL(func != NULL);
@@ -229,24 +412,15 @@ 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);
-
-		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;
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler);
+		tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler);
 
-		LIST_DEL(&h->link);
-		free(h);
+		LIST_DEL(&change_handler->link);
+		free(change_handler);
 
 		_pthread_mutex_unlock(&private_display->lock);
 
@@ -283,6 +457,13 @@ tdm_output_get_layer_count(tdm_output *output, int *count)
 
 	_pthread_mutex_lock(&private_display->lock);
 
+	if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) {
+		TDM_ERR("output(%p) support HWC. Use HWC functions", private_output);
+		*count = 0;
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
 	*count = 0;
 	LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
 	(*count)++;
@@ -309,6 +490,14 @@ tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
 	if (error)
 		*error = TDM_ERROR_NONE;
 
+	if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) {
+		_pthread_mutex_unlock(&private_display->lock);
+		TDM_ERR("output(%p) support HWC. Use HWC functions", private_output);
+		if (error)
+			*error = TDM_ERROR_BAD_REQUEST;
+		return NULL;
+	}
+
 	LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 		if (private_layer->index == index) {
 			_pthread_mutex_unlock(&private_display->lock);
@@ -391,22 +580,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_module_check_abi(private_output->private_module, 1, 5)) {
 		_pthread_mutex_unlock(&private_display->lock);
-
-		return TDM_ERROR_BAD_MODULE;
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
 	if (min_w)
@@ -498,17 +674,21 @@ 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_module *private_module;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	func_output = &private_display->func_output;
+	private_module = private_output->private_module;
+	func_output = &private_module->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 */
 	}
 
 	ret = func_output->output_set_property(private_output->output_backend, id,
@@ -522,6 +702,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_module *private_module;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -529,12 +710,15 @@ 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_module = private_output->private_module;
+	func_output = &private_module->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 */
 	}
 
 	ret = func_output->output_get_property(private_output->output_backend, id,
@@ -545,44 +729,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;
 
-		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;
+	assert(vblank_handler->owner_tid == tid);
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_vblank.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+	vblank_handler->sent_to_frontend = 0;
 
-		return;
-	}
+	_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;
@@ -605,9 +771,15 @@ tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
 		if (tdm_debug_module & TDM_DEBUG_COMMIT)
 			TDM_INFO("handler(%p)", v);
 
-		if (v->func)
-			v->func(v->private_output, sequence, tv_sec, tv_usec, v->user_data);
 		LIST_DEL(&v->link);
+
+		if (v->func)
+			v->func(v->private_output,
+					output_vblank->sequence,
+					output_vblank->tv_sec,
+					output_vblank->tv_usec,
+					v->user_data);
+
 		free(v);
 	}
 	_pthread_mutex_lock(&private_display->lock);
@@ -616,13 +788,39 @@ 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;
+
+	if (tdm_debug_module & TDM_DEBUG_COMMIT)
+		TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler);
+
+	ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base, 1);
+	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());
@@ -630,33 +828,18 @@ 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;
+	assert(output_commit_handler->owner_tid == syscall(SYS_gettid));
 
-		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;
+	tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_commit.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
-		return;
-	}
+	LIST_DEL(&output_commit_handler->link);
 
 	if (tdm_debug_module & TDM_DEBUG_COMMIT) {
 		TDM_INFO("----------------------------------------- output(%d) committed", private_output->pipe);
 		TDM_INFO("handler(%p)", output_commit_handler);
 	}
 
-	if (private_display->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
+	if (private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
 		/* In case of layer commit, the below will be handled in the layer commit callback */
 		LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
 			if (private_layer->committed_buffer)
@@ -666,55 +849,90 @@ 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);
 	}
 
-	LIST_DEL(&output_commit_handler->link);
 	free(output_commit_handler);
 
 	if (tdm_debug_module & TDM_DEBUG_COMMIT)
 		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, 1);
+	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_module *private_module;
 	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_module = private_output->private_module;
+	func_output = &private_module->func_output;
 
 	/* interval SHOULD be at least 1 */
 	if (interval <= 0)
 		interval = 1;
 
 	if (!func_output->output_wait_vblank) {
-		TDM_ERR("not implemented!!");
+		/* LCOV_EXCL_START */
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
 	}
 
 	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");
 		return TDM_ERROR_OUT_OF_MEMORY;
+		/* LCOV_EXCL_STOP */
 	}
 
 	if (tdm_debug_module & TDM_DEBUG_COMMIT)
@@ -741,10 +959,18 @@ _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);
 
+		_tdm_output_vblank_timeout_update(private_output, 1000);
+
 		if (tdm_debug_module & TDM_DEBUG_COMMIT)
 			TDM_INFO("output(%d) backend wait_vblank", private_output->pipe);
 	}
@@ -752,11 +978,14 @@ _tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
 	return ret;
 
 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);
 	}
 	return ret;
+	/* LCOV_EXCL_STOP */
 }
 
 EXTERN tdm_error
@@ -764,23 +993,25 @@ 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);
 
-	if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
+	if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 		TDM_WRN("output(%d) dpms: %s", private_output->pipe,
 				tdm_dpms_str(private_output->current_dpms_value));
 		_pthread_mutex_unlock(&private_display->lock);
 		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);
 
 	return ret;
 }
 
+/* LCOV_EXCL_START */
 EXTERN tdm_error
 tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync,
 								 tdm_output_vblank_handler func, void *user_data)
@@ -789,27 +1020,29 @@ tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync,
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
+	if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 		TDM_WRN("output(%d) dpms: %s", private_output->pipe,
 				tdm_dpms_str(private_output->current_dpms_value));
 		_pthread_mutex_unlock(&private_display->lock);
 		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);
 
 	return ret;
 }
+/* LCOV_EXCL_STOP */
 
 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());
 
 	LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
 		if (v->func == func && v->user_data == user_data) {
@@ -828,6 +1061,7 @@ tdm_output_remove_commit_handler_internal(tdm_output *output, tdm_output_commit_
 	tdm_private_output_commit_handler *c = NULL;
 
 	TDM_RETURN_IF_FAIL(private_output != NULL);
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 
 	LIST_FOR_EACH_ENTRY(c, &private_output->output_commit_handler_list, link) {
 		if (c->func == func && c->user_data == user_data) {
@@ -870,54 +1104,72 @@ 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_module *private_module;
 	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(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-	func_output = &private_display->func_output;
+	private_output = (tdm_private_output*)output;
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
 
 	if (!func_output->output_commit) {
-		TDM_ERR("not implemented!!");
+		/* LCOV_EXCL_START */
+		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
 	}
 
-	/* TODO: this is ugly. But before using tdm_output_get_dpms_internal, we have
-	 * to check if all backends's DPMS operation has no problem.
-	 */
-	if (private_display->commit_per_vblank)
-		tdm_output_get_dpms_internal(output, &dpms_value);
-	else
-		dpms_value = private_output->current_dpms_value;
-
-	if (dpms_value == TDM_OUTPUT_DPMS_ON) {
-		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);
-				TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
-			}
+	ret = tdm_output_get_dpms_internal(output, &dpms_value);
+	TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
 
-			output_commit_handler = calloc(1, sizeof(tdm_private_output_commit_handler));
-			if (!output_commit_handler) {
-				TDM_ERR("failed: alloc memory");
-				return TDM_ERROR_OUT_OF_MEMORY;
-			}
+	if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
+		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);
+			TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
+		}
+
+		output_commit_handler = calloc(1, sizeof(tdm_private_output_commit_handler));
+		if (!output_commit_handler) {
+			/* LCOV_EXCL_START */
+			TDM_ERR("failed: alloc memory");
+			return TDM_ERROR_OUT_OF_MEMORY;
+			/* LCOV_EXCL_STOP */
+		}
 
-			LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list);
-			output_commit_handler->private_output = private_output;
-			output_commit_handler->func = func;
-			output_commit_handler->user_data = user_data;
-			output_commit_handler->owner_tid = syscall(SYS_gettid);
+		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;
+		output_commit_handler->user_data = user_data;
+		output_commit_handler->owner_tid = syscall(SYS_gettid);
+
 		ret = func_output->output_commit(private_output->output_backend, sync,
 				output_commit_handler);
 		TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
 
+		if (ret == TDM_ERROR_NONE) {
+			if (private_output->current_mode &&
+				private_output->caps.status != TDM_OUTPUT_CONN_STATUS_MODE_SETTED) {
+				TDM_WRN("backend doesn't change the output connection status");
+				tdm_output_cb_status(private_output->output_backend,
+									 TDM_OUTPUT_CONN_STATUS_MODE_SETTED,
+									 private_output);
+			}
+		}
+
 		if (tdm_debug_module & TDM_DEBUG_COMMIT)
 			TDM_INFO("output(%d) backend commit: handle(%p) func(%p) user_data(%p)",
 					private_output->pipe, output_commit_handler, func, user_data);
@@ -930,6 +1182,15 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 		if (!private_layer->waiting_buffer)
 			continue;
 
+		if (private_layer->committed_buffer) {
+			tdm_layer_free_buffer(private_layer, private_layer->committed_buffer);
+			private_layer->committed_buffer = NULL;
+			if (tdm_debug_module & TDM_DEBUG_BUFFER)
+				TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)",
+						 private_layer, private_layer->waiting_buffer->buffer,
+						 private_layer->committed_buffer);
+		}
+
 		private_layer->committed_buffer = private_layer->waiting_buffer;
 		private_layer->waiting_buffer = NULL;
 		if (tdm_debug_module & TDM_DEBUG_BUFFER)
@@ -938,8 +1199,8 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 					 private_layer->committed_buffer->buffer);
 	}
 
-	if (dpms_value != TDM_OUTPUT_DPMS_ON) {
-		TDM_WRN("TDM_OUTPUT_DPMS_OFF. Directly call commit handler instead of commit.");
+	if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
+		TDM_WRN("dpms %s. Directly call commit handler instead of commit.", tdm_dpms_str(dpms_value));
 		if (func)
 			func(output, 0, 0, 0, user_data);
 	}
@@ -947,36 +1208,41 @@ tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handl
 	return ret;
 
 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);
 	}
 	return ret;
+	/* LCOV_EXCL_STOP */
 }
 
 EXTERN tdm_error
 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 				  void *user_data)
 {
+	tdm_private_layer *private_layer = NULL;
+
 	OUTPUT_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (private_display->commit_type == TDM_COMMIT_TYPE_NONE)
-		private_display->commit_type = TDM_COMMIT_TYPE_OUTPUT;
-	else if (private_display->commit_type == TDM_COMMIT_TYPE_LAYER) {
+	if (private_output->commit_type == TDM_COMMIT_TYPE_NONE)
+		private_output->commit_type = TDM_COMMIT_TYPE_OUTPUT;
+	else if (private_output->commit_type == TDM_COMMIT_TYPE_LAYER) {
 		TDM_ERR("Can't supported. Use tdm_layer_commit");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	if (private_display->commit_per_vblank) {
+	if (private_output->commit_per_vblank) {
 		TDM_ERR("Use tdm_layer_commit");
 		_pthread_mutex_unlock(&private_display->lock);
 		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	if (private_output->current_dpms_value > TDM_OUTPUT_DPMS_ON) {
+	if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
 		TDM_ERR("output(%d) dpms: %s", private_output->pipe,
 				tdm_dpms_str(private_output->current_dpms_value));
 		_pthread_mutex_unlock(&private_display->lock);
@@ -986,6 +1252,11 @@ tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
 	if (tdm_debug_module & TDM_DEBUG_COMMIT)
 		TDM_INFO("output(%d) commit", private_output->pipe);
 
+	/* apply the pending data of all layers */
+	LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
+		tdm_layer_commit_pending_data(private_layer);
+	}
+
 	ret = tdm_output_commit_internal(output, sync, func, user_data);
 
 	_pthread_mutex_unlock(&private_display->lock);
@@ -996,6 +1267,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_module *private_module;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
@@ -1003,17 +1275,24 @@ 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_module = private_output->private_module;
+	func_output = &private_module->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 */
 	}
 
 	ret = func_output->output_set_mode(private_output->output_backend, mode);
-	if (ret == TDM_ERROR_NONE)
+	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);
+	}
+
 	_pthread_mutex_unlock(&private_display->lock);
 
 	return ret;
@@ -1035,175 +1314,199 @@ 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)
+EXTERN tdm_error
+tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
 {
-	tdm_private_output *private_output = user_data;
-	tdm_value value;
+	tdm_private_module *private_module;
+	tdm_func_output *func_output;
+	OUTPUT_FUNC_ENTRY();
 
-	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);
+	if (dpms_value > TDM_OUTPUT_DPMS_OFF) {
+		if (dpms_value & TDM_OUTPUT_DPMS_DEFAULT_MASK) {
+			TDM_ERR("Don't use the low-4bit for an extended DPMS mode: dpms_value(%x)", dpms_value);
+			return TDM_ERROR_BAD_REQUEST;
+		}
 
-	return TDM_ERROR_NONE;
-}
+		if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_EXTENDED_DPMS)) {
+			TDM_ERR("output(%d) doesn't support the extended DPMS control: '%s'",
+					private_output->pipe, tdm_dpms_str(dpms_value));
+			return TDM_ERROR_BAD_REQUEST;
+		}
+	}
 
-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;
+	_pthread_mutex_lock(&private_display->lock);
 
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(private_output);
+	if (private_output->waiting_dpms_change) {
+		TDM_ERR("DPMS is not changed yet. Can't be changed twice");
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
 
-	private_display = private_output->private_display;
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
 
-	if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
-		tdm_thread_cb_output_dpms output_dpms;
-		tdm_error ret;
+	TDM_INFO("output(%d) dpms '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
 
-		_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;
+	if (func_output->output_set_dpms)
+		ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
+	else {
+		/* LCOV_EXCL_START */
+		ret = TDM_ERROR_NONE;
+		TDM_WRN("not implemented!!");
+		goto done;
+		/* LCOV_EXCL_STOP */
+	}
 
-		value.u32 = dpms;
-		tdm_output_call_change_handler_internal(private_output,
-												&private_output->change_handler_list_sub,
-												TDM_OUTPUT_CHANGE_DPMS,
-												value, 0);
+done:
+	if (ret == TDM_ERROR_NONE) {
+		if (private_output->current_dpms_value != dpms_value) {
+			private_output->current_dpms_value = dpms_value;
+			_tdm_output_call_thread_cb_dpms(private_output, dpms_value);
+		}
+		TDM_INFO("output(%d) dpms '%s' done", private_output->pipe, tdm_dpms_str(dpms_value));
+	} else {
+		tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
 
-		ret = tdm_thread_send_cb(private_display->private_loop, &output_dpms.base);
-		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+		/* update current_dpms_value forcely */
+		tdm_output_get_dpms_internal(output, &temp);
 
-		return;
+		TDM_ERR("output(%d) set_dpms failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
 	}
 
-	private_output->current_dpms_value = dpms;
-
-	TDM_INFO("output(%d) dpms %s", private_output->pipe, tdm_dpms_str(dpms));
+	_pthread_mutex_unlock(&private_display->lock);
 
-	value.u32 = dpms;
-	tdm_output_call_change_handler_internal(private_output,
-											&private_output->change_handler_list_main,
-											TDM_OUTPUT_CHANGE_DPMS,
-											value, 0);
+	return ret;
 }
 
+/* LCOV_EXCL_START */
 EXTERN tdm_error
-tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
+tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
 {
+	tdm_private_module *private_module;
 	tdm_func_output *func_output;
 	OUTPUT_FUNC_ENTRY();
 
-	if (dpms_value > TDM_OUTPUT_DPMS_OFF)
-		dpms_value = TDM_OUTPUT_DPMS_OFF;
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_ASYNC_DPMS)) {
+		TDM_ERR("output doesn't support the asynchronous DPMS control!");
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
+	if (dpms_value > TDM_OUTPUT_DPMS_OFF) {
+		if (dpms_value & TDM_OUTPUT_DPMS_DEFAULT_MASK) {
+			TDM_ERR("Don't use the low-4bit for an extended DPMS mode: dpms_value(%x)", dpms_value);
+			return TDM_ERROR_BAD_REQUEST;
+		}
+
+		if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_EXTENDED_DPMS)) {
+			TDM_ERR("output(%d) doesn't support the extended DPMS control: '%s'",
+					private_output->pipe, tdm_dpms_str(dpms_value));
+			return TDM_ERROR_BAD_REQUEST;
+		}
+	}
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (private_output->current_dpms_value == dpms_value) {
+	if (private_output->waiting_dpms_change) {
+		TDM_ERR("DPMS is not changed yet. Can't be changed twice");
 		_pthread_mutex_unlock(&private_display->lock);
-		return TDM_ERROR_NONE;
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
-	/** 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) {
-			TDM_ERR("can't create dpms timer!!");
-			_pthread_mutex_unlock(&private_display->lock);
-			return TDM_ERROR_OUT_OF_MEMORY;
-		}
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
+	if (!func_output->output_set_dpms_handler) {
+		TDM_WRN("not implemented: output_set_dpms_handler");
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
 
-	func_output = &private_display->func_output;
-
-	if (!func_output->output_set_dpms) {
+	if (!func_output->output_set_dpms_async) {
+		TDM_WRN("not implemented: output_set_dpms_async");
 		_pthread_mutex_unlock(&private_display->lock);
-		private_output->current_dpms_value = dpms_value;
-		TDM_INFO("output(%d) dpms %s", private_output->pipe, tdm_dpms_str(dpms_value));
-		TDM_WRN("not implemented!!");
-		return TDM_ERROR_NONE;
+		return TDM_ERROR_NOT_IMPLEMENTED;
 	}
 
-	if (func_output->output_set_dpms_handler) {
-		if (!private_output->regist_dpms_cb) {
-			private_output->regist_dpms_cb = 1;
-			ret = func_output->output_set_dpms_handler(private_output->output_backend,
-					tdm_output_cb_dpms, private_output);
-			if (ret != TDM_ERROR_NONE) {
-				_pthread_mutex_unlock(&private_display->lock);
-				TDM_ERR("Can't set the dpms handler!!");
-				return ret;
-			}
+	if (!private_output->regist_dpms_cb) {
+		private_output->regist_dpms_cb = 1;
+		ret = func_output->output_set_dpms_handler(private_output->output_backend,
+				tdm_output_cb_dpms, private_output);
+		if (ret != TDM_ERROR_NONE) {
+			_pthread_mutex_unlock(&private_display->lock);
+			TDM_ERR("Can't set the dpms handler!!");
+			return ret;
 		}
 	}
 
-	ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
+	TDM_INFO("output(%d) dpms async '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
 
-	if (ret == TDM_ERROR_NONE && !func_output->output_set_dpms_handler) {
-		tdm_value value;
+	ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value);
 
-		private_output->current_dpms_value = dpms_value;
-		TDM_INFO("output(%d) dpms %s", private_output->pipe, tdm_dpms_str(dpms_value));
+	if (ret == TDM_ERROR_NONE) {
+		private_output->waiting_dpms_change = 1;
+		TDM_INFO("output(%d) dpms async '%s' waiting", private_output->pipe, tdm_dpms_str(dpms_value));
+	} else {
+		tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
 
-		value.u32 = dpms_value;
-		tdm_output_call_change_handler_internal(private_output,
-												&private_output->change_handler_list_main,
-												TDM_OUTPUT_CHANGE_DPMS,
-												value, 0);
+		/* update current_dpms_value forcely */
+		tdm_output_get_dpms_internal(output, &temp);
 
-		if (!LIST_IS_EMPTY(&private_output->change_handler_list_sub)) {
-			ret = tdm_event_loop_source_timer_update(private_output->dpms_changed_timer, 1);
-			if (ret != TDM_ERROR_NONE)
-				TDM_NEVER_GET_HERE();
-		}
+		TDM_ERR("output(%d) set_dpms_async failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
 	}
 
 	_pthread_mutex_unlock(&private_display->lock);
 
 	return ret;
 }
+/* LCOV_EXCL_STOP */
 
 INTERN tdm_error
 tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
 {
+	tdm_private_output *private_output;
+	tdm_private_module *private_module;
 	tdm_func_output *func_output;
-	OUTPUT_FUNC_ENTRY();
+	tdm_error ret = TDM_ERROR_NONE;
+
+	TDM_RETURN_VAL_IF_FAIL(output != NULL, 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
+	 * better use new env instead of using commit_per_vblank variable to distinguish
+	 * whether we use the stored value or backend's output_get_dpms.
+	 */
+	if (!private_output->commit_per_vblank) {
+		*dpms_value = private_output->current_dpms_value;
+		return TDM_ERROR_NONE;
+	}
 
-	func_output = &private_display->func_output;
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
 
 	if (!func_output->output_get_dpms) {
+		/* LCOV_EXCL_START */
 		*dpms_value = private_output->current_dpms_value;
 		TDM_WRN("not implemented!!");
 		return TDM_ERROR_NONE;
+		/* LCOV_EXCL_STOP */
 	}
 
 	ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
 	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
 		TDM_ERR("output_get_dpms failed");
 		*dpms_value = TDM_OUTPUT_DPMS_OFF;
+		/* LCOV_EXCL_STOP */
 	}
 
+	/* checking with backend's value */
 	if (*dpms_value != private_output->current_dpms_value) {
+		TDM_ERR("output(%d) dpms changed suddenly: %s -> %s",
+				private_output->pipe, tdm_dpms_str(private_output->current_dpms_value),
+				tdm_dpms_str(*dpms_value));
 		private_output->current_dpms_value = *dpms_value;
-		TDM_ERR("output(%d) dpms changed suddenly: %s", private_output->pipe, tdm_dpms_str(*dpms_value));
+		_tdm_output_call_thread_cb_dpms(private_output, *dpms_value);
 	}
 
 	return ret;
@@ -1225,6 +1528,31 @@ tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
 	return ret;
 }
 
+EXTERN tdm_error
+tdm_output_has_capture_capability(tdm_output *output, unsigned int *has_capability)
+{
+	tdm_private_module *private_module;
+
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(has_capability != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	private_module = private_output->private_module;
+
+	if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
+		*has_capability = 0;
+	else if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT))
+		*has_capability = 0;
+	else
+		*has_capability = 1;
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
 EXTERN tdm_capture *
 tdm_output_create_capture(tdm_output *output, tdm_error *error)
 {
@@ -1241,39 +1569,672 @@ tdm_output_create_capture(tdm_output *output, tdm_error *error)
 	return capture;
 }
 
-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)
+EXTERN tdm_hwc_window *
+tdm_output_hwc_create_window(tdm_output *output, tdm_error *error)
 {
-	tdm_private_display *private_display;
-	tdm_private_change_handler *change_handler = NULL;
+	tdm_hwc_window *hwc_window = NULL;
 
-	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
-	TDM_RETURN_IF_FAIL(private_output);
+	OUTPUT_FUNC_ENTRY_ERROR();
 
-	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);
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)
+		hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_output, 0, error);
+	else {
+		/* LCOV_EXCL_START */
+		TDM_ERR("output(%p) not support HWC", private_output);
+		if (error)
+			*error = TDM_ERROR_BAD_REQUEST;
+		/* LCOV_EXCL_STOP */
 	}
 
-	if (LIST_IS_EMPTY(change_handler_list))
-		return;
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return hwc_window;
+}
+
+EXTERN tdm_hwc_window *
+tdm_output_hwc_create_video_window(tdm_output *output, tdm_error *error)
+{
+	tdm_hwc_window *hwc_window = NULL;
+
+	OUTPUT_FUNC_ENTRY_ERROR();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)
+		hwc_window = (tdm_hwc_window *)tdm_hwc_window_create_internal(private_output, 1, error);
+	else {
+		/* LCOV_EXCL_START */
+		TDM_ERR("output(%p) not support HWC", private_output);
+		if (error)
+			*error = TDM_ERROR_BAD_REQUEST;
+		/* LCOV_EXCL_STOP */
+	}
 
-	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);
+
+	return hwc_window;
+}
+
+EXTERN tdm_error
+tdm_output_hwc_destroy_window(tdm_output *output, tdm_hwc_window *hwc_window)
+{
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(hwc_window != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	ret = tdm_hwc_window_destroy_internal(hwc_window);
+
+	_pthread_mutex_unlock(&private_display->lock);
 
+	return ret;
+}
+
+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_module *private_module;
+	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();
+
+	TDM_RETURN_VAL_IF_FAIL(num_types != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_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);
-		change_handler->func(private_output, type,
-							 value, change_handler->user_data);
-		_pthread_mutex_lock(&private_display->lock);
+		return TDM_ERROR_BAD_REQUEST;
+	}
+
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
+
+	if (!func_output->output_hwc_validate) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		TDM_WRN("not implemented!!");
+		return TDM_ERROR_NOT_IMPLEMENTED;
+		/* LCOV_EXCL_STOP */
+	}
+
+	if (num_wnds == 0) {
+		ret = func_output->output_hwc_validate(private_output->output_backend, NULL, 0, num_types);
+
+		_pthread_mutex_unlock(&private_display->lock);
+
+		return ret;
+	}
+
+	composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *));
+	if (!composited_wnds_backend) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OUT_OF_MEMORY;
+		/* LCOV_EXCL_STOP */
+	}
+
+	composited_wnds_frontend = (tdm_private_hwc_window **)composited_wnds;
+
+	for (i = 0; i < num_wnds; i++)
+		composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend;
+
+	ret = func_output->output_hwc_validate(private_output->output_backend, composited_wnds_backend, num_wnds, num_types);
+
+	free(composited_wnds_backend);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+EXTERN tdm_error
+tdm_output_hwc_set_need_validate_handler(tdm_output *output,
+		tdm_output_need_validate_handler hndl)
+{
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(hndl != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_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;
+	}
+
+	/* there's no reason to allow this */
+	if (private_output->need_validate.hndl) {
+
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OPERATION_FAILED;
+	}
+
+	private_output->need_validate.hndl = hndl;
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+EXTERN tdm_error
+tdm_output_hwc_get_changed_composition_types(tdm_output *output,
+										 uint32_t *num_elements,
+										 tdm_hwc_window **hwc_window,
+										 tdm_hwc_window_composition *composition_types)
+{
+	tdm_private_module *private_module;
+	tdm_func_output *func_output = NULL;
+	tdm_private_hwc_window * private_hwc_window = NULL;
+	int i = 0;
+
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(num_elements != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_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_module = private_output->private_module;
+	func_output = &private_module->func_output;
+
+	if (!func_output->output_hwc_get_changed_composition_types) {
+		/* 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_get_changed_composition_types(private_output->output_backend,
+							num_elements, hwc_window, composition_types);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		return ret;
+		/* LCOV_EXCL_STOP */
+	}
+
+	if (hwc_window == NULL || composition_types == NULL) {
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_NONE;
+	}
+
+	for (i = 0; i < *num_elements; i++) {
+
+		private_hwc_window = _tdm_output_find_private_hwc_window(private_output, hwc_window[i]);
+
+		if (private_hwc_window == NULL) {
+			/* LCOV_EXCL_START */
+			TDM_ERR("failed! This should never happen!");
+			func_output->output_hwc_destroy_window(private_output->output_backend, hwc_window[i]);
+			*num_elements = 0;
+			_pthread_mutex_unlock(&private_display->lock);
+			return TDM_ERROR_OPERATION_FAILED;
+			/* LCOV_EXCL_STOP */
+		}
+
+		hwc_window[i] = (tdm_hwc_window*)private_hwc_window;
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+tdm_error
+tdm_output_hwc_accept_changes(tdm_output *output)
+{
+	tdm_private_module *private_module;
+	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_module = private_output->private_module;
+	func_output = &private_module->func_output;
+
+	if (!func_output->output_hwc_validate) {
+		/* 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_accept_changes(private_output->output_backend);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+tbm_surface_queue_h
+tdm_output_hwc_get_target_buffer_queue(tdm_output *output, tdm_error *error)
+{
+	tdm_private_module *private_module;
+	tdm_func_output *func_output = NULL;
+	tbm_surface_queue_h queue = NULL;
+
+	OUTPUT_FUNC_ENTRY_ERROR();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) {
+		TDM_ERR("output(%p) not support HWC", private_output);
+		if (error)
+			*error = TDM_ERROR_BAD_REQUEST;
+		_pthread_mutex_unlock(&private_display->lock);
+		return NULL;
+	}
+
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
+
+	if (!func_output->output_hwc_get_target_buffer_queue) {
+		/* LCOV_EXCL_START */
+		_pthread_mutex_unlock(&private_display->lock);
+		TDM_WRN("not implemented!!");
+		return NULL;
+		/* LCOV_EXCL_STOP */
+	}
+
+	queue = func_output->output_hwc_get_target_buffer_queue(private_output->output_backend, error);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return queue;
+}
+
+EXTERN tdm_error
+tdm_output_hwc_set_client_target_buffer(tdm_output *output, tbm_surface_h target_buffer, tdm_hwc_region damage)
+{
+	tdm_private_module *private_module;
+	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;
+	}
+
+	if (tdm_debug_dump & TDM_DUMP_FLAG_WINDOW) {
+		/* LCOV_EXCL_START */
+		char str[TDM_PATH_LEN];
+		static int i;
+		snprintf(str, TDM_PATH_LEN, "target_window_%d_%03d",
+				 private_output->index, i++);
+		tdm_helper_dump_buffer_str(target_buffer, tdm_debug_dump_dir, str);
+		/* LCOV_EXCL_STOP */
+	}
+
+	private_module = private_output->private_module;
+	func_output = &private_module->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_module *private_module;
+	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_module = private_output->private_module;
+	func_output = &private_module->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 */
+	}
+
+	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_module *private_module;
+	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;
+	}
+
+	private_module = private_output->private_module;
+	func_output = &private_module->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 */
+	}
+
+	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);
+		TDM_ERR("no assigned layer!!");
+		return TDM_ERROR_INVALID_PARAMETER;
+		/* LCOV_EXCL_STOP */
+	}
+
+	private_layer = (tdm_private_layer*)layer;
+
+	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 */
+	}
+
+	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;
+	}
+
+	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);
+
+	return ret;
+}
+
+tdm_error
+tdm_output_hwc_get_video_supported_formats(tdm_output *output, const tbm_format **formats,
+								int *count)
+{
+	tdm_private_module *private_module;
+	tdm_func_output *func_output;
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	private_module = private_output->private_module;
+	func_output = &private_module->func_output;
+
+	if (!func_output->output_hwc_get_video_supported_formats) {
+		/* 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_get_video_supported_formats(
+								private_output->output_backend, formats, count);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+static int
+_is_hwc_output_still_existed(tdm_private_output *private_output)
+{
+	tdm_private_module *private_module = private_output->private_module;
+	tdm_private_output *o = NULL;
+
+	LIST_FOR_EACH_ENTRY(o, &private_module->output_list, link) {
+		if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC))
+			continue;
+
+		if (o == private_output)
+			goto exist;
+	}
+
+	return 0;
+
+exist:
+	return 1;
+}
+
+/* gets called on behalf of the ecore-main-loop thread */
+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_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)) {
+		_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);
+}
+
+/* gets called on behalf of the tdm-thread */
+static tdm_error
+_need_validate_handler(int fd, tdm_event_loop_mask mask, void *user_data)
+{
+	tdm_thread_cb_need_validate ev;
+	tdm_private_output *private_output;
+	tdm_error ret;
+	uint64_t value;
+
+	private_output = (tdm_private_output *)user_data;
+
+	if (read(private_output->need_validate.event_fd, &value, sizeof(value)) < 0) {
+		TDM_ERR("error while trying to read from a need_validate.event_fd fd.");
+		return TDM_ERROR_OPERATION_FAILED;
+	}
+
+	memset(&ev, 0, sizeof ev);
+	ev.base.type = TDM_THREAD_CB_NEED_VALIDATE;
+	ev.base.length = sizeof ev;
+	ev.base.object_stamp = private_output->stamp;
+	ev.base.data = NULL;
+	ev.base.sync = 0;
+
+	ret = tdm_thread_cb_call(private_output, &ev.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+	TDM_INFO("tdm-thread: get a 'need to revalidate' event for the ouptut:%p.", private_output);
+
+	/* who cares about this? */
+	return TDM_ERROR_NONE;
+}
+
+INTERN tdm_error
+tdm_output_need_validate_event_init(tdm_output *output)
+{
+	int fd;
+
+	OUTPUT_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
+
+	if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) {
+		TDM_ERR("output(%p) not support HWC", private_output);
+		return TDM_ERROR_BAD_REQUEST;
 	}
+
+	/* build in eventfd fds into event_loop listened & handled by the tdm-thread */
+	fd = eventfd(0, 0);
+	TDM_WARNING_IF_FAIL(fd >= 0);
+
+	private_output->need_validate.event_source = tdm_event_loop_add_fd_handler(private_display,
+			fd,	TDM_EVENT_LOOP_READABLE, _need_validate_handler, private_output, &ret);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+	private_output->need_validate.event_fd = fd;
+
+	TDM_INFO("register an output:%p for the revalidation, event_fd:%d.", private_output, fd);
+
+	return ret;
+}
+
+INTERN tdm_error
+tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int mode)
+{
+	if (!private_output)
+		return TDM_ERROR_INVALID_PARAMETER;
+
+	if (mode < 0 || mode > 2)
+		return TDM_ERROR_INVALID_PARAMETER;
+
+	private_output->commit_per_vblank = mode;
+
+	if (private_output->commit_per_vblank == 0)
+		TDM_INFO("commit per vblank: disable");
+	else if (private_output->commit_per_vblank == 1)
+		TDM_INFO("commit per vblank: enable (1 layer)");
+	else if (private_output->commit_per_vblank == 2)
+		TDM_INFO("commit per vblank: enable (previous commit)");
+
+	return TDM_ERROR_NONE;
 }