X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm_vblank.c;h=568605a365ec76a4f0e4d9f0e51327ec2541eaca;hb=0613d5ca5f9a733c596b7b61d02ebd08c19a87ed;hp=4af896ff122479270261ce315bcfbc02e9cfbc20;hpb=bac98a645dc507a923680978ff6b45bb0efa0726;p=platform%2Fcore%2Fuifw%2Flibtdm.git

diff --git a/src/tdm_vblank.c b/src/tdm_vblank.c
index 4af896f..568605a 100644
--- a/src/tdm_vblank.c
+++ b/src/tdm_vblank.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,16 +37,14 @@
 #include "config.h"
 #endif
 
-#include "tdm.h"
 #include "tdm_private.h"
-#include "tdm_list.h"
 
 /* CAUTION:
- * - tdm vblank doesn't care about thread things.
- * - DO NOT use the TDM internal functions here.
- *     However, the internal function which does lock/unlock the mutex of
- *     private_display in itself can be called.
- * - DO NOT use the tdm_private_display structure here.
+ * Basically tdm vblank doesn't care about thread things.
+ * However, to use tdm_event_loop_xxx functions, have to use the internal function.
+ * So need to lock/unlock the mutex of private_display. And valid_vblank_list and
+ * valid_wait_list should be protected by valid_list_lock because tdm_vblank can
+ * be used in multi-thread.
  */
 
 /* TDM vblank
@@ -54,108 +52,225 @@
  * - use a tdm_event_loop_source object only.
  */
 
-#define VER(fmt,arg...)   TDM_ERR("[%p] "fmt, private_vblank, ##arg)
-#define VWR(fmt,arg...)   TDM_WRN("[%p] "fmt, private_vblank, ##arg)
-#define VIN(fmt,arg...)   TDM_INFO("[%p] "fmt, private_vblank, ##arg)
-#define VDB(fmt,arg...)   TDM_DBG("[%p] "fmt, private_vblank, ##arg)
+#define TDM_VBLANK_DEFAULT_VREFRESH    30
+
+/* We expact "(unsigned int)(0.0016667 / 0.0016667) = 1". But it becomes 0. */
+#define TDM_TIME_MARGIN     0.0000001
+
+#define TDM_VBLANK_UINT_MAX 4294967295U
+#define TDM_VBLANK_UINT_1Q  1073741823U     /* UINT_MAX / 4 */
+#define TDM_VBLANK_UINT_3Q  3221225471U     /* UINT_MAX / 4 * 3 */
+
+/* (seq < TDM_VBLANK_UINT_1Q && TDM_VBLANK_UINT_3Q < last_seq) means
+ * that the sequence value has reached the max value and started from 0 again.
+ */
+#define TDM_VBLANK_SEQ_REACHED_MAX(seq, last_seq) \
+	((seq) < TDM_VBLANK_UINT_1Q && TDM_VBLANK_UINT_3Q < (last_seq))
+
+#define VER(fmt, arg...)   TDM_ERR("[%p] "fmt, private_vblank, ##arg)
+#define VWR(fmt, arg...)   TDM_WRN("[%p] "fmt, private_vblank, ##arg)
+#define VIN(fmt, arg...)   do { if (tdm_debug_module & TDM_DEBUG_VBLANK) TDM_INFO("[%p] "fmt, private_vblank, ##arg); } while (0)
+#define VDB(fmt, arg...)   do { if (tdm_debug_module & TDM_DEBUG_VBLANK) TDM_DBG("[%p] "fmt, private_vblank, ##arg); } while (0)
+
+typedef enum {
+	VBLANK_TYPE_SW,
+	VBLANK_TYPE_SW_FAKE,
+	VBLANK_TYPE_HW,
+	VBLANK_TYPE_HW_SW,
+} tdm_vblank_wait_type;
+
+typedef enum {
+	VBLANK_EVENT_TYPE_NONE,
+	VBLANK_EVENT_TYPE_SW,
+	VBLANK_EVENT_TYPE_HW,
+} tdm_vblank_event_type;
 
 typedef struct _tdm_vblank_wait_info tdm_vblank_wait_info;
 
 typedef struct _tdm_private_vblank {
-	struct list_head link;
+	struct list_head valid_link;
+
+	double stamp;
+	pid_t owner_tid;
 
 	tdm_display *dpy;
 	tdm_output *output;
-	tdm_output_dpms dpms;
+	tdm_output_conn_status connection;
 	unsigned int vrefresh;
 
+	tdm_vblank_event_type last_type;
 	unsigned int check_HW_or_SW;
+	char name[TDM_NAME_LEN];
 	unsigned int fps;
+	unsigned int fps_changeable;
+	unsigned int fps_fixed;
 	int offset;
 	unsigned int enable_fake;
+	unsigned int ignore_global_fps;
+	unsigned int in_create_handler;
 
 	double vblank_gap;
+	unsigned int quotient;
+
+	int last_interval;
 	unsigned int last_seq;
-	unsigned int last_tv_sec;
-	unsigned int last_tv_usec;
+	double last_time;
+
+	unsigned int add_front;
+	struct wl_resource *resource;
 
 	/* for HW */
 	double HW_vblank_gap;
-	unsigned int HW_enable;
-	unsigned int HW_quotient;
 	struct list_head HW_wait_list;
 
 	/* for SW */
 	tdm_event_loop_source *SW_timer;
-	struct list_head SW_pending_wait_list;
 	struct list_head SW_wait_list;
-#if 0
-	tdm_vblank_wait_info *SW_align_wait;
-	double SW_align_offset;
-	unsigned int SW_align_sec;
-	unsigned int SW_align_usec;
-#endif
+
+	/* for timeout */
+	tdm_event_loop_source *timeout_timer;
 } tdm_private_vblank;
 
 struct _tdm_vblank_wait_info {
 	struct list_head link;
 	struct list_head valid_link;
 
-	unsigned int stamp;
+	double stamp;
 
-	unsigned int req_sec;
-	unsigned int req_usec;
+	double req_time;
 	unsigned int interval;
+	int hw_interval;
 
 	tdm_vblank_handler func;
 	void *user_data;
 	tdm_private_vblank *private_vblank;
 
-	/* target_sec can be 0 when last_tv_sec is 0 because we can't calculate
-	 * target_sec without last_tv_sec. So we have to call tdm_output_wait_vblank
-	 * to fill last_tv_sec at the first time.
-	 */
-	unsigned int target_sec;
-	unsigned int target_usec;
+	tdm_vblank_wait_type type;
+
+	double target_time;
 	unsigned int target_seq;
-	int target_hw_interval;
 };
 
-static struct list_head vblank_list;
+typedef struct _tdm_vblank_create_handler_info {
+	struct list_head link;
+
+	tdm_vblank_create_handler func;
+	void *user_data;
+} tdm_vblank_create_handler_info;
+
+/* valid_vblank_list, valid_wait_list and create_handler_list should be protected
+ * by valid_list_lock because tdm_vblank can be used in multi-thread.
+ */
+static pthread_mutex_t valid_list_lock = PTHREAD_MUTEX_INITIALIZER;
+static struct list_head valid_vblank_list;
 static struct list_head valid_wait_list;
+static struct list_head create_handler_list;
 static unsigned int vblank_list_inited;
-static unsigned int stamp = 0;
+static unsigned int vblank_global_fps;
+static double stamp = 0;
 
+static void _tdm_vblank_cb_vblank_SW(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data);
+static tdm_error _tdm_vblank_cb_timeout_SW(void *user_data);
 static tdm_error _tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info);
-#if 0
-static void _tdm_vblank_sw_timer_align(tdm_private_vblank *private_vblank);
-#endif
+static void _tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
+									 unsigned int tv_sec, unsigned int tv_usec,
+									 void *user_data);
+static void _tdm_vblank_timeout_timer_update(tdm_private_vblank *private_vblank, int ms_delay);
+static void _tdm_vblank_get_client_information(tdm_private_vblank *private_vblank,
+											   pid_t *pid, const char **name);
 
 #if 0
 static void
-_print_list(struct list_head *list)
+_print_list(tdm_private_vblank *private_vblank)
 {
 	tdm_vblank_wait_info *w = NULL;
+	int count = 0;
 
-	LIST_FOR_EACH_ENTRY(w, list, link) {
-		printf(" %d", w->interval);
+	LIST_FOR_EACH_ENTRY(w, &private_vblank->HW_wait_list, link) {
+		VIN("HW_wait(%p): type(%d) req_time(%.6f) target_time(%.6f) target_seq(%u)",
+			w, w->type, w->req_time, w->target_time, w->target_seq);
+		count++;
+	}
+
+	LIST_FOR_EACH_ENTRY(w, &private_vblank->SW_wait_list, link) {
+		VIN("SW_wait(%p): type(%d) req_time(%.6f) target_time(%.6f) target_seq(%u)",
+			w, w->type, w->req_time, w->target_time, w->target_seq);
+		count++;
 	}
-	printf("\n");
+
+	if (!count)
+		VIN("NO_wait");
 }
 #endif
 
+static int
+tdm_vblank_is_valid(tdm_vblank *vblank)
+{
+	tdm_private_vblank *v = NULL;
+
+	if (vblank && vblank_list_inited) {
+		pthread_mutex_lock(&valid_list_lock);
+		LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+			if (v == (tdm_private_vblank *)vblank) {
+				pthread_mutex_unlock(&valid_list_lock);
+				return 1;
+			}
+		}
+		pthread_mutex_unlock(&valid_list_lock);
+
+	}
+	return 0;
+}
+
+static void
+_tdm_vblank_valid_list_add(struct list_head *valid_link, struct list_head *valid_list)
+{
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_ADDTAIL(valid_link, valid_list);
+	pthread_mutex_unlock(&valid_list_lock);
+}
+
+static void
+_tdm_vblank_valid_list_del(struct list_head *valid_link)
+{
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_DEL(valid_link);
+	pthread_mutex_unlock(&valid_list_lock);
+}
+
+static inline void*
+_tdm_vblank_find_object(tdm_private_display *private_display, double vblank_stamp)
+{
+	tdm_private_vblank *v = NULL;
+
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+		if (v->stamp == vblank_stamp) {
+			pthread_mutex_unlock(&valid_list_lock);
+			return v;
+		}
+	}
+	pthread_mutex_unlock(&valid_list_lock);
+
+	return NULL;
+}
+
 static inline unsigned int
