X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm.c;h=6375b5399fc57fbcce4bf99d9526cf4dac07bbd4;hb=refs%2Fheads%2Fsandbox%2Fcyeon%2Fdevel;hp=3f6388c90e87b768d7c13a060d1199063ce010cb;hpb=969d9f15369b577ba5b8cd29c1e818e6e7e0c2ca;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm.c b/src/tdm.c
index 3f6388c..6375b53 100644
--- a/src/tdm.c
+++ b/src/tdm.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,14 +37,22 @@
 #include "config.h"
 #endif
 
-#include "tdm.h"
-#include "tdm_backend.h"
 #include "tdm_private.h"
-#include "tdm_helper.h"
 
 pthread_mutex_t tdm_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER;
 int tdm_mutex_locked;
+const char *tdm_mutex_lock_func;
+int tdm_mutex_lock_line;
+const char *tdm_mutex_unlock_func;
+int tdm_mutex_unlock_line;
 
+pthread_mutex_t tdm_debug_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER;
+const char *tdm_debug_mutex_lock_func;
+int tdm_debug_mutex_lock_line;
+
+static tdm_error _tdm_display_load_module_with_file(tdm_private_display *private_display, const char *file);
+
+/* LCOV_EXCL_START */
 static tdm_private_layer *
 _tdm_display_find_private_layer(tdm_private_output *private_output,
 								tdm_layer *layer_backend)
@@ -59,29 +67,119 @@ _tdm_display_find_private_layer(tdm_private_output *private_output,
 	return NULL;
 }
 
-static tdm_private_output *
-_tdm_display_find_private_output(tdm_private_display *private_display,
-								 tdm_output *output_backend)
+INTERN tdm_private_output *
+tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend)
 {
+	tdm_private_module *private_module = NULL;
 	tdm_private_output *private_output = NULL;
 
-	LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
-		if (private_output->output_backend == output_backend)
-			return private_output;
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			if (private_output->output_backend == output_backend)
+				return private_output;
+		}
 	}
 
 	return NULL;
 }
 
-INTERN tdm_private_output *
-tdm_display_find_output_stamp(tdm_private_display *private_display,
-							  unsigned long stamp)
+INTERN unsigned int
+tdm_display_find_empty_output_pipe(tdm_private_display *private_display)
+{
+	tdm_private_module *private_module = NULL;
+	tdm_private_output *private_output = NULL;
+	unsigned int pipe = 0;
+	while (1) {
+		int found = 0;
+		LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+			LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+				if (private_output->pipe == pipe) {
+					found = 1;
+					break;
+				}
+			}
+			if (found)
+				break;
+		}
+
+		if (!found)
+			break;
+		else
+			pipe++;
+	}
+
+	return pipe;
+}
+
+INTERN void *
+tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp)
 {
+	tdm_private_module *private_module = NULL;
 	tdm_private_output *private_output = NULL;
 
-	LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			if (private_output->stamp == stamp)
+				return private_output;
+		}
+	}
+
+	return NULL;
+}
+
+INTERN void *
+tdm_display_find_private_voutput(tdm_private_display *private_display, double stamp)
+{
+	tdm_private_module *private_module = NULL;
+	tdm_private_voutput *private_voutput = NULL;
+	tdm_private_output *private_output = NULL;
+
+	private_module = private_display->virtual_module;
+	if (!private_module) return NULL;
+
+	LIST_FOR_EACH_ENTRY(private_voutput, &private_module->voutput_list, link) {
+		if (!private_voutput->private_output) continue;
+		private_output = private_voutput->private_output;
 		if (private_output->stamp == stamp)
-			return private_output;
+			return private_voutput;
+	}
+
+	return NULL;
+}
+
+tdm_private_hwc *
+tdm_display_find_private_hwc(tdm_private_display *private_display, tdm_hwc *hwc_backend)
+{
+	tdm_private_module *private_module = NULL;
+	tdm_private_output *private_output = NULL;
+	tdm_private_hwc *private_hwc = NULL;
+
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			if (!private_output->private_hwc) continue;
+			private_hwc = private_output->private_hwc;
+			if (private_hwc->hwc_backend == hwc_backend)
+				return private_hwc;
+		}
+	}
+
+	return NULL;
+}
+
+INTERN void *
+tdm_display_find_hwc_stamp(tdm_private_display *private_display, double stamp)
+{
+	tdm_private_module *private_module = NULL;
+	tdm_private_output *private_output = NULL;
+	tdm_private_hwc *private_hwc = NULL;
+
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			if (!private_output->private_hwc) continue;
+			private_hwc = private_output->private_hwc;
+			if (private_hwc->stamp == stamp)
+				return private_hwc;
+		}
 	}
 
 	return NULL;
@@ -134,59 +232,123 @@ _tdm_display_destroy_private_layer(tdm_private_layer *private_layer)
 {
 	tdm_private_capture *c = NULL, *cc = NULL;
 
-	LIST_DEL(&private_layer->link);
+	tdm_layer_unset_buffer_internal(private_layer);
 
 	LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_layer->capture_list, link)
 	tdm_capture_destroy_internal(c);
 
 	_tdm_display_destroy_caps_layer(&private_layer->caps);
 
+	/* when destroying layer, someone could check if layer is valid. So delete
+	 * the layer's link at last.
+	 */
+	LIST_DEL(&private_layer->link);
+
 	free(private_layer);
 }
 
-static void
-_tdm_display_destroy_private_output(tdm_private_output *private_output)
+INTERN void
+tdm_display_destroy_private_output(tdm_private_output *private_output)
 {
+	tdm_private_display *private_display = private_output->private_display;
 	tdm_private_layer *l = NULL, *ll = NULL;
+	tdm_private_hwc *private_hwc = NULL;
+	tdm_private_hwc_window *hw = NULL, *hww = NULL;
 	tdm_private_capture *c = NULL, *cc = NULL;
-	tdm_private_vblank_handler *v = NULL, *vv = NULL;
-	tdm_private_commit_handler *m = NULL, *mm = NULL;
-	tdm_private_change_handler *h = NULL, *hh = NULL;
+	tdm_private_output_vblank_handler *v = NULL, *vv = NULL;
+	tdm_private_output_commit_handler *om = NULL, *omm = NULL;
+	tdm_private_hwc_commit_handler *hm = NULL, *hmm = NULL;
+	tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL;
+	tdm_private_output_change_handler *h = NULL, *hh = NULL;
+	tdm_private_output_destroy_handler *dh = NULL, *dhh = NULL;
+	tdm_error ret;
+	int mutex_locked = 0;
 
-	LIST_DEL(&private_output->link);
+	ret = tdm_output_call_thread_cb_destroy(private_output);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
 	free(private_output->layers_ptr);
 
+	if (private_output->vblank_timeout_timer)
+		tdm_event_loop_source_remove(private_output->vblank_timeout_timer);
+
 	LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_handler_list, link) {
 		LIST_DEL(&v->link);
 		free(v);
 	}
 
-	LIST_FOR_EACH_ENTRY_SAFE(m, mm, &private_output->commit_handler_list, link) {
-		LIST_DEL(&m->link);
-		free(m);
+	LIST_FOR_EACH_ENTRY_SAFE(om, omm, &private_output->output_commit_handler_list, link) {
+		LIST_DEL(&om->link);
+		free(om);
 	}
 
-	LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) {
-		LIST_DEL(&h->link);
-		free(h);
+	if (private_output->private_hwc) {
+		private_hwc = private_output->private_hwc;
+		LIST_FOR_EACH_ENTRY_SAFE(hm, hmm, &private_hwc->hwc_commit_handler_list, link) {
+			LIST_DEL(&hm->link);
+			free(hm);
+		}
+	} else {
+		LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) {
+			LIST_DEL(&lm->link);
+			free(lm);
+		}
 	}
 
