This currently doesn't use the native interface or the common egl state tracker code. This is to allow rapid experimentation and testing features that might fail. --- src/gallium/state_trackers/egl/Makefile | 15 ++- src/gallium/state_trackers/egl/drm/Makefile | 19 +++ src/gallium/state_trackers/egl/drm/drm_context.c | 92 +++++++++++++ src/gallium/state_trackers/egl/drm/drm_display.c | 153 ++++++++++++++++++++++ src/gallium/state_trackers/egl/drm/drm_image.c | 86 ++++++++++++ src/gallium/state_trackers/egl/drm/drm_surface.c | 149 +++++++++++++++++++++ src/gallium/state_trackers/egl/drm/drm_tracker.h | 128 ++++++++++++++++++ src/gallium/targets/Makefile.egl | 6 + 8 files changed, 645 insertions(+), 3 deletions(-) create mode 100644 src/gallium/state_trackers/egl/drm/Makefile create mode 100644 src/gallium/state_trackers/egl/drm/drm_context.c create mode 100644 src/gallium/state_trackers/egl/drm/drm_display.c create mode 100644 src/gallium/state_trackers/egl/drm/drm_image.c create mode 100644 src/gallium/state_trackers/egl/drm/drm_surface.c create mode 100644 src/gallium/state_trackers/egl/drm/drm_tracker.h
diff --git a/src/gallium/state_trackers/egl/Makefile b/src/gallium/state_trackers/egl/Makefile index a3c1bb4..dc2dbfd 100644 --- a/src/gallium/state_trackers/egl/Makefile +++ b/src/gallium/state_trackers/egl/Makefile @@ -29,10 +29,13 @@ kms_INCLUDES = $(shell pkg-config --cflags-only-I libdrm) kms_SOURCES = $(wildcard kms/*.c) kms_OBJECTS = $(kms_SOURCES:.c=.o) +drm_INCLUDES = $(shell pkg-config --cflags-only-I libdrm) +drm_SOURCES = $(wildcard drm/*.c) +drm_OBJECTS = $(drm_SOURCES:.c=.o) -ALL_INCLUDES = $(common_INCLUDES) $(x11_INCLUDES) $(kms_INCLUDES) -ALL_SOURCES = $(common_SOURCES) $(x11_SOURCES) $(kms_SOURCES) -ALL_OBJECTS = $(common_OBJECTS) $(x11_OBJECTS) $(kms_OBJECTS) +ALL_INCLUDES = $(common_INCLUDES) $(x11_INCLUDES) $(kms_INCLUDES) $(drm_INCLUDES) +ALL_SOURCES = $(common_SOURCES) $(x11_SOURCES) $(kms_SOURCES) $(drm_SOURCES) +ALL_OBJECTS = $(common_OBJECTS) $(x11_OBJECTS) $(kms_OBJECTS) $(drm_OBJECTS) ##### TARGETS ##### @@ -47,6 +50,9 @@ libeglx11.a: $(x11_OBJECTS) $(common_OBJECTS) Makefile libeglkms.a: $(kms_OBJECTS) $(common_OBJECTS) Makefile $(MKLIB) -o eglkms -static $(kms_OBJECTS) $(common_OBJECTS) +libegldrm.a: $(drm_OBJECTS) Makefile + $(MKLIB) -o egldrm -static $(drm_OBJECTS) + depend: rm -f depend touch depend @@ -72,4 +78,7 @@ $(x11_OBJECTS): %.o: %.c $(kms_OBJECTS): %.o: %.c $(CC) -c $(common_INCLUDES) $(kms_INCLUDES) $(DEFINES) $(CFLAGS) $< -o $@ +$(drm_OBJECTS): %.o: %.c + $(CC) -c $(common_INCLUDES) $(drm_INCLUDES) $(DEFINES) $(CFLAGS) $< -o $@ + sinclude depend diff --git a/src/gallium/state_trackers/egl/drm/Makefile b/src/gallium/state_trackers/egl/drm/Makefile new file mode 100644 index 0000000..4a59b7f --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/Makefile @@ -0,0 +1,19 @@ +TOP = ../../../.. +include $(TOP)/configs/current + +LIBNAME = egldrm + +LIBRARY_INCLUDES = \ + -I$(TOP)/src/gallium/auxiliary \ + -I$(TOP)/src/gallium/include \ + -I$(TOP)/src/egl/main \ + -I$(TOP)/include \ + $(shell pkg-config --cflags-only-I libdrm) + +C_SOURCES = \ + drm_image.c \ + drm_context.c \ + drm_surface.c \ + drm_display.c + +include ../../Makefile.template diff --git a/src/gallium/state_trackers/egl/drm/drm_context.c b/src/gallium/state_trackers/egl/drm/drm_context.c new file mode 100644 index 0000000..8e5f1e1 --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/drm_context.c @@ -0,0 +1,92 @@ + + +#include "egllog.h" +#include "eglcurrent.h" + +#include "pipe/p_context.h" +#include "pipe/p_screen.h" + +#include "drm_tracker.h" + +#include "state_tracker/st_api.h" +#include "state_tracker/drm_api.h" + +#include "util/u_debug.h" + +_EGLContext * +drm_create_context(_EGLDriver *drv, _EGLDisplay *dpy, + _EGLConfig *config, _EGLContext *share_list, + const EGLint *attrib) +{ + struct drm_device *dev = lookup_drm_device(dpy); + struct drm_config *conf = lookup_drm_config(config); + struct drm_context *ctx; + int i; + + for (i = 0; attrib && attrib[i] != EGL_NONE; i++) { + switch (attrib[i]) { + /* no attribs defined for now */ + default: + _eglError(EGL_BAD_ATTRIBUTE, "eglCreateContext"); + return EGL_NO_CONTEXT; + } + } + + ctx = (struct drm_context *) calloc(1, sizeof(struct drm_context)); + if (!ctx) + goto err_out; + + _eglInitContext(&ctx->base, dpy, config, attrib); + + ctx->st = dev->api->create_context(dev->api, &dev->manager, &conf->visual, NULL); + + if (!ctx->st) + goto err_free; + + return &ctx->base; + +err_free: + free(ctx); +err_out: + return NULL; +} + +EGLBoolean +drm_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *context) +{ + struct drm_context *ctx = lookup_drm_context(context); + if (!_eglIsContextBound(context)) { + ctx->st->destroy(ctx->st); + free(ctx); + } + return EGL_TRUE; +} + +EGLBoolean +drm_make_current(_EGLDriver *drv, _EGLDisplay *dpy, + _EGLSurface *draw, _EGLSurface *read, + _EGLContext *context) +{ + struct drm_surface *readSurf = lookup_drm_surface(read); + struct drm_surface *drawSurf = lookup_drm_surface(draw); + struct drm_context *ctx = lookup_drm_context(context); + struct drm_context *old_ctx = NULL; + struct drm_device *dev = lookup_drm_device(dpy); + boolean ret; + + /* bind the new context and return the "orphaned" one */ + if (!_eglBindContext(&context, &draw, &read)) + return EGL_FALSE; + + old_ctx = lookup_drm_context(context); + + if (ctx) { + ret = dev->api->make_current(dev->api, ctx->st, + &drawSurf->fb, + &readSurf->fb); + } else { + ret = dev->api->make_current(dev->api, NULL, NULL, NULL); + } + + return (EGLBoolean)ret; +} diff --git a/src/gallium/state_trackers/egl/drm/drm_display.c b/src/gallium/state_trackers/egl/drm/drm_display.c new file mode 100644 index 0000000..5692f79 --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/drm_display.c @@ -0,0 +1,153 @@ + + +#include <stdio.h> +#include <fcntl.h> + +#include "drm_tracker.h" + +#include "egllog.h" +#include "state_tracker/drm_api.h" + +#include "pipe/p_screen.h" +#include "util/u_memory.h" + +/** + * Called by libEGL just prior to unloading/closing the driver. + */ +static void +drm_unload(_EGLDriver *drv) +{ + FREE(drv); +} + +/** + * The bootstrap function. Return a new drm_driver object and + * plug in API functions. + * libEGL finds this function with dlopen()/dlsym() and calls it from + * "load driver" function. + */ +_EGLDriver * +_eglMain(const char *args) +{ + _EGLDriver *drv; + + drv = (_EGLDriver *)MALLOC(sizeof(_EGLDriver)); + if (!drv) + return NULL; + + /* First fill in the dispatch table with defaults */ + _eglInitDriverFallbacks(drv); + drv->API.Initialize = drm_initialize; + drv->API.Terminate = drm_terminate; + drv->API.CreateContext = drm_create_context; + drv->API.DestroyContext = drm_destroy_context; + drv->API.MakeCurrent = drm_make_current; + drv->API.SwapBuffers = drm_swap_buffers; + drv->API.CreatePbufferSurface = drm_create_pbuffer_surface; + drv->API.DestroySurface = drm_destroy_surface; + + drv->API.CreateImageKHR = drm_create_image; + drv->API.DestroyImageKHR = drm_destroy_image; + + drv->Name = "DRM/Gallium/Win"; + drv->Unload = drm_unload; + + return drv; +} + +static int drm_open_minor(int minor) +{ + char buf[64]; + + sprintf(buf, DRM_DEV_NAME, DRM_DIR_NAME, minor); + return open(buf, O_RDWR, 0); +} + +/** + * Called by libEGL to initialize the device. + */ +EGLBoolean +drm_initialize(_EGLDriver *drv, _EGLDisplay *dpy, EGLint *major, EGLint *minor) +{ + struct drm_device *dev; + struct drm_config *conf; + _EGLConfig *config; + + dev = CALLOC_STRUCT(drm_device); + if (!dev) + return EGL_FALSE; + + dev->display = dpy; + dev->driver = drm_api_create(); + dev->api = st_api_create_OpenGL(); + + /* try the first node */ + dev->fd = drm_open_minor(0); + if (dev->fd < 0) { + _eglLog(_EGL_WARNING, "could not open fd"); + goto err_free; + } + + dev->manager.get_egl_image = drm_get_egl_image; + dev->manager.screen = dev->driver->create_screen(dev->driver, dev->fd, NULL); + if (!dev->manager.screen) + goto err_close; + + dpy->DriverData = dev; + + /* for now we only have one config */ + conf = CALLOC_STRUCT(drm_config); + config = &conf->base; + _eglInitConfig(config, dpy, 1); + SET_CONFIG_ATTRIB(config, EGL_RED_SIZE, 8); + SET_CONFIG_ATTRIB(config, EGL_GREEN_SIZE, 8); + SET_CONFIG_ATTRIB(config, EGL_BLUE_SIZE, 8); + SET_CONFIG_ATTRIB(config, EGL_ALPHA_SIZE, 8); + SET_CONFIG_ATTRIB(config, EGL_BUFFER_SIZE, 32); + SET_CONFIG_ATTRIB(config, EGL_DEPTH_SIZE, 24); + SET_CONFIG_ATTRIB(config, EGL_STENCIL_SIZE, 8); + SET_CONFIG_ATTRIB(config, EGL_SURFACE_TYPE, EGL_PBUFFER_BIT); + SET_CONFIG_ATTRIB(config, EGL_CONFORMANT, EGL_OPENGL_BIT); + SET_CONFIG_ATTRIB(config, EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT); + conf->visual.buffer_mask = ST_ATTACHMENT_BACK_LEFT_MASK | + ST_ATTACHMENT_DEPTH_STENCIL; + conf->visual.render_buffer = ST_ATTACHMENT_BACK_LEFT; + conf->visual.color_format = PIPE_FORMAT_B8G8R8A8_UNORM; + conf->visual.depth_stencil_format = PIPE_FORMAT_Z24_UNORM_S8_USCALED; + _eglAddConfig(dpy, config); + + /* just assume */ + dpy->ClientAPIsMask = EGL_OPENGL_BIT; + + dpy->Extensions.KHR_image_base = EGL_TRUE; + + *major = 1; + *minor = 4; + + return EGL_TRUE; + +err_close: + drmClose(dev->fd); +err_free: + free(dev); + return EGL_FALSE; +} + +EGLBoolean +drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy) +{ + struct drm_device *dev = lookup_drm_device(dpy); + + _eglReleaseDisplayResources(drv, dpy); + _eglCleanupDisplay(dpy); + + dev->manager.screen->destroy(dev->manager.screen); + + drmClose(dev->fd); + + dev->driver->destroy(dev->driver); + free(dev); + dpy->DriverData = NULL; + + return EGL_TRUE; +} diff --git a/src/gallium/state_trackers/egl/drm/drm_image.c b/src/gallium/state_trackers/egl/drm/drm_image.c new file mode 100644 index 0000000..a25f486 --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/drm_image.c @@ -0,0 +1,86 @@ + + +#include "eglcurrent.h" + +#include "drm_tracker.h" + +#include "util/u_memory.h" + +/* + * Stub + */ +_EGLImage * +drm_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, + EGLenum target, EGLClientBuffer buffer, + const EGLint *attribs) +{ + struct pipe_resource *res; + struct drm_device *dev = lookup_drm_device(dpy); + struct drm_image *img; + + img = CALLOC_STRUCT(drm_image); + if (!img) + return EGL_NO_IMAGE_KHR; + + if (!_eglInitImage(&img->base, dpy, attribs)) + goto out_free; + + switch (target) { + default: + res = NULL; + } + + if (!res) + goto out_free; + + img->res = res; + + return &img->base; + +out_free: + FREE(img); + return EGL_NO_IMAGE_KHR; +} + +EGLBoolean +drm_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *image) +{ + struct drm_image *img = lookup_drm_image(image); + + pipe_resource_reference(&img->res, NULL); + FREE(img); + + return EGL_TRUE; +} + +boolean +drm_get_egl_image(struct st_manager *manager, + struct st_context_iface *stctxi, + void *egl_image, struct st_egl_image *stimg) +{ + struct drm_device *dev = (struct drm_device *)manager; + EGLImageKHR handle = (EGLImageKHR) egl_image; + _EGLImage *image; + struct drm_image *img; + + /* this is called from state trackers */ + _eglLockMutex(&dev->display->Mutex); + + image = _eglLookupImage(handle, dev->display); + if (!image) { + _eglUnlockMutex(&dev->display->Mutex); + return FALSE; + } + + img = lookup_drm_image(image); + + stimg->texture = NULL; + pipe_resource_reference(&stimg->texture, img->res); + stimg->face = 0; + stimg->level = 0; + stimg->zslice = 0; + + _eglUnlockMutex(&dev->display->Mutex); + + return TRUE; +} diff --git a/src/gallium/state_trackers/egl/drm/drm_surface.c b/src/gallium/state_trackers/egl/drm/drm_surface.c new file mode 100644 index 0000000..0001264 --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/drm_surface.c @@ -0,0 +1,149 @@ + +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#include "egllog.h" +#include "eglcurrent.h" + +#include "util/u_inlines.h" +#include "pipe/p_screen.h" +#include "pipe/p_context.h" + +#include "state_tracker/drm_api.h" + +#include "util/u_format.h" +#include "util/u_rect.h" + +#include "drm_tracker.h" + +static boolean +drm_flush_front(struct st_framebuffer_iface *fbi, + enum st_attachment_type statt) +{ + return TRUE; /* noop */ +} + +static boolean +drm_validate(struct st_framebuffer_iface *fbi, + const enum st_attachment_type *atts, + unsigned count, + struct pipe_resource **out) +{ + struct drm_surface *surf = (struct drm_surface *)fbi->st_manager_private; + struct drm_device *dev = lookup_drm_device(surf->base.Resource.Display); + struct pipe_screen *screen = dev->manager.screen; + struct pipe_resource templ; + int i, att = count; + + for (i = 0; i < count; i++) { + out[i] = NULL; + if (atts[i] == ST_ATTACHMENT_BACK_LEFT) + att = i; + } + + if (att == count) + return TRUE; + + + memset(&templ, 0, sizeof(templ)); + templ.target = PIPE_TEXTURE_2D; + templ.last_level = 0; + templ.width0 = surf->base.Width; + templ.height0 = surf->base.Height; + templ.depth0 = 1; + templ.format = surf->visual.color_format; + templ.bind = PIPE_BIND_RENDER_TARGET | PIPE_BIND_SAMPLER_VIEW; + + out[att] = screen->resource_create(screen, &templ); + + return TRUE; +} + +/** + * Called by libEGL's eglCreatePbufferSurface(). + */ +_EGLSurface * +drm_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, + _EGLConfig *config, const EGLint *attrib_list) +{ + struct drm_device *dev = lookup_drm_device(dpy); + struct drm_config *conf = lookup_drm_config(config); + struct drm_surface *surf = NULL; + int width = -1; + int height = -1; + int i; + + for (i = 0; attrib_list[i] != EGL_NONE; i++) { + switch (attrib_list[i]) { + case EGL_WIDTH: + width = attrib_list[++i]; + break; + case EGL_HEIGHT: + height = attrib_list[++i]; + break; + default: + _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePbufferSurface"); + return EGL_NO_SURFACE; + } + } + + if (width < 1 || height < 1) { + _eglError(EGL_BAD_ATTRIBUTE, "eglCreatePbufferSurface"); + return NULL; + } + + surf = (struct drm_surface *) calloc(1, sizeof(struct drm_surface)); + if (!surf) + goto err_out; + + if (!_eglInitSurface(&surf->base, dpy, EGL_PBUFFER_BIT, config, attrib_list)) + goto err_free; + + surf->visual = conf->visual; + surf->base.Width = width; + surf->base.Height = height; + surf->fb.visual = &surf->visual; /* set pointer */ + surf->fb.flush_front = drm_flush_front; + surf->fb.validate = drm_validate; + surf->fb.st_manager_private = surf; + (void)dev; + + return &surf->base; + +err_free: + free(surf); +err_out: + return NULL; +} + +/** + * Called by libEGL's eglDestroySurface(). + */ +EGLBoolean +drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface) +{ + struct drm_surface *surf = lookup_drm_surface(surface); + + if (!_eglIsSurfaceBound(&surf->base)) { + free(surf); + } + + return EGL_TRUE; +} + +/** + * Called by libEGL's eglSwapBuffers(). + */ +EGLBoolean +drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw) +{ + struct drm_surface *surf = lookup_drm_surface(draw); + + if (!surf) + return EGL_FALSE; + + /* only support pbuffers don't have a front buffer */ + + return EGL_TRUE; +} diff --git a/src/gallium/state_trackers/egl/drm/drm_tracker.h b/src/gallium/state_trackers/egl/drm/drm_tracker.h new file mode 100644 index 0000000..987833b --- /dev/null +++ b/src/gallium/state_trackers/egl/drm/drm_tracker.h @@ -0,0 +1,128 @@ + +#ifndef _EGL_TRACKER_H_ +#define _EGL_TRACKER_H_ + +#include <stdint.h> + +#include "eglconfig.h" +#include "eglcontext.h" +#include "egldisplay.h" +#include "egldriver.h" +#include "eglglobals.h" +#include "eglmode.h" +#include "eglscreen.h" +#include "eglsurface.h" +#include "eglimage.h" + +#include "xf86drm.h" + +#include "pipe/p_compiler.h" + +#include "state_tracker/st_api.h" + +struct pipe_winsys; +struct pipe_screen; +struct pipe_context; +struct state_tracker; + +struct drm_screen; +struct drm_context; + +struct drm_device { + struct st_manager manager; + + _EGLDisplay *display; + + struct drm_api *driver; + struct st_api *api; + + int fd; +}; + +struct drm_config { + _EGLConfig base; + struct st_visual visual; +}; + +struct drm_surface { + _EGLSurface base; /* base class/object */ + struct st_framebuffer_iface fb; + + struct st_visual visual; + + struct pipe_resource *res[ST_ATTACHMENT_COUNT]; +}; + +struct drm_context { + _EGLContext base; /* base class/object */ + + struct st_api *api; + struct st_context_iface *st; + struct pipe_context *pipe; +}; + +struct drm_image { + _EGLImage base; + struct pipe_resource *res; +}; + + +static INLINE struct drm_device * +lookup_drm_device(_EGLDisplay *d) +{ + return (struct drm_device *)d->DriverData; +} + +static INLINE struct drm_config * +lookup_drm_config(_EGLConfig *c) +{ + return (struct drm_config *)c; +} + +static INLINE struct drm_surface * +lookup_drm_surface(_EGLSurface *s) +{ + return (struct drm_surface *)s; +} + +static INLINE struct drm_context * +lookup_drm_context(_EGLContext *c) +{ + return (struct drm_context *)c; +} + +static INLINE struct drm_image * +lookup_drm_image(_EGLImage *i) +{ + return (struct drm_image *)i; +} + + +/** + * Functions exported via st_api interface. + */ +/* drm_image.c */ +boolean drm_get_egl_image(struct st_manager *m, struct st_context_iface *s, void *img, struct st_egl_image *stimg); + +/** + * All function exported to the egl side. + */ +/*...@{*/ +/* drm_display.c */ +EGLBoolean drm_initialize(_EGLDriver *drv, _EGLDisplay *dpy, EGLint *major, EGLint *minor); +EGLBoolean drm_terminate(_EGLDriver *drv, _EGLDisplay *dpy); +/* drm_context.c */ +_EGLContext *drm_create_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, _EGLContext *share_list, const EGLint *attrib_list); +EGLBoolean drm_destroy_context(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *context); +EGLBoolean drm_make_current(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw, _EGLSurface *read, _EGLContext *context); +EGLBoolean drm_swap_buffers(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *draw); +/* drm_surface.c */ +_EGLSurface *drm_create_pbuffer_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLConfig *conf, const EGLint *attrib_list); +EGLBoolean drm_destroy_surface(_EGLDriver *drv, _EGLDisplay *dpy, _EGLSurface *surface); +/* drm_image.c */ +_EGLImage *drm_create_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLContext *ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attribs); +EGLBoolean drm_destroy_image(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *image); +EGLBoolean drm_get_image_attrib(_EGLDriver *drv, _EGLDisplay *dpy, _EGLImage *img, EGLenum attrib, EGLint *out); +/*...@}*/ + +#endif diff --git a/src/gallium/targets/Makefile.egl b/src/gallium/targets/Makefile.egl index 4fa13e8..7d8d85b 100644 --- a/src/gallium/targets/Makefile.egl +++ b/src/gallium/targets/Makefile.egl @@ -43,6 +43,9 @@ INCLUDES = \ -I$(TOP)/src/egl/main \ $(LIBDRM_CFLAGS) +drm_ST = $(TOP)/src/gallium/state_trackers/egl/libegldrm.a +drm_LIBS = $(common_LIBS) + ##### RULES ##### .c.o: @@ -75,6 +78,9 @@ egl_x11_$(EGL_DRIVER_NAME).so: $(EGL_DRIVER_OBJECTS) $(x11_ST) $(EGL_DRIVER_PIPE egl_kms_$(EGL_DRIVER_NAME).so: $(EGL_DRIVER_OBJECTS) $(kms_ST) $(EGL_DRIVER_PIPES) $(GALLIUM_AUXILIARIES) Makefile $(call mklib-egl,kms) +egl_drm_$(EGL_DRIVER_NAME).so: $(EGL_DRIVER_OBJECTS) $(drm_ST) $(EGL_DRIVER_PIPES) $(GALLIUM_AUXILIARIES) Makefile + $(call mklib-egl,drm) + clean: -rm -f $(EGL_DRIVER_OBJECTS) -rm -f $(EGL_DISPLAY_DRIVERS) -- 1.7.0.4 _______________________________________________ mesa-dev mailing list mesa-dev@lists.freedesktop.org http://lists.freedesktop.org/mailman/listinfo/mesa-dev