-_tdm_vblank_check_valid(tdm_vblank_wait_info *wait_info)
+_tdm_vblank_check_valid_wait(tdm_vblank_wait_info *wait_info)
 {
 	tdm_vblank_wait_info *w = NULL;
 
 	if (!wait_info)
 		return 0;
 
+	pthread_mutex_lock(&valid_list_lock);
 	LIST_FOR_EACH_ENTRY(w, &valid_wait_list, valid_link) {
-		if (w->stamp == wait_info->stamp)
+		if (w == wait_info) {
+			pthread_mutex_unlock(&valid_list_lock);
 			return 1;
+		}
 	}
+	pthread_mutex_unlock(&valid_list_lock);
 
 	return 0;
 }
@@ -188,18 +303,15 @@ _tdm_vblank_insert_wait(tdm_vblank_wait_info *wait_info, struct list_head *list)
 	}
 
 	LIST_FOR_EACH_ENTRY(w, list, link) {
-		/* If last_tv_sec == 0, we can't calculate target_sec. */
-		if (wait_info->target_sec == 0) {
-			if (w->interval <= wait_info->interval) {
+		if (wait_info->type == VBLANK_TYPE_SW) {
+			if (wait_info->target_time == 0)
+				TDM_NEVER_GET_HERE();
+			if (w->target_time <= wait_info->target_time) {
 				found = w;
 				continue;
 			}
 		} else {
-			if (w->target_sec < wait_info->target_sec) {
-				found = w;
-				continue;
-			}
-			if (w->target_sec == wait_info->target_sec && w->target_usec <= wait_info->target_usec) {
+			if (w->interval <= wait_info->interval) {
 				found = w;
 				continue;
 			}
@@ -217,10 +329,14 @@ _tdm_vblank_change_to_SW(tdm_private_vblank *private_vblank)
 {
 	tdm_vblank_wait_info *w = NULL, *ww = NULL;
 
-	VIN("Change to SW");
-
 	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->HW_wait_list, link) {
 		LIST_DEL(&w->link);
+
+		tdm_display_lock(private_vblank->dpy);
+		tdm_output_remove_vblank_handler_internal(private_vblank->output, _tdm_vblank_cb_vblank_HW, w);
+		tdm_display_unlock(private_vblank->dpy);
+
+		w->type = VBLANK_TYPE_SW_FAKE;
 		_tdm_vblank_wait_SW(w);
 	}
 }
@@ -230,9 +346,23 @@ _tdm_vblank_free_HW_wait(tdm_private_vblank *private_vblank, tdm_error error, un
 {
 	tdm_vblank_wait_info *w = NULL, *ww = NULL;
 
+	if (!LIST_IS_EMPTY(&private_vblank->HW_wait_list)) {
+		pid_t pid;
+		const char *proc_name;
+		_tdm_vblank_get_client_information(private_vblank, &pid, &proc_name);
+		VWR("TDM HW vblank destroyed forcely!! (pid: %u, name: %s)", pid, proc_name);
+	}
+
 	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->HW_wait_list, link) {
 		LIST_DEL(&w->link);
-		LIST_DEL(&w->valid_link);
+		_tdm_vblank_valid_list_del(&w->valid_link);
+
+		tdm_display_lock(private_vblank->dpy);
+		tdm_output_remove_vblank_handler_internal(private_vblank->output, _tdm_vblank_cb_vblank_HW, w);
+		tdm_display_unlock(private_vblank->dpy);
+
+		VDB("wait(%p) last(%.6f) sequence(%u) done (error:%d, call_cb:%u)",
+			w, (double)0.0, w->target_seq, error, call_cb);
 
 		if (call_cb && w->func)
 			w->func(private_vblank, error, 0, 0, 0, w->user_data);
@@ -242,368 +372,757 @@ _tdm_vblank_free_HW_wait(tdm_private_vblank *private_vblank, tdm_error error, un
 }
 
 static void
+_tdm_vblank_update_output_info(tdm_private_vblank *private_vblank)
+{
+	tdm_output *output = private_vblank->output;
+	tdm_output_conn_status connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
+	unsigned int vrefresh = TDM_VBLANK_DEFAULT_VREFRESH;
+	const tdm_output_mode *mode = NULL;
+	tdm_error ret;
+
+	ret = tdm_output_get_conn_status(output, &connection);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+
+	ret = tdm_output_get_mode(output, &mode);
+	if (ret == TDM_ERROR_NONE && mode)
+		vrefresh = mode->vrefresh;
+	else
+		VWR("mode not setted!!!");
+
+	private_vblank->connection = connection;
+	private_vblank->vrefresh = vrefresh;
+	private_vblank->HW_vblank_gap = 1.0 / private_vblank->vrefresh;
+
+	if (private_vblank->fps_changeable)
+		private_vblank->fps = vrefresh;
+
+	VIN("connection(%d) vrefresh(%d) fps(%d) fps_changeable(%d)",
+		private_vblank->connection,
+		private_vblank->vrefresh, private_vblank->fps, private_vblank->fps_changeable);
+}
+
+/* LCOV_EXCL_START */
+static void
 _tdm_vblank_cb_output_change(tdm_output *output, tdm_output_change_type type,
 							 tdm_value value, void *user_data)
 {
 	tdm_private_vblank *private_vblank = user_data;
 
-	TDM_RETURN_IF_FAIL(private_vblank != NULL);
+	TDM_RETURN_IF_FAIL(tdm_vblank_is_valid(private_vblank));
 
 	switch (type) {
 	case TDM_OUTPUT_CHANGE_DPMS:
-		if (private_vblank->dpms == value.u32)
-			break;
 		VIN("dpms %s", tdm_dpms_str(value.u32));
-		private_vblank->dpms = value.u32;
 		private_vblank->check_HW_or_SW = 1;
-		if (private_vblank->dpms != TDM_OUTPUT_DPMS_ON) {
-#if 0
-			if (private_vblank->SW_align_wait) {
-				LIST_DEL(&private_vblank->SW_align_wait->valid_link);
-				free(private_vblank->SW_align_wait);
-				private_vblank->SW_align_wait = NULL;
-			}
-#endif
-
+		if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(value.u32)) {
 			if (private_vblank->enable_fake)
 				_tdm_vblank_change_to_SW(private_vblank);
-			else
+			else {
+				tdm_display_lock(private_vblank->dpy);
+				_tdm_vblank_timeout_timer_update(private_vblank, 0);
+				tdm_display_unlock(private_vblank->dpy);
+
 				_tdm_vblank_free_HW_wait(private_vblank, TDM_ERROR_DPMS_OFF, 1);
+			}
 		}
 		break;
 	case TDM_OUTPUT_CHANGE_CONNECTION:
+		if (private_vblank->connection == value.u32)
+			break;
 		VIN("output %s", tdm_status_str(value.u32));
-		if (value.u32 == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)
-			_tdm_vblank_free_HW_wait(private_vblank, 0, 0);
+		_tdm_vblank_update_output_info(private_vblank);
+		private_vblank->check_HW_or_SW = 1;
+		if (private_vblank->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+			if (private_vblank->enable_fake)
+				_tdm_vblank_change_to_SW(private_vblank);
+			else {
+				tdm_display_lock(private_vblank->dpy);
+				_tdm_vblank_timeout_timer_update(private_vblank, 0);
+				tdm_display_unlock(private_vblank->dpy);
+
+				_tdm_vblank_free_HW_wait(private_vblank, TDM_ERROR_OUTPUT_DISCONNECTED, 1);
+			}
+		}
 		break;
 	default:
 		break;
 	}
 }
+/* LCOV_EXCL_STOP */
 
-tdm_vblank*
-tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error)
+static tdm_error
+_tdm_vblank_set_fps(tdm_vblank *vblank, unsigned int fps)
 {
-	tdm_private_vblank *private_vblank;
-	const tdm_output_mode *mode = NULL;
-	tdm_output_dpms dpms = TDM_OUTPUT_DPMS_ON;
-	tdm_error ret;
-
-	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
-	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
-
-	if (error)
-		*error = TDM_ERROR_NONE;
-
-	if (!vblank_list_inited) {
-		LIST_INITHEAD(&vblank_list);
-		LIST_INITHEAD(&valid_wait_list);
-		vblank_list_inited = 1;
-	}
+	tdm_private_vblank *private_vblank = vblank;
 
-	tdm_output_get_mode(output, &mode);
-	if (!mode) {
-		if (error)
-			*error = TDM_ERROR_OPERATION_FAILED;
-		TDM_ERR("no mode");
-		return NULL;
+	if (private_vblank->fps_fixed) {
+		VIN("fps(%u) can't be changed", private_vblank->fps);
+		return TDM_ERROR_NONE;
 	}
 
-	tdm_output_get_dpms(output, &dpms);
+	private_vblank->fps_changeable = 0;
 
-	private_vblank = calloc(1, sizeof *private_vblank);
-	if (!private_vblank) {
-		if (error)
-			*error = TDM_ERROR_OUT_OF_MEMORY;
-		VER("alloc failed");
-		return NULL;
-	}
+	if (private_vblank->fps == fps)
+		return TDM_ERROR_NONE;
 
-	tdm_output_add_change_handler(output, _tdm_vblank_cb_output_change, private_vblank);
+	private_vblank->fps = fps;
+	private_vblank->check_HW_or_SW = 1;
 
-	private_vblank->dpy = dpy;
-	private_vblank->output = output;
-	private_vblank->dpms = dpms;
-	private_vblank->vrefresh = mode->vrefresh;
-	private_vblank->HW_vblank_gap = (double)1000000 / private_vblank->vrefresh;
+	VIN("fps(%u) changed", fps);
 
-	private_vblank->check_HW_or_SW = 1;
-	private_vblank->fps = mode->vrefresh;
+	return TDM_ERROR_NONE;
+}
 
-	LIST_INITHEAD(&private_vblank->HW_wait_list);
+static tdm_error
+_tdm_vblank_ignore_global_fps(tdm_vblank *vblank, unsigned int ignore)
+{
+	tdm_private_vblank *private_vblank = vblank;
 
-	LIST_INITHEAD(&private_vblank->SW_pending_wait_list);
-	LIST_INITHEAD(&private_vblank->SW_wait_list);
+	if (private_vblank->ignore_global_fps == ignore)
+		return TDM_ERROR_NONE;
 
-	LIST_ADD(&private_vblank->link, &vblank_list);
+	private_vblank->ignore_global_fps = ignore;
+	private_vblank->check_HW_or_SW = 1;
 
-	VDB("created. vrefresh(%d) dpms(%d)",
-		private_vblank->vrefresh, private_vblank->dpms);
+	VIN("ignore_global_fps(%u)", private_vblank->ignore_global_fps);
 
-	return (tdm_vblank*)private_vblank;
+	return TDM_ERROR_NONE;
 }
 
-void
-tdm_vblank_destroy(tdm_vblank *vblank)
+EXTERN tdm_error
+tdm_vblank_set_client_vblank_fps(unsigned int pid, const char *name, unsigned int fps)
 {
-	tdm_private_vblank *private_vblank = vblank;
-	tdm_vblank_wait_info *w = NULL, *ww = NULL;
+	tdm_private_vblank *v = NULL;
+	tdm_error ret = TDM_ERROR_NONE;
 
-	if (!private_vblank)
-		return;
+	TDM_RETURN_VAL_IF_FAIL(pid > 0, TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 
-	LIST_DEL(&private_vblank->link);
+	TDM_INFO("pid: %u, name: %s, fps: %d", pid, name, fps);
 
-#if 0
-	if (private_vblank->SW_align_wait) {
-		LIST_DEL(&private_vblank->SW_align_wait->valid_link);
-		free(private_vblank->SW_align_wait);
-	}
-#endif
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+		struct wl_client *client;
+		pid_t client_pid = 0;
 
-	if (private_vblank->SW_timer) {
-		if (tdm_display_lock(private_vblank->dpy) == TDM_ERROR_NONE) {
-			tdm_event_loop_source_remove(private_vblank->SW_timer);
-			tdm_display_unlock(private_vblank->dpy);
-		}
-	}
+		if (!v->resource)
+			continue;
 
-	tdm_output_remove_change_handler(private_vblank->output,
-									 _tdm_vblank_cb_output_change, private_vblank);
+		client = wl_resource_get_client(v->resource);
+		if (!client)
+			continue;
 
-	_tdm_vblank_free_HW_wait(private_vblank, 0, 0);
+		wl_client_get_credentials(client, &client_pid, NULL, NULL);
 
-	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_pending_wait_list, link) {
-		LIST_DEL(&w->link);
-		LIST_DEL(&w->valid_link);
-		free(w);
-	}
+		if (client_pid != pid)
+			continue;
 
-	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
-		LIST_DEL(&w->link);
-		LIST_DEL(&w->valid_link);
-		free(w);
-	}
+		if (name && strncmp(name, TDM_VBLANK_DEFAULT_NAME, TDM_NAME_LEN)) {
+			if (strncmp(v->name, name, TDM_NAME_LEN))
+				continue;
+		}
 
-	VIN("destroyed");
+		ret = _tdm_vblank_set_fps(v, fps);
+		if (ret == TDM_ERROR_NONE)
+			TDM_INFO("(pid:%u) '%s' fps changed: %d", pid, v->name, fps);
+		else
+			TDM_ERR("(pid:%u) '%s' fps changing failed: %d", pid, v->name, fps);
+	}
+	pthread_mutex_unlock(&valid_list_lock);
 
-	free(private_vblank);
+	return TDM_ERROR_NONE;
 }
 
-tdm_error
-tdm_vblank_set_fps(tdm_vblank *vblank, unsigned int fps)
+EXTERN tdm_error
+tdm_vblank_set_client_ignore_global_fps(unsigned int pid, const char *name, unsigned int ignore)
 {
-	tdm_private_vblank *private_vblank = vblank;
-
-	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
-	TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
+	tdm_private_vblank *v = NULL;
+	tdm_error ret = TDM_ERROR_NONE;
 
-	if (private_vblank->fps == fps)
-		return TDM_ERROR_NONE;
+	TDM_RETURN_VAL_IF_FAIL(pid > 0, TDM_ERROR_INVALID_PARAMETER);
 
-	private_vblank->fps = fps;
-	private_vblank->check_HW_or_SW = 1;
+	TDM_INFO("pid: %u, name: %s, ignore: %u", pid, name, ignore);
 
-	VDB("fps(%d)", private_vblank->fps);
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+		struct wl_client *client;
+		pid_t client_pid = 0;
 
-	return TDM_ERROR_NONE;
-}
+		if (!v->resource)
+			continue;
 
-tdm_error
-tdm_vblank_set_offset(tdm_vblank *vblank, int offset)
-{
-	tdm_private_vblank *private_vblank = vblank;
+		client = wl_resource_get_client(v->resource);
+		if (!client)
+			continue;
 
-	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
+		wl_client_get_credentials(client, &client_pid, NULL, NULL);
 
-	if (private_vblank->offset == offset)
-		return TDM_ERROR_NONE;
+		if (client_pid != pid)
+			continue;
 
-	private_vblank->offset = offset;
-	private_vblank->check_HW_or_SW = 1;
+		if (name && strncmp(name, TDM_VBLANK_DEFAULT_NAME, TDM_NAME_LEN)) {
+			if (strncmp(v->name, name, TDM_NAME_LEN))
+				continue;
+		}
 
-	VDB("offset(%d)", private_vblank->offset);
+		ret = _tdm_vblank_ignore_global_fps(v, ignore);
+		if (ret == TDM_ERROR_NONE)
+			TDM_INFO("(pid:%u) '%s' ignore changed: %u", pid, v->name, ignore);
+		else
+			TDM_ERR("(pid:%u) '%s' ignore changing failed: %u", pid, v->name, ignore);
+	}
+	pthread_mutex_unlock(&valid_list_lock);
 
 	return TDM_ERROR_NONE;
 }
 
-tdm_error
-tdm_vblank_set_enable_fake(tdm_vblank *vblank, unsigned int enable_fake)
+EXTERN tdm_error
+tdm_vblank_enable_global_fps(unsigned int enable, unsigned int fps)
 {
-	tdm_private_vblank *private_vblank = vblank;
+	tdm_private_vblank *v = NULL;
 
-	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
+	if (enable)
+		TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 
-	if (private_vblank->enable_fake == enable_fake)
-		return TDM_ERROR_NONE;
+	TDM_INFO("global fps: %s fps(%d)", (enable) ? "enabled" : "disabled", fps);
 
-	private_vblank->enable_fake = enable_fake;
+	pthread_mutex_lock(&valid_list_lock);
+
+	vblank_global_fps = (enable) ? fps : 0;
 
-	VDB("enable_fake(%d)", private_vblank->enable_fake);
+	LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+		/* skip if vblank is created in server side */
+		if (!v->resource)
+			continue;
+
+		v->check_HW_or_SW = 1;
+	}
+	pthread_mutex_unlock(&valid_list_lock);
 
 	return TDM_ERROR_NONE;
 }
 
 static void
-_tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
-						 unsigned int tv_sec, unsigned int tv_usec,
-						 void *user_data)
+_tdm_vblank_thread_cb_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 {
-	tdm_vblank_wait_info *wait_info = user_data;
+	tdm_thread_cb_vblank_create *vblank_create = (tdm_thread_cb_vblank_create *)cb_base;
+	tdm_vblank_create_handler_info *ch_info = user_data;
 	tdm_private_vblank *private_vblank;
 
-	if (!_tdm_vblank_check_valid(wait_info)) {
-		TDM_DBG("can't find wait(%p) from valid_wait_list", wait_info);
-		return;
-	}
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 
-	private_vblank = wait_info->private_vblank;
-	TDM_RETURN_IF_FAIL(private_vblank != NULL);
+	assert(ch_info != NULL);
 
-	if (!_tdm_vblank_find_wait(wait_info, &private_vblank->HW_wait_list)) {
-		VDB("can't find wait(%p)", wait_info);
+	private_vblank = _tdm_vblank_find_object(private_display, vblank_create->vblank_stamp);
+	if (!private_vblank) {
+		TDM_DBG("can't find vblank(%.0f) from valid_list", vblank_create->vblank_stamp);
 		return;
 	}
 
-	LIST_DEL(&wait_info->link);
-	LIST_DEL(&wait_info->valid_link);
+	private_vblank->in_create_handler = 1;
+	tdm_display_unlock(private_display);
+	ch_info->func(private_vblank, ch_info->user_data);
+	tdm_display_lock(private_display);
+	private_vblank->in_create_handler = 0;
+}
 
-	private_vblank->last_seq = wait_info->target_seq;
-	private_vblank->last_tv_sec = tv_sec;
-	private_vblank->last_tv_usec = tv_usec;
+static tdm_error
+_tdm_vblank_call_thread_cb(tdm_private_vblank *private_vblank)
+{
+	tdm_thread_cb_vblank_create vblank_create;
+	tdm_error ret;
 
-	if (wait_info->func)
-		wait_info->func(private_vblank, TDM_ERROR_NONE, private_vblank->last_seq,
-						tv_sec, tv_usec, wait_info->user_data);
+	memset(&vblank_create, 0, sizeof vblank_create);
+	vblank_create.base.type = TDM_THREAD_CB_VBLANK_CREATE;
+	vblank_create.base.length = sizeof vblank_create;
+	vblank_create.base.object_stamp = 1;
+	vblank_create.base.data = NULL;
+	vblank_create.base.sync = 0;
+	vblank_create.vblank_stamp = private_vblank->stamp;
 
-	VDB("wait(%p) done", wait_info);
+	ret = tdm_thread_cb_call(private_vblank->dpy, &vblank_create.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-	free(wait_info);
+	return TDM_ERROR_NONE;
 }
 
-static tdm_error
-_tdm_vblank_wait_HW(tdm_vblank_wait_info *wait_info)
+EXTERN tdm_error
+tdm_vblank_add_create_handler(tdm_display *dpy, tdm_vblank_create_handler func, void *user_data)
 {
-	tdm_private_vblank *private_vblank = wait_info->private_vblank;
+	tdm_vblank_create_handler_info *ch_info = NULL;
 	tdm_error ret;
 
-	TDM_RETURN_VAL_IF_FAIL(wait_info->target_hw_interval > 0, TDM_ERROR_OPERATION_FAILED);
+	TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 
-	_tdm_vblank_insert_wait(wait_info, &private_vblank->HW_wait_list);
+	pthread_mutex_lock(&valid_list_lock);
+
+	LIST_FOR_EACH_ENTRY(ch_info, &create_handler_list, link) {
+		if (ch_info->func == func && ch_info->user_data == user_data) {
+			TDM_ERR("can't be added twice");
+			pthread_mutex_unlock(&valid_list_lock);
+			return TDM_ERROR_BAD_REQUEST;
+		}
+	}
+
+	ch_info = calloc(1, sizeof *ch_info);
+	if (!ch_info) {
+		TDM_ERR("alloc failed: %m");
+		pthread_mutex_unlock(&valid_list_lock);
+		return TDM_ERROR_OUT_OF_MEMORY;
+	}
 
-	ret = tdm_output_wait_vblank(private_vblank->output, wait_info->target_hw_interval, 0,
-								 _tdm_vblank_cb_vblank_HW, wait_info);
+	tdm_display_lock(dpy);
+	ret = tdm_thread_cb_add(dpy, TDM_THREAD_CB_VBLANK_CREATE, NULL, _tdm_vblank_thread_cb_create, ch_info);
+	tdm_display_unlock(dpy);
 
 	if (ret != TDM_ERROR_NONE) {
-		VER("wait(%p) failed", wait_info);
-		LIST_DEL(&wait_info->link);
+		TDM_ERR("tdm_thread_cb_add failed");
+		free(ch_info);
+		pthread_mutex_unlock(&valid_list_lock);
 		return ret;
 	}
 
-	VDB("wait(%p) waiting", wait_info);
+	ch_info->func = func;
+	ch_info->user_data = user_data;
+
+	LIST_ADDTAIL(&ch_info->link, &create_handler_list);
+
+	pthread_mutex_unlock(&valid_list_lock);
 
 	return TDM_ERROR_NONE;
 }
 
-static tdm_error
-_tdm_vblank_cb_vblank_SW(void *user_data)
+EXTERN void
+tdm_vblank_remove_create_handler(tdm_display *dpy, tdm_vblank_create_handler func, void *user_data)
 {
-	tdm_private_vblank *private_vblank = user_data;
-	tdm_vblank_wait_info *first_wait_info = NULL, *w = NULL, *ww = NULL;
+	tdm_vblank_create_handler_info *ch_info = NULL, *hh = NULL;
 
-	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_OPERATION_FAILED);
+	TDM_RETURN_IF_FAIL(dpy != NULL);
+	TDM_RETURN_IF_FAIL(func != NULL);
 
-	if (LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
-		VER("no wait_info");
-		return TDM_ERROR_OPERATION_FAILED;
-	}
+	tdm_display_lock(dpy);
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_FOR_EACH_ENTRY_SAFE(ch_info, hh, &create_handler_list, link) {
+		if (ch_info->func != func || ch_info->user_data != user_data)
+			continue;
 
-	first_wait_info = container_of(private_vblank->SW_wait_list.next, first_wait_info, link);
-	TDM_RETURN_VAL_IF_FAIL(first_wait_info != NULL, TDM_ERROR_OPERATION_FAILED);
+		tdm_thread_cb_remove(dpy, TDM_THREAD_CB_VBLANK_CREATE, NULL, _tdm_vblank_thread_cb_create, ch_info);
 
-	VDB("wait(%p) done", first_wait_info);
+		LIST_DEL(&ch_info->link);
+		free(ch_info);
+		pthread_mutex_unlock(&valid_list_lock);
+		tdm_display_unlock(dpy);
+		return;
+	}
+	pthread_mutex_unlock(&valid_list_lock);
+	tdm_display_unlock(dpy);
+}
 
-	private_vblank->last_seq = first_wait_info->target_seq;
-	private_vblank->last_tv_sec = first_wait_info->target_sec;
-	private_vblank->last_tv_usec = first_wait_info->target_usec;
+static void*
+_tdm_vblank_find_display(tdm_private_display *private_display, double stamp)
+{
+	return private_display;
+}
 
-	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
-		if (w->target_sec != first_wait_info->target_sec ||
-			w->target_usec != first_wait_info->target_usec)
-			break;
+INTERN tdm_error
+tdm_vblank_init(tdm_display *dpy)
+{
+	if (vblank_list_inited)
+		return TDM_ERROR_NONE;
 
-		LIST_DEL(&w->link);
-		LIST_DEL(&w->valid_link);
+	LIST_INITHEAD(&valid_vblank_list);
+	LIST_INITHEAD(&valid_wait_list);
+	LIST_INITHEAD(&create_handler_list);
 
-		if (w->func)
-			w->func(private_vblank, TDM_ERROR_NONE, w->target_seq,
-					w->target_sec, w->target_usec,
-					w->user_data);
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_VBLANK_SW, _tdm_vblank_find_object);
+	tdm_thread_cb_set_find_func(TDM_THREAD_CB_VBLANK_CREATE, _tdm_vblank_find_display);
 
-		free(w);
-	}
+	vblank_list_inited = 1;
 
 	return TDM_ERROR_NONE;
 }
 
