[qemu.git] / hw / display / milkymist-tmu2.c

/*
 *  QEMU model of the Milkymist texture mapping unit.
 *
 *  Copyright (c) 2010 Michael Walle <[email protected]>
 *  Copyright (c) 2010 Sebastien Bourdeauducq
 *                       <[email protected]>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
 *
 *
 * Specification available at:
 *   http://milkymist.walle.cc/socdoc/tmu2.pdf
 *
 */

#include "qemu/osdep.h"
#include "hw/hw.h"
#include "hw/sysbus.h"
#include "trace.h"
#include "qapi/error.h"
#include "qemu/error-report.h"
#include "qapi/error.h"
#include "hw/display/milkymist_tmu2.h"

#include <X11/Xlib.h>
#include <epoxy/gl.h>
#include <epoxy/glx.h>

enum {
    R_CTL = 0,
    R_HMESHLAST,
    R_VMESHLAST,
    R_BRIGHTNESS,
    R_CHROMAKEY,
    R_VERTICESADDR,
    R_TEXFBUF,
    R_TEXHRES,
    R_TEXVRES,
    R_TEXHMASK,
    R_TEXVMASK,
    R_DSTFBUF,
    R_DSTHRES,
    R_DSTVRES,
    R_DSTHOFFSET,
    R_DSTVOFFSET,
    R_DSTSQUAREW,
    R_DSTSQUAREH,
    R_ALPHA,
    R_MAX
};

enum {
    CTL_START_BUSY  = (1<<0),
    CTL_CHROMAKEY   = (1<<1),
};

enum {
    MAX_BRIGHTNESS = 63,
    MAX_ALPHA      = 63,
};

enum {
    MESH_MAXSIZE = 128,
};

struct vertex {
    int x;
    int y;
} QEMU_PACKED;

#define TYPE_MILKYMIST_TMU2 "milkymist-tmu2"
#define MILKYMIST_TMU2(obj) \
    OBJECT_CHECK(MilkymistTMU2State, (obj), TYPE_MILKYMIST_TMU2)

struct MilkymistTMU2State {
    SysBusDevice parent_obj;

    MemoryRegion regs_region;
    Chardev *chr;
    qemu_irq irq;

    uint32_t regs[R_MAX];

    Display *dpy;
    GLXFBConfig glx_fb_config;
    GLXContext glx_context;
};
typedef struct MilkymistTMU2State MilkymistTMU2State;

static const int glx_fbconfig_attr[] = {
    GLX_GREEN_SIZE, 5,
    GLX_GREEN_SIZE, 6,
    GLX_BLUE_SIZE, 5,
    None
};

static int tmu2_glx_init(MilkymistTMU2State *s)
{
    GLXFBConfig *configs;
    int nelements;

    s->dpy = XOpenDisplay(NULL); /* FIXME: call XCloseDisplay() */
    if (s->dpy == NULL) {
        return 1;
    }

    configs = glXChooseFBConfig(s->dpy, 0, glx_fbconfig_attr, &nelements);
    if (configs == NULL) {
        return 1;
    }

    s->glx_fb_config = *configs;
    XFree(configs);

    /* FIXME: call glXDestroyContext() */
    s->glx_context = glXCreateNewContext(s->dpy, s->glx_fb_config,
            GLX_RGBA_TYPE, NULL, 1);
    if (s->glx_context == NULL) {
        return 1;
    }

    return 0;
}

static void tmu2_gl_map(struct vertex *mesh, int texhres, int texvres,
        int hmeshlast, int vmeshlast, int ho, int vo, int sw, int sh)
{
    int x, y;
    int x0, y0, x1, y1;
    int u0, v0, u1, v1, u2, v2, u3, v3;
    double xscale = 1.0 / ((double)(64 * texhres));
    double yscale = 1.0 / ((double)(64 * texvres));

    glLoadIdentity();
    glTranslatef(ho, vo, 0);
    glEnable(GL_TEXTURE_2D);
    glBegin(GL_QUADS);

    for (y = 0; y < vmeshlast; y++) {
        y0 = y * sh;
        y1 = y0 + sh;
        for (x = 0; x < hmeshlast; x++) {
            x0 = x * sw;
            x1 = x0 + sw;

            u0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].x);
            v0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].y);
            u1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].x);
            v1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].y);
            u2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].x);
            v2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].y);
            u3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].x);
            v3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].y);

            glTexCoord2d(((double)u0) * xscale, ((double)v0) * yscale);
            glVertex3i(x0, y0, 0);
            glTexCoord2d(((double)u1) * xscale, ((double)v1) * yscale);
            glVertex3i(x1, y0, 0);
            glTexCoord2d(((double)u2) * xscale, ((double)v2) * yscale);
            glVertex3i(x1, y1, 0);
            glTexCoord2d(((double)u3) * xscale, ((double)v3) * yscale);
            glVertex3i(x0, y1, 0);
        }
    }

    glEnd();
}

