Archipelago » qemu

/*

 *  QEMU model of the Milkymist texture mapping unit.

 *

 *  Copyright (c) 2010 Michael Walle <michael@walle.cc>

 *  Copyright (c) 2010 Sebastien Bourdeauducq

 *                       <sebastien.bourdeauducq@lekernel.net>

 *

 * 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;

    MemoryRegion regs_region;

    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 uint64_t tmu2_read(void *opaque, target_phys_addr_t 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, target_phys_addr_t 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 = 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);

    if (tmu2_glx_init(s)) {

        return 1;

    }

    sysbus_init_irq(dev, &s->irq);

    memory_region_init_io(&s->regs_region, &tmu2_mmio_ops, s,

            "milkymist-tmu2", R_MAX * 4);

    sysbus_init_mmio(dev, &s->regs_region);

    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 void milkymist_tmu2_class_init(ObjectClass *klass, void *data)

{

    DeviceClass *dc = DEVICE_CLASS(klass);

    SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass);

    k->init = milkymist_tmu2_init;

    dc->reset = milkymist_tmu2_reset;

    dc->vmsd = &vmstate_milkymist_tmu2;

}

static TypeInfo milkymist_tmu2_info = {

    .name          = "milkymist-tmu2",

    .parent        = TYPE_SYS_BUS_DEVICE,

    .instance_size = sizeof(MilkymistTMU2State),

    .class_init    = milkymist_tmu2_class_init,

};

static void milkymist_tmu2_register(void)

{

    type_register_static(&milkymist_tmu2_info);

}

device_init(milkymist_tmu2_register)