X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm.c;h=5d9e04dd4f1957b70015aa8717218d0b16642e43;hb=2adc0c96b4af5f88b3560e8ebd0b595a3f483578;hp=3a0ecad7d87bd0faad290886525c1a31d051d35f;hpb=65b89e98b7f61add110439f250cceab0e106c4af;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm.c b/src/tdm.c index 3a0ecad..5d9e04d 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, @@ -64,11 +68,11 @@ _tdm_display_find_private_layer(tdm_private_output *private_output, INTERN tdm_private_output * tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + 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; } @@ -80,11 +84,11 @@ tdm_display_find_private_output(tdm_private_display *private_display, tdm_output INTERN void * tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_private_output *private_output = NULL; - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + 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; } @@ -194,7 +198,8 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) 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_CHANGE, NULL, tdm_output_thread_cb_change, h); + 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); } @@ -240,48 +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_backend *private_backend = NULL, *bb = NULL; + tdm_private_module *private_module = NULL, *bb = NULL; tdm_private_output *o = NULL, *oo = NULL; tdm_private_pp *p = NULL, *pp = NULL; - LIST_FOR_EACH_ENTRY_SAFE(private_backend, bb, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY_SAFE(p, pp, &private_backend->pp_list, link) { + 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(o, oo, &private_backend->output_list, link) { + LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_module->output_list, link) { _tdm_display_destroy_private_output(o); } - _tdm_display_destroy_caps_pp(&private_backend->caps_pp); - _tdm_display_destroy_caps_capture(&private_backend->caps_capture); + _tdm_display_destroy_caps_pp(&private_module->caps_pp); + _tdm_display_destroy_caps_capture(&private_module->caps_capture); - private_backend->capabilities = 0; - private_backend->caps_display.max_layer_count = 0; + private_module->capabilities = 0; + private_module->caps_display.max_layer_count = 0; - if (private_backend->outputs) { - free(private_backend->outputs); - private_backend->outputs = NULL; + if (private_module->outputs) { + free(private_module->outputs); + private_module->outputs = NULL; } } } static tdm_error -_tdm_display_update_caps_pp(tdm_private_backend *private_backend, tdm_caps_pp *caps) +_tdm_display_update_caps_pp(tdm_private_module *private_module, tdm_caps_pp *caps) { tdm_func_display *func_display; tdm_error ret; - func_display = &private_backend->func_display; + func_display = &private_module->func_display; if (!func_display->display_get_pp_capability) { - TDM_ERR("backend(%s) no display_get_pp_capability()", private_backend->module_data->name); + 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_backend->bdata, caps); + ret = func_display->display_get_pp_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) display_get_pp_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) display_get_pp_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -289,21 +294,21 @@ _tdm_display_update_caps_pp(tdm_private_backend *private_backend, tdm_caps_pp *c } static tdm_error -_tdm_display_update_caps_capture(tdm_private_backend *private_backend, tdm_caps_capture *caps) +_tdm_display_update_caps_capture(tdm_private_module *private_module, tdm_caps_capture *caps) { tdm_func_display *func_display; tdm_error ret; - func_display = &private_backend->func_display; + func_display = &private_module->func_display; if (!func_display->display_get_capture_capability) { - TDM_ERR("backend(%s) no display_get_capture_capability()", private_backend->module_data->name); + 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_backend->bdata, caps); + ret = func_display->display_get_capture_capability(private_module->bdata, caps); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) display_get_capture_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) display_get_capture_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -311,20 +316,20 @@ _tdm_display_update_caps_capture(tdm_private_backend *private_backend, tdm_caps_ } static tdm_error -_tdm_display_update_caps_layer(tdm_private_backend *private_backend, +_tdm_display_update_caps_layer(tdm_private_module *private_module, tdm_layer *layer_backend, tdm_caps_layer *caps) { - tdm_func_layer *func_layer = &private_backend->func_layer; + tdm_func_layer *func_layer = &private_module->func_layer; tdm_error ret; if (!func_layer->layer_get_capability) { - TDM_ERR("backend(%s) no layer_get_capability()", private_backend->module_data->name); + 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("backend(%s) layer_get_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) layer_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -332,26 +337,26 @@ _tdm_display_update_caps_layer(tdm_private_backend *private_backend, } static tdm_error -_tdm_display_update_caps_output(tdm_private_backend *private_backend, 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_backend->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("backend(%s) no output_get_capability()", private_backend->module_data->name); + 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_backend->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); + private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0); if (ret != TDM_ERROR_NONE) { - TDM_ERR("backend(%s) output_get_capability() failed", private_backend->module_data->name); + TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name); return TDM_ERROR_BAD_MODULE; } @@ -375,52 +380,47 @@ _tdm_display_update_layer(tdm_private_output *private_output, 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_backend = private_output->private_backend; + 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_layer->private_backend, 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_backend *private_backend, - 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_backend->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_backend->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_backend->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_backend->output_list); + LIST_ADDTAIL(&private_output->link, &private_module->output_list); - private_output->private_backend = private_backend; - private_output->private_display = private_backend->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; @@ -435,60 +435,43 @@ tdm_display_update_output(tdm_private_backend *private_backend, 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) { func_output->output_set_status_handler(private_output->output_backend, tdm_output_cb_status, private_output); private_output->regist_change_cb = 1; } + } - ret = _tdm_display_update_caps_output(private_backend, pipe, output_backend, - &private_output->caps); - if (ret != TDM_ERROR_NONE) - return ret; - } else { - tdm_caps_output new_caps; - - ret = _tdm_display_update_caps_output(private_backend, pipe, output_backend, - &new_caps); - if (ret != TDM_ERROR_NONE) - return ret; + /* 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); - /* 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; - 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; - } + ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->caps); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); } 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_output, layers[i], i); - if (ret != TDM_ERROR_NONE) - goto failed_update; + 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 ** @@ -507,9 +490,9 @@ _tdm_display_set_main_first(tdm_output **outputs, int index) } static tdm_output ** -_tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *count) +_tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) { - tdm_func_display *func_display = &private_backend->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; @@ -521,12 +504,12 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun tdm_error ret; /* don't change list order if not init time */ - if (private_backend->outputs) { + if (private_module->outputs) { TDM_ERR("can't change output order"); - return private_backend->outputs; + return private_module->outputs; } - outputs = func_display->display_get_outputs(private_backend->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; @@ -535,13 +518,13 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun if (output_count == 0) goto failed_get_outputs; else if (output_count == 1) { - private_backend->outputs = outputs; + private_module->outputs = outputs; return outputs; } /* count connected outputs */ for (i = 0; i < output_count; i++) { - tdm_func_output *func_output = &private_backend->func_output; + tdm_func_output *func_output = &private_module->func_output; tdm_caps_output caps; memset(&caps, 0, sizeof(tdm_caps_output)); @@ -617,7 +600,7 @@ _tdm_display_get_ordered_outputs(tdm_private_backend *private_backend, int *coun new_outputs = outputs; } - private_backend->outputs = new_outputs; + private_module->outputs = new_outputs; return new_outputs; @@ -630,34 +613,34 @@ failed_get_outputs: static tdm_error _tdm_display_update(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_error ret = TDM_ERROR_NONE; int index = 0; - if (private_display->pp_backend) { - ret = _tdm_display_update_caps_pp(private_display->pp_backend, - &private_display->pp_backend->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; } - if (private_display->capture_backend) { - ret = _tdm_display_update_caps_capture(private_display->capture_backend, - &private_display->capture_backend->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; } - LIST_FOR_EACH_ENTRY(private_backend, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { tdm_output **outputs; int output_count = 0, i; - outputs = _tdm_display_get_ordered_outputs(private_backend, &output_count); + 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_backend, outputs[i], index++); + ret = tdm_display_update_output(private_module, outputs[i], index++, 1); if (ret != TDM_ERROR_NONE) goto failed_update; } @@ -742,29 +725,39 @@ _tdm_display_check_module(tdm_backend_module *module) } static tdm_error -_tdm_display_check_backend_functions(tdm_private_backend *private_backend) +_tdm_display_check_backend_functions(tdm_private_module *private_module) { - tdm_func_display *func_display = &private_backend->func_display; - tdm_func_output *func_output = &private_backend->func_output; - tdm_func_layer *func_layer = &private_backend->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_backend->bdata, &private_backend->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_backend->capabilities & TDM_DISPLAY_CAPABILITY_PP) { - tdm_func_pp *func_pp = &private_backend->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 +765,12 @@ _tdm_display_check_backend_functions(tdm_private_backend *private_backend) TDM_RETURN_VAL_IF_FAIL(func_pp->pp_set_done_handler, TDM_ERROR_BAD_MODULE); } - if (private_backend->capabilities & TDM_DISPLAY_CAPABILITY_CAPTURE) { - tdm_func_capture *func_capture = &private_backend->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_backend->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_backend->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); @@ -795,7 +788,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, void *module = NULL; tdm_backend_module *module_data; tdm_backend_data *bdata = NULL; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; tdm_error ret; double stamp; int size; @@ -806,27 +799,27 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, return TDM_ERROR_BAD_MODULE; }; - private_backend = calloc(1, sizeof *private_backend); - if (!private_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_backend->private_display = private_display; + 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(); ret = TDM_ERROR_BAD_MODULE; goto failed_load; } - private_backend->module = module; + private_module->module = module; module_data = dlsym(module, "tdm_backend_module_data"); if (!module_data) { @@ -837,7 +830,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, } TDM_TRACE_END(); - private_backend->module_data = module_data; + private_module->module_data = module_data; TDM_DBG("dlopen, dlsym time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); @@ -848,7 +841,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, goto failed_load; } - private_display->current_backend = private_backend; + 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"); @@ -857,26 +850,26 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, TDM_DBG("backend init() time: %.3f ms", (tdm_helper_get_time() - stamp) * 1000.0); TDM_TRACE_END(); - private_display->current_backend = NULL; + private_display->current_module = NULL; - private_backend->bdata = bdata; + private_module->bdata = bdata; if (ret != TDM_ERROR_NONE) { TDM_ERR("backend(%s) load failed: init error", module_data->name); goto failed_load; } - ret = _tdm_display_check_backend_functions(private_backend); + ret = _tdm_display_check_backend_functions(private_module); if (ret != TDM_ERROR_NONE) { TDM_ERR("backend(%s) load failed: check functions error", module_data->name); goto failed_load; } - LIST_INITHEAD(&private_backend->output_list); - LIST_INITHEAD(&private_backend->pp_list); - LIST_INITHEAD(&private_backend->capture_list); + LIST_INITHEAD(&private_module->output_list); + LIST_INITHEAD(&private_module->pp_list); + LIST_INITHEAD(&private_module->capture_list); - LIST_ADDTAIL(&private_backend->link, &private_display->backend_list); + LIST_ADDTAIL(&private_module->link, &private_display->module_list); TDM_INFO("Success to load '%s' module", module_data->name); @@ -884,9 +877,10 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, failed_load: if (bdata) module_data->deinit(bdata); - dlclose(module); - if (private_backend) - free(private_backend); + if (module) + dlclose(module); + if (private_module) + free(private_module); return ret; } @@ -899,7 +893,7 @@ _tdm_display_load_modules(tdm_private_display *private_display) char *arg; char *end; - LIST_INITHEAD(&private_display->backend_list); + LIST_INITHEAD(&private_display->module_list); module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE); @@ -917,7 +911,7 @@ _tdm_display_load_modules(tdm_private_display *private_display) } /* load bufmgr priv from dummy lib */ - if (LIST_IS_EMPTY(&private_display->backend_list)) { + 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) @@ -932,17 +926,17 @@ _tdm_display_load_modules(tdm_private_display *private_display) static void _tdm_display_unload_modules(tdm_private_display *private_display) { - tdm_private_backend *private_backend = NULL, *bb = NULL; + tdm_private_module *private_module = NULL, *bb = NULL; - LIST_FOR_EACH_ENTRY_SAFE(private_backend, bb, &private_display->backend_list, link) { - LIST_DEL(&private_backend->link); + LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) { + LIST_DEL(&private_module->link); - if (private_backend->module_data) - private_backend->module_data->deinit(private_backend->bdata); - if (private_backend->module) - dlclose(private_backend->module); + if (private_module->module_data) + private_module->module_data->deinit(private_module->bdata); + if (private_module->module) + dlclose(private_module->module); - free(private_backend); + free(private_module); } } /* LCOV_EXCL_STOP */ @@ -1070,9 +1064,9 @@ tdm_display_init(tdm_error *error) private_display->init_count = 1; g_private_display = private_display; - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; - LIST_FOR_EACH_ENTRY(b, &private_display->backend_list, link) { + 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); @@ -1084,12 +1078,12 @@ tdm_display_init(tdm_error *error) * 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_backend *b = NULL; + 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->backend_list, link) { + 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); @@ -1111,11 +1105,11 @@ tdm_display_init(tdm_error *error) failed_update: _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: @@ -1152,9 +1146,10 @@ tdm_display_deinit(tdm_display *dpy) */ _pthread_mutex_lock(&private_display->lock); tdm_event_loop_stop(private_display); - tdm_event_loop_deinit(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. @@ -1204,13 +1199,13 @@ tdm_display_is_valid(tdm_display *dpy) INTERN int tdm_output_is_valid(tdm_output *output) { - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; if (!output || !g_private_display) return 0; - LIST_FOR_EACH_ENTRY(b, &g_private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &g_private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) if (o == output) return 1; @@ -1221,9 +1216,9 @@ tdm_output_is_valid(tdm_output *output) /* LCOV_EXCL_START */ INTERN int -tdm_backend_check_module_abi(tdm_private_backend *private_backend, int abimaj, int abimin) +tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin) { - tdm_backend_module *module = private_backend->module_data; + tdm_backend_module *module = private_module->module_data; if (TDM_BACKEND_GET_ABI_MAJOR(module->abi_version) < abimaj) return 0; @@ -1311,7 +1306,7 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s TDM_GOTO_IF_FAIL(path != NULL, done); if (!strncmp(arg, "current", 7)) { - tdm_private_backend *b = NULL; + tdm_private_module *b = NULL; tdm_private_output *o = NULL; if (!private_display) { @@ -1319,7 +1314,7 @@ tdm_display_enable_dump(tdm_private_display *private_display, const char *dump_s goto done; } - LIST_FOR_EACH_ENTRY(b, &private_display->backend_list, link) { + LIST_FOR_EACH_ENTRY(b, &private_display->module_list, link) { LIST_FOR_EACH_ENTRY(o, &b->output_list, link) { tdm_private_layer *l = NULL; LIST_FOR_EACH_ENTRY(l, &o->layer_list, link) { @@ -1388,15 +1383,15 @@ INTERN tdm_error tdm_display_enable_ttrace_vblank(tdm_display *dpy, tdm_output *output, int enable) { tdm_private_display *private_display = dpy; - tdm_private_backend *private_backend = NULL; + tdm_private_module *private_module = NULL; 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_backend, &private_display->backend_list, link) { - LIST_FOR_EACH_ENTRY(private_output, &private_backend->output_list, link) { + 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->ttrace_vblank) tdm_vblank_destroy(private_output->ttrace_vblank); private_output->ttrace_vblank = NULL;