1 /**************************************************************************
5 * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
7 * Contact: Eunchul Kim <chulspro.kim@samsung.com>,
8 * JinYoung Jeon <jy0.jeon@samsung.com>,
9 * Taeheon Kim <th908.kim@samsung.com>,
10 * YoungJun Cho <yj44.cho@samsung.com>,
11 * SooChan Lim <sc1.lim@samsung.com>,
12 * Boram Park <sc1.lim@samsung.com>
14 * Permission is hereby granted, free of charge, to any person obtaining a
15 * copy of this software and associated documentation files (the
16 * "Software"), to deal in the Software without restriction, including
17 * without limitation the rights to use, copy, modify, merge, publish,
18 * distribute, sub license, and/or sell copies of the Software, and to
19 * permit persons to whom the Software is furnished to do so, subject to
20 * the following conditions:
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
27 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
29 * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
30 * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
31 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
32 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
34 **************************************************************************/
47 #include <tdm-client-protocol.h>
49 #include "tdm_client.h"
51 #include "tdm_macro.h"
54 #include "tdm_private.h"
56 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
58 typedef struct _tdm_private_client {
61 struct wl_display *display;
62 struct wl_event_queue *queue;
63 struct wl_registry *registry;
65 struct list_head output_list;
67 unsigned int enable_ttrace;
70 tdm_private_client_vblank *temp_vblank;
73 typedef struct _tdm_private_client_output {
74 tdm_private_client *private_client;
76 char name[TDM_NAME_LEN];
77 struct wl_tdm_output *output;
81 tdm_output_conn_status connection;
83 struct list_head vblank_list;
84 struct list_head change_handler_list;
87 unsigned int watch_output_changes;
89 struct list_head link;
90 } tdm_private_client_output;
92 struct _tdm_private_client_vblank {
93 tdm_private_client_output *private_output;
95 struct wl_tdm_vblank *vblank;
96 struct list_head wait_list;
98 char name[TDM_NAME_LEN];
102 unsigned int enable_fake;
103 unsigned int enable_ttrace;
105 unsigned int started;
111 struct list_head link;
114 typedef struct _tdm_client_output_handler_info {
115 tdm_private_client_output *private_output;
117 tdm_client_output_change_handler func;
120 struct list_head link;
121 struct list_head call_link;
122 } tdm_client_output_handler_info;
124 typedef struct _tdm_client_wait_info {
125 tdm_private_client_vblank *private_vblank;
127 tdm_client_vblank_handler func;
134 struct list_head link;
135 struct list_head call_link;
136 } tdm_client_wait_info;
139 _tdm_client_check_wl_error(tdm_private_client *private_client, const char *func, int line)
142 const struct wl_interface *intf;
145 err = wl_display_get_error(private_client->display);
149 if (err == EINVAL || err == ENOMEM || err == EFAULT || err == EPROTO) {
150 ec = wl_display_get_protocol_error(private_client->display, &intf, &id);
151 TDM_ERR("[%s,%d] errno(%d) Got protocol error '%u' on interface '%s' (object '%u')",
152 func, line, err, ec, (intf) ? intf->name : "destroyed", id);
154 TDM_ERR("[%s,%d] errno(%d)", func, line, err);
160 #define CHECK_WL_PROTOCOL_ERROR(pc) _tdm_client_check_wl_error(pc, __FUNCTION__, __LINE__)
163 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
165 tdm_private_client_vblank *private_vblank = data;
166 tdm_private_client *private_client;
168 TDM_RETURN_IF_FAIL(private_vblank != NULL);
170 private_vblank->stamp = stamp;
172 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
173 private_client = private_vblank->private_output->private_client;
175 private_client->stamp = stamp;
178 /* LCOV_EXCL_START */
180 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
181 uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
182 uint32_t tv_usec, uint32_t error)
184 tdm_private_client_vblank *private_vblank = data;
185 tdm_private_client *private_client;
186 tdm_client_wait_info *w = NULL, *wait_info = NULL;
188 TDM_RETURN_IF_FAIL(private_vblank != NULL);
190 private_client = private_vblank->private_output->private_client;
192 private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
194 TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
195 private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
197 LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) {
198 if (w->req_id != req_id)
206 TDM_ERR("no wait infomation for req_id(%d)", req_id);
210 if (private_vblank->enable_ttrace)
211 TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
213 if (wait_info->req_time >= private_vblank->last_time)
214 TDM_WRN("'req(%.6f) < last(%.6f)' failed. error(%d)", wait_info->req_time, private_vblank->last_time, error);
216 if (wait_info->need_free)
217 LIST_DEL(&wait_info->link);
219 if (wait_info->func) {
220 pthread_mutex_unlock(&private_client->lock);
221 wait_info->func(private_vblank, error, sequence, tv_sec, tv_usec, wait_info->user_data);
222 pthread_mutex_lock(&private_client->lock);
225 if (wait_info->need_free)
228 wait_info->need_free = 1;
232 /* LCOV_EXCL_START */
234 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
236 tdm_private_client_vblank *private_vblank = data;
237 tdm_private_client *private_client;
239 TDM_RETURN_IF_FAIL(private_vblank != NULL);
241 private_vblank->enable_ttrace = enable;
243 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
244 private_client = private_vblank->private_output->private_client;
246 private_client->enable_ttrace = enable;
250 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
251 _tdm_client_vblank_cb_stamp,
252 _tdm_client_vblank_cb_done,
253 _tdm_client_vblank_cb_ttrace,
257 _tdm_client_output_destroy(tdm_private_client_output *private_output)
259 tdm_private_client_vblank *v = NULL, *vv = NULL;
260 tdm_client_output_handler_info *h = NULL, *hh = NULL;
262 LIST_DEL(&private_output->link);
264 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
265 TDM_ERR("vblanks SHOULD be destroyed first!");
267 v->private_output = NULL;
270 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
275 wl_tdm_output_destroy(private_output->output);
277 free(private_output);
281 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
282 uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
284 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
286 TDM_RETURN_IF_FAIL(private_output != NULL);
288 private_output->width = width;
289 private_output->height = height;
290 private_output->refresh = refresh;
292 if (error != TDM_ERROR_NONE)
293 TDM_INFO("mode event error: %d", error);
295 TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
296 private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
297 width, height, refresh);
301 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
303 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
304 tdm_private_client *private_client;
305 tdm_client_output_handler_info *h = NULL, *hh = NULL;
307 struct list_head call_list;
309 TDM_RETURN_IF_FAIL(private_output != NULL);
311 private_client = private_output->private_client;
313 if (private_output->connection == value)
316 private_output->connection = value;
318 if (error != TDM_ERROR_NONE)
319 TDM_INFO("connection event error: %d", error);
321 TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
323 wl_proxy_get_id((struct wl_proxy*)private_output->output),
326 LIST_INITHEAD(&call_list);
328 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
329 LIST_ADDTAIL(&h->call_link, &call_list);
333 pthread_mutex_unlock(&private_client->lock);
334 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
336 h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
338 pthread_mutex_lock(&private_client->lock);
342 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
344 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
345 tdm_private_client *private_client;
346 tdm_client_output_handler_info *h = NULL, *hh = NULL;
348 struct list_head call_list;
350 TDM_RETURN_IF_FAIL(private_output != NULL);
352 private_client = private_output->private_client;
354 /* If value is extended value, we handle it as DPMS on in client side
355 * The extended DPMS value is valid only in server side.
356 * Or, need to export to client side also?
358 if (value > TDM_OUTPUT_DPMS_OFF)
359 value = TDM_OUTPUT_DPMS_ON;
361 if (private_output->dpms == value)
364 private_output->dpms = value;
366 if (error != TDM_ERROR_NONE)
367 TDM_INFO("dpms event error: %d", error);
369 TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
371 wl_proxy_get_id((struct wl_proxy*)private_output->output),
374 LIST_INITHEAD(&call_list);
376 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
377 LIST_ADDTAIL(&h->call_link, &call_list);
381 pthread_mutex_unlock(&private_client->lock);
382 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
384 h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
386 pthread_mutex_lock(&private_client->lock);
389 static const struct wl_tdm_output_listener tdm_client_output_listener = {
390 _tdm_client_output_cb_mode,
391 _tdm_client_output_cb_connection,
392 _tdm_client_output_cb_dpms,
396 _tdm_client_cb_global(void *data, struct wl_registry *registry,
397 uint32_t name, const char *interface,
400 tdm_private_client *private_client = data;
402 if (strncmp(interface, "wl_tdm", 6) == 0) {
403 private_client->tdm =
404 wl_registry_bind(registry, name, &wl_tdm_interface, version);
405 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
407 wl_display_flush(private_client->display);
411 /* LCOV_EXCL_START */
413 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
418 static const struct wl_registry_listener tdm_client_registry_listener = {
419 _tdm_client_cb_global,
420 _tdm_client_cb_global_remove
424 tdm_client_create(tdm_error *error)
426 tdm_private_client *private_client;
428 private_client = calloc(1, sizeof *private_client);
429 if (!private_client) {
430 /* LCOV_EXCL_START */
432 TDM_ERR("alloc failed");
434 *error = TDM_ERROR_OUT_OF_MEMORY;
440 if (pthread_mutex_init(&private_client->lock, NULL)) {
441 TDM_ERR("mutex init failed: %m");
442 free(private_client);
444 *error = TDM_ERROR_OUT_OF_MEMORY;
448 LIST_INITHEAD(&private_client->output_list);
450 private_client->display = wl_display_connect("tdm-socket");
451 TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
453 private_client->queue = wl_display_create_queue(private_client->display);
454 TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed);
456 private_client->registry = wl_display_get_registry(private_client->display);
457 TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
459 wl_registry_add_listener(private_client->registry,
460 &tdm_client_registry_listener, private_client);
461 wl_display_roundtrip(private_client->display);
463 if (CHECK_WL_PROTOCOL_ERROR(private_client))
466 /* check global objects */
467 TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
470 *error = TDM_ERROR_NONE;
472 return (tdm_client*)private_client;
474 tdm_client_destroy((tdm_client*)private_client);
476 *error = TDM_ERROR_OPERATION_FAILED;
481 tdm_client_destroy(tdm_client *client)
483 tdm_private_client *private_client = (tdm_private_client*)client;
484 tdm_private_client_output *o = NULL, *oo = NULL;
489 pthread_mutex_lock(&private_client->lock);
491 if (private_client->temp_vblank) {
492 pthread_mutex_unlock(&private_client->lock);
493 tdm_client_vblank_destroy(private_client->temp_vblank);
494 pthread_mutex_lock(&private_client->lock);
497 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
498 _tdm_client_output_destroy(o);
501 if (private_client->tdm)
502 wl_tdm_destroy(private_client->tdm);
503 if (private_client->registry)
504 wl_registry_destroy(private_client->registry);
505 if (private_client->queue)
506 wl_event_queue_destroy(private_client->queue);
507 if (private_client->display)
508 wl_display_disconnect(private_client->display);
510 pthread_mutex_unlock(&private_client->lock);
511 pthread_mutex_destroy(&private_client->lock);
513 free(private_client);
517 tdm_client_get_fd(tdm_client *client, int *fd)
519 tdm_private_client *private_client;
521 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
522 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
524 private_client = (tdm_private_client*)client;
526 pthread_mutex_lock(&private_client->lock);
528 *fd = wl_display_get_fd(private_client->display);
530 pthread_mutex_unlock(&private_client->lock);
533 return TDM_ERROR_OPERATION_FAILED;
535 return TDM_ERROR_NONE;
539 tdm_client_handle_events(tdm_client *client)
541 tdm_private_client *private_client;
543 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
545 /* LCOV_EXCL_START */
546 private_client = (tdm_private_client*)client;
548 pthread_mutex_lock(&private_client->lock);
550 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
551 pthread_mutex_unlock(&private_client->lock);
552 return TDM_ERROR_PROTOCOL_ERROR;
555 if (private_client->enable_ttrace)
556 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
558 wl_display_dispatch(private_client->display);
560 if (private_client->enable_ttrace)
561 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
563 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
564 pthread_mutex_unlock(&private_client->lock);
565 return TDM_ERROR_PROTOCOL_ERROR;
568 pthread_mutex_unlock(&private_client->lock);
570 return TDM_ERROR_NONE;
575 _tdm_client_poll(struct wl_display *display, short int events, int timeout)
578 struct pollfd pfd[1];
580 pfd[0].fd = wl_display_get_fd(display);
581 pfd[0].events = events;
583 ret = poll(pfd, 1, timeout);
584 } while (ret == -1 && errno == EINTR);
590 _tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout)
593 struct wl_display *display = private_client->display;
595 if (wl_display_prepare_read(display) == -1) {
596 if (wl_display_dispatch_pending(display) > 0)
597 return TDM_ERROR_NONE;
599 return TDM_ERROR_OPERATION_FAILED;
603 ret = wl_display_flush(display);
605 if (ret != -1 || errno != EAGAIN)
608 if (_tdm_client_poll(display, POLLOUT, -1) == -1) {
609 wl_display_cancel_read(display);
610 TDM_ERR("_tdm_client_poll failed");
611 return TDM_ERROR_OPERATION_FAILED;
615 /* Don't stop if flushing hits an EPIPE; continue so we can read any
616 * protocol error that may have triggered it. */
617 if (ret < 0 && errno != EPIPE) {
618 TDM_ERR("ret(%d) errno(%d)", ret, errno);
619 wl_display_cancel_read(display);
620 return TDM_ERROR_OPERATION_FAILED;
623 ret = _tdm_client_poll(display, POLLIN, timeout);
625 wl_display_cancel_read(display);
627 TDM_ERR("_tdm_client_poll timeout.");
628 return TDM_ERROR_TIMEOUT;
630 TDM_ERR("_tdm_client_poll failed. (ret:%d)", ret);
631 return TDM_ERROR_OPERATION_FAILED;
635 if (wl_display_read_events(display) == -1) {
636 TDM_ERR("wl_display_read_events failed");
637 return TDM_ERROR_OPERATION_FAILED;
640 ret = wl_display_dispatch_pending(display);
643 TDM_ERR("_tdm_client_dispatch_timeout failed");
644 return TDM_ERROR_OPERATION_FAILED;
647 return TDM_ERROR_NONE;
651 tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout)
653 tdm_private_client *private_client;
655 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
657 private_client = (tdm_private_client*)client;
659 pthread_mutex_lock(&private_client->lock);
661 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
662 pthread_mutex_unlock(&private_client->lock);
663 return TDM_ERROR_PROTOCOL_ERROR;
666 if (private_client->enable_ttrace)
667 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
669 ret = _tdm_client_dispatch_timeout(private_client, ms_timeout);
671 if (private_client->enable_ttrace)
672 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
674 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
675 pthread_mutex_unlock(&private_client->lock);
676 return TDM_ERROR_PROTOCOL_ERROR;
679 pthread_mutex_unlock(&private_client->lock);
684 typedef struct _tdm_client_vblank_temp {
685 tdm_client_vblank_handler2 func;
687 } tdm_client_vblank_temp;
689 /* LCOV_EXCL_START */
691 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
692 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
694 tdm_client_vblank_temp *vblank_temp = user_data;
696 TDM_RETURN_IF_FAIL(vblank_temp != NULL);
697 TDM_RETURN_IF_FAIL(vblank != NULL);
699 if (vblank_temp->func)
700 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
706 /* LCOV_EXCL_START */ /* deprecated */
708 tdm_client_wait_vblank(tdm_client *client, char *name,
709 int sw_timer, int interval, int sync,
710 tdm_client_vblank_handler2 func, void *user_data)
712 tdm_private_client *private_client = (tdm_private_client*)client;
713 tdm_client_output *output;
714 tdm_client_vblank_temp *vblank_temp;
717 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
718 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
719 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
721 if (CHECK_WL_PROTOCOL_ERROR(private_client))
722 return TDM_ERROR_PROTOCOL_ERROR;
724 if (!private_client->temp_vblank) {
725 output = tdm_client_get_output(client, name, &ret);
726 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
728 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
729 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
732 tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
733 tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
735 vblank_temp = calloc(1, sizeof *vblank_temp);
736 TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
738 vblank_temp->func = func;
739 vblank_temp->user_data = user_data;
741 return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
746 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
748 tdm_private_client *private_client;
749 tdm_private_client_output *private_output = NULL;
750 struct wl_proxy *wrapper;
753 *error = TDM_ERROR_NONE;
756 TDM_ERR("'!client' failed");
758 *error = TDM_ERROR_INVALID_PARAMETER;
762 private_client = (tdm_private_client*)client;
764 pthread_mutex_lock(&private_client->lock);
766 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
768 *error = TDM_ERROR_PROTOCOL_ERROR;
769 pthread_mutex_unlock(&private_client->lock);
775 } else if (strncmp(name, "primary", 7) && strncmp(name, "default", 7)) {
777 *error = TDM_ERROR_INVALID_PARAMETER;
778 pthread_mutex_unlock(&private_client->lock);
782 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
783 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
784 pthread_mutex_unlock(&private_client->lock);
785 return (tdm_client_output*)private_output;
789 wrapper = wl_proxy_create_wrapper(private_client->tdm);
791 TDM_ERR("create output_wrapper failed");
793 *error = TDM_ERROR_OUT_OF_MEMORY;
794 pthread_mutex_unlock(&private_client->lock);
798 wl_proxy_set_queue(wrapper, private_client->queue);
800 private_output = calloc(1, sizeof *private_output);
801 if (!private_output) {
802 /* LCOV_EXCL_START */
803 wl_proxy_wrapper_destroy(wrapper);
804 TDM_ERR("alloc failed");
806 *error = TDM_ERROR_OUT_OF_MEMORY;
807 pthread_mutex_unlock(&private_client->lock);
813 private_output->private_client = private_client;
815 snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
816 private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
817 wl_proxy_wrapper_destroy(wrapper);
818 if (!private_output->output) {
819 /* LCOV_EXCL_START */
821 TDM_ERR("couldn't create output resource");
822 free(private_output);
824 *error = TDM_ERROR_OUT_OF_MEMORY;
825 pthread_mutex_unlock(&private_client->lock);
831 LIST_INITHEAD(&private_output->vblank_list);
832 LIST_INITHEAD(&private_output->change_handler_list);
834 wl_tdm_output_add_listener(private_output->output,
835 &tdm_client_output_listener, private_output);
836 wl_display_roundtrip_queue(private_client->display, private_client->queue);
838 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
840 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
841 wl_tdm_output_destroy(private_output->output);
842 free(private_output);
844 *error = TDM_ERROR_PROTOCOL_ERROR;
845 pthread_mutex_unlock(&private_client->lock);
849 LIST_ADDTAIL(&private_output->link, &private_client->output_list);
851 pthread_mutex_unlock(&private_client->lock);
853 return (tdm_client_output*)private_output;
857 tdm_client_output_add_change_handler(tdm_client_output *output,
858 tdm_client_output_change_handler func,
861 tdm_private_client_output *private_output;
862 tdm_private_client *private_client;
863 tdm_client_output_handler_info *h = NULL;
865 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
866 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
868 private_output = (tdm_private_client_output*)output;
869 private_client = private_output->private_client;
871 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
872 if (h->func == func && h->user_data == user_data) {
873 TDM_ERR("can't add twice");
874 return TDM_ERROR_BAD_REQUEST;
878 h = calloc(1, sizeof *h);
879 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
881 pthread_mutex_lock(&private_client->lock);
883 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
885 pthread_mutex_unlock(&private_client->lock);
886 return TDM_ERROR_PROTOCOL_ERROR;
889 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
890 wl_tdm_output_watch_output_changes(private_output->output, 1);
891 wl_display_roundtrip_queue(private_client->display, private_client->queue);
893 /* TODO: this is very tricky.
894 * If a client adds the change_handler, we might be able to guess that
895 * the client will watch the tdm client's fd and handle tdm events in
896 * event loop. Otherwise, we CAN'T make sure if a client has event loop
897 * which handles tdm events.
899 private_output->watch_output_changes = 1;
902 h->private_output = private_output;
904 h->user_data = user_data;
905 LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
906 LIST_INITHEAD(&h->call_link);
908 pthread_mutex_unlock(&private_client->lock);
910 return TDM_ERROR_NONE;
914 tdm_client_output_remove_change_handler(tdm_client_output *output,
915 tdm_client_output_change_handler func,
918 tdm_private_client_output *private_output;
919 tdm_private_client *private_client;
920 tdm_client_output_handler_info *h = NULL;
922 TDM_RETURN_IF_FAIL(output != NULL);
923 TDM_RETURN_IF_FAIL(func != NULL);
925 private_output = (tdm_private_client_output*)output;
926 private_client = private_output->private_client;
928 pthread_mutex_lock(&private_client->lock);
930 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
931 if (h->func != func || h->user_data != user_data)
937 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
938 private_output->watch_output_changes = 0;
939 if (!CHECK_WL_PROTOCOL_ERROR(private_client)) {
940 wl_tdm_output_watch_output_changes(private_output->output, 0);
941 wl_display_roundtrip_queue(private_client->display, private_client->queue);
945 pthread_mutex_unlock(&private_client->lock);
950 pthread_mutex_unlock(&private_client->lock);
954 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
956 tdm_private_client_output *private_output;
957 tdm_private_client *private_client;
959 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
960 TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
962 private_output = (tdm_private_client_output*)output;
963 private_client = private_output->private_client;
965 pthread_mutex_lock(&private_client->lock);
967 if (private_output->watch_output_changes) {
968 *refresh = private_output->refresh;
969 pthread_mutex_unlock(&private_client->lock);
970 return TDM_ERROR_NONE;
973 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
974 pthread_mutex_unlock(&private_client->lock);
975 return TDM_ERROR_PROTOCOL_ERROR;
978 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
979 wl_tdm_output_get_mode(private_output->output);
980 wl_display_roundtrip_queue(private_client->display, private_client->queue);
981 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
983 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
984 pthread_mutex_unlock(&private_client->lock);
985 return TDM_ERROR_PROTOCOL_ERROR;
988 *refresh = private_output->refresh;
990 pthread_mutex_unlock(&private_client->lock);
992 return TDM_ERROR_NONE;
996 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
998 tdm_private_client_output *private_output;
999 tdm_private_client *private_client;
1001 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1002 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
1004 private_output = (tdm_private_client_output*)output;
1005 private_client = private_output->private_client;
1007 pthread_mutex_lock(&private_client->lock);
1009 if (private_output->watch_output_changes) {
1010 *status = private_output->connection;
1011 pthread_mutex_unlock(&private_client->lock);
1012 return TDM_ERROR_NONE;
1015 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1016 pthread_mutex_unlock(&private_client->lock);
1017 return TDM_ERROR_PROTOCOL_ERROR;
1020 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1021 wl_tdm_output_get_connection(private_output->output);
1022 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1023 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1025 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1026 pthread_mutex_unlock(&private_client->lock);
1027 return TDM_ERROR_PROTOCOL_ERROR;
1030 *status = private_output->connection;
1032 pthread_mutex_unlock(&private_client->lock);
1034 return TDM_ERROR_NONE;
1038 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
1040 tdm_private_client_output *private_output;
1041 tdm_private_client *private_client;
1043 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1044 TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
1046 private_output = (tdm_private_client_output*)output;
1047 private_client = private_output->private_client;
1049 if (private_output->watch_output_changes) {
1050 *dpms = private_output->dpms;
1051 return TDM_ERROR_NONE;
1054 pthread_mutex_lock(&private_client->lock);
1056 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1057 pthread_mutex_unlock(&private_client->lock);
1058 return TDM_ERROR_PROTOCOL_ERROR;
1061 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1062 wl_tdm_output_get_dpms(private_output->output);
1063 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1064 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1066 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1067 pthread_mutex_unlock(&private_client->lock);
1068 return TDM_ERROR_PROTOCOL_ERROR;
1071 *dpms = private_output->dpms;
1073 pthread_mutex_unlock(&private_client->lock);
1075 return TDM_ERROR_NONE;
1079 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
1081 tdm_private_client *private_client;
1082 tdm_private_client_output *private_output;
1083 tdm_private_client_vblank *private_vblank;
1084 struct wl_proxy *wrapper;
1087 *error = TDM_ERROR_NONE;
1090 TDM_ERR("'!output' failed");
1092 *error = TDM_ERROR_INVALID_PARAMETER;
1096 private_output = (tdm_private_client_output*)output;
1097 private_client = private_output->private_client;
1099 pthread_mutex_lock(&private_client->lock);
1101 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1103 *error = TDM_ERROR_PROTOCOL_ERROR;
1104 pthread_mutex_unlock(&private_client->lock);
1108 wrapper = wl_proxy_create_wrapper(private_output->output);
1110 TDM_ERR("create output_wrapper failed");
1112 *error = TDM_ERROR_OUT_OF_MEMORY;
1113 pthread_mutex_unlock(&private_client->lock);
1117 wl_proxy_set_queue(wrapper, private_client->queue);
1119 private_vblank = calloc(1, sizeof *private_vblank);
1120 if (!private_vblank) {
1121 /* LCOV_EXCL_START */
1123 TDM_ERR("alloc failed");
1124 wl_proxy_wrapper_destroy(wrapper);
1126 *error = TDM_ERROR_OUT_OF_MEMORY;
1127 pthread_mutex_unlock(&private_client->lock);
1130 /* LCOV_EXCL_STOP */
1133 private_vblank->private_output = private_output;
1135 private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
1136 wl_proxy_wrapper_destroy(wrapper);
1137 if (!private_vblank->vblank) {
1138 /* LCOV_EXCL_START */
1140 TDM_ERR("couldn't create vblank resource");
1141 free(private_vblank);
1143 *error = TDM_ERROR_OUT_OF_MEMORY;
1144 pthread_mutex_unlock(&private_client->lock);
1147 /* LCOV_EXCL_STOP */
1151 private_vblank->fps = private_output->refresh;
1152 private_vblank->offset = 0;
1153 private_vblank->enable_fake = 0;
1155 LIST_INITHEAD(&private_vblank->wait_list);
1157 wl_tdm_vblank_add_listener(private_vblank->vblank,
1158 &tdm_client_vblank_listener, private_vblank);
1159 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1161 wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
1163 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1164 wl_tdm_vblank_destroy(private_vblank->vblank);
1165 free(private_vblank);
1167 *error = TDM_ERROR_PROTOCOL_ERROR;
1168 pthread_mutex_unlock(&private_client->lock);
1172 LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
1174 pthread_mutex_unlock(&private_client->lock);
1176 return (tdm_client_vblank*)private_vblank;
1180 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
1182 tdm_private_client_vblank *private_vblank;
1183 tdm_private_client *private_client;
1184 tdm_client_wait_info *w = NULL, *ww = NULL;
1186 TDM_RETURN_IF_FAIL(vblank != NULL);
1188 private_vblank = vblank;
1189 private_client = private_vblank->private_output->private_client;
1191 pthread_mutex_lock(&private_client->lock);
1193 LIST_DEL(&private_vblank->link);
1195 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
1200 wl_tdm_vblank_destroy(private_vblank->vblank);
1202 free(private_vblank);
1204 pthread_mutex_unlock(&private_client->lock);
1208 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
1210 tdm_private_client_vblank *private_vblank;
1211 tdm_private_client *private_client;
1213 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1215 private_vblank = vblank;
1216 private_client = private_vblank->private_output->private_client;
1218 pthread_mutex_lock(&private_client->lock);
1220 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1221 pthread_mutex_unlock(&private_client->lock);
1222 return TDM_ERROR_PROTOCOL_ERROR;
1226 name = TDM_VBLANK_DEFAULT_NAME;
1228 strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
1229 private_vblank->name[TDM_NAME_LEN - 1] = '\0';
1231 wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
1233 pthread_mutex_unlock(&private_client->lock);
1235 return TDM_ERROR_NONE;
1239 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
1241 tdm_private_client_vblank *private_vblank;
1242 tdm_private_client *private_client;
1244 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1246 private_vblank = vblank;
1247 private_client = private_vblank->private_output->private_client;
1249 pthread_mutex_lock(&private_client->lock);
1250 private_vblank->sync = sync;
1251 pthread_mutex_unlock(&private_client->lock);
1253 return TDM_ERROR_NONE;
1257 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
1259 tdm_private_client_vblank *private_vblank;
1260 tdm_private_client *private_client;
1262 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1263 TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
1265 private_vblank = vblank;
1266 private_client = private_vblank->private_output->private_client;
1268 pthread_mutex_lock(&private_client->lock);
1270 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1271 pthread_mutex_unlock(&private_client->lock);
1272 return TDM_ERROR_PROTOCOL_ERROR;
1275 if (private_vblank->fps == fps) {
1276 pthread_mutex_unlock(&private_client->lock);
1277 return TDM_ERROR_NONE;
1280 private_vblank->fps = fps;
1282 wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
1284 pthread_mutex_unlock(&private_client->lock);
1286 return TDM_ERROR_NONE;
1290 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
1292 tdm_private_client_vblank *private_vblank;
1293 tdm_private_client *private_client;
1295 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1297 private_vblank = vblank;
1298 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
1300 private_client = private_vblank->private_output->private_client;
1302 pthread_mutex_lock(&private_client->lock);
1304 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1305 pthread_mutex_unlock(&private_client->lock);
1306 return TDM_ERROR_PROTOCOL_ERROR;
1309 if (private_vblank->offset == offset_ms) {
1310 pthread_mutex_unlock(&private_client->lock);
1311 return TDM_ERROR_NONE;
1314 private_vblank->offset = offset_ms;
1316 wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
1318 pthread_mutex_unlock(&private_client->lock);
1320 return TDM_ERROR_NONE;
1324 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
1326 tdm_private_client_vblank *private_vblank;
1327 tdm_private_client *private_client;
1329 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1331 private_vblank = vblank;
1332 private_client = private_vblank->private_output->private_client;
1334 pthread_mutex_lock(&private_client->lock);
1336 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1337 pthread_mutex_unlock(&private_client->lock);
1338 return TDM_ERROR_PROTOCOL_ERROR;
1341 if (private_vblank->enable_fake == enable_fake) {
1342 pthread_mutex_unlock(&private_client->lock);
1343 return TDM_ERROR_NONE;
1346 private_vblank->enable_fake = enable_fake;
1348 wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
1350 pthread_mutex_unlock(&private_client->lock);
1352 return TDM_ERROR_NONE;
1356 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
1358 tdm_private_client *private_client;
1359 tdm_private_client_output *private_output;
1360 tdm_private_client_vblank *private_vblank;
1361 tdm_client_wait_info *w;
1363 unsigned int req_sec, req_usec;
1366 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1367 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1368 /* can't support "interval 0" and "getting current_msc" things because
1369 * there is a socket communication between TDM client and server. It's impossible
1370 * to return the current msc or sequence immediately.
1372 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1374 private_vblank = vblank;
1375 private_output = private_vblank->private_output;
1376 private_client = private_output->private_client;
1378 pthread_mutex_lock(&private_client->lock);
1380 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1381 pthread_mutex_unlock(&private_client->lock);
1382 return TDM_ERROR_PROTOCOL_ERROR;
1385 if (!private_vblank->started)
1386 private_vblank->started = 1;
1388 if (!private_vblank->enable_fake) {
1389 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1390 TDM_ERR("output disconnected");
1391 pthread_mutex_unlock(&private_client->lock);
1392 return TDM_ERROR_OUTPUT_DISCONNECTED;
1394 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1395 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1396 pthread_mutex_unlock(&private_client->lock);
1397 return TDM_ERROR_DPMS_OFF;
1401 w = calloc(1, sizeof *w);
1403 /* LCOV_EXCL_START */
1405 TDM_ERR("alloc failed");
1406 pthread_mutex_unlock(&private_client->lock);
1407 return TDM_ERROR_OUT_OF_MEMORY;
1409 /* LCOV_EXCL_STOP */
1412 w->private_vblank = private_vblank;
1414 w->user_data = user_data;
1416 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1417 LIST_INITHEAD(&w->call_link);
1419 clock_gettime(CLOCK_MONOTONIC, &tp);
1420 req_sec = (unsigned int)tp.tv_sec;
1421 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1423 w->req_id = ++private_output->req_id;
1424 w->req_time = TDM_TIME(req_sec, req_usec);
1425 w->need_free = (private_vblank->sync) ? 0 : 1;
1427 wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1429 if (private_vblank->enable_ttrace)
1430 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1432 TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1433 vblank, interval, w->req_id, w->req_time);
1435 private_vblank->req_time = w->req_time;
1437 if (private_vblank->last_time >= w->req_time)
1438 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1440 if (!private_vblank->sync) {
1441 wl_display_flush(private_client->display);
1442 pthread_mutex_unlock(&private_client->lock);
1443 return TDM_ERROR_NONE;
1446 /* LCOV_EXCL_START */
1448 while (ret != -1 && !w->need_free)
1449 ret = wl_display_dispatch(private_client->display);
1451 clock_gettime(CLOCK_MONOTONIC, &tp);
1452 TDM_DBG("block during %d us",
1453 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1454 - (req_sec * 1000000 + req_usec));
1459 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1460 pthread_mutex_unlock(&private_client->lock);
1461 return TDM_ERROR_PROTOCOL_ERROR;
1464 pthread_mutex_unlock(&private_client->lock);
1466 return TDM_ERROR_NONE;
1468 /* LCOV_EXCL_STOP */
1472 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1473 tdm_client_vblank_handler func, void *user_data)
1475 tdm_private_client *private_client;
1476 tdm_private_client_output *private_output;
1477 tdm_private_client_vblank *private_vblank;
1478 tdm_client_wait_info *w;
1480 unsigned int req_sec, req_usec;
1483 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1484 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1486 private_vblank = vblank;
1487 private_output = private_vblank->private_output;
1488 private_client = private_output->private_client;
1490 pthread_mutex_lock(&private_client->lock);
1492 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1493 pthread_mutex_unlock(&private_client->lock);
1494 return TDM_ERROR_PROTOCOL_ERROR;
1497 if (!private_vblank->started)
1498 private_vblank->started = 1;
1500 if (!private_vblank->enable_fake) {
1501 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1502 TDM_ERR("output disconnected");
1503 pthread_mutex_unlock(&private_client->lock);
1504 return TDM_ERROR_OUTPUT_DISCONNECTED;
1506 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1507 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1508 pthread_mutex_unlock(&private_client->lock);
1509 return TDM_ERROR_DPMS_OFF;
1513 w = calloc(1, sizeof *w);
1515 /* LCOV_EXCL_START */
1517 TDM_ERR("alloc failed");
1518 pthread_mutex_unlock(&private_client->lock);
1519 return TDM_ERROR_OUT_OF_MEMORY;
1521 /* LCOV_EXCL_STOP */
1524 w->private_vblank = private_vblank;
1526 w->user_data = user_data;
1528 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1529 LIST_INITHEAD(&w->call_link);
1531 clock_gettime(CLOCK_MONOTONIC, &tp);
1532 req_sec = (unsigned int)tp.tv_sec;
1533 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1535 w->req_id = ++private_output->req_id;
1536 w->req_time = TDM_TIME(req_sec, req_usec);
1537 w->need_free = (private_vblank->sync) ? 0 : 1;
1539 wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1541 if (private_vblank->enable_ttrace)
1542 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1544 TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1545 vblank, sequence, w->req_id, w->req_time);
1547 private_vblank->req_time = w->req_time;
1549 if (private_vblank->last_time >= w->req_time)
1550 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1552 if (!private_vblank->sync) {
1553 wl_display_flush(private_client->display);
1554 pthread_mutex_unlock(&private_client->lock);
1555 return TDM_ERROR_NONE;
1558 /* LCOV_EXCL_START */
1560 while (ret != -1 && !w->need_free)
1561 ret = wl_display_dispatch(private_client->display);
1563 clock_gettime(CLOCK_MONOTONIC, &tp);
1564 TDM_DBG("block during %d us",
1565 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1566 - (req_sec * 1000000 + req_usec));
1571 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1572 pthread_mutex_unlock(&private_client->lock);
1573 return TDM_ERROR_PROTOCOL_ERROR;
1576 pthread_mutex_unlock(&private_client->lock);
1578 return TDM_ERROR_NONE;
1580 /* LCOV_EXCL_STOP */
1584 tdm_client_vblank_is_waiting(tdm_client_vblank *vblank)
1586 tdm_private_client_vblank *private_vblank;
1588 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, 0);
1590 private_vblank = vblank;
1592 return (LIST_LENGTH(&private_vblank->wait_list) > 0) ? 1 : 0;