X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Ftbm_module.c;h=974c67bcffdab244cef067b8063d98c328f68668;hb=86bbaa419184bd0a189896b347a4fcbd9c894c54;hp=2da81525407c4add310a5eb73ccd2a8cf8a0a230;hpb=0685d37af53e41e7ad4daa7aea7c799c5642a198;p=platform%2Fcore%2Fuifw%2Flibtbm.git diff --git a/src/tbm_module.c b/src/tbm_module.c index 2da8152..974c67b 100644 --- a/src/tbm_module.c +++ b/src/tbm_module.c @@ -52,7 +52,6 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. #define GET_MODULE_PATCHLEVEL(vers) ((vers) & 0xFFFF) /* LCOV_EXCL_START */ - static int _tbm_backend_load_hal_tbm(tbm_module *module) { @@ -341,7 +340,6 @@ err: dlclose(module_data); return 0; } - /* LCOV_EXCL_STOP */ tbm_module * @@ -364,6 +362,7 @@ tbm_module_load(int fd) goto done; } +/* LCOV_EXCL_START */ /* try to load the new backend module */ ret = _tbm_backend_load_module(module, DEFAULT_LIB); if (ret) { @@ -410,6 +409,7 @@ tbm_module_load(int fd) free(module); module = NULL; } +/* LCOV_EXCL_STOP */ done: return module; @@ -432,6 +432,7 @@ tbm_module_unload(tbm_module *module) 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; @@ -452,6 +453,7 @@ tbm_module_unload(tbm_module *module) default: TBM_ERR("Wrong module type:%d", module->type); break; +/* LCOV_EXCL_STOP */ } free(module); @@ -469,6 +471,7 @@ tbm_module_bufmgr_get_capabilities(tbm_module *module, tbm_error_e *error) 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); @@ -486,6 +489,7 @@ tbm_module_bufmgr_get_capabilities(tbm_module *module, tbm_error_e *error) TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; break; +/* LCOV_EXCL_STOP */ } return capabilities; @@ -505,7 +509,7 @@ tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display) 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 < -1) { + if (fd < 0) { TBM_ERR("error: module(%p) native_display(%p)\n", module, native_display); return TBM_ERROR_INVALID_OPERATION; } @@ -525,6 +529,7 @@ tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display) 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); @@ -533,7 +538,7 @@ tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display) 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 7.0."); + 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); @@ -547,6 +552,93 @@ tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display) 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; @@ -565,6 +657,7 @@ tbm_module_bufmgr_bo_alloc(tbm_module *module, tbm_bo bo, int size, int flags, t 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); @@ -573,7 +666,7 @@ tbm_module_bufmgr_bo_alloc(tbm_module *module, tbm_bo bo, int size, int flags, t 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 7.0."); + 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); @@ -585,6 +678,7 @@ tbm_module_bufmgr_bo_alloc(tbm_module *module, tbm_bo bo, int size, int flags, t TBM_ERR("Wrong module type:%d", module->type); *error = TBM_ERROR_INVALID_OPERATION; break; +/* LCOV_EXCL_STOP */ } return bo_data; @@ -605,16 +699,20 @@ tbm_module_bufmgr_bo_alloc_with_format(tbm_module *module, int format, int bo_id 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); - TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo_with_format, NULL, *error, TBM_ERROR_NOT_SUPPORTED); + 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 7.0."); - TBM_ERR("error: not supported tbm_bo_alloc_with_format."); + 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; @@ -622,7 +720,531 @@ tbm_module_bufmgr_bo_alloc_with_format(tbm_module *module, int format, int bo_id 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