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