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                 tdm_client_vblank_destroy(private_client->temp_vblank);
 492
 493         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
 494                 _tdm_client_output_destroy(o);
 495         }
 496
 497         if (private_client->tdm)
 498                 wl_tdm_destroy(private_client->tdm);
 499         if (private_client->registry)
 500                 wl_registry_destroy(private_client->registry);
 501         if (private_client->queue)
 502                 wl_event_queue_destroy(private_client->queue);
 503         if (private_client->display)
 504                 wl_display_disconnect(private_client->display);
 505
 506         pthread_mutex_unlock(&private_client->lock);
 507         pthread_mutex_destroy(&private_client->lock);
 508
 509         free(private_client);
 510 }
 511
 512 tdm_error
 513 tdm_client_get_fd(tdm_client *client, int *fd)
 514 {
 515         tdm_private_client *private_client;
 516
 517         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 518         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 519
 520         private_client = (tdm_private_client*)client;
 521
 522         pthread_mutex_lock(&private_client->lock);
 523
 524         *fd = wl_display_get_fd(private_client->display);
 525
 526         pthread_mutex_unlock(&private_client->lock);
 527
 528         if (*fd < 0)
 529                 return TDM_ERROR_OPERATION_FAILED;
 530
 531         return TDM_ERROR_NONE;
 532 }
 533
 534 tdm_error
 535 tdm_client_handle_events(tdm_client *client)
 536 {
 537         tdm_private_client *private_client;
 538
 539         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 540
 541         /* LCOV_EXCL_START */
 542         private_client = (tdm_private_client*)client;
 543
 544         pthread_mutex_lock(&private_client->lock);
 545
 546         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 547                 pthread_mutex_unlock(&private_client->lock);
 548                 return TDM_ERROR_PROTOCOL_ERROR;
 549         }
 550
 551         if (private_client->enable_ttrace)
 552                 TDM_TRACE_ASYNC_BEGIN((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 553
 554         wl_display_dispatch(private_client->display);
 555
 556         if (private_client->enable_ttrace)
 557                 TDM_TRACE_ASYNC_END((int)private_client->stamp, "TDM_Client_Events:%u", (unsigned int)private_client->stamp);
 558
 559         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 560                 pthread_mutex_unlock(&private_client->lock);
 561                 return TDM_ERROR_PROTOCOL_ERROR;
 562         }
 563
 564         pthread_mutex_unlock(&private_client->lock);
 565
 566         return TDM_ERROR_NONE;
 567         /* LCOV_EXCL_STOP */
 568 }
 569
 570 typedef struct _tdm_client_vblank_temp {
 571         tdm_client_vblank_handler2 func;
 572         void *user_data;
 573 } tdm_client_vblank_temp;
 574
 575 /* LCOV_EXCL_START */
 576 static void
 577 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
 578                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 579 {
 580         tdm_client_vblank_temp *vblank_temp = user_data;
 581         tdm_private_client_vblank *private_vblank;
 582         tdm_private_client *private_client;
 583
 584         TDM_RETURN_IF_FAIL(vblank_temp != NULL);
 585         TDM_RETURN_IF_FAIL(vblank != NULL);
 586
 587         private_vblank = vblank;
 588         private_client = private_vblank->private_output->private_client;
 589
 590         if (vblank_temp->func) {
 591                 pthread_mutex_unlock(&private_client->lock);
 592                 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
 593                 pthread_mutex_lock(&private_client->lock);
 594         }
 595
 596         free(vblank_temp);
 597 }
 598 /* LCOV_EXCL_STOP */
 599
 600 /* LCOV_EXCL_START */ /* deprecated */
 601 tdm_error
 602 tdm_client_wait_vblank(tdm_client *client, char *name,
 603                                            int sw_timer, int interval, int sync,
 604                                            tdm_client_vblank_handler2 func, void *user_data)
 605 {
 606         tdm_private_client *private_client = (tdm_private_client*)client;
 607         tdm_client_output *output;
 608         tdm_client_vblank_temp *vblank_temp;
 609         tdm_error ret;
 610
 611         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 612         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 613         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 614
 615         if (CHECK_WL_PROTOCOL_ERROR(private_client))
 616                 return TDM_ERROR_PROTOCOL_ERROR;
 617
 618         if (!private_client->temp_vblank) {
 619                 output = tdm_client_get_output(client, name, &ret);
 620                 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
 621
 622                 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
 623                 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
 624         }
 625
 626         tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
 627         tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
 628
 629         vblank_temp = calloc(1, sizeof *vblank_temp);
 630         TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
 631
 632         vblank_temp->func = func;
 633         vblank_temp->user_data = user_data;
 634
 635         return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
 636 }
 637 /* LCOV_EXCL_STOP */
 638
 639 tdm_client_output*
 640 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
 641 {
 642         tdm_private_client *private_client;
 643         tdm_private_client_output *private_output = NULL;
 644         struct wl_proxy *wrapper;
 645
 646         if (error)
 647                 *error = TDM_ERROR_NONE;
 648
 649         if (!client) {
 650                 TDM_ERR("'!client' failed");
 651                 if (error)
 652                         *error = TDM_ERROR_INVALID_PARAMETER;
 653                 return NULL;
 654         }
 655
 656         private_client = (tdm_private_client*)client;
 657
 658         pthread_mutex_lock(&private_client->lock);
 659
 660         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 661                 if (error)
 662                         *error = TDM_ERROR_PROTOCOL_ERROR;
 663                 pthread_mutex_unlock(&private_client->lock);
 664                 return NULL;
 665         }
 666
 667         if (!name)
 668                 name = "primary";
 669
 670         LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
 671                 if (!strncmp(private_output->name, name, TDM_NAME_LEN)) {
 672                         pthread_mutex_unlock(&private_client->lock);
 673                         return (tdm_client_output*)private_output;
 674                 }
 675         }
 676
 677         wrapper = wl_proxy_create_wrapper(private_client->tdm);
 678         if (!wrapper) {
 679                 TDM_ERR("create output_wrapper failed");
 680                 if (error)
 681                         *error = TDM_ERROR_OUT_OF_MEMORY;
 682                 pthread_mutex_unlock(&private_client->lock);
 683                 return NULL;
 684         }
 685
 686         wl_proxy_set_queue(wrapper, private_client->queue);
 687
 688         private_output = calloc(1, sizeof *private_output);
 689         if (!private_output) {
 690                 /* LCOV_EXCL_START */
 691                 wl_proxy_wrapper_destroy(wrapper);
 692                 TDM_ERR("alloc failed");
 693                 if (error)
 694                         *error = TDM_ERROR_OUT_OF_MEMORY;
 695                 pthread_mutex_unlock(&private_client->lock);
 696                 return NULL;
 697
 698                 /* LCOV_EXCL_STOP */
 699         }
 700
 701         private_output->private_client = private_client;
 702
 703         snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
 704         private_output->output = wl_tdm_create_output((struct wl_tdm *)wrapper, private_output->name);
 705         wl_proxy_wrapper_destroy(wrapper);
 706         if (!private_output->output) {
 707                 /* LCOV_EXCL_START */
 708
 709                 TDM_ERR("couldn't create output resource");
 710                 free(private_output);
 711                 if (error)
 712                         *error = TDM_ERROR_OUT_OF_MEMORY;
 713                 pthread_mutex_unlock(&private_client->lock);
 714                 return NULL;
 715
 716                 /* LCOV_EXCL_STOP */
 717         }
 718
 719         LIST_INITHEAD(&private_output->vblank_list);
 720         LIST_INITHEAD(&private_output->change_handler_list);
 721
 722         wl_tdm_output_add_listener(private_output->output,
 723                                                            &tdm_client_output_listener, private_output);
 724         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 725
 726         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 727
 728         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 729                 wl_tdm_output_destroy(private_output->output);
 730                 free(private_output);
 731                 if (error)
 732                         *error = TDM_ERROR_PROTOCOL_ERROR;
 733                 pthread_mutex_unlock(&private_client->lock);
 734                 return NULL;
 735         }
 736
 737         LIST_ADDTAIL(&private_output->link, &private_client->output_list);
 738
 739         pthread_mutex_unlock(&private_client->lock);
 740
 741         return (tdm_client_output*)private_output;
 742 }
 743
 744 tdm_error
 745 tdm_client_output_add_change_handler(tdm_client_output *output,
 746                                                                          tdm_client_output_change_handler func,
 747                                                                          void *user_data)
 748 {
 749         tdm_private_client_output *private_output;
 750         tdm_private_client *private_client;
 751         tdm_client_output_handler_info *h;
 752
 753         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 754         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 755
 756         private_output = (tdm_private_client_output*)output;
 757         private_client = private_output->private_client;
 758
 759         h = calloc(1, sizeof *h);
 760         TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
 761
 762         pthread_mutex_lock(&private_client->lock);
 763
 764         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 765                 free(h);
 766                 pthread_mutex_unlock(&private_client->lock);
 767                 return TDM_ERROR_PROTOCOL_ERROR;
 768         }
 769
 770         if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 771                 wl_tdm_output_watch_output_changes(private_output->output, 1);
 772
 773                 /* TODO: this is very tricky.
 774                  * If a client adds the change_handler, we might be able to guess that
 775                  * the client will watch the tdm client's fd and handle tdm events in
 776                  * event loop. Otherwise, we CAN'T make sure if a client has event loop
 777                  * which handles tdm events.
 778                  */
 779                 private_output->watch_output_changes = 1;
 780         }
 781
 782         h->private_output = private_output;
 783         h->func = func;
 784         h->user_data = user_data;
 785         LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
 786         LIST_INITHEAD(&h->call_link);
 787
 788         pthread_mutex_unlock(&private_client->lock);
 789
 790         return TDM_ERROR_NONE;
 791 }
 792
 793 void
 794 tdm_client_output_remove_change_handler(tdm_client_output *output,
 795                                                                                 tdm_client_output_change_handler func,
 796                                                                                 void *user_data)
 797 {
 798         tdm_private_client_output *private_output;
 799         tdm_private_client *private_client;
 800         tdm_client_output_handler_info *h = NULL;
 801
 802         TDM_RETURN_IF_FAIL(output != NULL);
 803         TDM_RETURN_IF_FAIL(func != NULL);
 804
 805         private_output = (tdm_private_client_output*)output;
 806         private_client = private_output->private_client;
 807
 808         pthread_mutex_lock(&private_client->lock);
 809
 810         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 811                 if (h->func != func || h->user_data != user_data)
 812                         continue;
 813
 814                 LIST_DEL(&h->link);
 815                 free(h);
 816
 817                 if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 818                         if (!CHECK_WL_PROTOCOL_ERROR(private_client))
 819                                 wl_tdm_output_watch_output_changes(private_output->output, 0);
 820                 }
 821
 822                 pthread_mutex_unlock(&private_client->lock);
 823
 824                 return;
 825         }
 826
 827         pthread_mutex_unlock(&private_client->lock);
 828 }
 829
 830 tdm_error
 831 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
 832 {
 833         tdm_private_client_output *private_output;
 834         tdm_private_client *private_client;
 835
 836         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 837         TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
 838
 839         private_output = (tdm_private_client_output*)output;
 840         private_client = private_output->private_client;
 841
 842         pthread_mutex_lock(&private_client->lock);
 843
 844         if (private_output->watch_output_changes) {
 845                 *refresh = private_output->refresh;
 846                 pthread_mutex_unlock(&private_client->lock);
 847                 return TDM_ERROR_NONE;
 848         }
 849
 850         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 851                 pthread_mutex_unlock(&private_client->lock);
 852                 return TDM_ERROR_PROTOCOL_ERROR;
 853         }
 854
 855         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 856         wl_tdm_output_get_mode(private_output->output);
 857         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 858         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 859
 860         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 861                 pthread_mutex_unlock(&private_client->lock);
 862                 return TDM_ERROR_PROTOCOL_ERROR;
 863         }
 864
 865         *refresh = private_output->refresh;
 866
 867         pthread_mutex_unlock(&private_client->lock);
 868
 869         return TDM_ERROR_NONE;
 870 }
 871
 872 tdm_error
 873 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
 874 {
 875         tdm_private_client_output *private_output;
 876         tdm_private_client *private_client;
 877
 878         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 879         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 880
 881         private_output = (tdm_private_client_output*)output;
 882         private_client = private_output->private_client;
 883
 884         pthread_mutex_lock(&private_client->lock);
 885
 886         if (private_output->watch_output_changes) {
 887                 *status = private_output->connection;
 888                 pthread_mutex_unlock(&private_client->lock);
 889                 return TDM_ERROR_NONE;
 890         }
 891
 892         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 893                 pthread_mutex_unlock(&private_client->lock);
 894                 return TDM_ERROR_PROTOCOL_ERROR;
 895         }
 896
 897         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 898         wl_tdm_output_get_connection(private_output->output);
 899         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 900         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 901
 902         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 903                 pthread_mutex_unlock(&private_client->lock);
 904                 return TDM_ERROR_PROTOCOL_ERROR;
 905         }
 906
 907         *status = private_output->connection;
 908
 909         pthread_mutex_unlock(&private_client->lock);
 910
 911         return TDM_ERROR_NONE;
 912 }
 913
 914 tdm_error
 915 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
 916 {
 917         tdm_private_client_output *private_output;
 918         tdm_private_client *private_client;
 919
 920         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 921         TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
 922
 923         private_output = (tdm_private_client_output*)output;
 924         private_client = private_output->private_client;
 925
 926         if (private_output->watch_output_changes) {
 927                 *dpms = private_output->dpms;
 928                 return TDM_ERROR_NONE;
 929         }
 930
 931         pthread_mutex_lock(&private_client->lock);
 932
 933         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 934                 pthread_mutex_unlock(&private_client->lock);
 935                 return TDM_ERROR_PROTOCOL_ERROR;
 936         }
 937
 938         wl_proxy_set_queue((struct wl_proxy *)private_output->output, private_client->queue);
 939         wl_tdm_output_get_dpms(private_output->output);
 940         wl_display_roundtrip_queue(private_client->display, private_client->queue);
 941         wl_proxy_set_queue((struct wl_proxy *)private_output->output, NULL);
 942
 943         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 944                 pthread_mutex_unlock(&private_client->lock);
 945                 return TDM_ERROR_PROTOCOL_ERROR;
 946         }
 947
 948         *dpms = private_output->dpms;
 949
 950         pthread_mutex_unlock(&private_client->lock);
 951
 952         return TDM_ERROR_NONE;
 953 }
 954
 955 tdm_client_vblank*
 956 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
 957 {
 958         tdm_private_client *private_client;
 959         tdm_private_client_output *private_output;
 960         tdm_private_client_vblank *private_vblank;
 961         struct wl_proxy *wrapper;
 962
 963         if (error)
 964                 *error = TDM_ERROR_NONE;
 965
 966         if (!output) {
 967                 TDM_ERR("'!output' failed");
 968                 if (error)
 969                         *error = TDM_ERROR_INVALID_PARAMETER;
 970                 return NULL;
 971         }
 972
 973         private_output = (tdm_private_client_output*)output;
 974         private_client = private_output->private_client;
 975
 976         pthread_mutex_lock(&private_client->lock);
 977
 978         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
 979                 if (error)
 980                         *error = TDM_ERROR_PROTOCOL_ERROR;
 981                 pthread_mutex_unlock(&private_client->lock);
 982                 return NULL;
 983         }
 984
 985         wrapper = wl_proxy_create_wrapper(private_output->output);
 986         if (!wrapper) {
 987                 TDM_ERR("create output_wrapper failed");
 988                 if (error)
 989                         *error = TDM_ERROR_OUT_OF_MEMORY;
 990                 pthread_mutex_unlock(&private_client->lock);
 991                 return NULL;
 992         }
 993
 994         wl_proxy_set_queue(wrapper, private_client->queue);
 995
 996         private_vblank = calloc(1, sizeof *private_vblank);
 997         if (!private_vblank) {
 998                 /* LCOV_EXCL_START */
 999
1000                 TDM_ERR("alloc failed");
1001                 wl_proxy_wrapper_destroy(wrapper);
1002                 if (error)
1003                         *error = TDM_ERROR_OUT_OF_MEMORY;
1004                 pthread_mutex_unlock(&private_client->lock);
1005                 return NULL;
1006
1007                 /* LCOV_EXCL_STOP */
1008         }
1009
1010         private_vblank->private_output = private_output;
1011
1012         private_vblank->vblank = wl_tdm_output_create_vblank((struct wl_tdm_output*)wrapper);
1013         wl_proxy_wrapper_destroy(wrapper);
1014         if (!private_vblank->vblank) {
1015                 /* LCOV_EXCL_START */
1016
1017                 TDM_ERR("couldn't create vblank resource");
1018                 free(private_vblank);
1019                 if (error)
1020                         *error = TDM_ERROR_OUT_OF_MEMORY;
1021                 pthread_mutex_unlock(&private_client->lock);
1022                 return NULL;
1023
1024                 /* LCOV_EXCL_STOP */
1025         }
1026
1027         /* initial value */
1028         private_vblank->fps = private_output->refresh;
1029         private_vblank->offset = 0;
1030         private_vblank->enable_fake = 0;
1031
1032         LIST_INITHEAD(&private_vblank->wait_list);
1033
1034         wl_tdm_vblank_add_listener(private_vblank->vblank,
1035                                                            &tdm_client_vblank_listener, private_vblank);
1036         wl_display_roundtrip_queue(private_client->display, private_client->queue);
1037
1038         wl_proxy_set_queue((struct wl_proxy *)private_vblank->vblank, NULL);
1039
1040         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1041                 wl_tdm_vblank_destroy(private_vblank->vblank);
1042                 free(private_vblank);
1043                 if (error)
1044                         *error = TDM_ERROR_PROTOCOL_ERROR;
1045                 pthread_mutex_unlock(&private_client->lock);
1046                 return NULL;
1047         }
1048
1049         LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
1050
1051         pthread_mutex_unlock(&private_client->lock);
1052
1053         return (tdm_client_vblank*)private_vblank;
1054 }
1055
1056 void
1057 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
1058 {
1059         tdm_private_client_vblank *private_vblank;
1060         tdm_private_client *private_client;
1061         tdm_client_wait_info *w = NULL, *ww = NULL;
1062
1063         TDM_RETURN_IF_FAIL(vblank != NULL);
1064
1065         private_vblank = vblank;
1066         private_client = private_vblank->private_output->private_client;
1067
1068         pthread_mutex_lock(&private_client->lock);
1069
1070         LIST_DEL(&private_vblank->link);
1071
1072         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
1073                 LIST_DEL(&w->link);
1074                 free(w);
1075         }
1076
1077         wl_tdm_vblank_destroy(private_vblank->vblank);
1078
1079         free(private_vblank);
1080
1081         pthread_mutex_unlock(&private_client->lock);
1082 }
1083
1084 tdm_error
1085 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
1086 {
1087         tdm_private_client_vblank *private_vblank;
1088         tdm_private_client *private_client;
1089
1090         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1091
1092         private_vblank = vblank;
1093         private_client = private_vblank->private_output->private_client;
1094
1095         pthread_mutex_lock(&private_client->lock);
1096
1097         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1098                 pthread_mutex_unlock(&private_client->lock);
1099                 return TDM_ERROR_PROTOCOL_ERROR;
1100         }
1101
1102         if (!name)
1103                 name = TDM_VBLANK_DEFAULT_NAME;
1104
1105         strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
1106         private_vblank->name[TDM_NAME_LEN - 1] = '\0';
1107
1108         wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
1109
1110         pthread_mutex_unlock(&private_client->lock);
1111
1112         return TDM_ERROR_NONE;
1113 }
1114
1115 tdm_error
1116 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
1117 {
1118         tdm_private_client_vblank *private_vblank;
1119         tdm_private_client *private_client;
1120
1121         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1122
1123         private_vblank = vblank;
1124         private_client = private_vblank->private_output->private_client;
1125
1126         pthread_mutex_lock(&private_client->lock);
1127         private_vblank->sync = sync;
1128         pthread_mutex_unlock(&private_client->lock);
1129
1130         return TDM_ERROR_NONE;
1131 }
1132
1133 tdm_error
1134 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
1135 {
1136         tdm_private_client_vblank *private_vblank;
1137         tdm_private_client *private_client;
1138
1139         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1140         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
1141
1142         private_vblank = vblank;
1143         private_client = private_vblank->private_output->private_client;
1144
1145         pthread_mutex_lock(&private_client->lock);
1146
1147         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1148                 pthread_mutex_unlock(&private_client->lock);
1149                 return TDM_ERROR_PROTOCOL_ERROR;
1150         }
1151
1152         if (private_vblank->fps == fps) {
1153                 pthread_mutex_unlock(&private_client->lock);
1154                 return TDM_ERROR_NONE;
1155         }
1156
1157         private_vblank->fps = fps;
1158
1159         wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
1160
1161         pthread_mutex_unlock(&private_client->lock);
1162
1163         return TDM_ERROR_NONE;
1164 }
1165
1166 tdm_error
1167 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
1168 {
1169         tdm_private_client_vblank *private_vblank;
1170         tdm_private_client *private_client;
1171
1172         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1173
1174         private_vblank = vblank;
1175         TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
1176
1177         private_client = private_vblank->private_output->private_client;
1178
1179         pthread_mutex_lock(&private_client->lock);
1180
1181         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1182                 pthread_mutex_unlock(&private_client->lock);
1183                 return TDM_ERROR_PROTOCOL_ERROR;
1184         }
1185
1186         if (private_vblank->offset == offset_ms) {
1187                 pthread_mutex_unlock(&private_client->lock);
1188                 return TDM_ERROR_NONE;
1189         }
1190
1191         private_vblank->offset = offset_ms;
1192
1193         wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
1194
1195         pthread_mutex_unlock(&private_client->lock);
1196
1197         return TDM_ERROR_NONE;
1198 }
1199
1200 tdm_error
1201 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
1202 {
1203         tdm_private_client_vblank *private_vblank;
1204         tdm_private_client *private_client;
1205
1206         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1207
1208         private_vblank = vblank;
1209         private_client = private_vblank->private_output->private_client;
1210
1211         pthread_mutex_lock(&private_client->lock);
1212
1213         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1214                 pthread_mutex_unlock(&private_client->lock);
1215                 return TDM_ERROR_PROTOCOL_ERROR;
1216         }
1217
1218         if (private_vblank->enable_fake == enable_fake) {
1219                 pthread_mutex_unlock(&private_client->lock);
1220                 return TDM_ERROR_NONE;
1221         }
1222
1223         private_vblank->enable_fake = enable_fake;
1224
1225         wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
1226
1227         pthread_mutex_unlock(&private_client->lock);
1228
1229         return TDM_ERROR_NONE;
1230 }
1231
1232 tdm_error
1233 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
1234 {
1235         tdm_private_client *private_client;
1236         tdm_private_client_output *private_output;
1237         tdm_private_client_vblank *private_vblank;
1238         tdm_client_wait_info *w;
1239         struct timespec tp;
1240         unsigned int req_sec, req_usec;
1241         int ret = 0;
1242
1243         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1244         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1245         /* can't support "interval 0" and "getting current_msc" things because
1246          * there is a socket communication between TDM client and server. It's impossible
1247          * to return the current msc or sequence immediately.
1248          */
1249         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1250
1251         private_vblank = vblank;
1252         private_output = private_vblank->private_output;
1253         private_client = private_output->private_client;
1254
1255         pthread_mutex_lock(&private_client->lock);
1256
1257         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1258                 pthread_mutex_unlock(&private_client->lock);
1259                 return TDM_ERROR_PROTOCOL_ERROR;
1260         }
1261
1262         if (!private_vblank->started)
1263                 private_vblank->started = 1;
1264
1265         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1266                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1267                         TDM_ERR("output disconnected");
1268                         pthread_mutex_unlock(&private_client->lock);
1269                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1270                 }
1271                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1272                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1273                         pthread_mutex_unlock(&private_client->lock);
1274                         return TDM_ERROR_DPMS_OFF;
1275                 }
1276         }
1277
1278         w = calloc(1, sizeof *w);
1279         if (!w) {
1280                 /* LCOV_EXCL_START */
1281
1282                 TDM_ERR("alloc failed");
1283                 pthread_mutex_unlock(&private_client->lock);
1284                 return TDM_ERROR_OUT_OF_MEMORY;
1285
1286                 /* LCOV_EXCL_STOP */
1287         }
1288
1289         w->private_vblank = private_vblank;
1290         w->func = func;
1291         w->user_data = user_data;
1292
1293         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1294         LIST_INITHEAD(&w->call_link);
1295
1296         clock_gettime(CLOCK_MONOTONIC, &tp);
1297         req_sec = (unsigned int)tp.tv_sec;
1298         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1299
1300         w->req_id = ++private_output->req_id;
1301         w->req_time = TDM_TIME(req_sec, req_usec);
1302         w->need_free = (private_vblank->sync) ? 0 : 1;
1303
1304         wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
1305
1306         if (private_vblank->enable_ttrace)
1307                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1308
1309         TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
1310                         vblank, interval, w->req_id, w->req_time);
1311
1312         private_vblank->req_time = w->req_time;
1313
1314         if (private_vblank->last_time >= w->req_time)
1315                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1316
1317         if (!private_vblank->sync) {
1318                 wl_display_flush(private_client->display);
1319                 pthread_mutex_unlock(&private_client->lock);
1320                 return TDM_ERROR_NONE;
1321         }
1322
1323         /* LCOV_EXCL_START */
1324
1325         while (ret != -1 && !w->need_free)
1326                 ret = wl_display_dispatch(private_client->display);
1327
1328         clock_gettime(CLOCK_MONOTONIC, &tp);
1329         TDM_DBG("block during %d us",
1330                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1331                         - (req_sec * 1000000 + req_usec));
1332
1333         LIST_DEL(&w->link);
1334         free(w);
1335
1336         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1337                 pthread_mutex_unlock(&private_client->lock);
1338                 return TDM_ERROR_PROTOCOL_ERROR;
1339         }
1340
1341         pthread_mutex_unlock(&private_client->lock);
1342
1343         return TDM_ERROR_NONE;
1344
1345         /* LCOV_EXCL_STOP */
1346 }
1347
1348 tdm_error
1349 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
1350                                                    tdm_client_vblank_handler func, void *user_data)
1351 {
1352         tdm_private_client *private_client;
1353         tdm_private_client_output *private_output;
1354         tdm_private_client_vblank *private_vblank;
1355         tdm_client_wait_info *w;
1356         struct timespec tp;
1357         unsigned int req_sec, req_usec;
1358         int ret = 0;
1359
1360         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
1361         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
1362
1363         private_vblank = vblank;
1364         private_output = private_vblank->private_output;
1365         private_client = private_output->private_client;
1366
1367         pthread_mutex_lock(&private_client->lock);
1368
1369         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1370                 pthread_mutex_unlock(&private_client->lock);
1371                 return TDM_ERROR_PROTOCOL_ERROR;
1372         }
1373
1374         if (!private_vblank->started)
1375                 private_vblank->started = 1;
1376
1377         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1378                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1379                         TDM_ERR("output disconnected");
1380                         pthread_mutex_unlock(&private_client->lock);
1381                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1382                 }
1383                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1384                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1385                         pthread_mutex_unlock(&private_client->lock);
1386                         return TDM_ERROR_DPMS_OFF;
1387                 }
1388         }
1389
1390         w = calloc(1, sizeof *w);
1391         if (!w) {
1392                 /* LCOV_EXCL_START */
1393
1394                 TDM_ERR("alloc failed");
1395                 pthread_mutex_unlock(&private_client->lock);
1396                 return TDM_ERROR_OUT_OF_MEMORY;
1397
1398                 /* LCOV_EXCL_STOP */
1399         }
1400
1401         w->private_vblank = private_vblank;
1402         w->func = func;
1403         w->user_data = user_data;
1404
1405         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1406         LIST_INITHEAD(&w->call_link);
1407
1408         clock_gettime(CLOCK_MONOTONIC, &tp);
1409         req_sec = (unsigned int)tp.tv_sec;
1410         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1411
1412         w->req_id = ++private_output->req_id;
1413         w->req_time = TDM_TIME(req_sec, req_usec);
1414         w->need_free = (private_vblank->sync) ? 0 : 1;
1415
1416         wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1417
1418         if (private_vblank->enable_ttrace)
1419                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1420
1421         TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1422                         vblank, sequence, w->req_id, w->req_time);
1423
1424         private_vblank->req_time = w->req_time;
1425
1426         if (private_vblank->last_time >= w->req_time)
1427                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1428
1429         if (!private_vblank->sync) {
1430                 wl_display_flush(private_client->display);
1431                 pthread_mutex_unlock(&private_client->lock);
1432                 return TDM_ERROR_NONE;
1433         }
1434
1435         /* LCOV_EXCL_START */
1436
1437         while (ret != -1 && !w->need_free)
1438                 ret = wl_display_dispatch(private_client->display);
1439
1440         clock_gettime(CLOCK_MONOTONIC, &tp);
1441         TDM_DBG("block during %d us",
1442                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1443                         - (req_sec * 1000000 + req_usec));
1444
1445         LIST_DEL(&w->link);
1446         free(w);
1447
1448         if (CHECK_WL_PROTOCOL_ERROR(private_client)) {
1449                 pthread_mutex_unlock(&private_client->lock);
1450                 return TDM_ERROR_PROTOCOL_ERROR;
1451         }
1452
1453         pthread_mutex_unlock(&private_client->lock);
1454
1455         return TDM_ERROR_NONE;
1456
1457         /* LCOV_EXCL_STOP */
1458 }