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 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 */ 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 */ 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 */ 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 */ 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 */ 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 */ 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 749 static void macfb_sysbus_reset(DeviceState *d) 750 { 751 MacfbSysBusState *s = MACFB(d); 752 macfb_reset(&s->macfb); 753 } 754 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 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 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 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