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         struct wl_display *display;
  59         struct wl_registry *registry;
  60         struct wl_tdm *tdm;
  61         struct list_head output_list;
  62
  63         tdm_private_client_vblank *temp_vblank;
  64 } tdm_private_client;
  65
  66 typedef struct _tdm_private_client_output {
  67         tdm_private_client *private_client;
  68
  69         char name[TDM_NAME_LEN];
  70         struct wl_tdm_output *output;
  71         int width;
  72         int height;
  73         int refresh;
  74         tdm_output_conn_status connection;
  75         tdm_output_dpms dpms;
  76         struct list_head vblank_list;
  77         struct list_head change_handler_list;
  78
  79         unsigned int req_id;
  80         unsigned int watch_output_changes;
  81
  82         struct list_head link;
  83 } tdm_private_client_output;
  84
  85 struct _tdm_private_client_vblank {
  86         tdm_private_client_output *private_output;
  87
  88         struct wl_tdm_vblank *vblank;
  89         struct list_head wait_list;
  90
  91         char name[TDM_NAME_LEN];
  92         unsigned int sync;
  93         unsigned int fps;
  94         int offset;
  95         unsigned int enable_fake;
  96         unsigned int enable_ttrace;
  97
  98         unsigned int started;
  99         unsigned int stamp;
 100
 101         double req_time;
 102         double last_time;
 103
 104         struct list_head link;
 105 };
 106
 107 typedef struct _tdm_client_output_handler_info {
 108         tdm_private_client_output *private_output;
 109
 110         tdm_client_output_change_handler func;
 111         void *user_data;
 112
 113         struct list_head link;
 114 } tdm_client_output_handler_info;
 115
 116 typedef struct _tdm_client_wait_info {
 117         tdm_private_client_vblank *private_vblank;
 118
 119         tdm_client_vblank_handler func;
 120         void *user_data;
 121
 122         unsigned int req_id;
 123         double req_time;
 124         int need_free;
 125
 126         struct list_head link;
 127 } tdm_client_wait_info;
 128
 129 static void
 130 _tdm_client_vblank_cb_stamp(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t stamp)
 131 {
 132         tdm_private_client_vblank *private_vblank = data;
 133
 134         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 135
 136         private_vblank->stamp = stamp;
 137 }
 138
 139 /* LCOV_EXCL_START */
 140 static void
 141 _tdm_client_vblank_cb_done(void *data, struct wl_tdm_vblank *wl_tdm_vblank,
 142                                                    uint32_t req_id, uint32_t sequence, uint32_t tv_sec,
 143                                                    uint32_t tv_usec, uint32_t error)
 144 {
 145         tdm_private_client_vblank *private_vblank = data;
 146         tdm_client_wait_info *w = NULL, *ww = NULL;
 147
 148         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 149
 150         private_vblank->last_time = TDM_TIME(tv_sec, tv_usec);
 151
 152         TDM_DBG("vblank(%p) req_id(%u) sequence(%u) time(%.6f)",
 153                         private_vblank, req_id, sequence, TDM_TIME(tv_sec, tv_usec));
 154
 155         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 156                 if (w->req_id != req_id)
 157                         continue;
 158
 159                 if (private_vblank->enable_ttrace)
 160                         TDM_TRACE_ASYNC_END((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 161
 162                 if (w->req_time >= private_vblank->last_time)
 163                         TDM_WRN("'req(%.6f) < last(%.6f)' failed", w->req_time, private_vblank->last_time);
 164
 165                 if (w->func)
 166                         w->func(private_vblank, error, sequence, tv_sec, tv_usec, w->user_data);
 167
 168                 if (w->need_free) {
 169                         LIST_DEL(&w->link);
 170                         free(w);
 171                 } else
 172                         w->need_free = 1;
 173                 return;
 174         }
 175 }
 176 /* LCOV_EXCL_STOP */
 177
 178 /* LCOV_EXCL_START */
 179 static void
 180 _tdm_client_vblank_cb_ttrace(void *data, struct wl_tdm_vblank *wl_tdm_vblank, uint32_t enable)
 181 {
 182         tdm_private_client_vblank *private_vblank = data;
 183
 184         TDM_RETURN_IF_FAIL(private_vblank != NULL);
 185
 186         private_vblank->enable_ttrace = enable;
 187 }
 188 /* LCOV_EXCL_STOP */
 189
 190 static const struct wl_tdm_vblank_listener tdm_client_vblank_listener = {
 191         _tdm_client_vblank_cb_stamp,
 192         _tdm_client_vblank_cb_done,
 193         _tdm_client_vblank_cb_ttrace,
 194 };
 195
 196 static void
 197 _tdm_client_output_destroy(tdm_private_client_output *private_output)
 198 {
 199         tdm_private_client_vblank *v = NULL, *vv = NULL;
 200         tdm_client_output_handler_info *h = NULL, *hh = NULL;
 201
 202         LIST_DEL(&private_output->link);
 203
 204         LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_list, link) {
 205                 TDM_ERR("vblanks SHOULD be destroyed first!");
 206                 LIST_DEL(&v->link);
 207                 v->private_output = NULL;
 208         }
 209
 210         LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) {
 211                 LIST_DEL(&h->link);
 212                 free(h);
 213         }
 214
 215         wl_tdm_output_destroy(private_output->output);
 216
 217         free(private_output);
 218 }
 219
 220 static void
 221 _tdm_client_output_cb_mode(void *data, struct wl_tdm_output *wl_tdm_output,
 222                                                    uint32_t width, uint32_t height, uint32_t refresh, uint32_t error)
 223 {
 224         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 225
 226         TDM_RETURN_IF_FAIL(private_output != NULL);
 227
 228         private_output->width = width;
 229         private_output->height = height;
 230         private_output->refresh = refresh;
 231
 232         if (error != TDM_ERROR_NONE)
 233                 TDM_INFO("mode event error: %d", error);
 234
 235         TDM_DBG("private_output(%p) wl_tbm_output@%d width(%d) height(%d) refresh(%d)",
 236                         private_output, wl_proxy_get_id((struct wl_proxy*)private_output->output),
 237                         width, height, refresh);
 238 }
 239
 240 static void
 241 _tdm_client_output_cb_connection(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 242 {
 243         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 244         tdm_client_output_handler_info *h = NULL;
 245         tdm_value v;
 246
 247         TDM_RETURN_IF_FAIL(private_output != NULL);
 248
 249         if (private_output->connection == value)
 250                 return;
 251
 252         private_output->connection = value;
 253
 254         if (error != TDM_ERROR_NONE)
 255                 TDM_INFO("connection event error: %d", error);
 256
 257         TDM_DBG("private_output(%p) wl_tbm_output@%d connection(%d)",
 258                         private_output,
 259                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 260                         value);
 261
 262         v.u32 = value;
 263         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 264                 if (h->func)
 265                         h->func(private_output, TDM_OUTPUT_CHANGE_CONNECTION, v, h->user_data);
 266         }
 267 }
 268
 269 static void
 270 _tdm_client_output_cb_dpms(void *data, struct wl_tdm_output *wl_tdm_output, uint32_t value, uint32_t error)
 271 {
 272         tdm_private_client_output *private_output = (tdm_private_client_output*)data;
 273         tdm_client_output_handler_info *h = NULL;
 274         tdm_value v;
 275
 276         TDM_RETURN_IF_FAIL(private_output != NULL);
 277
 278         /* If value is extended value, we handle it as DPMS on in client side
 279          * The extended DPMS value is valid only in server side.
 280          * Or, need to export to client side also?
 281          */
 282         if (value > TDM_OUTPUT_DPMS_OFF)
 283                 value = TDM_OUTPUT_DPMS_ON;
 284
 285         if (private_output->dpms == value)
 286                 return;
 287
 288         private_output->dpms = value;
 289
 290         if (error != TDM_ERROR_NONE)
 291                 TDM_INFO("dpms event error: %d", error);
 292
 293         TDM_DBG("private_output(%p) wl_tbm_output@%d dpms(%d)",
 294                         private_output,
 295                         wl_proxy_get_id((struct wl_proxy*)private_output->output),
 296                         value);
 297
 298         v.u32 = value;
 299         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 300                 if (h->func)
 301                         h->func(private_output, TDM_OUTPUT_CHANGE_DPMS, v, h->user_data);
 302         }
 303 }
 304
 305 static const struct wl_tdm_output_listener tdm_client_output_listener = {
 306         _tdm_client_output_cb_mode,
 307         _tdm_client_output_cb_connection,
 308         _tdm_client_output_cb_dpms,
 309 };
 310
 311 static void
 312 _tdm_client_cb_global(void *data, struct wl_registry *registry,
 313                                           uint32_t name, const char *interface,
 314                                           uint32_t version)
 315 {
 316         tdm_private_client *private_client = data;
 317
 318         if (strncmp(interface, "wl_tdm", 6) == 0) {
 319                 private_client->tdm =
 320                         wl_registry_bind(registry, name, &wl_tdm_interface, version);
 321                 TDM_RETURN_IF_FAIL(private_client->tdm != NULL);
 322
 323                 wl_display_flush(private_client->display);
 324         }
 325 }
 326
 327 /* LCOV_EXCL_START */
 328 static void
 329 _tdm_client_cb_global_remove(void *data, struct wl_registry *registry, uint32_t name)
 330 {
 331 }
 332 /* LCOV_EXCL_STOP */
 333
 334 static const struct wl_registry_listener tdm_client_registry_listener = {
 335         _tdm_client_cb_global,
 336         _tdm_client_cb_global_remove
 337 };
 338
 339 tdm_client*
 340 tdm_client_create(tdm_error *error)
 341 {
 342         tdm_private_client *private_client;
 343
 344         private_client = calloc(1, sizeof *private_client);
 345         if (!private_client) {
 346                 /* LCOV_EXCL_START */
 347
 348                 TDM_ERR("alloc failed");
 349                 if (error)
 350                         *error = TDM_ERROR_OUT_OF_MEMORY;
 351                 return NULL;
 352
 353                 /* LCOV_EXCL_STOP */
 354         }
 355
 356         LIST_INITHEAD(&private_client->output_list);
 357
 358         private_client->display = wl_display_connect("tdm-socket");
 359         TDM_GOTO_IF_FAIL(private_client->display != NULL, create_failed);
 360
 361         private_client->registry = wl_display_get_registry(private_client->display);
 362         TDM_GOTO_IF_FAIL(private_client->registry != NULL, create_failed);
 363
 364         wl_registry_add_listener(private_client->registry,
 365                                                          &tdm_client_registry_listener, private_client);
 366         wl_display_roundtrip(private_client->display);
 367
 368         /* check global objects */
 369         TDM_GOTO_IF_FAIL(private_client->tdm != NULL, create_failed);
 370
 371         if (error)
 372                 *error = TDM_ERROR_NONE;
 373
 374         return (tdm_client*)private_client;
 375 create_failed:
 376         tdm_client_destroy((tdm_client*)private_client);
 377         if (error)
 378                 *error = TDM_ERROR_OPERATION_FAILED;
 379         return NULL;
 380 }
 381
 382 void
 383 tdm_client_destroy(tdm_client *client)
 384 {
 385         tdm_private_client *private_client = (tdm_private_client*)client;
 386         tdm_private_client_output *o = NULL, *oo = NULL;
 387
 388         if (!private_client)
 389                 return;
 390
 391         if (private_client->temp_vblank)
 392                 tdm_client_vblank_destroy(private_client->temp_vblank);
 393
 394         LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_client->output_list, link) {
 395                 _tdm_client_output_destroy(o);
 396         }
 397
 398         if (private_client->tdm)
 399                 wl_tdm_destroy(private_client->tdm);
 400         if (private_client->registry)
 401                 wl_registry_destroy(private_client->registry);
 402         if (private_client->display)
 403                 wl_display_disconnect(private_client->display);
 404
 405         free(private_client);
 406 }
 407
 408 tdm_error
 409 tdm_client_get_fd(tdm_client *client, int *fd)
 410 {
 411         tdm_private_client *private_client;
 412
 413         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 414         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 415
 416         private_client = (tdm_private_client*)client;
 417
 418         *fd = wl_display_get_fd(private_client->display);
 419         if (*fd < 0)
 420                 return TDM_ERROR_OPERATION_FAILED;
 421
 422         return TDM_ERROR_NONE;
 423 }
 424
 425 tdm_error
 426 tdm_client_handle_events(tdm_client *client)
 427 {
 428         tdm_private_client *private_client;
 429
 430         TDM_RETURN_VAL_IF_FAIL(client != NULL, TDM_ERROR_INVALID_PARAMETER);
 431
 432         /* LCOV_EXCL_START */
 433         private_client = (tdm_private_client*)client;
 434
 435         wl_display_dispatch(private_client->display);
 436
 437         return TDM_ERROR_NONE;
 438         /* LCOV_EXCL_STOP */
 439 }
 440
 441 typedef struct _tdm_client_vblank_temp {
 442         tdm_client_vblank_handler2 func;
 443         void *user_data;
 444 } tdm_client_vblank_temp;
 445
 446 /* LCOV_EXCL_START */
 447 static void
 448 _tdm_client_vblank_handler_temp(tdm_client_vblank *vblank, tdm_error error, unsigned int sequence,
 449                                                                 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 450 {
 451         tdm_client_vblank_temp *vblank_temp = user_data;
 452
 453         TDM_RETURN_IF_FAIL(vblank_temp != NULL);
 454
 455         if (vblank_temp->func)
 456                 vblank_temp->func(sequence, tv_sec, tv_usec, vblank_temp->user_data);
 457
 458         free(vblank_temp);
 459 }
 460 /* LCOV_EXCL_STOP */
 461
 462 /* LCOV_EXCL_START */ /* deprecated */
 463 tdm_error
 464 tdm_client_wait_vblank(tdm_client *client, char *name,
 465                                            int sw_timer, int interval, int sync,
 466                                            tdm_client_vblank_handler2 func, void *user_data)
 467 {
 468         tdm_private_client *private_client = (tdm_private_client*)client;
 469         tdm_client_output *output;
 470         tdm_client_vblank_temp *vblank_temp;
 471         tdm_error ret;
 472
 473         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 474         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 475         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 476
 477         if (!private_client->temp_vblank) {
 478                 output = tdm_client_get_output(client, name, &ret);
 479                 TDM_RETURN_VAL_IF_FAIL(output != NULL, ret);
 480
 481                 private_client->temp_vblank = tdm_client_output_create_vblank(output, &ret);
 482                 TDM_RETURN_VAL_IF_FAIL(private_client->temp_vblank != NULL, ret);
 483         }
 484
 485         tdm_client_vblank_set_enable_fake(private_client->temp_vblank, sw_timer);
 486         tdm_client_vblank_set_sync(private_client->temp_vblank, sync);
 487
 488         vblank_temp = calloc(1, sizeof *vblank_temp);
 489         TDM_RETURN_VAL_IF_FAIL(vblank_temp != NULL, TDM_ERROR_OUT_OF_MEMORY);
 490
 491         vblank_temp->func = func;
 492         vblank_temp->user_data = user_data;
 493
 494         return tdm_client_vblank_wait(private_client->temp_vblank, interval, _tdm_client_vblank_handler_temp, vblank_temp);
 495 }
 496 /* LCOV_EXCL_STOP */
 497
 498 tdm_client_output*
 499 tdm_client_get_output(tdm_client *client, char *name, tdm_error *error)
 500 {
 501         tdm_private_client *private_client;
 502         tdm_private_client_output *private_output = NULL;
 503
 504         if (error)
 505                 *error = TDM_ERROR_NONE;
 506
 507         if (!client) {
 508                 TDM_ERR("'!client' failed");
 509                 if (error)
 510                         *error = TDM_ERROR_INVALID_PARAMETER;
 511                 return NULL;
 512         }
 513
 514         private_client = (tdm_private_client*)client;
 515
 516         if (!name)
 517                 name = "primary";
 518
 519         LIST_FOR_EACH_ENTRY(private_output, &private_client->output_list, link) {
 520                 if (!strncmp(private_output->name, name, TDM_NAME_LEN))
 521                         return (tdm_client_output*)private_output;
 522         }
 523
 524         private_output = calloc(1, sizeof *private_output);
 525         if (!private_output) {
 526                 /* LCOV_EXCL_START */
 527
 528                 TDM_ERR("alloc failed");
 529                 if (error)
 530                         *error = TDM_ERROR_OUT_OF_MEMORY;
 531                 return NULL;
 532
 533                 /* LCOV_EXCL_STOP */
 534         }
 535
 536         private_output->private_client = private_client;
 537
 538         snprintf(private_output->name, TDM_NAME_LEN, "%s", name);
 539         private_output->output = wl_tdm_create_output(private_client->tdm, private_output->name);
 540         if (!private_output->output) {
 541                 /* LCOV_EXCL_START */
 542
 543                 TDM_ERR("couldn't create output resource");
 544                 free(private_output);
 545                 if (error)
 546                         *error = TDM_ERROR_OUT_OF_MEMORY;
 547                 return NULL;
 548
 549                 /* LCOV_EXCL_STOP */
 550         }
 551
 552         LIST_INITHEAD(&private_output->vblank_list);
 553         LIST_INITHEAD(&private_output->change_handler_list);
 554         LIST_ADDTAIL(&private_output->link, &private_client->output_list);
 555
 556         wl_tdm_output_add_listener(private_output->output,
 557                                                            &tdm_client_output_listener, private_output);
 558         wl_display_roundtrip(private_client->display);
 559
 560         return (tdm_client_output*)private_output;
 561 }
 562
 563 tdm_error
 564 tdm_client_output_add_change_handler(tdm_client_output *output,
 565                                                                          tdm_client_output_change_handler func,
 566                                                                          void *user_data)
 567 {
 568         tdm_private_client_output *private_output;
 569         tdm_client_output_handler_info *h;
 570
 571         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 572         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 573
 574         private_output = (tdm_private_client_output*)output;
 575
 576         h = calloc(1, sizeof *h);
 577         TDM_RETURN_VAL_IF_FAIL(h != NULL, TDM_ERROR_OUT_OF_MEMORY);
 578
 579         if (LIST_IS_EMPTY(&private_output->change_handler_list)) {
 580                 wl_tdm_output_watch_output_changes(private_output->output, 1);
 581
 582                 /* TODO: this is very tricky.
 583                  * If a client adds the change_handler, we might be able to guess that
 584                  * the client will watch the tdm client's fd and handle tdm events in
 585                  * event loop. Otherwise, we CAN'T make sure if a client has event loop
 586                  * which handles tdm events.
 587                  */
 588                 private_output->watch_output_changes = 1;
 589         }
 590
 591         h->private_output = private_output;
 592         h->func = func;
 593         h->user_data = user_data;
 594         LIST_ADDTAIL(&h->link, &private_output->change_handler_list);
 595
 596         return TDM_ERROR_NOT_IMPLEMENTED;
 597 }
 598
 599 void
 600 tdm_client_output_remove_change_handler(tdm_client_output *output,
 601                                                                                 tdm_client_output_change_handler func,
 602                                                                                 void *user_data)
 603 {
 604         tdm_private_client_output *private_output;
 605         tdm_client_output_handler_info *h = NULL;
 606
 607         TDM_RETURN_IF_FAIL(output != NULL);
 608         TDM_RETURN_IF_FAIL(func != NULL);
 609
 610         private_output = (tdm_private_client_output*)output;
 611
 612         LIST_FOR_EACH_ENTRY(h, &private_output->change_handler_list, link) {
 613                 if (h->func != func || h->user_data != user_data)
 614                         continue;
 615
 616                 LIST_DEL(&h->link);
 617                 free(h);
 618
 619                 if (LIST_IS_EMPTY(&private_output->change_handler_list))
 620                         wl_tdm_output_watch_output_changes(private_output->output, 0);
 621
 622                 return;
 623         }
 624 }
 625
 626 tdm_error
 627 tdm_client_output_get_refresh_rate(tdm_client_output *output, unsigned int *refresh)
 628 {
 629         tdm_private_client_output *private_output;
 630         tdm_private_client *private_client;
 631
 632         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 633         TDM_RETURN_VAL_IF_FAIL(refresh != NULL, TDM_ERROR_INVALID_PARAMETER);
 634
 635         private_output = (tdm_private_client_output*)output;
 636
 637         if (private_output->watch_output_changes) {
 638                 *refresh = private_output->refresh;
 639                 return TDM_ERROR_NONE;
 640         }
 641
 642         private_client = private_output->private_client;
 643         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 644
 645         wl_tdm_output_get_mode(private_output->output);
 646         wl_display_roundtrip(private_client->display);
 647
 648         *refresh = private_output->refresh;
 649
 650         return TDM_ERROR_NONE;
 651 }
 652
 653 tdm_error
 654 tdm_client_output_get_conn_status(tdm_client_output *output, tdm_output_conn_status *status)
 655 {
 656         tdm_private_client_output *private_output;
 657         tdm_private_client *private_client;
 658
 659         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 660         TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
 661
 662         private_output = (tdm_private_client_output*)output;
 663
 664         if (private_output->watch_output_changes) {
 665                 *status = private_output->connection;
 666                 return TDM_ERROR_NONE;
 667         }
 668
 669         private_client = private_output->private_client;
 670         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 671
 672         wl_tdm_output_get_connection(private_output->output);
 673         wl_display_roundtrip(private_client->display);
 674
 675         *status = private_output->connection;
 676
 677         return TDM_ERROR_NONE;
 678 }
 679
 680 tdm_error
 681 tdm_client_output_get_dpms(tdm_client_output *output, tdm_output_dpms *dpms)
 682 {
 683         tdm_private_client_output *private_output;
 684         tdm_private_client *private_client;
 685
 686         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 687         TDM_RETURN_VAL_IF_FAIL(dpms != NULL, TDM_ERROR_INVALID_PARAMETER);
 688
 689         private_output = (tdm_private_client_output*)output;
 690
 691         if (private_output->watch_output_changes) {
 692                 *dpms = private_output->dpms;
 693                 return TDM_ERROR_NONE;
 694         }
 695
 696         private_client = private_output->private_client;
 697         TDM_RETURN_VAL_IF_FAIL(private_client != NULL, TDM_ERROR_INVALID_PARAMETER);
 698
 699         wl_tdm_output_get_dpms(private_output->output);
 700         wl_display_roundtrip(private_client->display);
 701
 702         *dpms = private_output->dpms;
 703
 704         return TDM_ERROR_NONE;
 705 }
 706
 707 tdm_client_vblank*
 708 tdm_client_output_create_vblank(tdm_client_output *output, tdm_error *error)
 709 {
 710         tdm_private_client *private_client;
 711         tdm_private_client_output *private_output;
 712         tdm_private_client_vblank *private_vblank;
 713
 714         if (error)
 715                 *error = TDM_ERROR_NONE;
 716
 717         if (!output) {
 718                 TDM_ERR("'!output' failed");
 719                 if (error)
 720                         *error = TDM_ERROR_INVALID_PARAMETER;
 721                 return NULL;
 722         }
 723
 724         private_output = (tdm_private_client_output*)output;
 725         private_client = private_output->private_client;
 726
 727         if (!private_client) {
 728                 TDM_ERR("'!private_client' failed");
 729                 if (error)
 730                         *error = TDM_ERROR_INVALID_PARAMETER;
 731                 return NULL;
 732         }
 733
 734         private_vblank = calloc(1, sizeof *private_vblank);
 735         if (!private_vblank) {
 736                 /* LCOV_EXCL_START */
 737
 738                 TDM_ERR("alloc failed");
 739                 if (error)
 740                         *error = TDM_ERROR_OUT_OF_MEMORY;
 741                 return NULL;
 742
 743                 /* LCOV_EXCL_STOP */
 744         }
 745
 746         private_vblank->private_output = private_output;
 747
 748         private_vblank->vblank = wl_tdm_output_create_vblank(private_output->output);
 749         if (!private_vblank->vblank) {
 750                 /* LCOV_EXCL_START */
 751
 752                 TDM_ERR("couldn't create vblank resource");
 753                 free(private_vblank);
 754                 if (error)
 755                         *error = TDM_ERROR_OUT_OF_MEMORY;
 756                 return NULL;
 757
 758                 /* LCOV_EXCL_STOP */
 759         }
 760
 761         /* initial value */
 762         private_vblank->fps = private_output->refresh;
 763         private_vblank->offset = 0;
 764         private_vblank->enable_fake = 0;
 765
 766         LIST_INITHEAD(&private_vblank->wait_list);
 767         LIST_ADDTAIL(&private_vblank->link, &private_output->vblank_list);
 768
 769         wl_tdm_vblank_add_listener(private_vblank->vblank,
 770                                                            &tdm_client_vblank_listener, private_vblank);
 771         wl_display_roundtrip(private_client->display);
 772
 773         return (tdm_client_vblank*)private_vblank;
 774 }
 775
 776 void
 777 tdm_client_vblank_destroy(tdm_client_vblank *vblank)
 778 {
 779         tdm_private_client_vblank *private_vblank;
 780         tdm_client_wait_info *w = NULL, *ww = NULL;
 781
 782         TDM_RETURN_IF_FAIL(vblank != NULL);
 783
 784         private_vblank = vblank;
 785         LIST_DEL(&private_vblank->link);
 786
 787         LIST_FOR_EACH_ENTRY_SAFE(w, ww, &private_vblank->wait_list, link) {
 788                 LIST_DEL(&w->link);
 789                 free(w);
 790         }
 791
 792         wl_tdm_vblank_destroy(private_vblank->vblank);
 793
 794         free(private_vblank);
 795 }
 796
 797 tdm_error
 798 tdm_client_vblank_set_name(tdm_client_vblank *vblank, const char *name)
 799 {
 800         tdm_private_client_vblank *private_vblank;
 801
 802         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 803
 804         private_vblank = vblank;
 805
 806         if (!name)
 807                 name = TDM_VBLANK_DEFAULT_NAME;
 808
 809         strncpy(private_vblank->name, name, TDM_NAME_LEN - 1);
 810         private_vblank->name[TDM_NAME_LEN - 1] = '\0';
 811
 812         wl_tdm_vblank_set_name(private_vblank->vblank, private_vblank->name);
 813
 814         return TDM_ERROR_NONE;
 815 }
 816
 817 tdm_error
 818 tdm_client_vblank_set_sync(tdm_client_vblank *vblank, unsigned int sync)
 819 {
 820         tdm_private_client_vblank *private_vblank;
 821
 822         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 823
 824         private_vblank = vblank;
 825         private_vblank->sync = sync;
 826
 827         return TDM_ERROR_NONE;
 828 }
 829
 830 tdm_error
 831 tdm_client_vblank_set_fps(tdm_client_vblank *vblank, unsigned int fps)
 832 {
 833         tdm_private_client_vblank *private_vblank;
 834
 835         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 836         TDM_RETURN_VAL_IF_FAIL(fps > 0, TDM_ERROR_INVALID_PARAMETER);
 837
 838         private_vblank = vblank;
 839
 840         if (private_vblank->fps == fps)
 841                 return TDM_ERROR_NONE;
 842         private_vblank->fps = fps;
 843
 844         wl_tdm_vblank_set_fps(private_vblank->vblank, fps);
 845
 846         return TDM_ERROR_NONE;
 847 }
 848
 849 tdm_error
 850 tdm_client_vblank_set_offset(tdm_client_vblank *vblank, int offset_ms)
 851 {
 852         tdm_private_client_vblank *private_vblank;
 853
 854         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 855
 856         private_vblank = vblank;
 857         TDM_RETURN_VAL_IF_FAIL(private_vblank->started == 0, TDM_ERROR_BAD_REQUEST);
 858
 859         if (private_vblank->offset == offset_ms)
 860                 return TDM_ERROR_NONE;
 861         private_vblank->offset = offset_ms;
 862
 863         wl_tdm_vblank_set_offset(private_vblank->vblank, offset_ms);
 864
 865         return TDM_ERROR_NONE;
 866 }
 867
 868 tdm_error
 869 tdm_client_vblank_set_enable_fake(tdm_client_vblank *vblank, unsigned int enable_fake)
 870 {
 871         tdm_private_client_vblank *private_vblank;
 872
 873         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 874
 875         private_vblank = vblank;
 876
 877         if (private_vblank->enable_fake == enable_fake)
 878                 return TDM_ERROR_NONE;
 879         private_vblank->enable_fake = enable_fake;
 880
 881         wl_tdm_vblank_set_enable_fake(private_vblank->vblank, enable_fake);
 882
 883         return TDM_ERROR_NONE;
 884 }
 885
 886 tdm_error
 887 tdm_client_vblank_wait(tdm_client_vblank *vblank, unsigned int interval, tdm_client_vblank_handler func, void *user_data)
 888 {
 889         tdm_private_client *private_client;
 890         tdm_private_client_output *private_output;
 891         tdm_private_client_vblank *private_vblank;
 892         tdm_client_wait_info *w;
 893         struct timespec tp;
 894         unsigned int req_sec, req_usec;
 895         int ret = 0;
 896
 897         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 898         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 899         /* can't support "interval 0" and "getting current_msc" things because
 900          * there is a socket communication between TDM client and server. It's impossible
 901          * to return the current msc or sequence immediately.
 902          */
 903         TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
 904
 905         private_vblank = vblank;
 906         private_output = private_vblank->private_output;
 907         private_client = private_output->private_client;
 908
 909         if (!private_vblank->started)
 910                 private_vblank->started = 1;
 911
 912         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
 913                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
 914                         TDM_ERR("output disconnected");
 915                         return TDM_ERROR_OUTPUT_DISCONNECTED;
 916                 }
 917                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
 918                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
 919                         return TDM_ERROR_DPMS_OFF;
 920                 }
 921         }
 922
 923         w = calloc(1, sizeof *w);
 924         if (!w) {
 925                 /* LCOV_EXCL_START */
 926
 927                 TDM_ERR("alloc failed");
 928                 return TDM_ERROR_OUT_OF_MEMORY;
 929
 930                 /* LCOV_EXCL_STOP */
 931         }
 932
 933         w->private_vblank = private_vblank;
 934         w->func = func;
 935         w->user_data = user_data;
 936
 937         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
 938
 939         clock_gettime(CLOCK_MONOTONIC, &tp);
 940         req_sec = (unsigned int)tp.tv_sec;
 941         req_usec = (unsigned int)(tp.tv_nsec / 1000);
 942
 943         w->req_id = ++private_output->req_id;
 944         w->req_time = TDM_TIME(req_sec, req_usec);
 945         w->need_free = (private_vblank->sync) ? 0 : 1;
 946
 947         wl_tdm_vblank_wait_vblank(private_vblank->vblank, interval, w->req_id, req_sec, req_usec);
 948
 949         if (private_vblank->enable_ttrace)
 950                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
 951
 952         TDM_DBG("vblank(%p) interval(%u) req_id(%d) req(%.6f)",
 953                         vblank, interval, w->req_id, w->req_time);
 954
 955         private_vblank->req_time = w->req_time;
 956
 957         if (private_vblank->last_time >= w->req_time)
 958                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
 959
 960         if (!private_vblank->sync) {
 961                 wl_display_flush(private_client->display);
 962                 return TDM_ERROR_NONE;
 963         }
 964
 965         /* LCOV_EXCL_START */
 966
 967         while (ret != -1 && !w->need_free)
 968                 ret = wl_display_dispatch(private_client->display);
 969
 970         clock_gettime(CLOCK_MONOTONIC, &tp);
 971         TDM_DBG("block during %d us",
 972                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
 973                         - (req_sec * 1000000 + req_usec));
 974
 975         LIST_DEL(&w->link);
 976         free(w);
 977
 978         return TDM_ERROR_NONE;
 979
 980         /* LCOV_EXCL_STOP */
 981 }
 982
 983 tdm_error
 984 tdm_client_vblank_wait_seq(tdm_client_vblank *vblank, unsigned int sequence,
 985                                                    tdm_client_vblank_handler func, void *user_data)
 986 {
 987         tdm_private_client *private_client;
 988         tdm_private_client_output *private_output;
 989         tdm_private_client_vblank *private_vblank;
 990         tdm_client_wait_info *w;
 991         struct timespec tp;
 992         unsigned int req_sec, req_usec;
 993         int ret = 0;
 994
 995         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, TDM_ERROR_INVALID_PARAMETER);
 996         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 997
 998         private_vblank = vblank;
 999         private_output = private_vblank->private_output;
