X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_module.c;h=974c67bcffdab244cef067b8063d98c328f68668;hb=86bbaa419184bd0a189896b347a4fcbd9c894c54;hp=0aef6a797e9bc99c29b52792c1eca27ac9346ebc;hpb=5e8efe4801471774ec573bf7a60907d4706e7a65;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_module.c b/src/tbm_module.c index 0aef6a7..974c67b 100644 --- a/src/tbm_module.c +++ b/src/tbm_module.c @@ -35,16 +35,1216 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #include "tbm_bufmgr_backend.h" #include "tbm_drm_helper.h" +#define PREFIX_LIB "libtbm_" +#define SUFFIX_LIB ".so" +#define DEFAULT_LIB PREFIX_LIB"default"SUFFIX_LIB + +/* values to indicate unspecified fields in XF86ModReqInfo. */ +#define MAJOR_UNSPEC 0xFF +#define MINOR_UNSPEC 0xFF +#define PATCH_UNSPEC 0xFFFF +#define ABI_VERS_UNSPEC 0xFFFFFFFF + +#define MODULE_VERSION_NUMERIC(maj, min, patch) \ + ((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF)) +#define GET_MODULE_MAJOR_VERSION(vers) (((vers) >> 24) & 0xFF) +#define GET_MODULE_MINOR_VERSION(vers) (((vers) >> 16) & 0xFF) +#define GET_MODULE_PATCHLEVEL(vers) ((vers) & 0xFFFF) + +/* LCOV_EXCL_START */ +static int +_tbm_backend_load_hal_tbm(tbm_module *module) +{ + hal_tbm_backend *hal_backend = NULL; + hal_tbm_bufmgr *hal_bufmgr; + hal_tbm_error ret = HAL_TBM_ERROR_NONE; + hal_tbm_fd auth_drm_fd = -1; + + hal_backend = hal_tbm_get_backend(&ret); + if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("get backend fail"); + return 0; + } + + hal_bufmgr = hal_tbm_backend_get_bufmgr(hal_backend, &ret); + if (hal_bufmgr == NULL || ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("get hal_bufmgr fail"); + goto get_backend_fail; + } + + if (hal_tbm_backend_has_drm_device(hal_backend, &ret)) { + auth_drm_fd = hal_tbm_backend_get_master_drm_fd(hal_backend, &ret); + if (auth_drm_fd < 0) { + TBM_INFO("tbm_backend has no master drm_fd."); + + auth_drm_fd = tbm_drm_helper_get_master_fd(); + if (auth_drm_fd < 0) { + TBM_INFO("libtbm requests an authenticated drm_fd to a process(display server)."); + if (!tbm_drm_helper_get_auth_info(&auth_drm_fd, NULL, NULL)) { + TBM_ERR("get auth drm_fd fail"); + goto get_backend_fail; + } + } else { + TBM_INFO("libtbm gets a master drm_fd from libtdm via tbm_drm_helper."); + } + + TBM_INFO("libtbm sends a master drm_fd as an authentiated drm_fd to tbm_backend."); + ret = hal_tbm_backend_set_authenticated_drm_fd(hal_backend, auth_drm_fd); + if (ret != HAL_TBM_ERROR_NONE) { + TBM_ERR("hal_tbm_backend_set_authenticated_drm_fd failed."); + goto get_backend_fail; + } + } else { + TBM_INFO("tbm_backend has a master drm_fd."); + + tbm_drm_helper_set_tbm_master_fd(auth_drm_fd); + } + tbm_drm_helper_set_fd(auth_drm_fd); + } + + module->hal_backend = hal_backend; + module->hal_bufmgr = hal_bufmgr; + + module->use_hal_tbm = 1; + + TBM_INFO("use HAL-TBM_API"); + + return 1; + +get_backend_fail: + if (auth_drm_fd >= 0) + close(auth_drm_fd); + hal_tbm_put_backend(hal_backend); + return 0; +} + +static int +_check_version(TBMModuleVersionInfo *data) +{ + int backend_module_major, backend_module_minor; + int tbm_backend_major, tbm_backend_minor; + + backend_module_major = GET_ABI_MAJOR(data->abiversion); + backend_module_minor = GET_ABI_MINOR(data->abiversion); + + TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n", + data->modname ? data->modname : "UNKNOWN!", + data->vendor ? data->vendor : "UNKNOWN!", backend_module_major, backend_module_minor); + + tbm_backend_major = GET_ABI_MAJOR(TBM_ABI_VERSION); + tbm_backend_minor = GET_ABI_MINOR(TBM_ABI_VERSION); + + TBM_DBG("TBM ABI version %d.%d\n", + tbm_backend_major, tbm_backend_minor); + + if (backend_module_major != tbm_backend_major) { + TBM_ERR("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n", + backend_module_major, tbm_backend_major); + return 0; + } else if (backend_module_minor > tbm_backend_minor) { + TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", + backend_module_minor, tbm_backend_minor); + return 0; + } + + return 1; +} + +static int +_tbm_backend_check_bufmgr_func(tbm_backend_bufmgr_func *bufmgr_func) +{ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, 0); /* mandatory symbol */ + if (!bufmgr_func->bufmgr_alloc_bo_with_format) + TBM_DBG("No bufmgr_func->bufmgr_alloc_bo_with_format."); + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_import_fd, 0); /* mandatory symbol */ + if (!bufmgr_func->bufmgr_import_key) + TBM_DBG("No bufmgr_func->bo_export_key."); + + return 1; +} + +static int +_tbm_backend_check_bufmgr_bo(tbm_backend_bo_func *bo_func) +{ + TBM_RETURN_VAL_IF_FAIL(bo_func, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_free, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_size, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_memory_types, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_handle, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_map, 0); /* mandatory symbol */ + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, 0); /* mandatory symbol */ + if (!bo_func->bo_lock) + TBM_DBG("No bo_func->bo_lock."); + if (!bo_func->bo_unlock) + TBM_DBG("No bo_func->bo_unlock."); + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_export_fd, 0); /* mandatory symbol */ + if (!bo_func->bo_export_key) + TBM_INFO("No bo_func->bo_export_key."); + + return 1; +} + +static int +_tbm_backend_load_module(tbm_module *module, const char *file) +{ + char path[PATH_MAX] = {0, }; + void *module_data = NULL; + tbm_backend_module *backend_module_data = NULL; + tbm_backend_bufmgr_data *bufmgr_data = NULL; + int backend_module_major, backend_module_minor; + int tbm_backend_major, tbm_backend_minor; + tbm_error_e error; + + snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file); + + module_data = dlopen(path, RTLD_LAZY); + if (!module_data) { + TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file); + return 0; + } + + backend_module_data = dlsym(module_data, "tbm_backend_module_data"); + if (!backend_module_data) { + TBM_ERR("Error: module does not have data object.\n"); + goto err; + } + + tbm_backend_major = GET_ABI_MAJOR(TBM_BACKEND_ABI_LATEST_VERSION); + tbm_backend_minor = GET_ABI_MINOR(TBM_BACKEND_ABI_LATEST_VERSION); + TBM_INFO("TBM Backend ABI version %d.%d\n", tbm_backend_major, tbm_backend_minor); + + backend_module_major = GET_ABI_MAJOR(backend_module_data->abi_version); + backend_module_minor = GET_ABI_MINOR(backend_module_data->abi_version); + + TBM_INFO("TBM module %s: vendor=\"%s\" Backend ABI version=%d.%d\n", + backend_module_data->name ? backend_module_data->name : "UNKNOWN!", + backend_module_data->vendor ? backend_module_data->vendor : "UNKNOWN!", + backend_module_major, backend_module_minor); + + if (backend_module_major > tbm_backend_major) { + TBM_ERR("TBM module ABI major ver(%d) is newer than the TBM's ver(%d)\n", + backend_module_major, tbm_backend_major); + goto err; + } else if (backend_module_minor > tbm_backend_minor) { + TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n", + backend_module_minor, tbm_backend_minor); + goto err; + } + + if (!backend_module_data->init) { + TBM_ERR("Error: module does not supply init symbol.\n"); + goto err; + } + + if (!backend_module_data->deinit) { + TBM_ERR("Error: module does not supply deinit symbol.\n"); + goto err; + } + + bufmgr_data = backend_module_data->init((tbm_bufmgr)module, &error); + if (!bufmgr_data) { + TBM_ERR("Fail to init module(%s)\n", file); + goto err; + } + + /* check the mandatory symbols of the backend module */ + if (!_tbm_backend_check_bufmgr_func(module->bufmgr_func)) { + TBM_ERR("Fail to check the bufmgr_func symboles."); + goto err; + } + + if (!_tbm_backend_check_bufmgr_bo(module->bo_func)) { + TBM_ERR("Fail to check the bufmgr_bo symboles."); + goto err; + } + + module->module_data = module_data; + module->backend_module_data = backend_module_data; + module->bufmgr_data = bufmgr_data; + + TBM_INFO("Success to load module(%s)\n", file); + + return 1; + +err: + if (bufmgr_data) + module->backend_module_data->deinit(bufmgr_data); + if (module_data) + dlclose(module_data); + + return 0; +} + +static int +_tbm_backend_load_bufmgr_module(tbm_module *module, int fd, const char *file) +{ + char path[PATH_MAX] = {0, }; + TBMModuleVersionInfo *vers; + TBMModuleData *initdata; + ModuleInitProc init; + void *module_data; + + snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file); + + module_data = dlopen(path, RTLD_LAZY); + if (!module_data) { + TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file); + return 0; + } + + initdata = dlsym(module_data, "tbmModuleData"); + if (!initdata) { + TBM_ERR("Error: module does not have data object.\n"); + goto err; + } + + vers = initdata->vers; + if (!vers) { + TBM_ERR("Error: module does not supply version information.\n"); + goto err; + } + + init = initdata->init; + if (!init) { + TBM_ERR("Error: module does not supply init symbol.\n"); + goto err; + } + + if (!_check_version(vers)) { + TBM_ERR("Fail to check version.\n"); + goto err; + } + + if (!init((tbm_bufmgr)module, fd)) { + TBM_ERR("Fail to init module(%s)\n", file); + goto err; + } + + if (!module->backend || !module->backend->priv) { + TBM_ERR("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file); + goto err; + } + + module->module_data = module_data; + + TBM_DBG("Success to load module(%s)\n", file); + + return 1; + +err: + dlclose(module_data); + return 0; +} +/* LCOV_EXCL_STOP */ + tbm_module * tbm_module_load(int fd) { - // TODO: - return NULL; + tbm_module *module; + struct dirent **namelist; + int ret = 0, n; + + module = calloc(1, sizeof(struct _tbm_module)); + if (!module) { + TBM_ERR("fail to allocate the memory"); + return NULL; + } + + /* try to load the hal-tbm backend module */ + ret = _tbm_backend_load_hal_tbm(module); + if (ret) { + module->type = TBM_MODULE_TYPE_HAL_TBM; + goto done; + } + +/* LCOV_EXCL_START */ + /* try to load the new backend module */ + ret = _tbm_backend_load_module(module, DEFAULT_LIB); + if (ret) { + module->type = TBM_MODULE_TYPE_TBM_BACKEND; + goto done; + } + + /* try to load the old(deprecated) backend mdoule */ + ret = _tbm_backend_load_bufmgr_module(module, fd, DEFAULT_LIB); + if (ret) { + module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND; + return module; + } + + /* load backend_module from configured path */ + n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort); + if (n < 0) { + TBM_ERR("no files : %s\n", BUFMGR_MODULE_DIR); + tbm_module_unload(module); + return NULL; + } + + while (n--) { + if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) { + const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB); + + if (p && !strcmp(p, SUFFIX_LIB)) { + ret = _tbm_backend_load_module(module, namelist[n]->d_name); + if (ret) + module->type = TBM_MODULE_TYPE_TBM_BACKEND; + else { + ret = _tbm_backend_load_bufmgr_module(module, fd, namelist[n]->d_name); + module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND; + } + } + } + + free(namelist[n]); + } + + free(namelist); + + if (!ret) { + free(module); + module = NULL; + } +/* LCOV_EXCL_STOP */ + +done: + return module; } void tbm_module_unload(tbm_module *module) { - // TODO: + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + if (module->auth_wl_socket_created) { + tbm_drm_helper_wl_auth_server_deinit(); + close(module->auth_fd); + } + tbm_drm_helper_unset_tbm_master_fd(); + tbm_drm_helper_unset_fd(); + + hal_tbm_put_backend(module->hal_backend); + module->hal_backend = NULL; + module->hal_bufmgr = NULL; + module->use_hal_tbm = 0; + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + module->backend_module_data->deinit(module->bufmgr_data); + module->bo_func = NULL; + module->bufmgr_func = NULL; + module->bufmgr_data = NULL; + module->backend_module_data = NULL; + + dlclose(module->module_data); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + module->backend->bufmgr_deinit(module->backend->priv); + module->backend->priv = NULL; + tbm_backend_free(module->backend); + module->backend = NULL; + + dlclose(module->module_data); + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + break; +/* LCOV_EXCL_STOP */ + } + + free(module); +} + +int +tbm_module_bufmgr_get_capabilities(tbm_module *module, tbm_error_e *error) +{ + int capabilities = 0; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, TBM_BUFMGR_CAPABILITY_NONE, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + capabilities = hal_tbm_bufmgr_get_capabilities(module->hal_bufmgr, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + capabilities = module->bufmgr_func->bufmgr_get_capabilities(module->bufmgr_data, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + TBM_ERR("Do not support at tbm_bufmgr_backend."); + + *error = TBM_ERROR_NOT_SUPPORTED; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return capabilities; } +tbm_error_e +tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display) +{ + tbm_error_e error = TBM_ERROR_NONE; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + int ret = 0; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + if (hal_tbm_backend_has_drm_device(module->hal_backend, &ret)) { + int fd = tbm_drm_helper_get_fd(); // this must be the auth drm_fd.(master drm_fd); + if (fd < 0) { + TBM_ERR("error: module(%p) native_display(%p)\n", module, native_display); + return TBM_ERROR_INVALID_OPERATION; + } + + // make the wayland server socket for sending the authenticated drm_fd to wayland clients. + if (!tbm_drm_helper_wl_auth_server_init(native_display, fd, NULL, 0)) { + TBM_ERR("error: tbm_drm_helper_wl_auth_server_init failed\n", module, native_display); + close(fd); + return TBM_ERROR_INVALID_OPERATION; + } + TBM_INFO("tbm creates a wayland socket for authentication of drm_fd."); + + module->auth_wl_socket_created = 1; + module->auth_fd = fd; + } else { + TBM_INFO("tbm_module has no drm device."); + error = TBM_ERROR_NONE; + } + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED); + + error = bufmgr_func->bufmgr_bind_native_display(module->bufmgr_data, (tbm_native_display *)native_display); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(backend->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED); + + ret = backend->bufmgr_bind_native_display((tbm_bufmgr)module, native_display); + if (!ret) + error = TBM_ERROR_INVALID_OPERATION; + + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_error_e +tbm_module_bufmgr_get_supported_formats(tbm_module *module, uint32_t **formats, uint32_t *num) +{ + tbm_error_e error = TBM_ERROR_NONE; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + int ret = 0; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + error = (tbm_error_e)hal_tbm_bufmgr_get_supported_formats(module->hal_bufmgr, formats, num); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, TBM_ERROR_NOT_SUPPORTED); + + error = bufmgr_func->bufmgr_get_supported_formats(module->bufmgr_data, formats, num); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(backend->surface_supported_format, TBM_ERROR_NOT_SUPPORTED); + + ret = backend->surface_supported_format(formats, num); + if (!ret) + error = TBM_ERROR_INVALID_OPERATION; + + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_error_e +tbm_module_bufmgr_get_plane_data(tbm_module *module, int format, int plane_idx, uint32_t w, uint32_t h, + uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx) +{ + tbm_error_e error = TBM_ERROR_NONE; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + int ret = 0; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + error = (tbm_error_e)hal_tbm_bufmgr_get_plane_data(module->hal_bufmgr, format, plane_idx, w, h, size, offset, pitch, bo_idx); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, TBM_ERROR_NOT_SUPPORTED); + + error = bufmgr_func->bufmgr_get_plane_data(module->bufmgr_data, format, plane_idx, w, h, size, offset, pitch, bo_idx); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(backend->surface_get_plane_data, TBM_ERROR_NOT_SUPPORTED); + + ret = backend->surface_get_plane_data(w, h, format, plane_idx, size, offset, pitch, bo_idx); + if (!ret) + error = TBM_ERROR_INVALID_OPERATION; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_backend_bo_data * +tbm_module_bufmgr_bo_alloc(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error) +{ + tbm_backend_bo_data *bo_data = NULL; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = module->bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = (void *)module->backend->bo_alloc(bo, size, flags); + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_data; +} + +tbm_backend_bo_data * +tbm_module_bufmgr_bo_alloc_with_format(tbm_module *module, int format, int bo_idx, int width, + int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error) +{ + tbm_backend_bo_data *bo_data = NULL; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr, + format, bo_idx, width, height, bpp, + (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); + if (!bufmgr_func->bufmgr_alloc_bo_with_format) { + *error = TBM_ERROR_NOT_SUPPORTED; + return NULL; + } + + bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + TBM_ERR("error: not supported tbm_bufmgr_internal_alloc_bo_with_format."); + + *error = TBM_ERROR_NOT_SUPPORTED; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_data; +} + + +tbm_backend_bo_data * +tbm_module_bufmgr_bo_import_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error) +{ + tbm_backend_bo_data *bo_data = NULL; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = (void *)backend->bo_import_fd(bo, fd); + if (!bo_data) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_data; +} + +tbm_backend_bo_data * +tbm_module_bufmgr_bo_import_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error) +{ + tbm_backend_bo_data *bo_data = NULL; + tbm_backend_bufmgr_func *bufmgr_func = NULL; + tbm_bufmgr_backend backend = NULL; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bufmgr_func = module->bufmgr_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_data = (void *)backend->bo_import(bo, key); + if (!bo_data) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_data; +} + +void +tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int get_from_hal_surface) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + + TBM_RETURN_IF_FAIL(module); + TBM_RETURN_IF_FAIL(bo); + TBM_RETURN_IF_FAIL(bo_data); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api. + if (get_from_hal_surface) + hal_tbm_bo_free(bo_data); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_IF_FAIL(bo_func); + TBM_RETURN_IF_FAIL(bo_func->bo_free); + + bo_func->bo_free(bo_data); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_IF_FAIL(backend); + TBM_RETURN_IF_FAIL(backend->bo_free); + + backend->bo_free(bo); + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + break; +/* LCOV_EXCL_STOP */ + } +} + +int +tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + int size = 0; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + size = hal_tbm_bo_get_size((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_size, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + size = bo_func->bo_get_size(bo_data, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_size, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + size = backend->bo_size(bo); + if (size == 0) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return size; +} + +int +tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + int memory_types = TBM_BO_DEFAULT; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_memory_types, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + memory_types = bo_func->bo_get_memory_types(bo_data, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_flags, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + memory_types = backend->bo_get_flags(bo); + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return memory_types; +} + +tbm_bo_handle +tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_bo_handle bo_handle; + hal_tbm_bo_handle hbo_handle; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo_data, device, (hal_tbm_error *)error); + if (hbo_handle.ptr != NULL) + memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_handle = bo_func->bo_get_handle(bo_data, device, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_handle = backend->bo_get_handle(bo, device); + if (!bo_handle.ptr) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + bo_handle.ptr = NULL; + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_handle; +} + +tbm_bo_handle +tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_bo_handle bo_handle; + hal_tbm_bo_handle hbo_handle; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo_data, device, opt, (hal_tbm_error *)error); + if (hbo_handle.ptr != NULL) + memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle)); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_handle = bo_func->bo_map(bo_data, device, opt, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED); + + bo_handle = backend->bo_map(bo, device, opt); + if (!bo_handle.ptr) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + bo_handle.ptr = NULL; + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return bo_handle; +} + +tbm_error_e +tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_error_e error; + int ret = 0; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo_data); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, TBM_ERROR_NOT_SUPPORTED); + + error = bo_func->bo_unmap(bo->bo_data); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_IF_FAIL(backend->bo_unmap, TBM_ERROR_NOT_SUPPORTED); + + ret = bo->bufmgr->backend->bo_unmap(bo); + if (!ret) + error = TBM_ERROR_INVALID_OPERATION; + else + error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_error_e +tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_error_e error; + int ret = 0; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo_data, device, opt); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION); + if (!bo_func->bo_lock) + return TBM_ERROR_NOT_SUPPORTED; + + error = bo_func->bo_lock(bo_data, device, opt); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + if (!backend->bo_unmap) + return TBM_ERROR_NOT_SUPPORTED; + + ret = backend->bo_lock(bo, device, opt); + if (!ret) + error = TBM_ERROR_INVALID_OPERATION; + else + error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_error_e +tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_error_e error; + + TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo_data); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION); + if (!bo_func->bo_unlock) + return TBM_ERROR_NOT_SUPPORTED; + + error = bo_func->bo_unlock(bo->bo_data); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION); + if (!backend->bo_unlock) + return TBM_ERROR_NOT_SUPPORTED; + + backend->bo_unlock(bo); + error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return error; +} + +tbm_fd +tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_fd fd; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, -1, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + fd = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, -1, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED); + + fd = bo_func->bo_export_fd(bo_data, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, -1, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED); + + fd = backend->bo_export_fd(bo); + if (fd < 0) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + fd = -1; + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return fd; +} + +tbm_key +tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error) +{ + tbm_backend_bo_func *bo_func = NULL; + tbm_bufmgr_backend backend = NULL; + tbm_key ret; + + TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER); + + switch (module->type) { + case TBM_MODULE_TYPE_HAL_TBM: + ret = (hal_tbm_fd)hal_tbm_bo_export_key((hal_tbm_bo *)bo_data, (hal_tbm_error *)error); + break; +/* LCOV_EXCL_START */ + case TBM_MODULE_TYPE_TBM_BACKEND: + bo_func = module->bo_func; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_key, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + ret = bo_func->bo_export_key(bo_data, error); + break; + case TBM_MODULE_TYPE_BUFMGR_BACKEND: + TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5."); + backend = module->backend; + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION); + TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export, 0, *error, TBM_ERROR_NOT_SUPPORTED); + + ret = backend->bo_export(bo); + if (!ret) + *error = TBM_ERROR_INVALID_OPERATION; + else + *error = TBM_ERROR_NONE; + break; + default: + TBM_ERR("Wrong module type:%d", module->type); + ret = -1; + *error = TBM_ERROR_INVALID_OPERATION; + break; +/* LCOV_EXCL_STOP */ + } + + return ret; +} \ No newline at end of file