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