static void tmu2_start(MilkymistTMU2State *s)
{
    int pbuffer_attrib[6] = {
        GLX_PBUFFER_WIDTH,
        0,
        GLX_PBUFFER_HEIGHT,
        0,
        GLX_PRESERVED_CONTENTS,
        True
    };

    GLXPbuffer pbuffer;
    GLuint texture;
    void *fb;
    hwaddr fb_len;
    void *mesh;
    hwaddr mesh_len;
    float m;

    trace_milkymist_tmu2_start();

    /* Create and set up a suitable OpenGL context */
    pbuffer_attrib[1] = s->regs[R_DSTHRES];
    pbuffer_attrib[3] = s->regs[R_DSTVRES];
    pbuffer = glXCreatePbuffer(s->dpy, s->glx_fb_config, pbuffer_attrib);
    glXMakeContextCurrent(s->dpy, pbuffer, pbuffer, s->glx_context);

    /* Fixup endianness. TODO: would it work on BE hosts? */
    glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
    glPixelStorei(GL_PACK_SWAP_BYTES, 1);

    /* Row alignment */
    glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
    glPixelStorei(GL_PACK_ALIGNMENT, 2);

    /* Read the QEMU source framebuffer into an OpenGL texture */
    glGenTextures(1, &texture);
    glBindTexture(GL_TEXTURE_2D, texture);
    fb_len = 2ULL * s->regs[R_TEXHRES] * s->regs[R_TEXVRES];
    fb = cpu_physical_memory_map(s->regs[R_TEXFBUF], &fb_len, 0);
    if (fb == NULL) {
        glDeleteTextures(1, &texture);
        glXMakeContextCurrent(s->dpy, None, None, NULL);
        glXDestroyPbuffer(s->dpy, pbuffer);
        return;
    }
    glTexImage2D(GL_TEXTURE_2D, 0, 3, s->regs[R_TEXHRES], s->regs[R_TEXVRES],
            0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, fb);
    cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);

    /* Set up texturing options */
    /* WARNING:
     * Many cases of TMU2 masking are not supported by OpenGL.
     * We only implement the most common ones:
     *  - full bilinear filtering vs. nearest texel
     *  - texture clamping vs. texture wrapping
     */
    if ((s->regs[R_TEXHMASK] & 0x3f) > 0x20) {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    } else {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
    }
    if ((s->regs[R_TEXHMASK] >> 6) & s->regs[R_TEXHRES]) {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    } else {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
    }
    if ((s->regs[R_TEXVMASK] >> 6) & s->regs[R_TEXVRES]) {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    } else {
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
    }

    /* Translucency and decay */
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    m = (float)(s->regs[R_BRIGHTNESS] + 1) / 64.0f;
    glColor4f(m, m, m, (float)(s->regs[R_ALPHA] + 1) / 64.0f);

    /* Read the QEMU dest. framebuffer into the OpenGL framebuffer */
    fb_len = 2ULL * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
    fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 0);
    if (fb == NULL) {
        glDeleteTextures(1, &texture);
        glXMakeContextCurrent(s->dpy, None, None, NULL);
        glXDestroyPbuffer(s->dpy, pbuffer);
        return;
    }

    glDrawPixels(s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
            GL_UNSIGNED_SHORT_5_6_5, fb);
    cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);
    glViewport(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES]);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(0.0, s->regs[R_DSTHRES], 0.0, s->regs[R_DSTVRES], -1.0, 1.0);
    glMatrixMode(GL_MODELVIEW);

    /* Map the texture */
    mesh_len = MESH_MAXSIZE*MESH_MAXSIZE*sizeof(struct vertex);
    mesh = cpu_physical_memory_map(s->regs[R_VERTICESADDR], &mesh_len, 0);
    if (mesh == NULL) {
        glDeleteTextures(1, &texture);
        glXMakeContextCurrent(s->dpy, None, None, NULL);
        glXDestroyPbuffer(s->dpy, pbuffer);
        return;
    }

    tmu2_gl_map((struct vertex *)mesh,
        s->regs[R_TEXHRES], s->regs[R_TEXVRES],
        s->regs[R_HMESHLAST], s->regs[R_VMESHLAST],
        s->regs[R_DSTHOFFSET], s->regs[R_DSTVOFFSET],
        s->regs[R_DSTSQUAREW], s->regs[R_DSTSQUAREH]);
    cpu_physical_memory_unmap(mesh, mesh_len, 0, mesh_len);

    /* Write back the OpenGL framebuffer to the QEMU framebuffer */
    fb_len = 2ULL * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
    fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 1);
    if (fb == NULL) {
        glDeleteTextures(1, &texture);
        glXMakeContextCurrent(s->dpy, None, None, NULL);
        glXDestroyPbuffer(s->dpy, pbuffer);
        return;
    }

    glReadPixels(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
            GL_UNSIGNED_SHORT_5_6_5, fb);
    cpu_physical_memory_unmap(fb, fb_len, 1, fb_len);

    /* Free OpenGL allocs */
    glDeleteTextures(1, &texture);
    glXMakeContextCurrent(s->dpy, None, None, NULL);
    glXDestroyPbuffer(s->dpy, pbuffer);

    s->regs[R_CTL] &= ~CTL_START_BUSY;

    trace_milkymist_tmu2_pulse_irq();
    qemu_irq_pulse(s->irq);
}

