X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm.c;h=08a9136f472f04cee04a6feef7383c56613928f2;hb=e3bf909bf70dabcee8bb28a68fdb75b1a93fc671;hp=24ee03891c8e761c3a33ccadba69171294808f1c;hpb=8a34b8790d9bc2b027f6ba2ac0338a0dea09f29c;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm.c b/src/tdm.c old mode 100755 new mode 100644 index 24ee038..08a9136 --- a/src/tdm.c +++ b/src/tdm.c @@ -1,50 +1,59 @@ /************************************************************************** - -libtdm - -Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. - -Contact: Eunchul Kim , - JinYoung Jeon , - Taeheon Kim , - YoungJun Cho , - SooChan Lim , - Boram Park - -Permission is hereby granted, free of charge, to any person obtaining a -copy of this software and associated documentation files (the -"Software"), to deal in the Software without restriction, including -without limitation the rights to use, copy, modify, merge, publish, -distribute, sub license, and/or sell copies of the Software, and to -permit persons to whom the Software is furnished to do so, subject to -the following conditions: - -The above copyright notice and this permission notice (including the -next paragraph) shall be included in all copies or substantial portions -of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF -MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. -IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR -ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, -TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE -SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. - + * + * libtdm + * + * Copyright 2015 Samsung Electronics co., Ltd. All Rights Reserved. + * + * Contact: Eunchul Kim , + * JinYoung Jeon , + * Taeheon Kim , + * YoungJun Cho , + * SooChan Lim , + * Boram Park + * + * Permission is hereby granted, free of charge, to any person obtaining a + * copy of this software and associated documentation files (the + * "Software"), to deal in the Software without restriction, including + * without limitation the rights to use, copy, modify, merge, publish, + * distribute, sub license, and/or sell copies of the Software, and to + * permit persons to whom the Software is furnished to do so, subject to + * the following conditions: + * + * The above copyright notice and this permission notice (including the + * next paragraph) shall be included in all copies or substantial portions + * of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. + * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. + * **************************************************************************/ #ifdef HAVE_CONFIG_H #include "config.h" #endif -#include "tdm.h" -#include "tdm_backend.h" #include "tdm_private.h" -#include "tdm_helper.h" +pthread_mutex_t tdm_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER; +int tdm_mutex_locked; +const char *tdm_mutex_lock_func; +int tdm_mutex_lock_line; +const char *tdm_mutex_unlock_func; +int tdm_mutex_unlock_line; + +pthread_mutex_t tdm_debug_mutex_check_lock = PTHREAD_MUTEX_INITIALIZER; +const char *tdm_debug_mutex_lock_func; +int tdm_debug_mutex_lock_line; + +/* LCOV_EXCL_START */ static tdm_private_layer * _tdm_display_find_private_layer(tdm_private_output *private_output, - tdm_layer *layer_backend) + tdm_layer *layer_backend) { tdm_private_layer *private_layer = NULL; @@ -56,29 +65,33 @@ _tdm_display_find_private_layer(tdm_private_output *private_output, return NULL; } -static tdm_private_output * -_tdm_display_find_private_output(tdm_private_display *private_display, - tdm_output *output_backend) +INTERN tdm_private_output * +tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend) { + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) { - if (private_output->output_backend == output_backend) - return private_output; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { + if (private_output->output_backend == output_backend) + return private_output; + } } return NULL; } -INTERN tdm_private_output * -tdm_display_find_output_stamp(tdm_private_display *private_display, - unsigned long stamp) +INTERN void * +tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp) { + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) { - if (private_output->stamp == stamp) - return private_output; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) { + if (private_output->stamp == stamp) + return private_output; + } } return NULL; @@ -87,30 +100,42 @@ tdm_display_find_output_stamp(tdm_private_display *private_display, static void _tdm_display_destroy_caps_pp(tdm_caps_pp *caps_pp) { - free(caps_pp->formats); + if (caps_pp->formats) + free(caps_pp->formats); + memset(caps_pp, 0, sizeof(tdm_caps_pp)); } static void _tdm_display_destroy_caps_capture(tdm_caps_capture *caps_capture) { - free(caps_capture->formats); + if (caps_capture->formats) + free(caps_capture->formats); + memset(caps_capture, 0, sizeof(tdm_caps_capture)); } static void _tdm_display_destroy_caps_layer(tdm_caps_layer *caps_layer) { - free(caps_layer->formats); - free(caps_layer->props); + if (caps_layer->formats) + free(caps_layer->formats); + + if (caps_layer->props) + free(caps_layer->props); + memset(caps_layer, 0, sizeof(tdm_caps_layer)); } static void _tdm_display_destroy_caps_output(tdm_caps_output *caps_output) { - free(caps_output->modes); - free(caps_output->props); + if (caps_output->modes) + free(caps_output->modes); + + if (caps_output->props) + free(caps_output->props); + memset(caps_output, 0, sizeof(tdm_caps_output)); } @@ -119,57 +144,100 @@ _tdm_display_destroy_private_layer(tdm_private_layer *private_layer) { tdm_private_capture *c = NULL, *cc = NULL; - LIST_DEL(&private_layer->link); + tdm_layer_unset_buffer_internal(private_layer); LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_layer->capture_list, link) tdm_capture_destroy_internal(c); _tdm_display_destroy_caps_layer(&private_layer->caps); + /* when destroying layer, someone could check if layer is valid. So delete + * the layer's link at last. + */ + LIST_DEL(&private_layer->link); + free(private_layer); } static void _tdm_display_destroy_private_output(tdm_private_output *private_output) { + tdm_private_display *private_display = private_output->private_display; tdm_private_layer *l = NULL, *ll = NULL; + tdm_private_hwc_window *hw = NULL, *hww = NULL; tdm_private_capture *c = NULL, *cc = NULL; - tdm_private_vblank_handler *v = NULL, *vv = NULL; - tdm_private_commit_handler *m = NULL, *mm = NULL; - tdm_private_change_handler *h = NULL, *hh = NULL; - - LIST_DEL(&private_output->link); + tdm_private_output_vblank_handler *v = NULL, *vv = NULL; + tdm_private_output_commit_handler *om = NULL, *omm = NULL; + tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL; + tdm_private_output_change_handler *h = NULL, *hh = NULL; free(private_output->layers_ptr); + if (private_output->vblank_timeout_timer) + tdm_event_loop_source_remove(private_output->vblank_timeout_timer); + LIST_FOR_EACH_ENTRY_SAFE(v, vv, &private_output->vblank_handler_list, link) { LIST_DEL(&v->link); free(v); } - LIST_FOR_EACH_ENTRY_SAFE(m, mm, &private_output->commit_handler_list, link) { - LIST_DEL(&m->link); - free(m); + LIST_FOR_EACH_ENTRY_SAFE(om, omm, &private_output->output_commit_handler_list, link) { + LIST_DEL(&om->link); + free(om); } - LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_main, link) { - LIST_DEL(&h->link); - free(h); + LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) { + LIST_DEL(&lm->link); + free(lm); + } + + LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->pending_commit_handler_list, link) { + LIST_DEL(&lm->link); + free(lm); } - LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list_sub, link) { + LIST_FOR_EACH_ENTRY_SAFE(h, hh, &private_output->change_handler_list, link) { LIST_DEL(&h->link); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_DPMS, NULL, tdm_output_thread_cb_change, h); + tdm_thread_cb_remove(h->private_output, TDM_THREAD_CB_OUTPUT_STATUS, NULL, tdm_output_thread_cb_change, h); free(h); } + if (private_output->vblank) { + /* tdm_vblank APIs is for server. it should be called in unlock status*/ + _pthread_mutex_unlock(&private_display->lock); + tdm_vblank_destroy(private_output->vblank); + _pthread_mutex_lock(&private_display->lock); + } + + if (private_output->ttrace_vblank) { + /* tdm_vblank APIs is for server. it should be called in unlock status*/ + _pthread_mutex_unlock(&private_display->lock); + tdm_vblank_destroy(private_output->ttrace_vblank); + _pthread_mutex_lock(&private_display->lock); + } + LIST_FOR_EACH_ENTRY_SAFE(c, cc, &private_output->capture_list, link) tdm_capture_destroy_internal(c); + LIST_FOR_EACH_ENTRY_SAFE(hw, hww, &private_output->hwc_window_list, link) + tdm_hwc_window_destroy_internal(hw); + LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link) _tdm_display_destroy_private_layer(l); _tdm_display_destroy_caps_output(&private_output->caps); + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_NEED_VALIDATE, NULL, + tdm_output_need_validate_handler_thread, NULL); + tdm_event_loop_source_remove(private_output->need_validate.event_source); + close(private_output->need_validate.event_fd); + + /* when destroying output, vblank objects are also destroyed. vblank checks + * if output object is valid. So delete the output's link at last. + */ + LIST_DEL(&private_output->link); + private_output->stamp = 0; free(private_output); } @@ -177,149 +245,118 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) static void _tdm_display_destroy_private_display(tdm_private_display *private_display) { + tdm_private_module *private_module = NULL, *bb = NULL; tdm_private_output *o = NULL, *oo = NULL; tdm_private_pp *p = NULL, *pp = NULL; - free(private_display->outputs_ptr); + LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_module->pp_list, link) { + tdm_pp_destroy_internal(p); + } - LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_display->pp_list, link) - tdm_pp_destroy_internal(p); + LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_module->output_list, link) { + _tdm_display_destroy_private_output(o); + } - LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_display->output_list, link) - _tdm_display_destroy_private_output(o); + _tdm_display_destroy_caps_pp(&private_module->caps_pp); + _tdm_display_destroy_caps_capture(&private_module->caps_capture); - _tdm_display_destroy_caps_pp(&private_display->caps_pp); - _tdm_display_destroy_caps_capture(&private_display->caps_capture); + private_module->capabilities = 0; + private_module->caps_display.max_layer_count = 0; - private_display->capabilities = 0; - private_display->caps_display.max_layer_count = -1; + if (private_module->outputs) { + free(private_module->outputs); + private_module->outputs = NULL; + } + } } static tdm_error -_tdm_display_update_caps_pp(tdm_private_display *private_display, - tdm_caps_pp *caps) +_tdm_display_update_caps_pp(tdm_private_module *private_module, tdm_caps_pp *caps) { - tdm_func_display *func_display = &private_display->func_display; - char buf[1024]; - int bufsize = sizeof(buf); - char *str_buf = buf; - int *len_buf = &bufsize; - int i; + tdm_func_display *func_display; tdm_error ret; - if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP)) - return TDM_ERROR_NONE; + func_display = &private_module->func_display; if (!func_display->display_get_pp_capability) { - TDM_ERR("no display_get_pp_capability()"); + TDM_ERR("backend(%s) no display_get_pp_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - ret = func_display->display_get_pp_capability(private_display->bdata, caps); + ret = func_display->display_get_pp_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("display_get_pp_capability() failed"); + TDM_ERR("backend(%s) display_get_pp_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - TDM_DBG("pp capabilities: %x", caps->capabilities); - buf[0] = '\0'; - for (i = 0; i < caps->format_count; i++) - TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i])); - TDM_DBG("pp formats: %s", buf); - TDM_DBG("pp min : %dx%d", caps->min_w, caps->min_h); - TDM_DBG("pp max : %dx%d", caps->max_w, caps->max_h); - TDM_DBG("pp align: %d", caps->preferred_align); - return TDM_ERROR_NONE; } static tdm_error -_tdm_display_update_caps_capture(tdm_private_display *private_display, - tdm_caps_capture *caps) +_tdm_display_update_caps_capture(tdm_private_module *private_module, tdm_caps_capture *caps) { - tdm_func_display *func_display = &private_display->func_display; - char buf[1024]; - int bufsize = sizeof(buf); - char *str_buf = buf; - int *len_buf = &bufsize; - int i; + tdm_func_display *func_display; tdm_error ret; - if (!(private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE)) - return TDM_ERROR_NONE; + func_display = &private_module->func_display; if (!func_display->display_get_capture_capability) { - TDM_ERR("no display_get_capture_capability()"); + TDM_ERR("backend(%s) no display_get_capture_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - ret = func_display->display_get_capture_capability(private_display->bdata, - caps); + ret = func_display->display_get_capture_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("display_get_capture_capability() failed"); + TDM_ERR("backend(%s) display_get_capture_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - buf[0] = '\0'; - for (i = 0; i < caps->format_count; i++) - TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i])); - TDM_DBG("capture formats: %s", buf); - return TDM_ERROR_NONE; } static tdm_error -_tdm_display_update_caps_layer(tdm_private_display *private_display, - tdm_layer *layer_backend, tdm_caps_layer *caps) +_tdm_display_update_caps_layer(tdm_private_module *private_module, + tdm_layer *layer_backend, tdm_caps_layer *caps) { - tdm_func_layer *func_layer = &private_display->func_layer; - char buf[1024]; - int bufsize = sizeof(buf); - char *str_buf = buf; - int *len_buf = &bufsize; - int i; + tdm_func_layer *func_layer = &private_module->func_layer; tdm_error ret; if (!func_layer->layer_get_capability) { - TDM_ERR("no layer_get_capability()"); + TDM_ERR("backend(%s) no layer_get_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } ret = func_layer->layer_get_capability(layer_backend, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("layer_get_capability() failed"); + TDM_ERR("backend(%s) layer_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } - TDM_DBG("layer capabilities: %x", caps->capabilities); - TDM_DBG("layer zpos : %d", caps->zpos); - buf[0] = '\0'; - for (i = 0; i < caps->format_count; i++) - TDM_SNPRINTF(str_buf, len_buf, "%c%c%c%c ", FOURCC_STR(caps->formats[i])); - TDM_DBG("layer formats: %s", buf); - for (i = 0; i < caps->prop_count; i++) - TDM_DBG("layer props: %d, %s", caps->props[i].id, caps->props[i].name); - return TDM_ERROR_NONE; } static tdm_error -_tdm_display_update_caps_output(tdm_private_display *private_display, int pipe, - tdm_output *output_backend, tdm_caps_output *caps) +_tdm_display_update_caps_output(tdm_private_module *private_module, int pipe, + tdm_output *output_backend, tdm_caps_output *caps) { - tdm_func_output *func_output = &private_display->func_output; + tdm_func_output *func_output = &private_module->func_output; char temp[TDM_NAME_LEN]; - int i; tdm_error ret; + double stamp; if (!func_output->output_get_capability) { - TDM_ERR("no output_get_capability()"); + TDM_ERR("backend(%s) no output_get_capability()", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } + stamp = tdm_helper_get_time(); ret = func_output->output_get_capability(output_backend, caps); + TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms", + private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); + if (ret != TDM_ERROR_NONE) { - TDM_ERR("output_get_capability() failed"); + TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -327,35 +364,12 @@ _tdm_display_update_caps_output(tdm_private_display *private_display, int pipe, snprintf(temp, TDM_NAME_LEN, "%s-%d", caps->model, pipe); snprintf(caps->model, TDM_NAME_LEN, "%s", temp); - TDM_DBG("output maker: %s", caps->maker); - TDM_DBG("output model: %s", caps->model); - TDM_DBG("output name: %s", caps->name); - TDM_DBG("output status: %d", caps->status); - TDM_DBG("output type : %d", caps->type); - for (i = 0; i < caps->prop_count; i++) - TDM_DBG("output props: %d, %s", caps->props[i].id, caps->props[i].name); - for (i = 0; i < caps->mode_count; i++) { - TDM_DBG("output modes: name(%s), clock(%d) vrefresh(%d), flags(%x), type(%d)", - caps->modes[i].name, caps->modes[i].clock, caps->modes[i].vrefresh, - caps->modes[i].flags, caps->modes[i].type); - TDM_DBG("\t\t %d, %d, %d, %d, %d", - caps->modes[i].hdisplay, caps->modes[i].hsync_start, caps->modes[i].hsync_end, - caps->modes[i].htotal, caps->modes[i].hskew); - TDM_DBG("\t\t %d, %d, %d, %d, %d", - caps->modes[i].vdisplay, caps->modes[i].vsync_start, caps->modes[i].vsync_end, - caps->modes[i].vtotal, caps->modes[i].vscan); - } - TDM_DBG("output min : %dx%d", caps->min_w, caps->min_h); - TDM_DBG("output max : %dx%d", caps->max_w, caps->max_h); - TDM_DBG("output align: %d", caps->preferred_align); - return TDM_ERROR_NONE; } static tdm_error -_tdm_display_update_layer(tdm_private_display *private_display, - tdm_private_output *private_output, - tdm_layer *layer_backend) +_tdm_display_update_layer(tdm_private_output *private_output, + tdm_layer *layer_backend, int index) { tdm_private_layer *private_layer; tdm_error ret; @@ -365,207 +379,340 @@ _tdm_display_update_layer(tdm_private_display *private_display, private_layer = calloc(1, sizeof(tdm_private_layer)); TDM_RETURN_VAL_IF_FAIL(private_layer != NULL, TDM_ERROR_OUT_OF_MEMORY); - LIST_ADD(&private_layer->link, &private_output->layer_list); - private_layer->private_display = private_display; - private_layer->private_output = private_output; - private_layer->layer_backend = layer_backend; - + LIST_ADDTAIL(&private_layer->link, &private_output->layer_list); LIST_INITHEAD(&private_layer->capture_list); + private_layer->index = index; + private_layer->private_module = private_output->private_module; + private_layer->private_display = private_output->private_display; + private_layer->private_output = private_output; + private_layer->layer_backend = layer_backend; private_layer->usable = 1; - } else - _tdm_display_destroy_caps_layer(&private_layer->caps); + } - ret = _tdm_display_update_caps_layer(private_display, layer_backend, - &private_layer->caps); - if (ret != TDM_ERROR_NONE) - goto failed_update; + _tdm_display_destroy_caps_layer(&private_layer->caps); + + ret = _tdm_display_update_caps_layer(private_output->private_module, layer_backend, &private_layer->caps); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); return TDM_ERROR_NONE; -failed_update: - _tdm_display_destroy_private_layer(private_layer); - return ret; } -static tdm_error -_tdm_display_update_output(tdm_private_display *private_display, - tdm_output *output_backend, int pipe) +INTERN tdm_error +tdm_display_update_output(tdm_private_module *private_module, + tdm_output *output_backend, int pipe, unsigned int need_new_caps) { - tdm_func_output *func_output = &private_display->func_output; + tdm_func_output *func_output = &private_module->func_output; tdm_private_output *private_output = NULL; tdm_layer **layers = NULL; int layer_count = 0, i; tdm_error ret; - private_output = _tdm_display_find_private_output(private_display, - output_backend); + private_output = tdm_display_find_private_output(private_module->private_display, output_backend); if (!private_output) { private_output = calloc(1, sizeof(tdm_private_output)); TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_OUT_OF_MEMORY); - private_output->stamp = tdm_helper_get_time_in_millis(); - while (tdm_display_find_output_stamp(private_display, private_output->stamp)) + private_output->stamp = tdm_helper_get_time(); + while (tdm_display_find_output_stamp(private_module->private_display, private_output->stamp)) private_output->stamp++; - LIST_ADD(&private_output->link, &private_display->output_list); + LIST_ADDTAIL(&private_output->link, &private_module->output_list); - private_output->private_display = private_display; + private_output->private_module = private_module; + private_output->private_display = private_module->private_display; private_output->current_dpms_value = TDM_OUTPUT_DPMS_OFF; private_output->output_backend = output_backend; private_output->pipe = pipe; + private_output->index = pipe; LIST_INITHEAD(&private_output->layer_list); + LIST_INITHEAD(&private_output->hwc_window_list); LIST_INITHEAD(&private_output->capture_list); LIST_INITHEAD(&private_output->vblank_handler_list); - LIST_INITHEAD(&private_output->commit_handler_list); - LIST_INITHEAD(&private_output->change_handler_list_main); - LIST_INITHEAD(&private_output->change_handler_list_sub); + LIST_INITHEAD(&private_output->output_commit_handler_list); + LIST_INITHEAD(&private_output->layer_commit_handler_list); + LIST_INITHEAD(&private_output->pending_commit_handler_list); + LIST_INITHEAD(&private_output->change_handler_list); + + private_output->need_validate.event_fd = -1; - if (func_output->output_set_status_handler) + if (func_output->output_set_status_handler) { func_output->output_set_status_handler(private_output->output_backend, - tdm_output_cb_status, - private_output); + tdm_output_cb_status, + private_output); + private_output->regist_change_cb = 1; + } + } - } else + /* need_new_caps will be true only in case of "disconnected -> connected" and "connected -> disconnected" + * because we have to get new modes. + */ + if (need_new_caps) { _tdm_display_destroy_caps_output(&private_output->caps); - ret = _tdm_display_update_caps_output(private_display, pipe, output_backend, - &private_output->caps); - if (ret != TDM_ERROR_NONE) - return ret; + ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->caps); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); + + if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + private_output->current_mode = NULL; + } layers = func_output->output_get_layers(output_backend, &layer_count, &ret); - if (ret != TDM_ERROR_NONE) - goto failed_update; + if (ret != TDM_ERROR_NONE) { + free(layers); + return ret; + } for (i = 0; i < layer_count; i++) { - ret = _tdm_display_update_layer(private_display, private_output, layers[i]); - if (ret != TDM_ERROR_NONE) - goto failed_update; + ret = _tdm_display_update_layer(private_output, layers[i], i); + if (ret != TDM_ERROR_NONE) { + free(layers); + return ret; + } } free(layers); return TDM_ERROR_NONE; -failed_update: - _tdm_display_destroy_private_output(private_output); - free(layers); - return ret; } -static tdm_error -_tdm_display_update_internal(tdm_private_display *private_display, - int only_display) +static void +_tdm_display_set_main_first(tdm_output **outputs, int index) +{ + tdm_output *output_tmp = NULL; + + if (index == 0) + return; + + output_tmp = outputs[0]; + outputs[0] = outputs[index]; + outputs[index] = output_tmp; +} + +static tdm_output ** +_tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) { - tdm_func_display *func_display = &private_display->func_display; + tdm_func_display *func_display = &private_module->func_display; tdm_output **outputs = NULL; - int output_count = 0, i; + tdm_output *output_dsi = NULL; + tdm_output *output_lvds = NULL; + tdm_output *output_hdmia = NULL; + tdm_output *output_hdmib = NULL; + int i, output_count = 0, output_connected_count = 0; + int index_dsi = 0, index_lvds = 0, index_hdmia = 0, index_hdmib = 0; tdm_error ret; - LIST_INITHEAD(&private_display->output_list); - LIST_INITHEAD(&private_display->pp_list); - LIST_INITHEAD(&private_display->capture_list); + /* don't change list order if not init time */ + if (private_module->outputs) { + TDM_ERR("can't change output order"); + return private_module->outputs; + } + + outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); + if (ret != TDM_ERROR_NONE) + goto failed_get_outputs; + + *count = output_count; + + if (output_count == 0) + goto failed_get_outputs; + else if (output_count == 1) { + private_module->outputs = outputs; + return outputs; + } + + /* count connected outputs */ + for (i = 0; i < output_count; i++) { + tdm_func_output *func_output = &private_module->func_output; + tdm_caps_output caps; + memset(&caps, 0, sizeof(tdm_caps_output)); + + if (!func_output->output_get_capability) { + TDM_ERR("no output_get_capability()"); + goto failed_get_outputs; + } + + ret = func_output->output_get_capability(outputs[i], &caps); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("output_get_capability() failed"); + goto failed_get_outputs; + } + + if (caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED) { + output_connected_count++; + + switch (caps.type) { + case TDM_OUTPUT_TYPE_DSI: + output_dsi = outputs[i]; + index_dsi = i; + break; + case TDM_OUTPUT_TYPE_LVDS: + output_lvds = outputs[i]; + index_lvds = i; + break; + case TDM_OUTPUT_TYPE_HDMIA: + output_hdmia = outputs[i]; + index_hdmia = i; + break; + case TDM_OUTPUT_TYPE_HDMIB: + output_hdmib = outputs[i]; + index_hdmib = i; + break; + default: + break; + } + } + + _tdm_display_destroy_caps_output(&caps); + } + + /* ordering : main output is first */ + /* If there is no connected output, lvds or dsi cannot be main display. (cannot connect after booting) + * But hdmi is possible, so set hdmi to main display. + * If connected only one output, it is main output. + * If connected outputs over 2, has priority like below. + * (dsi > lvds > hdmi > else) + */ + if (output_connected_count == 0) { + /* hdmi > dsi > lvds > else */ + if (output_hdmia != NULL) + _tdm_display_set_main_first(outputs, index_hdmia); + else if (output_hdmib != NULL) + _tdm_display_set_main_first(outputs, index_hdmib); + else if (output_dsi != NULL) + _tdm_display_set_main_first(outputs, index_dsi); + else if (output_lvds != NULL) + _tdm_display_set_main_first(outputs, index_lvds); + } else { /* (output_connected_count > 1) */ + /* dsi > lvds > hdmi > else */ + if (output_dsi != NULL) + _tdm_display_set_main_first(outputs, index_dsi); + else if (output_lvds != NULL) + _tdm_display_set_main_first(outputs, index_lvds); + else if (output_hdmia != NULL) + _tdm_display_set_main_first(outputs, index_hdmia); + else if (output_hdmib != NULL) + _tdm_display_set_main_first(outputs, index_hdmib); + } + + private_module->outputs = outputs; + + return outputs; + +failed_get_outputs: + free(outputs); + *count = 0; + return NULL; +} - if (!only_display) { - ret = _tdm_display_update_caps_pp(private_display, &private_display->caps_pp); +static tdm_error +_tdm_display_setup(tdm_private_display *private_display) +{ + tdm_private_module *private_module = NULL; + tdm_error ret = TDM_ERROR_NONE; + int index = 0; + + if (private_display->pp_module) { + ret = _tdm_display_update_caps_pp(private_display->pp_module, + &private_display->pp_module->caps_pp); if (ret != TDM_ERROR_NONE) goto failed_update; + } - ret = _tdm_display_update_caps_capture(private_display, - &private_display->caps_capture); + if (private_display->capture_module) { + ret = _tdm_display_update_caps_capture(private_display->capture_module, + &private_display->capture_module->caps_capture); if (ret != TDM_ERROR_NONE) goto failed_update; } - outputs = func_display->display_get_outputs(private_display->bdata, - &output_count, &ret); - if (ret != TDM_ERROR_NONE) - goto failed_update; + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { + tdm_output **outputs; + int output_count = 0, i; - for (i = 0; i < output_count; i++) { - ret = _tdm_display_update_output(private_display, outputs[i], i); - if (ret != TDM_ERROR_NONE) + outputs = _tdm_display_get_ordered_outputs(private_module, &output_count); + if (!outputs) goto failed_update; - } - free(outputs); + for (i = 0; i < output_count; i++) { + ret = tdm_display_update_output(private_module, outputs[i], index++, 1); + if (ret != TDM_ERROR_NONE) + goto failed_update; + } + } return TDM_ERROR_NONE; failed_update: _tdm_display_destroy_private_display(private_display); - free(outputs); return ret; } +/* LCOV_EXCL_STOP */ EXTERN tdm_error tdm_display_update(tdm_display *dpy) { - tdm_private_display *private_display; - tdm_error ret; - TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); - private_display = dpy; - _pthread_mutex_lock(&private_display->lock); - - ret = _tdm_display_update_internal(private_display, 1); + TDM_DEPRECATED(NULL); - _pthread_mutex_unlock(&private_display->lock); - - return ret; + return TDM_ERROR_NONE; } -#define SUFFIX_MODULE ".so" -#define DEFAULT_MODULE "libtdm-default"SUFFIX_MODULE - -int tdm_debug; -int tdm_debug_buffer; -int tdm_debug_thread; -int tdm_debug_mutex; +int tdm_debug_module; +int tdm_debug_dump; +int tdm_ttrace_module; +int tdm_ttrace_output; static tdm_private_display *g_private_display; static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; +/* LCOV_EXCL_START */ static tdm_error _tdm_display_check_module(tdm_backend_module *module) { - const char *name; - const char *vendor; int major, minor; - int abimaj, abimin; - abimaj = TDM_BACKEND_GET_ABI_MAJOR(TDM_BACKEND_ABI_VERSION); - abimin = TDM_BACKEND_GET_ABI_MINOR(TDM_BACKEND_ABI_VERSION); + TDM_INFO("TDM ABI version : %d.%d", + TDM_MAJOR_VERSION, TDM_MINOR_VERSION); - TDM_INFO("TDM module ABI version : %d.%d", abimaj, abimin); + if (!module->name) { + TDM_ERR("TDM backend doesn't have name"); + return TDM_ERROR_BAD_MODULE; + } + + if (!module->vendor) { + TDM_ERR("TDM backend doesn't have vendor"); + return TDM_ERROR_BAD_MODULE; + } - name = module->name ? module->name : "unknown"; - vendor = module->vendor ? module->vendor : "unknown"; major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version); minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version); - TDM_INFO("TDM module name: %s", name); - TDM_INFO("'%s' vendor: %s", name, vendor); - TDM_INFO("'%s' version: %d.%d", name, major, minor); + TDM_INFO("TDM module name: %s", module->name); + TDM_INFO("'%s' vendor: %s", module->name, module->vendor); + TDM_INFO("'%s' version: %d.%d", module->name, major, minor); - if (major != abimaj) { - TDM_ERR("'%s' major version mismatch, %d != %d", name, major, abimaj); + if (major != TDM_MAJOR_VERSION) { + TDM_ERR("'%s' major version mismatch, %d != %d", + module->name, major, TDM_MAJOR_VERSION); return TDM_ERROR_BAD_MODULE; } - if (minor > abimin) { - TDM_ERR("'%s' minor version(%d) is newer than %d", name, minor, abimin); + if (minor > TDM_MINOR_VERSION) { + TDM_ERR("'%s' minor version(%d) is newer than %d", + module->name, minor, TDM_MINOR_VERSION); return TDM_ERROR_BAD_MODULE; } if (!module->init) { - TDM_ERR("'%s' doesn't have init function", name); + TDM_ERR("'%s' doesn't have init function", module->name); return TDM_ERROR_BAD_MODULE; } if (!module->deinit) { - TDM_ERR("'%s' doesn't have deinit function", name); + TDM_ERR("'%s' doesn't have deinit function", module->name); return TDM_ERROR_BAD_MODULE; } @@ -573,52 +720,56 @@ _tdm_display_check_module(tdm_backend_module *module) } static tdm_error -_tdm_display_check_backend_functions(tdm_private_display *private_display) +_tdm_display_check_backend_functions(tdm_private_module *private_module) { - tdm_func_display *func_display = &private_display->func_display; - tdm_func_output *func_output = &private_display->func_output; - tdm_func_layer *func_layer = &private_display->func_layer; + tdm_func_display *func_display = &private_module->func_display; + tdm_func_output *func_output = &private_module->func_output; + tdm_func_layer *func_layer = &private_module->func_layer; tdm_error ret; /* below functions should be implemented in backend side */ TDM_RETURN_VAL_IF_FAIL(func_display != NULL, TDM_ERROR_BAD_MODULE); - TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capabilitiy, - TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_display->display_get_outputs, TDM_ERROR_BAD_MODULE); - TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, - TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_get_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_output->output_get_layers, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_wait_vblank, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_vblank_handler, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_commit, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_commit_handler, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_output->output_set_mode, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_capability, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_info, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_get_info, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_set_buffer, TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_unset_buffer, TDM_ERROR_BAD_MODULE); - ret = func_display->display_get_capabilitiy(private_display->bdata, - &private_display->caps_display); + ret = func_display->display_get_capability(private_module->bdata, &private_module->caps_display); if (ret != TDM_ERROR_NONE) { - TDM_ERR("display_get_capabilitiy() failed"); + TDM_ERR("display_get_capability() failed"); return TDM_ERROR_BAD_MODULE; } - if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP) { - tdm_func_pp *func_pp = &private_display->func_pp; - TDM_RETURN_VAL_IF_FAIL(func_display->display_get_pp_capability, - TDM_ERROR_BAD_MODULE); + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) { + tdm_func_pp *func_pp = &private_module->func_pp; + TDM_RETURN_VAL_IF_FAIL(func_display->display_get_pp_capability, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_display->display_create_pp, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_pp->pp_destroy, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_pp->pp_commit, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_pp->pp_set_done_handler, TDM_ERROR_BAD_MODULE); } - if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { - tdm_func_capture *func_capture = &private_display->func_capture; - TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, - TDM_ERROR_BAD_MODULE); - TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, - TDM_ERROR_BAD_MODULE); - TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE); + if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { + tdm_func_capture *func_capture = &private_module->func_capture; + TDM_RETURN_VAL_IF_FAIL(func_display->display_get_capture_capability, TDM_ERROR_BAD_MODULE); + if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT) + TDM_RETURN_VAL_IF_FAIL(func_output->output_create_capture, TDM_ERROR_BAD_MODULE); + if (private_module->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER) + TDM_RETURN_VAL_IF_FAIL(func_layer->layer_create_capture, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_capture->capture_destroy, TDM_ERROR_BAD_MODULE); TDM_RETURN_VAL_IF_FAIL(func_capture->capture_commit, TDM_ERROR_BAD_MODULE); - TDM_RETURN_VAL_IF_FAIL(func_capture->capture_set_done_handler, - TDM_ERROR_BAD_MODULE); + TDM_RETURN_VAL_IF_FAIL(func_capture->capture_set_done_handler, TDM_ERROR_BAD_MODULE); } return TDM_ERROR_NONE; @@ -626,24 +777,45 @@ _tdm_display_check_backend_functions(tdm_private_display *private_display) static tdm_error _tdm_display_load_module_with_file(tdm_private_display *private_display, - const char *file) + const char *file) { - char path[PATH_MAX] = {0,}; + char path[TDM_PATH_LEN] = {0,}; + void *module = NULL; tdm_backend_module *module_data; - void *module; + tdm_backend_data *bdata = NULL; + tdm_private_module *private_module = NULL; tdm_error ret; + double stamp; + int size; - snprintf(path, sizeof(path), TDM_MODULE_PATH "/%s", file); + size = snprintf(path, sizeof(path), TDM_MODULE_PATH "/%s", file); + if (size >= (int)sizeof(path)) { + TDM_WRN("too long: %s/%s", TDM_MODULE_PATH, file); + return TDM_ERROR_BAD_MODULE; + }; - TDM_TRACE_BEGIN(Load_Backend); + private_module = calloc(1, sizeof *private_module); + if (!private_module) { + TDM_ERR("alloc failed: %m"); + ret = TDM_ERROR_OUT_OF_MEMORY; + goto failed_load; + } + + private_module->private_display = private_display; + + stamp = tdm_helper_get_time(); + TDM_TRACE_BEGIN("TDM_Load_Backend"); module = dlopen(path, RTLD_LAZY); if (!module) { - TDM_ERR("failed to load module: %s(%s)", dlerror(), file); + TDM_ERR("%s", dlerror()); TDM_TRACE_END(); - return TDM_ERROR_BAD_MODULE; + ret = TDM_ERROR_BAD_MODULE; + goto failed_load; } + private_module->module = module; + module_data = dlsym(module, "tdm_backend_module_data"); if (!module_data) { TDM_ERR("'%s' doesn't have data object", file); @@ -651,147 +823,209 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, TDM_TRACE_END(); goto failed_load; } + TDM_TRACE_END(); + + private_module->module_data = module_data; - private_display->module_data = module_data; - private_display->module = module; + TDM_DBG("dlopen, dlsym time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); /* check if version, init() and deinit() are valid or not */ ret = _tdm_display_check_module(module_data); - if (ret != TDM_ERROR_NONE) + if (ret != TDM_ERROR_NONE) { + TDM_ERR("backend(%s) load failed: check module error", module_data->name); goto failed_load; + } - TDM_TRACE_END(); + private_display->current_module = private_module; /* We don't care if backend_data is NULL or not. It's up to backend. */ - TDM_TRACE_BEGIN(Init_Backend); - private_display->bdata = module_data->init((tdm_display *)private_display, - &ret); + TDM_TRACE_BEGIN("TDM_Init_Backend"); + stamp = tdm_helper_get_time(); + bdata = module_data->init((tdm_display *)private_display, &ret); + TDM_DBG("backend init() time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); TDM_TRACE_END(); + + private_display->current_module = NULL; + + private_module->bdata = bdata; + if (ret != TDM_ERROR_NONE) { - TDM_ERR("'%s' init failed", file); + TDM_ERR("backend(%s) load failed: init error", module_data->name); goto failed_load; } - ret = _tdm_display_check_backend_functions(private_display); + ret = _tdm_display_check_backend_functions(private_module); if (ret != TDM_ERROR_NONE) { - module_data->deinit(private_display->bdata); - private_display->bdata = NULL; + TDM_ERR("backend(%s) load failed: check functions error", module_data->name); goto failed_load; } - TDM_INFO("Success to load module(%s)", file); + LIST_INITHEAD(&private_module->output_list); + LIST_INITHEAD(&private_module->pp_list); + LIST_INITHEAD(&private_module->capture_list); + + LIST_ADDTAIL(&private_module->link, &private_display->module_list); + + TDM_INFO("Success to load '%s' module", module_data->name); return TDM_ERROR_NONE; failed_load: - dlclose(module); - private_display->module_data = NULL; - private_display->module = NULL; + if (bdata) + module_data->deinit(bdata); + if (module) + dlclose(module); + if (private_module) + free(private_module); return ret; } static tdm_error -_tdm_display_load_module(tdm_private_display *private_display) +_tdm_display_load_modules(tdm_private_display *private_display) { - const char *module_name; - struct dirent **namelist; - int n; - tdm_error ret = 0; - - module_name = getenv("TDM_MODULE"); - if (!module_name) - module_name = DEFAULT_MODULE; - - /* load bufmgr priv from default lib */ - ret = _tdm_display_load_module_with_file(private_display, module_name); - if (ret == TDM_ERROR_NONE) - return TDM_ERROR_NONE; - - /* load bufmgr priv from configured path */ - n = scandir(TDM_MODULE_PATH, &namelist, 0, alphasort); - if (n < 0) { - TDM_ERR("no module in '%s'\n", TDM_MODULE_PATH); - return TDM_ERROR_BAD_MODULE; + const char *module_names; + tdm_error ret = TDM_ERROR_NONE; + char temp[TDM_PATH_LEN]; + char *arg; + char *end; + + LIST_INITHEAD(&private_display->module_list); + + module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE); + + snprintf(temp, TDM_PATH_LEN, "%s", module_names); + + arg = strtok_r(temp, TDM_CONFIG_DELIM, &end); + while (arg) { + TDM_INFO("loading a %s backend", arg); + ret = _tdm_display_load_module_with_file(private_display, arg); + if (ret == TDM_ERROR_NONE) + TDM_INFO("%s backend loading success", arg); + else + TDM_INFO("%s backend loading failed", arg); + arg = strtok_r(NULL, TDM_CONFIG_DELIM, &end); } - ret = TDM_ERROR_BAD_MODULE; - while (n--) { - if (ret < 0 && strstr(namelist[n]->d_name, SUFFIX_MODULE)) - ret = _tdm_display_load_module_with_file(private_display, namelist[n]->d_name); - - free(namelist[n]); + /* load bufmgr priv from dummy lib */ + if (LIST_IS_EMPTY(&private_display->module_list)) { + TDM_WRN("No backend. loading a %s backend", TDM_DUMMY_MODULE); + ret = _tdm_display_load_module_with_file(private_display, TDM_DUMMY_MODULE); + if (ret == TDM_ERROR_NONE) + TDM_INFO("%s backend loading success", TDM_DUMMY_MODULE); + else + TDM_INFO("%s backend loading failed", TDM_DUMMY_MODULE); } - free(namelist); return ret; } static void -_tdm_display_unload_module(tdm_private_display *private_display) +_tdm_display_unload_modules(tdm_private_display *private_display) { - if (private_display->module_data) - private_display->module_data->deinit(private_display->bdata); - if (private_display->module) - dlclose(private_display->module); - - private_display->bdata = NULL; - private_display->module_data = NULL; - private_display->module = NULL; + tdm_private_module *private_module = NULL, *bb = NULL; + + LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { + LIST_DEL(&private_module->link); + + if (private_module->module_data) + private_module->module_data->deinit(private_module->bdata); + if (private_module->module) + dlclose(private_module->module); + + free(private_module); + } } +/* LCOV_EXCL_STOP */ EXTERN tdm_display * tdm_display_init(tdm_error *error) { tdm_private_display *private_display = NULL; - const char *debug; + const char *str; tdm_error ret; + double stamp1, stamp2, start; + int mode; - _pthread_mutex_lock(&gLock); + pthread_mutex_lock(&gLock); if (g_private_display) { g_private_display->init_count++; - _pthread_mutex_unlock(&gLock); + pthread_mutex_unlock(&gLock); if (error) *error = TDM_ERROR_NONE; return g_private_display; } - debug = getenv("TDM_DEBUG"); - if (debug && (strstr(debug, "1"))) - tdm_debug = 1; - - debug = getenv("TDM_DEBUG_BUFFER"); - if (debug && (strstr(debug, "1"))) - tdm_debug_buffer = 1; + start = stamp1 = tdm_helper_get_time(); - debug = getenv("TDM_DEBUG_THREAD"); - if (debug && (strstr(debug, "1"))) - tdm_debug_thread = 1; - - debug = getenv("TDM_DEBUG_MUTEX"); - if (debug && (strstr(debug, "1"))) - tdm_debug_mutex = 1; + stamp2 = tdm_helper_get_time(); + TDM_INFO("config init time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; private_display = calloc(1, sizeof(tdm_private_display)); if (!private_display) { + /* LCOV_EXCL_START */ ret = TDM_ERROR_OUT_OF_MEMORY; TDM_ERR("'private_display != NULL' failed"); goto failed_alloc; + /* LCOV_EXCL_STOP */ } + private_display->stamp = tdm_helper_get_time(); + + str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_MODULE, NULL); + if (str) + tdm_display_enable_debug_module(str); + + str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_DUMP, NULL); + if (str) + tdm_display_enable_dump(private_display, str, NULL, NULL); + if (pthread_mutex_init(&private_display->lock, NULL)) { + /* LCOV_EXCL_START */ ret = TDM_ERROR_OPERATION_FAILED; TDM_ERR("mutex init failed: %m"); goto failed_mutex_init; + /* LCOV_EXCL_STOP */ } + _pthread_mutex_lock(&private_display->lock); + + stamp2 = tdm_helper_get_time(); + TDM_DBG("prepare init time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; + ret = tdm_event_loop_init(private_display); if (ret != TDM_ERROR_NONE) goto failed_event; - ret = _tdm_display_load_module(private_display); + stamp2 = tdm_helper_get_time(); + TDM_INFO("event loop init time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; + + ret = tdm_vblank_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_vblank; + + ret = tdm_output_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_load; + + ret = tdm_pp_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_load; + + ret = tdm_capture_init(private_display); + if (ret != TDM_ERROR_NONE) + goto failed_load; + + ret = _tdm_display_load_modules(private_display); if (ret != TDM_ERROR_NONE) goto failed_load; + stamp2 = tdm_helper_get_time(); + TDM_INFO("loading backend time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; + #ifdef INIT_BUFMGR int tdm_drm_fd = tdm_helper_get_fd("TDM_DRM_MASTER_FD"); if (tdm_drm_fd >= 0) { @@ -803,43 +1037,84 @@ tdm_display_init(tdm_error *error) } else { TDM_INFO("tbm_bufmgr_init successed"); } + + stamp2 = tdm_helper_get_time(); + TDM_DBG("initializing bufmgr time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; } #endif - TDM_TRACE_BEGIN(Update_Display); - ret = _tdm_display_update_internal(private_display, 0); + TDM_TRACE_BEGIN("TDM_Update_Display"); + ret = _tdm_display_setup(private_display); TDM_TRACE_END(); if (ret != TDM_ERROR_NONE) goto failed_update; + stamp2 = tdm_helper_get_time(); + TDM_DBG("updating display time: %.3f ms", (stamp2 - stamp1) * 1000.0); + stamp1 = stamp2; + tdm_event_loop_create_backend_source(private_display); private_display->init_count = 1; - g_private_display = private_display; + tdm_private_module *b = NULL; + tdm_private_output *o = NULL; + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { + if (o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) + tdm_output_need_validate_event_init(o); + } + } + + /* the COMMIT_PER_VBLANK functionality is ability of an output to support + * several operational modes (commit_per_vblank modes) related to tdm_commit; + * this functionality can be turned off which means a default mode */ + mode = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_COMMIT_PER_VBLANK, 0); + if (mode > 0) { + tdm_private_module *b = NULL; + tdm_private_output *o = NULL; + + /* outputs which support hwc capability can work only + * if commit_per_vblank mode is '0' (default mode) */ + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { + LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { + if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) + tdm_output_choose_commit_per_vblank_mode(o, mode); + } + } + } + if (error) *error = TDM_ERROR_NONE; - _pthread_mutex_unlock(&gLock); + _pthread_mutex_unlock(&private_display->lock); + pthread_mutex_unlock(&gLock); + + TDM_INFO("init time: %.3f ms", (tdm_helper_get_time() - start) * 1000.0); return (tdm_display *)private_display; +/* LCOV_EXCL_START */ failed_update: - _tdm_display_unload_module(private_display); + _tdm_display_unload_modules(private_display); failed_load: + tdm_vblank_deinit(private_display); +failed_vblank: + tdm_event_loop_stop(private_display); tdm_event_loop_deinit(private_display); failed_event: + _pthread_mutex_unlock(&private_display->lock); pthread_mutex_destroy(&private_display->lock); failed_mutex_init: free(private_display); failed_alloc: - tdm_debug = 0; - tdm_debug_buffer = 0; if (error) *error = ret; - _pthread_mutex_unlock(&gLock); + pthread_mutex_unlock(&gLock); return NULL; +/* LCOV_EXCL_STOP */ } EXTERN void @@ -850,36 +1125,59 @@ tdm_display_deinit(tdm_display *dpy) if (!private_display) return; - _pthread_mutex_lock(&gLock); + pthread_mutex_lock(&gLock); private_display->init_count--; if (private_display->init_count > 0) { - _pthread_mutex_unlock(&gLock); + pthread_mutex_unlock(&gLock); return; } + /* dont move the position of lock/unlock. all resource should be protected + * during destroying. after tdm_event_loop_deinit, we don't worry about thread + * things because it's finalized. + */ _pthread_mutex_lock(&private_display->lock); + tdm_event_loop_stop(private_display); + _pthread_mutex_unlock(&private_display->lock); tdm_event_loop_deinit(private_display); + /* when private_output is destroyed, all vblank resources of client and server + * are destroyed. Then we can call tdm_vblank_deinit. After destroying display, + * we can unload backend modulues. + */ _tdm_display_destroy_private_display(private_display); - _tdm_display_unload_module(private_display); + _tdm_display_unload_modules(private_display); + + tdm_vblank_deinit(private_display); #ifdef INIT_BUFMGR if (private_display->bufmgr) tbm_bufmgr_deinit(private_display->bufmgr); #endif - tdm_helper_set_fd("TDM_DRM_MASTER_FD", -1); - - _pthread_mutex_unlock(&private_display->lock); + tbm_drm_helper_unset_tbm_master_fd(); pthread_mutex_destroy(&private_display->lock); free(private_display); g_private_display = NULL; - tdm_debug = 0; - tdm_debug_buffer = 0; - _pthread_mutex_unlock(&gLock); + if (tdm_debug_dump_dir) { + free(tdm_debug_dump_dir); + tdm_debug_dump_dir = NULL; + } + + tdm_config_deinit(); + + pthread_mutex_unlock(&gLock); + + TDM_INFO("done"); +} + +INTERN tdm_private_display * +tdm_display_get(void) +{ + return g_private_display; }