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