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