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 OUTPUT_FUNC_ENTRY() \
45 tdm_private_display *private_display; \
46 tdm_private_output *private_output; \
47 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
48 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER); \
49 private_output = (tdm_private_output*)output; \
50 private_display = private_output->private_display
52 #define OUTPUT_FUNC_ENTRY_ERROR() \
53 tdm_private_display *private_display; \
54 tdm_private_output *private_output; \
55 tdm_error ret = TDM_ERROR_NONE; /* default TDM_ERROR_NONE */\
56 TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(output != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \
57 private_output = (tdm_private_output*)output; \
58 private_display = private_output->private_display
61 _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_delay);
64 _tdm_output_vblank_timeout_cb(void *user_data)
66 tdm_private_output *private_output = user_data;
67 tdm_private_output_vblank_handler *v = NULL;
69 TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OPERATION_FAILED);
71 private_output->vblank_timeout_timer_expired++;
73 TDM_ERR("TDM output(%d) vblank TIMEOUT!! (%d time%s)",
75 private_output->vblank_timeout_timer_expired,
76 (private_output->vblank_timeout_timer_expired > 1) ? "s" : "");
78 LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
79 TDM_ERR("vblank_handler(%p) interval(%d) sync(%d) sent_to_frontend(%u) owner_tid(%d)",
80 v, v->interval, v->sync, v->sent_to_frontend, v->owner_tid);
83 return TDM_ERROR_NONE;
87 tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data)
89 tdm_private_output_vblank_handler *v = NULL;
91 TDM_RETURN_IF_FAIL(private_output != NULL);
92 TDM_RETURN_IF_FAIL(user_data != NULL);
94 TDM_ERR("TDM output(%d) vblank user_data(%p) info!!", private_output->pipe, user_data);
96 LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
97 if (v->user_data != user_data)
99 TDM_ERR("vblank_handler(%p) interval(%d) sync(%d) sent_to_frontend(%u) owner_tid(%d)",
100 v, v->interval, v->sync, v->sent_to_frontend, v->owner_tid);
105 _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_delay)
109 if (!private_output->vblank_timeout_timer) {
110 private_output->vblank_timeout_timer =
111 tdm_event_loop_add_timer_handler(private_output->private_display,
112 _tdm_output_vblank_timeout_cb,
115 if (!private_output->vblank_timeout_timer) {
116 TDM_ERR("output(%d) couldn't add timer", private_output->pipe);
119 TDM_INFO("output(%d) create vblank timeout timer", private_output->pipe);
120 private_output->vblank_timeout_timer_expired = 0;
123 ret = tdm_event_loop_source_timer_update(private_output->vblank_timeout_timer, ms_delay);
124 if (ret != TDM_ERROR_NONE) {
125 TDM_ERR("output(%d) couldn't update timer", private_output->pipe);
131 tdm_output_init(tdm_private_display *private_display)
133 tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DESTROY, tdm_display_find_output_stamp);
134 tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp);
135 tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp);
136 tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_STATUS, tdm_display_find_output_stamp);
137 tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp);
138 tdm_thread_cb_set_find_func(TDM_THREAD_CB_VOUTPUT_COMMIT, tdm_display_find_private_voutput);
140 return TDM_ERROR_NONE;
144 tdm_output_call_thread_cb_destroy(tdm_private_output *private_output)
146 tdm_thread_cb_output_destroy output_destroy;
149 memset(&output_destroy, 0, sizeof output_destroy);
150 output_destroy.base.type = TDM_THREAD_CB_OUTPUT_DESTROY;
151 output_destroy.base.length = sizeof output_destroy;
152 output_destroy.base.object_stamp = private_output->stamp;
153 output_destroy.base.data = NULL;
154 output_destroy.base.sync = 1;
156 ret = tdm_thread_cb_call(private_output, &output_destroy.base, 1);
157 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
159 return TDM_ERROR_NONE;
162 /* LCOV_EXCL_START */
164 tdm_output_thread_cb_destroy(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
166 tdm_private_output *private_output = object;
167 tdm_private_output_destroy_handler *destroy_handler = user_data;
169 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
171 assert(destroy_handler->owner_tid == syscall(SYS_gettid));
173 _pthread_mutex_unlock(&private_display->lock);
174 destroy_handler->func(private_output, destroy_handler->user_data);
175 _pthread_mutex_lock(&private_display->lock);
179 tdm_output_add_destroy_handler(tdm_output *output,
180 tdm_output_destroy_handler func,
183 tdm_private_output_destroy_handler *destroy_handler = NULL;
186 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
188 _pthread_mutex_lock(&private_display->lock);
190 LIST_FOR_EACH_ENTRY(destroy_handler, &private_output->destroy_handler_list, link) {
191 if (destroy_handler->func == func && destroy_handler->user_data == user_data) {
192 TDM_ERR("can't add twice");
193 _pthread_mutex_unlock(&private_display->lock);
194 return TDM_ERROR_BAD_REQUEST;
198 destroy_handler = calloc(1, sizeof(tdm_private_output_destroy_handler));
199 if (!destroy_handler) {
200 TDM_ERR("failed: alloc memory");
201 _pthread_mutex_unlock(&private_display->lock);
202 return TDM_ERROR_OUT_OF_MEMORY;
205 ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, destroy_handler);
206 if (ret != TDM_ERROR_NONE) {
207 TDM_ERR("tdm_thread_cb_add failed");
208 free(destroy_handler);
209 _pthread_mutex_unlock(&private_display->lock);
210 return TDM_ERROR_OPERATION_FAILED;
213 destroy_handler->private_output = private_output;
214 destroy_handler->func = func;
215 destroy_handler->user_data = user_data;
216 destroy_handler->owner_tid = syscall(SYS_gettid);
218 LIST_ADDTAIL(&destroy_handler->link, &private_output->destroy_handler_list);
220 _pthread_mutex_unlock(&private_display->lock);
226 tdm_output_remove_destroy_handler(tdm_output *output,
227 tdm_output_destroy_handler func,
230 tdm_private_display *private_display;
231 tdm_private_output *private_output;
232 tdm_private_output_destroy_handler *destroy_handler = NULL, *hh = NULL;
234 TDM_RETURN_IF_FAIL(output != NULL);
235 TDM_RETURN_IF_FAIL(func != NULL);
237 private_output = (tdm_private_output*)output;
238 private_display = private_output->private_display;
240 _pthread_mutex_lock(&private_display->lock);
242 LIST_FOR_EACH_ENTRY_SAFE(destroy_handler, hh, &private_output->destroy_handler_list, link) {
243 if (destroy_handler->func != func || destroy_handler->user_data != user_data)
246 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, destroy_handler);
248 LIST_DEL(&destroy_handler->link);
249 free(destroy_handler);
251 _pthread_mutex_unlock(&private_display->lock);
256 _pthread_mutex_unlock(&private_display->lock);
261 tdm_output_get_backend_module(tdm_output *output, tdm_error *error)
263 tdm_private_module *private_module;
265 OUTPUT_FUNC_ENTRY_ERROR();
267 _pthread_mutex_lock(&private_display->lock);
269 private_module = private_output->private_module;
272 *error = TDM_ERROR_NONE;
274 _pthread_mutex_unlock(&private_display->lock);
276 return private_module;
280 tdm_output_get_model_info(tdm_output *output, const char **maker,
281 const char **model, const char **name)
285 _pthread_mutex_lock(&private_display->lock);
288 *maker = private_output->caps.maker;
290 *model = private_output->caps.model;
292 *name = private_output->caps.name;
294 _pthread_mutex_unlock(&private_display->lock);
300 tdm_output_get_capabilities(tdm_output *output, tdm_output_capability *capabilities)
304 TDM_RETURN_VAL_IF_FAIL(capabilities != NULL, TDM_ERROR_INVALID_PARAMETER);
306 _pthread_mutex_lock(&private_display->lock);
308 *capabilities = private_output->caps.capabilities;
310 _pthread_mutex_unlock(&private_display->lock);
316 tdm_output_get_conn_status(tdm_output *output, tdm_output_conn_status *status)
320 TDM_RETURN_VAL_IF_FAIL(status != NULL, TDM_ERROR_INVALID_PARAMETER);
322 _pthread_mutex_lock(&private_display->lock);
324 *status = private_output->caps.status;
326 _pthread_mutex_unlock(&private_display->lock);
332 tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
334 tdm_private_output *private_output = object;
335 tdm_private_output_change_handler *change_handler = user_data;
336 tdm_output_change_type type = TDM_OUTPUT_CHANGE_CONNECTION;
337 tdm_value value = {.u32 = 0 };
339 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
341 assert(change_handler->owner_tid == syscall(SYS_gettid));
343 if (cb_base->type == TDM_THREAD_CB_OUTPUT_STATUS) {
344 tdm_thread_cb_output_status *output_status = (tdm_thread_cb_output_status *)cb_base;
345 type = TDM_OUTPUT_CHANGE_CONNECTION;
346 value.u32 = output_status->status;
347 } else if (cb_base->type == TDM_THREAD_CB_OUTPUT_DPMS) {
348 tdm_thread_cb_output_dpms *output_dpms = (tdm_thread_cb_output_dpms *)cb_base;
349 type = TDM_OUTPUT_CHANGE_DPMS;
350 value.u32 = output_dpms->dpms;
352 TDM_NEVER_GET_HERE();
356 _pthread_mutex_unlock(&private_display->lock);
357 change_handler->func(private_output, type, value, change_handler->user_data);
358 _pthread_mutex_lock(&private_display->lock);
363 _tdm_output_call_thread_cb_status(tdm_private_output *private_output, tdm_output_conn_status status)
365 tdm_thread_cb_output_status output_status;
366 pid_t caller_tid = syscall(SYS_gettid);
369 memset(&output_status, 0, sizeof output_status);
370 output_status.base.type = TDM_THREAD_CB_OUTPUT_STATUS;
371 output_status.base.length = sizeof output_status;
372 output_status.base.object_stamp = private_output->stamp;
373 output_status.base.data = NULL;
374 if (tdm_thread_in_display_thread(caller_tid))
375 output_status.base.sync = 0;
377 output_status.base.sync = 1;
378 output_status.status = status;
380 ret = tdm_thread_cb_call(private_output, &output_status.base, 1);
381 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
383 return TDM_ERROR_NONE;
387 _tdm_output_call_thread_cb_dpms(tdm_private_output *private_output, tdm_output_dpms dpms)
389 tdm_thread_cb_output_dpms output_dpms;
392 memset(&output_dpms, 0, sizeof output_dpms);
393 output_dpms.base.type = TDM_THREAD_CB_OUTPUT_DPMS;
394 output_dpms.base.length = sizeof output_dpms;
395 output_dpms.base.object_stamp = private_output->stamp;
396 output_dpms.base.data = NULL;
397 output_dpms.base.sync = 0;
398 output_dpms.dpms = dpms;
400 ret = tdm_thread_cb_call(private_output, &output_dpms.base, 1);
401 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
403 return TDM_ERROR_NONE;
406 /* LCOV_EXCL_START */
408 tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, void *user_data)
410 tdm_private_output *private_output = user_data;
413 TDM_RETURN_IF_FAIL(private_output);
415 TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str(status));
417 if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
418 (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) {
419 ret = tdm_display_update_output(private_output->private_module, output_backend);
420 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
422 private_output->caps.status = status;
425 ret = _tdm_output_call_thread_cb_status(private_output, status);
426 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
430 tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms, void *user_data)
432 tdm_private_output *private_output = user_data;
435 TDM_INFO("output(%d) %s", private_output->pipe, tdm_dpms_str(dpms));
437 private_output->current_dpms_value = dpms;
438 private_output->waiting_dpms_change = 0;
439 TDM_INFO("output(%d) DPMS async '%s' done", private_output->pipe, tdm_dpms_str(dpms));
441 ret = _tdm_output_call_thread_cb_dpms(private_output, dpms);
442 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
446 tdm_output_cb_status_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_conn_status status, void *user_data)
448 tdm_private_output *private_output = user_data;
451 TDM_RETURN_IF_FAIL(private_output);
453 TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str((tdm_output_conn_status)status));
455 if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
456 (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) {
457 ret = tdm_display_update_output(private_output->private_module, output_backend);
458 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
460 private_output->caps.status = (tdm_output_conn_status)status;
463 ret = _tdm_output_call_thread_cb_status(private_output, (tdm_output_conn_status)status);
464 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
468 tdm_output_cb_dpms_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_dpms dpms, void *user_data)
470 tdm_private_output *private_output = user_data;
473 TDM_INFO("output(%d) %s", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms));
475 private_output->current_dpms_value = (tdm_output_dpms)dpms;
476 private_output->waiting_dpms_change = 0;
477 TDM_INFO("output(%d) DPMS async '%s' done", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms));
479 ret = _tdm_output_call_thread_cb_dpms(private_output, (tdm_output_dpms)dpms);
480 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
485 tdm_output_add_change_handler(tdm_output *output,
486 tdm_output_change_handler func,
489 tdm_private_output_change_handler *change_handler = NULL;
492 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
494 _pthread_mutex_lock(&private_display->lock);
496 LIST_FOR_EACH_ENTRY(change_handler, &private_output->change_handler_list, link) {
497 if (change_handler->func == func && change_handler->user_data == user_data) {
498 TDM_ERR("can't add twice");
499 _pthread_mutex_unlock(&private_display->lock);
500 return TDM_ERROR_BAD_REQUEST;
504 change_handler = calloc(1, sizeof(tdm_private_output_change_handler));
505 if (!change_handler) {
506 /* LCOV_EXCL_START */
507 TDM_ERR("failed: alloc memory");
508 _pthread_mutex_unlock(&private_display->lock);
509 return TDM_ERROR_OUT_OF_MEMORY;
513 ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler);
514 if (ret != TDM_ERROR_NONE) {
515 /* LCOV_EXCL_START */
516 TDM_ERR("tdm_thread_cb_add failed");
517 free(change_handler);
518 _pthread_mutex_unlock(&private_display->lock);
519 return TDM_ERROR_OPERATION_FAILED;
523 ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler);
524 if (ret != TDM_ERROR_NONE) {
525 /* LCOV_EXCL_START */
526 TDM_ERR("tdm_thread_cb_add failed");
527 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler);
528 free(change_handler);
529 _pthread_mutex_unlock(&private_display->lock);
530 return TDM_ERROR_OPERATION_FAILED;
534 change_handler->private_output = private_output;
535 change_handler->func = func;
536 change_handler->user_data = user_data;
537 change_handler->owner_tid = syscall(SYS_gettid);
539 LIST_ADDTAIL(&change_handler->link, &private_output->change_handler_list);
541 _pthread_mutex_unlock(&private_display->lock);
546 /* LCOV_EXCL_START */
548 tdm_output_add_mode_change_request_handler(tdm_output *output,
549 tdm_output_mode_change_request_handler func,
552 tdm_private_display *private_display;
553 tdm_private_output *private_output;
554 tdm_private_output_mode_change_handler *mode_change_handler = NULL;
556 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
557 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
559 private_output = (tdm_private_output*)output;
560 private_display = private_output->private_display;
562 _pthread_mutex_lock(&private_display->lock);
564 LIST_FOR_EACH_ENTRY(mode_change_handler, &private_output->mode_change_request_handler_list, link) {
565 if (mode_change_handler->func == func && mode_change_handler->user_data == user_data) {
566 TDM_ERR("can't add twice");
567 _pthread_mutex_unlock(&private_display->lock);
568 return TDM_ERROR_BAD_REQUEST;
572 mode_change_handler = calloc(1, sizeof(tdm_private_output_mode_change_handler));
573 if (!mode_change_handler) {
574 /* LCOV_EXCL_START */
575 TDM_ERR("failed: alloc memory");
576 _pthread_mutex_unlock(&private_display->lock);
577 return TDM_ERROR_OUT_OF_MEMORY;
581 mode_change_handler->private_output = private_output;
582 mode_change_handler->func = func;
583 mode_change_handler->user_data = user_data;
585 LIST_ADDTAIL(&mode_change_handler->link, &private_output->mode_change_request_handler_list);
587 _pthread_mutex_unlock(&private_display->lock);
589 return TDM_ERROR_NONE;
593 tdm_output_remove_mode_change_request_handler(tdm_output *output,
594 tdm_output_mode_change_request_handler func,
597 tdm_private_display *private_display;
598 tdm_private_output *private_output;
599 tdm_private_output_mode_change_handler *mode_change_handler = NULL, *hh = NULL;
601 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
602 TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER);
604 private_output = (tdm_private_output*)output;
605 private_display = private_output->private_display;
607 _pthread_mutex_lock(&private_display->lock);
609 LIST_FOR_EACH_ENTRY_SAFE(mode_change_handler, hh, &private_output->mode_change_request_handler_list, link) {
610 if (mode_change_handler->func != func || mode_change_handler->user_data != user_data)
613 LIST_DEL(&mode_change_handler->link);
614 free(mode_change_handler);
616 _pthread_mutex_unlock(&private_display->lock);
618 return TDM_ERROR_NONE;
621 _pthread_mutex_unlock(&private_display->lock);
623 return TDM_ERROR_INVALID_PARAMETER;
628 tdm_output_remove_change_handler(tdm_output *output,
629 tdm_output_change_handler func,
632 tdm_private_display *private_display;
633 tdm_private_output *private_output;
634 tdm_private_output_change_handler *change_handler = NULL, *hh = NULL;
636 TDM_RETURN_IF_FAIL(output != NULL);
637 TDM_RETURN_IF_FAIL(func != NULL);
639 private_output = (tdm_private_output*)output;
640 private_display = private_output->private_display;
642 _pthread_mutex_lock(&private_display->lock);
644 LIST_FOR_EACH_ENTRY_SAFE(change_handler, hh, &private_output->change_handler_list, link) {
645 if (change_handler->func != func || change_handler->user_data != user_data)
648 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, change_handler);
649 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, change_handler);
651 LIST_DEL(&change_handler->link);
652 free(change_handler);
654 _pthread_mutex_unlock(&private_display->lock);
659 _pthread_mutex_unlock(&private_display->lock);
663 tdm_output_get_output_type(tdm_output *output, tdm_output_type *type)
667 TDM_RETURN_VAL_IF_FAIL(type != NULL, TDM_ERROR_INVALID_PARAMETER);
669 _pthread_mutex_lock(&private_display->lock);
671 *type = private_output->caps.type;
673 _pthread_mutex_unlock(&private_display->lock);
679 tdm_output_get_layer_count(tdm_output *output, int *count)
681 tdm_private_layer *private_layer = NULL;
685 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
687 _pthread_mutex_lock(&private_display->lock);
689 if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) {
690 TDM_ERR("output(%p) support HWC. Use HWC functions", private_output);
692 _pthread_mutex_unlock(&private_display->lock);
693 return TDM_ERROR_BAD_REQUEST;
697 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link)
700 _pthread_mutex_unlock(&private_display->lock);
701 return TDM_ERROR_NONE;
704 _pthread_mutex_unlock(&private_display->lock);
711 tdm_output_get_layer(tdm_output *output, int index, tdm_error *error)
713 tdm_private_layer *private_layer = NULL;
715 OUTPUT_FUNC_ENTRY_ERROR();
717 _pthread_mutex_lock(&private_display->lock);
720 *error = TDM_ERROR_NONE;
722 if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) {
723 _pthread_mutex_unlock(&private_display->lock);
724 TDM_ERR("output(%p) support HWC. Use HWC functions", private_output);
726 *error = TDM_ERROR_BAD_REQUEST;
730 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
731 if (private_layer->index == index) {
732 _pthread_mutex_unlock(&private_display->lock);
733 return private_layer;
737 _pthread_mutex_unlock(&private_display->lock);
743 tdm_output_get_available_properties(tdm_output *output, const tdm_prop **props,
748 TDM_RETURN_VAL_IF_FAIL(props != NULL, TDM_ERROR_INVALID_PARAMETER);
749 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
751 _pthread_mutex_lock(&private_display->lock);
753 *props = (const tdm_prop *)private_output->caps.props;
754 *count = private_output->caps.prop_count;
756 _pthread_mutex_unlock(&private_display->lock);
762 tdm_output_get_available_modes(tdm_output *output,
763 const tdm_output_mode **modes, int *count)
767 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
768 TDM_RETURN_VAL_IF_FAIL(count != NULL, TDM_ERROR_INVALID_PARAMETER);
770 _pthread_mutex_lock(&private_display->lock);
772 *modes = (const tdm_output_mode *)private_output->caps.modes;
773 *count = private_output->caps.mode_count;
775 _pthread_mutex_unlock(&private_display->lock);
781 tdm_output_get_available_size(tdm_output *output, int *min_w, int *min_h,
782 int *max_w, int *max_h, int *preferred_align)
786 _pthread_mutex_lock(&private_display->lock);
789 *min_w = TDM_FRONT_VALUE(private_output->caps.min_w);
791 *min_h = TDM_FRONT_VALUE(private_output->caps.min_h);
793 *max_w = TDM_FRONT_VALUE(private_output->caps.max_w);
795 *max_h = TDM_FRONT_VALUE(private_output->caps.max_h);
797 *preferred_align = TDM_FRONT_VALUE(private_output->caps.preferred_align);
799 _pthread_mutex_unlock(&private_display->lock);
805 tdm_output_get_cursor_available_size(tdm_output *output, int *min_w, int *min_h,
806 int *max_w, int *max_h, int *preferred_align)
810 _pthread_mutex_lock(&private_display->lock);
812 if (!tdm_module_check_abi(private_output->private_module, 1, 5)) {
813 _pthread_mutex_unlock(&private_display->lock);
814 return TDM_ERROR_BAD_REQUEST;
818 *min_w = TDM_FRONT_VALUE(private_output->caps.cursor_min_w);
820 *min_h = TDM_FRONT_VALUE(private_output->caps.cursor_min_h);
822 *max_w = TDM_FRONT_VALUE(private_output->caps.cursor_max_w);
824 *max_h = TDM_FRONT_VALUE(private_output->caps.cursor_max_h);
826 *preferred_align = TDM_FRONT_VALUE(private_output->caps.cursor_preferred_align);
828 _pthread_mutex_unlock(&private_display->lock);
834 tdm_output_get_physical_size(tdm_output *output, unsigned int *mmWidth,
835 unsigned int *mmHeight)
839 _pthread_mutex_lock(&private_display->lock);
842 *mmWidth = private_output->caps.mmWidth;
844 *mmHeight = private_output->caps.mmHeight;
846 _pthread_mutex_unlock(&private_display->lock);
852 tdm_output_get_subpixel(tdm_output *output, unsigned int *subpixel)
855 TDM_RETURN_VAL_IF_FAIL(subpixel != NULL, TDM_ERROR_INVALID_PARAMETER);
857 _pthread_mutex_lock(&private_display->lock);
859 *subpixel = private_output->caps.subpixel;
861 _pthread_mutex_unlock(&private_display->lock);
867 tdm_output_get_pipe(tdm_output *output, unsigned int *pipe)
870 TDM_RETURN_VAL_IF_FAIL(pipe != NULL, TDM_ERROR_INVALID_PARAMETER);
872 _pthread_mutex_lock(&private_display->lock);
874 *pipe = private_output->pipe;
876 _pthread_mutex_unlock(&private_display->lock);
882 tdm_output_get_primary_index(tdm_output *output, int *index)
884 tdm_private_layer *private_layer = NULL;
887 TDM_RETURN_VAL_IF_FAIL(index != NULL, TDM_ERROR_INVALID_PARAMETER);
889 _pthread_mutex_lock(&private_display->lock);
891 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
892 if (private_layer->caps.capabilities & TDM_LAYER_CAPABILITY_PRIMARY) {
893 *index = private_layer->index;
898 _pthread_mutex_unlock(&private_display->lock);
904 tdm_output_set_property(tdm_output *output, unsigned int id, tdm_value value)
906 tdm_private_module *private_module;
907 tdm_func_output *func_output;
910 _pthread_mutex_lock(&private_display->lock);
912 private_module = private_output->private_module;
914 if (private_module->use_hal_tdm) {
915 hal_tdm_value hvalue;
916 memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value));
917 ret = (tdm_error)hal_tdm_output_set_property(private_output->output_backend, id, hvalue);
919 func_output = &private_module->func_output;
921 if (!func_output->output_set_property) {
922 /* LCOV_EXCL_START */
923 _pthread_mutex_unlock(&private_display->lock);
924 TDM_WRN("not implemented!!");
925 return TDM_ERROR_NOT_IMPLEMENTED;
929 ret = func_output->output_set_property(private_output->output_backend, id, value);
932 _pthread_mutex_unlock(&private_display->lock);
938 tdm_output_get_property(tdm_output *output, unsigned int id, tdm_value *value)
940 tdm_private_module *private_module;
941 tdm_func_output *func_output;
944 TDM_RETURN_VAL_IF_FAIL(value != NULL, TDM_ERROR_INVALID_PARAMETER);
946 _pthread_mutex_lock(&private_display->lock);
948 private_module = private_output->private_module;
950 if (private_module->use_hal_tdm) {
951 hal_tdm_value hvalue;
952 ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend, id, &hvalue);
953 if (ret == TDM_ERROR_NONE)
954 memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value));
956 func_output = &private_module->func_output;
958 if (!func_output->output_get_property) {
959 /* LCOV_EXCL_START */
960 _pthread_mutex_unlock(&private_display->lock);
961 TDM_WRN("not implemented!!");
962 return TDM_ERROR_NOT_IMPLEMENTED;
966 ret = func_output->output_get_property(private_output->output_backend, id, value);
968 _pthread_mutex_unlock(&private_display->lock);
974 _tdm_output_thread_cb_vblank(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
976 tdm_thread_cb_output_vblank *output_vblank = (tdm_thread_cb_output_vblank *)cb_base;
977 tdm_private_output_vblank_handler *vblank_handler = output_vblank->base.data;
978 tdm_private_output_vblank_handler *v = NULL, *vv = NULL;
979 tdm_private_output *private_output = object;
980 struct list_head clone_list;
982 pid_t tid = syscall(SYS_gettid);
984 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
986 assert(vblank_handler->owner_tid == tid);
988 vblank_handler->sent_to_frontend = 0;
990 _tdm_output_vblank_timeout_update(private_output, 0);
992 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
994 interval = vblank_handler->interval;
995 sync = vblank_handler->sync;
997 LIST_INITHEAD(&clone_list);
999 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_handler_list, link) {
1000 if (v->interval != interval || v->sync != sync || v->owner_tid != tid)
1004 LIST_ADDTAIL(&v->link, &clone_list);
1007 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1008 TDM_INFO("----------------------------------------- output(%d) got vblank", private_output->pipe);
1010 _pthread_mutex_unlock(&private_display->lock);
1011 LIST_FOR_EACH_ENTRY_SAFE(v, vv, &clone_list, link) {
1012 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1013 TDM_INFO("handler(%p)", v);
1018 v->func(v->private_output,
1019 output_vblank->sequence,
1020 output_vblank->tv_sec,
1021 output_vblank->tv_usec,
1026 _pthread_mutex_lock(&private_display->lock);
1028 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1029 TDM_INFO("-----------------------------------------...");
1033 _tdm_output_cb_vblank(tdm_output *output_backend, unsigned int sequence,
1034 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
1036 tdm_private_output_vblank_handler *vblank_handler = user_data;
1037 tdm_thread_cb_output_vblank output_vblank;
1040 memset(&output_vblank, 0, sizeof output_vblank);
1041 output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
1042 output_vblank.base.length = sizeof output_vblank;
1043 output_vblank.base.object_stamp = vblank_handler->private_output->stamp;
1044 output_vblank.base.data = vblank_handler;
1045 output_vblank.base.sync = 0;
1046 output_vblank.sequence = sequence;
1047 output_vblank.tv_sec = tv_sec;
1048 output_vblank.tv_usec = tv_usec;
1050 vblank_handler->sent_to_frontend = 1;
1052 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1053 TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler);
1055 ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base, 1);
1056 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1060 _tdm_output_cb_vblank_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence,
1061 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
1063 tdm_private_output_vblank_handler *vblank_handler = user_data;
1064 tdm_thread_cb_output_vblank output_vblank;
1067 memset(&output_vblank, 0, sizeof output_vblank);
1068 output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
1069 output_vblank.base.length = sizeof output_vblank;
1070 output_vblank.base.object_stamp = vblank_handler->private_output->stamp;
1071 output_vblank.base.data = vblank_handler;
1072 output_vblank.base.sync = 0;
1073 output_vblank.sequence = sequence;
1074 output_vblank.tv_sec = tv_sec;
1075 output_vblank.tv_usec = tv_usec;
1077 vblank_handler->sent_to_frontend = 1;
1079 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1080 TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler);
1082 ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base, 1);
1083 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1086 /* LCOV_EXCL_START */
1088 _tdm_output_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
1090 tdm_thread_cb_output_commit *output_commit = (tdm_thread_cb_output_commit *)cb_base;
1091 tdm_private_output_commit_handler *output_commit_handler = output_commit->base.data;
1092 tdm_private_output *private_output = object;
1093 tdm_private_layer *private_layer = NULL;
1095 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1097 if (!output_commit_handler)
1100 assert(output_commit_handler->owner_tid == syscall(SYS_gettid));
1102 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
1104 LIST_DEL(&output_commit_handler->link);
1106 if (tdm_debug_module & TDM_DEBUG_COMMIT) {
1107 TDM_INFO("----------------------------------------- output(%d) committed", private_output->pipe);
1108 TDM_INFO("handler(%p)", output_commit_handler);
1111 if (private_output->commit_type == TDM_COMMIT_TYPE_OUTPUT) {
1112 /* In case of layer commit, the below will be handled in the layer commit callback */
1113 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
1114 if (private_layer->committed_buffer)
1115 tdm_layer_committed(private_layer, &private_layer->committed_buffer);
1119 if (output_commit_handler->func) {
1120 _pthread_mutex_unlock(&private_display->lock);
1121 output_commit_handler->func(private_output,
1122 output_commit->sequence,
1123 output_commit->tv_sec,
1124 output_commit->tv_usec,
1125 output_commit_handler->user_data);
1126 _pthread_mutex_lock(&private_display->lock);
1129 free(output_commit_handler);
1131 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1132 TDM_INFO("-----------------------------------------...");
1136 _tdm_output_cb_commit(tdm_output *output_backend, unsigned int sequence,
1137 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
1139 tdm_private_output_commit_handler *output_commit_handler = user_data;
1140 tdm_private_output *private_output;
1141 tdm_thread_cb_output_commit output_commit;
1144 if (output_commit_handler)
1145 private_output = output_commit_handler->private_output;
1147 private_output = tdm_display_find_private_output(tdm_display_get(), output_backend);
1149 memset(&output_commit, 0, sizeof output_commit);
1150 output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
1151 output_commit.base.length = sizeof output_commit;
1152 output_commit.base.object_stamp = private_output->stamp;
1153 output_commit.base.data = output_commit_handler;
1154 output_commit.base.sync = 0;
1155 output_commit.sequence = sequence;
1156 output_commit.tv_sec = tv_sec;
1157 output_commit.tv_usec = tv_usec;
1159 ret = tdm_thread_cb_call(private_output, &output_commit.base, 1);
1160 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1164 _tdm_output_cb_commit_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence,
1165 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
1167 tdm_private_output_commit_handler *output_commit_handler = user_data;
1168 tdm_private_output *private_output;
1169 tdm_thread_cb_output_commit output_commit;
1172 if (output_commit_handler)
1173 private_output = output_commit_handler->private_output;
1175 private_output = tdm_display_find_private_output(tdm_display_get(), (tdm_output *)output_backend);
1177 memset(&output_commit, 0, sizeof output_commit);
1178 output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
1179 output_commit.base.length = sizeof output_commit;
1180 output_commit.base.object_stamp = private_output->stamp;
1181 output_commit.base.data = output_commit_handler;
1182 output_commit.base.sync = 0;
1183 output_commit.sequence = sequence;
1184 output_commit.tv_sec = tv_sec;
1185 output_commit.tv_usec = tv_usec;
1187 ret = tdm_thread_cb_call(private_output, &output_commit.base, 1);
1188 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1190 /* LCOV_EXCL_STOP */
1192 /* LCOV_EXCL_START */
1194 _tdm_voutput_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
1196 tdm_thread_cb_voutput_commit *voutput_commit = (tdm_thread_cb_voutput_commit *)cb_base;
1197 tdm_private_voutput_commit_handler *voutput_commit_handler = voutput_commit->base.data;
1198 tdm_private_voutput *private_voutput = object;
1199 tdm_private_output *private_output = NULL;
1201 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1203 if (!voutput_commit_handler)
1206 assert(voutput_commit_handler->owner_tid == syscall(SYS_gettid));
1208 tdm_thread_cb_remove(private_voutput, TDM_THREAD_CB_VOUTPUT_COMMIT, voutput_commit_handler, _tdm_voutput_thread_cb_commit, NULL);
1210 LIST_DEL(&voutput_commit_handler->link);
1212 private_output = private_voutput->private_output;
1213 if (tdm_debug_module & TDM_DEBUG_COMMIT) {
1214 TDM_INFO("----------------------------------------- voutput(%d) committed", private_output->pipe);
1215 TDM_INFO("handler(%p)", voutput_commit_handler);
1218 if (voutput_commit_handler->func && private_voutput->set_voutput_commit != 0) {
1219 _pthread_mutex_unlock(&private_display->lock);
1220 voutput_commit_handler->func(private_voutput, voutput_commit_handler->user_data);
1221 _pthread_mutex_lock(&private_display->lock);
1224 free(voutput_commit_handler);
1226 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1227 TDM_INFO("-----------------------------------------...");
1231 _tdm_voutput_cb_commit(tdm_voutput *voutput_backend, unsigned int sequence,
1232 unsigned int tv_sec, unsigned int tv_usec, void *user_data)
1234 tdm_private_voutput_commit_handler *voutput_commit_handler = NULL;
1235 tdm_private_module *private_module;
1236 tdm_private_voutput *private_voutput = NULL, *v = NULL;
1237 tdm_private_output *private_output;
1238 tdm_thread_cb_voutput_commit voutput_commit;
1241 private_module = tdm_display_get()->virtual_module;
1243 LIST_FOR_EACH_ENTRY(v, &private_module->voutput_list, link) {
1244 if (v->voutput_backend == voutput_backend) {
1245 private_voutput = v;
1249 if (!private_voutput) {
1250 TDM_ERR("cannot find voutput");
1254 if (LIST_LENGTH(&private_voutput->voutput_commit_handler_list) == 0) return;
1256 voutput_commit_handler = LIST_FIRST_ENTRY(&private_voutput->voutput_commit_handler_list, tdm_private_voutput_commit_handler, link);
1258 private_output = private_voutput->private_output;
1260 memset(&voutput_commit, 0, sizeof voutput_commit);
1261 voutput_commit.base.type = TDM_THREAD_CB_VOUTPUT_COMMIT;
1262 voutput_commit.base.length = sizeof voutput_commit;
1263 voutput_commit.base.object_stamp = private_output->stamp;
1264 voutput_commit.base.data = voutput_commit_handler;
1265 voutput_commit.base.sync = 0;
1266 voutput_commit.sequence = sequence;
1267 voutput_commit.tv_sec = tv_sec;
1268 voutput_commit.tv_usec = tv_usec;
1270 ret = tdm_thread_cb_call(private_voutput, &voutput_commit.base, 1);
1271 TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
1273 /* LCOV_EXCL_STOP */
1275 /* add_front: To distinguish between the user vblank handlers and the layer
1276 * commit vblank handlers. The layer commit handlers will be called
1277 * before calling the user vblank handlers.
1280 _tdm_output_wait_vblank(tdm_private_output *private_output, int interval, int sync,
1281 tdm_output_vblank_handler func, void *user_data,
1282 unsigned int add_front)
1284 tdm_private_module *private_module;
1285 tdm_func_output *func_output;
1286 tdm_private_output_vblank_handler *vblank_handler = NULL, *v = NULL;
1287 unsigned int skip_request = 0;
1288 pid_t tid = syscall(SYS_gettid);
1289 tdm_error ret = TDM_ERROR_NONE;
1291 private_module = private_output->private_module;
1292 func_output = &private_module->func_output;
1294 /* interval SHOULD be at least 1 */
1298 if (private_module->use_hal_tdm) {
1299 if (!private_output->regist_vblank_cb) {
1300 private_output->regist_vblank_cb = 1;
1301 ret = (tdm_error)hal_tdm_output_set_vblank_handler(private_output->output_backend, _tdm_output_cb_vblank_hal_tdm);
1304 if (!func_output->output_wait_vblank) {
1305 /* LCOV_EXCL_START */
1306 TDM_WRN("not implemented!!");
1307 return TDM_ERROR_NOT_IMPLEMENTED;
1308 /* LCOV_EXCL_STOP */
1311 if (!private_output->regist_vblank_cb) {
1312 private_output->regist_vblank_cb = 1;
1313 ret = func_output->output_set_vblank_handler(private_output->output_backend,
1314 _tdm_output_cb_vblank);
1317 vblank_handler = calloc(1, sizeof(tdm_private_output_vblank_handler));
1318 if (!vblank_handler) {
1319 /* LCOV_EXCL_START */
1320 TDM_ERR("failed: alloc memory");
1321 return TDM_ERROR_OUT_OF_MEMORY;
1322 /* LCOV_EXCL_STOP */
1325 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1326 TDM_INFO("output(%d) wait_vblank: handler(%p)", private_output->pipe, vblank_handler);
1328 LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
1329 if (v->interval == interval && v->sync == sync && v->owner_tid == tid) {
1336 LIST_ADD(&vblank_handler->link, &private_output->vblank_handler_list);
1338 LIST_ADDTAIL(&vblank_handler->link, &private_output->vblank_handler_list);
1340 vblank_handler->private_output = private_output;
1341 vblank_handler->interval = interval;
1342 vblank_handler->sync = sync;
1343 vblank_handler->func = func;
1344 vblank_handler->user_data = user_data;
1345 vblank_handler->owner_tid = tid;
1347 /* If there is the previous request, we can skip to call output_wait_vblank() */
1348 if (!skip_request) {
1349 ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
1350 if (ret != TDM_ERROR_NONE) {
1351 TDM_ERR("tdm_thread_cb_add failed");
1354 if (private_module->use_hal_tdm)
1355 ret = (tdm_error)hal_tdm_output_wait_vblank(private_output->output_backend, interval,
1356 sync, vblank_handler);
1358 ret = func_output->output_wait_vblank(private_output->output_backend, interval,
1359 sync, vblank_handler);
1360 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
1362 _tdm_output_vblank_timeout_update(private_output, 1000);
1364 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1365 TDM_INFO("output(%d) backend wait_vblank", private_output->pipe);
1371 /* LCOV_EXCL_START */
1372 if (vblank_handler) {
1373 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_VBLANK, vblank_handler, _tdm_output_thread_cb_vblank, NULL);
1374 LIST_DEL(&vblank_handler->link);
1375 free(vblank_handler);
1378 /* LCOV_EXCL_STOP */
1382 tdm_output_wait_vblank(tdm_output *output, int interval, int sync,
1383 tdm_output_vblank_handler func, void *user_data)
1385 OUTPUT_FUNC_ENTRY();
1386 TDM_RETURN_VAL_IF_FAIL(interval > 0, TDM_ERROR_INVALID_PARAMETER);
1388 _pthread_mutex_lock(&private_display->lock);
1390 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
1391 TDM_WRN("output(%d) dpms: %s", private_output->pipe,
1392 tdm_dpms_str(private_output->current_dpms_value));
1393 _pthread_mutex_unlock(&private_display->lock);
1394 return TDM_ERROR_DPMS_OFF;
1397 if (private_output->waiting_dpms_change) {
1398 TDM_WRN("output(%d) dpms is changing: %s", private_output->pipe,
1399 tdm_dpms_str(private_output->current_dpms_value));
1400 _pthread_mutex_unlock(&private_display->lock);
1401 return TDM_ERROR_DPMS_OFF;
1404 ret = _tdm_output_wait_vblank(private_output, interval, sync, func, user_data, 0);
1406 _pthread_mutex_unlock(&private_display->lock);
1411 /* LCOV_EXCL_START */
1413 tdm_output_wait_vblank_add_front(tdm_output *output, int interval, int sync,
1414 tdm_output_vblank_handler func, void *user_data)
1416 OUTPUT_FUNC_ENTRY();
1418 _pthread_mutex_lock(&private_display->lock);
1420 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
1421 TDM_WRN("output(%d) dpms: %s", private_output->pipe,
1422 tdm_dpms_str(private_output->current_dpms_value));
1423 _pthread_mutex_unlock(&private_display->lock);
1424 return TDM_ERROR_DPMS_OFF;
1427 if (private_output->waiting_dpms_change) {
1428 TDM_WRN("output(%d) dpms is changing: %s", private_output->pipe,
1429 tdm_dpms_str(private_output->current_dpms_value));
1430 _pthread_mutex_unlock(&private_display->lock);
1431 return TDM_ERROR_DPMS_OFF;
1434 ret = _tdm_output_wait_vblank(private_output, interval, sync, func, user_data, 1);
1436 _pthread_mutex_unlock(&private_display->lock);
1440 /* LCOV_EXCL_STOP */
1443 tdm_output_remove_vblank_handler_internal(tdm_output *output, tdm_output_vblank_handler func, void *user_data)
1445 tdm_private_output *private_output = (tdm_private_output*)output;
1446 tdm_private_output_vblank_handler *v = NULL;
1448 TDM_RETURN_IF_FAIL(private_output != NULL);
1449 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1451 LIST_FOR_EACH_ENTRY(v, &private_output->vblank_handler_list, link) {
1452 if (v->func == func && v->user_data == user_data) {
1453 /* only set func & user_data to NULL. It will be freed when an event occurs */
1455 v->user_data = NULL;
1461 /* LCOV_EXCL_START */
1463 tdm_output_remove_commit_handler_internal(tdm_output *output, tdm_output_commit_handler func, void *user_data)
1465 tdm_private_output *private_output = (tdm_private_output*)output;
1466 tdm_private_output_commit_handler *c = NULL;
1468 TDM_RETURN_IF_FAIL(private_output != NULL);
1469 TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
1471 LIST_FOR_EACH_ENTRY(c, &private_output->output_commit_handler_list, link) {
1472 if (c->func == func && c->user_data == user_data) {
1473 /* only set func & user_data to NULL. It will be freed when an event occurs */
1475 c->user_data = NULL;
1480 /* LCOV_EXCL_STOP */
1483 tdm_output_remove_vblank_handler(tdm_output *output, tdm_output_vblank_handler func, void *user_data)
1485 OUTPUT_FUNC_ENTRY();
1487 _pthread_mutex_lock(&private_display->lock);
1489 tdm_output_remove_vblank_handler_internal(output, func, user_data);
1491 _pthread_mutex_unlock(&private_display->lock);
1496 /* LCOV_EXCL_START */
1498 tdm_output_remove_commit_handler(tdm_output *output, tdm_output_commit_handler func, void *user_data)
1500 OUTPUT_FUNC_ENTRY();
1502 _pthread_mutex_lock(&private_display->lock);
1504 tdm_output_remove_commit_handler_internal(output, func, user_data);
1506 _pthread_mutex_unlock(&private_display->lock);
1510 /* LCOV_EXCL_STOP */
1512 /* LCOV_EXCL_START */
1514 tdm_output_request_mode_set(tdm_output *output, unsigned int index)
1516 tdm_private_output *private_output = (tdm_private_output*)output;
1517 tdm_private_output_mode_change_handler *mode_change_handler = NULL;
1519 TDM_RETURN_IF_FAIL(private_output != NULL);
1521 if (LIST_IS_EMPTY(&private_output->mode_change_request_handler_list))
1524 LIST_FOR_EACH_ENTRY(mode_change_handler, &private_output->mode_change_request_handler_list, link) {
1525 mode_change_handler->func(mode_change_handler->private_output, index, mode_change_handler->user_data);
1530 _voutput_commit_func(tdm_voutput *voutput, tbm_surface_h buffer)
1532 tdm_private_voutput *private_voutput = (tdm_private_voutput *)voutput;
1535 TDM_RETURN_IF_FAIL(voutput != NULL);
1536 TDM_RETURN_IF_FAIL(buffer != NULL);
1538 ret = tdm_voutput_attach_buffer(private_voutput, buffer);
1539 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1540 ret = tdm_voutput_commit_buffer(private_voutput);
1541 TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
1547 tdm_output_set_voutput_commit(tdm_voutput *voutput)
1549 tdm_private_display *private_display;
1550 tdm_private_output *private_output;
1551 tdm_private_voutput *private_voutput;
1552 tdm_private_voutput_commit_handler *voutput_commit_handler = NULL;
1553 tdm_error ret = TDM_ERROR_NONE;
1555 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
1557 private_voutput = (tdm_private_voutput *)voutput;
1558 private_display = private_voutput->private_display;
1559 private_output = (tdm_private_output *)private_voutput->private_output;
1561 _pthread_mutex_lock(&private_display->lock);
1563 if (LIST_LENGTH(&private_voutput->voutput_commit_handler_list) != 0) {
1564 _pthread_mutex_unlock(&private_display->lock);
1568 if (!private_voutput->regist_commit_cb) {
1569 private_voutput->regist_commit_cb = 1;
1570 ret = tdm_voutput_set_commit_func(private_voutput, _tdm_voutput_cb_commit);
1571 if (ret != TDM_ERROR_NONE) {
1572 TDM_ERR("failed: tdm_voutput_set_commit_func");
1573 _pthread_mutex_unlock(&private_display->lock);
1578 voutput_commit_handler = calloc(1, sizeof(tdm_private_voutput_commit_handler));
1579 if (!voutput_commit_handler) {
1580 TDM_ERR("failed: alloc memory");
1581 _pthread_mutex_unlock(&private_display->lock);
1582 return TDM_ERROR_OUT_OF_MEMORY;
1585 ret = tdm_thread_cb_add(private_output->private_voutput, TDM_THREAD_CB_VOUTPUT_COMMIT, voutput_commit_handler, _tdm_voutput_thread_cb_commit, NULL);
1586 if (ret != TDM_ERROR_NONE) {
1587 TDM_ERR("tdm_thread_cb_add failed");
1588 free(voutput_commit_handler);
1589 _pthread_mutex_unlock(&private_display->lock);
1593 LIST_ADDTAIL(&voutput_commit_handler->link, &private_voutput->voutput_commit_handler_list);
1594 voutput_commit_handler->private_voutput = private_voutput;
1595 voutput_commit_handler->func = _voutput_commit_func;
1596 voutput_commit_handler->owner_tid = syscall(SYS_gettid);
1598 private_voutput->set_voutput_commit = 1;
1600 _pthread_mutex_unlock(&private_display->lock);
1606 tdm_output_unset_voutput_commit(tdm_voutput *voutput)
1608 tdm_private_display *private_display;
1609 tdm_private_output *private_output;
1610 tdm_private_voutput *private_voutput;
1611 tdm_private_voutput_commit_handler *voutput_commit_handler = NULL;
1612 tdm_error ret = TDM_ERROR_NONE;
1614 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
1616 private_voutput = (tdm_private_voutput *)voutput;
1617 private_display = private_voutput->private_display;
1618 private_output = (tdm_private_output *)private_voutput->private_output;
1620 _pthread_mutex_lock(&private_display->lock);
1622 private_voutput->set_voutput_commit = 0;
1624 if (private_voutput->regist_commit_cb) {
1625 private_voutput->regist_commit_cb = 0;
1626 ret = tdm_voutput_set_commit_func(private_voutput, NULL);
1627 if (ret != TDM_ERROR_NONE) {
1628 TDM_ERR("failed: tdm_voutput_set_commit_func");
1629 _pthread_mutex_unlock(&private_display->lock);
1634 if (LIST_LENGTH(&private_voutput->voutput_commit_handler_list) == 0) {
1635 _pthread_mutex_unlock(&private_display->lock);
1636 return TDM_ERROR_NONE;
1639 if (LIST_LENGTH(&private_output->output_commit_handler_list) != 0) {
1640 //commiting. don't remove voutput commit thread here
1641 _pthread_mutex_unlock(&private_display->lock);
1642 return TDM_ERROR_NONE;
1645 if (LIST_LENGTH(&private_voutput->voutput_commit_handler_list) != 0) {
1646 voutput_commit_handler = LIST_FIRST_ENTRY(&private_voutput->voutput_commit_handler_list, tdm_private_voutput_commit_handler, link);
1648 _pthread_mutex_unlock(&private_display->lock);
1649 return TDM_ERROR_NONE;
1652 tdm_thread_cb_remove(private_output->private_voutput, TDM_THREAD_CB_VOUTPUT_COMMIT, voutput_commit_handler, _tdm_voutput_thread_cb_commit, NULL);
1654 _pthread_mutex_unlock(&private_display->lock);
1656 return TDM_ERROR_NONE;
1658 /* LCOV_EXCL_STOP */
1660 /* LCOV_EXCL_START */
1662 tdm_output_commit_internal(tdm_output *output, int sync, tdm_output_commit_handler func, void *user_data)
1664 tdm_private_display *private_display;
1665 tdm_private_output *private_output;
1666 tdm_private_voutput *private_voutput;
1667 tdm_private_module *private_module;
1668 tdm_func_output *func_output;
1669 tdm_private_output_commit_handler *output_commit_handler = NULL;
1670 tdm_private_voutput_commit_handler *voutput_commit_handler = NULL;
1671 tdm_private_layer *private_layer = NULL;
1672 tdm_output_dpms dpms_value = TDM_OUTPUT_DPMS_ON;
1673 tdm_error ret = TDM_ERROR_NONE;
1675 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
1677 private_output = (tdm_private_output*)output;
1678 private_module = private_output->private_module;
1679 private_display = private_module->private_display;
1680 func_output = &private_module->func_output;
1682 if (!private_module->use_hal_tdm) {
1683 if (!func_output->output_commit) {
1684 TDM_WRN("not implemented!!");
1685 return TDM_ERROR_NOT_IMPLEMENTED;
1689 ret = tdm_output_get_dpms_internal(output, &dpms_value);
1690 TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret);
1692 if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
1693 if (!private_output->regist_commit_cb) {
1694 private_output->regist_commit_cb = 1;
1695 if (private_module->use_hal_tdm)
1696 ret = (tdm_error)hal_tdm_output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit_hal_tdm);
1698 ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit);
1699 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
1702 output_commit_handler = calloc(1, sizeof(tdm_private_output_commit_handler));
1703 if (!output_commit_handler) {
1704 TDM_ERR("failed: alloc memory");
1705 return TDM_ERROR_OUT_OF_MEMORY;
1708 if (private_module == private_display->virtual_module) {
1709 if (!private_output->private_voutput) {
1710 TDM_ERR("virtual module but don't have voutput");
1711 free(output_commit_handler);
1712 return TDM_ERROR_BAD_MODULE;
1716 ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
1717 if (ret != TDM_ERROR_NONE) {
1718 TDM_ERR("tdm_thread_cb_add failed");
1719 free(output_commit_handler);
1723 LIST_ADDTAIL(&output_commit_handler->link, &private_output->output_commit_handler_list);
1724 output_commit_handler->private_output = private_output;
1725 output_commit_handler->func = func;
1726 output_commit_handler->user_data = user_data;
1727 output_commit_handler->owner_tid = syscall(SYS_gettid);
1729 if (private_module == private_display->virtual_module) {
1730 private_voutput = private_output->private_voutput;
1732 /* voutput use only 1 layer */
1733 private_layer = LIST_FIRST_ENTRY(&private_output->layer_list, tdm_private_layer, link);
1735 if (LIST_LENGTH(&private_voutput->voutput_commit_handler_list) != 0) {
1736 voutput_commit_handler = LIST_FIRST_ENTRY(&private_voutput->voutput_commit_handler_list, tdm_private_voutput_commit_handler, link);
1737 voutput_commit_handler->user_data = private_layer->commiting_buffer;
1740 if (private_module->use_hal_tdm)
1741 ret = (tdm_error)hal_tdm_output_commit(private_output->output_backend, sync, output_commit_handler);
1743 ret = func_output->output_commit(private_output->output_backend, sync, output_commit_handler);
1744 TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
1746 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1747 TDM_INFO("output(%d) backend commit: handle(%p) func(%p) user_data(%p)",
1748 private_output->pipe, output_commit_handler, func, user_data);
1751 /* Even if DPMS is off, committed_buffer should be changed because it will be referred
1752 * for tdm_layer_committed() function.
1754 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
1755 if (!private_layer->waiting_buffer)
1758 if (private_layer->committed_buffer) {
1759 tdm_layer_free_buffer(private_layer, private_layer->committed_buffer);
1760 private_layer->committed_buffer = NULL;
1761 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1762 TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)",
1763 private_layer, private_layer->waiting_buffer->buffer,
1764 private_layer->committed_buffer);
1767 private_layer->committed_buffer = private_layer->waiting_buffer;
1768 private_layer->waiting_buffer = NULL;
1769 private_layer->commiting_buffer = NULL;
1770 if (tdm_debug_module & TDM_DEBUG_BUFFER)
1771 TDM_INFO("layer(%p) waiting_buffer(%p) committed_buffer(%p)",
1772 private_layer, private_layer->waiting_buffer,
1773 private_layer->committed_buffer->buffer);
1776 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
1777 TDM_WRN("dpms %s. Directly call commit handler instead of commit.", tdm_dpms_str(dpms_value));
1779 _pthread_mutex_unlock(&private_display->lock);
1780 func(output, 0, 0, 0, user_data);
1781 _pthread_mutex_lock(&private_display->lock);
1788 if (output_commit_handler) {
1789 tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_COMMIT, output_commit_handler, _tdm_output_thread_cb_commit, NULL);
1790 LIST_DEL(&output_commit_handler->link);
1791 free(output_commit_handler);
1798 tdm_output_commit(tdm_output *output, int sync, tdm_output_commit_handler func,
1801 tdm_private_layer *private_layer = NULL;
1803 OUTPUT_FUNC_ENTRY();
1805 _pthread_mutex_lock(&private_display->lock);
1807 if (private_output->commit_type == TDM_COMMIT_TYPE_NONE)
1808 private_output->commit_type = TDM_COMMIT_TYPE_OUTPUT;
1809 else if (private_output->commit_type == TDM_COMMIT_TYPE_LAYER) {
1810 TDM_ERR("Can't supported. Use tdm_layer_commit");
1811 _pthread_mutex_unlock(&private_display->lock);
1812 return TDM_ERROR_BAD_REQUEST;
1815 if (private_output->commit_per_vblank) {
1816 TDM_ERR("Use tdm_layer_commit");
1817 _pthread_mutex_unlock(&private_display->lock);
1818 return TDM_ERROR_BAD_REQUEST;
1821 if (TDM_OUTPUT_DPMS_VSYNC_IS_OFF(private_output->current_dpms_value)) {
1822 TDM_ERR("output(%d) dpms: %s", private_output->pipe,
1823 tdm_dpms_str(private_output->current_dpms_value));
1824 _pthread_mutex_unlock(&private_display->lock);
1825 return TDM_ERROR_DPMS_OFF;
1828 if (tdm_debug_module & TDM_DEBUG_COMMIT)
1829 TDM_INFO("output(%d) commit", private_output->pipe);
1831 /* apply the pending data of all layers */
1832 LIST_FOR_EACH_ENTRY(private_layer, &private_output->layer_list, link) {
1833 tdm_layer_commit_pending_data(private_layer);
1836 ret = tdm_output_commit_internal(output, sync, func, user_data);
1838 _pthread_mutex_unlock(&private_display->lock);
1842 /* LCOV_EXCL_STOP */
1845 tdm_output_set_mode(tdm_output *output, const tdm_output_mode *mode)
1847 tdm_private_module *private_module;
1848 tdm_func_output *func_output;
1849 OUTPUT_FUNC_ENTRY();
1851 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1853 _pthread_mutex_lock(&private_display->lock);
1855 private_module = private_output->private_module;
1856 func_output = &private_module->func_output;
1858 if (private_module->use_hal_tdm) {
1859 ret = (tdm_error)hal_tdm_output_set_mode(private_output->output_backend, (const hal_tdm_output_mode *)mode);
1861 if (!func_output->output_set_mode) {
1862 /* LCOV_EXCL_START */
1863 _pthread_mutex_unlock(&private_display->lock);
1864 TDM_WRN("not implemented!!");
1865 return TDM_ERROR_NOT_IMPLEMENTED;
1866 /* LCOV_EXCL_STOP */
1869 ret = func_output->output_set_mode(private_output->output_backend, mode);
1871 if (ret == TDM_ERROR_NONE) {
1872 private_output->current_mode = mode;
1873 private_output->need_set_target_info = 1;
1874 TDM_INFO("mode: %dx%d %dhz", mode->hdisplay, mode->vdisplay, mode->vrefresh);
1877 _pthread_mutex_unlock(&private_display->lock);
1883 tdm_output_get_mode(tdm_output *output, const tdm_output_mode **mode)
1885 OUTPUT_FUNC_ENTRY();
1887 TDM_RETURN_VAL_IF_FAIL(mode != NULL, TDM_ERROR_INVALID_PARAMETER);
1889 _pthread_mutex_lock(&private_display->lock);
1891 *mode = private_output->current_mode;
1893 _pthread_mutex_unlock(&private_display->lock);
1899 tdm_output_set_dpms(tdm_output *output, tdm_output_dpms dpms_value)
1901 tdm_private_module *private_module;
1902 tdm_func_output *func_output;
1903 OUTPUT_FUNC_ENTRY();
1905 if (dpms_value > TDM_OUTPUT_DPMS_OFF) {
1906 if (dpms_value & TDM_OUTPUT_DPMS_DEFAULT_MASK) {
1907 TDM_ERR("Don't use the low-4bit for an extended DPMS mode: dpms_value(%x)", dpms_value);
1908 return TDM_ERROR_BAD_REQUEST;
1911 if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_EXTENDED_DPMS)) {
1912 TDM_ERR("output(%d) doesn't support the extended DPMS control: '%s'",
1913 private_output->pipe, tdm_dpms_str(dpms_value));
1914 return TDM_ERROR_BAD_REQUEST;
1918 _pthread_mutex_lock(&private_display->lock);
1920 if (private_output->waiting_dpms_change) {
1921 TDM_ERR("DPMS is not changed yet. Can't be changed twice");
1922 _pthread_mutex_unlock(&private_display->lock);
1923 return TDM_ERROR_BAD_REQUEST;
1926 private_module = private_output->private_module;
1927 func_output = &private_module->func_output;
1929 TDM_INFO("output(%d) DPMS '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
1931 if (private_module->use_hal_tdm) {
1932 ret = (tdm_error)hal_tdm_output_set_dpms(private_output->output_backend, (hal_tdm_output_dpms)dpms_value);
1934 if (func_output->output_set_dpms)
1935 ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
1937 /* LCOV_EXCL_START */
1938 ret = TDM_ERROR_NONE;
1939 TDM_WRN("DPMS not implemented!!");
1940 /* LCOV_EXCL_STOP */
1944 if (ret == TDM_ERROR_NONE) {
1945 if (private_output->current_dpms_value != dpms_value) {
1946 private_output->current_dpms_value = dpms_value;
1947 _tdm_output_call_thread_cb_dpms(private_output, dpms_value);
1949 TDM_INFO("output(%d) DPMS '%s' done", private_output->pipe, tdm_dpms_str(dpms_value));
1951 tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
1953 /* update current_dpms_value forcely */
1954 tdm_output_get_dpms_internal(output, &temp);
1956 TDM_ERR("output(%d) set DPMS failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
1959 _pthread_mutex_unlock(&private_display->lock);
1964 /* LCOV_EXCL_START */
1966 tdm_output_set_dpms_async(tdm_output *output, tdm_output_dpms dpms_value)
1968 tdm_private_module *private_module;
1969 tdm_func_output *func_output;
1971 OUTPUT_FUNC_ENTRY();
1973 if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_ASYNC_DPMS)) {
1974 TDM_ERR("output doesn't support the asynchronous DPMS control!");
1975 return TDM_ERROR_BAD_REQUEST;
1978 if (dpms_value > TDM_OUTPUT_DPMS_OFF) {
1979 if (dpms_value & TDM_OUTPUT_DPMS_DEFAULT_MASK) {
1980 TDM_ERR("Don't use the low-4bit for an extended DPMS mode: dpms_value(%x)", dpms_value);
1981 return TDM_ERROR_BAD_REQUEST;
1984 if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_EXTENDED_DPMS)) {
1985 TDM_ERR("output(%d) doesn't support the extended DPMS control: '%s'",
1986 private_output->pipe, tdm_dpms_str(dpms_value));
1987 return TDM_ERROR_BAD_REQUEST;
1991 _pthread_mutex_lock(&private_display->lock);
1993 if (private_output->waiting_dpms_change) {
1994 TDM_ERR("DPMS is not changed yet. Can't be changed twice");
1995 _pthread_mutex_unlock(&private_display->lock);
1996 return TDM_ERROR_BAD_REQUEST;
1999 private_module = private_output->private_module;
2000 func_output = &private_module->func_output;
2001 if (!private_module->use_hal_tdm) {
2002 if (!func_output->output_set_dpms_handler) {
2003 TDM_WRN("not implemented DPMS: output_set_dpms_handler");
2004 _pthread_mutex_unlock(&private_display->lock);
2005 return TDM_ERROR_NOT_IMPLEMENTED;
2008 if (!func_output->output_set_dpms_async) {
2009 TDM_WRN("not implemented DPMS: output_set_dpms_async");
2010 _pthread_mutex_unlock(&private_display->lock);
2011 return TDM_ERROR_NOT_IMPLEMENTED;
2015 if (!private_output->regist_dpms_cb) {
2016 private_output->regist_dpms_cb = 1;
2017 if (private_module->use_hal_tdm)
2018 ret = (tdm_error)hal_tdm_output_set_dpms_handler(private_output->output_backend,
2019 tdm_output_cb_dpms_hal_tdm, private_output);
2021 ret = func_output->output_set_dpms_handler(private_output->output_backend,
2022 tdm_output_cb_dpms, private_output);
2023 if (ret != TDM_ERROR_NONE) {
2024 _pthread_mutex_unlock(&private_display->lock);
2025 TDM_ERR("Can't set the DPMS handler!!");
2030 TDM_INFO("output(%d) DPMS async '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
2032 if (private_module->use_hal_tdm)
2033 ret = (tdm_error)hal_tdm_output_set_dpms_async(private_output->output_backend, (hal_tdm_output_dpms)dpms_value, &sync);
2035 ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync);
2037 if (ret == TDM_ERROR_NONE) {
2039 tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
2041 tdm_output_get_dpms_internal(output, &temp);
2042 TDM_INFO("output(%d) DPMS async '%s'(%s) done", private_output->pipe, tdm_dpms_str(dpms_value), tdm_dpms_str(temp));
2044 private_output->waiting_dpms_change = 1;
2045 TDM_INFO("output(%d) DPMS async '%s' waiting", private_output->pipe, tdm_dpms_str(dpms_value));
2048 tdm_output_dpms temp = TDM_OUTPUT_DPMS_OFF;
2050 /* update current_dpms_value forcely */
2051 tdm_output_get_dpms_internal(output, &temp);
2053 TDM_ERR("output(%d) set DPMS async failed: dpms '%s'", private_output->pipe, tdm_dpms_str(temp));
2056 _pthread_mutex_unlock(&private_display->lock);
2060 /* LCOV_EXCL_STOP */
2063 tdm_output_get_dpms_internal(tdm_output *output, tdm_output_dpms *dpms_value)
2065 tdm_private_output *private_output;
2066 tdm_private_module *private_module;
2067 tdm_func_output *func_output;
2068 tdm_error ret = TDM_ERROR_NONE;
2070 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
2072 private_output = (tdm_private_output*)output;
2074 /* TODO: this is ugly. But before calling backend's output_get_dpms(), we have
2075 * to check if all backends's DPMS operation has no problem. In future, we'd
2076 * better use new env instead of using commit_per_vblank variable to distinguish
2077 * whether we use the stored value or backend's output_get_dpms.
2079 if (!private_output->commit_per_vblank) {
2080 *dpms_value = private_output->current_dpms_value;
2081 return TDM_ERROR_NONE;
2084 private_module = private_output->private_module;
2085 func_output = &private_module->func_output;
2087 if (private_module->use_hal_tdm) {
2088 ret = (tdm_error)hal_tdm_output_get_dpms(private_output->output_backend, (hal_tdm_output_dpms *)dpms_value);
2090 if (!func_output->output_get_dpms) {
2091 /* LCOV_EXCL_START */
2092 *dpms_value = private_output->current_dpms_value;
2093 TDM_WRN("DPMS get not implemented!!");
2094 return TDM_ERROR_NONE;
2095 /* LCOV_EXCL_STOP */
2098 ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
2100 if (ret != TDM_ERROR_NONE) {
2101 /* LCOV_EXCL_START */
2102 TDM_ERR("output get DPMS failed");
2103 *dpms_value = TDM_OUTPUT_DPMS_OFF;
2104 /* LCOV_EXCL_STOP */
2107 /* checking with backend's value */
2108 if (*dpms_value != private_output->current_dpms_value) {
2109 TDM_ERR("output(%d) DPMS changed suddenly: %s -> %s",
2110 private_output->pipe, tdm_dpms_str(private_output->current_dpms_value),
2111 tdm_dpms_str(*dpms_value));
2112 private_output->current_dpms_value = *dpms_value;
2113 _tdm_output_call_thread_cb_dpms(private_output, *dpms_value);
2120 tdm_output_get_dpms_changing(tdm_output *output, int *changing)
2122 tdm_private_output *private_output;
2124 TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_INVALID_PARAMETER);
2125 TDM_RETURN_VAL_IF_FAIL(changing != NULL, TDM_ERROR_INVALID_PARAMETER);
2127 private_output = (tdm_private_output*)output;
2129 *changing = private_output->waiting_dpms_change;
2131 return TDM_ERROR_NONE;
2136 tdm_output_get_dpms(tdm_output *output, tdm_output_dpms *dpms_value)
2138 OUTPUT_FUNC_ENTRY();
2140 TDM_RETURN_VAL_IF_FAIL(dpms_value != NULL, TDM_ERROR_INVALID_PARAMETER);
2142 _pthread_mutex_lock(&private_display->lock);
2144 ret = tdm_output_get_dpms_internal(output, dpms_value);
2146 _pthread_mutex_unlock(&private_display->lock);
2152 tdm_output_has_capture_capability(tdm_output *output, unsigned int *has_capability)
2154 tdm_private_module *private_module;
2156 OUTPUT_FUNC_ENTRY();
2158 TDM_RETURN_VAL_IF_FAIL(has_capability != NULL, TDM_ERROR_INVALID_PARAMETER);
2160 _pthread_mutex_lock(&private_display->lock);
2162 private_module = private_output->private_module;
2164 if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE))
2165 *has_capability = 0;
2166 else if (!(private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT))
2167 *has_capability = 0;
2169 *has_capability = 1;
2171 _pthread_mutex_unlock(&private_display->lock);
2176 EXTERN tdm_capture *
2177 tdm_output_create_capture(tdm_output *output, tdm_error *error)
2179 tdm_capture *capture = NULL;
2181 OUTPUT_FUNC_ENTRY_ERROR();
2183 _pthread_mutex_lock(&private_display->lock);
2185 capture = (tdm_capture *)tdm_capture_create_output_internal(private_output, error);
2187 _pthread_mutex_unlock(&private_display->lock);
2193 tdm_output_get_hwc(tdm_output *output, tdm_error *error)
2195 tdm_private_hwc *private_hwc = NULL;
2197 OUTPUT_FUNC_ENTRY_ERROR();
2199 _pthread_mutex_lock(&private_display->lock);
2201 private_hwc = private_output->private_hwc;
2204 *error = TDM_ERROR_BAD_REQUEST;
2205 _pthread_mutex_unlock(&private_display->lock);
2210 *error = TDM_ERROR_NONE;
2212 _pthread_mutex_unlock(&private_display->lock);
2218 tdm_output_set_mirror(tdm_output *output, tdm_output *src_output, tdm_transform transform)
2220 /* LCOV_EXCL_START */
2221 tdm_private_module *private_module;
2222 tdm_func_output *func_output;
2223 tdm_private_output *private_src_output;
2225 OUTPUT_FUNC_ENTRY();
2227 TDM_RETURN_VAL_IF_FAIL(src_output != NULL, TDM_ERROR_INVALID_PARAMETER);
2229 _pthread_mutex_lock(&private_display->lock);
2231 private_module = private_output->private_module;
2232 func_output = &private_module->func_output;
2233 private_src_output = (tdm_private_output*)src_output;
2235 if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_MIRROR)) {
2236 TDM_INFO("output(%d) doesn't support the mirror.", private_output->pipe);
2237 _pthread_mutex_unlock(&private_display->lock);
2238 return TDM_ERROR_BAD_REQUEST;
2241 if (private_module->use_hal_tdm) {
2242 ret = (tdm_error)hal_tdm_output_set_mirror((hal_tdm_output *)private_output->output_backend,
2243 (hal_tdm_output *)private_src_output->output_backend, (hal_tdm_transform)transform);
2246 if (!func_output->output_set_mirror) {
2247 TDM_WRN("not implemented!!");
2248 _pthread_mutex_unlock(&private_display->lock);
2249 return TDM_ERROR_NOT_IMPLEMENTED;
2252 ret = func_output->output_set_mirror(private_output->output_backend,
2253 private_src_output->output_backend,
2256 if (ret != TDM_ERROR_NONE) {
2257 TDM_ERR("output(%p) fails to set MIRROR.", private_output);
2258 _pthread_mutex_unlock(&private_display->lock);
2259 return TDM_ERROR_BAD_REQUEST;
2262 _pthread_mutex_unlock(&private_display->lock);
2265 /* LCOV_EXCL_STOP */
2269 tdm_output_unset_mirror(tdm_output *output)
2271 /* LCOV_EXCL_START */
2272 tdm_private_module *private_module;
2273 tdm_func_output *func_output;
2275 OUTPUT_FUNC_ENTRY();
2277 _pthread_mutex_lock(&private_display->lock);
2279 private_module = private_output->private_module;
2280 func_output = &private_module->func_output;
2282 if (!(private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_MIRROR)) {
2283 TDM_INFO("output(%d) doesn't support the mirror.", private_output->pipe);
2284 _pthread_mutex_unlock(&private_display->lock);
2285 return TDM_ERROR_BAD_REQUEST;
2288 if (private_module->use_hal_tdm) {
2289 ret = (tdm_error)hal_tdm_output_unset_mirror((hal_tdm_output *)private_output->output_backend);
2291 if (!func_output->output_unset_mirror) {
2292 TDM_WRN("not implemented!!");
2293 _pthread_mutex_unlock(&private_display->lock);
2294 return TDM_ERROR_NOT_IMPLEMENTED;
2297 ret = func_output->output_unset_mirror(private_output->output_backend);
2299 if (ret != TDM_ERROR_NONE) {
2300 TDM_ERR("output(%p) fails to unset MIRROR.", private_output);
2301 _pthread_mutex_unlock(&private_display->lock);
2302 return TDM_ERROR_BAD_REQUEST;
2305 _pthread_mutex_unlock(&private_display->lock);
2308 /* LCOV_EXCL_STOP */
2312 tdm_output_choose_commit_per_vblank_mode(tdm_private_output *private_output, int mode)
2314 if (!private_output)
2315 return TDM_ERROR_INVALID_PARAMETER;
2317 if (mode < 0 || mode > 2)
2318 return TDM_ERROR_INVALID_PARAMETER;
2320 private_output->commit_per_vblank = mode;
2322 if (private_output->commit_per_vblank == 0)
2323 TDM_INFO("commit per vblank: disable");
2324 else if (private_output->commit_per_vblank == 1)
2325 TDM_INFO("commit per vblank: enable (1 layer)");
2326 else if (private_output->commit_per_vblank == 2)
2327 TDM_INFO("commit per vblank: enable (previous commit)");
2329 return TDM_ERROR_NONE;
2332 /* LCOV_EXCL_START */
2334 tdm_voutput_destroy(tdm_voutput *voutput)
2336 tdm_private_module *private_module = NULL;
2337 tdm_voutput *voutput_backend = NULL;
2338 tdm_func_voutput *func_voutput = NULL;
2340 tdm_private_display *private_display;
2341 tdm_private_voutput *private_voutput;
2342 tdm_private_output *private_output;
2343 tdm_error ret = TDM_ERROR_NONE;
2344 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2345 private_voutput = (tdm_private_voutput*)voutput;
2346 private_display = private_voutput->private_display;
2347 private_module = private_voutput->private_module;
2348 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2350 _pthread_mutex_lock(&private_display->lock);
2352 func_voutput = &private_module->func_voutput;
2353 voutput_backend = private_voutput->voutput_backend;
2354 private_output = private_voutput->private_output;
2355 tdm_display_destroy_private_output(private_output);
2356 LIST_DEL(&private_voutput->link);
2357 free(private_voutput);
2358 if (func_voutput->voutput_destroy)
2359 ret = func_voutput->voutput_destroy(voutput_backend);
2361 _pthread_mutex_unlock(&private_display->lock);
2367 tdm_voutput_set_available_mode(tdm_voutput *voutput, const tdm_output_mode *modes, int count)
2369 tdm_private_display *private_display;
2370 tdm_private_module *private_module = NULL;
2371 tdm_private_voutput *private_voutput;
2372 tdm_func_voutput *func_voutput = NULL;
2373 tdm_error ret = TDM_ERROR_NONE;
2375 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2376 TDM_RETURN_VAL_IF_FAIL(modes != NULL, TDM_ERROR_INVALID_PARAMETER);
2377 TDM_RETURN_VAL_IF_FAIL(count != 0, TDM_ERROR_INVALID_PARAMETER);
2379 private_voutput = (tdm_private_voutput*)voutput;
2380 private_display = private_voutput->private_display;
2381 private_module = private_voutput->private_module;
2382 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2384 _pthread_mutex_lock(&private_display->lock);
2386 if (private_module->use_hal_tdm) {
2387 ret = (tdm_error)hal_tdm_voutput_set_available_mode((hal_tdm_voutput *)private_voutput->voutput_backend,
2388 (const hal_tdm_output_mode *)modes, count);
2390 func_voutput = &private_module->func_voutput;
2391 if (func_voutput->voutput_set_available_mode)
2392 ret = func_voutput->voutput_set_available_mode(private_voutput->voutput_backend, modes, count);
2394 ret = TDM_ERROR_NOT_IMPLEMENTED;
2396 _pthread_mutex_unlock(&private_display->lock);
2402 tdm_voutput_set_physical_size(tdm_voutput *voutput, unsigned int mmwidth, unsigned int mmheight)
2404 tdm_private_display *private_display;
2405 tdm_private_module *private_module = NULL;
2406 tdm_private_voutput *private_voutput;
2407 tdm_func_voutput *func_voutput = NULL;
2408 tdm_error ret = TDM_ERROR_NONE;
2410 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2411 TDM_RETURN_VAL_IF_FAIL(mmwidth != 0, TDM_ERROR_INVALID_PARAMETER);
2412 TDM_RETURN_VAL_IF_FAIL(mmheight != 0, TDM_ERROR_INVALID_PARAMETER);
2414 private_voutput = (tdm_private_voutput*)voutput;
2415 private_display = private_voutput->private_display;
2416 private_module = private_voutput->private_module;
2417 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2419 _pthread_mutex_lock(&private_display->lock);
2421 if (private_module->use_hal_tdm) {
2422 ret = (tdm_error)hal_tdm_voutput_set_physical_size((hal_tdm_voutput *)private_voutput->voutput_backend, mmwidth, mmheight);
2424 func_voutput = &private_module->func_voutput;
2425 if (func_voutput->voutput_set_physical_size)
2426 ret = func_voutput->voutput_set_physical_size(private_voutput->voutput_backend, mmwidth, mmheight);
2428 ret = TDM_ERROR_NOT_IMPLEMENTED;
2430 _pthread_mutex_unlock(&private_display->lock);
2436 tdm_voutput_connect(tdm_voutput *voutput)
2438 tdm_private_display *private_display;
2439 tdm_private_module *private_module = NULL;
2440 tdm_private_voutput *private_voutput;
2441 tdm_func_voutput *func_voutput = NULL;
2442 tdm_error ret = TDM_ERROR_NONE;
2444 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2446 private_voutput = (tdm_private_voutput*)voutput;
2447 private_display = private_voutput->private_display;
2448 private_module = private_voutput->private_module;
2449 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2451 _pthread_mutex_lock(&private_display->lock);
2453 if (private_module->use_hal_tdm) {
2454 ret = (tdm_error)hal_tdm_voutput_connect((hal_tdm_voutput *)private_voutput->voutput_backend);
2456 func_voutput = &private_module->func_voutput;
2457 if (func_voutput->voutput_connect)
2458 ret = func_voutput->voutput_connect(private_voutput->voutput_backend);
2460 ret = TDM_ERROR_NOT_IMPLEMENTED;
2462 _pthread_mutex_unlock(&private_display->lock);
2468 tdm_voutput_disconnect(tdm_voutput *voutput)
2470 tdm_private_display *private_display;
2471 tdm_private_module *private_module = NULL;
2472 tdm_private_voutput *private_voutput;
2473 tdm_func_voutput *func_voutput = NULL;
2474 tdm_error ret = TDM_ERROR_NONE;
2476 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2478 private_voutput = (tdm_private_voutput*)voutput;
2479 private_display = private_voutput->private_display;
2480 private_module = private_voutput->private_module;
2481 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2483 _pthread_mutex_lock(&private_display->lock);
2485 if (private_module->use_hal_tdm) {
2486 ret = (tdm_error)hal_tdm_voutput_disconnect((hal_tdm_voutput *)private_voutput->voutput_backend);
2488 func_voutput = &private_module->func_voutput;
2489 if (func_voutput->voutput_disconnect)
2490 ret = func_voutput->voutput_disconnect(private_voutput->voutput_backend);
2492 ret = TDM_ERROR_NOT_IMPLEMENTED;
2494 _pthread_mutex_unlock(&private_display->lock);
2500 tdm_voutput_set_commit_func(tdm_voutput *voutput, tdm_voutput_commit_handler func)
2502 tdm_private_display *private_display;
2503 tdm_private_module *private_module = NULL;
2504 tdm_private_voutput *private_voutput;
2505 tdm_func_voutput *func_voutput = NULL;
2506 tdm_error ret = TDM_ERROR_NONE;
2508 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2510 private_voutput = (tdm_private_voutput*)voutput;
2511 private_display = private_voutput->private_display;
2512 private_module = private_voutput->private_module;
2513 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2515 if (private_module->use_hal_tdm) {
2516 ret = (tdm_error)hal_tdm_voutput_set_commit_func((hal_tdm_voutput *)private_voutput->voutput_backend,
2517 (hal_tdm_voutput_commit_handler)func);
2519 func_voutput = &private_module->func_voutput;
2520 if (func_voutput->voutput_set_commit_func)
2521 ret = func_voutput->voutput_set_commit_func(private_voutput->voutput_backend, func);
2523 ret = TDM_ERROR_NOT_IMPLEMENTED;
2529 tdm_voutput_commit_done(tdm_voutput *voutput)
2531 tdm_private_display *private_display;
2532 tdm_private_module *private_module = NULL;
2533 tdm_private_voutput *private_voutput;
2534 tdm_func_voutput *func_voutput = NULL;
2535 tdm_error ret = TDM_ERROR_NONE;
2537 TDM_RETURN_VAL_IF_FAIL(voutput != NULL, TDM_ERROR_INVALID_PARAMETER);
2539 private_voutput = (tdm_private_voutput*)voutput;
2540 private_display = private_voutput->private_display;
2541 private_module = private_voutput->private_module;
2542 TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
2544 _pthread_mutex_lock(&private_display->lock);
2546 if (private_module->use_hal_tdm) {
2547 ret = (tdm_error)hal_tdm_voutput_commit_done((hal_tdm_voutput *)private_voutput->voutput_backend);
2549 func_voutput = &private_module->func_voutput;
2550 if (func_voutput->voutput_commit_done)
2551 ret = func_voutput->voutput_commit_done(private_voutput->voutput_backend);
2553 ret = TDM_ERROR_NOT_IMPLEMENTED;
2555 _pthread_mutex_unlock(&private_display->lock);
2559 /* LCOV_EXCL_STOP */