-	LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) {
+	LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) {
+		LIST_DEL(&lm->link);
+		free(lm);
+	}
+
+	LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
 		LIST_DEL(&h->link);
+		tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, h);
+		tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, h);
 		free(h);
 	}
 
-	LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link)
-	tdm_capture_destroy_internal(c);
+	LIST_FOR_EACH_ENTRY_SAFE(dh, dhh, &private_output->destroy_handler_list, link) {
+		LIST_DEL(&dh->link);
+		tdm_thread_cb_remove(dh->private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, dh);
+		free(dh);
+	}
+
+	if (tdm_thread_is_running() && TDM_MUTEX_IS_LOCKED()) mutex_locked = 1;
+	if (private_output->vblank) {
+		/* tdm_vblank APIs is for server. it should be called in unlock status*/
+		if (mutex_locked) _pthread_mutex_unlock(&private_display->lock);
+		tdm_vblank_destroy(private_output->vblank);
+		if (mutex_locked) _pthread_mutex_lock(&private_display->lock);
+	}
+
+	if (private_output->ttrace_vblank) {
+		/* tdm_vblank APIs is for server. it should be called in unlock status*/
+		if (mutex_locked) _pthread_mutex_unlock(&private_display->lock);
+		tdm_vblank_destroy(private_output->ttrace_vblank);
+		if (mutex_locked) _pthread_mutex_lock(&private_display->lock);
+	}
 
-	LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link)
-	_tdm_display_destroy_private_layer(l);
+	LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link)
+		tdm_capture_destroy_internal(c);
+
+	if (private_output->private_hwc) {
+		private_hwc = private_output->private_hwc;
+		LIST_FOR_EACH_ENTRY_SAFE(hw, hww, &private_hwc->hwc_window_list, link)
+			tdm_hwc_window_destroy_internal(hw);
+		if (private_hwc->display_target_buffer)
+			tbm_surface_internal_unref(private_hwc->display_target_buffer);
+		free(private_hwc);
+	} else {
+		LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link)
+			_tdm_display_destroy_private_layer(l);
+	}
 
 	_tdm_display_destroy_caps_output(&private_output->caps);
 
-	if (private_output->dpms_changed_timer)
-		tdm_event_loop_source_remove(private_output->dpms_changed_timer);
+	/* when destroying output, vblank objects are also destroyed. vblank checks
+	 * if output object is valid. So delete the output's link at last.
+	 */
+	LIST_DEL(&private_output->link);
 
 	private_output->stamp = 0;
 	free(private_output);
@@ -195,46 +357,58 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output)
 static void
 _tdm_display_destroy_private_display(tdm_private_display *private_display)
 {
+	tdm_private_module *private_module = NULL, *bb = NULL;
 	tdm_private_output *o = NULL, *oo = NULL;
 	tdm_private_pp *p = NULL, *pp = NULL;
+	tdm_private_output_create_handler *ch = NULL, *chh = NULL;
 
-	free(private_display->outputs_ptr);
-	if (private_display->outputs) {
-		free(private_display->outputs);
-		private_display->outputs = NULL;
-	}
+	LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_module->pp_list, link) {
+			tdm_pp_destroy_internal(p);
+		}
+
+		LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_module->output_list, link) {
+			tdm_display_destroy_private_output(o);
+		}
 
-	LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_display->pp_list, link)
-	tdm_pp_destroy_internal(p);
+		_tdm_display_destroy_caps_pp(&private_module->caps_pp);
+		_tdm_display_destroy_caps_capture(&private_module->caps_capture);
 
-	LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_display->output_list, link)
-	_tdm_display_destroy_private_output(o);
+		private_module->capabilities = 0;
+		private_module->caps_display.max_layer_count = 0;
 
-	_tdm_display_destroy_caps_pp(&private_display->caps_pp);
-	_tdm_display_destroy_caps_capture(&private_display->caps_capture);
+		if (private_module->outputs) {
+			free(private_module->outputs);
+			private_module->outputs = NULL;
+		}
+	}
 
-	private_display->capabilities = 0;
-	private_display->caps_display.max_layer_count = -1;
+	LIST_FOR_EACH_ENTRY_SAFE(ch, chh, &private_display->output_create_handler_list, link) {
+		LIST_DEL(&ch->link);
+		tdm_thread_cb_remove(ch->private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+							 tdm_display_thread_cb_output_create, ch);
+		free(ch);
+	}
 }
 
 static tdm_error
