src/hal-api-tbm.c

   1 /**************************************************************************
   2  *
   3  * hal-api-tbm
   4  *
   5  * Copyright 2021 Samsung Electronics co., Ltd. All Rights Reserved.
   6  *
   7  * Contact: SooChan Lim <sc1.lim@samsung.com>,
   8  *          Junkyeong Kim <jk0430.kim@samsung.com>,
   9  *          Changyeon Lee <cyeon.lee@samsung.com>
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining a
  12  * copy of this software and associated documentation files (the
  13  * "Software"), to deal in the Software without restriction, including
  14  * without limitation the rights to use, copy, modify, merge, publish,
  15  * distribute, sub license, and/or sell copies of the Software, and to
  16  * permit persons to whom the Software is furnished to do so, subject to
  17  * the following conditions:
  18  *
  19  * The above copyright notice and this permission notice (including the
  20  * next paragraph) shall be included in all copies or substantial portions
  21  * of the Software.
  22  *
  23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  24  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  26  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  27  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  28  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  29  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  30  *
  31 **************************************************************************/
  32
  33 #include <stdio.h>
  34 #include <stdint.h>
  35 #include <stdlib.h>
  36
  37 #include <hal-common.h>
  38 #include "common.h"
  39 #include "hal-tbm.h"
  40 #include "hal-tbm-interface.h"
  41
  42 #if defined(__GNUC__) && __GNUC__ >= 4
  43 #define EXTERN __attribute__ ((visibility("default")))
  44 #else
  45 #define EXTERN
  46 #endif
  47
  48 #if defined(__GNUC__) && __GNUC__ >= 4
  49 #define INTERN __attribute__ ((visibility("hidden")))
  50 #else
  51 #define INTERN
  52 #endif
  53
  54 #define ARRAY_SIZE(name)        (sizeof(name)/sizeof(name[0]))
  55
  56 #define BUFMGR_ENTRY() \
  57         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  58         if (!g_tbm_backend_data) return HAL_TBM_ERROR_NOT_SUPPORTED;
  59
  60 #define BUFMGR_ENTRY_NULL() \
  61         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  62         if (!g_hal_tbm_backend_data) { if (error) *error = HAL_TBM_ERROR_NOT_SUPPORTED; return NULL; }
  63
  64 #define BUFMGR_ENTRY_VOID() \
  65         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  66         if (!g_hal_tbm_backend_data) return;
  67
  68 #define BUFMGR_ENTRY_GOTO(__goto__) \
  69         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  70         if (!g_hal_tbm_backend_data) goto __goto__;
  71
  72 #define BUFMGR_FUNC_ENTRY(__func__) \
  73         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  74         if (!bufmgr) return HAL_TBM_ERROR_INVALID_PARAMETER; \
  75         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bufmgr_funcs) return HAL_TBM_ERROR_NOT_SUPPORTED; \
  76         bufmgr_funcs = g_hal_tbm_backend_data->bufmgr_funcs; \
  77         if (!bufmgr_funcs->__func__) return HAL_TBM_ERROR_NOT_SUPPORTED;
  78
  79 #define BUFMGR_FUNC_ENTRY_NULL(__func__) \
  80         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  81         if (!bufmgr) { if (error) *error = HAL_TBM_ERROR_INVALID_PARAMETER; return NULL; } \
  82         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bufmgr_funcs) { if (error) *error = HAL_TBM_ERROR_NOT_SUPPORTED; return NULL; } \
  83         bufmgr_funcs = g_hal_tbm_backend_data->bufmgr_funcs; \
  84         if (!bufmgr_funcs->__func__) { if (error) *error = HAL_TBM_ERROR_NOT_SUPPORTED; return NULL; };
  85
  86 #define BUFMGR_FUNC_ENTRY_GOTO(__func__, __goto__) \
  87         hal_tbm_bufmgr_funcs *bufmgr_funcs; \
  88         if (!bufmgr) goto __goto__; \
  89         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bufmgr_funcs) goto __goto__; \
  90         bufmgr_funcs = (hal_tbm_bufmgr_funcs *)g_hal_tbm_backend_data->bufmgr_funcs; \
  91         if (!bufmgr_funcs->__func__) goto __goto__;
  92
  93 #define BO_FUNC_ENTRY(__func__) \
  94         hal_tbm_bo_funcs *bo_funcs; \
  95         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bo_funcs) return HAL_TBM_ERROR_NOT_SUPPORTED; \
  96         bo_funcs = g_hal_tbm_backend_data->bo_funcs; \
  97         if (!bo_funcs->__func__) return HAL_TBM_ERROR_NOT_SUPPORTED;
  98
  99 #define BO_FUNC_ENTRY_VOID(__func__) \
 100         hal_tbm_bo_funcs *bo_funcs; \
 101         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bo_funcs) return; \
 102         bo_funcs = g_hal_tbm_backend_data->bo_funcs; \
 103         if (!bo_funcs->__func__) return;
 104
 105 #define BO_FUNC_ENTRY_GOTO(__func__, __goto__) \
 106         hal_tbm_bo_funcs *bo_funcs; \
 107         if (!g_hal_tbm_backend_data || !g_hal_tbm_backend_data->bo_funcs) goto __goto__; \
 108         bo_funcs = g_hal_tbm_backend_data->bo_funcs; \
 109         if (!bo_funcs->__func__) goto __goto__;
 110
 111 static hal_tbm_backend_data *g_hal_tbm_backend_data = NULL;
 112
 113 EXTERN hal_tbm_backend *
 114 hal_tbm_get_backend(hal_tbm_error *error)
 115 {
 116         hal_tbm_backend_data *backend_data;
 117         int ret;
 118
 119         if (g_hal_tbm_backend_data) {
 120                 if (error)
 121                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 122                 return NULL;
 123         }
 124
 125         ret = hal_common_get_backend(HAL_MODULE_TBM, (void **)&backend_data);
 126         if (ret < 0) {
 127                  _E("Failed to get backend\n");
 128                  if (error)
 129                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 130                 return NULL;
 131         }
 132
 133         g_hal_tbm_backend_data = (hal_tbm_backend_data *)backend_data;
 134
 135         if (error)
 136                 *error = HAL_TBM_ERROR_NONE;
 137
 138         _I("hal_tbm_get_backend");
 139
 140         return (hal_tbm_backend *)backend_data;
 141 }
 142
 143 EXTERN hal_tbm_error
 144 hal_tbm_put_backend(hal_tbm_backend *backend)
 145 {
 146         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)backend;
 147         int ret;
 148
 149         if (!backend_data && g_hal_tbm_backend_data != backend) {
 150                 _E("no backend_data\n");
 151                 return HAL_TBM_ERROR_INVALID_OPERATION;
 152         }
 153
 154         ret = hal_common_put_backend(HAL_MODULE_TBM, backend_data);
 155         if (ret < 0) {
 156                  _E("Failed to put backend\n");
 157                  return HAL_TBM_ERROR_INVALID_OPERATION;
 158         }
 159
 160         g_hal_tbm_backend_data = NULL;
 161
 162         _I("hal_tbm_put_backend");
 163
 164         return HAL_TBM_ERROR_NONE;
 165 }
 166
 167 EXTERN hal_tbm_bufmgr *
 168 hal_tbm_backend_get_bufmgr(hal_tbm_backend *backend, hal_tbm_error *error)
 169 {
 170         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)backend;
 171         hal_tbm_bufmgr *bufmgr;
 172
 173         if (!backend_data || g_hal_tbm_backend_data != backend_data) {
 174                 _E("no backend_data\n");
 175                 if (error)
 176                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 177                 return NULL;
 178         }
 179
 180         bufmgr = backend_data->bufmgr;
 181         if (!bufmgr) {
 182                 _E("no bufmgr\n");
 183                 if (error)
 184                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 185                 return NULL;
 186         }
 187
 188         if (error)
 189                 *error = HAL_TBM_ERROR_NONE;
 190
 191         return bufmgr;
 192 }
 193
 194 EXTERN int
 195 hal_tbm_backend_has_drm_device(hal_tbm_backend *backend, hal_tbm_error *error)
 196 {
 197         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)backend;
 198
 199         if (!backend_data || g_hal_tbm_backend_data != backend_data) {
 200                 _E("no backend_data\n");
 201                 if (error)
 202                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 203                 return 0;
 204         }
 205
 206         return backend_data->has_drm_device;
 207 }
 208
 209 EXTERN hal_tbm_fd
 210 hal_tbm_backend_get_master_drm_fd(hal_tbm_backend *backend, hal_tbm_error *error)
 211 {
 212         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)backend;
 213
 214         if (!backend_data || g_hal_tbm_backend_data != backend_data) {
 215                 _E("no backend_data\n");
 216                 if (error)
 217                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 218                 return -1;
 219         }
 220
 221         if (!backend_data->drm_info.is_master) {
 222                 _I("no master_drm_fd");
 223                 return -1;
 224         }
 225
 226         _I("master_drm_fd is %d", backend_data->drm_info.drm_fd);
 227
 228         return backend_data->drm_info.drm_fd;
 229 }
 230
 231 EXTERN  hal_tbm_error
 232 hal_tbm_backend_set_authenticated_drm_fd(hal_tbm_backend *backend, hal_tbm_fd auth_drm_fd)
 233 {
 234         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)backend;
 235         int ret;
 236
 237         if (!backend_data || g_hal_tbm_backend_data != backend_data) {
 238                 _E("no backend_data\n");
 239                 return HAL_TBM_ERROR_INVALID_OPERATION;
 240         }
 241
 242         if (!backend_data->drm_info.auth_drm_fd_func) {
 243                 _E("no backend_data->drm_info.auth_drm_fd_func\n");
 244                 return HAL_TBM_ERROR_INVALID_OPERATION;
 245         }
 246
 247         ret = backend_data->drm_info.auth_drm_fd_func(auth_drm_fd, backend_data->drm_info.user_data);
 248         if (ret != HAL_TBM_ERROR_NONE) {
 249                 _E("backend_data->drm_info.auth_drm_fd_func failed\n");
 250                 return ret;
 251         }
 252
 253         return HAL_TBM_ERROR_NONE;
 254 }
 255
 256 /* tbm_bufmgr_func */
 257 EXTERN hal_tbm_bufmgr_capability
 258 hal_tbm_bufmgr_get_capabilities(hal_tbm_bufmgr *bufmgr, hal_tbm_error *error)
 259 {
 260         BUFMGR_FUNC_ENTRY_GOTO(bufmgr_get_capabilities, fail);
 261
 262         return bufmgr_funcs->bufmgr_get_capabilities((hal_tbm_bufmgr *)bufmgr, error);
 263
 264 fail:
 265         if (error)
 266                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 267
 268         return HAL_TBM_BUFMGR_CAPABILITY_NONE;
 269 }
 270
 271 EXTERN hal_tbm_error
 272 hal_tbm_bufmgr_get_supported_formats(hal_tbm_bufmgr *bufmgr, uint32_t **formats, uint32_t *num)
 273 {
 274         BUFMGR_FUNC_ENTRY(bufmgr_get_supported_formats);
 275
 276         return bufmgr_funcs->bufmgr_get_supported_formats((hal_tbm_bufmgr *)bufmgr, formats, num);
 277 }
 278
 279 EXTERN hal_tbm_error
 280 hal_tbm_bufmgr_get_plane_data(hal_tbm_bufmgr *bufmgr, hal_tbm_format format, int plane_idx, int width, int height,
 281                                                                         uint32_t *size, uint32_t *offset, uint32_t *pitch, int *bo_idx)
 282 {
 283         BUFMGR_FUNC_ENTRY(bufmgr_get_plane_data);
 284
 285         return bufmgr_funcs->bufmgr_get_plane_data((hal_tbm_bufmgr *)bufmgr, format, plane_idx, width, height, size, offset, pitch, bo_idx);
 286 }
 287
 288 EXTERN hal_tbm_bo *
 289 hal_tbm_bufmgr_alloc_bo(hal_tbm_bufmgr *bufmgr, unsigned int size, hal_tbm_bo_memory_type mem_types, hal_tbm_error *error)
 290 {
 291         BUFMGR_FUNC_ENTRY_NULL(bufmgr_alloc_bo);
 292
 293         return bufmgr_funcs->bufmgr_alloc_bo((hal_tbm_bufmgr *)bufmgr, size, mem_types, error);
 294 }
 295
 296 EXTERN hal_tbm_bo *
 297 hal_tbm_bufmgr_alloc_bo_with_format(hal_tbm_bufmgr *bufmgr, int format, int bo_idx, int width, int height,
 298                                                                         hal_tbm_bo_memory_type mem_types, hal_tbm_error *error)
 299 {
 300         BUFMGR_FUNC_ENTRY_NULL(bufmgr_alloc_bo_with_format);
 301
 302         return bufmgr_funcs->bufmgr_alloc_bo_with_format((hal_tbm_bufmgr *)bufmgr, format, bo_idx, width, height, mem_types, error);
 303 }
 304
 305 EXTERN hal_tbm_bo *
 306 hal_tbm_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd fd, hal_tbm_error *error)
 307 {
 308         BUFMGR_FUNC_ENTRY_NULL(bufmgr_import_fd);
 309
 310         return bufmgr_funcs->bufmgr_import_fd((hal_tbm_bufmgr *)bufmgr, fd, error);
 311 }
 312
 313 EXTERN hal_tbm_bo *
 314 hal_tbm_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_error *error)
 315 {
 316         BUFMGR_FUNC_ENTRY_NULL(bufmgr_import_key);
 317
 318         return bufmgr_funcs->bufmgr_import_key((hal_tbm_bufmgr *)bufmgr, key, error);
 319 }
 320
 321
 322 /* tbm_bo_func*/
 323 EXTERN void
 324 hal_tbm_bo_free(hal_tbm_bo *bo)
 325 {
 326         BO_FUNC_ENTRY_VOID(bo_free);
 327
 328         bo_funcs->bo_free((hal_tbm_bo *)bo);
 329 }
 330
 331 EXTERN int
 332 hal_tbm_bo_get_size(hal_tbm_bo *bo, hal_tbm_error *error)
 333 {
 334         BO_FUNC_ENTRY_GOTO(bo_get_size, fail);
 335
 336         return bo_funcs->bo_get_size((hal_tbm_bo *)bo, error);
 337
 338 fail:
 339         if (error)
 340                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 341
 342         return 0;
 343 }
 344
 345 EXTERN hal_tbm_bo_memory_type
 346 hal_tbm_bo_get_memory_types(hal_tbm_bo *bo, hal_tbm_error *error)
 347 {
 348         BO_FUNC_ENTRY_GOTO(bo_get_memory_types, fail);
 349
 350         return bo_funcs->bo_get_memory_types((hal_tbm_bo *)bo, error);
 351
 352 fail:
 353         if (error)
 354                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 355
 356         return HAL_TBM_BO_DEFAULT;
 357 }
 358
 359 EXTERN hal_tbm_bo_handle
 360 hal_tbm_bo_get_handle(hal_tbm_bo *bo, hal_tbm_bo_device_type device, hal_tbm_error *error)
 361 {
 362         BO_FUNC_ENTRY_GOTO(bo_get_handle, fail);
 363
 364         return bo_funcs->bo_get_handle((hal_tbm_bo *)bo, device, error);
 365
 366 fail:
 367         if (error)
 368                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 369
 370         return (hal_tbm_bo_handle)NULL;
 371 }
 372
 373 EXTERN hal_tbm_bo_handle
 374 hal_tbm_bo_map(hal_tbm_bo *bo, hal_tbm_bo_device_type device, hal_tbm_bo_access_option opt, hal_tbm_error *error)
 375 {
 376         BO_FUNC_ENTRY_GOTO(bo_map, fail);
 377
 378         return bo_funcs->bo_map((hal_tbm_bo *)bo, device, opt, error);
 379
 380 fail:
 381         if (error)
 382                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 383
 384         return (hal_tbm_bo_handle)NULL;
 385 }
 386
 387 EXTERN hal_tbm_error
 388 hal_tbm_bo_unmap(hal_tbm_bo *bo)
 389 {
 390         BO_FUNC_ENTRY(bo_unmap);
 391
 392         return bo_funcs->bo_unmap((hal_tbm_bo *)bo);
 393 }
 394
 395 EXTERN hal_tbm_error
 396 hal_tbm_bo_lock(hal_tbm_bo *bo, hal_tbm_bo_device_type device, hal_tbm_bo_access_option opt)
 397 {
 398         BO_FUNC_ENTRY(bo_lock);
 399
 400         return bo_funcs->bo_lock((hal_tbm_bo *)bo, device, opt);
 401 }
 402
 403 EXTERN hal_tbm_error
 404 hal_tbm_bo_unlock(hal_tbm_bo *bo)
 405 {
 406         BO_FUNC_ENTRY(bo_unlock);
 407
 408         return bo_funcs->bo_unlock((hal_tbm_bo *)bo);
 409 }
 410
 411 EXTERN hal_tbm_fd
 412 hal_tbm_bo_export_fd(hal_tbm_bo *bo, hal_tbm_error *error)
 413 {
 414         BO_FUNC_ENTRY_GOTO(bo_export_fd, fail);
 415
 416         return bo_funcs->bo_export_fd((hal_tbm_bo *)bo, error);
 417
 418 fail:
 419         if (error)
 420                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 421
 422         return -1;
 423 }
 424
 425 EXTERN hal_tbm_key
 426 hal_tbm_bo_export_key(hal_tbm_bo *bo, hal_tbm_error *error)
 427 {
 428         BO_FUNC_ENTRY_GOTO(bo_export_key, fail);
 429
 430         return bo_funcs->bo_export_key((hal_tbm_bo *)bo, error);
 431
 432 fail:
 433         if (error)
 434                 *error = HAL_TBM_ERROR_NOT_SUPPORTED;
 435
 436         return 0;
 437 }