X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_display.c;h=814e60c8c836360002ab64d000837c17e0e1bb4d;hb=1b7ce67e473517578e9c78b4afe05fb0bf2a8361;hp=83fbec3f81cf57f0c1ec6b235f5154622f408813;hpb=e77e3b05eea42d515618712dfc8cdc1d8569fc3f;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_display.c b/src/tdm_display.c
index 83fbec3..814e60c 100644
--- a/src/tdm_display.c
+++ b/src/tdm_display.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
@@ -45,27 +45,445 @@
 	tdm_private_display *private_display; \
 	tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
 	TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
-	TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER); \
 	private_display = (tdm_private_display*)dpy;
 
 #define DISPLAY_FUNC_ENTRY_ERROR() \
 	tdm_private_display *private_display; \
 	tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
 	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
-	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER, NULL); \
 	private_display = (tdm_private_display*)dpy;
 
+#define BACKEND_FUNC_ENTRY() \
+	tdm_private_module *private_module; \
+	tdm_private_display *private_display; \
+	tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
+	TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
+	private_module = (tdm_private_module*)module; \
+	private_display = private_module->private_display;
+
+/* LCOV_EXCL_START */
+INTERN tdm_error
+tdm_display_enable_debug_module(const char*modules)
+{
+	char temp[TDM_PATH_LEN];
+	char *arg;
+	char *end;
+
+	snprintf(temp, TDM_PATH_LEN, "%s", modules);
+
+	tdm_debug_module = 0;
+
+	arg = strtok_r(temp, TDM_CONFIG_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, "event", 5))
+			tdm_debug_module |= TDM_DEBUG_EVENT;
+		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 if (!strncmp(arg, "commit", 6))
+			tdm_debug_module |= TDM_DEBUG_COMMIT;
+
+		arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
+	}
+
+	TDM_INFO("module debugging... '%s'", modules);
+
+	return TDM_ERROR_NONE;
+}
+
+INTERN tdm_error
+tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
+{
+	char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
+	char *path = NULL, *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++;
+
+	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;
+		TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown");
+		if (tdm_debug_dump_dir) {
+			free(tdm_debug_dump_dir);
+			tdm_debug_dump_dir = NULL;
+		}
+		goto done;
+	}
+
+	path = tdm_helper_dump_make_directory(path2, reply, len);
+	TDM_GOTO_IF_FAIL(path != NULL, done);
+
+	if (!strncmp(arg, "current", 7)) {
+		tdm_private_module *b = NULL;
+		tdm_private_output *o = NULL;
+
+		if (!private_display) {
+			TDM_WRN("no private_display");
+			goto done;
+		}
+
+		LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
+			LIST_FOR_EACH_ENTRY(o, &b->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 || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
+						continue;
+					if (!l->showing_buffer)
+						continue;
+					snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
+					tdm_helper_dump_buffer_str(l->showing_buffer->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 if (!strncmp(arg, "window", 6)) {
+			tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW;
+		} 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:
+	if (path)
+		free(path);
+
+	return TDM_ERROR_NONE;
+}
+
+static void
+_tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
+							  unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+	tdm_error ret = TDM_ERROR_NONE;
+
+	TDM_TRACE_MARK("VSYNC");
+
+	ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
+	TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
+INTERN tdm_error
+tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
+{
+	tdm_private_display *private_display = dpy;
+	tdm_private_module *private_module = NULL;
+	tdm_private_output *private_output = NULL;
+	const tdm_output_mode *mode = NULL;
+	tdm_vblank *vblank = NULL;
+	tdm_error ret = TDM_ERROR_NONE;
+
+	if (!enable) {
+		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->ttrace_vblank)
+					tdm_vblank_destroy(private_output->ttrace_vblank);
+				private_output->ttrace_vblank = NULL;
+			}
+		}
+		return TDM_ERROR_NONE;
+	}
+
+	private_output = output;
+	TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	if (private_output->ttrace_vblank)
+		return TDM_ERROR_NONE;
+
+	vblank = tdm_vblank_create(private_display, output, &ret);
+	TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
+
+	ret = tdm_output_get_mode(output, &mode);
+	TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
+
+	ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
+	TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+	ret = tdm_vblank_set_enable_fake(vblank, 1);
+	TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+	ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
+	TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
+
+	private_output->ttrace_vblank = vblank;
+
+	return TDM_ERROR_NONE;
+
+enable_fail:
+	if (vblank)
+		tdm_vblank_destroy(vblank);
+
+	return ret;
+}
+
+INTERN tdm_error
+tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
+{
+	char temp[TDM_PATH_LEN];
+	char *arg;
+	char *end;
+	tdm_output *output;
+	tdm_error ret;
+	tdm_output_type type;
+
+	snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
+
+	tdm_ttrace_output = output_id;
+	tdm_ttrace_module = 0;
+
+	output = tdm_display_get_output(private_display, output_id, &ret);
+	if (!output) {
+		TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
+		return ret;
+	}
+
+	ret = tdm_output_get_output_type(output, &type);
+	if (ret != TDM_ERROR_NONE) {
+		TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
+		return ret;
+	}
+
+	arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
+	while (arg) {
+		if (!strncmp(arg, "none", 4))
+			tdm_ttrace_module = 0;
+		else if (!strncmp(arg, "all", 3))
+			tdm_ttrace_module = 0xFFFFFFFF;
+		else if (!strncmp(arg, "vsync", 5))
+			tdm_ttrace_module |= TDM_TTRACE_VSYNC;
+		else if (!strncmp(arg, "client_vblank", 13))
+			tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK;
+		else if (!strncmp(arg, "server_vblank", 13))
+			tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK;
+		else if (!strncmp(arg, "vblank", 6))
+			tdm_ttrace_module |= TDM_TTRACE_VBLANK;
+		else if (!strncmp(arg, "layer", 5))
+			tdm_ttrace_module |= TDM_TTRACE_LAYER;
+		else if (!strncmp(arg, "pp", 2))
+			tdm_ttrace_module |= TDM_TTRACE_PP;
+		else if (!strncmp(arg, "capture", 7))
+			tdm_ttrace_module |= TDM_TTRACE_CAPTURE;
+		else  {
+			tdm_ttrace_module = 0;
+			tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
+			tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
+			TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg);
+			return TDM_ERROR_NONE;
+		}
+
+		arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
+	}
+
+	TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
+
+	if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
+		tdm_display_enable_ttrace_vblank(private_display, output, 1);
+	else
+		tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
+
+	if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
+		tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
+	else
+		tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
+
+	return TDM_ERROR_NONE;
+}
+
+INTERN tdm_error
+tdm_display_enable_fps(tdm_private_display *private_display, int enable)
+{
+	private_display->print_fps = enable;
+
+	TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
+
+	return TDM_ERROR_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+INTERN tdm_error
+tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
+{
+	tdm_thread_cb_display_output_create output_create;
+	tdm_error ret;
+
+	if (LIST_IS_EMPTY(&private_display->output_create_handler_list)) return TDM_ERROR_NONE;
+
+	memset(&output_create, 0, sizeof output_create);
+	output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
+	output_create.base.length = sizeof output_create;
+	output_create.base.object_stamp = tdm_helper_get_time();
+	output_create.base.data = NULL;
+	output_create.base.sync = 1;
+	output_create.output = output;
+
+	ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+	return TDM_ERROR_NONE;
+}
+
+INTERN void
+tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
+{
+	tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
+	tdm_private_output_create_handler *create_handler = user_data;
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+	assert(create_handler->owner_tid == syscall(SYS_gettid));
+
+	_pthread_mutex_unlock(&private_display->lock);
+	create_handler->func(private_display, output_create->output, create_handler->user_data);
+	_pthread_mutex_lock(&private_display->lock);
+}
+
+EXTERN tdm_error
+tdm_display_add_output_create_handler(tdm_display *dpy,
+									  tdm_output_create_handler func,
+									  void *user_data)
+{
+	tdm_private_output_create_handler *create_handler = NULL;
+
+	DISPLAY_FUNC_ENTRY();
+
+	TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
+		if (create_handler->func == func && create_handler->user_data == user_data) {
+			TDM_ERR("can't add twice");
+			_pthread_mutex_unlock(&private_display->lock);
+			return TDM_ERROR_BAD_REQUEST;
+		}
+	}
+
+	create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
+	if (!create_handler) {
+		TDM_ERR("failed: alloc memory");
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OUT_OF_MEMORY;
+	}
+
+	ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+							tdm_display_thread_cb_output_create, create_handler);
+	if (ret != TDM_ERROR_NONE) {
+		TDM_ERR("tdm_thread_cb_add failed");
+		free(create_handler);
+		_pthread_mutex_unlock(&private_display->lock);
+		return TDM_ERROR_OPERATION_FAILED;
+	}
+
+	create_handler->private_display = private_display;
+	create_handler->func = func;
+	create_handler->user_data = user_data;
+	create_handler->owner_tid = syscall(SYS_gettid);
+
+	LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+EXTERN void
+tdm_display_remove_output_create_handler(tdm_display *dpy,
+										 tdm_output_create_handler func,
+										 void *user_data)
+{
+	tdm_private_display *private_display;
+	tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
+
+	TDM_RETURN_IF_FAIL(dpy != NULL);
+	TDM_RETURN_IF_FAIL(func != NULL);
+
+	private_display = (tdm_private_display*)dpy;
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
+		if (create_handler->func != func || create_handler->user_data != user_data)
+			continue;
+
+		tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
+							 tdm_display_thread_cb_output_create, create_handler);
+
+		LIST_DEL(&create_handler->link);
+		free(create_handler);
+
+		_pthread_mutex_unlock(&private_display->lock);
+
+		return;
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
+}
+
 EXTERN tdm_error
 tdm_display_get_capabilities(tdm_display *dpy,
 							 tdm_display_capability *capabilities)
 {
+	tdm_private_module *private_module = NULL;
+
 	DISPLAY_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	*capabilities = private_display->capabilities;
+	*capabilities = 0;
+
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		*capabilities |= private_module->capabilities;
+	}
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -76,13 +494,15 @@ EXTERN tdm_error
 tdm_display_get_pp_capabilities(tdm_display *dpy,
 								tdm_pp_capability *capabilities)
 {
+	tdm_private_module *pp_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+	if (!private_display->pp_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no pp capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -90,7 +510,9 @@ tdm_display_get_pp_capabilities(tdm_display *dpy,
 		/* LCOV_EXCL_STOP */
 	}
 
-	*capabilities = private_display->caps_pp.capabilities;
+	pp_module = private_display->pp_module;
+
+	*capabilities = pp_module->caps_pp.capabilities;
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -101,6 +523,8 @@ EXTERN tdm_error
 tdm_display_get_pp_available_formats(tdm_display *dpy,
 									 const tbm_format **formats, int *count)
 {
+	tdm_private_module *pp_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
@@ -108,7 +532,7 @@ tdm_display_get_pp_available_formats(tdm_display *dpy,
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+	if (!private_display->pp_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no pp capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -116,8 +540,10 @@ tdm_display_get_pp_available_formats(tdm_display *dpy,
 		/* LCOV_EXCL_STOP */
 	}
 
-	*formats = (const tbm_format *)private_display->caps_pp.formats;
-	*count = private_display->caps_pp.format_count;
+	pp_module = private_display->pp_module;
+
+	*formats = (const tbm_format *)pp_module->caps_pp.formats;
+	*count = pp_module->caps_pp.format_count;
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -128,11 +554,13 @@ EXTERN tdm_error
 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 								  int *max_w, int *max_h, int *preferred_align)
 {
+	tdm_private_module *pp_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
+	if (!private_display->pp_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no pp capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -140,16 +568,18 @@ tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 		/* LCOV_EXCL_STOP */
 	}
 
+	pp_module = private_display->pp_module;
+
 	if (min_w)
-		*min_w = TDM_FRONT_VALUE(private_display->caps_pp.min_w);
+		*min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
 	if (min_h)
-		*min_h = TDM_FRONT_VALUE(private_display->caps_pp.min_h);
+		*min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
 	if (max_w)
-		*max_w = TDM_FRONT_VALUE(private_display->caps_pp.max_w);
+		*max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
 	if (max_h)
-		*max_h = TDM_FRONT_VALUE(private_display->caps_pp.max_h);
+		*max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
 	if (preferred_align)
-		*preferred_align = TDM_FRONT_VALUE(private_display->caps_pp.preferred_align);
+		*preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -160,13 +590,15 @@ EXTERN tdm_error
 tdm_display_get_capture_capabilities(tdm_display *dpy,
 									 tdm_capture_capability *capabilities)
 {
+	tdm_private_module *capture_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+	if (!private_display->capture_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no capture capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -174,7 +606,9 @@ tdm_display_get_capture_capabilities(tdm_display *dpy,
 		/* LCOV_EXCL_STOP */
 	}
 
-	*capabilities = private_display->caps_capture.capabilities;
+	capture_module = private_display->capture_module;
+
+	*capabilities = capture_module->caps_capture.capabilities;
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -182,9 +616,11 @@ tdm_display_get_capture_capabilities(tdm_display *dpy,
 }
 
 EXTERN tdm_error
-tdm_display_get_catpure_available_formats(tdm_display *dpy,
+tdm_display_get_capture_available_formats(tdm_display *dpy,
 		const tbm_format **formats, int *count)
 {
+	tdm_private_module *capture_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
@@ -192,7 +628,7 @@ tdm_display_get_catpure_available_formats(tdm_display *dpy,
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+	if (!private_display->capture_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no capture capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -200,8 +636,10 @@ tdm_display_get_catpure_available_formats(tdm_display *dpy,
 		/* LCOV_EXCL_STOP */
 	}
 
-	*formats = (const tbm_format *)private_display->caps_capture.formats;
-	*count = private_display->caps_capture.format_count;
+	capture_module = private_display->capture_module;
+
+	*formats = (const tbm_format *)capture_module->caps_capture.formats;
+	*count = capture_module->caps_capture.format_count;
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -212,11 +650,13 @@ EXTERN tdm_error
 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 									   int *max_w, int *max_h, int *preferred_align)
 {
+	tdm_private_module *capture_module;
+
 	DISPLAY_FUNC_ENTRY();
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) {
+	if (!private_display->capture_module) {
 		/* LCOV_EXCL_START */
 		TDM_ERR("no capture capability");
 		_pthread_mutex_unlock(&private_display->lock);
@@ -224,16 +664,18 @@ tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 		/* LCOV_EXCL_STOP */
 	}
 
+	capture_module = private_display->capture_module;
+
 	if (min_w)
-		*min_w = TDM_FRONT_VALUE(private_display->caps_capture.min_w);
+		*min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
 	if (min_h)
-		*min_h = TDM_FRONT_VALUE(private_display->caps_capture.min_h);
+		*min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
 	if (max_w)
-		*max_w = TDM_FRONT_VALUE(private_display->caps_capture.max_w);
+		*max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
 	if (max_h)
-		*max_h = TDM_FRONT_VALUE(private_display->caps_capture.max_h);
+		*max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
 	if (preferred_align)
-		*preferred_align = TDM_FRONT_VALUE(private_display->caps_capture.preferred_align);
+		*preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
@@ -243,22 +685,20 @@ tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 EXTERN tdm_error
 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
 {
-	DISPLAY_FUNC_ENTRY();
-
+	TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 	TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-	_pthread_mutex_lock(&private_display->lock);
+	TDM_DEPRECATED(NULL);
 
-	*max_count = TDM_FRONT_VALUE(private_display->caps_display.max_layer_count);
+	*max_count = -1;
 
-	_pthread_mutex_unlock(&private_display->lock);
-
-	return ret;
+	return TDM_ERROR_NONE;
 }
 
 EXTERN tdm_error
 tdm_display_get_output_count(tdm_display *dpy, int *count)
 {
+	tdm_private_module *private_module = NULL;
 	tdm_private_output *private_output = NULL;
 
 	DISPLAY_FUNC_ENTRY();
@@ -268,14 +708,10 @@ tdm_display_get_output_count(tdm_display *dpy, int *count)
 	_pthread_mutex_lock(&private_display->lock);
 
 	*count = 0;
-	LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link)
-	(*count)++;
-
-	if (*count == 0) {
-		/* LCOV_EXCL_START */
-		_pthread_mutex_unlock(&private_display->lock);
-		return TDM_ERROR_NONE;
-		/* LCOV_EXCL_STOP */
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			(*count)++;
+		}
 	}
 
 	_pthread_mutex_unlock(&private_display->lock);
@@ -287,22 +723,97 @@ tdm_display_get_output_count(tdm_display *dpy, int *count)
 EXTERN tdm_output *
 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 {
+	tdm_private_module *private_module = NULL;
+	tdm_private_output *private_output = NULL;
+
+	DISPLAY_FUNC_ENTRY_ERROR();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (error)
+		*error = TDM_ERROR_NONE;
+
+	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->index == index) {
+				_pthread_mutex_unlock(&private_display->lock);
+				return private_output;
+			}
+		}
+	}
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return NULL;
+}
+
+EXTERN tdm_output *
+tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
+{
+	tdm_private_module *private_module = NULL;
 	tdm_private_output *private_output = NULL;
+	tdm_private_output *mode_setted_output = NULL;
+	tdm_private_output *connected_output = NULL;
+	unsigned int find_primary = 0;
 
 	DISPLAY_FUNC_ENTRY_ERROR();
 
+	if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
+		find_primary = 1;
+
 	_pthread_mutex_lock(&private_display->lock);
 
 	if (error)
 		*error = TDM_ERROR_NONE;
 
-	LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) {
-		if (private_output->index == index) {
+	if (find_primary) {
+		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->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
+					connected_output = private_output;
+				else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
+					mode_setted_output = private_output;
+			}
+		}
+
+		if (mode_setted_output) {
+			_pthread_mutex_unlock(&private_display->lock);
+			return mode_setted_output;
+		}
+
+		if (connected_output) {
+			_pthread_mutex_unlock(&private_display->lock);
+			return connected_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->index == 0) {
+					_pthread_mutex_unlock(&private_display->lock);
+					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 (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
+				continue;
 			_pthread_mutex_unlock(&private_display->lock);
 			return private_output;
 		}
 	}
 
+	if (private_display->virtual_module) {
+		private_module = private_display->virtual_module;
+		LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+			if (strncmp(private_output->name, name, TDM_NAME_LEN))
+				continue;
+			_pthread_mutex_unlock(&private_display->lock);
+			return private_output;
+		}
+	}
 	_pthread_mutex_unlock(&private_display->lock);
 
 	return NULL;
@@ -342,7 +853,7 @@ tdm_display_handle_events(tdm_display *dpy)
 	fds.fd = fd;
 	fds.revents = 0;
 
-	if (tdm_debug_module & TDM_DEBUG_THREAD)
+	if (tdm_debug_module & TDM_DEBUG_EVENT)
 		TDM_INFO("fd(%d) polling in", fd);
 
 	while (poll(&fds, 1, -1) < 0) {
@@ -356,28 +867,54 @@ tdm_display_handle_events(tdm_display *dpy)
 		/* LCOV_EXCL_STOP */
 	}
 
-	if (tdm_debug_module & TDM_DEBUG_THREAD)
+	if (tdm_debug_module & TDM_DEBUG_EVENT)
 		TDM_INFO("fd(%d) polling out", fd);
 
-	if (tdm_thread_is_running())
+	if (tdm_thread_is_running()) {
+		_pthread_mutex_lock(&private_display->lock);
 		ret = tdm_thread_handle_cb(private_display->private_loop);
-	else
+		_pthread_mutex_unlock(&private_display->lock);
+	} else {
 		ret = tdm_event_loop_dispatch(private_display);
+	}
 
 	return ret;
 }
 
+EXTERN void
+tdm_display_flush(tdm_display *dpy)
+{
+	tdm_private_display *private_display;
+
+	TDM_RETURN_IF_FAIL(dpy != NULL);
+	private_display = (tdm_private_display*)dpy;
+
+	if (tdm_thread_is_running())
+		return;
+
+	tdm_event_loop_flush(private_display);
+}
+
 EXTERN tdm_error
 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 							 const char **vendor, int *major, int *minor)
 {
-	tdm_backend_module *module_data;
+	tdm_private_module *private_module = NULL;
+	tdm_backend_module *module_data = NULL;
 
 	DISPLAY_FUNC_ENTRY();
 
+	TDM_DEPRECATED("Use tdm_module_get_info");
+
 	_pthread_mutex_lock(&private_display->lock);
 
-	module_data = private_display->module_data;
+	/* use first backend */
+	LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
+		module_data = private_module->module_data;
+		break;
+	}
+
+	assert(module_data != NULL);
 
 	if (name)
 		*name = module_data->name;
@@ -402,9 +939,168 @@ tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 
 	_pthread_mutex_lock(&private_display->lock);
 
-	pp = (tdm_pp *)tdm_pp_create_internal(private_display, error);
+	pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
 
 	_pthread_mutex_unlock(&private_display->lock);
 
 	return pp;
 }
+
+EXTERN tdm_error
+tdm_module_get_info(tdm_module *module, const char **name,
+					const char **vendor, int *major, int *minor)
+{
+	tdm_backend_module *module_data;
+
+	BACKEND_FUNC_ENTRY();
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	module_data = private_module->module_data;
+
+	if (name)
+		*name = module_data->name;
+	if (vendor)
+		*vendor = module_data->vendor;
+	if (major)
+		*major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
+	if (minor)
+		*minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return ret;
+}
+
+INTERN int
+tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
+{
+	tdm_backend_module *module = private_module->module_data;
+
+	if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
+		return 1;
+
+	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_voutput *
+tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
+{
+	tdm_private_module *private_module = NULL;
+	tdm_private_module *current_module = NULL;
+	tdm_private_voutput *private_voutput = NULL;
+	tdm_private_output *private_output = NULL;
+	tdm_func_display *func_display = NULL;
+	tdm_func_voutput *func_voutput = NULL;
+	tdm_voutput *voutput_backend = NULL;
+	tdm_output *output_backend = NULL;
+	int output_find = 0;
+	tdm_private_display *private_display;
+	tdm_error ret = TDM_ERROR_NONE;
+
+	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
+	private_display = (tdm_private_display*)dpy;
+	private_module = private_display->virtual_module;
+	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
+
+	_pthread_mutex_lock(&private_display->lock);
+
+	if (error) *error = TDM_ERROR_NONE;
+
+	private_voutput = calloc(1, sizeof(tdm_private_voutput));
+	if (!private_voutput) {
+		if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
+		_pthread_mutex_unlock(&private_display->lock);
+		return NULL;
+	}
+
+	func_display = &private_module->func_display;
+	func_voutput = &private_module->func_voutput;
+	current_module = private_display->current_module;
+	private_display->current_module = private_module;
+
+	voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
+
+	if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
+		TDM_ERR("display_voutput_create fail");
+		free(private_voutput);
+		if (error) *error = ret;
+		private_display->current_module = current_module;
+		_pthread_mutex_unlock(&private_display->lock);
+		return NULL;
+	}
+	private_voutput->voutput_backend = voutput_backend;
+	private_voutput->private_display = private_display;
+	private_voutput->private_module = private_module;
+	LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
+
+	output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
+	if (output_backend == NULL || ret != TDM_ERROR_NONE) {
+		TDM_ERR("voutput_get_output fail");
+		free(private_voutput);
+		if (error) *error = ret;
+		if (func_voutput->voutput_destroy)
+			func_voutput->voutput_destroy(voutput_backend);
+		else
+			TDM_ERR("no destroy function");
+		private_display->current_module = current_module;
+		_pthread_mutex_unlock(&private_display->lock);
+		return NULL;
+	}
+
+	ret = tdm_display_update_output(private_display->current_module, output_backend);
+	if (ret != TDM_ERROR_NONE) {
+		TDM_ERR("tdm_display_update_output fail");
+		free(private_voutput);
+		if (func_voutput->voutput_destroy)
+			func_voutput->voutput_destroy(voutput_backend);
+		else
+			TDM_ERR("no destroy function");
+		if (error) *error = ret;
+		private_display->current_module = current_module;
+		_pthread_mutex_unlock(&private_display->lock);
+		return NULL;
+	}
+
+	LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
+		if (private_output->output_backend == output_backend) {
+			output_find = 1;
+			break;
+		}
+	}
+
+	if (output_find != 1) {
+		private_output = NULL;
+		free(private_voutput);
+		if (func_voutput->voutput_destroy)
+			func_voutput->voutput_destroy(voutput_backend);
+		else
+			TDM_ERR("no destroy function");
+		private_voutput = NULL;
+	} else {
+		strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
+		private_voutput->name[TDM_NAME_LEN - 1] = '\0';
+		strncpy(private_output->name, name, TDM_NAME_LEN - 1);
+		private_output->name[TDM_NAME_LEN - 1] = '\0';
+
+		private_voutput->private_output = private_output;
+		private_output->private_voutput = private_voutput;
+
+		/* do not use vblank */
+		tdm_output_choose_commit_per_vblank_mode(private_output, 0);
+
+		LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
+	}
+
+	private_display->current_module = current_module;
+
+	_pthread_mutex_unlock(&private_display->lock);
+
+	return private_voutput;
+}