[qemu.git] / hw / 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://www.milkymist.org/socdoc/tmu2.pdf
 *
 */

#include "hw.h"
#include "sysbus.h"
#include "trace.h"
#include "qemu-error.h"

#include <X11/Xlib.h>
#include <GL/gl.h>
#include <GL/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;

struct MilkymistTMU2State {
    SysBusDevice busdev;
    CharDriverState *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;
    target_phys_addr_t fb_len;
    void *mesh;
    target_phys_addr_t 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 = 2*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 = 2 * 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 = 2 * 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 uint32_t tmu2_read(void *opaque, target_phys_addr_t addr)
{
    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, target_phys_addr_t addr, uint32_t value)
{
    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 CPUReadMemoryFunc * const tmu2_read_fn[] = {
    NULL,
    NULL,
    &tmu2_read,
};

static CPUWriteMemoryFunc * const tmu2_write_fn[] = {
    NULL,
    NULL,
    &tmu2_write,
};

static void milkymist_tmu2_reset(DeviceState *d)
{
    MilkymistTMU2State *s = container_of(d, MilkymistTMU2State, busdev.qdev);
    int i;

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

static int milkymist_tmu2_init(SysBusDevice *dev)
{
    MilkymistTMU2State *s = FROM_SYSBUS(typeof(*s), dev);
    int tmu2_regs;

    if (tmu2_glx_init(s)) {
        return 1;
    }

    sysbus_init_irq(dev, &s->irq);

    tmu2_regs = cpu_register_io_memory(tmu2_read_fn, tmu2_write_fn, s,
            DEVICE_NATIVE_ENDIAN);
    sysbus_init_mmio(dev, R_MAX * 4, tmu2_regs);

    return 0;
}

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

static SysBusDeviceInfo milkymist_tmu2_info = {
    .init = milkymist_tmu2_init,
    .qdev.name  = "milkymist-tmu2",
    .qdev.size  = sizeof(MilkymistTMU2State),
    .qdev.vmsd  = &vmstate_milkymist_tmu2,
    .qdev.reset = milkymist_tmu2_reset,
};

static void milkymist_tmu2_register(void)
{
    sysbus_register_withprop(&milkymist_tmu2_info);
}

device_init(milkymist_tmu2_register)
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:
	23	* http://www.milkymist.org/socdoc/tmu2.pdf
	24	*
	25	*/
	26
	27	#include "hw.h"
	28	#include "sysbus.h"
	29	#include "trace.h"
	30	#include "qemu-error.h"
	31
	32	#include <X11/Xlib.h>
	33	#include <GL/gl.h>
	34	#include <GL/glx.h>
	35
	36	enum {
	37	R_CTL = 0,
	38	R_HMESHLAST,
	39	R_VMESHLAST,
	40	R_BRIGHTNESS,
	41	R_CHROMAKEY,
	42	R_VERTICESADDR,
	43	R_TEXFBUF,
	44	R_TEXHRES,
	45	R_TEXVRES,
	46	R_TEXHMASK,
	47	R_TEXVMASK,
	48	R_DSTFBUF,
	49	R_DSTHRES,
	50	R_DSTVRES,
	51	R_DSTHOFFSET,
	52	R_DSTVOFFSET,
	53	R_DSTSQUAREW,
	54	R_DSTSQUAREH,
	55	R_ALPHA,
	56	R_MAX
	57	};
	58
	59	enum {
	60	CTL_START_BUSY = (1<<0),
	61	CTL_CHROMAKEY = (1<<1),
	62	};
	63
	64	enum {
65	MAX_BRIGHTNESS = 63,
66	MAX_ALPHA = 63,
67	};
68
69	enum {
70	MESH_MAXSIZE = 128,
71	};
72
73	struct vertex {
74	int x;
75	int y;
541dc0d4	76	} QEMU_PACKED;
0670dadd MW	77
	78	struct MilkymistTMU2State {
	79	SysBusDevice busdev;
	80	CharDriverState *chr;
	81	qemu_irq irq;
	82
	83	uint32_t regs[R_MAX];
	84
	85	Display *dpy;
	86	GLXFBConfig glx_fb_config;
	87	GLXContext glx_context;
	88	};
	89	typedef struct MilkymistTMU2State MilkymistTMU2State;
	90
	91	static const int glx_fbconfig_attr[] = {
	92	GLX_GREEN_SIZE, 5,
	93	GLX_GREEN_SIZE, 6,
	94	GLX_BLUE_SIZE, 5,
	95	None
	96	};
	97
	98	static int tmu2_glx_init(MilkymistTMU2State *s)
	99	{
	100	GLXFBConfig *configs;
	101	int nelements;
	102
	103	s->dpy = XOpenDisplay(NULL); /* FIXME: call XCloseDisplay() */
	104	if (s->dpy == NULL) {
	105	return 1;
	106	}
	107
	108	configs = glXChooseFBConfig(s->dpy, 0, glx_fbconfig_attr, &nelements);
	109	if (configs == NULL) {
	110	return 1;
	111	}
	112
	113	s->glx_fb_config = *configs;
	114	XFree(configs);
	115
	116	/* FIXME: call glXDestroyContext() */
	117	s->glx_context = glXCreateNewContext(s->dpy, s->glx_fb_config,
	118	GLX_RGBA_TYPE, NULL, 1);
	119	if (s->glx_context == NULL) {
	120	return 1;
	121	}
	122
	123	return 0;
	124	}
	125
	126	static void tmu2_gl_map(struct vertex *mesh, int texhres, int texvres,
	127	int hmeshlast, int vmeshlast, int ho, int vo, int sw, int sh)
	128	{
	129	int x, y;
	130	int x0, y0, x1, y1;
	131	int u0, v0, u1, v1, u2, v2, u3, v3;
	132	double xscale = 1.0 / ((double)(64 * texhres));
	133	double yscale = 1.0 / ((double)(64 * texvres));
	134
	135	glLoadIdentity();
	136	glTranslatef(ho, vo, 0);
	137	glEnable(GL_TEXTURE_2D);
	138	glBegin(GL_QUADS);
	139
	140	for (y = 0; y < vmeshlast; y++) {
141	y0 = y * sh;
142	y1 = y0 + sh;
143	for (x = 0; x < hmeshlast; x++) {
144	x0 = x * sw;
145	x1 = x0 + sw;
146
147	u0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].x);
148	v0 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x].y);
149	u1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].x);
150	v1 = be32_to_cpu(mesh[MESH_MAXSIZE * y + x + 1].y);
151	u2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].x);
152	v2 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x + 1].y);
153	u3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].x);
154	v3 = be32_to_cpu(mesh[MESH_MAXSIZE * (y + 1) + x].y);
155
156	glTexCoord2d(((double)u0) * xscale, ((double)v0) * yscale);
157	glVertex3i(x0, y0, 0);
158	glTexCoord2d(((double)u1) * xscale, ((double)v1) * yscale);
159	glVertex3i(x1, y0, 0);
160	glTexCoord2d(((double)u2) * xscale, ((double)v2) * yscale);
161	glVertex3i(x1, y1, 0);
162	glTexCoord2d(((double)u3) * xscale, ((double)v3) * yscale);
163	glVertex3i(x0, y1, 0);
164	}
165	}
166
167	glEnd();
168	}
169
170	static void tmu2_start(MilkymistTMU2State *s)
171	{
172	int pbuffer_attrib[6] = {
173	GLX_PBUFFER_WIDTH,
174	0,
175	GLX_PBUFFER_HEIGHT,
176	0,
177	GLX_PRESERVED_CONTENTS,
178	True
179	};
180
181	GLXPbuffer pbuffer;
182	GLuint texture;
183	void *fb;
184	target_phys_addr_t fb_len;
185	void *mesh;
186	target_phys_addr_t mesh_len;
187	float m;
188
189	trace_milkymist_tmu2_start();
190
191	/* Create and set up a suitable OpenGL context */
192	pbuffer_attrib[1] = s->regs[R_DSTHRES];
193	pbuffer_attrib[3] = s->regs[R_DSTVRES];
194	pbuffer = glXCreatePbuffer(s->dpy, s->glx_fb_config, pbuffer_attrib);
195	glXMakeContextCurrent(s->dpy, pbuffer, pbuffer, s->glx_context);
196
197	/* Fixup endianness. TODO: would it work on BE hosts? */
198	glPixelStorei(GL_UNPACK_SWAP_BYTES, 1);
199	glPixelStorei(GL_PACK_SWAP_BYTES, 1);
200
201	/* Row alignment */
202	glPixelStorei(GL_UNPACK_ALIGNMENT, 2);
203	glPixelStorei(GL_PACK_ALIGNMENT, 2);
204
205	/* Read the QEMU source framebuffer into an OpenGL texture */
206	glGenTextures(1, &texture);
207	glBindTexture(GL_TEXTURE_2D, texture);
208	fb_len = 2s->regs[R_TEXHRES]s->regs[R_TEXVRES];
209	fb = cpu_physical_memory_map(s->regs[R_TEXFBUF], &fb_len, 0);
210	if (fb == NULL) {
211	glDeleteTextures(1, &texture);
212	glXMakeContextCurrent(s->dpy, None, None, NULL);
213	glXDestroyPbuffer(s->dpy, pbuffer);
214	return;
215	}
216	glTexImage2D(GL_TEXTURE_2D, 0, 3, s->regs[R_TEXHRES], s->regs[R_TEXVRES],
217	0, GL_RGB, GL_UNSIGNED_SHORT_5_6_5, fb);
218	cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);
219
220	/* Set up texturing options */
221	/* WARNING:
222	* Many cases of TMU2 masking are not supported by OpenGL.
223	* We only implement the most common ones:
224	* - full bilinear filtering vs. nearest texel
225	* - texture clamping vs. texture wrapping
226	*/
227	if ((s->regs[R_TEXHMASK] & 0x3f) > 0x20) {
228	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
229	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
230	} else {
231	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
232	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
233	}
234	if ((s->regs[R_TEXHMASK] >> 6) & s->regs[R_TEXHRES]) {
235	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
236	} else {
237	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
238	}
239	if ((s->regs[R_TEXVMASK] >> 6) & s->regs[R_TEXVRES]) {
240	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
241	} else {
242	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
243	}
244
245	/* Translucency and decay */
246	glEnable(GL_BLEND);
247	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
248	m = (float)(s->regs[R_BRIGHTNESS] + 1) / 64.0f;
249	glColor4f(m, m, m, (float)(s->regs[R_ALPHA] + 1) / 64.0f);
250
251	/* Read the QEMU dest. framebuffer into the OpenGL framebuffer */
252	fb_len = 2 * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
253	fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 0);
254	if (fb == NULL) {
255	glDeleteTextures(1, &texture);
256	glXMakeContextCurrent(s->dpy, None, None, NULL);
257	glXDestroyPbuffer(s->dpy, pbuffer);
258	return;
259	}
260
261	glDrawPixels(s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
262	GL_UNSIGNED_SHORT_5_6_5, fb);
263	cpu_physical_memory_unmap(fb, fb_len, 0, fb_len);
264	glViewport(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES]);
265	glMatrixMode(GL_PROJECTION);
266	glLoadIdentity();
267	glOrtho(0.0, s->regs[R_DSTHRES], 0.0, s->regs[R_DSTVRES], -1.0, 1.0);
268	glMatrixMode(GL_MODELVIEW);
269
270	/* Map the texture */
271	mesh_len = MESH_MAXSIZEMESH_MAXSIZEsizeof(struct vertex);
272	mesh = cpu_physical_memory_map(s->regs[R_VERTICESADDR], &mesh_len, 0);
273	if (mesh == NULL) {
274	glDeleteTextures(1, &texture);
275	glXMakeContextCurrent(s->dpy, None, None, NULL);
276	glXDestroyPbuffer(s->dpy, pbuffer);
277	return;
278	}
279
280	tmu2_gl_map((struct vertex *)mesh,
281	s->regs[R_TEXHRES], s->regs[R_TEXVRES],
282	s->regs[R_HMESHLAST], s->regs[R_VMESHLAST],
283	s->regs[R_DSTHOFFSET], s->regs[R_DSTVOFFSET],
284	s->regs[R_DSTSQUAREW], s->regs[R_DSTSQUAREH]);
285	cpu_physical_memory_unmap(mesh, mesh_len, 0, mesh_len);
286
287	/* Write back the OpenGL framebuffer to the QEMU framebuffer */
288	fb_len = 2 * s->regs[R_DSTHRES] * s->regs[R_DSTVRES];
289	fb = cpu_physical_memory_map(s->regs[R_DSTFBUF], &fb_len, 1);
290	if (fb == NULL) {
291	glDeleteTextures(1, &texture);
292	glXMakeContextCurrent(s->dpy, None, None, NULL);
293	glXDestroyPbuffer(s->dpy, pbuffer);
294	return;
295	}
296
297	glReadPixels(0, 0, s->regs[R_DSTHRES], s->regs[R_DSTVRES], GL_RGB,
298	GL_UNSIGNED_SHORT_5_6_5, fb);
299	cpu_physical_memory_unmap(fb, fb_len, 1, fb_len);
300
301	/* Free OpenGL allocs */
302	glDeleteTextures(1, &texture);
303	glXMakeContextCurrent(s->dpy, None, None, NULL);
304	glXDestroyPbuffer(s->dpy, pbuffer);
305
306	s->regs[R_CTL] &= ~CTL_START_BUSY;
307
308	trace_milkymist_tmu2_pulse_irq();
309	qemu_irq_pulse(s->irq);
310	}
311
312	static uint32_t tmu2_read(void *opaque, target_phys_addr_t addr)
313	{
314	MilkymistTMU2State *s = opaque;
315	uint32_t r = 0;
316
317	addr >>= 2;
318	switch (addr) {
319	case R_CTL:
320	case R_HMESHLAST:
321	case R_VMESHLAST:
322	case R_BRIGHTNESS:
323	case R_CHROMAKEY:
324	case R_VERTICESADDR:
325	case R_TEXFBUF:
326	case R_TEXHRES:
327	case R_TEXVRES:
328	case R_TEXHMASK:
329	case R_TEXVMASK:
330	case R_DSTFBUF:
331	case R_DSTHRES:
332	case R_DSTVRES:
333	case R_DSTHOFFSET:
334	case R_DSTVOFFSET:
335	case R_DSTSQUAREW:
336	case R_DSTSQUAREH:
337	case R_ALPHA:
338	r = s->regs[addr];
339	break;
340
341	default:
342	error_report("milkymist_tmu2: read access to unknown register 0x"
343	TARGET_FMT_plx, addr << 2);
344	break;
345	}
346
347	trace_milkymist_tmu2_memory_read(addr << 2, r);
348
349	return r;
350	}
351
352	static void tmu2_check_registers(MilkymistTMU2State *s)
353	{
354	if (s->regs[R_BRIGHTNESS] > MAX_BRIGHTNESS) {
6daf194d	355	error_report("milkymist_tmu2: max brightness is %d", MAX_BRIGHTNESS);
0670dadd MW	356	}
	357
	358	if (s->regs[R_ALPHA] > MAX_ALPHA) {
6daf194d	359	error_report("milkymist_tmu2: max alpha is %d", MAX_ALPHA);
0670dadd MW	360	}
	361
	362	if (s->regs[R_VERTICESADDR] & 0x07) {
	363	error_report("milkymist_tmu2: vertex mesh address has to be 64-bit "
6daf194d	364	"aligned");
0670dadd MW	365	}
	366
	367	if (s->regs[R_TEXFBUF] & 0x01) {
	368	error_report("milkymist_tmu2: texture buffer address has to be "
6daf194d	369	"16-bit aligned");
0670dadd MW	370	}
	371	}
	372
	373	static void tmu2_write(void *opaque, target_phys_addr_t addr, uint32_t value)
	374	{
	375	MilkymistTMU2State *s = opaque;
	376
	377	trace_milkymist_tmu2_memory_write(addr, value);
	378
	379	addr >>= 2;
	380	switch (addr) {
	381	case R_CTL:
	382	s->regs[addr] = value;
	383	if (value & CTL_START_BUSY) {
	384	tmu2_start(s);
	385	}
	386	break;
	387	case R_BRIGHTNESS:
	388	case R_HMESHLAST:
	389	case R_VMESHLAST:
	390	case R_CHROMAKEY:
	391	case R_VERTICESADDR:
	392	case R_TEXFBUF:
	393	case R_TEXHRES:
	394	case R_TEXVRES:
	395	case R_TEXHMASK:
	396	case R_TEXVMASK:
	397	case R_DSTFBUF:
	398	case R_DSTHRES:
	399	case R_DSTVRES:
	400	case R_DSTHOFFSET:
	401	case R_DSTVOFFSET:
	402	case R_DSTSQUAREW:
	403	case R_DSTSQUAREH:
	404	case R_ALPHA:
	405	s->regs[addr] = value;
	406	break;
	407
	408	default:
	409	error_report("milkymist_tmu2: write access to unknown register 0x"
	410	TARGET_FMT_plx, addr << 2);
	411	break;
	412	}
	413
	414	tmu2_check_registers(s);
	415	}
	416
	417	static CPUReadMemoryFunc * const tmu2_read_fn[] = {
	418	NULL,
	419	NULL,
	420	&tmu2_read,
	421	};
	422
	423	static CPUWriteMemoryFunc * const tmu2_write_fn[] = {
	424	NULL,
	425	NULL,
	426	&tmu2_write,
	427	};
	428
	429	static void milkymist_tmu2_reset(DeviceState *d)
	430	{
	431	MilkymistTMU2State *s = container_of(d, MilkymistTMU2State, busdev.qdev);
	432	int i;
	433
434	for (i = 0; i < R_MAX; i++) {
435	s->regs[i] = 0;
436	}
437	}
438
439	static int milkymist_tmu2_init(SysBusDevice *dev)
440	{
441	MilkymistTMU2State s = FROM_SYSBUS(typeof(s), dev);
442	int tmu2_regs;
443
444	if (tmu2_glx_init(s)) {
445	return 1;
446	}
447
448	sysbus_init_irq(dev, &s->irq);
449
450	tmu2_regs = cpu_register_io_memory(tmu2_read_fn, tmu2_write_fn, s,
451	DEVICE_NATIVE_ENDIAN);
452	sysbus_init_mmio(dev, R_MAX * 4, tmu2_regs);
453
454	return 0;
455	}
456
457	static const VMStateDescription vmstate_milkymist_tmu2 = {
458	.name = "milkymist-tmu2",
459	.version_id = 1,
460	.minimum_version_id = 1,
461	.minimum_version_id_old = 1,
462	.fields = (VMStateField[]) {
463	VMSTATE_UINT32_ARRAY(regs, MilkymistTMU2State, R_MAX),
464	VMSTATE_END_OF_LIST()
465	}
466	};
467
468	static SysBusDeviceInfo milkymist_tmu2_info = {
469	.init = milkymist_tmu2_init,
470	.qdev.name = "milkymist-tmu2",
471	.qdev.size = sizeof(MilkymistTMU2State),
472	.qdev.vmsd = &vmstate_milkymist_tmu2,
473	.qdev.reset = milkymist_tmu2_reset,
474	};
475
476	static void milkymist_tmu2_register(void)
477	{
478	sysbus_register_withprop(&milkymist_tmu2_info);
479	}
480
481	device_init(milkymist_tmu2_register)