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 tbm_backend_surface_data *
 648 tbm_module_alloc_surface_data(tbm_module *module, int width, int height, int format, int flags, tbm_error_e *error)
 649 {
 650         tbm_backend_surface_data *surface_data = NULL;
 651
 652         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 653         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module->type == TBM_MODULE_TYPE_HAL_TBM, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 654
 655         surface_data = calloc(1, sizeof(struct _tbm_backend_surface_data));
 656         if (!surface_data) {
 657                 TBM_ERR("memory allocation failed.");
 658                 *error = TBM_ERROR_OUT_OF_MEMORY;
 659                 return NULL;
 660         }
 661
 662         surface_data->hal_surface = hal_tbm_bufmgr_alloc_surface(module->hal_bufmgr,
 663                                                                                            (uint32_t)width,
 664                                                                                            (uint32_t)height,
 665                                                                                            (hal_tbm_format)format,
 666                                                                                            (hal_tbm_bo_memory_type)flags,
 667                                                                                            NULL,
 668                                                                                            0,
 669                                                                                            (hal_tbm_error *)error);
 670         if (!surface_data->hal_surface) {
 671                 TBM_ERR("hal_tbm_bufmgr_alloc_surface failed.");
 672                 *error = TBM_ERROR_INVALID_OPERATION;
 673                 free(surface_data);
 674                 return NULL;
 675         }
 676
 677         surface_data->module = module;
 678
 679         return surface_data;
 680 }
 681
 682 tbm_backend_bo_data *
 683 tbm_module_alloc_bo_data(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error)
 684 {
 685         tbm_backend_bo_data *bo_data = NULL;
 686         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 687         tbm_bufmgr_backend backend = NULL;
 688
 689         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 690
 691         switch (module->type) {
 692         case TBM_MODULE_TYPE_HAL_TBM:
 693                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error);
 694                 break;
 695 /* LCOV_EXCL_START */
 696         case TBM_MODULE_TYPE_TBM_BACKEND:
 697                 bufmgr_func = module->bufmgr_func;
 698                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 699                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 700
 701                 bo_data = module->bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error);
 702                 break;
 703         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 704                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 705                 backend = module->backend;
 706                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 707                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 708
 709                 bo_data = (void *)module->backend->bo_alloc(bo, size, flags);
 710                 *error = TBM_ERROR_NONE;
 711                 break;
 712         default:
 713                 TBM_ERR("Wrong module type:%d", module->type);
 714                 *error = TBM_ERROR_INVALID_OPERATION;
 715                 break;
 716 /* LCOV_EXCL_STOP */
 717         }
 718
 719         return bo_data;
 720 }
 721
 722 tbm_backend_bo_data *
 723 tbm_module_alloc_bo_data_with_format(tbm_module *module, int format, int bo_idx, int width,
 724                                                 int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error)
 725 {
 726         tbm_backend_bo_data *bo_data = NULL;
 727         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 728
 729         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 730
 731         switch (module->type) {
 732         case TBM_MODULE_TYPE_HAL_TBM:
 733                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr,
 734                                                                                         format, bo_idx, width, height, bpp,
 735                                                                                         (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error);
 736                 break;
 737 /* LCOV_EXCL_START */
 738         case TBM_MODULE_TYPE_TBM_BACKEND:
 739                 bufmgr_func = module->bufmgr_func;
 740                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 741                 if (!bufmgr_func->bufmgr_alloc_bo_with_format) {
 742                         *error = TBM_ERROR_NOT_SUPPORTED;
 743                         return NULL;
 744                 }
 745
 746                 bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error);
 747                 break;
 748         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 749                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 750                 TBM_ERR("error: not supported tbm_bufmgr_internal_alloc_bo_with_format.");
 751
 752                 *error = TBM_ERROR_NOT_SUPPORTED;
 753                 break;
 754         default:
 755                 TBM_ERR("Wrong module type:%d", module->type);
 756                 *error = TBM_ERROR_INVALID_OPERATION;
 757                 break;
 758 /* LCOV_EXCL_STOP */
 759         }
 760
 761         return bo_data;
 762 }
 763
 764
 765 tbm_backend_bo_data *
 766 tbm_module_import_bo_data_with_fd(tbm_module *module, tbm_bo bo, tbm_fd fd, tbm_error_e *error)
 767 {
 768         tbm_backend_bo_data *bo_data = NULL;
 769         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 770         tbm_bufmgr_backend backend = NULL;
 771
 772         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 773
 774         switch (module->type) {
 775         case TBM_MODULE_TYPE_HAL_TBM:
 776                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_fd(module->hal_bufmgr, (hal_tbm_fd)fd, (hal_tbm_error *)error);
 777                 break;
 778 /* LCOV_EXCL_START */
 779         case TBM_MODULE_TYPE_TBM_BACKEND:
 780                 bufmgr_func = module->bufmgr_func;
 781                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 782                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 783
 784                 bo_data = bufmgr_func->bufmgr_import_fd(module->bufmgr_data, fd, error);
 785                 break;
 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_import_fd, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 791
 792                 bo_data = (void *)backend->bo_import_fd(bo, fd);
 793                 if (!bo_data)
 794                         *error = TBM_ERROR_INVALID_OPERATION;
 795                 else
 796                         *error = TBM_ERROR_NONE;
 797                 break;
 798         default:
 799                 TBM_ERR("Wrong module type:%d", module->type);
 800                 *error = TBM_ERROR_INVALID_OPERATION;
 801                 break;
 802 /* LCOV_EXCL_STOP */
 803         }
 804
 805         return bo_data;
 806 }
 807
 808 tbm_backend_bo_data *
 809 tbm_module_import_bo_data_with_key(tbm_module *module, tbm_bo bo, tbm_key key, tbm_error_e *error)
 810 {
 811         tbm_backend_bo_data *bo_data = NULL;
 812         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 813         tbm_bufmgr_backend backend = NULL;
 814
 815         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 816
 817         switch (module->type) {
 818         case TBM_MODULE_TYPE_HAL_TBM:
 819                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_import_key(module->hal_bufmgr, key, (hal_tbm_error *)error);
 820                 break;
 821 /* LCOV_EXCL_START */
 822         case TBM_MODULE_TYPE_TBM_BACKEND:
 823                 bufmgr_func = module->bufmgr_func;
 824                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 825                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_import_key, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 826
 827                 bo_data = bufmgr_func->bufmgr_import_key(module->bufmgr_data, key, error);
 828                 break;
 829         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 830                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 831                 backend = module->backend;
 832                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 833                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_import, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 834
 835                 bo_data = (void *)backend->bo_import(bo, key);
 836                 if (!bo_data)
 837                         *error = TBM_ERROR_INVALID_OPERATION;
 838                 else
 839                         *error = TBM_ERROR_NONE;
 840                 break;
 841         default:
 842                 TBM_ERR("Wrong module type:%d", module->type);
 843                 *error = TBM_ERROR_INVALID_OPERATION;
 844                 break;
 845 /* LCOV_EXCL_STOP */
 846         }
 847
 848         return bo_data;
 849 }
 850
 851 void
 852 tbm_module_bo_free(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int get_from_hal_surface)
 853 {
 854         tbm_backend_bo_func *bo_func = NULL;
 855         tbm_bufmgr_backend backend = NULL;
 856
 857         TBM_RETURN_IF_FAIL(module);
 858         TBM_RETURN_IF_FAIL(bo);
 859         TBM_RETURN_IF_FAIL(bo_data);
 860
 861         switch (module->type) {
 862         case TBM_MODULE_TYPE_HAL_TBM:
 863                 // call hal_tbm_bo_free when bo is created by tbm_bo_alloc api.
 864                 if (!get_from_hal_surface)
 865                         hal_tbm_bo_free(bo_data);
 866                 break;
 867 /* LCOV_EXCL_START */
 868         case TBM_MODULE_TYPE_TBM_BACKEND:
 869                 bo_func = module->bo_func;
 870                 TBM_RETURN_IF_FAIL(bo_func);
 871                 TBM_RETURN_IF_FAIL(bo_func->bo_free);
 872
 873                 bo_func->bo_free(bo_data);
 874                 break;
 875         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 876                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 877                 backend = module->backend;
 878                 TBM_RETURN_IF_FAIL(backend);
 879                 TBM_RETURN_IF_FAIL(backend->bo_free);
 880
 881                 backend->bo_free(bo);
 882                 break;
 883         default:
 884                 TBM_ERR("Wrong module type:%d", module->type);
 885                 break;
 886 /* LCOV_EXCL_STOP */
 887         }
 888 }
 889
 890 int
 891 tbm_module_bo_get_size(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error)
 892 {
 893         tbm_backend_bo_func *bo_func = NULL;
 894         tbm_bufmgr_backend backend = NULL;
 895         int size = 0;
 896
 897         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
 898
 899         switch (module->type) {
 900         case TBM_MODULE_TYPE_HAL_TBM:
 901                 size = hal_tbm_bo_get_size((hal_tbm_bo *)bo_data, (hal_tbm_error *)error);
 902                 break;
 903 /* LCOV_EXCL_START */
 904         case TBM_MODULE_TYPE_TBM_BACKEND:
 905                 bo_func = module->bo_func;
 906                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
 907                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
 908
 909                 size = bo_func->bo_get_size(bo_data, error);
 910                 break;
 911         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 912                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 913                 backend = module->backend;
 914                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
 915                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_size, 0, *error, TBM_ERROR_NOT_SUPPORTED);
 916
 917                 size = backend->bo_size(bo);
 918                 if (size == 0)
 919                         *error = TBM_ERROR_INVALID_OPERATION;
 920                 else
 921                         *error = TBM_ERROR_NONE;
 922                 break;
 923         default:
 924                 TBM_ERR("Wrong module type:%d", module->type);
 925                 *error = TBM_ERROR_INVALID_OPERATION;
 926                 break;
 927 /* LCOV_EXCL_STOP */
 928         }
 929
 930         return size;
 931 }
 932
 933 int
 934 tbm_module_bo_get_memory_types(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error)
 935 {
 936         tbm_backend_bo_func *bo_func = NULL;
 937         tbm_bufmgr_backend backend = NULL;
 938         int memory_types = TBM_BO_DEFAULT;
 939
 940         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
 941
 942         switch (module->type) {
 943         case TBM_MODULE_TYPE_HAL_TBM:
 944                 memory_types = (tbm_bo_memory_type)hal_tbm_bo_get_memory_types((hal_tbm_bo *)bo_data, (hal_tbm_error *)error);
 945                 break;
 946 /* LCOV_EXCL_START */
 947         case TBM_MODULE_TYPE_TBM_BACKEND:
 948                 bo_func = module->bo_func;
 949                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
 950                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_memory_types, 0, *error, TBM_ERROR_NOT_SUPPORTED);
 951
 952                 memory_types = bo_func->bo_get_memory_types(bo_data, error);
 953                 break;
 954         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 955                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 956                 backend = module->backend;
 957                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
 958                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_flags, 0, *error, TBM_ERROR_NOT_SUPPORTED);
 959
 960                 memory_types = backend->bo_get_flags(bo);
 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                 break;
 967 /* LCOV_EXCL_STOP */
 968         }
 969
 970         return memory_types;
 971 }
 972
 973 tbm_bo_handle
 974 tbm_module_bo_get_handle(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, tbm_error_e *error)
 975 {
 976         tbm_backend_bo_func *bo_func = NULL;
 977         tbm_bufmgr_backend backend = NULL;
 978         tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
 979         hal_tbm_bo_handle hbo_handle;
 980
 981         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 982
 983         switch (module->type) {
 984         case TBM_MODULE_TYPE_HAL_TBM:
 985                 hbo_handle = hal_tbm_bo_get_handle((hal_tbm_bo *)bo_data, device, (hal_tbm_error *)error);
 986                 if (hbo_handle.ptr != NULL)
 987                         memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
 988                 break;
 989 /* LCOV_EXCL_START */
 990         case TBM_MODULE_TYPE_TBM_BACKEND:
 991                 bo_func = module->bo_func;
 992                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
 993                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 994
 995                 bo_handle = bo_func->bo_get_handle(bo_data, device, error);
 996                 break;
 997         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 998                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 999                 backend = module->backend;
1000                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1001                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_get_handle, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1002
1003                 bo_handle = backend->bo_get_handle(bo, device);
1004                 if (!bo_handle.ptr)
1005                         *error = TBM_ERROR_INVALID_OPERATION;
1006                 else
1007                         *error = TBM_ERROR_NONE;
1008                 break;
1009         default:
1010                 TBM_ERR("Wrong module type:%d", module->type);
1011                 bo_handle.ptr = NULL;
1012                 *error = TBM_ERROR_INVALID_OPERATION;
1013                 break;
1014 /* LCOV_EXCL_STOP */
1015         }
1016
1017         return bo_handle;
1018 }
1019
1020 tbm_bo_handle
1021 tbm_module_bo_map(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt, tbm_error_e *error)
1022 {
1023         tbm_backend_bo_func *bo_func = NULL;
1024         tbm_bufmgr_backend backend = NULL;
1025         tbm_bo_handle bo_handle = (tbm_bo_handle)NULL;
1026         hal_tbm_bo_handle hbo_handle;
1027
1028         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_PARAMETER);
1029
1030         switch (module->type) {
1031         case TBM_MODULE_TYPE_HAL_TBM:
1032                 hbo_handle = hal_tbm_bo_map((hal_tbm_bo *)bo_data, device, opt, (hal_tbm_error *)error);
1033                 if (hbo_handle.ptr != NULL)
1034                         memcpy(&bo_handle.ptr, &hbo_handle.ptr, sizeof(tbm_bo_handle));
1035                 break;
1036 /* LCOV_EXCL_START */
1037         case TBM_MODULE_TYPE_TBM_BACKEND:
1038                 bo_func = module->bo_func;
1039                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1040                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1041
1042                 bo_handle = bo_func->bo_map(bo_data, device, opt, error);
1043                 break;
1044         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1045                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1046                 backend = module->backend;
1047                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, (tbm_bo_handle)NULL, *error, TBM_ERROR_INVALID_OPERATION);
1048                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_map, (tbm_bo_handle)NULL, *error, TBM_ERROR_NOT_SUPPORTED);
1049
1050                 bo_handle = backend->bo_map(bo, device, opt);
1051                 if (!bo_handle.ptr)
1052                         *error = TBM_ERROR_INVALID_OPERATION;
1053                 else
1054                         *error = TBM_ERROR_NONE;
1055                 break;
1056         default:
1057                 TBM_ERR("Wrong module type:%d", module->type);
1058                 bo_handle.ptr = NULL;
1059                 *error = TBM_ERROR_INVALID_OPERATION;
1060                 break;
1061 /* LCOV_EXCL_STOP */
1062         }
1063
1064         return bo_handle;
1065 }
1066
1067 tbm_error_e
1068 tbm_module_bo_unmap(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data)
1069 {
1070         tbm_backend_bo_func *bo_func = NULL;
1071         tbm_bufmgr_backend backend = NULL;
1072         tbm_error_e error;
1073         int ret = 0;
1074
1075         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
1076
1077         switch (module->type) {
1078         case TBM_MODULE_TYPE_HAL_TBM:
1079                 error = (hal_tbm_error)hal_tbm_bo_unmap((hal_tbm_bo *)bo_data);
1080                 break;
1081 /* LCOV_EXCL_START */
1082         case TBM_MODULE_TYPE_TBM_BACKEND:
1083                 bo_func = module->bo_func;
1084                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1085                 TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1086
1087                 error = bo_func->bo_unmap(bo->bo_data);
1088                 break;
1089         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1090                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1091                 backend = module->backend;
1092                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1093                 TBM_RETURN_VAL_IF_FAIL(backend->bo_unmap, TBM_ERROR_NOT_SUPPORTED);
1094
1095                 ret = bo->bufmgr->backend->bo_unmap(bo);
1096                 if (!ret)
1097                         error = TBM_ERROR_INVALID_OPERATION;
1098                 else
1099                         error = TBM_ERROR_NONE;
1100                 break;
1101         default:
1102                 TBM_ERR("Wrong module type:%d", module->type);
1103                 error = TBM_ERROR_INVALID_OPERATION;
1104                 break;
1105 /* LCOV_EXCL_STOP */
1106         }
1107
1108         return error;
1109 }
1110
1111 tbm_error_e
1112 tbm_module_bo_lock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, int device, int opt)
1113 {
1114         tbm_backend_bo_func *bo_func = NULL;
1115         tbm_bufmgr_backend backend = NULL;
1116         tbm_error_e error;
1117         int ret = 0;
1118
1119         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
1120
1121         switch (module->type) {
1122         case TBM_MODULE_TYPE_HAL_TBM:
1123                 error = (tbm_error_e)hal_tbm_bo_lock((hal_tbm_bo *)bo_data, device, opt);
1124                 break;
1125 /* LCOV_EXCL_START */
1126         case TBM_MODULE_TYPE_TBM_BACKEND:
1127                 bo_func = module->bo_func;
1128                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1129                 if (!bo_func->bo_lock)
1130                         return TBM_ERROR_NOT_SUPPORTED;
1131
1132                 error = bo_func->bo_lock(bo_data, device, opt);
1133                 break;
1134         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1135                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1136                 backend = module->backend;
1137                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1138                 if (!backend->bo_unmap)
1139                         return TBM_ERROR_NOT_SUPPORTED;
1140
1141                 ret = backend->bo_lock(bo, device, opt);
1142                 if (!ret)
1143                         error = TBM_ERROR_INVALID_OPERATION;
1144                 else
1145                         error = TBM_ERROR_NONE;
1146                 break;
1147         default:
1148                 TBM_ERR("Wrong module type:%d", module->type);
1149                 error = TBM_ERROR_INVALID_OPERATION;
1150                 break;
1151 /* LCOV_EXCL_STOP */
1152         }
1153
1154         return error;
1155 }
1156
1157 tbm_error_e
1158 tbm_module_bo_unlock(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data)
1159 {
1160         tbm_backend_bo_func *bo_func = NULL;
1161         tbm_bufmgr_backend backend = NULL;
1162         tbm_error_e error;
1163
1164         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
1165
1166         switch (module->type) {
1167         case TBM_MODULE_TYPE_HAL_TBM:
1168                 error = (tbm_error_e)hal_tbm_bo_unlock((hal_tbm_bo *)bo_data);
1169                 break;
1170 /* LCOV_EXCL_START */
1171         case TBM_MODULE_TYPE_TBM_BACKEND:
1172                 bo_func = module->bo_func;
1173                 TBM_RETURN_VAL_IF_FAIL(bo_func, TBM_ERROR_INVALID_OPERATION);
1174                 if (!bo_func->bo_unlock)
1175                         return TBM_ERROR_NOT_SUPPORTED;
1176
1177                 error = bo_func->bo_unlock(bo->bo_data);
1178                 break;
1179         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1180                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1181                 backend = module->backend;
1182                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
1183                 if (!backend->bo_unlock)
1184                         return TBM_ERROR_NOT_SUPPORTED;
1185
1186                 backend->bo_unlock(bo);
1187                 error = TBM_ERROR_NONE;
1188                 break;
1189         default:
1190                 TBM_ERR("Wrong module type:%d", module->type);
1191                 error = TBM_ERROR_INVALID_OPERATION;
1192                 break;
1193 /* LCOV_EXCL_STOP */
1194         }
1195
1196         return error;
1197 }
1198
1199 tbm_fd
1200 tbm_module_bo_export_fd(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error)
1201 {
1202         tbm_backend_bo_func *bo_func = NULL;
1203         tbm_bufmgr_backend backend = NULL;
1204         tbm_fd fd;
1205
1206         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, -1, *error, TBM_ERROR_INVALID_PARAMETER);
1207
1208         switch (module->type) {
1209         case TBM_MODULE_TYPE_HAL_TBM:
1210                 fd = (hal_tbm_fd)hal_tbm_bo_export_fd((hal_tbm_bo *)bo_data, (hal_tbm_error *)error);
1211                 break;
1212 /* LCOV_EXCL_START */
1213         case TBM_MODULE_TYPE_TBM_BACKEND:
1214                 bo_func = module->bo_func;
1215                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, -1, *error, TBM_ERROR_INVALID_OPERATION);
1216                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1217
1218                 fd = bo_func->bo_export_fd(bo_data, error);
1219                 break;
1220         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1221                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1222                 backend = module->backend;
1223                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, -1, *error, TBM_ERROR_INVALID_OPERATION);
1224                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export_fd, -1, *error, TBM_ERROR_NOT_SUPPORTED);
1225
1226                 fd = backend->bo_export_fd(bo);
1227                 if (fd < 0)
1228                         *error = TBM_ERROR_INVALID_OPERATION;
1229                 else
1230                         *error = TBM_ERROR_NONE;
1231                 break;
1232         default:
1233                 TBM_ERR("Wrong module type:%d", module->type);
1234                 fd = -1;
1235                 *error = TBM_ERROR_INVALID_OPERATION;
1236                 break;
1237 /* LCOV_EXCL_STOP */
1238         }
1239
1240         return fd;
1241 }
1242
1243 tbm_key
1244 tbm_module_bo_export_key(tbm_module *module, tbm_bo bo, tbm_backend_bo_data *bo_data, tbm_error_e *error)
1245 {
1246         tbm_backend_bo_func *bo_func = NULL;
1247         tbm_bufmgr_backend backend = NULL;
1248         tbm_key ret;
1249
1250         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, 0, *error, TBM_ERROR_INVALID_PARAMETER);
1251
1252         switch (module->type) {
1253         case TBM_MODULE_TYPE_HAL_TBM:
1254                 ret = (hal_tbm_fd)hal_tbm_bo_export_key((hal_tbm_bo *)bo_data, (hal_tbm_error *)error);
1255                 break;
1256 /* LCOV_EXCL_START */
1257         case TBM_MODULE_TYPE_TBM_BACKEND:
1258                 bo_func = module->bo_func;
1259                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
1260                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bo_func->bo_export_key, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1261
1262                 ret = bo_func->bo_export_key(bo_data, error);
1263                 break;
1264         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
1265                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
1266                 backend = module->backend;
1267                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, 0, *error, TBM_ERROR_INVALID_OPERATION);
1268                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_export, 0, *error, TBM_ERROR_NOT_SUPPORTED);
1269
1270                 ret = backend->bo_export(bo);
1271                 if (!ret)
1272                         *error = TBM_ERROR_INVALID_OPERATION;
1273                 else
1274                         *error = TBM_ERROR_NONE;
1275                 break;
1276         default:
1277                 TBM_ERR("Wrong module type:%d", module->type);
1278                 ret = -1;
1279                 *error = TBM_ERROR_INVALID_OPERATION;
1280                 break;
1281 /* LCOV_EXCL_STOP */
1282         }
1283
1284         return ret;
1285 }