![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to milkymist-tmu2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / hw|
Return to milkymist-tmu2.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / hw |
1.1 root 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;
76: } __attribute__((packed));
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 = 2*s->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_MAXSIZE*MESH_MAXSIZE*sizeof(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) {
355: error_report("milkymist_tmu2: max brightness is %d", MAX_BRIGHTNESS);
356: }
357:
358: if (s->regs[R_ALPHA] > MAX_ALPHA) {
359: error_report("milkymist_tmu2: max alpha is %d", MAX_ALPHA);
360: }
361:
362: if (s->regs[R_VERTICESADDR] & 0x07) {
363: error_report("milkymist_tmu2: vertex mesh address has to be 64-bit "
364: "aligned");
365: }
366:
367: if (s->regs[R_TEXFBUF] & 0x01) {
368: error_report("milkymist_tmu2: texture buffer address has to be "
369: "16-bit aligned");
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)
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.