2 * QEMU model of the Milkymist texture mapping unit.
4 * Copyright (c) 2010 Michael Walle <michael@walle.cc>
5 * Copyright (c) 2010 Sebastien Bourdeauducq
6 * <sebastien.bourdeauducq@lekernel.net>
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.
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.
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/>.
22 * Specification available at:
23 * http://milkymist.walle.cc/socdoc/tmu2.pdf
27 #include "qemu/osdep.h"
29 #include "hw/sysbus.h"
30 #include "migration/vmstate.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"
40 #include <epoxy/glx.h>
41 #include "qom/object.h"
67 CTL_START_BUSY
= (1<<0),
68 CTL_CHROMAKEY
= (1<<1),
85 #define TYPE_MILKYMIST_TMU2 "milkymist-tmu2"
86 typedef struct MilkymistTMU2State MilkymistTMU2State
;
87 DECLARE_INSTANCE_CHECKER(MilkymistTMU2State
, MILKYMIST_TMU2
,
90 struct MilkymistTMU2State
{
91 SysBusDevice parent_obj
;
93 MemoryRegion regs_region
;
100 GLXFBConfig glx_fb_config
;
101 GLXContext glx_context
;
104 static const int glx_fbconfig_attr
[] = {
111 static int tmu2_glx_init(MilkymistTMU2State
*s
)
113 GLXFBConfig
*configs
;
116 s
->dpy
= XOpenDisplay(NULL
); /* FIXME: call XCloseDisplay() */
117 if (s
->dpy
== NULL
) {
121 configs
= glXChooseFBConfig(s
->dpy
, 0, glx_fbconfig_attr
, &nelements
);
122 if (configs
== NULL
) {
126 s
->glx_fb_config
= *configs
;
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
) {
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
)
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
));
149 glTranslatef(ho
, vo
, 0);
150 glEnable(GL_TEXTURE_2D
);
153 for (y
= 0; y
< vmeshlast
; y
++) {
156 for (x
= 0; x
< hmeshlast
; x
++) {
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
);
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);
183 static void tmu2_start(MilkymistTMU2State
*s
)
185 int pbuffer_attrib
[6] = {
190 GLX_PRESERVED_CONTENTS
,
202 trace_milkymist_tmu2_start();
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
);
210 /* Fixup endianness. TODO: would it work on BE hosts? */
211 glPixelStorei(GL_UNPACK_SWAP_BYTES
, 1);
212 glPixelStorei(GL_PACK_SWAP_BYTES
, 1);
215 glPixelStorei(GL_UNPACK_ALIGNMENT
, 2);
216 glPixelStorei(GL_PACK_ALIGNMENT
, 2);
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);
224 glDeleteTextures(1, &texture
);
225 glXMakeContextCurrent(s
->dpy
, None
, None
, NULL
);
226 glXDestroyPbuffer(s
->dpy
, pbuffer
);
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
);
233 /* Set up texturing options */
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
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
);
244 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MIN_FILTER
, GL_NEAREST
);
245 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_MAG_FILTER
, GL_NEAREST
);
247 if ((s
->regs
[R_TEXHMASK
] >> 6) & s
->regs
[R_TEXHRES
]) {
248 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_CLAMP
);
250 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_S
, GL_REPEAT
);
252 if ((s
->regs
[R_TEXVMASK
] >> 6) & s
->regs
[R_TEXVRES
]) {
253 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_CLAMP
);
255 glTexParameteri(GL_TEXTURE_2D
, GL_TEXTURE_WRAP_T
, GL_REPEAT
);
258 /* Translucency and decay */
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
);
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);
268 glDeleteTextures(1, &texture
);
269 glXMakeContextCurrent(s
->dpy
, None
, None
, NULL
);
270 glXDestroyPbuffer(s
->dpy
, pbuffer
);
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
);
280 glOrtho(0.0, s
->regs
[R_DSTHRES
], 0.0, s
->regs
[R_DSTVRES
], -1.0, 1.0);
281 glMatrixMode(GL_MODELVIEW
);
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);
287 glDeleteTextures(1, &texture
);
288 glXMakeContextCurrent(s
->dpy
, None
, None
, NULL
);
289 glXDestroyPbuffer(s
->dpy
, pbuffer
);
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
);
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);
304 glDeleteTextures(1, &texture
);
305 glXMakeContextCurrent(s
->dpy
, None
, None
, NULL
);
306 glXDestroyPbuffer(s
->dpy
, pbuffer
);
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
);
314 /* Free OpenGL allocs */
315 glDeleteTextures(1, &texture
);
316 glXMakeContextCurrent(s
->dpy
, None
, None
, NULL
);
317 glXDestroyPbuffer(s
->dpy
, pbuffer
);
319 s
->regs
[R_CTL
] &= ~CTL_START_BUSY
;
321 trace_milkymist_tmu2_pulse_irq();
322 qemu_irq_pulse(s
->irq
);
325 static uint64_t tmu2_read(void *opaque
, hwaddr addr
,
328 MilkymistTMU2State
*s
= opaque
;
356 error_report("milkymist_tmu2: read access to unknown register 0x"
357 TARGET_FMT_plx
, addr
<< 2);
361 trace_milkymist_tmu2_memory_read(addr
<< 2, r
);
366 static void tmu2_check_registers(MilkymistTMU2State
*s
)
368 if (s
->regs
[R_BRIGHTNESS
] > MAX_BRIGHTNESS
) {
369 error_report("milkymist_tmu2: max brightness is %d", MAX_BRIGHTNESS
);
372 if (s
->regs
[R_ALPHA
] > MAX_ALPHA
) {
373 error_report("milkymist_tmu2: max alpha is %d", MAX_ALPHA
);
376 if (s
->regs
[R_VERTICESADDR
] & 0x07) {
377 error_report("milkymist_tmu2: vertex mesh address has to be 64-bit "
381 if (s
->regs
[R_TEXFBUF
] & 0x01) {
382 error_report("milkymist_tmu2: texture buffer address has to be "
387 static void tmu2_write(void *opaque
, hwaddr addr
, uint64_t value
,
390 MilkymistTMU2State
*s
= opaque
;
392 trace_milkymist_tmu2_memory_write(addr
, value
);
397 s
->regs
[addr
] = value
;
398 if (value
& CTL_START_BUSY
) {
420 s
->regs
[addr
] = value
;
424 error_report("milkymist_tmu2: write access to unknown register 0x"
425 TARGET_FMT_plx
, addr
<< 2);
429 tmu2_check_registers(s
);
432 static const MemoryRegionOps tmu2_mmio_ops
= {
436 .min_access_size
= 4,
437 .max_access_size
= 4,
439 .endianness
= DEVICE_NATIVE_ENDIAN
,
442 static void milkymist_tmu2_reset(DeviceState
*d
)
444 MilkymistTMU2State
*s
= MILKYMIST_TMU2(d
);
447 for (i
= 0; i
< R_MAX
; i
++) {
452 static void milkymist_tmu2_init(Object
*obj
)
454 MilkymistTMU2State
*s
= MILKYMIST_TMU2(obj
);
455 SysBusDevice
*dev
= SYS_BUS_DEVICE(obj
);
457 sysbus_init_irq(dev
, &s
->irq
);
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
);
464 static void milkymist_tmu2_realize(DeviceState
*dev
, Error
**errp
)
466 MilkymistTMU2State
*s
= MILKYMIST_TMU2(dev
);
468 if (tmu2_glx_init(s
)) {
469 error_setg(errp
, "tmu2_glx_init failed");
473 static const VMStateDescription vmstate_milkymist_tmu2
= {
474 .name
= "milkymist-tmu2",
476 .minimum_version_id
= 1,
477 .fields
= (VMStateField
[]) {
478 VMSTATE_UINT32_ARRAY(regs
, MilkymistTMU2State
, R_MAX
),
479 VMSTATE_END_OF_LIST()
483 static void milkymist_tmu2_class_init(ObjectClass
*klass
, void *data
)
485 DeviceClass
*dc
= DEVICE_CLASS(klass
);
487 dc
->realize
= milkymist_tmu2_realize
;
488 dc
->reset
= milkymist_tmu2_reset
;
489 dc
->vmsd
= &vmstate_milkymist_tmu2
;
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
,
500 static void milkymist_tmu2_register_types(void)
502 type_register_static(&milkymist_tmu2_info
);
505 type_init(milkymist_tmu2_register_types
)
507 DeviceState
*milkymist_tmu2_create(hwaddr base
, qemu_irq irq
)
511 GLXFBConfig
*configs
;
513 int ver_major
, ver_minor
;
515 /* check that GLX will work */
516 d
= XOpenDisplay(NULL
);
521 if (!glXQueryVersion(d
, &ver_major
, &ver_minor
)) {
523 * Yeah, sometimes getting the GLX version can fail.
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
);
538 configs
= glXChooseFBConfig(d
, 0, glx_fbconfig_attr
, &nelements
);
539 if (configs
== NULL
) {
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
);