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