cros_gralloc/cros_gralloc_helpers.cc

   1 /*
   2  * Copyright 2016 The Chromium OS Authors. All rights reserved.
   3  * Use of this source code is governed by a BSD-style license that can be
   4  * found in the LICENSE file.
   5  */
   6
   7 #include "cros_gralloc_helpers.h"
   8
   9 #include <cstdlib>
  10 #include <cutils/log.h>
  11 #include <fcntl.h>
  12 #include <xf86drm.h>
  13
  14 uint64_t cros_gralloc_convert_flags(int flags)
  15 {
  16         uint64_t usage = BO_USE_NONE;
  17
  18         if (flags & GRALLOC_USAGE_CURSOR)
  19                 usage |= BO_USE_NONE;
  20         if ((flags & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_RARELY)
  21                 usage |= BO_USE_SW_READ_RARELY;
  22         if ((flags & GRALLOC_USAGE_SW_READ_MASK) == GRALLOC_USAGE_SW_READ_OFTEN)
  23                 usage |= BO_USE_SW_READ_OFTEN;
  24         if ((flags & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_RARELY)
  25                 usage |= BO_USE_SW_WRITE_RARELY;
  26         if ((flags & GRALLOC_USAGE_SW_WRITE_MASK) == GRALLOC_USAGE_SW_WRITE_OFTEN)
  27                 usage |= BO_USE_SW_WRITE_OFTEN;
  28         if (flags & GRALLOC_USAGE_HW_TEXTURE)
  29                 usage |= BO_USE_TEXTURE;
  30         if (flags & GRALLOC_USAGE_HW_RENDER)
  31                 usage |= BO_USE_RENDERING;
  32         if (flags & GRALLOC_USAGE_HW_2D)
  33                 usage |= BO_USE_RENDERING;
  34         if (flags & GRALLOC_USAGE_HW_COMPOSER)
  35                 /* HWC wants to use display hardware, but can defer to OpenGL. */
  36                 usage |= BO_USE_SCANOUT | BO_USE_TEXTURE;
  37         if (flags & GRALLOC_USAGE_HW_FB)
  38                 usage |= BO_USE_NONE;
  39         if (flags & GRALLOC_USAGE_EXTERNAL_DISP)
  40                 /* We're ignoring this flag until we decide what to with display link */
  41                 usage |= BO_USE_NONE;
  42         if (flags & GRALLOC_USAGE_PROTECTED)
  43                 usage |= BO_USE_PROTECTED;
  44         if (flags & GRALLOC_USAGE_HW_VIDEO_ENCODER)
  45                 /*HACK: See b/30054495 */
  46                 usage |= BO_USE_SW_READ_OFTEN;
  47         if (flags & GRALLOC_USAGE_HW_CAMERA_WRITE)
  48                 usage |= BO_USE_HW_CAMERA_WRITE;
  49         if (flags & GRALLOC_USAGE_HW_CAMERA_READ)
  50                 usage |= BO_USE_HW_CAMERA_READ;
  51         if (flags & GRALLOC_USAGE_HW_CAMERA_ZSL)
  52                 usage |= BO_USE_HW_CAMERA_ZSL;
  53         if (flags & GRALLOC_USAGE_RENDERSCRIPT)
  54                 /* We use CPU for compute. */
  55                 usage |= BO_USE_LINEAR;
  56
  57         return usage;
  58 }
  59
  60 uint32_t cros_gralloc_convert_format(int format)
  61 {
  62         /*
  63          * Conversion from HAL to fourcc-based DRV formats based on
  64          * platform_android.c in mesa.
  65          */
  66
  67         switch (format) {
  68         case HAL_PIXEL_FORMAT_BGRA_8888:
  69                 return DRM_FORMAT_ARGB8888;
  70         case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
  71                 return DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED;
  72         case HAL_PIXEL_FORMAT_RGB_565:
  73                 return DRM_FORMAT_RGB565;
  74         case HAL_PIXEL_FORMAT_RGB_888:
  75                 return DRM_FORMAT_RGB888;
  76         case HAL_PIXEL_FORMAT_RGBA_8888:
  77                 return DRM_FORMAT_ABGR8888;
  78         case HAL_PIXEL_FORMAT_RGBX_8888:
  79                 return DRM_FORMAT_XBGR8888;
  80         case HAL_PIXEL_FORMAT_YCbCr_420_888:
  81                 return DRM_FORMAT_FLEX_YCbCr_420_888;
  82         case HAL_PIXEL_FORMAT_YV12:
  83                 return DRM_FORMAT_YVU420_ANDROID;
  84         /*
  85          * Choose DRM_FORMAT_R8 because <system/graphics.h> requires the buffers
  86          * with a format HAL_PIXEL_FORMAT_BLOB have a height of 1, and width
  87          * equal to their size in bytes.
  88          */
  89         case HAL_PIXEL_FORMAT_BLOB:
  90                 return DRM_FORMAT_R8;
  91         }
  92
  93         return DRM_FORMAT_NONE;
  94 }
  95
  96 static int32_t cros_gralloc_query_rendernode(struct driver **drv, const char *undesired)
  97 {
  98         /*
  99          * Create a driver from rendernode while filtering out
 100          * the specified undesired driver.
 101          *
 102          * TODO(gsingh): Enable render nodes on udl/evdi.
 103          */
 104
 105         int fd;
 106         drmVersionPtr version;
 107         char const *str = "%s/renderD%d";
 108         int32_t num_nodes = 63;
 109         int32_t min_node = 128;
 110         int32_t max_node = (min_node + num_nodes);
 111
 112         for (int i = min_node; i < max_node; i++) {
 113                 char *node;
 114
 115                 if (asprintf(&node, str, DRM_DIR_NAME, i) < 0)
 116                         continue;
 117
 118                 fd = open(node, O_RDWR, 0);
 119                 free(node);
 120
 121                 if (fd < 0)
 122                         continue;
 123
 124                 version = drmGetVersion(fd);
 125                 if (!version)
 126                         continue;
 127
 128                 if (undesired && !strcmp(version->name, undesired)) {
 129                         drmFreeVersion(version);
 130                         continue;
 131                 }
 132
 133                 drmFreeVersion(version);
 134                 *drv = drv_create(fd);
 135
 136                 if (*drv)
 137                         return CROS_GRALLOC_ERROR_NONE;
 138         }
 139
 140         return CROS_GRALLOC_ERROR_NO_RESOURCES;
 141 }
 142
 143 int32_t cros_gralloc_rendernode_open(struct driver **drv)
 144 {
 145         int32_t ret;
 146         ret = cros_gralloc_query_rendernode(drv, "vgem");
 147
 148         /* Allow vgem driver if no hardware is found. */
 149         if (ret)
 150                 ret = cros_gralloc_query_rendernode(drv, NULL);
 151
 152         return ret;
 153 }
 154
 155 int32_t cros_gralloc_validate_handle(struct cros_gralloc_handle *hnd)
 156 {
 157         if (!hnd || hnd->magic != cros_gralloc_magic)
 158                 return CROS_GRALLOC_ERROR_BAD_HANDLE;
 159
 160         return CROS_GRALLOC_ERROR_NONE;
 161 }
 162
 163 void cros_gralloc_log(const char *prefix, const char *file, int line, const char *format, ...)
 164 {
 165         char buf[50];
 166         snprintf(buf, sizeof(buf), "[%s:%s(%d)]", prefix, basename(file), line);
 167
 168         va_list args;
 169         va_start(args, format);
 170         __android_log_vprint(ANDROID_LOG_ERROR, buf, format, args);
 171         va_end(args);
 172 }