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_get_combination(gbm->drv, format, drv_usage) != NULL);
  46 }
  47
  48 PUBLIC struct gbm_device *gbm_create_device(int fd)
  49 {
  50         struct gbm_device *gbm;
  51
  52         gbm = (struct gbm_device*) malloc(sizeof(*gbm));
  53
  54         if (!gbm)
  55                 return NULL;
  56
  57         gbm->drv = drv_create(fd);
  58         if (!gbm->drv) {
  59                 free(gbm);
  60                 return NULL;
  61         }
  62
  63         return gbm;
  64 }
  65
  66 PUBLIC void gbm_device_destroy(struct gbm_device *gbm)
  67 {
  68         drv_destroy(gbm->drv);
  69         free(gbm);
  70 }
  71
  72 PUBLIC struct gbm_surface *gbm_surface_create(struct gbm_device *gbm,
  73                                               uint32_t width, uint32_t height,
  74                                               uint32_t format, uint32_t flags)
  75 {
  76         struct gbm_surface *surface =
  77                 (struct gbm_surface*) malloc(sizeof(*surface));
  78
  79         if (!surface)
  80                 return NULL;
  81
  82         return surface;
  83 }
  84
  85 PUBLIC void gbm_surface_destroy(struct gbm_surface *surface)
  86 {
  87         free(surface);
  88 }
  89
  90 PUBLIC struct gbm_bo *gbm_surface_lock_front_buffer(struct gbm_surface *surface)
  91 {
  92         return NULL;
  93 }
  94
  95 PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface,
  96                                        struct gbm_bo *bo)
  97 {
  98 }
  99
 100 static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm, uint32_t format)
 101 {
 102         struct gbm_bo *bo;
 103
 104         bo = (struct gbm_bo*) calloc(1, sizeof(*bo));
 105         if (!bo)
 106                 return NULL;
 107
 108         bo->gbm = gbm;
 109         bo->gbm_format = format;
 110
 111         return bo;
 112 }
 113
 114 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width,
 115                                     uint32_t height, uint32_t format,
 116                                     uint32_t flags)
 117 {
 118         struct gbm_bo *bo;
 119
 120         if (!gbm_device_is_format_supported(gbm, format, flags))
 121                 return NULL;
 122
 123         bo = gbm_bo_new(gbm, format);
 124
 125         if (!bo)
 126                 return NULL;
 127
 128         bo->bo = drv_bo_create(gbm->drv, width, height, format,
 129                                gbm_convert_flags(flags));
 130
 131         if (!bo->bo) {
 132                 free(bo);
 133                 return NULL;
 134         }
 135
 136         return bo;
 137 }
 138
 139 PUBLIC struct gbm_bo *gbm_bo_create_with_modifiers(struct gbm_device *gbm,
 140                                                    uint32_t width,
 141                                                    uint32_t height,
 142                                                    uint32_t format,
 143                                                    const uint64_t *modifiers,
 144                                                    uint32_t count)
 145 {
 146         struct gbm_bo *bo;
 147
 148         bo = gbm_bo_new(gbm, format);
 149
 150         if (!bo)
 151                 return NULL;
 152
 153         bo->bo = drv_bo_create_with_modifiers(gbm->drv,
 154                                               width, height, format,
 155                                               modifiers, count);
 156
 157         if (!bo->bo) {
 158                 free(bo);
 159                 return NULL;
 160         }
 161
 162         return bo;
 163 }
 164
 165 PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
 166 {
 167         if (bo->destroy_user_data) {
 168                 bo->destroy_user_data(bo, bo->user_data);
 169                 bo->destroy_user_data = NULL;
 170                 bo->user_data = NULL;
 171         }
 172
 173         drv_bo_destroy(bo->bo);
 174         free(bo);
 175 }
 176
 177 PUBLIC struct gbm_bo *
 178 gbm_bo_import(struct gbm_device *gbm, uint32_t type,
 179               void *buffer, uint32_t usage)
 180 {
 181         struct gbm_bo *bo;
 182         struct drv_import_fd_data drv_data;
 183         struct gbm_import_fd_data *fd_data = buffer;
 184         struct gbm_import_fd_planar_data *fd_planar_data = buffer;
 185         uint32_t gbm_format;
 186         size_t num_planes, i;
 187
 188         memset(&drv_data, 0, sizeof(drv_data));
 189
 190         switch (type) {
 191         case GBM_BO_IMPORT_FD:
 192                 gbm_format = fd_data->format;
 193                 drv_data.width = fd_data->width;
 194                 drv_data.height = fd_data->height;
 195                 drv_data.format = fd_data->format;
 196                 drv_data.fds[0] = fd_data->fd;
 197                 drv_data.strides[0] = fd_data->stride;
 198                 drv_data.sizes[0] = fd_data->height * fd_data->stride;
 199                 break;
 200         case GBM_BO_IMPORT_FD_PLANAR:
 201                 gbm_format = fd_planar_data->format;
 202                 drv_data.width = fd_planar_data->width;
 203                 drv_data.height = fd_planar_data->height;
 204                 drv_data.format = fd_planar_data->format;
 205                 num_planes = drv_num_planes_from_format(drv_data.format);
 206
 207                 assert(num_planes);
 208
 209                 for (i = 0; i < num_planes; i++) {
 210                         drv_data.fds[i] = fd_planar_data->fds[i];
 211                         drv_data.offsets[i] = fd_planar_data->offsets[i];
 212                         drv_data.strides[i] = fd_planar_data->strides[i];
 213                         drv_data.format_modifiers[i] =
 214                                 fd_planar_data->format_modifiers[i];
 215
 216                         drv_data.sizes[i] = drv_size_from_format(
 217                                                 drv_data.format,
 218                                                 drv_data.strides[i],
 219                                                 drv_data.height,
 220                                                 i);
 221                 }
 222
 223                 for (i = num_planes; i < GBM_MAX_PLANES; i++)
 224                         drv_data.fds[i] = -1;
 225
 226                 break;
 227         default:
 228                 return NULL;
 229         }
 230
 231         if (!gbm_device_is_format_supported(gbm, gbm_format, usage))
 232                 return NULL;
 233
 234         bo = gbm_bo_new(gbm, gbm_format);
 235
 236         if (!bo)
 237                 return NULL;
 238
 239         bo->bo = drv_bo_import(gbm->drv, &drv_data);
 240
 241         if (!bo->bo) {
 242                 free(bo);
 243                 return NULL;
 244         }
 245
 246         return bo;
 247 }
 248
 249 PUBLIC void *
 250 gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width,
 251            uint32_t height, uint32_t flags, uint32_t *stride, void **map_data,
 252            size_t plane)
 253 {
 254         if (!bo || width == 0 || height == 0 || !stride || !map_data)
 255                 return NULL;
 256
 257         *stride = gbm_bo_get_plane_stride(bo, plane);
 258         return drv_bo_map(bo->bo, x, y, width, height, 0,
 259                           (struct map_info**)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 }