1 /*
2 * QEMU Motorola 680x0 Macintosh Video Card Emulation
3 * Copyright (c) 2012-2018 Laurent Vivier
4 *
5 * some parts from QEMU G364 framebuffer Emulator.
6 * Copyright (c) 2007-2011 Herve Poussineau
7 *
8 * This work is licensed under the terms of the GNU GPL, version 2 or later.
9 * See the COPYING file in the top-level directory.
10 *
11 */
12
13 #include "qemu/osdep.h"
14 #include "qemu/units.h"
15 #include "hw/sysbus.h"
16 #include "ui/console.h"
17 #include "ui/pixel_ops.h"
18 #include "hw/nubus/nubus.h"
19 #include "hw/display/macfb.h"
20 #include "qapi/error.h"
21 #include "hw/qdev-properties.h"
22 #include "migration/vmstate.h"
23 #include "trace.h"
24
25 #define VIDEO_BASE 0x0
26 #define DAFB_BASE 0x00800000
27
28 #define MACFB_PAGE_SIZE 4096
29 #define MACFB_VRAM_SIZE (4 * MiB)
30
31 #define DAFB_MODE_VADDR1 0x0
32 #define DAFB_MODE_VADDR2 0x4
33 #define DAFB_MODE_CTRL1 0x8
34 #define DAFB_MODE_CTRL2 0xc
35 #define DAFB_MODE_SENSE 0x1c
36 #define DAFB_INTR_MASK 0x104
37 #define DAFB_INTR_STAT 0x108
38 #define DAFB_INTR_CLEAR 0x10c
39 #define DAFB_LUT_INDEX 0x200
40 #define DAFB_LUT 0x210
41
42 #define DAFB_INTR_VBL 0x4
43
44 /* Vertical Blank period (60.15Hz) */
45 #define DAFB_INTR_VBL_PERIOD_NS 16625800
46
47 /*
48 * Quadra sense codes taken from Apple Technical Note HW26:
49 * "Macintosh Quadra Built-In Video". The sense codes and
50 * extended sense codes have different meanings:
51 *
52 * Sense:
53 * bit 2: SENSE2 (pin 10)
54 * bit 1: SENSE1 (pin 7)
55 * bit 0: SENSE0 (pin 4)
56 *
57 * 0 = pin tied to ground
58 * 1 = pin unconnected
59 *
60 * Extended Sense:
61 * bit 2: pins 4-10
62 * bit 1: pins 10-7
63 * bit 0: pins 7-4
64 *
65 * 0 = pins tied together
66 * 1 = pins unconnected
67 *
68 * Reads from the sense register appear to be active low, i.e. a 1 indicates
69 * that the pin is tied to ground, a 0 indicates the pin is disconnected.
70 *
71 * Writes to the sense register appear to activate pulldowns i.e. a 1 enables
72 * a pulldown on a particular pin.
73 *
74 * The MacOS toolbox appears to use a series of reads and writes to first
75 * determine if extended sense is to be used, and then check which pins are
76 * tied together in order to determine the display type.
77 */
78
79 typedef struct MacFbSense {
80 uint8_t type;
81 uint8_t sense;
82 uint8_t ext_sense;
83 } MacFbSense;
84
85 static MacFbSense macfb_sense_table[] = {
86 { MACFB_DISPLAY_APPLE_21_COLOR, 0x0, 0 },
87 { MACFB_DISPLAY_APPLE_PORTRAIT, 0x1, 0 },
88 { MACFB_DISPLAY_APPLE_12_RGB, 0x2, 0 },
89 { MACFB_DISPLAY_APPLE_2PAGE_MONO, 0x3, 0 },
90 { MACFB_DISPLAY_NTSC_UNDERSCAN, 0x4, 0 },
91 { MACFB_DISPLAY_NTSC_OVERSCAN, 0x4, 0 },
92 { MACFB_DISPLAY_APPLE_12_MONO, 0x6, 0 },
93 { MACFB_DISPLAY_APPLE_13_RGB, 0x6, 0 },
94 { MACFB_DISPLAY_16_COLOR, 0x7, 0x3 },
95 { MACFB_DISPLAY_PAL1_UNDERSCAN, 0x7, 0x0 },
96 { MACFB_DISPLAY_PAL1_OVERSCAN, 0x7, 0x0 },
97 { MACFB_DISPLAY_PAL2_UNDERSCAN, 0x7, 0x6 },
98 { MACFB_DISPLAY_PAL2_OVERSCAN, 0x7, 0x6 },
99 { MACFB_DISPLAY_VGA, 0x7, 0x5 },
100 { MACFB_DISPLAY_SVGA, 0x7, 0x5 },
101 };
102
103 static MacFbMode macfb_mode_table[] = {
104 { MACFB_DISPLAY_VGA, 1, 0x100, 0x71e, 640, 480, 0x400, 0x1000 },
105 { MACFB_DISPLAY_VGA, 2, 0x100, 0x70e, 640, 480, 0x400, 0x1000 },
106 { MACFB_DISPLAY_VGA, 4, 0x100, 0x706, 640, 480, 0x400, 0x1000 },
107 { MACFB_DISPLAY_VGA, 8, 0x100, 0x702, 640, 480, 0x400, 0x1000 },
108 { MACFB_DISPLAY_VGA, 24, 0x100, 0x7ff, 640, 480, 0x1000, 0x1000 },
109 { MACFB_DISPLAY_VGA, 1, 0xd0 , 0x70e, 800, 600, 0x340, 0xe00 },
110 { MACFB_DISPLAY_VGA, 2, 0xd0 , 0x706, 800, 600, 0x340, 0xe00 },
111 { MACFB_DISPLAY_VGA, 4, 0xd0 , 0x702, 800, 600, 0x340, 0xe00 },
112 { MACFB_DISPLAY_VGA, 8, 0xd0, 0x700, 800, 600, 0x340, 0xe00 },
113 { MACFB_DISPLAY_VGA, 24, 0x340, 0x100, 800, 600, 0xd00, 0xe00 },
114 { MACFB_DISPLAY_APPLE_21_COLOR, 1, 0x90, 0x506, 1152, 870, 0x240, 0x80 },
115 { MACFB_DISPLAY_APPLE_21_COLOR, 2, 0x90, 0x502, 1152, 870, 0x240, 0x80 },
116 { MACFB_DISPLAY_APPLE_21_COLOR, 4, 0x90, 0x500, 1152, 870, 0x240, 0x80 },
117 { MACFB_DISPLAY_APPLE_21_COLOR, 8, 0x120, 0x5ff, 1152, 870, 0x480, 0x80 },
118 };
119
120 typedef void macfb_draw_line_func(MacfbState *s, uint8_t *d, uint32_t addr,
121 int width);
122
macfb_read_byte(MacfbState * s,uint32_t addr)123 static inline uint8_t macfb_read_byte(MacfbState *s, uint32_t addr)
124 {
125 return s->vram[addr & s->vram_bit_mask];
126 }
127
128 /* 1-bit color */
macfb_draw_line1(MacfbState * s,uint8_t * d,uint32_t addr,int width)129 static void macfb_draw_line1(MacfbState *s, uint8_t *d, uint32_t addr,
130 int width)
131 {
132 uint8_t r, g, b;
133 int x;
134
135 for (x = 0; x < width; x++) {
136 int bit = x & 7;
137 int idx = (macfb_read_byte(s, addr) >> (7 - bit)) & 1;
138 r = s->color_palette[idx * 3];
139 g = s->color_palette[idx * 3 + 1];
140 b = s->color_palette[idx * 3 + 2];
141 addr += (bit == 7);
142
143 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
144 d += 4;
145 }
146 }
147
148 /* 2-bit color */
macfb_draw_line2(MacfbState * s,uint8_t * d,uint32_t addr,int width)149 static void macfb_draw_line2(MacfbState *s, uint8_t *d, uint32_t addr,
150 int width)
151 {
152 uint8_t r, g, b;
153 int x;
154
155 for (x = 0; x < width; x++) {
156 int bit = (x & 3);
157 int idx = (macfb_read_byte(s, addr) >> ((3 - bit) << 1)) & 3;
158 r = s->color_palette[idx * 3];
159 g = s->color_palette[idx * 3 + 1];
160 b = s->color_palette[idx * 3 + 2];
161 addr += (bit == 3);
162
163 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
164 d += 4;
165 }
166 }
167
168 /* 4-bit color */
macfb_draw_line4(MacfbState * s,uint8_t * d,uint32_t addr,int width)169 static void macfb_draw_line4(MacfbState *s, uint8_t *d, uint32_t addr,
170 int width)
171 {
172 uint8_t r, g, b;
173 int x;
174
175 for (x = 0; x < width; x++) {
176 int bit = x & 1;
177 int idx = (macfb_read_byte(s, addr) >> ((1 - bit) << 2)) & 15;
178 r = s->color_palette[idx * 3];
179 g = s->color_palette[idx * 3 + 1];
180 b = s->color_palette[idx * 3 + 2];
181 addr += (bit == 1);
182
183 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
184 d += 4;
185 }
186 }
187
188 /* 8-bit color */
macfb_draw_line8(MacfbState * s,uint8_t * d,uint32_t addr,int width)189 static void macfb_draw_line8(MacfbState *s, uint8_t *d, uint32_t addr,
190 int width)
191 {
192 uint8_t r, g, b;
193 int x;
194
195 for (x = 0; x < width; x++) {
196 r = s->color_palette[macfb_read_byte(s, addr) * 3];
197 g = s->color_palette[macfb_read_byte(s, addr) * 3 + 1];
198 b = s->color_palette[macfb_read_byte(s, addr) * 3 + 2];
199 addr++;
200
201 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
202 d += 4;
203 }
204 }
205
206 /* 16-bit color */
macfb_draw_line16(MacfbState * s,uint8_t * d,uint32_t addr,int width)207 static void macfb_draw_line16(MacfbState *s, uint8_t *d, uint32_t addr,
208 int width)
209 {
210 uint8_t r, g, b;
211 int x;
212
213 for (x = 0; x < width; x++) {
214 uint16_t pixel;
215 pixel = (macfb_read_byte(s, addr) << 8) | macfb_read_byte(s, addr + 1);
216 r = ((pixel >> 10) & 0x1f) << 3;
217 g = ((pixel >> 5) & 0x1f) << 3;
218 b = (pixel & 0x1f) << 3;
219 addr += 2;
220
221 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
222 d += 4;
223 }
224 }
225
226 /* 24-bit color */
macfb_draw_line24(MacfbState * s,uint8_t * d,uint32_t addr,int width)227 static void macfb_draw_line24(MacfbState *s, uint8_t *d, uint32_t addr,
228 int width)
229 {
230 uint8_t r, g, b;
231 int x;
232
233 for (x = 0; x < width; x++) {
234 r = macfb_read_byte(s, addr + 1);
235 g = macfb_read_byte(s, addr + 2);
236 b = macfb_read_byte(s, addr + 3);
237 addr += 4;
238
239 *(uint32_t *)d = rgb_to_pixel32(r, g, b);
240 d += 4;
241 }
242 }
243
244
245 enum {
246 MACFB_DRAW_LINE1,
247 MACFB_DRAW_LINE2,
248 MACFB_DRAW_LINE4,
249 MACFB_DRAW_LINE8,
250 MACFB_DRAW_LINE16,
251 MACFB_DRAW_LINE24,
252 MACFB_DRAW_LINE_NB,
253 };
254
255 static macfb_draw_line_func * const
256 macfb_draw_line_table[MACFB_DRAW_LINE_NB] = {
257 macfb_draw_line1,
258 macfb_draw_line2,
259 macfb_draw_line4,
260 macfb_draw_line8,
261 macfb_draw_line16,
262 macfb_draw_line24,
263 };
264
macfb_check_dirty(MacfbState * s,DirtyBitmapSnapshot * snap,ram_addr_t addr,int len)265 static int macfb_check_dirty(MacfbState *s, DirtyBitmapSnapshot *snap,
266 ram_addr_t addr, int len)
267 {
268 return memory_region_snapshot_get_dirty(&s->mem_vram, snap, addr, len);
269 }
270
macfb_draw_graphic(MacfbState * s)271 static void macfb_draw_graphic(MacfbState *s)
272 {
273 DisplaySurface *surface = qemu_console_surface(s->con);
274 DirtyBitmapSnapshot *snap = NULL;
275 ram_addr_t page;
276 uint32_t v = 0;
277 int y, ymin;
278 int macfb_stride = s->mode->stride;
279 macfb_draw_line_func *macfb_draw_line;
280
281 switch (s->depth) {
282 case 1:
283 v = MACFB_DRAW_LINE1;
284 break;
285 case 2:
286 v = MACFB_DRAW_LINE2;
287 break;
288 case 4:
289 v = MACFB_DRAW_LINE4;
290 break;
291 case 8:
292 v = MACFB_DRAW_LINE8;
293 break;
294 case 16:
295 v = MACFB_DRAW_LINE16;
296 break;
297 case 24:
298 v = MACFB_DRAW_LINE24;
299 break;
300 }
301
302 macfb_draw_line = macfb_draw_line_table[v];
303 assert(macfb_draw_line != NULL);
304
305 snap = memory_region_snapshot_and_clear_dirty(&s->mem_vram, 0x0,
306 memory_region_size(&s->mem_vram),
307 DIRTY_MEMORY_VGA);
308
309 ymin = -1;
310 page = s->mode->offset;
311 for (y = 0; y < s->height; y++, page += macfb_stride) {
312 if (macfb_check_dirty(s, snap, page, macfb_stride)) {
313 uint8_t *data_display;
314
315 data_display = surface_data(surface) + y * surface_stride(surface);
316 macfb_draw_line(s, data_display, page, s->width);
317
318 if (ymin < 0) {
319 ymin = y;
320 }
321 } else {
322 if (ymin >= 0) {
323 dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
324 ymin = -1;
325 }
326 }
327 }
328
329 if (ymin >= 0) {
330 dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
331 }
332
333 g_free(snap);
334 }
335
macfb_invalidate_display(void * opaque)336 static void macfb_invalidate_display(void *opaque)
337 {
338 MacfbState *s = opaque;
339
340 memory_region_set_dirty(&s->mem_vram, 0, MACFB_VRAM_SIZE);
341 }
342
macfb_sense_read(MacfbState * s)343 static uint32_t macfb_sense_read(MacfbState *s)
344 {
345 MacFbSense *macfb_sense;
346 uint8_t sense;
347
348 assert(s->type < ARRAY_SIZE(macfb_sense_table));
349 macfb_sense = &macfb_sense_table[s->type];
350 if (macfb_sense->sense == 0x7) {
351 /* Extended sense */
352 sense = 0;
353 if (!(macfb_sense->ext_sense & 1)) {
354 /* Pins 7-4 together */
355 if (~s->regs[DAFB_MODE_SENSE >> 2] & 3) {
356 sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 3;
357 }
358 }
359 if (!(macfb_sense->ext_sense & 2)) {
360 /* Pins 10-7 together */
361 if (~s->regs[DAFB_MODE_SENSE >> 2] & 6) {
362 sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 6;
363 }
364 }
365 if (!(macfb_sense->ext_sense & 4)) {
366 /* Pins 4-10 together */
367 if (~s->regs[DAFB_MODE_SENSE >> 2] & 5) {
368 sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 5;
369 }
370 }
371 } else {
372 /* Normal sense */
373 sense = (~macfb_sense->sense & 7) |
374 (~s->regs[DAFB_MODE_SENSE >> 2] & 7);
375 }
376
377 trace_macfb_sense_read(sense);
378 return sense;
379 }
380
macfb_sense_write(MacfbState * s,uint32_t val)381 static void macfb_sense_write(MacfbState *s, uint32_t val)
382 {
383 s->regs[DAFB_MODE_SENSE >> 2] = val;
384
385 trace_macfb_sense_write(val);
386 }
387
macfb_update_mode(MacfbState * s)388 static void macfb_update_mode(MacfbState *s)
389 {
390 s->width = s->mode->width;
391 s->height = s->mode->height;
392 s->depth = s->mode->depth;
393
394 trace_macfb_update_mode(s->width, s->height, s->depth);
395 macfb_invalidate_display(s);
396 }
397
macfb_mode_write(MacfbState * s)398 static void macfb_mode_write(MacfbState *s)
399 {
400 MacFbMode *macfb_mode;
401 int i;
402
403 for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
404 macfb_mode = &macfb_mode_table[i];
405
406 if (s->type != macfb_mode->type) {
407 continue;
408 }
409
410 if ((s->regs[DAFB_MODE_CTRL1 >> 2] & 0xff) ==
411 (macfb_mode->mode_ctrl1 & 0xff) &&
412 (s->regs[DAFB_MODE_CTRL2 >> 2] & 0xff) ==
413 (macfb_mode->mode_ctrl2 & 0xff)) {
414 s->mode = macfb_mode;
415 macfb_update_mode(s);
416 break;
417 }
418 }
419 }
420
macfb_find_mode(MacfbDisplayType display_type,uint16_t width,uint16_t height,uint8_t depth)421 static MacFbMode *macfb_find_mode(MacfbDisplayType display_type,
422 uint16_t width, uint16_t height,
423 uint8_t depth)
424 {
425 MacFbMode *macfb_mode;
426 int i;
427
428 for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
429 macfb_mode = &macfb_mode_table[i];
430
431 if (display_type == macfb_mode->type && width == macfb_mode->width &&
432 height == macfb_mode->height && depth == macfb_mode->depth) {
433 return macfb_mode;
434 }
435 }
436
437 return NULL;
438 }
439
macfb_mode_list(void)440 static gchar *macfb_mode_list(void)
441 {
442 GString *list = g_string_new("");
443 MacFbMode *macfb_mode;
444 int i;
445
446 for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
447 macfb_mode = &macfb_mode_table[i];
448
449 g_string_append_printf(list, " %dx%dx%d\n", macfb_mode->width,
450 macfb_mode->height, macfb_mode->depth);
451 }
452
453 return g_string_free(list, FALSE);
454 }
455
456
macfb_update_display(void * opaque)457 static void macfb_update_display(void *opaque)
458 {
459 MacfbState *s = opaque;
460 DisplaySurface *surface = qemu_console_surface(s->con);
461
462 qemu_flush_coalesced_mmio_buffer();
463
464 if (s->width == 0 || s->height == 0) {
465 return;
466 }
467
468 if (s->width != surface_width(surface) ||
469 s->height != surface_height(surface)) {
470 qemu_console_resize(s->con, s->width, s->height);
471 }
472
473 macfb_draw_graphic(s);
474 }
475
macfb_update_irq(MacfbState * s)476 static void macfb_update_irq(MacfbState *s)
477 {
478 uint32_t irq_state = s->regs[DAFB_INTR_STAT >> 2] &
479 s->regs[DAFB_INTR_MASK >> 2];
480
481 if (irq_state) {
482 qemu_irq_raise(s->irq);
483 } else {
484 qemu_irq_lower(s->irq);
485 }
486 }
487
macfb_next_vbl(void)488 static int64_t macfb_next_vbl(void)
489 {
490 return (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + DAFB_INTR_VBL_PERIOD_NS) /
491 DAFB_INTR_VBL_PERIOD_NS * DAFB_INTR_VBL_PERIOD_NS;
492 }
493
macfb_vbl_timer(void * opaque)494 static void macfb_vbl_timer(void *opaque)
495 {
496 MacfbState *s = opaque;
497 int64_t next_vbl;
498
499 s->regs[DAFB_INTR_STAT >> 2] |= DAFB_INTR_VBL;
500 macfb_update_irq(s);
501
502 /* 60 Hz irq */
503 next_vbl = macfb_next_vbl();
504 timer_mod(s->vbl_timer, next_vbl);
505 }
506
macfb_reset(MacfbState * s)507 static void macfb_reset(MacfbState *s)
508 {
509 int i;
510
511 s->palette_current = 0;
512 for (i = 0; i < 256; i++) {
513 s->color_palette[i * 3] = 255 - i;
514 s->color_palette[i * 3 + 1] = 255 - i;
515 s->color_palette[i * 3 + 2] = 255 - i;
516 }
517 memset(s->vram, 0, MACFB_VRAM_SIZE);
518 macfb_invalidate_display(s);
519 }
520
macfb_ctrl_read(void * opaque,hwaddr addr,unsigned int size)521 static uint64_t macfb_ctrl_read(void *opaque,
522 hwaddr addr,
523 unsigned int size)
524 {
525 MacfbState *s = opaque;
526 uint64_t val = 0;
527
528 switch (addr) {
529 case DAFB_MODE_VADDR1:
530 case DAFB_MODE_VADDR2:
531 case DAFB_MODE_CTRL1:
532 case DAFB_MODE_CTRL2:
533 case DAFB_INTR_STAT:
534 val = s->regs[addr >> 2];
535 break;
536 case DAFB_MODE_SENSE:
537 val = macfb_sense_read(s);
538 break;
539 case DAFB_LUT ... DAFB_LUT + 3:
540 val = s->color_palette[s->palette_current];
541 s->palette_current = (s->palette_current + 1) %
542 ARRAY_SIZE(s->color_palette);
543 break;
544 default:
545 if (addr < MACFB_CTRL_TOPADDR) {
546 val = s->regs[addr >> 2];
547 }
548 }
549
550 trace_macfb_ctrl_read(addr, val, size);
551 return val;
552 }
553
macfb_ctrl_write(void * opaque,hwaddr addr,uint64_t val,unsigned int size)554 static void macfb_ctrl_write(void *opaque,
555 hwaddr addr,
556 uint64_t val,
557 unsigned int size)
558 {
559 MacfbState *s = opaque;
560 int64_t next_vbl;
561
562 switch (addr) {
563 case DAFB_MODE_VADDR1:
564 case DAFB_MODE_VADDR2:
565 s->regs[addr >> 2] = val;
566 break;
567 case DAFB_MODE_CTRL1 ... DAFB_MODE_CTRL1 + 3:
568 case DAFB_MODE_CTRL2 ... DAFB_MODE_CTRL2 + 3:
569 s->regs[addr >> 2] = val;
570 if (val) {
571 macfb_mode_write(s);
572 }
573 break;
574 case DAFB_MODE_SENSE:
575 macfb_sense_write(s, val);
576 break;
577 case DAFB_INTR_MASK:
578 s->regs[addr >> 2] = val;
579 if (val & DAFB_INTR_VBL) {
580 next_vbl = macfb_next_vbl();
581 timer_mod(s->vbl_timer, next_vbl);
582 } else {
583 timer_del(s->vbl_timer);
584 }
585 break;
586 case DAFB_INTR_CLEAR:
587 s->regs[DAFB_INTR_STAT >> 2] &= ~DAFB_INTR_VBL;
588 macfb_update_irq(s);
589 break;
590 case DAFB_LUT_INDEX:
591 s->palette_current = (val & 0xff) * 3;
592 break;
593 case DAFB_LUT ... DAFB_LUT + 3:
594 s->color_palette[s->palette_current] = val & 0xff;
595 s->palette_current = (s->palette_current + 1) %
596 ARRAY_SIZE(s->color_palette);
597 if (s->palette_current % 3) {
598 macfb_invalidate_display(s);
599 }
600 break;
601 default:
602 if (addr < MACFB_CTRL_TOPADDR) {
603 s->regs[addr >> 2] = val;
604 }
605 }
606
607 trace_macfb_ctrl_write(addr, val, size);
608 }
609
610 static const MemoryRegionOps macfb_ctrl_ops = {
611 .read = macfb_ctrl_read,
612 .write = macfb_ctrl_write,
613 .endianness = DEVICE_BIG_ENDIAN,
614 .impl.min_access_size = 1,
615 .impl.max_access_size = 4,
616 };
617
macfb_post_load(void * opaque,int version_id)618 static int macfb_post_load(void *opaque, int version_id)
619 {
620 macfb_mode_write(opaque);
621 return 0;
622 }
623
624 static const VMStateDescription vmstate_macfb = {
625 .name = "macfb",
626 .version_id = 1,
627 .minimum_version_id = 1,
628 .post_load = macfb_post_load,
629 .fields = (const VMStateField[]) {
630 VMSTATE_UINT8(type, MacfbState),
631 VMSTATE_UINT8_ARRAY(color_palette, MacfbState, 256 * 3),
632 VMSTATE_UINT32(palette_current, MacfbState),
633 VMSTATE_UINT32_ARRAY(regs, MacfbState, MACFB_NUM_REGS),
634 VMSTATE_TIMER_PTR(vbl_timer, MacfbState),
635 VMSTATE_END_OF_LIST()
636 }
637 };
638
639 static const GraphicHwOps macfb_ops = {
640 .invalidate = macfb_invalidate_display,
641 .gfx_update = macfb_update_display,
642 };
643
macfb_common_realize(DeviceState * dev,MacfbState * s,Error ** errp)644 static bool macfb_common_realize(DeviceState *dev, MacfbState *s, Error **errp)
645 {
646 DisplaySurface *surface;
647
648 s->mode = macfb_find_mode(s->type, s->width, s->height, s->depth);
649 if (!s->mode) {
650 gchar *list;
651 error_setg(errp, "unknown display mode: width %d, height %d, depth %d",
652 s->width, s->height, s->depth);
653 list = macfb_mode_list();
654 error_append_hint(errp, "Available modes:\n%s", list);
655 g_free(list);
656
657 return false;
658 }
659
660 /*
661 * Set mode control registers to match the mode found above so that
662 * macfb_mode_write() does the right thing if no MacOS toolbox ROM
663 * is present to initialise them
664 */
665 s->regs[DAFB_MODE_CTRL1 >> 2] = s->mode->mode_ctrl1;
666 s->regs[DAFB_MODE_CTRL2 >> 2] = s->mode->mode_ctrl2;
667
668 s->con = graphic_console_init(dev, 0, &macfb_ops, s);
669 surface = qemu_console_surface(s->con);
670
671 if (surface_bits_per_pixel(surface) != 32) {
672 error_setg(errp, "unknown host depth %d",
673 surface_bits_per_pixel(surface));
674 return false;
675 }
676
677 memory_region_init_io(&s->mem_ctrl, OBJECT(dev), &macfb_ctrl_ops, s,
678 "macfb-ctrl", 0x1000);
679
680 memory_region_init_ram(&s->mem_vram, OBJECT(dev), "macfb-vram",
681 MACFB_VRAM_SIZE, &error_abort);
682 memory_region_set_log(&s->mem_vram, true, DIRTY_MEMORY_VGA);
683 s->vram = memory_region_get_ram_ptr(&s->mem_vram);
684 s->vram_bit_mask = MACFB_VRAM_SIZE - 1;
685
686 s->vbl_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, macfb_vbl_timer, s);
687 macfb_update_mode(s);
688 return true;
689 }
690
macfb_sysbus_realize(DeviceState * dev,Error ** errp)691 static void macfb_sysbus_realize(DeviceState *dev, Error **errp)
692 {
693 MacfbSysBusState *s = MACFB(dev);
694 MacfbState *ms = &s->macfb;
695
696 if (!macfb_common_realize(dev, ms, errp)) {
697 return;
698 }
699
700 sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_ctrl);
701 sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_vram);
702
703 qdev_init_gpio_out(dev, &ms->irq, 1);
704 }
705
macfb_nubus_set_irq(void * opaque,int n,int level)706 static void macfb_nubus_set_irq(void *opaque, int n, int level)
707 {
708 MacfbNubusState *s = NUBUS_MACFB(opaque);
709 NubusDevice *nd = NUBUS_DEVICE(s);
710
711 nubus_set_irq(nd, level);
712 }
713
macfb_nubus_realize(DeviceState * dev,Error ** errp)714 static void macfb_nubus_realize(DeviceState *dev, Error **errp)
715 {
716 ERRP_GUARD();
717 NubusDevice *nd = NUBUS_DEVICE(dev);
718 MacfbNubusState *s = NUBUS_MACFB(dev);
719 MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
720 MacfbState *ms = &s->macfb;
721
722 ndc->parent_realize(dev, errp);
723 if (*errp) {
724 return;
725 }
726
727 if (!macfb_common_realize(dev, ms, errp)) {
728 return;
729 }
730
731 memory_region_add_subregion(&nd->slot_mem, DAFB_BASE, &ms->mem_ctrl);
732 memory_region_add_subregion(&nd->slot_mem, VIDEO_BASE, &ms->mem_vram);
733
734 ms->irq = qemu_allocate_irq(macfb_nubus_set_irq, s, 0);
735 }
736
macfb_nubus_unrealize(DeviceState * dev)737 static void macfb_nubus_unrealize(DeviceState *dev)
738 {
739 MacfbNubusState *s = NUBUS_MACFB(dev);
740 MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
741 MacfbState *ms = &s->macfb;
742
743 ndc->parent_unrealize(dev);
744
745 qemu_free_irq(ms->irq);
746 }
747
macfb_sysbus_reset(DeviceState * d)748 static void macfb_sysbus_reset(DeviceState *d)
749 {
750 MacfbSysBusState *s = MACFB(d);
751 macfb_reset(&s->macfb);
752 }
753
macfb_nubus_reset(DeviceState * d)754 static void macfb_nubus_reset(DeviceState *d)
755 {
756 MacfbNubusState *s = NUBUS_MACFB(d);
757 macfb_reset(&s->macfb);
758 }
759
760 static const Property macfb_sysbus_properties[] = {
761 DEFINE_PROP_UINT32("width", MacfbSysBusState, macfb.width, 640),
762 DEFINE_PROP_UINT32("height", MacfbSysBusState, macfb.height, 480),
763 DEFINE_PROP_UINT8("depth", MacfbSysBusState, macfb.depth, 8),
764 DEFINE_PROP_UINT8("display", MacfbSysBusState, macfb.type,
765 MACFB_DISPLAY_VGA),
766 };
767
768 static const VMStateDescription vmstate_macfb_sysbus = {
769 .name = "macfb-sysbus",
770 .version_id = 1,
771 .minimum_version_id = 1,
772 .fields = (const VMStateField[]) {
773 VMSTATE_STRUCT(macfb, MacfbSysBusState, 1, vmstate_macfb, MacfbState),
774 VMSTATE_END_OF_LIST()
775 }
776 };
777
778 static const Property macfb_nubus_properties[] = {
779 DEFINE_PROP_UINT32("width", MacfbNubusState, macfb.width, 640),
780 DEFINE_PROP_UINT32("height", MacfbNubusState, macfb.height, 480),
781 DEFINE_PROP_UINT8("depth", MacfbNubusState, macfb.depth, 8),
782 DEFINE_PROP_UINT8("display", MacfbNubusState, macfb.type,
783 MACFB_DISPLAY_VGA),
784 };
785
786 static const VMStateDescription vmstate_macfb_nubus = {
787 .name = "macfb-nubus",
788 .version_id = 1,
789 .minimum_version_id = 1,
790 .fields = (const VMStateField[]) {
791 VMSTATE_STRUCT(macfb, MacfbNubusState, 1, vmstate_macfb, MacfbState),
792 VMSTATE_END_OF_LIST()
793 }
794 };
795
macfb_sysbus_class_init(ObjectClass * klass,const void * data)796 static void macfb_sysbus_class_init(ObjectClass *klass, const void *data)
797 {
798 DeviceClass *dc = DEVICE_CLASS(klass);
799
800 dc->realize = macfb_sysbus_realize;
801 dc->desc = "SysBus Macintosh framebuffer";
802 device_class_set_legacy_reset(dc, macfb_sysbus_reset);
803 dc->vmsd = &vmstate_macfb_sysbus;
804 device_class_set_props(dc, macfb_sysbus_properties);
805 }
806
macfb_nubus_class_init(ObjectClass * klass,const void * data)807 static void macfb_nubus_class_init(ObjectClass *klass, const void *data)
808 {
809 DeviceClass *dc = DEVICE_CLASS(klass);
810 MacfbNubusDeviceClass *ndc = NUBUS_MACFB_CLASS(klass);
811
812 device_class_set_parent_realize(dc, macfb_nubus_realize,
813 &ndc->parent_realize);
814 device_class_set_parent_unrealize(dc, macfb_nubus_unrealize,
815 &ndc->parent_unrealize);
816 dc->desc = "Nubus Macintosh framebuffer";
817 device_class_set_legacy_reset(dc, macfb_nubus_reset);
818 dc->vmsd = &vmstate_macfb_nubus;
819 set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
820 device_class_set_props(dc, macfb_nubus_properties);
821 }
822
823 static const TypeInfo macfb_sysbus_info = {
824 .name = TYPE_MACFB,
825 .parent = TYPE_SYS_BUS_DEVICE,
826 .instance_size = sizeof(MacfbSysBusState),
827 .class_init = macfb_sysbus_class_init,
828 };
829
830 static const TypeInfo macfb_nubus_info = {
831 .name = TYPE_NUBUS_MACFB,
832 .parent = TYPE_NUBUS_DEVICE,
833 .instance_size = sizeof(MacfbNubusState),
834 .class_init = macfb_nubus_class_init,
835 .class_size = sizeof(MacfbNubusDeviceClass),
836 };
837
macfb_register_types(void)838 static void macfb_register_types(void)
839 {
840 type_register_static(&macfb_sysbus_info);
841 type_register_static(&macfb_nubus_info);
842 }
843
844 type_init(macfb_register_types)
845