src/nx_video_alloc.c

   1 /*
   2  * Copyright (C) 2016  Nexell Co., Ltd.
   3  * Author: SeongO, Park <ray@nexell.co.kr>
   4  */
   5
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <unistd.h>
   9 #include <fcntl.h>
  10 #include <stdint.h>
  11 #include <errno.h>
  12 #include <stdarg.h>
  13 #include <ctype.h>
  14 #include <string.h>
  15 #include <strings.h>
  16
  17 #include <sys/types.h>
  18 #include <sys/stat.h>
  19 #include <sys/ioctl.h>
  20 #include <sys/mman.h>           //      PROT_READ/PROT_WRITE/MAP_SHARED/mmap/munmap
  21
  22 #include <nexell/nexell_drm.h>
  23 #include <nx_video_alloc.h>
  24
  25 #include <libdrm/drm_fourcc.h>
  26 #include <linux/videodev2.h>
  27 #include <linux/videodev2_nxp_media.h>
  28 #ifdef TIZEN_FEATURE_ARTIK530
  29 #include <tbm_bufmgr.h>
  30 #endif
  31 #include "nx_video_log.h"
  32
  33 #define DRM_DEVICE_NAME "/dev/dri/renderD128"
  34
  35 #define DRM_IOCTL_NR(n)         _IOC_NR(n)
  36 #define DRM_IOC_VOID            _IOC_NONE
  37 #define DRM_IOC_READ            _IOC_READ
  38 #define DRM_IOC_WRITE           _IOC_WRITE
  39 #define DRM_IOC_READWRITE       _IOC_READ|_IOC_WRITE
  40 #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
  41
  42 static int
  43 drm_ioctl (int32_t drm_fd, uint32_t request, void *arg)
  44 {
  45   int ret;
  46
  47   do {
  48     ret = ioctl (drm_fd, request, arg);
  49   } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
  50   return ret;
  51 }
  52
  53 static int
  54 drm_command_write_read (int fd, uint32_t command_index,
  55     void *data, uint32_t size)
  56 {
  57   uint32_t request;
  58
  59   request = DRM_IOC (DRM_IOC_READ | DRM_IOC_WRITE, DRM_IOCTL_BASE,
  60       DRM_COMMAND_BASE + command_index, size);
  61   if (drm_ioctl (fd, request, data))
  62     return -errno;
  63   return 0;
  64 }
  65
  66 /**
  67  * return gem_fd
  68  */
  69 static int
  70 alloc_gem (int drm_fd, int size, int flags)
  71 {
  72   struct nx_drm_gem_create arg = { 0, };
  73   int ret;
  74
  75   arg.size = (uint32_t) size;
  76   arg.flags = flags;
  77
  78   ret = drm_command_write_read (drm_fd, DRM_NX_GEM_CREATE, &arg, sizeof (arg));
  79   if (ret) {
  80     _E ("drm_command_write_read(errno=%d, flags=%d)\n", -ret, flags);
  81     return ret;
  82   }
  83   //_D ("[DRM ALLOC] gem %d, size %d, flags 0x%x\n", arg.handle, size, flags);
  84
  85   return arg.handle;
  86 }
  87
  88 static void
  89 free_gem (int drm_fd, int gem)
  90 {
  91   struct drm_gem_close arg = { 0, };
  92
  93   arg.handle = gem;
  94   drm_ioctl (drm_fd, DRM_IOCTL_GEM_CLOSE, &arg);
  95 }
  96
  97 /**
  98  * return dmabuf fd
  99  */
 100 static int
 101 gem_to_dmafd (int drm_fd, int gem_fd)
 102 {
 103   int ret;
 104   struct drm_prime_handle arg = { 0, };
 105
 106   arg.handle = gem_fd;
 107   arg.flags = O_CLOEXEC | O_RDWR;
 108   ret = drm_ioctl (drm_fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &arg);
 109   if (0 != ret) {
 110     _E ("fail : get fd from gem:%d (DRM_IOCTL_PRIME_HANDLE_TO_FD)\n", ret);
 111     return -1;
 112   }
 113   return arg.fd;
 114 }
 115
 116 static uint32_t
 117 get_flink_name (int fd, int gem)
 118 {
 119   struct drm_gem_flink arg = { 0, };
 120
 121   arg.handle = gem;
 122   if (drm_ioctl (fd, DRM_IOCTL_GEM_FLINK, &arg)) {
 123     _E ("fail : get flink from gem:%d (DRM_IOCTL_GEM_FLINK)\n", gem);
 124     return 0;
 125   }
 126   return arg.name;
 127 }
 128
 129 static uint32_t
 130 gem_from_flink (int fd, uint32_t flink_name)
 131 {
 132   struct drm_gem_open arg = { 0, };
 133   /* struct nx_drm_gem_info info = { 0, }; */
 134
 135   arg.name = flink_name;
 136   if (drm_ioctl (fd, DRM_IOCTL_GEM_OPEN, &arg)) {
 137     _E ("fail : cannot open gem name=%d\n", flink_name);
 138     return -EINVAL;
 139   }
 140   return arg.handle;
 141 }
 142
 143
 144 //
 145 //      Nexell Private Video Memory Allocator for DRM
 146 //
 147
 148 #ifndef ALIGN
 149 #define ALIGN(X,N)      ( (X+N-1) & (~(N-1)) )
 150 #endif
 151
 152 #define ALIGNED16(X)    ALIGN(X,16)
 153
 154
 155 //      Nexell Private Memory Allocator
 156 NX_MEMORY_INFO *
 157 NX_AllocateMemory (int size, int align)
 158 {
 159   int gemFd = -1;
 160   int dmaFd = -1;
 161   int32_t flags = 0;
 162   NX_MEMORY_INFO *pMem;
 163
 164   int drmFd = open (DRM_DEVICE_NAME, O_RDWR);
 165   if (drmFd < 0)
 166     return NULL;
 167
 168   drmDropMaster (drmFd);
 169
 170   gemFd = alloc_gem (drmFd, size, flags);
 171   if (gemFd < 0)
 172     goto ErrorExit;
 173
 174   dmaFd = gem_to_dmafd (drmFd, gemFd);
 175   if (dmaFd < 0)
 176     goto ErrorExit;
 177
 178   pMem = (NX_MEMORY_INFO *) calloc (1, sizeof (NX_MEMORY_INFO));
 179   pMem->drmFd = drmFd;
 180   pMem->dmaFd = dmaFd;
 181   pMem->gemFd = gemFd;
 182   pMem->size = size;
 183   pMem->align = align;
 184   return pMem;
 185
 186 ErrorExit:
 187   if (gemFd > 0) {
 188     free_gem (drmFd, gemFd);
 189   }
 190   if (drmFd > 0)
 191     close (drmFd);
 192   return NULL;
 193 }
 194
 195 void
 196 NX_FreeMemory (NX_MEMORY_INFO * pMem)
 197 {
 198   if (pMem) {
 199     if (pMem->pBuffer) {
 200       munmap (pMem->pBuffer, pMem->size);
 201     }
 202
 203     free_gem (pMem->drmFd, pMem->gemFd);
 204     close (pMem->dmaFd);
 205     close (pMem->drmFd);
 206     free (pMem);
 207   }
 208 }
 209
 210
 211 //      Video Specific Allocator Wrapper
 212 //
 213 //      Suport Format & Planes
 214 //              YUV420 Format :
 215 //                      1 Plane : I420, NV12
 216 //                      2 Plane : NV12
 217 //                      3 Plane : I420
 218 //
 219 NX_VID_MEMORY_INFO *
 220 NX_AllocateVideoMemory (int width, int height, int32_t planes, uint32_t format,
 221     int align)
 222 {
 223   int gemFd[NX_MAX_PLANES] = { 0, };
 224   int dmaFd[NX_MAX_PLANES] = { 0, };
 225   int32_t flags = 0, i = 0;
 226   int32_t luStride, cStride;
 227   int32_t luVStride, cVStride;
 228   int32_t stride[NX_MAX_PLANES];
 229   int32_t size[NX_MAX_PLANES];
 230   uint32_t flink[NX_MAX_PLANES];
 231
 232   NX_VID_MEMORY_INFO *pVidMem;
 233
 234   int drmFd = open (DRM_DEVICE_NAME, O_RDWR);
 235   if (drmFd < 0)
 236     return NULL;
 237
 238   drmDropMaster (drmFd);
 239
 240   //      Luma
 241   luStride = ALIGN (width, 32);
 242   luVStride = ALIGN (height, 16);
 243
 244   //      Chroma
 245   switch (format) {
 246     case DRM_FORMAT_YUV420:
 247     case DRM_FORMAT_NV12:
 248     case DRM_FORMAT_NV21:
 249     case V4L2_PIX_FMT_YUV420M:
 250     case V4L2_PIX_FMT_NV12M:
 251     case V4L2_PIX_FMT_NV21M:
 252       cStride = luStride / 2;
 253       cVStride = ALIGN (height / 2, 16);
 254       break;
 255
 256     case DRM_FORMAT_YUV422:
 257     case DRM_FORMAT_NV16:
 258     case DRM_FORMAT_NV61:
 259     case V4L2_PIX_FMT_YUV422M:
 260 #if 0                           // Disabled by DIGNSYS
 261     case V4L2_PIX_FMT_NV16M:
 262     case V4L2_PIX_FMT_NV61M:
 263 #endif
 264       cStride = luStride / 2;
 265       cVStride = luVStride;
 266       break;
 267
 268     case DRM_FORMAT_YUV444:
 269       //case DRM_FORMAT_NV24:
 270       //case DRM_FORMAT_NV42:
 271     case V4L2_PIX_FMT_YUV444M:
 272     case V4L2_PIX_FMT_NV24M:
 273     case V4L2_PIX_FMT_NV42M:
 274       cStride = luStride;
 275       cVStride = luVStride;
 276       break;
 277
 278     case V4L2_PIX_FMT_GREY:
 279       cStride = 0;
 280       cVStride = 0;
 281       break;
 282     default:
 283       _E ("Unknown format type\n");
 284       goto ErrorExit;
 285   }
 286
 287   //      Decide Memory Size
 288   switch (planes) {
 289     case 1:
 290       size[0] = luStride * luVStride + cStride * cVStride * 2;
 291       stride[0] = luStride;
 292       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 293       if (gemFd[0] < 0)
 294         goto ErrorExit;
 295       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 296       if (dmaFd[0] < 0)
 297         goto ErrorExit;
 298       break;
 299     case 2:
 300       //      Buffer 1
 301       size[0] = luStride * luVStride;
 302       stride[0] = luStride;
 303       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 304       if (gemFd[0] < 0)
 305         goto ErrorExit;
 306       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 307       if (dmaFd[0] < 0)
 308         goto ErrorExit;
 309
 310       //      Buffer 2
 311       size[1] = cStride * cVStride * 2;
 312       stride[1] = cStride * 2;
 313       gemFd[1] = alloc_gem (drmFd, size[1], flags);
 314       if (gemFd[1] < 0)
 315         goto ErrorExit;
 316       dmaFd[1] = gem_to_dmafd (drmFd, gemFd[1]);
 317       if (dmaFd[1] < 0)
 318         goto ErrorExit;
 319       break;
 320     case 3:
 321       //      Buffer 1
 322       size[0] = luStride * luVStride;
 323       stride[0] = luStride;
 324       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 325       if (gemFd[0] < 0)
 326         goto ErrorExit;
 327       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 328       if (dmaFd[0] < 0)
 329         goto ErrorExit;
 330
 331       //      Buffer 2
 332       size[1] = cStride * cVStride;
 333       stride[1] = cStride;
 334       gemFd[1] = alloc_gem (drmFd, size[1], flags);
 335       if (gemFd[1] < 0)
 336         goto ErrorExit;
 337       dmaFd[1] = gem_to_dmafd (drmFd, gemFd[1]);
 338       if (dmaFd[1] < 0)
 339         goto ErrorExit;
 340
 341       //      Buffer 3
 342       size[2] = cStride * cVStride;
 343       stride[2] = cStride;
 344       gemFd[2] = alloc_gem (drmFd, size[2], flags);
 345       if (gemFd[2] < 0)
 346         goto ErrorExit;
 347       dmaFd[2] = gem_to_dmafd (drmFd, gemFd[2]);
 348       if (dmaFd[2] < 0)
 349         goto ErrorExit;
 350       break;
 351       break;
 352   }
 353
 354   pVidMem = (NX_VID_MEMORY_INFO *) calloc (1, sizeof (NX_VID_MEMORY_INFO));
 355   if (!pVidMem)
 356     goto ErrorExit;
 357
 358 #ifdef TIZEN_FEATURE_ARTIK530
 359   pVidMem->bufmgr = tbm_bufmgr_init (drmFd);
 360   _D ("bufmgr = %p", pVidMem->bufmgr);
 361   if (!pVidMem->bufmgr)
 362     goto ErrorExit;
 363 #endif
 364
 365   pVidMem->width = width;
 366   pVidMem->height = height;
 367   pVidMem->align = align;
 368   pVidMem->planes = planes;
 369   pVidMem->format = format;
 370   pVidMem->drmFd = drmFd;
 371   for (i = 0; i < planes; i++) {
 372     pVidMem->dmaFd[i] = dmaFd[i];
 373     pVidMem->gemFd[i] = gemFd[i];
 374     pVidMem->size[i] = size[i];
 375     pVidMem->stride[i] = stride[i];
 376 #ifdef TIZEN_FEATURE_ARTIK530
 377     pVidMem->bo[i] = tbm_bo_import_fd (pVidMem->bufmgr, dmaFd[i]);
 378     _D ("bo[%d] = %p", i, pVidMem->bo[i]);
 379     if (!pVidMem->bo[i])
 380       goto alloc_bo_fail;
 381 #endif
 382   }
 383   return pVidMem;
 384
 385 #ifdef TIZEN_FEATURE_ARTIK530
 386 alloc_bo_fail:
 387   for (i = 0; i < planes; i++) {
 388     if (pVidMem->bo[i])
 389       tbm_bo_unref (pVidMem->bo[i]);
 390   }
 391 #endif
 392
 393 ErrorExit:
 394   for (i = 0; i < planes; i++) {
 395     if (gemFd[i] > 0) {
 396       free_gem (drmFd, gemFd[i]);
 397     }
 398     if (dmaFd[i] > 0) {
 399       close (dmaFd[i]);
 400     }
 401   }
 402   if (pVidMem) {
 403 #ifdef TIZEN_FEATURE_ARTIK530
 404     if (pVidMem->bufmgr)
 405       tbm_bufmgr_deinit (pVidMem->bufmgr);
 406 #endif
 407     free(pVidMem);
 408   }
 409   if (drmFd > 0)
 410     close (drmFd);
 411
 412   return NULL;
 413 }
 414
 415 void
 416 NX_FreeVideoMemory (NX_VID_MEMORY_INFO * pMem)
 417 {
 418   int32_t i;
 419   if (pMem) {
 420     for (i = 0; i < pMem->planes; i++) {
 421 #ifdef TIZEN_FEATURE_ARTIK530
 422       if (pMem->bo[i])
 423         tbm_bo_unref (pMem->bo[i]);
 424 #endif
 425       if (pMem->pBuffer[i]) {
 426         munmap (pMem->pBuffer[i], pMem->size[i]);
 427       }
 428       free_gem (pMem->drmFd, pMem->gemFd[i]);
 429       close (pMem->dmaFd[i]);
 430     }
 431 #ifdef TIZEN_FEATURE_ARTIK530
 432     if (pMem->bufmgr)
 433       tbm_bufmgr_deinit (pMem->bufmgr);
 434 #endif
 435     close (pMem->drmFd);
 436     free (pMem);
 437   }
 438 }
 439
 440
 441 //
 442 //              Memory Mapping/Unmapping Memory
 443 //
 444 int
 445 NX_MapMemory (NX_MEMORY_INFO * pMem)
 446 {
 447   void *pBuf;
 448   if (!pMem)
 449     return -1;
 450
 451   //      Already Mapped
 452   if (pMem->pBuffer)
 453     return -1;
 454
 455   pBuf =
 456       mmap (0, pMem->size, PROT_READ | PROT_WRITE, MAP_SHARED, pMem->dmaFd, 0);
 457   if (pBuf == MAP_FAILED) {
 458     _E ("Map failed : size %d, fd %d, error : %s\n", pMem->size, pMem->dmaFd, strerror(errno));
 459     return -1;
 460   }
 461   pMem->pBuffer = pBuf;
 462   return 0;
 463 }
 464
 465
 466 int
 467 NX_UnmapMemory (NX_MEMORY_INFO * pMem)
 468 {
 469   if (!pMem)
 470     return -1;
 471
 472   if (!pMem->pBuffer)
 473     return -1;
 474
 475   if (0 != munmap (pMem->pBuffer, pMem->size))
 476     return -1;
 477
 478   pMem->pBuffer = NULL;
 479   return 0;
 480 }
 481
 482 int
 483 NX_MapVideoMemory (NX_VID_MEMORY_INFO * pMem)
 484 {
 485   int32_t i;
 486   void *pBuf;
 487   if (!pMem)
 488     return -1;
 489
 490   //      Already Mapped
 491   for (i = 0; i < pMem->planes; i++) {
 492     if (pMem->pBuffer[i])
 493       return -1;
 494     else {
 495       pBuf =
 496           mmap (0, pMem->size[i], PROT_READ | PROT_WRITE, MAP_SHARED,
 497           pMem->dmaFd[i], 0);
 498       if (pBuf == MAP_FAILED) {
 499         return -1;
 500       }
 501     }
 502     pMem->pBuffer[i] = pBuf;
 503   }
 504   return 0;
 505 }
 506
 507 int
 508 NX_UnmapVideoMemory (NX_VID_MEMORY_INFO * pMem)
 509 {
 510   int32_t i;
 511   if (!pMem)
 512     return -1;
 513   for (i = 0; i < pMem->planes; i++) {
 514     if (pMem->pBuffer[i]) {
 515       munmap (pMem->pBuffer[i], pMem->size[i]);
 516     } else
 517       return -1;
 518   }
 519   return 0;
 520 }
 521
 522 int
 523 NX_GetGEMHandles (int drmFd, NX_VID_MEMORY_INFO * pMem,
 524     uint32_t handles[NX_MAX_PLANES])
 525 {
 526   int32_t i;
 527   memset (handles, 0, sizeof (uint32_t) * NX_MAX_PLANES);
 528
 529   for (i = 0; i < pMem->planes; i++) {
 530     handles[i] = gem_from_flink (drmFd, pMem->flink[i]);
 531     if (0 > (int) handles[i]) {
 532       return -1;
 533     }
 534   }
 535   return 0;
 536 }
 537
 538 int
 539 NX_GetGemHandle (int drmFd, NX_VID_MEMORY_INFO * pMem, int32_t plane)
 540 {
 541   if (plane >= NX_MAX_PLANES || plane < 0)
 542     return -1;
 543
 544   return gem_from_flink (drmFd, pMem->flink[plane]);
 545 }