-_tdm_display_update_caps_pp(tdm_private_display *private_display,
-							tdm_caps_pp *caps)
+_tdm_display_update_caps_pp(tdm_private_module *private_module, tdm_caps_pp *caps)
 {
-	tdm_func_display *func_display = &private_display->func_display;
+	tdm_func_display *func_display;
 	tdm_error ret;
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP))
-		return TDM_ERROR_NONE;
+	func_display = &private_module->func_display;
 
 	if (!func_display->display_get_pp_capability) {
-		TDM_ERR("no display_get_pp_capability()");
+		TDM_ERR("backend(%s) no display_get_pp_capability()", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
-	ret = func_display->display_get_pp_capability(private_display->bdata, caps);
+	memset(caps, 0, sizeof(tdm_caps_pp));
+
+	ret = func_display->display_get_pp_capability(private_module->bdata, caps);
 	if (ret != TDM_ERROR_NONE) {
-		TDM_ERR("display_get_pp_capability() failed");
+		TDM_ERR("backend(%s) display_get_pp_capability() failed", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
@@ -242,23 +416,21 @@ _tdm_display_update_caps_pp(tdm_private_display *private_display,
 }
 
 static tdm_error
-_tdm_display_update_caps_capture(tdm_private_display *private_display,
-								 tdm_caps_capture *caps)
+_tdm_display_update_caps_capture(tdm_private_module *private_module, tdm_caps_capture *caps)
 {
-	tdm_func_display *func_display = &private_display->func_display;
+	tdm_func_display *func_display;
 	tdm_error ret;
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
-		return TDM_ERROR_NONE;
+	func_display = &private_module->func_display;
 
 	if (!func_display->display_get_capture_capability) {
-		TDM_ERR("no display_get_capture_capability()");
+		TDM_ERR("backend(%s) no display_get_capture_capability()", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
-	ret = func_display->display_get_capture_capability(private_display->bdata, caps);
+	ret = func_display->display_get_capture_capability(private_module->bdata, caps);
 	if (ret != TDM_ERROR_NONE) {
-		TDM_ERR("display_get_capture_capability() failed");
+		TDM_ERR("backend(%s) display_get_capture_capability() failed", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
@@ -266,20 +438,20 @@ _tdm_display_update_caps_capture(tdm_private_display *private_display,
 }
 
 static tdm_error
-_tdm_display_update_caps_layer(tdm_private_display *private_display,
+_tdm_display_update_caps_layer(tdm_private_module *private_module,
 							   tdm_layer *layer_backend, tdm_caps_layer *caps)
 {
-	tdm_func_layer *func_layer = &private_display->func_layer;
+	tdm_func_layer *func_layer = &private_module->func_layer;
 	tdm_error ret;
 
 	if (!func_layer->layer_get_capability) {
-		TDM_ERR("no layer_get_capability()");
+		TDM_ERR("backend(%s) no layer_get_capability()", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
 	ret = func_layer->layer_get_capability(layer_backend, caps);
 	if (ret != TDM_ERROR_NONE) {
-		TDM_ERR("layer_get_capability() failed");
+		TDM_ERR("backend(%s) layer_get_capability() failed", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
@@ -287,34 +459,38 @@ _tdm_display_update_caps_layer(tdm_private_display *private_display,
 }
 
 static tdm_error
-_tdm_display_update_caps_output(tdm_private_display *private_display, int pipe,
+_tdm_display_update_caps_output(tdm_private_module *private_module, int pipe,
 								tdm_output *output_backend, tdm_caps_output *caps)
 {
-	tdm_func_output *func_output = &private_display->func_output;
+	tdm_func_output *func_output = &private_module->func_output;
 	char temp[TDM_NAME_LEN];
 	tdm_error ret;
+	double stamp;
+	int n;
 
-	if (!func_output->output_get_capability) {
-		TDM_ERR("no output_get_capability()");
-		return TDM_ERROR_BAD_MODULE;
-	}
-
+	stamp = tdm_helper_get_time();
 	ret = func_output->output_get_capability(output_backend, caps);
+	TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms",
+			private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0);
+
 	if (ret != TDM_ERROR_NONE) {
-		TDM_ERR("output_get_capability() failed");
+		TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
 	/* FIXME: Use model for tdm client to distinguish amoung outputs */
-	snprintf(temp, TDM_NAME_LEN, "%s-%d", caps->model, pipe);
+	n = snprintf(temp, sizeof(temp), "%s-%d", caps->model, pipe);
+	if ((size_t)n >= sizeof(temp)) {
+		 temp[sizeof(temp) - 1] = '\0';
+	}
+
 	snprintf(caps->model, TDM_NAME_LEN, "%s", temp);
 
 	return TDM_ERROR_NONE;
 }
 
 static tdm_error
-_tdm_display_update_layer(tdm_private_display *private_display,
-						  tdm_private_output *private_output,
+_tdm_display_update_layer(tdm_private_output *private_output,
 						  tdm_layer *layer_backend, int index)
 {
 	tdm_private_layer *private_layer;
@@ -326,61 +502,66 @@ _tdm_display_update_layer(tdm_private_display *private_display,
 		TDM_RETURN_VAL_IF_FAIL(private_layer != NULL, TDM_ERROR_OUT_OF_MEMORY);
 
 		LIST_ADDTAIL(&private_layer->link, &private_output->layer_list);
+		LIST_INITHEAD(&private_layer->capture_list);
+
 		private_layer->index = index;
-		private_layer->private_display = private_display;
+		private_layer->private_module = private_output->private_module;
+		private_layer->private_display = private_output->private_display;
 		private_layer->private_output = private_output;
 		private_layer->layer_backend = layer_backend;
-
-		LIST_INITHEAD(&private_layer->capture_list);
-
 		private_layer->usable = 1;
-	} else
-		_tdm_display_destroy_caps_layer(&private_layer->caps);
+	}
 
-	ret = _tdm_display_update_caps_layer(private_display, layer_backend,
-										 &private_layer->caps);
-	if (ret != TDM_ERROR_NONE)
-		goto failed_update;
+	_tdm_display_destroy_caps_layer(&private_layer->caps);
+
+	ret = _tdm_display_update_caps_layer(private_output->private_module, layer_backend, &private_layer->caps);
+	TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
 
 	return TDM_ERROR_NONE;
-failed_update:
-	_tdm_display_destroy_private_layer(private_layer);
-	return ret;
 }
 
 INTERN tdm_error
-tdm_display_update_output(tdm_private_display *private_display,
-						  tdm_output *output_backend, int pipe)
+tdm_display_update_output(tdm_private_module *private_module, tdm_output *output_backend)
 {
-	tdm_func_output *func_output = &private_display->func_output;
+	tdm_func_output *func_output = &private_module->func_output;
+	tdm_private_display *private_display = NULL;
 	tdm_private_output *private_output = NULL;
 	tdm_layer **layers = NULL;
+	tdm_private_hwc *private_hwc = NULL;
+	tdm_hwc *hwc;
 	int layer_count = 0, i;
 	tdm_error ret;
+	unsigned int output_created = 0;
+
+	private_display = private_module->private_display;
 
-	private_output = _tdm_display_find_private_output(private_display, output_backend);
+	private_output = tdm_display_find_private_output(private_display, output_backend);
 	if (!private_output) {
+		unsigned int pipe = tdm_display_find_empty_output_pipe(private_display);
+
 		private_output = calloc(1, sizeof(tdm_private_output));
 		TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OUT_OF_MEMORY);
 
-		private_output->stamp = tdm_helper_get_time_in_millis();
+		private_output->stamp = tdm_helper_get_time();
 		while (tdm_display_find_output_stamp(private_display, private_output->stamp))
 			private_output->stamp++;
 
-		LIST_ADDTAIL(&private_output->link, &private_display->output_list);
+		LIST_ADDTAIL(&private_output->link, &private_module->output_list);
 
+		private_output->private_module = private_module;
 		private_output->private_display = private_display;
 		private_output->current_dpms_value = TDM_OUTPUT_DPMS_OFF;
 		private_output->output_backend = output_backend;
 		private_output->pipe = pipe;
 		private_output->index = pipe;
 
-		LIST_INITHEAD(&private_output->layer_list);
 		LIST_INITHEAD(&private_output->capture_list);
 		LIST_INITHEAD(&private_output->vblank_handler_list);
-		LIST_INITHEAD(&private_output->commit_handler_list);
-		LIST_INITHEAD(&private_output->change_handler_list_main);
-		LIST_INITHEAD(&private_output->change_handler_list_sub);
+		LIST_INITHEAD(&private_output->output_commit_handler_list);
+		LIST_INITHEAD(&private_output->pending_commit_handler_list);
+		LIST_INITHEAD(&private_output->destroy_handler_list);
+		LIST_INITHEAD(&private_output->change_handler_list);
+		LIST_INITHEAD(&private_output->mode_change_request_handler_list);
 
 		if (func_output->output_set_status_handler) {
 			func_output->output_set_status_handler(private_output->output_backend,
@@ -389,54 +570,94 @@ tdm_display_update_output(tdm_private_display *private_display,
 			private_output->regist_change_cb = 1;
 		}
 
-	} else
+		output_created = 1;
+
+		/* NOTE that output modes will be allocated newly after here */
 		_tdm_display_destroy_caps_output(&private_output->caps);
+		ret = _tdm_display_update_caps_output(private_module, private_output->pipe, output_backend, &private_output->caps);
+		TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
 
-	ret = _tdm_display_update_caps_output(private_display, pipe, output_backend,
-										  &private_output->caps);
-	if (ret != TDM_ERROR_NONE)
-		return ret;
+		if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
+			private_output->current_mode = NULL;
 
-	layers = func_output->output_get_layers(output_backend, &layer_count, &ret);
-	if (ret != TDM_ERROR_NONE)
-		goto failed_update;
+		/* get the tdm_hwc object */
+		if (private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) {
+			hwc = func_output->output_get_hwc(output_backend, &ret);
+			TDM_RETURN_VAL_IF_FAIL(hwc != NULL, ret);
 
-	for (i = 0; i < layer_count; i++) {
-		ret = _tdm_display_update_layer(private_display, private_output, layers[i], i);
-		if (ret != TDM_ERROR_NONE)
-			goto failed_update;
+			private_hwc = calloc(1, sizeof(tdm_private_hwc));
+			TDM_RETURN_VAL_IF_FAIL(private_hwc != NULL, TDM_ERROR_OUT_OF_MEMORY);
+
+			private_hwc->private_module = private_module;
+			private_hwc->private_output = private_output;
+			private_hwc->hwc_backend = hwc;
+			private_hwc->index = pipe;
+			private_hwc->stamp = tdm_helper_get_time();
+			while (tdm_display_find_hwc_stamp(private_module->private_display, private_hwc->stamp))
+				private_hwc->stamp++;
+
+			LIST_INITHEAD(&private_hwc->hwc_window_list);
+			LIST_INITHEAD(&private_hwc->hwc_commit_handler_list);
+
+			private_output->private_hwc = private_hwc;
+		} else {
+			LIST_INITHEAD(&private_output->layer_list);
+			LIST_INITHEAD(&private_output->layer_commit_handler_list);
+		}
+	} else {
+		_tdm_display_destroy_caps_output(&private_output->caps);
+		ret = _tdm_display_update_caps_output(private_module, private_output->pipe, output_backend, &private_output->caps);
+		TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
+
+		if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
+			private_output->current_mode = NULL;
+	}
+
+	/* do not use the layer object when the tdm_output has the hwc capability */
+	if ((private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) == 0) {
+		layers = func_output->output_get_layers(output_backend, &layer_count, &ret);
+		if (ret != TDM_ERROR_NONE) {
+			free(layers);
+			return ret;
+		}
+
+		for (i = 0; i < layer_count; i++) {
+			ret = _tdm_display_update_layer(private_output, layers[i], i);
+			if (ret != TDM_ERROR_NONE) {
+				free(layers);
+				return ret;
+			}
+		}
+
+		free(layers);
 	}
 
-	free(layers);
+	if (output_created) {
+		ret = tdm_display_call_thread_cb_output_create(private_display, private_output);
+		TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+	}
 
 	return TDM_ERROR_NONE;
-failed_update:
-	_tdm_display_destroy_private_output(private_output);
-	free(layers);
-	return ret;
 }
 
-static tdm_output **
+static void
 _tdm_display_set_main_first(tdm_output **outputs, int index)
 {
 	tdm_output *output_tmp = NULL;
 
 	if (index == 0)
-		return outputs;
+		return;
 
 	output_tmp = outputs[0];
 	outputs[0] = outputs[index];
 	outputs[index] = output_tmp;
-
-	return outputs;
 }
 
 static tdm_output **
-_tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *count)
+_tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count)
 {
-	tdm_func_display *func_display = &private_display->func_display;
+	tdm_func_display *func_display = &private_module->func_display;
 	tdm_output **outputs = NULL;
-	tdm_output **new_outputs = NULL;
 	tdm_output *output_dsi = NULL;
 	tdm_output *output_lvds = NULL;
 	tdm_output *output_hdmia = NULL;
@@ -446,37 +667,34 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun
 	tdm_error ret;
 
 	/* don't change list order if not init time */
-	if (private_display->outputs)
-		return private_display->outputs;
+	if (private_module->outputs) {
+		TDM_ERR("can't change output order");
+		return private_module->outputs;
+	}
 
-	outputs = func_display->display_get_outputs(private_display->bdata, &output_count, &ret);
+	outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret);
 	if (ret != TDM_ERROR_NONE)
-		goto failed_get_outputs;
+		goto no_output;
 
 	*count = output_count;
 
 	if (output_count == 0)
-		goto failed_get_outputs;
+		goto no_output;
 	else if (output_count == 1) {
-		private_display->outputs = outputs;
+		private_module->outputs = outputs;
 		return outputs;
 	}
 
 	/* count connected outputs */
 	for (i = 0; i < output_count; i++) {
-		tdm_func_output *func_output = &private_display->func_output;
+		tdm_func_output *func_output = &private_module->func_output;
 		tdm_caps_output caps;
 		memset(&caps, 0, sizeof(tdm_caps_output));
 
-		if (!func_output->output_get_capability) {
-			TDM_ERR("no output_get_capability()");
-			goto failed_get_outputs;
-		}
-
 		ret = func_output->output_get_capability(outputs[i], &caps);
 		if (ret != TDM_ERROR_NONE) {
 			TDM_ERR("output_get_capability() failed");
-			goto failed_get_outputs;
+			goto no_output;
 		}
 
 		if (caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED) {
@@ -503,6 +721,8 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun
 				break;
 			}
 		}
+
+		_tdm_display_destroy_caps_output(&caps);
 	}
 
 	/* ordering : main output is first */
@@ -515,70 +735,112 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun
 	if (output_connected_count == 0) {
 		/* hdmi > dsi > lvds > else */
 		if (output_hdmia != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_hdmia);
+			_tdm_display_set_main_first(outputs, index_hdmia);
 		else if (output_hdmib != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_hdmib);
+			_tdm_display_set_main_first(outputs, index_hdmib);
 		else if (output_dsi != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_dsi);
+			_tdm_display_set_main_first(outputs, index_dsi);
 		else if (output_lvds != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_lvds);
-		else
-			new_outputs = outputs;
+			_tdm_display_set_main_first(outputs, index_lvds);
 	} else { /* (output_connected_count > 1) */
 		/* dsi > lvds > hdmi > else */
 		if (output_dsi != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_dsi);
+			_tdm_display_set_main_first(outputs, index_dsi);
 		else if (output_lvds != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_lvds);
+			_tdm_display_set_main_first(outputs, index_lvds);
 		else if (output_hdmia != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_hdmia);
+			_tdm_display_set_main_first(outputs, index_hdmia);
 		else if (output_hdmib != NULL)
-			new_outputs = _tdm_display_set_main_first(outputs, index_hdmib);
-		else
-			new_outputs = outputs;
+			_tdm_display_set_main_first(outputs, index_hdmib);
 	}
 
-	private_display->outputs = new_outputs;
+	private_module->outputs = outputs;
 
-	return new_outputs;
+	return outputs;
 
-failed_get_outputs:
+no_output:
 	free(outputs);
 	*count = 0;
 	return NULL;
 }
 
 static tdm_error
-_tdm_display_update_internal(tdm_private_display *private_display,
-							 int only_display)
+_tdm_display_setup(tdm_private_display *private_display)
 {
-	tdm_output **outputs = NULL;
-	int output_count = 0, i;
+	tdm_private_module *private_module = NULL;
 	tdm_error ret = TDM_ERROR_NONE;
+	int output_count = 0;
+	int virtual = 0;
+	int virtual_hwc_target_buffer_bo_default = 0;
 
-	LIST_INITHEAD(&private_display->output_list);
-	LIST_INITHEAD(&private_display->pp_list);
-	LIST_INITHEAD(&private_display->capture_list);
-
-	if (!only_display) {
-		ret = _tdm_display_update_caps_pp(private_display, &private_display->caps_pp);
+	if (private_display->pp_module) {
+		ret = _tdm_display_update_caps_pp(private_display->pp_module,
+										  &private_display->pp_module->caps_pp);
 		if (ret != TDM_ERROR_NONE)
 			goto failed_update;
+	}
 
-		ret = _tdm_display_update_caps_capture(private_display,
-											   &private_display->caps_capture);
+	if (private_display->capture_module) {
+		ret = _tdm_display_update_caps_capture(private_display->capture_module,
+											   &private_display->capture_module->caps_capture);
 		if (ret != TDM_ERROR_NONE)
 			goto failed_update;
 	}
 
-	outputs = _tdm_display_get_ordered_outputs(private_display, &output_count);
-	if (!outputs)
-		goto failed_update;
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		tdm_output **outputs;
+		int i, count = 0;
 
-	for (i = 0; i < output_count; i++) {
-		ret = tdm_display_update_output(private_display, outputs[i], i);
-		if (ret != TDM_ERROR_NONE)
-			goto failed_update;
+		outputs = _tdm_display_get_ordered_outputs(private_module, &count);
+
+		if (count > 0)
+			TDM_GOTO_IF_FAIL(outputs != NULL, failed_update);
+
+		for (i = 0; i < count; i++) {
+			ret = tdm_display_update_output(private_module, outputs[i]);
+			if (ret != TDM_ERROR_NONE)
+				goto failed_update;
+			output_count++;
+		}
+	}
+
+	/* At least, the output count should be greater than 0 to ensure tdm_vblank works.
+	 * So we will create a dummy output when backends don't have any output.
+	 * Without destroying a tdm_output object, this dummy output will be replaced with
+	 * a virtual output which is created in runtime.
+	 */
+	if (output_count == 0) {
+		tdm_output **outputs;
+		int i, count = 0;
+
+		TDM_INIT_INFO("loading a %s backend", TDM_DUMMY_MODULE);
+		ret = _tdm_display_load_module_with_file(private_display, TDM_DUMMY_MODULE);
+		TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed_update);
+		TDM_GOTO_IF_FAIL(private_display->dummy_module != NULL, failed_update);
+
+		private_module = private_display->dummy_module;
+
+		outputs = _tdm_display_get_ordered_outputs(private_module, &count);
+		TDM_GOTO_IF_FAIL(count > 0, failed_update);
+		TDM_GOTO_IF_FAIL(outputs != NULL, failed_update);
+
+		for (i = 0; i < count; i++) {
+			ret = tdm_display_update_output(private_module, outputs[i]);
+			if (ret != TDM_ERROR_NONE)
+				goto failed_update;
+		}
+	}
+
+	virtual = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0);
+	if (virtual) {
+		TDM_INIT_INFO("loading a %s backend", TDM_VIRTUAL_MODULE);
+		ret = _tdm_display_load_module_with_file(private_display, TDM_VIRTUAL_MODULE);
+		TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed_update);
+		TDM_GOTO_IF_FAIL(private_display->virtual_module != NULL, failed_update);
+
+		virtual_hwc_target_buffer_bo_default = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT_HWC_TARGET_BO_DEFAULT, 0);
+		if (virtual_hwc_target_buffer_bo_default)
+			private_display->virtual_module->use_default_type_bo = 1;
 	}
 
 	return TDM_ERROR_NONE;
@@ -587,41 +849,38 @@ failed_update:
 	_tdm_display_destroy_private_display(private_display);
 	return ret;
 }
+/* LCOV_EXCL_STOP */
 
 EXTERN tdm_error
 tdm_display_update(tdm_display *dpy)
 {
-	tdm_private_display *private_display;
-	tdm_error ret;
-
 	TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-	private_display = dpy;
-	_pthread_mutex_lock(&private_display->lock);
-
-	ret = _tdm_display_update_internal(private_display, 1);
-
-	_pthread_mutex_unlock(&private_display->lock);
+	TDM_DEPRECATED(NULL);
 
-	return ret;
+	return TDM_ERROR_NONE;
 }
 
-#define SUFFIX_MODULE    ".so"
-#define DEFAULT_MODULE   "libtdm-default"SUFFIX_MODULE
-
 int tdm_debug_module;
 int tdm_debug_dump;
+int tdm_ttrace_module;
+int tdm_ttrace_output;
 
 static tdm_private_display *g_private_display;
 static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER;
 
+/* LCOV_EXCL_START */
 static tdm_error
 _tdm_display_check_module(tdm_backend_module *module)
 {
-	int major, minor;
+	int tdm_backend_major, tdm_backend_minor;
+	int backend_module_major, backend_module_minor;
+
+	tdm_backend_major = TDM_BACKEND_GET_ABI_MAJOR(TDM_BACKEND_ABI_LATEST_VERSION);
+	tdm_backend_minor = TDM_BACKEND_GET_ABI_MINOR(TDM_BACKEND_ABI_LATEST_VERSION);
 
-	TDM_INFO("TDM ABI version : %d.%d",
-			 TDM_MAJOR_VERSION, TDM_MINOR_VERSION);
+	TDM_INFO("TDM Backend ABI version : %d.%d",
+			 tdm_backend_major, tdm_backend_minor);
 
 	if (!module->name) {
 		TDM_ERR("TDM backend doesn't have name");
@@ -633,22 +892,23 @@ _tdm_display_check_module(tdm_backend_module *module)
 		return TDM_ERROR_BAD_MODULE;
 	}
 
-	major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version);
-	minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version);
+	backend_module_major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version);
+	backend_module_minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version);
 
 	TDM_INFO("TDM module name: %s", module->name);
 	TDM_INFO("'%s' vendor: %s", module->name, module->vendor);
-	TDM_INFO("'%s' version: %d.%d", module->name, major, minor);
+	TDM_INFO("'%s' backend ABI version: %d.%d", module->name, backend_module_major, backend_module_minor);
 
-	if (major != TDM_MAJOR_VERSION) {
-		TDM_ERR("'%s' major version mismatch, %d != %d",
-				module->name, major, TDM_MAJOR_VERSION);
+	if (backend_module_major > tdm_backend_major) {
+		TDM_ERR("'%s' major version(%d) is newer than %d",
+				module->name, backend_module_major, tdm_backend_major);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
-	if (minor > TDM_MINOR_VERSION) {
+	if (tdm_backend_major == backend_module_major &&
+		backend_module_minor > tdm_backend_minor) {
 		TDM_ERR("'%s' minor version(%d) is newer than %d",
-				module->name, minor, TDM_MINOR_VERSION);
+				module->name, backend_module_minor, tdm_backend_minor);
 		return TDM_ERROR_BAD_MODULE;
 	}
 
@@ -666,33 +926,39 @@ _tdm_display_check_module(tdm_backend_module *module)
 }
 
 static tdm_error
-_tdm_display_check_backend_functions(tdm_private_display *private_display)
+_tdm_display_check_backend_functions(tdm_private_module *private_module)
 {
-	tdm_func_display *func_display = &private_display->func_display;
-	tdm_func_output *func_output = &private_display->func_output;
-	tdm_func_layer *func_layer = &private_display->func_layer;
+	tdm_func_display *func_display = &private_module->func_display;
+	tdm_func_output *func_output = &private_module->func_output;
+	tdm_func_layer *func_layer = &private_module->func_layer;
 	tdm_error ret;
 
 	/* below functions should be implemented in backend side */
 
 	TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_BAD_MODULE);
-//	TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capabilitiy, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capability, TDM_ERROR_BAD_MODULE);
 	TDM_RETURN_VAL_IF_FAIL(func_display->display_get_outputs, TDM_ERROR_BAD_MODULE);
 	TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, TDM_ERROR_BAD_MODULE);
 	TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_output->output_wait_vblank, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_output->output_set_vblank_handler, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_output->output_commit, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_output->output_set_commit_handler, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_output->output_set_mode, TDM_ERROR_BAD_MODULE);
 	TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_info, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_info, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_buffer, TDM_ERROR_BAD_MODULE);
+	TDM_RETURN_VAL_IF_FAIL(func_layer->layer_unset_buffer, TDM_ERROR_BAD_MODULE);
 
-	if (func_display->display_get_capability)
-		ret = func_display->display_get_capability(private_display->bdata, &private_display->caps_display);
-	else
-		ret = func_display->display_get_capabilitiy(private_display->bdata, &private_display->caps_display);
+	ret = func_display->display_get_capability(private_module->bdata, &private_module->caps_display);
 	if (ret != TDM_ERROR_NONE) {
 		TDM_ERR("display_get_capability() failed");
 		return TDM_ERROR_BAD_MODULE;
 	}
 
-	if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP) {
-		tdm_func_pp *func_pp = &private_display->func_pp;
+	if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) {
+		tdm_func_pp *func_pp = &private_module->func_pp;
 		TDM_RETURN_VAL_IF_FAIL(func_display->display_get_pp_capability, TDM_ERROR_BAD_MODULE);
 		TDM_RETURN_VAL_IF_FAIL(func_display->display_create_pp, TDM_ERROR_BAD_MODULE);
 		TDM_RETURN_VAL_IF_FAIL(func_pp->pp_destroy, TDM_ERROR_BAD_MODULE);
@@ -700,11 +966,13 @@ _tdm_display_check_backend_functions(tdm_private_display *private_display)
 		TDM_RETURN_VAL_IF_FAIL(func_pp->pp_set_done_handler, TDM_ERROR_BAD_MODULE);
 	}
 
-	if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) {
-		tdm_func_capture *func_capture = &private_display->func_capture;
+	if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) {
+		tdm_func_capture *func_capture = &private_module->func_capture;
 		TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, TDM_ERROR_BAD_MODULE);
-		TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE);
-		TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE);
+		if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT)
+			TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE);
+		if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER)
+			TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE);
 		TDM_RETURN_VAL_IF_FAIL(func_capture->capture_destroy, TDM_ERROR_BAD_MODULE);
 		TDM_RETURN_VAL_IF_FAIL(func_capture->capture_commit, TDM_ERROR_BAD_MODULE);
 		TDM_RETURN_VAL_IF_FAIL(func_capture->capture_set_done_handler, TDM_ERROR_BAD_MODULE);