static uint64_t tmu2_read(void *opaque, hwaddr addr,
                          unsigned size)
{
    MilkymistTMU2State *s = opaque;
    uint32_t r = 0;

    addr >>= 2;
    switch (addr) {
    case R_CTL:
    case R_HMESHLAST:
    case R_VMESHLAST:
    case R_BRIGHTNESS:
    case R_CHROMAKEY:
    case R_VERTICESADDR:
    case R_TEXFBUF:
    case R_TEXHRES:
    case R_TEXVRES:
    case R_TEXHMASK:
    case R_TEXVMASK:
    case R_DSTFBUF:
    case R_DSTHRES:
    case R_DSTVRES:
    case R_DSTHOFFSET:
    case R_DSTVOFFSET:
    case R_DSTSQUAREW:
    case R_DSTSQUAREH:
    case R_ALPHA:
        r = s->regs[addr];
        break;

    default:
        error_report("milkymist_tmu2: read access to unknown register 0x"
                TARGET_FMT_plx, addr << 2);
        break;
    }

    trace_milkymist_tmu2_memory_read(addr << 2, r);

    return r;
}

static void tmu2_check_registers(MilkymistTMU2State *s)
{
    if (s->regs[R_BRIGHTNESS] > MAX_BRIGHTNESS) {
        error_report("milkymist_tmu2: max brightness is %d", MAX_BRIGHTNESS);
    }

    if (s->regs[R_ALPHA] > MAX_ALPHA) {
        error_report("milkymist_tmu2: max alpha is %d", MAX_ALPHA);
    }

    if (s->regs[R_VERTICESADDR] & 0x07) {
        error_report("milkymist_tmu2: vertex mesh address has to be 64-bit "
                "aligned");
    }

    if (s->regs[R_TEXFBUF] & 0x01) {
        error_report("milkymist_tmu2: texture buffer address has to be "
                "16-bit aligned");
    }
}

static void tmu2_write(void *opaque, hwaddr addr, uint64_t value,
                       unsigned size)
{
    MilkymistTMU2State *s = opaque;

    trace_milkymist_tmu2_memory_write(addr, value);

    addr >>= 2;
    switch (addr) {
    case R_CTL:
        s->regs[addr] = value;
        if (value & CTL_START_BUSY) {
            tmu2_start(s);
        }
        break;
    case R_BRIGHTNESS:
    case R_HMESHLAST:
    case R_VMESHLAST:
    case R_CHROMAKEY:
    case R_VERTICESADDR:
    case R_TEXFBUF:
    case R_TEXHRES:
    case R_TEXVRES:
    case R_TEXHMASK:
    case R_TEXVMASK:
    case R_DSTFBUF:
    case R_DSTHRES:
    case R_DSTVRES:
    case R_DSTHOFFSET:
    case R_DSTVOFFSET:
    case R_DSTSQUAREW:
    case R_DSTSQUAREH:
    case R_ALPHA:
        s->regs[addr] = value;
        break;

    default:
        error_report("milkymist_tmu2: write access to unknown register 0x"
                TARGET_FMT_plx, addr << 2);
        break;
    }

    tmu2_check_registers(s);
}

static const MemoryRegionOps tmu2_mmio_ops = {
    .read = tmu2_read,
    .write = tmu2_write,
    .valid = {
        .min_access_size = 4,
        .max_access_size = 4,
    },
    .endianness = DEVICE_NATIVE_ENDIAN,
};

static void milkymist_tmu2_reset(DeviceState *d)
{
    MilkymistTMU2State *s = MILKYMIST_TMU2(d);
    int i;

    for (i = 0; i < R_MAX; i++) {
        s->regs[i] = 0;
    }
}

static void milkymist_tmu2_init(Object *obj)
{
    MilkymistTMU2State *s = MILKYMIST_TMU2(obj);
    SysBusDevice *dev = SYS_BUS_DEVICE(obj);

    sysbus_init_irq(dev, &s->irq);

    memory_region_init_io(&s->regs_region, obj, &tmu2_mmio_ops, s,
            "milkymist-tmu2", R_MAX * 4);
    sysbus_init_mmio(dev, &s->regs_region);
}

static void milkymist_tmu2_realize(DeviceState *dev, Error **errp)
{
    MilkymistTMU2State *s = MILKYMIST_TMU2(dev);

    if (tmu2_glx_init(s)) {
        error_setg(errp, "tmu2_glx_init failed");
    }
}

