xref: /openbmc/qemu/hw/display/macfb.c (revision 5aa4a641)
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     return;
387 }
388 
macfb_update_mode(MacfbState * s)389 static void macfb_update_mode(MacfbState *s)
390 {
391     s->width = s->mode->width;
392     s->height = s->mode->height;
393     s->depth = s->mode->depth;
394 
395     trace_macfb_update_mode(s->width, s->height, s->depth);
396     macfb_invalidate_display(s);
397 }
398 
macfb_mode_write(MacfbState * s)399 static void macfb_mode_write(MacfbState *s)
400 {
401     MacFbMode *macfb_mode;
402     int i;
403 
404     for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
405         macfb_mode = &macfb_mode_table[i];
406 
407         if (s->type != macfb_mode->type) {
408             continue;
409         }
410 
411         if ((s->regs[DAFB_MODE_CTRL1 >> 2] & 0xff) ==
412              (macfb_mode->mode_ctrl1 & 0xff) &&
413             (s->regs[DAFB_MODE_CTRL2 >> 2] & 0xff) ==
414              (macfb_mode->mode_ctrl2 & 0xff)) {
415             s->mode = macfb_mode;
416             macfb_update_mode(s);
417             break;
418         }
419     }
420 }
421 
macfb_find_mode(MacfbDisplayType display_type,uint16_t width,uint16_t height,uint8_t depth)422 static MacFbMode *macfb_find_mode(MacfbDisplayType display_type,
423                                   uint16_t width, uint16_t height,
424                                   uint8_t depth)
425 {
426     MacFbMode *macfb_mode;
427     int i;
428 
429     for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
430         macfb_mode = &macfb_mode_table[i];
431 
432         if (display_type == macfb_mode->type && width == macfb_mode->width &&
433                 height == macfb_mode->height && depth == macfb_mode->depth) {
434             return macfb_mode;
435         }
436     }
437 
438     return NULL;
439 }
440 
macfb_mode_list(void)441 static gchar *macfb_mode_list(void)
442 {
443     GString *list = g_string_new("");
444     MacFbMode *macfb_mode;
445     int i;
446 
447     for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
448         macfb_mode = &macfb_mode_table[i];
449 
450         g_string_append_printf(list, "    %dx%dx%d\n", macfb_mode->width,
451                                macfb_mode->height, macfb_mode->depth);
452     }
453 
454     return g_string_free(list, FALSE);
455 }
456 
457 
macfb_update_display(void * opaque)458 static void macfb_update_display(void *opaque)
459 {
460     MacfbState *s = opaque;
461     DisplaySurface *surface = qemu_console_surface(s->con);
462 
463     qemu_flush_coalesced_mmio_buffer();
464 
465     if (s->width == 0 || s->height == 0) {
466         return;
467     }
468 
469     if (s->width != surface_width(surface) ||
470         s->height != surface_height(surface)) {
471         qemu_console_resize(s->con, s->width, s->height);
472     }
473 
474     macfb_draw_graphic(s);
475 }
476 
macfb_update_irq(MacfbState * s)477 static void macfb_update_irq(MacfbState *s)
478 {
479     uint32_t irq_state = s->regs[DAFB_INTR_STAT >> 2] &
480                          s->regs[DAFB_INTR_MASK >> 2];
481 
482     if (irq_state) {
483         qemu_irq_raise(s->irq);
484     } else {
485         qemu_irq_lower(s->irq);
486     }
487 }
488 
macfb_next_vbl(void)489 static int64_t macfb_next_vbl(void)
490 {
491     return (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + DAFB_INTR_VBL_PERIOD_NS) /
492             DAFB_INTR_VBL_PERIOD_NS * DAFB_INTR_VBL_PERIOD_NS;
493 }
494 
macfb_vbl_timer(void * opaque)495 static void macfb_vbl_timer(void *opaque)
496 {
497     MacfbState *s = opaque;
498     int64_t next_vbl;
499 
500     s->regs[DAFB_INTR_STAT >> 2] |= DAFB_INTR_VBL;
501     macfb_update_irq(s);
502 
503     /* 60 Hz irq */
504     next_vbl = macfb_next_vbl();
505     timer_mod(s->vbl_timer, next_vbl);
506 }
507 
macfb_reset(MacfbState * s)508 static void macfb_reset(MacfbState *s)
509 {
510     int i;
511 
512     s->palette_current = 0;
513     for (i = 0; i < 256; i++) {
514         s->color_palette[i * 3] = 255 - i;
515         s->color_palette[i * 3 + 1] = 255 - i;
516         s->color_palette[i * 3 + 2] = 255 - i;
517     }
518     memset(s->vram, 0, MACFB_VRAM_SIZE);
519     macfb_invalidate_display(s);
520 }
521 
macfb_ctrl_read(void * opaque,hwaddr addr,unsigned int size)522 static uint64_t macfb_ctrl_read(void *opaque,
523                                 hwaddr addr,
524                                 unsigned int size)
525 {
526     MacfbState *s = opaque;
527     uint64_t val = 0;
528 
529     switch (addr) {
530     case DAFB_MODE_VADDR1:
531     case DAFB_MODE_VADDR2:
532     case DAFB_MODE_CTRL1:
533     case DAFB_MODE_CTRL2:
534     case DAFB_INTR_STAT:
535         val = s->regs[addr >> 2];
536         break;
537     case DAFB_MODE_SENSE:
538         val = macfb_sense_read(s);
539         break;
540     case DAFB_LUT ... DAFB_LUT + 3:
541         val = s->color_palette[s->palette_current];
542         s->palette_current = (s->palette_current + 1) %
543                              ARRAY_SIZE(s->color_palette);
544         break;
545     default:
546         if (addr < MACFB_CTRL_TOPADDR) {
547             val = s->regs[addr >> 2];
548         }
549     }
550 
551     trace_macfb_ctrl_read(addr, val, size);
552     return val;
553 }
554 
macfb_ctrl_write(void * opaque,hwaddr addr,uint64_t val,unsigned int size)555 static void macfb_ctrl_write(void *opaque,
556                              hwaddr addr,
557                              uint64_t val,
558                              unsigned int size)
559 {
560     MacfbState *s = opaque;
561     int64_t next_vbl;
562 
563     switch (addr) {
564     case DAFB_MODE_VADDR1:
565     case DAFB_MODE_VADDR2:
566         s->regs[addr >> 2] = val;
567         break;
568     case DAFB_MODE_CTRL1 ... DAFB_MODE_CTRL1 + 3:
569     case DAFB_MODE_CTRL2 ... DAFB_MODE_CTRL2 + 3:
570         s->regs[addr >> 2] = val;
571         if (val) {
572             macfb_mode_write(s);
573         }
574         break;
575     case DAFB_MODE_SENSE:
576         macfb_sense_write(s, val);
577         break;
578     case DAFB_INTR_MASK:
579         s->regs[addr >> 2] = val;
580         if (val & DAFB_INTR_VBL) {
581             next_vbl = macfb_next_vbl();
582             timer_mod(s->vbl_timer, next_vbl);
583         } else {
584             timer_del(s->vbl_timer);
585         }
586         break;
587     case DAFB_INTR_CLEAR:
588         s->regs[DAFB_INTR_STAT >> 2] &= ~DAFB_INTR_VBL;
589         macfb_update_irq(s);
590         break;
591     case DAFB_LUT_INDEX:
592         s->palette_current = (val & 0xff) * 3;
593         break;
594     case DAFB_LUT ... DAFB_LUT + 3:
595         s->color_palette[s->palette_current] = val & 0xff;
596         s->palette_current = (s->palette_current + 1) %
597                              ARRAY_SIZE(s->color_palette);
598         if (s->palette_current % 3) {
599             macfb_invalidate_display(s);
600         }
601         break;
602     default:
603         if (addr < MACFB_CTRL_TOPADDR) {
604             s->regs[addr >> 2] = val;
605         }
606     }
607 
608     trace_macfb_ctrl_write(addr, val, size);
609 }
610 
611 static const MemoryRegionOps macfb_ctrl_ops = {
612     .read = macfb_ctrl_read,
613     .write = macfb_ctrl_write,
614     .endianness = DEVICE_BIG_ENDIAN,
615     .impl.min_access_size = 1,
616     .impl.max_access_size = 4,
617 };
618 
macfb_post_load(void * opaque,int version_id)619 static int macfb_post_load(void *opaque, int version_id)
620 {
621     macfb_mode_write(opaque);
622     return 0;
623 }
624 
625 static const VMStateDescription vmstate_macfb = {
626     .name = "macfb",
627     .version_id = 1,
628     .minimum_version_id = 1,
629     .post_load = macfb_post_load,
630     .fields = (const VMStateField[]) {
631         VMSTATE_UINT8(type, MacfbState),
632         VMSTATE_UINT8_ARRAY(color_palette, MacfbState, 256 * 3),
633         VMSTATE_UINT32(palette_current, MacfbState),
634         VMSTATE_UINT32_ARRAY(regs, MacfbState, MACFB_NUM_REGS),
635         VMSTATE_TIMER_PTR(vbl_timer, MacfbState),
636         VMSTATE_END_OF_LIST()
637     }
638 };
639 
640 static const GraphicHwOps macfb_ops = {
641     .invalidate = macfb_invalidate_display,
642     .gfx_update = macfb_update_display,
643 };
644 
macfb_common_realize(DeviceState * dev,MacfbState * s,Error ** errp)645 static bool macfb_common_realize(DeviceState *dev, MacfbState *s, Error **errp)
646 {
647     DisplaySurface *surface;
648 
649     s->mode = macfb_find_mode(s->type, s->width, s->height, s->depth);
650     if (!s->mode) {
651         gchar *list;
652         error_setg(errp, "unknown display mode: width %d, height %d, depth %d",
653                    s->width, s->height, s->depth);
654         list = macfb_mode_list();
655         error_append_hint(errp, "Available modes:\n%s", list);
656         g_free(list);
657 
658         return false;
659     }
660 
661     /*
662      * Set mode control registers to match the mode found above so that
663      * macfb_mode_write() does the right thing if no MacOS toolbox ROM
664      * is present to initialise them
665      */
666     s->regs[DAFB_MODE_CTRL1 >> 2] = s->mode->mode_ctrl1;
667     s->regs[DAFB_MODE_CTRL2 >> 2] = s->mode->mode_ctrl2;
668 
669     s->con = graphic_console_init(dev, 0, &macfb_ops, s);
670     surface = qemu_console_surface(s->con);
671 
672     if (surface_bits_per_pixel(surface) != 32) {
673         error_setg(errp, "unknown host depth %d",
674                    surface_bits_per_pixel(surface));
675         return false;
676     }
677 
678     memory_region_init_io(&s->mem_ctrl, OBJECT(dev), &macfb_ctrl_ops, s,
679                           "macfb-ctrl", 0x1000);
680 
681     memory_region_init_ram(&s->mem_vram, OBJECT(dev), "macfb-vram",
682                            MACFB_VRAM_SIZE, &error_abort);
683     memory_region_set_log(&s->mem_vram, true, DIRTY_MEMORY_VGA);
684     s->vram = memory_region_get_ram_ptr(&s->mem_vram);
685     s->vram_bit_mask = MACFB_VRAM_SIZE - 1;
686 
687     s->vbl_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, macfb_vbl_timer, s);
688     macfb_update_mode(s);
689     return true;
690 }
691 
macfb_sysbus_realize(DeviceState * dev,Error ** errp)692 static void macfb_sysbus_realize(DeviceState *dev, Error **errp)
693 {
694     MacfbSysBusState *s = MACFB(dev);
695     MacfbState *ms = &s->macfb;
696 
697     if (!macfb_common_realize(dev, ms, errp)) {
698         return;
699     }
700 
701     sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_ctrl);
702     sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_vram);
703 
704     qdev_init_gpio_out(dev, &ms->irq, 1);
705 }
706 
macfb_nubus_set_irq(void * opaque,int n,int level)707 static void macfb_nubus_set_irq(void *opaque, int n, int level)
708 {
709     MacfbNubusState *s = NUBUS_MACFB(opaque);
710     NubusDevice *nd = NUBUS_DEVICE(s);
711 
712     nubus_set_irq(nd, level);
713 }
714 
macfb_nubus_realize(DeviceState * dev,Error ** errp)715 static void macfb_nubus_realize(DeviceState *dev, Error **errp)
716 {
717     ERRP_GUARD();
718     NubusDevice *nd = NUBUS_DEVICE(dev);
719     MacfbNubusState *s = NUBUS_MACFB(dev);
720     MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
721     MacfbState *ms = &s->macfb;
722 
723     ndc->parent_realize(dev, errp);
724     if (*errp) {
725         return;
726     }
727 
728     if (!macfb_common_realize(dev, ms, errp)) {
729         return;
730     }
731 
732     memory_region_add_subregion(&nd->slot_mem, DAFB_BASE, &ms->mem_ctrl);
733     memory_region_add_subregion(&nd->slot_mem, VIDEO_BASE, &ms->mem_vram);
734 
735     ms->irq = qemu_allocate_irq(macfb_nubus_set_irq, s, 0);
736 }
737 
macfb_nubus_unrealize(DeviceState * dev)738 static void macfb_nubus_unrealize(DeviceState *dev)
739 {
740     MacfbNubusState *s = NUBUS_MACFB(dev);
741     MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
742     MacfbState *ms = &s->macfb;
743 
744     ndc->parent_unrealize(dev);
745 
746     qemu_free_irq(ms->irq);
747 }
748 
macfb_sysbus_reset(DeviceState * d)749 static void macfb_sysbus_reset(DeviceState *d)
750 {
751     MacfbSysBusState *s = MACFB(d);
752     macfb_reset(&s->macfb);
753 }
754 
macfb_nubus_reset(DeviceState * d)755 static void macfb_nubus_reset(DeviceState *d)
756 {
757     MacfbNubusState *s = NUBUS_MACFB(d);
758     macfb_reset(&s->macfb);
759 }
760 
761 static Property macfb_sysbus_properties[] = {
762     DEFINE_PROP_UINT32("width", MacfbSysBusState, macfb.width, 640),
763     DEFINE_PROP_UINT32("height", MacfbSysBusState, macfb.height, 480),
764     DEFINE_PROP_UINT8("depth", MacfbSysBusState, macfb.depth, 8),
765     DEFINE_PROP_UINT8("display", MacfbSysBusState, macfb.type,
766                       MACFB_DISPLAY_VGA),
767     DEFINE_PROP_END_OF_LIST(),
768 };
769 
770 static const VMStateDescription vmstate_macfb_sysbus = {
771     .name = "macfb-sysbus",
772     .version_id = 1,
773     .minimum_version_id = 1,
774     .fields = (const VMStateField[]) {
775         VMSTATE_STRUCT(macfb, MacfbSysBusState, 1, vmstate_macfb, MacfbState),
776         VMSTATE_END_OF_LIST()
777     }
778 };
779 
780 static Property macfb_nubus_properties[] = {
781     DEFINE_PROP_UINT32("width", MacfbNubusState, macfb.width, 640),
782     DEFINE_PROP_UINT32("height", MacfbNubusState, macfb.height, 480),
783     DEFINE_PROP_UINT8("depth", MacfbNubusState, macfb.depth, 8),
784     DEFINE_PROP_UINT8("display", MacfbNubusState, macfb.type,
785                       MACFB_DISPLAY_VGA),
786     DEFINE_PROP_END_OF_LIST(),
787 };
788 
789 static const VMStateDescription vmstate_macfb_nubus = {
790     .name = "macfb-nubus",
791     .version_id = 1,
792     .minimum_version_id = 1,
793     .fields = (const VMStateField[]) {
794         VMSTATE_STRUCT(macfb, MacfbNubusState, 1, vmstate_macfb, MacfbState),
795         VMSTATE_END_OF_LIST()
796     }
797 };
798 
macfb_sysbus_class_init(ObjectClass * klass,void * data)799 static void macfb_sysbus_class_init(ObjectClass *klass, void *data)
800 {
801     DeviceClass *dc = DEVICE_CLASS(klass);
802 
803     dc->realize = macfb_sysbus_realize;
804     dc->desc = "SysBus Macintosh framebuffer";
805     dc->reset = macfb_sysbus_reset;
806     dc->vmsd = &vmstate_macfb_sysbus;
807     device_class_set_props(dc, macfb_sysbus_properties);
808 }
809 
macfb_nubus_class_init(ObjectClass * klass,void * data)810 static void macfb_nubus_class_init(ObjectClass *klass, void *data)
811 {
812     DeviceClass *dc = DEVICE_CLASS(klass);
813     MacfbNubusDeviceClass *ndc = NUBUS_MACFB_CLASS(klass);
814 
815     device_class_set_parent_realize(dc, macfb_nubus_realize,
816                                     &ndc->parent_realize);
817     device_class_set_parent_unrealize(dc, macfb_nubus_unrealize,
818                                       &ndc->parent_unrealize);
819     dc->desc = "Nubus Macintosh framebuffer";
820     dc->reset = macfb_nubus_reset;
821     dc->vmsd = &vmstate_macfb_nubus;
822     set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
823     device_class_set_props(dc, macfb_nubus_properties);
824 }
825 
826 static const TypeInfo macfb_sysbus_info = {
827     .name          = TYPE_MACFB,
828     .parent        = TYPE_SYS_BUS_DEVICE,
829     .instance_size = sizeof(MacfbSysBusState),
830     .class_init    = macfb_sysbus_class_init,
831 };
832 
833 static const TypeInfo macfb_nubus_info = {
834     .name          = TYPE_NUBUS_MACFB,
835     .parent        = TYPE_NUBUS_DEVICE,
836     .instance_size = sizeof(MacfbNubusState),
837     .class_init    = macfb_nubus_class_init,
838     .class_size    = sizeof(MacfbNubusDeviceClass),
839 };
840 
macfb_register_types(void)841 static void macfb_register_types(void)
842 {
843     type_register_static(&macfb_sysbus_info);
844     type_register_static(&macfb_nubus_info);
845 }
846 
847 type_init(macfb_register_types)
848