@@ -717,22 +985,43 @@ static tdm_error
 _tdm_display_load_module_with_file(tdm_private_display *private_display,
 								   const char *file)
 {
-	char path[PATH_MAX] = {0,};
+	char path[TDM_PATH_LEN] = {0,};
+	void *module = NULL;
 	tdm_backend_module *module_data;
-	void *module;
+	tdm_backend_data *bdata = NULL;
+	tdm_private_module *private_module = NULL;
 	tdm_error ret;
+	double stamp;
+	int size;
 
-	snprintf(path, sizeof(path), TDM_MODULE_PATH "/%s", file);
+	size = snprintf(path, sizeof(path), TDM_MODULE_PATH "/%s", file);
+	if (size >= (int)sizeof(path)) {
+		TDM_WRN("too long: %s/%s", TDM_MODULE_PATH, file);
+		return TDM_ERROR_BAD_MODULE;
+	};
 
-	TDM_TRACE_BEGIN(Load_Backend);
+	private_module = calloc(1, sizeof *private_module);
+	if (!private_module) {
+		TDM_ERR("alloc failed: %m");
+		ret = TDM_ERROR_OUT_OF_MEMORY;
+		goto failed_load;
+	}
+
+	private_module->private_display = private_display;
 
+	stamp = tdm_helper_get_time();
+
+	TDM_TRACE_BEGIN("TDM_Load_Backend");
 	module = dlopen(path, RTLD_LAZY);
 	if (!module) {
-		TDM_ERR("failed to load module: %s(%s)", dlerror(), file);
+		TDM_ERR("%s", dlerror());
 		TDM_TRACE_END();
-		return TDM_ERROR_BAD_MODULE;
+		ret = TDM_ERROR_NO_MODULE;
+		goto failed_load;
 	}
 
+	private_module->module = module;
+
 	module_data = dlsym(module, "tdm_backend_module_data");
 	if (!module_data) {
 		TDM_ERR("'%s' doesn't have data object", file);
@@ -740,144 +1029,216 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display,
 		TDM_TRACE_END();
 		goto failed_load;
 	}
+	TDM_TRACE_END();
 
-	private_display->module_data = module_data;
-	private_display->module = module;
+	private_module->module_data = module_data;
+
+	TDM_DBG("dlopen, dlsym time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0);
 
 	/* check if version, init() and deinit() are valid or not */
 	ret = _tdm_display_check_module(module_data);
-	if (ret != TDM_ERROR_NONE)
+	if (ret != TDM_ERROR_NONE) {
+		TDM_ERR("backend(%s) load failed: check module error", module_data->name);
 		goto failed_load;
+	}
 
-	TDM_TRACE_END();
+	private_display->current_module = private_module;
 
 	/* We don't care if backend_data is NULL or not. It's up to backend. */
-	TDM_TRACE_BEGIN(Init_Backend);
-	private_display->bdata = module_data->init((tdm_display *)private_display, &ret);
+	TDM_TRACE_BEGIN("TDM_Init_Backend");
+	stamp = tdm_helper_get_time();
+	TDM_INIT_INFO("init backend");
+	bdata = module_data->init((tdm_display *)private_display, &ret);
+	TDM_INIT_INFO("init backend done");
+	TDM_DBG("backend init() time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0);
 	TDM_TRACE_END();
+
+	private_display->current_module = NULL;
+
+	if (!strncmp(file, TDM_DUMMY_MODULE, TDM_NAME_LEN))
+		private_display->dummy_module = private_module;
+
+	if (!strncmp(file, TDM_VIRTUAL_MODULE, TDM_NAME_LEN))
+		private_display->virtual_module = private_module;
+
+	private_module->bdata = bdata;
+
 	if (ret != TDM_ERROR_NONE) {
-		TDM_ERR("failed to init '%s' module", module_data->name);
+		TDM_ERR("backend(%s) load failed: init error", module_data->name);
 		goto failed_load;
 	}
 
-	ret = _tdm_display_check_backend_functions(private_display);
+	ret = _tdm_display_check_backend_functions(private_module);
 	if (ret != TDM_ERROR_NONE) {
-		module_data->deinit(private_display->bdata);
-		private_display->bdata = NULL;
+		TDM_ERR("backend(%s) load failed: check functions error", module_data->name);
 		goto failed_load;
 	}
 
-	TDM_INFO("Success to load '%s' module", module_data->name);
+	LIST_INITHEAD(&private_module->output_list);
+	LIST_INITHEAD(&private_module->voutput_list);
+	LIST_INITHEAD(&private_module->pp_list);
+	LIST_INITHEAD(&private_module->capture_list);
+
+	LIST_ADDTAIL(&private_module->link, &private_display->module_list);
+
+	TDM_INIT_INFO("Success to load '%s' module", module_data->name);
 
 	return TDM_ERROR_NONE;
 failed_load:
-	dlclose(module);
-	private_display->module_data = NULL;
-	private_display->module = NULL;
+	if (bdata)
+		module_data->deinit(bdata);
+	if (module)
+		dlclose(module);
+	if (private_module)
+		free(private_module);
 	return ret;
 }
 
 static tdm_error
-_tdm_display_load_module(tdm_private_display *private_display)
+_tdm_display_load_modules(tdm_private_display *private_display)
 {
-	const char *module_name;
-	struct dirent **namelist;
-	int n;
-	tdm_error ret = 0;
-
-	module_name = getenv("TDM_MODULE");
-	if (!module_name)
-		module_name = DEFAULT_MODULE;
+	const char *module_names;
+	tdm_error ret = TDM_ERROR_NONE;
+	char temp[TDM_PATH_LEN];
+	char *arg;
+	char *end;
 
-	/* load bufmgr priv from default lib */
-	ret = _tdm_display_load_module_with_file(private_display, module_name);
-	if (ret == TDM_ERROR_NONE)
-		return TDM_ERROR_NONE;
+	LIST_INITHEAD(&private_display->module_list);
 
-	/* load bufmgr priv from configured path */
-	n = scandir(TDM_MODULE_PATH, &namelist, 0, alphasort);
-	if (n < 0) {
-		TDM_ERR("no module in '%s'\n", TDM_MODULE_PATH);
-		return TDM_ERROR_BAD_MODULE;
-	}
+	module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE);
 
-	ret = TDM_ERROR_BAD_MODULE;
-	while (n--) {
-		if (ret < 0 && strstr(namelist[n]->d_name, SUFFIX_MODULE))
-			ret = _tdm_display_load_module_with_file(private_display, namelist[n]->d_name);
+	snprintf(temp, TDM_PATH_LEN, "%s", module_names);
 
-		free(namelist[n]);
+	arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
+	while (arg) {
+		TDM_INIT_INFO("loading a %s backend", arg);
+		ret = _tdm_display_load_module_with_file(private_display, arg);
+		if (ret == TDM_ERROR_NONE)
+			TDM_INIT_INFO("%s backend loading success", arg);
+		else
+			TDM_INIT_INFO("%s backend loading failed", arg);
+		arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 	}
-	free(namelist);
 
 	return ret;
 }
 
 static void
-_tdm_display_unload_module(tdm_private_display *private_display)
+_tdm_display_unload_modules(tdm_private_display *private_display)
 {
-	if (private_display->module_data)
-		private_display->module_data->deinit(private_display->bdata);
-	if (private_display->module)
-		dlclose(private_display->module);
-
-	private_display->bdata = NULL;
-	private_display->module_data = NULL;
-	private_display->module = NULL;
+	tdm_private_module *private_module = NULL, *bb = NULL;
+
+	LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) {
+		LIST_DEL(&private_module->link);
+
+		if (private_module->module_data)
+			private_module->module_data->deinit(private_module->bdata);
+		if (private_module->module)
+			dlclose(private_module->module);
+
+		free(private_module);
+	}
+}
+/* LCOV_EXCL_STOP */
+
+INTERN void *
+tdm_display_find_stamp(tdm_private_display *private_display, double stamp)
+{
+	return (void*)g_private_display;
 }
 
 EXTERN tdm_display *
 tdm_display_init(tdm_error *error)
 {
 	tdm_private_display *private_display = NULL;
-	const char *debug;
+	const char *str;
 	tdm_error ret;
+	double stamp1, stamp2, start;
+	int mode;
 
-	_pthread_mutex_lock(&gLock);
+	pthread_mutex_lock(&gLock);
 
 	if (g_private_display) {
 		g_private_display->init_count++;
-		_pthread_mutex_unlock(&gLock);
+		pthread_mutex_unlock(&gLock);
 		if (error)
 			*error = TDM_ERROR_NONE;
 		return g_private_display;
 	}
 
+	start = stamp1 = tdm_helper_get_time();
+
 	private_display = calloc(1, sizeof(tdm_private_display));
 	if (!private_display) {
+		/* LCOV_EXCL_START */
 		ret = TDM_ERROR_OUT_OF_MEMORY;
 		TDM_ERR("'private_display != NULL' failed");
 		goto failed_alloc;
+		/* LCOV_EXCL_STOP */
 	}
 
-	debug = getenv("TDM_DEBUG_MODULE");
-	if (debug)
-		tdm_display_enable_debug_module(debug);
+	private_display->stamp = tdm_helper_get_time();
+
+	LIST_INITHEAD(&private_display->output_create_handler_list);
 
-	debug = getenv("TDM_DEBUG_DUMP");
-	if (debug)
-		tdm_display_enable_dump(private_display, debug, NULL, NULL);
+	str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_MODULE, NULL);
+	if (str)
+		tdm_display_enable_debug_module(str);
 
-	debug = getenv("TDM_DEBUG_PATH");
-	if (debug)
-		tdm_display_enable_path(debug);
+	str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_DUMP, NULL);
+	if (str)
+		tdm_display_enable_dump(private_display, str, NULL, NULL);
 
 	if (pthread_mutex_init(&private_display->lock, NULL)) {
+		/* LCOV_EXCL_START */
 		ret = TDM_ERROR_OPERATION_FAILED;
 		TDM_ERR("mutex init failed: %m");
 		goto failed_mutex_init;
+		/* LCOV_EXCL_STOP */
 	}
 
 	_pthread_mutex_lock(&private_display->lock);
 
