From e1484d5a3d75564e15a09d9321eb132393d890ce Mon Sep 17 00:00:00 2001 From: Boram Park Date: Mon, 9 Apr 2018 21:34:02 +0900 Subject: [PATCH] implementation Change-Id: I6600b589fb140b2ff5a5c5258f4ddf9bcab89e87 Signed-off-by: Junkyeong Kim --- backends/dummy/tdm_dummy_display.c | 2 +- src/tdm.c | 177 +++++++++++++++++++++++++++---------- src/tdm_backend.c | 47 ++++++++++ src/tdm_display.c | 123 ++++++++++++++++++++++++++ src/tdm_event_loop.c | 4 + src/tdm_helper.c | 4 + src/tdm_layer.c | 14 +++ src/tdm_macro.h | 2 + src/tdm_output.c | 125 +++++++++++++++++++++++++- src/tdm_private.h | 17 +++- src/tdm_private_types.h | 39 ++++++++ src/tdm_thread.c | 2 + 12 files changed, 506 insertions(+), 50 deletions(-) diff --git a/backends/dummy/tdm_dummy_display.c b/backends/dummy/tdm_dummy_display.c index a43c8c9..a3d9d2d 100644 --- a/backends/dummy/tdm_dummy_display.c +++ b/backends/dummy/tdm_dummy_display.c @@ -233,7 +233,7 @@ tdm_dummy_display_create_output_list(tdm_dummy_data *dummy_data) output_data->dummy_data = dummy_data; output_data->pipe = 0; output_data->connector_type = TDM_OUTPUT_TYPE_Unknown; - output_data->status = TDM_OUTPUT_CONN_STATUS_CONNECTED; + output_data->status = TDM_OUTPUT_CONN_STATUS_DISCONNECTED; output_data->output_mode = calloc(1, sizeof(tdm_output_mode)); if (!output_data->output_mode) { diff --git a/src/tdm.c b/src/tdm.c index 6f938ec..3bbd6c3 100644 --- a/src/tdm.c +++ b/src/tdm.c @@ -50,6 +50,8 @@ 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, @@ -81,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) { @@ -197,8 +227,8 @@ _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; @@ -210,6 +240,11 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) 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; + + ret = tdm_output_call_thread_cb_destroy(private_output); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); free(private_output->layers_ptr); @@ -251,6 +286,12 @@ _tdm_display_destroy_private_output(tdm_private_output *private_output) 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 (private_output->vblank) { /* tdm_vblank APIs is for server. it should be called in unlock status*/ _pthread_mutex_unlock(&private_display->lock); @@ -295,6 +336,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) { @@ -302,7 +344,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); @@ -316,6 +358,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 @@ -392,11 +441,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", @@ -446,30 +490,35 @@ _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; @@ -479,6 +528,7 @@ tdm_display_update_output(tdm_private_module *private_module, LIST_INITHEAD(&private_output->vblank_handler_list); LIST_INITHEAD(&private_output->output_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); if (func_output->output_set_status_handler) { @@ -488,7 +538,11 @@ tdm_display_update_output(tdm_private_module *private_module, private_output->regist_change_cb = 1; } - ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->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) @@ -519,18 +573,12 @@ tdm_display_update_output(tdm_private_module *private_module, LIST_INITHEAD(&private_output->layer_commit_handler_list); } } else { - /* need_new_caps will be true only in case of "disconnected -> connected" and "connected -> disconnected" - * because we have to get new modes. - */ - if (need_new_caps) { - _tdm_display_destroy_caps_output(&private_output->caps); - - ret = _tdm_display_update_caps_output(private_module, pipe, output_backend, &private_output->caps); - TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); + _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; - } + if (private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED) + private_output->current_mode = NULL; } /* do not use the layer object when the tdm_output has the hwc capability */ @@ -552,6 +600,11 @@ tdm_display_update_output(tdm_private_module *private_module, 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; } @@ -589,12 +642,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; @@ -609,7 +662,7 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) 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) { @@ -673,7 +726,7 @@ _tdm_display_get_ordered_outputs(tdm_private_module *private_module, int *count) return outputs; -failed_get_outputs: +no_output: free(outputs); *count = 0; return NULL; @@ -684,7 +737,7 @@ _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; if (private_display->pp_module) { ret = _tdm_display_update_caps_pp(private_display->pp_module, @@ -702,14 +755,43 @@ _tdm_display_setup(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 < 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; - for (i = 0; i < output_count; i++) { - ret = tdm_display_update_output(private_module, outputs[i], index++, 1); + 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; } @@ -925,6 +1007,9 @@ _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; + private_module->bdata = bdata; if (ret != TDM_ERROR_NONE) { @@ -983,16 +1068,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; } @@ -1014,6 +1089,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) { @@ -1050,6 +1131,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); @@ -1162,6 +1245,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); diff --git a/src/tdm_backend.c b/src/tdm_backend.c index c979129..7d469d1 100644 --- a/src/tdm_backend.c +++ b/src/tdm_backend.c @@ -44,6 +44,11 @@ TDM_RETURN_VAL_IF_FAIL(dpy != NULL, TDM_ERROR_INVALID_PARAMETER); \ private_display = (tdm_private_display*)dpy; +#define BACKEND_FUNC_ENTRY_VOID() \ + tdm_private_display *private_display; \ + TDM_RETURN_IF_FAIL(dpy != NULL); \ + private_display = (tdm_private_display*)dpy; + static int _check_abi_version(tdm_backend_module *module, int abimaj, int abimin) { @@ -224,3 +229,45 @@ tdm_backend_register_func_capture(tdm_display *dpy, return TDM_ERROR_NONE; } + +EXTERN tdm_error +tdm_backend_register_output(tdm_display *dpy, tdm_output *output) +{ + tdm_error ret; + + BACKEND_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), TDM_ERROR_OPERATION_FAILED); + TDM_RETURN_VAL_IF_FAIL(output != NULL, TDM_ERROR_OPERATION_FAILED); + + /* this function is only for backend. if backend calls this function, it means + * that it's triggered by frontend. frontend should set current_module before calling + * backend functions. + */ + TDM_RETURN_VAL_IF_FAIL(private_display->current_module != NULL, TDM_ERROR_OPERATION_FAILED); + + ret = tdm_display_update_output(private_display->current_module, output); + TDM_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, ret); + + return TDM_ERROR_NONE; +} + +EXTERN void +tdm_backend_unregister_output(tdm_display *dpy, tdm_output *output) +{ + tdm_private_output *private_output; + + BACKEND_FUNC_ENTRY_VOID(); + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + TDM_RETURN_IF_FAIL(output != NULL); + + /* this function is only for backend. if backend calls this function, it means + * that it's triggered by frontend. frontend should set current_module before calling + * backend functions. + */ + TDM_RETURN_IF_FAIL(private_display->current_module != NULL); + + private_output = tdm_display_find_private_output(private_display, output); + tdm_display_destroy_private_output(private_output); +} diff --git a/src/tdm_display.c b/src/tdm_display.c index 45ccdf2..9f6dd72 100644 --- a/src/tdm_display.c +++ b/src/tdm_display.c @@ -53,6 +53,13 @@ TDM_RETURN_VAL_IF_FAIL_WITH_ERROR(dpy != NULL, TDM_ERROR_INVALID_PARAMETER, NULL); \ private_display = (tdm_private_display*)dpy; +#define DISPLAY_FUNC_ENTRY_VOID() \ + tdm_private_display *private_display; \ + TDM_RETURN_IF_FAIL(dpy != NULL); \ + TDM_RETURN_IF_FAIL(tdm_display_is_valid(dpy)); \ + private_display = (tdm_private_display*)dpy; + + #define BACKEND_FUNC_ENTRY() \ tdm_private_module *private_module; \ tdm_private_display *private_display; \ @@ -349,6 +356,122 @@ tdm_display_enable_fps(tdm_private_display *private_display, int enable) } /* LCOV_EXCL_STOP */ +INTERN tdm_error +tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output) +{ + tdm_thread_cb_display_output_create output_create; + tdm_error ret; + + memset(&output_create, 0, sizeof output_create); + output_create.base.type = TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE; + output_create.base.length = sizeof output_create; + output_create.base.object_stamp = 0; + output_create.base.data = NULL; + output_create.base.sync = 1; + output_create.output = output; + + ret = tdm_thread_cb_call(private_display, &output_create.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); + + return TDM_ERROR_NONE; +} + +INTERN void +tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) +{ + tdm_thread_cb_display_output_create *output_create = (tdm_thread_cb_display_output_create*)cb_base; + tdm_private_output_create_handler *create_handler = user_data; + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + assert(create_handler->owner_tid == syscall(SYS_gettid)); + + _pthread_mutex_unlock(&private_display->lock); + create_handler->func(private_display, output_create->output, create_handler->user_data); + _pthread_mutex_lock(&private_display->lock); +} + +EXTERN tdm_error +tdm_display_add_output_create_handler(tdm_display *dpy, + tdm_output_create_handler func, + void *user_data) +{ + tdm_private_output_create_handler *create_handler = NULL; + + DISPLAY_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + LIST_FOR_EACH_ENTRY(create_handler, &private_display->output_create_handler_list, link) { + if (create_handler->func == func && create_handler->user_data == user_data) { + TDM_ERR("can't add twice"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_BAD_REQUEST; + } + } + + create_handler = calloc(1, sizeof(tdm_private_output_create_handler)); + if (!create_handler) { + TDM_ERR("failed: alloc memory"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OUT_OF_MEMORY; + } + + ret = tdm_thread_cb_add(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL, + tdm_display_thread_cb_output_create, create_handler); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("tdm_thread_cb_add failed"); + free(create_handler); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OPERATION_FAILED; + } + + create_handler->private_display = private_display; + create_handler->func = func; + create_handler->user_data = user_data; + create_handler->owner_tid = syscall(SYS_gettid); + + LIST_ADDTAIL(&create_handler->link, &private_display->output_create_handler_list); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + +EXTERN void +tdm_display_remove_output_create_handler(tdm_display *dpy, + tdm_output_create_handler func, + void *user_data) +{ + tdm_private_display *private_display; + tdm_private_output_create_handler *create_handler = NULL, *hh = NULL; + + TDM_RETURN_IF_FAIL(dpy != NULL); + TDM_RETURN_IF_FAIL(func != NULL); + + private_display = (tdm_private_display*)dpy; + + _pthread_mutex_lock(&private_display->lock); + + LIST_FOR_EACH_ENTRY_SAFE(create_handler, hh, &private_display->output_create_handler_list, link) { + if (create_handler->func != func || create_handler->user_data != user_data) + continue; + + tdm_thread_cb_remove(private_display, TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, NULL, + tdm_display_thread_cb_output_create, create_handler); + + LIST_DEL(&create_handler->link); + free(create_handler); + + _pthread_mutex_unlock(&private_display->lock); + + return; + } + + _pthread_mutex_unlock(&private_display->lock); +} + EXTERN tdm_error tdm_display_get_capabilities(tdm_display *dpy, tdm_display_capability *capabilities) diff --git a/src/tdm_event_loop.c b/src/tdm_event_loop.c index b7de4ab..5117c27 100644 --- a/src/tdm_event_loop.c +++ b/src/tdm_event_loop.c @@ -63,6 +63,7 @@ static tdm_error _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_data) { tdm_private_module *private_module = (tdm_private_module*)user_data; + tdm_private_display *private_display; tdm_func_display *func_display; tdm_error ret; @@ -76,7 +77,10 @@ _tdm_event_loop_main_fd_handler(int fd, tdm_event_loop_mask mask, void *user_dat if (!func_display->display_handle_events) return TDM_ERROR_NONE; + private_display = private_module->private_display; + private_display->current_module = private_module; ret = func_display->display_handle_events(private_module->bdata); + private_display->current_module = NULL; return ret; } diff --git a/src/tdm_helper.c b/src/tdm_helper.c index 0c8b336..5b5d96b 100644 --- a/src/tdm_helper.c +++ b/src/tdm_helper.c @@ -846,6 +846,8 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re } } } + if (LIST_IS_EMPTY(&private_module->output_list)) + TDM_SNPRINTF(reply, len, "(no output)\n"); TDM_SNPRINTF(reply, len, "\n"); /* layer information */ @@ -948,6 +950,8 @@ _tdm_helper_get_backend_information(tdm_private_module *private_module, char *re } } } + if (LIST_IS_EMPTY(&private_module->output_list)) + TDM_SNPRINTF(reply, len, "(no layer)\n"); TDM_SNPRINTF(reply, len, "\n"); if (private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP) { diff --git a/src/tdm_layer.c b/src/tdm_layer.c index d8503a5..429f885 100644 --- a/src/tdm_layer.c +++ b/src/tdm_layer.c @@ -1265,6 +1265,20 @@ tdm_layer_set_buffer_queue(tdm_layer *layer, tbm_surface_queue_h buffer_queue) return ret; } +tdm_error +tdm_layer_get_own_buffer_queue(tdm_layer *layer, tbm_surface_queue_h *buffer_queue) +{ + LAYER_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(buffer_queue != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + EXTERN tdm_error tdm_layer_unset_buffer_queue(tdm_layer *layer) { diff --git a/src/tdm_macro.h b/src/tdm_macro.h index 5b8f861..24899c3 100644 --- a/src/tdm_macro.h +++ b/src/tdm_macro.h @@ -245,6 +245,8 @@ TDM_TYPE_NAME_FN(value_type) static struct tdm_type_name tdm_cb_type_names[] = { { TDM_THREAD_CB_NONE, "none" }, { TDM_THREAD_CB_EXIT, "exit" }, + { TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, "output-create" }, + { TDM_THREAD_CB_OUTPUT_DESTROY, "output-destroy" }, { TDM_THREAD_CB_OUTPUT_COMMIT, "output-commit" }, { TDM_THREAD_CB_OUTPUT_VBLANK, "output-vblank" }, { TDM_THREAD_CB_OUTPUT_STATUS, "output-status" }, diff --git a/src/tdm_output.c b/src/tdm_output.c index ee760c1..550a750 100644 --- a/src/tdm_output.c +++ b/src/tdm_output.c @@ -57,6 +57,13 @@ private_output = (tdm_private_output*)output; \ private_display = private_output->private_display +#define OUTPUT_FUNC_ENTRY_VOID() \ + tdm_private_display *private_display; \ + tdm_private_output *private_output; \ + TDM_RETURN_IF_FAIL(tdm_output_is_valid(output)); \ + private_output = (tdm_private_output*)output; \ + private_display = private_output->private_display + static void _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_delay); @@ -130,15 +137,131 @@ _tdm_output_vblank_timeout_update(tdm_private_output *private_output, int ms_del INTERN tdm_error tdm_output_init(tdm_private_display *private_display) { + tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DESTROY, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_COMMIT, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_VBLANK, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_STATUS, tdm_display_find_output_stamp); tdm_thread_cb_set_find_func(TDM_THREAD_CB_OUTPUT_DPMS, tdm_display_find_output_stamp); + return TDM_ERROR_NONE; +} + +INTERN tdm_error +tdm_output_call_thread_cb_destroy(tdm_private_output *private_output) +{ + tdm_thread_cb_output_destroy output_destroy; + tdm_error ret; + + memset(&output_destroy, 0, sizeof output_destroy); + output_destroy.base.type = TDM_THREAD_CB_OUTPUT_DESTROY; + output_destroy.base.length = sizeof output_destroy; + output_destroy.base.object_stamp = private_output->stamp; + output_destroy.base.data = NULL; + output_destroy.base.sync = 1; + + ret = tdm_thread_cb_call(private_output, &output_destroy.base, 1); + TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE); return TDM_ERROR_NONE; } +INTERN void +tdm_output_thread_cb_destroy(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data) +{ + tdm_private_output *private_output = object; + tdm_private_output_destroy_handler *destroy_handler = user_data; + + TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED()); + + assert(destroy_handler->owner_tid == syscall(SYS_gettid)); + + _pthread_mutex_unlock(&private_display->lock); + destroy_handler->func(private_output, destroy_handler->user_data); + _pthread_mutex_lock(&private_display->lock); +} + +EXTERN tdm_error +tdm_output_add_destroy_handler(tdm_output *output, + tdm_output_destroy_handler func, + void *user_data) +{ + tdm_private_output_destroy_handler *destroy_handler = NULL; + OUTPUT_FUNC_ENTRY(); + + TDM_RETURN_VAL_IF_FAIL(func != NULL, TDM_ERROR_INVALID_PARAMETER); + + _pthread_mutex_lock(&private_display->lock); + + LIST_FOR_EACH_ENTRY(destroy_handler, &private_output->destroy_handler_list, link) { + if (destroy_handler->func == func && destroy_handler->user_data == user_data) { + TDM_ERR("can't add twice"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_BAD_REQUEST; + } + } + + destroy_handler = calloc(1, sizeof(tdm_private_output_destroy_handler)); + if (!destroy_handler) { + TDM_ERR("failed: alloc memory"); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OUT_OF_MEMORY; + } + + ret = tdm_thread_cb_add(private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, destroy_handler); + if (ret != TDM_ERROR_NONE) { + TDM_ERR("tdm_thread_cb_add failed"); + free(destroy_handler); + _pthread_mutex_unlock(&private_display->lock); + return TDM_ERROR_OPERATION_FAILED; + } + + destroy_handler->private_output = private_output; + destroy_handler->func = func; + destroy_handler->user_data = user_data; + destroy_handler->owner_tid = syscall(SYS_gettid); + + LIST_ADDTAIL(&destroy_handler->link, &private_output->destroy_handler_list); + + _pthread_mutex_unlock(&private_display->lock); + + return ret; +} + + +EXTERN void +tdm_output_remove_destroy_handler(tdm_output *output, + tdm_output_destroy_handler func, + void *user_data) +{ + tdm_private_display *private_display; + tdm_private_output *private_output; + tdm_private_output_destroy_handler *destroy_handler = NULL, *hh = NULL; + + TDM_RETURN_IF_FAIL(output != NULL); + TDM_RETURN_IF_FAIL(func != NULL); + + private_output = (tdm_private_output*)output; + private_display = private_output->private_display; + + _pthread_mutex_lock(&private_display->lock); + + LIST_FOR_EACH_ENTRY_SAFE(destroy_handler, hh, &private_output->destroy_handler_list, link) { + if (destroy_handler->func != func || destroy_handler->user_data != user_data) + continue; + + tdm_thread_cb_remove(private_output, TDM_THREAD_CB_OUTPUT_DESTROY, NULL, tdm_output_thread_cb_destroy, destroy_handler); + + LIST_DEL(&destroy_handler->link); + free(destroy_handler); + + _pthread_mutex_unlock(&private_display->lock); + + return; + } + + _pthread_mutex_unlock(&private_display->lock); +} + EXTERN tdm_module * tdm_output_get_backend_module(tdm_output *output, tdm_error *error) { @@ -297,7 +420,7 @@ tdm_output_cb_status(tdm_output *output_backend, tdm_output_conn_status status, if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED) || (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) { - ret = tdm_display_update_output(private_output->private_module, output_backend, private_output->pipe, 1); + ret = tdm_display_update_output(private_output->private_module, output_backend); TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE); } else { private_output->caps.status = status; diff --git a/src/tdm_private.h b/src/tdm_private.h index 5e1ed84..6478221 100644 --- a/src/tdm_private.h +++ b/src/tdm_private.h @@ -88,10 +88,17 @@ tdm_display_get(void); int tdm_module_check_abi(tdm_private_module *private_module, int abimaj, int abimin); +tdm_error +tdm_display_call_thread_cb_output_create(tdm_private_display *private_display, tdm_output *output); +void +tdm_display_thread_cb_output_create(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data); void * tdm_display_find_output_stamp(tdm_private_display *private_display, double stamp); tdm_private_output * tdm_display_find_private_output(tdm_private_display *private_display, tdm_output *output_backend); +unsigned int +tdm_display_find_empty_output_pipe(tdm_private_display *private_display); + void * tdm_display_find_hwc_stamp(tdm_private_display *private_display, double stamp); @@ -101,6 +108,10 @@ tdm_display_find_private_hwc(tdm_private_display *private_display, tdm_hwc *hwc_ tdm_error tdm_output_init(tdm_private_display *private_display); +tdm_error +tdm_output_call_thread_cb_destroy(tdm_private_output *private_output); +void +tdm_output_thread_cb_destroy(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data); void tdm_output_thread_cb_change(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data); void @@ -225,8 +236,10 @@ extern int tdm_dump_enable; extern char *tdm_debug_dump_dir; 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); +void +tdm_display_destroy_private_output(tdm_private_output *private_output); + tdm_error tdm_display_enable_debug_module(const char*modules); tdm_error diff --git a/src/tdm_private_types.h b/src/tdm_private_types.h index 37adf72..365ea7d 100644 --- a/src/tdm_private_types.h +++ b/src/tdm_private_types.h @@ -107,6 +107,8 @@ typedef struct _tdm_private_capture tdm_private_capture; typedef struct _tdm_private_loop tdm_private_loop; typedef struct _tdm_private_server tdm_private_server; typedef struct _tdm_private_thread tdm_private_thread; +typedef struct _tdm_private_output_create_handler tdm_private_output_create_handler; +typedef struct _tdm_private_output_destroy_handler tdm_private_output_destroy_handler; typedef struct _tdm_private_output_change_handler tdm_private_output_change_handler; typedef struct _tdm_private_output_commit_handler tdm_private_output_commit_handler; typedef struct _tdm_private_output_vblank_handler tdm_private_output_vblank_handler; @@ -163,6 +165,7 @@ struct _tdm_private_display { #endif struct list_head module_list; + tdm_private_module *dummy_module; tdm_private_module *current_module; //setted only when loading tdm_private_module *pp_module; //pp-support backend tdm_private_module *capture_module; //TODO: remove later @@ -170,6 +173,8 @@ struct _tdm_private_display { /* for event handling */ tdm_private_loop *private_loop; + struct list_head output_create_handler_list; + int print_fps; }; @@ -210,6 +215,7 @@ struct _tdm_private_output { tdm_event_loop_source *vblank_timeout_timer; unsigned int vblank_timeout_timer_expired; + struct list_head destroy_handler_list; struct list_head change_handler_list; void **layers_ptr; @@ -384,6 +390,26 @@ struct _tdm_private_output_vblank_handler { pid_t owner_tid; }; +struct _tdm_private_output_create_handler { + struct list_head link; + + tdm_private_display *private_display; + tdm_output_create_handler func; + void *user_data; + + pid_t owner_tid; +}; + +struct _tdm_private_output_destroy_handler { + struct list_head link; + + tdm_private_output *private_output; + tdm_output_destroy_handler func; + void *user_data; + + pid_t owner_tid; +}; + struct _tdm_private_output_change_handler { struct list_head link; @@ -458,6 +484,8 @@ typedef struct _tdm_capture_private_buffer { typedef enum { TDM_THREAD_CB_NONE, TDM_THREAD_CB_EXIT, /* special type to exit the tdm-thread */ + TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE, + TDM_THREAD_CB_OUTPUT_DESTROY, TDM_THREAD_CB_OUTPUT_COMMIT, TDM_THREAD_CB_OUTPUT_VBLANK, TDM_THREAD_CB_OUTPUT_STATUS, @@ -471,6 +499,8 @@ typedef enum { } tdm_thread_cb_type; typedef struct _tdm_thread_cb_base tdm_thread_cb_base; +typedef struct _tdm_thread_cb_display_output_create tdm_thread_cb_display_output_create; +typedef struct _tdm_thread_cb_output_destroy tdm_thread_cb_output_destroy; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_commit; typedef struct _tdm_thread_cb_output_vblank tdm_thread_cb_output_vblank; typedef struct _tdm_thread_cb_output_dpms tdm_thread_cb_output_dpms; @@ -489,6 +519,15 @@ struct _tdm_thread_cb_base { unsigned int sync; }; +struct _tdm_thread_cb_display_output_create { + tdm_thread_cb_base base; + tdm_output *output; +}; + +struct _tdm_thread_cb_output_destroy { + tdm_thread_cb_base base; +}; + struct _tdm_thread_cb_output_vblank { tdm_thread_cb_base base; unsigned int sequence; diff --git a/src/tdm_thread.c b/src/tdm_thread.c index 2cc2f13..d367d4e 100644 --- a/src/tdm_thread.c +++ b/src/tdm_thread.c @@ -451,6 +451,8 @@ tdm_thread_handle_cb(tdm_private_loop *private_loop) if (tdm_debug_module & TDM_DEBUG_THREAD) TDM_INFO("type(%s), length(%d)", tdm_cb_type_str(base->type), base->length); switch (base->type) { + case TDM_THREAD_CB_DISPLAY_OUTPUT_CREATE: + case TDM_THREAD_CB_OUTPUT_DESTROY: case TDM_THREAD_CB_OUTPUT_COMMIT: case TDM_THREAD_CB_OUTPUT_VBLANK: case TDM_THREAD_CB_OUTPUT_STATUS: -- 2.7.4