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 <boram1288.park@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 typedef struct _tdm_private_client_voutput {
93 tdm_private_client_output base;
94 struct wl_tdm_voutput *wl_voutput;
105 tdm_client_output_mode *modes;
108 unsigned int mmwidth;
109 unsigned int mmheight;
112 } tdm_private_client_voutput;
114 struct _tdm_private_client_vblank {
115 tdm_private_client_output *private_output;
117 struct wl_tdm_vblank *vblank;
118 struct list_head wait_list;
120 char name[TDM_NAME_LEN];
124 unsigned int enable_fake;
125 unsigned int enable_ttrace;
127 unsigned int started;
133 struct list_head link;
136 typedef struct _tdm_client_output_handler_info {
137 tdm_private_client_output *private_output;
139 tdm_client_output_change_handler func;
142 struct list_head link;
143 struct list_head call_link;
144 } tdm_client_output_handler_info;
146 typedef struct _tdm_client_wait_info {
147 tdm_private_client_vblank *private_vblank;
149 tdm_client_vblank_handler func;
156 struct list_head link;
157 struct list_head call_link;
158 } tdm_client_wait_info;
161 _tdm_client_check_wl_error(tdm_private_client *private_client, const char *func, int line)
164 const struct wl_interface *intf;
167 err = wl_display_get_error(private_client->display);
171 if (err == EINVAL || err == ENOMEM || err == EFAULT || err == EPROTO) {
172 ec = wl_display_get_protocol_error(private_client->display, &intf, &id);
173 TDM_ERR("[%s,%d] errno(%d) Got protocol error '%u' on interface '%s' (object '%u')",
174 func, line, err, ec, (intf) ? intf->name : "destroyed", id);
176 TDM_ERR("[%s,%d] errno(%d)", func, line, err);
182 #define CHECK_WL_PROTOCOL_ERROR(pc) _tdm_client_check_wl_error(pc, __FUNCTION__, __LINE__)
185 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
187 tdm_private_client_vblank *private_vblank = data;
188 tdm_private_client *private_client;
190 TDM_RETURN_IF_FAIL(private_vblank != NULL);
192 private_vblank->stamp = stamp;
194 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
195 private_client = private_vblank->private_output->private_client;
197 private_client->stamp = stamp;
200 /* LCOV_EXCL_START */
202 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
203 uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
204 uint32_t tv_usec, uint32_t error)
206 tdm_private_client_vblank *private_vblank = data;
207 tdm_private_client *private_client;
208 tdm_client_wait_info *w = NULL, *wait_info = NULL;
210 TDM_RETURN_IF_FAIL(private_vblank != NULL);
212 private_client = private_vblank->private_output->private_client;
214 private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
216 TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
217 private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
219 LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) {
220 if (w->req_id != req_id)
228 TDM_ERR("no wait infomation for req_id(%d)", req_id);
232 if (private_vblank->enable_ttrace)
233 TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
235 if (wait_info->req_time >= private_vblank->last_time)
236 TDM_WRN("'req(%.6f) < last(%.6f)' failed. error(%d)", wait_info->req_time, private_vblank->last_time, error);
238 if (wait_info->need_free)
239 LIST_DEL(&wait_info->link);
241 if (wait_info->func) {
242 pthread_mutex_unlock(&private_client->lock);
243 wait_info->func(private_vblank, error, sequence, tv_sec, tv_usec, wait_info->user_data);
244 pthread_mutex_lock(&private_client->lock);
247 if (wait_info->need_free)
250 wait_info->need_free = 1;
254 /* LCOV_EXCL_START */
256 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
258 tdm_private_client_vblank *private_vblank = data;
259 tdm_private_client *private_client;
261 TDM_RETURN_IF_FAIL(private_vblank != NULL);
263 private_vblank->enable_ttrace = enable;
265 TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
266 private_client = private_vblank->private_output->private_client;
268 private_client->enable_ttrace = enable;
272 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
273 _tdm_client_vblank_cb_stamp,
274 _tdm_client_vblank_cb_done,
275 _tdm_client_vblank_cb_ttrace,
279 _tdm_client_output_destroy(tdm_private_client_output *private_output)
281 tdm_private_client_vblank *v = NULL, *vv = NULL;
282 tdm_client_output_handler_info *h = NULL, *hh = NULL;
284 LIST_DEL(&private_output->link);
286 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
287 TDM_ERR("vblanks SHOULD be destroyed first!");
289 v->private_output = NULL;
292 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
297 wl_tdm_output_destroy(private_output->output);
299 free(private_output);
303 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
304 uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
306 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
308 TDM_RETURN_IF_FAIL(private_output != NULL);
310 private_output->width = width;
311 private_output->height = height;
312 private_output->refresh = refresh;
314 if (error != TDM_ERROR_NONE)
315 TDM_INFO("mode event error: %d", error);
317 TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
318 private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
319 width, height, refresh);
323 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
325 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
326 tdm_private_client *private_client;
327 tdm_client_output_handler_info *h = NULL, *hh = NULL;
329 struct list_head call_list;
331 TDM_RETURN_IF_FAIL(private_output != NULL);
333 private_client = private_output->private_client;
335 if (private_output->connection == value)
338 private_output->connection = value;
340 if (error != TDM_ERROR_NONE)
341 TDM_INFO("connection event error: %d", error);
343 TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
345 wl_proxy_get_id((struct wl_proxy*)private_output->output),
348 LIST_INITHEAD(&call_list);
350 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
351 LIST_ADDTAIL(&h->call_link, &call_list);
355 pthread_mutex_unlock(&private_client->lock);
356 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
358 h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
360 pthread_mutex_lock(&private_client->lock);
364 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
366 tdm_private_client_output *private_output = (tdm_private_client_output*)data;
367 tdm_private_client *private_client;
368 tdm_client_output_handler_info *h = NULL, *hh = NULL;
370 struct list_head call_list;
372 TDM_RETURN_IF_FAIL(private_output != NULL);
374 private_client = private_output->private_client;
376 /* If value is extended value, we handle it as DPMS on in client side
377 * The extended DPMS value is valid only in server side.
378 * Or, need to export to client side also?
380 if (value > TDM_OUTPUT_DPMS_OFF)
381 value = TDM_OUTPUT_DPMS_ON;
383 if (private_output->dpms == value)
386 private_output->dpms = value;
388 if (error != TDM_ERROR_NONE)
389 TDM_INFO("dpms event error: %d", error);
391 TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
393 wl_proxy_get_id((struct wl_proxy*)private_output->output),
396 LIST_INITHEAD(&call_list);
398 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
399 LIST_ADDTAIL(&h->call_link, &call_list);
403 pthread_mutex_unlock(&private_client->lock);
404 LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
406 h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
408 pthread_mutex_lock(&private_client->lock);
411 static const struct wl_tdm_output_listener tdm_client_output_listener = {
412 _tdm_client_output_cb_mode,
413 _tdm_client_output_cb_connection,
414 _tdm_client_output_cb_dpms,
418 _tdm_client_cb_global(void *data, struct wl_registry *registry,
419 uint32_t name, const char *interface,
422 tdm_private_client *private_client = data;
424 if (strncmp(interface, "wl_tdm", 6) == 0) {
425 private_client->tdm =
426 wl_registry_bind(registry, name, &wl_tdm_interface, version);
427 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
429 wl_display_flush(private_client->display);
433 /* LCOV_EXCL_START */
435 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
440 static const struct wl_registry_listener tdm_client_registry_listener = {
441 _tdm_client_cb_global,
442 _tdm_client_cb_global_remove
446 tdm_client_create(tdm_error *error)
448 tdm_private_client *private_client;
450 private_client = calloc(1, sizeof *private_client);
451 if (!private_client) {
452 /* LCOV_EXCL_START */
454 TDM_ERR("alloc failed");
456 *error = TDM_ERROR_OUT_OF_MEMORY;
462 if (pthread_mutex_init(&private_client->lock, NULL)) {
463 TDM_ERR("mutex init failed: %m");
464 free(private_client);
466 *error = TDM_ERROR_OUT_OF_MEMORY;
470 LIST_INITHEAD(&private_client->output_list);
472 private_client->display = wl_display_connect("tdm-socket");
473 TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
475 private_client->queue = wl_display_create_queue(private_client->display);
476 TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed);
478 private_client->registry = wl_display_get_registry(private_client->display);
479 TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
481 wl_registry_add_listener(private_client->registry,
482 &tdm_client_registry_listener, private_client);
483 wl_display_roundtrip(private_client->display);
485 if (CHECK_WL_PROTOCOL_ERROR(private_client))
488 /* check global objects */
489 TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
492 *error = TDM_ERROR_NONE;
494 return (tdm_client*)private_client;
496 tdm_client_destroy((tdm_client*)private_client);
498 *error = TDM_ERROR_OPERATION_FAILED;
503 tdm_client_destroy(tdm_client *client)
505 tdm_private_client *private_client = (tdm_private_client*)client;
506 tdm_private_client_output *o = NULL, *oo = NULL;
511 pthread_mutex_lock(&private_client->lock);
513 if (private_client->temp_vblank) {
514 pthread_mutex_unlock(&private_client->lock);
515 tdm_client_vblank_destroy(private_client->temp_vblank);
516 pthread_mutex_lock(&private_client->lock);
519 LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
520 _tdm_client_output_destroy(o);
523 if (private_client->tdm)
524 wl_tdm_destroy(private_client->tdm);
525 if (private_client->registry)
526 wl_registry_destroy(private_client->registry);
527 if (private_client->queue)
528 wl_event_queue_destroy(private_client->queue);
529 if (private_client->display)
530 wl_display_disconnect(private_client->display);
532 pthread_mutex_unlock(&private_client->lock);
533 pthread_mutex_destroy(&private_client->lock);
535 free(private_client);
539 tdm_client_get_fd(tdm_client *client, int *fd)
541 tdm_private_client *private_client;
543 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
544 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
546 private_client = (tdm_private_client*)client;
548 pthread_mutex_lock(&private_client->lock);
550 *fd = wl_display_get_fd(private_client->display);
552 pthread_mutex_unlock(&private_client->lock);
555 return TDM_ERROR_OPERATION_FAILED;
557 return TDM_ERROR_NONE;
561 tdm_client_handle_events(tdm_client *client)
563 tdm_private_client *private_client;
565 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
567 /* LCOV_EXCL_START */
568 private_client = (tdm_private_client*)client;
570 pthread_mutex_lock(&private_client->lock);
572 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
573 pthread_mutex_unlock(&private_client->lock);
574 return TDM_ERROR_PROTOCOL_ERROR;
577 if (private_client->enable_ttrace)
578 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
580 wl_display_dispatch(private_client->display);
582 if (private_client->enable_ttrace)
583 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
585 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
586 pthread_mutex_unlock(&private_client->lock);
587 return TDM_ERROR_PROTOCOL_ERROR;
590 pthread_mutex_unlock(&private_client->lock);
592 return TDM_ERROR_NONE;
597 _tdm_client_poll(struct wl_display *display, short int events, int timeout)
600 struct pollfd pfd[1];
602 pfd[0].fd = wl_display_get_fd(display);
603 pfd[0].events = events;
605 ret = poll(pfd, 1, timeout);
606 } while (ret == -1 && errno == EINTR);
612 _tdm_client_dispatch_timeout(tdm_private_client *private_client, int timeout)
615 struct wl_display *display = private_client->display;
617 if (wl_display_prepare_read(display) == -1) {
618 if (wl_display_dispatch_pending(display) > 0)
619 return TDM_ERROR_NONE;
621 return TDM_ERROR_OPERATION_FAILED;
625 ret = wl_display_flush(display);
627 if (ret != -1 || errno != EAGAIN)
630 if (_tdm_client_poll(display, POLLOUT, -1) == -1) {
631 wl_display_cancel_read(display);
632 TDM_ERR("_tdm_client_poll failed");
633 return TDM_ERROR_OPERATION_FAILED;
637 /* Don't stop if flushing hits an EPIPE; continue so we can read any
638 * protocol error that may have triggered it. */
639 if (ret < 0 && errno != EPIPE) {
640 TDM_ERR("ret(%d) errno(%d)", ret, errno);
641 wl_display_cancel_read(display);
642 return TDM_ERROR_OPERATION_FAILED;
645 ret = _tdm_client_poll(display, POLLIN, timeout);
647 wl_display_cancel_read(display);
649 TDM_ERR("_tdm_client_poll timeout.");
650 return TDM_ERROR_TIMEOUT;
652 TDM_ERR("_tdm_client_poll failed. (ret:%d)", ret);
653 return TDM_ERROR_OPERATION_FAILED;
657 if (wl_display_read_events(display) == -1) {
658 TDM_ERR("wl_display_read_events failed");
659 return TDM_ERROR_OPERATION_FAILED;
662 ret = wl_display_dispatch_pending(display);
665 TDM_ERR("_tdm_client_dispatch_timeout failed");
666 return TDM_ERROR_OPERATION_FAILED;
669 return TDM_ERROR_NONE;
673 tdm_client_handle_events_timeout(tdm_client *client, int ms_timeout)
675 tdm_private_client *private_client;
677 TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
679 private_client = (tdm_private_client*)client;
681 pthread_mutex_lock(&private_client->lock);
683 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
684 pthread_mutex_unlock(&private_client->lock);
685 return TDM_ERROR_PROTOCOL_ERROR;
688 if (private_client->enable_ttrace)
689 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
691 ret = _tdm_client_dispatch_timeout(private_client, ms_timeout);
693 if (private_client->enable_ttrace)
694 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events_Timeout:%u", (unsigned int)private_client->stamp);
696 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
697 pthread_mutex_unlock(&private_client->lock);
698 return TDM_ERROR_PROTOCOL_ERROR;
701 pthread_mutex_unlock(&private_client->lock);
706 typedef struct _tdm_client_vblank_temp {
707 tdm_client_vblank_handler2 func;
709 } tdm_client_vblank_temp;
711 /* LCOV_EXCL_START */
713 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
714 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
716 tdm_client_vblank_temp *vblank_temp = user_data;
718 TDM_RETURN_IF_FAIL(vblank_temp != NULL);
719 TDM_RETURN_IF_FAIL(vblank != NULL);
721 if (vblank_temp->func)
722 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
728 /* LCOV_EXCL_START */ /* deprecated */
730 tdm_client_wait_vblank(tdm_client *client, char *name,
731 int sw_timer, int interval, int sync,
732 tdm_client_vblank_handler2 func, void *user_data)
734 tdm_private_client *private_client = (tdm_private_client*)client;
735 tdm_client_output *output;
736 tdm_client_vblank_temp *vblank_temp;
739 TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
740 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
741 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
743 if (CHECK_WL_PROTOCOL_ERROR(private_client))
744 return TDM_ERROR_PROTOCOL_ERROR;
746 if (!private_client->temp_vblank) {
747 output = tdm_client_get_output(client, name, &ret);
748 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
750 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
751 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
754 tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
755 tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
757 vblank_temp = calloc(1, sizeof *vblank_temp);
758 TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
760 vblank_temp->func = func;
761 vblank_temp->user_data = user_data;
763 return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
768 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
770 tdm_private_client *private_client;
771 tdm_private_client_output *private_output = NULL;
772 struct wl_proxy *wrapper;
775 *error = TDM_ERROR_NONE;
778 TDM_ERR("'!client' failed");
780 *error = TDM_ERROR_INVALID_PARAMETER;
784 private_client = (tdm_private_client*)client;
786 pthread_mutex_lock(&private_client->lock);
788 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
790 *error = TDM_ERROR_PROTOCOL_ERROR;
791 pthread_mutex_unlock(&private_client->lock);
797 } else if (strncmp(name, "primary", 7) && strncmp(name, "default", 7)) {
799 *error = TDM_ERROR_INVALID_PARAMETER;
800 pthread_mutex_unlock(&private_client->lock);
804 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
805 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
806 pthread_mutex_unlock(&private_client->lock);
807 return (tdm_client_output*)private_output;
811 wrapper = wl_proxy_create_wrapper(private_client->tdm);
813 TDM_ERR("create output_wrapper failed");
815 *error = TDM_ERROR_OUT_OF_MEMORY;
816 pthread_mutex_unlock(&private_client->lock);
820 wl_proxy_set_queue(wrapper, private_client->queue);
822 private_output = calloc(1, sizeof *private_output);
823 if (!private_output) {
824 /* LCOV_EXCL_START */
825 wl_proxy_wrapper_destroy(wrapper);
826 TDM_ERR("alloc failed");
828 *error = TDM_ERROR_OUT_OF_MEMORY;
829 pthread_mutex_unlock(&private_client->lock);
835 private_output->private_client = private_client;
837 snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
838 private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
839 wl_proxy_wrapper_destroy(wrapper);
840 if (!private_output->output) {
841 /* LCOV_EXCL_START */
843 TDM_ERR("couldn't create output resource");
844 free(private_output);
846 *error = TDM_ERROR_OUT_OF_MEMORY;
847 pthread_mutex_unlock(&private_client->lock);
853 LIST_INITHEAD(&private_output->vblank_list);
854 LIST_INITHEAD(&private_output->change_handler_list);
856 wl_tdm_output_add_listener(private_output->output,
857 &tdm_client_output_listener, private_output);
858 wl_display_roundtrip_queue(private_client->display, private_client->queue);
860 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
862 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
863 wl_tdm_output_destroy(private_output->output);
864 free(private_output);
866 *error = TDM_ERROR_PROTOCOL_ERROR;
867 pthread_mutex_unlock(&private_client->lock);
871 LIST_ADDTAIL(&private_output->link, &private_client->output_list);
873 pthread_mutex_unlock(&private_client->lock);
875 return (tdm_client_output*)private_output;
879 tdm_client_output_add_change_handler(tdm_client_output *output,
880 tdm_client_output_change_handler func,
883 tdm_private_client_output *private_output;
884 tdm_private_client *private_client;
885 tdm_client_output_handler_info *h = NULL;
887 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
888 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
890 private_output = (tdm_private_client_output*)output;
891 private_client = private_output->private_client;
893 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
894 if (h->func == func && h->user_data == user_data) {
895 TDM_ERR("can't add twice");
896 return TDM_ERROR_BAD_REQUEST;
900 h = calloc(1, sizeof *h);
901 TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
903 pthread_mutex_lock(&private_client->lock);
905 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
907 pthread_mutex_unlock(&private_client->lock);
908 return TDM_ERROR_PROTOCOL_ERROR;
911 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
912 wl_tdm_output_watch_output_changes(private_output->output, 1);
913 wl_display_roundtrip_queue(private_client->display, private_client->queue);
915 /* TODO: this is very tricky.
916 * If a client adds the change_handler, we might be able to guess that
917 * the client will watch the tdm client's fd and handle tdm events in
918 * event loop. Otherwise, we CAN'T make sure if a client has event loop
919 * which handles tdm events.
921 private_output->watch_output_changes = 1;
924 h->private_output = private_output;
926 h->user_data = user_data;
927 LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
928 LIST_INITHEAD(&h->call_link);
930 pthread_mutex_unlock(&private_client->lock);
932 return TDM_ERROR_NONE;
936 tdm_client_output_remove_change_handler(tdm_client_output *output,
937 tdm_client_output_change_handler func,
940 tdm_private_client_output *private_output;
941 tdm_private_client *private_client;
942 tdm_client_output_handler_info *h = NULL;
944 TDM_RETURN_IF_FAIL(output != NULL);
945 TDM_RETURN_IF_FAIL(func != NULL);
947 private_output = (tdm_private_client_output*)output;
948 private_client = private_output->private_client;
950 pthread_mutex_lock(&private_client->lock);
952 LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
953 if (h->func != func || h->user_data != user_data)
959 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
960 private_output->watch_output_changes = 0;
961 if (!CHECK_WL_PROTOCOL_ERROR(private_client)) {
962 wl_tdm_output_watch_output_changes(private_output->output, 0);
963 wl_display_roundtrip_queue(private_client->display, private_client->queue);
967 pthread_mutex_unlock(&private_client->lock);
972 pthread_mutex_unlock(&private_client->lock);
976 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
978 tdm_private_client_output *private_output;
979 tdm_private_client *private_client;
981 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
982 TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
984 private_output = (tdm_private_client_output*)output;
985 private_client = private_output->private_client;
987 pthread_mutex_lock(&private_client->lock);
989 if (private_output->watch_output_changes) {
990 *refresh = private_output->refresh;
991 pthread_mutex_unlock(&private_client->lock);
992 return TDM_ERROR_NONE;
995 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
996 pthread_mutex_unlock(&private_client->lock);
997 return TDM_ERROR_PROTOCOL_ERROR;
1000 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1001 wl_tdm_output_get_mode(private_output->output);
1002 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1003 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1005 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1006 pthread_mutex_unlock(&private_client->lock);
1007 return TDM_ERROR_PROTOCOL_ERROR;
1010 *refresh = private_output->refresh;
1012 pthread_mutex_unlock(&private_client->lock);
1014 return TDM_ERROR_NONE;
1018 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
1020 tdm_private_client_output *private_output;
1021 tdm_private_client *private_client;
1023 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1024 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
1026 private_output = (tdm_private_client_output*)output;
1027 private_client = private_output->private_client;
1029 pthread_mutex_lock(&private_client->lock);
1031 if (private_output->watch_output_changes) {
1032 *status = private_output->connection;
1033 pthread_mutex_unlock(&private_client->lock);
1034 return TDM_ERROR_NONE;
1037 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1038 pthread_mutex_unlock(&private_client->lock);
1039 return TDM_ERROR_PROTOCOL_ERROR;
1042 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1043 wl_tdm_output_get_connection(private_output->output);
1044 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1045 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1047 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1048 pthread_mutex_unlock(&private_client->lock);
1049 return TDM_ERROR_PROTOCOL_ERROR;
1052 *status = private_output->connection;
1054 pthread_mutex_unlock(&private_client->lock);
1056 return TDM_ERROR_NONE;
1060 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
1062 tdm_private_client_output *private_output;
1063 tdm_private_client *private_client;
1065 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1066 TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
1068 private_output = (tdm_private_client_output*)output;
1069 private_client = private_output->private_client;
1071 if (private_output->watch_output_changes) {
1072 *dpms = private_output->dpms;
1073 return TDM_ERROR_NONE;
1076 pthread_mutex_lock(&private_client->lock);
1078 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1079 pthread_mutex_unlock(&private_client->lock);
1080 return TDM_ERROR_PROTOCOL_ERROR;
1083 wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
1084 wl_tdm_output_get_dpms(private_output->output);
1085 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1086 wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
1088 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1089 pthread_mutex_unlock(&private_client->lock);
1090 return TDM_ERROR_PROTOCOL_ERROR;
1093 *dpms = private_output->dpms;
1095 pthread_mutex_unlock(&private_client->lock);
1097 return TDM_ERROR_NONE;
1101 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
1103 tdm_private_client *private_client;
1104 tdm_private_client_output *private_output;
1105 tdm_private_client_vblank *private_vblank;
1106 struct wl_proxy *wrapper;
1109 *error = TDM_ERROR_NONE;
1112 TDM_ERR("'!output' failed");
1114 *error = TDM_ERROR_INVALID_PARAMETER;
1118 private_output = (tdm_private_client_output*)output;
1119 private_client = private_output->private_client;
1121 pthread_mutex_lock(&private_client->lock);
1123 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1125 *error = TDM_ERROR_PROTOCOL_ERROR;
1126 pthread_mutex_unlock(&private_client->lock);
1130 wrapper = wl_proxy_create_wrapper(private_output->output);
1132 TDM_ERR("create output_wrapper failed");
1134 *error = TDM_ERROR_OUT_OF_MEMORY;
1135 pthread_mutex_unlock(&private_client->lock);
1139 wl_proxy_set_queue(wrapper, private_client->queue);
1141 private_vblank = calloc(1, sizeof *private_vblank);
1142 if (!private_vblank) {
1143 /* LCOV_EXCL_START */
1145 TDM_ERR("alloc failed");
1146 wl_proxy_wrapper_destroy(wrapper);
1148 *error = TDM_ERROR_OUT_OF_MEMORY;
1149 pthread_mutex_unlock(&private_client->lock);
1152 /* LCOV_EXCL_STOP */
1155 private_vblank->private_output = private_output;
1157 private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
1158 wl_proxy_wrapper_destroy(wrapper);
1159 if (!private_vblank->vblank) {
1160 /* LCOV_EXCL_START */
1162 TDM_ERR("couldn't create vblank resource");
1163 free(private_vblank);
1165 *error = TDM_ERROR_OUT_OF_MEMORY;
1166 pthread_mutex_unlock(&private_client->lock);
1169 /* LCOV_EXCL_STOP */
1173 private_vblank->fps = private_output->refresh;
1174 private_vblank->offset = 0;
1175 private_vblank->enable_fake = 0;
1177 LIST_INITHEAD(&private_vblank->wait_list);
1179 wl_tdm_vblank_add_listener(private_vblank->vblank,
1180 &tdm_client_vblank_listener, private_vblank);
1181 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1183 wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
1185 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1186 wl_tdm_vblank_destroy(private_vblank->vblank);
1187 free(private_vblank);
1189 *error = TDM_ERROR_PROTOCOL_ERROR;
1190 pthread_mutex_unlock(&private_client->lock);
1194 LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
1196 pthread_mutex_unlock(&private_client->lock);
1198 return (tdm_client_vblank*)private_vblank;
1202 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
1204 tdm_private_client_vblank *private_vblank;
1205 tdm_private_client *private_client;
1206 tdm_client_wait_info *w = NULL, *ww = NULL;
1208 TDM_RETURN_IF_FAIL(vblank != NULL);
1210 private_vblank = vblank;
1211 private_client = private_vblank->private_output->private_client;
1213 pthread_mutex_lock(&private_client->lock);
1215 LIST_DEL(&private_vblank->link);
1217 LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
1222 wl_tdm_vblank_destroy(private_vblank->vblank);
1224 free(private_vblank);
1226 pthread_mutex_unlock(&private_client->lock);
1230 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
1232 tdm_private_client_vblank *private_vblank;
1233 tdm_private_client *private_client;
1235 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1237 private_vblank = vblank;
1238 private_client = private_vblank->private_output->private_client;
1240 pthread_mutex_lock(&private_client->lock);
1242 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1243 pthread_mutex_unlock(&private_client->lock);
1244 return TDM_ERROR_PROTOCOL_ERROR;
1248 name = TDM_VBLANK_DEFAULT_NAME;
1250 strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
1251 private_vblank->name[TDM_NAME_LEN - 1] = '\0';
1253 wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
1255 pthread_mutex_unlock(&private_client->lock);
1257 return TDM_ERROR_NONE;
1261 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
1263 tdm_private_client_vblank *private_vblank;
1264 tdm_private_client *private_client;
1266 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1268 private_vblank = vblank;
1269 private_client = private_vblank->private_output->private_client;
1271 pthread_mutex_lock(&private_client->lock);
1272 private_vblank->sync = sync;
1273 pthread_mutex_unlock(&private_client->lock);
1275 return TDM_ERROR_NONE;
1279 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
1281 tdm_private_client_vblank *private_vblank;
1282 tdm_private_client *private_client;
1284 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1285 TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
1287 private_vblank = vblank;
1288 private_client = private_vblank->private_output->private_client;
1290 pthread_mutex_lock(&private_client->lock);
1292 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1293 pthread_mutex_unlock(&private_client->lock);
1294 return TDM_ERROR_PROTOCOL_ERROR;
1297 if (private_vblank->fps == fps) {
1298 pthread_mutex_unlock(&private_client->lock);
1299 return TDM_ERROR_NONE;
1302 private_vblank->fps = fps;
1304 wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
1306 pthread_mutex_unlock(&private_client->lock);
1308 return TDM_ERROR_NONE;
1312 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
1314 tdm_private_client_vblank *private_vblank;
1315 tdm_private_client *private_client;
1317 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1319 private_vblank = vblank;
1320 TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
1322 private_client = private_vblank->private_output->private_client;
1324 pthread_mutex_lock(&private_client->lock);
1326 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1327 pthread_mutex_unlock(&private_client->lock);
1328 return TDM_ERROR_PROTOCOL_ERROR;
1331 if (private_vblank->offset == offset_ms) {
1332 pthread_mutex_unlock(&private_client->lock);
1333 return TDM_ERROR_NONE;
1336 private_vblank->offset = offset_ms;
1338 wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
1340 pthread_mutex_unlock(&private_client->lock);
1342 return TDM_ERROR_NONE;
1346 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
1348 tdm_private_client_vblank *private_vblank;
1349 tdm_private_client *private_client;
1351 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1353 private_vblank = vblank;
1354 private_client = private_vblank->private_output->private_client;
1356 pthread_mutex_lock(&private_client->lock);
1358 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1359 pthread_mutex_unlock(&private_client->lock);
1360 return TDM_ERROR_PROTOCOL_ERROR;
1363 if (private_vblank->enable_fake == enable_fake) {
1364 pthread_mutex_unlock(&private_client->lock);
1365 return TDM_ERROR_NONE;
1368 private_vblank->enable_fake = enable_fake;
1370 wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
1372 pthread_mutex_unlock(&private_client->lock);
1374 return TDM_ERROR_NONE;
1378 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
1380 tdm_private_client *private_client;
1381 tdm_private_client_output *private_output;
1382 tdm_private_client_vblank *private_vblank;
1383 tdm_client_wait_info *w;
1385 unsigned int req_sec, req_usec;
1388 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1389 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1390 /* can't support "interval 0" and "getting current_msc" things because
1391 * there is a socket communication between TDM client and server. It's impossible
1392 * to return the current msc or sequence immediately.
1394 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1396 private_vblank = vblank;
1397 private_output = private_vblank->private_output;
1398 private_client = private_output->private_client;
1400 pthread_mutex_lock(&private_client->lock);
1402 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1403 pthread_mutex_unlock(&private_client->lock);
1404 return TDM_ERROR_PROTOCOL_ERROR;
1407 if (!private_vblank->started)
1408 private_vblank->started = 1;
1410 if (!private_vblank->enable_fake) {
1411 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1412 TDM_ERR("output disconnected");
1413 pthread_mutex_unlock(&private_client->lock);
1414 return TDM_ERROR_OUTPUT_DISCONNECTED;
1416 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1417 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1418 pthread_mutex_unlock(&private_client->lock);
1419 return TDM_ERROR_DPMS_OFF;
1423 w = calloc(1, sizeof *w);
1425 /* LCOV_EXCL_START */
1427 TDM_ERR("alloc failed");
1428 pthread_mutex_unlock(&private_client->lock);
1429 return TDM_ERROR_OUT_OF_MEMORY;
1431 /* LCOV_EXCL_STOP */
1434 w->private_vblank = private_vblank;
1436 w->user_data = user_data;
1438 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1439 LIST_INITHEAD(&w->call_link);
1441 clock_gettime(CLOCK_MONOTONIC, &tp);
1442 req_sec = (unsigned int)tp.tv_sec;
1443 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1445 w->req_id = ++private_output->req_id;
1446 w->req_time = TDM_TIME(req_sec, req_usec);
1447 w->need_free = (private_vblank->sync) ? 0 : 1;
1449 wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1451 if (private_vblank->enable_ttrace)
1452 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1454 TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1455 vblank, interval, w->req_id, w->req_time);
1457 private_vblank->req_time = w->req_time;
1459 if (private_vblank->last_time >= w->req_time)
1460 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1462 if (!private_vblank->sync) {
1463 wl_display_flush(private_client->display);
1464 pthread_mutex_unlock(&private_client->lock);
1465 return TDM_ERROR_NONE;
1468 /* LCOV_EXCL_START */
1470 while (ret != -1 && !w->need_free)
1471 ret = wl_display_dispatch(private_client->display);
1473 clock_gettime(CLOCK_MONOTONIC, &tp);
1474 TDM_DBG("block during %d us",
1475 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1476 - (req_sec * 1000000 + req_usec));
1481 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1482 pthread_mutex_unlock(&private_client->lock);
1483 return TDM_ERROR_PROTOCOL_ERROR;
1486 pthread_mutex_unlock(&private_client->lock);
1488 return TDM_ERROR_NONE;
1490 /* LCOV_EXCL_STOP */
1494 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1495 tdm_client_vblank_handler func, void *user_data)
1497 tdm_private_client *private_client;
1498 tdm_private_client_output *private_output;
1499 tdm_private_client_vblank *private_vblank;
1500 tdm_client_wait_info *w;
1502 unsigned int req_sec, req_usec;
1505 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1506 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1508 private_vblank = vblank;
1509 private_output = private_vblank->private_output;
1510 private_client = private_output->private_client;
1512 pthread_mutex_lock(&private_client->lock);
1514 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1515 pthread_mutex_unlock(&private_client->lock);
1516 return TDM_ERROR_PROTOCOL_ERROR;
1519 if (!private_vblank->started)
1520 private_vblank->started = 1;
1522 if (!private_vblank->enable_fake) {
1523 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1524 TDM_ERR("output disconnected");
1525 pthread_mutex_unlock(&private_client->lock);
1526 return TDM_ERROR_OUTPUT_DISCONNECTED;
1528 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1529 TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1530 pthread_mutex_unlock(&private_client->lock);
1531 return TDM_ERROR_DPMS_OFF;
1535 w = calloc(1, sizeof *w);
1537 /* LCOV_EXCL_START */
1539 TDM_ERR("alloc failed");
1540 pthread_mutex_unlock(&private_client->lock);
1541 return TDM_ERROR_OUT_OF_MEMORY;
1543 /* LCOV_EXCL_STOP */
1546 w->private_vblank = private_vblank;
1548 w->user_data = user_data;
1550 LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1551 LIST_INITHEAD(&w->call_link);
1553 clock_gettime(CLOCK_MONOTONIC, &tp);
1554 req_sec = (unsigned int)tp.tv_sec;
1555 req_usec = (unsigned int)(tp.tv_nsec / 1000);
1557 w->req_id = ++private_output->req_id;
1558 w->req_time = TDM_TIME(req_sec, req_usec);
1559 w->need_free = (private_vblank->sync) ? 0 : 1;
1561 wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1563 if (private_vblank->enable_ttrace)
1564 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1566 TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1567 vblank, sequence, w->req_id, w->req_time);
1569 private_vblank->req_time = w->req_time;
1571 if (private_vblank->last_time >= w->req_time)
1572 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1574 if (!private_vblank->sync) {
1575 wl_display_flush(private_client->display);
1576 pthread_mutex_unlock(&private_client->lock);
1577 return TDM_ERROR_NONE;
1580 /* LCOV_EXCL_START */
1582 while (ret != -1 && !w->need_free)
1583 ret = wl_display_dispatch(private_client->display);
1585 clock_gettime(CLOCK_MONOTONIC, &tp);
1586 TDM_DBG("block during %d us",
1587 ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1588 - (req_sec * 1000000 + req_usec));
1593 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1594 pthread_mutex_unlock(&private_client->lock);
1595 return TDM_ERROR_PROTOCOL_ERROR;
1598 pthread_mutex_unlock(&private_client->lock);
1600 return TDM_ERROR_NONE;
1602 /* LCOV_EXCL_STOP */
1606 tdm_client_vblank_is_waiting(tdm_client_vblank *vblank)
1608 tdm_private_client_vblank *private_vblank;
1610 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, 0);
1612 private_vblank = vblank;
1614 return (LIST_LENGTH(&private_vblank->wait_list) > 0) ? 1 : 0;
1618 tdm_client_voutput_cb_ack_message(void *data, struct wl_tdm_voutput *wl_voutput, uint32_t msg)
1620 tdm_private_client_voutput *private_voutput = data;
1622 private_voutput->msg = msg;
1625 static const struct wl_tdm_voutput_listener tdm_client_voutput_lisntener = {
1626 tdm_client_voutput_cb_ack_message
1629 tdm_client_voutput *
1630 tdm_client_create_voutput(tdm_client *client, const char *name, tdm_error *error)
1632 tdm_private_client *private_client;
1633 tdm_private_client_output *private_output;
1634 tdm_private_client_voutput *private_voutput;
1635 struct wl_proxy *wrapper;
1638 *error = TDM_ERROR_NONE;
1641 TDM_ERR("'!client' failed");
1643 *error = TDM_ERROR_INVALID_PARAMETER;
1648 TDM_ERR("'!name' failed");
1650 *error = TDM_ERROR_INVALID_PARAMETER;
1654 private_client = (tdm_private_client *)client;
1656 pthread_mutex_lock(&private_client->lock);
1658 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1660 *error = TDM_ERROR_PROTOCOL_ERROR;
1661 pthread_mutex_unlock(&private_client->lock);
1665 LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
1666 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
1668 *error = TDM_ERROR_INVALID_PARAMETER; // FIXME define new error type.
1669 pthread_mutex_unlock(&private_client->lock);
1674 wrapper = wl_proxy_create_wrapper(private_client->tdm);
1676 TDM_ERR("create virtual output wrapper failed");
1678 *error = TDM_ERROR_OUT_OF_MEMORY;
1679 pthread_mutex_unlock(&private_client->lock);
1683 wl_proxy_set_queue(wrapper, private_client->queue);
1685 private_voutput = calloc(1, sizeof *private_voutput);
1686 if (!private_voutput) {
1687 /* LOCV_EXCL_START */
1688 wl_proxy_wrapper_destroy(wrapper);
1689 TDM_ERR("alloc failed");
1691 *error = TDM_ERROR_OUT_OF_MEMORY;
1693 /* LOCV_EXCL_STOP */
1696 private_voutput->base.private_client = private_client;
1698 private_voutput->wl_voutput = wl_tdm_create_voutput((struct wl_tdm *)wrapper, private_voutput->base.name);
1699 wl_proxy_wrapper_destroy(wrapper);
1700 if (!private_voutput->wl_voutput) {
1701 /* LCOV_EXCL_START */
1702 TDM_ERR("couldn't create voutput resource");
1703 free(private_voutput);
1705 *error = TDM_ERROR_OUT_OF_MEMORY;
1706 pthread_mutex_unlock(&private_client->lock);
1708 /* LCOV_EXCL_STOP */
1711 wl_tdm_voutput_add_listener(private_voutput->wl_voutput,
1712 &tdm_client_voutput_lisntener, private_voutput);
1713 wl_display_roundtrip_queue(private_client->display, private_client->queue);
1715 wl_proxy_set_queue((struct wl_proxy *)private_voutput->wl_voutput, NULL);
1717 if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1718 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
1719 free(private_voutput);
1721 *error = TDM_ERROR_PROTOCOL_ERROR;
1722 pthread_mutex_unlock(&private_client->lock);
1726 if (private_voutput->msg != WL_TDM_VOUTPUT_MESSAGE_ADDED)
1728 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
1729 free(private_voutput);
1731 *error = TDM_ERROR_PROTOCOL_ERROR; // FIXME add new error type.
1732 pthread_mutex_unlock(&private_client->lock);
1736 pthread_mutex_unlock(&private_client->lock);
1738 return (tdm_client_voutput *)private_voutput;
1742 tdm_client_voutput_destroy(tdm_client_voutput *voutput)
1744 tdm_private_client_voutput *private_voutput = (tdm_private_client_voutput *)voutput;
1746 if (!private_voutput)
1749 if (private_voutput->available_modes.modes)
1750 free(private_voutput->available_modes.modes);
1752 if (private_voutput->available_formats.formats)
1753 free(private_voutput->available_formats.formats);
1755 wl_tdm_voutput_destroy(private_voutput->wl_voutput);
1757 free(private_voutput);
1761 tdm_client_voutput_set_available_modes(tdm_client_voutput *voutput, const tdm_client_output_mode *modes, int count)
1763 tdm_private_client_voutput *private_voutput;
1765 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
1767 if ((count > 0) && (modes == NULL))
1768 return TDM_ERROR_INVALID_PARAMETER;
1770 private_voutput = (tdm_private_client_voutput *)voutput;
1772 if (private_voutput->base.connection == TDM_OUTPUT_CONN_STATUS_CONNECTED)
1773 return TDM_ERROR_BAD_REQUEST;
1775 if (private_voutput->available_modes.modes)
1776 free(private_voutput->available_modes.modes);
1778 private_voutput->available_modes.count = count;
1782 private_voutput->available_modes.modes = calloc(count, sizeof(tdm_client_output_mode));
1783 memcpy(private_voutput->available_modes.modes, modes, sizeof(tdm_client_output_mode) * count);
1786 return TDM_ERROR_NONE;
1790 tdm_client_voutput_set_available_formats(tdm_client_voutput *voutput, const tbm_format *formats, const int count)
1792 tdm_private_client_voutput *private_voutput;
1794 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
1796 if ((count > 0) && (formats == NULL))
1797 return TDM_ERROR_INVALID_PARAMETER;
1799 private_voutput = (tdm_private_client_voutput *)voutput;
1801 if (private_voutput->base.connection == TDM_OUTPUT_CONN_STATUS_CONNECTED)
1802 return TDM_ERROR_BAD_REQUEST;
1804 if (private_voutput->available_formats.formats)
1805 free(private_voutput->available_formats.formats);
1807 private_voutput->available_formats.count = count;
1811 private_voutput->available_formats.formats = calloc(count, sizeof(tbm_format));
1812 memcpy(private_voutput->available_formats.formats, formats, sizeof(tbm_format) * count);
1815 return TDM_ERROR_NONE;
1819 tdm_client_voutput_set_physical_size(tdm_client_voutput *voutput, unsigned int mmWidth, unsigned int mmHeight)
1821 tdm_private_client_voutput *private_voutput;
1823 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
1824 TDM_RETURN_VAL_IF_FAIL(mmWidth != 0, TDM_ERROR_INVALID_PARAMETER);
1825 TDM_RETURN_VAL_IF_FAIL(mmHeight != 0, TDM_ERROR_INVALID_PARAMETER);
1827 private_voutput = (tdm_private_client_voutput *)voutput;
1829 if (private_voutput->base.connection == TDM_OUTPUT_CONN_STATUS_CONNECTED)
1830 return TDM_ERROR_BAD_REQUEST;
1832 private_voutput->mmwidth = mmWidth;
1833 private_voutput->mmheight = mmHeight;
1835 return TDM_ERROR_NONE;
1839 tdm_client_voutput_get_client_output(tdm_client_voutput *voutput, tdm_error *error)
1841 tdm_private_client_voutput *private_voutput;
1844 *error = TDM_ERROR_NONE;
1848 TDM_ERR("'!voutput' failed");
1850 *error = TDM_ERROR_INVALID_PARAMETER;
1854 private_voutput = (tdm_private_client_voutput *)voutput;
1856 return &private_voutput->base;
1860 tdm_client_output_get_available_modes(tdm_client_output *output, tdm_client_output_mode **modes, int *count)
1862 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1863 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
1864 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
1866 return TDM_ERROR_NONE;
1870 tdm_client_output_set_mode(tdm_client_output *output, const tdm_client_output_mode *mode)
1872 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1873 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1875 return TDM_ERROR_NONE;
1879 _tdm_client_voutput_send_available_formats(tdm_private_client_voutput *private_voutput)
1882 struct wl_array array;
1885 size = sizeof(tbm_format);
1886 wl_array_init(&array);
1887 for (i = 0; i < private_voutput->available_formats.count; i++) {
1888 format = wl_array_add(&array, size);
1889 *format = private_voutput->available_formats.formats[i];
1891 wl_tdm_voutput_set_available_formats(private_voutput->wl_voutput, &array);
1892 wl_array_release(&array);
1896 tdm_client_output_connect(tdm_client_output *output)
1898 tdm_private_client_output *private_output;
1899 tdm_private_client_voutput *private_voutput;
1900 tdm_client_output_mode *modes;
1903 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1905 private_output = (tdm_private_client_output *)output;
1906 private_voutput = (tdm_private_client_voutput *)output;
1908 TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_CONNECTED,
1909 TDM_ERROR_BAD_REQUEST);
1911 private_output->connection = TDM_OUTPUT_CONN_STATUS_CONNECTED;
1913 modes = private_voutput->available_modes.modes;
1914 for (i = 0; i < private_voutput->available_modes.count; i++) {
1915 wl_tdm_voutput_set_available_modes(private_voutput->wl_voutput, i,
1916 modes[i].clock, modes[i].hdisplay,
1917 modes[i].hsync_start, modes[i].hsync_end,
1918 modes[i].htotal, modes[i].hskew,
1919 modes[i].vdisplay, modes[i].vsync_start,
1920 modes[i].vsync_end, modes[i].vtotal,
1921 modes[i].vscan, modes[i].vrefresh,
1922 modes[i].flags, modes[i].type,
1926 _tdm_client_voutput_send_available_formats(private_voutput);
1928 wl_tdm_voutput_set_physical_size(private_voutput->wl_voutput, private_voutput->mmwidth, private_voutput->mmheight);
1930 wl_tdm_voutput_connect(private_voutput->wl_voutput);
1932 return TDM_ERROR_NONE;
1936 tdm_client_output_disconnect(tdm_client_output *output)
1938 tdm_private_client_voutput *private_voutput;
1939 tdm_private_client_output *private_output;
1941 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1943 private_output = (tdm_private_client_output *)output;
1944 private_voutput = (tdm_private_client_voutput *)output;
1946 TDM_RETURN_VAL_IF_FAIL(private_output->connection != TDM_OUTPUT_CONN_STATUS_DISCONNECTED,
1947 TDM_ERROR_BAD_REQUEST);
1949 private_output->connection = TDM_OUTPUT_CONN_STATUS_DISCONNECTED;
1951 wl_tdm_voutput_disconnect(private_voutput->wl_voutput);
1953 return TDM_ERROR_NONE;