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