path: root/intel.c

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <sys/mman.h>
#include <fcntl.h>
#include <unistd.h>
#include <i915_drm.h>
#include <xf86drmMode.h>
#include <linux/fb.h>
#include <GL/gl.h> /* dri_interface.h uses some GL integer types... */
#include "eagle-internal.h"

#define INTEL_STRIDE_ALIGNMENT 64

typedef struct EGLDisplayNative *EGLDisplayNative;
struct EGLDisplayNative {
	struct EGLDisplay		 base;

#ifdef __DRI_COPY_BUFFER
	__DRIbuffer			 front;
	__DRIcopyBufferExtension	*copyBuffer;
#endif

	unsigned int	 stride;
	unsigned int	 width;
	unsigned int	 height;
	void		*fb;
};

typedef struct EGLSurfaceNative *EGLSurfaceNative;
struct EGLSurfaceNative {
	struct EGLSurface	base;
	uint32_t		handles[10];
	int			x, y, width, height;
	uint32_t		name, stride;
};

static inline uint32_t
align_to(uint32_t value, uint32_t align)
{
	return (value + align - 1) & ~(align - 1);
}

static void
nativeGetBuffers(EGLSurface surface, unsigned int *attachments, int count)
{
	EGLSurfaceNative nativeSurface = (EGLSurfaceNative) surface;
	struct drm_i915_gem_create create;
	struct drm_gem_flink flink;
	struct drm_gem_open open_arg;
	__DRIbuffer *buffer;
	uint32_t size;
	int fd, i, ret;

	if (nativeSurface->width == surface->width &&
	    nativeSurface->height == surface->height)
		return;

	for (i = 0; i < count; i++) {
		if (attachments[i] == __DRI_BUFFER_DEPTH)
			surface->depth = i;

		buffer = &surface->buffers[i];
		buffer->attachment = attachments[i];
		buffer->pitch = align_to(nativeSurface->width * 4,
					 INTEL_STRIDE_ALIGNMENT);
		buffer->cpp = 4;

		if (buffer->attachment == __DRI_BUFFER_FRONT_LEFT &&
		    nativeSurface->name != ~0) {
			buffer->name = nativeSurface->name;
			buffer->pitch = nativeSurface->stride;
			open_arg.name = buffer->name;
			ret = ioctl(surface->display->fd,
				    DRM_IOCTL_GEM_OPEN, &open_arg);
			nativeSurface->handles[i] = open_arg.handle;
			continue;
		}

		if (attachments[i] == __DRI_BUFFER_STENCIL) {
			buffer->name = surface->buffers[surface->depth].name;
			nativeSurface->handles[i] =
				nativeSurface->handles[surface->depth];
			continue;
		}

		size = buffer->pitch * nativeSurface->height;
		fd = surface->display->fd;
		create.size = size;
		if (ioctl(fd, DRM_IOCTL_I915_GEM_CREATE, &create)) {
			fprintf(stderr, "failed to create buffer\n");
			return;
		}
		nativeSurface->handles[i] = create.handle;

		flink.handle = create.handle;
		if (ioctl(fd, DRM_IOCTL_GEM_FLINK, &flink) < 0) {
			fprintf(stderr, "failed to create buffer\n");
			return;
		}

		buffer->name = flink.name;
	}

	surface->width = nativeSurface->width;
	surface->height = nativeSurface->height;
	surface->count = count;
}

static EGLBoolean
nativeDestroySurface(EGLDisplay display, EGLSurface surface)
{
	free(surface);

	return EGL_TRUE;
}

#ifdef __DRI_COPY_BUFFER

static EGLBoolean
nativeDRISwapBuffers(EGLDisplay display, EGLSurface surface)
{
	EGLDisplayNative nativeDisplay = (EGLDisplayNative) display;
	EGLContext context;

	context = eglGetCurrentContext();

	return nativeDisplay->copyBuffer->copyBuffer(context->driContext,
						     surface->driDrawable,
						     __DRI_BUFFER_FRONT_LEFT,
						     &nativeDisplay->front);
}

static const struct EagleBackend nativeDRIBackend = {
	nativeGetBuffers,
	nativeDRISwapBuffers,
	nativeDestroySurface,
};

static void
nativeInitDRICopyBuffer(EGLDisplay display)
{
	EGLDisplayNative nativeDisplay = (EGLDisplayNative) display;
	const __DRIextension **extensions;
	drmModeResPtr mode_res;
	drmModeCrtcPtr crtc;
	drmModeFBPtr fb;
	struct drm_gem_flink flink;
	struct driPrivate *private;
	int i;

	extensions = display->core->getExtensions(display->driScreen);
	if (extensions == NULL)
		return;

	for (i = 0; extensions[i]; i++) {
		if (strcmp(extensions[i]->name, __DRI_COPY_BUFFER) == 0 &&
		    extensions[i]->version >= __DRI_COPY_BUFFER_VERSION) {
			nativeDisplay->copyBuffer =
				(__DRIcopyBufferExtension *) extensions[i];
		}
	}

	if (nativeDisplay->copyBuffer == NULL)
		goto fail;

	mode_res = drmModeGetResources(display->fd);
	if (mode_res == NULL) {
		fprintf(stderr, "drmModeGetResources returns NULL\n");
		goto fail;
	}

	crtc = drmModeGetCrtc(display->fd, mode_res->crtcs[1]);
	if (crtc == NULL) {
		fprintf(stderr, "drmModeGetCrtc returns NULL\n");
		goto fail;
	}

	fb = drmModeGetFB(display->fd, crtc->buffer_id);
	if (fb == NULL) {
		fprintf(stderr, "drmModeGetFB returns NULL\n");
		goto fail;
	}

	flink.handle = fb->handle;
	if (ioctl(display->fd, DRM_IOCTL_GEM_FLINK, &flink) < 0) {
		fprintf(stderr, "failed to create buffer\n");
		goto fail;
	}

	nativeDisplay->front.attachment = __DRI_BUFFER_FRONT_LEFT;
	nativeDisplay->front.name = flink.name;
	nativeDisplay->front.cpp = fb->bpp / 8;
	nativeDisplay->front.pitch = fb->pitch;
	nativeDisplay->front.flags = 0;

	display->width = fb->width;
	display->height = fb->height;
	display->backend = &nativeDRIBackend;

	printf("Using DRI CopyBuffer swapbuffer\n");

	return;

 fail:
	free(private);
}

