client/tdm_client.c

   1 /**************************************************************************
   2  *
   3  * libtdm
   4  *
   5  * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   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>
  13  *
  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:
  21  *
  22  * The above copyright notice and this permission notice (including the
  23  * next paragraph) shall be included in all copies or substantial portions
  24  * of the Software.
  25  *
  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.
  33  *
  34 **************************************************************************/
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include "config.h"
  38 #endif
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <stdlib.h>
  43 #include <time.h>
  44 #include <strings.h>
  45
  46 #include <tdm-client-protocol.h>
  47
  48 #include "tdm_client.h"
  49 #include "tdm_log.h"
  50 #include "tdm_macro.h"
  51 #include "tdm_list.h"
  52 #include "tdm.h"
  53 #include "tdm_private.h"
  54
  55 typedef struct _tdm_private_client_vblank tdm_private_client_vblank;
  56
  57 typedef struct _tdm_private_client {
  58         pthread_mutex_t lock;
  59
  60         struct wl_display *display;
  61         struct wl_event_queue *queue;
  62         struct wl_registry *registry;
  63         struct wl_tdm *tdm;
  64         struct list_head output_list;
  65
  66         unsigned int enable_ttrace;
  67         unsigned int stamp;
  68
  69         tdm_private_client_vblank *temp_vblank;
  70 } tdm_private_client;
  71
  72 typedef struct _tdm_private_client_output {
  73         tdm_private_client *private_client;
  74
  75         char name[TDM_NAME_LEN];
  76         struct wl_tdm_output *output;
  77         int width;
  78         int height;
  79         int refresh;
  80         tdm_output_conn_status connection;
  81         tdm_output_dpms dpms;
  82         struct list_head vblank_list;
  83         struct list_head change_handler_list;
  84
  85         unsigned int req_id;
  86         unsigned int watch_output_changes;
  87
  88         struct list_head link;
  89 } tdm_private_client_output;
  90
  91 struct _tdm_private_client_vblank {
  92         tdm_private_client_output *private_output;
  93
  94         struct wl_tdm_vblank *vblank;
  95         struct list_head wait_list;
  96
  97         char name[TDM_NAME_LEN];
  98         unsigned int sync;
  99         unsigned int fps;
 100         int offset;
 101         unsigned int enable_fake;
 102         unsigned int enable_ttrace;
 103
 104         unsigned int started;
 105         unsigned int stamp;
 106
 107         double req_time;
 108         double last_time;
 109
 110         struct list_head link;
 111 };
 112
 113 typedef struct _tdm_client_output_handler_info {
 114         tdm_private_client_output *private_output;
 115
 116         tdm_client_output_change_handler func;
 117         void *user_data;
 118
 119         struct list_head link;
 120         struct list_head call_link;
 121 } tdm_client_output_handler_info;
 122
 123 typedef struct _tdm_client_wait_info {
 124         tdm_private_client_vblank *private_vblank;
 125
 126         tdm_client_vblank_handler func;
 127         void *user_data;
 128
 129         unsigned int req_id;
 130         double req_time;
 131         int need_free;
 132
 133         struct list_head link;
 134         struct list_head call_link;
 135 } tdm_client_wait_info;
 136
 137 static unsigned int
 138 _tdm_client_check_wl_error(tdm_private_client *private_client, const char *func, int line)
 139 {
 140         uint32_t ec, id;
 141         const struct wl_interface *intf;
 142         int err;
 143
 144         err = wl_display_get_error(private_client->display);
 145         if (!err)
 146                 return false;
 147
 148         if (err == EINVAL || err == ENOMEM || err == EFAULT || err == EPROTO) {
 149                 ec = wl_display_get_protocol_error(private_client->display, &intf, &id);
 150                 TDM_ERR("[%s,%d] errno(%d) Got protocol error '%u' on interface '%s' (object '%u')",
 151                                 func, line, err, ec, (intf) ? intf->name : "destroyed", id);
 152         } else {
 153                 TDM_ERR("[%s,%d] errno(%d)", func, line, err);
 154         }
 155
 156         return true;
 157 }
 158
 159 #define CHECK_WL_PROTOCOL_ERROR(pc)  _tdm_client_check_wl_error(pc, __FUNCTION__, __LINE__)
 160
 161 static void
 162 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
 163 {
 164         tdm_private_client_vblank *private_vblank = data;
 165         tdm_private_client *private_client;
 166
 167         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 168
 169         private_vblank->stamp = stamp;
 170
 171         TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
 172         private_client = private_vblank->private_output->private_client;
 173
 174         private_client->stamp = stamp;
 175 }
 176
 177 /* LCOV_EXCL_START */
 178 static void
 179 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
 180                                                    uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
 181                                                    uint32_t tv_usec, uint32_t error)
 182 {
 183         tdm_private_client_vblank *private_vblank = data;
 184         tdm_private_client *private_client;
 185         tdm_client_wait_info *w = NULL, *wait_info = NULL;
 186
 187         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 188
 189         private_client = private_vblank->private_output->private_client;
 190
 191         private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
 192
 193         TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
 194                         private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
 195
 196         LIST_FOR_EACH_ENTRY(w, &private_vblank->wait_list, link) {
 197                 if (w->req_id != req_id)
 198                         continue;
 199
 200                 wait_info = w;
 201                 break;
 202         }
 203
 204         if (!wait_info) {
 205                 TDM_ERR("no wait infomation for req_id(%d)", req_id);
 206                 return;
 207         }
 208
 209         if (private_vblank->enable_ttrace)
 210                 TDM_TRACE_ASYNC_END((int)wait_info->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 211
 212         if (wait_info->req_time >= private_vblank->last_time)
 213                 TDM_WRN("'req(%.6f) < last(%.6f)' failed. error(%d)", wait_info->req_time, private_vblank->last_time, error);
 214
 215         if (wait_info->need_free)
 216                 LIST_DEL(&wait_info->link);
 217
 218         if (wait_info->func) {
 219                 pthread_mutex_unlock(&private_client->lock);
 220                 wait_info->func(private_vblank, error, sequence, tv_sec, tv_usec, wait_info->user_data);
 221                 pthread_mutex_lock(&private_client->lock);
 222         }
 223
 224         if (wait_info->need_free)
 225                 free(w);
 226         else
 227                 wait_info->need_free = 1;
 228 }
 229 /* LCOV_EXCL_STOP */
 230
 231 /* LCOV_EXCL_START */
 232 static void
 233 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
 234 {
 235         tdm_private_client_vblank *private_vblank = data;
 236         tdm_private_client *private_client;
 237
 238         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 239
 240         private_vblank->enable_ttrace = enable;
 241
 242         TDM_RETURN_IF_FAIL(private_vblank->private_output != NULL);
 243         private_client = private_vblank->private_output->private_client;
 244
 245         private_client->enable_ttrace = enable;
 246 }
 247 /* LCOV_EXCL_STOP */
 248
 249 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
 250         _tdm_client_vblank_cb_stamp,
 251         _tdm_client_vblank_cb_done,
 252         _tdm_client_vblank_cb_ttrace,
 253 };
 254
 255 static void
 256 _tdm_client_output_destroy(tdm_private_client_output *private_output)
 257 {
 258         tdm_private_client_vblank *v = NULL, *vv = NULL;
 259         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 260
 261         LIST_DEL(&private_output->link);
 262
 263         LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
 264                 TDM_ERR("vblanks SHOULD be destroyed first!");
 265                 LIST_DEL(&v->link);
 266                 v->private_output = NULL;
 267         }
 268
 269         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
 270                 LIST_DEL(&h->link);
 271                 free(h);
 272         }
 273
 274         wl_tdm_output_destroy(private_output->output);
 275
 276         free(private_output);
 277 }
 278
 279 static void
 280 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
 281                                                    uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
 282 {
 283         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 284
 285         TDM_RETURN_IF_FAIL(private_output != NULL);
 286
 287         private_output->width = width;
 288         private_output->height = height;
 289         private_output->refresh = refresh;
 290
 291         if (error != TDM_ERROR_NONE)
 292                 TDM_INFO("mode event error: %d", error);
 293
 294         TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
 295                         private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
 296                         width, height, refresh);
 297 }
 298
 299 static void
 300 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 301 {
 302         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 303         tdm_private_client *private_client;
 304         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 305         tdm_value v;
 306         struct list_head call_list;
 307
 308         TDM_RETURN_IF_FAIL(private_output != NULL);
 309
 310         private_client = private_output->private_client;
 311
 312         if (private_output->connection == value)
 313                 return;
 314
 315         private_output->connection = value;
 316
 317         if (error != TDM_ERROR_NONE)
 318                 TDM_INFO("connection event error: %d", error);
 319
 320         TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
 321                         private_output,
 322                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 323                         value);
 324
 325         LIST_INITHEAD(&call_list);
 326
 327         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 328                 LIST_ADDTAIL(&h->call_link, &call_list);
 329         }
 330
 331         v.u32 = value;
 332         pthread_mutex_unlock(&private_client->lock);
 333         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
 334                 if (h->func)
 335                         h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
 336         }
 337         pthread_mutex_lock(&private_client->lock);
 338 }
 339
 340 static void
 341 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 342 {
 343         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 344         tdm_private_client *private_client;
 345         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 346         tdm_value v;
 347         struct list_head call_list;
 348
 349         TDM_RETURN_IF_FAIL(private_output != NULL);
 350
 351         private_client = private_output->private_client;
 352
 353         /* If value is extended value, we handle it as DPMS on in client side
 354          * The extended DPMS value is valid only in server side.
 355          * Or, need to export to client side also?
 356          */
 357         if (value > TDM_OUTPUT_DPMS_OFF)
 358                 value = TDM_OUTPUT_DPMS_ON;
 359
 360         if (private_output->dpms == value)
 361                 return;
 362
 363         private_output->dpms = value;
 364
 365         if (error != TDM_ERROR_NONE)
 366                 TDM_INFO("dpms event error: %d", error);
 367
 368         TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
 369                         private_output,
 370                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 371                         value);
 372
 373         LIST_INITHEAD(&call_list);
 374
 375         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 376                 LIST_ADDTAIL(&h->call_link, &call_list);
 377         }
 378
 379         v.u32 = value;
 380         pthread_mutex_unlock(&private_client->lock);
 381         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &call_list, call_link) {
 382                 if (h->func)
 383                         h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
 384         }
 385         pthread_mutex_lock(&private_client->lock);
 386 }
 387
 388 static const struct wl_tdm_output_listener tdm_client_output_listener = {
 389         _tdm_client_output_cb_mode,
 390         _tdm_client_output_cb_connection,
 391         _tdm_client_output_cb_dpms,
 392 };
 393
 394 static void
 395 _tdm_client_cb_global(void *data, struct wl_registry *registry,
 396                                           uint32_t name, const char *interface,
 397                                           uint32_t version)
 398 {
 399         tdm_private_client *private_client = data;
 400
 401         if (strncmp(interface, "wl_tdm", 6) == 0) {
 402                 private_client->tdm =
 403                         wl_registry_bind(registry, name, &wl_tdm_interface, version);
 404                 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
 405
 406                 wl_display_flush(private_client->display);
 407         }
 408 }
 409
 410 /* LCOV_EXCL_START */
 411 static void
 412 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
 413 {
 414 }
 415 /* LCOV_EXCL_STOP */
 416
 417 static const struct wl_registry_listener tdm_client_registry_listener = {
 418         _tdm_client_cb_global,
 419         _tdm_client_cb_global_remove
 420 };
 421
 422 tdm_client*
 423 tdm_client_create(tdm_error *error)
 424 {
 425         tdm_private_client *private_client;
 426
 427         private_client = calloc(1, sizeof *private_client);
 428         if (!private_client) {
 429                 /* LCOV_EXCL_START */
 430
 431                 TDM_ERR("alloc failed");
 432                 if (error)
 433                         *error = TDM_ERROR_OUT_OF_MEMORY;
 434                 return NULL;
 435
 436                 /* LCOV_EXCL_STOP */
 437         }
 438
 439         if (pthread_mutex_init(&private_client->lock, NULL)) {
 440                 TDM_ERR("mutex init failed: %m");
 441                 free(private_client);
 442                 if (error)
 443                         *error = TDM_ERROR_OUT_OF_MEMORY;
 444                 return NULL;
 445         }
 446
 447         LIST_INITHEAD(&private_client->output_list);
 448
 449         private_client->display = wl_display_connect("tdm-socket");
 450         TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
 451
 452         private_client->queue = wl_display_create_queue(private_client->display);
 453         TDM_GOTO_IF_FAIL(private_client->queue != NULL, create_failed);
 454
 455         private_client->registry = wl_display_get_registry(private_client->display);
 456         TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
 457
 458         wl_registry_add_listener(private_client->registry,
 459                                                          &tdm_client_registry_listener, private_client);
 460         wl_display_roundtrip(private_client->display);
 461
 462         if (CHECK_WL_PROTOCOL_ERROR(private_client))
 463                 goto create_failed;
 464
 465         /* check global objects */
 466         TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
 467
 468         if (error)
 469                 *error = TDM_ERROR_NONE;
 470
 471         return (tdm_client*)private_client;
 472 create_failed:
 473         tdm_client_destroy((tdm_client*)private_client);
 474         if (error)
 475                 *error = TDM_ERROR_OPERATION_FAILED;
 476         return NULL;
 477 }
 478
 479 void
 480 tdm_client_destroy(tdm_client *client)
 481 {
 482         tdm_private_client *private_client = (tdm_private_client*)client;
 483         tdm_private_client_output *o = NULL, *oo = NULL;
 484
 485         if (!private_client)
 486                 return;
 487
 488         pthread_mutex_lock(&private_client->lock);
 489
 490         if (private_client->temp_vblank) {
 491                 pthread_mutex_unlock(&private_client->lock);
 492                 tdm_client_vblank_destroy(private_client->temp_vblank);
 493                 pthread_mutex_lock(&private_client->lock);
 494         }
 495
 496         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
 497                 _tdm_client_output_destroy(o);
 498         }
 499
 500         if (private_client->tdm)
 501                 wl_tdm_destroy(private_client->tdm);
 502         if (private_client->registry)
 503                 wl_registry_destroy(private_client->registry);
 504         if (private_client->queue)
 505                 wl_event_queue_destroy(private_client->queue);
 506         if (private_client->display)
 507                 wl_display_disconnect(private_client->display);
 508
 509         pthread_mutex_unlock(&private_client->lock);
 510         pthread_mutex_destroy(&private_client->lock);
 511
 512         free(private_client);
 513 }
 514
 515 tdm_error
 516 tdm_client_get_fd(tdm_client *client, int *fd)
 517 {
 518         tdm_private_client *private_client;
 519
 520         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 521         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 522
 523         private_client = (tdm_private_client*)client;
 524
 525         pthread_mutex_lock(&private_client->lock);
 526
 527         *fd = wl_display_get_fd(private_client->display);
 528
 529         pthread_mutex_unlock(&private_client->lock);
 530
 531         if (*fd < 0)
 532                 return TDM_ERROR_OPERATION_FAILED;
 533
 534         return TDM_ERROR_NONE;
 535 }
 536
 537 tdm_error
 538 tdm_client_handle_events(tdm_client *client)
 539 {
 540         tdm_private_client *private_client;
 541
 542         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 543
 544         /* LCOV_EXCL_START */
 545         private_client = (tdm_private_client*)client;
 546
 547         pthread_mutex_lock(&private_client->lock);
 548
 549         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 550                 pthread_mutex_unlock(&private_client->lock);
 551                 return TDM_ERROR_PROTOCOL_ERROR;
 552         }
 553
 554         if (private_client->enable_ttrace)
 555                 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 556
 557         wl_display_dispatch(private_client->display);
 558
 559         if (private_client->enable_ttrace)
 560                 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 561
 562         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 563                 pthread_mutex_unlock(&private_client->lock);
 564                 return TDM_ERROR_PROTOCOL_ERROR;
 565         }
 566
 567         pthread_mutex_unlock(&private_client->lock);
 568
 569         return TDM_ERROR_NONE;
 570         /* LCOV_EXCL_STOP */
 571 }
 572
 573 typedef struct _tdm_client_vblank_temp {
 574         tdm_client_vblank_handler2 func;
 575         void *user_data;
 576 } tdm_client_vblank_temp;
 577
 578 /* LCOV_EXCL_START */
 579 static void
 580 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
 581                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 582 {
 583         tdm_client_vblank_temp *vblank_temp = user_data;
 584
 585         TDM_RETURN_IF_FAIL(vblank_temp != NULL);
 586         TDM_RETURN_IF_FAIL(vblank != NULL);
 587
 588         if (vblank_temp->func)
 589                 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
 590
 591         free(vblank_temp);
 592 }
 593 /* LCOV_EXCL_STOP */
 594
 595 /* LCOV_EXCL_START */ /* deprecated */
 596 tdm_error
 597 tdm_client_wait_vblank(tdm_client *client, char *name,
 598                                            int sw_timer, int interval, int sync,
 599                                            tdm_client_vblank_handler2 func, void *user_data)
 600 {
 601         tdm_private_client *private_client = (tdm_private_client*)client;
 602         tdm_client_output *output;
 603         tdm_client_vblank_temp *vblank_temp;
 604         tdm_error ret;
 605
 606         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 607         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 608         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 609
 610         if (CHECK_WL_PROTOCOL_ERROR(private_client))
 611                 return TDM_ERROR_PROTOCOL_ERROR;
 612
 613         if (!private_client->temp_vblank) {
 614                 output = tdm_client_get_output(client, name, &ret);
 615                 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
 616
 617                 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
 618                 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
 619         }
 620
 621         tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
 622         tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
 623
 624         vblank_temp = calloc(1, sizeof *vblank_temp);
 625         TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
 626
 627         vblank_temp->func = func;
 628         vblank_temp->user_data = user_data;
 629
 630         return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
 631 }
 632 /* LCOV_EXCL_STOP */
 633
 634 tdm_client_output*
 635 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
 636 {
 637         tdm_private_client *private_client;
 638         tdm_private_client_output *private_output = NULL;
 639         struct wl_proxy *wrapper;
 640
 641         if (error)
 642                 *error = TDM_ERROR_NONE;
 643
 644         if (!client) {
 645                 TDM_ERR("'!client' failed");
 646                 if (error)
 647                         *error = TDM_ERROR_INVALID_PARAMETER;
 648                 return NULL;
 649         }
 650
 651         private_client = (tdm_private_client*)client;
 652
 653         pthread_mutex_lock(&private_client->lock);
 654
 655         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 656                 if (error)
 657                         *error = TDM_ERROR_PROTOCOL_ERROR;
 658                 pthread_mutex_unlock(&private_client->lock);
 659                 return NULL;
 660         }
 661
 662         if (!name)
 663                 name = "primary";
 664
 665         LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
 666                 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
 667                         pthread_mutex_unlock(&private_client->lock);
 668                         return (tdm_client_output*)private_output;
 669                 }
 670         }
 671
 672         wrapper = wl_proxy_create_wrapper(private_client->tdm);
 673         if (!wrapper) {
 674                 TDM_ERR("create output_wrapper failed");
 675                 if (error)
 676                         *error = TDM_ERROR_OUT_OF_MEMORY;
 677                 pthread_mutex_unlock(&private_client->lock);
 678                 return NULL;
 679         }
 680
 681         wl_proxy_set_queue(wrapper, private_client->queue);
 682
 683         private_output = calloc(1, sizeof *private_output);
 684         if (!private_output) {
 685                 /* LCOV_EXCL_START */
 686                 wl_proxy_wrapper_destroy(wrapper);
 687                 TDM_ERR("alloc failed");
 688                 if (error)
 689                         *error = TDM_ERROR_OUT_OF_MEMORY;
 690                 pthread_mutex_unlock(&private_client->lock);
 691                 return NULL;
 692
 693                 /* LCOV_EXCL_STOP */
 694         }
 695
 696         private_output->private_client = private_client;
 697
 698         snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
 699         private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
 700         wl_proxy_wrapper_destroy(wrapper);
 701         if (!private_output->output) {
 702                 /* LCOV_EXCL_START */
 703
 704                 TDM_ERR("couldn't create output resource");
 705                 free(private_output);
 706                 if (error)
 707                         *error = TDM_ERROR_OUT_OF_MEMORY;
 708                 pthread_mutex_unlock(&private_client->lock);
 709                 return NULL;
 710
 711                 /* LCOV_EXCL_STOP */
 712         }
 713
 714         LIST_INITHEAD(&private_output->vblank_list);
 715         LIST_INITHEAD(&private_output->change_handler_list);
 716
 717         wl_tdm_output_add_listener(private_output->output,
 718                                                            &tdm_client_output_listener, private_output);
 719         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 720
 721         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 722
 723         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 724                 wl_tdm_output_destroy(private_output->output);
 725                 free(private_output);
 726                 if (error)
 727                         *error = TDM_ERROR_PROTOCOL_ERROR;
 728                 pthread_mutex_unlock(&private_client->lock);
 729                 return NULL;
 730         }
 731
 732         LIST_ADDTAIL(&private_output->link, &private_client->output_list);
 733
 734         pthread_mutex_unlock(&private_client->lock);
 735
 736         return (tdm_client_output*)private_output;
 737 }
 738
 739 tdm_error
 740 tdm_client_output_add_change_handler(tdm_client_output *output,
 741                                                                          tdm_client_output_change_handler func,
 742                                                                          void *user_data)
 743 {
 744         tdm_private_client_output *private_output;
 745         tdm_private_client *private_client;
 746         tdm_client_output_handler_info *h;
 747
 748         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 749         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 750
 751         private_output = (tdm_private_client_output*)output;
 752         private_client = private_output->private_client;
 753
 754         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 755                 if (h->func == func && h->user_data == user_data) {
 756                         TDM_ERR("can't add twice");
 757                         return TDM_ERROR_BAD_REQUEST;
 758                 }
 759         }
 760
 761         h = calloc(1, sizeof *h);
 762         TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
 763
 764         pthread_mutex_lock(&private_client->lock);
 765
 766         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 767                 free(h);
 768                 pthread_mutex_unlock(&private_client->lock);
 769                 return TDM_ERROR_PROTOCOL_ERROR;
 770         }
 771
 772         if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 773                 wl_tdm_output_watch_output_changes(private_output->output, 1);
 774
 775                 /* TODO: this is very tricky.
 776                  * If a client adds the change_handler, we might be able to guess that
 777                  * the client will watch the tdm client's fd and handle tdm events in
 778                  * event loop. Otherwise, we CAN'T make sure if a client has event loop
 779                  * which handles tdm events.
 780                  */
 781                 private_output->watch_output_changes = 1;
 782         }
 783
 784         h->private_output = private_output;
 785         h->func = func;
 786         h->user_data = user_data;
 787         LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
 788         LIST_INITHEAD(&h->call_link);
 789
 790         pthread_mutex_unlock(&private_client->lock);
 791
 792         return TDM_ERROR_NONE;
 793 }
 794
 795 void
 796 tdm_client_output_remove_change_handler(tdm_client_output *output,
 797                                                                                 tdm_client_output_change_handler func,
 798                                                                                 void *user_data)
 799 {
 800         tdm_private_client_output *private_output;
 801         tdm_private_client *private_client;
 802         tdm_client_output_handler_info *h = NULL;
 803
 804         TDM_RETURN_IF_FAIL(output != NULL);
 805         TDM_RETURN_IF_FAIL(func != NULL);
 806
 807         private_output = (tdm_private_client_output*)output;
 808         private_client = private_output->private_client;
 809
 810         pthread_mutex_lock(&private_client->lock);
 811
 812         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 813                 if (h->func != func || h->user_data != user_data)
 814                         continue;
 815
 816                 LIST_DEL(&h->link);
 817                 free(h);
 818
 819                 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 820                         if (!CHECK_WL_PROTOCOL_ERROR(private_client))
 821                                 wl_tdm_output_watch_output_changes(private_output->output, 0);
 822                 }
 823
 824                 pthread_mutex_unlock(&private_client->lock);
 825
 826                 return;
 827         }
 828
 829         pthread_mutex_unlock(&private_client->lock);
 830 }
 831
 832 tdm_error
 833 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
 834 {
 835         tdm_private_client_output *private_output;
 836         tdm_private_client *private_client;
 837
 838         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 839         TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
 840
 841         private_output = (tdm_private_client_output*)output;
 842         private_client = private_output->private_client;
 843
 844         pthread_mutex_lock(&private_client->lock);
 845
 846         if (private_output->watch_output_changes) {
 847                 *refresh = private_output->refresh;
 848                 pthread_mutex_unlock(&private_client->lock);
 849                 return TDM_ERROR_NONE;
 850         }
 851
 852         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 853                 pthread_mutex_unlock(&private_client->lock);
 854                 return TDM_ERROR_PROTOCOL_ERROR;
 855         }
 856
 857         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 858         wl_tdm_output_get_mode(private_output->output);
 859         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 860         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 861
 862         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 863                 pthread_mutex_unlock(&private_client->lock);
 864                 return TDM_ERROR_PROTOCOL_ERROR;
 865         }
 866
 867         *refresh = private_output->refresh;
 868
 869         pthread_mutex_unlock(&private_client->lock);
 870
 871         return TDM_ERROR_NONE;
 872 }
 873
 874 tdm_error
 875 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
 876 {
 877         tdm_private_client_output *private_output;
 878         tdm_private_client *private_client;
 879
 880         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 881         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 882
 883         private_output = (tdm_private_client_output*)output;
 884         private_client = private_output->private_client;
 885
 886         pthread_mutex_lock(&private_client->lock);
 887
 888         if (private_output->watch_output_changes) {
 889                 *status = private_output->connection;
 890                 pthread_mutex_unlock(&private_client->lock);
 891                 return TDM_ERROR_NONE;
 892         }
 893
 894         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 895                 pthread_mutex_unlock(&private_client->lock);
 896                 return TDM_ERROR_PROTOCOL_ERROR;
 897         }
 898
 899         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 900         wl_tdm_output_get_connection(private_output->output);
 901         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 902         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 903
 904         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 905                 pthread_mutex_unlock(&private_client->lock);
 906                 return TDM_ERROR_PROTOCOL_ERROR;
 907         }
 908
 909         *status = private_output->connection;
 910
 911         pthread_mutex_unlock(&private_client->lock);
 912
 913         return TDM_ERROR_NONE;
 914 }
 915
 916 tdm_error
 917 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
 918 {
 919         tdm_private_client_output *private_output;
 920         tdm_private_client *private_client;
 921
 922         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 923         TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
 924
 925         private_output = (tdm_private_client_output*)output;
 926         private_client = private_output->private_client;
 927
 928         if (private_output->watch_output_changes) {
 929                 *dpms = private_output->dpms;
 930                 return TDM_ERROR_NONE;
 931         }
 932
 933         pthread_mutex_lock(&private_client->lock);
 934
 935         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 936                 pthread_mutex_unlock(&private_client->lock);
 937                 return TDM_ERROR_PROTOCOL_ERROR;
 938         }
 939
 940         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 941         wl_tdm_output_get_dpms(private_output->output);
 942         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 943         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 944
 945         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 946                 pthread_mutex_unlock(&private_client->lock);
 947                 return TDM_ERROR_PROTOCOL_ERROR;
 948         }
 949
 950         *dpms = private_output->dpms;
 951
 952         pthread_mutex_unlock(&private_client->lock);
 953
 954         return TDM_ERROR_NONE;
 955 }
 956
 957 tdm_client_vblank*
 958 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
 959 {
 960         tdm_private_client *private_client;
 961         tdm_private_client_output *private_output;
 962         tdm_private_client_vblank *private_vblank;
 963         struct wl_proxy *wrapper;
 964
 965         if (error)
 966                 *error = TDM_ERROR_NONE;
 967
 968         if (!output) {
 969                 TDM_ERR("'!output' failed");
 970                 if (error)
 971                         *error = TDM_ERROR_INVALID_PARAMETER;
 972                 return NULL;
 973         }
 974
 975         private_output = (tdm_private_client_output*)output;
 976         private_client = private_output->private_client;
 977
 978         pthread_mutex_lock(&private_client->lock);
 979
 980         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 981                 if (error)
 982                         *error = TDM_ERROR_PROTOCOL_ERROR;
 983                 pthread_mutex_unlock(&private_client->lock);
 984                 return NULL;
 985         }
 986
 987         wrapper = wl_proxy_create_wrapper(private_output->output);
 988         if (!wrapper) {
 989                 TDM_ERR("create output_wrapper failed");
 990                 if (error)
 991                         *error = TDM_ERROR_OUT_OF_MEMORY;
 992                 pthread_mutex_unlock(&private_client->lock);
 993                 return NULL;
 994         }
 995
 996         wl_proxy_set_queue(wrapper, private_client->queue);
 997
 998         private_vblank = calloc(1, sizeof *private_vblank);
 999         if (!private_vblank) {
1000                 /* LCOV_EXCL_START */
1001
1002                 TDM_ERR("alloc failed");
1003                 wl_proxy_wrapper_destroy(wrapper);
1004                 if (error)
1005                         *error = TDM_ERROR_OUT_OF_MEMORY;
1006                 pthread_mutex_unlock(&private_client->lock);
1007                 return NULL;
1008
1009                 /* LCOV_EXCL_STOP */
1010         }
1011
1012         private_vblank->private_output = private_output;
1013
1014         private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
1015         wl_proxy_wrapper_destroy(wrapper);
1016         if (!private_vblank->vblank) {
1017                 /* LCOV_EXCL_START */
1018
1019                 TDM_ERR("couldn't create vblank resource");
1020                 free(private_vblank);
1021                 if (error)
1022                         *error = TDM_ERROR_OUT_OF_MEMORY;
1023                 pthread_mutex_unlock(&private_client->lock);
1024                 return NULL;
1025
1026                 /* LCOV_EXCL_STOP */
1027         }
1028
1029         /* initial value */
1030         private_vblank->fps = private_output->refresh;
1031         private_vblank->offset = 0;
1032         private_vblank->enable_fake = 0;
1033
1034         LIST_INITHEAD(&private_vblank->wait_list);
1035
1036         wl_tdm_vblank_add_listener(private_vblank->vblank,
1037                                                            &tdm_client_vblank_listener, private_vblank);
1038         wl_display_roundtrip_queue(private_client->display, private_client->queue);
1039
1040         wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
1041
1042         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1043                 wl_tdm_vblank_destroy(private_vblank->vblank);
1044                 free(private_vblank);
1045                 if (error)
1046                         *error = TDM_ERROR_PROTOCOL_ERROR;
1047                 pthread_mutex_unlock(&private_client->lock);
1048                 return NULL;
1049         }
1050
1051         LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
1052
1053         pthread_mutex_unlock(&private_client->lock);
1054
1055         return (tdm_client_vblank*)private_vblank;
1056 }
1057
1058 void
1059 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
1060 {
1061         tdm_private_client_vblank *private_vblank;
1062         tdm_private_client *private_client;
1063         tdm_client_wait_info *w = NULL, *ww = NULL;
1064
1065         TDM_RETURN_IF_FAIL(vblank != NULL);
1066
1067         private_vblank = vblank;
1068         private_client = private_vblank->private_output->private_client;
1069
1070         pthread_mutex_lock(&private_client->lock);
1071
1072         LIST_DEL(&private_vblank->link);
1073
1074         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
1075                 LIST_DEL(&w->link);
1076                 free(w);
1077         }
1078
1079         wl_tdm_vblank_destroy(private_vblank->vblank);
1080
1081         free(private_vblank);
1082
1083         pthread_mutex_unlock(&private_client->lock);
1084 }
1085
1086 tdm_error
1087 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
1088 {
1089         tdm_private_client_vblank *private_vblank;
1090         tdm_private_client *private_client;
1091
1092         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1093
1094         private_vblank = vblank;
1095         private_client = private_vblank->private_output->private_client;
1096
1097         pthread_mutex_lock(&private_client->lock);
1098
1099         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1100                 pthread_mutex_unlock(&private_client->lock);
1101                 return TDM_ERROR_PROTOCOL_ERROR;
1102         }
1103
1104         if (!name)
1105                 name = TDM_VBLANK_DEFAULT_NAME;
1106
1107         strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
1108         private_vblank->name[TDM_NAME_LEN - 1] = '\0';
1109
1110         wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
1111
1112         pthread_mutex_unlock(&private_client->lock);
1113
1114         return TDM_ERROR_NONE;
1115 }
1116
1117 tdm_error
1118 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
1119 {
1120         tdm_private_client_vblank *private_vblank;
1121         tdm_private_client *private_client;
1122
1123         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1124
1125         private_vblank = vblank;
1126         private_client = private_vblank->private_output->private_client;
1127
1128         pthread_mutex_lock(&private_client->lock);
1129         private_vblank->sync = sync;
1130         pthread_mutex_unlock(&private_client->lock);
1131
1132         return TDM_ERROR_NONE;
1133 }
1134
1135 tdm_error
1136 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
1137 {
1138         tdm_private_client_vblank *private_vblank;
1139         tdm_private_client *private_client;
1140
1141         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1142         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
1143
1144         private_vblank = vblank;
1145         private_client = private_vblank->private_output->private_client;
1146
1147         pthread_mutex_lock(&private_client->lock);
1148
1149         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1150                 pthread_mutex_unlock(&private_client->lock);
1151                 return TDM_ERROR_PROTOCOL_ERROR;
1152         }
1153
1154         if (private_vblank->fps == fps) {
1155                 pthread_mutex_unlock(&private_client->lock);
1156                 return TDM_ERROR_NONE;
1157         }
1158
1159         private_vblank->fps = fps;
1160
1161         wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
1162
1163         pthread_mutex_unlock(&private_client->lock);
1164
1165         return TDM_ERROR_NONE;
1166 }
1167
1168 tdm_error
1169 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
1170 {
1171         tdm_private_client_vblank *private_vblank;
1172         tdm_private_client *private_client;
1173
1174         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1175
1176         private_vblank = vblank;
1177         TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
1178
1179         private_client = private_vblank->private_output->private_client;
1180
1181         pthread_mutex_lock(&private_client->lock);
1182
1183         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1184                 pthread_mutex_unlock(&private_client->lock);
1185                 return TDM_ERROR_PROTOCOL_ERROR;
1186         }
1187
1188         if (private_vblank->offset == offset_ms) {
1189                 pthread_mutex_unlock(&private_client->lock);
1190                 return TDM_ERROR_NONE;
1191         }
1192
1193         private_vblank->offset = offset_ms;
1194
1195         wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
1196
1197         pthread_mutex_unlock(&private_client->lock);
1198
1199         return TDM_ERROR_NONE;
1200 }
1201
1202 tdm_error
1203 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
1204 {
1205         tdm_private_client_vblank *private_vblank;
1206         tdm_private_client *private_client;
1207
1208         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1209
1210         private_vblank = vblank;
1211         private_client = private_vblank->private_output->private_client;
1212
1213         pthread_mutex_lock(&private_client->lock);
1214
1215         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1216                 pthread_mutex_unlock(&private_client->lock);
1217                 return TDM_ERROR_PROTOCOL_ERROR;
1218         }
1219
1220         if (private_vblank->enable_fake == enable_fake) {
1221                 pthread_mutex_unlock(&private_client->lock);
1222                 return TDM_ERROR_NONE;
1223         }
1224
1225         private_vblank->enable_fake = enable_fake;
1226
1227         wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
1228
1229         pthread_mutex_unlock(&private_client->lock);
1230
1231         return TDM_ERROR_NONE;
1232 }
1233
1234 tdm_error
1235 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
1236 {
1237         tdm_private_client *private_client;
1238         tdm_private_client_output *private_output;
1239         tdm_private_client_vblank *private_vblank;
1240         tdm_client_wait_info *w;
1241         struct timespec tp;
1242         unsigned int req_sec, req_usec;
1243         int ret = 0;
1244
1245         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1246         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1247         /* can't support "interval 0" and "getting current_msc" things because
1248          * there is a socket communication between TDM client and server. It's impossible
1249          * to return the current msc or sequence immediately.
1250          */
1251         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1252
1253         private_vblank = vblank;
1254         private_output = private_vblank->private_output;
1255         private_client = private_output->private_client;
1256
1257         pthread_mutex_lock(&private_client->lock);
1258
1259         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1260                 pthread_mutex_unlock(&private_client->lock);
1261                 return TDM_ERROR_PROTOCOL_ERROR;
1262         }
1263
1264         if (!private_vblank->started)
1265                 private_vblank->started = 1;
1266
1267         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1268                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1269                         TDM_ERR("output disconnected");
1270                         pthread_mutex_unlock(&private_client->lock);
1271                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1272                 }
1273                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1274                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1275                         pthread_mutex_unlock(&private_client->lock);
1276                         return TDM_ERROR_DPMS_OFF;
1277                 }
1278         }
1279
1280         w = calloc(1, sizeof *w);
1281         if (!w) {
1282                 /* LCOV_EXCL_START */
1283
1284                 TDM_ERR("alloc failed");
1285                 pthread_mutex_unlock(&private_client->lock);
1286                 return TDM_ERROR_OUT_OF_MEMORY;
1287
1288                 /* LCOV_EXCL_STOP */
1289         }
1290
1291         w->private_vblank = private_vblank;
1292         w->func = func;
1293         w->user_data = user_data;
1294
1295         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1296         LIST_INITHEAD(&w->call_link);
1297
1298         clock_gettime(CLOCK_MONOTONIC, &tp);
1299         req_sec = (unsigned int)tp.tv_sec;
1300         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1301
1302         w->req_id = ++private_output->req_id;
1303         w->req_time = TDM_TIME(req_sec, req_usec);
1304         w->need_free = (private_vblank->sync) ? 0 : 1;
1305
1306         wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1307
1308         if (private_vblank->enable_ttrace)
1309                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1310
1311         TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1312                         vblank, interval, w->req_id, w->req_time);
1313
1314         private_vblank->req_time = w->req_time;
1315
1316         if (private_vblank->last_time >= w->req_time)
1317                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1318
1319         if (!private_vblank->sync) {
1320                 wl_display_flush(private_client->display);
1321                 pthread_mutex_unlock(&private_client->lock);
1322                 return TDM_ERROR_NONE;
1323         }
1324
1325         /* LCOV_EXCL_START */
1326
1327         while (ret != -1 && !w->need_free)
1328                 ret = wl_display_dispatch(private_client->display);
1329
1330         clock_gettime(CLOCK_MONOTONIC, &tp);
1331         TDM_DBG("block during %d us",
1332                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1333                         - (req_sec * 1000000 + req_usec));
1334
1335         LIST_DEL(&w->link);
1336         free(w);
1337
1338         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1339                 pthread_mutex_unlock(&private_client->lock);
1340                 return TDM_ERROR_PROTOCOL_ERROR;
1341         }
1342
1343         pthread_mutex_unlock(&private_client->lock);
1344
1345         return TDM_ERROR_NONE;
1346
1347         /* LCOV_EXCL_STOP */
1348 }
1349
1350 tdm_error
1351 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1352                                                    tdm_client_vblank_handler func, void *user_data)
1353 {
1354         tdm_private_client *private_client;
1355         tdm_private_client_output *private_output;
1356         tdm_private_client_vblank *private_vblank;
1357         tdm_client_wait_info *w;
1358         struct timespec tp;
1359         unsigned int req_sec, req_usec;
1360         int ret = 0;
1361
1362         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1363         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1364
1365         private_vblank = vblank;
1366         private_output = private_vblank->private_output;
1367         private_client = private_output->private_client;
1368
1369         pthread_mutex_lock(&private_client->lock);
1370
1371         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1372                 pthread_mutex_unlock(&private_client->lock);
1373                 return TDM_ERROR_PROTOCOL_ERROR;
1374         }
1375
1376         if (!private_vblank->started)
1377                 private_vblank->started = 1;
1378
1379         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1380                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1381                         TDM_ERR("output disconnected");
1382                         pthread_mutex_unlock(&private_client->lock);
1383                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1384                 }
1385                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1386                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1387                         pthread_mutex_unlock(&private_client->lock);
1388                         return TDM_ERROR_DPMS_OFF;
1389                 }
1390         }
1391
1392         w = calloc(1, sizeof *w);
1393         if (!w) {
1394                 /* LCOV_EXCL_START */
1395
1396                 TDM_ERR("alloc failed");
1397                 pthread_mutex_unlock(&private_client->lock);
1398                 return TDM_ERROR_OUT_OF_MEMORY;
1399
1400                 /* LCOV_EXCL_STOP */
1401         }
1402
1403         w->private_vblank = private_vblank;
1404         w->func = func;
1405         w->user_data = user_data;
1406
1407         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1408         LIST_INITHEAD(&w->call_link);
1409
1410         clock_gettime(CLOCK_MONOTONIC, &tp);
1411         req_sec = (unsigned int)tp.tv_sec;
1412         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1413
1414         w->req_id = ++private_output->req_id;
1415         w->req_time = TDM_TIME(req_sec, req_usec);
1416         w->need_free = (private_vblank->sync) ? 0 : 1;
1417
1418         wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1419
1420         if (private_vblank->enable_ttrace)
1421                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1422
1423         TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1424                         vblank, sequence, w->req_id, w->req_time);
1425
1426         private_vblank->req_time = w->req_time;
1427
1428         if (private_vblank->last_time >= w->req_time)
1429                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1430
1431         if (!private_vblank->sync) {
1432                 wl_display_flush(private_client->display);
1433                 pthread_mutex_unlock(&private_client->lock);
1434                 return TDM_ERROR_NONE;
1435         }
1436
1437         /* LCOV_EXCL_START */
1438
1439         while (ret != -1 && !w->need_free)
1440                 ret = wl_display_dispatch(private_client->display);
1441
1442         clock_gettime(CLOCK_MONOTONIC, &tp);
1443         TDM_DBG("block during %d us",
1444                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1445                         - (req_sec * 1000000 + req_usec));
1446
1447         LIST_DEL(&w->link);
1448         free(w);
1449
1450         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1451                 pthread_mutex_unlock(&private_client->lock);
1452                 return TDM_ERROR_PROTOCOL_ERROR;
1453         }
1454
1455         pthread_mutex_unlock(&private_client->lock);
1456
1457         return TDM_ERROR_NONE;
1458
1459         /* LCOV_EXCL_STOP */
1460 }