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/card0"
  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\n");
  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->flink = get_flink_name (drmFd, gemFd);
 183   pMem->size = size;
 184   pMem->align = align;
 185   return pMem;
 186
 187 ErrorExit:
 188   if (gemFd > 0) {
 189     free_gem (drmFd, gemFd);
 190   }
 191   if (drmFd > 0)
 192     close (drmFd);
 193   return NULL;
 194 }
 195
 196 void
 197 NX_FreeMemory (NX_MEMORY_INFO * pMem)
 198 {
 199   if (pMem) {
 200     if (pMem->pBuffer) {
 201       munmap (pMem->pBuffer, pMem->size);
 202     }
 203
 204     free_gem (pMem->drmFd, pMem->gemFd);
 205     close (pMem->dmaFd);
 206     close (pMem->drmFd);
 207     free (pMem);
 208   }
 209 }
 210
 211
 212 //      Video Specific Allocator Wrapper
 213 //
 214 //      Suport Format & Planes
 215 //              YUV420 Format :
 216 //                      1 Plane : I420, NV12
 217 //                      2 Plane : NV12
 218 //                      3 Plane : I420
 219 //
 220 NX_VID_MEMORY_INFO *
 221 NX_AllocateVideoMemory (int width, int height, int32_t planes, uint32_t format,
 222     int align)
 223 {
 224   int gemFd[NX_MAX_PLANES] = { 0, };
 225   int dmaFd[NX_MAX_PLANES] = { 0, };
 226   int32_t flags = 0, i = 0;
 227   int32_t luStride, cStride;
 228   int32_t luVStride, cVStride;
 229   int32_t stride[NX_MAX_PLANES];
 230   int32_t size[NX_MAX_PLANES];
 231   uint32_t flink[NX_MAX_PLANES];
 232
 233   NX_VID_MEMORY_INFO *pVidMem;
 234
 235   int drmFd = open (DRM_DEVICE_NAME, O_RDWR);
 236   if (drmFd < 0)
 237     return NULL;
 238
 239   drmDropMaster (drmFd);
 240
 241   //      Luma
 242   luStride = ALIGN (width, 32);
 243   luVStride = ALIGN (height, 16);
 244
 245   //      Chroma
 246   switch (format) {
 247     case DRM_FORMAT_YUV420:
 248     case DRM_FORMAT_NV12:
 249     case DRM_FORMAT_NV21:
 250     case V4L2_PIX_FMT_YUV420M:
 251     case V4L2_PIX_FMT_NV12M:
 252     case V4L2_PIX_FMT_NV21M:
 253       cStride = luStride / 2;
 254       cVStride = ALIGN (height / 2, 16);
 255       break;
 256
 257     case DRM_FORMAT_YUV422:
 258     case DRM_FORMAT_NV16:
 259     case DRM_FORMAT_NV61:
 260     case V4L2_PIX_FMT_YUV422M:
 261 #if 0                           // Disabled by DIGNSYS
 262     case V4L2_PIX_FMT_NV16M:
 263     case V4L2_PIX_FMT_NV61M:
 264 #endif
 265       cStride = luStride / 2;
 266       cVStride = luVStride;
 267       break;
 268
 269     case DRM_FORMAT_YUV444:
 270       //case DRM_FORMAT_NV24:
 271       //case DRM_FORMAT_NV42:
 272     case V4L2_PIX_FMT_YUV444M:
 273     case V4L2_PIX_FMT_NV24M:
 274     case V4L2_PIX_FMT_NV42M:
 275       cStride = luStride;
 276       cVStride = luVStride;
 277       break;
 278
 279     case V4L2_PIX_FMT_GREY:
 280       cStride = 0;
 281       cVStride = 0;
 282       break;
 283     default:
 284       _E ("Unknown format type\n");
 285       goto ErrorExit;
 286   }
 287
 288   //      Decide Memory Size
 289   switch (planes) {
 290     case 1:
 291       size[0] = luStride * luVStride + cStride * cVStride * 2;
 292       stride[0] = luStride;
 293       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 294       if (gemFd[0] < 0)
 295         goto ErrorExit;
 296       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 297       if (dmaFd[0] < 0)
 298         goto ErrorExit;
 299       flink[0] = get_flink_name (drmFd, gemFd[0]);
 300       break;
 301     case 2:
 302       //      Buffer 1
 303       size[0] = luStride * luVStride;
 304       stride[0] = luStride;
 305       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 306       if (gemFd[0] < 0)
 307         goto ErrorExit;
 308       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 309       if (dmaFd[0] < 0)
 310         goto ErrorExit;
 311       flink[0] = get_flink_name (drmFd, gemFd[0]);
 312
 313       //      Buffer 2
 314       size[1] = cStride * cVStride * 2;
 315       stride[1] = cStride * 2;
 316       gemFd[1] = alloc_gem (drmFd, size[1], flags);
 317       if (gemFd[1] < 0)
 318         goto ErrorExit;
 319       dmaFd[1] = gem_to_dmafd (drmFd, gemFd[1]);
 320       if (dmaFd[1] < 0)
 321         goto ErrorExit;
 322       flink[1] = get_flink_name (drmFd, gemFd[1]);
 323       break;
 324     case 3:
 325       //      Buffer 1
 326       size[0] = luStride * luVStride;
 327       stride[0] = luStride;
 328       gemFd[0] = alloc_gem (drmFd, size[0], flags);
 329       if (gemFd[0] < 0)
 330         goto ErrorExit;
 331       dmaFd[0] = gem_to_dmafd (drmFd, gemFd[0]);
 332       if (dmaFd[0] < 0)
 333         goto ErrorExit;
 334       flink[0] = get_flink_name (drmFd, gemFd[0]);
 335
 336       //      Buffer 2
 337       size[1] = cStride * cVStride;
 338       stride[1] = cStride;
 339       gemFd[1] = alloc_gem (drmFd, size[1], flags);
 340       if (gemFd[1] < 0)
 341         goto ErrorExit;
 342       dmaFd[1] = gem_to_dmafd (drmFd, gemFd[1]);
 343       if (dmaFd[1] < 0)
 344         goto ErrorExit;
 345       flink[1] = get_flink_name (drmFd, gemFd[1]);
 346
 347       //      Buffer 3
 348       size[2] = cStride * cVStride;
 349       stride[2] = cStride;
 350       gemFd[2] = alloc_gem (drmFd, size[2], flags);
 351       if (gemFd[2] < 0)
 352         goto ErrorExit;
 353       dmaFd[2] = gem_to_dmafd (drmFd, gemFd[2]);
 354       if (dmaFd[2] < 0)
 355         goto ErrorExit;
 356       flink[2] = get_flink_name (drmFd, gemFd[2]);
 357       break;
 358       break;
 359   }
 360
 361   pVidMem = (NX_VID_MEMORY_INFO *) calloc (1, sizeof (NX_VID_MEMORY_INFO));
 362   if (!pVidMem)
 363     goto ErrorExit;
 364
 365 #ifdef TIZEN_FEATURE_ARTIK530
 366   pVidMem->bufmgr = tbm_bufmgr_init (drmFd);
 367   _D ("bufmgr = %p", pVidMem->bufmgr);
 368   if (!pVidMem->bufmgr)
 369     goto ErrorExit;
 370 #endif
 371
 372   pVidMem->width = width;
 373   pVidMem->height = height;
 374   pVidMem->align = align;
 375   pVidMem->planes = planes;
 376   pVidMem->format = format;
 377   pVidMem->drmFd = drmFd;
 378   for (i = 0; i < planes; i++) {
 379     pVidMem->dmaFd[i] = dmaFd[i];
 380     pVidMem->gemFd[i] = gemFd[i];
 381     pVidMem->size[i] = size[i];
 382     pVidMem->stride[i] = stride[i];
 383     pVidMem->flink[i] = flink[i];
 384 #ifdef TIZEN_FEATURE_ARTIK530
 385     pVidMem->bo[i] = tbm_bo_import (pVidMem->bufmgr, flink[i]);
 386     _D ("bo[%d] = %p", i, pVidMem->bo[i]);
 387     if (!pVidMem->bo[i])
 388       goto alloc_bo_fail;
 389 #endif
 390   }
 391   return pVidMem;
 392
 393 #ifdef TIZEN_FEATURE_ARTIK530
 394 alloc_bo_fail:
 395   for (i = 0; i < planes; i++) {
 396     if (pVidMem->bo[i])
 397       tbm_bo_unref (pVidMem->bo[i]);
 398   }
 399 #endif
 400
 401 ErrorExit:
 402   for (i = 0; i < planes; i++) {
 403     if (gemFd[i] > 0) {
 404       free_gem (drmFd, gemFd[i]);
 405     }
 406     if (dmaFd[i] > 0) {
 407       close (dmaFd[i]);
 408     }
 409   }
 410   if (pVidMem) {
 411 #ifdef TIZEN_FEATURE_ARTIK530
 412     if (pVidMem->bufmgr)
 413       tbm_bufmgr_deinit (pVidMem->bufmgr);
 414 #endif
 415     free(pVidMem);
 416   }
 417   if (drmFd > 0)
 418     close (drmFd);
 419
 420   return NULL;
 421 }
 422
 423 void
 424 NX_FreeVideoMemory (NX_VID_MEMORY_INFO * pMem)
 425 {
 426   int32_t i;
 427   if (pMem) {
 428     for (i = 0; i < pMem->planes; i++) {
 429 #ifdef TIZEN_FEATURE_ARTIK530
 430       if (pMem->bo[i])
 431         tbm_bo_unref (pMem->bo[i]);
 432 #endif
 433       if (pMem->pBuffer[i]) {
 434         munmap (pMem->pBuffer[i], pMem->size[i]);
 435       }
 436       free_gem (pMem->drmFd, pMem->gemFd[i]);
 437       close (pMem->dmaFd[i]);
 438     }
 439 #ifdef TIZEN_FEATURE_ARTIK530
 440     if (pMem->bufmgr)
 441       tbm_bufmgr_deinit (pMem->bufmgr);
 442 #endif
 443     close (pMem->drmFd);
 444     free (pMem);
 445   }
 446 }
 447
 448
 449 //
 450 //              Memory Mapping/Unmapping Memory
 451 //
 452 int
 453 NX_MapMemory (NX_MEMORY_INFO * pMem)
 454 {
 455   void *pBuf;
 456   if (!pMem)
 457     return -1;
 458
 459   //      Already Mapped
 460   if (pMem->pBuffer)
 461     return -1;
 462
 463   pBuf =
 464       mmap (0, pMem->size, PROT_READ | PROT_WRITE, MAP_SHARED, pMem->dmaFd, 0);
 465   if (pBuf == MAP_FAILED) {
 466     _E ("Map failed : size %d, fd %d, error : %s\n", pMem->size, pMem->dmaFd, strerror(errno));
 467     return -1;
 468   }
 469   pMem->pBuffer = pBuf;
 470   return 0;
 471 }
 472
 473
 474 int
 475 NX_UnmapMemory (NX_MEMORY_INFO * pMem)
 476 {
 477   if (!pMem)
 478     return -1;
 479
 480   if (!pMem->pBuffer)
 481     return -1;
 482
 483   if (0 != munmap (pMem->pBuffer, pMem->size))
 484     return -1;
 485
 486   pMem->pBuffer = NULL;
 487   return 0;
 488 }
 489
 490 int
 491 NX_MapVideoMemory (NX_VID_MEMORY_INFO * pMem)
 492 {
 493   int32_t i;
 494   void *pBuf;
 495   if (!pMem)
 496     return -1;
 497
 498   //      Already Mapped
 499   for (i = 0; i < pMem->planes; i++) {
 500     if (pMem->pBuffer[i])
 501       return -1;
 502     else {
 503       pBuf =
 504           mmap (0, pMem->size[i], PROT_READ | PROT_WRITE, MAP_SHARED,
 505           pMem->dmaFd[i], 0);
 506       if (pBuf == MAP_FAILED) {
 507         return -1;
 508       }
 509     }
 510     pMem->pBuffer[i] = pBuf;
 511   }
 512   return 0;
 513 }
 514
 515 int
 516 NX_UnmapVideoMemory (NX_VID_MEMORY_INFO * pMem)
 517 {
 518   int32_t i;
 519   if (!pMem)
 520     return -1;
 521   for (i = 0; i < pMem->planes; i++) {
 522     if (pMem->pBuffer[i]) {
 523       munmap (pMem->pBuffer[i], pMem->size[i]);
 524     } else
 525       return -1;
 526   }
 527   return 0;
 528 }
 529
 530 int
 531 NX_GetGEMHandles (int drmFd, NX_VID_MEMORY_INFO * pMem,
 532     uint32_t handles[NX_MAX_PLANES])
 533 {
 534   int32_t i;
 535   memset (handles, 0, sizeof (uint32_t) * NX_MAX_PLANES);
 536
 537   for (i = 0; i < pMem->planes; i++) {
 538     handles[i] = gem_from_flink (drmFd, pMem->flink[i]);
 539     if (0 > (int) handles[i]) {
 540       return -1;
 541     }
 542   }
 543   return 0;
 544 }
 545
 546 int
 547 NX_GetGemHandle (int drmFd, NX_VID_MEMORY_INFO * pMem, int32_t plane)
 548 {
 549   if (plane >= NX_MAX_PLANES || plane < 0)
 550     return -1;
 551
 552   return gem_from_flink (drmFd, pMem->flink[plane]);
 553 }