src/tbm_module.c

   1 /**************************************************************************
   2
   3 libtbm
   4
   5 Copyright 2012-2021 Samsung Electronics co., Ltd. All Rights Reserved.
   6
   7 Contact: SooChan Lim <sc1.lim@samsung.com>
   8          Changyeon Lee <cyeon.lee@samsung.com>
   9
  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:
  17
  18 The above copyright notice and this permission notice (including the
  19 next paragraph) shall be included in all copies or substantial portions
  20 of the Software.
  21
  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.
  29
  30 **************************************************************************/
  31
  32 #include "config.h"
  33
  34 #include "tbm_bufmgr_int.h"
  35 #include "tbm_bufmgr_backend.h"
  36 #include "tbm_drm_helper.h"
  37
  38 #define PREFIX_LIB    "libtbm_"
  39 #define SUFFIX_LIB    ".so"
  40 #define DEFAULT_LIB   PREFIX_LIB"default"SUFFIX_LIB
  41
  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
  47
  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)
  53
  54 /* LCOV_EXCL_START */
  55 static int
  56 _tbm_backend_load_hal_tbm(tbm_module *module)
  57 {
  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;
  62
  63         hal_backend = hal_tbm_get_backend(&ret);
  64         if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) {
  65                 TBM_ERR("get backend fail");
  66                 return 0;
  67         }
  68
  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;
  73         }
  74
  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.");
  79
  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;
  86                                 }
  87                         } else {
  88                                 TBM_INFO("libtbm gets a master drm_fd from libtdm via tbm_drm_helper.");
  89                         }
  90
  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;
  96                         }
  97                 } else {
  98                         TBM_INFO("tbm_backend has a master drm_fd.");
  99
 100                         tbm_drm_helper_set_tbm_master_fd(auth_drm_fd);
 101                 }
 102                 tbm_drm_helper_set_fd(auth_drm_fd);
 103         }
 104
 105         module->hal_backend = hal_backend;
 106         module->hal_bufmgr = hal_bufmgr;
 107
 108         module->use_hal_tbm = 1;
 109
 110         TBM_INFO("use HAL-TBM_API");
 111
 112         return 1;
 113
 114 get_backend_fail:
 115         if (auth_drm_fd >= 0)
 116                 close(auth_drm_fd);
 117         hal_tbm_put_backend(hal_backend);
 118         return 0;
 119 }
 120
 121 static int
 122 _check_version(TBMModuleVersionInfo *data)
 123 {
 124         int backend_module_major, backend_module_minor;
 125         int tbm_backend_major, tbm_backend_minor;
 126
 127         backend_module_major = GET_ABI_MAJOR(data->abiversion);
 128         backend_module_minor = GET_ABI_MINOR(data->abiversion);
 129
 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);
 133
 134         tbm_backend_major = GET_ABI_MAJOR(TBM_ABI_VERSION);
 135         tbm_backend_minor = GET_ABI_MINOR(TBM_ABI_VERSION);
 136
 137         TBM_DBG("TBM ABI version %d.%d\n",
 138             tbm_backend_major, tbm_backend_minor);
 139
 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);
 143                 return 0;
 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);
 147                 return 0;
 148         }
 149
 150         return 1;
 151 }
 152
 153 static int
 154 _tbm_backend_check_bufmgr_func(tbm_backend_bufmgr_func *bufmgr_func)
 155 {
 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.");
 167
 168         return 1;
 169 }
 170
 171 static int
 172 _tbm_backend_check_bufmgr_bo(tbm_backend_bo_func *bo_func)
 173 {
 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.");
 188
 189         return 1;
 190 }
 191
 192 static int
 193 _tbm_backend_load_module(tbm_module *module, const char *file)
 194 {
 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;
 201         tbm_error_e error;
 202
 203         snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
 204
 205         module_data = dlopen(path, RTLD_LAZY);
 206         if (!module_data) {
 207                 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
 208                 return 0;
 209         }
 210
 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");
 214                 goto err;
 215         }
 216
 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);
 220
 221         backend_module_major = GET_ABI_MAJOR(backend_module_data->abi_version);
 222         backend_module_minor = GET_ABI_MINOR(backend_module_data->abi_version);
 223
 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);
 228
 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);
 232                 goto err;
 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);
 236                 goto err;
 237         }
 238
 239         if (!backend_module_data->init) {
 240                 TBM_ERR("Error: module does not supply init symbol.\n");
 241                 goto err;
 242         }
 243
 244         if (!backend_module_data->deinit)       {
 245                 TBM_ERR("Error: module does not supply deinit symbol.\n");
 246                 goto err;
 247         }
 248
 249         bufmgr_data = backend_module_data->init((tbm_bufmgr)module, &error);
 250         if (!bufmgr_data) {
 251                 TBM_ERR("Fail to init module(%s)\n", file);
 252                 goto err;
 253         }
 254
 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.");
 258                 goto err;
 259         }
 260
 261         if (!_tbm_backend_check_bufmgr_bo(module->bo_func)) {
 262                 TBM_ERR("Fail to check the bufmgr_bo symboles.");
 263                 goto err;
 264         }
 265
 266         module->module_data = module_data;
 267         module->backend_module_data = backend_module_data;
 268         module->bufmgr_data = bufmgr_data;
 269
 270         TBM_INFO("Success to load module(%s)\n", file);
 271
 272         return 1;
 273
 274 err:
 275         if (bufmgr_data)
 276                 module->backend_module_data->deinit(bufmgr_data);
 277         if (module_data)
 278                 dlclose(module_data);
 279
 280         return 0;
 281 }
 282
 283 static int
 284 _tbm_backend_load_bufmgr_module(tbm_module *module, int fd, const char *file)
 285 {
 286         char path[PATH_MAX] = {0, };
 287         TBMModuleVersionInfo *vers;
 288         TBMModuleData *initdata;
 289         ModuleInitProc init;
 290         void *module_data;
 291
 292         snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
 293
 294         module_data = dlopen(path, RTLD_LAZY);
 295         if (!module_data) {
 296                 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
 297                 return 0;
 298         }
 299
 300         initdata = dlsym(module_data, "tbmModuleData");
 301         if (!initdata) {
 302                 TBM_ERR("Error: module does not have data object.\n");
 303                 goto err;
 304         }
 305
 306         vers = initdata->vers;
 307         if (!vers) {
 308                 TBM_ERR("Error: module does not supply version information.\n");
 309                 goto err;
 310         }
 311
 312         init = initdata->init;
 313         if (!init) {
 314                 TBM_ERR("Error: module does not supply init symbol.\n");
 315                 goto err;
 316         }
 317
 318         if (!_check_version(vers)) {
 319                 TBM_ERR("Fail to check version.\n");
 320                 goto err;
 321         }
 322
 323         if (!init((tbm_bufmgr)module, fd)) {
 324                 TBM_ERR("Fail to init module(%s)\n", file);
 325                 goto err;
 326         }
 327
 328         if (!module->backend || !module->backend->priv) {
 329                 TBM_ERR("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file);
 330                 goto err;
 331         }
 332
 333         module->module_data = module_data;
 334
 335         TBM_DBG("Success to load module(%s)\n", file);
 336
 337         return 1;
 338
 339 err:
 340         dlclose(module_data);
 341         return 0;
 342 }
 343 /* LCOV_EXCL_STOP */
 344
 345 tbm_module *
 346 tbm_module_load(int fd)
 347 {
 348         tbm_module *module;
 349         struct dirent **namelist;
 350         int ret = 0, n;
 351
 352         module = calloc(1, sizeof(struct _tbm_module));
 353         if (!module) {
 354                 TBM_ERR("fail to allocate the memory");
 355                 return NULL;
 356         }
 357
 358         /* try to load the hal-tbm backend module */
 359         ret = _tbm_backend_load_hal_tbm(module);
 360         if (ret) {
 361                 module->type = TBM_MODULE_TYPE_HAL_TBM;
 362                 goto done;
 363         }
 364
 365 /* LCOV_EXCL_START */
 366         /* try to load the new backend module */
 367         ret = _tbm_backend_load_module(module, DEFAULT_LIB);
 368         if (ret) {
 369                 module->type = TBM_MODULE_TYPE_TBM_BACKEND;
 370                 goto done;
 371         }
 372
 373         /* try to load the old(deprecated) backend mdoule */
 374         ret = _tbm_backend_load_bufmgr_module(module, fd, DEFAULT_LIB);
 375         if (ret) {
 376                 module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
 377                 return module;
 378         }
 379
 380         /* load backend_module from configured path */
 381         n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort);
 382         if (n < 0) {
 383                 TBM_ERR("no files : %s\n", BUFMGR_MODULE_DIR);
 384                 tbm_module_unload(module);
 385                 return NULL;
 386         }
 387
 388         while (n--) {
 389                 if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) {
 390                         const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB);
 391
 392                         if (p && !strcmp(p, SUFFIX_LIB)) {
 393                                 ret = _tbm_backend_load_module(module, namelist[n]->d_name);
 394                                 if (ret)
 395                                         module->type = TBM_MODULE_TYPE_TBM_BACKEND;
 396                                 else {
 397                                         ret = _tbm_backend_load_bufmgr_module(module, fd, namelist[n]->d_name);
 398                                         module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
 399                                 }
 400                         }
 401                 }
 402
 403                 free(namelist[n]);
 404         }
 405
 406         free(namelist);
 407
 408         if (!ret) {
 409                 free(module);
 410                 module = NULL;
 411         }
 412 /* LCOV_EXCL_STOP */
 413
 414 done:
 415         return module;
 416 }
 417
 418 void
 419 tbm_module_unload(tbm_module *module)
 420 {
 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);
 426                 }
 427                 tbm_drm_helper_unset_tbm_master_fd();
 428                 tbm_drm_helper_unset_fd();
 429
 430                 hal_tbm_put_backend(module->hal_backend);
 431                 module->hal_backend = NULL;
 432                 module->hal_bufmgr = NULL;
 433                 module->use_hal_tbm = 0;
 434                 break;
 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;
 442
 443                 dlclose(module->module_data);
 444                 break;
 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;
 450
 451                 dlclose(module->module_data);
 452                 break;
 453         default:
 454                 TBM_ERR("Wrong module type:%d", module->type);
 455                 break;
 456 /* LCOV_EXCL_STOP */
 457         }
 458
 459         free(module);
 460 }
 461
 462 int
 463 tbm_module_get_capabilities(tbm_module *module, tbm_error_e *error)
 464 {
 465         int capabilities = 0;
 466         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 467
 468         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, TBM_BUFMGR_CAPABILITY_NONE, *error, TBM_ERROR_INVALID_PARAMETER);
 469
 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);
 473                 break;
 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);
 479
 480                 capabilities = module->bufmgr_func->bufmgr_get_capabilities(module->bufmgr_data, error);
 481                 break;
 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.");
 485
 486                 *error = TBM_ERROR_NOT_SUPPORTED;
 487                 break;
 488         default:
 489                 TBM_ERR("Wrong module type:%d", module->type);
 490                 *error = TBM_ERROR_INVALID_OPERATION;
 491                 break;
 492 /* LCOV_EXCL_STOP */
 493         }
 494
 495         return capabilities;
 496 }
 497
 498 tbm_error_e
 499 tbm_module_bind_native_display(tbm_module *module, void *native_display)
 500 {
 501         tbm_error_e error = TBM_ERROR_NONE;
 502         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 503         tbm_bufmgr_backend backend = NULL;
 504         int ret = 0;
 505
 506         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
 507
 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);
 512                         if (fd < 0) {
 513                                 TBM_ERR("error: module(%p) native_display(%p)\n", module, native_display);
 514                                 return TBM_ERROR_INVALID_OPERATION;
 515                         }
 516
 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);
 520                                 close(fd);
 521                                 return TBM_ERROR_INVALID_OPERATION;
 522                         }
 523                         TBM_INFO("tbm creates a wayland socket for authentication of drm_fd.");
 524
 525                         module->auth_wl_socket_created = 1;
 526                         module->auth_fd = fd;
 527                 } else {
 528                         TBM_INFO("tbm_module has no drm device.");
 529                         error = TBM_ERROR_NONE;
 530                 }
 531                 break;
 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);
 537
 538                 error = bufmgr_func->bufmgr_bind_native_display(module->bufmgr_data, (tbm_native_display *)native_display);
 539                 break;
 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);
 545
 546                 ret = backend->bufmgr_bind_native_display((tbm_bufmgr)module, native_display);
 547                 if (!ret)
 548                         error = TBM_ERROR_INVALID_OPERATION;
 549
 550                 break;
 551         default:
 552                 TBM_ERR("Wrong module type:%d", module->type);
 553                 error = TBM_ERROR_INVALID_OPERATION;
 554                 break;
 555 /* LCOV_EXCL_STOP */
 556         }
 557
 558         return error;
 559 }
 560
 561 tbm_error_e
 562 tbm_module_get_supported_formats(tbm_module *module, uint32_t **formats, uint32_t *num)
 563 {
 564         tbm_error_e error = TBM_ERROR_NONE;
 565         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 566         tbm_bufmgr_backend backend = NULL;
 567         int ret = 0;
 568
 569         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
 570
 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);
 574                 break;
 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);
 580
 581                 error = bufmgr_func->bufmgr_get_supported_formats(module->bufmgr_data, formats, num);
 582                 break;
 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);
 588
 589                 ret = backend->surface_supported_format(formats, num);
 590                 if (!ret)
 591                         error = TBM_ERROR_INVALID_OPERATION;
 592
 593                 break;
 594         default:
 595                 TBM_ERR("Wrong module type:%d", module->type);
 596                 error = TBM_ERROR_INVALID_OPERATION;
 597                 break;
 598 /* LCOV_EXCL_STOP */
 599         }
 600
 601         return error;
 602 }
 603
 604 tbm_error_e
 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)
 607 {
 608         tbm_error_e error = TBM_ERROR_NONE;
 609         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 610         tbm_bufmgr_backend backend = NULL;
 611         int ret = 0;
 612
 613         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
 614
 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);
 618                 break;
 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);
 624
 625                 error = bufmgr_func->bufmgr_get_plane_data(module->bufmgr_data, format, plane_idx, w, h, size, offset, pitch, bo_idx);
 626                 break;
 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);
 632
 633                 ret = backend->surface_get_plane_data(w, h, format, plane_idx, size, offset, pitch, bo_idx);
 634                 if (!ret)
 635                         error = TBM_ERROR_INVALID_OPERATION;
 636                 break;
 637         default:
 638                 TBM_ERR("Wrong module type:%d", module->type);
 639                 error = TBM_ERROR_INVALID_OPERATION;
 640                 break;
 641 /* LCOV_EXCL_STOP */
 642         }
 643
 644         return error;
 645 }
 646
 647 int
 648 tbm_module_support_surface_data(tbm_module *module)
 649 {
 650         tbm_error_e error = TBM_ERROR_NONE;
 651         tbm_surface_data *surface_data = NULL;
 652
 653         TBM_RETURN_VAL_IF_FAIL(module, 0);
 654
 655         // check once support_surface_data or not.
 656         if (module->check_surface_data) {
 657                 // return the value which already set.
 658                 return module->support_surface_data;
 659         }
 660
 661         // check this only once
 662         module->check_surface_data = 1;
 663
 664         if (module->type != TBM_MODULE_TYPE_HAL_TBM)
 665                 goto done;
 666
 667         // Assume that the hal-tbm supports the hal surface apis if tbm_module_alloc_surface_data succeed.
 668         surface_data = tbm_module_alloc_surface_data(module, 10, 10, TBM_FORMAT_ARGB8888, TBM_BO_DEFAULT, &error);
 669         if (!surface_data)
 670                 goto done;
 671         free(surface_data);
 672
 673         module->support_surface_data = 1;
 674
 675 done:
 676         return module->support_surface_data;
 677 }
 678
 679
 680 tbm_surface_data *
 681 tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int format, int flags, tbm_error_e *error)
 682 {
 683         tbm_surface_data *surface_data = NULL;
 684
 685         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 686         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 687
 688         surface_data = calloc(1, sizeof(struct _tbm_surface_data));
 689         if (!surface_data) {
 690                 TBM_ERR("memory allocation failed.");
 691                 *error = TBM_ERROR_OUT_OF_MEMORY;
 692                 return NULL;
 693         }
 694
 695         surface_data->hal_surface = hal_tbm_bufmgr_alloc_surface(module->hal_bufmgr,
 696                                                                                            (uint32_t)width,
 697                                                                                            (uint32_t)height,
 698                                                                                            (hal_tbm_format)format,
 699                                                                                            (hal_tbm_bo_memory_type)flags,
 700                                                                                            NULL,
 701                                                                                            0,
 702                                                                                            (hal_tbm_error *)error);
 703         if (!surface_data->hal_surface) {
 704                 if (*error != TBM_ERROR_NOT_SUPPORTED) // do not print the error message when it is not supported.
 705                         TBM_ERR("hal_tbm_bufmgr_alloc_surface failed.");
 706                 free(surface_data);
 707                 return NULL;
 708         }
 709
 710         surface_data->module = module;
 711
 712         return surface_data;
 713 }
 714
 715 tbm_surface_data *
 716 tbm_module_import_surface_data(tbm_module *module, int width, int height, int format, tbm_surface_buffer_data *buffer_data, tbm_error_e *error)
 717 {
 718         tbm_surface_data *surface_data = NULL;
 719
 720         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 721         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 722
 723         surface_data = calloc(1, sizeof(struct _tbm_surface_data));
 724         if (!surface_data) {
 725                 TBM_ERR("memory allocation failed.");
 726                 *error = TBM_ERROR_OUT_OF_MEMORY;
 727                 return NULL;
 728         }
 729
 730         surface_data->hal_surface = hal_tbm_bufmgr_import_surface(module->hal_bufmgr,
 731                                                                                         (uint32_t)width,
 732                                                                                         (uint32_t)height,
 733                                                                                         (hal_tbm_format)format,
 734                                                                                         (hal_tbm_surface_buffer_data *)buffer_data,
 735                                                                                         (hal_tbm_error *)error);
 736         if (!surface_data->hal_surface) {
 737                 TBM_ERR("hal_tbm_bufmgr_import_surface failed. width:%d height:%d format:%d error:%s",
 738                                 width, height, format, tbm_error_str(*error));
 739                 free(surface_data);
 740                 return NULL;
 741         }
 742
 743         surface_data->module = module;
 744
 745         return surface_data;
 746 }
 747
 748 tbm_bo_data *
 749 tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error)
 750 {
 751         tbm_bo_data *bo_data = NULL;
 752         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 753         tbm_bufmgr_backend backend = NULL;
 754
 755         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 756
 757         bo_data = calloc(1, sizeof(struct _tbm_bo_data));
 758         TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY);
 759
 760         switch (module->type) {
 761         case TBM_MODULE_TYPE_HAL_TBM:
 762                 bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error);
 763                 TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed);
 764                 break;
 765 /* LCOV_EXCL_START */
 766         case TBM_MODULE_TYPE_TBM_BACKEND:
 767                 bufmgr_func = module->bufmgr_func;
 768                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION);
 769                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 770
 771                 bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error);
 772                 TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed);
 773                 break;
 774         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 775                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 776
 777                 backend = module->backend;
 778                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION);
 779                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 780
 781                 bo_data->priv = (void *)backend->bo_alloc(bo, size, flags);
 782                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION);
 783
 784                 *error = TBM_ERROR_NONE;
 785                 break;
 786         default:
 787                 TBM_ERR("Wrong module type:%d", module->type);
 788                 *error = TBM_ERROR_INVALID_OPERATION;
 789                 goto failed;
 790                 break;
 791 /* LCOV_EXCL_STOP */
 792         }
 793
 794         bo_data->module = module;
 795
 796         return bo_data;
 797
 798 /* LCOV_EXCL_START */
 799 failed:
 800         if (bo_data)
 801                 free(bo_data);
 802
 803         return NULL;
 804 /* LCOV_EXCL_STOP */
 805 }
 806
 807 tbm_bo_data *
 808 tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width,
 809                                                 int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error)
 810 {
 811         tbm_bo_data *bo_data = NULL;
 812         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 813
 814         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 815
 816         bo_data = calloc(1, sizeof(struct _tbm_bo_data));
 817         TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY);
 818
 819         switch (module->type) {
 820         case TBM_MODULE_TYPE_HAL_TBM:
 821                 bo_data->hal_bo = hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr,
 822                                                                                         format, bo_idx, width, height, bpp,
 823                                                                                         (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error);
 824                 if (!bo_data->hal_bo)
 825                         goto failed;
 826                 break;
 827 /* LCOV_EXCL_START */
 828         case TBM_MODULE_TYPE_TBM_BACKEND:
 829                 bufmgr_func = module->bufmgr_func;
 830                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION);
 831                 if (!bufmgr_func->bufmgr_alloc_bo_with_format) {
 832                         *error = TBM_ERROR_NOT_SUPPORTED;
 833                         goto failed;
 834                 }
 835
 836                 bo_data->backend_bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error);
 837                 if (!bo_data->backend_bo_data)
 838                         goto failed;
 839                 break;
 840         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 841                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 842                 TBM_ERR("error: not supported tbm_module_alloc_bo_data_with_format.");
 843
 844                 *error = TBM_ERROR_NOT_SUPPORTED;
 845                 goto failed;
 846                 break;
 847         default:
 848                 TBM_ERR("Wrong module type:%d", module->type);
 849                 *error = TBM_ERROR_INVALID_OPERATION;
 850                 goto failed;
 851                 break;
 852 /* LCOV_EXCL_STOP */
 853         }
 854
 855         bo_data->module = module;
 856
 857         return bo_data;
 858
 859 /* LCOV_EXCL_START */
 860 failed:
 861         if (bo_data)
 862                 free(bo_data);
 863
 864         return NULL;
 865 /* LCOV_EXCL_STOP */
 866 }
 867
 868 tbm_bo_data *
 869 tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error)
 870 {
 871         tbm_bo_data *bo_data = NULL;
 872         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 873         tbm_bufmgr_backend backend = NULL;
 874
 875         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 876
 877         bo_data = calloc(1, sizeof(struct _tbm_bo_data));
 878         TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY);
 879
 880         switch (module->type) {
 881         case TBM_MODULE_TYPE_HAL_TBM:
 882                 bo_data->hal_bo = hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error);
 883                 TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed);
 884                 break;
 885 /* LCOV_EXCL_START */
 886         case TBM_MODULE_TYPE_TBM_BACKEND:
 887                 bufmgr_func = module->bufmgr_func;
 888                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION);
 889                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 890
 891                 bo_data->backend_bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error);
 892                 TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed);
 893                 break;
 894         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 895                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 896                 backend = module->backend;
 897                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION);
 898                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_import_fd, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 899
 900                 bo_data->priv = (void *)backend->bo_import_fd(bo, fd);
 901                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION);
 902
 903                 *error = TBM_ERROR_NONE;
 904                 break;
 905         default:
 906                 TBM_ERR("Wrong module type:%d", module->type);
 907                 *error = TBM_ERROR_INVALID_OPERATION;
 908                 goto failed;
 909                 break;
 910 /* LCOV_EXCL_STOP */
 911         }
 912
 913         bo_data->module = module;
 914
 915         return bo_data;
 916
 917 /* LCOV_EXCL_START */
 918 failed:
 919         if (bo_data)
 920                 free(bo_data);
 921
 922         return NULL;
 923 /* LCOV_EXCL_STOP */
 924 }
 925
 926 tbm_bo_data *
 927 tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error)
 928 {
 929         tbm_bo_data *bo_data = NULL;
 930         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 931         tbm_bufmgr_backend backend = NULL;
 932
 933         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 934
 935         bo_data = calloc(1, sizeof(struct _tbm_bo_data));
 936         TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data, failed, *error, TBM_ERROR_OUT_OF_MEMORY);
 937
 938         switch (module->type) {
 939         case TBM_MODULE_TYPE_HAL_TBM:
 940                 bo_data->hal_bo = hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error);
 941                 TBM_GOTO_VAL_IF_FAIL(bo_data->hal_bo, failed);
 942                 break;
 943 /* LCOV_EXCL_START */
 944         case TBM_MODULE_TYPE_TBM_BACKEND:
 945                 bufmgr_func = module->bufmgr_func;
 946                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func, failed, *error, TBM_ERROR_INVALID_OPERATION);
 947                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 948
 949                 bo_data->backend_bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error);
 950                 TBM_GOTO_VAL_IF_FAIL(bo_data->backend_bo_data, failed);
 951                 break;
 952         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 953                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 954                 backend = module->backend;
 955                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend, failed, *error, TBM_ERROR_INVALID_OPERATION);
 956                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(backend->bo_import, failed, *error, TBM_ERROR_NOT_SUPPORTED);
 957
 958                 bo_data->priv = (void *)backend->bo_import(bo, key);
 959                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data->priv, failed, *error, TBM_ERROR_INVALID_OPERATION);
 960
 961                 *error = TBM_ERROR_NONE;
 962                 break;
 963         default:
 964                 TBM_ERR("Wrong module type:%d", module->type);
 965                 *error = TBM_ERROR_INVALID_OPERATION;
 966                 goto failed;
 967                 break;
 968 /* LCOV_EXCL_STOP */
 969         }
 970
 971         bo_data->module = module;
 972
 973         return bo_data;
 974
 975 /* LCOV_EXCL_START */
 976 failed:
 977         if (bo_data)
 978                 free(bo_data);
 979
 980         return NULL;
 981 /* LCOV_EXCL_STOP */
 982 }
 983
 984 int
 985 tbm_module_compare_bo_data(tbm_module *module, tbm_bo_data *bo_data1, tbm_bo_data *bo_data2)
 986 {
 987         TBM_RETURN_VAL_IF_FAIL(module, 0);
 988
 989         switch (module->type) {
 990         case TBM_MODULE_TYPE_HAL_TBM:
 991                 return (bo_data1->hal_bo == bo_data2->hal_bo);
 992                 break;
 993 /* LCOV_EXCL_START */
 994         case TBM_MODULE_TYPE_TBM_BACKEND:
 995                 return (bo_data1->backend_bo_data == bo_data2->backend_bo_data);
 996                 break;
 997         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 998                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 999                 return (bo_data1->priv == bo_data2->priv);
1000                 break;
1001         default:
1002                 TBM_ERR("Wrong module type:%d", module->type);
1003                 break;
1004 /* LCOV_EXCL_STOP */
1005         }
1006
1007         return 0;
1008 }
1009
1010 void
1011 tbm_surface_data_free(tbm_surface_data *surface_data)
1012 {
1013         TBM_RETURN_IF_FAIL(surface_data);
1014         TBM_RETURN_IF_FAIL(surface_data->module);
1015         TBM_RETURN_IF_FAIL(surface_data->module->type == TBM_MODULE_TYPE_HAL_TBM);
1016
1017         surface_data->module = NULL;
1018
1019         hal_tbm_surface_free(surface_data->hal_surface);
1020         surface_data->hal_surface = NULL;
1021
1022         free(surface_data);
1023 }
1024
1025 tbm_error_e
1026 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)
1027 {
1028         tbm_error_e error;
1029
1030         TBM_RETURN_VAL_IF_FAIL(surface_data, TBM_ERROR_INVALID_PARAMETER);
1031         TBM_RETURN_VAL_IF_FAIL(surface_data->hal_surface, TBM_ERROR_NOT_SUPPORTED);
1032
1033         error = (tbm_error_e)hal_tbm_surface_get_plane_data(surface_data->hal_surface, plane_idx, size, offset, pitch, bo_idx);
1034         TBM_RETURN_VAL_IF_FAIL(error == TBM_ERROR_NONE, error);
1035
1036         return TBM_ERROR_NONE;
1037 }
1038
1039 tbm_bo_data **
1040 tbm_surface_data_get_bo_data_array(tbm_surface_data *surface_data, int *num_bos, int *memory_types, tbm_error_e *error)
1041 {
1042         tbm_bo_data **bo_data_array = NULL;
1043         hal_tbm_bo **hal_bos = NULL;
1044         int i;
1045
1046         TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1047         TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data->hal_surface, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1048
1049         hal_bos = hal_tbm_surface_get_bos(surface_data->hal_surface, num_bos, (hal_tbm_error *)error);
1050         TBM_RETURN_VAL_IF_FAIL(hal_bos, NULL);
1051
1052         bo_data_array = calloc(*num_bos, sizeof(tbm_bo_data *));
1053         TBM_RETURN_VAL_IF_FAIL(bo_data_array, NULL);
1054
1055         for (i = 0; i < *num_bos; i++) {
1056                 bo_data_array[i] = calloc(*num_bos, sizeof(struct _tbm_bo_data));
1057                 TBM_GOTO_VAL_SET_ERR_IF_FAIL(bo_data_array[i], failed, *error, TBM_ERROR_OUT_OF_MEMORY);
1058         }
1059
1060         for (i = 0; i < *num_bos; i++) {
1061                 bo_data_array[i]->hal_bo = hal_bos[i];
1062                 bo_data_array[i]->module = surface_data->module;
1063         }
1064
1065         // get memory_types(bo flags)
1066         *memory_types = tbm_bo_data_get_memory_types(bo_data_array[0], error);
1067         TBM_GOTO_VAL_IF_FAIL(*error == TBM_ERROR_NONE, failed);
1068
1069         return bo_data_array;
1070
1071 /* LCOV_EXCL_START */
1072 failed:
1073         for (i = 0; i < *num_bos; i++) {
1074                 if (bo_data_array[i])
1075                         free(bo_data_array[i]);
1076         }
1077         free(bo_data_array);
1078
1079         return NULL;
1080 /* LCOV_EXCL_STOP */
1081 }
1082
1083 tbm_surface_buffer_data *
1084 tbm_surface_data_export(tbm_surface_data *surface_data, tbm_error_e *error)
1085 {
1086         tbm_surface_buffer_data *buffer_data;
1087
1088         TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1089         TBM_RETURN_VAL_SET_ERR_IF_FAIL(surface_data->hal_surface, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1090
1091         buffer_data = (tbm_surface_buffer_data *)hal_tbm_surface_export((hal_tbm_surface *)surface_data->hal_surface,
1092                                                                                                                                         (hal_tbm_error *)error);
1093         TBM_RETURN_VAL_IF_FAIL(buffer_data, NULL);
1094
1095         return buffer_data;
1096 }
1097
1098 void
1099 tbm_bo_data_free(tbm_bo_data *bo_data, int get_from_surface_data)
1100 {
1101         tbm_module *module = NULL;
1102         tbm_backend_bo_func *bo_func = NULL;
1103         tbm_bufmgr_backend backend = NULL;
1104
1105         TBM_RETURN_IF_FAIL(bo_data);
1106         TBM_RETURN_IF_FAIL(bo_data->module);
1107
1108         module = bo_data->module;
1109
1110         switch (module->type) {
1111         case TBM_MODULE_TYPE_HAL_TBM:
1112                 // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api.
1113                 if (!get_from_surface_data) {
1114                         hal_tbm_bo_free(bo_data->hal_bo);
1115                         bo_data->hal_bo = NULL;
1116                 }
1117                 break;
1118 /* LCOV_EXCL_START */
1119         case TBM_MODULE_TYPE_TBM_BACKEND:
1120                 bo_func = module->bo_func;
1121                 TBM_RETURN_IF_FAIL(bo_func);
1122                 TBM_RETURN_IF_FAIL(bo_func->bo_free);
1123
1124                 bo_func->bo_free(bo_data->backend_bo_data);
1125                 bo_data->backend_bo_data = NULL;
1126                 break;
1127         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1128                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1129                 backend = module->backend;
1130                 TBM_RETURN_IF_FAIL(backend);
1131                 TBM_RETURN_IF_FAIL(backend->bo_free);
1132
1133                 backend->bo_free(bo_data->priv);
1134                 bo_data->priv = NULL;
1135                 break;
1136         default:
1137                 TBM_ERR("Wrong module type:%d", module->type);
1138                 break;
1139 /* LCOV_EXCL_STOP */
1140         }
1141
1142         bo_data->module = NULL;
1143         free(bo_data);
1144 }
1145
1146 int
1147 tbm_bo_data_get_size(tbm_bo_data *bo_data, tbm_error_e *error)
1148 {
1149         tbm_module *module = NULL;
1150         tbm_backend_bo_func *bo_func = NULL;
1151         tbm_bufmgr_backend backend = NULL;
1152         int size = 0;
1153
1154         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1155         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1156
1157         module = bo_data->module;
1158
1159         switch (module->type) {
1160         case TBM_MODULE_TYPE_HAL_TBM:
1161                 size = hal_tbm_bo_get_size(bo_data->hal_bo, (hal_tbm_error *)error);
1162                 break;
1163 /* LCOV_EXCL_START */
1164         case TBM_MODULE_TYPE_TBM_BACKEND:
1165                 bo_func = module->bo_func;
1166                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1167                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1168
1169                 size = bo_func->bo_get_size(bo_data->backend_bo_data, error);
1170                 break;
1171         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1172                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1173                 backend = module->backend;
1174                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1175                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1176
1177                 size = backend->bo_size(bo_data->priv);
1178                 if (size == 0)
1179                         *error = TBM_ERROR_INVALID_OPERATION;
1180                 else
1181                         *error = TBM_ERROR_NONE;
1182                 break;
1183         default:
1184                 TBM_ERR("Wrong module type:%d", module->type);
1185                 *error = TBM_ERROR_INVALID_OPERATION;
1186                 break;
1187 /* LCOV_EXCL_STOP */
1188         }
1189
1190         return size;
1191 }
1192
1193 int
1194 tbm_bo_data_get_memory_types(tbm_bo_data *bo_data, tbm_error_e *error)
1195 {
1196         tbm_module *module = NULL;
1197         tbm_backend_bo_func *bo_func = NULL;
1198         tbm_bufmgr_backend backend = NULL;
1199         int memory_types = TBM_BO_DEFAULT;
1200
1201         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1202         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1203
1204         module = bo_data->module;
1205
1206         switch (module->type) {
1207         case TBM_MODULE_TYPE_HAL_TBM:
1208                 memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types(bo_data->hal_bo, (hal_tbm_error *)error);
1209                 break;
1210 /* LCOV_EXCL_START */
1211         case TBM_MODULE_TYPE_TBM_BACKEND:
1212                 bo_func = module->bo_func;
1213                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1214                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_memory_types, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1215
1216                 memory_types = bo_func->bo_get_memory_types(bo_data->backend_bo_data, error);
1217                 break;
1218         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1219                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1220                 backend = module->backend;
1221                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1222                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_flags, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1223
1224                 memory_types = backend->bo_get_flags(bo_data->priv);
1225                 *error = TBM_ERROR_NONE;
1226                 break;
1227         default:
1228                 TBM_ERR("Wrong module type:%d", module->type);
1229                 *error = TBM_ERROR_INVALID_OPERATION;
1230                 break;
1231 /* LCOV_EXCL_STOP */
1232         }
1233
1234         return memory_types;
1235 }
1236
1237 tbm_bo_handle
1238 tbm_bo_data_get_handle(tbm_bo_data *bo_data, int device, tbm_error_e *error)
1239 {
1240         tbm_module *module = NULL;
1241         tbm_backend_bo_func *bo_func = NULL;
1242         tbm_bufmgr_backend backend = NULL;
1243         tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
1244         hal_tbm_bo_handle hbo_handle;
1245
1246         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1247         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1248
1249         module = bo_data->module;
1250
1251         switch (module->type) {
1252         case TBM_MODULE_TYPE_HAL_TBM:
1253                 hbo_handle = hal_tbm_bo_get_handle(bo_data->hal_bo, device, (hal_tbm_error *)error);
1254                 if (hbo_handle.ptr != NULL)
1255                         memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
1256                 break;
1257 /* LCOV_EXCL_START */
1258         case TBM_MODULE_TYPE_TBM_BACKEND:
1259                 bo_func = module->bo_func;
1260                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1261                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1262
1263                 bo_handle = bo_func->bo_get_handle(bo_data->backend_bo_data, device, error);
1264                 break;
1265         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1266                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1267                 backend = module->backend;
1268                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1269                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1270
1271                 bo_handle = backend->bo_get_handle(bo_data->priv, device);
1272                 if (!bo_handle.ptr)
1273                         *error = TBM_ERROR_INVALID_OPERATION;
1274                 else
1275                         *error = TBM_ERROR_NONE;
1276                 break;
1277         default:
1278                 TBM_ERR("Wrong module type:%d", module->type);
1279                 bo_handle.ptr = NULL;
1280                 *error = TBM_ERROR_INVALID_OPERATION;
1281                 break;
1282 /* LCOV_EXCL_STOP */
1283         }
1284
1285         return bo_handle;
1286 }
1287
1288 tbm_bo_handle
1289 tbm_bo_data_map(tbm_bo_data *bo_data, int device, int opt, tbm_error_e *error)
1290 {
1291         tbm_module *module = NULL;
1292         tbm_backend_bo_func *bo_func = NULL;
1293         tbm_bufmgr_backend backend = NULL;
1294         tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
1295         hal_tbm_bo_handle hbo_handle = (hal_tbm_bo_handle)NULL;
1296
1297         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1298         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1299
1300         module = bo_data->module;
1301
1302         switch (module->type) {
1303         case TBM_MODULE_TYPE_HAL_TBM:
1304                 hbo_handle = hal_tbm_bo_map(bo_data->hal_bo, device, opt, (hal_tbm_error *)error);
1305                 if (hbo_handle.ptr != NULL)
1306                         memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
1307                 break;
1308 /* LCOV_EXCL_START */
1309         case TBM_MODULE_TYPE_TBM_BACKEND:
1310                 bo_func = module->bo_func;
1311                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1312                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1313
1314                 bo_handle = bo_func->bo_map(bo_data->backend_bo_data, device, opt, error);
1315                 break;
1316         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1317                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1318                 backend = module->backend;
1319                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1320                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1321
1322                 bo_handle = backend->bo_map(bo_data->priv, device, opt);
1323                 if (!bo_handle.ptr)
1324                         *error = TBM_ERROR_INVALID_OPERATION;
1325                 else
1326                         *error = TBM_ERROR_NONE;
1327                 break;
1328         default:
1329                 TBM_ERR("Wrong module type:%d", module->type);
1330                 bo_handle.ptr = NULL;
1331                 *error = TBM_ERROR_INVALID_OPERATION;
1332                 break;
1333 /* LCOV_EXCL_STOP */
1334         }
1335
1336         return bo_handle;
1337 }
1338
1339 tbm_error_e
1340 tbm_bo_data_unmap(tbm_bo_data *bo_data)
1341 {
1342         tbm_module *module = NULL;
1343         tbm_backend_bo_func *bo_func = NULL;
1344         tbm_bufmgr_backend backend = NULL;
1345         tbm_error_e error;
1346         int ret = 0;
1347
1348         TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1349         TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1350
1351         module = bo_data->module;
1352
1353         switch (module->type) {
1354         case TBM_MODULE_TYPE_HAL_TBM:
1355                 error = (hal_tbm_error)hal_tbm_bo_unmap(bo_data->hal_bo);
1356                 break;
1357 /* LCOV_EXCL_START */
1358         case TBM_MODULE_TYPE_TBM_BACKEND:
1359                 bo_func = module->bo_func;
1360                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1361                 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1362
1363                 error = bo_func->bo_unmap(bo_data->backend_bo_data);
1364                 break;
1365         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1366                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1367                 backend = module->backend;
1368                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1369                 TBM_RETURN_VAL_IF_FAIL(backend->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1370
1371                 ret = backend->bo_unmap(bo_data->priv);
1372                 if (!ret)
1373                         error = TBM_ERROR_INVALID_OPERATION;
1374                 else
1375                         error = TBM_ERROR_NONE;
1376                 break;
1377         default:
1378                 TBM_ERR("Wrong module type:%d", module->type);
1379                 error = TBM_ERROR_INVALID_OPERATION;
1380                 break;
1381 /* LCOV_EXCL_STOP */
1382         }
1383
1384         return error;
1385 }
1386
1387 tbm_error_e
1388 tbm_bo_data_lock(tbm_bo_data *bo_data, int device, int opt)
1389 {
1390         tbm_module *module = NULL;
1391         tbm_backend_bo_func *bo_func = NULL;
1392         tbm_bufmgr_backend backend = NULL;
1393         tbm_error_e error;
1394         int ret = 0;
1395
1396         TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1397         TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1398
1399         module = bo_data->module;
1400
1401         switch (module->type) {
1402         case TBM_MODULE_TYPE_HAL_TBM:
1403                 error = (tbm_error_e)hal_tbm_bo_lock(bo_data->hal_bo, device, opt);
1404                 break;
1405 /* LCOV_EXCL_START */
1406         case TBM_MODULE_TYPE_TBM_BACKEND:
1407                 bo_func = module->bo_func;
1408                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1409                 if (!bo_func->bo_lock)
1410                         return TBM_ERROR_NOT_SUPPORTED;
1411
1412                 error = bo_func->bo_lock(bo_data->backend_bo_data, device, opt);
1413                 break;
1414         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1415                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1416                 backend = module->backend;
1417                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1418                 if (!backend->bo_unmap)
1419                         return TBM_ERROR_NOT_SUPPORTED;
1420
1421                 ret = backend->bo_lock(bo_data->priv, device, opt);
1422                 if (!ret)
1423                         error = TBM_ERROR_INVALID_OPERATION;
1424                 else
1425                         error = TBM_ERROR_NONE;
1426                 break;
1427         default:
1428                 TBM_ERR("Wrong module type:%d", module->type);
1429                 error = TBM_ERROR_INVALID_OPERATION;
1430                 break;
1431 /* LCOV_EXCL_STOP */
1432         }
1433
1434         return error;
1435 }
1436
1437 tbm_error_e
1438 tbm_bo_data_unlock(tbm_bo_data *bo_data)
1439 {
1440         tbm_module *module = NULL;
1441         tbm_backend_bo_func *bo_func = NULL;
1442         tbm_bufmgr_backend backend = NULL;
1443         tbm_error_e error;
1444
1445         TBM_RETURN_VAL_IF_FAIL(bo_data, TBM_ERROR_INVALID_PARAMETER);
1446         TBM_RETURN_VAL_IF_FAIL(bo_data->module, TBM_ERROR_INVALID_PARAMETER);
1447
1448         module = bo_data->module;
1449
1450         switch (module->type) {
1451         case TBM_MODULE_TYPE_HAL_TBM:
1452                 error = (tbm_error_e)hal_tbm_bo_unlock(bo_data->hal_bo);
1453                 break;
1454 /* LCOV_EXCL_START */
1455         case TBM_MODULE_TYPE_TBM_BACKEND:
1456                 bo_func = module->bo_func;
1457                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1458                 if (!bo_func->bo_unlock)
1459                         return TBM_ERROR_NOT_SUPPORTED;
1460
1461                 error = bo_func->bo_unlock(bo_data->backend_bo_data);
1462                 break;
1463         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1464                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1465                 backend = module->backend;
1466                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1467                 if (!backend->bo_unlock)
1468                         return TBM_ERROR_NOT_SUPPORTED;
1469
1470                 backend->bo_unlock(bo_data->priv);
1471                 error = TBM_ERROR_NONE;
1472                 break;
1473         default:
1474                 TBM_ERR("Wrong module type:%d", module->type);
1475                 error = TBM_ERROR_INVALID_OPERATION;
1476                 break;
1477 /* LCOV_EXCL_STOP */
1478         }
1479
1480         return error;
1481 }
1482
1483 tbm_fd
1484 tbm_bo_data_export_fd(tbm_bo_data *bo_data, tbm_error_e *error)
1485 {
1486         tbm_module *module = NULL;
1487         tbm_backend_bo_func *bo_func = NULL;
1488         tbm_bufmgr_backend backend = NULL;
1489         tbm_fd fd;
1490
1491         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, -1, *error, TBM_ERROR_INVALID_PARAMETER);
1492         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, -1, *error, TBM_ERROR_INVALID_PARAMETER);
1493
1494         module = bo_data->module;
1495
1496         switch (module->type) {
1497         case TBM_MODULE_TYPE_HAL_TBM:
1498                 fd = (hal_tbm_fd)hal_tbm_bo_export_fd(bo_data->hal_bo, (hal_tbm_error *)error);
1499                 break;
1500 /* LCOV_EXCL_START */
1501         case TBM_MODULE_TYPE_TBM_BACKEND:
1502                 bo_func = module->bo_func;
1503                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, -1, *error, TBM_ERROR_INVALID_OPERATION);
1504                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1505
1506                 fd = bo_func->bo_export_fd(bo_data->backend_bo_data, error);
1507                 break;
1508         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1509                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1510                 backend = module->backend;
1511                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, -1, *error, TBM_ERROR_INVALID_OPERATION);
1512                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1513
1514                 fd = backend->bo_export_fd(bo_data->priv);
1515                 if (fd < 0)
1516                         *error = TBM_ERROR_INVALID_OPERATION;
1517                 else
1518                         *error = TBM_ERROR_NONE;
1519                 break;
1520         default:
1521                 TBM_ERR("Wrong module type:%d", module->type);
1522                 fd = -1;
1523                 *error = TBM_ERROR_INVALID_OPERATION;
1524                 break;
1525 /* LCOV_EXCL_STOP */
1526         }
1527
1528         return fd;
1529 }
1530
1531 tbm_key
1532 tbm_bo_data_export_key(tbm_bo_data *bo_data, tbm_error_e *error)
1533 {
1534         tbm_module *module = NULL;
1535         tbm_backend_bo_func *bo_func = NULL;
1536         tbm_bufmgr_backend backend = NULL;
1537         tbm_key ret;
1538
1539         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1540         TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_data->module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1541
1542         module = bo_data->module;
1543
1544         switch (module->type) {
1545         case TBM_MODULE_TYPE_HAL_TBM:
1546                 ret = (hal_tbm_fd)hal_tbm_bo_export_key(bo_data->hal_bo, (hal_tbm_error *)error);
1547                 break;
1548 /* LCOV_EXCL_START */
1549         case TBM_MODULE_TYPE_TBM_BACKEND:
1550                 bo_func = module->bo_func;
1551                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1552                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_key, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1553
1554                 ret = bo_func->bo_export_key(bo_data->backend_bo_data, error);
1555                 break;
1556         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1557                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1558                 backend = module->backend;
1559                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1560                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1561
1562                 ret = backend->bo_export(bo_data->priv);
1563                 if (!ret)
1564                         *error = TBM_ERROR_INVALID_OPERATION;
1565                 else
1566                         *error = TBM_ERROR_NONE;
1567                 break;
1568         default:
1569                 TBM_ERR("Wrong module type:%d", module->type);
1570                 ret = -1;
1571                 *error = TBM_ERROR_INVALID_OPERATION;
1572                 break;
1573 /* LCOV_EXCL_STOP */
1574         }
1575
1576         return ret;
1577 }