hw/display/milkymist-tmu2.c

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