libtdm uses hal-api-tdm from Tizen 6.5.
Therefore, libtdm links libhal-api-tdm library and libtdm work with
hal-api-tdm when the hal-backend-tdm backend library at /hal/lib directory.
If not, libtdm works with the legacy tdm backend so file at /usr/lib/tdm
directory.
Change-Id: I76aebd60306d87705669c61af1033259ed3a1a67
Signed-off-by: Junkyeong Kim <jk0430.kim@samsung.com>
PKG_CHECK_MODULES(WAYLAND_SCANNER, wayland-scanner >= 1.7.0)
-PKG_CHECK_MODULES(TDM, dlog libtbm libpng pixman-1 wayland-server iniparser)
+PKG_CHECK_MODULES(TDM, dlog libtbm libpng pixman-1 wayland-server iniparser hal-api-tdm)
PKG_CHECK_MODULES(TDM_CLIENT, dlog libtbm wayland-client)
PKG_CHECK_MODULES(TTRACE,
BuildRequires: pkgconfig(wayland-client)
BuildRequires: pkgconfig(iniparser)
BuildRequires: pkgconfig(pixman-1)
+BuildRequires: pkgconfig(hal-api-tdm)
BuildRequires: gtest-devel
%description
tdm_func_output *func_output = &private_module->func_output;
char temp[TDM_NAME_LEN];
tdm_error ret;
+ hal_tdm_error hret;
double stamp;
int n;
stamp = tdm_helper_get_time();
- ret = func_output->output_get_capability(output_backend, caps);
- TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms",
- private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0);
-
- if (ret != TDM_ERROR_NONE) {
- TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name);
- return TDM_ERROR_BAD_MODULE;
+ if (private_module->use_hal_tdm) {
+ hret = hal_tdm_output_get_capability(output_backend, (hal_tdm_caps_output *)caps);
+ TDM_DBG("backend(HAL-TDM) backend output_get_capability() time: %.3f ms",
+ (tdm_helper_get_time() - stamp) * 1000.0);
+ if (hret != HAL_TDM_ERROR_NONE) {
+ TDM_ERR("backend(HAL-TDM) output_get_capability() failed");
+ return TDM_ERROR_BAD_MODULE;
+ }
+ } else {
+ ret = func_output->output_get_capability(output_backend, caps);
+ TDM_DBG("backend(%s) backend output_get_capability() time: %.3f ms",
+ private_module->module_data->name, (tdm_helper_get_time() - stamp) * 1000.0);
+ if (ret != TDM_ERROR_NONE) {
+ TDM_ERR("backend(%s) output_get_capability() failed", private_module->module_data->name);
+ return TDM_ERROR_BAD_MODULE;
+ }
}
/* FIXME: Use model for tdm client to distinguish amoung outputs */
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,
- tdm_output_cb_status,
- private_output);
- private_output->regist_change_cb = 1;
+ if (private_module->use_hal_tdm) {
+ hal_tdm_error hret;
+ hret = hal_tdm_output_set_status_handler(private_output->output_backend, tdm_output_cb_status_hal_tdm, private_output);
+ if (hret == HAL_TDM_ERROR_NONE)
+ private_output->regist_change_cb = 1;
+ } else {
+ 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;
+ }
}
output_created = 1;
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);
+ if (private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) {
+ if (private_module->use_hal_tdm)
+ hwc = (tdm_hwc *)hal_tdm_output_get_hwc(output_backend, (hal_tdm_error *)&ret);
+ else
+ 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));
}
/* do not use the layer object when the tdm_output has the hwc capability */
- if ((private_output->caps.capabilities&TDM_OUTPUT_CAPABILITY_HWC) == 0) {
+ if ((private_output->caps.capabilities & TDM_OUTPUT_CAPABILITY_HWC) == 0) {
+ if (private_module->use_hal_tdm) {
+ TDM_ERR("hal-tdm not support layer");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
layers = func_output->output_get_layers(output_backend, &layer_count, &ret);
if (ret != TDM_ERROR_NONE) {
free(layers);
return private_module->outputs;
}
- outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret);
+ if (private_module->use_hal_tdm)
+ outputs = (tdm_output **)hal_tdm_display_get_outputs(private_module->htdm_backend, &output_count, (hal_tdm_error *)&ret);
+ else
+ outputs = func_display->display_get_outputs(private_module->bdata, &output_count, &ret);
if (ret != TDM_ERROR_NONE)
goto no_output;
tdm_caps_output caps;
memset(&caps, 0, sizeof(tdm_caps_output));
- ret = func_output->output_get_capability(outputs[i], &caps);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_get_capability(outputs[i], (hal_tdm_caps_output *)&caps);
+ else
+ ret = func_output->output_get_capability(outputs[i], &caps);
if (ret != TDM_ERROR_NONE) {
TDM_ERR("output_get_capability() failed");
goto no_output;
int virtual = 0;
int virtual_hwc_target_buffer_bo_default = 0;
- if (private_display->pp_module) {
+ if (private_display->pp_module && !private_display->pp_module->use_hal_tdm) {
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_module) {
+ if (private_display->capture_module && !private_display->pp_module->use_hal_tdm) {
ret = _tdm_display_update_caps_capture(private_display->capture_module,
&private_display->capture_module->caps_capture);
if (ret != TDM_ERROR_NONE)
/* LCOV_EXCL_START */
static tdm_error
+_tdm_display_load_hal_backend(tdm_private_display *private_display)
+{
+ hal_tdm_backend *hal_tdm = NULL;
+ hal_tdm_display *hal_tdm_dpy = NULL;
+ tdm_private_module *private_module = NULL;
+ hal_tdm_event_source **event_sources = NULL;
+ hal_tdm_caps_display caps;
+ hal_tdm_caps_pp pp_caps;
+ hal_tdm_caps_capture capture_caps;
+ hal_tdm_error hret;
+ tdm_error error;
+ int num = 0;
+
+ hal_tdm = hal_tdm_get_backend(&hret);
+ if (hal_tdm == NULL || hret != HAL_TDM_ERROR_NONE) {
+ TDM_INIT_INFO("failed hal_tdm_get_backend");
+ return TDM_ERROR_NO_MODULE;
+ }
+
+ private_module = calloc(1, sizeof *private_module);
+ if (private_module == NULL) {
+ TDM_ERR("failed: alloc");
+ hal_tdm_put_backend(hal_tdm);
+ return TDM_ERROR_OUT_OF_MEMORY;
+ }
+
+ hal_tdm_dpy = hal_tdm_backend_get_display(hal_tdm, &hret);
+ if (hal_tdm_dpy == NULL || hret != HAL_TDM_ERROR_NONE) {
+ TDM_ERR("failed hal_tdm_backend_get_display");
+ goto fail;
+ }
+
+ if (hal_tdm_display_get_capability(hal_tdm_dpy, &caps) != HAL_TDM_ERROR_NONE) {
+ TDM_ERR("failed hal_tdm_display_get_capability");
+ goto fail;
+ }
+
+ private_module->use_hal_tdm = 1;
+ private_module->htdm_backend = hal_tdm;
+ private_module->htdm_dpy = hal_tdm_dpy;
+ private_module->private_display = private_display;
+ private_display->current_module = private_module;
+
+ if (hal_tdm_display_get_pp_capability(hal_tdm_dpy, &pp_caps) == HAL_TDM_ERROR_NONE) {
+ private_display->pp_module = private_module;
+ private_module->caps_pp.capabilities = (tdm_pp_capability)pp_caps.capabilities;
+ private_module->caps_pp.format_count = pp_caps.format_count;
+ private_module->caps_pp.formats = pp_caps.formats;
+ private_module->caps_pp.min_w = pp_caps.min_w;
+ private_module->caps_pp.min_h = pp_caps.min_h;
+ private_module->caps_pp.max_w = pp_caps.max_w;
+ private_module->caps_pp.max_h = pp_caps.max_h;
+ private_module->caps_pp.preferred_align = pp_caps.preferred_align;
+ private_module->caps_pp.preferred_align_vertical = pp_caps.preferred_align_vertical;
+ private_module->caps_pp.max_attach_count = pp_caps.max_attach_count;
+ }
+ if (hal_tdm_display_get_capture_capability(hal_tdm_dpy, &capture_caps) == HAL_TDM_ERROR_NONE) {
+ private_display->capture_module = private_module;
+ private_module->caps_capture.capabilities = (tdm_capture_capability)capture_caps.capabilities;
+ private_module->caps_capture.format_count = capture_caps.format_count;
+ private_module->caps_capture.formats = capture_caps.formats;
+ private_module->caps_capture.min_w = capture_caps.min_w;
+ private_module->caps_capture.min_h = capture_caps.min_h;
+ private_module->caps_capture.max_w = capture_caps.max_w;
+ private_module->caps_capture.max_h = capture_caps.max_h;
+ private_module->caps_capture.preferred_align = capture_caps.preferred_align;
+ private_module->caps_capture.max_attach_count = capture_caps.max_attach_count;
+ }
+
+ LIST_INITHEAD(&private_module->output_list);
+ LIST_INITHEAD(&private_module->voutput_list);
+ LIST_INITHEAD(&private_module->pp_list);
+ LIST_INITHEAD(&private_module->capture_list);
+
+ LIST_ADDTAIL(&private_module->link, &private_display->module_list);
+
+ event_sources = hal_tdm_backend_get_event_sources(hal_tdm, &num, &hret);
+ if (num != 0 && hret == HAL_TDM_ERROR_NONE) {
+ for (int i = 0; i < num; i++) {
+ hal_tdm_event_source *event_source = event_sources[i];
+ private_module->htdm_event_source = tdm_event_loop_add_fd_handler(private_display, event_source->event_fd,
+ TDM_EVENT_LOOP_READABLE, (tdm_event_loop_fd_handler)event_source->func, event_source->user_data, &error);
+ break;
+ }
+ }
+
+ TDM_INIT_INFO("use hal tdm");
+
+ return TDM_ERROR_NONE;
+
+fail:
+ hal_tdm_put_backend(hal_tdm);
+ free(private_module);
+ return TDM_ERROR_NO_MODULE;
+}
+
+static tdm_error
_tdm_display_check_module(tdm_backend_module *module)
{
int tdm_backend_major, tdm_backend_minor;
LIST_INITHEAD(&private_display->module_list);
+ if (_tdm_display_load_hal_backend(private_display) == TDM_ERROR_NONE) {
+ TDM_INIT_INFO("use hal tdm");
+ return ret;
+ }
+
module_names = tdm_config_get_string(TDM_CONFIG_KEY_GENERAL_BACKENDS, TDM_DEFAULT_MODULE);
snprintf(temp, TDM_PATH_LEN, "%s", module_names);
LIST_FOR_EACH_ENTRY_SAFE(private_module, bb, &private_display->module_list, link) {
LIST_DEL(&private_module->link);
+ if (private_module->use_hal_tdm) {
+ if (private_module->htdm_event_source)
+ tdm_event_loop_source_remove(private_module->htdm_event_source);
+ hal_tdm_put_backend(private_module->htdm_backend);
+ free(private_module);
+ continue;
+ }
if (private_module->module_data)
private_module->module_data->deinit(private_module->bdata);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+static void
+_tdm_capture_cb_done_hal_tdm(hal_tdm_capture *capture_module, tbm_surface_h buffer, void *user_data)
+{
+ tdm_private_capture *private_capture = user_data;
+ tdm_thread_cb_capture_done capture_done;
+ tdm_error ret;
+
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+ memset(&capture_done, 0, sizeof capture_done);
+ capture_done.base.type = TDM_THREAD_CB_CAPTURE_DONE;
+ capture_done.base.length = sizeof capture_done;
+ capture_done.base.object_stamp = private_capture->stamp;
+ capture_done.base.data = NULL;
+ capture_done.base.sync = 0;
+ capture_done.buffer = buffer;
+
+ ret = tdm_thread_cb_call(private_capture, &capture_done.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
static void *
_tdm_capture_find_object(tdm_private_display *private_display, double stamp)
{
/* LCOV_EXCL_STOP */
}
- capture_module = func_output->output_create_capture(
- private_output->output_backend, &ret);
+ if (private_module->use_hal_tdm)
+ capture_module = (tdm_capture *)hal_tdm_output_create_capture(private_output->output_backend, (hal_tdm_error *)&ret);
+ else
+ capture_module = func_output->output_create_capture(private_output->output_backend, &ret);
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
- if (error)
- *error = ret;
+ if (error) *error = ret;
return NULL;
/* LCOV_EXCL_STOP */
}
if (!private_capture) {
/* LCOV_EXCL_START */
TDM_ERR("failed: alloc memory");
- func_capture->capture_destroy(capture_module);
- if (error)
- *error = TDM_ERROR_OUT_OF_MEMORY;
- return NULL;
+ if (error) *error = TDM_ERROR_OUT_OF_MEMORY;
+ goto alloc_fail;
/* LCOV_EXCL_STOP */
}
ret = tdm_thread_cb_add(private_capture, TDM_THREAD_CB_CAPTURE_DONE, NULL, _tdm_capture_thread_cb_done, NULL);
if (ret != TDM_ERROR_NONE) {
+ /* LCOV_EXCL_START */
TDM_ERR("capture tdm_thread_cb_add failed");
- func_capture->capture_destroy(capture_module);
- free(private_capture);
- if (error)
- *error = ret;
- return NULL;
+ if (error) *error = ret;
+ goto thread_fail;
+ /* LCOV_EXCL_STOP */
}
- ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture);
+ if (private_module->use_hal_tdm)
+ ret = (hal_tdm_error)hal_tdm_capture_set_done_handler((hal_tdm_capture *)capture_module, _tdm_capture_cb_done_hal_tdm, private_capture);
+ else
+ ret = func_capture->capture_set_done_handler(capture_module, _tdm_capture_cb_done, private_capture);
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
TDM_ERR("capture(%p) set capture_done_handler failed", private_capture);
- func_capture->capture_destroy(capture_module);
- free(private_capture);
- if (error)
- *error = ret;
- return NULL;
+ if (error) *error = ret;
+ goto thread_fail;
/* LCOV_EXCL_STOP */
}
*error = TDM_ERROR_NONE;
return private_capture;
+
+thread_fail:
+ free(private_capture);
+alloc_fail:
+ if (private_module->use_hal_tdm)
+ hal_tdm_capture_destroy((hal_tdm_capture *)capture_module);
+ else
+ func_capture->capture_destroy(capture_module);
+
+ return NULL;
}
/* LCOV_EXCL_START */
private_module = private_capture->private_module;
func_capture = &private_module->func_capture;
- func_capture->capture_destroy(private_capture->capture_module);
+ if (private_module->use_hal_tdm)
+ hal_tdm_capture_destroy((hal_tdm_capture *)private_capture->capture_module);
+ else
+ func_capture->capture_destroy(private_capture->capture_module);
if (!LIST_IS_EMPTY(&private_capture->pending_buffer_list)) {
TDM_WRN("capture(%p) not finished:", private_capture);
_pthread_mutex_lock(&private_display->lock);
- if (!func_capture->capture_set_info) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_capture->capture_set_info) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
if (info->type == TDM_CAPTURE_TYPE_STREAM && info->frequency == 0) {
FOURCC_STR(info->dst_config.format),
info->transform, info->type, info->frequency, info->flags);
- ret = func_capture->capture_set_info(private_capture->capture_module, info);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_capture_set_info((hal_tdm_capture *)private_capture->capture_module, (hal_tdm_info_capture *)info);
+ else
+ ret = func_capture->capture_set_info(private_capture->capture_module, info);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
private_capture->info = *info;
_pthread_mutex_lock(&private_display->lock);
- if (!func_capture->capture_attach) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_capture->capture_attach) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
if (tdm_module_check_abi(private_module, 1, 2) &&
/* LCOV_EXCL_STOP */
}
- ret = func_capture->capture_attach(private_capture->capture_module, buffer);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_capture_attach((hal_tdm_capture *)private_capture->capture_module, buffer);
+ else
+ ret = func_capture->capture_attach(private_capture->capture_module, buffer);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
if (ret != TDM_ERROR_NONE) {
return TDM_ERROR_BAD_REQUEST;
}
- if (!func_capture->capture_commit) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_capture->capture_commit) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
LIST_INITHEAD(&commit_buffer_list);
_tdm_capture_print_list(&private_capture->buffer_list);
}
- ret = func_capture->capture_commit(private_capture->capture_module);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_capture_commit((hal_tdm_capture *)private_capture->capture_module);
+ else
+ ret = func_capture->capture_commit(private_capture->capture_module);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
return NULL;
}
- func_display = &private_module->func_display;
- func_voutput = &private_module->func_voutput;
current_module = private_display->current_module;
private_display->current_module = private_module;
- voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
-
+ if (private_module->use_hal_tdm) {
+ voutput_backend = (tdm_voutput *)hal_tdm_display_voutput_create(private_module->htdm_backend, name, (hal_tdm_error *)&ret);
+ } else {
+ func_display = &private_module->func_display;
+ func_voutput = &private_module->func_voutput;
+ voutput_backend = func_display->display_voutput_create(private_module->bdata, name, &ret);
+ }
if (voutput_backend == NULL || ret != TDM_ERROR_NONE) {
TDM_ERR("display_voutput_create fail");
- free(private_voutput);
if (error) *error = ret;
- private_display->current_module = current_module;
- _pthread_mutex_unlock(&private_display->lock);
- return NULL;
+ goto voutput_create_fail;
}
private_voutput->voutput_backend = voutput_backend;
private_voutput->private_display = private_display;
private_voutput->private_module = private_module;
LIST_INITHEAD(&private_voutput->voutput_commit_handler_list);
- output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
+ if (private_module->use_hal_tdm)
+ output_backend = (tdm_output *)hal_tdm_voutput_get_output((hal_tdm_voutput *)voutput_backend, (hal_tdm_error *)&ret);
+ else
+ output_backend = func_voutput->voutput_get_output(voutput_backend, &ret);
if (output_backend == NULL || ret != TDM_ERROR_NONE) {
TDM_ERR("voutput_get_output fail");
- free(private_voutput);
if (error) *error = ret;
- if (func_voutput->voutput_destroy)
- func_voutput->voutput_destroy(voutput_backend);
- else
- TDM_ERR("no destroy function");
- private_display->current_module = current_module;
- _pthread_mutex_unlock(&private_display->lock);
- return NULL;
+ goto output_get_fail;
}
- if (func_voutput->voutput_set_target_buffer_queue_flag) {
+ if (private_module->use_hal_tdm) {
if (private_module->use_default_type_bo == 1)
- func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_DEFAULT);
+ hal_tdm_voutput_set_target_buffer_queue_flag((hal_tdm_voutput *)voutput_backend, TBM_BO_DEFAULT);
else
- func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_SCANOUT);
+ hal_tdm_voutput_set_target_buffer_queue_flag((hal_tdm_voutput *)voutput_backend, TBM_BO_SCANOUT);
+ } else {
+ if (func_voutput->voutput_set_target_buffer_queue_flag) {
+ if (private_module->use_default_type_bo == 1)
+ func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_DEFAULT);
+ else
+ func_voutput->voutput_set_target_buffer_queue_flag(voutput_backend, TBM_BO_SCANOUT);
+ }
}
ret = tdm_display_update_output(private_display->current_module, output_backend);
if (ret != TDM_ERROR_NONE) {
TDM_ERR("tdm_display_update_output fail");
- free(private_voutput);
- if (func_voutput->voutput_destroy)
- func_voutput->voutput_destroy(voutput_backend);
- else
- TDM_ERR("no destroy function");
if (error) *error = ret;
- private_display->current_module = current_module;
- _pthread_mutex_unlock(&private_display->lock);
- return NULL;
+ goto update_output_fail;
}
LIST_FOR_EACH_ENTRY(private_output, &private_module->output_list, link) {
if (output_find != 1) {
private_output = NULL;
free(private_voutput);
- if (func_voutput->voutput_destroy)
- func_voutput->voutput_destroy(voutput_backend);
- else
- TDM_ERR("no destroy function");
+ if (private_module->use_hal_tdm) {
+ hal_tdm_voutput_destroy((hal_tdm_voutput *)voutput_backend);
+ } else {
+ if (func_voutput->voutput_destroy)
+ func_voutput->voutput_destroy(voutput_backend);
+ else
+ TDM_ERR("no destroy function");
+ }
private_voutput = NULL;
} else {
strncpy(private_voutput->name, name, TDM_NAME_LEN - 1);
_pthread_mutex_unlock(&private_display->lock);
return private_voutput;
+
+update_output_fail:
+output_get_fail:
+ if (private_module->use_hal_tdm) {
+ hal_tdm_voutput_destroy((hal_tdm_voutput *)voutput_backend);
+ } else {
+ if (func_voutput->voutput_destroy)
+ func_voutput->voutput_destroy(voutput_backend);
+ else
+ TDM_ERR("no destroy function");
+ }
+voutput_create_fail:
+ free(private_voutput);
+ private_display->current_module = current_module;
+ _pthread_mutex_unlock(&private_display->lock);
+
+ return NULL;
}
/* LCOV_EXCL_STOP */
if (tdm_debug_module & TDM_DEBUG_EVENT)
TDM_INFO("backend fd(%d) event happens", private_module->fd);
- func_display = &private_module->func_display;
- 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;
+ if (private_module->use_hal_tdm) {
+ tdm_private_module *current_module;
+ private_display = private_module->private_display;
+ current_module = private_display->current_module;
+ private_display->current_module = private_module;
+ ret = (tdm_error)hal_tdm_display_handle_events(private_module->htdm_backend);
+ if (ret == TDM_ERROR_NONE)
+ private_display->current_module = NULL;
+ else
+ private_display->current_module = current_module;
+ } else {
+ func_display = &private_module->func_display;
+ 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;
}
TDM_RETURN_IF_FAIL(private_loop != NULL);
LIST_FOR_EACH_ENTRY(private_module, &private_display->module_list, link) {
- tdm_func_display *func_display = &private_module->func_display;
-
- if (!func_display->display_get_fd) {
- TDM_INFO("TDM backend module won't offer a display fd");
- private_module->event_source = NULL;
- private_module->fd = -1;
- continue;
+ if (private_module->use_hal_tdm) {
+ if (hal_tdm_display_get_fd(private_module->htdm_backend, &fd) != HAL_TDM_ERROR_NONE) {
+ TDM_INFO("TDM backend module won't offer a display fd");
+ private_module->event_source = NULL;
+ private_module->fd = -1;
+ continue;
+ }
+ ret = TDM_ERROR_NONE;
+ } else {
+ tdm_func_display *func_display = &private_module->func_display;
+
+ if (!func_display->display_get_fd) {
+ TDM_INFO("TDM backend module won't offer a display fd");
+ private_module->event_source = NULL;
+ private_module->fd = -1;
+ continue;
+ }
+
+ ret = func_display->display_get_fd(private_module->bdata, &fd);
+ assert(func_display->display_handle_events);
}
-
- ret = func_display->display_get_fd(private_module->bdata, &fd);
-
assert(ret == TDM_ERROR_NONE && fd >= 0);
- assert(func_display->display_handle_events);
private_module->event_source =
tdm_event_loop_add_fd_handler(private_display, fd,
TDM_SNPRINTF(reply, len, "\t\tname\ttype\tidx\tvalue\n");
for (i = 0; i < private_output->caps.prop_count; i++) {
tdm_value value;
- TDM_DBG_RETURN_VAL_IF_FAIL(func_output->output_get_property, reply);
- ret = func_output->output_get_property(private_output->output_backend,
- private_output->caps.props[i].id,
- &value);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend,
+ private_output->caps.props[i].id,
+ (hal_tdm_value *)&value);
+ } else {
+ TDM_DBG_RETURN_VAL_IF_FAIL(func_output->output_get_property, reply);
+ ret = func_output->output_get_property(private_output->output_backend,
+ private_output->caps.props[i].id,
+ &value);
+ }
TDM_DBG_RETURN_VAL_IF_FAIL(ret == TDM_ERROR_NONE, reply);
TDM_SNPRINTF(reply, len, "\t\t%s\t%s\t%u\t",
private_output->caps.props[i].name,
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+static void
+_tdm_hwc_cb_commit_hal_tdm(hal_tdm_hwc *hwc_backend, unsigned int sequence,
+ unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+ tdm_private_hwc_commit_handler *hwc_commit_handler = user_data;
+ tdm_private_hwc *private_hwc;
+ tdm_thread_cb_hwc_commit hwc_commit;
+ tdm_error ret;
+
+ if (hwc_commit_handler && hwc_commit_handler->use_vblank)
+ return;
+
+ if (hwc_commit_handler)
+ private_hwc = hwc_commit_handler->private_hwc;
+ else
+ private_hwc = tdm_display_find_private_hwc(tdm_display_get(), (tdm_hwc *)hwc_backend);
+
+ memset(&hwc_commit, 0, sizeof hwc_commit);
+ hwc_commit.base.type = TDM_THREAD_CB_HWC_COMMIT;
+ hwc_commit.base.length = sizeof hwc_commit;
+ hwc_commit.base.object_stamp = private_hwc->stamp;
+ hwc_commit.base.data = hwc_commit_handler;
+ hwc_commit.base.sync = 0;
+ hwc_commit.sequence = sequence;
+ hwc_commit.tv_sec = tv_sec;
+ hwc_commit.tv_usec = tv_usec;
+
+ ret = tdm_thread_cb_call(private_hwc, &hwc_commit.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
/* LCOV_EXCL_START */
static void
_tdm_hwc_got_wait_vblank(unsigned int sequence,
private_module = private_output->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_video_supported_formats) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_video_supported_formats(private_hwc->hwc_backend, formats, count);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_video_supported_formats((hal_tdm_hwc *)private_hwc->hwc_backend, formats, count);
+ } else {
+ if (!func_hwc->hwc_get_video_supported_formats) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_video_supported_formats(private_hwc->hwc_backend, formats, count);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_video_available_properties) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_video_available_properties(private_hwc->hwc_backend, props, count);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_video_available_properties((hal_tdm_hwc *)private_hwc->hwc_backend,
+ (const hal_tdm_prop **)props, count);
+ } else {
+ if (!func_hwc->hwc_get_video_available_properties) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_video_available_properties(private_hwc->hwc_backend, props, count);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_capabilities) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc->hwc_get_capabilities(private_hwc->hwc_backend, capabilities);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_capabilities((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_capability *)capabilities);
+ } else {
+ if (!func_hwc->hwc_get_capabilities) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc->hwc_get_capabilities(private_hwc->hwc_backend, capabilities);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_available_properties) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_available_properties(private_hwc->hwc_backend, props, count);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_available_properties((hal_tdm_hwc *)private_hwc->hwc_backend, (const hal_tdm_prop **)props, count);
+ } else {
+ if (!func_hwc->hwc_get_available_properties) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_available_properties(private_hwc->hwc_backend, props, count);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_client_target_buffer_queue) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return NULL;
- /* LCOV_EXCL_STOP */
- }
-
- queue = func_hwc->hwc_get_client_target_buffer_queue(private_hwc->hwc_backend, error);
+ if (private_module->use_hal_tdm) {
+ queue = hal_tdm_hwc_get_client_target_buffer_queue((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_error *)error);
+ } else {
+ if (!func_hwc->hwc_get_client_target_buffer_queue) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return NULL;
+ /* LCOV_EXCL_STOP */
+ }
+ queue = func_hwc->hwc_get_client_target_buffer_queue(private_hwc->hwc_backend, error);
+ }
_pthread_mutex_unlock(&private_display->lock);
return queue;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_set_client_target_buffer) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_set_client_target_buffer(private_hwc->hwc_backend, target_buffer, damage);
+ if (private_module->use_hal_tdm) {
+ hal_tdm_region hdamage;
+ memcpy(&hdamage, &damage, sizeof(hal_tdm_region));
+ ret = (tdm_error)hal_tdm_hwc_set_client_target_buffer((hal_tdm_hwc *)private_hwc->hwc_backend, target_buffer, hdamage);
+ } else {
+ if (!func_hwc->hwc_set_client_target_buffer) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_set_client_target_buffer(private_hwc->hwc_backend, target_buffer, damage);
+ }
if (private_hwc->display_target_buffer) {
if (private_hwc->display_target_buffer != target_buffer) {
tbm_surface_internal_unref(private_hwc->display_target_buffer);
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_set_client_target_acquire_fence) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_set_client_target_acquire_fence(private_hwc->hwc_backend, acquire_fence);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_set_client_target_acquire_fence((hal_tdm_hwc *)private_hwc->hwc_backend, acquire_fence);
+ } else {
+ if (!func_hwc->hwc_set_client_target_acquire_fence) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_set_client_target_acquire_fence(private_hwc->hwc_backend, acquire_fence);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_validate) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ if (num_wnds == 0) {
+ ret = (tdm_error)hal_tdm_hwc_validate((hal_tdm_hwc *)private_hwc->hwc_backend, NULL, 0, num_types);
- if (num_wnds == 0) {
- ret = func_hwc->hwc_validate(private_hwc->hwc_backend, NULL, 0, num_types);
+ _pthread_mutex_unlock(&private_display->lock);
+ return ret;
+ }
+ } else {
+ if (!func_hwc->hwc_validate) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
- _pthread_mutex_unlock(&private_display->lock);
- return ret;
- }
+ if (num_wnds == 0) {
+ ret = func_hwc->hwc_validate(private_hwc->hwc_backend, NULL, 0, num_types);
+ _pthread_mutex_unlock(&private_display->lock);
+ return ret;
+ }
+ }
composited_wnds_backend = calloc(num_wnds, sizeof(tdm_hwc_window *));
if (!composited_wnds_backend) {
/* LCOV_EXCL_START */
for (i = 0; i < num_wnds; i++)
composited_wnds_backend[i] = composited_wnds_frontend[i]->hwc_window_backend;
- ret = func_hwc->hwc_validate(private_hwc->hwc_backend, composited_wnds_backend,
- num_wnds, num_types);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_hwc_validate((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_window **)composited_wnds_backend,
+ num_wnds, num_types);
+ else
+ ret = func_hwc->hwc_validate(private_hwc->hwc_backend, composited_wnds_backend,
+ num_wnds, num_types);
free(composited_wnds_backend);
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_changed_composition_types) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_changed_composition_types((hal_tdm_hwc *)private_hwc->hwc_backend, num_elements,
+ (hal_tdm_hwc_window **)hwc_window,
+ (hal_tdm_hwc_window_composition *)composition_types);
+ } else {
+ if (!func_hwc->hwc_get_changed_composition_types) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
- ret = func_hwc->hwc_get_changed_composition_types(private_hwc->hwc_backend,
- num_elements, hwc_window, composition_types);
+ ret = func_hwc->hwc_get_changed_composition_types(private_hwc->hwc_backend,
+ num_elements, hwc_window, composition_types);
+ }
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
_pthread_mutex_unlock(&private_display->lock);
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_validate) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_accept_validation(private_hwc->hwc_backend);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_accept_validation((hal_tdm_hwc *)private_hwc->hwc_backend);
+ } else {
+ if (!func_hwc->hwc_validate) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_accept_validation(private_hwc->hwc_backend);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_commit) {
- /* LCOV_EXCL_START */
- TDM_WRN("not implemented!!");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_hwc->hwc_commit) {
+ /* LCOV_EXCL_START */
+ TDM_WRN("not implemented!!");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
//TODO: I am not sure yet whether we have to check the dpms at hwc_commit.
if (!private_hwc->regist_commit_cb) {
private_hwc->regist_commit_cb = 1;
- ret = func_hwc->hwc_set_commit_handler(private_hwc->hwc_backend, _tdm_hwc_cb_commit);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_hwc_set_commit_handler((hal_tdm_hwc *)private_hwc->hwc_backend, _tdm_hwc_cb_commit_hal_tdm);
+ else
+ ret = func_hwc->hwc_set_commit_handler(private_hwc->hwc_backend, _tdm_hwc_cb_commit);
/* LCOV_EXCL_START */
if (ret != TDM_ERROR_NONE) {
private_hwc->regist_commit_cb = 0;
}
}
- ret = func_hwc->hwc_commit(private_hwc->hwc_backend, sync, hwc_commit_handler);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_hwc_commit((hal_tdm_hwc *)private_hwc->hwc_backend, sync, hwc_commit_handler);
+ else
+ ret = func_hwc->hwc_commit(private_hwc->hwc_backend, sync, hwc_commit_handler);
TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
if (hwc_use_vblank) {
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_commit_fence) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_commit_fence(private_hwc->hwc_backend, commit_fence);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_commit_fence((hal_tdm_hwc *)private_hwc->hwc_backend, commit_fence);
+ } else {
+ if (!func_hwc->hwc_get_commit_fence) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_commit_fence(private_hwc->hwc_backend, commit_fence);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_release_fences) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_release_fences(private_hwc->hwc_backend, num_elements,
- hwc_windows, fences);
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_release_fences((hal_tdm_hwc *)private_hwc->hwc_backend, num_elements,
+ (hal_tdm_hwc_window **)hwc_windows, fences);
+ } else {
+ if (!func_hwc->hwc_get_release_fences) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_release_fences(private_hwc->hwc_backend, num_elements,
+ hwc_windows, fences);
+ }
if (hwc_windows == NULL || fences == NULL) {
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_NONE;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_set_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_set_property(private_hwc->hwc_backend, id, value);
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value));
+ ret = (tdm_error)hal_tdm_hwc_set_property((hal_tdm_hwc *)private_hwc->hwc_backend, id, hvalue);
+ } else {
+ if (!func_hwc->hwc_set_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_set_property(private_hwc->hwc_backend, id, value);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- if (!func_hwc->hwc_get_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
-
- ret = func_hwc->hwc_get_property(private_hwc->hwc_backend, id, value);
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ ret = (tdm_error)hal_tdm_hwc_get_property((hal_tdm_hwc *)private_hwc->hwc_backend, id, &hvalue);
+ memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value));
+ } else {
+ if (!func_hwc->hwc_get_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_hwc->hwc_get_property(private_hwc->hwc_backend, id, value);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_hwc->private_module;
func_hwc = &private_module->func_hwc;
- /* LCOV_EXCL_START */
- if (!func_hwc->hwc_get_commit_interval) {
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc->hwc_get_commit_interval(private_hwc->hwc_backend, refresh);
- /* LCOV_EXCL_STOP */
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_get_commit_interval((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_hwc_commit_interval *)refresh);
+ } else {
+ /* LCOV_EXCL_START */
+ if (!func_hwc->hwc_get_commit_interval) {
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc->hwc_get_commit_interval(private_hwc->hwc_backend, refresh);
+ /* LCOV_EXCL_STOP */
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
- if (!func_hwc->hwc_create_window) {
- /* LCOV_EXCL_START */
- if (error)
- *error = TDM_ERROR_BAD_MODULE;
- return NULL;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_hwc->hwc_create_window) {
+ /* LCOV_EXCL_START */
+ if (error)
+ *error = TDM_ERROR_BAD_MODULE;
+ return NULL;
+ /* LCOV_EXCL_STOP */
+ }
}
private_hwc_window = calloc(1, sizeof(tdm_private_hwc_window));
return NULL;
/* LCOV_EXCL_STOP */
}
-
- hwc_window_backend = func_hwc->hwc_create_window(private_hwc->hwc_backend, &ret);
+ if (private_module->use_hal_tdm)
+ hwc_window_backend = (tdm_hwc_window *)hal_tdm_hwc_create_window((hal_tdm_hwc *)private_hwc->hwc_backend, (hal_tdm_error *)&ret);
+ else
+ hwc_window_backend = func_hwc->hwc_create_window(private_hwc->hwc_backend, &ret);
if (ret != TDM_ERROR_NONE) {
free(private_hwc_window);
if (error)
LIST_DEL(&private_hwc_window->link);
- func_hwc_window = &private_module->func_hwc_window;
- func_hwc_window->hwc_window_destroy(private_hwc_window->hwc_window_backend);
+ if (private_module->use_hal_tdm)
+ hal_tdm_hwc_window_destroy((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend);
+ else
+ func_hwc_window->hwc_window_destroy(private_hwc_window->hwc_window_backend);
free(private_hwc_window);
}
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_acquire_buffer_queue) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- if (error)
- *error = TDM_ERROR_NOT_IMPLEMENTED;
- return NULL;
+ if (private_module->use_hal_tdm) {
+ queue = hal_tdm_hwc_window_acquire_buffer_queue((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, (hal_tdm_error *)error);
+ } else {
+ if (!func_hwc_window->hwc_window_acquire_buffer_queue) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ if (error)
+ *error = TDM_ERROR_NOT_IMPLEMENTED;
+ return NULL;
+ }
+
+ queue = func_hwc_window->hwc_window_acquire_buffer_queue(private_hwc_window->hwc_window_backend, error);
}
-
- queue = func_hwc_window->hwc_window_acquire_buffer_queue(private_hwc_window->hwc_window_backend, error);
-
_pthread_mutex_unlock(&private_display->lock);
return queue;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_release_buffer_queue) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return;
- }
-
- func_hwc_window->hwc_window_release_buffer_queue(private_hwc_window->hwc_window_backend, queue);
+ if (private_module->use_hal_tdm) {
+ hal_tdm_hwc_window_release_buffer_queue((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, queue);
+ } else {
+ if (!func_hwc_window->hwc_window_release_buffer_queue) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return;
+ }
+ func_hwc_window->hwc_window_release_buffer_queue(private_hwc_window->hwc_window_backend, queue);
+ }
_pthread_mutex_unlock(&private_display->lock);
return;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_composition_type) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_hwc_window_set_composition_type((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend,
+ (tdm_hwc_window_composition)composition_type);
+ } else {
+ if (!func_hwc_window->hwc_window_set_composition_type) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+
+ ret = func_hwc_window->hwc_window_set_composition_type(private_hwc_window->hwc_window_backend, composition_type);
}
-
- ret = func_hwc_window->hwc_window_set_composition_type(private_hwc_window->hwc_window_backend, composition_type);
if (ret == TDM_ERROR_NONE)
private_hwc_window->composition_type = composition_type;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_buffer_damage) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (private_module->use_hal_tdm) {
+ hal_tdm_region hdamage;
+ memcpy(&hdamage, &damage, sizeof(hal_tdm_region));
+ ret = (tdm_error)hal_tdm_hwc_window_set_buffer_damage((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, hdamage);
+ } else {
+ if (!func_hwc_window->hwc_window_set_buffer_damage) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+
+ ret = func_hwc_window->hwc_window_set_buffer_damage(private_hwc_window->hwc_window_backend, damage);
}
-
- ret = func_hwc_window->hwc_window_set_buffer_damage(private_hwc_window->hwc_window_backend, damage);
-
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_info) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (!private_module->use_hal_tdm) {
+ if (!func_hwc_window->hwc_window_set_info) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
}
if (info->src_config.format)
info->dst_pos.w, info->dst_pos.h,
info->transform);
- ret = func_hwc_window->hwc_window_set_info(private_hwc_window->hwc_window_backend, info);
+ if (private_module->use_hal_tdm)
+ ret = hal_tdm_hwc_window_set_info((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, (hal_tdm_hwc_window_info *)info);
+ else
+ ret = func_hwc_window->hwc_window_set_info(private_hwc_window->hwc_window_backend, info);
_pthread_mutex_unlock(&private_display->lock);
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_buffer) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
+ if (private_module->use_hal_tdm) {
+ ret = hal_tdm_hwc_window_set_buffer((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, buffer);
+ } else {
+ if (!func_hwc_window->hwc_window_set_buffer) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
- ret = func_hwc_window->hwc_window_set_buffer(private_hwc_window->hwc_window_backend, buffer);
+ ret = func_hwc_window->hwc_window_set_buffer(private_hwc_window->hwc_window_backend, buffer);
+ }
if (ret == TDM_ERROR_NONE)
private_hwc_window->display_buffer = buffer;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_acquire_fence) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc_window->hwc_window_set_acquire_fence(private_hwc_window->hwc_window_backend, acquire_fence);
+ if (private_module->use_hal_tdm) {
+ ret = hal_tdm_hwc_window_set_acquire_fence((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, acquire_fence);
+ } else {
+ if (!func_hwc_window->hwc_window_set_acquire_fence) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc_window->hwc_window_set_acquire_fence(private_hwc_window->hwc_window_backend, acquire_fence);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_get_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ ret = hal_tdm_hwc_window_get_property((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, id, &hvalue);
+ memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value));
+ } else {
+ if (!func_hwc_window->hwc_window_get_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+
+ ret = func_hwc_window->hwc_window_get_property(private_hwc_window->hwc_window_backend, id, value);
}
-
- ret = func_hwc_window->hwc_window_get_property(private_hwc_window->hwc_window_backend, id, value);
-
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value));
+ ret = hal_tdm_hwc_window_set_property((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, id, hvalue);
+ } else {
+ if (!func_hwc_window->hwc_window_set_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+
+ ret = func_hwc_window->hwc_window_set_property(private_hwc_window->hwc_window_backend, id, value);
}
-
- ret = func_hwc_window->hwc_window_set_property(private_hwc_window->hwc_window_backend, id, value);
-
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_get_constraints) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc_window->hwc_window_get_constraints(private_hwc_window->hwc_window_backend, constraints);
+ if (private_module->use_hal_tdm) {
+ ret = hal_tdm_hwc_window_get_constraints((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, constraints);
+ } else {
+ if (!func_hwc_window->hwc_window_get_constraints) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc_window->hwc_window_get_constraints(private_hwc_window->hwc_window_backend, constraints);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_name) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc_window->hwc_window_set_name(private_hwc_window->hwc_window_backend, name);
+ if (private_module->use_hal_tdm) {
+ ret = hal_tdm_hwc_window_set_name((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, name);
+ } else {
+ if (!func_hwc_window->hwc_window_set_name) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc_window->hwc_window_set_name(private_hwc_window->hwc_window_backend, name);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_output->private_module;
func_hwc_window = &private_module->func_hwc_window;
- if (!func_hwc_window->hwc_window_set_cursor_image) {
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
-
- ret = func_hwc_window->hwc_window_set_cursor_image(private_hwc_window->hwc_window_backend, width, height, stride, ptr);
+ if (private_module->use_hal_tdm) {
+ ret = hal_tdm_hwc_window_set_cursor_image((hal_tdm_hwc_window *)private_hwc_window->hwc_window_backend, width, height, stride, ptr);
+ } else {
+ if (!func_hwc_window->hwc_window_set_cursor_image) {
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
+ ret = func_hwc_window->hwc_window_set_cursor_image(private_hwc_window->hwc_window_backend, width, height, stride, ptr);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
ret = _tdm_output_call_thread_cb_dpms(private_output, dpms);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+
+INTERN void
+tdm_output_cb_status_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_conn_status status, void *user_data)
+{
+ tdm_private_output *private_output = user_data;
+ tdm_error ret;
+
+ TDM_RETURN_IF_FAIL(private_output);
+
+ TDM_INFO("output(%d) %s", private_output->pipe, tdm_status_str((tdm_output_conn_status)status));
+
+ if ((private_output->caps.status == TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status != HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED) ||
+ (private_output->caps.status != TDM_OUTPUT_CONN_STATUS_DISCONNECTED && status == HAL_TDM_OUTPUT_CONN_STATUS_DISCONNECTED)) {
+ ret = tdm_display_update_output(private_output->private_module, output_backend);
+ TDM_RETURN_IF_FAIL(ret == TDM_ERROR_NONE);
+ } else {
+ private_output->caps.status = (tdm_output_conn_status)status;
+ }
+
+ ret = _tdm_output_call_thread_cb_status(private_output, (tdm_output_conn_status)status);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
+INTERN void
+tdm_output_cb_dpms_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_dpms dpms, void *user_data)
+{
+ tdm_private_output *private_output = user_data;
+ tdm_error ret;
+
+ TDM_INFO("output(%d) %s", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms));
+
+ private_output->current_dpms_value = (tdm_output_dpms)dpms;
+ private_output->waiting_dpms_change = 0;
+ TDM_INFO("output(%d) DPMS async '%s' done", private_output->pipe, tdm_dpms_str((tdm_output_dpms)dpms));
+
+ ret = _tdm_output_call_thread_cb_dpms(private_output, (tdm_output_dpms)dpms);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
/* LCOV_EXCL_STOP */
EXTERN tdm_error
_pthread_mutex_lock(&private_display->lock);
private_module = private_output->private_module;
- func_output = &private_module->func_output;
- if (!func_output->output_set_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ memcpy(&hvalue.ptr, &value.ptr, sizeof(hal_tdm_value));
+ ret = (tdm_error)hal_tdm_output_set_property(private_output->output_backend, id, hvalue);
+ } else {
+ func_output = &private_module->func_output;
+
+ if (!func_output->output_set_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
- ret = func_output->output_set_property(private_output->output_backend, id,
- value);
+ ret = func_output->output_set_property(private_output->output_backend, id, value);
+ }
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
private_module = private_output->private_module;
- func_output = &private_module->func_output;
- if (!func_output->output_get_property) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ hal_tdm_value hvalue;
+ ret = (tdm_error)hal_tdm_output_get_property(private_output->output_backend, id, &hvalue);
+ memcpy(value->ptr, &hvalue.ptr, sizeof(tdm_value));
+ } else {
+ func_output = &private_module->func_output;
- ret = func_output->output_get_property(private_output->output_backend, id,
- value);
+ if (!func_output->output_get_property) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
+ ret = func_output->output_get_property(private_output->output_backend, id, value);
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+static void
+_tdm_output_cb_vblank_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence,
+ unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+ tdm_private_output_vblank_handler *vblank_handler = user_data;
+ tdm_thread_cb_output_vblank output_vblank;
+ tdm_error ret;
+
+ memset(&output_vblank, 0, sizeof output_vblank);
+ output_vblank.base.type = TDM_THREAD_CB_OUTPUT_VBLANK;
+ output_vblank.base.length = sizeof output_vblank;
+ output_vblank.base.object_stamp = vblank_handler->private_output->stamp;
+ output_vblank.base.data = vblank_handler;
+ output_vblank.base.sync = 0;
+ output_vblank.sequence = sequence;
+ output_vblank.tv_sec = tv_sec;
+ output_vblank.tv_usec = tv_usec;
+
+ vblank_handler->sent_to_frontend = 1;
+
+ if (tdm_debug_module & TDM_DEBUG_COMMIT)
+ TDM_INFO("output(%d) wait_vblank: handler(%p)", vblank_handler->private_output->pipe, vblank_handler);
+
+ ret = tdm_thread_cb_call(vblank_handler->private_output, &output_vblank.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
/* LCOV_EXCL_START */
static void
_tdm_output_thread_cb_commit(tdm_private_display *private_display, void *object, tdm_thread_cb_base *cb_base, void *user_data)
ret = tdm_thread_cb_call(private_output, &output_commit.base, 1);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+
+static void
+_tdm_output_cb_commit_hal_tdm(hal_tdm_output *output_backend, unsigned int sequence,
+ unsigned int tv_sec, unsigned int tv_usec, void *user_data)
+{
+ tdm_private_output_commit_handler *output_commit_handler = user_data;
+ tdm_private_output *private_output;
+ tdm_thread_cb_output_commit output_commit;
+ tdm_error ret;
+
+ if (output_commit_handler)
+ private_output = output_commit_handler->private_output;
+ else
+ private_output = tdm_display_find_private_output(tdm_display_get(), (tdm_output *)output_backend);
+
+ memset(&output_commit, 0, sizeof output_commit);
+ output_commit.base.type = TDM_THREAD_CB_OUTPUT_COMMIT;
+ output_commit.base.length = sizeof output_commit;
+ output_commit.base.object_stamp = private_output->stamp;
+ output_commit.base.data = output_commit_handler;
+ output_commit.base.sync = 0;
+ output_commit.sequence = sequence;
+ output_commit.tv_sec = tv_sec;
+ output_commit.tv_usec = tv_usec;
+
+ ret = tdm_thread_cb_call(private_output, &output_commit.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
/* LCOV_EXCL_STOP */
/* LCOV_EXCL_START */
if (interval <= 0)
interval = 1;
- if (!func_output->output_wait_vblank) {
- /* LCOV_EXCL_START */
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ if (!private_output->regist_vblank_cb) {
+ private_output->regist_vblank_cb = 1;
+ ret = (tdm_error)hal_tdm_output_set_vblank_handler(private_output->output_backend, _tdm_output_cb_vblank_hal_tdm);
+ }
+ } else {
+ if (!func_output->output_wait_vblank) {
+ /* LCOV_EXCL_START */
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
- if (!private_output->regist_vblank_cb) {
- private_output->regist_vblank_cb = 1;
- ret = func_output->output_set_vblank_handler(private_output->output_backend,
- _tdm_output_cb_vblank);
+ if (!private_output->regist_vblank_cb) {
+ private_output->regist_vblank_cb = 1;
+ ret = func_output->output_set_vblank_handler(private_output->output_backend,
+ _tdm_output_cb_vblank);
+ }
}
-
vblank_handler = calloc(1, sizeof(tdm_private_output_vblank_handler));
if (!vblank_handler) {
/* LCOV_EXCL_START */
TDM_ERR("tdm_thread_cb_add failed");
goto wait_failed;
}
-
- ret = func_output->output_wait_vblank(private_output->output_backend, interval,
- sync, vblank_handler);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_wait_vblank(private_output->output_backend, interval,
+ sync, vblank_handler);
+ else
+ ret = func_output->output_wait_vblank(private_output->output_backend, interval,
+ sync, vblank_handler);
TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, wait_failed);
_tdm_output_vblank_timeout_update(private_output, 1000);
private_display = private_module->private_display;
func_output = &private_module->func_output;
- if (!func_output->output_commit) {
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (!private_module->use_hal_tdm) {
+ if (!func_output->output_commit) {
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
}
ret = tdm_output_get_dpms_internal(output, &dpms_value);
if (!TDM_OUTPUT_DPMS_VSYNC_IS_OFF(dpms_value)) {
if (!private_output->regist_commit_cb) {
private_output->regist_commit_cb = 1;
- ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit_hal_tdm);
+ else
+ ret = func_output->output_set_commit_handler(private_output->output_backend, _tdm_output_cb_commit);
TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
}
voutput_commit_handler->user_data = private_layer->commiting_buffer;
}
}
-
- ret = func_output->output_commit(private_output->output_backend, sync,
- output_commit_handler);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_commit(private_output->output_backend, sync, output_commit_handler);
+ else
+ ret = func_output->output_commit(private_output->output_backend, sync, output_commit_handler);
TDM_GOTO_IF_FAIL(ret == TDM_ERROR_NONE, commit_failed);
if (tdm_debug_module & TDM_DEBUG_COMMIT)
private_module = private_output->private_module;
func_output = &private_module->func_output;
- if (!func_output->output_set_mode) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_WRN("not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_set_mode(private_output->output_backend, (const hal_tdm_output_mode *)mode);
+ } else {
+ if (!func_output->output_set_mode) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_WRN("not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
- ret = func_output->output_set_mode(private_output->output_backend, mode);
+ ret = func_output->output_set_mode(private_output->output_backend, mode);
+ }
if (ret == TDM_ERROR_NONE) {
private_output->current_mode = mode;
private_output->need_set_target_info = 1;
TDM_INFO("output(%d) DPMS '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
- if (func_output->output_set_dpms)
- ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
- else {
- /* LCOV_EXCL_START */
- ret = TDM_ERROR_NONE;
- TDM_WRN("DPMS not implemented!!");
- goto done;
- /* LCOV_EXCL_STOP */
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_set_dpms(private_output->output_backend, (hal_tdm_output_dpms)dpms_value);
+ } else {
+ if (func_output->output_set_dpms)
+ ret = func_output->output_set_dpms(private_output->output_backend, dpms_value);
+ else {
+ /* LCOV_EXCL_START */
+ ret = TDM_ERROR_NONE;
+ TDM_WRN("DPMS not implemented!!");
+ /* LCOV_EXCL_STOP */
+ }
}
-done:
if (ret == TDM_ERROR_NONE) {
if (private_output->current_dpms_value != dpms_value) {
private_output->current_dpms_value = dpms_value;
private_module = private_output->private_module;
func_output = &private_module->func_output;
- if (!func_output->output_set_dpms_handler) {
- TDM_WRN("not implemented DPMS: output_set_dpms_handler");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
+ if (!private_module->use_hal_tdm) {
+ if (!func_output->output_set_dpms_handler) {
+ TDM_WRN("not implemented DPMS: output_set_dpms_handler");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
- if (!func_output->output_set_dpms_async) {
- TDM_WRN("not implemented DPMS: output_set_dpms_async");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (!func_output->output_set_dpms_async) {
+ TDM_WRN("not implemented DPMS: output_set_dpms_async");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
}
if (!private_output->regist_dpms_cb) {
private_output->regist_dpms_cb = 1;
- ret = func_output->output_set_dpms_handler(private_output->output_backend,
- tdm_output_cb_dpms, private_output);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_set_dpms_handler(private_output->output_backend,
+ tdm_output_cb_dpms_hal_tdm, private_output);
+ else
+ ret = func_output->output_set_dpms_handler(private_output->output_backend,
+ tdm_output_cb_dpms, private_output);
if (ret != TDM_ERROR_NONE) {
_pthread_mutex_unlock(&private_display->lock);
TDM_ERR("Can't set the DPMS handler!!");
TDM_INFO("output(%d) DPMS async '%s'", private_output->pipe, tdm_dpms_str(dpms_value));
- ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_output_set_dpms_async(private_output->output_backend, (hal_tdm_output_dpms)dpms_value, &sync);
+ else
+ ret = func_output->output_set_dpms_async(private_output->output_backend, dpms_value, &sync);
if (ret == TDM_ERROR_NONE) {
if (sync) {
private_module = private_output->private_module;
func_output = &private_module->func_output;
- if (!func_output->output_get_dpms) {
- /* LCOV_EXCL_START */
- *dpms_value = private_output->current_dpms_value;
- TDM_WRN("DPMS get not implemented!!");
- return TDM_ERROR_NONE;
- /* LCOV_EXCL_STOP */
- }
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_get_dpms(private_output->output_backend, (hal_tdm_output_dpms *)dpms_value);
+ } else {
+ if (!func_output->output_get_dpms) {
+ /* LCOV_EXCL_START */
+ *dpms_value = private_output->current_dpms_value;
+ TDM_WRN("DPMS get not implemented!!");
+ return TDM_ERROR_NONE;
+ /* LCOV_EXCL_STOP */
+ }
- ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
+ ret = func_output->output_get_dpms(private_output->output_backend, dpms_value);
+ }
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
TDM_ERR("output get DPMS failed");
return TDM_ERROR_BAD_REQUEST;
}
- if (!func_output->output_set_mirror) {
- TDM_WRN("not implemented!!");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_set_mirror((hal_tdm_output *)private_output->output_backend,
+ (hal_tdm_output *)private_src_output->output_backend, (hal_tdm_transform)transform);
}
+ else {
+ if (!func_output->output_set_mirror) {
+ TDM_WRN("not implemented!!");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
- ret = func_output->output_set_mirror(private_output->output_backend,
- private_src_output->output_backend,
- transform);
+ ret = func_output->output_set_mirror(private_output->output_backend,
+ private_src_output->output_backend,
+ transform);
+ }
if (ret != TDM_ERROR_NONE) {
TDM_ERR("output(%p) fails to set MIRROR.", private_output);
_pthread_mutex_unlock(&private_display->lock);
return TDM_ERROR_BAD_REQUEST;
}
- if (!func_output->output_unset_mirror) {
- TDM_WRN("not implemented!!");
- _pthread_mutex_unlock(&private_display->lock);
- return TDM_ERROR_NOT_IMPLEMENTED;
- }
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_output_unset_mirror((hal_tdm_output *)private_output->output_backend);
+ } else {
+ if (!func_output->output_unset_mirror) {
+ TDM_WRN("not implemented!!");
+ _pthread_mutex_unlock(&private_display->lock);
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ }
- ret = func_output->output_unset_mirror(private_output->output_backend);
+ ret = func_output->output_unset_mirror(private_output->output_backend);
+ }
if (ret != TDM_ERROR_NONE) {
TDM_ERR("output(%p) fails to unset MIRROR.", private_output);
_pthread_mutex_unlock(&private_display->lock);
_pthread_mutex_lock(&private_display->lock);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_set_available_mode)
- ret = func_voutput->voutput_set_available_mode(private_voutput->voutput_backend, modes, count);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_set_available_mode((hal_tdm_voutput *)private_voutput->voutput_backend,
+ (const hal_tdm_output_mode *)modes, count);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_set_available_mode)
+ ret = func_voutput->voutput_set_available_mode(private_voutput->voutput_backend, modes, count);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
_pthread_mutex_lock(&private_display->lock);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_set_physical_size)
- ret = func_voutput->voutput_set_physical_size(private_voutput->voutput_backend, mmwidth, mmheight);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_set_physical_size((hal_tdm_voutput *)private_voutput->voutput_backend, mmwidth, mmheight);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_set_physical_size)
+ ret = func_voutput->voutput_set_physical_size(private_voutput->voutput_backend, mmwidth, mmheight);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
_pthread_mutex_lock(&private_display->lock);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_connect)
- ret = func_voutput->voutput_connect(private_voutput->voutput_backend);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_connect((hal_tdm_voutput *)private_voutput->voutput_backend);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_connect)
+ ret = func_voutput->voutput_connect(private_voutput->voutput_backend);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
_pthread_mutex_lock(&private_display->lock);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_disconnect)
- ret = func_voutput->voutput_disconnect(private_voutput->voutput_backend);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_disconnect((hal_tdm_voutput *)private_voutput->voutput_backend);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_disconnect)
+ ret = func_voutput->voutput_disconnect(private_voutput->voutput_backend);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
private_module = private_voutput->private_module;
TDM_RETURN_VAL_IF_FAIL(private_module == private_display->virtual_module, TDM_ERROR_BAD_MODULE);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_set_commit_func)
- ret = func_voutput->voutput_set_commit_func(private_voutput->voutput_backend, func);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_set_commit_func((hal_tdm_voutput *)private_voutput->voutput_backend,
+ (hal_tdm_voutput_commit_handler)func);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_set_commit_func)
+ ret = func_voutput->voutput_set_commit_func(private_voutput->voutput_backend, func);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
return ret;
}
_pthread_mutex_lock(&private_display->lock);
- func_voutput = &private_module->func_voutput;
- if (func_voutput->voutput_commit_done)
- ret = func_voutput->voutput_commit_done(private_voutput->voutput_backend);
- else
- ret = TDM_ERROR_NOT_IMPLEMENTED;
-
+ if (private_module->use_hal_tdm) {
+ ret = (tdm_error)hal_tdm_voutput_commit_done((hal_tdm_voutput *)private_voutput->voutput_backend);
+ } else {
+ func_voutput = &private_module->func_voutput;
+ if (func_voutput->voutput_commit_done)
+ ret = func_voutput->voutput_commit_done(private_voutput->voutput_backend);
+ else
+ ret = TDM_ERROR_NOT_IMPLEMENTED;
+ }
_pthread_mutex_unlock(&private_display->lock);
return ret;
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
}
+static void
+_tdm_pp_cb_done_hal_tdm(hal_tdm_pp *pp_module, tbm_surface_h src, tbm_surface_h dst, void *user_data)
+{
+ tdm_thread_cb_pp_done pp_done;
+ tdm_private_pp *private_pp = user_data;
+ tdm_error ret;
+
+ TDM_RETURN_IF_FAIL(TDM_MUTEX_IS_LOCKED());
+
+ memset(&pp_done, 0, sizeof pp_done);
+ pp_done.base.type = TDM_THREAD_CB_PP_DONE;
+ pp_done.base.length = sizeof pp_done;
+ pp_done.base.object_stamp = private_pp->stamp;
+ pp_done.base.data = NULL;
+ pp_done.base.sync = 0;
+ pp_done.src = src;
+ pp_done.dst = dst;
+
+ ret = tdm_thread_cb_call(private_pp, &pp_done.base, 1);
+ TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
+}
+
static void *
_tdm_pp_find_object(tdm_private_display *private_display, double stamp)
{
TDM_RETURN_VAL_IF_FAIL(TDM_MUTEX_IS_LOCKED(), NULL);
TDM_RETURN_VAL_IF_FAIL(private_module != NULL, NULL);
- private_display = private_module->private_display;
- func_display = &private_module->func_display;
- func_pp = &private_module->func_pp;
-
if (!(private_module->capabilities & TDM_DISPLAY_CAPABILITY_PP)) {
/* LCOV_EXCL_START */
- TDM_ERR("backedn(%s) no pp capability", private_module->module_data->name);
+ TDM_ERR("backend no pp capability");
if (error)
*error = TDM_ERROR_NO_CAPABILITY;
return NULL;
/* LCOV_EXCL_STOP */
}
- pp_module = func_display->display_create_pp(private_module->bdata, &ret);
+ private_display = private_module->private_display;
+ func_display = &private_module->func_display;
+ func_pp = &private_module->func_pp;
+
+ if (private_module->use_hal_tdm) {
+ pp_module = (tdm_pp *)hal_tdm_display_create_pp(private_module->htdm_backend, (hal_tdm_error *)&ret);
+ } else {
+ pp_module = func_display->display_create_pp(private_module->bdata, &ret);
+ }
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
+ TDM_ERR("create pp fail");
if (error)
*error = ret;
return NULL;
private_pp = calloc(1, sizeof(tdm_private_pp));
if (!private_pp) {
/* LCOV_EXCL_START */
- TDM_ERR("failed: alloc memory");
- func_pp->pp_destroy(pp_module);
+ TDM_ERR("memory alloc fail");
if (error)
*error = TDM_ERROR_OUT_OF_MEMORY;
- return NULL;
+ goto alloc_fail;
/* LCOV_EXCL_STOP */
}
ret = tdm_thread_cb_add(private_pp, TDM_THREAD_CB_PP_DONE, NULL, _tdm_pp_thread_cb_done, NULL);
if (ret != TDM_ERROR_NONE) {
+ /* LCOV_EXCL_START */
TDM_ERR("pp tdm_thread_cb_add failed");
- func_pp->pp_destroy(pp_module);
- free(private_pp);
if (error)
*error = ret;
- return NULL;
+ goto thread_fail;
+ /* LCOV_EXCL_STOP */
}
- ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_pp_set_done_handler((hal_tdm_pp *)pp_module, _tdm_pp_cb_done_hal_tdm, private_pp);
+ else
+ ret = func_pp->pp_set_done_handler(pp_module, _tdm_pp_cb_done, private_pp);
if (ret != TDM_ERROR_NONE) {
/* LCOV_EXCL_START */
TDM_ERR("spp(%p) et pp_done_handler failed", private_pp);
- func_pp->pp_destroy(pp_module);
- free(private_pp);
if (error)
*error = ret;
- return NULL;
+ goto thread_fail;
/* LCOV_EXCL_STOP */
}
*error = TDM_ERROR_NONE;
return private_pp;
+
+thread_fail:
+ free(private_pp);
+alloc_fail:
+ if (private_module->use_hal_tdm)
+ hal_tdm_pp_destroy((hal_tdm_pp *)pp_module);
+ else
+ func_pp->pp_destroy(pp_module);
+
+ return NULL;
}
INTERN void
LIST_DEL(&private_pp->link);
- func_pp->pp_destroy(private_pp->pp_module);
+ if (private_module->use_hal_tdm)
+ hal_tdm_pp_destroy((hal_tdm_pp *)private_pp->pp_module);
+ else
+ func_pp->pp_destroy(private_pp->pp_module);
if (!LIST_IS_EMPTY(&private_pp->pending_buffer_list)) {
TDM_WRN("pp(%p) not finished:", private_pp);
_pthread_mutex_lock(&private_display->lock);
- if (!func_pp->pp_set_info) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_pp->pp_set_info) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
TDM_INFO("pp(%p) info: src(%ux%u %u,%u %ux%u %c%c%c%c) dst(%ux%u %u,%u %ux%u %c%c%c%c) trans(%d) sync(%d) flags(%x)",
FOURCC_STR(info->dst_config.format),
info->transform, info->sync, info->flags);
- ret = func_pp->pp_set_info(private_pp->pp_module, info);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_pp_set_info((hal_tdm_pp *)private_pp->pp_module, (hal_tdm_info_pp *)info);
+ else
+ ret = func_pp->pp_set_info(private_pp->pp_module, info);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
private_pp->info = *info;
_pthread_mutex_lock(&private_display->lock);
- if (!func_pp->pp_attach) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_pp->pp_attach) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
if (tdm_module_check_abi(private_module, 1, 2) &&
/* LCOV_EXCL_STOP */
}
- ret = func_pp->pp_attach(private_pp->pp_module, src, dst);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_pp_attach((hal_tdm_pp *)private_pp->pp_module, src, dst);
+ else
+ ret = func_pp->pp_attach(private_pp->pp_module, src, dst);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
if (ret != TDM_ERROR_NONE) {
_pthread_mutex_lock(&private_display->lock);
- if (!func_pp->pp_commit) {
- /* LCOV_EXCL_START */
- _pthread_mutex_unlock(&private_display->lock);
- TDM_DBG("failed: not implemented!!");
- return TDM_ERROR_NOT_IMPLEMENTED;
- /* LCOV_EXCL_STOP */
+ if (!private_module->use_hal_tdm) {
+ if (!func_pp->pp_commit) {
+ /* LCOV_EXCL_START */
+ _pthread_mutex_unlock(&private_display->lock);
+ TDM_DBG("failed: not implemented!!");
+ return TDM_ERROR_NOT_IMPLEMENTED;
+ /* LCOV_EXCL_STOP */
+ }
}
LIST_INITHEAD(&commit_buffer_list);
LIST_ADDTAIL(&b->commit_link, &commit_buffer_list);
}
- ret = func_pp->pp_commit(private_pp->pp_module);
+ if (private_module->use_hal_tdm)
+ ret = (tdm_error)hal_tdm_pp_commit((hal_tdm_pp *)private_pp->pp_module);
+ else
+ ret = func_pp->pp_commit(private_pp->pp_module);
TDM_WARNING_IF_FAIL(ret == TDM_ERROR_NONE);
LIST_FOR_EACH_ENTRY_SAFE(b, bb, &commit_buffer_list, commit_link) {
void
tdm_output_cb_dpms(tdm_output *output_backend, tdm_output_dpms dpms,
void *user_data);
+void
+tdm_output_cb_status_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_conn_status status, void *user_data);
+void
+tdm_output_cb_dpms_hal_tdm(hal_tdm_output *output_backend, hal_tdm_output_dpms dpms, void *user_data);
void
tdm_output_vblank_print_wait_information(tdm_private_output *private_output, void *user_data);
#include <pthread.h>
#include <tbm_bufmgr.h>
#include <tbm_surface_queue.h>
+#include <hal/hal-tdm.h>
#include "tdm_types.h"
#include "tdm_list.h"
/* backend virtual output target buffer type default set for hwc */
int use_default_type_bo;
+
+ /* hal tdm */
+ int use_hal_tdm;
+ hal_tdm_backend *htdm_backend;
+ hal_tdm_display *htdm_dpy;
+ tdm_event_loop_source *htdm_event_source;
};
struct _tdm_private_display {
projects / platform / core / uifw / libtdm.git / commitdiff