+	stamp2 = tdm_helper_get_time();
+	TDM_DBG("prepare init time: %.3f ms", (stamp2 - stamp1) * 1000.0);
+	stamp1 = stamp2;
+
 	ret = tdm_event_loop_init(private_display);
 	if (ret != TDM_ERROR_NONE)
 		goto failed_event;
 
-	ret = _tdm_display_load_module(private_display);
+	stamp2 = tdm_helper_get_time();
+	TDM_INIT_INFO("event loop init time: %.3f ms", (stamp2 - stamp1) * 1000.0);
+	stamp1 = stamp2;
+
+	ret = tdm_vblank_init(private_display);
+	if (ret != TDM_ERROR_NONE)
+		goto failed_vblank;
+
+	ret = tdm_output_init(private_display);
 	if (ret != TDM_ERROR_NONE)
 		goto failed_load;
 
+	ret = tdm_hwc_init(private_display);
+	if (ret != TDM_ERROR_NONE)
+		goto failed_load;
+
+	ret = tdm_pp_init(private_display);
+	if (ret != TDM_ERROR_NONE)
+		goto failed_load;
+
+	ret = tdm_capture_init(private_display);
+	if (ret != TDM_ERROR_NONE)
+		goto failed_load;
+
+	ret = _tdm_display_load_modules(private_display);
+	if (!(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_MODULE))
+		goto failed_load;
+
+	stamp2 = tdm_helper_get_time();
+	TDM_INIT_INFO("loading backend time: %.3f ms", (stamp2 - stamp1) * 1000.0);
+	stamp1 = stamp2;
+
 #ifdef INIT_BUFMGR
 	int tdm_drm_fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD");
 	if (tdm_drm_fd >= 0) {
@@ -889,32 +1250,66 @@ tdm_display_init(tdm_error *error)
 		} else {
 			TDM_INFO("tbm_bufmgr_init successed");
 		}
