gbm.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 <stdint.h>
   9 #include <string.h>
  10 #include <xf86drm.h>
  11
  12 #include "gbm_priv.h"
  13 #include "util.h"
  14
  15 /*
  16 gbm_buffer_base.cc:  gbm_bo_get_width(bo),
  17 gbm_buffer_base.cc:  gbm_bo_get_height(bo),
  18 gbm_buffer_base.cc:  gbm_bo_get_stride(bo),
  19 gbm_buffer_base.cc:  gbm_bo_get_handle(bo).u32,
  20 gbm_buffer_base.cc:  return gbm_bo_get_handle(bo_).u32;
  21 gbm_buffer_base.cc:  return gfx::Size(gbm_bo_get_width(bo_), gbm_bo_get_height(bo_));
  22 gbm_buffer.cc:    gbm_bo_destroy(bo());
  23 gbm_buffer.cc:  gbm_bo* bo = gbm_bo_create(device,
  24 gbm_surface.cc:    gbm_bo_set_user_data(bo, this, GbmSurfaceBuffer::Destroy);
  25 gbm_surface.cc:      static_cast<GbmSurfaceBuffer*>(gbm_bo_get_user_data(buffer)));
  26 gbm_surface.cc:    gbm_surface_release_buffer(native_surface_, current_buffer_);
  27 gbm_surface.cc:    gbm_surface_destroy(native_surface_);
  28 gbm_surface.cc:  native_surface_ = gbm_surface_create(
  29 gbm_surface.cc:  gbm_bo* pending_buffer = gbm_surface_lock_front_buffer(native_surface_);
  30 gbm_surface.cc:    gbm_surface_release_buffer(native_surface_, current_buffer_);
  31 ozone_platform_gbm.cc:        device_(gbm_create_device(dri_->get_fd())) {}
  32 ozone_platform_gbm.cc:    gbm_device_destroy(device_);
  33 */
  34
  35 extern struct gbm_driver gbm_driver_cirrus;
  36 #ifdef GBM_EXYNOS
  37 extern struct gbm_driver gbm_driver_exynos;
  38 #endif
  39 extern struct gbm_driver gbm_driver_gma500;
  40 #ifdef GBM_I915
  41 extern struct gbm_driver gbm_driver_i915;
  42 #endif
  43 #ifdef GBM_ROCKCHIP
  44 extern struct gbm_driver gbm_driver_rockchip;
  45 #endif
  46 #ifdef GBM_TEGRA
  47 extern struct gbm_driver gbm_driver_tegra;
  48 #endif
  49 extern struct gbm_driver gbm_driver_udl;
  50
  51 static struct gbm_driver *gbm_get_driver(int fd)
  52 {
  53         drmVersionPtr drm_version;
  54         unsigned int i;
  55
  56         drm_version = drmGetVersion(fd);
  57
  58         if (!drm_version)
  59                 return NULL;
  60
  61         struct gbm_driver *driver_list[] = {
  62                 &gbm_driver_cirrus,
  63 #ifdef GBM_EXYNOS
  64                 &gbm_driver_exynos,
  65 #endif
  66                 &gbm_driver_gma500,
  67 #ifdef GBM_I915
  68                 &gbm_driver_i915,
  69 #endif
  70 #ifdef GBM_ROCKCHIP
  71                 &gbm_driver_rockchip,
  72 #endif
  73 #ifdef GBM_TEGRA
  74                 &gbm_driver_tegra,
  75 #endif
  76                 &gbm_driver_udl,
  77         };
  78
  79         for(i = 0; i < ARRAY_SIZE(driver_list); i++)
  80                 if (!strcmp(drm_version->name, driver_list[i]->name))
  81                 {
  82                         drmFreeVersion(drm_version);
  83                         return driver_list[i];
  84                 }
  85
  86         drmFreeVersion(drm_version);
  87         return NULL;
  88 }
  89
  90 PUBLIC int
  91 gbm_device_get_fd(struct gbm_device *gbm)
  92 {
  93         return gbm->fd;
  94 }
  95
  96 PUBLIC const char *
  97 gbm_device_get_backend_name(struct gbm_device *gbm)
  98 {
  99         return gbm->driver->name;
 100 }
 101
 102 PUBLIC int
 103 gbm_device_is_format_supported(struct gbm_device *gbm,
 104                              uint32_t format, uint32_t usage)
 105 {
 106         unsigned i;
 107
 108         if (format == GBM_BO_FORMAT_XRGB8888)
 109                 format = GBM_FORMAT_XRGB8888;
 110         if (format == GBM_BO_FORMAT_ARGB8888)
 111                 format = GBM_FORMAT_ARGB8888;
 112
 113         if (usage & GBM_BO_USE_CURSOR &&
 114                 usage & GBM_BO_USE_RENDERING)
 115                 return 0;
 116
 117         for(i = 0 ; i < ARRAY_SIZE(gbm->driver->format_list); i++)
 118         {
 119                 if (!gbm->driver->format_list[i].format)
 120                         break;
 121
 122                 if (gbm->driver->format_list[i].format == format &&
 123                         (gbm->driver->format_list[i].usage & usage) == usage)
 124                         return 1;
 125         }
 126
 127         return 0;
 128 }
 129
 130 PUBLIC struct gbm_device *gbm_create_device(int fd)
 131 {
 132         struct gbm_device *gbm;
 133         int ret;
 134
 135         gbm = (struct gbm_device*) malloc(sizeof(*gbm));
 136         if (!gbm)
 137                 return NULL;
 138
 139         gbm->fd = fd;
 140
 141         gbm->driver = gbm_get_driver(fd);
 142         if (!gbm->driver) {
 143                 free(gbm);
 144                 return NULL;
 145         }
 146
 147         if (gbm->driver->init) {
 148                 ret = gbm->driver->init(gbm);
 149                 if (ret) {
 150                         free(gbm);
 151                         return NULL;
 152                 }
 153         }
 154
 155         return gbm;
 156 }
 157
 158 PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
 159 {
 160         if (gbm->driver->close)
 161                 gbm->driver->close(gbm);
 162         free(gbm);
 163 }
 164
 165 PUBLIC struct gbm_surface *gbm_surface_create(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, uint32_t flags)
 166 {
 167         struct gbm_surface *surface = (struct gbm_surface*) malloc(sizeof(*surface));
 168         if (!surface)
 169                 return NULL;
 170
 171         return surface;
 172 }
 173
 174 PUBLIC void gbm_surface_destroy(struct gbm_surface *surface)
 175 {
 176         free(surface);
 177 }
 178
 179 PUBLIC struct gbm_bo *gbm_surface_lock_front_buffer(struct gbm_surface *surface)
 180 {
 181         return NULL;
 182 }
 183
 184 PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface, struct gbm_bo *bo)
 185 {
 186 }
 187
 188 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height, uint32_t format, uint32_t flags)
 189 {
 190         struct gbm_bo *bo;
 191         int ret;
 192
 193         bo = (struct gbm_bo*) malloc(sizeof(*bo));
 194         if (!bo)
 195                 return NULL;
 196
 197         bo->gbm = gbm;
 198         bo->width = width;
 199         bo->height = height;
 200         bo->stride = 0;
 201         bo->format = format;
 202         bo->handle.u32 = 0;
 203         bo->destroy_user_data = NULL;
 204         bo->user_data = NULL;
 205
 206         ret = gbm->driver->bo_create(bo, width, height, format, flags);
 207         if (ret) {
 208                 free(bo);
 209                 return NULL;
 210         }
 211
 212         return bo;
 213 }
 214
 215 PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
 216 {
 217         if (bo->destroy_user_data) {
 218                 bo->destroy_user_data(bo, bo->user_data);
 219                 bo->destroy_user_data = NULL;
 220                 bo->user_data = NULL;
 221         }
 222
 223         bo->gbm->driver->bo_destroy(bo);
 224         free(bo);
 225 }
 226
 227 PUBLIC uint32_t
 228 gbm_bo_get_width(struct gbm_bo *bo)
 229 {
 230         return bo->width;
 231 }
 232
 233 PUBLIC uint32_t
 234 gbm_bo_get_height(struct gbm_bo *bo)
 235 {
 236         return bo->height;
 237 }
 238
 239 PUBLIC uint32_t
 240 gbm_bo_get_stride(struct gbm_bo *bo)
 241 {
 242         return bo->stride;
 243 }
 244
 245 PUBLIC uint32_t
 246 gbm_bo_get_format(struct gbm_bo *bo)
 247 {
 248         return bo->format;
 249 }
 250
 251 PUBLIC struct gbm_device *
 252 gbm_bo_get_device(struct gbm_bo *bo)
 253 {
 254         return bo->gbm;
 255 }
 256
 257 PUBLIC union gbm_bo_handle
 258 gbm_bo_get_handle(struct gbm_bo *bo)
 259 {
 260         return bo->handle;
 261 }
 262
 263 PUBLIC int
 264 gbm_bo_get_fd(struct gbm_bo *bo)
 265 {
 266         int fd;
 267
 268         if (drmPrimeHandleToFD(dri->get_fd(),
 269                                 bo->handle,
 270                                 DRM_CLOEXEC,
 271                                 &fd))
 272                 return fd;
 273         else
 274                 return -1
 275 }
 276
 277 PUBLIC void
 278 gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
 279                      void (*destroy_user_data)(struct gbm_bo *, void *))
 280 {
 281         bo->user_data = data;
 282         bo->destroy_user_data = destroy_user_data;
 283 }
 284
 285 PUBLIC void *
 286 gbm_bo_get_user_data(struct gbm_bo *bo)
 287 {
 288         return bo->user_data;
 289 }