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 INTERN tdm_error
 353 tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
 354 {
 355         tdm_thread_cb_display_output_create output_create;
 356         tdm_error ret;
 357
 358         if (LIST_IS_EMPTY(&private_display->output_create_handler_list)) return TDM_ERROR_NONE;
 359
 360         memset(&output_create, 0, sizeof output_create);
 361         output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
 362         output_create.base.length = sizeof output_create;
 363         output_create.base.object_stamp = tdm_helper_get_time();
 364         output_create.base.data = NULL;
 365         output_create.base.sync = 1;
 366         output_create.output = output;
 367
 368         ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
 369         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 370
 371         return TDM_ERROR_NONE;
 372 }
 373
 374 INTERN void
 375 tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 376 {
 377         tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
 378         tdm_private_output_create_handler *create_handler = user_data;
 379         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 380
 381         assert(create_handler->owner_tid == syscall(SYS_gettid));
 382
 383         _pthread_mutex_unlock(&private_display->lock);
 384         create_handler->func(private_display, output_create->output, create_handler->user_data);
 385         _pthread_mutex_lock(&private_display->lock);
 386 }
 387
 388 EXTERN tdm_error
 389 tdm_display_add_output_create_handler(tdm_display *dpy,
 390                                                                           tdm_output_create_handler func,
 391                                                                           void *user_data)
 392 {
 393         tdm_private_output_create_handler *create_handler = NULL;
 394
 395         DISPLAY_FUNC_ENTRY();
 396
 397         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 398
 399         _pthread_mutex_lock(&private_display->lock);
 400
 401         LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
 402                 if (create_handler->func == func && create_handler->user_data == user_data) {
 403                         TDM_ERR("can't add twice");
 404                         _pthread_mutex_unlock(&private_display->lock);
 405                         return TDM_ERROR_BAD_REQUEST;
 406                 }
 407         }
 408
 409         create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
 410         if (!create_handler) {
 411                 TDM_ERR("failed: alloc memory");
 412                 _pthread_mutex_unlock(&private_display->lock);
 413                 return TDM_ERROR_OUT_OF_MEMORY;
 414         }
 415
 416         ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
 417                                                         tdm_display_thread_cb_output_create, create_handler);
 418         if (ret != TDM_ERROR_NONE) {
 419                 TDM_ERR("tdm_thread_cb_add failed");
 420                 free(create_handler);
 421                 _pthread_mutex_unlock(&private_display->lock);
 422                 return TDM_ERROR_OPERATION_FAILED;
 423         }
 424
 425         create_handler->private_display = private_display;
 426         create_handler->func = func;
 427         create_handler->user_data = user_data;
 428         create_handler->owner_tid = syscall(SYS_gettid);
 429
 430         LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
 431
 432         _pthread_mutex_unlock(&private_display->lock);
 433
 434         return ret;
 435 }
 436
 437 EXTERN void
 438 tdm_display_remove_output_create_handler(tdm_display *dpy,
 439                                                                                  tdm_output_create_handler func,
 440                                                                                  void *user_data)
 441 {
 442         tdm_private_display *private_display;
 443         tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
 444
 445         TDM_RETURN_IF_FAIL(dpy != NULL);
 446         TDM_RETURN_IF_FAIL(func != NULL);
 447
 448         private_display = (tdm_private_display*)dpy;
 449
 450         _pthread_mutex_lock(&private_display->lock);
 451
 452         LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
 453                 if (create_handler->func != func || create_handler->user_data != user_data)
 454                         continue;
 455
 456                 tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
 457                                                          tdm_display_thread_cb_output_create, create_handler);
 458
 459                 LIST_DEL(&create_handler->link);
 460                 free(create_handler);
 461
 462                 _pthread_mutex_unlock(&private_display->lock);
 463
 464                 return;
 465         }
 466
 467         _pthread_mutex_unlock(&private_display->lock);
 468 }
 469
 470 EXTERN tdm_error
 471 tdm_display_get_capabilities(tdm_display *dpy,
 472                                                          tdm_display_capability *capabilities)
 473 {
 474         tdm_private_module *private_module = NULL;
 475
 476         DISPLAY_FUNC_ENTRY();
 477
 478         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 479
 480         _pthread_mutex_lock(&private_display->lock);
 481
 482         *capabilities = 0;
 483
 484         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 485                 *capabilities |= private_module->capabilities;
 486         }
 487
 488         _pthread_mutex_unlock(&private_display->lock);
 489
 490         return ret;
 491 }
 492
 493 EXTERN tdm_error
 494 tdm_display_get_pp_capabilities(tdm_display *dpy,
 495                                                                 tdm_pp_capability *capabilities)
 496 {
 497         tdm_private_module *pp_module;
 498
 499         DISPLAY_FUNC_ENTRY();
 500
 501         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 502
 503         _pthread_mutex_lock(&private_display->lock);
 504
 505         if (!private_display->pp_module) {
 506                 /* LCOV_EXCL_START */
 507                 TDM_ERR("no pp capability");
 508                 _pthread_mutex_unlock(&private_display->lock);
 509                 return TDM_ERROR_NO_CAPABILITY;
 510                 /* LCOV_EXCL_STOP */
 511         }
 512
 513         pp_module = private_display->pp_module;
 514
 515         *capabilities = pp_module->caps_pp.capabilities;
 516
 517         _pthread_mutex_unlock(&private_display->lock);
 518
 519         return ret;
 520 }
 521
 522 EXTERN tdm_error
 523 tdm_display_get_pp_available_formats(tdm_display *dpy,
 524                                                                          const tbm_format **formats, int *count)
 525 {
 526         tdm_private_module *pp_module;
 527
 528         DISPLAY_FUNC_ENTRY();
 529
 530         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 531         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 532
 533         _pthread_mutex_lock(&private_display->lock);
 534
 535         if (!private_display->pp_module) {
 536                 /* LCOV_EXCL_START */
 537                 TDM_ERR("no pp capability");
 538                 _pthread_mutex_unlock(&private_display->lock);
 539                 return TDM_ERROR_NO_CAPABILITY;
 540                 /* LCOV_EXCL_STOP */
 541         }
 542
 543         pp_module = private_display->pp_module;
 544
 545         *formats = (const tbm_format *)pp_module->caps_pp.formats;
 546         *count = pp_module->caps_pp.format_count;
 547
 548         _pthread_mutex_unlock(&private_display->lock);
 549
 550         return ret;
 551 }
 552
 553 EXTERN tdm_error
 554 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 555                                                                   int *max_w, int *max_h, int *preferred_align)
 556 {
 557         tdm_private_module *pp_module;
 558
 559         DISPLAY_FUNC_ENTRY();
 560
 561         _pthread_mutex_lock(&private_display->lock);
 562
 563         if (!private_display->pp_module) {
 564                 /* LCOV_EXCL_START */
 565                 TDM_ERR("no pp capability");
 566                 _pthread_mutex_unlock(&private_display->lock);
 567                 return TDM_ERROR_NO_CAPABILITY;
 568                 /* LCOV_EXCL_STOP */
 569         }
 570
 571         pp_module = private_display->pp_module;
 572
 573         if (min_w)
 574                 *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
 575         if (min_h)
 576                 *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
 577         if (max_w)
 578                 *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
 579         if (max_h)
 580                 *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
 581         if (preferred_align)
 582                 *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
 583
 584         _pthread_mutex_unlock(&private_display->lock);
 585
 586         return ret;
 587 }
 588
 589 EXTERN tdm_error
 590 tdm_display_get_pp_preferred_align_vertical(tdm_display *dpy, int *preferred_align_vertical)
 591 {
 592         tdm_private_module *pp_module;
 593
 594         DISPLAY_FUNC_ENTRY();
 595
 596         _pthread_mutex_lock(&private_display->lock);
 597
 598         if (!private_display->pp_module) {
 599                 /* LCOV_EXCL_START */
 600                 TDM_ERR("no pp capability");
 601                 _pthread_mutex_unlock(&private_display->lock);
 602                 return TDM_ERROR_NO_CAPABILITY;
 603                 /* LCOV_EXCL_STOP */
 604         }
 605
 606         pp_module = private_display->pp_module;
 607
 608         if (preferred_align_vertical)
 609                 *preferred_align_vertical = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align_vertical);
 610
 611         _pthread_mutex_unlock(&private_display->lock);
 612
 613         return ret;
 614 }
 615
 616 EXTERN tdm_error
 617 tdm_display_get_capture_capabilities(tdm_display *dpy,
 618                                                                          tdm_capture_capability *capabilities)
 619 {
 620         tdm_private_module *capture_module;
 621
 622         DISPLAY_FUNC_ENTRY();
 623
 624         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 625
 626         _pthread_mutex_lock(&private_display->lock);
 627
 628         if (!private_display->capture_module) {
 629                 /* LCOV_EXCL_START */
 630                 TDM_ERR("no capture capability");
 631                 _pthread_mutex_unlock(&private_display->lock);
 632                 return TDM_ERROR_NO_CAPABILITY;
 633                 /* LCOV_EXCL_STOP */
 634         }
 635
 636         capture_module = private_display->capture_module;
 637
 638         *capabilities = capture_module->caps_capture.capabilities;
 639
 640         _pthread_mutex_unlock(&private_display->lock);
 641
 642         return ret;
 643 }
 644
 645 EXTERN tdm_error
 646 tdm_display_get_capture_available_formats(tdm_display *dpy,
 647                 const tbm_format **formats, int *count)
 648 {
 649         tdm_private_module *capture_module;
 650
 651         DISPLAY_FUNC_ENTRY();
 652
 653         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 654         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 655
 656         _pthread_mutex_lock(&private_display->lock);
 657
 658         if (!private_display->capture_module) {
 659                 /* LCOV_EXCL_START */
 660                 TDM_ERR("no capture capability");
 661                 _pthread_mutex_unlock(&private_display->lock);
 662                 return TDM_ERROR_NO_CAPABILITY;
 663                 /* LCOV_EXCL_STOP */
 664         }
 665
 666         capture_module = private_display->capture_module;
 667
 668         *formats = (const tbm_format *)capture_module->caps_capture.formats;
 669         *count = capture_module->caps_capture.format_count;
 670
 671         _pthread_mutex_unlock(&private_display->lock);
 672
 673         return ret;
 674 }
 675
 676 EXTERN tdm_error
 677 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 678                                                                            int *max_w, int *max_h, int *preferred_align)
 679 {
 680         tdm_private_module *capture_module;
 681
 682         DISPLAY_FUNC_ENTRY();
 683
 684         _pthread_mutex_lock(&private_display->lock);
 685
 686         if (!private_display->capture_module) {
 687                 /* LCOV_EXCL_START */
 688                 TDM_ERR("no capture capability");
 689                 _pthread_mutex_unlock(&private_display->lock);
 690                 return TDM_ERROR_NO_CAPABILITY;
 691                 /* LCOV_EXCL_STOP */
 692         }
 693
 694         capture_module = private_display->capture_module;
 695
 696         if (min_w)
 697                 *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
 698         if (min_h)
 699                 *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
 700         if (max_w)
 701                 *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
 702         if (max_h)
 703                 *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
 704         if (preferred_align)
 705                 *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
 706
 707         _pthread_mutex_unlock(&private_display->lock);
 708
 709         return ret;
 710 }
 711
 712 EXTERN tdm_error
 713 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
 714 {
 715         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 716         TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
 717
 718         TDM_DEPRECATED(NULL);
 719
 720         *max_count = -1;
 721
 722         return TDM_ERROR_NONE;
 723 }
 724
 725 EXTERN tdm_error
 726 tdm_display_get_output_count(tdm_display *dpy, int *count)
 727 {
 728         tdm_private_module *private_module = NULL;
 729         tdm_private_output *private_output = NULL;
 730
 731         DISPLAY_FUNC_ENTRY();
 732
 733         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 734
 735         _pthread_mutex_lock(&private_display->lock);
 736
 737         *count = 0;
 738         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 739                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 740                         (*count)++;
 741                 }
 742         }
 743
 744         _pthread_mutex_unlock(&private_display->lock);
 745
 746         return ret;
 747 }
 748
 749
 750 EXTERN tdm_output *
 751 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 752 {
 753         tdm_private_module *private_module = NULL;
 754         tdm_private_output *private_output = NULL;
 755
 756         DISPLAY_FUNC_ENTRY_ERROR();
 757
 758         _pthread_mutex_lock(&private_display->lock);
 759
 760         if (error)
 761                 *error = TDM_ERROR_NONE;
 762
 763         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 764                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 765                         if (private_output->index == index) {
 766                                 _pthread_mutex_unlock(&private_display->lock);
 767                                 return private_output;
 768                         }
 769                 }
 770         }
 771
 772         _pthread_mutex_unlock(&private_display->lock);
 773
 774         return NULL;
 775 }
 776
 777 EXTERN tdm_output *
 778 tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
 779 {
 780         tdm_private_module *private_module = NULL;
 781         tdm_private_output *private_output = NULL;
 782         tdm_private_output *mode_setted_output = NULL;
 783         tdm_private_output *connected_output = NULL;
 784         unsigned int find_primary = 0;
 785
 786         DISPLAY_FUNC_ENTRY_ERROR();
 787
 788         if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
 789                 find_primary = 1;
 790
 791         _pthread_mutex_lock(&private_display->lock);
 792
 793         if (error)
 794                 *error = TDM_ERROR_NONE;
 795
 796         if (find_primary) {
 797                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 798                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 799                                 if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
 800                                         connected_output = private_output;
 801                                 else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
 802                                         mode_setted_output = private_output;
 803                         }
 804                 }
 805
 806                 if (mode_setted_output) {
 807                         _pthread_mutex_unlock(&private_display->lock);
 808                         return mode_setted_output;
 809                 }
 810
 811                 if (connected_output) {
 812                         _pthread_mutex_unlock(&private_display->lock);
 813                         return connected_output;
 814                 }
 815
 816                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 817                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 818                                 if (private_output->index == 0) {
 819                                         _pthread_mutex_unlock(&private_display->lock);
 820                                         return private_output;
 821                                 }
 822                         }
 823                 }
 824         }
 825
 826         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 827                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 828                         if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
 829                                 continue;
 830                         _pthread_mutex_unlock(&private_display->lock);
 831                         return private_output;
 832                 }
 833         }
 834
 835         if (private_display->virtual_module) {
 836                 private_module = private_display->virtual_module;
 837                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 838                         if (strncmp(private_output->name, name, TDM_NAME_LEN))
 839                                 continue;
 840                         _pthread_mutex_unlock(&private_display->lock);
 841                         return private_output;
 842                 }
 843         }
 844         _pthread_mutex_unlock(&private_display->lock);
 845
 846         return NULL;
 847 }
 848
 849 EXTERN tdm_error
 850 tdm_display_get_fd(tdm_display *dpy, int *fd)
 851 {
 852         DISPLAY_FUNC_ENTRY();
 853
 854         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 855
 856         _pthread_mutex_lock(&private_display->lock);
 857
 858         if (tdm_thread_is_running())
 859                 *fd = tdm_thread_get_fd(private_display->private_loop);
 860         else
 861                 *fd = tdm_event_loop_get_fd(private_display);
 862
 863         _pthread_mutex_unlock(&private_display->lock);
 864
 865         return ret;
 866 }
 867
 868 EXTERN tdm_error
 869 tdm_display_handle_events(tdm_display *dpy)
 870 {
 871         struct pollfd fds;
 872         int fd = -1;
 873
 874         DISPLAY_FUNC_ENTRY();
 875
 876         ret = tdm_display_get_fd(dpy, &fd);
 877         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 878
 879         fds.events = POLLIN;
 880         fds.fd = fd;
 881         fds.revents = 0;
 882
 883         if (tdm_debug_module & TDM_DEBUG_EVENT)
 884                 TDM_INFO("fd(%d) polling in", fd);
 885
 886         while (poll(&fds, 1, -1) < 0) {
 887                 /* LCOV_EXCL_START */
 888                 if (errno == EINTR || errno == EAGAIN)  /* normal case */
 889                         continue;
 890                 else {
 891                         TDM_ERR("poll failed: %m");
 892                         return TDM_ERROR_OPERATION_FAILED;
 893                 }
 894                 /* LCOV_EXCL_STOP */
 895         }
 896
 897         if (tdm_debug_module & TDM_DEBUG_EVENT)
 898                 TDM_INFO("fd(%d) polling out", fd);
 899
 900         if (tdm_thread_is_running()) {
 901                 _pthread_mutex_lock(&private_display->lock);
 902                 ret = tdm_thread_handle_cb(private_display->private_loop);
 903                 _pthread_mutex_unlock(&private_display->lock);
 904         } else {
 905                 ret = tdm_event_loop_dispatch(private_display);
 906         }
 907
 908         return ret;
 909 }
 910
 911 EXTERN void
 912 tdm_display_flush(tdm_display *dpy)
 913 {
 914         tdm_private_display *private_display;
 915
 916         TDM_RETURN_IF_FAIL(dpy != NULL);
 917         private_display = (tdm_private_display*)dpy;
 918
 919         if (tdm_thread_is_running())
 920                 return;
 921
 922         tdm_event_loop_flush(private_display);
 923 }
 924
 925 EXTERN tdm_error
 926 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 927                                                          const char **vendor, int *major, int *minor)
 928 {
 929         tdm_private_module *private_module = NULL;
 930         tdm_backend_module *module_data = NULL;
 931
 932         DISPLAY_FUNC_ENTRY();
 933
 934         TDM_DEPRECATED("Use tdm_module_get_info");
 935
 936         _pthread_mutex_lock(&private_display->lock);
 937
 938         /* use first backend */
 939         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 940                 module_data = private_module->module_data;
 941                 break;
 942         }
 943
 944         assert(module_data != NULL);
 945
 946         if (name)
 947                 *name = module_data->name;
 948         if (vendor)
 949                 *vendor = module_data->vendor;
 950         if (major)
 951                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 952         if (minor)
 953                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 954
 955         _pthread_mutex_unlock(&private_display->lock);
 956
 957         return ret;
 958 }
 959
 960 EXTERN tdm_pp *
 961 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 962 {
 963         tdm_pp *pp;
 964
 965         DISPLAY_FUNC_ENTRY_ERROR();
 966
 967         _pthread_mutex_lock(&private_display->lock);
 968
 969         pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
 970
 971         _pthread_mutex_unlock(&private_display->lock);
 972
 973         return pp;
 974 }
 975
 976 EXTERN tdm_error
 977 tdm_module_get_info(tdm_module *module, const char **name,
 978                                         const char **vendor, int *major, int *minor)
 979 {
 980         tdm_backend_module *module_data;
 981
 982         BACKEND_FUNC_ENTRY();
 983
 984         _pthread_mutex_lock(&private_display->lock);
 985
 986         module_data = private_module->module_data;
 987
 988         if (name)
 989                 *name = module_data->name;
 990         if (vendor)
 991                 *vendor = module_data->vendor;
 992         if (major)
 993                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 994         if (minor)
 995                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 996
 997         _pthread_mutex_unlock(&private_display->lock);
 998
 999         return ret;
1000 }
1001
1002 INTERN int
1003 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
1004 {
1005         tdm_backend_module *module = private_module->module_data;
1006
1007         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
1008                 return 1;
1009
1010         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
1011                 return 0;
1012
1013         if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
1014                 return 0;
1015
1016         return 1;
1017 }
1018
1019 INTERN tdm_voutput *
1020 tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
1021 {
1022         tdm_private_module *private_module = NULL;
1023         tdm_private_module *current_module = NULL;
1024         tdm_private_voutput *private_voutput = NULL;
1025         tdm_private_output *private_output = NULL;
1026         tdm_func_display *func_display = NULL;
1027         tdm_func_voutput *func_voutput = NULL;
1028         tdm_voutput *voutput_backend = NULL;
1029         tdm_output *output_backend = NULL;
1030         int output_find = 0;
1031         tdm_private_display *private_display;
1032         tdm_error ret = TDM_ERROR_NONE;
1033
1034         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
1035         private_display = (tdm_private_display*)dpy;
1036         private_module = private_display->virtual_module;
1037         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
1038
1039         _pthread_mutex_lock(&private_display->lock);
1040
1041         if (error) *error = TDM_ERROR_NONE;
1042
1043         private_voutput = calloc(1, sizeof(tdm_private_voutput));
1044         if (!private_voutput) {
1045                 if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
1046                 _pthread_mutex_unlock(&private_display->lock);
1047                 return NULL;
1048         }
1049
1050         func_display = &private_module->func_display;
1051         func_voutput = &private_module->func_voutput;
1052         current_module = private_display->current_module;
1053         private_display->current_module = private_module;
1054
1055         voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
1056
1057         if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
1058                 TDM_ERR("display_voutput_create fail");
1059                 free(private_voutput);
1060                 if (error) *error = ret;
1061                 private_display->current_module = current_module;
1062                 _pthread_mutex_unlock(&private_display->lock);
1063                 return NULL;
1064         }
1065         private_voutput->voutput_backend = voutput_backend;
1066         private_voutput->private_display = private_display;
1067         private_voutput->private_module = private_module;
1068         LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
1069
1070         output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
1071         if (output_backend == NULL || ret != TDM_ERROR_NONE) {
1072                 TDM_ERR("voutput_get_output fail");
1073                 free(private_voutput);
1074                 if (error) *error = ret;
1075                 if (func_voutput->voutput_destroy)
1076                         func_voutput->voutput_destroy(voutput_backend);
1077                 else
1078                         TDM_ERR("no destroy function");
1079                 private_display->current_module = current_module;
1080                 _pthread_mutex_unlock(&private_display->lock);
1081                 return NULL;
1082         }
1083
1084         ret = tdm_display_update_output(private_display->current_module, output_backend);
1085         if (ret != TDM_ERROR_NONE) {
1086                 TDM_ERR("tdm_display_update_output fail");
1087                 free(private_voutput);
1088                 if (func_voutput->voutput_destroy)
1089                         func_voutput->voutput_destroy(voutput_backend);
1090                 else
1091                         TDM_ERR("no destroy function");
1092                 if (error) *error = ret;
1093                 private_display->current_module = current_module;
1094                 _pthread_mutex_unlock(&private_display->lock);
1095                 return NULL;
1096         }
1097
1098         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
1099                 if (private_output->output_backend == output_backend) {
1100                         output_find = 1;
1101                         break;
1102                 }
1103         }
1104
1105         if (output_find != 1) {
1106                 private_output = NULL;
1107                 free(private_voutput);
1108                 if (func_voutput->voutput_destroy)
1109                         func_voutput->voutput_destroy(voutput_backend);
1110                 else
1111                         TDM_ERR("no destroy function");
1112                 private_voutput = NULL;
1113         } else {
1114                 strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
1115                 private_voutput->name[TDM_NAME_LEN - 1] = '\0';
1116                 strncpy(private_output->name, name, TDM_NAME_LEN - 1);
1117                 private_output->name[TDM_NAME_LEN - 1] = '\0';
1118
1119                 private_voutput->private_output = private_output;
1120                 private_output->private_voutput = private_voutput;
1121
1122                 /* do not use vblank */
1123                 tdm_output_choose_commit_per_vblank_mode(private_output, 0);
1124
1125                 LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
1126         }
1127
1128         private_display->current_module = current_module;
1129
1130         _pthread_mutex_unlock(&private_display->lock);
1131
1132         return private_voutput;
1133 }