-static void
-_tdm_vblank_cb_vblank_SW_first(tdm_output *output, unsigned int sequence,
-							   unsigned int tv_sec, unsigned int tv_usec,
-							   void *user_data)
+INTERN void
+tdm_vblank_deinit(tdm_display *dpy)
 {
-	tdm_vblank_wait_info *wait_info = user_data;
-	tdm_private_vblank *private_vblank;
-	tdm_vblank_wait_info *w = NULL, *ww = NULL;
-	unsigned int min_interval = 0;
-	unsigned long last;
+	tdm_vblank_create_handler_info *ch_info = NULL, *hh = NULL;
 
-	if (!_tdm_vblank_check_valid(wait_info))
+	if (!vblank_list_inited)
 		return;
 
-	private_vblank = wait_info->private_vblank;
-	TDM_RETURN_IF_FAIL(private_vblank != NULL);
+	if (!LIST_IS_EMPTY(&valid_vblank_list))
+		TDM_NEVER_GET_HERE();
 
-	if (LIST_IS_EMPTY(&private_vblank->SW_pending_wait_list)) {
-		VER("no wait_info");
-		return;
-	}
+	if (!LIST_IS_EMPTY(&valid_wait_list))
+		TDM_NEVER_GET_HERE();
 
-	w = container_of((&private_vblank->SW_pending_wait_list)->next, w, link);
-	TDM_RETURN_IF_FAIL(w != NULL);
+	LIST_FOR_EACH_ENTRY_SAFE(ch_info, hh, &create_handler_list, link) {
+		LIST_DEL(&ch_info->link);
+		free(ch_info);
+	}
 
-	VDB("wait(%p) done", w);
+	vblank_list_inited = 0;
+}
 
