egl: inline fallback for swap_buffers_region
[mesa.git] / src / egl / drivers / dri2 / platform_surfaceless.c
1 /*
2 * Mesa 3-D graphics library
3 *
4 * Copyright (c) 2014 The Chromium OS Authors.
5 * Copyright © 2011 Intel Corporation
6 *
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
13 *
14 * The above copyright notice and this permission notice shall be included
15 * in all copies or substantial portions of the Software.
16 *
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
24 */
25
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <xf86drm.h>
30 #include <dlfcn.h>
31 #include <sys/types.h>
32 #include <sys/stat.h>
33 #include <fcntl.h>
34 #include <unistd.h>
35
36 #include "egl_dri2.h"
37 #include "egl_dri2_fallbacks.h"
38 #include "loader.h"
39
40 static __DRIimage*
41 surfaceless_alloc_image(struct dri2_egl_display *dri2_dpy,
42 struct dri2_egl_surface *dri2_surf)
43 {
44 return dri2_dpy->image->createImage(
45 dri2_dpy->dri_screen,
46 dri2_surf->base.Width,
47 dri2_surf->base.Height,
48 dri2_surf->visual,
49 0,
50 NULL);
51 }
52
53 static void
54 surfaceless_free_images(struct dri2_egl_surface *dri2_surf)
55 {
56 struct dri2_egl_display *dri2_dpy =
57 dri2_egl_display(dri2_surf->base.Resource.Display);
58
59 if (dri2_surf->front) {
60 dri2_dpy->image->destroyImage(dri2_surf->front);
61 dri2_surf->front = NULL;
62 }
63
64 free(dri2_surf->swrast_device_buffer);
65 dri2_surf->swrast_device_buffer = NULL;
66 }
67
68 static int
69 surfaceless_image_get_buffers(__DRIdrawable *driDrawable,
70 unsigned int format,
71 uint32_t *stamp,
72 void *loaderPrivate,
73 uint32_t buffer_mask,
74 struct __DRIimageList *buffers)
75 {
76 struct dri2_egl_surface *dri2_surf = loaderPrivate;
77 struct dri2_egl_display *dri2_dpy =
78 dri2_egl_display(dri2_surf->base.Resource.Display);
79
80 buffers->image_mask = 0;
81 buffers->front = NULL;
82 buffers->back = NULL;
83
84 /* The EGL 1.5 spec states that pbuffers are single-buffered. Specifically,
85 * the spec states that they have a back buffer but no front buffer, in
86 * contrast to pixmaps, which have a front buffer but no back buffer.
87 *
88 * Single-buffered surfaces with no front buffer confuse Mesa; so we deviate
89 * from the spec, following the precedent of Mesa's EGL X11 platform. The
90 * X11 platform correctly assigns pbuffers to single-buffered configs, but
91 * assigns the pbuffer a front buffer instead of a back buffer.
92 *
93 * Pbuffers in the X11 platform mostly work today, so let's just copy its
94 * behavior instead of trying to fix (and hence potentially breaking) the
95 * world.
96 */
97
98 if (buffer_mask & __DRI_IMAGE_BUFFER_FRONT) {
99
100 if (!dri2_surf->front)
101 dri2_surf->front =
102 surfaceless_alloc_image(dri2_dpy, dri2_surf);
103
104 buffers->image_mask |= __DRI_IMAGE_BUFFER_FRONT;
105 buffers->front = dri2_surf->front;
106 }
107
108 return 1;
109 }
110
111 static _EGLSurface *
112 dri2_surfaceless_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
113 _EGLConfig *conf, const EGLint *attrib_list)
114 {
115 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
116 struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
117 struct dri2_egl_surface *dri2_surf;
118 const __DRIconfig *config;
119
120 /* Make sure to calloc so all pointers
121 * are originally NULL.
122 */
123 dri2_surf = calloc(1, sizeof *dri2_surf);
124
125 if (!dri2_surf) {
126 _eglError(EGL_BAD_ALLOC, "eglCreatePbufferSurface");
127 return NULL;
128 }
129
130 if (!dri2_init_surface(&dri2_surf->base, disp, type, conf, attrib_list,
131 false, NULL))
132 goto cleanup_surface;
133
134 config = dri2_get_dri_config(dri2_conf, type,
135 dri2_surf->base.GLColorspace);
136
137 if (!config) {
138 _eglError(EGL_BAD_MATCH, "Unsupported surfacetype/colorspace configuration");
139 goto cleanup_surface;
140 }
141
142 dri2_surf->visual = dri2_image_format_for_pbuffer_config(dri2_dpy, config);
143 if (dri2_surf->visual == __DRI_IMAGE_FORMAT_NONE)
144 goto cleanup_surface;
145
146 if (!dri2_create_drawable(dri2_dpy, config, dri2_surf, dri2_surf))
147 goto cleanup_surface;
148
149 return &dri2_surf->base;
150
151 cleanup_surface:
152 free(dri2_surf);
153 return NULL;
154 }
155
156 static EGLBoolean
157 surfaceless_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
158 {
159 struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
160 struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
161
162 surfaceless_free_images(dri2_surf);
163
164 dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
165
166 dri2_fini_surface(surf);
167 free(dri2_surf);
168 return EGL_TRUE;
169 }
170
171 static _EGLSurface *
172 dri2_surfaceless_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *disp,
173 _EGLConfig *conf, const EGLint *attrib_list)
174 {
175 return dri2_surfaceless_create_surface(drv, disp, EGL_PBUFFER_BIT, conf,
176 attrib_list);
177 }
178
179 static const struct dri2_egl_display_vtbl dri2_surfaceless_display_vtbl = {
180 .create_pbuffer_surface = dri2_surfaceless_create_pbuffer_surface,
181 .destroy_surface = surfaceless_destroy_surface,
182 .create_image = dri2_create_image_khr,
183 .post_sub_buffer = dri2_fallback_post_sub_buffer,
184 .copy_buffers = dri2_fallback_copy_buffers,
185 .query_buffer_age = dri2_fallback_query_buffer_age,
186 .create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
187 .get_sync_values = dri2_fallback_get_sync_values,
188 .get_dri_drawable = dri2_surface_get_dri_drawable,
189 };
190
191 static void
192 surfaceless_flush_front_buffer(__DRIdrawable *driDrawable, void *loaderPrivate)
193 {
194 }
195
196 static unsigned
197 surfaceless_get_capability(void *loaderPrivate, enum dri_loader_cap cap)
198 {
199 /* Note: loaderPrivate is _EGLDisplay* */
200 switch (cap) {
201 case DRI_LOADER_CAP_FP16:
202 return 1;
203 default:
204 return 0;
205 }
206 }
207
208 static const __DRIimageLoaderExtension image_loader_extension = {
209 .base = { __DRI_IMAGE_LOADER, 2 },
210 .getBuffers = surfaceless_image_get_buffers,
211 .flushFrontBuffer = surfaceless_flush_front_buffer,
212 .getCapability = surfaceless_get_capability,
213 };
214
215 static const __DRIextension *image_loader_extensions[] = {
216 &image_loader_extension.base,
217 &image_lookup_extension.base,
218 &use_invalidate.base,
219 NULL,
220 };
221
222 static const __DRIextension *swrast_loader_extensions[] = {
223 &swrast_pbuffer_loader_extension.base,
224 &image_loader_extension.base,
225 &image_lookup_extension.base,
226 &use_invalidate.base,
227 NULL,
228 };
229
230 static bool
231 surfaceless_probe_device(_EGLDisplay *disp, bool swrast)
232 {
233 #define MAX_DRM_DEVICES 64
234 const unsigned node_type = swrast ? DRM_NODE_PRIMARY : DRM_NODE_RENDER;
235 struct dri2_egl_display *dri2_dpy = disp->DriverData;
236 drmDevicePtr device, devices[MAX_DRM_DEVICES] = { NULL };
237 int i, num_devices;
238
239 num_devices = drmGetDevices2(0, devices, ARRAY_SIZE(devices));
240 if (num_devices < 0)
241 return false;
242
243 for (i = 0; i < num_devices; ++i) {
244 device = devices[i];
245
246 if (!(device->available_nodes & (1 << node_type)))
247 continue;
248
249 dri2_dpy->fd = loader_open_device(device->nodes[node_type]);
250 if (dri2_dpy->fd < 0)
251 continue;
252
253 disp->Device = _eglAddDevice(dri2_dpy->fd, swrast);
254 if (!disp->Device) {
255 close(dri2_dpy->fd);
256 dri2_dpy->fd = -1;
257 continue;
258 }
259
260 char *driver_name = loader_get_driver_for_fd(dri2_dpy->fd);
261 if (swrast) {
262 /* Use kms swrast only with vgem / virtio_gpu.
263 * virtio-gpu fallbacks to software rendering when 3D features
264 * are unavailable since 6c5ab, and kms_swrast is more
265 * feature complete than swrast.
266 */
267 if (driver_name &&
268 (strcmp(driver_name, "vgem") == 0 ||
269 strcmp(driver_name, "virtio_gpu") == 0))
270 dri2_dpy->driver_name = strdup("kms_swrast");
271 free(driver_name);
272 } else {
273 /* Use the given hardware driver */
274 dri2_dpy->driver_name = driver_name;
275 }
276
277 if (dri2_dpy->driver_name && dri2_load_driver_dri3(disp))
278 break;
279
280 free(dri2_dpy->driver_name);
281 dri2_dpy->driver_name = NULL;
282 close(dri2_dpy->fd);
283 dri2_dpy->fd = -1;
284 }
285 drmFreeDevices(devices, num_devices);
286
287 if (i == num_devices)
288 return false;
289
290 if (swrast)
291 dri2_dpy->loader_extensions = swrast_loader_extensions;
292 else
293 dri2_dpy->loader_extensions = image_loader_extensions;
294
295 return true;
296 }
297
298 static bool
299 surfaceless_probe_device_sw(_EGLDisplay *disp)
300 {
301 struct dri2_egl_display *dri2_dpy = disp->DriverData;
302
303 dri2_dpy->fd = -1;
304 disp->Device = _eglAddDevice(dri2_dpy->fd, true);
305 assert(disp->Device);
306
307 dri2_dpy->driver_name = strdup("swrast");
308 if (!dri2_dpy->driver_name)
309 return false;
310
311 if (!dri2_load_driver_swrast(disp)) {
312 free(dri2_dpy->driver_name);
313 dri2_dpy->driver_name = NULL;
314 return false;
315 }
316
317 dri2_dpy->loader_extensions = swrast_loader_extensions;
318 return true;
319 }
320
321 EGLBoolean
322 dri2_initialize_surfaceless(_EGLDriver *drv, _EGLDisplay *disp)
323 {
324 struct dri2_egl_display *dri2_dpy;
325 const char* err;
326 bool driver_loaded = false;
327
328 dri2_dpy = calloc(1, sizeof *dri2_dpy);
329 if (!dri2_dpy)
330 return _eglError(EGL_BAD_ALLOC, "eglInitialize");
331
332 dri2_dpy->fd = -1;
333 disp->DriverData = (void *) dri2_dpy;
334
335 if (!disp->Options.ForceSoftware) {
336 driver_loaded = surfaceless_probe_device(disp, false);
337 if (!driver_loaded)
338 _eglLog(_EGL_WARNING,
339 "No hardware driver found, falling back to software rendering");
340 }
341
342 if (!driver_loaded)
343 driver_loaded = surfaceless_probe_device(disp, true);
344
345 if (!driver_loaded) {
346 _eglLog(_EGL_DEBUG, "Falling back to surfaceless swrast without DRM.");
347 if (!surfaceless_probe_device_sw(disp)) {
348 err = "DRI2: failed to load driver";
349 goto cleanup;
350 }
351 }
352
353 if (!dri2_create_screen(disp)) {
354 err = "DRI2: failed to create screen";
355 goto cleanup;
356 }
357
358 if (!dri2_setup_extensions(disp)) {
359 err = "DRI2: failed to find required DRI extensions";
360 goto cleanup;
361 }
362
363 dri2_setup_screen(disp);
364 #ifdef HAVE_WAYLAND_PLATFORM
365 dri2_dpy->device_name = loader_get_device_name_for_fd(dri2_dpy->fd);
366 #endif
367 dri2_set_WL_bind_wayland_display(drv, disp);
368
369 if (!dri2_add_pbuffer_configs_for_visuals(drv, disp)) {
370 err = "DRI2: failed to add configs";
371 goto cleanup;
372 }
373
374 /* Fill vtbl last to prevent accidentally calling virtual function during
375 * initialization.
376 */
377 dri2_dpy->vtbl = &dri2_surfaceless_display_vtbl;
378
379 return EGL_TRUE;
380
381 cleanup:
382 dri2_display_destroy(disp);
383 return _eglError(EGL_NOT_INITIALIZED, err);
384 }