add egltest

8 files changed, 360 insertions, 63 deletions

diff --git a/drminfo.spec b/drminfo.spec
index 21dd01b..af2de04 100644
--- a/drminfo.spec
+++ b/drminfo.spec
@@ -40,6 +40,7 @@ cp -a tests %{buildroot}%{_datadir}/%{name}
 %{_bindir}/drm*
 %{_bindir}/prime
 %{_bindir}/virtiotest
+%{_bindir}/egltest
 %{_bindir}/fb*
 %{_mandir}/man1/drm*.1*
 %{_datadir}/%{name}/tests
diff --git a/drmtest.c b/drmtest.c
index 374ae72..368452f 100644
--- a/drmtest.c
+++ b/drmtest.c
@@ -50,7 +50,7 @@ static void drm_draw(bool autotest)
     cairo_t *cr;
 
     snprintf(info1, sizeof(info1), "mode: %dx%d",
-             mode->hdisplay, mode->vdisplay);
+             drm_mode->hdisplay, drm_mode->vdisplay);
 
     if (fmt->fourcc) {
         snprintf(info2, sizeof(info2),
@@ -66,15 +66,15 @@ static void drm_draw(bool autotest)
                  fmt->bpp, fmt->depth);
     }
 
-    drm_conn_name(conn, name, sizeof(name));
+    drm_conn_name(drm_conn, name, sizeof(name));
     snprintf(info3, sizeof(info3), "drm driver: %s, output %.10s",
              version->name, name);
 
     cr = cairo_create(cs);
     if (image) {
-        render_image(cr, mode->hdisplay, mode->vdisplay, image);
+        render_image(cr, drm_mode->hdisplay, drm_mode->vdisplay, image);
     } else {
-        render_test(cr, mode->hdisplay, mode->vdisplay, info1, info2,
+        render_test(cr, drm_mode->hdisplay, drm_mode->vdisplay, info1, info2,
                     autotest ? NULL : info3);
     }
     cairo_destroy(cr);
@@ -84,7 +84,7 @@ static void drm_draw(bool autotest)
                                0, 0,
                                0, 0,
                                0, 0,
-                               mode->hdisplay, mode->vdisplay);
+                               drm_mode->hdisplay, drm_mode->vdisplay);
     }
 }
 
@@ -98,17 +98,17 @@ static void drm_init_dumb_fb(bool use_pixman)
 
     /* create framebuffer */
     memset(&creq, 0, sizeof(creq));
-    creq.width = mode->hdisplay;
-    creq.height = mode->vdisplay;
+    creq.width = drm_mode->hdisplay;
+    creq.height = drm_mode->vdisplay;
     creq.bpp = fmt->bpp;
