dri.c

   1 /*
   2  * Copyright 2017 Advanced Micro Devices. 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 #ifdef DRV_AMDGPU
   8
   9 #include <assert.h>
  10 #include <dlfcn.h>
  11 #include <errno.h>
  12 #include <fcntl.h>
  13 #include <stdbool.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16 #include <sys/mman.h>
  17 #include <unistd.h>
  18 #include <xf86drm.h>
  19
  20 #include "dri.h"
  21 #include "drv_priv.h"
  22 #include "helpers.h"
  23 #include "util.h"
  24
  25 static const struct {
  26         uint32_t drm_format;
  27         int dri_image_format;
  28 } drm_to_dri_image_formats[] = {
  29         { DRM_FORMAT_R8, __DRI_IMAGE_FORMAT_R8 },
  30         { DRM_FORMAT_GR88, __DRI_IMAGE_FORMAT_GR88 },
  31         { DRM_FORMAT_RGB565, __DRI_IMAGE_FORMAT_RGB565 },
  32         { DRM_FORMAT_XRGB8888, __DRI_IMAGE_FORMAT_XRGB8888 },
  33         { DRM_FORMAT_ARGB8888, __DRI_IMAGE_FORMAT_ARGB8888 },
  34         { DRM_FORMAT_XBGR8888, __DRI_IMAGE_FORMAT_XBGR8888 },
  35         { DRM_FORMAT_ABGR8888, __DRI_IMAGE_FORMAT_ABGR8888 },
  36         { DRM_FORMAT_XRGB2101010, __DRI_IMAGE_FORMAT_XRGB2101010 },
  37         { DRM_FORMAT_XBGR2101010, __DRI_IMAGE_FORMAT_XBGR2101010 },
  38         { DRM_FORMAT_ARGB2101010, __DRI_IMAGE_FORMAT_ARGB2101010 },
  39         { DRM_FORMAT_ABGR2101010, __DRI_IMAGE_FORMAT_ABGR2101010 },
  40 };
  41
  42 static int drm_format_to_dri_format(uint32_t drm_format)
  43 {
  44         uint32_t i;
  45         for (i = 0; i < ARRAY_SIZE(drm_to_dri_image_formats); i++) {
  46                 if (drm_to_dri_image_formats[i].drm_format == drm_format)
  47                         return drm_to_dri_image_formats[i].dri_image_format;
  48         }
  49
  50         return 0;
  51 }
  52
  53 static bool lookup_extension(const __DRIextension *const *extensions, const char *name,
  54                              int min_version, const __DRIextension **dst)
  55 {
  56         while (*extensions) {
  57                 if ((*extensions)->name && !strcmp((*extensions)->name, name) &&
  58                     (*extensions)->version >= min_version) {
  59                         *dst = *extensions;
  60                         return true;
  61                 }
  62
  63                 extensions++;
  64         }
  65
  66         return false;
  67 }
  68
  69 /*
  70  * Close Gem Handle
  71  */
  72 static void close_gem_handle(uint32_t handle, int fd)
  73 {
  74         struct drm_gem_close gem_close;
  75         int ret = 0;
  76
  77         memset(&gem_close, 0, sizeof(gem_close));
  78         gem_close.handle = handle;
  79         ret = drmIoctl(fd, DRM_IOCTL_GEM_CLOSE, &gem_close);
  80         if (ret)
  81                 drv_log("DRM_IOCTL_GEM_CLOSE failed (handle=%x) error %d\n", handle, ret);
  82 }
  83
  84 /*
  85  * The DRI GEM namespace may be different from the minigbm's driver GEM namespace. We have
  86  * to import into minigbm.
  87  */
  88 static int import_into_minigbm(struct dri_driver *dri, struct bo *bo)
  89 {
  90         uint32_t handle;
  91         int ret, modifier_upper, modifier_lower, num_planes, i, j;
  92         off_t dmabuf_sizes[DRV_MAX_PLANES];
  93         __DRIimage *plane_image = NULL;
  94
  95         if (dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_MODIFIER_UPPER,
  96                                              &modifier_upper) &&
  97             dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_MODIFIER_LOWER,
  98                                              &modifier_lower)) {
  99                 bo->meta.format_modifiers[0] =
 100                     ((uint64_t)modifier_upper << 32) | (uint32_t)modifier_lower;
 101         } else {
 102                 bo->meta.format_modifiers[0] = DRM_FORMAT_MOD_INVALID;
 103         }
 104
 105         if (!dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_NUM_PLANES,
 106                                               &num_planes)) {
 107                 return -errno;
 108         }
 109
 110         bo->meta.num_planes = num_planes;
 111
 112         for (i = 0; i < num_planes; ++i) {
 113                 int prime_fd, stride, offset;
 114                 plane_image = dri->image_extension->fromPlanar(bo->priv, i, NULL);
 115                 __DRIimage *image = plane_image ? plane_image : bo->priv;
 116
 117                 if (i)
 118                         bo->meta.format_modifiers[i] = bo->meta.format_modifiers[0];
 119
 120                 if (!dri->image_extension->queryImage(image, __DRI_IMAGE_ATTRIB_STRIDE, &stride) ||
 121                     !dri->image_extension->queryImage(image, __DRI_IMAGE_ATTRIB_OFFSET, &offset)) {
 122                         ret = -errno;
 123                         goto cleanup;
 124                 }
 125
 126                 if (!dri->image_extension->queryImage(image, __DRI_IMAGE_ATTRIB_FD, &prime_fd)) {
 127                         ret = -errno;
 128                         goto cleanup;
 129                 }
 130
 131                 dmabuf_sizes[i] = lseek(prime_fd, 0, SEEK_END);
 132                 if (dmabuf_sizes[i] == (off_t)-1) {
 133                         ret = -errno;
 134                         close(prime_fd);
 135                         goto cleanup;
 136                 }
 137
 138                 lseek(prime_fd, 0, SEEK_SET);
 139
 140                 ret = drmPrimeFDToHandle(bo->drv->fd, prime_fd, &handle);
 141
 142                 close(prime_fd);
 143
 144                 if (ret) {
 145                         drv_log("drmPrimeFDToHandle failed with %s\n", strerror(errno));
 146                         goto cleanup;
 147                 }
 148
 149                 bo->handles[i].u32 = handle;
 150
 151                 bo->meta.strides[i] = stride;
 152                 bo->meta.offsets[i] = offset;
 153
 154                 if (plane_image)
 155                         dri->image_extension->destroyImage(plane_image);
 156         }
 157
 158         for (i = 0; i < num_planes; ++i) {
 159                 off_t next_plane = dmabuf_sizes[i];
 160                 for (j = 0; j < num_planes; ++j) {
 161                         if (bo->meta.offsets[j] < next_plane &&
 162                             bo->meta.offsets[j] > bo->meta.offsets[i] &&
 163                             bo->handles[j].u32 == bo->handles[i].u32)
 164                                 next_plane = bo->meta.offsets[j];
 165                 }
 166
 167                 bo->meta.sizes[i] = next_plane - bo->meta.offsets[i];
 168
 169                 /* This is kind of misleading if different planes use
 170                    different dmabufs. */
 171                 bo->meta.total_size += bo->meta.sizes[i];
 172         }
 173
 174         return 0;
 175
 176 cleanup:
 177         if (plane_image)
 178                 dri->image_extension->destroyImage(plane_image);
 179         while (--i >= 0) {
 180                 for (j = 0; j <= i; ++j)
 181                         if (bo->handles[j].u32 == bo->handles[i].u32)
 182                                 break;
 183
 184                 /* Multiple equivalent handles) */
 185                 if (i == j)
 186                         break;
 187
 188                 /* This kind of goes horribly wrong when we already imported
 189                  * the same handles earlier, as we should really reference
 190                  * count handles. */
 191                 close_gem_handle(bo->handles[i].u32, bo->drv->fd);
 192         }
 193         return ret;
 194 }
 195
 196 /*
 197  * The caller is responsible for setting drv->priv to a structure that derives from dri_driver.
 198  */
 199 int dri_init(struct driver *drv, const char *dri_so_path, const char *driver_suffix)
 200 {
 201         char fname[128];
 202         const __DRIextension **(*get_extensions)();
 203         const __DRIextension *loader_extensions[] = { NULL };
 204
 205         struct dri_driver *dri = drv->priv;
 206
 207         dri->fd = open(drmGetRenderDeviceNameFromFd(drv_get_fd(drv)), O_RDWR);
 208         if (dri->fd < 0)
 209                 return -ENODEV;
 210
 211         dri->driver_handle = dlopen(dri_so_path, RTLD_NOW | RTLD_GLOBAL);
 212         if (!dri->driver_handle)
 213                 goto close_dri_fd;
 214
 215         snprintf(fname, sizeof(fname), __DRI_DRIVER_GET_EXTENSIONS "_%s", driver_suffix);
 216         get_extensions = dlsym(dri->driver_handle, fname);
 217         if (!get_extensions)
 218                 goto free_handle;
 219
 220         dri->extensions = get_extensions();
 221         if (!dri->extensions)
 222                 goto free_handle;
 223
 224         if (!lookup_extension(dri->extensions, __DRI_CORE, 2,
 225                               (const __DRIextension **)&dri->core_extension))
 226                 goto free_handle;
 227
 228         /* Version 4 for createNewScreen2 */
 229         if (!lookup_extension(dri->extensions, __DRI_DRI2, 4,
 230                               (const __DRIextension **)&dri->dri2_extension))
 231                 goto free_handle;
 232
 233         dri->device = dri->dri2_extension->createNewScreen2(0, dri->fd, loader_extensions,
 234                                                             dri->extensions, &dri->configs, NULL);
 235         if (!dri->device)
 236                 goto free_handle;
 237
 238         dri->context =
 239             dri->dri2_extension->createNewContext(dri->device, *dri->configs, NULL, NULL);
 240
 241         if (!dri->context)
 242                 goto free_screen;
 243
 244         if (!lookup_extension(dri->core_extension->getExtensions(dri->device), __DRI_IMAGE, 12,
 245                               (const __DRIextension **)&dri->image_extension))
 246                 goto free_context;
 247
 248         if (!lookup_extension(dri->core_extension->getExtensions(dri->device), __DRI2_FLUSH, 4,
 249                               (const __DRIextension **)&dri->flush_extension))
 250                 goto free_context;
 251
 252         return 0;
 253
 254 free_context:
 255         dri->core_extension->destroyContext(dri->context);
 256 free_screen:
 257         dri->core_extension->destroyScreen(dri->device);
 258 free_handle:
 259         dlclose(dri->driver_handle);
 260         dri->driver_handle = NULL;
 261 close_dri_fd:
 262         close(dri->fd);
 263         return -ENODEV;
 264 }
 265
 266 /*
 267  * The caller is responsible for freeing drv->priv.
 268  */
 269 void dri_close(struct driver *drv)
 270 {
 271         struct dri_driver *dri = drv->priv;
 272
 273         dri->core_extension->destroyContext(dri->context);
 274         dri->core_extension->destroyScreen(dri->device);
 275         dlclose(dri->driver_handle);
 276         dri->driver_handle = NULL;
 277         close(dri->fd);
 278 }
 279
 280 int dri_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
 281                   uint64_t use_flags)
 282 {
 283         unsigned int dri_use;
 284         int ret, dri_format;
 285         struct dri_driver *dri = bo->drv->priv;
 286
 287         dri_format = drm_format_to_dri_format(format);
 288
 289         /* Gallium drivers require shared to get the handle and stride. */
 290         dri_use = __DRI_IMAGE_USE_SHARE;
 291         if (use_flags & BO_USE_SCANOUT)
 292                 dri_use |= __DRI_IMAGE_USE_SCANOUT;
 293         if (use_flags & BO_USE_CURSOR)
 294                 dri_use |= __DRI_IMAGE_USE_CURSOR;
 295         if (use_flags & BO_USE_LINEAR)
 296                 dri_use |= __DRI_IMAGE_USE_LINEAR;
 297
 298         bo->priv = dri->image_extension->createImage(dri->device, width, height, dri_format,
 299                                                      dri_use, NULL);
 300         if (!bo->priv) {
 301                 ret = -errno;
 302                 return ret;
 303         }
 304
 305         ret = import_into_minigbm(dri, bo);
 306         if (ret)
 307                 goto free_image;
 308
 309         return 0;
 310
 311 free_image:
 312         dri->image_extension->destroyImage(bo->priv);
 313         return ret;
 314 }
 315
 316 int dri_bo_create_with_modifiers(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
 317                                  const uint64_t *modifiers, uint32_t modifier_count)
 318 {
 319         int ret, dri_format;
 320         struct dri_driver *dri = bo->drv->priv;
 321
 322         if (!dri->image_extension->createImageWithModifiers) {
 323                 return -ENOENT;
 324         }
 325
 326         dri_format = drm_format_to_dri_format(format);
 327
 328         bo->priv = dri->image_extension->createImageWithModifiers(
 329             dri->device, width, height, dri_format, modifiers, modifier_count, NULL);
 330         if (!bo->priv) {
 331                 ret = -errno;
 332                 return ret;
 333         }
 334
 335         ret = import_into_minigbm(dri, bo);
 336         if (ret)
 337                 goto free_image;
 338
 339         return 0;
 340
 341 free_image:
 342         dri->image_extension->destroyImage(bo->priv);
 343         return ret;
 344 }
 345
 346 int dri_bo_import(struct bo *bo, struct drv_import_fd_data *data)
 347 {
 348         int ret;
 349         struct dri_driver *dri = bo->drv->priv;
 350
 351         if (data->format_modifiers[0] != DRM_FORMAT_MOD_INVALID) {
 352                 unsigned error;
 353
 354                 if (!dri->image_extension->createImageFromDmaBufs2)
 355                         return -ENOSYS;
 356
 357                 // clang-format off
 358                 bo->priv = dri->image_extension->createImageFromDmaBufs2(dri->device, data->width, data->height,
 359                                                                          data->format,
 360                                                                          data->format_modifiers[0],
 361                                                                          data->fds,
 362                                                                          bo->meta.num_planes,
 363                                                                          (int *)data->strides,
 364                                                                          (int *)data->offsets,
 365                                                                          __DRI_YUV_COLOR_SPACE_UNDEFINED,
 366                                                                          __DRI_YUV_RANGE_UNDEFINED,
 367                                                                          __DRI_YUV_CHROMA_SITING_UNDEFINED,
 368                                                                          __DRI_YUV_CHROMA_SITING_UNDEFINED,
 369                                                                          &error, NULL);
 370                 // clang-format on
 371
 372                 /* Could translate the DRI error, but the Mesa GBM also returns ENOSYS. */
 373                 if (!bo->priv)
 374                         return -ENOSYS;
 375         } else {
 376                 // clang-format off
 377                 bo->priv = dri->image_extension->createImageFromFds(dri->device, data->width, data->height,
 378                                                                     data->format, data->fds,
 379                                                                     bo->meta.num_planes,
 380                                                                     (int *)data->strides,
 381                                                                     (int *)data->offsets, NULL);
 382                 // clang-format on
 383                 if (!bo->priv)
 384                         return -errno;
 385         }
 386
 387         ret = import_into_minigbm(dri, bo);
 388         if (ret) {
 389                 dri->image_extension->destroyImage(bo->priv);
 390                 return ret;
 391         }
 392
 393         return 0;
 394 }
 395
 396 int dri_bo_destroy(struct bo *bo)
 397 {
 398         struct dri_driver *dri = bo->drv->priv;
 399
 400         assert(bo->priv);
 401         close_gem_handle(bo->handles[0].u32, bo->drv->fd);
 402         dri->image_extension->destroyImage(bo->priv);
 403         bo->priv = NULL;
 404         return 0;
 405 }
 406
 407 /*
 408  * Map an image plane.
 409  *
 410  * This relies on the underlying driver to do a decompressing and/or de-tiling
 411  * blit if necessary,
 412  *
 413  * This function itself is not thread-safe; we rely on the fact that the caller
 414  * locks a per-driver mutex.
 415  */
 416 void *dri_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
 417 {
 418         struct dri_driver *dri = bo->drv->priv;
 419
 420         /* GBM flags and DRI flags are the same. */
 421         vma->addr = dri->image_extension->mapImage(dri->context, bo->priv, 0, 0, bo->meta.width,
 422                                                    bo->meta.height, map_flags,
 423                                                    (int *)&vma->map_strides[plane], &vma->priv);
 424         if (!vma->addr)
 425                 return MAP_FAILED;
 426
 427         return vma->addr;
 428 }
 429
 430 int dri_bo_unmap(struct bo *bo, struct vma *vma)
 431 {
 432         struct dri_driver *dri = bo->drv->priv;
 433
 434         assert(vma->priv);
 435         dri->image_extension->unmapImage(dri->context, bo->priv, vma->priv);
 436
 437         /*
 438          * From gbm_dri.c in Mesa:
 439          *
 440          * "Not all DRI drivers use direct maps. They may queue up DMA operations
 441          *  on the mapping context. Since there is no explicit gbm flush mechanism,
 442          *  we need to flush here."
 443          */
 444
 445         dri->flush_extension->flush_with_flags(dri->context, NULL, __DRI2_FLUSH_CONTEXT, 0);
 446         return 0;
 447 }
 448
 449 size_t dri_num_planes_from_modifier(struct driver *drv, uint32_t format, uint64_t modifier)
 450 {
 451         struct dri_driver *dri = drv->priv;
 452         if (!dri->image_extension->queryDmaBufFormatModifierAttribs) {
 453                 /* We do not do any modifier checks here. The create will fail
 454                  * later if the modifier is not supported. */
 455                 return drv_num_planes_from_format(format);
 456         }
 457
 458         uint64_t planes;
 459         GLboolean ret = dri->image_extension->queryDmaBufFormatModifierAttribs(
 460             dri->device, format, modifier, __DRI_IMAGE_ATTRIB_NUM_PLANES, &planes);
 461         if (!ret)
 462                 return 0;
 463
 464         return planes;
 465 }
 466
 467 #endif