-	min_interval = w->interval;
+EXTERN tdm_vblank *
+tdm_vblank_create(tdm_display *dpy, tdm_output *output, tdm_error *error)
+{
+	tdm_private_vblank *private_vblank;
+	tdm_error ret;
 
-	last = (unsigned long)tv_sec * 1000000 + tv_usec;
-	last -= private_vblank->offset * 1000;
+	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
+	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
 
-	private_vblank->last_seq = min_interval;
-	private_vblank->last_tv_sec = last / 1000000;
-	private_vblank->last_tv_usec = last % 1000000;
+	if (error)
+		*error = TDM_ERROR_NONE;
 
-	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_pending_wait_list, link) {
-		if (w->interval == min_interval) {
-			LIST_DEL(&w->link);
-			LIST_DEL(&w->valid_link);
+	private_vblank = calloc(1, sizeof * private_vblank);
+	if (!private_vblank) {
+		/* LCOV_EXCL_START */
+		if (error)
+			*error = TDM_ERROR_OUT_OF_MEMORY;
+		TDM_ERR("alloc failed");
+		return NULL;
+		/* LCOV_EXCL_STOP */
+	}
 
-			if (w->func)
-				w->func(private_vblank, TDM_ERROR_NONE, private_vblank->last_seq,
-						tv_sec, tv_usec, w->user_data);
-			free(w);
-		} else {
-			LIST_DEL(&w->link);
-			w->interval -= min_interval;
-			_tdm_vblank_wait_SW(w);
+	ret = tdm_output_add_change_handler(output, _tdm_vblank_cb_output_change, private_vblank);
+	if (ret != TDM_ERROR_NONE) {
+		free(private_vblank);
+		if (error)
+			*error = TDM_ERROR_OPERATION_FAILED;
+		TDM_ERR("tdm_output_add_change_handler failed");
+		return NULL;
+	}
+
+	private_vblank->stamp = ++stamp;
+	private_vblank->owner_tid = syscall(SYS_gettid);
+	private_vblank->dpy = dpy;
+	private_vblank->output = output;
+	private_vblank->check_HW_or_SW = 1;
+	private_vblank->fps_changeable = 1;
+	private_vblank->last_interval = -1;
+
+	_tdm_vblank_update_output_info(private_vblank);
+
+	strncpy(private_vblank->name, TDM_VBLANK_DEFAULT_NAME, TDM_NAME_LEN - 1);
+	private_vblank->name[TDM_NAME_LEN - 1] = '\0';
+
+	LIST_INITHEAD(&private_vblank->HW_wait_list);
+	LIST_INITHEAD(&private_vblank->SW_wait_list);
+
+	_tdm_vblank_valid_list_add(&private_vblank->valid_link, &valid_vblank_list);
+
+	VIN("created. vrefresh(%d) connection(%d)",
+		private_vblank->vrefresh, private_vblank->connection);
+
+	tdm_display_lock(private_vblank->dpy);
+	_tdm_vblank_call_thread_cb(private_vblank);
+	tdm_display_unlock(private_vblank->dpy);
+
+	return (tdm_vblank *)private_vblank;
+}
+
+EXTERN void
+tdm_vblank_destroy(tdm_vblank *vblank)
+{
+	tdm_private_vblank *private_vblank = vblank;
+	tdm_vblank_wait_info *w = NULL, *ww = NULL;
+
+	TDM_RETURN_IF_FAIL(tdm_vblank_is_valid(vblank));
+
+	if (private_vblank->in_create_handler) {
+		TDM_ERR("NOT allowed to be called in a create handler");
+		return;
+	}
+
+	_tdm_vblank_valid_list_del(&private_vblank->valid_link);
+
+	if (private_vblank->SW_timer) {
+		tdm_display_lock(private_vblank->dpy);
+		tdm_thread_cb_remove(private_vblank, TDM_THREAD_CB_VBLANK_SW, NULL, _tdm_vblank_cb_vblank_SW, NULL);
+		tdm_event_loop_source_remove(private_vblank->SW_timer);
+		tdm_display_unlock(private_vblank->dpy);
+	}
+
+	tdm_output_remove_change_handler(private_vblank->output,
+									 _tdm_vblank_cb_output_change, private_vblank);
+
+	_tdm_vblank_free_HW_wait(private_vblank, 0, 0);
+
+	if (!LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
+		pid_t pid;
+		const char *proc_name;
+		_tdm_vblank_get_client_information(private_vblank, &pid, &proc_name);
+		VER("TDM SW vblank destroyed forcely!! (pid: %u, name: %s)", pid, proc_name);
+	}
+
+	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
+		LIST_DEL(&w->link);
+		_tdm_vblank_valid_list_del(&w->valid_link);
+		free(w);
+	}
+
+	if (private_vblank->timeout_timer) {
+		tdm_display_lock(private_vblank->dpy);
+		tdm_event_loop_source_remove(private_vblank->timeout_timer);
+		tdm_display_unlock(private_vblank->dpy);
+	}
+
+	VIN("destroyed");
+
+	free(private_vblank);
+}
+
+EXTERN tdm_output *
+tdm_vblank_get_output(tdm_vblank *vblank, tdm_error *error)
+{
+	tdm_private_vblank *private_vblank = vblank;
+	tdm_error ret = TDM_ERROR_NONE;
+
+	TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER, NULL);
+
+	if (error)
+		*error = TDM_ERROR_NONE;
+
+	return private_vblank->output;
+}
+
+EXTERN tdm_error
+tdm_vblank_get_client_pid(tdm_vblank *vblank, pid_t *pid)
+{
+	tdm_private_vblank *private_vblank = vblank;
+	struct wl_client *client;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(pid != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	if (!private_vblank->resource) {
+		*pid = 0;
+		return TDM_ERROR_NONE;
+	}
+
+	client = wl_resource_get_client(private_vblank->resource);
+	if (!client) {
+		*pid = 0;
+		return TDM_ERROR_NONE;
+	}
+
+	wl_client_get_credentials(client, pid, NULL, NULL);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_set_name(tdm_vblank *vblank, const char *name)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+
+	if (!name)
+		name = TDM_VBLANK_DEFAULT_NAME;
+
+	strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
+	private_vblank->name[TDM_NAME_LEN - 1] = '\0';
+
+	VIN("name(%s)", name);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_get_name(tdm_vblank *vblank, const char **name)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(name != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	*name = (const char*)private_vblank->name;
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_set_fps(tdm_vblank *vblank, unsigned int fps)
+{
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
+
+	return _tdm_vblank_set_fps(vblank, fps);
+}
+
+EXTERN tdm_error
+tdm_vblank_get_fps(tdm_vblank *vblank, unsigned int *fps)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(fps != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	*fps = private_vblank->fps;
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_set_fixed_fps(tdm_vblank *vblank, unsigned int fps)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
+
+	private_vblank->fps_changeable = 0;
+	private_vblank->fps_fixed = 1;
+
+	if (private_vblank->fps == fps)
+		return TDM_ERROR_NONE;
+
+	private_vblank->fps = fps;
+	private_vblank->check_HW_or_SW = 1;
+
+	VIN("fps(%u) fixed", fps);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_ignore_global_fps(tdm_vblank *vblank, unsigned int ignore)
+{
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+
+	return _tdm_vblank_ignore_global_fps(vblank, ignore);
+}
+
+EXTERN tdm_error
+tdm_vblank_set_offset(tdm_vblank *vblank, int offset)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(offset >= 0, TDM_ERROR_INVALID_PARAMETER);
+
+	if (private_vblank->offset == offset)
+		return TDM_ERROR_NONE;
+
+	private_vblank->offset = offset;
+	private_vblank->check_HW_or_SW = 1;
+
+	VIN("offset(%u)", private_vblank->offset);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_get_offset(tdm_vblank *vblank, int *offset)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(offset != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	*offset = private_vblank->offset;
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_set_enable_fake(tdm_vblank *vblank, unsigned int enable_fake)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+
+	if (private_vblank->enable_fake == enable_fake)
+		return TDM_ERROR_NONE;
+
+	private_vblank->enable_fake = enable_fake;
+
+	VIN("enable_fake(%u)", private_vblank->enable_fake);
+
+	return TDM_ERROR_NONE;
+}
+
+EXTERN tdm_error
+tdm_vblank_get_enable_fake(tdm_vblank *vblank, unsigned int *enable_fake)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(enable_fake != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	*enable_fake = private_vblank->enable_fake;
+
+	return TDM_ERROR_NONE;
+}
+
+static tdm_error
+_tdm_vblank_timeout_timer_cb(void *user_data)
+{
+	tdm_private_vblank *private_vblank = user_data;
+	tdm_vblank_wait_info *w = NULL;
+	pid_t pid;
+	const char *proc_name;
+
+	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_OPERATION_FAILED);
+
+	_tdm_vblank_get_client_information(private_vblank, &pid, &proc_name);
+
+	VER("TDM vblank TIMEOUT!! (pid: %u, name: %s)", pid, proc_name);
+	VER("quotient(%u) last_seq(%u) last_time(%.6f)", private_vblank->quotient, private_vblank->last_seq, private_vblank->last_time);
+
+	LIST_FOR_EACH_ENTRY(w, &private_vblank->HW_wait_list, link) {
+		VER("wait_info(%p) req_time(%.6f) target_seq(%u) interval(%u) hw_interval(%d)",
+			w, w->req_time, w->target_seq, w->interval, w->hw_interval);
+		tdm_output_vblank_print_wait_information(private_vblank->output, w);
+	}
+
+	LIST_FOR_EACH_ENTRY(w, &private_vblank->SW_wait_list, link) {
+		VER("wait_info(%p) req_time(%.6f) target_time(%.6f) target_seq(%u) interval(%u)",
+			w, w->req_time, w->target_time, w->target_seq, w->interval);
+	}
+
+	return TDM_ERROR_NONE;
+}
+
+static void
+_tdm_vblank_timeout_timer_update(tdm_private_vblank *private_vblank, int ms_delay)
+{
+	tdm_error ret;
+
+	if (!private_vblank->timeout_timer) {
+		private_vblank->timeout_timer =
+			tdm_event_loop_add_timer_handler(private_vblank->dpy,
+											 _tdm_vblank_timeout_timer_cb,
+											 private_vblank,
+											 &ret);
+		if (!private_vblank->timeout_timer) {
+			VER("couldn't add timer");
+			return;
 		}
+		VIN("Create Timeout timer");
 	}
+
+	ret = tdm_event_loop_source_timer_update(private_vblank->timeout_timer, ms_delay);
+	if (ret != TDM_ERROR_NONE) {
+		VER("couldn't update timer");
+		return;
+	}
+
+	if (ms_delay != 0)
+		VDB("timeout timer updated");
+	else
+		VDB("timeout timer disabled");
 }
 
 static tdm_error
 _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank)
 {
 	tdm_vblank_wait_info *first_wait_info = NULL;
-	unsigned long curr, target;
+	double curr, target;
 	int ms_delay;
 	tdm_error ret;
 
@@ -613,27 +1132,29 @@ _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank)
 	}
 
 	first_wait_info = container_of(private_vblank->SW_wait_list.next, first_wait_info, link);
-	curr = tdm_helper_get_time_in_micros();
-	target = first_wait_info->target_sec * 1000000 + first_wait_info->target_usec;
+	curr = tdm_helper_get_time();
+	target = first_wait_info->target_time;
 
+	/* ms_delay should be more that 1 */
 	if (target < curr)
 		ms_delay = 1;
 	else
-		ms_delay = ceil((double)(target - curr) / 1000);
+		ms_delay = ceil((target - curr) * 1000.0);
 
 	if (ms_delay < 1)
 		ms_delay = 1;
 
-	VDB("wait(%p) curr(%4lu) target(%4lu) ms_delay(%d)",
-		first_wait_info, curr, target, ms_delay);
+	if (ms_delay > 5000)
+		VER("wait(%p) curr(%.6f) target(%.6f) ms_delay(%d)", first_wait_info, curr, target, ms_delay);
+	else
+		VDB("wait(%p) curr(%.6f) target(%.6f) ms_delay(%d)", first_wait_info, curr, target, ms_delay);
 
-	ret = tdm_display_lock(private_vblank->dpy);
-	TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
+	tdm_display_lock(private_vblank->dpy);
 
 	if (!private_vblank->SW_timer) {
 		private_vblank->SW_timer =
 			tdm_event_loop_add_timer_handler(private_vblank->dpy,
-											 _tdm_vblank_cb_vblank_SW,
+											 _tdm_vblank_cb_timeout_SW,
 											 private_vblank,
 											 &ret);
 		if (!private_vblank->SW_timer) {
@@ -641,14 +1162,28 @@ _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank)
 			VER("couldn't add timer");
 			return ret;
 		}
-		VIN("Use SW vblank");
+
+		ret = tdm_thread_cb_add(private_vblank, TDM_THREAD_CB_VBLANK_SW, NULL, _tdm_vblank_cb_vblank_SW, NULL);
+		if (ret != TDM_ERROR_NONE) {
+			tdm_event_loop_source_remove(private_vblank->SW_timer);
+			private_vblank->SW_timer = NULL;
+			tdm_display_unlock(private_vblank->dpy);
+			VER("couldn't add thread_cb");
+			return ret;
+		}
+
+		VIN("Create SW timer");
 	}
 
