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_unmap(struct gbm_bo *bo, void *map_data)
 267 {
 268         assert(bo);
 269         drv_bo_flush_or_unmap(bo->bo, map_data);
 270 }
 271
 272 PUBLIC uint32_t gbm_bo_get_width(struct gbm_bo *bo)
 273 {
 274         return drv_bo_get_width(bo->bo);
 275 }
 276
 277 PUBLIC uint32_t gbm_bo_get_height(struct gbm_bo *bo)
 278 {
 279         return drv_bo_get_height(bo->bo);
 280 }
 281
 282 PUBLIC uint32_t gbm_bo_get_stride(struct gbm_bo *bo)
 283 {
 284         return gbm_bo_get_stride_for_plane(bo, 0);
 285 }
 286
 287 PUBLIC uint32_t gbm_bo_get_format(struct gbm_bo *bo)
 288 {
 289         return bo->gbm_format;
 290 }
 291
 292 PUBLIC uint32_t gbm_bo_get_bpp(struct gbm_bo *bo)
 293 {
 294         return drv_bytes_per_pixel_from_format(drv_bo_get_format(bo->bo), 0);
 295 }
 296
 297 PUBLIC uint64_t gbm_bo_get_modifier(struct gbm_bo *bo)
 298 {
 299         return drv_bo_get_plane_format_modifier(bo->bo, 0);
 300 }
 301
 302 PUBLIC struct gbm_device *gbm_bo_get_device(struct gbm_bo *bo)
 303 {
 304         return bo->gbm;
 305 }
 306
 307 PUBLIC union gbm_bo_handle gbm_bo_get_handle(struct gbm_bo *bo)
 308 {
 309         return gbm_bo_get_handle_for_plane(bo, 0);
 310 }
 311
 312 PUBLIC int gbm_bo_get_fd(struct gbm_bo *bo)
 313 {
 314         return gbm_bo_get_plane_fd(bo, 0);
 315 }
 316
 317 PUBLIC int gbm_bo_get_plane_count(struct gbm_bo *bo)
 318 {
 319         return drv_bo_get_num_planes(bo->bo);
 320 }
 321
 322 PUBLIC union gbm_bo_handle gbm_bo_get_handle_for_plane(struct gbm_bo *bo, size_t plane)
 323 {
 324         return (union gbm_bo_handle)drv_bo_get_plane_handle(bo->bo, (size_t)plane).u64;
 325 }
 326
 327 PUBLIC uint32_t gbm_bo_get_offset(struct gbm_bo *bo, size_t plane)
 328 {
 329         return drv_bo_get_plane_offset(bo->bo, (size_t)plane);
 330 }
 331
 332 PUBLIC uint32_t gbm_bo_get_stride_for_plane(struct gbm_bo *bo, size_t plane)
 333 {
 334         return drv_bo_get_plane_stride(bo->bo, (size_t)plane);
 335 }
 336
 337 PUBLIC void gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
 338                                  void (*destroy_user_data)(struct gbm_bo *, void *))
 339 {
 340         bo->user_data = data;
 341         bo->destroy_user_data = destroy_user_data;
 342 }
 343
 344 PUBLIC void *gbm_bo_get_user_data(struct gbm_bo *bo)
 345 {
 346         return bo->user_data;
 347 }
 348
 349 /* The two GBM_BO_FORMAT_[XA]RGB8888 formats alias the GBM_FORMAT_*
 350  * formats of the same name. We want to accept them whenever someone
 351  * has a GBM format, but never return them to the user.
 352  */
 353 static uint32_t gbm_format_canonicalize(uint32_t gbm_format)
 354 {
 355         switch (gbm_format) {
 356         case GBM_BO_FORMAT_XRGB8888:
 357                 return GBM_FORMAT_XRGB8888;
 358         case GBM_BO_FORMAT_ARGB8888:
 359                 return GBM_FORMAT_ARGB8888;
 360         default:
 361                 return gbm_format;
 362         }
 363 }
 364
 365 /**
 366  * Returns a string representing the fourcc format name.
 367  */
 368 PUBLIC char *gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc)
 369 {
 370         gbm_format = gbm_format_canonicalize(gbm_format);
 371
 372         desc->name[0] = gbm_format;
 373         desc->name[1] = gbm_format >> 8;
 374         desc->name[2] = gbm_format >> 16;
 375         desc->name[3] = gbm_format >> 24;
 376         desc->name[4] = 0;
 377
 378         return desc->name;
 379 }
 380
 381 /*
 382  * The following functions are not deprecated, but not in the Mesa the gbm
 383  * header. The main difference is minigbm allows for the possibility of
 384  * disjoint YUV images, while Mesa GBM does not.
 385  */
 386 PUBLIC uint32_t gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
 387 {
 388         return drv_bo_get_plane_size(bo->bo, plane);
 389 }
 390
 391 PUBLIC int gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
 392 {
 393         return drv_bo_get_plane_fd(bo->bo, plane);
 394 }
 395
 396 PUBLIC void *gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
 397                         uint32_t transfer_flags, uint32_t *stride, void **map_data, size_t plane)
 398 {
 399         return gbm_bo_map2(bo, x, y, width, height, transfer_flags, stride, map_data, 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 }