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 DISPLAY_FUNC_ENTRY_VOID() \
  57         tdm_private_display *private_display; \
  58         TDM_RETURN_IF_FAIL(dpy != NULL); \
  59         TDM_RETURN_IF_FAIL(tdm_display_is_valid(dpy)); \
  60         private_display = (tdm_private_display*)dpy;
  61
  62
  63 #define BACKEND_FUNC_ENTRY() \
  64         tdm_private_module *private_module; \
  65         tdm_private_display *private_display; \
  66         tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
  67         TDM_RETURN_VAL_IF_FAIL(module != NULL, TDM_ERROR_INVALID_PARAMETER); \
  68         private_module = (tdm_private_module*)module; \
  69         private_display = private_module->private_display;
  70
  71 /* LCOV_EXCL_START */
  72 INTERN tdm_error
  73 tdm_display_enable_debug_module(const char*modules)
  74 {
  75         char temp[TDM_PATH_LEN];
  76         char *arg;
  77         char *end;
  78
  79         snprintf(temp, TDM_PATH_LEN, "%s", modules);
  80
  81         tdm_debug_module = 0;
  82
  83         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
  84         while (arg) {
  85                 if (!strncmp(arg, "none", 4)) {
  86                         tdm_debug_module = 0;
  87                         return TDM_ERROR_NONE;
  88                 }
  89                 if (!strncmp(arg, "all", 3)) {
  90                         tdm_debug_module = 0xFFFFFFFF;
  91                         return TDM_ERROR_NONE;
  92                 }
  93                 if (!strncmp(arg, "buffer", 6))
  94                         tdm_debug_module |= TDM_DEBUG_BUFFER;
  95                 else if (!strncmp(arg, "event", 5))
  96                         tdm_debug_module |= TDM_DEBUG_EVENT;
  97                 else if (!strncmp(arg, "thread", 6))
  98                         tdm_debug_module |= TDM_DEBUG_THREAD;
  99                 else if (!strncmp(arg, "mutex", 5))
 100                         tdm_debug_module |= TDM_DEBUG_MUTEX;
 101                 else if (!strncmp(arg, "vblank", 6))
 102                         tdm_debug_module |= TDM_DEBUG_VBLANK;
 103                 else if (!strncmp(arg, "commit", 6))
 104                         tdm_debug_module |= TDM_DEBUG_COMMIT;
 105
 106                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 107         }
 108
 109         TDM_INFO("module debugging... '%s'", modules);
 110
 111         return TDM_ERROR_NONE;
 112 }
 113
 114 INTERN tdm_error
 115 tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
 116 {
 117         char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
 118         char *path = NULL, *path2;
 119         char *arg;
 120         char *end;
 121
 122         snprintf(temp2, TDM_PATH_LEN, "%s", dump_str);
 123         path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@");
 124         if (!path2 || path2[0] == '\0')
 125                 path2 = TDM_DUMP_DIR;
 126         else
 127                 path2++;
 128
 129         tdm_debug_dump = 0;
 130
 131         snprintf(temp, sizeof(temp), "%s", dump_str);
 132         arg = strtok_r(temp, ",", &end);
 133         TDM_GOTO_IF_FAIL(arg != NULL, done);
 134
 135         if (!strncmp(arg, "none", 4)) {
 136                 tdm_debug_dump = 0;
 137                 TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown");
 138                 if (tdm_debug_dump_dir) {
 139                         free(tdm_debug_dump_dir);
 140                         tdm_debug_dump_dir = NULL;
 141                 }
 142                 goto done;
 143         }
 144
 145         path = tdm_helper_dump_make_directory(path2, reply, len);
 146         TDM_GOTO_IF_FAIL(path != NULL, done);
 147
 148         if (!strncmp(arg, "current", 7)) {
 149                 tdm_private_module *b = NULL;
 150                 tdm_private_output *o = NULL;
 151
 152                 if (!private_display) {
 153                         TDM_WRN("no private_display");
 154                         goto done;
 155                 }
 156
 157                 LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) {
 158                         LIST_FOR_EACH_ENTRY(o, &b->output_list, link) {
 159                                 tdm_private_layer *l = NULL;
 160                                 LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) {
 161                                         char str[TDM_PATH_LEN];
 162                                         if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO)
 163                                                 continue;
 164                                         if (!l->showing_buffer)
 165                                                 continue;
 166                                         snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index);
 167                                         tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str);
 168                                 }
 169                         }
 170                 }
 171
 172                 TDM_SNPRINTF(reply, len, "path: %s\n", path);
 173                 goto done;
 174         }
 175
 176         TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
 177
 178         while (arg) {
 179                 if (!strncmp(arg, "all", 3)) {
 180                         tdm_debug_dump = 0xFFFFFFFF;
 181                         goto done;
 182                 } else if (!strncmp(arg, "layer", 5)) {
 183                         tdm_debug_dump |= TDM_DUMP_FLAG_LAYER;
 184                 } else if (!strncmp(arg, "pp", 2)) {
 185                         tdm_debug_dump |= TDM_DUMP_FLAG_PP;
 186                 } else if (!strncmp(arg, "capture", 7)) {
 187                         tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE;
 188                 } else if (!strncmp(arg, "window", 6)) {
 189                         tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW;
 190                 } else
 191                         goto done;
 192
 193                 arg = strtok_r(NULL, ",", &end);
 194         }
 195
 196         if (tdm_debug_dump_dir)
 197                 free(tdm_debug_dump_dir);
 198
 199         tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
 200
 201         TDM_INFO("dump... '%s'", dump_str);
 202
 203 done:
 204         if (path)
 205                 free(path);
 206
 207         return TDM_ERROR_NONE;
 208 }
 209
 210 static void
 211 _tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence,
 212                                                           unsigned int tv_sec, unsigned int tv_usec, void *user_data)
 213 {
 214         tdm_error ret = TDM_ERROR_NONE;
 215
 216         TDM_TRACE_MARK("VSYNC");
 217
 218         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 219         TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
 220 }
 221
 222 INTERN tdm_error
 223 tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
 224 {
 225         tdm_private_display *private_display = dpy;
 226         tdm_private_module *private_module = NULL;
 227         tdm_private_output *private_output = NULL;
 228         const tdm_output_mode *mode = NULL;
 229         tdm_vblank *vblank = NULL;
 230         tdm_error ret = TDM_ERROR_NONE;
 231
 232         if (!enable) {
 233                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 234                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 235                                 if (private_output->ttrace_vblank)
 236                                         tdm_vblank_destroy(private_output->ttrace_vblank);
 237                                 private_output->ttrace_vblank = NULL;
 238                         }
 239                 }
 240                 return TDM_ERROR_NONE;
 241         }
 242
 243         private_output = output;
 244         TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
 245
 246         if (private_output->ttrace_vblank)
 247                 return TDM_ERROR_NONE;
 248
 249         vblank = tdm_vblank_create(private_display, output, &ret);
 250         TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
 251
 252         ret = tdm_output_get_mode(output, &mode);
 253         TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
 254
 255         ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
 256         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 257
 258         ret = tdm_vblank_set_enable_fake(vblank, 1);
 259         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 260
 261         ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
 262         TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
 263
 264         private_output->ttrace_vblank = vblank;
 265
 266         return TDM_ERROR_NONE;
 267
 268 enable_fail:
 269         if (vblank)
 270                 tdm_vblank_destroy(vblank);
 271
 272         return ret;
 273 }
 274
 275 INTERN tdm_error
 276 tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
 277 {
 278         char temp[TDM_PATH_LEN];
 279         char *arg;
 280         char *end;
 281         tdm_output *output;
 282         tdm_error ret;
 283         tdm_output_type type;
 284
 285         snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
 286
 287         tdm_ttrace_output = output_id;
 288         tdm_ttrace_module = 0;
 289
 290         output = tdm_display_get_output(private_display, output_id, &ret);
 291         if (!output) {
 292                 TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
 293                 return ret;
 294         }
 295
 296         ret = tdm_output_get_output_type(output, &type);
 297         if (ret != TDM_ERROR_NONE) {
 298                 TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id);
 299                 return ret;
 300         }
 301
 302         arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
 303         while (arg) {
 304                 if (!strncmp(arg, "none", 4))
 305                         tdm_ttrace_module = 0;
 306                 else if (!strncmp(arg, "all", 3))
 307                         tdm_ttrace_module = 0xFFFFFFFF;
 308                 else if (!strncmp(arg, "vsync", 5))
 309                         tdm_ttrace_module |= TDM_TTRACE_VSYNC;
 310                 else if (!strncmp(arg, "client_vblank", 13))
 311                         tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK;
 312                 else if (!strncmp(arg, "server_vblank", 13))
 313                         tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK;
 314                 else if (!strncmp(arg, "vblank", 6))
 315                         tdm_ttrace_module |= TDM_TTRACE_VBLANK;
 316                 else if (!strncmp(arg, "layer", 5))
 317                         tdm_ttrace_module |= TDM_TTRACE_LAYER;
 318                 else if (!strncmp(arg, "pp", 2))
 319                         tdm_ttrace_module |= TDM_TTRACE_PP;
 320                 else if (!strncmp(arg, "capture", 7))
 321                         tdm_ttrace_module |= TDM_TTRACE_CAPTURE;
 322                 else  {
 323                         tdm_ttrace_module = 0;
 324                         tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 325                         tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 326                         TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg);
 327                         return TDM_ERROR_NONE;
 328                 }
 329
 330                 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
 331         }
 332
 333         TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
 334
 335         if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
 336                 tdm_display_enable_ttrace_vblank(private_display, output, 1);
 337         else
 338                 tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
 339
 340         if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
 341                 tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
 342         else
 343                 tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
 344
 345         return TDM_ERROR_NONE;
 346 }
 347
 348 INTERN tdm_error
 349 tdm_display_enable_fps(tdm_private_display *private_display, int enable)
 350 {
 351         private_display->print_fps = enable;
 352
 353         TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
 354
 355         return TDM_ERROR_NONE;
 356 }
 357 /* LCOV_EXCL_STOP */
 358
 359 INTERN tdm_error
 360 tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
 361 {
 362         tdm_thread_cb_display_output_create output_create;
 363         tdm_error ret;
 364
 365         memset(&output_create, 0, sizeof output_create);
 366         output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE;
 367         output_create.base.length = sizeof output_create;
 368         output_create.base.object_stamp = 0;
 369         output_create.base.data = NULL;
 370         output_create.base.sync = 1;
 371         output_create.output = output;
 372
 373         ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
 374         TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
 375
 376         return TDM_ERROR_NONE;
 377 }
 378
 379 INTERN void
 380 tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
 381 {
 382         tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base;
 383         tdm_private_output_create_handler *create_handler = user_data;
 384         TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
 385
 386         assert(create_handler->owner_tid == syscall(SYS_gettid));
 387
 388         _pthread_mutex_unlock(&private_display->lock);
 389         create_handler->func(private_display, output_create->output, create_handler->user_data);
 390         _pthread_mutex_lock(&private_display->lock);
 391 }
 392
 393 EXTERN tdm_error
 394 tdm_display_add_output_create_handler(tdm_display *dpy,
 395                                                                           tdm_output_create_handler func,
 396                                                                           void *user_data)
 397 {
 398         tdm_private_output_create_handler *create_handler = NULL;
 399
 400         DISPLAY_FUNC_ENTRY();
 401
 402         TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
 403
 404         _pthread_mutex_lock(&private_display->lock);
 405
 406         LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) {
 407                 if (create_handler->func == func && create_handler->user_data == user_data) {
 408                         TDM_ERR("can't add twice");
 409                         _pthread_mutex_unlock(&private_display->lock);
 410                         return TDM_ERROR_BAD_REQUEST;
 411                 }
 412         }
 413
 414         create_handler = calloc(1, sizeof(tdm_private_output_create_handler));
 415         if (!create_handler) {
 416                 TDM_ERR("failed: alloc memory");
 417                 _pthread_mutex_unlock(&private_display->lock);
 418                 return TDM_ERROR_OUT_OF_MEMORY;
 419         }
 420
 421         ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
 422                                                         tdm_display_thread_cb_output_create, create_handler);
 423         if (ret != TDM_ERROR_NONE) {
 424                 TDM_ERR("tdm_thread_cb_add failed");
 425                 free(create_handler);
 426                 _pthread_mutex_unlock(&private_display->lock);
 427                 return TDM_ERROR_OPERATION_FAILED;
 428         }
 429
 430         create_handler->private_display = private_display;
 431         create_handler->func = func;
 432         create_handler->user_data = user_data;
 433         create_handler->owner_tid = syscall(SYS_gettid);
 434
 435         LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
 436
 437         _pthread_mutex_unlock(&private_display->lock);
 438
 439         return ret;
 440 }
 441
 442 EXTERN void
 443 tdm_display_remove_output_create_handler(tdm_display *dpy,
 444                                                                                  tdm_output_create_handler func,
 445                                                                                  void *user_data)
 446 {
 447         tdm_private_display *private_display;
 448         tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
 449
 450         TDM_RETURN_IF_FAIL(dpy != NULL);
 451         TDM_RETURN_IF_FAIL(func != NULL);
 452
 453         private_display = (tdm_private_display*)dpy;
 454
 455         _pthread_mutex_lock(&private_display->lock);
 456
 457         LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) {
 458                 if (create_handler->func != func || create_handler->user_data != user_data)
 459                         continue;
 460
 461                 tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
 462                                                          tdm_display_thread_cb_output_create, create_handler);
 463
 464                 LIST_DEL(&create_handler->link);
 465                 free(create_handler);
 466
 467                 _pthread_mutex_unlock(&private_display->lock);
 468
 469                 return;
 470         }
 471
 472         _pthread_mutex_unlock(&private_display->lock);
 473 }
 474
 475 EXTERN tdm_error
 476 tdm_display_get_capabilities(tdm_display *dpy,
 477                                                          tdm_display_capability *capabilities)
 478 {
 479         tdm_private_module *private_module = NULL;
 480
 481         DISPLAY_FUNC_ENTRY();
 482
 483         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 484
 485         _pthread_mutex_lock(&private_display->lock);
 486
 487         *capabilities = 0;
 488
 489         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 490                 *capabilities |= private_module->capabilities;
 491         }
 492
 493         _pthread_mutex_unlock(&private_display->lock);
 494
 495         return ret;
 496 }
 497
 498 EXTERN tdm_error
 499 tdm_display_get_pp_capabilities(tdm_display *dpy,
 500                                                                 tdm_pp_capability *capabilities)
 501 {
 502         tdm_private_module *pp_module;
 503
 504         DISPLAY_FUNC_ENTRY();
 505
 506         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 507
 508         _pthread_mutex_lock(&private_display->lock);
 509
 510         if (!private_display->pp_module) {
 511                 /* LCOV_EXCL_START */
 512                 TDM_ERR("no pp capability");
 513                 _pthread_mutex_unlock(&private_display->lock);
 514                 return TDM_ERROR_NO_CAPABILITY;
 515                 /* LCOV_EXCL_STOP */
 516         }
 517
 518         pp_module = private_display->pp_module;
 519
 520         *capabilities = pp_module->caps_pp.capabilities;
 521
 522         _pthread_mutex_unlock(&private_display->lock);
 523
 524         return ret;
 525 }
 526
 527 EXTERN tdm_error
 528 tdm_display_get_pp_available_formats(tdm_display *dpy,
 529                                                                          const tbm_format **formats, int *count)
 530 {
 531         tdm_private_module *pp_module;
 532
 533         DISPLAY_FUNC_ENTRY();
 534
 535         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 536         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 537
 538         _pthread_mutex_lock(&private_display->lock);
 539
 540         if (!private_display->pp_module) {
 541                 /* LCOV_EXCL_START */
 542                 TDM_ERR("no pp capability");
 543                 _pthread_mutex_unlock(&private_display->lock);
 544                 return TDM_ERROR_NO_CAPABILITY;
 545                 /* LCOV_EXCL_STOP */
 546         }
 547
 548         pp_module = private_display->pp_module;
 549
 550         *formats = (const tbm_format *)pp_module->caps_pp.formats;
 551         *count = pp_module->caps_pp.format_count;
 552
 553         _pthread_mutex_unlock(&private_display->lock);
 554
 555         return ret;
 556 }
 557
 558 EXTERN tdm_error
 559 tdm_display_get_pp_available_size(tdm_display *dpy, int *min_w, int *min_h,
 560                                                                   int *max_w, int *max_h, int *preferred_align)
 561 {
 562         tdm_private_module *pp_module;
 563
 564         DISPLAY_FUNC_ENTRY();
 565
 566         _pthread_mutex_lock(&private_display->lock);
 567
 568         if (!private_display->pp_module) {
 569                 /* LCOV_EXCL_START */
 570                 TDM_ERR("no pp capability");
 571                 _pthread_mutex_unlock(&private_display->lock);
 572                 return TDM_ERROR_NO_CAPABILITY;
 573                 /* LCOV_EXCL_STOP */
 574         }
 575
 576         pp_module = private_display->pp_module;
 577
 578         if (min_w)
 579                 *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
 580         if (min_h)
 581                 *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
 582         if (max_w)
 583                 *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
 584         if (max_h)
 585                 *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
 586         if (preferred_align)
 587                 *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
 588
 589         _pthread_mutex_unlock(&private_display->lock);
 590
 591         return ret;
 592 }
 593
 594 EXTERN tdm_error
 595 tdm_display_get_capture_capabilities(tdm_display *dpy,
 596                                                                          tdm_capture_capability *capabilities)
 597 {
 598         tdm_private_module *capture_module;
 599
 600         DISPLAY_FUNC_ENTRY();
 601
 602         TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
 603
 604         _pthread_mutex_lock(&private_display->lock);
 605
 606         if (!private_display->capture_module) {
 607                 /* LCOV_EXCL_START */
 608                 TDM_ERR("no capture capability");
 609                 _pthread_mutex_unlock(&private_display->lock);
 610                 return TDM_ERROR_NO_CAPABILITY;
 611                 /* LCOV_EXCL_STOP */
 612         }
 613
 614         capture_module = private_display->capture_module;
 615
 616         *capabilities = capture_module->caps_capture.capabilities;
 617
 618         _pthread_mutex_unlock(&private_display->lock);
 619
 620         return ret;
 621 }
 622
 623 EXTERN tdm_error
 624 tdm_display_get_capture_available_formats(tdm_display *dpy,
 625                 const tbm_format **formats, int *count)
 626 {
 627         tdm_private_module *capture_module;
 628
 629         DISPLAY_FUNC_ENTRY();
 630
 631         TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
 632         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 633
 634         _pthread_mutex_lock(&private_display->lock);
 635
 636         if (!private_display->capture_module) {
 637                 /* LCOV_EXCL_START */
 638                 TDM_ERR("no capture capability");
 639                 _pthread_mutex_unlock(&private_display->lock);
 640                 return TDM_ERROR_NO_CAPABILITY;
 641                 /* LCOV_EXCL_STOP */
 642         }
 643
 644         capture_module = private_display->capture_module;
 645
 646         *formats = (const tbm_format *)capture_module->caps_capture.formats;
 647         *count = capture_module->caps_capture.format_count;
 648
 649         _pthread_mutex_unlock(&private_display->lock);
 650
 651         return ret;
 652 }
 653
 654 EXTERN tdm_error
 655 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
 656                                                                            int *max_w, int *max_h, int *preferred_align)
 657 {
 658         tdm_private_module *capture_module;
 659
 660         DISPLAY_FUNC_ENTRY();
 661
 662         _pthread_mutex_lock(&private_display->lock);
 663
 664         if (!private_display->capture_module) {
 665                 /* LCOV_EXCL_START */
 666                 TDM_ERR("no capture capability");
 667                 _pthread_mutex_unlock(&private_display->lock);
 668                 return TDM_ERROR_NO_CAPABILITY;
 669                 /* LCOV_EXCL_STOP */
 670         }
 671
 672         capture_module = private_display->capture_module;
 673
 674         if (min_w)
 675                 *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
 676         if (min_h)
 677                 *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
 678         if (max_w)
 679                 *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
 680         if (max_h)
 681                 *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
 682         if (preferred_align)
 683                 *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
 684
 685         _pthread_mutex_unlock(&private_display->lock);
 686
 687         return ret;
 688 }
 689
 690 EXTERN tdm_error
 691 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
 692 {
 693         TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
 694         TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
 695
 696         TDM_DEPRECATED(NULL);
 697
 698         *max_count = -1;
 699
 700         return TDM_ERROR_NONE;
 701 }
 702
 703 EXTERN tdm_error
 704 tdm_display_get_output_count(tdm_display *dpy, int *count)
 705 {
 706         tdm_private_module *private_module = NULL;
 707         tdm_private_output *private_output = NULL;
 708
 709         DISPLAY_FUNC_ENTRY();
 710
 711         TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
 712
 713         _pthread_mutex_lock(&private_display->lock);
 714
 715         *count = 0;
 716         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 717                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 718                         (*count)++;
 719                 }
 720         }
 721
 722         _pthread_mutex_unlock(&private_display->lock);
 723
 724         return ret;
 725 }
 726
 727
 728 EXTERN tdm_output *
 729 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
 730 {
 731         tdm_private_module *private_module = NULL;
 732         tdm_private_output *private_output = NULL;
 733
 734         DISPLAY_FUNC_ENTRY_ERROR();
 735
 736         _pthread_mutex_lock(&private_display->lock);
 737
 738         if (error)
 739                 *error = TDM_ERROR_NONE;
 740
 741         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 742                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 743                         if (private_output->index == index) {
 744                                 _pthread_mutex_unlock(&private_display->lock);
 745                                 return private_output;
 746                         }
 747                 }
 748         }
 749
 750         _pthread_mutex_unlock(&private_display->lock);
 751
 752         return NULL;
 753 }
 754
 755 EXTERN tdm_output *
 756 tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
 757 {
 758         tdm_private_module *private_module = NULL;
 759         tdm_private_output *private_output = NULL;
 760         tdm_private_output *mode_setted_output = NULL;
 761         tdm_private_output *connected_output = NULL;
 762         unsigned int find_primary = 0;
 763
 764         DISPLAY_FUNC_ENTRY_ERROR();
 765
 766         if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
 767                 find_primary = 1;
 768
 769         _pthread_mutex_lock(&private_display->lock);
 770
 771         if (error)
 772                 *error = TDM_ERROR_NONE;
 773
 774         if (find_primary) {
 775                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 776                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 777                                 if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
 778                                         connected_output = private_output;
 779                                 else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
 780                                         mode_setted_output = private_output;
 781                         }
 782                 }
 783
 784                 if (mode_setted_output) {
 785                         _pthread_mutex_unlock(&private_display->lock);
 786                         return mode_setted_output;
 787                 }
 788
 789                 if (connected_output) {
 790                         _pthread_mutex_unlock(&private_display->lock);
 791                         return connected_output;
 792                 }
 793
 794                 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 795                         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 796                                 if (private_output->index == 0) {
 797                                         _pthread_mutex_unlock(&private_display->lock);
 798                                         return private_output;
 799                                 }
 800                         }
 801                 }
 802         }
 803
 804         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 805                 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 806                         if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
 807                                 continue;
 808                         _pthread_mutex_unlock(&private_display->lock);
 809                         return private_output;
 810                 }
 811         }
 812
 813         _pthread_mutex_unlock(&private_display->lock);
 814
 815         return NULL;
 816 }
 817
 818 INTERN tdm_output *
 819 tdm_display_create_output(tdm_display *dpy, const char *name, tdm_error *error)
 820 {
 821         tdm_private_module *private_module = NULL;
 822         tdm_private_module *current_module = NULL;
 823         tdm_private_output *private_output = NULL;
 824         tdm_func_display *func_display = NULL;
 825         tdm_output *output = NULL;
 826         int output_find = 0;
 827
 828         DISPLAY_FUNC_ENTRY_ERROR();
 829
 830         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
 831         private_display = (tdm_private_display*)dpy;
 832
 833         private_module = private_display->virtual_module;
 834         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
 835
 836         _pthread_mutex_lock(&private_display->lock);
 837
 838         if (error)
 839                 *error = TDM_ERROR_NONE;
 840
 841         func_display = &private_module->func_display;
 842         current_module = private_display->current_module;
 843         private_display->current_module = private_module;
 844         output = func_display->display_output_create(private_module->bdata, name, &ret);
 845         LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
 846                 if (private_output->output_backend == output) {
 847                         output_find = 1;
 848                         break;
 849                 }
 850         }
 851         private_display->current_module = current_module;
 852
 853         _pthread_mutex_unlock(&private_display->lock);
 854
 855         TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, ret, NULL);
 856         if (output_find != 1)
 857                 private_output = NULL;
 858
 859         return private_output;
 860 }
 861
 862 INTERN tdm_error
 863 tdm_display_destroy_output(tdm_display *dpy, tdm_output *output)
 864 {
 865         tdm_private_module *private_module = NULL;
 866         tdm_private_module *current_module = NULL;
 867         tdm_private_output *private_output = NULL;
 868         tdm_func_display *func_display = NULL;
 869
 870         DISPLAY_FUNC_ENTRY();
 871
 872         TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
 873         private_display = (tdm_private_display*)dpy;
 874
 875         private_module = private_display->virtual_module;
 876         TDM_RETURN_VAL_IF_FAIL(private_module != NULL, TDM_ERROR_BAD_MODULE);
 877
 878         private_output = (tdm_private_output*)output;
 879
 880         _pthread_mutex_lock(&private_display->lock);
 881
 882         func_display = &private_module->func_display;
 883         current_module = private_display->current_module;
 884         private_display->current_module = private_module;
 885         ret = func_display->display_output_destroy(private_module->bdata, private_output->output_backend);
 886         private_display->current_module = current_module;
 887
 888         _pthread_mutex_unlock(&private_display->lock);
 889
 890         return ret;
 891 }
 892
 893 EXTERN tdm_error
 894 tdm_display_get_fd(tdm_display *dpy, int *fd)
 895 {
 896         DISPLAY_FUNC_ENTRY();
 897
 898         TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
 899
 900         _pthread_mutex_lock(&private_display->lock);
 901
 902         if (tdm_thread_is_running())
 903                 *fd = tdm_thread_get_fd(private_display->private_loop);
 904         else
 905                 *fd = tdm_event_loop_get_fd(private_display);
 906
 907         _pthread_mutex_unlock(&private_display->lock);
 908
 909         return ret;
 910 }
 911
 912 EXTERN tdm_error
 913 tdm_display_handle_events(tdm_display *dpy)
 914 {
 915         struct pollfd fds;
 916         int fd = -1;
 917
 918         DISPLAY_FUNC_ENTRY();
 919
 920         ret = tdm_display_get_fd(dpy, &fd);
 921         TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
 922
 923         fds.events = POLLIN;
 924         fds.fd = fd;
 925         fds.revents = 0;
 926
 927         if (tdm_debug_module & TDM_DEBUG_EVENT)
 928                 TDM_INFO("fd(%d) polling in", fd);
 929
 930         while (poll(&fds, 1, -1) < 0) {
 931                 /* LCOV_EXCL_START */
 932                 if (errno == EINTR || errno == EAGAIN)  /* normal case */
 933                         continue;
 934                 else {
 935                         TDM_ERR("poll failed: %m");
 936                         return TDM_ERROR_OPERATION_FAILED;
 937                 }
 938                 /* LCOV_EXCL_STOP */
 939         }
 940
 941         if (tdm_debug_module & TDM_DEBUG_EVENT)
 942                 TDM_INFO("fd(%d) polling out", fd);
 943
 944         if (tdm_thread_is_running()) {
 945                 _pthread_mutex_lock(&private_display->lock);
 946                 ret = tdm_thread_handle_cb(private_display->private_loop);
 947                 _pthread_mutex_unlock(&private_display->lock);
 948         } else {
 949                 ret = tdm_event_loop_dispatch(private_display);
 950         }
 951
 952         return ret;
 953 }
 954
 955 EXTERN void
 956 tdm_display_flush(tdm_display *dpy)
 957 {
 958         tdm_private_display *private_display;
 959
 960         TDM_RETURN_IF_FAIL(dpy != NULL);
 961         private_display = (tdm_private_display*)dpy;
 962
 963         if (tdm_thread_is_running())
 964                 return;
 965
 966         tdm_event_loop_flush(private_display);
 967 }
 968
 969 EXTERN tdm_error
 970 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
 971                                                          const char **vendor, int *major, int *minor)
 972 {
 973         tdm_private_module *private_module = NULL;
 974         tdm_backend_module *module_data = NULL;
 975
 976         DISPLAY_FUNC_ENTRY();
 977
 978         TDM_DEPRECATED("Use tdm_module_get_info");
 979
 980         _pthread_mutex_lock(&private_display->lock);
 981
 982         /* use first backend */
 983         LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
 984                 module_data = private_module->module_data;
 985                 break;
 986         }
 987
 988         assert(module_data != NULL);
 989
 990         if (name)
 991                 *name = module_data->name;
 992         if (vendor)
 993                 *vendor = module_data->vendor;
 994         if (major)
 995                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
 996         if (minor)
 997                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
 998
 999         _pthread_mutex_unlock(&private_display->lock);
