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 <sys/mman.h>
  14 #include <xf86drm.h>
  15
  16 #include "drv.h"
  17 #include "gbm_helpers.h"
  18 #include "gbm_priv.h"
  19 #include "util.h"
  20
  21 PUBLIC int gbm_device_get_fd(struct gbm_device *gbm)
  22 {
  23
  24         return drv_get_fd(gbm->drv);
  25 }
  26
  27 PUBLIC const char *gbm_device_get_backend_name(struct gbm_device *gbm)
  28 {
  29         return drv_get_name(gbm->drv);
  30 }
  31
  32 PUBLIC int gbm_device_is_format_supported(struct gbm_device *gbm, uint32_t format, uint32_t usage)
  33 {
  34         uint64_t use_flags;
  35
  36         if (usage & GBM_BO_USE_CURSOR && usage & GBM_BO_USE_RENDERING)
  37                 return 0;
  38
  39         use_flags = gbm_convert_usage(usage);
  40
  41         return (drv_get_combination(gbm->drv, format, use_flags) != NULL);
  42 }
  43
  44 PUBLIC int gbm_device_get_format_modifier_plane_count(struct gbm_device *gbm, uint32_t format,
  45                                                       uint64_t modifier)
  46 {
  47         return 0;
  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, uint32_t width,
  75                                               uint32_t height, uint32_t format, uint32_t usage)
  76 {
  77         struct gbm_surface *surface = (struct gbm_surface *)malloc(sizeof(*surface));
  78
  79         if (!surface)
  80                 return NULL;
  81
  82         return surface;
  83 }
  84
  85 PUBLIC struct gbm_surface *gbm_surface_create_with_modifiers(struct gbm_device *gbm, uint32_t width,
  86                                                              uint32_t height, uint32_t format,
  87                                                              const uint64_t *modifiers,
  88                                                              const unsigned int count)
  89 {
  90         if (count != 0 || modifiers != NULL)
  91                 return NULL;
  92
  93         return gbm_surface_create(gbm, width, height, format, 0);
  94 }
  95
  96 PUBLIC struct gbm_bo *gbm_surface_lock_front_buffer(struct gbm_surface *surface)
  97 {
  98         return NULL;
  99 }
 100
 101 PUBLIC void gbm_surface_release_buffer(struct gbm_surface *surface, struct gbm_bo *bo)
 102 {
 103 }
 104
 105 PUBLIC int gbm_surface_has_free_buffers(struct gbm_surface *surface)
 106 {
 107         return 0;
 108 }
 109
 110 PUBLIC void gbm_surface_destroy(struct gbm_surface *surface)
 111 {
 112         free(surface);
 113 }
 114
 115 static struct gbm_bo *gbm_bo_new(struct gbm_device *gbm, uint32_t format)
 116 {
 117         struct gbm_bo *bo;
 118
 119         bo = (struct gbm_bo *)calloc(1, sizeof(*bo));
 120         if (!bo)
 121                 return NULL;
 122
 123         bo->gbm = gbm;
 124         bo->gbm_format = format;
 125
 126         return bo;
 127 }
 128
 129 PUBLIC struct gbm_bo *gbm_bo_create(struct gbm_device *gbm, uint32_t width, uint32_t height,
 130                                     uint32_t format, uint32_t usage)
 131 {
 132         struct gbm_bo *bo;
 133
 134         if (!gbm_device_is_format_supported(gbm, format, usage))
 135                 return NULL;
 136
 137         bo = gbm_bo_new(gbm, format);
 138
 139         if (!bo)
 140                 return NULL;
 141
 142         /*
 143          * HACK: This is for HAL_PIXEL_FORMAT_YV12 buffers allocated by arcvm.
 144          * None of our platforms can display YV12, so we can treat as a SW buffer.
 145          * Remove once this can be intelligently resolved in the guest.
 146          */
 147         if (format == GBM_FORMAT_YVU420 && (usage & GBM_BO_USE_LINEAR))
 148                 format = DRM_FORMAT_YVU420_ANDROID;
 149
 150         bo->bo = drv_bo_create(gbm->drv, width, height, format, gbm_convert_usage(usage));
 151
 152         if (!bo->bo) {
 153                 free(bo);
 154                 return NULL;
 155         }
 156
 157         return bo;
 158 }
 159
 160 PUBLIC struct gbm_bo *gbm_bo_create_with_modifiers(struct gbm_device *gbm, uint32_t width,
 161                                                    uint32_t height, uint32_t format,
 162                                                    const uint64_t *modifiers, uint32_t count)
 163 {
 164         struct gbm_bo *bo;
 165
 166         bo = gbm_bo_new(gbm, format);
 167
 168         if (!bo)
 169                 return NULL;
 170
 171         bo->bo = drv_bo_create_with_modifiers(gbm->drv, width, height, format, modifiers, count);
 172
 173         if (!bo->bo) {
 174                 free(bo);
 175                 return NULL;
 176         }
 177
 178         return bo;
 179 }
 180
 181 PUBLIC void gbm_bo_destroy(struct gbm_bo *bo)
 182 {
 183         if (bo->destroy_user_data) {
 184                 bo->destroy_user_data(bo, bo->user_data);
 185                 bo->destroy_user_data = NULL;
 186                 bo->user_data = NULL;
 187         }
 188
 189         drv_bo_destroy(bo->bo);
 190         free(bo);
 191 }
 192
 193 PUBLIC struct gbm_bo *gbm_bo_import(struct gbm_device *gbm, uint32_t type, void *buffer,
 194                                     uint32_t usage)
 195 {
 196         struct gbm_bo *bo;
 197         struct drv_import_fd_data drv_data;
 198         struct gbm_import_fd_data *fd_data = buffer;
 199         struct gbm_import_fd_modifier_data *fd_modifier_data = buffer;
 200         uint32_t gbm_format;
 201         size_t num_planes, i, num_fds;
 202
 203         memset(&drv_data, 0, sizeof(drv_data));
 204         drv_data.use_flags = gbm_convert_usage(usage);
 205         switch (type) {
 206         case GBM_BO_IMPORT_FD:
 207                 gbm_format = fd_data->format;
 208                 drv_data.width = fd_data->width;
 209                 drv_data.height = fd_data->height;
 210                 drv_data.format = fd_data->format;
 211                 drv_data.fds[0] = fd_data->fd;
 212                 drv_data.strides[0] = fd_data->stride;
 213
 214                 for (i = 0; i < GBM_MAX_PLANES; ++i)
 215                         drv_data.format_modifiers[i] = DRM_FORMAT_MOD_INVALID;
 216                 break;
 217         case GBM_BO_IMPORT_FD_MODIFIER:
 218                 gbm_format = fd_modifier_data->format;
 219                 drv_data.width = fd_modifier_data->width;
 220                 drv_data.height = fd_modifier_data->height;
 221                 drv_data.format = fd_modifier_data->format;
 222                 num_planes = drv_num_planes_from_modifier(gbm->drv, drv_data.format,
 223                                                           fd_modifier_data->modifier);
 224                 assert(num_planes);
 225
 226                 num_fds = fd_modifier_data->num_fds;
 227                 if (!num_fds || num_fds > num_planes)
 228                         return NULL;
 229
 230                 for (i = 0; i < num_planes; i++) {
 231                         if (num_fds != num_planes)
 232                                 drv_data.fds[i] = fd_modifier_data->fds[0];
 233                         else
 234                                 drv_data.fds[i] = fd_modifier_data->fds[i];
 235                         drv_data.offsets[i] = fd_modifier_data->offsets[i];
 236                         drv_data.strides[i] = fd_modifier_data->strides[i];
 237                         drv_data.format_modifiers[i] = fd_modifier_data->modifier;
 238                 }
 239
 240                 for (i = num_planes; i < GBM_MAX_PLANES; i++)
 241                         drv_data.fds[i] = -1;
 242
 243                 break;
 244         default:
 245                 return NULL;
 246         }
 247
 248         if (!gbm_device_is_format_supported(gbm, gbm_format, usage))
 249                 return NULL;
 250
 251         bo = gbm_bo_new(gbm, gbm_format);
 252
 253         if (!bo)
 254                 return NULL;
 255
 256         bo->bo = drv_bo_import(gbm->drv, &drv_data);
 257
 258         if (!bo->bo) {
 259                 free(bo);
 260                 return NULL;
 261         }
 262
 263         return bo;
 264 }
 265
 266 PUBLIC void *gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
 267                         uint32_t transfer_flags, uint32_t *stride, void **map_data)
 268 {
 269         return gbm_bo_map2(bo, x, y, width, height, transfer_flags, stride, map_data, 0);
 270 }
 271
 272 PUBLIC void gbm_bo_unmap(struct gbm_bo *bo, void *map_data)
 273 {
 274         assert(bo);
 275         drv_bo_flush_or_unmap(bo->bo, map_data);
 276 }
 277
 278 PUBLIC uint32_t gbm_bo_get_width(struct gbm_bo *bo)
 279 {
 280         return drv_bo_get_width(bo->bo);
 281 }
 282
 283 PUBLIC uint32_t gbm_bo_get_height(struct gbm_bo *bo)
 284 {
 285         return drv_bo_get_height(bo->bo);
 286 }
 287
 288 PUBLIC uint32_t gbm_bo_get_stride(struct gbm_bo *bo)
 289 {
 290         return gbm_bo_get_stride_for_plane(bo, 0);
 291 }
 292
 293 PUBLIC uint32_t gbm_bo_get_format(struct gbm_bo *bo)
 294 {
 295         return bo->gbm_format;
 296 }
 297
 298 PUBLIC uint32_t gbm_bo_get_bpp(struct gbm_bo *bo)
 299 {
 300         return drv_bytes_per_pixel_from_format(drv_bo_get_format(bo->bo), 0);
 301 }
 302
 303 PUBLIC uint64_t gbm_bo_get_modifier(struct gbm_bo *bo)
 304 {
 305         return drv_bo_get_plane_format_modifier(bo->bo, 0);
 306 }
 307
 308 PUBLIC struct gbm_device *gbm_bo_get_device(struct gbm_bo *bo)
 309 {
 310         return bo->gbm;
 311 }
 312
 313 PUBLIC union gbm_bo_handle gbm_bo_get_handle(struct gbm_bo *bo)
 314 {
 315         return gbm_bo_get_handle_for_plane(bo, 0);
 316 }
 317
 318 PUBLIC int gbm_bo_get_fd(struct gbm_bo *bo)
 319 {
 320         return gbm_bo_get_plane_fd(bo, 0);
 321 }
 322
 323 PUBLIC int gbm_bo_get_plane_count(struct gbm_bo *bo)
 324 {
 325         return drv_bo_get_num_planes(bo->bo);
 326 }
 327
 328 PUBLIC union gbm_bo_handle gbm_bo_get_handle_for_plane(struct gbm_bo *bo, size_t plane)
 329 {
 330         return (union gbm_bo_handle)drv_bo_get_plane_handle(bo->bo, (size_t)plane).u64;
 331 }
 332
 333 PUBLIC uint32_t gbm_bo_get_offset(struct gbm_bo *bo, size_t plane)
 334 {
 335         return drv_bo_get_plane_offset(bo->bo, (size_t)plane);
 336 }
 337
 338 PUBLIC uint32_t gbm_bo_get_stride_for_plane(struct gbm_bo *bo, size_t plane)
 339 {
 340         return drv_bo_get_plane_stride(bo->bo, (size_t)plane);
 341 }
 342
 343 PUBLIC void gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
 344                                  void (*destroy_user_data)(struct gbm_bo *, void *))
 345 {
 346         bo->user_data = data;
 347         bo->destroy_user_data = destroy_user_data;
 348 }
 349
 350 PUBLIC void *gbm_bo_get_user_data(struct gbm_bo *bo)
 351 {
 352         return bo->user_data;
 353 }
 354
 355 /* The two GBM_BO_FORMAT_[XA]RGB8888 formats alias the GBM_FORMAT_*
 356  * formats of the same name. We want to accept them whenever someone
 357  * has a GBM format, but never return them to the user.
 358  */
 359 static uint32_t gbm_format_canonicalize(uint32_t gbm_format)
 360 {
 361         switch (gbm_format) {
 362         case GBM_BO_FORMAT_XRGB8888:
 363                 return GBM_FORMAT_XRGB8888;
 364         case GBM_BO_FORMAT_ARGB8888:
 365                 return GBM_FORMAT_ARGB8888;
 366         default:
 367                 return gbm_format;
 368         }
 369 }
 370
 371 /**
 372  * Returns a string representing the fourcc format name.
 373  */
 374 PUBLIC char *gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc)
 375 {
 376         gbm_format = gbm_format_canonicalize(gbm_format);
 377
 378         desc->name[0] = gbm_format;
 379         desc->name[1] = gbm_format >> 8;
 380         desc->name[2] = gbm_format >> 16;
 381         desc->name[3] = gbm_format >> 24;
 382         desc->name[4] = 0;
 383
 384         return desc->name;
 385 }
 386
 387 /*
 388  * The following functions are not deprecated, but not in the Mesa the gbm
 389  * header. The main difference is minigbm allows for the possibility of
 390  * disjoint YUV images, while Mesa GBM does not.
 391  */
 392 PUBLIC uint32_t gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
 393 {
 394         return drv_bo_get_plane_size(bo->bo, plane);
 395 }
 396
 397 PUBLIC int gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
 398 {
 399         return drv_bo_get_plane_fd(bo->bo, plane);
 400 }
 401
 402 PUBLIC void *gbm_bo_map2(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
 403                          uint32_t transfer_flags, uint32_t *stride, void **map_data, int plane)
 404 {
 405         void *addr;
 406         off_t offset;
 407         uint32_t map_flags;
 408         plane = (size_t)plane;
 409         struct rectangle rect = { .x = x, .y = y, .width = width, .height = height };
 410         if (!bo || width == 0 || height == 0 || !stride || !map_data)
 411                 return NULL;
 412
 413         map_flags = (transfer_flags & GBM_BO_TRANSFER_READ) ? BO_MAP_READ : BO_MAP_NONE;
 414         map_flags |= (transfer_flags & GBM_BO_TRANSFER_WRITE) ? BO_MAP_WRITE : BO_MAP_NONE;
 415
 416         addr = drv_bo_map(bo->bo, &rect, map_flags, (struct mapping **)map_data, plane);
 417         if (addr == MAP_FAILED)
 418                 return MAP_FAILED;
 419
 420         *stride = ((struct mapping *)*map_data)->vma->map_strides[plane];
 421
 422         offset = *stride * rect.y;
 423         offset += rect.x * drv_bytes_per_pixel_from_format(bo->gbm_format, plane);
 424         return (void *)((uint8_t *)addr + offset);
 425 }