1000         private_client = private_output->private_client;
1001
1002         if (!private_vblank->started)
1003                 private_vblank->started = 1;
1004
1005         if (private_output->watch_output_changes && !private_vblank->enable_fake) {
1006                 if (private_output->connection == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) {
1007                         TDM_ERR("output disconnected");
1008                         return TDM_ERROR_OUTPUT_DISCONNECTED;
1009                 }
1010                 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->dpms)) {
1011                         TDM_ERR("dpms %s", tdm_dpms_str(private_output->dpms));
1012                         return TDM_ERROR_DPMS_OFF;
1013                 }
1014         }
1015
1016         w = calloc(1, sizeof *w);
1017         if (!w) {
1018                 /* LCOV_EXCL_START */
1019
1020                 TDM_ERR("alloc failed");
1021                 return TDM_ERROR_OUT_OF_MEMORY;
1022
1023                 /* LCOV_EXCL_STOP */
1024         }
1025
1026         w->private_vblank = private_vblank;
1027         w->func = func;
1028         w->user_data = user_data;
1029
1030         LIST_ADDTAIL(&w->link, &private_vblank->wait_list);
1031
1032         clock_gettime(CLOCK_MONOTONIC, &tp);
1033         req_sec = (unsigned int)tp.tv_sec;
1034         req_usec = (unsigned int)(tp.tv_nsec / 1000);
1035
1036         w->req_id = ++private_output->req_id;
1037         w->req_time = TDM_TIME(req_sec, req_usec);
1038         w->need_free = (private_vblank->sync) ? 0 : 1;
1039
1040         wl_tdm_vblank_wait_vblank_seq(private_vblank->vblank, sequence, w->req_id, req_sec, req_usec);
1041
1042         if (private_vblank->enable_ttrace)
1043                 TDM_TRACE_ASYNC_BEGIN((int)w->req_time, "TDM_Client_Vblank:%u", private_vblank->stamp);
1044
1045         TDM_DBG("vblank(%p) sequence(%u) req_id(%d) req(%.6f)",
1046                         vblank, sequence, w->req_id, w->req_time);
1047
1048         private_vblank->req_time = w->req_time;
1049
1050         if (private_vblank->last_time >= w->req_time)
1051                 TDM_ERR("'last(%.6f) < req(%.6f)' failed", private_vblank->last_time, w->req_time);
1052
1053         if (!private_vblank->sync) {
1054                 wl_display_flush(private_client->display);
1055                 return TDM_ERROR_NONE;
1056         }
1057
1058         /* LCOV_EXCL_START */
1059
1060         while (ret != -1 && !w->need_free)
1061                 ret = wl_display_dispatch(private_client->display);
1062
1063         clock_gettime(CLOCK_MONOTONIC, &tp);
1064         TDM_DBG("block during %d us",
1065                         ((unsigned int)(tp.tv_sec * 1000000) + (unsigned int)(tp.tv_nsec / 1000))
1066                         - (req_sec * 1000000 + req_usec));
1067
1068         LIST_DEL(&w->link);
1069         free(w);
1070
1071         return TDM_ERROR_NONE;
1072
1073         /* LCOV_EXCL_STOP */
1074 }