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 = DRV_BO_USE_NONE;
  17
  18         if (flags & GRALLOC_USAGE_CURSOR)
  19                 usage |= DRV_BO_USE_CURSOR;
  20         if ((flags & sw_read()) == GRALLOC_USAGE_SW_READ_RARELY)
  21                 usage |= DRV_BO_USE_SW_READ_RARELY;
  22         if ((flags & sw_read()) == GRALLOC_USAGE_SW_READ_OFTEN)
  23                 usage |= DRV_BO_USE_SW_READ_OFTEN;
  24         if ((flags & sw_write()) == GRALLOC_USAGE_SW_WRITE_RARELY)
  25                 usage |= DRV_BO_USE_SW_WRITE_RARELY;
  26         if ((flags & sw_write()) == GRALLOC_USAGE_SW_WRITE_OFTEN)
  27                 usage |= DRV_BO_USE_SW_WRITE_OFTEN;
  28         if (flags & GRALLOC_USAGE_HW_TEXTURE)
  29                 usage |= DRV_BO_USE_RENDERING;
  30         if (flags & GRALLOC_USAGE_HW_RENDER)
  31                 usage |= DRV_BO_USE_RENDERING;
  32         if (flags & GRALLOC_USAGE_HW_2D)
  33                 usage |= DRV_BO_USE_RENDERING;
  34         if (flags & GRALLOC_USAGE_HW_COMPOSER)
  35         /* HWC wants to use display hardware, but can defer to OpenGL. */
  36                 usage |= DRV_BO_USE_SCANOUT | DRV_BO_USE_RENDERING;
  37         if (flags & GRALLOC_USAGE_HW_FB)
  38                 usage |= DRV_BO_USE_SCANOUT;
  39         if (flags & GRALLOC_USAGE_EXTERNAL_DISP)
  40         /* We're ignoring this flag until we decide what to with display link */
  41                 usage |= DRV_BO_USE_NONE;
  42         if (flags & GRALLOC_USAGE_PROTECTED)
  43                 usage |= DRV_BO_USE_PROTECTED;
  44         if (flags & GRALLOC_USAGE_HW_VIDEO_ENCODER)
  45                 /*HACK: See b/30054495 */
  46                 usage |= DRV_BO_USE_SW_READ_OFTEN;
  47         if (flags & GRALLOC_USAGE_HW_CAMERA_WRITE)
  48                 usage |= DRV_BO_USE_HW_CAMERA_WRITE;
  49         if (flags & GRALLOC_USAGE_HW_CAMERA_READ)
  50                 usage |= DRV_BO_USE_HW_CAMERA_READ;
  51         if (flags & GRALLOC_USAGE_HW_CAMERA_ZSL)
  52                 usage |= DRV_BO_USE_HW_CAMERA_ZSL;
  53         if (flags & GRALLOC_USAGE_RENDERSCRIPT)
  54                 usage |= DRV_BO_USE_RENDERSCRIPT;
  55
  56         return usage;
  57 }
  58
  59 uint32_t cros_gralloc_convert_format(int format)
  60 {
  61         /*
  62          * Conversion from HAL to fourcc-based DRV formats based on
  63          * platform_android.c in mesa.
  64          */
  65
  66         switch (format) {
  67         case HAL_PIXEL_FORMAT_BGRA_8888:
  68                 return DRM_FORMAT_ARGB8888;
  69         case HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED:
  70                 return DRM_FORMAT_FLEX_IMPLEMENTATION_DEFINED;
  71         case HAL_PIXEL_FORMAT_RGB_565:
  72                 return DRM_FORMAT_RGB565;
  73         case HAL_PIXEL_FORMAT_RGB_888:
  74                 return DRM_FORMAT_RGB888;
  75         case HAL_PIXEL_FORMAT_RGBA_8888:
  76                 return DRM_FORMAT_ABGR8888;
  77         case HAL_PIXEL_FORMAT_RGBX_8888:
  78                 return DRM_FORMAT_XBGR8888;
  79         case HAL_PIXEL_FORMAT_YCbCr_420_888:
  80                 return DRM_FORMAT_FLEX_YCbCr_420_888;
  81         case HAL_PIXEL_FORMAT_YV12:
  82                 return DRM_FORMAT_YVU420;
  83         }
  84
  85         return DRM_FORMAT_NONE;
  86 }
  87
  88 static int32_t cros_gralloc_query_rendernode(struct driver **drv,
  89                                              const char *name)
  90 {
  91         /* TODO(gsingh): Enable render nodes on udl/evdi. */
  92         int fd;
  93         drmVersionPtr version;
  94         char const *str = "%s/renderD%d";
  95         int32_t num_nodes = 63;
  96         int32_t min_node = 128;
  97         int32_t max_node = (min_node + num_nodes);
  98
  99         for (int i = min_node; i < max_node; i++) {
 100                 char *node;
 101
 102                 if (asprintf(&node, str, DRM_DIR_NAME, i) < 0)
 103                         continue;
 104
 105                 fd = open(node, O_RDWR, 0);
 106                 free(node);
 107
 108                 if (fd < 0)
 109                         continue;
 110
 111                 version = drmGetVersion(fd);
 112
 113                 if (version && name && !strcmp(version->name, name)) {
 114                         drmFreeVersion(version);
 115                         continue;
 116                 }
 117
 118                 drmFreeVersion(version);
 119                 *drv = drv_create(fd);
 120
 121                 if (*drv)
 122                         return CROS_GRALLOC_ERROR_NONE;
 123         }
 124
 125         return CROS_GRALLOC_ERROR_NO_RESOURCES;
 126 }
 127
 128 int32_t cros_gralloc_rendernode_open(struct driver **drv)
 129 {
 130         int32_t ret;
 131         ret = cros_gralloc_query_rendernode(drv, NULL);
 132
 133         /* Look for vgem driver if no hardware is found. */
 134         if (ret)
 135                 ret = cros_gralloc_query_rendernode(drv, "vgem");
 136
 137         return ret;
 138 }
 139
 140 int32_t cros_gralloc_validate_handle(struct cros_gralloc_handle *hnd)
 141 {
 142         if (!hnd || hnd->magic != cros_gralloc_magic())
 143                 return CROS_GRALLOC_ERROR_BAD_HANDLE;
 144
 145         return CROS_GRALLOC_ERROR_NONE;
 146 }
 147
 148 void cros_gralloc_log(const char *prefix, const char *file, int line,
 149                       const char *format, ...)
 150 {
 151         va_list args;
 152         va_start(args, format);
 153         ALOGE("%s - [%s(%d)]", prefix, basename(file), line);
 154         __android_log_vprint(ANDROID_LOG_ERROR, prefix, format, args);
 155         va_end(args);
 156 }