src/libhal-backend-tbm-vigs/tbm_backend_vigs.c

   1 /*
   2  * buffer manager for libtbm-vigs
   3  *
   4  * Copyright (c) 2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact :
   7  * Stanislav Vorobiov <s.vorobiov@samsung.com>
   8  * Jinhyung Jo <jinhyung.jo@samsung.com>
   9  * Sangho Park <sangho1206.park@samsung.com>
  10  * YeongKyoon Lee <yeongkyoon.lee@samsung.com>
  11  *
  12  * Permission is hereby granted, free of charge, to any person obtaining a copy
  13  * of this software and associated documentation files (the "Software"), to deal
  14  * in the Software without restriction, including without limitation the rights
  15  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  16  * copies of the Software, and to permit persons to whom the Software is
  17  * furnished to do so, subject to the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be included in
  20  * all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  23  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  24  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  25  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  26  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  27  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  28  * THE SOFTWARE.
  29  *
  30  * Contributors:
  31  * - S-Core Co., Ltd
  32  *
  33  */
  34
  35 #ifdef HAVE_CONFIG_H
  36 #include "config.h"
  37 #endif
  38
  39 #include "vigs.h"
  40 #include <string.h>
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <unistd.h>
  44 #include <errno.h>
  45 #include <xf86drm.h>
  46 #include <hal-common.h>
  47 #include <hal-tbm-types.h>
  48 #include <hal-tbm-interface.h>
  49 #include "tbm_backend_log.h"
  50
  51 #define STRERR_BUFSIZE 128
  52
  53 #define VIGS_DRM_NAME "vigs"
  54
  55 /* global singleton drm_dev. this is shared with yagl. */
  56 struct vigs_drm_device *g_drm_dev = NULL;
  57
  58 static uint32_t tbm_bufmgr_vigs_color_format_list[] = {
  59         HAL_TBM_FORMAT_RGB888,
  60         HAL_TBM_FORMAT_ARGB8888,
  61         HAL_TBM_FORMAT_RGBA8888,
  62         HAL_TBM_FORMAT_XRGB8888,
  63         HAL_TBM_FORMAT_XBGR8888,
  64         HAL_TBM_FORMAT_NV21,
  65         HAL_TBM_FORMAT_NV61,
  66         HAL_TBM_FORMAT_YUV420,
  67 };
  68
  69 typedef struct _tbm_vigs_bufmgr tbm_vigs_bufmgr;
  70 typedef struct _tbm_vigs_bo tbm_vigs_bo;
  71
  72 /* tbm buffor object for vigs */
  73 struct _tbm_vigs_bo {
  74         struct vigs_drm_surface *sfc;
  75
  76         tbm_vigs_bufmgr *bufmgr_data;
  77 };
  78
  79 /* tbm bufmgr private for vigs */
  80 struct _tbm_vigs_bufmgr {
  81         int fd;
  82         void *hash_bos;
  83
  84         struct vigs_drm_device *drm_dev;
  85 };
  86
  87 static int
  88 _tbm_vigs_open_drm(void)
  89 {
  90         int fd = -1;
  91
  92         fd = drmOpen(VIGS_DRM_NAME, NULL);
  93         if (fd < 0) {
  94                 TBM_BACKEND_ERR("open vigs drm device failed");
  95                 return -1;
  96         }
  97
  98         return fd;
  99 }
 100
 101 static unsigned int
 102 _get_name(int fd, unsigned int gem)
 103 {
 104         struct drm_gem_flink arg = {0,};
 105
 106         arg.handle = gem;
 107         if (drmIoctl(fd, DRM_IOCTL_GEM_FLINK, &arg)) {
 108                 TBM_BACKEND_ERR("fail to DRM_IOCTL_GEM_FLINK gem:%d", gem);
 109                 return 0;
 110         }
 111
 112         return (unsigned int)arg.name;
 113 }
 114
 115 static hal_tbm_bo_handle
 116 get_tbm_bo_handle(struct vigs_drm_surface *sfc, int device)
 117 {
 118         hal_tbm_bo_handle bo_handle;
 119         int ret;
 120         struct vigs_drm_gem *gem = &sfc->gem;
 121         char buf[STRERR_BUFSIZE];
 122
 123         memset(&bo_handle, 0, sizeof(bo_handle));
 124
 125         switch (device) {
 126         case HAL_TBM_DEVICE_DEFAULT:
 127         case HAL_TBM_DEVICE_2D:
 128                 bo_handle.u32 = gem->handle;
 129                 break;
 130         case HAL_TBM_DEVICE_CPU:
 131                 ret = vigs_drm_gem_map(gem, 1);
 132
 133                 if (ret == 0)
 134                         bo_handle.ptr = gem->vaddr;
 135                 else
 136                         TBM_BACKEND_ERR("vigs_drm_gem_map failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 137
 138                 break;
 139         case HAL_TBM_DEVICE_3D:
 140                 bo_handle.ptr = (void *)sfc;
 141                 break;
 142         case HAL_TBM_DEVICE_MM:
 143                 TBM_BACKEND_ERR("HAL_TBM_DEVICE_MM not supported");
 144                 break;
 145         default:
 146                 TBM_BACKEND_ERR("%d not supported", device);
 147                 break;
 148         }
 149
 150         return bo_handle;
 151 }
 152
 153 static hal_tbm_bufmgr_capability
 154 tbm_vigs_bufmgr_get_capabilities(hal_tbm_bufmgr *bufmgr, hal_tbm_error *error)
 155 {
 156         hal_tbm_bufmgr_capability capabilities = HAL_TBM_BUFMGR_CAPABILITY_NONE;
 157
 158         capabilities = HAL_TBM_BUFMGR_CAPABILITY_SHARE_KEY | HAL_TBM_BUFMGR_CAPABILITY_SHARE_FD;
 159
 160         if (error)
 161                 *error = HAL_TBM_ERROR_NONE;
 162
 163         return capabilities;
 164 }
 165
 166 static hal_tbm_error
 167 tbm_vigs_bufmgr_get_supported_formats(hal_tbm_bufmgr *bufmgr,
 168                                                         uint32_t **formats, uint32_t *num)
 169 {
 170         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 171         uint32_t *color_formats;
 172
 173         if (!bufmgr_data)
 174                 return HAL_TBM_ERROR_INVALID_PARAMETER;
 175
 176         color_formats = (uint32_t *) calloc(1, sizeof(tbm_bufmgr_vigs_color_format_list));
 177         if (!color_formats)
 178                 return HAL_TBM_ERROR_OUT_OF_MEMORY;
 179
 180         memcpy(color_formats, tbm_bufmgr_vigs_color_format_list, sizeof(tbm_bufmgr_vigs_color_format_list));
 181
 182         *formats = color_formats;
 183         *num = sizeof(tbm_bufmgr_vigs_color_format_list) / sizeof(tbm_bufmgr_vigs_color_format_list[0]);
 184
 185         return HAL_TBM_ERROR_NONE;
 186 }
 187
 188 static hal_tbm_error
 189 tbm_vigs_bufmgr_get_plane_data(hal_tbm_bufmgr *bufmgr,
 190                                                          hal_tbm_format format, int plane_idx, int width,
 191                                                          int height, uint32_t * size, uint32_t * offset,
 192                                                          uint32_t * pitch, int *bo_idx)
 193 {
 194         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 195
 196         *size = 0;
 197         *offset = 0;
 198         *pitch = 0;
 199         *bo_idx = 0;
 200
 201         TBM_BACKEND_RETURN_VAL_IF_FAIL(bufmgr_data != NULL, HAL_TBM_ERROR_INVALID_PARAMETER);
 202
 203         switch (format) {
 204         case HAL_TBM_FORMAT_RGB888:
 205                 *size = width * height * 3;
 206                 *offset = 0;
 207                 *pitch = width * 3;
 208                 *bo_idx = 0;
 209                 return HAL_TBM_ERROR_NONE;
 210         case HAL_TBM_FORMAT_XRGB8888:
 211         case HAL_TBM_FORMAT_XBGR8888:
 212         case HAL_TBM_FORMAT_ARGB8888:
 213         case HAL_TBM_FORMAT_RGBA8888:
 214                 *size = width * height * 4;
 215                 *offset = 0;
 216                 *pitch = width * 4;
 217                 *bo_idx = 0;
 218                 return HAL_TBM_ERROR_NONE;
 219         case HAL_TBM_FORMAT_NV21:
 220                 if (plane_idx == 0) {
 221                         *size = width * height;
 222                         *offset = 0;
 223                         *pitch = width;
 224                         *bo_idx = 0;
 225                 } else if (plane_idx == 1) {
 226                         *size = width * (height >> 1);
 227                         *offset = width * height;
 228                         *pitch = width;
 229                         *bo_idx = 0;
 230                 } else {
 231                         return HAL_TBM_ERROR_INVALID_PARAMETER;
 232                 }
 233                 return HAL_TBM_ERROR_NONE;
 234         case HAL_TBM_FORMAT_NV61:
 235                 if (plane_idx == 0) {
 236                         *size = width * height;
 237                         *offset = 0;
 238                         *pitch = width;
 239                         *bo_idx = 0;
 240                 } else if (plane_idx == 1) {
 241                         *size = width * height;
 242                         *offset = width * height;
 243                         *pitch = width;
 244                         *bo_idx = 0;
 245                 } else {
 246                         return HAL_TBM_ERROR_INVALID_PARAMETER;
 247                 }
 248                 return HAL_TBM_ERROR_NONE;
 249         case HAL_TBM_FORMAT_YUV420:
 250                 if (plane_idx == 0) {
 251                         *size = width * height;
 252                         *offset = 0;
 253                         *pitch = width;
 254                         *bo_idx = 0;
 255                 } else if (plane_idx == 1) {
 256                         *size = (width * height) >> 2;
 257                         *offset = width * height;
 258                         *pitch = width >> 1;
 259                         *bo_idx = 0;
 260                 } else if (plane_idx == 2) {
 261                         *size = (width * height) >> 2;
 262                         *offset = (width * height) + (width * height >> 2);
 263                         *pitch = width >> 1;
 264                         *bo_idx = 0;
 265                 } else {
 266                         return HAL_TBM_ERROR_INVALID_PARAMETER;
 267                 }
 268                 return HAL_TBM_ERROR_NONE;
 269         default:
 270                 return HAL_TBM_ERROR_INVALID_PARAMETER;
 271         }
 272 }
 273
 274 static hal_tbm_bo *
 275 tbm_vigs_bufmgr_alloc_bo(hal_tbm_bufmgr *bufmgr, unsigned int size,
 276                                         hal_tbm_bo_memory_type flags, hal_tbm_error *error)
 277 {
 278         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 279         tbm_vigs_bo *bo_data;
 280         struct vigs_drm_device *drm_dev;
 281         struct vigs_drm_surface *sfc;
 282         uint32_t width = 2048, height;
 283         int ret;
 284         char buf[STRERR_BUFSIZE];
 285
 286         if (bufmgr_data == NULL || bufmgr_data->drm_dev ==  NULL) {
 287                 TBM_BACKEND_ERR("bufmgr_data is null\n");
 288                 if (error)
 289                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 290                 return NULL;
 291         }
 292
 293         drm_dev = bufmgr_data->drm_dev;
 294
 295         height = ((uint32_t) size + (width * 4) - 1) / (width * 4);
 296
 297         ret = vigs_drm_surface_create(drm_dev, width, height, width * 4, vigs_drm_surface_bgra8888, 0, &sfc);
 298         if (ret != 0) {
 299                 TBM_BACKEND_ERR("vigs_drm_suface_create failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 300                 if (error)
 301                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 302                 return NULL;
 303         }
 304
 305         bo_data = calloc(1, sizeof(struct _tbm_vigs_bo));
 306         if (!bo_data) {
 307                 TBM_BACKEND_ERR("fail to allocate the bo_data private\n");
 308                 vigs_drm_gem_unref(&sfc->gem);
 309                 if (error)
 310                         *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
 311                 return NULL;
 312         }
 313         bo_data->bufmgr_data = bufmgr_data;
 314         bo_data->sfc = sfc;
 315
 316         ret = vigs_drm_gem_get_name(&sfc->gem);
 317         if (ret != 0) {
 318                 TBM_BACKEND_ERR("vigs_drm_gem_get_name failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 319                 vigs_drm_gem_unref(&sfc->gem);
 320                 free(bo_data);
 321                 if (error)
 322                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 323                 return 0;
 324         }
 325
 326         if (drmHashInsert(bufmgr_data->hash_bos, bo_data->sfc->gem.name, (void *)bo_data) < 0)
 327                 TBM_BACKEND_ERR("Cannot insert bo_data to Hash(%d)\n", bo_data->sfc->gem.name);
 328
 329         TBM_BACKEND_DBG("size = %d, flags = 0x%X", size, flags);
 330
 331         if (error)
 332                 *error = HAL_TBM_ERROR_NONE;
 333
 334         return (hal_tbm_bo *)bo_data;
 335 }
 336
 337 static hal_tbm_bo *
 338 tbm_vigs_bufmgr_alloc_bo_with_format(hal_tbm_bufmgr *bufmgr, int format,  int bo_idx,
 339                                                                 int width, int height, int cpp, hal_tbm_bo_memory_type flags, hal_tbm_error *error)
 340 {
 341         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 342         tbm_vigs_bo *bo_data;
 343         struct vigs_drm_device *drm_dev;
 344         struct vigs_drm_surface *sfc;
 345         int ret;
 346         char buf[STRERR_BUFSIZE];
 347
 348         if (bufmgr_data == NULL || bufmgr_data->drm_dev ==  NULL) {
 349                 TBM_BACKEND_ERR("bufmgr_data is null\n");
 350                 if (error)
 351                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 352                 return NULL;
 353         }
 354
 355         if (bo_idx != 0) {
 356                 TBM_BACKEND_ERR("Not supported bo idx");
 357                 if (error)
 358                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 359                 return NULL;
 360         }
 361
 362         drm_dev = bufmgr_data->drm_dev;
 363
 364         switch (format) {
 365         case HAL_TBM_FORMAT_RGB888:
 366                 ret = vigs_drm_surface_create(drm_dev, width, height, width * 3, vigs_drm_surface_bgra8888, 0, &sfc);
 367                 break;
 368         case HAL_TBM_FORMAT_XRGB8888:
 369         case HAL_TBM_FORMAT_XBGR8888:
 370                 ret = vigs_drm_surface_create(drm_dev, width, height, width * 4, vigs_drm_surface_bgra8888, 0, &sfc);
 371                 break;
 372         case HAL_TBM_FORMAT_ARGB8888:
 373         case HAL_TBM_FORMAT_RGBA8888:
 374                 ret = vigs_drm_surface_create(drm_dev, width, height, width * 4, vigs_drm_surface_bgra8888, 0, &sfc);
 375                 break;
 376         case HAL_TBM_FORMAT_NV21:
 377                 ret = vigs_drm_surface_create(drm_dev, width, height * 3 >> 1, width, vigs_drm_surface_bgra8888, 0, &sfc);
 378                 break;
 379         case HAL_TBM_FORMAT_NV61:
 380                 ret = vigs_drm_surface_create(drm_dev, width, height * 2, width, vigs_drm_surface_bgra8888, 0, &sfc);
 381                 break;
 382         case HAL_TBM_FORMAT_YUV420:
 383                 ret = vigs_drm_surface_create(drm_dev, width >> 2, height * 3 >> 1, width, vigs_drm_surface_bgra8888, 0, &sfc);
 384                 break;
 385         default:
 386                 TBM_BACKEND_ERR("Not supported format");
 387                 if (error)
 388                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 389                 return NULL;
 390         }
 391
 392         if (ret != 0) {
 393                 TBM_BACKEND_ERR("vigs_drm_suface_create failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 394                 if (error)
 395                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 396                 return NULL;
 397         }
 398
 399         bo_data = calloc(1, sizeof(struct _tbm_vigs_bo));
 400         if (!bo_data) {
 401                 TBM_BACKEND_ERR("fail to allocate the bo_data private\n");
 402                 vigs_drm_gem_unref(&sfc->gem);
 403                 if (error)
 404                         *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
 405                 return NULL;
 406         }
 407         bo_data->bufmgr_data = bufmgr_data;
 408         bo_data->sfc = sfc;
 409
 410         ret = vigs_drm_gem_get_name(&sfc->gem);
 411         if (ret != 0) {
 412                 TBM_BACKEND_ERR("vigs_drm_gem_get_name failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 413                 vigs_drm_gem_unref(&sfc->gem);
 414                 free(bo_data);
 415                 if (error)
 416                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 417                 return 0;
 418         }
 419
 420         if (drmHashInsert(bufmgr_data->hash_bos, bo_data->sfc->gem.name, (void *)bo_data) < 0)
 421                 TBM_BACKEND_ERR("Cannot insert bo_data to Hash(%d)\n", bo_data->sfc->gem.name);
 422
 423         TBM_BACKEND_DBG("width = %d, height = %d, format = %x, flags = 0x%X bo_idx = %d",
 424                         width, height, format, flags, bo_idx);
 425
 426         if (error)
 427                 *error = HAL_TBM_ERROR_NONE;
 428
 429         return (hal_tbm_bo *)bo_data;
 430 }
 431
 432 static hal_tbm_bo *
 433 tbm_vigs_bufmgr_import_fd(hal_tbm_bufmgr *bufmgr, hal_tbm_fd key, hal_tbm_error *error)
 434 {
 435         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 436         tbm_vigs_bo *bo_data;
 437         struct vigs_drm_device *drm_dev;
 438         struct vigs_drm_surface *sfc;
 439         int ret;
 440         char buf[STRERR_BUFSIZE];
 441         struct drm_prime_handle arg = {0, };
 442         unsigned int gem;
 443         unsigned int name;
 444
 445         if (bufmgr_data == NULL || bufmgr_data->drm_dev ==  NULL) {
 446                 TBM_BACKEND_ERR("bufmgr_data is null\n");
 447                 if (error)
 448                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 449                 return NULL;
 450         }
 451
 452         drm_dev = bufmgr_data->drm_dev;
 453
 454         arg.fd = key;
 455         if (drmIoctl(bufmgr_data->drm_dev->fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &arg)) {
 456                 TBM_BACKEND_ERR("Cannot get gem handle from fd:%d (%s)\n",
 457                                arg.fd, strerror_r(errno, buf, STRERR_BUFSIZE));
 458                 if (error)
 459                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 460                 return NULL;
 461         }
 462         gem = arg.handle;
 463
 464         name = _get_name(bufmgr_data->drm_dev->fd, gem);
 465         if (!name) {
 466                 TBM_BACKEND_ERR("Cannot get name from gem:%d, fd:%d (%s)\n",
 467                                gem, key, strerror_r(errno, buf, STRERR_BUFSIZE));
 468                 if (error)
 469                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 470                 return NULL;
 471         }
 472
 473         ret = drmHashLookup(bufmgr_data->hash_bos, name, (void **)&bo_data);
 474         if (ret == 0) {
 475                 if (gem == bo_data->sfc->gem.handle) {
 476                         if (error)
 477                                 *error = HAL_TBM_ERROR_NONE;
 478                         return (hal_tbm_bo *)bo_data;
 479                 }
 480         }
 481
 482         ret = vigs_drm_prime_import_fd(drm_dev, key, &sfc);
 483         if (ret != 0) {
 484                 TBM_BACKEND_ERR("vigs_drm_prime_import_fd failed for key %d: %s",
 485                         key, strerror_r(errno, buf, STRERR_BUFSIZE));
 486                 if (error)
 487                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 488                 return NULL;
 489         }
 490
 491         bo_data = calloc(1, sizeof(struct _tbm_vigs_bo));
 492         if (!bo_data) {
 493                 TBM_BACKEND_ERR("fail to allocate the bo_data private\n");
 494                 vigs_drm_gem_unref(&sfc->gem);
 495                 if (error)
 496                         *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
 497                 return NULL;
 498         }
 499         bo_data->bufmgr_data = bufmgr_data;
 500         bo_data->sfc = sfc;
 501
 502         ret = vigs_drm_gem_get_name(&sfc->gem);
 503         if (ret != 0) {
 504                 TBM_BACKEND_ERR("vigs_drm_gem_get_name failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 505                 vigs_drm_gem_unref(&sfc->gem);
 506                 free(bo_data);
 507                 if (error)
 508                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 509                 return 0;
 510         }
 511
 512         if (drmHashInsert(bufmgr_data->hash_bos, bo_data->sfc->gem.name, (void *)bo_data) < 0)
 513                 TBM_BACKEND_ERR("Cannot insert bo_data to Hash(%d)\n", bo_data->sfc->gem.name);
 514
 515         TBM_BACKEND_DBG("bo_data = %p, key = %u handle = %u", bo_data, key, sfc->gem.handle);
 516
 517         if (error)
 518                 *error = HAL_TBM_ERROR_NONE;
 519
 520         return (hal_tbm_bo *)bo_data;
 521 }
 522
 523 static hal_tbm_bo *
 524 tbm_vigs_bufmgr_import_key(hal_tbm_bufmgr *bufmgr, hal_tbm_key key, hal_tbm_error *error)
 525 {
 526         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *)bufmgr;
 527         tbm_vigs_bo *bo_data;
 528         struct vigs_drm_device *drm_dev;
 529         int ret;
 530         struct vigs_drm_surface *sfc;
 531         char buf[STRERR_BUFSIZE];
 532
 533         if (bufmgr_data == NULL || bufmgr_data->drm_dev ==  NULL) {
 534                 TBM_BACKEND_ERR("bufmgr_data is null\n");
 535                 if (error)
 536                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 537                 return NULL;
 538         }
 539
 540         drm_dev = bufmgr_data->drm_dev;
 541
 542         ret = drmHashLookup(bufmgr_data->hash_bos, key, (void **)&bo_data);
 543         if (ret == 0) {
 544                 if (error)
 545                         *error = HAL_TBM_ERROR_NONE;
 546                 return (hal_tbm_bo *)bo_data;
 547         }
 548
 549         ret = vigs_drm_surface_open(drm_dev, key, &sfc);
 550         if (ret != 0) {
 551                 TBM_BACKEND_ERR("vigs_drm_surface_open failed for key %u: %s",
 552                         key, strerror_r(errno, buf, STRERR_BUFSIZE));
 553                 if (error)
 554                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 555                 return NULL;
 556         }
 557
 558         bo_data = calloc(1, sizeof(struct _tbm_vigs_bo));
 559         if (!bo_data) {
 560                 TBM_BACKEND_ERR("fail to allocate the bo_data private\n");
 561                 vigs_drm_gem_unref(&sfc->gem);
 562                 if (error)
 563                         *error = HAL_TBM_ERROR_OUT_OF_MEMORY;
 564                 return NULL;
 565         }
 566         bo_data->bufmgr_data = bufmgr_data;
 567         bo_data->sfc = sfc;
 568
 569         ret = vigs_drm_gem_get_name(&sfc->gem);
 570         if (ret != 0) {
 571                 TBM_BACKEND_ERR("vigs_drm_gem_get_name failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 572                 vigs_drm_gem_unref(&sfc->gem);
 573                 free(bo_data);
 574                 if (error)
 575                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 576                 return 0;
 577         }
 578
 579         if (drmHashInsert(bufmgr_data->hash_bos, bo_data->sfc->gem.name, (void *)bo_data) < 0)
 580                 TBM_BACKEND_ERR("Cannot insert bo_data to Hash(%d)\n", bo_data->sfc->gem.name);
 581
 582         TBM_BACKEND_DBG("bo_data = %p, key = %u handle = %u", bo_data, key, sfc->gem.handle);
 583
 584         if (error)
 585                 *error = HAL_TBM_ERROR_NONE;
 586
 587         return (hal_tbm_bo *)bo_data;
 588 }
 589
 590 static void
 591 tbm_vigs_bo_free(hal_tbm_bo *bo)
 592 {
 593         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 594         tbm_vigs_bo *temp;
 595         struct vigs_drm_surface *sfc;
 596         tbm_vigs_bufmgr *bufmgr_data;
 597         int ret;
 598
 599         if (!bo_data)
 600                 return;
 601
 602         bufmgr_data = bo_data->bufmgr_data;
 603         if (!bufmgr_data)
 604                 return;
 605
 606         TBM_BACKEND_DBG("bo_data = %p", bo_data);
 607
 608         sfc = bo_data->sfc;
 609
 610         /* delete bo from hash */
 611         ret = drmHashLookup(bufmgr_data->hash_bos, bo_data->sfc->gem.name,
 612                              (void **)&temp);
 613         if (ret == 0)
 614                 drmHashDelete(bufmgr_data->hash_bos, bo_data->sfc->gem.name);
 615         else
 616                 TBM_BACKEND_ERR("Cannot find bo_data to Hash(%d), ret=%d\n", bo_data->sfc->gem.name, ret);
 617
 618         vigs_drm_gem_unref(&sfc->gem);
 619
 620         free(bo_data);
 621 }
 622
 623 static int
 624 tbm_vigs_bo_get_size(hal_tbm_bo *bo, hal_tbm_error *error)
 625 {
 626         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 627         struct vigs_drm_surface *sfc;
 628
 629         if (!bo_data || !bo_data->sfc) {
 630                 if (error)
 631                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 632                 return 0;
 633         }
 634
 635         TBM_BACKEND_DBG("bo_data = %p", bo_data);
 636
 637         sfc = bo_data->sfc;
 638
 639         if (error)
 640                 *error = HAL_TBM_ERROR_NONE;
 641
 642         return sfc->gem.size;
 643 }
 644
 645 static hal_tbm_bo_memory_type
 646 tbm_vigs_bo_get_memory_type(hal_tbm_bo *bo, hal_tbm_error *error)
 647 {
 648         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 649
 650         if (!bo_data || !bo_data->sfc) {
 651                 if (error)
 652                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 653                 return HAL_TBM_BO_DEFAULT;
 654         }
 655
 656         if (error)
 657                 *error = HAL_TBM_ERROR_NONE;
 658
 659         return HAL_TBM_BO_DEFAULT;
 660 }
 661
 662 static hal_tbm_bo_handle
 663 tbm_vigs_bo_get_handle(hal_tbm_bo *bo, hal_tbm_bo_device_type device, hal_tbm_error *error)
 664 {
 665         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 666         struct vigs_drm_surface *sfc;
 667         hal_tbm_bo_handle handle;
 668
 669         if (!bo_data || !bo_data->sfc) {
 670                 if (error)
 671                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 672                 return (hal_tbm_bo_handle) NULL;
 673         }
 674
 675         sfc = bo_data->sfc;
 676
 677         TBM_BACKEND_DBG("bo_data = %p, device = %d", bo_data, device);
 678
 679         handle = get_tbm_bo_handle(sfc, device);
 680         if (!handle.ptr) {
 681                 if (error)
 682                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 683                 return handle;
 684         }
 685
 686         if (error)
 687                 *error = HAL_TBM_ERROR_NONE;
 688
 689         return handle;
 690 }
 691
 692 static hal_tbm_bo_handle
 693 tbm_vigs_bo_map(hal_tbm_bo *bo, hal_tbm_bo_device_type device,
 694                                 hal_tbm_bo_access_option opt, hal_tbm_error *error)
 695 {
 696         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 697         struct vigs_drm_surface *sfc;
 698         hal_tbm_bo_handle handle;
 699         uint32_t saf = 0;
 700
 701         if (!bo_data || !bo_data->sfc) {
 702                 if (error)
 703                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 704                 return (hal_tbm_bo_handle) NULL;
 705         }
 706
 707         sfc = bo_data->sfc;
 708
 709         TBM_BACKEND_DBG("bo_data = %p, device = %d, opt = %d", bo_data, device, opt);
 710
 711         handle = get_tbm_bo_handle(sfc, device);
 712         if (!handle.ptr) {
 713                 if (error)
 714                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 715                 return handle;
 716         }
 717
 718         if ((opt & HAL_TBM_OPTION_READ) != 0)
 719                 saf |= VIGS_DRM_SAF_READ;
 720
 721         if ((opt & HAL_TBM_OPTION_WRITE) != 0)
 722                 saf |= VIGS_DRM_SAF_WRITE;
 723
 724         vigs_drm_surface_start_access(sfc, saf);
 725
 726         if (error)
 727                 *error = HAL_TBM_ERROR_NONE;
 728
 729         return handle;
 730 }
 731
 732 static hal_tbm_error
 733 tbm_vigs_bo_unmap(hal_tbm_bo *bo)
 734 {
 735         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 736         struct vigs_drm_surface *sfc;
 737
 738         if (!bo_data || !bo_data->sfc)
 739                 return HAL_TBM_ERROR_INVALID_PARAMETER;
 740
 741         sfc = bo_data->sfc;
 742
 743         TBM_BACKEND_DBG("bo_data = %p", bo_data);
 744
 745         vigs_drm_surface_end_access(sfc, 1);
 746
 747         return HAL_TBM_ERROR_NONE;
 748 }
 749
 750 static hal_tbm_error
 751 tbm_vigs_bo_lock(hal_tbm_bo *bo, hal_tbm_bo_device_type device,
 752                                 hal_tbm_bo_access_option opt)
 753 {
 754         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 755
 756         if (!bo_data || !bo_data->sfc)
 757                 return HAL_TBM_ERROR_INVALID_PARAMETER;
 758
 759         TBM_BACKEND_DBG("bo_data = %p", bo_data);
 760
 761         return HAL_TBM_ERROR_NONE;
 762 }
 763
 764 static hal_tbm_error
 765 tbm_vigs_bo_unlock(hal_tbm_bo *bo)
 766 {
 767         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 768
 769         if (!bo_data || !bo_data->sfc)
 770                 return HAL_TBM_ERROR_INVALID_PARAMETER;
 771
 772         TBM_BACKEND_DBG("bo_data = %p", bo_data);
 773
 774         return HAL_TBM_ERROR_NONE;
 775 }
 776
 777 hal_tbm_fd
 778 tbm_vigs_bo_export_fd(hal_tbm_bo *bo, hal_tbm_error *error)
 779 {
 780         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 781         tbm_vigs_bufmgr *bufmgr_data;
 782         struct vigs_drm_surface *sfc;
 783         struct vigs_drm_device *drm_dev;
 784         int ret, fd = 0;
 785         char buf[STRERR_BUFSIZE];
 786
 787         if (!bo_data || !bo_data->sfc) {
 788                 if (error)
 789                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 790                 return -1;
 791         }
 792
 793         bufmgr_data = bo_data->bufmgr_data;
 794         if (!bufmgr_data || !bufmgr_data->drm_dev) {
 795                 if (error)
 796                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 797                 return -1;
 798         }
 799
 800         drm_dev = bufmgr_data->drm_dev;
 801         sfc = bo_data->sfc;
 802
 803         ret = vigs_drm_prime_export_fd(drm_dev, sfc, &fd);
 804         if (ret != 0) {
 805                 TBM_BACKEND_ERR("vigs_drm_prime_export_fd failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 806                 if (error)
 807                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 808                 return -1;
 809         }
 810
 811         TBM_BACKEND_DBG("    bo_data:%p, gem:%d(%d)\n", bo_data, sfc->gem);
 812
 813         if (error)
 814                 *error = HAL_TBM_ERROR_NONE;
 815
 816         return (hal_tbm_fd)fd;
 817 }
 818
 819 static hal_tbm_key
 820 tbm_vigs_bo_export_key(hal_tbm_bo *bo, hal_tbm_error *error)
 821 {
 822         tbm_vigs_bo *bo_data = (tbm_vigs_bo *)bo;
 823         struct vigs_drm_surface *sfc;
 824         int ret;
 825         char buf[STRERR_BUFSIZE];
 826
 827         if (!bo_data || !bo_data->sfc) {
 828                 if (error)
 829                         *error = HAL_TBM_ERROR_INVALID_PARAMETER;
 830                 return 0;
 831         }
 832
 833         sfc = bo_data->sfc;
 834
 835         ret = vigs_drm_gem_get_name(&sfc->gem);
 836         if (ret != 0) {
 837                 TBM_BACKEND_ERR("vigs_drm_gem_get_name failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 838                 if (error)
 839                         *error = HAL_TBM_ERROR_INVALID_OPERATION;
 840                 return 0;
 841         }
 842
 843         TBM_BACKEND_DBG("    bo_data:%p, gem:%d(%d)\n", bo_data, sfc->gem);
 844
 845         if (error)
 846                 *error = HAL_TBM_ERROR_NONE;
 847
 848         return (hal_tbm_key)sfc->gem.name;
 849 }
 850 static void
 851 _tbm_vigs_bufmgr_deinitialize(tbm_vigs_bufmgr *bufmgr_data)
 852 {
 853         if (bufmgr_data->drm_dev)
 854                 vigs_drm_device_destroy(bufmgr_data->drm_dev);
 855
 856         g_drm_dev = NULL;
 857 }
 858
 859 static hal_tbm_error
 860 _tbm_vigs_bufmgr_initailize(tbm_vigs_bufmgr *bufmgr_data)
 861 {
 862         struct vigs_drm_device *drm_dev = NULL;
 863         char buf[STRERR_BUFSIZE];
 864         int ret = 0;
 865
 866         ret = vigs_drm_device_create(bufmgr_data->fd, &drm_dev);
 867         if (ret != 0) {
 868                 TBM_BACKEND_ERR("vigs_drm_device_create failed: %s", strerror_r(errno, buf, STRERR_BUFSIZE));
 869                 vigs_drm_device_destroy(drm_dev);
 870                 g_drm_dev = NULL;
 871                 return HAL_TBM_ERROR_INVALID_OPERATION;
 872         }
 873
 874         bufmgr_data->drm_dev = drm_dev;
 875         g_drm_dev = drm_dev;
 876
 877         return HAL_TBM_ERROR_NONE;
 878 }
 879
 880 static hal_tbm_error
 881 _tbm_vigs_authenticated_drm_fd_handler(hal_tbm_fd auth_fd, void *user_data)
 882 {
 883         tbm_vigs_bufmgr *bufmgr_data = (tbm_vigs_bufmgr *) user_data;
 884         int ret = 0;
 885
 886         TBM_BACKEND_RETURN_VAL_IF_FAIL(bufmgr_data != NULL, HAL_TBM_ERROR_INVALID_PARAMETER);
 887
 888         bufmgr_data->fd = auth_fd;
 889         TBM_BACKEND_INFO("Get the authenticated drm_fd(%d)!\n", bufmgr_data->fd);
 890
 891         ret = _tbm_vigs_bufmgr_initailize(bufmgr_data);
 892         if (ret != HAL_TBM_ERROR_NONE) {
 893                 TBM_BACKEND_ERR("_tbm_vigs_bufmgr_initailize failed.");
 894                 return ret;
 895         }
 896
 897         return HAL_TBM_ERROR_NONE;
 898 }
 899
 900 static int
 901 hal_backend_tbm_vigs_exit(void *data)
 902 {
 903         hal_tbm_backend_data *backend_data = (hal_tbm_backend_data *)data;
 904         tbm_vigs_bufmgr *bufmgr_data;
 905         unsigned long key;
 906         void *value;
 907
 908         TBM_BACKEND_DBG("enter");
 909
 910         TBM_BACKEND_RETURN_VAL_IF_FAIL(backend_data != NULL, -1);
 911
 912         bufmgr_data = (tbm_vigs_bufmgr *)backend_data->bufmgr;
 913         TBM_BACKEND_RETURN_VAL_IF_FAIL(bufmgr_data != NULL, -1);
 914
 915         if (bufmgr_data->hash_bos) {
 916                 while (drmHashFirst(bufmgr_data->hash_bos, &key, &value) > 0) {
 917                         free(value);
 918                         drmHashDelete(bufmgr_data->hash_bos, key);
 919                 }
 920
 921                 drmHashDestroy(bufmgr_data->hash_bos);
 922                 bufmgr_data->hash_bos = NULL;
 923         }
 924
 925         if (backend_data->bufmgr_funcs)
 926                 free(backend_data->bufmgr_funcs);
 927         if (backend_data->bo_funcs)
 928                 free(backend_data->bo_funcs);
 929
 930         _tbm_vigs_bufmgr_deinitialize(bufmgr_data);
 931
 932         if (bufmgr_data->fd >= 0)
 933                 close(bufmgr_data->fd);
 934
 935         free(backend_data->bufmgr);
 936         free(backend_data);
 937
 938         return HAL_TBM_ERROR_NONE;
 939 }
 940
 941 static int
 942 hal_backend_tbm_vigs_init(void **data)
 943 {
 944         hal_tbm_backend_data *backend_data = NULL;
 945         hal_tbm_bufmgr_funcs *bufmgr_funcs = NULL;
 946         hal_tbm_bo_funcs *bo_funcs = NULL;
 947         tbm_vigs_bufmgr *bufmgr_data = NULL;
 948         int drm_fd = -1;
 949         int ret = 0;
 950
 951         TBM_BACKEND_DBG("enter");
 952
 953         /* allocate a hal_tbm_backend_data */
 954         backend_data = calloc(1, sizeof(struct _hal_tbm_backend_data));
 955         if (!backend_data) {
 956                 TBM_BACKEND_ERR("fail to alloc backend_data!\n");
 957                 *data = NULL;
 958                 return -1;
 959         }
 960         *data = backend_data;
 961
 962         /* allocate a hal_tbm_bufmgr */
 963         bufmgr_data = calloc(1, sizeof(struct _tbm_vigs_bufmgr));
 964         if (!bufmgr_data) {
 965                 TBM_BACKEND_ERR("fail to alloc bufmgr_data!\n");
 966                 goto fail_alloc_bufmgr_data;
 967         }
 968         backend_data->bufmgr = (hal_tbm_bufmgr *)bufmgr_data;
 969
 970         bufmgr_data->fd = -1;
 971
 972         // open drm_fd
 973         drm_fd = _tbm_vigs_open_drm();
 974         if (drm_fd < 0) {
 975                 TBM_BACKEND_ERR("fail to open drm!\n");
 976                 goto fail_open_drm;
 977         }
 978
 979         // set true when backend has a drm_device.
 980         backend_data->has_drm_device = 1;
 981
 982         // check if drm_fd is master_drm_fd.
 983         if (drmIsMaster(drm_fd)) {
 984                 // drm_fd is a master_drm_fd.
 985                 backend_data->drm_info.drm_fd = drm_fd;
 986                 backend_data->drm_info.is_master = 1;
 987
 988                 bufmgr_data->fd = drm_fd;
 989                 TBM_BACKEND_INFO("Get the master drm_fd(%d)!\n", bufmgr_data->fd);
 990
 991                 ret = _tbm_vigs_bufmgr_initailize(bufmgr_data);
 992                 if (ret != HAL_TBM_ERROR_NONE) {
 993                         TBM_BACKEND_ERR("_tbm_vigs_bufmgr_initailize failed.");
 994                         goto fail_create_vigs_drm_device;
 995                 }
 996         } else {
 997                 // drm_fd is not a master_drm_fd.
 998                 // request authenticated fd
 999                 close(drm_fd);
1000                 backend_data->drm_info.drm_fd = -1;
1001                 backend_data->drm_info.is_master = 0;
1002                 backend_data->drm_info.auth_drm_fd_func = _tbm_vigs_authenticated_drm_fd_handler;
1003                 backend_data->drm_info.user_data = bufmgr_data;
1004
1005                 TBM_BACKEND_INFO("A backend requests an authenticated drm_fd.\n");
1006         }
1007
1008         bufmgr_data->hash_bos = drmHashCreate();
1009
1010         /* alloc and register bufmgr_funcs */
1011         bufmgr_funcs = calloc(1, sizeof(struct _hal_tbm_bufmgr_funcs));
1012         if (!bufmgr_funcs) {
1013                 TBM_BACKEND_ERR("fail to alloc bufmgr_funcs!\n");
1014                 goto fail_alloc_bufmgr_funcs;
1015         }
1016         backend_data->bufmgr_funcs = bufmgr_funcs;
1017
1018         bufmgr_funcs->bufmgr_get_capabilities = tbm_vigs_bufmgr_get_capabilities;
1019         bufmgr_funcs->bufmgr_get_supported_formats = tbm_vigs_bufmgr_get_supported_formats;
1020         bufmgr_funcs->bufmgr_get_plane_data = tbm_vigs_bufmgr_get_plane_data;
1021         bufmgr_funcs->bufmgr_alloc_bo = tbm_vigs_bufmgr_alloc_bo;
1022         bufmgr_funcs->bufmgr_alloc_bo_with_format = tbm_vigs_bufmgr_alloc_bo_with_format;
1023         bufmgr_funcs->bufmgr_import_fd = tbm_vigs_bufmgr_import_fd;
1024         bufmgr_funcs->bufmgr_import_key = tbm_vigs_bufmgr_import_key;
1025
1026         /* alloc and register bo_funcs */
1027         bo_funcs = calloc(1, sizeof(struct _hal_tbm_bo_funcs));
1028         if (!bo_funcs) {
1029                 TBM_BACKEND_ERR("fail to alloc bo_funcs!\n");
1030                 goto fail_alloc_bo_funcs;
1031         }
1032         backend_data->bo_funcs = bo_funcs;
1033
1034         bo_funcs->bo_free = tbm_vigs_bo_free;
1035         bo_funcs->bo_get_size = tbm_vigs_bo_get_size;
1036         bo_funcs->bo_get_memory_types = tbm_vigs_bo_get_memory_type;
1037         bo_funcs->bo_get_handle = tbm_vigs_bo_get_handle;
1038         bo_funcs->bo_map = tbm_vigs_bo_map;
1039         bo_funcs->bo_unmap = tbm_vigs_bo_unmap;
1040         bo_funcs->bo_lock = tbm_vigs_bo_lock;
1041         bo_funcs->bo_unlock = tbm_vigs_bo_unlock;
1042         bo_funcs->bo_export_fd = tbm_vigs_bo_export_fd;
1043         bo_funcs->bo_export_key = tbm_vigs_bo_export_key;
1044
1045         TBM_BACKEND_DBG("drm_fd:%d\n", bufmgr_data->fd);
1046
1047         return HAL_TBM_ERROR_NONE;
1048
1049 fail_alloc_bo_funcs:
1050         free(bufmgr_funcs);
1051 fail_alloc_bufmgr_funcs:
1052         drmHashDestroy(bufmgr_data->hash_bos);
1053         _tbm_vigs_bufmgr_deinitialize(bufmgr_data);
1054 fail_create_vigs_drm_device:
1055         if (bufmgr_data->fd >= 0)
1056                 close(bufmgr_data->fd);
1057 fail_open_drm:
1058         free(bufmgr_data);
1059 fail_alloc_bufmgr_data:
1060         free(backend_data);
1061
1062         g_drm_dev = NULL;
1063         *data = NULL;
1064
1065         return -1;
1066 }
1067
1068 hal_backend hal_backend_tbm_data = {
1069         "vigs",
1070         "Samsung",
1071         HAL_ABI_VERSION_TIZEN_6_5,
1072         hal_backend_tbm_vigs_init,
1073         hal_backend_tbm_vigs_exit
1074 };
1075
1076 struct vigs_drm_device *
1077 libhal_backend_tbm_vigs_get_drm_dev(void)
1078 {
1079         return g_drm_dev;
1080 }