-    rc = drmIoctl(fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &creq);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_MODE_CREATE_DUMB: %s\n", strerror(errno));
         exit(1);
     }
 
     if (fmt->fourcc) {
-        rc = drmModeAddFB2(fd, creq.width, creq.height, fmt->fourcc,
+        rc = drmModeAddFB2(drm_fd, creq.width, creq.height, fmt->fourcc,
                            &creq.handle, &creq.pitch, &zero,
                            &fb_id, 0);
         if (rc < 0) {
@@ -120,7 +120,7 @@ static void drm_init_dumb_fb(bool use_pixman)
             exit(1);
         }
     } else {
-        rc = drmModeAddFB(fd, creq.width, creq.height, fmt->depth, fmt->bpp,
+        rc = drmModeAddFB(drm_fd, creq.width, creq.height, fmt->depth, fmt->bpp,
                           creq.pitch, creq.handle, &fb_id);
         if (rc < 0) {
             fprintf(stderr, "drmModeAddFB() failed (bpp %d, depth %d)\n",
@@ -132,12 +132,12 @@ static void drm_init_dumb_fb(bool use_pixman)
     /* map framebuffer */
     memset(&mreq, 0, sizeof(mreq));
     mreq.handle = creq.handle;
-    rc = drmIoctl(fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_MODE_MAP_DUMB, &mreq);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_MODE_MAP_DUMB: %s\n", strerror(errno));
         exit(1);
     }
-    fbmem = mmap(0, creq.size, PROT_READ | PROT_WRITE, MAP_SHARED, fd, mreq.offset);
+    fbmem = mmap(0, creq.size, PROT_READ | PROT_WRITE, MAP_SHARED, drm_fd, mreq.offset);
     if (fbmem == MAP_FAILED) {
         fprintf(stderr, "framebuffer mmap: %s\n", strerror(errno));
         exit(1);
@@ -170,7 +170,7 @@ static void drm_init_dumb_fb(bool use_pixman)
 static void drm_draw_dumb_fb(bool autotest)
 {
     drm_draw(autotest);
-    drmModeDirtyFB(fd, fb_id, 0, 0);
+    drmModeDirtyFB(drm_fd, fb_id, 0, 0);
 }
 
 /* ------------------------------------------------------------------ */
@@ -184,6 +184,7 @@ static void usage(FILE *fp)
             "options:\n"
             "  -h         print this\n"
             "  -p         pixman mode\n"
+            "  -a         autotest mode (don't print hardware info)\n"
             "  -c <nr>    pick card\n"
             "  -o <name>  pick output\n"
             "  -s <secs>  set sleep time (default: 60)\n"
@@ -277,7 +278,7 @@ int main(int argc, char **argv)
                 if (fmts[i].cairo == CAIRO_FORMAT_INVALID)
                     continue;
             }
-            if (!drm_probe_format_fb(fd, &fmts[i]))
+            if (!drm_probe_format_fb(drm_fd, &fmts[i]))
                 continue;
             if (!drm_probe_format_primary(&fmts[i]))
                 continue;
diff --git a/drmtools-egl.c b/drmtools-egl.c
new file mode 100644
index 0000000..10cc715
--- /dev/null
+++ b/drmtools-egl.c
@@ -0,0 +1,165 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <string.h>
+#include <inttypes.h>
+#include <getopt.h>
+
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+#include <gbm.h>
+#include <epoxy/gl.h>
+#include <epoxy/egl.h>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cairo.h>
+#include <pixman.h>
+
+#include "drmtools.h"
+
+/* ------------------------------------------------------------------ */
+
+static struct gbm_device *gbm_dev;
+static struct gbm_surface *gbm_surface;
+static EGLDisplay dpy;
+static EGLConfig cfg;
+static EGLContext ctx;
+static EGLSurface surface;
+
+/* ------------------------------------------------------------------ */
+
+int drm_setup_egl(void)
+{
+    static const EGLint conf_att[] = {
+        EGL_RENDERABLE_TYPE, EGL_OPENGL_BIT,
+        EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
+        EGL_RED_SIZE,   5,
+        EGL_GREEN_SIZE, 5,
+        EGL_BLUE_SIZE,  5,
+        EGL_ALPHA_SIZE, 0,
+        EGL_NONE,
+    };
+    static const EGLint ctx_att[] = {
+        EGL_NONE
+    };
+    EGLint major, minor;
+    EGLBoolean b;
+    EGLint n;
+
+    gbm_dev = gbm_create_device(drm_fd);
+    if (!gbm_dev) {
+        fprintf(stderr, "egl: gbm_create_device failed\n");
+        return -1;
+    }
+
+    gbm_surface = gbm_surface_create(gbm_dev,
+                                     drm_mode->hdisplay,
+                                     drm_mode->vdisplay,
+                                     GBM_FORMAT_XRGB8888,
+                                     GBM_BO_USE_RENDERING);
+    if (!gbm_surface) {
+        fprintf(stderr, "egl: gbm_create_surface failed\n");
+        return -1;
+    }
+
+#ifdef EGL_MESA_platform_gbm
+    dpy = eglGetPlatformDisplayEXT(EGL_PLATFORM_GBM_MESA, gbm_dev, NULL);
+#else
+    dpy = eglGetDisplay(gbm_dev);
+#endif
+    if (dpy == EGL_NO_DISPLAY) {
+        fprintf(stderr, "egl: eglGetDisplay failed\n");
+        return -1;
+    }
+
+    b = eglInitialize(dpy, &major, &minor);
+    if (b == EGL_FALSE) {
+        fprintf(stderr, "egl: eglInitialize failed\n");
+        return -1;
+    }
+
+    b = eglBindAPI(EGL_OPENGL_API);
+    if (b == EGL_FALSE) {
+        fprintf(stderr, "egl: eglBindAPI failed\n");
+        return -1;
+    }
+
+    b = eglChooseConfig(dpy, conf_att, &cfg, 1, &n);
+    if (b == EGL_FALSE || n != 1) {
+        fprintf(stderr, "egl: eglChooseConfig failed\n");
+        return -1;
+    }
+
+    ctx = eglCreateContext(dpy, cfg, EGL_NO_CONTEXT, ctx_att);
+    if (ctx == EGL_NO_CONTEXT) {
+        fprintf(stderr, "egl: eglCreateContext failed\n");
+        return -1;
+    }
+
+    b = eglMakeCurrent(dpy, EGL_NO_SURFACE, EGL_NO_SURFACE, ctx);
+    if (b == EGL_FALSE) {
+        fprintf(stderr, "egl: eglMakeCurrent(EGL_NO_SURFACE) failed\n");
+        return -1;
+    }
+
+    surface = eglCreateWindowSurface(dpy, cfg,
+                                     (EGLNativeWindowType)gbm_surface,
+                                     NULL);
+    if (!surface) {
+        fprintf(stderr, "egl: eglCreateWindowSurface failed\n");
+        return -1;
+    }
+
+    b = eglMakeCurrent(dpy, surface, surface, ctx);
+    if (b == EGL_FALSE) {
+        fprintf(stderr, "egl: eglMakeCurrent(surface) failed\n");
+        return -1;
+    }
+    return 0;
+}
+
+static int fbid;
+static struct gbm_bo *bo;
+
+void drm_egl_flush_display(void)
+{
+    uint32_t handle, stride, newfb;
+    struct gbm_bo *newbo;
+    int rc;
+
+    eglSwapBuffers(dpy, surface);
+
+    newbo = gbm_surface_lock_front_buffer(gbm_surface);
+    if (!newbo) {
+        fprintf(stderr, "egl: gbm_surface_lock_front_buffer failed\n");
+        return;
+    }
+    handle = gbm_bo_get_handle(newbo).u32;
+    stride = gbm_bo_get_stride(newbo);
+
+    drmModeAddFB(drm_fd, drm_mode->hdisplay, drm_mode->vdisplay, 24, 32,
+                 stride, handle, &newfb);
+    rc = drmModeSetCrtc(drm_fd, drm_enc->crtc_id, newfb, 0, 0,
+                        &drm_conn->connector_id, 1,
+                        &drm_conn->modes[0]);
+    if (rc < 0) {
+        fprintf(stderr, "egl: drmModeSetCrtc() failed\n");
+        return;
+    }
+
+    if (fbid) {
+        drmModeRmFB(drm_fd, fbid);
+    }
+    fbid = newfb;
+
+    if (bo) {
+        gbm_surface_release_buffer(gbm_surface, bo);
+    }
+    bo = newbo;
+}
diff --git a/drmtools.c b/drmtools.c
index 71dca29..87fd979 100644
--- a/drmtools.c
+++ b/drmtools.c
@@ -698,13 +698,13 @@ void drm_print_format_hdr(FILE *fp, int indent, bool libs, bool virtio)
 
 /* ------------------------------------------------------------------ */
 
-int fd;
+int drm_fd;
 uint32_t fb_id;
-drmModeConnector *conn = NULL;
-drmModeModeInfo *mode = NULL;
+drmModeConnector *drm_conn = NULL;
+drmModeModeInfo *drm_mode = NULL;
+drmModeEncoder *drm_enc = NULL;
 drmVersion *version = NULL;
 
-static drmModeEncoder *enc = NULL;
 static drmModeCrtc *scrtc = NULL;
 
 void drm_init_dev(int devnr, const char *output,
@@ -719,15 +719,15 @@ void drm_init_dev(int devnr, const char *output,
 
     /* open device */
     snprintf(dev, sizeof(dev), DRM_DEV_NAME, DRM_DIR_NAME, devnr);
-    fd = open(dev, O_RDWR);
-    if (fd < 0) {
+    drm_fd = open(dev, O_RDWR);
+    if (drm_fd < 0) {
         fprintf(stderr, "open %s: %s\n", dev, strerror(errno));
         exit(1);
     }
-    version = drmGetVersion(fd);
+    version = drmGetVersion(drm_fd);
 
     if (need_dumb) {
-        rc = drmGetCap(fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
+        rc = drmGetCap(drm_fd, DRM_CAP_DUMB_BUFFER, &has_dumb);
         if (rc < 0 || !has_dumb) {
             fprintf(stderr, "no dumb buffer support\n");
             exit(1);
@@ -735,7 +735,7 @@ void drm_init_dev(int devnr, const char *output,
     }
 #if 0
     if (need_master) {
-        rc = drmSetMaster(fd);
+        rc = drmSetMaster(drm_fd);
         if (rc < 0) {
             fprintf(stderr, "drmSetMaster() failed: %s\n",
                     strerror(errno));
@@ -745,18 +745,18 @@ void drm_init_dev(int devnr, const char *output,
 #endif
 
     /* find connector */
-    res = drmModeGetResources(fd);
+    res = drmModeGetResources(drm_fd);
     if (res == NULL) {
         fprintf(stderr, "drmModeGetResources() failed\n");
         exit(1);
     }
     for (i = 0; i < res->count_connectors; i++) {
-        conn = drmModeGetConnector(fd, res->connectors[i]);
-        if (conn &&
-            (conn->connection == DRM_MODE_CONNECTED) &&
-            conn->count_modes) {
+        drm_conn = drmModeGetConnector(drm_fd, res->connectors[i]);
+        if (drm_conn &&
+            (drm_conn->connection == DRM_MODE_CONNECTED) &&
+            drm_conn->count_modes) {
             if (output) {
-                drm_conn_name(conn, name, sizeof(name));
+                drm_conn_name(drm_conn, name, sizeof(name));
                 if (strcmp(name, output) == 0) {
                     break;
                 }
@@ -764,10 +764,10 @@ void drm_init_dev(int devnr, const char *output,
                 break;
             }
         }
-        drmModeFreeConnector(conn);
-        conn = NULL;
+        drmModeFreeConnector(drm_conn);
+        drm_conn = NULL;
     }
-    if (!conn) {
+    if (!drm_conn) {
         if (output) {
             fprintf(stderr, "drm: output %s not found or disconnected\n",
                     output);
@@ -778,39 +778,39 @@ void drm_init_dev(int devnr, const char *output,
     }
 
     if (modename) {
-        for (i = 0; i < conn->count_modes; i++) {
+        for (i = 0; i < drm_conn->count_modes; i++) {
             snprintf(m, sizeof(m), "%dx%d",
-                     conn->modes[i].hdisplay,
-                     conn->modes[i].vdisplay);
+                     drm_conn->modes[i].hdisplay,
+                     drm_conn->modes[i].vdisplay);
             if (strcmp(m, modename) == 0) {
                 fprintf(stderr, "Using mode %s\n", modename);
-                mode = &conn->modes[i];
+                drm_mode = &drm_conn->modes[i];
                 break;
             }
         }
     }
-    if (!mode) {
-        mode = &conn->modes[0];
+    if (!drm_mode) {
+        drm_mode = &drm_conn->modes[0];
     }
 
-    enc = drmModeGetEncoder(fd, conn->encoder_id);
-    if (enc == NULL) {
+    drm_enc = drmModeGetEncoder(drm_fd, drm_conn->encoder_id);
+    if (drm_enc == NULL) {
         fprintf(stderr, "drmModeGetEncoder() failed\n");
         exit(1);
     }
 
-    drm_plane_init(fd);
+    drm_plane_init(drm_fd);
 
     /* save crtc */
-    scrtc = drmModeGetCrtc(fd, enc->crtc_id);
+    scrtc = drmModeGetCrtc(drm_fd, drm_enc->crtc_id);
 }
 
 void drm_fini_dev(void)
 {
     /* restore crtc */
     if (scrtc) {
-        drmModeSetCrtc(fd, scrtc->crtc_id, scrtc->buffer_id, scrtc->x, scrtc->y,
-                       &conn->connector_id, 1, &scrtc->mode);
+        drmModeSetCrtc(drm_fd, scrtc->crtc_id, scrtc->buffer_id, scrtc->x, scrtc->y,
+                       &drm_conn->connector_id, 1, &scrtc->mode);
     }
 }
 
@@ -818,9 +818,9 @@ void drm_show_fb(void)
 {
     int rc;
 
-    rc = drmModeSetCrtc(fd, enc->crtc_id, fb_id, 0, 0,
-                        &conn->connector_id, 1,
-                        mode);
+    rc = drmModeSetCrtc(drm_fd, drm_enc->crtc_id, fb_id, 0, 0,
+                        &drm_conn->connector_id, 1,
+                        drm_mode);
     if (rc < 0) {
         fprintf(stderr, "drmModeSetCrtc() failed: %s\n", strerror(errno));
         exit (1);
diff --git a/drmtools.h b/drmtools.h
index b8f3e0d..0fbcdb7 100644
--- a/drmtools.h
+++ b/drmtools.h
@@ -34,13 +34,18 @@ void drm_print_format_hdr(FILE *fp, int indent,
 
 /* ------------------------------------------------------------------ */
 
-extern int fd;
+extern int drm_fd;
 extern uint32_t fb_id;
-extern drmModeConnector *conn;
-extern drmModeModeInfo *mode;
+extern drmModeConnector *drm_conn;
+extern drmModeModeInfo *drm_mode;
+extern drmModeEncoder *drm_enc;
 extern drmVersion *version;
 
 void drm_init_dev(int devnr, const char *output,
                   const char *modename, bool need_dumb);
 void drm_fini_dev(void);
 void drm_show_fb(void);
+
+/* drmtools-egl.c */
+int drm_setup_egl(void);
+void drm_egl_flush_display(void);
diff --git a/egltest.c b/egltest.c
new file mode 100644
index 0000000..fdafa14
--- /dev/null
+++ b/egltest.c
@@ -0,0 +1,117 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <unistd.h>
+#include <errno.h>
+#include <string.h>
+#include <inttypes.h>
+#include <getopt.h>
+#include <assert.h>
+
+#include <gbm.h>
+#include <epoxy/gl.h>
+#include <epoxy/egl.h>
+
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#include <cairo.h>
+#include <pixman.h>
+
+#include "drmtools.h"
+#include "ttytools.h"
+
+/* ------------------------------------------------------------------ */
+
+static void egl_print_info(void)
+{
+    printf("version:  %s\n", glGetString(GL_VERSION));
+    printf("vendor:   %s\n", glGetString(GL_VENDOR));
+    printf("renderer: %s\n", glGetString(GL_RENDERER));
+}
+
+static void egl_draw(void)
+{
+    /* green background */
+    glClearColor(0.0, 0.6, 0.0, 1.0);
+    glClear(GL_COLOR_BUFFER_BIT);
+    glFlush();
+}
+
+/* ------------------------------------------------------------------ */
+
+static void usage(FILE *fp)
+{
+    fprintf(fp,
+            "\n"
+            "usage: egltest [ options ]\n"
+            "\n"
+            "options:\n"
+            "  -h         print this\n"
+            "  -a         autotest mode\n"
+            "  -c <nr>    pick card\n"
+            "  -s <secs>  set sleep time (default: 60)\n"
+            "  -i         print device info\n"
+            "\n");
+}
+
+int main(int argc, char **argv)
+{
+    int card = 0;
+    int secs = 60;
+    char *output = NULL;
+    char *modename = NULL;
+    bool printinfo = false;
+    bool autotest = false;
+    char buf[32];
+    int c;
+
+    for (;;) {
+        c = getopt(argc, argv, "haic:s:");
+        if (c == -1)
+            break;
+        switch (c) {
+        case 'c':
+            card = atoi(optarg);
+            break;
+        case 's':
+            secs = atoi(optarg);
+            break;
+        case 'i':
+            printinfo = true;
+            break;
+        case 'a':
+            autotest = true;
+            break;
+        case 'h':
+            usage(stdout);
+            exit(0);
+        default:
+            usage(stderr);
+            exit(1);
+        }
+    }
+
+    drm_init_dev(card, output, modename, false);
+    drm_setup_egl();
+
+    if (printinfo) {
+        egl_print_info();
+        goto done;
+    }
+
+    egl_draw();
+    drm_egl_flush_display();
+
+    if (autotest)
+        fprintf(stdout, "---ok---\n");
+
+    tty_raw();
+    kbd_wait(secs);
+    read(0, buf, sizeof(buf));
+    tty_restore();
+
+done:
+    drm_fini_dev();
+    return 0;
+}
diff --git a/meson.build b/meson.build
index 18b2633..82cba82 100644
--- a/meson.build
+++ b/meson.build
@@ -21,6 +21,7 @@ fbinfo_srcs   = [ 'fbinfo.c', 'fbtools.c' ]
 fbtest_srcs   = [ 'fbtest.c', 'fbtools.c', 'ttytools.c', 'render.c', 'image.c' ]
 prime_srcs    = [ 'prime.c' ]
 viotest_srcs  = [ 'virtiotest.c', 'drmtools.c', 'ttytools.c', 'render.c' ]
+egltest_srcs  = [ 'egltest.c', 'drmtools.c', 'drmtools-egl.c', 'ttytools.c' ]
 gtktest_srcs  = [ 'gtktest.c', 'render.c', 'image.c' ]
 
 drminfo_deps  = [ libdrm_dep, cairo_dep, pixman_dep ]
@@ -31,6 +32,8 @@ fbtest_deps   = [ cairo_dep, pixman_dep, jpeg_dep ]
 prime_deps    = [ libdrm_dep, gbm_dep ]
 viotest_deps  = [ libdrm_dep, gbm_dep, epoxy_dep,
                   cairo_dep, pixman_dep, jpeg_dep ]
+egltest_deps  = [ libdrm_dep, gbm_dep, epoxy_dep,
+                  cairo_dep, pixman_dep ]
 gtktest_deps  = [ gtk3_dep,
                   cairo_dep, pixman_dep, jpeg_dep ]
 
@@ -58,6 +61,10 @@ executable('virtiotest',
            sources      : viotest_srcs,
            dependencies : viotest_deps,
            install      : true)
+executable('egltest',
+           sources      : egltest_srcs,
+           dependencies : egltest_deps,
+           install      : true)
 executable('gtktest',
            sources      : gtktest_srcs,
            dependencies : gtktest_deps,
diff --git a/virtiotest.c b/virtiotest.c
index 05582fd..03f046c 100644
--- a/virtiotest.c
+++ b/virtiotest.c
@@ -49,7 +49,7 @@ static int virtio_get_cap(uint64_t cap, int *value)
 
     args.param = cap;
     args.value = (intptr_t)(value);
-    rc = drmIoctl(fd, DRM_IOCTL_VIRTGPU_GETPARAM, &args);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_VIRTGPU_GETPARAM, &args);
     if (rc != 0) {
         if (errno == EINVAL) {
             return -1;
@@ -125,8 +125,8 @@ static void virtio_init_fb(void)
     /* create framebuffer */
     memset(&create, 0, sizeof(create));
     create.format = fmt->virtio;
-    create.width  = mode->hdisplay;
-    create.height = mode->vdisplay;
+    create.width  = drm_mode->hdisplay;
+    create.height = drm_mode->vdisplay;
 
     create.target = 2;       /* ??? */
     create.bind = (1 << 1);  /* ??? */
@@ -135,7 +135,7 @@ static void virtio_init_fb(void)
 
     stride = create.width * fmt->bpp / 8;
     create.size   = stride * create.height;
-    rc = drmIoctl(fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_VIRTGPU_RESOURCE_CREATE, &create);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_VIRTGPU_RESOURCE_CREATE: %s\n",
                 strerror(errno));
@@ -144,7 +144,7 @@ static void virtio_init_fb(void)
 
     memset(&info, 0, sizeof(info));
     info.bo_handle = create.bo_handle;
-    rc = drmIoctl(fd, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, &info);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_VIRTGPU_RESOURCE_INFO, &info);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_VIRTGPU_RESOURCE_INFO: %s\n",
                 strerror(errno));
@@ -153,14 +153,14 @@ static void virtio_init_fb(void)
 
     memset(&map, 0, sizeof(map));
     map.handle = create.bo_handle;
-    rc = drmIoctl(fd, DRM_IOCTL_VIRTGPU_MAP, &map);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_VIRTGPU_MAP, &map);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_VIRTGPU_MAP: %s\n", strerror(errno));
         exit(1);
     }
 
     fbmem = mmap(0, info.size, PROT_READ | PROT_WRITE,
-                 MAP_SHARED, fd, map.offset);
+                 MAP_SHARED, drm_fd, map.offset);
     if (fbmem == MAP_FAILED) {
         fprintf(stderr, "framebuffer mmap: %s\n", strerror(errno));
         exit(1);
@@ -168,7 +168,7 @@ static void virtio_init_fb(void)
 
     if (info.stride)
         stride = info.stride;
-    rc = drmModeAddFB2(fd, create.width, create.height, fmt->fourcc,
+    rc = drmModeAddFB2(drm_fd, create.width, create.height, fmt->fourcc,
                        &create.bo_handle, &stride, &zero, &fb_id, 0);
     if (rc < 0) {
         fprintf(stderr, "drmModeAddFB2() failed: %s\n", strerror(errno));
@@ -189,7 +189,7 @@ static void virtio_draw(void)
 
     snprintf(info1, sizeof(info1), "virtio-gpu");
     snprintf(info2, sizeof(info2), "%dx%d",
-             mode->hdisplay, mode->vdisplay);
+             drm_mode->hdisplay, drm_mode->vdisplay);
     snprintf(info3, sizeof(info3), "fourcc %c%c%c%c",
              (fmt->fourcc >>  0) & 0xff,
              (fmt->fourcc >>  8) & 0xff,
@@ -197,7 +197,7 @@ static void virtio_draw(void)
              (fmt->fourcc >> 24) & 0xff);
 
     cr = cairo_create(cs);
-    render_test(cr, mode->hdisplay, mode->vdisplay, info1, info2, info3);
+    render_test(cr, drm_mode->hdisplay, drm_mode->vdisplay, info1, info2, info3);
     cairo_destroy(cr);
 }
 
@@ -208,10 +208,10 @@ static void virtio_transfer(void)
 
     memset(&xfer, 0, sizeof(xfer));
     xfer.bo_handle = create.bo_handle;
-    xfer.box.w = mode->hdisplay;
-    xfer.box.h = mode->vdisplay;
+    xfer.box.w = drm_mode->hdisplay;
+    xfer.box.h = drm_mode->vdisplay;
     xfer.box.d = 1;
-    rc = drmIoctl(fd, DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST, &xfer);
+    rc = drmIoctl(drm_fd, DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST, &xfer);
     if (rc < 0) {
         fprintf(stderr, "DRM_IOCTL_VIRTGPU_TRANSFER_TO_HOST: %s\n",
                 strerror(errno));
@@ -229,6 +229,7 @@ static void usage(FILE *fp)
             "\n"
             "options:\n"
             "  -h         print this\n"
+            "  -a         autotest mode\n"
             "  -c <nr>    pick card\n"
             "  -s <secs>  set sleep time (default: 60)\n"
             "  -i         print device info\n"