#endif

static EGLBoolean
nativeMemcpySwapBuffers(EGLDisplay display, EGLSurface surface)
{
	EGLDisplayNative nativeDisplay = (EGLDisplayNative) display;
	EGLSurfaceNative nativeSurface = (EGLSurfaceNative) surface;
	struct drm_i915_gem_pread pread;
	char *data, *dst;
	int i, stride, x, y;

	stride = surface->buffers[0].pitch;

	pread.handle = nativeSurface->handles[0];
	pread.pad = 0;
	pread.offset = 0;
	pread.size = stride * nativeSurface->height;

	data = malloc(pread.size);
	if (data == NULL) {
		fprintf(stderr, "swap buffers malloc failed\n");
		return EGL_FALSE;
	}

	pread.data_ptr = (long) data;

	if (ioctl(display->fd, DRM_IOCTL_I915_GEM_PREAD, &pread)) {
		fprintf(stderr, "gem pread failed\n");
		return EGL_FALSE;
	}

	x = nativeSurface->x;
	y = nativeSurface->y;
	dst = nativeDisplay->fb + nativeDisplay->stride * y + x * 4;
	for (i = 0; i < nativeSurface->height; i++)
		memcpy(dst + nativeDisplay->stride * i,
		       data + stride * i, nativeSurface->width * 4);

	free(data);

	return EGL_TRUE;
}

static const struct EagleBackend intelMemcpyBackend = {
	nativeGetBuffers,
	nativeMemcpySwapBuffers,
	nativeDestroySurface,
};

static const char fb_device[] = "/dev/fb";

static void
nativeInitMemcpy(EGLDisplay display)
{
	EGLDisplayNative nativeDisplay = (EGLDisplayNative) display;
	struct fb_fix_screeninfo fix;
	struct fb_var_screeninfo var;
	int fd;

	fd = open(fb_device, O_RDWR);
	if (fd < 0) {
		fprintf(stderr, "failed to open %s\n", fb_device);
		return;
	}

	if (ioctl(fd, FBIOGET_FSCREENINFO, &fix) < 0) {
		fprintf(stderr, "fb get fixed failed\n");
		return;
	}

	if (ioctl(fd, FBIOGET_VSCREENINFO, &var) < 0) {
		fprintf(stderr, "fb get fixed failed\n");
		return;
	}

	nativeDisplay->stride = fix.line_length;
	nativeDisplay->width = var.xres;
	nativeDisplay->height = var.yres;
	nativeDisplay->fb = mmap(NULL, nativeDisplay->stride * nativeDisplay->height,
				 PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);

	close(fd);

	if (nativeDisplay->fb == MAP_FAILED) {
		fprintf(stderr, "fb map failed\n");
		return;
	}

	display->backend = &intelMemcpyBackend;
	display->width = nativeDisplay->width;
	display->height = nativeDisplay->height;

	printf("Using memcpy swapbuffer\n");
}

EGLDisplay
eglCreateDisplayNative(const char *device, const char *driver)
{
	EGLDisplayNative nativeDisplay;

	nativeDisplay = malloc(sizeof *nativeDisplay);
	if (nativeDisplay == NULL)
		return NULL;
	
	if (eglInitDisplay(&nativeDisplay->base, device, driver) < 0) {
		free(nativeDisplay);
		return NULL;
	}

#ifdef __DRI_COPY_BUFFER
	nativeInitDRICopyBuffer(&nativeDisplay->base);
#endif

	if (nativeDisplay->base.backend == NULL)
		nativeInitMemcpy(&nativeDisplay->base);

	return &nativeDisplay->base;
}

EGLSurface
eglCreateSurfaceNative(EGLDisplay display, EGLConfig config,
		       int x, int y, int width, int height)
{
	EGLSurfaceNative nativeSurface;

	nativeSurface = malloc(sizeof *nativeSurface);
	if (nativeSurface == NULL)
		return NULL;

	nativeSurface->x = x;
	nativeSurface->y = y;
	nativeSurface->width = width;
	nativeSurface->height = height;
	nativeSurface->name = ~0;
	nativeSurface->stride = 0;

	eglInitSurface(&nativeSurface->base, display, config);

	return &nativeSurface->base;
}

EGLSurface
eglCreatePixmapForName(EGLDisplay display, EGLConfig config,
		       uint32_t name, uint32_t width,
		       uint32_t height, uint32_t stride, const EGLint *attribList)
{
	EGLSurfaceNative nativeSurface;

	nativeSurface = malloc(sizeof *nativeSurface);
	if (nativeSurface == NULL)
		return NULL;

	nativeSurface->x = 0;
	nativeSurface->y = 0;
	nativeSurface->width = width;
	nativeSurface->height = height;
	nativeSurface->name = name;
	nativeSurface->stride = stride;

	eglInitSurface(&nativeSurface->base, display, config);

	return &nativeSurface->base;
}