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_capture_capabilities(tdm_display *dpy,
 591                                                                          tdm_capture_capability *capabilities)
 592 {
 593         tdm_private_module *capture_module;
 594
 595         DISPLAY_FUNC_ENTRY();
 596
 597         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 598
 599         _pthread_mutex_lock(&private_display->lock);
 600
 601         if (!private_display->capture_module) {
 602                 /* LCOV_EXCL_START */
 603                 TDM_ERR("no capture capability");
 604                 _pthread_mutex_unlock(&private_display->lock);
 605                 return TDM_ERROR_NO_CAPABILITY;
 606                 /* LCOV_EXCL_STOP */
 607         }
 608
 609         capture_module = private_display->capture_module;
 610
 611         *capabilities = capture_module->caps_capture.capabilities;
 612
 613         _pthread_mutex_unlock(&private_display->lock);
 614
 615         return ret;
 616 }
 617
 618 EXTERN tdm_error
 619 tdm_display_get_capture_available_formats(tdm_display *dpy,
 620                 const tbm_format **formats, int *count)
 621 {
 622         tdm_private_module *capture_module;
 623
 624         DISPLAY_FUNC_ENTRY();
 625
 626         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 627         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 628
 629         _pthread_mutex_lock(&private_display->lock);
 630
 631         if (!private_display->capture_module) {
 632                 /* LCOV_EXCL_START */
 633                 TDM_ERR("no capture capability");
 634                 _pthread_mutex_unlock(&private_display->lock);
 635                 return TDM_ERROR_NO_CAPABILITY;
 636                 /* LCOV_EXCL_STOP */
 637         }
 638
 639         capture_module = private_display->capture_module;
 640
 641         *formats = (const tbm_format *)capture_module->caps_capture.formats;
 642         *count = capture_module->caps_capture.format_count;
 643
 644         _pthread_mutex_unlock(&private_display->lock);
 645
 646         return ret;
 647 }
 648
 649 EXTERN tdm_error
 650 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 651                                                                            int *max_w, int *max_h, int *preferred_align)
 652 {
 653         tdm_private_module *capture_module;
 654
 655         DISPLAY_FUNC_ENTRY();
 656
 657         _pthread_mutex_lock(&private_display->lock);
 658
 659         if (!private_display->capture_module) {
 660                 /* LCOV_EXCL_START */
 661                 TDM_ERR("no capture capability");
 662                 _pthread_mutex_unlock(&private_display->lock);
 663                 return TDM_ERROR_NO_CAPABILITY;
 664                 /* LCOV_EXCL_STOP */
 665         }
 666
 667         capture_module = private_display->capture_module;
 668
 669         if (min_w)
 670                 *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
 671         if (min_h)
 672                 *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
 673         if (max_w)
 674                 *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
 675         if (max_h)
 676                 *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
 677         if (preferred_align)
 678                 *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
 679
 680         _pthread_mutex_unlock(&private_display->lock);
 681
 682         return ret;
 683 }
 684
 685 EXTERN tdm_error
 686 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
 687 {
 688         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 689         TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
 690
 691         TDM_DEPRECATED(NULL);
 692
 693         *max_count = -1;
 694
 695         return TDM_ERROR_NONE;
 696 }
 697
 698 EXTERN tdm_error
 699 tdm_display_get_output_count(tdm_display *dpy, int *count)
 700 {
 701         tdm_private_module *private_module = NULL;
 702         tdm_private_output *private_output = NULL;
 703
 704         DISPLAY_FUNC_ENTRY();
 705
 706         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 707
 708         _pthread_mutex_lock(&private_display->lock);
 709
 710         *count = 0;
 711         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 712                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 713                         (*count)++;
 714                 }
 715         }
 716
 717         _pthread_mutex_unlock(&private_display->lock);
 718
 719         return ret;
 720 }
 721
 722
 723 EXTERN tdm_output *
 724 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 725 {
 726         tdm_private_module *private_module = NULL;
 727         tdm_private_output *private_output = NULL;
 728
 729         DISPLAY_FUNC_ENTRY_ERROR();
 730
 731         _pthread_mutex_lock(&private_display->lock);
 732
 733         if (error)
 734                 *error = TDM_ERROR_NONE;
 735
 736         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 737                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 738                         if (private_output->index == index) {
 739                                 _pthread_mutex_unlock(&private_display->lock);
 740                                 return private_output;
 741                         }
 742                 }
 743         }
 744
 745         _pthread_mutex_unlock(&private_display->lock);
 746
 747         return NULL;
 748 }
 749
 750 EXTERN tdm_output *
 751 tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
 752 {
 753         tdm_private_module *private_module = NULL;
 754         tdm_private_output *private_output = NULL;
 755         tdm_private_output *mode_setted_output = NULL;
 756         tdm_private_output *connected_output = NULL;
 757         unsigned int find_primary = 0;
 758
 759         DISPLAY_FUNC_ENTRY_ERROR();
 760
 761         if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
 762                 find_primary = 1;
 763
 764         _pthread_mutex_lock(&private_display->lock);
 765
 766         if (error)
 767                 *error = TDM_ERROR_NONE;
 768
 769         if (find_primary) {
 770                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 771                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 772                                 if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
 773                                         connected_output = private_output;
 774                                 else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
 775                                         mode_setted_output = private_output;
 776                         }
 777                 }
 778
 779                 if (mode_setted_output) {
 780                         _pthread_mutex_unlock(&private_display->lock);
 781                         return mode_setted_output;
 782                 }
 783
 784                 if (connected_output) {
 785                         _pthread_mutex_unlock(&private_display->lock);
 786                         return connected_output;
 787                 }
 788
 789                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 790                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 791                                 if (private_output->index == 0) {
 792                                         _pthread_mutex_unlock(&private_display->lock);
 793                                         return private_output;
 794                                 }
 795                         }
 796                 }
 797         }
 798
 799         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 800                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 801                         if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
 802                                 continue;
 803                         _pthread_mutex_unlock(&private_display->lock);
 804                         return private_output;
 805                 }
 806         }
 807
 808         if (private_display->virtual_module) {
 809                 private_module = private_display->virtual_module;
 810                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 811                         if (strncmp(private_output->name, name, TDM_NAME_LEN))
 812                                 continue;
 813                         _pthread_mutex_unlock(&private_display->lock);
 814                         return private_output;
 815                 }
 816         }
 817         _pthread_mutex_unlock(&private_display->lock);
 818
 819         return NULL;
 820 }
 821
 822 EXTERN tdm_error
 823 tdm_display_get_fd(tdm_display *dpy, int *fd)
 824 {
 825         DISPLAY_FUNC_ENTRY();
 826
 827         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 828
 829         _pthread_mutex_lock(&private_display->lock);
 830
 831         if (tdm_thread_is_running())
 832                 *fd = tdm_thread_get_fd(private_display->private_loop);
 833         else
 834                 *fd = tdm_event_loop_get_fd(private_display);
 835
 836         _pthread_mutex_unlock(&private_display->lock);
 837
 838         return ret;
 839 }
 840
 841 EXTERN tdm_error
 842 tdm_display_handle_events(tdm_display *dpy)
 843 {
 844         struct pollfd fds;
 845         int fd = -1;
 846
 847         DISPLAY_FUNC_ENTRY();
 848
 849         ret = tdm_display_get_fd(dpy, &fd);
 850         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 851
 852         fds.events = POLLIN;
 853         fds.fd = fd;
 854         fds.revents = 0;
 855
 856         if (tdm_debug_module & TDM_DEBUG_EVENT)
 857                 TDM_INFO("fd(%d) polling in", fd);
 858
 859         while (poll(&fds, 1, -1) < 0) {
 860                 /* LCOV_EXCL_START */
 861                 if (errno == EINTR || errno == EAGAIN)  /* normal case */
 862                         continue;
 863                 else {
 864                         TDM_ERR("poll failed: %m");
 865                         return TDM_ERROR_OPERATION_FAILED;
 866                 }
 867                 /* LCOV_EXCL_STOP */
 868         }
 869
 870         if (tdm_debug_module & TDM_DEBUG_EVENT)
 871                 TDM_INFO("fd(%d) polling out", fd);
 872
 873         if (tdm_thread_is_running()) {
 874                 _pthread_mutex_lock(&private_display->lock);
 875                 ret = tdm_thread_handle_cb(private_display->private_loop);
 876                 _pthread_mutex_unlock(&private_display->lock);
 877         } else {
 878                 ret = tdm_event_loop_dispatch(private_display);
 879         }
 880
 881         return ret;
 882 }
 883
 884 EXTERN void
 885 tdm_display_flush(tdm_display *dpy)
 886 {
 887         tdm_private_display *private_display;
 888
 889         TDM_RETURN_IF_FAIL(dpy != NULL);
 890         private_display = (tdm_private_display*)dpy;
 891
 892         if (tdm_thread_is_running())
 893                 return;
 894
 895         tdm_event_loop_flush(private_display);
 896 }
 897
 898 EXTERN tdm_error
 899 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 900                                                          const char **vendor, int *major, int *minor)
 901 {
 902         tdm_private_module *private_module = NULL;
 903         tdm_backend_module *module_data = NULL;
 904
 905         DISPLAY_FUNC_ENTRY();
 906
 907         TDM_DEPRECATED("Use tdm_module_get_info");
 908
 909         _pthread_mutex_lock(&private_display->lock);
 910
 911         /* use first backend */
 912         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 913                 module_data = private_module->module_data;
 914                 break;
 915         }
 916
 917         assert(module_data != NULL);
 918
 919         if (name)
 920                 *name = module_data->name;
 921         if (vendor)
 922                 *vendor = module_data->vendor;
 923         if (major)
 924                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 925         if (minor)
 926                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 927
 928         _pthread_mutex_unlock(&private_display->lock);
 929
 930         return ret;
 931 }
 932
 933 EXTERN tdm_pp *
 934 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
 935 {
 936         tdm_pp *pp;
 937
 938         DISPLAY_FUNC_ENTRY_ERROR();
 939
 940         _pthread_mutex_lock(&private_display->lock);
 941
 942         pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
 943
 944         _pthread_mutex_unlock(&private_display->lock);
 945
 946         return pp;
 947 }
 948
 949 EXTERN tdm_error
 950 tdm_module_get_info(tdm_module *module, const char **name,
 951                                         const char **vendor, int *major, int *minor)
 952 {
 953         tdm_backend_module *module_data;
 954
 955         BACKEND_FUNC_ENTRY();
 956
 957         _pthread_mutex_lock(&private_display->lock);
 958
 959         module_data = private_module->module_data;
 960
 961         if (name)
 962                 *name = module_data->name;
 963         if (vendor)
 964                 *vendor = module_data->vendor;
 965         if (major)
 966                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 967         if (minor)
 968                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 969
 970         _pthread_mutex_unlock(&private_display->lock);
 971
 972         return ret;
 973 }
 974
 975 INTERN int
 976 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
 977 {
 978         tdm_backend_module *module = private_module->module_data;
 979
 980         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
 981                 return 1;
 982
 983         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
 984                 return 0;
 985
 986         if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
 987                 return 0;
 988
 989         return 1;
 990 }
 991
 992 INTERN tdm_voutput *
 993 tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
 994 {
 995         tdm_private_module *private_module = NULL;
 996         tdm_private_module *current_module = NULL;
 997         tdm_private_voutput *private_voutput = NULL;
 998         tdm_private_output *private_output = NULL;
 999         tdm_func_display *func_display = NULL;
1000         tdm_func_voutput *func_voutput = NULL;
1001         tdm_voutput *voutput_backend = NULL;
1002         tdm_output *output_backend = NULL;
1003         int output_find = 0;
1004         tdm_private_display *private_display;
1005         tdm_error ret = TDM_ERROR_NONE;
1006
1007         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
1008         private_display = (tdm_private_display*)dpy;
1009         private_module = private_display->virtual_module;
1010         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
1011
1012         _pthread_mutex_lock(&private_display->lock);
1013
1014         if (error) *error = TDM_ERROR_NONE;
1015
1016         private_voutput = calloc(1, sizeof(tdm_private_voutput));
1017         if (!private_voutput) {
1018                 if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
1019                 _pthread_mutex_unlock(&private_display->lock);
1020                 return NULL;
1021         }
1022
1023         func_display = &private_module->func_display;
1024         func_voutput = &private_module->func_voutput;
1025         current_module = private_display->current_module;
1026         private_display->current_module = private_module;
1027
1028         voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
1029
1030         if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
1031                 TDM_ERR("display_voutput_create fail");
1032                 free(private_voutput);
1033                 if (error) *error = ret;
1034                 private_display->current_module = current_module;
1035                 _pthread_mutex_unlock(&private_display->lock);
1036                 return NULL;
1037         }
1038         private_voutput->voutput_backend = voutput_backend;
1039         private_voutput->private_display = private_display;
1040         private_voutput->private_module = private_module;
1041         LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
1042
1043         output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
1044         if (output_backend == NULL || ret != TDM_ERROR_NONE) {
1045                 TDM_ERR("voutput_get_output fail");
1046                 free(private_voutput);
1047                 if (error) *error = ret;
1048                 if (func_voutput->voutput_destroy)
1049                         func_voutput->voutput_destroy(voutput_backend);
1050                 else
1051                         TDM_ERR("no destroy function");
1052                 private_display->current_module = current_module;
1053                 _pthread_mutex_unlock(&private_display->lock);
1054                 return NULL;
1055         }
1056
1057         ret = tdm_display_update_output(private_display->current_module, output_backend);
1058         if (ret != TDM_ERROR_NONE) {
1059                 TDM_ERR("tdm_display_update_output fail");
1060                 free(private_voutput);
1061                 if (func_voutput->voutput_destroy)
1062                         func_voutput->voutput_destroy(voutput_backend);
1063                 else
1064                         TDM_ERR("no destroy function");
1065                 if (error) *error = ret;
1066                 private_display->current_module = current_module;
1067                 _pthread_mutex_unlock(&private_display->lock);
1068                 return NULL;
1069         }
1070
1071         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
1072                 if (private_output->output_backend == output_backend) {
1073                         output_find = 1;
1074                         break;
1075                 }
1076         }
1077
1078         if (output_find != 1) {
1079                 private_output = NULL;
1080                 free(private_voutput);
1081                 if (func_voutput->voutput_destroy)
1082                         func_voutput->voutput_destroy(voutput_backend);
1083                 else
1084                         TDM_ERR("no destroy function");
1085                 private_voutput = NULL;
1086         } else {
1087                 strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
1088                 private_voutput->name[TDM_NAME_LEN - 1] = '\0';
1089                 strncpy(private_output->name, name, TDM_NAME_LEN - 1);
1090                 private_output->name[TDM_NAME_LEN - 1] = '\0';
1091
1092                 private_voutput->private_output = private_output;
1093                 private_output->private_voutput = private_voutput;
1094
1095                 /* do not use vblank */
1096                 tdm_output_choose_commit_per_vblank_mode(private_output, 0);
1097
1098                 LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
1099         }
1100
1101         private_display->current_module = current_module;
1102
1103         _pthread_mutex_unlock(&private_display->lock);
1104
1105         return private_voutput;
1106 }