haraldwolff/qemu-patch-raspberry4
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity
qemu-patch-raspberry4/hw/display/macfb.c
Mark Cave-Ayland 4e136629f0 macfb: fix VRAM dirty memory region logging 
The macfb VRAM memory region was configured with coalescing rather than dirty
memory logging enabled, causing some areas of the screen not to redraw after
a full screen update.

Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Fixes: 8ac919a065 ("hw/m68k: add Nubus macfb video card")
Reviewed-by: Laurent Vivier <laurent@vivier.eu>
Message-Id: <20220108164147.30813-1-mark.cave-ayland@ilande.co.uk>
Signed-off-by: Laurent Vivier <laurent@vivier.eu>
2022-01-09 12:04:30 +01:00

808 lines
22 KiB
C
Raw Blame History

/*
* QEMU Motorola 680x0 Macintosh Video Card Emulation
* Copyright (c) 2012-2018 Laurent Vivier
*
* some parts from QEMU G364 framebuffer Emulator.
* Copyright (c) 2007-2011 Herve Poussineau
*
* This work is licensed under the terms of the GNU GPL, version 2 or later.
* See the COPYING file in the top-level directory.
*
*/
#include "qemu/osdep.h"
#include "qemu/units.h"
#include "hw/sysbus.h"
#include "ui/console.h"
#include "ui/pixel_ops.h"
#include "hw/nubus/nubus.h"
#include "hw/display/macfb.h"
#include "qapi/error.h"
#include "hw/qdev-properties.h"
#include "migration/vmstate.h"
#include "trace.h"
#define VIDEO_BASE 0x0
#define DAFB_BASE 0x00800000
#define MACFB_PAGE_SIZE 4096
#define MACFB_VRAM_SIZE (4 * MiB)
#define DAFB_MODE_VADDR1 0x0
#define DAFB_MODE_VADDR2 0x4
#define DAFB_MODE_CTRL1 0x8
#define DAFB_MODE_CTRL2 0xc
#define DAFB_MODE_SENSE 0x1c
#define DAFB_INTR_MASK 0x104
#define DAFB_INTR_STAT 0x108
#define DAFB_INTR_CLEAR 0x10c
#define DAFB_RESET 0x200
#define DAFB_LUT 0x213
#define DAFB_INTR_VBL 0x4
/* Vertical Blank period (60.15Hz) */
#define DAFB_INTR_VBL_PERIOD_NS 16625800
/*
* Quadra sense codes taken from Apple Technical Note HW26:
* "Macintosh Quadra Built-In Video". The sense codes and
* extended sense codes have different meanings:
*
* Sense:
* bit 2: SENSE2 (pin 10)
* bit 1: SENSE1 (pin 7)
* bit 0: SENSE0 (pin 4)
*
* 0 = pin tied to ground
* 1 = pin unconnected
*
* Extended Sense:
* bit 2: pins 4-10
* bit 1: pins 10-7
* bit 0: pins 7-4
*
* 0 = pins tied together
* 1 = pins unconnected
*
* Reads from the sense register appear to be active low, i.e. a 1 indicates
* that the pin is tied to ground, a 0 indicates the pin is disconnected.
*
* Writes to the sense register appear to activate pulldowns i.e. a 1 enables
* a pulldown on a particular pin.
*
* The MacOS toolbox appears to use a series of reads and writes to first
* determine if extended sense is to be used, and then check which pins are
* tied together in order to determine the display type.
*/
typedef struct MacFbSense {
uint8_t type;
uint8_t sense;
uint8_t ext_sense;
} MacFbSense;
static MacFbSense macfb_sense_table[] = {
{ MACFB_DISPLAY_APPLE_21_COLOR, 0x0, 0 },
{ MACFB_DISPLAY_APPLE_PORTRAIT, 0x1, 0 },
{ MACFB_DISPLAY_APPLE_12_RGB, 0x2, 0 },
{ MACFB_DISPLAY_APPLE_2PAGE_MONO, 0x3, 0 },
{ MACFB_DISPLAY_NTSC_UNDERSCAN, 0x4, 0 },
{ MACFB_DISPLAY_NTSC_OVERSCAN, 0x4, 0 },
{ MACFB_DISPLAY_APPLE_12_MONO, 0x6, 0 },
{ MACFB_DISPLAY_APPLE_13_RGB, 0x6, 0 },
{ MACFB_DISPLAY_16_COLOR, 0x7, 0x3 },
{ MACFB_DISPLAY_PAL1_UNDERSCAN, 0x7, 0x0 },
{ MACFB_DISPLAY_PAL1_OVERSCAN, 0x7, 0x0 },
{ MACFB_DISPLAY_PAL2_UNDERSCAN, 0x7, 0x6 },
{ MACFB_DISPLAY_PAL2_OVERSCAN, 0x7, 0x6 },
{ MACFB_DISPLAY_VGA, 0x7, 0x5 },
{ MACFB_DISPLAY_SVGA, 0x7, 0x5 },
};
static MacFbMode macfb_mode_table[] = {
{ MACFB_DISPLAY_VGA, 1, 0x100, 0x71e, 640, 480, 0x400, 0x1000 },
{ MACFB_DISPLAY_VGA, 2, 0x100, 0x70e, 640, 480, 0x400, 0x1000 },
{ MACFB_DISPLAY_VGA, 4, 0x100, 0x706, 640, 480, 0x400, 0x1000 },
{ MACFB_DISPLAY_VGA, 8, 0x100, 0x702, 640, 480, 0x400, 0x1000 },
{ MACFB_DISPLAY_VGA, 24, 0x100, 0x7ff, 640, 480, 0x1000, 0x1000 },
{ MACFB_DISPLAY_VGA, 1, 0xd0 , 0x70e, 800, 600, 0x340, 0xe00 },
{ MACFB_DISPLAY_VGA, 2, 0xd0 , 0x706, 800, 600, 0x340, 0xe00 },
{ MACFB_DISPLAY_VGA, 4, 0xd0 , 0x702, 800, 600, 0x340, 0xe00 },
{ MACFB_DISPLAY_VGA, 8, 0xd0, 0x700, 800, 600, 0x340, 0xe00 },
{ MACFB_DISPLAY_VGA, 24, 0x340, 0x100, 800, 600, 0xd00, 0xe00 },
{ MACFB_DISPLAY_APPLE_21_COLOR, 1, 0x90, 0x506, 1152, 870, 0x240, 0x80 },
{ MACFB_DISPLAY_APPLE_21_COLOR, 2, 0x90, 0x502, 1152, 870, 0x240, 0x80 },
{ MACFB_DISPLAY_APPLE_21_COLOR, 4, 0x90, 0x500, 1152, 870, 0x240, 0x80 },
{ MACFB_DISPLAY_APPLE_21_COLOR, 8, 0x120, 0x5ff, 1152, 870, 0x480, 0x80 },
};
typedef void macfb_draw_line_func(MacfbState *s, uint8_t *d, uint32_t addr,
int width);
static inline uint8_t macfb_read_byte(MacfbState *s, uint32_t addr)
{
return s->vram[addr & s->vram_bit_mask];
}
/* 1-bit color */
static void macfb_draw_line1(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
int bit = x & 7;
int idx = (macfb_read_byte(s, addr) >> (7 - bit)) & 1;
r = s->color_palette[idx * 3];
g = s->color_palette[idx * 3 + 1];
b = s->color_palette[idx * 3 + 2];
addr += (bit == 7);
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
/* 2-bit color */
static void macfb_draw_line2(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
int bit = (x & 3);
int idx = (macfb_read_byte(s, addr) >> ((3 - bit) << 1)) & 3;
r = s->color_palette[idx * 3];
g = s->color_palette[idx * 3 + 1];
b = s->color_palette[idx * 3 + 2];
addr += (bit == 3);
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
/* 4-bit color */
static void macfb_draw_line4(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
int bit = x & 1;
int idx = (macfb_read_byte(s, addr) >> ((1 - bit) << 2)) & 15;
r = s->color_palette[idx * 3];
g = s->color_palette[idx * 3 + 1];
b = s->color_palette[idx * 3 + 2];
addr += (bit == 1);
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
/* 8-bit color */
static void macfb_draw_line8(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
r = s->color_palette[macfb_read_byte(s, addr) * 3];
g = s->color_palette[macfb_read_byte(s, addr) * 3 + 1];
b = s->color_palette[macfb_read_byte(s, addr) * 3 + 2];
addr++;
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
/* 16-bit color */
static void macfb_draw_line16(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
uint16_t pixel;
pixel = (macfb_read_byte(s, addr) << 8) | macfb_read_byte(s, addr + 1);
r = ((pixel >> 10) & 0x1f) << 3;
g = ((pixel >> 5) & 0x1f) << 3;
b = (pixel & 0x1f) << 3;
addr += 2;
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
/* 24-bit color */
static void macfb_draw_line24(MacfbState *s, uint8_t *d, uint32_t addr,
int width)
{
uint8_t r, g, b;
int x;
for (x = 0; x < width; x++) {
r = macfb_read_byte(s, addr + 1);
g = macfb_read_byte(s, addr + 2);
b = macfb_read_byte(s, addr + 3);
addr += 4;
*(uint32_t *)d = rgb_to_pixel32(r, g, b);
d += 4;
}
}
enum {
MACFB_DRAW_LINE1,
MACFB_DRAW_LINE2,
MACFB_DRAW_LINE4,
MACFB_DRAW_LINE8,
MACFB_DRAW_LINE16,
MACFB_DRAW_LINE24,
MACFB_DRAW_LINE_NB,
};
static macfb_draw_line_func * const
macfb_draw_line_table[MACFB_DRAW_LINE_NB] = {
macfb_draw_line1,
macfb_draw_line2,
macfb_draw_line4,
macfb_draw_line8,
macfb_draw_line16,
macfb_draw_line24,
};
static int macfb_check_dirty(MacfbState *s, DirtyBitmapSnapshot *snap,
ram_addr_t addr, int len)
{
return memory_region_snapshot_get_dirty(&s->mem_vram, snap, addr, len);
}
static void macfb_draw_graphic(MacfbState *s)
{
DisplaySurface *surface = qemu_console_surface(s->con);
DirtyBitmapSnapshot *snap = NULL;
ram_addr_t page;
uint32_t v = 0;
int y, ymin;
int macfb_stride = s->mode->stride;
macfb_draw_line_func *macfb_draw_line;
switch (s->depth) {
case 1:
v = MACFB_DRAW_LINE1;
break;
case 2:
v = MACFB_DRAW_LINE2;
break;
case 4:
v = MACFB_DRAW_LINE4;
break;
case 8:
v = MACFB_DRAW_LINE8;
break;
case 16:
v = MACFB_DRAW_LINE16;
break;
case 24:
v = MACFB_DRAW_LINE24;
break;
}
macfb_draw_line = macfb_draw_line_table[v];
assert(macfb_draw_line != NULL);
snap = memory_region_snapshot_and_clear_dirty(&s->mem_vram, 0x0,
memory_region_size(&s->mem_vram),
DIRTY_MEMORY_VGA);
ymin = -1;
page = s->mode->offset;
for (y = 0; y < s->height; y++, page += macfb_stride) {
if (macfb_check_dirty(s, snap, page, macfb_stride)) {
uint8_t *data_display;
data_display = surface_data(surface) + y * surface_stride(surface);
macfb_draw_line(s, data_display, page, s->width);
if (ymin < 0) {
ymin = y;
}
} else {
if (ymin >= 0) {
dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
ymin = -1;
}
}
}
if (ymin >= 0) {
dpy_gfx_update(s->con, 0, ymin, s->width, y - ymin);
}
g_free(snap);
}
static void macfb_invalidate_display(void *opaque)
{
MacfbState *s = opaque;
memory_region_set_dirty(&s->mem_vram, 0, MACFB_VRAM_SIZE);
}
static uint32_t macfb_sense_read(MacfbState *s)
{
MacFbSense *macfb_sense;
uint8_t sense;
assert(s->type < ARRAY_SIZE(macfb_sense_table));
macfb_sense = &macfb_sense_table[s->type];
if (macfb_sense->sense == 0x7) {
/* Extended sense */
sense = 0;
if (!(macfb_sense->ext_sense & 1)) {
/* Pins 7-4 together */
if (~s->regs[DAFB_MODE_SENSE >> 2] & 3) {
sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 3;
}
}
if (!(macfb_sense->ext_sense & 2)) {
/* Pins 10-7 together */
if (~s->regs[DAFB_MODE_SENSE >> 2] & 6) {
sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 6;
}
}
if (!(macfb_sense->ext_sense & 4)) {
/* Pins 4-10 together */
if (~s->regs[DAFB_MODE_SENSE >> 2] & 5) {
sense = (~s->regs[DAFB_MODE_SENSE >> 2] & 7) | 5;
}
}
} else {
/* Normal sense */
sense = (~macfb_sense->sense & 7) |
(~s->regs[DAFB_MODE_SENSE >> 2] & 7);
}
trace_macfb_sense_read(sense);
return sense;
}
static void macfb_sense_write(MacfbState *s, uint32_t val)
{
s->regs[DAFB_MODE_SENSE >> 2] = val;
trace_macfb_sense_write(val);
return;
}
static void macfb_update_mode(MacfbState *s)
{
s->width = s->mode->width;
s->height = s->mode->height;
s->depth = s->mode->depth;
trace_macfb_update_mode(s->width, s->height, s->depth);
macfb_invalidate_display(s);
}
static void macfb_mode_write(MacfbState *s)
{
MacFbMode *macfb_mode;
int i;
for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
macfb_mode = &macfb_mode_table[i];
if (s->type != macfb_mode->type) {
continue;
}
if ((s->regs[DAFB_MODE_CTRL1 >> 2] & 0xff) ==
(macfb_mode->mode_ctrl1 & 0xff) &&
(s->regs[DAFB_MODE_CTRL2 >> 2] & 0xff) ==
(macfb_mode->mode_ctrl2 & 0xff)) {
s->mode = macfb_mode;
macfb_update_mode(s);
break;
}
}
}
static MacFbMode *macfb_find_mode(MacfbDisplayType display_type,
uint16_t width, uint16_t height,
uint8_t depth)
{
MacFbMode *macfb_mode;
int i;
for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
macfb_mode = &macfb_mode_table[i];
if (display_type == macfb_mode->type && width == macfb_mode->width &&
height == macfb_mode->height && depth == macfb_mode->depth) {
return macfb_mode;
}
}
return NULL;
}
static gchar *macfb_mode_list(void)
{
GString *list = g_string_new("");
MacFbMode *macfb_mode;
int i;
for (i = 0; i < ARRAY_SIZE(macfb_mode_table); i++) {
macfb_mode = &macfb_mode_table[i];
g_string_append_printf(list, " %dx%dx%d\n", macfb_mode->width,
macfb_mode->height, macfb_mode->depth);
}
return g_string_free(list, FALSE);
}
static void macfb_update_display(void *opaque)
{
MacfbState *s = opaque;
DisplaySurface *surface = qemu_console_surface(s->con);
qemu_flush_coalesced_mmio_buffer();
if (s->width == 0 || s->height == 0) {
return;
}
if (s->width != surface_width(surface) ||
s->height != surface_height(surface)) {
qemu_console_resize(s->con, s->width, s->height);
}
macfb_draw_graphic(s);
}
static void macfb_update_irq(MacfbState *s)
{
uint32_t irq_state = s->irq_state & s->irq_mask;
if (irq_state) {
qemu_irq_raise(s->irq);
} else {
qemu_irq_lower(s->irq);
}
}
static int64_t macfb_next_vbl(void)
{
return (qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + DAFB_INTR_VBL_PERIOD_NS) /
DAFB_INTR_VBL_PERIOD_NS * DAFB_INTR_VBL_PERIOD_NS;
}
static void macfb_vbl_timer(void *opaque)
{
MacfbState *s = opaque;
int64_t next_vbl;
s->irq_state |= DAFB_INTR_VBL;
macfb_update_irq(s);
/* 60 Hz irq */
next_vbl = macfb_next_vbl();
timer_mod(s->vbl_timer, next_vbl);
}
static void macfb_reset(MacfbState *s)
{
int i;
s->palette_current = 0;
for (i = 0; i < 256; i++) {
s->color_palette[i * 3] = 255 - i;
s->color_palette[i * 3 + 1] = 255 - i;
s->color_palette[i * 3 + 2] = 255 - i;
}
memset(s->vram, 0, MACFB_VRAM_SIZE);
macfb_invalidate_display(s);
}
static uint64_t macfb_ctrl_read(void *opaque,
hwaddr addr,
unsigned int size)
{
MacfbState *s = opaque;
uint64_t val = 0;
switch (addr) {
case DAFB_MODE_VADDR1:
case DAFB_MODE_VADDR2:
case DAFB_MODE_CTRL1:
case DAFB_MODE_CTRL2:
val = s->regs[addr >> 2];
break;
case DAFB_INTR_STAT:
val = s->irq_state;
break;
case DAFB_MODE_SENSE:
val = macfb_sense_read(s);
break;
}
trace_macfb_ctrl_read(addr, val, size);
return val;
}
static void macfb_ctrl_write(void *opaque,
hwaddr addr,
uint64_t val,
unsigned int size)
{
MacfbState *s = opaque;
int64_t next_vbl;
switch (addr) {
case DAFB_MODE_VADDR1:
case DAFB_MODE_VADDR2:
s->regs[addr >> 2] = val;
break;
case DAFB_MODE_CTRL1 ... DAFB_MODE_CTRL1 + 3:
case DAFB_MODE_CTRL2 ... DAFB_MODE_CTRL2 + 3:
s->regs[addr >> 2] = val;
if (val) {
macfb_mode_write(s);
}
break;
case DAFB_MODE_SENSE:
macfb_sense_write(s, val);
break;
case DAFB_INTR_MASK:
s->irq_mask = val;
if (val & DAFB_INTR_VBL) {
next_vbl = macfb_next_vbl();
timer_mod(s->vbl_timer, next_vbl);
} else {
timer_del(s->vbl_timer);
}
break;
case DAFB_INTR_CLEAR:
s->irq_state &= ~DAFB_INTR_VBL;
macfb_update_irq(s);
break;
case DAFB_RESET:
s->palette_current = 0;
s->irq_state &= ~DAFB_INTR_VBL;
macfb_update_irq(s);
break;
case DAFB_LUT:
s->color_palette[s->palette_current] = val;
s->palette_current = (s->palette_current + 1) %
ARRAY_SIZE(s->color_palette);
if (s->palette_current % 3) {
macfb_invalidate_display(s);
}
break;
}
trace_macfb_ctrl_write(addr, val, size);
}
static const MemoryRegionOps macfb_ctrl_ops = {
.read = macfb_ctrl_read,
.write = macfb_ctrl_write,
.endianness = DEVICE_BIG_ENDIAN,
.impl.min_access_size = 1,
.impl.max_access_size = 4,
};
static int macfb_post_load(void *opaque, int version_id)
{
macfb_mode_write(opaque);
return 0;
}
static const VMStateDescription vmstate_macfb = {
.name = "macfb",
.version_id = 1,
.minimum_version_id = 1,
.minimum_version_id_old = 1,
.post_load = macfb_post_load,
.fields = (VMStateField[]) {
VMSTATE_UINT8_ARRAY(color_palette, MacfbState, 256 * 3),
VMSTATE_UINT32(palette_current, MacfbState),
VMSTATE_UINT32_ARRAY(regs, MacfbState, MACFB_NUM_REGS),
VMSTATE_END_OF_LIST()
}
};
static const GraphicHwOps macfb_ops = {
.invalidate = macfb_invalidate_display,
.gfx_update = macfb_update_display,
};
static bool macfb_common_realize(DeviceState *dev, MacfbState *s, Error **errp)
{
DisplaySurface *surface;
s->mode = macfb_find_mode(s->type, s->width, s->height, s->depth);
if (!s->mode) {
gchar *list;
error_setg(errp, "unknown display mode: width %d, height %d, depth %d",
s->width, s->height, s->depth);
list = macfb_mode_list();
error_append_hint(errp, "Available modes:\n%s", list);
g_free(list);
return false;
}
s->con = graphic_console_init(dev, 0, &macfb_ops, s);
surface = qemu_console_surface(s->con);
if (surface_bits_per_pixel(surface) != 32) {
error_setg(errp, "unknown host depth %d",
surface_bits_per_pixel(surface));
return false;
}
memory_region_init_io(&s->mem_ctrl, OBJECT(dev), &macfb_ctrl_ops, s,
"macfb-ctrl", 0x1000);
memory_region_init_ram(&s->mem_vram, OBJECT(dev), "macfb-vram",
MACFB_VRAM_SIZE, &error_abort);
memory_region_set_log(&s->mem_vram, true, DIRTY_MEMORY_VGA);
s->vram = memory_region_get_ram_ptr(&s->mem_vram);
s->vram_bit_mask = MACFB_VRAM_SIZE - 1;
s->vbl_timer = timer_new_ns(QEMU_CLOCK_VIRTUAL, macfb_vbl_timer, s);
macfb_update_mode(s);
return true;
}
static void macfb_sysbus_realize(DeviceState *dev, Error **errp)
{
MacfbSysBusState *s = MACFB(dev);
MacfbState *ms = &s->macfb;
if (!macfb_common_realize(dev, ms, errp)) {
return;
}
sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_ctrl);
sysbus_init_mmio(SYS_BUS_DEVICE(s), &ms->mem_vram);
qdev_init_gpio_out(dev, &ms->irq, 1);
}
static void macfb_nubus_set_irq(void *opaque, int n, int level)
{
MacfbNubusState *s = NUBUS_MACFB(opaque);
NubusDevice *nd = NUBUS_DEVICE(s);
nubus_set_irq(nd, level);
}
static void macfb_nubus_realize(DeviceState *dev, Error **errp)
{
NubusDevice *nd = NUBUS_DEVICE(dev);
MacfbNubusState *s = NUBUS_MACFB(dev);
MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
MacfbState *ms = &s->macfb;
ndc->parent_realize(dev, errp);
if (*errp) {
return;
}
if (!macfb_common_realize(dev, ms, errp)) {
return;
}
memory_region_add_subregion(&nd->slot_mem, DAFB_BASE, &ms->mem_ctrl);
memory_region_add_subregion(&nd->slot_mem, VIDEO_BASE, &ms->mem_vram);
ms->irq = qemu_allocate_irq(macfb_nubus_set_irq, s, 0);
}
static void macfb_nubus_unrealize(DeviceState *dev)
{
MacfbNubusState *s = NUBUS_MACFB(dev);
MacfbNubusDeviceClass *ndc = NUBUS_MACFB_GET_CLASS(dev);
MacfbState *ms = &s->macfb;
ndc->parent_unrealize(dev);
qemu_free_irq(ms->irq);
}
static void macfb_sysbus_reset(DeviceState *d)
{
MacfbSysBusState *s = MACFB(d);
macfb_reset(&s->macfb);
}
static void macfb_nubus_reset(DeviceState *d)
{
MacfbNubusState *s = NUBUS_MACFB(d);
macfb_reset(&s->macfb);
}
static Property macfb_sysbus_properties[] = {
DEFINE_PROP_UINT32("width", MacfbSysBusState, macfb.width, 640),
DEFINE_PROP_UINT32("height", MacfbSysBusState, macfb.height, 480),
DEFINE_PROP_UINT8("depth", MacfbSysBusState, macfb.depth, 8),
DEFINE_PROP_UINT8("display", MacfbSysBusState, macfb.type,
MACFB_DISPLAY_VGA),
DEFINE_PROP_END_OF_LIST(),
};
static Property macfb_nubus_properties[] = {
DEFINE_PROP_UINT32("width", MacfbNubusState, macfb.width, 640),
DEFINE_PROP_UINT32("height", MacfbNubusState, macfb.height, 480),
DEFINE_PROP_UINT8("depth", MacfbNubusState, macfb.depth, 8),
DEFINE_PROP_UINT8("display", MacfbNubusState, macfb.type,
MACFB_DISPLAY_VGA),
DEFINE_PROP_END_OF_LIST(),
};
static void macfb_sysbus_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
dc->realize = macfb_sysbus_realize;
dc->desc = "SysBus Macintosh framebuffer";
dc->reset = macfb_sysbus_reset;
dc->vmsd = &vmstate_macfb;
device_class_set_props(dc, macfb_sysbus_properties);
}
static void macfb_nubus_class_init(ObjectClass *klass, void *data)
{
DeviceClass *dc = DEVICE_CLASS(klass);
MacfbNubusDeviceClass *ndc = NUBUS_MACFB_CLASS(klass);
device_class_set_parent_realize(dc, macfb_nubus_realize,
&ndc->parent_realize);
device_class_set_parent_unrealize(dc, macfb_nubus_unrealize,
&ndc->parent_unrealize);
dc->desc = "Nubus Macintosh framebuffer";
dc->reset = macfb_nubus_reset;
dc->vmsd = &vmstate_macfb;
set_bit(DEVICE_CATEGORY_DISPLAY, dc->categories);
device_class_set_props(dc, macfb_nubus_properties);
}
static TypeInfo macfb_sysbus_info = {
.name = TYPE_MACFB,
.parent = TYPE_SYS_BUS_DEVICE,
.instance_size = sizeof(MacfbSysBusState),
.class_init = macfb_sysbus_class_init,
};
static TypeInfo macfb_nubus_info = {
.name = TYPE_NUBUS_MACFB,
.parent = TYPE_NUBUS_DEVICE,
.instance_size = sizeof(MacfbNubusState),
.class_init = macfb_nubus_class_init,
.class_size = sizeof(MacfbNubusDeviceClass),
};
static void macfb_register_types(void)
{
type_register_static(&macfb_sysbus_info);
type_register_static(&macfb_nubus_info);
}
type_init(macfb_register_types)
Reference in a new issue View git blame Copy permalink