void *user_data;
} tdm_vblank_create_handler_info;
-/* valid_vblank_list and valid_wait_list should be protected by valid_list_lock because
- * tdm_vblank can be used in multi-thread.
+/* 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;
+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_global_fps;
static double stamp = 0;
-static tdm_error _tdm_vblank_cb_vblank_SW(void *user_data);
+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);
static void _tdm_vblank_cb_vblank_HW(tdm_output *output, unsigned int sequence,
unsigned int tv_sec, unsigned int tv_usec,
#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
pthread_mutex_unlock(&valid_list_lock);
}
-static inline tdm_private_vblank*
-_tdm_vblank_find(double vblank_stamp)
+static inline void*
+_tdm_vblank_find_object(tdm_private_display *private_display, double vblank_stamp)
{
tdm_private_vblank *v = NULL;
- if (!vblank_stamp)
- return 0;
-
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 0;
+ return NULL;
}
static inline unsigned int
pid_t pid;
const char *proc_name;
_tdm_vblank_get_client_information(private_vblank, &pid, &proc_name);
- VER("TDM HW vblank destroyed forcely!! (pid: %u, name: %s)", 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) {
tdm_display_unlock(private_vblank->dpy);
VDB("wait(%p) last(%.6f) sequence(%u) done (error:%d, call_cb:%u)",
- w, 0, w->target_seq, error, call_cb);
+ 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);
{
tdm_output *output = private_vblank->output;
tdm_output_conn_status connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
- unsigned int vrefresh = 0;
+ unsigned int vrefresh = TDM_VBLANK_DEFAULT_VREFRESH;
tdm_error ret;
ret = tdm_output_get_conn_status(output, &connection);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
- if (connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
+ if (connection == TDM_OUTPUT_CONN_STATUS_MODE_SETTED) {
const tdm_output_mode *mode = NULL;
tdm_output_get_mode(output, &mode);
if (mode)
VWR("mode not setted!!!");
}
- if (vrefresh == 0) {
- VWR("vrefresh can't be zero !!!");
- vrefresh = TDM_VBLANK_DEFAULT_VREFRESH;
- }
-
private_vblank->connection = connection;
private_vblank->vrefresh = vrefresh;
private_vblank->HW_vblank_gap = 1.0 / private_vblank->vrefresh;
return TDM_ERROR_NONE;
}
-INTERN tdm_error
-tdm_vblank_cb_vblank_create(tdm_vblank *vblank, double vblank_stamp)
+static void
+_tdm_vblank_thread_cb_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *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;
- tdm_vblank_create_handler_info *ch_info = NULL, *hh = NULL;
- TDM_RETURN_VAL_IF_FAIL(vblank || vblank_stamp > 0, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- if (vblank)
- private_vblank = vblank;
- else {
- private_vblank = _tdm_vblank_find(vblank_stamp);
- if (!private_vblank) {
- TDM_DBG("can't find vblank(%.0f) from valid_list", vblank_stamp);
- return TDM_ERROR_NONE;
- }
- }
+ assert(ch_info != NULL);
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- tdm_thread_cb_vblank_create vblank_create;
- tdm_private_display *private_display = private_vblank->dpy;
- tdm_error ret;
+ 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;
+ }
- vblank_create.base.type = TDM_THREAD_CB_VBLANK_CREATE;
- vblank_create.base.length = sizeof vblank_create;
- vblank_create.vblank_stamp = private_vblank->stamp;
+ 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;
+}
- ret = tdm_thread_send_cb(private_display->private_loop, &vblank_create.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+static tdm_error
+_tdm_vblank_call_thread_cb(tdm_private_vblank *private_vblank)
+{
+ tdm_thread_cb_vblank_create vblank_create;
+ tdm_error ret;
- return TDM_ERROR_NONE;
- }
+ 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;
- LIST_FOR_EACH_ENTRY_SAFE(ch_info, hh, &create_handler_list, link) {
- private_vblank->in_create_handler = 1;
- ch_info->func(private_vblank, ch_info->user_data);
- private_vblank->in_create_handler = 0;
- }
+ ret = tdm_thread_cb_call(private_vblank->dpy, &vblank_create.base);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
return TDM_ERROR_NONE;
}
EXTERN tdm_error
tdm_vblank_add_create_handler(tdm_display *dpy, tdm_vblank_create_handler func, void *user_data)
{
- tdm_vblank_create_handler_info *ch_info;
+ tdm_vblank_create_handler_info *ch_info = NULL;
+ tdm_error ret;
+ TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
- /* we don't allow adding a create handler in sub-thread because tdm_vblank_create()
- * can be called in both threads and tdm_thread_send_cb supports only one-way
- * communication now.
- */
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- TDM_ERR("add_create_handler should be called in main thread");
- return TDM_ERROR_BAD_REQUEST;
+ 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);
- TDM_RETURN_VAL_IF_FAIL(ch_info != NULL, TDM_ERROR_OUT_OF_MEMORY);
+ if (!ch_info) {
+ TDM_ERR("alloc failed: %m");
+ pthread_mutex_unlock(&valid_list_lock);
+ return TDM_ERROR_OUT_OF_MEMORY;
+ }
+
+ 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) {
+ TDM_ERR("tdm_thread_cb_add failed");
+ free(ch_info);
+ pthread_mutex_unlock(&valid_list_lock);
+ return ret;
+ }
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;
}
{
tdm_vblank_create_handler_info *ch_info = NULL, *hh = NULL;
- /* we don't allow adding a create handler in sub-thread because tdm_vblank_create()
- * can be called in both threads and tdm_thread_send_cb supports only one-way
- * communication now.
- */
- if (!tdm_thread_in_display_thread(syscall(SYS_gettid))) {
- TDM_ERR("remove_create_handler should be called in main thread");
- return;
- }
+ TDM_RETURN_IF_FAIL(dpy != NULL);
+ TDM_RETURN_IF_FAIL(func != NULL);
+ 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)
+ if (ch_info->func != func || ch_info->user_data != user_data)
continue;
+ tdm_thread_cb_remove(dpy, TDM_THREAD_CB_VBLANK_CREATE, NULL, _tdm_vblank_thread_cb_create, ch_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);
+}
+
+static void*
+_tdm_vblank_find_display(tdm_private_display *private_display, double stamp)
+{
+ return private_display;
}
INTERN tdm_error
if (vblank_list_inited)
return TDM_ERROR_NONE;
- if (pthread_mutex_init(&valid_list_lock, NULL)) {
- TDM_ERR("mutex init failed: %m");
- return TDM_ERROR_OUT_OF_MEMORY;
- }
-
LIST_INITHEAD(&valid_vblank_list);
LIST_INITHEAD(&valid_wait_list);
LIST_INITHEAD(&create_handler_list);
+ 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);
+
vblank_list_inited = 1;
return TDM_ERROR_NONE;
free(ch_info);
}
- pthread_mutex_destroy(&valid_list_lock);
-
vblank_list_inited = 0;
}
private_vblank->vrefresh, private_vblank->connection);
tdm_display_lock(private_vblank->dpy);
- tdm_vblank_cb_vblank_create(NULL, private_vblank->stamp);
+ _tdm_vblank_call_thread_cb(private_vblank);
tdm_display_unlock(private_vblank->dpy);
return (tdm_vblank *)private_vblank;
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);
}
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_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
if (private_vblank->fps_fixed) {
- VIN("fps(%d) can't be changed", private_vblank->fps);
+ VIN("fps(%u) can't be changed", private_vblank->fps);
return TDM_ERROR_NONE;
}
private_vblank->fps = fps;
private_vblank->check_HW_or_SW = 1;
- VIN("fps(%d) changed", fps);
+ VIN("fps(%u) changed", fps);
return TDM_ERROR_NONE;
}
private_vblank->fps = fps;
private_vblank->check_HW_or_SW = 1;
- VIN("fps(%d) fixed", fps);
+ VIN("fps(%u) fixed", fps);
return TDM_ERROR_NONE;
}
private_vblank->ignore_global_fps = ignore;
private_vblank->check_HW_or_SW = 1;
- VIN("ignore_global_fps(%d)", private_vblank->ignore_global_fps);
+ VIN("ignore_global_fps(%u)", private_vblank->ignore_global_fps);
return TDM_ERROR_NONE;
}
private_vblank->offset = offset;
private_vblank->check_HW_or_SW = 1;
- VIN("offset(%d)", private_vblank->offset);
+ VIN("offset(%u)", private_vblank->offset);
return TDM_ERROR_NONE;
}
private_vblank->enable_fake = enable_fake;
- VIN("enable_fake(%d)", private_vblank->enable_fake);
+ VIN("enable_fake(%u)", private_vblank->enable_fake);
return TDM_ERROR_NONE;
}
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) {
VER("couldn't add timer");
return ret;
}
+
+ 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 = wait_info->private_vblank;
TDM_RETURN_IF_FAIL(tdm_vblank_is_valid(private_vblank));
+ assert(private_vblank->owner_tid == syscall(SYS_gettid));
+
if (!_tdm_vblank_find_wait(wait_info, &private_vblank->HW_wait_list)) {
VER("can't find wait(%p)", wait_info);
return;
ret = _tdm_vblank_sw_timer_update(private_vblank);
- /* wait_info will be freed in _tdm_vblank_cb_vblank_SW() */
+ /* wait_info will be freed in _tdm_vblank_cb_timeout_SW() */
if (ret == TDM_ERROR_NONE) {
VIN("wait(%p) SW timer", wait_info);
return;
return TDM_ERROR_NONE;
}
-static tdm_error
-_tdm_vblank_cb_vblank_SW(void *user_data)
-{
- tdm_private_vblank *private_vblank = user_data;
-
- TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(private_vblank), TDM_ERROR_OPERATION_FAILED);
-
- return tdm_vblank_cb_vblank_SW(private_vblank, 0);
-}
-
-INTERN tdm_error
-tdm_vblank_cb_vblank_SW(tdm_vblank *vblank, double vblank_stamp)
+static void
+_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;
+ tdm_private_vblank *private_vblank = object;
tdm_vblank_wait_info *first_wait_info = NULL, *w = NULL, *ww = NULL;
- TDM_RETURN_VAL_IF_FAIL(vblank || vblank_stamp > 0, TDM_ERROR_INVALID_PARAMETER);
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
- if (vblank)
- private_vblank = vblank;
- else {
- private_vblank = _tdm_vblank_find(vblank_stamp);
- if (!private_vblank) {
- TDM_ERR("can't find vblank(%.0f) from valid_list", vblank_stamp);
- return TDM_ERROR_NONE;
- }
- }
-
- if (private_vblank->owner_tid != syscall(SYS_gettid)) {
- tdm_thread_cb_vblank_sw vblank_sw;
- tdm_private_display *private_display = private_vblank->dpy;
- tdm_error ret;
-
- vblank_sw.base.type = TDM_THREAD_CB_VBLANK_SW;
- vblank_sw.base.length = sizeof vblank_sw;
- vblank_sw.vblank_stamp = private_vblank->stamp;
-
- ret = tdm_thread_send_cb(private_display->private_loop, &vblank_sw.base);
- TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
-
- return TDM_ERROR_NONE;
- }
+ assert(private_vblank->owner_tid == syscall(SYS_gettid));
if (LIST_IS_EMPTY(&private_vblank->SW_wait_list)) {
VER("no wait_info");
- return TDM_ERROR_OPERATION_FAILED;
+ return;
}
if (!LIST_IS_EMPTY(&private_vblank->HW_wait_list))
TDM_NEVER_GET_HERE();
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_RETURN_IF_FAIL(first_wait_info != NULL);
_tdm_vblank_timeout_timer_update(private_vblank, 0);
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;
+
+ TDM_RETURN_VAL_IF_FAIL(tdm_vblank_is_valid(private_vblank), TDM_ERROR_OPERATION_FAILED);
+
+ 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);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
return TDM_ERROR_NONE;
}
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->in_create_handler) {
TDM_ERR("NOT allowed to be called in a create handler");
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) {
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_DISCONNECTED)
+ 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;
projects / platform / core / uifw / libtdm.git / blobdiff