+
+		stamp2 = tdm_helper_get_time();
+		TDM_DBG("initializing bufmgr time: %.3f ms", (stamp2 - stamp1) * 1000.0);
+		stamp1 = stamp2;
 	}
 #endif
 
-	TDM_TRACE_BEGIN(Update_Display);
-	ret = _tdm_display_update_internal(private_display, 0);
+	TDM_TRACE_BEGIN("TDM_Update_Display");
+	ret = _tdm_display_setup(private_display);
+	TDM_INIT_INFO("updating display");
 	TDM_TRACE_END();
 	if (ret != TDM_ERROR_NONE)
 		goto failed_update;
 
+	stamp2 = tdm_helper_get_time();
+	TDM_DBG("updating display time: %.3f ms", (stamp2 - stamp1) * 1000.0);
+	stamp1 = stamp2;
+
 	tdm_event_loop_create_backend_source(private_display);
 
 	private_display->init_count = 1;
-
 	g_private_display = private_display;
 
+	/* the COMMIT_PER_VBLANK functionality is ability of an output to support
+	 * several operational modes (commit_per_vblank modes) related to tdm_commit;
+	 * this functionality can be turned off which means a default mode */
+	mode = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, 0);
+	if (mode > 0) {
+		tdm_private_module *b = NULL;
+		tdm_private_output *o = NULL;
+
+		/* outputs which support hwc capability can work only
+		 * if commit_per_vblank mode is '0' (default mode) */
+		LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
+			LIST_FOR_EACH_ENTRY(o, &b->output_list, link) {
+				if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC))
+					tdm_output_choose_commit_per_vblank_mode(o, mode);
+			}
+		}
+	}
+
 	if (error)
 		*error = TDM_ERROR_NONE;
 
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, tdm_display_find_stamp);
+
 	_pthread_mutex_unlock(&private_display->lock);