static const VMStateDescription vmstate_milkymist_tmu2 = {
    .name = "milkymist-tmu2",
    .version_id = 1,
    .minimum_version_id = 1,
    .fields = (VMStateField[]) {
        VMSTATE_UINT32_ARRAY(regs, MilkymistTMU2State, R_MAX),
        VMSTATE_END_OF_LIST()
    }
};

static void milkymist_tmu2_class_init(ObjectClass *klass, void *data)
{
    DeviceClass *dc = DEVICE_CLASS(klass);

    dc->realize = milkymist_tmu2_realize;
    dc->reset = milkymist_tmu2_reset;
    dc->vmsd = &vmstate_milkymist_tmu2;
}

static const TypeInfo milkymist_tmu2_info = {
    .name          = TYPE_MILKYMIST_TMU2,
    .parent        = TYPE_SYS_BUS_DEVICE,
    .instance_size = sizeof(MilkymistTMU2State),
    .instance_init = milkymist_tmu2_init,
    .class_init    = milkymist_tmu2_class_init,
};

static void milkymist_tmu2_register_types(void)
{
    type_register_static(&milkymist_tmu2_info);
}

type_init(milkymist_tmu2_register_types)

DeviceState *milkymist_tmu2_create(hwaddr base, qemu_irq irq)
{
    DeviceState *dev;
    Display *d;
    GLXFBConfig *configs;
    int nelements;
    int ver_major, ver_minor;

    /* check that GLX will work */
    d = XOpenDisplay(NULL);
    if (d == NULL) {
        return NULL;
    }

    if (!glXQueryVersion(d, &ver_major, &ver_minor)) {
        /*
         * Yeah, sometimes getting the GLX version can fail.
         * Isn't X beautiful?
         */
        XCloseDisplay(d);
        return NULL;
    }

    if ((ver_major < 1) || ((ver_major == 1) && (ver_minor < 3))) {
        printf("Your GLX version is %d.%d,"
          "but TMU emulation needs at least 1.3. TMU disabled.\n",
          ver_major, ver_minor);
        XCloseDisplay(d);
        return NULL;
    }

    configs = glXChooseFBConfig(d, 0, glx_fbconfig_attr, &nelements);
    if (configs == NULL) {
        XCloseDisplay(d);
        return NULL;
    }

    XFree(configs);
    XCloseDisplay(d);

    dev = qdev_create(NULL, TYPE_MILKYMIST_TMU2);
    qdev_init_nofail(dev);
    sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
    sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);

    return dev;
}
Commit	Line	Data
0670dadd MW	1	/*
	2	* QEMU model of the Milkymist texture mapping unit.
	3	*
	4	* Copyright (c) 2010 Michael Walle <[email protected]>
	5	* Copyright (c) 2010 Sebastien Bourdeauducq
	6	* <[email protected]>
	7	*
	8	* This library is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU Lesser General Public
	10	* License as published by the Free Software Foundation; either
	11	* version 2 of the License, or (at your option) any later version.
	12	*
	13	* This library is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	* Lesser General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU Lesser General Public
	19	* License along with this library; if not, see <http://www.gnu.org/licenses/>.
	20	*
	21	*
	22	* Specification available at:
6dbbe243	23	* http://milkymist.walle.cc/socdoc/tmu2.pdf
0670dadd MW	24	*
	25	*/
	26
ea99dde1	27	#include "qemu/osdep.h"
83c9f4ca PB	28	#include "hw/hw.h"
83c9f4ca PB	29	#include "hw/sysbus.h"
0670dadd	30	#include "trace.h"
e688df6b	31	#include "qapi/error.h"
1de7afc9	32	#include "qemu/error-report.h"
55543e76	33	#include "qapi/error.h"
70cc0c1f	34	#include "hw/display/milkymist_tmu2.h"
0670dadd MW	35
0670dadd MW	36	#include <X11/Xlib.h>
fb719563 OH	37	#include <epoxy/gl.h>
fb719563 OH	38	#include <epoxy/glx.h>
0670dadd MW	39
	40	enum {
	41	R_CTL = 0,
	42	R_HMESHLAST,
	43	R_VMESHLAST,
	44	R_BRIGHTNESS,
	45	R_CHROMAKEY,
	46	R_VERTICESADDR,
	47	R_TEXFBUF,
	48	R_TEXHRES,
	49	R_TEXVRES,
	50	R_TEXHMASK,
	51	R_TEXVMASK,
	52	R_DSTFBUF,
	53	R_DSTHRES,
	54	R_DSTVRES,
	55	R_DSTHOFFSET,
	56	R_DSTVOFFSET,
	57	R_DSTSQUAREW,
	58	R_DSTSQUAREH,
	59	R_ALPHA,
	60	R_MAX
	61	};
	62
	63	enum {
	64	CTL_START_BUSY = (1<<0),
	65	CTL_CHROMAKEY = (1<<1),
	66	};
	67
	68	enum {
	69	MAX_BRIGHTNESS = 63,
	70	MAX_ALPHA = 63,
	71	};
	72
	73	enum {
	74	MESH_MAXSIZE = 128,
	75	};
	76
	77	struct vertex {
	78	int x;
	79	int y;
541dc0d4	80	} QEMU_PACKED;
0670dadd	81
56299135 AF	82	#define TYPE_MILKYMIST_TMU2 "milkymist-tmu2"
	83	#define MILKYMIST_TMU2(obj) \
	84	OBJECT_CHECK(MilkymistTMU2State, (obj), TYPE_MILKYMIST_TMU2)
	85
