src/tdm_display.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 <boram1288.park@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 "tdm_private.h"
  41
  42 #define COUNT_MAX   10
  43
  44 #define DISPLAY_FUNC_ENTRY() \
  45         tdm_private_display *private_display; \
  46         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  47         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \
  48         TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER); \
  49         private_display = (tdm_private_display*)dpy;
  50
  51 #define DISPLAY_FUNC_ENTRY_ERROR() \
  52         tdm_private_display *private_display; \
  53         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  54         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
  55         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(tdm_display_is_valid(dpy), TDM_ERROR_INVALID_PARAMETER, NULL); \
  56         private_display = (tdm_private_display*)dpy;
  57
  58 #define BACKEND_FUNC_ENTRY() \
  59         tdm_private_module *private_module; \
  60         tdm_private_display *private_display; \
  61         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  62         TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
  63         private_module = (tdm_private_module*)module; \
  64         private_display = private_module->private_display;
  65
  66 INTERN tdm_error
  67 tdm_display_enable_debug_module(const char*modules)
  68 {
  69         char temp[TDM_PATH_LEN];
  70         char *arg;
  71         char *end;
  72
  73         snprintf(temp, TDM_PATH_LEN, "%s", modules);
  74
  75         tdm_debug_module = 0;
  76
  77         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
  78         while (arg) {
  79                 if (!strncmp(arg, "none", 4)) {
  80                         tdm_debug_module = 0;
  81                         return TDM_ERROR_NONE;
  82                 }
  83                 if (!strncmp(arg, "all", 3)) {
  84                         tdm_debug_module = 0xFFFFFFFF;
  85                         return TDM_ERROR_NONE;
  86                 }
  87                 if (!strncmp(arg, "buffer", 6))
  88                         tdm_debug_module |= TDM_DEBUG_BUFFER;
  89                 else if (!strncmp(arg, "event", 5))
  90                         tdm_debug_module |= TDM_DEBUG_EVENT;
  91                 else if (!strncmp(arg, "thread", 6))
  92                         tdm_debug_module |= TDM_DEBUG_THREAD;
  93                 else if (!strncmp(arg, "mutex", 5))
  94                         tdm_debug_module |= TDM_DEBUG_MUTEX;
  95                 else if (!strncmp(arg, "vblank", 6))
  96                         tdm_debug_module |= TDM_DEBUG_VBLANK;
  97                 else if (!strncmp(arg, "commit", 6))
  98                         tdm_debug_module |= TDM_DEBUG_COMMIT;
  99
 100                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 101         }
 102
 103         TDM_INFO("module debugging... '%s'", modules);
 104
 105         return TDM_ERROR_NONE;
 106 }
 107
 108 INTERN tdm_error
 109 tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
 110 {
 111         char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
 112         char *path = NULL, *path2;
 113         char *arg;
 114         char *end;
 115
 116         snprintf(temp2, TDM_PATH_LEN, "%s", dump_str);
 117         path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@");
 118         if (!path2 || path2[0] == '\0')
 119                 path2 = TDM_DUMP_DIR;
 120         else
 121                 path2++;
 122
 123         tdm_debug_dump = 0;
 124
 125         snprintf(temp, sizeof(temp), "%s", dump_str);
 126         arg = strtok_r(temp, ",", &end);
 127         TDM_GOTO_IF_FAIL(arg != NULL, done);
 128
 129         if (!strncmp(arg, "none", 4)) {
 130                 tdm_debug_dump = 0;
 131                 TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown");
 132                 if (tdm_debug_dump_dir) {
 133                         free(tdm_debug_dump_dir);
 134                         tdm_debug_dump_dir = NULL;
 135                 }
 136                 goto done;
 137         }
 138
 139         path = tdm_helper_dump_make_directory(path2, reply, len);
 140         TDM_GOTO_IF_FAIL(path != NULL, done);
 141
 142         if (!strncmp(arg, "current", 7)) {
 143                 tdm_private_module *b = NULL;
 144                 tdm_private_output *o = NULL;
 145
 146                 if (!private_display) {
 147                         TDM_WRN("no private_display");
 148                         goto done;
 149                 }
 150
 151                 LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
 152                         LIST_FOR_EACH_ENTRY(o, &b->output_list, link) {
 153                                 tdm_private_layer *l = NULL;
 154                                 LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
 155                                         char str[TDM_PATH_LEN];
 156                                         if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
 157                                                 continue;
 158                                         if (!l->showing_buffer)
 159                                                 continue;
 160                                         snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
 161                                         tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str);
 162                                 }
 163                         }
 164                 }
 165
 166                 TDM_SNPRINTF(reply, len, "path: %s\n", path);
 167                 goto done;
 168         }
 169
 170         TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
 171
 172         while (arg) {
 173                 if (!strncmp(arg, "all", 3)) {
 174                         tdm_debug_dump = 0xFFFFFFFF;
 175                         goto done;
 176                 } else if (!strncmp(arg, "layer", 5)) {
 177                         tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
 178                 } else if (!strncmp(arg, "pp", 2)) {
 179                         tdm_debug_dump |= TDM_DUMP_FLAG_PP;
 180                 } else if (!strncmp(arg, "capture", 7)) {
 181                         tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
 182                 } else if (!strncmp(arg, "window", 6)) {
 183                         tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW;
 184                 } else
 185                         goto done;
 186
 187                 arg = strtok_r(NULL, ",", &end);
 188         }
 189
 190         if (tdm_debug_dump_dir)
 191                 free(tdm_debug_dump_dir);
 192
 193         tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
 194
 195         TDM_INFO("dump... '%s'", dump_str);
 196
 197 done:
 198         if (path)
 199                 free(path);
 200
 201         return TDM_ERROR_NONE;
 202 }
 203
 204 static void
 205 _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 206                                                           unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 207 {
 208         tdm_error ret = TDM_ERROR_NONE;
 209
 210         TDM_TRACE_MARK("VSYNC");
 211
 212         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 213         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 214 }
 215
 216 INTERN tdm_error
 217 tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
 218 {
 219         tdm_private_display *private_display = dpy;
 220         tdm_private_module *private_module = NULL;
 221         tdm_private_output *private_output = NULL;
 222         const tdm_output_mode *mode = NULL;
 223         tdm_vblank *vblank = NULL;
 224         tdm_error ret = TDM_ERROR_NONE;
 225
 226         if (!enable) {
 227                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 228                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 229                                 if (private_output->ttrace_vblank)
 230                                         tdm_vblank_destroy(private_output->ttrace_vblank);
 231                                 private_output->ttrace_vblank = NULL;
 232                         }
 233                 }
 234                 return TDM_ERROR_NONE;
 235         }
 236
 237         private_output = output;
 238         TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
 239
 240         if (private_output->ttrace_vblank)
 241                 return TDM_ERROR_NONE;
 242
 243         vblank = tdm_vblank_create(private_display, output, &ret);
 244         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
 245
 246         ret = tdm_output_get_mode(output, &mode);
 247         TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
 248
 249         ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
 250         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 251
 252         ret = tdm_vblank_set_enable_fake(vblank, 1);
 253         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 254
 255         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 256         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 257
 258         private_output->ttrace_vblank = vblank;
 259
 260         return TDM_ERROR_NONE;
 261
 262 enable_fail:
 263         if (vblank)
 264                 tdm_vblank_destroy(vblank);
 265
 266         return ret;
 267 }
 268
 269 INTERN tdm_error
 270 tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
 271 {
 272         char temp[TDM_PATH_LEN];
 273         char *arg;
 274         char *end;
 275         tdm_output *output;
 276         tdm_error ret;
 277         tdm_output_type type;
 278
 279         snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
 280
 281         tdm_ttrace_output = output_id;
 282         tdm_ttrace_module = 0;
 283
 284         output = tdm_display_get_output(private_display, output_id, &ret);
 285         if (!output) {
 286                 TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
 287                 return ret;
 288         }
 289
 290         ret = tdm_output_get_output_type(output, &type);
 291         if (ret != TDM_ERROR_NONE) {
 292                 TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
 293                 return ret;
 294         }
 295
 296         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
 297         while (arg) {
 298                 if (!strncmp(arg, "none", 4))
 299                         tdm_ttrace_module = 0;
 300                 else if (!strncmp(arg, "all", 3))
 301                         tdm_ttrace_module = 0xFFFFFFFF;
 302                 else if (!strncmp(arg, "vsync", 5))
 303                         tdm_ttrace_module |= TDM_TTRACE_VSYNC;
 304                 else if (!strncmp(arg, "client_vblank", 13))
 305                         tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK;
 306                 else if (!strncmp(arg, "server_vblank", 13))
 307                         tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK;
 308                 else if (!strncmp(arg, "vblank", 6))
 309                         tdm_ttrace_module |= TDM_TTRACE_VBLANK;
 310                 else if (!strncmp(arg, "layer", 5))
 311                         tdm_ttrace_module |= TDM_TTRACE_LAYER;
 312                 else if (!strncmp(arg, "pp", 2))
 313                         tdm_ttrace_module |= TDM_TTRACE_PP;
 314                 else if (!strncmp(arg, "capture", 7))
 315                         tdm_ttrace_module |= TDM_TTRACE_CAPTURE;
 316                 else  {
 317                         tdm_ttrace_module = 0;
 318                         tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 319                         tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 320                         TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg);
 321                         return TDM_ERROR_NONE;
 322                 }
 323
 324                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 325         }
 326
 327         TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
 328
 329         if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
 330                 tdm_display_enable_ttrace_vblank(private_display, output, 1);
 331         else
 332                 tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 333
 334         if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
 335                 tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
 336         else
 337                 tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 338
 339         return TDM_ERROR_NONE;
 340 }
 341
 342 INTERN tdm_error
 343 tdm_display_enable_fps(tdm_private_display *private_display, int enable)
 344 {
 345         private_display->print_fps = enable;
 346
 347         TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
 348
 349         return TDM_ERROR_NONE;
 350 }
 351
 352 EXTERN tdm_error
 353 tdm_display_get_capabilities(tdm_display *dpy,
 354                                                          tdm_display_capability *capabilities)
 355 {
 356         tdm_private_module *private_module = NULL;
 357
 358         DISPLAY_FUNC_ENTRY();
 359
 360         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 361
 362         _pthread_mutex_lock(&private_display->lock);
 363
 364         *capabilities = 0;
 365
 366         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 367                 *capabilities |= private_module->capabilities;
 368         }
 369
 370         _pthread_mutex_unlock(&private_display->lock);
 371
 372         return ret;
 373 }
 374
 375 EXTERN tdm_error
 376 tdm_display_get_pp_capabilities(tdm_display *dpy,
 377                                                                 tdm_pp_capability *capabilities)
 378 {
 379         tdm_private_module *pp_module;
 380
 381         DISPLAY_FUNC_ENTRY();
 382
 383         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 384
 385         _pthread_mutex_lock(&private_display->lock);
 386
 387         if (!private_display->pp_module) {
 388                 /* LCOV_EXCL_START */
 389                 TDM_ERR("no pp capability");
 390                 _pthread_mutex_unlock(&private_display->lock);
 391                 return TDM_ERROR_NO_CAPABILITY;
 392                 /* LCOV_EXCL_STOP */
 393         }
 394
 395         pp_module = private_display->pp_module;
 396
 397         *capabilities = pp_module->caps_pp.capabilities;
 398
 399         _pthread_mutex_unlock(&private_display->lock);
 400
 401         return ret;
 402 }
 403
 404 EXTERN tdm_error
 405 tdm_display_get_pp_available_formats(tdm_display *dpy,
 406                                                                          const tbm_format **formats, int *count)
 407 {
 408         tdm_private_module *pp_module;
 409
 410         DISPLAY_FUNC_ENTRY();
 411
 412         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 413         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 414
 415         _pthread_mutex_lock(&private_display->lock);
 416
 417         if (!private_display->pp_module) {
 418                 /* LCOV_EXCL_START */
 419                 TDM_ERR("no pp capability");
 420                 _pthread_mutex_unlock(&private_display->lock);
 421                 return TDM_ERROR_NO_CAPABILITY;
 422                 /* LCOV_EXCL_STOP */
 423         }
 424
 425         pp_module = private_display->pp_module;
 426
 427         *formats = (const tbm_format *)pp_module->caps_pp.formats;
 428         *count = pp_module->caps_pp.format_count;
 429
 430         _pthread_mutex_unlock(&private_display->lock);
 431
 432         return ret;
 433 }
 434
 435 EXTERN tdm_error
 436 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 437                                                                   int *max_w, int *max_h, int *preferred_align)
 438 {
 439         tdm_private_module *pp_module;
 440
 441         DISPLAY_FUNC_ENTRY();
 442
 443         _pthread_mutex_lock(&private_display->lock);
 444
 445         if (!private_display->pp_module) {
 446                 /* LCOV_EXCL_START */
 447                 TDM_ERR("no pp capability");
 448                 _pthread_mutex_unlock(&private_display->lock);
 449                 return TDM_ERROR_NO_CAPABILITY;
 450                 /* LCOV_EXCL_STOP */
 451         }
 452
 453         pp_module = private_display->pp_module;
 454
 455         if (min_w)
 456                 *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
 457         if (min_h)
 458                 *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
 459         if (max_w)
 460                 *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
 461         if (max_h)
 462                 *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
 463         if (preferred_align)
 464                 *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
 465
 466         _pthread_mutex_unlock(&private_display->lock);
 467
 468         return ret;
 469 }
 470
 471 EXTERN tdm_error
 472 tdm_display_get_capture_capabilities(tdm_display *dpy,
 473                                                                          tdm_capture_capability *capabilities)
 474 {
 475         tdm_private_module *capture_module;
 476
 477         DISPLAY_FUNC_ENTRY();
 478
 479         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 480
 481         _pthread_mutex_lock(&private_display->lock);
 482
 483         if (!private_display->capture_module) {
 484                 /* LCOV_EXCL_START */
 485                 TDM_ERR("no capture capability");
 486                 _pthread_mutex_unlock(&private_display->lock);
 487                 return TDM_ERROR_NO_CAPABILITY;
 488                 /* LCOV_EXCL_STOP */
 489         }
 490
 491         capture_module = private_display->capture_module;
 492
 493         *capabilities = capture_module->caps_capture.capabilities;
 494
 495         _pthread_mutex_unlock(&private_display->lock);
 496
 497         return ret;
 498 }
 499
 500 EXTERN tdm_error
 501 tdm_display_get_capture_available_formats(tdm_display *dpy,
 502                 const tbm_format **formats, int *count)
 503 {
 504         tdm_private_module *capture_module;
 505
 506         DISPLAY_FUNC_ENTRY();
 507
 508         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 509         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 510
 511         _pthread_mutex_lock(&private_display->lock);
 512
 513         if (!private_display->capture_module) {
 514                 /* LCOV_EXCL_START */
 515                 TDM_ERR("no capture capability");
 516                 _pthread_mutex_unlock(&private_display->lock);
 517                 return TDM_ERROR_NO_CAPABILITY;
 518                 /* LCOV_EXCL_STOP */
 519         }
 520
 521         capture_module = private_display->capture_module;
 522
 523         *formats = (const tbm_format *)capture_module->caps_capture.formats;
 524         *count = capture_module->caps_capture.format_count;
 525
 526         _pthread_mutex_unlock(&private_display->lock);
 527
 528         return ret;
 529 }
 530
 531 EXTERN tdm_error
 532 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 533                                                                            int *max_w, int *max_h, int *preferred_align)
 534 {
 535         tdm_private_module *capture_module;
 536
 537         DISPLAY_FUNC_ENTRY();
 538
 539         _pthread_mutex_lock(&private_display->lock);
 540
 541         if (!private_display->capture_module) {
 542                 /* LCOV_EXCL_START */
 543                 TDM_ERR("no capture capability");
 544                 _pthread_mutex_unlock(&private_display->lock);
 545                 return TDM_ERROR_NO_CAPABILITY;
 546                 /* LCOV_EXCL_STOP */
 547         }
 548
 549         capture_module = private_display->capture_module;
 550
 551         if (min_w)
 552                 *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
 553         if (min_h)
 554                 *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
 555         if (max_w)
 556                 *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
 557         if (max_h)
 558                 *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
 559         if (preferred_align)
 560                 *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
 561
 562         _pthread_mutex_unlock(&private_display->lock);
 563
 564         return ret;
 565 }
 566
 567 EXTERN tdm_error
 568 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
 569 {
 570         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 571         TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
 572
 573         TDM_DEPRECATED(NULL);
 574
 575         *max_count = -1;
 576
 577         return TDM_ERROR_NONE;
 578 }
 579
 580 EXTERN tdm_error
 581 tdm_display_get_output_count(tdm_display *dpy, int *count)
 582 {
 583         tdm_private_module *private_module = NULL;
 584         tdm_private_output *private_output = NULL;
 585
 586         DISPLAY_FUNC_ENTRY();
 587
 588         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 589
 590         _pthread_mutex_lock(&private_display->lock);
 591
 592         *count = 0;
 593         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 594                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 595                         (*count)++;
 596                 }
 597         }
 598
 599         _pthread_mutex_unlock(&private_display->lock);
 600
 601         return ret;
 602 }
 603
 604
 605 EXTERN tdm_output *
 606 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 607 {
 608         tdm_private_module *private_module = NULL;
 609         tdm_private_output *private_output = NULL;
 610
 611         DISPLAY_FUNC_ENTRY_ERROR();
 612
 613         _pthread_mutex_lock(&private_display->lock);
 614
 615         if (error)
 616                 *error = TDM_ERROR_NONE;
 617
 618         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 619                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 620                         if (private_output->index == index) {
 621                                 _pthread_mutex_unlock(&private_display->lock);
 622                                 return private_output;
 623                         }
 624                 }
 625         }
 626
 627         _pthread_mutex_unlock(&private_display->lock);
 628
 629         return NULL;
 630 }
 631
 632 EXTERN tdm_output *
 633 tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
 634 {
 635         tdm_private_module *private_module = NULL;
 636         tdm_private_output *private_output = NULL;
 637
 638         DISPLAY_FUNC_ENTRY_ERROR();
 639
 640         if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7)) {
 641                 return tdm_display_get_output(dpy, 0, error);
 642         }
 643
 644         _pthread_mutex_lock(&private_display->lock);
 645
 646         if (error)
 647                 *error = TDM_ERROR_NONE;
 648
 649         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 650                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 651                         if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
 652                                 continue;
 653                         _pthread_mutex_unlock(&private_display->lock);
 654                         return private_output;
 655                 }
 656         }
 657
 658         _pthread_mutex_unlock(&private_display->lock);
 659
 660         return NULL;
 661 }
 662
 663 EXTERN tdm_error
 664 tdm_display_get_fd(tdm_display *dpy, int *fd)
 665 {
 666         DISPLAY_FUNC_ENTRY();
 667
 668         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 669
 670         _pthread_mutex_lock(&private_display->lock);
 671
 672         if (tdm_thread_is_running())
 673                 *fd = tdm_thread_get_fd(private_display->private_loop);
 674         else
 675                 *fd = tdm_event_loop_get_fd(private_display);
 676
 677         _pthread_mutex_unlock(&private_display->lock);
 678
 679         return ret;
 680 }
 681
 682 EXTERN tdm_error
 683 tdm_display_handle_events(tdm_display *dpy)
 684 {
 685         struct pollfd fds;
 686         int fd = -1;
 687
 688         DISPLAY_FUNC_ENTRY();
 689
 690         ret = tdm_display_get_fd(dpy, &fd);
 691         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 692
 693         fds.events = POLLIN;
 694         fds.fd = fd;
 695         fds.revents = 0;
 696
 697         if (tdm_debug_module & TDM_DEBUG_EVENT)
 698                 TDM_INFO("fd(%d) polling in", fd);
 699
 700         while (poll(&fds, 1, -1) < 0) {
 701                 /* LCOV_EXCL_START */
 702                 if (errno == EINTR || errno == EAGAIN)  /* normal case */
 703                         continue;
 704                 else {
 705                         TDM_ERR("poll failed: %m");
 706                         return TDM_ERROR_OPERATION_FAILED;
 707                 }
 708                 /* LCOV_EXCL_STOP */
 709         }
 710
 711         if (tdm_debug_module & TDM_DEBUG_EVENT)
 712                 TDM_INFO("fd(%d) polling out", fd);
 713
 714         if (tdm_thread_is_running()) {
 715                 _pthread_mutex_lock(&private_display->lock);
 716                 ret = tdm_thread_handle_cb(private_display->private_loop);
 717                 _pthread_mutex_unlock(&private_display->lock);
 718         } else {
 719                 ret = tdm_event_loop_dispatch(private_display);
 720         }
 721
 722         return ret;
 723 }
 724
 725 EXTERN void
 726 tdm_display_flush(tdm_display *dpy)
 727 {
 728         tdm_private_display *private_display;
 729
 730         TDM_RETURN_IF_FAIL(dpy != NULL);
 731         private_display = (tdm_private_display*)dpy;
 732
 733         if (tdm_thread_is_running())
 734                 return;
 735
 736         tdm_event_loop_flush(private_display);
 737 }
 738
 739 EXTERN tdm_error
 740 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 741                                                          const char **vendor, int *major, int *minor)
 742 {
 743         tdm_private_module *private_module = NULL;
 744         tdm_backend_module *module_data = NULL;
 745
 746         DISPLAY_FUNC_ENTRY();
 747
 748         TDM_DEPRECATED("Use tdm_module_get_info");
 749
 750         _pthread_mutex_lock(&private_display->lock);
 751
 752         /* use first backend */
 753         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 754                 module_data = private_module->module_data;
 755                 break;
 756         }
 757
 758         assert(module_data != NULL);
 759
 760         if (name)
 761                 *name = module_data->name;
 762         if (vendor)
 763                 *vendor = module_data->vendor;
 764         if (major)
 765                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 766         if (minor)
 767                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 768
 769         _pthread_mutex_unlock(&private_display->lock);
 770
 771         return ret;
 772 }
 773
 774 EXTERN tdm_pp *
 775 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 776 {
 777         tdm_pp *pp;
 778
 779         DISPLAY_FUNC_ENTRY_ERROR();
 780
 781         _pthread_mutex_lock(&private_display->lock);
 782
 783         pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
 784
 785         _pthread_mutex_unlock(&private_display->lock);
 786
 787         return pp;
 788 }
 789
 790 EXTERN tdm_error
 791 tdm_module_get_info(tdm_module *module, const char **name,
 792                                         const char **vendor, int *major, int *minor)
 793 {
 794         tdm_backend_module *module_data;
 795
 796         BACKEND_FUNC_ENTRY();
 797
 798         _pthread_mutex_lock(&private_display->lock);
 799
 800         module_data = private_module->module_data;
 801
 802         if (name)
 803                 *name = module_data->name;
 804         if (vendor)
 805                 *vendor = module_data->vendor;
 806         if (major)
 807                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 808         if (minor)
 809                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 810
 811         _pthread_mutex_unlock(&private_display->lock);
 812
 813         return ret;
 814 }
 815
 816 INTERN int
 817 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
 818 {
 819         tdm_backend_module *module = private_module->module_data;
 820
 821         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
 822                 return 0;
 823
 824         if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
 825                 return 0;
 826
 827         return 1;
 828 }
 829