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
  56 static int
  57 _tbm_backend_load_hal_tbm(tbm_module *module)
  58 {
  59         hal_tbm_backend *hal_backend = NULL;
  60         hal_tbm_bufmgr *hal_bufmgr;
  61         hal_tbm_error ret = HAL_TBM_ERROR_NONE;
  62         hal_tbm_fd auth_drm_fd = -1;
  63
  64         hal_backend = hal_tbm_get_backend(&ret);
  65         if (hal_backend == NULL || ret != HAL_TBM_ERROR_NONE) {
  66                 TBM_ERR("get backend fail");
  67                 return 0;
  68         }
  69
  70         hal_bufmgr = hal_tbm_backend_get_bufmgr(hal_backend, &ret);
  71         if (hal_bufmgr == NULL || ret != HAL_TBM_ERROR_NONE) {
  72                 TBM_ERR("get hal_bufmgr fail");
  73                 goto get_backend_fail;
  74         }
  75
  76         if (hal_tbm_backend_has_drm_device(hal_backend, &ret)) {
  77                 auth_drm_fd = hal_tbm_backend_get_master_drm_fd(hal_backend, &ret);
  78                 if (auth_drm_fd < 0) {
  79                         TBM_INFO("tbm_backend has no master drm_fd.");
  80
  81                         auth_drm_fd = tbm_drm_helper_get_master_fd();
  82                         if (auth_drm_fd < 0) {
  83                                 TBM_INFO("libtbm requests an authenticated drm_fd to a process(display server).");
  84                                 if (!tbm_drm_helper_get_auth_info(&auth_drm_fd, NULL, NULL)) {
  85                                         TBM_ERR("get auth drm_fd fail");
  86                                         goto get_backend_fail;
  87                                 }
  88                         } else {
  89                                 TBM_INFO("libtbm gets a master drm_fd from libtdm via tbm_drm_helper.");
  90                         }
  91
  92                         TBM_INFO("libtbm sends a master drm_fd as an authentiated drm_fd to tbm_backend.");
  93                         ret = hal_tbm_backend_set_authenticated_drm_fd(hal_backend, auth_drm_fd);
  94                         if (ret != HAL_TBM_ERROR_NONE) {
  95                                 TBM_ERR("hal_tbm_backend_set_authenticated_drm_fd failed.");
  96                                 goto get_backend_fail;
  97                         }
  98                 } else {
  99                         TBM_INFO("tbm_backend has a master drm_fd.");
 100
 101                         tbm_drm_helper_set_tbm_master_fd(auth_drm_fd);
 102                 }
 103                 tbm_drm_helper_set_fd(auth_drm_fd);
 104         }
 105
 106         module->hal_backend = hal_backend;
 107         module->hal_bufmgr = hal_bufmgr;
 108
 109         module->use_hal_tbm = 1;
 110
 111         TBM_INFO("use HAL-TBM_API");
 112
 113         return 1;
 114
 115 get_backend_fail:
 116         if (auth_drm_fd >= 0)
 117                 close(auth_drm_fd);
 118         hal_tbm_put_backend(hal_backend);
 119         return 0;
 120 }
 121
 122 static int
 123 _check_version(TBMModuleVersionInfo *data)
 124 {
 125         int backend_module_major, backend_module_minor;
 126         int tbm_backend_major, tbm_backend_minor;
 127
 128         backend_module_major = GET_ABI_MAJOR(data->abiversion);
 129         backend_module_minor = GET_ABI_MINOR(data->abiversion);
 130
 131         TBM_DBG("TBM module %s: vendor=\"%s\" ABI=%d,%d\n",
 132             data->modname ? data->modname : "UNKNOWN!",
 133             data->vendor ? data->vendor : "UNKNOWN!", backend_module_major, backend_module_minor);
 134
 135         tbm_backend_major = GET_ABI_MAJOR(TBM_ABI_VERSION);
 136         tbm_backend_minor = GET_ABI_MINOR(TBM_ABI_VERSION);
 137
 138         TBM_DBG("TBM ABI version %d.%d\n",
 139             tbm_backend_major, tbm_backend_minor);
 140
 141         if (backend_module_major != tbm_backend_major) {
 142                 TBM_ERR("TBM module ABI major ver(%d) doesn't match the TBM's ver(%d)\n",
 143                         backend_module_major, tbm_backend_major);
 144                 return 0;
 145         } else if (backend_module_minor > tbm_backend_minor) {
 146                 TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n",
 147                         backend_module_minor, tbm_backend_minor);
 148                 return 0;
 149         }
 150
 151         return 1;
 152 }
 153
 154 static int
 155 _tbm_backend_check_bufmgr_func(tbm_backend_bufmgr_func *bufmgr_func)
 156 {
 157         TBM_RETURN_VAL_IF_FAIL(bufmgr_func, 0); /* mandatory symbol */
 158         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0); /* mandatory symbol */
 159         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, 0); /* mandatory symbol */
 160         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_supported_formats, 0); /* mandatory symbol */
 161         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_get_plane_data, 0); /* mandatory symbol */
 162         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, 0); /* mandatory symbol */
 163         if (!bufmgr_func->bufmgr_alloc_bo_with_format)
 164                 TBM_DBG("No bufmgr_func->bufmgr_alloc_bo_with_format.");
 165         TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_import_fd, 0); /* mandatory symbol */
 166         if (!bufmgr_func->bufmgr_import_key)
 167                 TBM_DBG("No bufmgr_func->bo_export_key.");
 168
 169         return 1;
 170 }
 171
 172 static int
 173 _tbm_backend_check_bufmgr_bo(tbm_backend_bo_func *bo_func)
 174 {
 175         TBM_RETURN_VAL_IF_FAIL(bo_func, 0); /* mandatory symbol */
 176         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_free, 0); /* mandatory symbol */
 177         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_size, 0); /* mandatory symbol */
 178         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_memory_types, 0); /* mandatory symbol */
 179         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_get_handle, 0); /* mandatory symbol */
 180         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_map, 0); /* mandatory symbol */
 181         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_unmap, 0); /* mandatory symbol */
 182         if (!bo_func->bo_lock)
 183                 TBM_DBG("No bo_func->bo_lock.");
 184         if (!bo_func->bo_unlock)
 185                 TBM_DBG("No bo_func->bo_unlock.");
 186         TBM_RETURN_VAL_IF_FAIL(bo_func->bo_export_fd, 0); /* mandatory symbol */
 187         if (!bo_func->bo_export_key)
 188                 TBM_INFO("No bo_func->bo_export_key.");
 189
 190         return 1;
 191 }
 192
 193 static int
 194 _tbm_backend_load_module(tbm_module *module, const char *file)
 195 {
 196         char path[PATH_MAX] = {0, };
 197         void *module_data = NULL;
 198         tbm_backend_module *backend_module_data = NULL;
 199         tbm_backend_bufmgr_data *bufmgr_data = NULL;
 200         int backend_module_major, backend_module_minor;
 201         int tbm_backend_major, tbm_backend_minor;
 202         tbm_error_e error;
 203
 204         snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
 205
 206         module_data = dlopen(path, RTLD_LAZY);
 207         if (!module_data) {
 208                 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
 209                 return 0;
 210         }
 211
 212         backend_module_data = dlsym(module_data, "tbm_backend_module_data");
 213         if (!backend_module_data) {
 214                 TBM_ERR("Error: module does not have data object.\n");
 215                 goto err;
 216         }
 217
 218         tbm_backend_major = GET_ABI_MAJOR(TBM_BACKEND_ABI_LATEST_VERSION);
 219         tbm_backend_minor = GET_ABI_MINOR(TBM_BACKEND_ABI_LATEST_VERSION);
 220         TBM_INFO("TBM Backend ABI version %d.%d\n", tbm_backend_major, tbm_backend_minor);
 221
 222         backend_module_major = GET_ABI_MAJOR(backend_module_data->abi_version);
 223         backend_module_minor = GET_ABI_MINOR(backend_module_data->abi_version);
 224
 225         TBM_INFO("TBM module %s: vendor=\"%s\" Backend ABI version=%d.%d\n",
 226             backend_module_data->name ? backend_module_data->name : "UNKNOWN!",
 227             backend_module_data->vendor ? backend_module_data->vendor : "UNKNOWN!",
 228                 backend_module_major, backend_module_minor);
 229
 230         if (backend_module_major > tbm_backend_major) {
 231                 TBM_ERR("TBM module ABI major ver(%d) is newer than the TBM's ver(%d)\n",
 232                         backend_module_major, tbm_backend_major);
 233                 goto err;
 234         } else if (backend_module_minor > tbm_backend_minor) {
 235                 TBM_ERR("TBM module ABI minor ver(%d) is newer than the TBM's ver(%d)\n",
 236                         backend_module_minor, tbm_backend_minor);
 237                 goto err;
 238         }
 239
 240         if (!backend_module_data->init) {
 241                 TBM_ERR("Error: module does not supply init symbol.\n");
 242                 goto err;
 243         }
 244
 245         if (!backend_module_data->deinit)       {
 246                 TBM_ERR("Error: module does not supply deinit symbol.\n");
 247                 goto err;
 248         }
 249
 250         bufmgr_data = backend_module_data->init((tbm_bufmgr)module, &error);
 251         if (!bufmgr_data) {
 252                 TBM_ERR("Fail to init module(%s)\n", file);
 253                 goto err;
 254         }
 255
 256         /* check the mandatory symbols of the backend module */
 257         if (!_tbm_backend_check_bufmgr_func(module->bufmgr_func)) {
 258                 TBM_ERR("Fail to check the bufmgr_func symboles.");
 259                 goto err;
 260         }
 261
 262         if (!_tbm_backend_check_bufmgr_bo(module->bo_func)) {
 263                 TBM_ERR("Fail to check the bufmgr_bo symboles.");
 264                 goto err;
 265         }
 266
 267         module->module_data = module_data;
 268         module->backend_module_data = backend_module_data;
 269         module->bufmgr_data = bufmgr_data;
 270
 271         TBM_INFO("Success to load module(%s)\n", file);
 272
 273         return 1;
 274
 275 err:
 276         if (bufmgr_data)
 277                 module->backend_module_data->deinit(bufmgr_data);
 278         if (module_data)
 279                 dlclose(module_data);
 280
 281         return 0;
 282 }
 283
 284 static int
 285 _tbm_backend_load_bufmgr_module(tbm_module *module, int fd, const char *file)
 286 {
 287         char path[PATH_MAX] = {0, };
 288         TBMModuleVersionInfo *vers;
 289         TBMModuleData *initdata;
 290         ModuleInitProc init;
 291         void *module_data;
 292
 293         snprintf(path, sizeof(path), BUFMGR_MODULE_DIR "/%s", file);
 294
 295         module_data = dlopen(path, RTLD_LAZY);
 296         if (!module_data) {
 297                 TBM_ERR("failed to load module: %s(%s)\n", dlerror(), file);
 298                 return 0;
 299         }
 300
 301         initdata = dlsym(module_data, "tbmModuleData");
 302         if (!initdata) {
 303                 TBM_ERR("Error: module does not have data object.\n");
 304                 goto err;
 305         }
 306
 307         vers = initdata->vers;
 308         if (!vers) {
 309                 TBM_ERR("Error: module does not supply version information.\n");
 310                 goto err;
 311         }
 312
 313         init = initdata->init;
 314         if (!init) {
 315                 TBM_ERR("Error: module does not supply init symbol.\n");
 316                 goto err;
 317         }
 318
 319         if (!_check_version(vers)) {
 320                 TBM_ERR("Fail to check version.\n");
 321                 goto err;
 322         }
 323
 324         if (!init((tbm_bufmgr)module, fd)) {
 325                 TBM_ERR("Fail to init module(%s)\n", file);
 326                 goto err;
 327         }
 328
 329         if (!module->backend || !module->backend->priv) {
 330                 TBM_ERR("Error: module(%s) wrong operation. Check backend or backend's priv.\n", file);
 331                 goto err;
 332         }
 333
 334         module->module_data = module_data;
 335
 336         TBM_DBG("Success to load module(%s)\n", file);
 337
 338         return 1;
 339
 340 err:
 341         dlclose(module_data);
 342         return 0;
 343 }
 344
 345 /* LCOV_EXCL_STOP */
 346
 347 tbm_module *
 348 tbm_module_load(int fd)
 349 {
 350         tbm_module *module;
 351         struct dirent **namelist;
 352         int ret = 0, n;
 353
 354         module = calloc(1, sizeof(struct _tbm_module));
 355         if (!module) {
 356                 TBM_ERR("fail to allocate the memory");
 357                 return NULL;
 358         }
 359
 360         /* try to load the hal-tbm backend module */
 361         ret = _tbm_backend_load_hal_tbm(module);
 362         if (ret) {
 363                 module->type = TBM_MODULE_TYPE_HAL_TBM;
 364                 goto done;
 365         }
 366
 367         /* try to load the new backend module */
 368         ret = _tbm_backend_load_module(module, DEFAULT_LIB);
 369         if (ret) {
 370                 module->type = TBM_MODULE_TYPE_TBM_BACKEND;
 371                 goto done;
 372         }
 373
 374         /* try to load the old(deprecated) backend mdoule */
 375         ret = _tbm_backend_load_bufmgr_module(module, fd, DEFAULT_LIB);
 376         if (ret) {
 377                 module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
 378                 return module;
 379         }
 380
 381         /* load backend_module from configured path */
 382         n = scandir(BUFMGR_MODULE_DIR, &namelist, 0, alphasort);
 383         if (n < 0) {
 384                 TBM_ERR("no files : %s\n", BUFMGR_MODULE_DIR);
 385                 tbm_module_unload(module);
 386                 return NULL;
 387         }
 388
 389         while (n--) {
 390                 if (!ret && strstr(namelist[n]->d_name, PREFIX_LIB)) {
 391                         const char *p = strstr(namelist[n]->d_name, SUFFIX_LIB);
 392
 393                         if (p && !strcmp(p, SUFFIX_LIB)) {
 394                                 ret = _tbm_backend_load_module(module, namelist[n]->d_name);
 395                                 if (ret)
 396                                         module->type = TBM_MODULE_TYPE_TBM_BACKEND;
 397                                 else {
 398                                         ret = _tbm_backend_load_bufmgr_module(module, fd, namelist[n]->d_name);
 399                                         module->type = TBM_MODULE_TYPE_BUFMGR_BACKEND;
 400                                 }
 401                         }
 402                 }
 403
 404                 free(namelist[n]);
 405         }
 406
 407         free(namelist);
 408
 409         if (!ret) {
 410                 free(module);
 411                 module = NULL;
 412         }
 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         case TBM_MODULE_TYPE_TBM_BACKEND:
 436                 module->backend_module_data->deinit(module->bufmgr_data);
 437                 module->bo_func = NULL;
 438                 module->bufmgr_func = NULL;
 439                 module->bufmgr_data = NULL;
 440                 module->backend_module_data = NULL;
 441
 442                 dlclose(module->module_data);
 443                 break;
 444         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 445                 module->backend->bufmgr_deinit(module->backend->priv);
 446                 module->backend->priv = NULL;
 447                 tbm_backend_free(module->backend);
 448                 module->backend = NULL;
 449
 450                 dlclose(module->module_data);
 451                 break;
 452         default:
 453                 TBM_ERR("Wrong module type:%d", module->type);
 454                 break;
 455         }
 456
 457         free(module);
 458 }
 459
 460 int
 461 tbm_module_bufmgr_get_capabilities(tbm_module *module, tbm_error_e *error)
 462 {
 463         int capabilities = 0;
 464         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 465
 466         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, TBM_BUFMGR_CAPABILITY_NONE, *error, TBM_ERROR_INVALID_PARAMETER);
 467
 468         switch (module->type) {
 469         case TBM_MODULE_TYPE_HAL_TBM:
 470                 capabilities = hal_tbm_bufmgr_get_capabilities(module->hal_bufmgr, (hal_tbm_error *)error);
 471                 break;
 472         case TBM_MODULE_TYPE_TBM_BACKEND:
 473                 bufmgr_func = module->bufmgr_func;
 474                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, 0, *error, TBM_ERROR_INVALID_OPERATION);
 475                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_get_capabilities, 0, *error, TBM_ERROR_NOT_SUPPORTED);
 476
 477                 capabilities = module->bufmgr_func->bufmgr_get_capabilities(module->bufmgr_data, error);
 478                 break;
 479         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 480                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 6.5.");
 481                 TBM_ERR("Do not support at tbm_bufmgr_backend.");
 482
 483                 *error = TBM_ERROR_NOT_SUPPORTED;
 484                 break;
 485         default:
 486                 TBM_ERR("Wrong module type:%d", module->type);
 487                 *error = TBM_ERROR_INVALID_OPERATION;
 488                 break;
 489         }
 490
 491         return capabilities;
 492 }
 493
 494 tbm_error_e
 495 tbm_module_bufmgr_bind_native_display(tbm_module *module, void *native_display)
 496 {
 497         tbm_error_e error = TBM_ERROR_NONE;
 498         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 499         tbm_bufmgr_backend backend = NULL;
 500         int ret = 0;
 501
 502         TBM_RETURN_VAL_IF_FAIL(module, TBM_ERROR_INVALID_PARAMETER);
 503
 504         switch (module->type) {
 505         case TBM_MODULE_TYPE_HAL_TBM:
 506                 if (hal_tbm_backend_has_drm_device(module->hal_backend, &ret)) {
 507                         int fd = tbm_drm_helper_get_fd(); // this must be the auth drm_fd.(master drm_fd);
 508                         if (fd < -1) {
 509                                 TBM_ERR("error: module(%p) native_display(%p)\n", module, native_display);
 510                                 return TBM_ERROR_INVALID_OPERATION;
 511                         }
 512
 513                         // make the wayland server socket for sending the authenticated drm_fd to wayland clients.
 514                         if (!tbm_drm_helper_wl_auth_server_init(native_display, fd, NULL, 0)) {
 515                                 TBM_ERR("error: tbm_drm_helper_wl_auth_server_init failed\n", module, native_display);
 516                                 close(fd);
 517                                 return TBM_ERROR_INVALID_OPERATION;
 518                         }
 519                         TBM_INFO("tbm creates a wayland socket for authentication of drm_fd.");
 520
 521                         module->auth_wl_socket_created = 1;
 522                         module->auth_fd = fd;
 523                 } else {
 524                         TBM_INFO("tbm_module has no drm device.");
 525                         error = TBM_ERROR_NONE;
 526                 }
 527                 break;
 528         case TBM_MODULE_TYPE_TBM_BACKEND:
 529                 bufmgr_func = module->bufmgr_func;
 530                 TBM_RETURN_VAL_IF_FAIL(bufmgr_func, TBM_ERROR_INVALID_OPERATION);
 531                 TBM_RETURN_VAL_IF_FAIL(bufmgr_func->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED);
 532
 533                 error = bufmgr_func->bufmgr_bind_native_display(module->bufmgr_data, (tbm_native_display *)native_display);
 534                 break;
 535         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 536                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 7.0.");
 537                 backend = module->backend;
 538                 TBM_RETURN_VAL_IF_FAIL(backend, TBM_ERROR_INVALID_OPERATION);
 539                 TBM_RETURN_VAL_IF_FAIL(backend->bufmgr_bind_native_display, TBM_ERROR_NOT_SUPPORTED);
 540
 541                 ret = backend->bufmgr_bind_native_display((tbm_bufmgr)module, native_display);
 542                 if (!ret)
 543                         error = TBM_ERROR_INVALID_OPERATION;
 544
 545                 break;
 546         default:
 547                 TBM_ERR("Wrong module type:%d", module->type);
 548                 error = TBM_ERROR_INVALID_OPERATION;
 549                 break;
 550         }
 551
 552         return error;
 553 }
 554
 555 tbm_backend_bo_data *
 556 tbm_module_bufmgr_bo_alloc(tbm_module *module, tbm_bo bo, int size, int flags, tbm_error_e *error)
 557 {
 558         tbm_backend_bo_data *bo_data = NULL;
 559         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 560         tbm_bufmgr_backend backend = NULL;
 561
 562         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 563
 564         switch (module->type) {
 565         case TBM_MODULE_TYPE_HAL_TBM:
 566                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo(module->hal_bufmgr, size, flags, (hal_tbm_error *)error);
 567                 break;
 568         case TBM_MODULE_TYPE_TBM_BACKEND:
 569                 bufmgr_func = module->bufmgr_func;
 570                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 571                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 572
 573                 bo_data = module->bufmgr_func->bufmgr_alloc_bo(module->bufmgr_data, (unsigned int)size, flags, error);
 574                 break;
 575         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 576                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 7.0.");
 577                 backend = module->backend;
 578                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 579                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(backend->bo_alloc, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 580
 581                 bo_data = (void *)module->backend->bo_alloc(bo, size, flags);
 582                 *error = TBM_ERROR_NONE;
 583                 break;
 584         default:
 585                 TBM_ERR("Wrong module type:%d", module->type);
 586                 *error = TBM_ERROR_INVALID_OPERATION;
 587                 break;
 588         }
 589
 590         return bo_data;
 591 }
 592
 593 tbm_backend_bo_data *
 594 tbm_module_bufmgr_bo_alloc_with_format(tbm_module *module, int format, int bo_idx, int width,
 595                                                 int height, int bpp, tbm_bo_memory_type flags, tbm_error_e *error)
 596 {
 597         tbm_backend_bo_data *bo_data = NULL;
 598         tbm_backend_bufmgr_func *bufmgr_func = NULL;
 599
 600         TBM_RETURN_VAL_SET_ERR_IF_FAIL(module, NULL, *error, TBM_ERROR_INVALID_PARAMETER);
 601
 602         switch (module->type) {
 603         case TBM_MODULE_TYPE_HAL_TBM:
 604                 bo_data = (tbm_backend_bo_data *)hal_tbm_bufmgr_alloc_bo_with_format(module->hal_bufmgr,
 605                                                                                         format, bo_idx, width, height, bpp,
 606                                                                                         (hal_tbm_bo_memory_type)flags, (hal_tbm_error *)error);
 607                 break;
 608         case TBM_MODULE_TYPE_TBM_BACKEND:
 609                 bufmgr_func = module->bufmgr_func;
 610                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func, NULL, *error, TBM_ERROR_INVALID_OPERATION);
 611                 TBM_RETURN_VAL_SET_ERR_IF_FAIL(bufmgr_func->bufmgr_alloc_bo_with_format, NULL, *error, TBM_ERROR_NOT_SUPPORTED);
 612
 613                 bo_data = bufmgr_func->bufmgr_alloc_bo_with_format(module->bufmgr_data, format, bo_idx, width, height, flags, error);
 614                 break;
 615         case TBM_MODULE_TYPE_BUFMGR_BACKEND:
 616                 TBM_WRN("!!WARNING: This backend interface will be DEPRECATED after Tizen 7.0.");
 617                 TBM_ERR("error: not supported tbm_bo_alloc_with_format.");
 618
 619                 *error = TBM_ERROR_NOT_SUPPORTED;
 620                 break;
 621         default:
 622                 TBM_ERR("Wrong module type:%d", module->type);
 623                 *error = TBM_ERROR_INVALID_OPERATION;
 624                 break;
 625         }
 626
 627         return bo_data;
 628 }