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