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