helpers.c

   1 /*
   2  * Copyright (c) 2014 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 <stdlib.h>
   8 #include <stdio.h>
   9 #include <string.h>
  10 #include <xf86drm.h>
  11
  12 #include "gbm_priv.h"
  13 #include "helpers.h"
  14
  15 int gbm_bpp_from_format(uint32_t format)
  16 {
  17         if (format == GBM_BO_FORMAT_XRGB8888)
  18                 format = GBM_FORMAT_XRGB8888;
  19         if (format == GBM_BO_FORMAT_ARGB8888)
  20                 format = GBM_FORMAT_ARGB8888;
  21
  22         switch(format)
  23         {
  24                 case GBM_FORMAT_C8:
  25                 case GBM_FORMAT_RGB332:
  26                 case GBM_FORMAT_BGR233:
  27                         return 8;
  28
  29                 case GBM_FORMAT_XRGB4444:
  30                 case GBM_FORMAT_XBGR4444:
  31                 case GBM_FORMAT_RGBX4444:
  32                 case GBM_FORMAT_BGRX4444:
  33                 case GBM_FORMAT_ARGB4444:
  34                 case GBM_FORMAT_ABGR4444:
  35                 case GBM_FORMAT_RGBA4444:
  36                 case GBM_FORMAT_BGRA4444:
  37                 case GBM_FORMAT_XRGB1555:
  38                 case GBM_FORMAT_XBGR1555:
  39                 case GBM_FORMAT_RGBX5551:
  40                 case GBM_FORMAT_BGRX5551:
  41                 case GBM_FORMAT_ARGB1555:
  42                 case GBM_FORMAT_ABGR1555:
  43                 case GBM_FORMAT_RGBA5551:
  44                 case GBM_FORMAT_BGRA5551:
  45                 case GBM_FORMAT_RGB565:
  46                 case GBM_FORMAT_BGR565:
  47                         return 16;
  48
  49                 case GBM_FORMAT_RGB888:
  50                 case GBM_FORMAT_BGR888:
  51                         return 24;
  52
  53                 case GBM_FORMAT_XRGB8888:
  54                 case GBM_FORMAT_XBGR8888:
  55                 case GBM_FORMAT_RGBX8888:
  56                 case GBM_FORMAT_BGRX8888:
  57                 case GBM_FORMAT_ARGB8888:
  58                 case GBM_FORMAT_ABGR8888:
  59                 case GBM_FORMAT_RGBA8888:
  60                 case GBM_FORMAT_BGRA8888:
  61                 case GBM_FORMAT_XRGB2101010:
  62                 case GBM_FORMAT_XBGR2101010:
  63                 case GBM_FORMAT_RGBX1010102:
  64                 case GBM_FORMAT_BGRX1010102:
  65                 case GBM_FORMAT_ARGB2101010:
  66                 case GBM_FORMAT_ABGR2101010:
  67                 case GBM_FORMAT_RGBA1010102:
  68                 case GBM_FORMAT_BGRA1010102:
  69                 case GBM_FORMAT_YUYV:
  70                 case GBM_FORMAT_YVYU:
  71                 case GBM_FORMAT_UYVY:
  72                 case GBM_FORMAT_VYUY:
  73                 case GBM_FORMAT_AYUV:
  74                         return 32;
  75         }
  76
  77         printf("UNKNOWN FORMAT %d\n", format);
  78         return 0;
  79 }
  80
  81 int gbm_bytes_from_format(uint32_t format)
  82 {
  83         return gbm_bpp_from_format(format) / 8;
  84 }
  85
  86 int gbm_is_format_supported(struct gbm_bo *bo)
  87 {
  88         return 1;
  89 }
  90
  91 int gbm_dumb_bo_create(struct gbm_bo *bo, uint32_t width, uint32_t height, uint32_t format, uint32_t flags)
  92 {
  93         struct drm_mode_create_dumb create_dumb;
  94         int ret;
  95
  96         memset(&create_dumb, 0, sizeof(create_dumb));
  97         create_dumb.height = height;
  98         create_dumb.width = width;
  99         create_dumb.bpp = gbm_bpp_from_format(format);
 100         create_dumb.flags = 0;
 101
 102         ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb);
 103         if (ret) {
 104                 fprintf(stderr, "minigbm: DRM_IOCTL_MODE_CREATE_DUMB failed "
 105                                 "(handle=%x)\n", bo->handle.u32);
 106                 return ret;
 107         }
 108
 109         bo->handle.u32 = create_dumb.handle;
 110         bo->size = create_dumb.size;
 111         bo->stride = create_dumb.pitch;
 112
 113         return 0;
 114 }
 115
 116 int gbm_dumb_bo_destroy(struct gbm_bo *bo)
 117 {
 118         struct drm_mode_destroy_dumb destroy_dumb;
 119         int ret;
 120
 121         memset(&destroy_dumb, 0, sizeof(destroy_dumb));
 122         destroy_dumb.handle = bo->handle.u32;
 123
 124         ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
 125         if (ret) {
 126                 fprintf(stderr, "minigbm: DRM_IOCTL_MODE_DESTROY_DUMB failed "
 127                                 "(handle=%x)\n", bo->handle.u32);
 128                 return ret;
 129         }
 130
 131         return 0;
 132 }
 133
 134 int gbm_gem_bo_destroy(struct gbm_bo *bo)
 135 {
 136         struct drm_gem_close gem_close;
 137         int ret;
 138
 139         memset(&gem_close, 0, sizeof(gem_close));
 140         gem_close.handle = bo->handle.u32;
 141
 142         ret = drmIoctl(bo->gbm->fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
 143         if (ret) {
 144                 fprintf(stderr, "minigbm: DRM_IOCTL_GEM_CLOSE failed "
 145                                 "(handle=%x)\n", bo->handle.u32);
 146                 return ret;
 147         }
 148
 149         return 0;
 150 }