-	_pthread_mutex_unlock(&gLock);
+	pthread_mutex_unlock(&gLock);
+
+	TDM_INIT_INFO("init time: %.3f ms", (tdm_helper_get_time() - start) * 1000.0);
 
 	return (tdm_display *)private_display;
 
+/* LCOV_EXCL_START */
 failed_update:
-	_tdm_display_unload_module(private_display);
+	_tdm_display_unload_modules(private_display);
 failed_load:
+	tdm_vblank_deinit(private_display);
+failed_vblank:
+	tdm_event_loop_stop(private_display);
 	tdm_event_loop_deinit(private_display);
 failed_event:
 	_pthread_mutex_unlock(&private_display->lock);
@@ -924,8 +1319,9 @@ failed_mutex_init:
 failed_alloc:
 	if (error)
 		*error = ret;
-	_pthread_mutex_unlock(&gLock);
+	pthread_mutex_unlock(&gLock);
 	return NULL;
+/* LCOV_EXCL_STOP */
 }
 
 EXTERN void
@@ -936,11 +1332,11 @@ tdm_display_deinit(tdm_display *dpy)
 	if (!private_display)
 		return;
 
-	_pthread_mutex_lock(&gLock);
+	pthread_mutex_lock(&gLock);
 
 	private_display->init_count--;
 	if (private_display->init_count > 0) {
-		_pthread_mutex_unlock(&gLock);
+		pthread_mutex_unlock(&gLock);
 		return;
 	}
 