0670dadd	86	struct MilkymistTMU2State {
56299135 AF	87	SysBusDevice parent_obj;
56299135 AF	88
7100453f	89	MemoryRegion regs_region;
0ec7b3e7	90	Chardev *chr;
0670dadd MW	91	qemu_irq irq;
	92
	93	uint32_t regs[R_MAX];
	94
	95	Display *dpy;
	96	GLXFBConfig glx_fb_config;
	97	GLXContext glx_context;
	98	};
	99	typedef struct MilkymistTMU2State MilkymistTMU2State;
	100
	101	static const int glx_fbconfig_attr[] = {
	102	GLX_GREEN_SIZE, 5,
	103	GLX_GREEN_SIZE, 6,
	104	GLX_BLUE_SIZE, 5,
	105	None
	106	};
	107
	108	static int tmu2_glx_init(MilkymistTMU2State *s)
	109	{
	110	GLXFBConfig *configs;
	111	int nelements;
	112
	113	s->dpy = XOpenDisplay(NULL); /* FIXME: call XCloseDisplay() */
	114	if (s->dpy == NULL) {
	115	return 1;
	116	}
	117
	118	configs = glXChooseFBConfig(s->dpy, 0, glx_fbconfig_attr, &nelements);
	119	if (configs == NULL) {
	120	return 1;
	121	}
	122
	123	s->glx_fb_config = *configs;
	124	XFree(configs);
	125
	126	/* FIXME: call glXDestroyContext() */
	127	s->glx_context = glXCreateNewContext(s->dpy, s->glx_fb_config,
	128	GLX_RGBA_TYPE, NULL, 1);
	129	if (s->glx_context == NULL) {
	130	return 1;
	131	}
	132
	133	return 0;
	134	}
	135
	136	static void tmu2_gl_map(struct vertex *mesh, int texhres, int texvres,
	137	int hmeshlast, int vmeshlast, int ho, int vo, int sw, int sh)
	138	{
	139	int x, y;
	140	int x0, y0, x1, y1;
	141	int u0, v0, u1, v1, u2, v2, u3, v3;
	142	double xscale = 1.0 / ((double)(64 * texhres));
	143	double yscale = 1.0 / ((double)(64 * texvres));
	144
	145	glLoadIdentity();
	146	glTranslatef(ho, vo, 0);
	147	glEnable(GL_TEXTURE_2D);
	148	glBegin(GL_QUADS);
	149
	150	for (y = 0; y < vmeshlast; y++) {
	151	y0 = y * sh;
	152	y1 = y0 + sh;
	153	for (x = 0; x < hmeshlast; x++) {
	154	x0 = x * sw;
155	x1 = x0 + sw;
156
157	u0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].x);
158	v0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].y);
159	u1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].x);
160	v1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].y);
161	u2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].x);
162	v2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].y);
163	u3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].x);
164	v3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].y);
165
166	glTexCoord2d(((double)u0) * xscale, ((double)v0) * yscale);
167	glVertex3i(x0, y0, 0);
168	glTexCoord2d(((double)u1) * xscale, ((double)v1) * yscale);
169	glVertex3i(x1, y0, 0);
170	glTexCoord2d(((double)u2) * xscale, ((double)v2) * yscale);
171	glVertex3i(x1, y1, 0);
172	glTexCoord2d(((double)u3) * xscale, ((double)v3) * yscale);
173	glVertex3i(x0, y1, 0);
174	}
175	}
176
177	glEnd();
178	}
179
180	static void tmu2_start(MilkymistTMU2State *s)
181	{
182	int pbuffer_attrib[6] = {
183	GLX_PBUFFER_WIDTH,
184	0,
185	GLX_PBUFFER_HEIGHT,
186	0,
187	GLX_PRESERVED_CONTENTS,
188	True
189	};
190
191	GLXPbuffer pbuffer;
192	GLuint texture;
193	void *fb;
a8170e5e	194	hwaddr fb_len;
0670dadd	195	void *mesh;
a8170e5e	196	hwaddr mesh_len;
0670dadd MW	197	float m;
	198
	199	trace_milkymist_tmu2_start();
	200
	201	/* Create and set up a suitable OpenGL context */
	202	pbuffer_attrib[1] = s->regs[R_DSTHRES];
	203	pbuffer_attrib[3] = s->regs[R_DSTVRES];
	204	pbuffer = glXCreatePbuffer(s->dpy, s->glx_fb_config, pbuffer_attrib);
	205	glXMakeContextCurrent(s->dpy, pbuffer, pbuffer, s->glx_context);
	206
	207	/* Fixup endianness. TODO: would it work on BE hosts? */
	208	glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
	209	glPixelStorei(GL_PACK_SWAP_BYTES, 1);
	210
	211	/* Row alignment */
	212	glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
	213	glPixelStorei(GL_PACK_ALIGNMENT, 2);
	214
	215	/* Read the QEMU source framebuffer into an OpenGL texture */
	216	glGenTextures(1, &texture);
	217	glBindTexture(GL_TEXTURE_2D, texture);
237a8650	218	fb_len = 2ULL * s->regs[R_TEXHRES] * s->regs[R_TEXVRES];
0670dadd MW	219	fb = cpu_physical_memory_map(s->regs[R_TEXFBUF], &fb_len, 0);
	220	if (fb == NULL) {
	221	glDeleteTextures(1, &texture);
	222	glXMakeContextCurrent(s->dpy, None, None, NULL);
	223	glXDestroyPbuffer(s->dpy, pbuffer);
	224	return;
	225	}
	226	glTexImage2D(GL_TEXTURE_2D, 0, 3, s->regs[R_TEXHRES], s->regs[R_TEXVRES],
	227	0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, fb);
	228	cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);
	229
	230	/* Set up texturing options */
	231	/* WARNING:
	232	* Many cases of TMU2 masking are not supported by OpenGL.
	233	* We only implement the most common ones:
	234	* - full bilinear filtering vs. nearest texel
	235	* - texture clamping vs. texture wrapping
	236	*/
	237	if ((s->regs[R_TEXHMASK] & 0x3f) > 0x20) {
	238	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	239	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	240	} else {
	241	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	242	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	243	}
	244	if ((s->regs[R_TEXHMASK] >> 6) & s->regs[R_TEXHRES]) {
	245	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	246	} else {
	247	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
	248	}
	249	if ((s->regs[R_TEXVMASK] >> 6) & s->regs[R_TEXVRES]) {
	250	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
	251	} else {
	252	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
	253	}
	254
	255	/* Translucency and decay */
	256	glEnable(GL_BLEND);
	257	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
	258	m = (float)(s->regs[R_BRIGHTNESS] + 1) / 64.0f;
	259	glColor4f(m, m, m, (float)(s->regs[R_ALPHA] + 1) / 64.0f);
	260
	261	/* Read the QEMU dest. framebuffer into the OpenGL framebuffer */
