2011-02-03 03:21:13 +00:00
|
|
|
/*
|
|
|
|
* Copyright © 2011 Intel Corporation
|
|
|
|
*
|
|
|
|
* Permission is hereby granted, free of charge, to any person obtaining a
|
|
|
|
* copy of this software and associated documentation files (the "Software"),
|
|
|
|
* to deal in the Software without restriction, including without limitation
|
|
|
|
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
|
|
|
|
* and/or sell copies of the Software, and to permit persons to whom the
|
|
|
|
* Software is furnished to do so, subject to the following conditions:
|
|
|
|
*
|
|
|
|
* The above copyright notice and this permission notice (including the next
|
|
|
|
* paragraph) shall be included in all copies or substantial portions of the
|
|
|
|
* Software.
|
|
|
|
*
|
|
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
|
|
* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
|
|
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
|
|
* NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
|
|
|
|
* HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
|
|
|
* WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
|
|
|
|
* DEALINGS IN THE SOFTWARE.
|
|
|
|
*
|
|
|
|
* Authors:
|
|
|
|
* Kristian Høgsberg <krh@bitplanet.net>
|
|
|
|
*/
|
|
|
|
|
2015-02-28 17:12:40 +00:00
|
|
|
#include <stdint.h>
|
2011-02-03 03:21:13 +00:00
|
|
|
#include <stdlib.h>
|
|
|
|
#include <stdio.h>
|
2011-05-30 09:49:55 +01:00
|
|
|
#include <string.h>
|
2011-02-03 03:21:13 +00:00
|
|
|
#include <xf86drm.h>
|
2011-06-07 21:19:21 +01:00
|
|
|
#include <dlfcn.h>
|
2011-06-29 07:49:39 +01:00
|
|
|
#include <sys/types.h>
|
|
|
|
#include <sys/stat.h>
|
|
|
|
#include <fcntl.h>
|
|
|
|
#include <unistd.h>
|
2011-02-03 03:21:13 +00:00
|
|
|
|
|
|
|
#include "egl_dri2.h"
|
2014-01-28 20:34:19 +00:00
|
|
|
#include "egl_dri2_fallbacks.h"
|
2014-01-11 04:52:48 +00:00
|
|
|
#include "loader.h"
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2012-01-25 14:24:17 +00:00
|
|
|
static struct gbm_bo *
|
|
|
|
lock_front_buffer(struct gbm_surface *_surf)
|
|
|
|
{
|
|
|
|
struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
|
|
|
|
struct dri2_egl_surface *dri2_surf = surf->dri_private;
|
2014-06-15 12:49:49 +01:00
|
|
|
struct gbm_dri_device *device = (struct gbm_dri_device *) _surf->gbm;
|
2012-01-25 14:24:17 +00:00
|
|
|
struct gbm_bo *bo;
|
|
|
|
|
|
|
|
if (dri2_surf->current == NULL) {
|
|
|
|
_eglError(EGL_BAD_SURFACE, "no front buffer");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
bo = dri2_surf->current->bo;
|
2014-06-15 12:49:49 +01:00
|
|
|
|
|
|
|
if (device->dri2) {
|
|
|
|
dri2_surf->current->locked = 1;
|
|
|
|
dri2_surf->current = NULL;
|
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
return bo;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
release_buffer(struct gbm_surface *_surf, struct gbm_bo *bo)
|
|
|
|
{
|
|
|
|
struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
|
|
|
|
struct dri2_egl_surface *dri2_surf = surf->dri_private;
|
2015-08-06 07:34:07 +01:00
|
|
|
unsigned i;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
|
|
|
|
if (dri2_surf->color_buffers[i].bo == bo) {
|
|
|
|
dri2_surf->color_buffers[i].locked = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
has_free_buffers(struct gbm_surface *_surf)
|
|
|
|
{
|
|
|
|
struct gbm_dri_surface *surf = (struct gbm_dri_surface *) _surf;
|
|
|
|
struct dri2_egl_surface *dri2_surf = surf->dri_private;
|
2015-08-06 07:34:07 +01:00
|
|
|
unsigned i;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
|
|
|
|
if (!dri2_surf->color_buffers[i].locked)
|
|
|
|
return 1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static _EGLSurface *
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_create_surface(_EGLDriver *drv, _EGLDisplay *disp, EGLint type,
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
_EGLConfig *conf, void *native_window,
|
2014-01-28 20:47:38 +00:00
|
|
|
const EGLint *attrib_list)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
struct dri2_egl_config *dri2_conf = dri2_egl_config(conf);
|
|
|
|
struct dri2_egl_surface *dri2_surf;
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
struct gbm_surface *window = native_window;
|
2012-01-25 14:24:17 +00:00
|
|
|
struct gbm_dri_surface *surf;
|
2015-09-13 12:36:54 +01:00
|
|
|
const __DRIconfig *config;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
(void) drv;
|
|
|
|
|
2012-09-05 07:09:22 +01:00
|
|
|
dri2_surf = calloc(1, sizeof *dri2_surf);
|
2012-01-25 14:24:17 +00:00
|
|
|
if (!dri2_surf) {
|
|
|
|
_eglError(EGL_BAD_ALLOC, "dri2_create_surface");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_eglInitSurface(&dri2_surf->base, disp, type, conf, attrib_list))
|
|
|
|
goto cleanup_surf;
|
|
|
|
|
|
|
|
switch (type) {
|
|
|
|
case EGL_WINDOW_BIT:
|
2015-06-18 20:16:46 +01:00
|
|
|
if (!window) {
|
|
|
|
_eglError(EGL_BAD_NATIVE_WINDOW, "dri2_create_surface");
|
|
|
|
goto cleanup_surf;
|
|
|
|
}
|
|
|
|
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
surf = gbm_dri_surface(window);
|
2012-01-25 14:24:17 +00:00
|
|
|
dri2_surf->gbm_surf = surf;
|
|
|
|
dri2_surf->base.Width = surf->base.width;
|
|
|
|
dri2_surf->base.Height = surf->base.height;
|
|
|
|
surf->dri_private = dri2_surf;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
goto cleanup_surf;
|
|
|
|
}
|
|
|
|
|
2015-09-13 12:36:54 +01:00
|
|
|
config = dri2_get_dri_config(dri2_conf, EGL_WINDOW_BIT,
|
|
|
|
dri2_surf->base.GLColorspace);
|
2015-06-10 01:49:29 +01:00
|
|
|
|
2015-09-13 12:36:54 +01:00
|
|
|
if (dri2_dpy->dri2) {
|
2014-06-15 12:49:49 +01:00
|
|
|
dri2_surf->dri_drawable =
|
2015-11-25 05:27:02 +00:00
|
|
|
dri2_dpy->dri2->createNewDrawable(dri2_dpy->dri_screen, config,
|
|
|
|
dri2_surf->gbm_surf);
|
2014-06-15 12:49:49 +01:00
|
|
|
|
|
|
|
} else {
|
|
|
|
assert(dri2_dpy->swrast != NULL);
|
2015-09-13 12:36:54 +01:00
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
dri2_surf->dri_drawable =
|
2015-11-25 05:27:02 +00:00
|
|
|
dri2_dpy->swrast->createNewDrawable(dri2_dpy->dri_screen, config,
|
|
|
|
dri2_surf->gbm_surf);
|
2012-01-25 14:24:17 +00:00
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
if (dri2_surf->dri_drawable == NULL) {
|
2014-06-15 12:49:49 +01:00
|
|
|
_eglError(EGL_BAD_ALLOC, "createNewDrawable()");
|
2012-01-25 14:24:17 +00:00
|
|
|
goto cleanup_surf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &dri2_surf->base;
|
|
|
|
|
|
|
|
cleanup_surf:
|
|
|
|
free(dri2_surf);
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static _EGLSurface *
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_create_window_surface(_EGLDriver *drv, _EGLDisplay *disp,
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
_EGLConfig *conf, void *native_window,
|
2014-01-28 20:47:38 +00:00
|
|
|
const EGLint *attrib_list)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
2014-01-28 20:47:38 +00:00
|
|
|
return dri2_drm_create_surface(drv, disp, EGL_WINDOW_BIT, conf,
|
egl/main: Stop using EGLNative types internally
Internally, much of the EGL code uses EGLNativeDisplayType,
EGLNativeWindowType, and EGLPixmapType. However, the EGLNative type
often does not match the variable's actual type.
The concept of EGLNative types are a bad match for Linux, as explained
below. And the EGL platform extensions don't use EGLNative types at all.
Those extensions attempt to solve cross-platform issues by moving the
EGL API away from the EGLNative types.
The core of the problem is that eglplatform.h can define each EGLNative
type once only, but Linux supports multiple EGL platforms.
To work around the problem, Mesa's eglplatform.h contains multiple
definitions of each EGLNative type, selected by feature macros. Mesa
expects EGL clients to set the feature macro approrpiately. But the
feature macros don't work when a single codebase must be built with
support for multiple EGL platforms, *such as Mesa itself*.
When building libEGL, autotools chooses the EGLNative typedefs based on
the first element of '--with-egl-platforms'. For example,
'--with-egl-platforms=x11,drm,wayland' defines the following:
typedef Display* EGLNativeDisplayType;
typedef Window EGLNativeWindowType;
typedef Pixmap EGLNativePixmapType;
Clearly, this doesn't work well for Wayland and GBM. Mesa works around
the problem by casting the EGLNative types to different things in
different files.
For sanity's sake, and to prepare for the EGL platform extensions, this
patch removes from egl/main and egl/dri2 all internal use of the
EGLNative types. It replaces them with 'void*' and checks each explicit
cast with a static assertion. Also, the patch touches egl_gallium the
minimal amount to keep it compatible with eglapi.h.
Signed-off-by: Chad Versace <chad.versace@linux.intel.com>
2014-01-07 22:54:51 +00:00
|
|
|
native_window, attrib_list);
|
2012-01-25 14:24:17 +00:00
|
|
|
}
|
|
|
|
|
2014-02-09 17:13:08 +00:00
|
|
|
static _EGLSurface *
|
|
|
|
dri2_drm_create_pixmap_surface(_EGLDriver *drv, _EGLDisplay *disp,
|
|
|
|
_EGLConfig *conf, void *native_window,
|
|
|
|
const EGLint *attrib_list)
|
|
|
|
{
|
|
|
|
/* From the EGL_MESA_platform_gbm spec, version 5:
|
|
|
|
*
|
|
|
|
* It is not valid to call eglCreatePlatformPixmapSurfaceEXT with a <dpy>
|
|
|
|
* that belongs to the GBM platform. Any such call fails and generates
|
|
|
|
* EGL_BAD_PARAMETER.
|
|
|
|
*/
|
|
|
|
_eglError(EGL_BAD_PARAMETER, "cannot create EGL pixmap surfaces on GBM");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-01-25 14:24:17 +00:00
|
|
|
static EGLBoolean
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *surf)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surf);
|
2015-08-06 07:34:07 +01:00
|
|
|
unsigned i;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
2015-11-25 05:27:02 +00:00
|
|
|
dri2_dpy->core->destroyDrawable(dri2_surf->dri_drawable);
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
|
|
|
|
if (dri2_surf->color_buffers[i].bo)
|
|
|
|
gbm_bo_destroy(dri2_surf->color_buffers[i].bo);
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < __DRI_BUFFER_COUNT; i++) {
|
|
|
|
if (dri2_surf->dri_buffers[i])
|
|
|
|
dri2_dpy->dri2->releaseBuffer(dri2_dpy->dri_screen,
|
|
|
|
dri2_surf->dri_buffers[i]);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(surf);
|
|
|
|
|
|
|
|
return EGL_TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
2013-11-09 06:06:51 +00:00
|
|
|
get_back_bo(struct dri2_egl_surface *dri2_surf)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy =
|
|
|
|
dri2_egl_display(dri2_surf->base.Resource.Display);
|
|
|
|
struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
|
2016-11-23 22:40:42 +00:00
|
|
|
int age = 0;
|
2015-08-06 07:34:07 +01:00
|
|
|
unsigned i;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
if (dri2_surf->back == NULL) {
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++) {
|
2016-11-23 22:40:42 +00:00
|
|
|
if (!dri2_surf->color_buffers[i].locked &&
|
|
|
|
dri2_surf->color_buffers[i].age >= age) {
|
2012-01-25 14:24:17 +00:00
|
|
|
dri2_surf->back = &dri2_surf->color_buffers[i];
|
2016-11-23 22:40:42 +00:00
|
|
|
age = dri2_surf->color_buffers[i].age;
|
2012-01-25 14:24:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dri2_surf->back == NULL)
|
|
|
|
return -1;
|
2017-03-14 01:19:00 +00:00
|
|
|
if (dri2_surf->back->bo == NULL) {
|
|
|
|
if (surf->base.modifiers)
|
|
|
|
dri2_surf->back->bo = gbm_bo_create_with_modifiers(&dri2_dpy->gbm_dri->base.base,
|
|
|
|
surf->base.width, surf->base.height,
|
|
|
|
surf->base.format,
|
|
|
|
surf->base.modifiers,
|
|
|
|
surf->base.count);
|
|
|
|
else
|
|
|
|
dri2_surf->back->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base.base,
|
|
|
|
surf->base.width,
|
|
|
|
surf->base.height,
|
|
|
|
surf->base.format,
|
|
|
|
surf->base.flags);
|
|
|
|
|
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
if (dri2_surf->back->bo == NULL)
|
|
|
|
return -1;
|
|
|
|
|
2013-11-09 06:06:51 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
static int
|
|
|
|
get_swrast_front_bo(struct dri2_egl_surface *dri2_surf)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy =
|
|
|
|
dri2_egl_display(dri2_surf->base.Resource.Display);
|
|
|
|
struct gbm_dri_surface *surf = dri2_surf->gbm_surf;
|
|
|
|
|
|
|
|
if (dri2_surf->current == NULL) {
|
|
|
|
assert(!dri2_surf->color_buffers[0].locked);
|
|
|
|
dri2_surf->current = &dri2_surf->color_buffers[0];
|
|
|
|
}
|
|
|
|
|
|
|
|
if (dri2_surf->current->bo == NULL)
|
|
|
|
dri2_surf->current->bo = gbm_bo_create(&dri2_dpy->gbm_dri->base.base,
|
|
|
|
surf->base.width, surf->base.height,
|
|
|
|
surf->base.format, surf->base.flags);
|
|
|
|
if (dri2_surf->current->bo == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2013-11-09 06:06:51 +00:00
|
|
|
static void
|
|
|
|
back_bo_to_dri_buffer(struct dri2_egl_surface *dri2_surf, __DRIbuffer *buffer)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy =
|
|
|
|
dri2_egl_display(dri2_surf->base.Resource.Display);
|
|
|
|
struct gbm_dri_bo *bo;
|
|
|
|
int name, pitch;
|
|
|
|
|
2012-01-25 14:24:17 +00:00
|
|
|
bo = (struct gbm_dri_bo *) dri2_surf->back->bo;
|
|
|
|
|
|
|
|
dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_NAME, &name);
|
|
|
|
dri2_dpy->image->queryImage(bo->image, __DRI_IMAGE_ATTRIB_STRIDE, &pitch);
|
|
|
|
|
|
|
|
buffer->attachment = __DRI_BUFFER_BACK_LEFT;
|
|
|
|
buffer->name = name;
|
|
|
|
buffer->pitch = pitch;
|
|
|
|
buffer->cpp = 4;
|
|
|
|
buffer->flags = 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int
|
|
|
|
get_aux_bo(struct dri2_egl_surface *dri2_surf,
|
|
|
|
unsigned int attachment, unsigned int format, __DRIbuffer *buffer)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy =
|
|
|
|
dri2_egl_display(dri2_surf->base.Resource.Display);
|
2012-04-10 22:48:14 +01:00
|
|
|
__DRIbuffer *b = dri2_surf->dri_buffers[attachment];
|
2012-01-25 14:24:17 +00:00
|
|
|
|
2012-04-10 22:48:14 +01:00
|
|
|
if (b == NULL) {
|
2012-01-25 14:24:17 +00:00
|
|
|
b = dri2_dpy->dri2->allocateBuffer(dri2_dpy->dri_screen,
|
|
|
|
attachment, format,
|
|
|
|
dri2_surf->base.Width,
|
|
|
|
dri2_surf->base.Height);
|
2012-04-10 22:48:14 +01:00
|
|
|
dri2_surf->dri_buffers[attachment] = b;
|
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
if (b == NULL)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
memcpy(buffer, b, sizeof *buffer);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __DRIbuffer *
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_get_buffers_with_format(__DRIdrawable *driDrawable,
|
2012-01-25 14:24:17 +00:00
|
|
|
int *width, int *height,
|
|
|
|
unsigned int *attachments, int count,
|
|
|
|
int *out_count, void *loaderPrivate)
|
|
|
|
{
|
|
|
|
struct dri2_egl_surface *dri2_surf = loaderPrivate;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
dri2_surf->buffer_count = 0;
|
|
|
|
for (i = 0, j = 0; i < 2 * count; i += 2, j++) {
|
|
|
|
assert(attachments[i] < __DRI_BUFFER_COUNT);
|
|
|
|
assert(dri2_surf->buffer_count < 5);
|
|
|
|
|
|
|
|
switch (attachments[i]) {
|
|
|
|
case __DRI_BUFFER_BACK_LEFT:
|
2013-11-09 06:06:51 +00:00
|
|
|
if (get_back_bo(dri2_surf) < 0) {
|
2012-01-25 14:24:17 +00:00
|
|
|
_eglError(EGL_BAD_ALLOC, "failed to allocate color buffer");
|
|
|
|
return NULL;
|
|
|
|
}
|
2013-11-09 06:06:51 +00:00
|
|
|
back_bo_to_dri_buffer(dri2_surf, &dri2_surf->buffers[j]);
|
2012-01-25 14:24:17 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
if (get_aux_bo(dri2_surf, attachments[i], attachments[i + 1],
|
|
|
|
&dri2_surf->buffers[j]) < 0) {
|
|
|
|
_eglError(EGL_BAD_ALLOC, "failed to allocate aux buffer");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*out_count = j;
|
|
|
|
if (j == 0)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
*width = dri2_surf->base.Width;
|
|
|
|
*height = dri2_surf->base.Height;
|
|
|
|
|
|
|
|
return dri2_surf->buffers;
|
|
|
|
}
|
|
|
|
|
|
|
|
static __DRIbuffer *
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_get_buffers(__DRIdrawable * driDrawable,
|
|
|
|
int *width, int *height,
|
|
|
|
unsigned int *attachments, int count,
|
|
|
|
int *out_count, void *loaderPrivate)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
unsigned int *attachments_with_format;
|
|
|
|
__DRIbuffer *buffer;
|
|
|
|
const unsigned int format = 32;
|
|
|
|
int i;
|
|
|
|
|
2014-09-03 22:33:18 +01:00
|
|
|
attachments_with_format = calloc(count, 2 * sizeof(unsigned int));
|
2012-01-25 14:24:17 +00:00
|
|
|
if (!attachments_with_format) {
|
|
|
|
*out_count = 0;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < count; ++i) {
|
|
|
|
attachments_with_format[2*i] = attachments[i];
|
|
|
|
attachments_with_format[2*i + 1] = format;
|
|
|
|
}
|
|
|
|
|
|
|
|
buffer =
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_get_buffers_with_format(driDrawable,
|
|
|
|
width, height,
|
|
|
|
attachments_with_format, count,
|
|
|
|
out_count, loaderPrivate);
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
free(attachments_with_format);
|
|
|
|
|
|
|
|
return buffer;
|
|
|
|
}
|
|
|
|
|
2013-11-09 06:06:51 +00:00
|
|
|
static int
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_image_get_buffers(__DRIdrawable *driDrawable,
|
|
|
|
unsigned int format,
|
|
|
|
uint32_t *stamp,
|
|
|
|
void *loaderPrivate,
|
|
|
|
uint32_t buffer_mask,
|
|
|
|
struct __DRIimageList *buffers)
|
2013-11-09 06:06:51 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_surface *dri2_surf = loaderPrivate;
|
|
|
|
struct gbm_dri_bo *bo;
|
|
|
|
|
|
|
|
if (get_back_bo(dri2_surf) < 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
bo = (struct gbm_dri_bo *) dri2_surf->back->bo;
|
|
|
|
buffers->image_mask = __DRI_IMAGE_BUFFER_BACK;
|
|
|
|
buffers->back = bo->image;
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2012-01-25 14:24:17 +00:00
|
|
|
static void
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_flush_front_buffer(__DRIdrawable * driDrawable, void *loaderPrivate)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
(void) driDrawable;
|
|
|
|
(void) loaderPrivate;
|
|
|
|
}
|
|
|
|
|
|
|
|
static EGLBoolean
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *disp, _EGLSurface *draw)
|
2012-01-25 14:24:17 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
struct dri2_egl_surface *dri2_surf = dri2_egl_surface(draw);
|
2015-08-06 07:34:07 +01:00
|
|
|
unsigned i;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
if (dri2_dpy->swrast) {
|
2015-11-25 05:27:02 +00:00
|
|
|
dri2_dpy->core->swapBuffers(dri2_surf->dri_drawable);
|
2014-06-15 12:49:49 +01:00
|
|
|
} else {
|
|
|
|
if (dri2_surf->base.Type == EGL_WINDOW_BIT) {
|
|
|
|
if (dri2_surf->current)
|
|
|
|
_eglError(EGL_BAD_SURFACE, "dri2_swap_buffers");
|
|
|
|
for (i = 0; i < ARRAY_SIZE(dri2_surf->color_buffers); i++)
|
|
|
|
if (dri2_surf->color_buffers[i].age > 0)
|
|
|
|
dri2_surf->color_buffers[i].age++;
|
2014-10-14 10:39:47 +01:00
|
|
|
|
|
|
|
/* Make sure we have a back buffer in case we're swapping without
|
|
|
|
* ever rendering. */
|
|
|
|
if (get_back_bo(dri2_surf) < 0) {
|
|
|
|
_eglError(EGL_BAD_ALLOC, "dri2_swap_buffers");
|
|
|
|
return EGL_FALSE;
|
|
|
|
}
|
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
dri2_surf->current = dri2_surf->back;
|
|
|
|
dri2_surf->current->age = 1;
|
|
|
|
dri2_surf->back = NULL;
|
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
|
2014-12-21 19:51:33 +00:00
|
|
|
dri2_flush_drawable_for_swapbuffers(disp, draw);
|
2015-11-25 05:27:02 +00:00
|
|
|
dri2_dpy->flush->invalidate(dri2_surf->dri_drawable);
|
2014-06-15 12:49:49 +01:00
|
|
|
}
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
return EGL_TRUE;
|
|
|
|
}
|
|
|
|
|
2012-12-14 04:39:45 +00:00
|
|
|
static EGLint
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_query_buffer_age(_EGLDriver *drv,
|
|
|
|
_EGLDisplay *disp, _EGLSurface *surface)
|
2012-12-14 04:39:45 +00:00
|
|
|
{
|
|
|
|
struct dri2_egl_surface *dri2_surf = dri2_egl_surface(surface);
|
|
|
|
|
2013-11-09 06:06:51 +00:00
|
|
|
if (get_back_bo(dri2_surf) < 0) {
|
2012-12-14 04:39:45 +00:00
|
|
|
_eglError(EGL_BAD_ALLOC, "dri2_query_buffer_age");
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
return dri2_surf->back->age;
|
|
|
|
}
|
|
|
|
|
2011-05-30 09:50:52 +01:00
|
|
|
static _EGLImage *
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_drm_create_image_khr_pixmap(_EGLDisplay *disp, _EGLContext *ctx,
|
|
|
|
EGLClientBuffer buffer, const EGLint *attr_list)
|
2011-05-30 09:50:52 +01:00
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
struct gbm_dri_bo *dri_bo = gbm_dri_bo((struct gbm_bo *) buffer);
|
|
|
|
struct dri2_egl_image *dri2_img;
|
|
|
|
|
|
|
|
dri2_img = malloc(sizeof *dri2_img);
|
|
|
|
if (!dri2_img) {
|
|
|
|
_eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!_eglInitImage(&dri2_img->base, disp)) {
|
|
|
|
free(dri2_img);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
dri2_img->dri_image = dri2_dpy->image->dupImage(dri_bo->image, dri2_img);
|
|
|
|
if (dri2_img->dri_image == NULL) {
|
|
|
|
free(dri2_img);
|
|
|
|
_eglError(EGL_BAD_ALLOC, "dri2_create_image_khr_pixmap");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return &dri2_img->base;
|
|
|
|
}
|
|
|
|
|
|
|
|
static _EGLImage *
|
|
|
|
dri2_drm_create_image_khr(_EGLDriver *drv, _EGLDisplay *disp,
|
|
|
|
_EGLContext *ctx, EGLenum target,
|
|
|
|
EGLClientBuffer buffer, const EGLint *attr_list)
|
|
|
|
{
|
|
|
|
(void) drv;
|
|
|
|
|
|
|
|
switch (target) {
|
|
|
|
case EGL_NATIVE_PIXMAP_KHR:
|
2014-01-28 20:47:38 +00:00
|
|
|
return dri2_drm_create_image_khr_pixmap(disp, ctx, buffer, attr_list);
|
2011-05-30 09:50:52 +01:00
|
|
|
default:
|
|
|
|
return dri2_create_image_khr(drv, disp, ctx, target, buffer, attr_list);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-02-21 15:22:34 +00:00
|
|
|
static int
|
|
|
|
dri2_drm_authenticate(_EGLDisplay *disp, uint32_t id)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
|
|
|
|
return drmAuthMagic(dri2_dpy->fd, id);
|
|
|
|
}
|
|
|
|
|
2014-06-15 12:49:49 +01:00
|
|
|
static void
|
|
|
|
swrast_put_image2(__DRIdrawable *driDrawable,
|
|
|
|
int op,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int width,
|
|
|
|
int height,
|
|
|
|
int stride,
|
|
|
|
char *data,
|
|
|
|
void *loaderPrivate)
|
|
|
|
{
|
|
|
|
struct dri2_egl_surface *dri2_surf = loaderPrivate;
|
|
|
|
int internal_stride, i;
|
|
|
|
struct gbm_dri_bo *bo;
|
|
|
|
|
|
|
|
if (op != __DRI_SWRAST_IMAGE_OP_DRAW &&
|
|
|
|
op != __DRI_SWRAST_IMAGE_OP_SWAP)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (get_swrast_front_bo(dri2_surf) < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bo = gbm_dri_bo(dri2_surf->current->bo);
|
2016-05-17 03:14:21 +01:00
|
|
|
if (gbm_dri_bo_map_dumb(bo) == NULL)
|
2014-06-15 12:49:49 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
internal_stride = bo->base.base.stride;
|
|
|
|
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
memcpy(bo->map + (x + i) * internal_stride + y,
|
|
|
|
data + i * stride, stride);
|
|
|
|
}
|
|
|
|
|
2016-05-17 03:14:21 +01:00
|
|
|
gbm_dri_bo_unmap_dumb(bo);
|
2014-06-15 12:49:49 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
swrast_get_image(__DRIdrawable *driDrawable,
|
|
|
|
int x,
|
|
|
|
int y,
|
|
|
|
int width,
|
|
|
|
int height,
|
|
|
|
char *data,
|
|
|
|
void *loaderPrivate)
|
|
|
|
{
|
|
|
|
struct dri2_egl_surface *dri2_surf = loaderPrivate;
|
|
|
|
int internal_stride, stride, i;
|
|
|
|
struct gbm_dri_bo *bo;
|
|
|
|
|
|
|
|
if (get_swrast_front_bo(dri2_surf) < 0)
|
|
|
|
return;
|
|
|
|
|
|
|
|
bo = gbm_dri_bo(dri2_surf->current->bo);
|
2016-05-17 03:14:21 +01:00
|
|
|
if (gbm_dri_bo_map_dumb(bo) == NULL)
|
2014-06-15 12:49:49 +01:00
|
|
|
return;
|
|
|
|
|
|
|
|
internal_stride = bo->base.base.stride;
|
|
|
|
stride = width * 4;
|
|
|
|
|
|
|
|
for (i = 0; i < height; i++) {
|
|
|
|
memcpy(data + i * stride,
|
|
|
|
bo->map + (x + i) * internal_stride + y, stride);
|
|
|
|
}
|
|
|
|
|
2016-05-17 03:14:21 +01:00
|
|
|
gbm_dri_bo_unmap_dumb(bo);
|
2014-06-15 12:49:49 +01:00
|
|
|
}
|
|
|
|
|
2016-08-25 14:00:50 +01:00
|
|
|
static EGLBoolean
|
|
|
|
drm_add_configs_for_visuals(_EGLDriver *drv, _EGLDisplay *disp)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy = dri2_egl_display(disp);
|
|
|
|
static const struct {
|
|
|
|
int format;
|
|
|
|
unsigned int red_mask;
|
|
|
|
unsigned int alpha_mask;
|
|
|
|
} visuals[] = {
|
|
|
|
{ GBM_FORMAT_XRGB2101010, 0x3ff00000, 0x00000000 },
|
|
|
|
{ GBM_FORMAT_ARGB2101010, 0x3ff00000, 0xc0000000 },
|
|
|
|
{ GBM_FORMAT_XRGB8888, 0x00ff0000, 0x00000000 },
|
|
|
|
{ GBM_FORMAT_ARGB8888, 0x00ff0000, 0xff000000 },
|
|
|
|
{ GBM_FORMAT_RGB565, 0x0000f800, 0x00000000 },
|
|
|
|
};
|
|
|
|
EGLint attr_list[] = {
|
|
|
|
EGL_NATIVE_VISUAL_ID, 0,
|
|
|
|
EGL_NONE,
|
|
|
|
};
|
|
|
|
unsigned int format_count[ARRAY_SIZE(visuals)] = { 0 };
|
|
|
|
unsigned int count, i, j;
|
|
|
|
|
|
|
|
count = 0;
|
|
|
|
for (i = 0; dri2_dpy->driver_configs[i]; i++) {
|
|
|
|
unsigned int red, alpha;
|
|
|
|
|
|
|
|
dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[i],
|
|
|
|
__DRI_ATTRIB_RED_MASK, &red);
|
|
|
|
dri2_dpy->core->getConfigAttrib(dri2_dpy->driver_configs[i],
|
|
|
|
__DRI_ATTRIB_ALPHA_MASK, &alpha);
|
|
|
|
|
|
|
|
for (j = 0; j < ARRAY_SIZE(visuals); j++) {
|
|
|
|
struct dri2_egl_config *dri2_conf;
|
|
|
|
|
|
|
|
if (visuals[j].red_mask != red || visuals[j].alpha_mask != alpha)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
attr_list[1] = visuals[j].format;
|
|
|
|
|
|
|
|
dri2_conf = dri2_add_config(disp, dri2_dpy->driver_configs[i],
|
|
|
|
count + 1, EGL_WINDOW_BIT, attr_list, NULL);
|
|
|
|
if (dri2_conf) {
|
|
|
|
count++;
|
|
|
|
format_count[j]++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
for (i = 0; i < ARRAY_SIZE(format_count); i++) {
|
|
|
|
if (!format_count[i]) {
|
|
|
|
_eglLog(_EGL_DEBUG, "No DRI config supports native format 0x%x",
|
|
|
|
visuals[i].format);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return (count != 0);
|
|
|
|
}
|
|
|
|
|
2014-01-28 19:41:46 +00:00
|
|
|
static struct dri2_egl_display_vtbl dri2_drm_display_vtbl = {
|
|
|
|
.authenticate = dri2_drm_authenticate,
|
2014-01-29 00:39:09 +00:00
|
|
|
.create_window_surface = dri2_drm_create_window_surface,
|
2014-02-09 17:13:08 +00:00
|
|
|
.create_pixmap_surface = dri2_drm_create_pixmap_surface,
|
2014-01-29 01:03:03 +00:00
|
|
|
.create_pbuffer_surface = dri2_fallback_create_pbuffer_surface,
|
2014-01-29 01:03:03 +00:00
|
|
|
.destroy_surface = dri2_drm_destroy_surface,
|
2014-01-29 01:03:03 +00:00
|
|
|
.create_image = dri2_drm_create_image_khr,
|
2014-01-28 20:34:19 +00:00
|
|
|
.swap_interval = dri2_fallback_swap_interval,
|
2014-01-29 00:21:21 +00:00
|
|
|
.swap_buffers = dri2_drm_swap_buffers,
|
2014-01-29 00:26:44 +00:00
|
|
|
.swap_buffers_with_damage = dri2_fallback_swap_buffers_with_damage,
|
2014-01-29 01:03:03 +00:00
|
|
|
.swap_buffers_region = dri2_fallback_swap_buffers_region,
|
2014-01-29 01:03:03 +00:00
|
|
|
.post_sub_buffer = dri2_fallback_post_sub_buffer,
|
2014-01-29 01:03:03 +00:00
|
|
|
.copy_buffers = dri2_fallback_copy_buffers,
|
2014-01-29 01:03:03 +00:00
|
|
|
.query_buffer_age = dri2_drm_query_buffer_age,
|
2014-01-29 01:03:03 +00:00
|
|
|
.create_wayland_buffer_from_image = dri2_fallback_create_wayland_buffer_from_image,
|
2014-05-06 20:10:57 +01:00
|
|
|
.get_sync_values = dri2_fallback_get_sync_values,
|
2015-07-21 16:43:59 +01:00
|
|
|
.get_dri_drawable = dri2_surface_get_dri_drawable,
|
2014-01-28 19:41:46 +00:00
|
|
|
};
|
|
|
|
|
2011-02-03 03:21:13 +00:00
|
|
|
EGLBoolean
|
|
|
|
dri2_initialize_drm(_EGLDriver *drv, _EGLDisplay *disp)
|
|
|
|
{
|
|
|
|
struct dri2_egl_display *dri2_dpy;
|
2011-05-30 09:50:52 +01:00
|
|
|
struct gbm_device *gbm;
|
2016-08-25 15:52:58 +01:00
|
|
|
const char *err;
|
2011-06-29 07:49:39 +01:00
|
|
|
int fd = -1;
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2014-01-11 04:52:48 +00:00
|
|
|
loader_set_logger(_eglLog);
|
|
|
|
|
2012-09-05 07:09:22 +01:00
|
|
|
dri2_dpy = calloc(1, sizeof *dri2_dpy);
|
2011-02-03 03:21:13 +00:00
|
|
|
if (!dri2_dpy)
|
|
|
|
return _eglError(EGL_BAD_ALLOC, "eglInitialize");
|
2011-05-30 09:50:52 +01:00
|
|
|
|
2011-02-03 03:21:13 +00:00
|
|
|
disp->DriverData = (void *) dri2_dpy;
|
|
|
|
|
2011-06-29 07:49:39 +01:00
|
|
|
gbm = disp->PlatformDisplay;
|
|
|
|
if (gbm == NULL) {
|
2014-04-03 06:22:26 +01:00
|
|
|
char buf[64];
|
|
|
|
int n = snprintf(buf, sizeof(buf), DRM_DEV_NAME, DRM_DIR_NAME, 0);
|
|
|
|
if (n != -1 && n < sizeof(buf))
|
2015-06-17 17:28:51 +01:00
|
|
|
fd = loader_open_device(buf);
|
2014-04-03 06:22:26 +01:00
|
|
|
if (fd < 0)
|
2015-06-17 17:28:51 +01:00
|
|
|
fd = loader_open_device("/dev/dri/card0");
|
2011-12-13 13:43:48 +00:00
|
|
|
dri2_dpy->own_device = 1;
|
2011-06-29 07:49:39 +01:00
|
|
|
gbm = gbm_create_device(fd);
|
2016-08-25 15:52:58 +01:00
|
|
|
if (gbm == NULL) {
|
|
|
|
err = "DRI2: failed to create gbm device";
|
2015-07-15 17:00:41 +01:00
|
|
|
goto cleanup;
|
2016-08-25 15:52:58 +01:00
|
|
|
}
|
2015-09-07 09:53:53 +01:00
|
|
|
} else {
|
|
|
|
fd = fcntl(gbm_device_get_fd(gbm), F_DUPFD_CLOEXEC, 3);
|
2016-08-25 15:52:58 +01:00
|
|
|
if (fd < 0) {
|
|
|
|
err = "DRI2: failed to fcntl() existing gbm device";
|
2015-09-07 09:53:53 +01:00
|
|
|
goto cleanup;
|
2016-08-25 15:52:58 +01:00
|
|
|
}
|
2011-06-29 07:49:39 +01:00
|
|
|
}
|
|
|
|
|
2016-08-25 15:52:58 +01:00
|
|
|
if (strcmp(gbm_device_get_backend_name(gbm), "drm") != 0) {
|
|
|
|
err = "DRI2: gbm device using incorrect/incompatible backend";
|
2015-07-15 17:00:41 +01:00
|
|
|
goto cleanup;
|
2016-08-25 15:52:58 +01:00
|
|
|
}
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2011-05-30 09:50:52 +01:00
|
|
|
dri2_dpy->gbm_dri = gbm_dri_device(gbm);
|
2016-08-25 15:52:58 +01:00
|
|
|
if (dri2_dpy->gbm_dri->base.type != GBM_DRM_DRIVER_TYPE_DRI) {
|
|
|
|
err = "DRI2: gbm device using incorrect/incompatible type";
|
2015-07-15 17:00:41 +01:00
|
|
|
goto cleanup;
|
2016-08-25 15:52:58 +01:00
|
|
|
}
|
2011-02-21 15:22:34 +00:00
|
|
|
|
2011-06-29 07:49:39 +01:00
|
|
|
dri2_dpy->fd = fd;
|
2014-06-02 12:26:17 +01:00
|
|
|
dri2_dpy->driver_name = strdup(dri2_dpy->gbm_dri->base.driver_name);
|
2011-05-30 09:50:52 +01:00
|
|
|
|
|
|
|
dri2_dpy->dri_screen = dri2_dpy->gbm_dri->screen;
|
|
|
|
dri2_dpy->core = dri2_dpy->gbm_dri->core;
|
|
|
|
dri2_dpy->dri2 = dri2_dpy->gbm_dri->dri2;
|
2016-08-16 17:56:45 +01:00
|
|
|
dri2_dpy->fence = dri2_dpy->gbm_dri->fence;
|
2011-05-30 09:50:52 +01:00
|
|
|
dri2_dpy->image = dri2_dpy->gbm_dri->image;
|
2012-01-25 14:24:15 +00:00
|
|
|
dri2_dpy->flush = dri2_dpy->gbm_dri->flush;
|
2014-06-15 12:49:49 +01:00
|
|
|
dri2_dpy->swrast = dri2_dpy->gbm_dri->swrast;
|
2011-05-30 09:50:52 +01:00
|
|
|
dri2_dpy->driver_configs = dri2_dpy->gbm_dri->driver_configs;
|
2016-10-27 16:41:55 +01:00
|
|
|
dri2_dpy->interop = dri2_dpy->gbm_dri->interop;
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2011-05-30 09:50:52 +01:00
|
|
|
dri2_dpy->gbm_dri->lookup_image = dri2_lookup_egl_image;
|
|
|
|
dri2_dpy->gbm_dri->lookup_user_data = disp;
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2014-01-28 20:47:38 +00:00
|
|
|
dri2_dpy->gbm_dri->get_buffers = dri2_drm_get_buffers;
|
|
|
|
dri2_dpy->gbm_dri->flush_front_buffer = dri2_drm_flush_front_buffer;
|
|
|
|
dri2_dpy->gbm_dri->get_buffers_with_format = dri2_drm_get_buffers_with_format;
|
|
|
|
dri2_dpy->gbm_dri->image_get_buffers = dri2_drm_image_get_buffers;
|
2014-06-15 12:49:49 +01:00
|
|
|
dri2_dpy->gbm_dri->swrast_put_image2 = swrast_put_image2;
|
|
|
|
dri2_dpy->gbm_dri->swrast_get_image = swrast_get_image;
|
2012-01-25 14:24:17 +00:00
|
|
|
|
|
|
|
dri2_dpy->gbm_dri->base.base.surface_lock_front_buffer = lock_front_buffer;
|
|
|
|
dri2_dpy->gbm_dri->base.base.surface_release_buffer = release_buffer;
|
|
|
|
dri2_dpy->gbm_dri->base.base.surface_has_free_buffers = has_free_buffers;
|
|
|
|
|
2011-05-30 09:50:52 +01:00
|
|
|
dri2_setup_screen(disp);
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2016-08-25 14:00:50 +01:00
|
|
|
if (!drm_add_configs_for_visuals(drv, disp)) {
|
2016-08-25 15:52:58 +01:00
|
|
|
err = "DRI2: failed to add configs";
|
2016-08-25 14:00:50 +01:00
|
|
|
goto cleanup;
|
2013-09-25 22:57:22 +01:00
|
|
|
}
|
2011-05-30 09:50:52 +01:00
|
|
|
|
2014-09-03 21:43:41 +01:00
|
|
|
disp->Extensions.KHR_image_pixmap = EGL_TRUE;
|
2014-06-15 12:49:49 +01:00
|
|
|
if (dri2_dpy->dri2)
|
|
|
|
disp->Extensions.EXT_buffer_age = EGL_TRUE;
|
2011-02-03 03:21:13 +00:00
|
|
|
|
2011-02-21 15:22:34 +00:00
|
|
|
#ifdef HAVE_WAYLAND_PLATFORM
|
2016-08-25 13:15:43 +01:00
|
|
|
dri2_dpy->device_name = loader_get_device_name_for_fd(dri2_dpy->fd);
|
2011-02-21 15:22:34 +00:00
|
|
|
#endif
|
2016-08-25 13:15:43 +01:00
|
|
|
dri2_set_WL_bind_wayland_display(drv, disp);
|
2011-05-30 09:50:52 +01:00
|
|
|
|
2014-01-28 19:41:46 +00:00
|
|
|
/* Fill vtbl last to prevent accidentally calling virtual function during
|
|
|
|
* initialization.
|
|
|
|
*/
|
|
|
|
dri2_dpy->vtbl = &dri2_drm_display_vtbl;
|
|
|
|
|
2011-02-03 03:21:13 +00:00
|
|
|
return EGL_TRUE;
|
2015-07-15 17:00:41 +01:00
|
|
|
|
|
|
|
cleanup:
|
|
|
|
if (fd >= 0)
|
|
|
|
close(fd);
|
|
|
|
|
|
|
|
free(dri2_dpy);
|
2016-08-04 03:07:53 +01:00
|
|
|
disp->DriverData = NULL;
|
2016-08-25 15:52:58 +01:00
|
|
|
return _eglError(EGL_NOT_INITIALIZED, err);
|
2011-02-03 03:21:13 +00:00
|
|
|
}
|