@@ -949,18 +1345,26 @@ tdm_display_deinit(tdm_display *dpy)
 	 * things because it's finalized.
 	 */
 	_pthread_mutex_lock(&private_display->lock);
-	tdm_event_loop_deinit(private_display);
+	tdm_event_loop_stop(private_display);
 	_pthread_mutex_unlock(&private_display->lock);
 
+	tdm_event_loop_deinit(private_display);
+
+	/* when private_output is destroyed, all vblank resources of client and server
+	 * are destroyed. Then we can call tdm_vblank_deinit. After destroying display,
+	 * we can unload backend modulues.
+	 */
 	_tdm_display_destroy_private_display(private_display);
-	_tdm_display_unload_module(private_display);
+	_tdm_display_unload_modules(private_display);
+
+	tdm_vblank_deinit(private_display);
 
 #ifdef INIT_BUFMGR
 	if (private_display->bufmgr)
 		tbm_bufmgr_deinit(private_display->bufmgr);
 #endif
 
-	tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1);
+	tbm_drm_helper_unset_tbm_master_fd();
 
 	pthread_mutex_destroy(&private_display->lock);
 	free(private_display);
@@ -971,180 +1375,16 @@ tdm_display_deinit(tdm_display *dpy)
 		tdm_debug_dump_dir = NULL;
 	}
 
-	_pthread_mutex_unlock(&gLock);
-
-	TDM_INFO("done");
-}
-
-INTERN int
-tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin)
-{
-	tdm_backend_module *module = private_display->module_data;
-
-	if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
-		return 0;
-
-	if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
-		return 0;
-
-	return 1;
-}
-
-INTERN tdm_error
-tdm_display_enable_debug_module(const char*modules)
-{
-	char temp[TDM_PATH_LEN];
-	char *arg;
-	char *end;
+	tdm_config_deinit();
 
-	snprintf(temp, TDM_PATH_LEN, "%s", modules);
+	pthread_mutex_unlock(&gLock);
 
-	tdm_debug_module = 0;
-
-	arg = strtok_r(temp, TDM_DELIM, &end);
-	while (arg) {
-		if (!strncmp(arg, "none", 4)) {
-			tdm_debug_module = 0;
-			return TDM_ERROR_NONE;
-		}
-		if (!strncmp(arg, "all", 3)) {
-			tdm_debug_module = 0xFFFFFFFF;
-			return TDM_ERROR_NONE;
-		}
-		if (!strncmp(arg, "buffer", 6))
-			tdm_debug_module |= TDM_DEBUG_BUFFER;
-		else if (!strncmp(arg, "thread", 6))
-			tdm_debug_module |= TDM_DEBUG_THREAD;
-		else if (!strncmp(arg, "mutex", 5))
-			tdm_debug_module |= TDM_DEBUG_MUTEX;
-		else if (!strncmp(arg, "vblank", 6))
-			tdm_debug_module |= TDM_DEBUG_VBLANK;
-		else
-			return TDM_ERROR_BAD_REQUEST;
-
-		arg = strtok_r(NULL, TDM_DELIM, &end);
-	}
-
-	TDM_INFO("module debugging... '%s'", modules);
-
-	return TDM_ERROR_NONE;
+	TDM_INFO("done");
 }
 
-INTERN tdm_error
-tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
+INTERN tdm_private_display *
+tdm_display_get(void)
 {
-	char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
-	char *path, *path2;
-	char *arg;
-	char *end;
-
-	snprintf(temp2, TDM_PATH_LEN, "%s", dump_str);
-	path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@");
-	if (!path2 || path2[0] == '\0')
-		path2 = TDM_DUMP_DIR;
-	else
-		path2++;
-
-	path = tdm_helper_dump_make_directory(path2, reply, len);
-	TDM_GOTO_IF_FAIL(path != NULL, done);
-
-	tdm_debug_dump = 0;
-
-	snprintf(temp, sizeof(temp), "%s", dump_str);
-	arg = strtok_r(temp, ",", &end);
-	TDM_GOTO_IF_FAIL(arg != NULL, done);
-
-	if (!strncmp(arg, "none", 4)) {
-		tdm_debug_dump = 0;
-		if (tdm_debug_dump_dir) {
-			free(tdm_debug_dump_dir);
-			tdm_debug_dump_dir = NULL;
-		}
-		TDM_SNPRINTF(reply, len, "path: %s\n", path);
-		goto done;
-	}
-
-	if (!strncmp(arg, "current", 7)) {
-		tdm_private_output *o = NULL;
-		if (!private_display) {
-			TDM_WRN("no private_display");
-			goto done;
-		}
-
-		LIST_FOR_EACH_ENTRY(o, &private_display->output_list, link) {
-			tdm_private_layer *l = NULL;
-			LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
-				char str[TDM_PATH_LEN];
-				if (l->usable)
-					continue;
-				snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
-				tdm_helper_dump_buffer_str(l->showing_buffer, path, str);
-			}
-		}
-
-		TDM_SNPRINTF(reply, len, "path: %s\n", path);
-		goto done;
-	}
-
-	TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
-
-	while (arg) {
-		if (!strncmp(arg, "all", 3)) {
-			tdm_debug_dump = 0xFFFFFFFF;
-			goto done;
-		} else if (!strncmp(arg, "layer", 5)) {
-			tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
-		} else if (!strncmp(arg, "pp", 2)) {
-			tdm_debug_dump |= TDM_DUMP_FLAG_PP;
-		} else if (!strncmp(arg, "capture", 7)) {
-			tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
-		} else
-			goto done;
-
-		arg = strtok_r(NULL, ",", &end);
-	}
-
-	if (tdm_debug_dump_dir)
-		free(tdm_debug_dump_dir);
-
-	tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
-
-	TDM_INFO("dump... '%s'", dump_str);
-
-done:
-	free(path);
-	return TDM_ERROR_NONE;
+	return g_private_display;
 }
 
-INTERN tdm_error
-tdm_display_enable_path(const char *path)
-{
-	static int old_stdout = -1;
-	char fd_name[TDM_PATH_LEN];
-	int  log_fd = -1;
-	FILE *log_fl;
-
-	if (old_stdout == -1)
-		old_stdout = dup(STDOUT_FILENO);
-
-	tdm_log_enable_dlog(0);
-
-	snprintf(fd_name, TDM_PATH_LEN, "%s", path);
-
-	log_fl = fopen(fd_name, "a");
-	if (!log_fl) {
-		TDM_ERR("failed: open file(%s)\n", fd_name);
-		return TDM_ERROR_OPERATION_FAILED;
-	}
-
-	fflush(stderr);
-	close(STDOUT_FILENO);
-
-	setvbuf(log_fl, NULL, _IOLBF, 512);
-	log_fd = fileno(log_fl);
-
-	dup2(log_fd, STDOUT_FILENO);
-	fclose(log_fl);
-
-	return TDM_ERROR_NONE;
-}