X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftdm.c;h=f20bfa4962a9adb3e9ace92ae7fcb49d13a02e5e;hb=7d4b4af6e3fa30d838b15fb031e2337842823d71;hp=fca53ddd2d49d1ee35212c38d1d0c9d49e9f23fc;hpb=a1cca1d19c5d26aa9dfad12d88a27d0e16cdb606;p=platform%2Fcore%2Fuifw%2Flibtdm.git diff --git a/src/tdm.c b/src/tdm.c index fca53dd..f20bfa4 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,12 @@ 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; + +static tdm_error _tdm_display_load_module_with_file(tdm_private_display *private_display, const char *file); + /* LCOV_EXCL_START */ static tdm_private_layer * _tdm_display_find_private_layer(tdm_private_output *private_output, @@ -77,6 +83,34 @@ tdm_display_find_private_output(tdm_private_display *private_display, tdm_output return NULL; } +INTERN unsigned int +tdm_display_find_empty_output_pipe(tdm_private_display *private_display) +{ + tdm_private_module *private_module = NULL; + tdm_private_output *private_output = NULL; + unsigned int pipe = 0; + while (1) { + int found = 0; + 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->pipe == pipe) { + found = 1; + break; + } + } + if (found) + break; + } + + if (!found) + break; + else + pipe++; + } + + return pipe; +} + INTERN void * tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp) { @@ -93,6 +127,64 @@ tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp return NULL; } +INTERN void * +tdm_display_find_private_voutput(tdm_private_display *private_display, double stamp) +{ + tdm_private_module *private_module = NULL; + tdm_private_voutput *private_voutput = NULL; + tdm_private_output *private_output = NULL; + + private_module = private_display->virtual_module; + if (!private_module) return NULL; + + LIST_FOR_EACH_ENTRY(private_voutput, &private_module->voutput_list, link) { + if (!private_voutput->private_output) continue; + private_output = private_voutput->private_output; + if (private_output->stamp == stamp) + return private_voutput; + } + + return NULL; +} + +tdm_private_hwc * +tdm_display_find_private_hwc(tdm_private_display *private_display, tdm_hwc *hwc_backend) +{ + tdm_private_module *private_module = NULL; + tdm_private_output *private_output = NULL; + tdm_private_hwc *private_hwc = NULL; + + 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->private_hwc) continue; + private_hwc = private_output->private_hwc; + if (private_hwc->hwc_backend == hwc_backend) + return private_hwc; + } + } + + return NULL; +} + +INTERN void * +tdm_display_find_hwc_stamp(tdm_private_display *private_display, double stamp) +{ + tdm_private_module *private_module = NULL; + tdm_private_output *private_output = NULL; + tdm_private_hwc *private_hwc = NULL; + + 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->private_hwc) continue; + private_hwc = private_output->private_hwc; + if (private_hwc->stamp == stamp) + return private_hwc; + } + } + + return NULL; +} + static void _tdm_display_destroy_caps_pp(tdm_caps_pp *caps_pp) { @@ -155,17 +247,25 @@ _tdm_display_destroy_private_layer(tdm_private_layer *private_layer) free(private_layer); } -static void -_tdm_display_destroy_private_output(tdm_private_output *private_output) +INTERN 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 *private_hwc = NULL; tdm_private_hwc_window *hw = NULL, *hww = NULL; tdm_private_capture *c = NULL, *cc = NULL; tdm_private_output_vblank_handler *v = NULL, *vv = NULL; tdm_private_output_commit_handler *om = NULL, *omm = NULL; + tdm_private_hwc_commit_handler *hm = NULL, *hmm = NULL; tdm_private_layer_commit_handler *lm = NULL, *lmm = NULL; tdm_private_output_change_handler *h = NULL, *hh = NULL; + tdm_private_output_destroy_handler *dh = NULL, *dhh = NULL; + tdm_error ret; + int mutex_locked = 0; + + ret = tdm_output_call_thread_cb_destroy(private_output); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); free(private_output->layers_ptr); @@ -182,9 +282,17 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) free(om); } - LIST_FOR_EACH_ENTRY_SAFE(lm, lmm, &private_output->layer_commit_handler_list, link) { - LIST_DEL(&lm->link); - free(lm); + if (private_output->private_hwc) { + private_hwc = private_output->private_hwc; + LIST_FOR_EACH_ENTRY_SAFE(hm, hmm, &private_hwc->hwc_commit_handler_list, link) { + LIST_DEL(&hm->link); + free(hm); + } + } else { + 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) { @@ -194,40 +302,49 @@ _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); } + LIST_FOR_EACH_ENTRY_SAFE(dh, dhh, &private_output->destroy_handler_list, link) { + LIST_DEL(&dh->link); + tdm_thread_cb_remove(dh->private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, dh); + free(dh); + } + + if (tdm_thread_is_running() && TDM_MUTEX_IS_LOCKED()) mutex_locked = 1; if (private_output->vblank) { /* tdm_vblank APIs is for server. it should be called in unlock status*/ - _pthread_mutex_unlock(&private_display->lock); + if (mutex_locked) _pthread_mutex_unlock(&private_display->lock); tdm_vblank_destroy(private_output->vblank); - _pthread_mutex_lock(&private_display->lock); + if (mutex_locked) _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); + if (mutex_locked) _pthread_mutex_unlock(&private_display->lock); tdm_vblank_destroy(private_output->ttrace_vblank); - _pthread_mutex_lock(&private_display->lock); + if (mutex_locked) _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); + tdm_capture_destroy_internal(c); - LIST_FOR_EACH_ENTRY_SAFE(l, ll, &private_output->layer_list, link) - _tdm_display_destroy_private_layer(l); + if (private_output->private_hwc) { + private_hwc = private_output->private_hwc; + LIST_FOR_EACH_ENTRY_SAFE(hw, hww, &private_hwc->hwc_window_list, link) + tdm_hwc_window_destroy_internal(hw); + if (private_hwc->display_target_buffer) + tbm_surface_internal_unref(private_hwc->display_target_buffer); + free(private_hwc); + } else { + 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. */ @@ -243,6 +360,7 @@ _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; + tdm_private_output_create_handler *ch = NULL, *chh = 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) { @@ -250,7 +368,7 @@ _tdm_display_destroy_private_display(tdm_private_display *private_display) } LIST_FOR_EACH_ENTRY_SAFE(o, oo, &private_module->output_list, link) { - _tdm_display_destroy_private_output(o); + tdm_display_destroy_private_output(o); } _tdm_display_destroy_caps_pp(&private_module->caps_pp); @@ -264,6 +382,13 @@ _tdm_display_destroy_private_display(tdm_private_display *private_display) private_module->outputs = NULL; } } + + LIST_FOR_EACH_ENTRY_SAFE(ch, chh, &private_display->output_create_handler_list, link) { + LIST_DEL(&ch->link); + tdm_thread_cb_remove(ch->private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL, + tdm_display_thread_cb_output_create, ch); + free(ch); + } } static tdm_error @@ -340,11 +465,6 @@ _tdm_display_update_caps_output(tdm_private_module *private_module, int pipe, tdm_error ret; double stamp; - if (!func_output->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", @@ -394,41 +514,47 @@ _tdm_display_update_layer(tdm_private_output *private_output, } INTERN tdm_error -tdm_display_update_output(tdm_private_module *private_module, - tdm_output *output_backend, int pipe, unsigned int need_new_caps) +tdm_display_update_output(tdm_private_module *private_module, tdm_output *output_backend) { tdm_func_output *func_output = &private_module->func_output; + tdm_private_display *private_display = NULL; tdm_private_output *private_output = NULL; tdm_layer **layers = NULL; + tdm_private_hwc *private_hwc = NULL; + tdm_hwc *hwc; int layer_count = 0, i; tdm_error ret; + unsigned int output_created = 0; + + private_display = private_module->private_display; - private_output = tdm_display_find_private_output(private_module->private_display, output_backend); + private_output = tdm_display_find_private_output(private_display, output_backend); if (!private_output) { + unsigned int pipe = tdm_display_find_empty_output_pipe(private_display); + 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_module->private_display, private_output->stamp)) + while (tdm_display_find_output_stamp(private_display, private_output->stamp)) private_output->stamp++; LIST_ADDTAIL(&private_output->link, &private_module->output_list); private_output->private_module = private_module; - private_output->private_display = private_module->private_display; + private_output->private_display = 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->output_commit_handler_list); - LIST_INITHEAD(&private_output->layer_commit_handler_list); LIST_INITHEAD(&private_output->pending_commit_handler_list); + LIST_INITHEAD(&private_output->destroy_handler_list); LIST_INITHEAD(&private_output->change_handler_list); + LIST_INITHEAD(&private_output->mode_change_request_handler_list); if (func_output->output_set_status_handler) { func_output->output_set_status_handler(private_output->output_backend, @@ -436,50 +562,88 @@ tdm_display_update_output(tdm_private_module *private_module, private_output); private_output->regist_change_cb = 1; } - } - /* 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) { + output_created = 1; + + /* NOTE that output modes will be allocated newly after here */ _tdm_display_destroy_caps_output(&private_output->caps); + ret = _tdm_display_update_caps_output(private_module, private_output->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; + + /* get the tdm_hwc object */ + if (private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) { + hwc = func_output->output_get_hwc(output_backend, &ret); + TDM_RETURN_VAL_IF_FAIL(hwc != NULL, ret); + + private_hwc = calloc(1, sizeof(tdm_private_hwc)); + TDM_RETURN_VAL_IF_FAIL(private_hwc != NULL, TDM_ERROR_OUT_OF_MEMORY); + + private_hwc->private_module = private_module; + private_hwc->private_output = private_output; + private_hwc->hwc_backend = hwc; + private_hwc->index = pipe; + private_hwc->stamp = tdm_helper_get_time(); + while (tdm_display_find_hwc_stamp(private_module->private_display, private_hwc->stamp)) + private_hwc->stamp++; + + LIST_INITHEAD(&private_hwc->hwc_window_list); + LIST_INITHEAD(&private_hwc->hwc_commit_handler_list); - ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->caps); + private_output->private_hwc = private_hwc; + } else { + LIST_INITHEAD(&private_output->layer_list); + LIST_INITHEAD(&private_output->layer_commit_handler_list); + } + } else { + _tdm_display_destroy_caps_output(&private_output->caps); + ret = _tdm_display_update_caps_output(private_module, private_output->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) { - free(layers); - return ret; + if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + private_output->current_mode = NULL; } - for (i = 0; i < layer_count; i++) { - ret = _tdm_display_update_layer(private_output, layers[i], i); + /* do not use the layer object when the tdm_output has the hwc capability */ + if ((private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) == 0) { + layers = func_output->output_get_layers(output_backend, &layer_count, &ret); 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) { + free(layers); + return ret; + } + } + + free(layers); } - free(layers); + if (output_created) { + ret = tdm_display_call_thread_cb_output_create(private_display, private_output); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); + } return TDM_ERROR_NONE; } -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 ** @@ -487,7 +651,6 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) { 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; @@ -504,12 +667,12 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret); if (ret != TDM_ERROR_NONE) - goto failed_get_outputs; + goto no_output; *count = output_count; if (output_count == 0) - goto failed_get_outputs; + goto no_output; else if (output_count == 1) { private_module->outputs = outputs; return outputs; @@ -521,15 +684,10 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) 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; + goto no_output; } if (caps.status == TDM_OUTPUT_CONN_STATUS_CONNECTED) { @@ -570,45 +728,42 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) 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_module->outputs = new_outputs; + private_module->outputs = outputs; - return new_outputs; + return outputs; -failed_get_outputs: +no_output: free(outputs); *count = 0; return NULL; } static tdm_error -_tdm_display_update(tdm_private_display *private_display) +_tdm_display_setup(tdm_private_display *private_display) { tdm_private_module *private_module = NULL; tdm_error ret = TDM_ERROR_NONE; - int index = 0; + int output_count = 0; + int virtual = 0; if (private_display->pp_module) { ret = _tdm_display_update_caps_pp(private_display->pp_module, @@ -626,19 +781,56 @@ _tdm_display_update(tdm_private_display *private_display) LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) { tdm_output **outputs; - int output_count = 0, i; + int i, count = 0; - outputs = _tdm_display_get_ordered_outputs(private_module, &output_count); - if (!outputs) - goto failed_update; + outputs = _tdm_display_get_ordered_outputs(private_module, &count); + + if (count > 0) + TDM_GOTO_IF_FAIL(outputs != NULL, failed_update); - for (i = 0; i < output_count; i++) { - ret = tdm_display_update_output(private_module, outputs[i], index++, 1); + for (i = 0; i < count; i++) { + ret = tdm_display_update_output(private_module, outputs[i]); if (ret != TDM_ERROR_NONE) goto failed_update; + output_count++; } } + /* At least, the output count should be greater than 0 to ensure tdm_vblank works. + * So we will create a dummy output when backends don't have any output. + * Without destroying a tdm_output object, this dummy output will be replaced with + * a virtual output which is created in runtime. + */ + if (output_count == 0) { + tdm_output **outputs; + int i, count = 0; + + TDM_INFO("loading a %s backend", TDM_DUMMY_MODULE); + ret = _tdm_display_load_module_with_file(private_display, TDM_DUMMY_MODULE); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed_update); + TDM_GOTO_IF_FAIL(private_display->dummy_module != NULL, failed_update); + + private_module = private_display->dummy_module; + + outputs = _tdm_display_get_ordered_outputs(private_module, &count); + TDM_GOTO_IF_FAIL(count > 0, failed_update); + TDM_GOTO_IF_FAIL(outputs != NULL, failed_update); + + for (i = 0; i < count; i++) { + ret = tdm_display_update_output(private_module, outputs[i]); + if (ret != TDM_ERROR_NONE) + goto failed_update; + } + } + + virtual = tdm_config_get_int(TDM_CONFIG_KEY_GENERAL_VIRTUAL_OUTPUT, 0); + if (virtual) { + TDM_INFO("loading a %s backend", TDM_VIRTUAL_MODULE); + ret = _tdm_display_load_module_with_file(private_display, TDM_VIRTUAL_MODULE); + TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, failed_update); + TDM_GOTO_IF_FAIL(private_display->virtual_module != NULL, failed_update); + } + return TDM_ERROR_NONE; failed_update: @@ -651,7 +843,6 @@ EXTERN tdm_error tdm_display_update(tdm_display *dpy) { 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); TDM_DEPRECATED(NULL); @@ -670,10 +861,14 @@ static pthread_mutex_t gLock = PTHREAD_MUTEX_INITIALIZER; static tdm_error _tdm_display_check_module(tdm_backend_module *module) { - int major, minor; + int tdm_backend_major, tdm_backend_minor; + int backend_module_major, backend_module_minor; - TDM_INFO("TDM ABI version : %d.%d", - TDM_MAJOR_VERSION, TDM_MINOR_VERSION); + tdm_backend_major = TDM_BACKEND_GET_ABI_MAJOR(TDM_BACKEND_ABI_LATEST_VERSION); + tdm_backend_minor = TDM_BACKEND_GET_ABI_MINOR(TDM_BACKEND_ABI_LATEST_VERSION); + + TDM_INFO("TDM Backend ABI version : %d.%d", + tdm_backend_major, tdm_backend_minor); if (!module->name) { TDM_ERR("TDM backend doesn't have name"); @@ -685,22 +880,23 @@ _tdm_display_check_module(tdm_backend_module *module) return TDM_ERROR_BAD_MODULE; } - major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version); - minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version); + backend_module_major = TDM_BACKEND_GET_ABI_MAJOR(module->abi_version); + backend_module_minor = TDM_BACKEND_GET_ABI_MINOR(module->abi_version); 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); + TDM_INFO("'%s' backend ABI version: %d.%d", module->name, backend_module_major, backend_module_minor); - if (major != TDM_MAJOR_VERSION) { - TDM_ERR("'%s' major version mismatch, %d != %d", - module->name, major, TDM_MAJOR_VERSION); + if (backend_module_major > tdm_backend_major) { + TDM_ERR("'%s' major version(%d) is newer than %d", + module->name, backend_module_major, tdm_backend_major); return TDM_ERROR_BAD_MODULE; } - if (minor > TDM_MINOR_VERSION) { + if (tdm_backend_major == backend_module_major && + backend_module_minor > tdm_backend_minor) { TDM_ERR("'%s' minor version(%d) is newer than %d", - module->name, minor, TDM_MINOR_VERSION); + module->name, backend_module_minor, tdm_backend_minor); return TDM_ERROR_BAD_MODULE; } @@ -806,9 +1002,9 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, 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; + ret = TDM_ERROR_NO_MODULE; goto failed_load; } @@ -845,6 +1041,12 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, private_display->current_module = NULL; + if (!strncmp(file, TDM_DUMMY_MODULE, TDM_NAME_LEN)) + private_display->dummy_module = private_module; + + if (!strncmp(file, TDM_VIRTUAL_MODULE, TDM_NAME_LEN)) + private_display->virtual_module = private_module; + private_module->bdata = bdata; if (ret != TDM_ERROR_NONE) { @@ -859,6 +1061,7 @@ _tdm_display_load_module_with_file(tdm_private_display *private_display, } LIST_INITHEAD(&private_module->output_list); + LIST_INITHEAD(&private_module->voutput_list); LIST_INITHEAD(&private_module->pp_list); LIST_INITHEAD(&private_module->capture_list); @@ -881,7 +1084,7 @@ static tdm_error _tdm_display_load_modules(tdm_private_display *private_display) { const char *module_names; - tdm_error ret = 0; + tdm_error ret = TDM_ERROR_NONE; char temp[TDM_PATH_LEN]; char *arg; char *end; @@ -903,16 +1106,6 @@ _tdm_display_load_modules(tdm_private_display *private_display) 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); - } - return ret; } @@ -934,6 +1127,12 @@ _tdm_display_unload_modules(tdm_private_display *private_display) } /* LCOV_EXCL_STOP */ +INTERN void * +tdm_display_find_stamp(tdm_private_display *private_display, double stamp) +{ + return (void*)g_private_display; +} + EXTERN tdm_display * tdm_display_init(tdm_error *error) { @@ -955,10 +1154,6 @@ 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 */ @@ -970,6 +1165,8 @@ tdm_display_init(tdm_error *error) private_display->stamp = tdm_helper_get_time(); + LIST_INITHEAD(&private_display->output_create_handler_list); + str = tdm_config_get_string(TDM_CONFIG_KEY_DEBUG_MODULE, NULL); if (str) tdm_display_enable_debug_module(str); @@ -1008,6 +1205,10 @@ tdm_display_init(tdm_error *error) if (ret != TDM_ERROR_NONE) goto failed_load; + ret = tdm_hwc_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; @@ -1017,7 +1218,7 @@ tdm_display_init(tdm_error *error) goto failed_load; ret = _tdm_display_load_modules(private_display); - if (ret != TDM_ERROR_NONE) + if (!(ret == TDM_ERROR_NONE || ret == TDM_ERROR_NO_MODULE)) goto failed_load; stamp2 = tdm_helper_get_time(); @@ -1043,7 +1244,7 @@ tdm_display_init(tdm_error *error) #endif TDM_TRACE_BEGIN("TDM_Update_Display"); - ret = _tdm_display_update(private_display); + ret = _tdm_display_setup(private_display); TDM_TRACE_END(); if (ret != TDM_ERROR_NONE) goto failed_update; @@ -1057,15 +1258,6 @@ 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(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 */ @@ -1087,6 +1279,8 @@ tdm_display_init(tdm_error *error) if (error) *error = TDM_ERROR_NONE; + tdm_thread_cb_set_find_func(TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, tdm_display_find_stamp); + _pthread_mutex_unlock(&private_display->lock); pthread_mutex_unlock(&gLock); @@ -1123,8 +1317,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--; @@ -1139,9 +1331,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. @@ -1180,330 +1373,3 @@ tdm_display_get(void) return g_private_display; } -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_module *b = NULL; - tdm_private_output *o = NULL; - - if (!output || !g_private_display) - return 0; - - 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; - } - - return 0; -} - -/* LCOV_EXCL_START */ -INTERN int -tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin) -{ - tdm_backend_module *module = private_module->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_CONFIG_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, "event", 5)) - tdm_debug_module |= TDM_DEBUG_EVENT; - 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_CONFIG_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) -{ - 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_module *b = NULL; - tdm_private_output *o = NULL; - - if (!private_display) { - TDM_WRN("no private_display"); - goto done; - } - - 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) { - 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; -} - -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_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_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; - } - } - 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_CONFIG_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_CONFIG_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 */