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 /* LCOV_EXCL_START */
  65 INTERN tdm_error
  66 tdm_display_enable_debug_module(const char*modules)
  67 {
  68         char temp[TDM_PATH_LEN];
  69         char *arg;
  70         char *end;
  71
  72         snprintf(temp, TDM_PATH_LEN, "%s", modules);
  73
  74         tdm_debug_module = 0;
  75
  76         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
  77         while (arg) {
  78                 if (!strncmp(arg, "none", 4)) {
  79                         tdm_debug_module = 0;
  80                         return TDM_ERROR_NONE;
  81                 }
  82                 if (!strncmp(arg, "all", 3)) {
  83                         tdm_debug_module = 0xFFFFFFFF;
  84                         return TDM_ERROR_NONE;
  85                 }
  86                 if (!strncmp(arg, "buffer", 6))
  87                         tdm_debug_module |= TDM_DEBUG_BUFFER;
  88                 else if (!strncmp(arg, "event", 5))
  89                         tdm_debug_module |= TDM_DEBUG_EVENT;
  90                 else if (!strncmp(arg, "thread", 6))
  91                         tdm_debug_module |= TDM_DEBUG_THREAD;
  92                 else if (!strncmp(arg, "mutex", 5))
  93                         tdm_debug_module |= TDM_DEBUG_MUTEX;
  94                 else if (!strncmp(arg, "vblank", 6))
  95                         tdm_debug_module |= TDM_DEBUG_VBLANK;
  96                 else if (!strncmp(arg, "commit", 6))
  97                         tdm_debug_module |= TDM_DEBUG_COMMIT;
  98
  99                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 100         }
 101
 102         TDM_INFO("module debugging... '%s'", modules);
 103
 104         return TDM_ERROR_NONE;
 105 }
 106
 107 INTERN tdm_error
 108 tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
 109 {
 110         char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
 111         char *path = NULL, *path2;
 112         char *arg;
 113         char *end;
 114
 115         snprintf(temp2, TDM_PATH_LEN, "%s", dump_str);
 116         path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@");
 117         if (!path2 || path2[0] == '\0')
 118                 path2 = TDM_DUMP_DIR;
 119         else
 120                 path2++;
 121
 122         tdm_debug_dump = 0;
 123
 124         snprintf(temp, sizeof(temp), "%s", dump_str);
 125         arg = strtok_r(temp, ",", &end);
 126         TDM_GOTO_IF_FAIL(arg != NULL, done);
 127
 128         if (!strncmp(arg, "none", 4)) {
 129                 tdm_debug_dump = 0;
 130                 TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown");
 131                 if (tdm_debug_dump_dir) {
 132                         free(tdm_debug_dump_dir);
 133                         tdm_debug_dump_dir = NULL;
 134                 }
 135                 goto done;
 136         }
 137
 138         path = tdm_helper_dump_make_directory(path2, reply, len);
 139         TDM_GOTO_IF_FAIL(path != NULL, done);
 140
 141         if (!strncmp(arg, "current", 7)) {
 142                 tdm_private_module *b = NULL;
 143                 tdm_private_output *o = NULL;
 144
 145                 if (!private_display) {
 146                         TDM_WRN("no private_display");
 147                         goto done;
 148                 }
 149
 150                 LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
 151                         LIST_FOR_EACH_ENTRY(o, &b->output_list, link) {
 152                                 tdm_private_layer *l = NULL;
 153                                 LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
 154                                         char str[TDM_PATH_LEN];
 155                                         if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
 156                                                 continue;
 157                                         if (!l->showing_buffer)
 158                                                 continue;
 159                                         snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
 160                                         tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str);
 161                                 }
 162                         }
 163                 }
 164
 165                 TDM_SNPRINTF(reply, len, "path: %s\n", path);
 166                 goto done;
 167         }
 168
 169         TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
 170
 171         while (arg) {
 172                 if (!strncmp(arg, "all", 3)) {
 173                         tdm_debug_dump = 0xFFFFFFFF;
 174                         goto done;
 175                 } else if (!strncmp(arg, "layer", 5)) {
 176                         tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
 177                 } else if (!strncmp(arg, "pp", 2)) {
 178                         tdm_debug_dump |= TDM_DUMP_FLAG_PP;
 179                 } else if (!strncmp(arg, "capture", 7)) {
 180                         tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
 181                 } else if (!strncmp(arg, "window", 6)) {
 182                         tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW;
 183                 } else
 184                         goto done;
 185
 186                 arg = strtok_r(NULL, ",", &end);
 187         }
 188
 189         if (tdm_debug_dump_dir)
 190                 free(tdm_debug_dump_dir);
 191
 192         tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
 193
 194         TDM_INFO("dump... '%s'", dump_str);
 195
 196 done:
 197         if (path)
 198                 free(path);
 199
 200         return TDM_ERROR_NONE;
 201 }
 202
 203 static void
 204 _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 205                                                           unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 206 {
 207         tdm_error ret = TDM_ERROR_NONE;
 208
 209         TDM_TRACE_MARK("VSYNC");
 210
 211         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 212         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 213 }
 214
 215 INTERN tdm_error
 216 tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
 217 {
 218         tdm_private_display *private_display = dpy;
 219         tdm_private_module *private_module = NULL;
 220         tdm_private_output *private_output = NULL;
 221         const tdm_output_mode *mode = NULL;
 222         tdm_vblank *vblank = NULL;
 223         tdm_error ret = TDM_ERROR_NONE;
 224
 225         if (!enable) {
 226                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 227                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 228                                 if (private_output->ttrace_vblank)
 229                                         tdm_vblank_destroy(private_output->ttrace_vblank);
 230                                 private_output->ttrace_vblank = NULL;
 231                         }
 232                 }
 233                 return TDM_ERROR_NONE;
 234         }
 235
 236         private_output = output;
 237         TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
 238
 239         if (private_output->ttrace_vblank)
 240                 return TDM_ERROR_NONE;
 241
 242         vblank = tdm_vblank_create(private_display, output, &ret);
 243         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
 244
 245         ret = tdm_output_get_mode(output, &mode);
 246         TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
 247
 248         ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
 249         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 250
 251         ret = tdm_vblank_set_enable_fake(vblank, 1);
 252         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 253
 254         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 255         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 256
 257         private_output->ttrace_vblank = vblank;
 258
 259         return TDM_ERROR_NONE;
 260
 261 enable_fail:
 262         if (vblank)
 263                 tdm_vblank_destroy(vblank);
 264
 265         return ret;
 266 }
 267
 268 INTERN tdm_error
 269 tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
 270 {
 271         char temp[TDM_PATH_LEN];
 272         char *arg;
 273         char *end;
 274         tdm_output *output;
 275         tdm_error ret;
 276         tdm_output_type type;
 277
 278         snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
 279
 280         tdm_ttrace_output = output_id;
 281         tdm_ttrace_module = 0;
 282
 283         output = tdm_display_get_output(private_display, output_id, &ret);
 284         if (!output) {
 285                 TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
 286                 return ret;
 287         }
 288
 289         ret = tdm_output_get_output_type(output, &type);
 290         if (ret != TDM_ERROR_NONE) {
 291                 TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
 292                 return ret;
 293         }
 294
 295         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
 296         while (arg) {
 297                 if (!strncmp(arg, "none", 4))
 298                         tdm_ttrace_module = 0;
 299                 else if (!strncmp(arg, "all", 3))
 300                         tdm_ttrace_module = 0xFFFFFFFF;
 301                 else if (!strncmp(arg, "vsync", 5))
 302                         tdm_ttrace_module |= TDM_TTRACE_VSYNC;
 303                 else if (!strncmp(arg, "client_vblank", 13))
 304                         tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK;
 305                 else if (!strncmp(arg, "server_vblank", 13))
 306                         tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK;
 307                 else if (!strncmp(arg, "vblank", 6))
 308                         tdm_ttrace_module |= TDM_TTRACE_VBLANK;
 309                 else if (!strncmp(arg, "layer", 5))
 310                         tdm_ttrace_module |= TDM_TTRACE_LAYER;
 311                 else if (!strncmp(arg, "pp", 2))
 312                         tdm_ttrace_module |= TDM_TTRACE_PP;
 313                 else if (!strncmp(arg, "capture", 7))
 314                         tdm_ttrace_module |= TDM_TTRACE_CAPTURE;
 315                 else  {
 316                         tdm_ttrace_module = 0;
 317                         tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 318                         tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 319                         TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg);
 320                         return TDM_ERROR_NONE;
 321                 }
 322
 323                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 324         }
 325
 326         TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
 327
 328         if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
 329                 tdm_display_enable_ttrace_vblank(private_display, output, 1);
 330         else
 331                 tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 332
 333         if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
 334                 tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
 335         else
 336                 tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 337
 338         return TDM_ERROR_NONE;
 339 }
 340
 341 INTERN tdm_error
 342 tdm_display_enable_fps(tdm_private_display *private_display, int enable)
 343 {
 344         private_display->print_fps = enable;
 345
 346         TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
 347
 348         return TDM_ERROR_NONE;
 349 }
 350 /* LCOV_EXCL_STOP */
 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         tdm_private_output *mode_setted_output = NULL;
 638         tdm_private_output *connected_output = NULL;
 639         unsigned int find_primary = 0;
 640
 641         DISPLAY_FUNC_ENTRY_ERROR();
 642
 643         if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
 644                 find_primary = 1;
 645
 646         _pthread_mutex_lock(&private_display->lock);
 647
 648         if (error)
 649                 *error = TDM_ERROR_NONE;
 650
 651         if (find_primary) {
 652                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 653                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 654                                 if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
 655                                         connected_output = private_output;
 656                                 else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
 657                                         mode_setted_output = private_output;
 658                         }
 659                 }
 660
 661                 if (mode_setted_output) {
 662                         _pthread_mutex_unlock(&private_display->lock);
 663                         return mode_setted_output;
 664                 }
 665
 666                 if (connected_output) {
 667                         _pthread_mutex_unlock(&private_display->lock);
 668                         return connected_output;
 669                 }
 670
 671                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 672                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 673                                 if (private_output->index == 0) {
 674                                         _pthread_mutex_unlock(&private_display->lock);
 675                                         return private_output;
 676                                 }
 677                         }
 678                 }
 679         }
 680
 681         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 682                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 683                         if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
 684                                 continue;
 685                         _pthread_mutex_unlock(&private_display->lock);
 686                         return private_output;
 687                 }
 688         }
 689
 690         _pthread_mutex_unlock(&private_display->lock);
 691
 692         return NULL;
 693 }
 694
 695 EXTERN tdm_error
 696 tdm_display_get_fd(tdm_display *dpy, int *fd)
 697 {
 698         DISPLAY_FUNC_ENTRY();
 699
 700         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 701
 702         _pthread_mutex_lock(&private_display->lock);
 703
 704         if (tdm_thread_is_running())
 705                 *fd = tdm_thread_get_fd(private_display->private_loop);
 706         else
 707                 *fd = tdm_event_loop_get_fd(private_display);
 708
 709         _pthread_mutex_unlock(&private_display->lock);
 710
 711         return ret;
 712 }
 713
 714 EXTERN tdm_error
 715 tdm_display_handle_events(tdm_display *dpy)
 716 {
 717         struct pollfd fds;
 718         int fd = -1;
 719
 720         DISPLAY_FUNC_ENTRY();
 721
 722         ret = tdm_display_get_fd(dpy, &fd);
 723         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 724
 725         fds.events = POLLIN;
 726         fds.fd = fd;
 727         fds.revents = 0;
 728
 729         if (tdm_debug_module & TDM_DEBUG_EVENT)
 730                 TDM_INFO("fd(%d) polling in", fd);
 731
 732         while (poll(&fds, 1, -1) < 0) {
 733                 /* LCOV_EXCL_START */
 734                 if (errno == EINTR || errno == EAGAIN)  /* normal case */
 735                         continue;
 736                 else {
 737                         TDM_ERR("poll failed: %m");
 738                         return TDM_ERROR_OPERATION_FAILED;
 739                 }
 740                 /* LCOV_EXCL_STOP */
 741         }
 742
 743         if (tdm_debug_module & TDM_DEBUG_EVENT)
 744                 TDM_INFO("fd(%d) polling out", fd);
 745
 746         if (tdm_thread_is_running()) {
 747                 _pthread_mutex_lock(&private_display->lock);
 748                 ret = tdm_thread_handle_cb(private_display->private_loop);
 749                 _pthread_mutex_unlock(&private_display->lock);
 750         } else {
 751                 ret = tdm_event_loop_dispatch(private_display);
 752         }
 753
 754         return ret;
 755 }
 756
 757 EXTERN void
 758 tdm_display_flush(tdm_display *dpy)
 759 {
 760         tdm_private_display *private_display;
 761
 762         TDM_RETURN_IF_FAIL(dpy != NULL);
 763         private_display = (tdm_private_display*)dpy;
 764
 765         if (tdm_thread_is_running())
 766                 return;
 767
 768         tdm_event_loop_flush(private_display);
 769 }
 770
 771 EXTERN tdm_error
 772 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 773                                                          const char **vendor, int *major, int *minor)
 774 {
 775         tdm_private_module *private_module = NULL;
 776         tdm_backend_module *module_data = NULL;
 777
 778         DISPLAY_FUNC_ENTRY();
 779
 780         TDM_DEPRECATED("Use tdm_module_get_info");
 781
 782         _pthread_mutex_lock(&private_display->lock);
 783
 784         /* use first backend */
 785         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 786                 module_data = private_module->module_data;
 787                 break;
 788         }
 789
 790         assert(module_data != NULL);
 791
 792         if (name)
 793                 *name = module_data->name;
 794         if (vendor)
 795                 *vendor = module_data->vendor;
 796         if (major)
 797                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 798         if (minor)
 799                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 800
 801         _pthread_mutex_unlock(&private_display->lock);
 802
 803         return ret;
 804 }
 805
 806 EXTERN tdm_pp *
 807 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 808 {
 809         tdm_pp *pp;
 810
 811         DISPLAY_FUNC_ENTRY_ERROR();
 812
 813         _pthread_mutex_lock(&private_display->lock);
 814
 815         pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
 816
 817         _pthread_mutex_unlock(&private_display->lock);
 818
 819         return pp;
 820 }
 821
 822 EXTERN tdm_error
 823 tdm_module_get_info(tdm_module *module, const char **name,
 824                                         const char **vendor, int *major, int *minor)
 825 {
 826         tdm_backend_module *module_data;
 827
 828         BACKEND_FUNC_ENTRY();
 829
 830         _pthread_mutex_lock(&private_display->lock);
 831
 832         module_data = private_module->module_data;
 833
 834         if (name)
 835                 *name = module_data->name;
 836         if (vendor)
 837                 *vendor = module_data->vendor;
 838         if (major)
 839                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 840         if (minor)
 841                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 842
 843         _pthread_mutex_unlock(&private_display->lock);
 844
 845         return ret;
 846 }
 847
 848 INTERN int
 849 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
 850 {
 851         tdm_backend_module *module = private_module->module_data;
 852
 853         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
 854                 return 1;
 855
 856         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
 857                 return 0;
 858
 859         if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
 860                 return 0;
 861
 862         return 1;
 863 }
 864