1 /**************************************************************************
5 * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved.
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>
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:
22 * The above copyright notice and this permission notice (including the
23 * next paragraph) shall be included in all copies or substantial portions
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.
34 **************************************************************************/
40 #include "tdm_private.h"
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;
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;
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;
66 tdm_display_enable_debug_module(const char*modules)
68 char temp[TDM_PATH_LEN];
72 snprintf(temp, TDM_PATH_LEN, "%s", modules);
76 arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
78 if (!strncmp(arg, "none", 4)) {
80 return TDM_ERROR_NONE;
82 if (!strncmp(arg, "all", 3)) {
83 tdm_debug_module = 0xFFFFFFFF;
84 return TDM_ERROR_NONE;
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;
99 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
102 TDM_INFO("module debugging... '%s'", modules);
104 return TDM_ERROR_NONE;
108 tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len)
110 char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,};
111 char *path = NULL, *path2;
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;
124 snprintf(temp, sizeof(temp), "%s", dump_str);
125 arg = strtok_r(temp, ",", &end);
126 TDM_GOTO_IF_FAIL(arg != NULL, done);
128 if (!strncmp(arg, "none", 4)) {
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;
138 path = tdm_helper_dump_make_directory(path2, reply, len);
139 TDM_GOTO_IF_FAIL(path != NULL, done);
141 if (!strncmp(arg, "current", 7)) {
142 tdm_private_module *b = NULL;
143 tdm_private_output *o = NULL;
145 if (!private_display) {
146 TDM_WRN("no private_display");
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)
157 if (!l->showing_buffer)
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);
165 TDM_SNPRINTF(reply, len, "path: %s\n", path);
169 TDM_SNPRINTF(reply, len, "dump: %s\n", arg);
172 if (!strncmp(arg, "all", 3)) {
173 tdm_debug_dump = 0xFFFFFFFF;
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;
186 arg = strtok_r(NULL, ",", &end);
189 if (tdm_debug_dump_dir)
190 free(tdm_debug_dump_dir);
192 tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN);
194 TDM_INFO("dump... '%s'", dump_str);
200 return TDM_ERROR_NONE;
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)
207 tdm_error ret = TDM_ERROR_NONE;
209 TDM_TRACE_MARK("VSYNC");
211 ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL);
212 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
216 tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable)
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;
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;
233 return TDM_ERROR_NONE;
236 private_output = output;
237 TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER);
239 if (private_output->ttrace_vblank)
240 return TDM_ERROR_NONE;
242 vblank = tdm_vblank_create(private_display, output, &ret);
243 TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret);
245 ret = tdm_output_get_mode(output, &mode);
246 TDM_GOTO_IF_FAIL(mode != NULL, enable_fail);
248 ret = tdm_vblank_set_fps(vblank, mode->vrefresh);
249 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
251 ret = tdm_vblank_set_enable_fake(vblank, 1);
252 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail);
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);
257 private_output->ttrace_vblank = vblank;
259 return TDM_ERROR_NONE;
263 tdm_vblank_destroy(vblank);
269 tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len)
271 char temp[TDM_PATH_LEN];
276 tdm_output_type type;
278 snprintf(temp, TDM_PATH_LEN, "%s", ttrace);
280 tdm_ttrace_output = output_id;
281 tdm_ttrace_module = 0;
283 output = tdm_display_get_output(private_display, output_id, &ret);
285 TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id);
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);
295 arg = strtok_r(temp, TDM_CONFIG_DELIM, &end);
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;
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;
323 arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end);
326 TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module);
328 if (tdm_ttrace_module & TDM_TTRACE_VSYNC)
329 tdm_display_enable_ttrace_vblank(private_display, output, 1);
331 tdm_display_enable_ttrace_vblank(private_display, NULL, 0);
333 if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK)
334 tdm_server_enable_ttrace_client_vblank(private_display, output, 1);
336 tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0);
338 return TDM_ERROR_NONE;
342 tdm_display_enable_fps(tdm_private_display *private_display, int enable)
344 private_display->print_fps = enable;
346 TDM_INFO("print fps: %s", (enable) ? "enable" : "disable");
348 return TDM_ERROR_NONE;
353 tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output)
355 tdm_thread_cb_display_output_create output_create;
358 if (LIST_IS_EMPTY(&private_display->output_create_handler_list)) return TDM_ERROR_NONE;
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;
368 ret = tdm_thread_cb_call(private_display, &output_create.base, 1);
369 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
371 return TDM_ERROR_NONE;
375 tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
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());
381 assert(create_handler->owner_tid == syscall(SYS_gettid));
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);
389 tdm_display_add_output_create_handler(tdm_display *dpy,
390 tdm_output_create_handler func,
393 tdm_private_output_create_handler *create_handler = NULL;
395 DISPLAY_FUNC_ENTRY();
397 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
399 _pthread_mutex_lock(&private_display->lock);
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;
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;
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;
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);
430 LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list);
432 _pthread_mutex_unlock(&private_display->lock);
438 tdm_display_remove_output_create_handler(tdm_display *dpy,
439 tdm_output_create_handler func,
442 tdm_private_display *private_display;
443 tdm_private_output_create_handler *create_handler = NULL, *hh = NULL;
445 TDM_RETURN_IF_FAIL(dpy != NULL);
446 TDM_RETURN_IF_FAIL(func != NULL);
448 private_display = (tdm_private_display*)dpy;
450 _pthread_mutex_lock(&private_display->lock);
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)
456 tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL,
457 tdm_display_thread_cb_output_create, create_handler);
459 LIST_DEL(&create_handler->link);
460 free(create_handler);
462 _pthread_mutex_unlock(&private_display->lock);
467 _pthread_mutex_unlock(&private_display->lock);
471 tdm_display_get_capabilities(tdm_display *dpy,
472 tdm_display_capability *capabilities)
474 tdm_private_module *private_module = NULL;
476 DISPLAY_FUNC_ENTRY();
478 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
480 _pthread_mutex_lock(&private_display->lock);
484 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
485 *capabilities |= private_module->capabilities;
488 _pthread_mutex_unlock(&private_display->lock);
494 tdm_display_get_pp_capabilities(tdm_display *dpy,
495 tdm_pp_capability *capabilities)
497 tdm_private_module *pp_module;
499 DISPLAY_FUNC_ENTRY();
501 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
503 _pthread_mutex_lock(&private_display->lock);
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;
513 pp_module = private_display->pp_module;
515 *capabilities = pp_module->caps_pp.capabilities;
517 _pthread_mutex_unlock(&private_display->lock);
523 tdm_display_get_pp_available_formats(tdm_display *dpy,
524 const tbm_format **formats, int *count)
526 tdm_private_module *pp_module;
528 DISPLAY_FUNC_ENTRY();
530 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
531 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
533 _pthread_mutex_lock(&private_display->lock);
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;
543 pp_module = private_display->pp_module;
545 *formats = (const tbm_format *)pp_module->caps_pp.formats;
546 *count = pp_module->caps_pp.format_count;
548 _pthread_mutex_unlock(&private_display->lock);
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)
557 tdm_private_module *pp_module;
559 DISPLAY_FUNC_ENTRY();
561 _pthread_mutex_lock(&private_display->lock);
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;
571 pp_module = private_display->pp_module;
574 *min_w = TDM_FRONT_VALUE(pp_module->caps_pp.min_w);
576 *min_h = TDM_FRONT_VALUE(pp_module->caps_pp.min_h);
578 *max_w = TDM_FRONT_VALUE(pp_module->caps_pp.max_w);
580 *max_h = TDM_FRONT_VALUE(pp_module->caps_pp.max_h);
582 *preferred_align = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align);
584 _pthread_mutex_unlock(&private_display->lock);
590 tdm_display_get_pp_preferred_align_vertical(tdm_display *dpy, int *preferred_align_vertical)
592 tdm_private_module *pp_module;
594 DISPLAY_FUNC_ENTRY();
596 _pthread_mutex_lock(&private_display->lock);
598 if (!private_display->pp_module) {
599 /* LCOV_EXCL_START */
600 TDM_ERR("no pp capability");
601 _pthread_mutex_unlock(&private_display->lock);
602 return TDM_ERROR_NO_CAPABILITY;
606 pp_module = private_display->pp_module;
608 if (preferred_align_vertical)
609 *preferred_align_vertical = TDM_FRONT_VALUE(pp_module->caps_pp.preferred_align_vertical);
611 _pthread_mutex_unlock(&private_display->lock);
617 tdm_display_get_capture_capabilities(tdm_display *dpy,
618 tdm_capture_capability *capabilities)
620 tdm_private_module *capture_module;
622 DISPLAY_FUNC_ENTRY();
624 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
626 _pthread_mutex_lock(&private_display->lock);
628 if (!private_display->capture_module) {
629 /* LCOV_EXCL_START */
630 TDM_ERR("no capture capability");
631 _pthread_mutex_unlock(&private_display->lock);
632 return TDM_ERROR_NO_CAPABILITY;
636 capture_module = private_display->capture_module;
638 *capabilities = capture_module->caps_capture.capabilities;
640 _pthread_mutex_unlock(&private_display->lock);
646 tdm_display_get_capture_available_formats(tdm_display *dpy,
647 const tbm_format **formats, int *count)
649 tdm_private_module *capture_module;
651 DISPLAY_FUNC_ENTRY();
653 TDM_RETURN_VAL_IF_FAIL(formats != NULL, TDM_ERROR_INVALID_PARAMETER);
654 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
656 _pthread_mutex_lock(&private_display->lock);
658 if (!private_display->capture_module) {
659 /* LCOV_EXCL_START */
660 TDM_ERR("no capture capability");
661 _pthread_mutex_unlock(&private_display->lock);
662 return TDM_ERROR_NO_CAPABILITY;
666 capture_module = private_display->capture_module;
668 *formats = (const tbm_format *)capture_module->caps_capture.formats;
669 *count = capture_module->caps_capture.format_count;
671 _pthread_mutex_unlock(&private_display->lock);
677 tdm_display_get_capture_available_size(tdm_display *dpy, int *min_w, int *min_h,
678 int *max_w, int *max_h, int *preferred_align)
680 tdm_private_module *capture_module;
682 DISPLAY_FUNC_ENTRY();
684 _pthread_mutex_lock(&private_display->lock);
686 if (!private_display->capture_module) {
687 /* LCOV_EXCL_START */
688 TDM_ERR("no capture capability");
689 _pthread_mutex_unlock(&private_display->lock);
690 return TDM_ERROR_NO_CAPABILITY;
694 capture_module = private_display->capture_module;
697 *min_w = TDM_FRONT_VALUE(capture_module->caps_capture.min_w);
699 *min_h = TDM_FRONT_VALUE(capture_module->caps_capture.min_h);
701 *max_w = TDM_FRONT_VALUE(capture_module->caps_capture.max_w);
703 *max_h = TDM_FRONT_VALUE(capture_module->caps_capture.max_h);
705 *preferred_align = TDM_FRONT_VALUE(capture_module->caps_capture.preferred_align);
707 _pthread_mutex_unlock(&private_display->lock);
713 tdm_display_get_max_layer_count(tdm_display *dpy, int *max_count)
715 TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER);
716 TDM_RETURN_VAL_IF_FAIL(max_count != NULL, TDM_ERROR_INVALID_PARAMETER);
718 TDM_DEPRECATED(NULL);
722 return TDM_ERROR_NONE;
726 tdm_display_get_output_count(tdm_display *dpy, int *count)
728 tdm_private_module *private_module = NULL;
729 tdm_private_output *private_output = NULL;
731 DISPLAY_FUNC_ENTRY();
733 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
735 _pthread_mutex_lock(&private_display->lock);
738 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
739 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
744 _pthread_mutex_unlock(&private_display->lock);
751 tdm_display_get_output(tdm_display *dpy, int index, tdm_error *error)
753 tdm_private_module *private_module = NULL;
754 tdm_private_output *private_output = NULL;
756 DISPLAY_FUNC_ENTRY_ERROR();
758 _pthread_mutex_lock(&private_display->lock);
761 *error = TDM_ERROR_NONE;
763 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
764 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
765 if (private_output->index == index) {
766 _pthread_mutex_unlock(&private_display->lock);
767 return private_output;
772 _pthread_mutex_unlock(&private_display->lock);
778 tdm_display_find_output(tdm_display *dpy, const char *name, tdm_error *error)
780 tdm_private_module *private_module = NULL;
781 tdm_private_output *private_output = NULL;
782 tdm_private_output *mode_setted_output = NULL;
783 tdm_private_output *connected_output = NULL;
784 unsigned int find_primary = 0;
786 DISPLAY_FUNC_ENTRY_ERROR();
788 if (!strncasecmp(name, "primary", 7) || !strncasecmp(name, "default", 7))
791 _pthread_mutex_lock(&private_display->lock);
794 *error = TDM_ERROR_NONE;
797 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
798 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
799 if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED && !connected_output)
800 connected_output = private_output;
801 else if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_MODE_SETTED && !mode_setted_output)
802 mode_setted_output = private_output;
806 if (mode_setted_output) {
807 _pthread_mutex_unlock(&private_display->lock);
808 return mode_setted_output;
811 if (connected_output) {
812 _pthread_mutex_unlock(&private_display->lock);
813 return connected_output;
816 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
817 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
818 if (private_output->index == 0) {
819 _pthread_mutex_unlock(&private_display->lock);
820 return private_output;
826 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
827 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
828 if (strncmp(private_output->caps.model, name, TDM_NAME_LEN))
830 _pthread_mutex_unlock(&private_display->lock);
831 return private_output;
835 if (private_display->virtual_module) {
836 private_module = private_display->virtual_module;
837 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
838 if (strncmp(private_output->name, name, TDM_NAME_LEN))
840 _pthread_mutex_unlock(&private_display->lock);
841 return private_output;
844 _pthread_mutex_unlock(&private_display->lock);
850 tdm_display_get_fd(tdm_display *dpy, int *fd)
852 DISPLAY_FUNC_ENTRY();
854 TDM_RETURN_VAL_IF_FAIL(fd != NULL, TDM_ERROR_INVALID_PARAMETER);
856 _pthread_mutex_lock(&private_display->lock);
858 if (tdm_thread_is_running())
859 *fd = tdm_thread_get_fd(private_display->private_loop);
861 *fd = tdm_event_loop_get_fd(private_display);
863 _pthread_mutex_unlock(&private_display->lock);
869 tdm_display_handle_events(tdm_display *dpy)
874 DISPLAY_FUNC_ENTRY();
876 ret = tdm_display_get_fd(dpy, &fd);
877 TDM_RETURN_VAL_IF_FAIL(fd >= 0, ret);
883 if (tdm_debug_module & TDM_DEBUG_EVENT)
884 TDM_INFO("fd(%d) polling in", fd);
886 while (poll(&fds, 1, -1) < 0) {
887 /* LCOV_EXCL_START */
888 if (errno == EINTR || errno == EAGAIN) /* normal case */
891 TDM_ERR("poll failed: %m");
892 return TDM_ERROR_OPERATION_FAILED;
897 if (tdm_debug_module & TDM_DEBUG_EVENT)
898 TDM_INFO("fd(%d) polling out", fd);
900 if (tdm_thread_is_running()) {
901 _pthread_mutex_lock(&private_display->lock);
902 ret = tdm_thread_handle_cb(private_display->private_loop);
903 _pthread_mutex_unlock(&private_display->lock);
905 ret = tdm_event_loop_dispatch(private_display);
912 tdm_display_flush(tdm_display *dpy)
914 tdm_private_display *private_display;
916 TDM_RETURN_IF_FAIL(dpy != NULL);
917 private_display = (tdm_private_display*)dpy;
919 if (tdm_thread_is_running())
922 tdm_event_loop_flush(private_display);
926 tdm_display_get_backend_info(tdm_display *dpy, const char **name,
927 const char **vendor, int *major, int *minor)
929 tdm_private_module *private_module = NULL;
930 tdm_backend_module *module_data = NULL;
932 DISPLAY_FUNC_ENTRY();
934 TDM_DEPRECATED("Use tdm_module_get_info");
936 _pthread_mutex_lock(&private_display->lock);
938 /* use first backend */
939 LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
940 module_data = private_module->module_data;
944 assert(module_data != NULL);
947 *name = module_data->name;
949 *vendor = module_data->vendor;
951 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
953 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
955 _pthread_mutex_unlock(&private_display->lock);
961 tdm_display_create_pp(tdm_display *dpy, tdm_error *error)
965 DISPLAY_FUNC_ENTRY_ERROR();
967 _pthread_mutex_lock(&private_display->lock);
969 pp = (tdm_pp *)tdm_pp_create_internal(private_display->pp_module, error);
971 _pthread_mutex_unlock(&private_display->lock);
977 tdm_module_get_info(tdm_module *module, const char **name,
978 const char **vendor, int *major, int *minor)
980 tdm_backend_module *module_data;
982 BACKEND_FUNC_ENTRY();
984 _pthread_mutex_lock(&private_display->lock);
986 module_data = private_module->module_data;
989 *name = module_data->name;
991 *vendor = module_data->vendor;
993 *major = TDM_BACKEND_GET_ABI_MAJOR(module_data->abi_version);
995 *minor = TDM_BACKEND_GET_ABI_MINOR(module_data->abi_version);
997 _pthread_mutex_unlock(&private_display->lock);
1003 tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin)
1005 tdm_backend_module *module = private_module->module_data;
1007 if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) > abimaj)
1010 if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj)
1013 if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin)
1019 INTERN tdm_voutput *
1020 tdm_display_voutput_create(tdm_display *dpy, const char *name, tdm_error *error)
1022 tdm_private_module *private_module = NULL;
1023 tdm_private_module *current_module = NULL;
1024 tdm_private_voutput *private_voutput = NULL;
1025 tdm_private_output *private_output = NULL;
1026 tdm_func_display *func_display = NULL;
1027 tdm_func_voutput *func_voutput = NULL;
1028 tdm_voutput *voutput_backend = NULL;
1029 tdm_output *output_backend = NULL;
1030 int output_find = 0;
1031 tdm_private_display *private_display;
1032 tdm_error ret = TDM_ERROR_NONE;
1034 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL);
1035 private_display = (tdm_private_display*)dpy;
1036 private_module = private_display->virtual_module;
1037 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(private_module != NULL, TDM_ERROR_BAD_MODULE, NULL);
1039 _pthread_mutex_lock(&private_display->lock);
1041 if (error) *error = TDM_ERROR_NONE;
1043 private_voutput = calloc(1, sizeof(tdm_private_voutput));
1044 if (!private_voutput) {
1045 if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
1046 _pthread_mutex_unlock(&private_display->lock);
1050 func_display = &private_module->func_display;
1051 func_voutput = &private_module->func_voutput;
1052 current_module = private_display->current_module;
1053 private_display->current_module = private_module;
1055 voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
1057 if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
1058 TDM_ERR("display_voutput_create fail");
1059 free(private_voutput);
1060 if (error) *error = ret;
1061 private_display->current_module = current_module;
1062 _pthread_mutex_unlock(&private_display->lock);
1065 private_voutput->voutput_backend = voutput_backend;
1066 private_voutput->private_display = private_display;
1067 private_voutput->private_module = private_module;
1068 LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
1070 output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
1071 if (output_backend == NULL || ret != TDM_ERROR_NONE) {
1072 TDM_ERR("voutput_get_output fail");
1073 free(private_voutput);
1074 if (error) *error = ret;
1075 if (func_voutput->voutput_destroy)
1076 func_voutput->voutput_destroy(voutput_backend);
1078 TDM_ERR("no destroy function");
1079 private_display->current_module = current_module;
1080 _pthread_mutex_unlock(&private_display->lock);
1084 if (func_voutput->voutput_set_target_buffer_queue_flag) {
1085 if (private_module->use_default_type_bo == 1)
1086 func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_DEFAULT);
1088 func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_SCANOUT);
1091 ret = tdm_display_update_output(private_display->current_module, output_backend);
1092 if (ret != TDM_ERROR_NONE) {
1093 TDM_ERR("tdm_display_update_output fail");
1094 free(private_voutput);
1095 if (func_voutput->voutput_destroy)
1096 func_voutput->voutput_destroy(voutput_backend);
1098 TDM_ERR("no destroy function");
1099 if (error) *error = ret;
1100 private_display->current_module = current_module;
1101 _pthread_mutex_unlock(&private_display->lock);
1105 LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
1106 if (private_output->output_backend == output_backend) {
1112 if (output_find != 1) {
1113 private_output = NULL;
1114 free(private_voutput);
1115 if (func_voutput->voutput_destroy)
1116 func_voutput->voutput_destroy(voutput_backend);
1118 TDM_ERR("no destroy function");
1119 private_voutput = NULL;
1121 strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
1122 private_voutput->name[TDM_NAME_LEN - 1] = '\0';
1123 strncpy(private_output->name, name, TDM_NAME_LEN - 1);
1124 private_output->name[TDM_NAME_LEN - 1] = '\0';
1126 private_voutput->private_output = private_output;
1127 private_output->private_voutput = private_voutput;
1129 /* do not use vblank */
1130 tdm_output_choose_commit_per_vblank_mode(private_output, 0);
1132 LIST_ADDTAIL(&private_voutput->link, &private_module->voutput_list);
1135 private_display->current_module = current_module;
1137 _pthread_mutex_unlock(&private_display->lock);
1139 return private_voutput;