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 <assert.h>
   8 #include <fcntl.h>
   9 #include <stdint.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13 #include <xf86drm.h>
  14
  15 #include "drv.h"
  16 #include "gbm_priv.h"
  17 #include "gbm_helpers.h"
  18 #include "util.h"
  19
  20 PUBLIC int
  21 gbm_device_get_fd(struct gbm_device *gbm)
  22 {
  23
  24         return drv_get_fd(gbm->drv);
  25 }
  26
  27 PUBLIC const char *
  28 gbm_device_get_backend_name(struct gbm_device *gbm)
  29 {
  30         return drv_get_name(gbm->drv);
  31 }
  32
  33 PUBLIC int
  34 gbm_device_is_format_supported(struct gbm_device *gbm,
  35                                uint32_t format, uint32_t usage)
  36 {
  37         uint32_t drv_format;
  38         uint64_t drv_usage;
  39
  40         if (usage & GBM_BO_USE_CURSOR &&
  41                 usage & GBM_BO_USE_RENDERING)
  42                 return 0;
  43
  44         drv_format = gbm_convert_format(format);
  45         drv_usage = gbm_convert_flags(usage);
  46
  47         return drv_is_format_supported(gbm->drv, drv_format, drv_usage);
  48 }
  49
  50 PUBLIC struct gbm_device *gbm_create_device(int fd)
  51 {
  52         struct gbm_device *gbm;
  53
  54         gbm = (struct gbm_device*) malloc(sizeof(*gbm));
  55
  56         if (!gbm)
  57                 return NULL;
  58
  59         gbm->drv = drv_create(fd);
  60         if (!gbm->drv) {
  61                 free(gbm);
  62                 return NULL;
  63         }
  64
  65         return gbm;
  66 }
  67
  68 PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
  69 {
  70         drv_destroy(gbm->drv);
  71         free(gbm);
  72 }
  73
  74 PUBLIC struct gbm_surface *gbm_surface_create(struct gbm_device *gbm,
  75                                               uint32_t width, uint32_t height,
  76                                               uint32_t format, uint32_t flags)
  77 {
  78         struct gbm_surface *surface =
  79                 (struct gbm_surface*) malloc(sizeof(*surface));
  80
  81         if (!surface)
  82                 return NULL;
  83
  84         return surface;
  85 }
  86
  87 PUBLIC void gbm_surface_destroy(struct gbm_surface *surface)
  88 {
  89         free(surface);
  90 }
  91
  92 PUBLIC struct gbm_bo *gbm_surface_lock_front_buffer(struct gbm_surface *surface)
  93 {
  94         return NULL;
  95 }
  96
  97 PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface,
  98                                        struct gbm_bo *bo)
  99 {
 100 }
 101
 102 static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm, uint32_t format)
 103 {
 104         struct gbm_bo *bo;
 105
 106         bo = (struct gbm_bo*) calloc(1, sizeof(*bo));
 107         if (!bo)
 108                 return NULL;
 109
 110         bo->gbm = gbm;
 111         bo->gbm_format = format;
 112
 113         return bo;
 114 }
 115
 116 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width,
 117                                     uint32_t height, uint32_t format,
 118                                     uint32_t flags)
 119 {
 120         struct gbm_bo *bo;
 121
 122         if (!gbm_device_is_format_supported(gbm, format, flags))
 123                 return NULL;
 124
 125         bo = gbm_bo_new(gbm, format);
 126
 127         if (!bo)
 128                 return NULL;
 129
 130         bo->bo = drv_bo_create(gbm->drv, width, height,
 131                                gbm_convert_format(format),
 132                                gbm_convert_flags(flags));
 133
 134         if (!bo->bo) {
 135                 free(bo);
 136                 return NULL;
 137         }
 138
 139         return bo;
 140 }
 141
 142 PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
 143 {
 144         if (bo->destroy_user_data) {
 145                 bo->destroy_user_data(bo, bo->user_data);
 146                 bo->destroy_user_data = NULL;
 147                 bo->user_data = NULL;
 148         }
 149
 150         drv_bo_destroy(bo->bo);
 151         free(bo);
 152 }
 153
 154 PUBLIC struct gbm_bo *
 155 gbm_bo_import(struct gbm_device *gbm, uint32_t type,
 156               void *buffer, uint32_t usage)
 157 {
 158         struct gbm_bo *bo;
 159         struct drv_import_fd_data drv_data;
 160         struct gbm_import_fd_data *fd_data = buffer;
 161         struct gbm_import_fd_planar_data *fd_planar_data = buffer;
 162         uint32_t gbm_format;
 163         int i;
 164
 165         memset(&drv_data, 0, sizeof(drv_data));
 166
 167         switch (type) {
 168         case GBM_BO_IMPORT_FD:
 169                 gbm_format = fd_data->format;
 170                 drv_data.width = fd_data->width;
 171                 drv_data.height = fd_data->height;
 172                 drv_data.format = gbm_convert_format(fd_data->format);
 173                 drv_data.fds[0] = fd_data->fd;
 174                 drv_data.strides[0] = fd_data->stride;
 175                 drv_data.sizes[0] = fd_data->height * fd_data->stride;
 176                 break;
 177         case GBM_BO_IMPORT_FD_PLANAR:
 178                 gbm_format = fd_planar_data->format;
 179                 drv_data.width = fd_planar_data->width;
 180                 drv_data.height = fd_planar_data->height;
 181                 drv_data.format = gbm_convert_format(fd_planar_data->format);
 182                 for (i = 0; i < GBM_MAX_PLANES; i++) {
 183                         drv_data.fds[i] = fd_planar_data->fds[i];
 184                         drv_data.offsets[i] = fd_planar_data->offsets[i];
 185                         drv_data.strides[i] = fd_planar_data->strides[i];
 186                         drv_data.sizes[i] = fd_planar_data->height *
 187                                             fd_planar_data->strides[i];
 188                         drv_data.format_modifiers[i] =
 189                                 fd_planar_data->format_modifiers[i];
 190                 }
 191                 break;
 192         default:
 193                 return NULL;
 194         }
 195
 196         if (!gbm_device_is_format_supported(gbm, gbm_format, usage))
 197                 return NULL;
 198
 199         bo = gbm_bo_new(gbm, gbm_format);
 200
 201         if (!bo)
 202                 return NULL;
 203
 204         bo->bo = drv_bo_import(gbm->drv, &drv_data);
 205
 206         if (!bo->bo) {
 207                 free(bo);
 208                 return NULL;
 209         }
 210
 211         return bo;
 212 }
 213
 214 PUBLIC void *
 215 gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width,
 216            uint32_t height, uint32_t flags, uint32_t *stride, void **map_data,
 217            size_t plane)
 218 {
 219         if (!bo || width == 0 || height == 0 || !stride || !map_data)
 220                 return NULL;
 221
 222         *stride = gbm_bo_get_plane_stride(bo, plane);
 223         return drv_bo_map(bo->bo, x, y, width, height, 0, map_data, plane);
 224 }
 225
 226 PUBLIC void
 227 gbm_bo_unmap(struct gbm_bo *bo, void *map_data)
 228 {
 229         assert(bo);
 230         drv_bo_unmap(bo->bo, map_data);
 231 }
 232
 233 PUBLIC uint32_t
 234 gbm_bo_get_width(struct gbm_bo *bo)
 235 {
 236         return drv_bo_get_width(bo->bo);
 237 }
 238
 239 PUBLIC uint32_t
 240 gbm_bo_get_height(struct gbm_bo *bo)
 241 {
 242         return drv_bo_get_height(bo->bo);
 243 }
 244
 245 PUBLIC uint32_t
 246 gbm_bo_get_stride(struct gbm_bo *bo)
 247 {
 248         return gbm_bo_get_plane_stride(bo, 0);
 249 }
 250
 251 PUBLIC uint32_t
 252 gbm_bo_get_stride_or_tiling(struct gbm_bo *bo)
 253 {
 254         return drv_bo_get_stride_or_tiling(bo->bo);
 255 }
 256
 257 PUBLIC uint32_t
 258 gbm_bo_get_format(struct gbm_bo *bo)
 259 {
 260         return bo->gbm_format;
 261 }
 262
 263 PUBLIC uint64_t
 264 gbm_bo_get_format_modifier(struct gbm_bo *bo)
 265 {
 266         return gbm_bo_get_plane_format_modifier(bo, 0);
 267 }
 268
 269 PUBLIC struct gbm_device *
 270 gbm_bo_get_device(struct gbm_bo *bo)
 271 {
 272         return bo->gbm;
 273 }
 274
 275 PUBLIC union gbm_bo_handle
 276 gbm_bo_get_handle(struct gbm_bo *bo)
 277 {
 278         return gbm_bo_get_plane_handle(bo, 0);
 279 }
 280
 281 PUBLIC int
 282 gbm_bo_get_fd(struct gbm_bo *bo)
 283 {
 284         return gbm_bo_get_plane_fd(bo, 0);
 285 }
 286
 287 PUBLIC size_t
 288 gbm_bo_get_num_planes(struct gbm_bo *bo)
 289 {
 290         return drv_bo_get_num_planes(bo->bo);
 291 }
 292
 293 PUBLIC union gbm_bo_handle
 294 gbm_bo_get_plane_handle(struct gbm_bo *bo, size_t plane)
 295 {
 296         return (union gbm_bo_handle) drv_bo_get_plane_handle(bo->bo, plane).u64;
 297 }
 298
 299 PUBLIC int
 300 gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
 301 {
 302         return drv_bo_get_plane_fd(bo->bo, plane);
 303 }
 304
 305 PUBLIC uint32_t
 306 gbm_bo_get_plane_offset(struct gbm_bo *bo, size_t plane)
 307 {
 308         return drv_bo_get_plane_offset(bo->bo, plane);
 309 }
 310
 311 PUBLIC uint32_t
 312 gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
 313 {
 314         return drv_bo_get_plane_size(bo->bo, plane);
 315 }
 316
 317 PUBLIC uint32_t
 318 gbm_bo_get_plane_stride(struct gbm_bo *bo, size_t plane)
 319 {
 320         return drv_bo_get_plane_stride(bo->bo, plane);
 321 }
 322
 323 PUBLIC uint64_t
 324 gbm_bo_get_plane_format_modifier(struct gbm_bo *bo, size_t plane)
 325 {
 326         return drv_bo_get_plane_format_modifier(bo->bo, plane);
 327 }
 328
 329 PUBLIC void
 330 gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
 331                      void (*destroy_user_data)(struct gbm_bo *, void *))
 332 {
 333         bo->user_data = data;
 334         bo->destroy_user_data = destroy_user_data;
 335 }
 336
 337 PUBLIC void *
 338 gbm_bo_get_user_data(struct gbm_bo *bo)
 339 {
 340         return bo->user_data;
 341 }