+	private_vblank->last_interval = ms_delay;
+
 	ret = tdm_event_loop_source_timer_update(private_vblank->SW_timer, ms_delay);
 	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
 		tdm_display_unlock(private_vblank->dpy);
 		VER("couldn't update timer");
 		return ret;
+		/* LCOV_EXCL_STOP */
 	}
 
 	tdm_display_unlock(private_vblank->dpy);
@@ -656,253 +1191,616 @@ _tdm_vblank_sw_timer_update(tdm_private_vblank *private_vblank)
 	return TDM_ERROR_NONE;
 }
 
-#if 0
 static void
-_tdm_vblank_cb_vblank_align(tdm_output *output, unsigned int sequence,
-							unsigned int tv_sec, unsigned int tv_usec,
-							void *user_data)
+_tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
+						 unsigned int tv_sec, unsigned int tv_usec,
+						 void *user_data)
 {
-	tdm_vblank_wait_info *align_info = user_data;
+	tdm_vblank_wait_info *wait_info = user_data;
 	tdm_private_vblank *private_vblank;
-	unsigned int diff_sec, diff_usec;
 
-	if (!_tdm_vblank_check_valid(align_info))
+	if (!_tdm_vblank_check_valid_wait(wait_info)) {
+		TDM_ERR("can't find wait(%p) from valid_wait_list", wait_info);
 		return;
+	}
 
-	private_vblank = align_info->private_vblank;
-	TDM_RETURN_IF_FAIL(private_vblank != NULL);
-
-	private_vblank->SW_align_wait = NULL;
-	private_vblank->SW_align_sec = tv_sec;
-	private_vblank->SW_align_usec = tv_usec;
+	private_vblank = wait_info->private_vblank;
+	TDM_RETURN_IF_FAIL(tdm_vblank_is_valid(private_vblank));
 
-	LIST_DEL(&align_info->valid_link);
+	assert(private_vblank->owner_tid == syscall(SYS_gettid));
 
-	if (tv_usec > align_info->req_usec) {
-		diff_usec = tv_usec - align_info->req_usec;
-		diff_sec = tv_sec - align_info->req_sec;
-	} else {
-		diff_usec = 1000000 + tv_usec - align_info->req_usec;
-		diff_sec = tv_sec - align_info->req_sec - 1;
+	if (!_tdm_vblank_find_wait(wait_info, &private_vblank->HW_wait_list)) {
+		VER("can't find wait(%p)", wait_info);
+		return;
 	}
 
-	private_vblank->SW_align_offset = (double)(1000000 - diff_sec * 1000000 - diff_usec) / private_vblank->vrefresh;
+	if (wait_info->type == VBLANK_TYPE_HW_SW) {
+		tdm_error ret;
 
-	free(align_info);
+		LIST_DEL(&wait_info->link);
 
-	/* align vblank continously only if non HW and DPMS on */
-	if (!private_vblank->HW_enable && private_vblank->dpms == TDM_OUTPUT_DPMS_ON)
-		_tdm_vblank_sw_timer_align(private_vblank);
-}
+		/* kernel sends the wrong time of first vblank event. and the time of
+		 * second vblank is correct.
+		 */
+		wait_info->target_time = TDM_TIME(tv_sec, tv_usec);
+		wait_info->target_time += (((double)private_vblank->offset) / 1000.0);
 
-static void
-_tdm_vblank_sw_timer_align(tdm_private_vblank *private_vblank)
-{
-	tdm_vblank_wait_info *align_info;
-	unsigned long curr;
-	tdm_error ret;
+		_tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list);
 
-	if (private_vblank->SW_align_wait)
-		return;
+		ret = _tdm_vblank_sw_timer_update(private_vblank);
 
-	TDM_RETURN_IF_FAIL(private_vblank->dpms == TDM_OUTPUT_DPMS_ON);
+		/* wait_info will be freed in _tdm_vblank_cb_timeout_SW() */
+		if (ret == TDM_ERROR_NONE) {
+			VIN("wait(%p) SW timer", wait_info);
+			return;
+		}
 
-	align_info = calloc(1, sizeof *align_info);
-	if (!align_info) {
-		VER("alloc failed");
-		return;
+		VER("couldn't update sw timer");
 	}
 
-	LIST_ADDTAIL(&align_info->valid_link, &valid_wait_list);
-	align_info->stamp = ++stamp;
-	align_info->private_vblank = private_vblank;
+	tdm_display_lock(private_vblank->dpy);
+	_tdm_vblank_timeout_timer_update(private_vblank, 0);
+	tdm_display_unlock(private_vblank->dpy);
 
-	curr = tdm_helper_get_time_in_micros();
-	align_info->req_sec = curr / 1000000;
-	align_info->req_usec = curr % 1000000;
+	LIST_DEL(&wait_info->link);
+	_tdm_vblank_valid_list_del(&wait_info->valid_link);
 
-	ret = tdm_output_wait_vblank(private_vblank->output, private_vblank->vrefresh, 0,
-								 _tdm_vblank_cb_vblank_align, align_info);
-	if (ret != TDM_ERROR_NONE) {
-		LIST_DEL(&align_info->valid_link);
-		free(align_info);
-		return;
+	/* tv_sec & tv_usec shouldn't be zero. But sometimes they are zero in some hardware.
+	 * We need to prohibit that last_time becomes zero because "last_time == 0" means
+	 * that a tdm_vblank object is just created and doesn't have the first vblank event.
+	 * If last_time becomes 0, it would make issue.
+	 */
+	if (tv_sec == 0 && tv_usec == 0) {
+		double curr = tdm_helper_get_time();
+		tv_sec = TDM_TIME_SEC(curr);
+		tv_usec = TDM_TIME_USEC(curr);
 	}
 
-	private_vblank->SW_align_wait = align_info;
+	private_vblank->last_seq = wait_info->target_seq;
+	private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
+
+	VDB("wait(%p) last(%.6f) sequence(%u) done", wait_info, private_vblank->last_time, wait_info->target_seq);
+
+	if (tdm_ttrace_module & TDM_TTRACE_VBLANK)
+		TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Vblank:%u", (unsigned int)private_vblank->stamp);
+
+	if (wait_info->func)
+		wait_info->func(private_vblank, TDM_ERROR_NONE, wait_info->target_seq,
+						tv_sec, tv_usec, wait_info->user_data);
+
+	free(wait_info);
 }
-#endif
 
 static tdm_error
-_tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info)
+_tdm_vblank_wait_HW(tdm_vblank_wait_info *wait_info)
 {
 	tdm_private_vblank *private_vblank = wait_info->private_vblank;
+	int hw_interval;
 	tdm_error ret;
 
-	if (private_vblank->last_tv_sec == 0 && private_vblank->dpms == TDM_OUTPUT_DPMS_ON) {
-		unsigned int do_wait = LIST_IS_EMPTY(&private_vblank->SW_pending_wait_list);
-		_tdm_vblank_insert_wait(wait_info, &private_vblank->SW_pending_wait_list);
-		if (do_wait) {
-			ret = tdm_output_wait_vblank(private_vblank->output, 1, 0,
-										 _tdm_vblank_cb_vblank_SW_first, wait_info);
-			if (ret != TDM_ERROR_NONE) {
-				LIST_DEL(&wait_info->link);
-				return ret;
-			}
-			VDB("wait(%p) waiting", wait_info);
-		}
-		return TDM_ERROR_NONE;
+	if (private_vblank->last_type != VBLANK_EVENT_TYPE_HW) {
+		VIN("Use HW vblank");
+		private_vblank->last_type = VBLANK_EVENT_TYPE_HW;
 	}
 
-	TDM_RETURN_VAL_IF_FAIL(wait_info->target_sec > 0, TDM_ERROR_OPERATION_FAILED);
+	_tdm_vblank_insert_wait(wait_info, &private_vblank->HW_wait_list);
 
-	_tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list);
+	if (private_vblank->last_time == 0) {
+		hw_interval = wait_info->interval * private_vblank->quotient;
+
+		/* SW vblank starts from now. SW vblank doesn't need to be aligned with HW vblank. */
+		private_vblank->last_seq = 0;
+		private_vblank->last_time = tdm_helper_get_time();
+
+		/* +1 ms to call the handler ASAP at the first. no matter for SW timer. */
+		wait_info->target_seq = 1;
+
+		VDB("wait(%p) last(%.6f) hw_itvl(%d) targ_seq(%u)",
+			wait_info, private_vblank->last_time, hw_interval, wait_info->target_seq);
+	} else {
+		double last, prev, req, curr, target;
+		unsigned int skip;
+
+		last = private_vblank->last_time;
+		req = wait_info->req_time;
+
+		/* make sure that req time is bigger than last. */
+		if (req < last)
+			req = last;
+
+		skip = (unsigned int)((req - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN);
+		prev = last + private_vblank->vblank_gap * skip;
+
+		curr = tdm_helper_get_time();
+		target = last;
+		while (target < curr)
+			target += (private_vblank->vblank_gap * wait_info->interval);
+
+		hw_interval = (unsigned int)((target - curr) / private_vblank->HW_vblank_gap + TDM_TIME_MARGIN) + 1;
+
+		wait_info->target_seq = private_vblank->last_seq;
+		wait_info->target_seq += (unsigned int)((target - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN);
+
+		if (hw_interval > 300)
+			VER("wait(%p) last(%.6f) req(%.6f) prev(%.6f) curr(%.6f) targ(%.6f,%.6f) skip(%u) hw_itvl(%d) targ_seq(%u)",
+				wait_info, last, req - last, prev - last, curr - last, target, target - last,
+				skip, hw_interval, wait_info->target_seq);
+		else
+			VDB("wait(%p) last(%.6f) req(%.6f) prev(%.6f) curr(%.6f) targ(%.6f,%.6f) skip(%u) hw_itvl(%d) targ_seq(%u)",
+				wait_info, last, req - last, prev - last, curr - last, target, target - last,
+				skip, hw_interval, wait_info->target_seq);
+	}
+
+	private_vblank->last_interval = hw_interval;
+	wait_info->hw_interval = hw_interval;
+
+	if (tdm_ttrace_module & TDM_TTRACE_VBLANK)
+		TDM_TRACE_ASYNC_BEGIN((int)wait_info->req_time, "TDM_Vblank:%u", (unsigned int)private_vblank->stamp);
+
+	if (private_vblank->add_front)
+		ret = tdm_output_wait_vblank_add_front(private_vblank->output, hw_interval, 0,
+											   _tdm_vblank_cb_vblank_HW, wait_info);
+	else
+		ret = tdm_output_wait_vblank(private_vblank->output, hw_interval, 0,
+									 _tdm_vblank_cb_vblank_HW, wait_info);
 
-	ret = _tdm_vblank_sw_timer_update(private_vblank);
 	if (ret != TDM_ERROR_NONE) {
 		LIST_DEL(&wait_info->link);
-		VER("couldn't update sw timer");
 		return ret;
 	}
 
+	VDB("wait(%p) waiting", wait_info);
+
 	return TDM_ERROR_NONE;
 }
 
 static void
-_tdm_vblank_calculate_target(tdm_vblank_wait_info *wait_info)
+_tdm_vblank_cb_vblank_SW(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 {
-	tdm_private_vblank *private_vblank = wait_info->private_vblank;
-	unsigned long last, prev, req, curr, target;
-	unsigned int skip = 0;
-
-	curr = tdm_helper_get_time_in_micros();
-
-	if (!private_vblank->HW_enable) {
-		if (private_vblank->last_tv_sec == 0) {
-			/* If last == 0 and DPMS == on, we will use HW vblank to sync with HW vblank. */
-			if (private_vblank->dpms == TDM_OUTPUT_DPMS_ON) {
-				return;
-			} else {
-				private_vblank->last_tv_sec = curr / 1000000;
-				private_vblank->last_tv_usec = curr % 1000000;
-			}
-		}
+	tdm_private_vblank *private_vblank = object;
+	tdm_vblank_wait_info *first_wait_info = NULL, *w = NULL, *ww = NULL;
+
+	TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+	assert(private_vblank->owner_tid == syscall(SYS_gettid));
+
+	if (LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
+		VER("no wait_info");
+		return;
 	}
 
-	/* last can be 0 when HW enable. But it doesn't matter if HW enable. */
-	if (!private_vblank->HW_enable)
-		TDM_RETURN_IF_FAIL(private_vblank->last_tv_sec != 0);
+	if (!LIST_IS_EMPTY(&private_vblank->HW_wait_list))
+		TDM_NEVER_GET_HERE();
 
-	last = (unsigned long)private_vblank->last_tv_sec * 1000000 + private_vblank->last_tv_usec;
-	req = (unsigned long)wait_info->req_sec * 1000000 + wait_info->req_usec;
-	skip = (unsigned int)((req - last) / private_vblank->vblank_gap);
-	prev = last + skip * private_vblank->vblank_gap;
+	first_wait_info = container_of(private_vblank->SW_wait_list.next, first_wait_info, link);
+	TDM_RETURN_IF_FAIL(first_wait_info != NULL);
 
-	if (private_vblank->last_seq == 0)
-		skip = 0;
+	_tdm_vblank_timeout_timer_update(private_vblank, 0);
 
-	skip += wait_info->interval;
+	if (private_vblank->last_seq >= first_wait_info->target_seq)
+		TDM_ERR("last_seq(%u) target_seq(%u)", private_vblank->last_seq, first_wait_info->target_seq);
 
-	if (private_vblank->HW_enable) {
-		unsigned int hw_skip = (unsigned int)((curr - prev) / private_vblank->HW_vblank_gap);
+	private_vblank->last_seq = first_wait_info->target_seq;
+	private_vblank->last_time = first_wait_info->target_time;
 
-		wait_info->target_hw_interval = wait_info->interval * private_vblank->HW_quotient;
-		wait_info->target_hw_interval -= hw_skip;
+	VDB("wait(%p) last(%.6f) sequence(%u) done", first_wait_info, private_vblank->last_time, first_wait_info->target_seq);
 
-		if (wait_info->target_hw_interval < 1)
-			wait_info->target_hw_interval = 1;
+	LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->SW_wait_list, link) {
+		if (w->target_time != first_wait_info->target_time)
+			break;
 
-		target = prev + wait_info->target_hw_interval * private_vblank->HW_vblank_gap;
-	} else {
-		target = prev + (unsigned long)(private_vblank->vblank_gap * wait_info->interval);
+		LIST_DEL(&w->link);
+		_tdm_vblank_valid_list_del(&w->valid_link);
 
-		while (target < curr) {
-			target += (unsigned long)private_vblank->vblank_gap;
-			skip++;
+		if (w->func) {
+			tdm_display_unlock(private_vblank->dpy);
+			w->func(private_vblank, TDM_ERROR_NONE, w->target_seq,
+					TDM_TIME_SEC(w->target_time), TDM_TIME_USEC(w->target_time),
+					w->user_data);
+			tdm_display_lock(private_vblank->dpy);
 		}
+
+		free(w);
 	}
+}
+
+static tdm_error
+_tdm_vblank_cb_timeout_SW(void *user_data)
+{
+	tdm_private_vblank *private_vblank = user_data;
+	tdm_thread_cb_vblank_sw vblank_sw;
+	tdm_error ret;
 
-	VDB("target_seq(%d) last_seq(%d) skip(%d)",
-		wait_info->target_seq, private_vblank->last_seq, skip);
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(private_vblank), TDM_ERROR_OPERATION_FAILED);
 
-#if 0
-	target -= (private_vblank->SW_align_offset * skip * private_vblank->HW_quotient);
-#endif
+	VIN("timeout_SW -> thread-cb");
+
+	memset(&vblank_sw, 0, sizeof vblank_sw);
+	vblank_sw.base.type = TDM_THREAD_CB_VBLANK_SW;
+	vblank_sw.base.length = sizeof vblank_sw;
+	vblank_sw.base.object_stamp = private_vblank->stamp;
+	vblank_sw.base.data = NULL;
+	vblank_sw.base.sync = 0;
+
+	ret = tdm_thread_cb_call(private_vblank, &vblank_sw.base, 1);
+	TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 
-	wait_info->target_seq = private_vblank->last_seq + skip;
-	wait_info->target_sec = target / 1000000;
-	wait_info->target_usec = target % 1000000;
+	return TDM_ERROR_NONE;
+}
+
+static tdm_error
+_tdm_vblank_wait_SW(tdm_vblank_wait_info *wait_info)
+{
+	tdm_private_vblank *private_vblank = wait_info->private_vblank;
+	tdm_error ret;
+	double last, prev, req, curr, target;
+	unsigned int skip;
+
+	if (private_vblank->last_type != VBLANK_EVENT_TYPE_SW) {
+		tdm_output_dpms dpms;
 
-	VDB("wait(%p) last(%4lu) req(%4lu) prev(%4lu) curr(%4lu) skip(%d) hw_interval(%d) target(%4lu,%4lu)",
+		tdm_output_get_dpms(private_vblank->output, &dpms);
+
+		VIN("Use SW vblank. connection(%s), dpms(%s), vrefresh(%d), fps(%d), offset(%d)",
+			tdm_status_str(private_vblank->connection), tdm_dpms_str(dpms),
+			private_vblank->vrefresh, private_vblank->fps, private_vblank->offset);
+		private_vblank->last_type = VBLANK_EVENT_TYPE_SW;
+	}
+
+	if (private_vblank->last_time == 0) {
+		/* SW vblank starts from now. SW vblank doesn't need to be aligned with HW vblank. */
+		private_vblank->last_seq = 0;
+		private_vblank->last_time = tdm_helper_get_time() - private_vblank->vblank_gap;
+
+		/* +1 ms to call the handler ASAP at the first. no matter for SW timer. */
+		wait_info->target_seq = 1;
+	}
+
+	last = private_vblank->last_time;
+	req = wait_info->req_time;
+
+	/* make sure that req time is bigger than last. */
+	if (req < last)
+		req = last;
+
+	skip = (unsigned int)((req - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN);
+	prev = last + private_vblank->vblank_gap * skip;
+
+	curr = tdm_helper_get_time();
+	target = prev + private_vblank->vblank_gap * wait_info->interval;
+
+	while (target < curr)
+		target += private_vblank->vblank_gap;
+
+	wait_info->target_seq = private_vblank->last_seq;
+	wait_info->target_seq += (unsigned int)((target - last) / private_vblank->vblank_gap + TDM_TIME_MARGIN);
+
+	wait_info->target_time = target + (double)(private_vblank->offset) / 1000;
+
+	VDB("wait(%p) last(%.6f) req(%.6f) prev(%.6f) curr(%.6f) targ(%.6f,%.6f) skip(%u) targ_seq(%u)",
 		wait_info, last, req - last, prev - last, curr - last,
-		skip, wait_info->target_hw_interval, target, target - last);
+		target, target - last, skip, wait_info->target_seq);
+
+	_tdm_vblank_insert_wait(wait_info, &private_vblank->SW_wait_list);
+
+	ret = _tdm_vblank_sw_timer_update(private_vblank);
+	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
+		LIST_DEL(&wait_info->link);
+		VER("couldn't update sw timer");
+		return ret;
+		/* LCOV_EXCL_STOP */
+	}
+
+	return TDM_ERROR_NONE;
 }
 
-tdm_error
+EXTERN tdm_error
 tdm_vblank_wait(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
 				unsigned int interval, tdm_vblank_handler func, void *user_data)
 {
 	tdm_private_vblank *private_vblank = vblank;
 	tdm_vblank_wait_info *wait_info;
+	tdm_output_dpms dpms = TDM_OUTPUT_DPMS_OFF;
+	unsigned int fps;
 	tdm_error ret;
 
-	TDM_RETURN_VAL_IF_FAIL(private_vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
 	TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 
-	if (private_vblank->dpms != TDM_OUTPUT_DPMS_ON && !private_vblank->enable_fake) {
-		VIN("can't wait a vblank because of DPMS off");
-		return TDM_ERROR_DPMS_OFF;
+	if (private_vblank->in_create_handler) {
+		TDM_ERR("NOT allowed to be called in a create handler");
+		return TDM_ERROR_BAD_REQUEST;
 	}
 
-#if 0
-	if (!private_vblank->SW_align_wait && private_vblank->dpms == TDM_OUTPUT_DPMS_ON)
-		_tdm_vblank_sw_timer_align(private_vblank);
-#endif
+	if (private_vblank->owner_tid != syscall(SYS_gettid)) {
+		TDM_ERR("SHOULD be called in the owner thread(%d)", (int)private_vblank->owner_tid);
+		return TDM_ERROR_BAD_REQUEST;
+	}
 
-	if (private_vblank->check_HW_or_SW) {
-		private_vblank->check_HW_or_SW = 0;
-		private_vblank->vblank_gap = (double)1000000 / private_vblank->fps;
-		private_vblank->HW_quotient = private_vblank->vrefresh / private_vblank->fps;
+	tdm_output_get_dpms(private_vblank->output, &dpms);
 
-		if (private_vblank->dpms == TDM_OUTPUT_DPMS_ON &&
-			!(private_vblank->vrefresh % private_vblank->fps)) {
-			private_vblank->HW_enable = 1;
-			VIN("Use HW vblank");
-		} else {
-			private_vblank->HW_enable = 0;
-			VIN("Use SW vblank");
+	if (!private_vblank->enable_fake) {
+		if (private_vblank->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+			VER("can't wait a vblank: output disconnected");
+			return TDM_ERROR_OUTPUT_DISCONNECTED;
+		}
+		if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms)) {
+			VER("can't wait a vblank: DPMS %s", tdm_dpms_str(dpms));
+			return TDM_ERROR_DPMS_OFF;
 		}
 	}
 
-	wait_info = calloc(1, sizeof *wait_info);
+	wait_info = calloc(1, sizeof * wait_info);
 	if (!wait_info) {
+		/* LCOV_EXCL_START */
 		VER("alloc failed");
 		return TDM_ERROR_OUT_OF_MEMORY;
+		/* LCOV_EXCL_STOP */
+	}
+	_tdm_vblank_update_output_info(private_vblank);
+
+	/* set request time to current time if 0. This function seems to be called in server side. */
+	if (req_sec == 0 && req_usec == 0) {
+		double curr = tdm_helper_get_time();
+		req_sec = TDM_TIME_SEC(curr);
+		req_usec = TDM_TIME_USEC(curr);
 	}
 
 	LIST_INITHEAD(&wait_info->link);
-	LIST_ADDTAIL(&wait_info->valid_link, &valid_wait_list);
+
+	_tdm_vblank_valid_list_add(&wait_info->valid_link, &valid_wait_list);
+
 	wait_info->stamp = ++stamp;
-	wait_info->req_sec = req_sec;
-	wait_info->req_usec = req_usec;
+	wait_info->req_time = TDM_TIME(req_sec, req_usec);
 	wait_info->interval = interval;
 	wait_info->func = func;
 	wait_info->user_data = user_data;
 	wait_info->private_vblank = private_vblank;
 
-	_tdm_vblank_calculate_target(wait_info);
+	if (!private_vblank->resource ||
+		private_vblank->ignore_global_fps ||
+		vblank_global_fps == 0 ||
+		private_vblank->fps < vblank_global_fps)
+		fps = private_vblank->fps;
+	else
+		fps = vblank_global_fps;
 
-	if (private_vblank->HW_enable)
-		ret = _tdm_vblank_wait_HW(wait_info);
+	if (private_vblank->check_HW_or_SW) {
+		private_vblank->check_HW_or_SW = 0;
+		private_vblank->vblank_gap = 1.0 / fps;
+		private_vblank->quotient = private_vblank->vrefresh / fps;
+	}
+
+	/* 1) if fps != factor of vrefresh, SW timer
+	 * 2) if fps == factor of vrefresh && dpms == off, SW timer (Fake HW vblank)
+	 * 2) if fps == factor of vrefresh && dpms == on && offset == 0, HW vblank
+	 * 3) if fps == factor of vrefresh && dpms == on && offset != 0, HW vblank + SW timer
+	 * In case of 1), we really don't need to align with HW vblank.
+	 */
+	if (private_vblank->vrefresh % fps)
+		wait_info->type = VBLANK_TYPE_SW;
+	else if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms) ||
+			 private_vblank->connection != TDM_OUTPUT_CONN_STATUS_MODE_SETTED)
+		wait_info->type = VBLANK_TYPE_SW_FAKE;
+	else if (private_vblank->offset == 0)
+		wait_info->type = VBLANK_TYPE_HW;
 	else
+		wait_info->type = VBLANK_TYPE_HW_SW;
+
+	if (wait_info->type == VBLANK_TYPE_SW || wait_info->type == VBLANK_TYPE_SW_FAKE) {
 		ret = _tdm_vblank_wait_SW(wait_info);
+		if (ret != TDM_ERROR_NONE)
+			TDM_ERR("_tdm_vblank_wait_SW failed: ret(%d)", ret);
+	} else {
+		ret = _tdm_vblank_wait_HW(wait_info);
+		if (ret != TDM_ERROR_NONE)
+			TDM_ERR("_tdm_vblank_wait_HW failed: ret(%d)", ret);
+
+		if (ret == TDM_ERROR_OUTPUT_DISCONNECTED || ret == TDM_ERROR_DPMS_OFF) {
+			ret = _tdm_vblank_wait_SW(wait_info);
+			if (ret != TDM_ERROR_NONE)
+				TDM_ERR("_tdm_vblank_wait_SW failed: ret(%d)", ret);
+		}
+	}
 
 	if (ret != TDM_ERROR_NONE) {
+		/* LCOV_EXCL_START */
 		LIST_DEL(&wait_info->link);
-		LIST_DEL(&wait_info->valid_link);
+		_tdm_vblank_valid_list_del(&wait_info->valid_link);
+
+		tdm_display_lock(private_vblank->dpy);
+		tdm_output_remove_vblank_handler_internal(private_vblank->output, _tdm_vblank_cb_vblank_HW, wait_info);
+		tdm_display_unlock(private_vblank->dpy);
+
 		free(wait_info);
 		return ret;
+		/* LCOV_EXCL_STOP */
 	}
 
+	tdm_display_lock(private_vblank->dpy);
+	_tdm_vblank_timeout_timer_update(private_vblank, 1000);
+	tdm_display_unlock(private_vblank->dpy);
+
 	return TDM_ERROR_NONE;
 }
+
+EXTERN tdm_error
+tdm_vblank_wait_seq(tdm_vblank *vblank, unsigned int req_sec, unsigned int req_usec,
+					unsigned int sequence, tdm_vblank_handler func, void *user_data)
+{
+	tdm_private_vblank *private_vblank = vblank;
+	unsigned int interval;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
+
+	/* if the sequence of vblank reaches the max value, sequence can be 0. */
+
+	if (private_vblank->last_seq == 0) {
+		VWR("can't calculate interval with sequence(%u)", sequence);
+		interval = 1;
+	} else if (sequence > private_vblank->last_seq ||
+			   TDM_VBLANK_SEQ_REACHED_MAX(sequence, private_vblank->last_seq)) {
+		double last, curr, seq_target;
+
+		last = private_vblank->last_time;
+		curr = tdm_helper_get_time();
+		seq_target = last + private_vblank->vblank_gap * (sequence - private_vblank->last_seq);
+
+		/* If target is old or too close(1ms) to current, we call the handler immediately.
+		 * 2ms? it seems too much.
+		 */
+		if (seq_target < curr) {
+			func(vblank, TDM_ERROR_NONE, sequence,
+				 TDM_TIME_SEC(seq_target), TDM_TIME_USEC(seq_target),
+				 user_data);
+			return TDM_ERROR_NONE;
+		} else if ((seq_target - curr) < 0.001) {  /* 1ms */
+			func(vblank, TDM_ERROR_NONE, sequence,
+				 TDM_TIME_SEC(curr), TDM_TIME_USEC(curr),
+				 user_data);
+			return TDM_ERROR_NONE;
+		}
+
+		interval = (unsigned int)((seq_target - curr) / private_vblank->vblank_gap + TDM_TIME_MARGIN) + 1;
+	} else {
+		/* this seems error. But we handle this like normal to avoid the unexpected error in cliend side */
+		VER("sequence(%u) should be over the last sequence(%u)", sequence, private_vblank->last_seq);
+		func(vblank, TDM_ERROR_NONE, private_vblank->last_seq,
+			 TDM_TIME_SEC(private_vblank->last_time), TDM_TIME_USEC(private_vblank->last_time),
+			 user_data);
+		return TDM_ERROR_NONE;
+	}
+
+	return tdm_vblank_wait(vblank, req_sec, req_usec, interval, func, user_data);
+}
+
+/* LCOV_EXCL_START */
+INTERN tdm_error
+tdm_vblank_set_add_front(tdm_vblank *vblank, unsigned int add_front)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+
+	TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED);
+
+	if (private_vblank->add_front == add_front)
+		return TDM_ERROR_NONE;
+
+	private_vblank->add_front = add_front;
+
+	return TDM_ERROR_NONE;
+}
+/* LCOV_EXCL_STOP */
+
+INTERN tdm_error
+tdm_vblank_set_resource(tdm_vblank *vblank, struct wl_resource *resource)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+	TDM_RETURN_VAL_IF_FAIL(private_vblank->resource == NULL, TDM_ERROR_OPERATION_FAILED);
+
+	private_vblank->resource = resource;
+
+	return TDM_ERROR_NONE;
+}
+
+INTERN double
+tdm_vblank_get_stamp(tdm_vblank *vblank)
+{
+	tdm_private_vblank *private_vblank = vblank;
+
+	TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(vblank), TDM_ERROR_INVALID_PARAMETER);
+
+	return private_vblank->stamp;
+}
+
+static unsigned int
+_tdm_vblank_get_waiting_count(tdm_private_vblank *private_vblank)
+{
+	tdm_vblank_wait_info *wait_info = NULL;
+	unsigned int count = 0;
+
+	LIST_FOR_EACH_ENTRY(wait_info, &private_vblank->HW_wait_list, link) {
+		count++;
+	}
+
+	LIST_FOR_EACH_ENTRY(wait_info, &private_vblank->SW_wait_list, link) {
+		count++;
+	}
+
+	return count;
+}
+
+static void
+_tdm_vblank_get_client_information(tdm_private_vblank *private_vblank, pid_t *pid, const char **name)
+{
+	struct wl_client *client;
+
+	if (!private_vblank->resource)
+		goto no_client;
+
+	client = wl_resource_get_client(private_vblank->resource);
+	if (!client)
+		goto no_client;
+
+	wl_client_get_credentials(client, pid, NULL, NULL);
+	*name = tdm_server_get_client_name(*pid);
+
+	return;
+
+no_client:
+	*pid = 0;
+	*name = NULL;
+	return;
+}
+
+/* LCOV_EXCL_START */
+INTERN void
+tdm_vblank_get_vblank_list_information(tdm_display *dpy, char *reply, int *len)
+{
+	tdm_private_vblank *v = NULL;
+	tdm_output_dpms dpms = TDM_OUTPUT_DPMS_OFF;
+	tdm_output *output = tdm_display_get_output(dpy, 0, NULL);
+
+	if (output)
+		tdm_output_get_dpms(output, &dpms);
+
+	TDM_SNPRINTF(reply, len, "[Client Vblank List]\n");
+	TDM_SNPRINTF(reply, len, "* DPMS: %s\n", tdm_dpms_str(dpms));
+	TDM_SNPRINTF(reply, len, "* global fps: %u\n", vblank_global_fps);
+	TDM_SNPRINTF(reply, len, "----------------------------------------------------------------------------------\n");
+	TDM_SNPRINTF(reply, len, "Name                 Type Wait Interval Sequence Fps Ignore Offset Fake Process\n");
+	TDM_SNPRINTF(reply, len, "----------------------------------------------------------------------------------\n");
+
+	pthread_mutex_lock(&valid_list_lock);
+	LIST_FOR_EACH_ENTRY(v, &valid_vblank_list, valid_link) {
+		const char *proc_name = NULL;
+		pid_t pid = 0;
+		unsigned int count;
+
+		_tdm_vblank_get_client_information(v, &pid, &proc_name);
+
+		count = _tdm_vblank_get_waiting_count(v);
+
+		TDM_SNPRINTF(reply, len, "%-8s(%p) ", v->name, v);
+		TDM_SNPRINTF(reply, len, "%-4s ", (v->last_type == VBLANK_EVENT_TYPE_HW) ? "HW" : "SW");
+		TDM_SNPRINTF(reply, len, "%-4s ", (count > 0) ? "O" : " ");
+		TDM_SNPRINTF(reply, len, "%-8d ", v->last_interval);
+		TDM_SNPRINTF(reply, len, "%-8u ", v->last_seq);
+		TDM_SNPRINTF(reply, len, "%-3u ", v->fps);
+		TDM_SNPRINTF(reply, len, "%-6u ", v->ignore_global_fps);
+		TDM_SNPRINTF(reply, len, "%-6d ", v->offset);
+		TDM_SNPRINTF(reply, len, "%-4u ", v->enable_fake);
+		TDM_SNPRINTF(reply, len, "%s(pid:%d)\n", (proc_name) ? proc_name : "Unknown", pid);
+	}
+	pthread_mutex_unlock(&valid_list_lock);
+
+	TDM_SNPRINTF(reply, len, "\n");
+}
+/* LCOV_EXCL_STOP */
+