X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm.c;h=08a9136f472f04cee04a6feef7383c56613928f2;hb=e3bf909bf70dabcee8bb28a68fdb75b1a93fc671;hp=33b27a74d141469d15dd38a434926f05d11c0ba3;hpb=f08216fac3a6803d459b5cd267197cc4448deb58;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm.c b/src/tdm.c index 33b27a7..08a9136 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -9,7 +9,7 @@ * Taeheon Kim , * YoungJun Cho , * SooChan Lim , - * Boram Park + * Boram Park * * Permission is hereby granted, free of charge, to any person obtaining a * copy of this software and associated documentation files (the @@ -46,6 +46,10 @@ 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, @@ -61,28 +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 * +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; @@ -135,8 +144,6 @@ _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) @@ -144,6 +151,11 @@ _tdm_display_destroy_private_layer(tdm_private_layer *private_layer) _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); } @@ -154,12 +166,10 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) 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_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_change_handler *h = NULL, *hh = NULL; - - LIST_DEL(&private_output->link); + tdm_private_output_change_handler *h = NULL, *hh = NULL; free(private_output->layers_ptr); @@ -186,13 +196,10 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) free(lm); } - 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(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); } @@ -221,12 +228,16 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) _tdm_display_destroy_caps_output(&private_output->caps); - if (private_output->dpms_changed_timer) - tdm_event_loop_source_remove(private_output->dpms_changed_timer); - + 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); } @@ -234,46 +245,48 @@ _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); - if (private_display->outputs) { - free(private_display->outputs); - private_display->outputs = NULL; - } + 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 = 0; + 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; + 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; } @@ -281,23 +294,21 @@ _tdm_display_update_caps_pp(tdm_private_display *private_display, } 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; + 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; } @@ -305,20 +316,20 @@ _tdm_display_update_caps_capture(tdm_private_display *private_display, } static tdm_error -_tdm_display_update_caps_layer(tdm_private_display *private_display, +_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; + 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; } @@ -326,25 +337,26 @@ _tdm_display_update_caps_layer(tdm_private_display *private_display, } static tdm_error -_tdm_display_update_caps_output(tdm_private_display *private_display, int pipe, +_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]; 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 output_get_capability() time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); + 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; } @@ -356,8 +368,7 @@ _tdm_display_update_caps_output(tdm_private_display *private_display, int pipe, } static tdm_error -_tdm_display_update_layer(tdm_private_display *private_display, - tdm_private_output *private_output, +_tdm_display_update_layer(tdm_private_output *private_output, tdm_layer *layer_backend, int index) { tdm_private_layer *private_layer; @@ -369,50 +380,47 @@ _tdm_display_update_layer(tdm_private_display *private_display, TDM_RETURN_VAL_IF_FAIL(private_layer != NULL, TDM_ERROR_OUT_OF_MEMORY); LIST_ADDTAIL(&private_layer->link, &private_output->layer_list); + LIST_INITHEAD(&private_layer->capture_list); + private_layer->index = index; - private_layer->private_display = private_display; + 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; - - LIST_INITHEAD(&private_layer->capture_list); - 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; } INTERN tdm_error -tdm_display_update_output(tdm_private_display *private_display, - tdm_output *output_backend, int pipe) +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(); - while (tdm_display_find_output_stamp(private_display, private_output->stamp)) + while (tdm_display_find_output_stamp(private_module->private_display, private_output->stamp)) private_output->stamp++; - LIST_ADDTAIL(&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; @@ -425,8 +433,9 @@ tdm_display_update_output(tdm_private_display *private_display, 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_main); - LIST_INITHEAD(&private_output->change_handler_list_sub); + LIST_INITHEAD(&private_output->change_handler_list); + + private_output->need_validate.event_fd = -1; if (func_output->output_set_status_handler) { func_output->output_set_status_handler(private_output->output_backend, @@ -434,77 +443,58 @@ tdm_display_update_output(tdm_private_display *private_display, private_output); private_output->regist_change_cb = 1; } + } - ret = _tdm_display_update_caps_output(private_display, pipe, output_backend, - &private_output->caps); - if (ret != TDM_ERROR_NONE) - return ret; - } else { - tdm_caps_output new_caps; + /* 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, - &new_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); - /* FIXME: This is very ugly. need to fix after the TDM ABI is changed. */ - if (private_output->caps.status != new_caps.status) { - _tdm_display_destroy_caps_output(&private_output->caps); - private_output->caps = new_caps; + if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) private_output->current_mode = NULL; - } else { - tdm_output_mode *old_modes = private_output->caps.modes; - unsigned int old_mode_count = private_output->caps.mode_count; - if (new_caps.modes) - free(new_caps.modes); - new_caps.modes = old_modes; - new_caps.mode_count = old_mode_count; - if (private_output->caps.props) - free(private_output->caps.props); - private_output->caps = new_caps; - } } 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], 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_output ** +static void _tdm_display_set_main_first(tdm_output **outputs, int index) { tdm_output *output_tmp = NULL; if (index == 0) - return outputs; + return; output_tmp = outputs[0]; outputs[0] = outputs[index]; outputs[index] = output_tmp; - - return outputs; } static tdm_output ** -_tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *count) +_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; - tdm_output **new_outputs = NULL; tdm_output *output_dsi = NULL; tdm_output *output_lvds = NULL; tdm_output *output_hdmia = NULL; @@ -514,10 +504,12 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun tdm_error ret; /* don't change list order if not init time */ - if (private_display->outputs) - return private_display->outputs; + if (private_module->outputs) { + TDM_ERR("can't change output order"); + return private_module->outputs; + } - outputs = func_display->display_get_outputs(private_display->bdata, &output_count, &ret); + outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); if (ret != TDM_ERROR_NONE) goto failed_get_outputs; @@ -526,13 +518,13 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun if (output_count == 0) goto failed_get_outputs; else if (output_count == 1) { - private_display->outputs = outputs; + private_module->outputs = outputs; return outputs; } /* count connected outputs */ for (i = 0; i < output_count; i++) { - tdm_func_output *func_output = &private_display->func_output; + tdm_func_output *func_output = &private_module->func_output; tdm_caps_output caps; memset(&caps, 0, sizeof(tdm_caps_output)); @@ -585,32 +577,28 @@ _tdm_display_get_ordered_outputs(tdm_private_display *private_display, int *coun if (output_connected_count == 0) { /* hdmi > dsi > lvds > else */ if (output_hdmia != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmia); + _tdm_display_set_main_first(outputs, index_hdmia); else if (output_hdmib != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmib); + _tdm_display_set_main_first(outputs, index_hdmib); else if (output_dsi != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_dsi); + _tdm_display_set_main_first(outputs, index_dsi); else if (output_lvds != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_lvds); - else - new_outputs = outputs; + _tdm_display_set_main_first(outputs, index_lvds); } else { /* (output_connected_count > 1) */ /* dsi > lvds > hdmi > else */ if (output_dsi != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_dsi); + _tdm_display_set_main_first(outputs, index_dsi); else if (output_lvds != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_lvds); + _tdm_display_set_main_first(outputs, index_lvds); else if (output_hdmia != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmia); + _tdm_display_set_main_first(outputs, index_hdmia); else if (output_hdmib != NULL) - new_outputs = _tdm_display_set_main_first(outputs, index_hdmib); - else - new_outputs = outputs; + _tdm_display_set_main_first(outputs, index_hdmib); } - private_display->outputs = new_outputs; + private_module->outputs = outputs; - return new_outputs; + return outputs; failed_get_outputs: free(outputs); @@ -619,36 +607,39 @@ failed_get_outputs: } static tdm_error -_tdm_display_update_internal(tdm_private_display *private_display, - int only_display) +_tdm_display_setup(tdm_private_display *private_display) { - tdm_output **outputs = NULL; - int output_count = 0, i; + tdm_private_module *private_module = NULL; tdm_error ret = TDM_ERROR_NONE; + int index = 0; - LIST_INITHEAD(&private_display->output_list); - LIST_INITHEAD(&private_display->pp_list); - LIST_INITHEAD(&private_display->capture_list); - - if (!only_display) { - ret = _tdm_display_update_caps_pp(private_display, &private_display->caps_pp); + 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 = _tdm_display_get_ordered_outputs(private_display, &output_count); - if (!outputs) - 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; + + 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; @@ -662,26 +653,13 @@ failed_update: 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); - TDM_RETURN_VAL_IF_FAIL(tdm_display_is_valid(dpy), 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 TDM_DEFAULT_MODULE "libtdm-default"SUFFIX_MODULE -#define TDM_DUMMY_MODULE "libtdm-dummy"SUFFIX_MODULE - int tdm_debug_module; int tdm_debug_dump; int tdm_ttrace_module; @@ -742,29 +720,39 @@ _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_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_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_capability(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_capability() failed"); return TDM_ERROR_BAD_MODULE; } - if (private_display->capabilities & TDM_DISPLAY_CAPABILITY_PP) { - tdm_func_pp *func_pp = &private_display->func_pp; + 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); @@ -772,12 +760,12 @@ _tdm_display_check_backend_functions(tdm_private_display *private_display) 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; + 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_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_OUTPUT) + 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_display->caps_capture.capabilities & TDM_CAPTURE_CAPABILITY_LAYER) + 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); @@ -792,8 +780,10 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, const char *file) { 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; @@ -804,16 +794,28 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, return TDM_ERROR_BAD_MODULE; }; + 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); @@ -823,103 +825,114 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, } TDM_TRACE_END(); - TDM_DBG("dlopen, dlsym time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); + 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; + } + + 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("TDM_Init_Backend"); stamp = tdm_helper_get_time(); - private_display->bdata = module_data->init((tdm_display *)private_display, &ret); + 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("failed to init '%s' module", module_data->name); + 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; } + 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, len; - tdm_error ret = 0; - - module_name = getenv("TDM_MODULE"); - if (!module_name) - module_name = TDM_DEFAULT_MODULE; - - len = strlen(module_name); - if (len > TDM_NAME_LEN - 1) { - TDM_ERR("TDM_MODULE is too long\n"); - return TDM_ERROR_OPERATION_FAILED; - } + const char *module_names; + tdm_error ret = TDM_ERROR_NONE; + char temp[TDM_PATH_LEN]; + char *arg; + char *end; - /* 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; + LIST_INITHEAD(&private_display->module_list); - /* load bufmgr priv from dummy lib */ - ret = _tdm_display_load_module_with_file(private_display, TDM_DUMMY_MODULE); - 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; - } + module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE); - 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); + snprintf(temp, TDM_PATH_LEN, "%s", module_names); - free(namelist[n]); + 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); + } + + /* 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 */ @@ -930,6 +943,7 @@ tdm_display_init(tdm_error *error) const char *str; tdm_error ret; double stamp1, stamp2, start; + int mode; pthread_mutex_lock(&gLock); @@ -943,6 +957,10 @@ tdm_display_init(tdm_error *error) start = stamp1 = tdm_helper_get_time(); + 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 */ @@ -952,18 +970,16 @@ tdm_display_init(tdm_error *error) /* LCOV_EXCL_STOP */ } - str = getenv("TDM_DEBUG_MODULE"); + 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 = getenv("TDM_DEBUG_DUMP"); + str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_DUMP, NULL); if (str) tdm_display_enable_dump(private_display, str, NULL, NULL); - str = getenv("TDM_DEBUG_PATH"); - if (str) - tdm_display_enable_path(str); - if (pthread_mutex_init(&private_display->lock, NULL)) { /* LCOV_EXCL_START */ ret = TDM_ERROR_OPERATION_FAILED; @@ -978,24 +994,36 @@ tdm_display_init(tdm_error *error) TDM_DBG("prepare 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_event_loop_init(private_display); if (ret != TDM_ERROR_NONE) goto failed_event; stamp2 = tdm_helper_get_time(); - TDM_DBG("creating event loop time: %.3f ms", (stamp2 - stamp1) * 1000.0); + TDM_INFO("event loop init time: %.3f ms", (stamp2 - stamp1) * 1000.0); stamp1 = stamp2; - ret = _tdm_display_load_module(private_display); + 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_DBG("loading backend time: %.3f ms", (stamp2 - stamp1) * 1000.0); + TDM_INFO("loading backend time: %.3f ms", (stamp2 - stamp1) * 1000.0); stamp1 = stamp2; #ifdef INIT_BUFMGR @@ -1017,7 +1045,7 @@ tdm_display_init(tdm_error *error) #endif TDM_TRACE_BEGIN("TDM_Update_Display"); - ret = _tdm_display_update_internal(private_display, 0); + ret = _tdm_display_setup(private_display); TDM_TRACE_END(); if (ret != TDM_ERROR_NONE) goto failed_update; @@ -1031,26 +1059,31 @@ tdm_display_init(tdm_error *error) private_display->init_count = 1; g_private_display = private_display; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; - LIST_FOR_EACH_ENTRY(o, &private_display->output_list, link) { - if (o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) - tdm_output_need_validate_event_init(o); + 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 */ - str = getenv("TDM_COMMIT_PER_VBLANK"); - if (str) { + 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; - char *end; - int mode = strtol(str, &end, 10); /* outputs which support hwc capability can work only * if commit_per_vblank mode is '0' (default mode) */ - LIST_FOR_EACH_ENTRY(o, &private_display->output_list, link) - if (!(o->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC)) - tdm_output_choose_commit_per_vblank_mode(o, 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) @@ -1065,13 +1098,13 @@ tdm_display_init(tdm_error *error) /* 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: - tdm_vblank_deinit(private_display); -failed_vblank: _pthread_mutex_unlock(&private_display->lock); pthread_mutex_destroy(&private_display->lock); failed_mutex_init: @@ -1092,8 +1125,6 @@ tdm_display_deinit(tdm_display *dpy) if (!private_display) return; - TDM_RETURN_IF_FAIL(tdm_display_is_valid(dpy)); - pthread_mutex_lock(&gLock); private_display->init_count--; @@ -1108,11 +1139,17 @@ tdm_display_deinit(tdm_display *dpy) */ _pthread_mutex_lock(&private_display->lock); tdm_event_loop_stop(private_display); - _tdm_display_destroy_private_display(private_display); - _tdm_display_unload_module(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_modules(private_display); + tdm_vblank_deinit(private_display); #ifdef INIT_BUFMGR @@ -1131,352 +1168,16 @@ tdm_display_deinit(tdm_display *dpy) tdm_debug_dump_dir = NULL; } + tdm_config_deinit(); + pthread_mutex_unlock(&gLock); TDM_INFO("done"); } -INTERN int -tdm_display_is_valid(tdm_display *dpy) -{ - if (dpy != NULL && dpy == g_private_display) - return 1; - return 0; -} - -INTERN int -tdm_output_is_valid(tdm_output *output) -{ - tdm_private_output *o = NULL, *private_output = output; - if (output && g_private_display) - LIST_FOR_EACH_ENTRY(o, &g_private_display->output_list, link) - if (o == private_output) - return 1; - return 0; -} - -/* LCOV_EXCL_START */ -INTERN int -tdm_display_check_module_abi(tdm_private_display *private_display, int abimaj, int abimin) -{ - tdm_backend_module *module = private_display->module_data; - - if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj) - return 0; - - if (TDM_BACKEND_GET_ABI_MINOR(module->abi_version) < abimin) - return 0; - - return 1; -} - -INTERN tdm_error -tdm_display_enable_debug_module(const char*modules) -{ - char temp[TDM_PATH_LEN]; - char *arg; - char *end; - - snprintf(temp, TDM_PATH_LEN, "%s", modules); - - tdm_debug_module = 0; - - arg = strtok_r(temp, TDM_DELIM, &end); - while (arg) { - if (!strncmp(arg, "none", 4)) { - tdm_debug_module = 0; - return TDM_ERROR_NONE; - } - if (!strncmp(arg, "all", 3)) { - tdm_debug_module = 0xFFFFFFFF; - return TDM_ERROR_NONE; - } - if (!strncmp(arg, "buffer", 6)) - tdm_debug_module |= TDM_DEBUG_BUFFER; - else if (!strncmp(arg, "thread", 6)) - tdm_debug_module |= TDM_DEBUG_THREAD; - else if (!strncmp(arg, "mutex", 5)) - tdm_debug_module |= TDM_DEBUG_MUTEX; - else if (!strncmp(arg, "vblank", 6)) - tdm_debug_module |= TDM_DEBUG_VBLANK; - else if (!strncmp(arg, "commit", 6)) - tdm_debug_module |= TDM_DEBUG_COMMIT; - - arg = strtok_r(NULL, TDM_DELIM, &end); - } - - TDM_INFO("module debugging... '%s'", modules); - - return TDM_ERROR_NONE; -} - -INTERN tdm_error -tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_str, char *reply, int *len) +INTERN tdm_private_display * +tdm_display_get(void) { - char temp[TDM_PATH_LEN] = {0,}, temp2[TDM_PATH_LEN] = {0,}; - char *path = NULL, *path2; - char *arg; - char *end; - - snprintf(temp2, TDM_PATH_LEN, "%s", dump_str); - path2 = strtostr(temp, TDM_PATH_LEN, temp2, "@"); - if (!path2 || path2[0] == '\0') - path2 = TDM_DUMP_DIR; - else - path2++; - - tdm_debug_dump = 0; - - snprintf(temp, sizeof(temp), "%s", dump_str); - arg = strtok_r(temp, ",", &end); - TDM_GOTO_IF_FAIL(arg != NULL, done); - - if (!strncmp(arg, "none", 4)) { - tdm_debug_dump = 0; - TDM_SNPRINTF(reply, len, "path: %s\n", (tdm_debug_dump_dir) ? : "unknown"); - if (tdm_debug_dump_dir) { - free(tdm_debug_dump_dir); - tdm_debug_dump_dir = NULL; - } - goto done; - } - - path = tdm_helper_dump_make_directory(path2, reply, len); - TDM_GOTO_IF_FAIL(path != NULL, done); - - if (!strncmp(arg, "current", 7)) { - tdm_private_output *o = NULL; - if (!private_display) { - TDM_WRN("no private_display"); - goto done; - } - - LIST_FOR_EACH_ENTRY(o, &private_display->output_list, link) { - tdm_private_layer *l = NULL; - LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) { - char str[TDM_PATH_LEN]; - if (l->usable || l->caps.capabilities & TDM_LAYER_CAPABILITY_VIDEO) - continue; - if (!l->showing_buffer) - continue; - snprintf(str, TDM_PATH_LEN, "layer_%d_%d", o->index, l->index); - tdm_helper_dump_buffer_str(l->showing_buffer->buffer, path, str); - } - } - - TDM_SNPRINTF(reply, len, "path: %s\n", path); - goto done; - } - - TDM_SNPRINTF(reply, len, "dump: %s\n", arg); - - while (arg) { - if (!strncmp(arg, "all", 3)) { - tdm_debug_dump = 0xFFFFFFFF; - goto done; - } else if (!strncmp(arg, "layer", 5)) { - tdm_debug_dump |= TDM_DUMP_FLAG_LAYER; - } else if (!strncmp(arg, "pp", 2)) { - tdm_debug_dump |= TDM_DUMP_FLAG_PP; - } else if (!strncmp(arg, "capture", 7)) { - tdm_debug_dump |= TDM_DUMP_FLAG_CAPTURE; - } else if (!strncmp(arg, "window", 6)) { - tdm_debug_dump |= TDM_DUMP_FLAG_WINDOW; - } else - goto done; - - arg = strtok_r(NULL, ",", &end); - } - - if (tdm_debug_dump_dir) - free(tdm_debug_dump_dir); - - tdm_debug_dump_dir = strndup(path, TDM_PATH_LEN); - - TDM_INFO("dump... '%s'", dump_str); - -done: - if (path) - free(path); - - return TDM_ERROR_NONE; + return g_private_display; } -INTERN tdm_error -tdm_display_enable_path(const char *path) -{ - static int old_stdout = -1; - char fd_name[TDM_PATH_LEN]; - int log_fd = -1; - FILE *log_fl; - - if (old_stdout == -1) - old_stdout = dup(STDOUT_FILENO); - - tdm_log_enable_dlog(0); - - snprintf(fd_name, TDM_PATH_LEN, "%s", path); - - log_fl = fopen(fd_name, "a"); - if (!log_fl) { - TDM_ERR("failed: open file(%s)\n", fd_name); - return TDM_ERROR_OPERATION_FAILED; - } - - fflush(stderr); - close(STDOUT_FILENO); - - setvbuf(log_fl, NULL, _IOLBF, 512); - log_fd = fileno(log_fl); - - dup2(log_fd, STDOUT_FILENO); - fclose(log_fl); - - return TDM_ERROR_NONE; -} - -static void -_tdm_display_ttrace_vblank_cb(tdm_vblank *vblank, tdm_error error, unsigned int sequence, - unsigned int tv_sec, unsigned int tv_usec, void *user_data) -{ - tdm_error ret = TDM_ERROR_NONE; - - TDM_TRACE_MARK("VSYNC"); - - ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL); - TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); -} - -INTERN tdm_error -tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable) -{ - tdm_private_display *private_display = dpy; - tdm_private_output *private_output = NULL; - const tdm_output_mode *mode = NULL; - tdm_vblank *vblank = NULL; - tdm_error ret = TDM_ERROR_NONE; - - if (!enable) { - LIST_FOR_EACH_ENTRY(private_output, &private_display->output_list, link) { - if (private_output->ttrace_vblank) - tdm_vblank_destroy(private_output->ttrace_vblank); - private_output->ttrace_vblank = NULL; - } - return TDM_ERROR_NONE; - } - - private_output = output; - TDM_RETURN_VAL_IF_FAIL(private_output != NULL, TDM_ERROR_INVALID_PARAMETER); - - if (private_output->ttrace_vblank) - return TDM_ERROR_NONE; - - vblank = tdm_vblank_create(private_display, output, &ret); - TDM_RETURN_VAL_IF_FAIL(vblank != NULL, ret); - - ret = tdm_output_get_mode(output, &mode); - TDM_GOTO_IF_FAIL(mode != NULL, enable_fail); - - ret = tdm_vblank_set_fps(vblank, mode->vrefresh); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); - - ret = tdm_vblank_set_enable_fake(vblank, 1); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); - - ret = tdm_vblank_wait(vblank, 0, 0, 1, _tdm_display_ttrace_vblank_cb, NULL); - TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, enable_fail); - - private_output->ttrace_vblank = vblank; - - return TDM_ERROR_NONE; - -enable_fail: - if (vblank) - tdm_vblank_destroy(vblank); - - return ret; -} - -INTERN tdm_error -tdm_display_enable_ttrace(tdm_private_display *private_display, const char *ttrace, int output_id, char *reply, int *len) -{ - char temp[TDM_PATH_LEN]; - char *arg; - char *end; - tdm_output *output; - tdm_error ret; - tdm_output_type type; - - snprintf(temp, TDM_PATH_LEN, "%s", ttrace); - - tdm_ttrace_output = output_id; - tdm_ttrace_module = 0; - - output = tdm_display_get_output(private_display, output_id, &ret); - if (!output) { - TDM_SNPRINTF(reply, len, "can't find the output_id(%d)\n", output_id); - return ret; - } - - ret = tdm_output_get_output_type(output, &type); - if (ret != TDM_ERROR_NONE) { - TDM_SNPRINTF(reply, len, "can't find the type of output_id(%d)\n", output_id); - return ret; - } - - arg = strtok_r(temp, TDM_DELIM, &end); - while (arg) { - if (!strncmp(arg, "none", 4)) - tdm_ttrace_module = 0; - else if (!strncmp(arg, "all", 3)) - tdm_ttrace_module = 0xFFFFFFFF; - else if (!strncmp(arg, "vsync", 5)) - tdm_ttrace_module |= TDM_TTRACE_VSYNC; - else if (!strncmp(arg, "client_vblank", 13)) - tdm_ttrace_module |= TDM_TTRACE_CLIENT_VBLANK; - else if (!strncmp(arg, "server_vblank", 13)) - tdm_ttrace_module |= TDM_TTRACE_SERVER_VBLANK; - else if (!strncmp(arg, "vblank", 6)) - tdm_ttrace_module |= TDM_TTRACE_VBLANK; - else if (!strncmp(arg, "layer", 5)) - tdm_ttrace_module |= TDM_TTRACE_LAYER; - else if (!strncmp(arg, "pp", 2)) - tdm_ttrace_module |= TDM_TTRACE_PP; - else if (!strncmp(arg, "capture", 7)) - tdm_ttrace_module |= TDM_TTRACE_CAPTURE; - else { - tdm_ttrace_module = 0; - tdm_display_enable_ttrace_vblank(private_display, NULL, 0); - tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0); - TDM_SNPRINTF(reply, len, "unknown option: '%s'\n", arg); - return TDM_ERROR_NONE; - } - - arg = strtok_r(NULL, TDM_DELIM, &end); - } - - TDM_SNPRINTF(reply, len, "ttrace debugging... '%s' %x\n", ttrace, tdm_ttrace_module); - - if (tdm_ttrace_module & TDM_TTRACE_VSYNC) - tdm_display_enable_ttrace_vblank(private_display, output, 1); - else - tdm_display_enable_ttrace_vblank(private_display, NULL, 0); - - if (tdm_ttrace_module & TDM_TTRACE_CLIENT_VBLANK) - tdm_server_enable_ttrace_client_vblank(private_display, output, 1); - else - tdm_server_enable_ttrace_client_vblank(private_display, NULL, 0); - - return TDM_ERROR_NONE; -} - -INTERN tdm_error -tdm_display_enable_fps(tdm_private_display *private_display, int enable) -{ - private_display->print_fps = enable; - - TDM_INFO("print fps: %s", (enable) ? "enable" : "disable"); - - return TDM_ERROR_NONE; -} -/* LCOV_EXCL_STOP */