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 <stdbool.h>
13 #include <stdio.h>
14 #include <string.h>
15 #include <sys/mman.h>
16 #include <unistd.h>
17 #include <xf86drm.h>
18
19 #include "dri.h"
20 #include "drv_priv.h"
21 #include "helpers.h"
22 #include "util.h"
23
24 static const struct {
25 uint32_t drm_format;
26 int dri_image_format;
27 } drm_to_dri_image_formats[] = {
28 { DRM_FORMAT_R8, __DRI_IMAGE_FORMAT_R8 },
29 { DRM_FORMAT_GR88, __DRI_IMAGE_FORMAT_GR88 },
30 { DRM_FORMAT_RGB565, __DRI_IMAGE_FORMAT_RGB565 },
31 { DRM_FORMAT_XRGB8888, __DRI_IMAGE_FORMAT_XRGB8888 },
32 { DRM_FORMAT_ARGB8888, __DRI_IMAGE_FORMAT_ARGB8888 },
33 { DRM_FORMAT_XBGR8888, __DRI_IMAGE_FORMAT_XBGR8888 },
34 { DRM_FORMAT_ABGR8888, __DRI_IMAGE_FORMAT_ABGR8888 },
35 { DRM_FORMAT_XRGB2101010, __DRI_IMAGE_FORMAT_XRGB2101010 },
36 { DRM_FORMAT_ARGB2101010, __DRI_IMAGE_FORMAT_ARGB2101010 },
37 };
38
drm_format_to_dri_format(uint32_t drm_format)39 static int drm_format_to_dri_format(uint32_t drm_format)
40 {
41 uint32_t i;
42 for (i = 0; i < ARRAY_SIZE(drm_to_dri_image_formats); i++) {
43 if (drm_to_dri_image_formats[i].drm_format == drm_format)
44 return drm_to_dri_image_formats[i].dri_image_format;
45 }
46
47 return 0;
48 }
49
lookup_extension(const __DRIextension * const * extensions,const char * name,int min_version,const __DRIextension ** dst)50 static bool lookup_extension(const __DRIextension *const *extensions, const char *name,
51 int min_version, const __DRIextension **dst)
52 {
53 while (*extensions) {
54 if ((*extensions)->name && !strcmp((*extensions)->name, name) &&
55 (*extensions)->version >= min_version) {
56 *dst = *extensions;
57 return true;
58 }
59
60 extensions++;
61 }
62
63 return false;
64 }
65
66 /*
67 * The DRI GEM namespace may be different from the minigbm's driver GEM namespace. We have
68 * to import into minigbm.
69 */
import_into_minigbm(struct dri_driver * dri,struct bo * bo)70 static int import_into_minigbm(struct dri_driver *dri, struct bo *bo)
71 {
72 uint32_t handle;
73 int prime_fd, ret;
74
75 if (!dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_FD, &prime_fd))
76 return -errno;
77
78 ret = drmPrimeFDToHandle(bo->drv->fd, prime_fd, &handle);
79 if (ret) {
80 drv_log("drmPrimeFDToHandle failed with %s\n", strerror(errno));
81 return ret;
82 }
83
84 bo->handles[0].u32 = handle;
85 close(prime_fd);
86 return 0;
87 }
88
89 /*
90 * The caller is responsible for setting drv->priv to a structure that derives from dri_driver.
91 */
dri_init(struct driver * drv,const char * dri_so_path,const char * driver_suffix)92 int dri_init(struct driver *drv, const char *dri_so_path, const char *driver_suffix)
93 {
94 char fname[128];
95 const __DRIextension **(*get_extensions)();
96 const __DRIextension *loader_extensions[] = { NULL };
97
98 struct dri_driver *dri = drv->priv;
99 dri->driver_handle = dlopen(dri_so_path, RTLD_NOW | RTLD_GLOBAL);
100 if (!dri->driver_handle)
101 return -ENODEV;
102
103 snprintf(fname, sizeof(fname), __DRI_DRIVER_GET_EXTENSIONS "_%s", driver_suffix);
104 get_extensions = dlsym(dri->driver_handle, fname);
105 if (!get_extensions)
106 goto free_handle;
107
108 dri->extensions = get_extensions();
109 if (!dri->extensions)
110 goto free_handle;
111
112 if (!lookup_extension(dri->extensions, __DRI_CORE, 2,
113 (const __DRIextension **)&dri->core_extension))
114 goto free_handle;
115
116 /* Version 4 for createNewScreen2 */
117 if (!lookup_extension(dri->extensions, __DRI_DRI2, 4,
118 (const __DRIextension **)&dri->dri2_extension))
119 goto free_handle;
120
121 dri->device = dri->dri2_extension->createNewScreen2(0, drv_get_fd(drv), loader_extensions,
122 dri->extensions, &dri->configs, NULL);
123 if (!dri->device)
124 goto free_handle;
125
126 dri->context =
127 dri->dri2_extension->createNewContext(dri->device, *dri->configs, NULL, NULL);
128
129 if (!dri->context)
130 goto free_screen;
131
132 if (!lookup_extension(dri->core_extension->getExtensions(dri->device), __DRI_IMAGE, 12,
133 (const __DRIextension **)&dri->image_extension))
134 goto free_context;
135
136 if (!lookup_extension(dri->core_extension->getExtensions(dri->device), __DRI2_FLUSH, 4,
137 (const __DRIextension **)&dri->flush_extension))
138 goto free_context;
139
140 return 0;
141
142 free_context:
143 dri->core_extension->destroyContext(dri->context);
144 free_screen:
145 dri->core_extension->destroyScreen(dri->device);
146 free_handle:
147 dlclose(dri->driver_handle);
148 dri->driver_handle = NULL;
149 return -ENODEV;
150 }
151
152 /*
153 * The caller is responsible for freeing drv->priv.
154 */
dri_close(struct driver * drv)155 void dri_close(struct driver *drv)
156 {
157 struct dri_driver *dri = drv->priv;
158
159 dri->core_extension->destroyContext(dri->context);
160 dri->core_extension->destroyScreen(dri->device);
161 dlclose(dri->driver_handle);
162 dri->driver_handle = NULL;
163 }
164
dri_bo_create(struct bo * bo,uint32_t width,uint32_t height,uint32_t format,uint64_t use_flags)165 int dri_bo_create(struct bo *bo, uint32_t width, uint32_t height, uint32_t format,
166 uint64_t use_flags)
167 {
168 unsigned int dri_use;
169 int ret, dri_format, stride, offset;
170 struct dri_driver *dri = bo->drv->priv;
171
172 assert(bo->num_planes == 1);
173 dri_format = drm_format_to_dri_format(format);
174
175 /* Gallium drivers require shared to get the handle and stride. */
176 dri_use = __DRI_IMAGE_USE_SHARE;
177 if (use_flags & BO_USE_SCANOUT)
178 dri_use |= __DRI_IMAGE_USE_SCANOUT;
179 if (use_flags & BO_USE_CURSOR)
180 dri_use |= __DRI_IMAGE_USE_CURSOR;
181 if (use_flags & BO_USE_LINEAR)
182 dri_use |= __DRI_IMAGE_USE_LINEAR;
183
184 bo->priv = dri->image_extension->createImage(dri->device, width, height, dri_format,
185 dri_use, NULL);
186 if (!bo->priv) {
187 ret = -errno;
188 return ret;
189 }
190
191 ret = import_into_minigbm(dri, bo);
192 if (ret)
193 goto free_image;
194
195 if (!dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_STRIDE, &stride)) {
196 ret = -errno;
197 goto free_image;
198 }
199
200 if (!dri->image_extension->queryImage(bo->priv, __DRI_IMAGE_ATTRIB_OFFSET, &offset)) {
201 ret = -errno;
202 goto free_image;
203 }
204
205 bo->strides[0] = stride;
206 bo->sizes[0] = stride * height;
207 bo->offsets[0] = offset;
208 bo->total_size = offset + bo->sizes[0];
209 return 0;
210
211 free_image:
212 dri->image_extension->destroyImage(bo->priv);
213 return ret;
214 }
215
dri_bo_import(struct bo * bo,struct drv_import_fd_data * data)216 int dri_bo_import(struct bo *bo, struct drv_import_fd_data *data)
217 {
218 int ret;
219 struct dri_driver *dri = bo->drv->priv;
220
221 assert(bo->num_planes == 1);
222
223 // clang-format off
224 bo->priv = dri->image_extension->createImageFromFds(dri->device, data->width, data->height,
225 data->format, data->fds, bo->num_planes,
226 (int *)data->strides,
227 (int *)data->offsets, NULL);
228 // clang-format on
229 if (!bo->priv)
230 return -errno;
231
232 ret = import_into_minigbm(dri, bo);
233 if (ret) {
234 dri->image_extension->destroyImage(bo->priv);
235 return ret;
236 }
237
238 return 0;
239 }
240
dri_bo_destroy(struct bo * bo)241 int dri_bo_destroy(struct bo *bo)
242 {
243 struct dri_driver *dri = bo->drv->priv;
244
245 assert(bo->priv);
246 dri->image_extension->destroyImage(bo->priv);
247 bo->priv = NULL;
248 return 0;
249 }
250
251 /*
252 * Map an image plane.
253 *
254 * This relies on the underlying driver to do a decompressing and/or de-tiling
255 * blit if necessary,
256 *
257 * This function itself is not thread-safe; we rely on the fact that the caller
258 * locks a per-driver mutex.
259 */
dri_bo_map(struct bo * bo,struct vma * vma,size_t plane,uint32_t map_flags)260 void *dri_bo_map(struct bo *bo, struct vma *vma, size_t plane, uint32_t map_flags)
261 {
262 struct dri_driver *dri = bo->drv->priv;
263
264 /* GBM flags and DRI flags are the same. */
265 vma->addr =
266 dri->image_extension->mapImage(dri->context, bo->priv, 0, 0, bo->width, bo->height,
267 map_flags, (int *)&vma->map_strides[plane], &vma->priv);
268 if (!vma->addr)
269 return MAP_FAILED;
270
271 return vma->addr;
272 }
273
dri_bo_unmap(struct bo * bo,struct vma * vma)274 int dri_bo_unmap(struct bo *bo, struct vma *vma)
275 {
276 struct dri_driver *dri = bo->drv->priv;
277
278 assert(vma->priv);
279 dri->image_extension->unmapImage(dri->context, bo->priv, vma->priv);
280
281 /*
282 * From gbm_dri.c in Mesa:
283 *
284 * "Not all DRI drivers use direct maps. They may queue up DMA operations
285 * on the mapping context. Since there is no explicit gbm flush mechanism,
286 * we need to flush here."
287 */
288
289 dri->flush_extension->flush_with_flags(dri->context, NULL, __DRI2_FLUSH_CONTEXT, 0);
290 return 0;
291 }
292
293 #endif
294