gbm.c

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