4382fa65	262	fb_len = 2ULL * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
0670dadd MW	263	fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 0);
	264	if (fb == NULL) {
	265	glDeleteTextures(1, &texture);
	266	glXMakeContextCurrent(s->dpy, None, None, NULL);
	267	glXDestroyPbuffer(s->dpy, pbuffer);
	268	return;
	269	}
	270
	271	glDrawPixels(s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
	272	GL_UNSIGNED_SHORT_5_6_5, fb);
	273	cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);
	274	glViewport(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES]);
	275	glMatrixMode(GL_PROJECTION);
	276	glLoadIdentity();
	277	glOrtho(0.0, s->regs[R_DSTHRES], 0.0, s->regs[R_DSTVRES], -1.0, 1.0);
	278	glMatrixMode(GL_MODELVIEW);
	279
	280	/* Map the texture */
	281	mesh_len = MESH_MAXSIZEMESH_MAXSIZEsizeof(struct vertex);
	282	mesh = cpu_physical_memory_map(s->regs[R_VERTICESADDR], &mesh_len, 0);
	283	if (mesh == NULL) {
	284	glDeleteTextures(1, &texture);
	285	glXMakeContextCurrent(s->dpy, None, None, NULL);
	286	glXDestroyPbuffer(s->dpy, pbuffer);
	287	return;
	288	}
	289
	290	tmu2_gl_map((struct vertex *)mesh,
	291	s->regs[R_TEXHRES], s->regs[R_TEXVRES],
	292	s->regs[R_HMESHLAST], s->regs[R_VMESHLAST],
	293	s->regs[R_DSTHOFFSET], s->regs[R_DSTVOFFSET],
	294	s->regs[R_DSTSQUAREW], s->regs[R_DSTSQUAREH]);
	295	cpu_physical_memory_unmap(mesh, mesh_len, 0, mesh_len);
	296
	297	/* Write back the OpenGL framebuffer to the QEMU framebuffer */