1000
1001         return ret;
1002 }
1003
1004 EXTERN tdm_pp *
1005 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
1006 {
1007         tdm_pp *pp;
1008
1009         DISPLAY_FUNC_ENTRY_ERROR();
1010
1011         _pthread_mutex_lock(&private_display->lock);
1012
1013         pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
1014
1015         _pthread_mutex_unlock(&private_display->lock);
1016
1017         return pp;
1018 }
1019
1020 EXTERN tdm_error
1021 tdm_module_get_info(tdm_module *module, const char **name,
1022                                         const char **vendor, int *major, int *minor)
1023 {
1024         tdm_backend_module *module_data;
1025
1026         BACKEND_FUNC_ENTRY();
1027
1028         _pthread_mutex_lock(&private_display->lock);
1029
1030         module_data = private_module->module_data;
1031
1032         if (name)
1033                 *name = module_data->name;
1034         if (vendor)
1035                 *vendor = module_data->vendor;
1036         if (major)
1037                 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
1038         if (minor)
1039                 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
1040
1041         _pthread_mutex_unlock(&private_display->lock);
1042
1043         return ret;
1044 }
1045
1046 INTERN int
1047 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
1048 {
1049         tdm_backend_module *module = private_module->module_data;
1050
1051         if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
1052                 return 0;
1053
1054         if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
1055                 return 0;
1056
1057         return 1;
1058 }
1059