1 /**************************************************************************
5 Copyright 2012-2021 Samsung Electronics co., Ltd. All Rights Reserved.
7 Contact: SooChan Lim <sc1.lim@samsung.com>
8 Changyeon Lee <cyeon.lee@samsung.com>
10 Permission is hereby granted, free of charge, to any person obtaining a
11 copy of this software and associated documentation files (the
12 "Software"), to deal in the Software without restriction, including
13 without limitation the rights to use, copy, modify, merge, publish,
14 distribute, sub license, and/or sell copies of the Software, and to
15 permit persons to whom the Software is furnished to do so, subject to
16 the following conditions:
18 The above copyright notice and this permission notice (including the
19 next paragraph) shall be included in all copies or substantial portions
22 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
23 OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
24 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
25 IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
26 ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
27 TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
28 SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
30 **************************************************************************/
34 #include "tbm_bufmgr_int.h"
35 #include "tbm_bufmgr_backend.h"
36 #include "tbm_drm_helper.h"
38 #define PREFIX_LIB "libtbm_"
39 #define SUFFIX_LIB ".so"
40 #define DEFAULT_LIB PREFIX_LIB"default"SUFFIX_LIB
42 /* values to indicate unspecified fields in XF86ModReqInfo. */
43 #define MAJOR_UNSPEC 0xFF
44 #define MINOR_UNSPEC 0xFF
45 #define PATCH_UNSPEC 0xFFFF
46 #define ABI_VERS_UNSPEC 0xFFFFFFFF
48 #define MODULE_VERSION_NUMERIC(maj, min, patch) \
49 ((((maj) & 0xFF) << 24) | (((min) & 0xFF) << 16) | (patch & 0xFFFF))
50 #define GET_MODULE_MAJOR_VERSION(vers) (((vers) >> 24) & 0xFF)
51 #define GET_MODULE_MINOR_VERSION(vers) (((vers) >> 16) & 0xFF)
52 #define GET_MODULE_PATCHLEVEL(vers) ((vers) & 0xFFFF)
56 _tbm_backend_load_hal_tbm(tbm_module *module)
58 hal_tbm_backend *hal_backend = NULL;
59 hal_tbm_bufmgr *hal_bufmgr;
60 hal_tbm_error ret = HAL_TBM_ERROR_NONE;
61 hal_tbm_fd auth_drm_fd = -1;
63 hal_backend = hal_tbm_get_backend(&ret);
64 if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) {
65 TBM_ERR("get backend fail");
69 hal_bufmgr = hal_tbm_backend_get_bufmgr(hal_backend, &ret);
70 if (hal_bufmgr == NULL || ret != HAL_TBM_ERROR_NONE) {
71 TBM_ERR("get hal_bufmgr fail");
72 goto get_backend_fail;
75 if (hal_tbm_backend_has_drm_device(hal_backend, &ret)) {
76 auth_drm_fd = hal_tbm_backend_get_master_drm_fd(hal_backend, &ret);
77 if (auth_drm_fd < 0) {
78 TBM_INFO("tbm_backend has no master drm_fd.");
80 auth_drm_fd = tbm_drm_helper_get_master_fd();
81 if (auth_drm_fd < 0) {
82 TBM_INFO("libtbm requests an authenticated drm_fd to a process(display server).");
83 if (!tbm_drm_helper_get_auth_info(&auth_drm_fd, NULL, NULL)) {
84 TBM_ERR("get auth drm_fd fail");
85 goto get_backend_fail;
88 TBM_INFO("libtbm gets a master drm_fd from libtdm via tbm_drm_helper.");
91 TBM_INFO("libtbm sends a master drm_fd as an authentiated drm_fd to tbm_backend.");
92 ret = hal_tbm_backend_set_authenticated_drm_fd(hal_backend, auth_drm_fd);
93 if (ret != HAL_TBM_ERROR_NONE) {
94 TBM_ERR("hal_tbm_backend_set_authenticated_drm_fd failed.");
95 goto get_backend_fail;
98 TBM_INFO("tbm_backend has a master drm_fd.");
100 tbm_drm_helper_set_tbm_master_fd(auth_drm_fd);
102 tbm_drm_helper_set_fd(auth_drm_fd);
105 module->hal_backend = hal_backend;
106 module->hal_bufmgr = hal_bufmgr;
108 module->use_hal_tbm = 1;
110 TBM_INFO("use HAL-TBM_API");
115 if (auth_drm_fd >= 0)
117 hal_tbm_put_backend(hal_backend);
122 _check_version(TBMModuleVersionInfo *data)
124 int backend_module_major, backend_module_minor;
125 int tbm_backend_major, tbm_backend_minor;
127 backend_module_major = GET_ABI_MAJOR(data->abiversion);
128 backend_module_minor = GET_ABI_MINOR(data->abiversion);
130 TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n",
131 data->modname ? data->modname : "UNKNOWN!",
132 data->vendor ? data->vendor : "UNKNOWN!", backend_module_major, backend_module_minor);
134 tbm_backend_major = GET_ABI_MAJOR(TBM_ABI_VERSION);
135 tbm_backend_minor = GET_ABI_MINOR(TBM_ABI_VERSION);
137 TBM_DBG("TBM ABI version %d.%d\n",
138 tbm_backend_major, tbm_backend_minor);
140 if (backend_module_major != tbm_backend_major) {
141 TBM_ERR("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n",
142 backend_module_major, tbm_backend_major);
144 } else if (backend_module_minor > tbm_backend_minor) {
145 TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n",
146 backend_module_minor, tbm_backend_minor);
154 _tbm_backend_check_bufmgr_func(tbm_backend_bufmgr_func *bufmgr_func)
156 TBM_RETURN_VAL_IF_FAIL(bufmgr_func, 0); /* mandatory symbol */
157 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0); /* mandatory symbol */
158 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, 0); /* mandatory symbol */
159 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, 0); /* mandatory symbol */
160 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, 0); /* mandatory symbol */
161 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, 0); /* mandatory symbol */
162 if (!bufmgr_func->bufmgr_alloc_bo_with_format)
163 TBM_DBG("No bufmgr_func->bufmgr_alloc_bo_with_format.");
164 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_import_fd, 0); /* mandatory symbol */
165 if (!bufmgr_func->bufmgr_import_key)
166 TBM_DBG("No bufmgr_func->bo_export_key.");
172 _tbm_backend_check_bufmgr_bo(tbm_backend_bo_func *bo_func)
174 TBM_RETURN_VAL_IF_FAIL(bo_func, 0); /* mandatory symbol */
175 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_free, 0); /* mandatory symbol */
176 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_size, 0); /* mandatory symbol */
177 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_memory_types, 0); /* mandatory symbol */
178 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_handle, 0); /* mandatory symbol */
179 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_map, 0); /* mandatory symbol */
180 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, 0); /* mandatory symbol */
181 if (!bo_func->bo_lock)
182 TBM_DBG("No bo_func->bo_lock.");
183 if (!bo_func->bo_unlock)
184 TBM_DBG("No bo_func->bo_unlock.");
185 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_export_fd, 0); /* mandatory symbol */
186 if (!bo_func->bo_export_key)
187 TBM_INFO("No bo_func->bo_export_key.");
193 _tbm_backend_load_module(tbm_module *module, const char *file)
195 char path[PATH_MAX] = {0, };
196 void *module_data = NULL;
197 tbm_backend_module *backend_module_data = NULL;
198 tbm_backend_bufmgr_data *bufmgr_data = NULL;
199 int backend_module_major, backend_module_minor;
200 int tbm_backend_major, tbm_backend_minor;
203 snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
205 module_data = dlopen(path, RTLD_LAZY);
207 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
211 backend_module_data = dlsym(module_data, "tbm_backend_module_data");
212 if (!backend_module_data) {
213 TBM_ERR("Error: module does not have data object.\n");
217 tbm_backend_major = GET_ABI_MAJOR(TBM_BACKEND_ABI_LATEST_VERSION);
218 tbm_backend_minor = GET_ABI_MINOR(TBM_BACKEND_ABI_LATEST_VERSION);
219 TBM_INFO("TBM Backend ABI version %d.%d\n", tbm_backend_major, tbm_backend_minor);
221 backend_module_major = GET_ABI_MAJOR(backend_module_data->abi_version);
222 backend_module_minor = GET_ABI_MINOR(backend_module_data->abi_version);
224 TBM_INFO("TBM module %s: vendor=\"%s\" Backend ABI version=%d.%d\n",
225 backend_module_data->name ? backend_module_data->name : "UNKNOWN!",
226 backend_module_data->vendor ? backend_module_data->vendor : "UNKNOWN!",
227 backend_module_major, backend_module_minor);
229 if (backend_module_major > tbm_backend_major) {
230 TBM_ERR("TBM module ABI major ver(%d) is newer than the TBM's ver(%d)\n",
231 backend_module_major, tbm_backend_major);
233 } else if (backend_module_minor > tbm_backend_minor) {
234 TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n",
235 backend_module_minor, tbm_backend_minor);
239 if (!backend_module_data->init) {
240 TBM_ERR("Error: module does not supply init symbol.\n");
244 if (!backend_module_data->deinit) {
245 TBM_ERR("Error: module does not supply deinit symbol.\n");
249 bufmgr_data = backend_module_data->init((tbm_bufmgr)module, &error);
251 TBM_ERR("Fail to init module(%s)\n", file);
255 /* check the mandatory symbols of the backend module */
256 if (!_tbm_backend_check_bufmgr_func(module->bufmgr_func)) {
257 TBM_ERR("Fail to check the bufmgr_func symboles.");
261 if (!_tbm_backend_check_bufmgr_bo(module->bo_func)) {
262 TBM_ERR("Fail to check the bufmgr_bo symboles.");
266 module->module_data = module_data;
267 module->backend_module_data = backend_module_data;
268 module->bufmgr_data = bufmgr_data;
270 TBM_INFO("Success to load module(%s)\n", file);
276 module->backend_module_data->deinit(bufmgr_data);
278 dlclose(module_data);
284 _tbm_backend_load_bufmgr_module(tbm_module *module, int fd, const char *file)
286 char path[PATH_MAX] = {0, };
287 TBMModuleVersionInfo *vers;
288 TBMModuleData *initdata;
292 snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
294 module_data = dlopen(path, RTLD_LAZY);
296 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
300 initdata = dlsym(module_data, "tbmModuleData");
302 TBM_ERR("Error: module does not have data object.\n");
306 vers = initdata->vers;
308 TBM_ERR("Error: module does not supply version information.\n");
312 init = initdata->init;
314 TBM_ERR("Error: module does not supply init symbol.\n");
318 if (!_check_version(vers)) {
319 TBM_ERR("Fail to check version.\n");
323 if (!init((tbm_bufmgr)module, fd)) {
324 TBM_ERR("Fail to init module(%s)\n", file);
328 if (!module->backend || !module->backend->priv) {
329 TBM_ERR("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file);
333 module->module_data = module_data;
335 TBM_DBG("Success to load module(%s)\n", file);
340 dlclose(module_data);
346 tbm_module_load(int fd)
349 struct dirent **namelist;
352 module = calloc(1, sizeof(struct _tbm_module));
354 TBM_ERR("fail to allocate the memory");
358 /* try to load the hal-tbm backend module */
359 ret = _tbm_backend_load_hal_tbm(module);
361 module->type = TBM_MODULE_TYPE_HAL_TBM;
365 /* LCOV_EXCL_START */
366 /* try to load the new backend module */
367 ret = _tbm_backend_load_module(module, DEFAULT_LIB);
369 module->type = TBM_MODULE_TYPE_TBM_BACKEND;
373 /* try to load the old(deprecated) backend mdoule */
374 ret = _tbm_backend_load_bufmgr_module(module, fd, DEFAULT_LIB);
376 module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
380 /* load backend_module from configured path */
381 n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort);
383 TBM_ERR("no files : %s\n", BUFMGR_MODULE_DIR);
384 tbm_module_unload(module);
389 if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) {
390 const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB);
392 if (p && !strcmp(p, SUFFIX_LIB)) {
393 ret = _tbm_backend_load_module(module, namelist[n]->d_name);
395 module->type = TBM_MODULE_TYPE_TBM_BACKEND;
397 ret = _tbm_backend_load_bufmgr_module(module, fd, namelist[n]->d_name);
398 module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
419 tbm_module_unload(tbm_module *module)
421 switch (module->type) {
422 case TBM_MODULE_TYPE_HAL_TBM:
423 if (module->auth_wl_socket_created) {
424 tbm_drm_helper_wl_auth_server_deinit();
425 close(module->auth_fd);
427 tbm_drm_helper_unset_tbm_master_fd();
428 tbm_drm_helper_unset_fd();
430 hal_tbm_put_backend(module->hal_backend);
431 module->hal_backend = NULL;
432 module->hal_bufmgr = NULL;
433 module->use_hal_tbm = 0;
435 /* LCOV_EXCL_START */
436 case TBM_MODULE_TYPE_TBM_BACKEND:
437 module->backend_module_data->deinit(module->bufmgr_data);
438 module->bo_func = NULL;
439 module->bufmgr_func = NULL;
440 module->bufmgr_data = NULL;
441 module->backend_module_data = NULL;
443 dlclose(module->module_data);
445 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
446 module->backend->bufmgr_deinit(module->backend->priv);
447 module->backend->priv = NULL;
448 tbm_backend_free(module->backend);
449 module->backend = NULL;
451 dlclose(module->module_data);
454 TBM_ERR("Wrong module type:%d", module->type);
463 tbm_module_get_capabilities(tbm_module *module, tbm_error_e *error)
465 int capabilities = 0;
466 tbm_backend_bufmgr_func *bufmgr_func = NULL;
468 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, TBM_BUFMGR_CAPABILITY_NONE, *error, TBM_ERROR_INVALID_PARAMETER);
470 switch (module->type) {
471 case TBM_MODULE_TYPE_HAL_TBM:
472 capabilities = hal_tbm_bufmgr_get_capabilities(module->hal_bufmgr, (hal_tbm_error *)error);
474 /* LCOV_EXCL_START */
475 case TBM_MODULE_TYPE_TBM_BACKEND:
476 bufmgr_func = module->bufmgr_func;
477 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
478 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0, *error, TBM_ERROR_NOT_SUPPORTED);
480 capabilities = module->bufmgr_func->bufmgr_get_capabilities(module->bufmgr_data, error);
482 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
483 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
484 TBM_ERR("Do not support at tbm_bufmgr_backend.");
486 *error = TBM_ERROR_NOT_SUPPORTED;
489 TBM_ERR("Wrong module type:%d", module->type);
490 *error = TBM_ERROR_INVALID_OPERATION;
499 tbm_module_bind_native_display(tbm_module *module, void *native_display)
501 tbm_error_e error = TBM_ERROR_NONE;
502 tbm_backend_bufmgr_func *bufmgr_func = NULL;
503 tbm_bufmgr_backend backend = NULL;
506 TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
508 switch (module->type) {
509 case TBM_MODULE_TYPE_HAL_TBM:
510 if (hal_tbm_backend_has_drm_device(module->hal_backend, &ret)) {
511 int fd = tbm_drm_helper_get_fd(); // this must be the auth drm_fd.(master drm_fd);
513 TBM_ERR("error: module(%p) native_display(%p)\n", module, native_display);
514 return TBM_ERROR_INVALID_OPERATION;
517 // make the wayland server socket for sending the authenticated drm_fd to wayland clients.
518 if (!tbm_drm_helper_wl_auth_server_init(native_display, fd, NULL, 0)) {
519 TBM_ERR("error: tbm_drm_helper_wl_auth_server_init failed\n", module, native_display);
521 return TBM_ERROR_INVALID_OPERATION;
523 TBM_INFO("tbm creates a wayland socket for authentication of drm_fd.");
525 module->auth_wl_socket_created = 1;
526 module->auth_fd = fd;
528 TBM_INFO("tbm_module has no drm device.");
529 error = TBM_ERROR_NONE;
532 /* LCOV_EXCL_START */
533 case TBM_MODULE_TYPE_TBM_BACKEND:
534 bufmgr_func = module->bufmgr_func;
535 TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION);
536 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED);
538 error = bufmgr_func->bufmgr_bind_native_display(module->bufmgr_data, (tbm_native_display *)native_display);
540 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
541 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
542 backend = module->backend;
543 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
544 TBM_RETURN_VAL_IF_FAIL(backend->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED);
546 ret = backend->bufmgr_bind_native_display((tbm_bufmgr)module, native_display);
548 error = TBM_ERROR_INVALID_OPERATION;
552 TBM_ERR("Wrong module type:%d", module->type);
553 error = TBM_ERROR_INVALID_OPERATION;
562 tbm_module_get_supported_formats(tbm_module *module, uint32_t **formats, uint32_t *num)
564 tbm_error_e error = TBM_ERROR_NONE;
565 tbm_backend_bufmgr_func *bufmgr_func = NULL;
566 tbm_bufmgr_backend backend = NULL;
569 TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
571 switch (module->type) {
572 case TBM_MODULE_TYPE_HAL_TBM:
573 error = (tbm_error_e)hal_tbm_bufmgr_get_supported_formats(module->hal_bufmgr, formats, num);
575 /* LCOV_EXCL_START */
576 case TBM_MODULE_TYPE_TBM_BACKEND:
577 bufmgr_func = module->bufmgr_func;
578 TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION);
579 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, TBM_ERROR_NOT_SUPPORTED);
581 error = bufmgr_func->bufmgr_get_supported_formats(module->bufmgr_data, formats, num);
583 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
584 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
585 backend = module->backend;
586 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
587 TBM_RETURN_VAL_IF_FAIL(backend->surface_supported_format, TBM_ERROR_NOT_SUPPORTED);
589 ret = backend->surface_supported_format(formats, num);
591 error = TBM_ERROR_INVALID_OPERATION;
595 TBM_ERR("Wrong module type:%d", module->type);
596 error = TBM_ERROR_INVALID_OPERATION;
605 tbm_module_get_plane_data(tbm_module *module, int format, int plane_idx, uint32_t w, uint32_t h,
606 uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
608 tbm_error_e error = TBM_ERROR_NONE;
609 tbm_backend_bufmgr_func *bufmgr_func = NULL;
610 tbm_bufmgr_backend backend = NULL;
613 TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
615 switch (module->type) {
616 case TBM_MODULE_TYPE_HAL_TBM:
617 error = (tbm_error_e)hal_tbm_bufmgr_get_plane_data(module->hal_bufmgr, format, plane_idx, w, h, size, offset, pitch, bo_idx);
619 /* LCOV_EXCL_START */
620 case TBM_MODULE_TYPE_TBM_BACKEND:
621 bufmgr_func = module->bufmgr_func;
622 TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION);
623 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, TBM_ERROR_NOT_SUPPORTED);
625 error = bufmgr_func->bufmgr_get_plane_data(module->bufmgr_data, format, plane_idx, w, h, size, offset, pitch, bo_idx);
627 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
628 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
629 backend = module->backend;
630 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
631 TBM_RETURN_VAL_IF_FAIL(backend->surface_get_plane_data, TBM_ERROR_NOT_SUPPORTED);
633 ret = backend->surface_get_plane_data(w, h, format, plane_idx, size, offset, pitch, bo_idx);
635 error = TBM_ERROR_INVALID_OPERATION;
638 TBM_ERR("Wrong module type:%d", module->type);
639 error = TBM_ERROR_INVALID_OPERATION;
648 tbm_module_support_surface_data(tbm_module *module)
650 tbm_error_e error = TBM_ERROR_NONE;
651 tbm_surface_data *surface_data = NULL;
653 static int tbm_module_check_support_surface_data = 0;
655 TBM_RETURN_VAL_IF_FAIL(module, 0);
657 // check once support_surface_data or not.
658 if (tbm_module_check_support_surface_data) {
659 // return the value which already set.
660 return module->support_surface_data;
663 // check this only once
664 tbm_module_check_support_surface_data = 1;
666 if (module->type != TBM_MODULE_TYPE_HAL_TBM)
669 // Assume that the hal-tbm supports the hal surface apis if tbm_module_alloc_surface_data succeed.
670 surface_data = tbm_module_alloc_surface_data(module, 10, 10, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT, &error);
675 module->support_surface_data = 1;
678 return module->support_surface_data;
683 tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int format, int flags, tbm_error_e *error)
685 tbm_surface_data *surface_data = NULL;
687 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
688 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION);
690 surface_data = calloc(1, sizeof(struct _tbm_surface_data));
692 TBM_ERR("memory allocation failed.");
693 *error = TBM_ERROR_OUT_OF_MEMORY;
697 surface_data->hal_surface = hal_tbm_bufmgr_alloc_surface(module->hal_bufmgr,
700 (hal_tbm_format)format,
701 (hal_tbm_bo_memory_type)flags,
704 (hal_tbm_error *)error);
705 if (!surface_data->hal_surface) {
706 TBM_ERR("hal_tbm_bufmgr_alloc_surface failed.");
707 *error = TBM_ERROR_INVALID_OPERATION;
712 surface_data->module = module;
718 tbm_module_import_surface_data(tbm_module *module, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
720 tbm_surface_data *surface_data = NULL;
722 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
723 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION);
725 surface_data = calloc(1, sizeof(struct _tbm_surface_data));
727 TBM_ERR("memory allocation failed.");
728 *error = TBM_ERROR_OUT_OF_MEMORY;
732 surface_data->hal_surface = hal_tbm_bufmgr_import_surface(module->hal_bufmgr,
735 (hal_tbm_format)format,
736 (hal_tbm_surface_buffer_data *)buffer_data,
737 (hal_tbm_error *)error);
738 if (!surface_data->hal_surface) {
739 TBM_ERR("hal_tbm_bufmgr_import_surface failed. width:%d height:%d format:%d error:%s",
740 width, height, format, tbm_error_str(*error));
745 surface_data->module = module;
751 tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error)
753 tbm_bo_data *bo_data = NULL;
754 tbm_backend_bufmgr_func *bufmgr_func = NULL;
755 tbm_bufmgr_backend backend = NULL;
757 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
759 bo_data = calloc(1, sizeof(struct _tbm_bo_data));
761 TBM_ERR("memory allocation failed.");
762 *error = TBM_ERROR_OUT_OF_MEMORY;
766 switch (module->type) {
767 case TBM_MODULE_TYPE_HAL_TBM:
768 bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error);
769 if (!bo_data->hal_bo) {
771 TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL);
774 /* LCOV_EXCL_START */
775 case TBM_MODULE_TYPE_TBM_BACKEND:
776 bufmgr_func = module->bufmgr_func;
777 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
778 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
780 bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error);
781 if (!bo_data->backend_bo_data) {
783 TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL);
786 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
787 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
788 backend = module->backend;
789 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
790 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
792 bo_data->priv = (void *)backend->bo_alloc(bo, size, flags);
793 *error = TBM_ERROR_NONE;
797 TBM_ERR("Wrong module type:%d", module->type);
798 *error = TBM_ERROR_INVALID_OPERATION;
804 bo_data->module = module;
810 tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width,
811 int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error)
813 tbm_bo_data *bo_data = NULL;
814 tbm_backend_bufmgr_func *bufmgr_func = NULL;
816 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
818 bo_data = calloc(1, sizeof(struct _tbm_bo_data));
820 TBM_ERR("memory allocation failed.");
821 *error = TBM_ERROR_OUT_OF_MEMORY;
825 switch (module->type) {
826 case TBM_MODULE_TYPE_HAL_TBM:
827 bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr,
828 format, bo_idx, width, height, bpp,
829 (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error);
830 if (!bo_data->hal_bo) {
832 TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL);
835 /* LCOV_EXCL_START */
836 case TBM_MODULE_TYPE_TBM_BACKEND:
837 bufmgr_func = module->bufmgr_func;
838 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
839 if (!bufmgr_func->bufmgr_alloc_bo_with_format) {
840 *error = TBM_ERROR_NOT_SUPPORTED;
844 bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error);
845 if (!bo_data->backend_bo_data) {
847 TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL);
850 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
851 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
852 TBM_ERR("error: not supported tbm_bufmgr_internal_alloc_bo_with_format.");
854 *error = TBM_ERROR_NOT_SUPPORTED;
858 TBM_ERR("Wrong module type:%d", module->type);
859 *error = TBM_ERROR_INVALID_OPERATION;
865 bo_data->module = module;
871 tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error)
873 tbm_bo_data *bo_data = NULL;
874 tbm_backend_bufmgr_func *bufmgr_func = NULL;
875 tbm_bufmgr_backend backend = NULL;
877 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
879 bo_data = calloc(1, sizeof(struct _tbm_bo_data));
881 TBM_ERR("memory allocation failed.");
882 *error = TBM_ERROR_OUT_OF_MEMORY;
886 switch (module->type) {
887 case TBM_MODULE_TYPE_HAL_TBM:
888 bo_data->hal_bo = hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error);
889 if (!bo_data->hal_bo) {
891 TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL);
894 /* LCOV_EXCL_START */
895 case TBM_MODULE_TYPE_TBM_BACKEND:
896 bufmgr_func = module->bufmgr_func;
897 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
898 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
900 bo_data->backend_bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error);
901 if (!bo_data->backend_bo_data) {
903 TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL);
906 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
907 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
908 backend = module->backend;
909 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
910 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
912 bo_data->priv = (void *)backend->bo_import_fd(bo, fd);
913 if (!bo_data->priv) {
914 *error = TBM_ERROR_INVALID_OPERATION;
916 TBM_RETURN_VAL_IF_FAIL(bo_data->priv, NULL);
918 *error = TBM_ERROR_NONE;
922 TBM_ERR("Wrong module type:%d", module->type);
923 *error = TBM_ERROR_INVALID_OPERATION;
929 bo_data->module = module;
935 tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error)
937 tbm_bo_data *bo_data = NULL;
938 tbm_backend_bufmgr_func *bufmgr_func = NULL;
939 tbm_bufmgr_backend backend = NULL;
941 TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
943 bo_data = calloc(1, sizeof(struct _tbm_bo_data));
945 TBM_ERR("memory allocation failed.");
946 *error = TBM_ERROR_OUT_OF_MEMORY;
950 switch (module->type) {
951 case TBM_MODULE_TYPE_HAL_TBM:
952 bo_data->hal_bo = hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error);
953 if (!bo_data->hal_bo) {
955 TBM_RETURN_VAL_IF_FAIL(bo_data->hal_bo, NULL);
958 /* LCOV_EXCL_START */
959 case TBM_MODULE_TYPE_TBM_BACKEND:
960 bufmgr_func = module->bufmgr_func;
961 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
962 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
964 bo_data->backend_bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error);
965 if (!bo_data->backend_bo_data) {
967 TBM_RETURN_VAL_IF_FAIL(bo_data->backend_bo_data, NULL);
970 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
971 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
972 backend = module->backend;
973 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
974 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
976 bo_data->priv = (void *)backend->bo_import(bo, key);
977 if (!bo_data->priv) {
978 *error = TBM_ERROR_INVALID_OPERATION;
980 TBM_RETURN_VAL_IF_FAIL(bo_data->priv, NULL);
982 *error = TBM_ERROR_NONE;
986 TBM_ERR("Wrong module type:%d", module->type);
987 *error = TBM_ERROR_INVALID_OPERATION;
993 bo_data->module = module;
999 tbm_module_compare_bo_data(tbm_module *module, tbm_bo_data *bo_data1, tbm_bo_data *bo_data2)
1001 TBM_RETURN_VAL_IF_FAIL(module, 0);
1003 switch (module->type) {
1004 case TBM_MODULE_TYPE_HAL_TBM:
1005 return (bo_data1->hal_bo == bo_data2->hal_bo);
1007 /* LCOV_EXCL_START */
1008 case TBM_MODULE_TYPE_TBM_BACKEND:
1009 return (bo_data1->backend_bo_data == bo_data2->backend_bo_data);
1011 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1012 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1013 return (bo_data1->priv == bo_data2->priv);
1016 TBM_ERR("Wrong module type:%d", module->type);
1018 /* LCOV_EXCL_STOP */
1025 tbm_surface_data_free(tbm_surface_data *surface_data)
1027 TBM_RETURN_IF_FAIL(surface_data);
1028 TBM_RETURN_IF_FAIL(surface_data->module);
1029 TBM_RETURN_IF_FAIL(surface_data->module->type == TBM_MODULE_TYPE_HAL_TBM);
1031 surface_data->module = NULL;
1033 hal_tbm_surface_free(surface_data->hal_surface);
1034 surface_data->hal_surface = NULL;
1040 tbm_surface_data_get_plane_data(tbm_surface_data *surface_data, int plane_idx, uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
1044 TBM_RETURN_VAL_IF_FAIL(surface_data, TBM_ERROR_INVALID_PARAMETER);
1045 TBM_RETURN_VAL_IF_FAIL(surface_data->hal_surface, TBM_ERROR_NOT_SUPPORTED);
1047 error = (tbm_error_e)hal_tbm_surface_get_plane_data(surface_data->hal_surface, plane_idx, size, offset, pitch, bo_idx);
1048 TBM_RETURN_VAL_IF_FAIL(error == TBM_ERROR_NONE, error);
1050 return TBM_ERROR_NONE;
1054 tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, tbm_error_e *error)
1056 tbm_bo_data **bo_data_array = NULL;
1057 hal_tbm_bo **hal_bos = NULL;
1060 TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1061 TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data->hal_surface, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1063 hal_bos = hal_tbm_surface_get_bos(surface_data->hal_surface, num_bos, (hal_tbm_error *)error);
1064 TBM_RETURN_VAL_IF_FAIL(hal_bos, NULL);
1066 bo_data_array = calloc(*num_bos, sizeof(struct _tbm_bo_data));
1067 if (bo_data_array) {
1068 TBM_ERR("memory allocation failed.");
1069 *error = TBM_ERROR_OUT_OF_MEMORY;
1073 for (i = 0; i < *num_bos; i++) {
1074 bo_data_array[i]->hal_bo = hal_bos[i];
1075 bo_data_array[i]->module = surface_data->module;
1078 return bo_data_array;
1081 tbm_surface_buffer_data *
1082 tbm_surface_data_export(tbm_surface_data *surface_data, tbm_error_e *error)
1084 tbm_surface_buffer_data *buffer_data;
1086 TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1087 TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data->hal_surface, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1089 buffer_data = (tbm_surface_buffer_data *)hal_tbm_surface_export((hal_tbm_surface *)surface_data->hal_surface,
1090 (hal_tbm_error *)error);
1091 TBM_RETURN_VAL_IF_FAIL(buffer_data, NULL);
1097 tbm_bo_data_free(tbm_bo_data *bo_data, int get_from_surface_data)
1099 tbm_module *module = NULL;
1100 tbm_backend_bo_func *bo_func = NULL;
1101 tbm_bufmgr_backend backend = NULL;
1103 TBM_RETURN_IF_FAIL(bo_data);
1104 TBM_RETURN_IF_FAIL(bo_data->module);
1106 module = bo_data->module;
1108 switch (module->type) {
1109 case TBM_MODULE_TYPE_HAL_TBM:
1110 // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api.
1111 if (!get_from_surface_data) {
1112 hal_tbm_bo_free(bo_data->hal_bo);
1113 bo_data->hal_bo = NULL;
1116 /* LCOV_EXCL_START */
1117 case TBM_MODULE_TYPE_TBM_BACKEND:
1118 bo_func = module->bo_func;
1119 TBM_RETURN_IF_FAIL(bo_func);
1120 TBM_RETURN_IF_FAIL(bo_func->bo_free);
1122 bo_func->bo_free(bo_data->backend_bo_data);
1123 bo_data->backend_bo_data = NULL;
1125 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1126 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1127 backend = module->backend;
1128 TBM_RETURN_IF_FAIL(backend);
1129 TBM_RETURN_IF_FAIL(backend->bo_free);
1131 backend->bo_free(bo_data->priv);
1132 bo_data->priv = NULL;
1135 TBM_ERR("Wrong module type:%d", module->type);
1137 /* LCOV_EXCL_STOP */
1140 bo_data->module = NULL;
1145 tbm_bo_data_get_size(tbm_bo_data *bo_data, tbm_error_e *error)
1147 tbm_module *module = NULL;
1148 tbm_backend_bo_func *bo_func = NULL;
1149 tbm_bufmgr_backend backend = NULL;
1152 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1153 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1155 module = bo_data->module;
1157 switch (module->type) {
1158 case TBM_MODULE_TYPE_HAL_TBM:
1159 size = hal_tbm_bo_get_size(bo_data->hal_bo, (hal_tbm_error *)error);
1161 /* LCOV_EXCL_START */
1162 case TBM_MODULE_TYPE_TBM_BACKEND:
1163 bo_func = module->bo_func;
1164 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1165 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1167 size = bo_func->bo_get_size(bo_data->backend_bo_data, error);
1169 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1170 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1171 backend = module->backend;
1172 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1173 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1175 size = backend->bo_size(bo_data->priv);
1177 *error = TBM_ERROR_INVALID_OPERATION;
1179 *error = TBM_ERROR_NONE;
1182 TBM_ERR("Wrong module type:%d", module->type);
1183 *error = TBM_ERROR_INVALID_OPERATION;
1185 /* LCOV_EXCL_STOP */
1192 tbm_bo_data_get_memory_types(tbm_bo_data *bo_data, tbm_error_e *error)
1194 tbm_module *module = NULL;
1195 tbm_backend_bo_func *bo_func = NULL;
1196 tbm_bufmgr_backend backend = NULL;
1197 int memory_types = TBM_BO_DEFAULT;
1199 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1200 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1202 module = bo_data->module;
1204 switch (module->type) {
1205 case TBM_MODULE_TYPE_HAL_TBM:
1206 memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types(bo_data->hal_bo, (hal_tbm_error *)error);
1208 /* LCOV_EXCL_START */
1209 case TBM_MODULE_TYPE_TBM_BACKEND:
1210 bo_func = module->bo_func;
1211 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1212 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_memory_types, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1214 memory_types = bo_func->bo_get_memory_types(bo_data->backend_bo_data, error);
1216 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1217 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1218 backend = module->backend;
1219 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1220 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_flags, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1222 memory_types = backend->bo_get_flags(bo_data->priv);
1223 *error = TBM_ERROR_NONE;
1226 TBM_ERR("Wrong module type:%d", module->type);
1227 *error = TBM_ERROR_INVALID_OPERATION;
1229 /* LCOV_EXCL_STOP */
1232 return memory_types;
1236 tbm_bo_data_get_handle(tbm_bo_data *bo_data, int device, tbm_error_e *error)
1238 tbm_module *module = NULL;
1239 tbm_backend_bo_func *bo_func = NULL;
1240 tbm_bufmgr_backend backend = NULL;
1241 tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
1242 hal_tbm_bo_handle hbo_handle;
1244 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1245 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1247 module = bo_data->module;
1249 switch (module->type) {
1250 case TBM_MODULE_TYPE_HAL_TBM:
1251 hbo_handle = hal_tbm_bo_get_handle(bo_data->hal_bo, device, (hal_tbm_error *)error);
1252 if (hbo_handle.ptr != NULL)
1253 memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
1255 /* LCOV_EXCL_START */
1256 case TBM_MODULE_TYPE_TBM_BACKEND:
1257 bo_func = module->bo_func;
1258 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1259 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1261 bo_handle = bo_func->bo_get_handle(bo_data->backend_bo_data, device, error);
1263 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1264 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1265 backend = module->backend;
1266 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1267 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1269 bo_handle = backend->bo_get_handle(bo_data->priv, device);
1271 *error = TBM_ERROR_INVALID_OPERATION;
1273 *error = TBM_ERROR_NONE;
1276 TBM_ERR("Wrong module type:%d", module->type);
1277 bo_handle.ptr = NULL;
1278 *error = TBM_ERROR_INVALID_OPERATION;
1280 /* LCOV_EXCL_STOP */
1287 tbm_bo_data_map(tbm_bo_data *bo_data, int device, int opt, tbm_error_e *error)
1289 tbm_module *module = NULL;
1290 tbm_backend_bo_func *bo_func = NULL;
1291 tbm_bufmgr_backend backend = NULL;
1292 tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
1293 hal_tbm_bo_handle hbo_handle;
1295 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1296 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1298 module = bo_data->module;
1300 switch (module->type) {
1301 case TBM_MODULE_TYPE_HAL_TBM:
1302 hbo_handle = hal_tbm_bo_map(bo_data->hal_bo, device, opt, (hal_tbm_error *)error);
1303 if (hbo_handle.ptr != NULL)
1304 memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
1306 /* LCOV_EXCL_START */
1307 case TBM_MODULE_TYPE_TBM_BACKEND:
1308 bo_func = module->bo_func;
1309 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1310 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1312 bo_handle = bo_func->bo_map(bo_data->backend_bo_data, device, opt, error);
1314 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1315 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1316 backend = module->backend;
1317 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1318 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1320 bo_handle = backend->bo_map(bo_data->priv, device, opt);
1322 *error = TBM_ERROR_INVALID_OPERATION;
1324 *error = TBM_ERROR_NONE;
1327 TBM_ERR("Wrong module type:%d", module->type);
1328 bo_handle.ptr = NULL;
1329 *error = TBM_ERROR_INVALID_OPERATION;
1331 /* LCOV_EXCL_STOP */
1338 tbm_bo_data_unmap(tbm_bo_data *bo_data)
1340 tbm_module *module = NULL;
1341 tbm_backend_bo_func *bo_func = NULL;
1342 tbm_bufmgr_backend backend = NULL;
1346 TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1347 TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1349 module = bo_data->module;
1351 switch (module->type) {
1352 case TBM_MODULE_TYPE_HAL_TBM:
1353 error = (hal_tbm_error)hal_tbm_bo_unmap(bo_data->hal_bo);
1355 /* LCOV_EXCL_START */
1356 case TBM_MODULE_TYPE_TBM_BACKEND:
1357 bo_func = module->bo_func;
1358 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1359 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1361 error = bo_func->bo_unmap(bo_data->backend_bo_data);
1363 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1364 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1365 backend = module->backend;
1366 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1367 TBM_RETURN_VAL_IF_FAIL(backend->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1369 ret = backend->bo_unmap(bo_data->priv);
1371 error = TBM_ERROR_INVALID_OPERATION;
1373 error = TBM_ERROR_NONE;
1376 TBM_ERR("Wrong module type:%d", module->type);
1377 error = TBM_ERROR_INVALID_OPERATION;
1379 /* LCOV_EXCL_STOP */
1386 tbm_bo_data_lock(tbm_bo_data *bo_data, int device, int opt)
1388 tbm_module *module = NULL;
1389 tbm_backend_bo_func *bo_func = NULL;
1390 tbm_bufmgr_backend backend = NULL;
1394 TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1395 TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1397 module = bo_data->module;
1399 switch (module->type) {
1400 case TBM_MODULE_TYPE_HAL_TBM:
1401 error = (tbm_error_e)hal_tbm_bo_lock(bo_data->hal_bo, device, opt);
1403 /* LCOV_EXCL_START */
1404 case TBM_MODULE_TYPE_TBM_BACKEND:
1405 bo_func = module->bo_func;
1406 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1407 if (!bo_func->bo_lock)
1408 return TBM_ERROR_NOT_SUPPORTED;
1410 error = bo_func->bo_lock(bo_data->backend_bo_data, device, opt);
1412 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1413 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1414 backend = module->backend;
1415 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1416 if (!backend->bo_unmap)
1417 return TBM_ERROR_NOT_SUPPORTED;
1419 ret = backend->bo_lock(bo_data->priv, device, opt);
1421 error = TBM_ERROR_INVALID_OPERATION;
1423 error = TBM_ERROR_NONE;
1426 TBM_ERR("Wrong module type:%d", module->type);
1427 error = TBM_ERROR_INVALID_OPERATION;
1429 /* LCOV_EXCL_STOP */
1436 tbm_bo_data_unlock(tbm_bo_data *bo_data)
1438 tbm_module *module = NULL;
1439 tbm_backend_bo_func *bo_func = NULL;
1440 tbm_bufmgr_backend backend = NULL;
1443 TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1444 TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1446 module = bo_data->module;
1448 switch (module->type) {
1449 case TBM_MODULE_TYPE_HAL_TBM:
1450 error = (tbm_error_e)hal_tbm_bo_unlock(bo_data->hal_bo);
1452 /* LCOV_EXCL_START */
1453 case TBM_MODULE_TYPE_TBM_BACKEND:
1454 bo_func = module->bo_func;
1455 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1456 if (!bo_func->bo_unlock)
1457 return TBM_ERROR_NOT_SUPPORTED;
1459 error = bo_func->bo_unlock(bo_data->backend_bo_data);
1461 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1462 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1463 backend = module->backend;
1464 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1465 if (!backend->bo_unlock)
1466 return TBM_ERROR_NOT_SUPPORTED;
1468 backend->bo_unlock(bo_data->priv);
1469 error = TBM_ERROR_NONE;
1472 TBM_ERR("Wrong module type:%d", module->type);
1473 error = TBM_ERROR_INVALID_OPERATION;
1475 /* LCOV_EXCL_STOP */
1482 tbm_bo_data_export_fd(tbm_bo_data *bo_data, tbm_error_e *error)
1484 tbm_module *module = NULL;
1485 tbm_backend_bo_func *bo_func = NULL;
1486 tbm_bufmgr_backend backend = NULL;
1489 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, -1, *error, TBM_ERROR_INVALID_PARAMETER);
1490 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, -1, *error, TBM_ERROR_INVALID_PARAMETER);
1492 module = bo_data->module;
1494 switch (module->type) {
1495 case TBM_MODULE_TYPE_HAL_TBM:
1496 fd = (hal_tbm_fd)hal_tbm_bo_export_fd(bo_data->hal_bo, (hal_tbm_error *)error);
1498 /* LCOV_EXCL_START */
1499 case TBM_MODULE_TYPE_TBM_BACKEND:
1500 bo_func = module->bo_func;
1501 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, -1, *error, TBM_ERROR_INVALID_OPERATION);
1502 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1504 fd = bo_func->bo_export_fd(bo_data->backend_bo_data, error);
1506 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1507 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1508 backend = module->backend;
1509 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, -1, *error, TBM_ERROR_INVALID_OPERATION);
1510 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1512 fd = backend->bo_export_fd(bo_data->priv);
1514 *error = TBM_ERROR_INVALID_OPERATION;
1516 *error = TBM_ERROR_NONE;
1519 TBM_ERR("Wrong module type:%d", module->type);
1521 *error = TBM_ERROR_INVALID_OPERATION;
1523 /* LCOV_EXCL_STOP */
1530 tbm_bo_data_export_key(tbm_bo_data *bo_data, tbm_error_e *error)
1532 tbm_module *module = NULL;
1533 tbm_backend_bo_func *bo_func = NULL;
1534 tbm_bufmgr_backend backend = NULL;
1537 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1538 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1540 module = bo_data->module;
1542 switch (module->type) {
1543 case TBM_MODULE_TYPE_HAL_TBM:
1544 ret = (hal_tbm_fd)hal_tbm_bo_export_key(bo_data->hal_bo, (hal_tbm_error *)error);
1546 /* LCOV_EXCL_START */
1547 case TBM_MODULE_TYPE_TBM_BACKEND:
1548 bo_func = module->bo_func;
1549 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1550 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_key, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1552 ret = bo_func->bo_export_key(bo_data->backend_bo_data, error);
1554 case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1555 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1556 backend = module->backend;
1557 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1558 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1560 ret = backend->bo_export(bo_data->priv);
1562 *error = TBM_ERROR_INVALID_OPERATION;
1564 *error = TBM_ERROR_NONE;
1567 TBM_ERR("Wrong module type:%d", module->type);
1569 *error = TBM_ERROR_INVALID_OPERATION;
1571 /* LCOV_EXCL_STOP */