3d74ee7d	298	fb_len = 2ULL * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
0670dadd MW	299	fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 1);
	300	if (fb == NULL) {
	301	glDeleteTextures(1, &texture);
	302	glXMakeContextCurrent(s->dpy, None, None, NULL);
	303	glXDestroyPbuffer(s->dpy, pbuffer);
	304	return;
	305	}
	306
	307	glReadPixels(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
	308	GL_UNSIGNED_SHORT_5_6_5, fb);
	309	cpu_physical_memory_unmap(fb, fb_len, 1, fb_len);
	310
	311	/* Free OpenGL allocs */
	312	glDeleteTextures(1, &texture);
	313	glXMakeContextCurrent(s->dpy, None, None, NULL);
	314	glXDestroyPbuffer(s->dpy, pbuffer);
	315
	316	s->regs[R_CTL] &= ~CTL_START_BUSY;
	317
	318	trace_milkymist_tmu2_pulse_irq();
	319	qemu_irq_pulse(s->irq);
	320	}
	321
a8170e5e	322	static uint64_t tmu2_read(void *opaque, hwaddr addr,
7100453f	323	unsigned size)
0670dadd MW	324	{
	325	MilkymistTMU2State *s = opaque;
	326	uint32_t r = 0;
	327
	328	addr >>= 2;
	329	switch (addr) {
	330	case R_CTL:
	331	case R_HMESHLAST:
	332	case R_VMESHLAST:
	333	case R_BRIGHTNESS:
	334	case R_CHROMAKEY:
	335	case R_VERTICESADDR:
	336	case R_TEXFBUF:
	337	case R_TEXHRES:
	338	case R_TEXVRES:
	339	case R_TEXHMASK:
	340	case R_TEXVMASK:
	341	case R_DSTFBUF:
	342	case R_DSTHRES:
	343	case R_DSTVRES:
	344	case R_DSTHOFFSET:
	345	case R_DSTVOFFSET:
	346	case R_DSTSQUAREW:
	347	case R_DSTSQUAREH:
	348	case R_ALPHA:
	349	r = s->regs[addr];
	350	break;
	351
	352	default:
	353	error_report("milkymist_tmu2: read access to unknown register 0x"
	354	TARGET_FMT_plx, addr << 2);
	355	break;
	356	}
	357
	358	trace_milkymist_tmu2_memory_read(addr << 2, r);
	359
	360	return r;
	361	}
	362
	363	static void tmu2_check_registers(MilkymistTMU2State *s)
	364	{
	365	if (s->regs[R_BRIGHTNESS] > MAX_BRIGHTNESS) {
6daf194d	366	error_report("milkymist_tmu2: max brightness is %d", MAX_BRIGHTNESS);
0670dadd MW	367	}
	368
	369	if (s->regs[R_ALPHA] > MAX_ALPHA) {
6daf194d	370	error_report("milkymist_tmu2: max alpha is %d", MAX_ALPHA);
0670dadd MW	371	}
	372
	373	if (s->regs[R_VERTICESADDR] & 0x07) {
	374	error_report("milkymist_tmu2: vertex mesh address has to be 64-bit "
6daf194d	375	"aligned");
0670dadd MW	376	}
	377
	378	if (s->regs[R_TEXFBUF] & 0x01) {
	379	error_report("milkymist_tmu2: texture buffer address has to be "
6daf194d	380	"16-bit aligned");
0670dadd MW	381	}
	382	}
	383
a8170e5e	384	static void tmu2_write(void *opaque, hwaddr addr, uint64_t value,
7100453f	385	unsigned size)
0670dadd MW	386	{
	387	MilkymistTMU2State *s = opaque;
	388
	389	trace_milkymist_tmu2_memory_write(addr, value);
	390
	391	addr >>= 2;
	392	switch (addr) {
	393	case R_CTL:
	394	s->regs[addr] = value;
	395	if (value & CTL_START_BUSY) {
	396	tmu2_start(s);
	397	}
	398	break;
	399	case R_BRIGHTNESS:
	400	case R_HMESHLAST:
	401	case R_VMESHLAST:
	402	case R_CHROMAKEY:
	403	case R_VERTICESADDR:
	404	case R_TEXFBUF:
	405	case R_TEXHRES:
	406	case R_TEXVRES:
	407	case R_TEXHMASK:
	408	case R_TEXVMASK:
	409	case R_DSTFBUF:
	410	case R_DSTHRES:
	411	case R_DSTVRES:
	412	case R_DSTHOFFSET:
	413	case R_DSTVOFFSET:
	414	case R_DSTSQUAREW:
	415	case R_DSTSQUAREH:
	416	case R_ALPHA:
	417	s->regs[addr] = value;
	418	break;
	419
	420	default:
	421	error_report("milkymist_tmu2: write access to unknown register 0x"
	422	TARGET_FMT_plx, addr << 2);
	423	break;
	424	}
	425
	426	tmu2_check_registers(s);
	427	}
	428
7100453f MW	429	static const MemoryRegionOps tmu2_mmio_ops = {
	430	.read = tmu2_read,
	431	.write = tmu2_write,
	432	.valid = {
	433	.min_access_size = 4,
	434	.max_access_size = 4,
	435	},
	436	.endianness = DEVICE_NATIVE_ENDIAN,
0670dadd MW	437	};
	438
	439	static void milkymist_tmu2_reset(DeviceState *d)
	440	{
56299135	441	MilkymistTMU2State *s = MILKYMIST_TMU2(d);
0670dadd MW	442	int i;
	443
	444	for (i = 0; i < R_MAX; i++) {
	445	s->regs[i] = 0;
	446	}
	447	}
	448
