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                 break;
 214         case GBM_BO_IMPORT_FD_MODIFIER:
 215                 gbm_format = fd_modifier_data->format;
 216                 drv_data.width = fd_modifier_data->width;
 217                 drv_data.height = fd_modifier_data->height;
 218                 drv_data.format = fd_modifier_data->format;
 219                 num_planes = drv_num_planes_from_format(drv_data.format);
 220                 assert(num_planes);
 221
 222                 num_fds = fd_modifier_data->num_fds;
 223                 if (!num_fds || num_fds > num_planes)
 224                         return NULL;
 225
 226                 for (i = 0; i < num_planes; i++) {
 227                         if (num_fds != num_planes)
 228                                 drv_data.fds[i] = fd_modifier_data->fds[0];
 229                         else
 230                                 drv_data.fds[i] = fd_modifier_data->fds[i];
 231                         drv_data.offsets[i] = fd_modifier_data->offsets[i];
 232                         drv_data.strides[i] = fd_modifier_data->strides[i];
 233                         drv_data.format_modifiers[i] = fd_modifier_data->modifier;
 234                 }
 235
 236                 for (i = num_planes; i < GBM_MAX_PLANES; i++)
 237                         drv_data.fds[i] = -1;
 238
 239                 break;
 240         default:
 241                 return NULL;
 242         }
 243
 244         if (!gbm_device_is_format_supported(gbm, gbm_format, usage))
 245                 return NULL;
 246
 247         bo = gbm_bo_new(gbm, gbm_format);
 248
 249         if (!bo)
 250                 return NULL;
 251
 252         bo->bo = drv_bo_import(gbm->drv, &drv_data);
 253
 254         if (!bo->bo) {
 255                 free(bo);
 256                 return NULL;
 257         }
 258
 259         return bo;
 260 }
 261
 262 PUBLIC void gbm_bo_unmap(struct gbm_bo *bo, void *map_data)
 263 {
 264         assert(bo);
 265         drv_bo_flush_or_unmap(bo->bo, map_data);
 266 }
 267
 268 PUBLIC uint32_t gbm_bo_get_width(struct gbm_bo *bo)
 269 {
 270         return drv_bo_get_width(bo->bo);
 271 }
 272
 273 PUBLIC uint32_t gbm_bo_get_height(struct gbm_bo *bo)
 274 {
 275         return drv_bo_get_height(bo->bo);
 276 }
 277
 278 PUBLIC uint32_t gbm_bo_get_stride(struct gbm_bo *bo)
 279 {
 280         return gbm_bo_get_stride_for_plane(bo, 0);
 281 }
 282
 283 PUBLIC uint32_t gbm_bo_get_format(struct gbm_bo *bo)
 284 {
 285         return bo->gbm_format;
 286 }
 287
 288 PUBLIC uint32_t gbm_bo_get_bpp(struct gbm_bo *bo)
 289 {
 290         return drv_bytes_per_pixel_from_format(drv_bo_get_format(bo->bo), 0);
 291 }
 292
 293 PUBLIC uint64_t gbm_bo_get_modifier(struct gbm_bo *bo)
 294 {
 295         return drv_bo_get_plane_format_modifier(bo->bo, 0);
 296 }
 297
 298 PUBLIC struct gbm_device *gbm_bo_get_device(struct gbm_bo *bo)
 299 {
 300         return bo->gbm;
 301 }
 302
 303 PUBLIC union gbm_bo_handle gbm_bo_get_handle(struct gbm_bo *bo)
 304 {
 305         return gbm_bo_get_handle_for_plane(bo, 0);
 306 }
 307
 308 PUBLIC int gbm_bo_get_fd(struct gbm_bo *bo)
 309 {
 310         return gbm_bo_get_plane_fd(bo, 0);
 311 }
 312
 313 PUBLIC int gbm_bo_get_plane_count(struct gbm_bo *bo)
 314 {
 315         return drv_bo_get_num_planes(bo->bo);
 316 }
 317
 318 PUBLIC union gbm_bo_handle gbm_bo_get_handle_for_plane(struct gbm_bo *bo, size_t plane)
 319 {
 320         return (union gbm_bo_handle)drv_bo_get_plane_handle(bo->bo, (size_t)plane).u64;
 321 }
 322
 323 PUBLIC uint32_t gbm_bo_get_offset(struct gbm_bo *bo, size_t plane)
 324 {
 325         return drv_bo_get_plane_offset(bo->bo, (size_t)plane);
 326 }
 327
 328 PUBLIC uint32_t gbm_bo_get_stride_for_plane(struct gbm_bo *bo, size_t plane)
 329 {
 330         return drv_bo_get_plane_stride(bo->bo, (size_t)plane);
 331 }
 332
 333 PUBLIC void gbm_bo_set_user_data(struct gbm_bo *bo, void *data,
 334                                  void (*destroy_user_data)(struct gbm_bo *, void *))
 335 {
 336         bo->user_data = data;
 337         bo->destroy_user_data = destroy_user_data;
 338 }
 339
 340 PUBLIC void *gbm_bo_get_user_data(struct gbm_bo *bo)
 341 {
 342         return bo->user_data;
 343 }
 344
 345 /* The two GBM_BO_FORMAT_[XA]RGB8888 formats alias the GBM_FORMAT_*
 346  * formats of the same name. We want to accept them whenever someone
 347  * has a GBM format, but never return them to the user.
 348  */
 349 static uint32_t gbm_format_canonicalize(uint32_t gbm_format)
 350 {
 351         switch (gbm_format) {
 352         case GBM_BO_FORMAT_XRGB8888:
 353                 return GBM_FORMAT_XRGB8888;
 354         case GBM_BO_FORMAT_ARGB8888:
 355                 return GBM_FORMAT_ARGB8888;
 356         default:
 357                 return gbm_format;
 358         }
 359 }
 360
 361 /**
 362  * Returns a string representing the fourcc format name.
 363  */
 364 PUBLIC char *gbm_format_get_name(uint32_t gbm_format, struct gbm_format_name_desc *desc)
 365 {
 366         gbm_format = gbm_format_canonicalize(gbm_format);
 367
 368         desc->name[0] = gbm_format;
 369         desc->name[1] = gbm_format >> 8;
 370         desc->name[2] = gbm_format >> 16;
 371         desc->name[3] = gbm_format >> 24;
 372         desc->name[4] = 0;
 373
 374         return desc->name;
 375 }
 376
 377 /*
 378  * The following functions are not deprecated, but not in the Mesa the gbm
 379  * header. The main difference is minigbm allows for the possibility of
 380  * disjoint YUV images, while Mesa GBM does not.
 381  */
 382 PUBLIC uint32_t gbm_bo_get_plane_size(struct gbm_bo *bo, size_t plane)
 383 {
 384         return drv_bo_get_plane_size(bo->bo, plane);
 385 }
 386
 387 PUBLIC int gbm_bo_get_plane_fd(struct gbm_bo *bo, size_t plane)
 388 {
 389         return drv_bo_get_plane_fd(bo->bo, plane);
 390 }
 391
 392 PUBLIC void *gbm_bo_map(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
 393                         uint32_t transfer_flags, uint32_t *stride, void **map_data, size_t plane)
 394 {
 395         return gbm_bo_map2(bo, x, y, width, height, transfer_flags, stride, map_data, plane);
 396 }
 397
 398 PUBLIC void *gbm_bo_map2(struct gbm_bo *bo, uint32_t x, uint32_t y, uint32_t width, uint32_t height,
 399                          uint32_t transfer_flags, uint32_t *stride, void **map_data, int plane)
 400 {
 401         void *addr;
 402         off_t offset;
 403         uint32_t map_flags;
 404         plane = (size_t)plane;
 405         struct rectangle rect = { .x = x, .y = y, .width = width, .height = height };
 406         if (!bo || width == 0 || height == 0 || !stride || !map_data)
 407                 return NULL;
 408
 409         map_flags = (transfer_flags & GBM_BO_TRANSFER_READ) ? BO_MAP_READ : BO_MAP_NONE;
 410         map_flags |= (transfer_flags & GBM_BO_TRANSFER_WRITE) ? BO_MAP_WRITE : BO_MAP_NONE;
 411
 412         addr = drv_bo_map(bo->bo, &rect, map_flags, (struct mapping **)map_data, plane);
 413         if (addr == MAP_FAILED)
 414                 return MAP_FAILED;
 415
 416         *stride = ((struct mapping *)*map_data)->vma->map_strides[plane];
 417
 418         offset = *stride * rect.y;
 419         offset += rect.x * drv_bytes_per_pixel_from_format(bo->gbm_format, plane);
 420         return (void *)((uint8_t *)addr + offset);
 421 }