cf79c64d	449	static void milkymist_tmu2_init(Object *obj)
0670dadd	450	{
cf79c64d XZ	451	MilkymistTMU2State *s = MILKYMIST_TMU2(obj);
cf79c64d XZ	452	SysBusDevice *dev = SYS_BUS_DEVICE(obj);
0670dadd MW	453
	454	sysbus_init_irq(dev, &s->irq);
	455
cf79c64d	456	memory_region_init_io(&s->regs_region, obj, &tmu2_mmio_ops, s,
7100453f	457	"milkymist-tmu2", R_MAX * 4);
750ecd44	458	sysbus_init_mmio(dev, &s->regs_region);
cf79c64d	459	}
0670dadd	460
cf79c64d XZ	461	static void milkymist_tmu2_realize(DeviceState dev, Error *errp)
	462	{
	463	MilkymistTMU2State *s = MILKYMIST_TMU2(dev);
	464
	465	if (tmu2_glx_init(s)) {
	466	error_setg(errp, "tmu2_glx_init failed");
	467	}
0670dadd MW	468	}
	469
	470	static const VMStateDescription vmstate_milkymist_tmu2 = {
	471	.name = "milkymist-tmu2",
	472	.version_id = 1,
	473	.minimum_version_id = 1,
35d08458	474	.fields = (VMStateField[]) {
0670dadd MW	475	VMSTATE_UINT32_ARRAY(regs, MilkymistTMU2State, R_MAX),
	476	VMSTATE_END_OF_LIST()
	477	}
	478	};
	479
999e12bb AL	480	static void milkymist_tmu2_class_init(ObjectClass klass, void data)
999e12bb AL	481	{
39bffca2	482	DeviceClass *dc = DEVICE_CLASS(klass);
999e12bb	483
cf79c64d	484	dc->realize = milkymist_tmu2_realize;
39bffca2 AL	485	dc->reset = milkymist_tmu2_reset;
39bffca2 AL	486	dc->vmsd = &vmstate_milkymist_tmu2;
999e12bb AL	487	}
999e12bb AL	488
8c43a6f0	489	static const TypeInfo milkymist_tmu2_info = {
56299135	490	.name = TYPE_MILKYMIST_TMU2,
39bffca2 AL	491	.parent = TYPE_SYS_BUS_DEVICE,
39bffca2 AL	492	.instance_size = sizeof(MilkymistTMU2State),
cf79c64d	493	.instance_init = milkymist_tmu2_init,
39bffca2	494	.class_init = milkymist_tmu2_class_init,
0670dadd MW	495	};
0670dadd MW	496
83f7d43a	497	static void milkymist_tmu2_register_types(void)
0670dadd	498	{
39bffca2	499	type_register_static(&milkymist_tmu2_info);
0670dadd MW	500	}
0670dadd MW	501
83f7d43a	502	type_init(milkymist_tmu2_register_types)
70cc0c1f PMD	503
	504	DeviceState *milkymist_tmu2_create(hwaddr base, qemu_irq irq)
	505	{
	506	DeviceState *dev;
	507	Display *d;
	508	GLXFBConfig *configs;
	509	int nelements;
	510	int ver_major, ver_minor;
	511
	512	/* check that GLX will work */
	513	d = XOpenDisplay(NULL);
	514	if (d == NULL) {
	515	return NULL;
	516	}
	517
	518	if (!glXQueryVersion(d, &ver_major, &ver_minor)) {
	519	/*
	520	* Yeah, sometimes getting the GLX version can fail.
	521	* Isn't X beautiful?
	522	*/
	523	XCloseDisplay(d);
	524	return NULL;
	525	}
	526
	527	if ((ver_major < 1) \|\| ((ver_major == 1) && (ver_minor < 3))) {
	528	printf("Your GLX version is %d.%d,"
	529	"but TMU emulation needs at least 1.3. TMU disabled.\n",
	530	ver_major, ver_minor);
	531	XCloseDisplay(d);
	532	return NULL;
	533	}
	534
	535	configs = glXChooseFBConfig(d, 0, glx_fbconfig_attr, &nelements);
	536	if (configs == NULL) {
	537	XCloseDisplay(d);
	538	return NULL;
	539	}
	540
	541	XFree(configs);
	542	XCloseDisplay(d);
	543
	544	dev = qdev_create(NULL, TYPE_MILKYMIST_TMU2);
	545	qdev_init_nofail(dev);
	546	sysbus_mmio_map(SYS_BUS_DEVICE(dev), 0, base);
	547	sysbus_connect_irq(SYS_BUS_DEVICE(dev), 0, irq);
	548
	549	return dev;
	550	}