hw/display/artist.c

   1 /*
   2  * QEMU HP Artist Emulation
   3  *
   4  * Copyright (c) 2019-2022 Sven Schnelle <svens@stackframe.org>
   5  * Copyright (c) 2022 Helge Deller <deller@gmx.de>
   6  *
   7  * This work is licensed under the terms of the GNU GPL, version 2 or later.
   8  */
   9
  10 #include "qemu/osdep.h"
  11 #include "qemu/error-report.h"
  12 #include "qemu/log.h"
  13 #include "qemu/module.h"
  14 #include "qemu/units.h"
  15 #include "qapi/error.h"
  16 #include "hw/sysbus.h"
  17 #include "hw/loader.h"
  18 #include "hw/qdev-core.h"
  19 #include "hw/qdev-properties.h"
  20 #include "migration/vmstate.h"
  21 #include "ui/console.h"
  22 #include "trace.h"
  23 #include "framebuffer.h"
  24 #include "qom/object.h"
  25
  26 #define TYPE_ARTIST "artist"
  27 OBJECT_DECLARE_SIMPLE_TYPE(ARTISTState, ARTIST)
  28
  29 struct vram_buffer {
  30     MemoryRegion mr;
  31     uint8_t *data;
  32     unsigned int size;
  33     unsigned int width;
  34     unsigned int height;
  35 };
  36
  37 struct ARTISTState {
  38     SysBusDevice parent_obj;
  39
  40     QemuConsole *con;
  41     MemoryRegion vram_mem;
  42     MemoryRegion mem_as_root;
  43     MemoryRegion reg;
  44     MemoryRegionSection fbsection;
  45
  46     void *vram_int_mr;
  47     AddressSpace as;
  48
  49     struct vram_buffer vram_buffer[16];
  50
  51     uint16_t width;
  52     uint16_t height;
  53     uint16_t depth;
  54
  55     uint32_t fg_color;
  56     uint32_t bg_color;
  57
  58     uint32_t vram_char_y;
  59     uint32_t vram_bitmask;
  60
  61     uint32_t vram_start;
  62     uint32_t vram_pos;
  63
  64     uint32_t vram_size;
  65
  66     uint32_t blockmove_source;
  67     uint32_t blockmove_dest;
  68     uint32_t blockmove_size;
  69
  70     uint32_t line_size;
  71     uint32_t line_end;
  72     uint32_t line_xy;
  73     uint32_t line_pattern_start;
  74     uint32_t line_pattern_skip;
  75
  76     uint32_t cursor_pos;
  77     uint32_t cursor_cntrl;
  78
  79     uint32_t cursor_height;
  80     uint32_t cursor_width;
  81
  82     uint32_t plane_mask;
  83
  84     uint32_t reg_100080;
  85     uint32_t horiz_backporch;
  86     uint32_t active_lines_low;
  87     uint32_t misc_video;
  88     uint32_t misc_ctrl;
  89
  90     uint32_t dst_bm_access;
  91     uint32_t src_bm_access;
  92     uint32_t control_plane;
  93     uint32_t transfer_data;
  94     uint32_t image_bitmap_op;
  95
  96     uint32_t font_write1;
  97     uint32_t font_write2;
  98     uint32_t font_write_pos_y;
  99
 100     int draw_line_pattern;
 101 };
 102
 103 /* hardware allows up to 64x64, but we emulate 32x32 only. */
 104 #define NGLE_MAX_SPRITE_SIZE    32
 105
 106 typedef enum {
 107     ARTIST_BUFFER_AP = 1,
 108     ARTIST_BUFFER_OVERLAY = 2,
 109     ARTIST_BUFFER_CURSOR1 = 6,
 110     ARTIST_BUFFER_CURSOR2 = 7,
 111     ARTIST_BUFFER_ATTRIBUTE = 13,
 112     ARTIST_BUFFER_CMAP = 15,
 113 } artist_buffer_t;
 114
 115 typedef enum {
 116     VRAM_IDX = 0x1004a0,
 117     VRAM_BITMASK = 0x1005a0,
 118     VRAM_WRITE_INCR_X = 0x100600,
 119     VRAM_WRITE_INCR_X2 = 0x100604,
 120     VRAM_WRITE_INCR_Y = 0x100620,
 121     VRAM_START = 0x100800,
 122     BLOCK_MOVE_SIZE = 0x100804,
 123     BLOCK_MOVE_SOURCE = 0x100808,
 124     TRANSFER_DATA = 0x100820,
 125     FONT_WRITE_INCR_Y = 0x1008a0,
 126     VRAM_START_TRIGGER = 0x100a00,
 127     VRAM_SIZE_TRIGGER = 0x100a04,
 128     FONT_WRITE_START = 0x100aa0,
 129     BLOCK_MOVE_DEST_TRIGGER = 0x100b00,
 130     BLOCK_MOVE_SIZE_TRIGGER = 0x100b04,
 131     LINE_XY = 0x100ccc,
 132     PATTERN_LINE_START = 0x100ecc,
 133     LINE_SIZE = 0x100e04,
 134     LINE_END = 0x100e44,
 135     DST_SRC_BM_ACCESS = 0x118000,
 136     DST_BM_ACCESS = 0x118004,
 137     SRC_BM_ACCESS = 0x118008,
 138     CONTROL_PLANE = 0x11800c,
 139     FG_COLOR = 0x118010,
 140     BG_COLOR = 0x118014,
 141     PLANE_MASK = 0x118018,
 142     IMAGE_BITMAP_OP = 0x11801c,
 143     CURSOR_POS = 0x300100,      /* reg17 */
 144     CURSOR_CTRL = 0x300104,     /* reg18 */
 145     MISC_VIDEO = 0x300218,      /* reg21 */
 146     MISC_CTRL = 0x300308,       /* reg27 */
 147     HORIZ_BACKPORCH = 0x300200, /* reg19 */
 148     ACTIVE_LINES_LOW = 0x300208,/* reg20 */
 149     FIFO1 = 0x300008,           /* reg34 */
 150     FIFO2 = 0x380008,
 151 } artist_reg_t;
 152
 153 typedef enum {
 154     ARTIST_ROP_CLEAR = 0,
 155     ARTIST_ROP_COPY = 3,
 156     ARTIST_ROP_XOR = 6,
 157     ARTIST_ROP_NOT_DST = 10,
 158     ARTIST_ROP_SET = 15,
 159 } artist_rop_t;
 160
 161 #define REG_NAME(_x) case _x: return " "#_x;
 162 static const char *artist_reg_name(uint64_t addr)
 163 {
 164     switch ((artist_reg_t)addr) {
 165     REG_NAME(VRAM_IDX);
 166     REG_NAME(VRAM_BITMASK);
 167     REG_NAME(VRAM_WRITE_INCR_X);
 168     REG_NAME(VRAM_WRITE_INCR_X2);
 169     REG_NAME(VRAM_WRITE_INCR_Y);
 170     REG_NAME(VRAM_START);
 171     REG_NAME(BLOCK_MOVE_SIZE);
 172     REG_NAME(BLOCK_MOVE_SOURCE);
 173     REG_NAME(FG_COLOR);
 174     REG_NAME(BG_COLOR);
 175     REG_NAME(PLANE_MASK);
 176     REG_NAME(VRAM_START_TRIGGER);
 177     REG_NAME(VRAM_SIZE_TRIGGER);
 178     REG_NAME(BLOCK_MOVE_DEST_TRIGGER);
 179     REG_NAME(BLOCK_MOVE_SIZE_TRIGGER);
 180     REG_NAME(TRANSFER_DATA);
 181     REG_NAME(CONTROL_PLANE);
 182     REG_NAME(IMAGE_BITMAP_OP);
 183     REG_NAME(DST_SRC_BM_ACCESS);
 184     REG_NAME(DST_BM_ACCESS);
 185     REG_NAME(SRC_BM_ACCESS);
 186     REG_NAME(CURSOR_POS);
 187     REG_NAME(CURSOR_CTRL);
 188     REG_NAME(HORIZ_BACKPORCH);
 189     REG_NAME(ACTIVE_LINES_LOW);
 190     REG_NAME(MISC_VIDEO);
 191     REG_NAME(MISC_CTRL);
 192     REG_NAME(LINE_XY);
 193     REG_NAME(PATTERN_LINE_START);
 194     REG_NAME(LINE_SIZE);
 195     REG_NAME(LINE_END);
 196     REG_NAME(FONT_WRITE_INCR_Y);
 197     REG_NAME(FONT_WRITE_START);
 198     REG_NAME(FIFO1);
 199     REG_NAME(FIFO2);
 200     }
 201     return "";
 202 }
 203 #undef REG_NAME
 204
 205 static void artist_invalidate(void *opaque);
 206
 207 /* artist has a fixed line length of 2048 bytes. */
 208 #define ADDR_TO_Y(addr) extract32(addr, 11, 11)
 209 #define ADDR_TO_X(addr) extract32(addr, 0, 11)
 210
 211 static int16_t artist_get_x(uint32_t reg)
 212 {
 213     return reg >> 16;
 214 }
 215
 216 static int16_t artist_get_y(uint32_t reg)
 217 {
 218     return reg & 0xffff;
 219 }
 220
 221 static void artist_invalidate_lines(struct vram_buffer *buf,
 222                                     int starty, int height)
 223 {
 224     int start = starty * buf->width;
 225     int size;
 226
 227     if (starty + height > buf->height) {
 228         height = buf->height - starty;
 229     }
 230
 231     size = height * buf->width;
 232
 233     if (start + size <= buf->size) {
 234         memory_region_set_dirty(&buf->mr, start, size);
 235     }
 236 }
 237
 238 static int vram_write_bufidx(ARTISTState *s)
 239 {
 240     return (s->dst_bm_access >> 12) & 0x0f;
 241 }
 242
 243 static int vram_read_bufidx(ARTISTState *s)
 244 {
 245     return (s->src_bm_access >> 12) & 0x0f;
 246 }
 247
 248 static struct vram_buffer *vram_read_buffer(ARTISTState *s)
 249 {
 250     return &s->vram_buffer[vram_read_bufidx(s)];
 251 }
 252
 253 static struct vram_buffer *vram_write_buffer(ARTISTState *s)
 254 {
 255     return &s->vram_buffer[vram_write_bufidx(s)];
 256 }
 257
 258 static uint8_t artist_get_color(ARTISTState *s)
 259 {
 260     if (s->image_bitmap_op & 2) {
 261         return s->fg_color;
 262     } else {
 263         return s->bg_color;
 264     }
 265 }
 266
 267 static artist_rop_t artist_get_op(ARTISTState *s)
 268 {
 269     return (s->image_bitmap_op >> 8) & 0xf;
 270 }
 271
 272 static void artist_rop8(ARTISTState *s, struct vram_buffer *buf,
 273                         unsigned int offset, uint8_t val)
 274 {
 275     const artist_rop_t op = artist_get_op(s);
 276     uint8_t plane_mask;
 277     uint8_t *dst;
 278
 279     if (offset >= buf->size) {
 280         qemu_log_mask(LOG_GUEST_ERROR,
 281                       "rop8 offset:%u bufsize:%u\n", offset, buf->size);
 282         return;
 283     }
 284     dst = buf->data + offset;
 285     plane_mask = s->plane_mask & 0xff;
 286
 287     switch (op) {
 288     case ARTIST_ROP_CLEAR:
 289         *dst &= ~plane_mask;
 290         break;
 291
 292     case ARTIST_ROP_COPY:
 293         *dst = (*dst & ~plane_mask) | (val & plane_mask);
 294         break;
 295
 296     case ARTIST_ROP_XOR:
 297         *dst ^= val & plane_mask;
 298         break;
 299
 300     case ARTIST_ROP_NOT_DST:
 301         *dst ^= plane_mask;
 302         break;
 303
 304     case ARTIST_ROP_SET:
 305         *dst |= plane_mask;
 306         break;
 307
 308     default:
 309         qemu_log_mask(LOG_UNIMP, "%s: unsupported rop %d\n", __func__, op);
 310         break;
 311     }
 312 }
 313
 314 static void artist_get_cursor_pos(ARTISTState *s, int *x, int *y)
 315 {
 316     /*
 317      * The emulated Artist graphic is like a CRX graphic, and as such
 318      * it's usually fixed at 1280x1024 pixels.
 319      * Other resolutions may work, but no guarantee.
 320      */
 321
 322     unsigned int hbp_times_vi, horizBackPorch;
 323     int16_t xHi, xLo;
 324     const int videoInterleave = 4;
 325     const int pipelineDelay = 4;
 326
 327     /* ignore if uninitialized */
 328     if (s->cursor_pos == 0) {
 329         *x = *y = 0;
 330         return;
 331     }
 332
 333     /*
 334      * Calculate X position based on backporch and interleave values.
 335      * Based on code from Xorg X11R6.6
 336      */
 337     horizBackPorch = ((s->horiz_backporch & 0xff0000) >> 16) +
 338                      ((s->horiz_backporch & 0xff00) >> 8) + 2;
 339     hbp_times_vi = horizBackPorch * videoInterleave;
 340     xHi = s->cursor_pos >> 19;
 341     *x = ((xHi + pipelineDelay) * videoInterleave) - hbp_times_vi;
 342
 343     xLo = (s->cursor_pos >> 16) & 0x07;
 344     *x += ((xLo - hbp_times_vi) & (videoInterleave - 1)) + 8 - 1;
 345
 346     /* subtract cursor offset from cursor control register */
 347     *x -= (s->cursor_cntrl & 0xf0) >> 4;
 348
 349     /* Calculate Y position */
 350     *y = s->height - artist_get_y(s->cursor_pos);
 351     *y -= (s->cursor_cntrl & 0x0f);
 352
 353     if (*x > s->width) {
 354         *x = s->width;
 355     }
 356
 357     if (*y > s->height) {
 358         *y = s->height;
 359     }
 360 }
 361
 362 static inline bool cursor_visible(ARTISTState *s)
 363 {
 364     /* cursor is visible if bit 0x80 is set in cursor_cntrl */
 365     return s->cursor_cntrl & 0x80;
 366 }
 367
 368 static void artist_invalidate_cursor(ARTISTState *s)
 369 {
 370     int x, y;
 371
 372     if (!cursor_visible(s)) {
 373         return;
 374     }
 375
 376     artist_get_cursor_pos(s, &x, &y);
 377     artist_invalidate_lines(&s->vram_buffer[ARTIST_BUFFER_AP],
 378                             y, s->cursor_height);
 379 }
 380
 381 static void block_move(ARTISTState *s,
 382                        unsigned int source_x, unsigned int source_y,
 383                        unsigned int dest_x,   unsigned int dest_y,
 384                        unsigned int width,    unsigned int height)
 385 {
 386     struct vram_buffer *buf;
 387     int line, endline, lineincr, startcolumn, endcolumn, columnincr, column;
 388     unsigned int dst, src;
 389
 390     trace_artist_block_move(source_x, source_y, dest_x, dest_y, width, height);
 391
 392     if (s->control_plane != 0) {
 393         /* We don't support CONTROL_PLANE accesses */
 394         qemu_log_mask(LOG_UNIMP, "%s: CONTROL_PLANE: %08x\n", __func__,
 395                       s->control_plane);
 396         return;
 397     }
 398
 399     buf = &s->vram_buffer[ARTIST_BUFFER_AP];
 400     if (height > buf->height) {
 401         height = buf->height;
 402     }
 403     if (width > buf->width) {
 404         width = buf->width;
 405     }
 406
 407     if (dest_y > source_y) {
 408         /* move down */
 409         line = height - 1;
 410         endline = -1;
 411         lineincr = -1;
 412     } else {
 413         /* move up */
 414         line = 0;
 415         endline = height;
 416         lineincr = 1;
 417     }
 418
 419     if (dest_x > source_x) {
 420         /* move right */
 421         startcolumn = width - 1;
 422         endcolumn = -1;
 423         columnincr = -1;
 424     } else {
 425         /* move left */
 426         startcolumn = 0;
 427         endcolumn = width;
 428         columnincr = 1;
 429     }
 430
 431     for ( ; line != endline; line += lineincr) {
 432         src = source_x + ((line + source_y) * buf->width) + startcolumn;
 433         dst = dest_x + ((line + dest_y) * buf->width) + startcolumn;
 434
 435         for (column = startcolumn; column != endcolumn; column += columnincr) {
 436             if (dst >= buf->size || src >= buf->size) {
 437                 continue;
 438             }
 439             artist_rop8(s, buf, dst, buf->data[src]);
 440             src += columnincr;
 441             dst += columnincr;
 442         }
 443     }
 444
 445     artist_invalidate_lines(buf, dest_y, height);
 446 }
 447
 448 static void fill_window(ARTISTState *s,
 449                         unsigned int startx, unsigned int starty,
 450                         unsigned int width,  unsigned int height)
 451 {
 452     unsigned int offset;
 453     uint8_t color = artist_get_color(s);
 454     struct vram_buffer *buf;
 455     int x, y;
 456
 457     trace_artist_fill_window(startx, starty, width, height,
 458                              s->image_bitmap_op, s->control_plane);
 459
 460     if (s->control_plane != 0) {
 461         /* We don't support CONTROL_PLANE accesses */
 462         qemu_log_mask(LOG_UNIMP, "%s: CONTROL_PLANE: %08x\n", __func__,
 463                       s->control_plane);
 464         return;
 465     }
 466
 467     if (s->reg_100080 == 0x7d) {
 468         /*
 469          * Not sure what this register really does, but
 470          * 0x7d seems to enable autoincremt of the Y axis
 471          * by the current block move height.
 472          */
 473         height = artist_get_y(s->blockmove_size);
 474         s->vram_start += height;
 475     }
 476
 477     buf = &s->vram_buffer[ARTIST_BUFFER_AP];
 478
 479     for (y = starty; y < starty + height; y++) {
 480         offset = y * s->width;
 481
 482         for (x = startx; x < startx + width; x++) {
 483             artist_rop8(s, buf, offset + x, color);
 484         }
 485     }
 486     artist_invalidate_lines(buf, starty, height);
 487 }
 488
 489 static void draw_line(ARTISTState *s,
 490                       unsigned int x1, unsigned int y1,
 491                       unsigned int x2, unsigned int y2,
 492                       bool update_start, int skip_pix, int max_pix)
 493 {
 494     struct vram_buffer *buf = &s->vram_buffer[ARTIST_BUFFER_AP];
 495     uint8_t color;
 496     int dx, dy, t, e, x, y, incy, diago, horiz;
 497     bool c1;
 498
 499     trace_artist_draw_line(x1, y1, x2, y2);
 500
 501     if ((x1 >= buf->width && x2 >= buf->width) ||
 502         (y1 >= buf->height && y2 >= buf->height)) {
 503         return;
 504     }
 505
 506     if (update_start) {
 507         s->vram_start = (x2 << 16) | y2;
 508     }
 509
 510     if (x2 > x1) {
 511         dx = x2 - x1;
 512     } else {
 513         dx = x1 - x2;
 514     }
 515     if (y2 > y1) {
 516         dy = y2 - y1;
 517     } else {
 518         dy = y1 - y2;
 519     }
 520
 521     c1 = false;
 522     if (dy > dx) {
 523         t = y2;
 524         y2 = x2;
 525         x2 = t;
 526
 527         t = y1;
 528         y1 = x1;
 529         x1 = t;
 530
 531         t = dx;
 532         dx = dy;
 533         dy = t;
 534
 535         c1 = true;
 536     }
 537
 538     if (x1 > x2) {
 539         t = y2;
 540         y2 = y1;
 541         y1 = t;
 542
 543         t = x1;
 544         x1 = x2;
 545         x2 = t;
 546     }
 547
 548     horiz = dy << 1;
 549     diago = (dy - dx) << 1;
 550     e = (dy << 1) - dx;
 551
 552     if (y1 <= y2) {
 553         incy = 1;
 554     } else {
 555         incy = -1;
 556     }
 557     x = x1;
 558     y = y1;
 559     color = artist_get_color(s);
 560
 561     do {
 562         unsigned int ofs;
 563
 564         if (c1) {
 565             ofs = x * s->width + y;
 566         } else {
 567             ofs = y * s->width + x;
 568         }
 569
 570         if (skip_pix > 0) {
 571             skip_pix--;
 572         } else {
 573             artist_rop8(s, buf, ofs, color);
 574         }
 575
 576         if (e > 0) {
 577             y  += incy;
 578             e  += diago;
 579         } else {
 580             e += horiz;
 581         }
 582         x++;
 583     } while (x <= x2 && (max_pix == -1 || --max_pix > 0));
 584
 585     if (c1) {
 586         artist_invalidate_lines(buf, x1, x2 - x1);
 587     } else {
 588         artist_invalidate_lines(buf, y1 > y2 ? y2 : y1, x2 - x1);
 589     }
 590 }
 591
 592 static void draw_line_pattern_start(ARTISTState *s)
 593 {
 594     int startx = artist_get_x(s->vram_start);
 595     int starty = artist_get_y(s->vram_start);
 596     int endx = artist_get_x(s->blockmove_size);
 597     int endy = artist_get_y(s->blockmove_size);
 598     int pstart = s->line_pattern_start >> 16;
 599
 600     draw_line(s, startx, starty, endx, endy, false, -1, pstart);
 601     s->line_pattern_skip = pstart;
 602 }
 603
 604 static void draw_line_pattern_next(ARTISTState *s)
 605 {
 606     int startx = artist_get_x(s->vram_start);
 607     int starty = artist_get_y(s->vram_start);
 608     int endx = artist_get_x(s->blockmove_size);
 609     int endy = artist_get_y(s->blockmove_size);
 610     int line_xy = s->line_xy >> 16;
 611
 612     draw_line(s, startx, starty, endx, endy, false, s->line_pattern_skip,
 613               s->line_pattern_skip + line_xy);
 614     s->line_pattern_skip += line_xy;
 615     s->image_bitmap_op ^= 2;
 616 }
 617
 618 static void draw_line_size(ARTISTState *s, bool update_start)
 619 {
 620     int startx = artist_get_x(s->vram_start);
 621     int starty = artist_get_y(s->vram_start);
 622     int endx = artist_get_x(s->line_size);
 623     int endy = artist_get_y(s->line_size);
 624
 625     draw_line(s, startx, starty, endx, endy, update_start, -1, -1);
 626 }
 627
 628 static void draw_line_xy(ARTISTState *s, bool update_start)
 629 {
 630     int startx = artist_get_x(s->vram_start);
 631     int starty = artist_get_y(s->vram_start);
 632     int sizex = artist_get_x(s->blockmove_size);
 633     int sizey = artist_get_y(s->blockmove_size);
 634     int linexy = s->line_xy >> 16;
 635     int endx, endy;
 636
 637     endx = startx;
 638     endy = starty;
 639
 640     if (sizex > 0) {
 641         endx = startx + linexy;
 642     }
 643
 644     if (sizex < 0) {
 645         endx = startx;
 646         startx -= linexy;
 647     }
 648
 649     if (sizey > 0) {
 650         endy = starty + linexy;
 651     }
 652
 653     if (sizey < 0) {
 654         endy = starty;
 655         starty -= linexy;
 656     }
 657
 658     if (startx < 0) {
 659         startx = 0;
 660     }
 661
 662     if (endx < 0) {
 663         endx = 0;
 664     }
 665
 666     if (starty < 0) {
 667         starty = 0;
 668     }
 669
 670     if (endy < 0) {
 671         endy = 0;
 672     }
 673
 674     draw_line(s, startx, starty, endx, endy, false, -1, -1);
 675 }
 676
 677 static void draw_line_end(ARTISTState *s, bool update_start)
 678 {
 679     int startx = artist_get_x(s->vram_start);
 680     int starty = artist_get_y(s->vram_start);
 681     int endx = artist_get_x(s->line_end);
 682     int endy = artist_get_y(s->line_end);
 683
 684     draw_line(s, startx, starty, endx, endy, update_start, -1, -1);
 685 }
 686
 687 static void font_write16(ARTISTState *s, uint16_t val)
 688 {
 689     struct vram_buffer *buf;
 690     uint32_t color = (s->image_bitmap_op & 2) ? s->fg_color : s->bg_color;
 691     uint16_t mask;
 692     int i;
 693
 694     unsigned int startx = artist_get_x(s->vram_start);
 695     unsigned int starty = artist_get_y(s->vram_start) + s->font_write_pos_y;
 696     unsigned int offset = starty * s->width + startx;
 697
 698     buf = &s->vram_buffer[ARTIST_BUFFER_AP];
 699
 700     if (startx >= buf->width || starty >= buf->height ||
 701         offset + 16 >= buf->size) {
 702         return;
 703     }
 704
 705     for (i = 0; i < 16; i++) {
 706         mask = 1 << (15 - i);
 707         if (val & mask) {
 708             artist_rop8(s, buf, offset + i, color);
 709         } else {
 710             if (!(s->image_bitmap_op & 0x20000000)) {
 711                 artist_rop8(s, buf, offset + i, s->bg_color);
 712             }
 713         }
 714     }
 715     artist_invalidate_lines(buf, starty, 1);
 716 }
 717
 718 static void font_write(ARTISTState *s, uint32_t val)
 719 {
 720     font_write16(s, val >> 16);
 721     if (++s->font_write_pos_y == artist_get_y(s->blockmove_size)) {
 722         s->vram_start += (s->blockmove_size & 0xffff0000);
 723         return;
 724     }
 725
 726     font_write16(s, val & 0xffff);
 727     if (++s->font_write_pos_y == artist_get_y(s->blockmove_size)) {
 728         s->vram_start += (s->blockmove_size & 0xffff0000);
 729         return;
 730     }
 731 }
 732
 733 static void combine_write_reg(hwaddr addr, uint64_t val, int size, void *out)
 734 {
 735     /*
 736      * FIXME: is there a qemu helper for this?
 737      */
 738
 739 #if !HOST_BIG_ENDIAN
 740     addr ^= 3;
 741 #endif
 742
 743     switch (size) {
 744     case 1:
 745         *(uint8_t *)(out + (addr & 3)) = val;
 746         break;
 747
 748     case 2:
 749         *(uint16_t *)(out + (addr & 2)) = val;
 750         break;
 751
 752     case 4:
 753         *(uint32_t *)out = val;
 754         break;
 755
 756     default:
 757         qemu_log_mask(LOG_UNIMP, "unsupported write size: %d\n", size);
 758     }
 759 }
 760
 761 static void artist_vram_write4(ARTISTState *s, struct vram_buffer *buf,
 762                                uint32_t offset, uint32_t data)
 763 {
 764     int i;
 765     int mask = s->vram_bitmask >> 28;
 766
 767     for (i = 0; i < 4; i++) {
 768         if (!(s->image_bitmap_op & 0x20000000) || (mask & 8)) {
 769             artist_rop8(s, buf, offset + i, data >> 24);
 770             data <<= 8;
 771             mask <<= 1;
 772         }
 773     }
 774     memory_region_set_dirty(&buf->mr, offset, 3);
 775 }
 776
 777 static void artist_vram_write32(ARTISTState *s, struct vram_buffer *buf,
 778                                 uint32_t offset, int size, uint32_t data,
 779                                 int fg, int bg)
 780 {
 781     uint32_t mask, vram_bitmask = s->vram_bitmask >> ((4 - size) * 8);
 782     int i, pix_count = size * 8;
 783
 784     for (i = 0; i < pix_count && offset + i < buf->size; i++) {
 785         mask = 1 << (pix_count - 1 - i);
 786
 787         if (!(s->image_bitmap_op & 0x20000000) || (vram_bitmask & mask)) {
 788             if (data & mask) {
 789                 artist_rop8(s, buf, offset + i, fg);
 790             } else {
 791                 if (!(s->image_bitmap_op & 0x10000002)) {
 792                     artist_rop8(s, buf, offset + i, bg);
 793                 }
 794             }
 795         }
 796     }
 797     memory_region_set_dirty(&buf->mr, offset, pix_count);
 798 }
 799
 800 static int get_vram_offset(ARTISTState *s, struct vram_buffer *buf,
 801                            int pos, int posy)
 802 {
 803     unsigned int posx, width;
 804
 805     width = buf->width;
 806     posx = ADDR_TO_X(pos);
 807     posy += ADDR_TO_Y(pos);
 808     return posy * width + posx;
 809 }
 810
 811 static int vram_bit_write(ARTISTState *s, uint32_t pos, int posy,
 812                           uint32_t data, int size)
 813 {
 814     struct vram_buffer *buf = vram_write_buffer(s);
 815
 816     switch (s->dst_bm_access >> 16) {
 817     case 0x3ba0:
 818     case 0xbbe0:
 819         artist_vram_write4(s, buf, pos, bswap32(data));
 820         pos += 4;
 821         break;
 822
 823     case 0x1360: /* linux */
 824         artist_vram_write4(s, buf, get_vram_offset(s, buf, pos, posy), data);
 825         pos += 4;
 826         break;
 827
 828     case 0x13a0:
 829         artist_vram_write4(s, buf, get_vram_offset(s, buf, pos >> 2, posy),
 830                            data);
 831         pos += 16;
 832         break;
 833
 834     case 0x2ea0:
 835         artist_vram_write32(s, buf, get_vram_offset(s, buf, pos >> 2, posy),
 836                             size, data, s->fg_color, s->bg_color);
 837         pos += 4;
 838         break;
 839
 840     case 0x28a0:
 841         artist_vram_write32(s, buf, get_vram_offset(s, buf, pos >> 2, posy),
 842                             size, data, 1, 0);
 843         pos += 4;
 844         break;
 845
 846     default:
 847         qemu_log_mask(LOG_UNIMP, "%s: unknown dst bm access %08x\n",
 848                       __func__, s->dst_bm_access);
 849         break;
 850     }
 851
 852     if (vram_write_bufidx(s) == ARTIST_BUFFER_CURSOR1 ||
 853         vram_write_bufidx(s) == ARTIST_BUFFER_CURSOR2) {
 854         artist_invalidate_cursor(s);
 855     }
 856     return pos;
 857 }
 858
 859 static void artist_vram_write(void *opaque, hwaddr addr, uint64_t val,
 860                               unsigned size)
 861 {
 862     ARTISTState *s = opaque;
 863
 864     s->vram_char_y = 0;
 865     trace_artist_vram_write(size, addr, val);
 866     vram_bit_write(opaque, addr, 0, val, size);
 867 }
 868
 869 static uint64_t artist_vram_read(void *opaque, hwaddr addr, unsigned size)
 870 {
 871     ARTISTState *s = opaque;
 872     struct vram_buffer *buf;
 873     unsigned int offset;
 874     uint64_t val;
 875
 876     buf = vram_read_buffer(s);
 877     if (!buf->size) {
 878         return 0;
 879     }
 880
 881     offset = get_vram_offset(s, buf, addr >> 2, 0);
 882
 883     if (offset > buf->size) {
 884         return 0;
 885     }
 886
 887     switch (s->src_bm_access >> 16) {
 888     case 0x3ba0:
 889         val = *(uint32_t *)(buf->data + offset);
 890         break;
 891
 892     case 0x13a0:
 893     case 0x2ea0:
 894         val = bswap32(*(uint32_t *)(buf->data + offset));
 895         break;
 896
 897     default:
 898         qemu_log_mask(LOG_UNIMP, "%s: unknown src bm access %08x\n",
 899                       __func__, s->dst_bm_access);
 900         val = -1ULL;
 901         break;
 902     }
 903     trace_artist_vram_read(size, addr, val);
 904     return val;
 905 }
 906
 907 static void artist_reg_write(void *opaque, hwaddr addr, uint64_t val,
 908                              unsigned size)
 909 {
 910     ARTISTState *s = opaque;
 911     int width, height;
 912     uint64_t oldval;
 913
 914     trace_artist_reg_write(size, addr, artist_reg_name(addr & ~3ULL), val);
 915
 916     switch (addr & ~3ULL) {
 917     case 0x100080:
 918         combine_write_reg(addr, val, size, &s->reg_100080);
 919         break;
 920
 921     case FG_COLOR:
 922         combine_write_reg(addr, val, size, &s->fg_color);
 923         break;
 924
 925     case BG_COLOR:
 926         combine_write_reg(addr, val, size, &s->bg_color);
 927         break;
 928
 929     case VRAM_BITMASK:
 930         combine_write_reg(addr, val, size, &s->vram_bitmask);
 931         break;
 932
 933     case VRAM_WRITE_INCR_Y:
 934         vram_bit_write(s, s->vram_pos, s->vram_char_y++, val, size);
 935         break;
 936
 937     case VRAM_WRITE_INCR_X:
 938     case VRAM_WRITE_INCR_X2:
 939         s->vram_pos = vram_bit_write(s, s->vram_pos, s->vram_char_y, val, size);
 940         break;
 941
 942     case VRAM_IDX:
 943         combine_write_reg(addr, val, size, &s->vram_pos);
 944         s->vram_char_y = 0;
 945         s->draw_line_pattern = 0;
 946         break;
 947
 948     case VRAM_START:
 949         combine_write_reg(addr, val, size, &s->vram_start);
 950         s->draw_line_pattern = 0;
 951         break;
 952
 953     case VRAM_START_TRIGGER:
 954         combine_write_reg(addr, val, size, &s->vram_start);
 955         fill_window(s, artist_get_x(s->vram_start),
 956                     artist_get_y(s->vram_start),
 957                     artist_get_x(s->blockmove_size),
 958                     artist_get_y(s->blockmove_size));
 959         break;
 960
 961     case VRAM_SIZE_TRIGGER:
 962         combine_write_reg(addr, val, size, &s->vram_size);
 963
 964         if (size == 2 && !(addr & 2)) {
 965             height = artist_get_y(s->blockmove_size);
 966         } else {
 967             height = artist_get_y(s->vram_size);
 968         }
 969
 970         if (size == 2 && (addr & 2)) {
 971             width = artist_get_x(s->blockmove_size);
 972         } else {
 973             width = artist_get_x(s->vram_size);
 974         }
 975
 976         fill_window(s, artist_get_x(s->vram_start),
 977                     artist_get_y(s->vram_start),
 978                     width, height);
 979         break;
 980
 981     case LINE_XY:
 982         combine_write_reg(addr, val, size, &s->line_xy);
 983         if (s->draw_line_pattern) {
 984             draw_line_pattern_next(s);
 985         } else {
 986             draw_line_xy(s, true);
 987         }
 988         break;
 989
 990     case PATTERN_LINE_START:
 991         combine_write_reg(addr, val, size, &s->line_pattern_start);
 992         s->draw_line_pattern = 1;
 993         draw_line_pattern_start(s);
 994         break;
 995
 996     case LINE_SIZE:
 997         combine_write_reg(addr, val, size, &s->line_size);
 998         draw_line_size(s, true);
 999         break;
1000
1001     case LINE_END:
1002         combine_write_reg(addr, val, size, &s->line_end);
1003         draw_line_end(s, true);
1004         break;
1005
1006     case BLOCK_MOVE_SIZE:
1007         combine_write_reg(addr, val, size, &s->blockmove_size);
1008         break;
1009
1010     case BLOCK_MOVE_SOURCE:
1011         combine_write_reg(addr, val, size, &s->blockmove_source);
1012         break;
1013
1014     case BLOCK_MOVE_DEST_TRIGGER:
1015         combine_write_reg(addr, val, size, &s->blockmove_dest);
1016
1017         block_move(s, artist_get_x(s->blockmove_source),
1018                    artist_get_y(s->blockmove_source),
1019                    artist_get_x(s->blockmove_dest),
1020                    artist_get_y(s->blockmove_dest),
1021                    artist_get_x(s->blockmove_size),
1022                    artist_get_y(s->blockmove_size));
1023         break;
1024
1025     case BLOCK_MOVE_SIZE_TRIGGER:
1026         combine_write_reg(addr, val, size, &s->blockmove_size);
1027
1028         block_move(s,
1029                    artist_get_x(s->blockmove_source),
1030                    artist_get_y(s->blockmove_source),
1031                    artist_get_x(s->vram_start),
1032                    artist_get_y(s->vram_start),
1033                    artist_get_x(s->blockmove_size),
1034                    artist_get_y(s->blockmove_size));
1035         break;
1036
1037     case PLANE_MASK:
1038         combine_write_reg(addr, val, size, &s->plane_mask);
1039         break;
1040
1041     case DST_SRC_BM_ACCESS:
1042         combine_write_reg(addr, val, size, &s->dst_bm_access);
1043         combine_write_reg(addr, val, size, &s->src_bm_access);
1044         break;
1045
1046     case DST_BM_ACCESS:
1047         combine_write_reg(addr, val, size, &s->dst_bm_access);
1048         break;
1049
1050     case SRC_BM_ACCESS:
1051         combine_write_reg(addr, val, size, &s->src_bm_access);
1052         break;
1053
1054     case CONTROL_PLANE:
1055         combine_write_reg(addr, val, size, &s->control_plane);
1056         break;
1057
1058     case TRANSFER_DATA:
1059         combine_write_reg(addr, val, size, &s->transfer_data);
1060         break;
1061
1062     case HORIZ_BACKPORCH:
1063         /* overwrite HP-UX settings to fix X cursor position. */
1064         val = (NGLE_MAX_SPRITE_SIZE << 16) + (NGLE_MAX_SPRITE_SIZE << 8);
1065         combine_write_reg(addr, val, size, &s->horiz_backporch);
1066         break;
1067
1068     case ACTIVE_LINES_LOW:
1069         combine_write_reg(addr, val, size, &s->active_lines_low);
1070         break;
1071
1072     case MISC_VIDEO:
1073         oldval = s->misc_video;
1074         combine_write_reg(addr, val, size, &s->misc_video);
1075         /* Invalidate and hide screen if graphics signal is turned off. */
1076         if (((oldval & 0x0A000000) == 0x0A000000) &&
1077             ((val & 0x0A000000) != 0x0A000000)) {
1078             artist_invalidate(s);
1079         }
1080         /* Invalidate and redraw screen if graphics signal is turned back on. */
1081         if (((oldval & 0x0A000000) != 0x0A000000) &&
1082             ((val & 0x0A000000) == 0x0A000000)) {
1083             artist_invalidate(s);
1084         }
1085         break;
1086
1087     case MISC_CTRL:
1088         combine_write_reg(addr, val, size, &s->misc_ctrl);
1089         break;
1090
1091     case CURSOR_POS:
1092         artist_invalidate_cursor(s);
1093         combine_write_reg(addr, val, size, &s->cursor_pos);
1094         artist_invalidate_cursor(s);
1095         break;
1096
1097     case CURSOR_CTRL:
1098         combine_write_reg(addr, val, size, &s->cursor_cntrl);
1099         break;
1100
1101     case IMAGE_BITMAP_OP:
1102         combine_write_reg(addr, val, size, &s->image_bitmap_op);
1103         break;
1104
1105     case FONT_WRITE_INCR_Y:
1106         combine_write_reg(addr, val, size, &s->font_write1);
1107         font_write(s, s->font_write1);
1108         break;
1109
1110     case FONT_WRITE_START:
1111         combine_write_reg(addr, val, size, &s->font_write2);
1112         s->font_write_pos_y = 0;
1113         font_write(s, s->font_write2);
1114         break;
1115
1116     case 300104:
1117         break;
1118
1119     default:
1120         qemu_log_mask(LOG_UNIMP, "%s: unknown register: reg=%08" HWADDR_PRIx
1121                       " val=%08" PRIx64 " size=%d\n",
1122                       __func__, addr, val, size);
1123         break;
1124     }
1125 }
1126
1127 static uint64_t combine_read_reg(hwaddr addr, int size, void *in)
1128 {
1129     /*
1130      * FIXME: is there a qemu helper for this?
1131      */
1132
1133 #if !HOST_BIG_ENDIAN
1134     addr ^= 3;
1135 #endif
1136
1137     switch (size) {
1138     case 1:
1139         return *(uint8_t *)(in + (addr & 3));
1140
1141     case 2:
1142         return *(uint16_t *)(in + (addr & 2));
1143
1144     case 4:
1145         return *(uint32_t *)in;
1146
1147     default:
1148         qemu_log_mask(LOG_UNIMP, "unsupported read size: %d\n", size);
1149         return 0;
1150     }
1151 }
1152
1153 static uint64_t artist_reg_read(void *opaque, hwaddr addr, unsigned size)
1154 {
1155     ARTISTState *s = opaque;
1156     uint32_t val = 0;
1157
1158     switch (addr & ~3ULL) {
1159         /* Unknown status registers */
1160     case 0:
1161         break;
1162
1163     case 0x211110:
1164         val = (s->width << 16) | s->height;
1165         if (s->depth == 1) {
1166             val |= 1 << 31;
1167         }
1168         break;
1169
1170     case 0x100000:
1171     case 0x300000:
1172     case 0x300004:
1173     case 0x380000:
1174         break;
1175
1176     case FIFO1:
1177     case FIFO2:
1178         /*
1179          * FIFO ready flag. we're not emulating the FIFOs
1180          * so we're always ready
1181          */
1182         val = 0x10;
1183         break;
1184
1185     case HORIZ_BACKPORCH:
1186         val = s->horiz_backporch;
1187         break;
1188
1189     case ACTIVE_LINES_LOW:
1190         val = s->active_lines_low;
1191         /* activeLinesLo for cursor is in reg20.b.b0 */
1192         val &= ~(0xff << 24);
1193         val |= (s->height & 0xff) << 24;
1194         break;
1195
1196     case MISC_VIDEO:
1197         /* emulate V-blank */
1198         s->misc_video ^= 0x00040000;
1199         /* activeLinesHi for cursor is in reg21.b.b2 */
1200         val = s->misc_video;
1201         val &= ~0xff00UL;
1202         val |= (s->height & 0xff00);
1203         break;
1204
1205     case MISC_CTRL:
1206         val = s->misc_ctrl;
1207         break;
1208
1209     case 0x30023c:
1210         val = 0xac4ffdac;
1211         break;
1212
1213     case 0x380004:
1214         /* 0x02000000 Buserror */
1215         val = 0x6dc20006;
1216         break;
1217
1218     default:
1219         qemu_log_mask(LOG_UNIMP, "%s: unknown register: %08" HWADDR_PRIx
1220                       " size %d\n", __func__, addr, size);
1221         break;
1222     }
1223     val = combine_read_reg(addr, size, &val);
1224     trace_artist_reg_read(size, addr, artist_reg_name(addr & ~3ULL), val);
1225     return val;
1226 }
1227
1228 static const MemoryRegionOps artist_reg_ops = {
1229     .read = artist_reg_read,
1230     .write = artist_reg_write,
1231     .endianness = DEVICE_NATIVE_ENDIAN,
1232     .impl.min_access_size = 1,
1233     .impl.max_access_size = 4,
1234 };
1235
1236 static const MemoryRegionOps artist_vram_ops = {
1237     .read = artist_vram_read,
1238     .write = artist_vram_write,
1239     .endianness = DEVICE_NATIVE_ENDIAN,
1240     .impl.min_access_size = 1,
1241     .impl.max_access_size = 4,
1242 };
1243
1244 static void artist_draw_cursor(ARTISTState *s)
1245 {
1246     DisplaySurface *surface = qemu_console_surface(s->con);
1247     uint32_t *data = (uint32_t *)surface_data(surface);
1248     struct vram_buffer *cursor0, *cursor1 , *buf;
1249     int cx, cy, cursor_pos_x, cursor_pos_y;
1250
1251     if (!cursor_visible(s)) {
1252         return;
1253     }
1254
1255     cursor0 = &s->vram_buffer[ARTIST_BUFFER_CURSOR1];
1256     cursor1 = &s->vram_buffer[ARTIST_BUFFER_CURSOR2];
1257     buf = &s->vram_buffer[ARTIST_BUFFER_AP];
1258
1259     artist_get_cursor_pos(s, &cursor_pos_x, &cursor_pos_y);
1260
1261     for (cy = 0; cy < s->cursor_height; cy++) {
1262
1263         for (cx = 0; cx < s->cursor_width; cx++) {
1264
1265             if (cursor_pos_y + cy < 0 ||
1266                 cursor_pos_x + cx < 0 ||
1267                 cursor_pos_y + cy > buf->height - 1 ||
1268                 cursor_pos_x + cx > buf->width) {
1269                 continue;
1270             }
1271
1272             int dstoffset = (cursor_pos_y + cy) * s->width +
1273                 (cursor_pos_x + cx);
1274
1275             if (cursor0->data[cy * cursor0->width + cx]) {
1276                 data[dstoffset] = 0;
1277             } else {
1278                 if (cursor1->data[cy * cursor1->width + cx]) {
1279                     data[dstoffset] = 0xffffff;
1280                 }
1281             }
1282         }
1283     }
1284 }
1285
1286 static bool artist_screen_enabled(ARTISTState *s)
1287 {
1288     /*  We could check for (s->misc_ctrl & 0x00800000) too... */
1289     return ((s->misc_video & 0x0A000000) == 0x0A000000);
1290 }
1291
1292 static void artist_draw_line(void *opaque, uint8_t *d, const uint8_t *src,
1293                              int width, int pitch)
1294 {
1295     ARTISTState *s = ARTIST(opaque);
1296     uint32_t *cmap, *data = (uint32_t *)d;
1297     int x;
1298
1299     if (!artist_screen_enabled(s)) {
1300         /* clear screen */
1301         memset(data, 0, s->width * sizeof(uint32_t));
1302         return;
1303     }
1304
1305     cmap = (uint32_t *)(s->vram_buffer[ARTIST_BUFFER_CMAP].data + 0x400);
1306
1307     for (x = 0; x < s->width; x++) {
1308         *data++ = cmap[*src++];
1309     }
1310 }
1311
1312 static void artist_update_display(void *opaque)
1313 {
1314     ARTISTState *s = opaque;
1315     DisplaySurface *surface = qemu_console_surface(s->con);
1316     int first = 0, last;
1317
1318     framebuffer_update_display(surface, &s->fbsection, s->width, s->height,
1319                                s->width, s->width * 4, 0, 0, artist_draw_line,
1320                                s, &first, &last);
1321
1322     artist_draw_cursor(s);
1323
1324     if (first >= 0) {
1325         dpy_gfx_update(s->con, 0, first, s->width, last - first + 1);
1326     }
1327 }
1328
1329 static void artist_invalidate(void *opaque)
1330 {
1331     ARTISTState *s = ARTIST(opaque);
1332     struct vram_buffer *buf = &s->vram_buffer[ARTIST_BUFFER_AP];
1333
1334     memory_region_set_dirty(&buf->mr, 0, buf->size);
1335 }
1336
1337 static const GraphicHwOps artist_ops = {
1338     .invalidate  = artist_invalidate,
1339     .gfx_update = artist_update_display,
1340 };
1341
1342 static void artist_initfn(Object *obj)
1343 {
1344     SysBusDevice *sbd = SYS_BUS_DEVICE(obj);
1345     ARTISTState *s = ARTIST(obj);
1346
1347     memory_region_init_io(&s->reg, obj, &artist_reg_ops, s, "artist.reg",
1348                           4 * MiB);
1349     memory_region_init_io(&s->vram_mem, obj, &artist_vram_ops, s, "artist.vram",
1350                           8 * MiB);
1351     sysbus_init_mmio(sbd, &s->reg);
1352     sysbus_init_mmio(sbd, &s->vram_mem);
1353 }
1354
1355 static void artist_create_buffer(ARTISTState *s, const char *name,
1356                                  hwaddr *offset, unsigned int idx,
1357                                  int width, int height)
1358 {
1359     struct vram_buffer *buf = s->vram_buffer + idx;
1360
1361     memory_region_init_ram(&buf->mr, NULL, name, width * height,
1362                            &error_fatal);
1363     memory_region_add_subregion_overlap(&s->mem_as_root, *offset, &buf->mr, 0);
1364
1365     buf->data = memory_region_get_ram_ptr(&buf->mr);
1366     buf->size = height * width;
1367     buf->width = width;
1368     buf->height = height;
1369
1370     *offset += buf->size;
1371 }
1372
1373 static void artist_realizefn(DeviceState *dev, Error **errp)
1374 {
1375     ARTISTState *s = ARTIST(dev);
1376     struct vram_buffer *buf;
1377     hwaddr offset = 0;
1378
1379     if (s->width > 2048 || s->height > 2048) {
1380         error_report("artist: screen size can not exceed 2048 x 2048 pixel.");
1381         s->width = MIN(s->width, 2048);
1382         s->height = MIN(s->height, 2048);
1383     }
1384
1385     if (s->width < 640 || s->height < 480) {
1386         error_report("artist: minimum screen size is 640 x 480 pixel.");
1387         s->width = MAX(s->width, 640);
1388         s->height = MAX(s->height, 480);
1389     }
1390
1391     memory_region_init(&s->mem_as_root, OBJECT(dev), "artist", ~0ull);
1392     address_space_init(&s->as, &s->mem_as_root, "artist");
1393
1394     artist_create_buffer(s, "cmap", &offset, ARTIST_BUFFER_CMAP, 2048, 4);
1395     artist_create_buffer(s, "ap", &offset, ARTIST_BUFFER_AP,
1396                          s->width, s->height);
1397     artist_create_buffer(s, "cursor1", &offset, ARTIST_BUFFER_CURSOR1, 64, 64);
1398     artist_create_buffer(s, "cursor2", &offset, ARTIST_BUFFER_CURSOR2, 64, 64);
1399     artist_create_buffer(s, "attribute", &offset, ARTIST_BUFFER_ATTRIBUTE,
1400                          64, 64);
1401
1402     buf = &s->vram_buffer[ARTIST_BUFFER_AP];
1403     framebuffer_update_memory_section(&s->fbsection, &buf->mr, 0,
1404                                       buf->width, buf->height);
1405     /*
1406      * Artist cursor max size
1407      */
1408     s->cursor_height = NGLE_MAX_SPRITE_SIZE;
1409     s->cursor_width = NGLE_MAX_SPRITE_SIZE;
1410
1411     /*
1412      * These two registers are not initialized by seabios's STI implementation.
1413      * Initialize them here to sane values so artist also works with older
1414      * (not-fixed) seabios versions.
1415      */
1416     s->image_bitmap_op = 0x23000300;
1417     s->plane_mask = 0xff;
1418
1419     /* enable screen */
1420     s->misc_video |= 0x0A000000;
1421     s->misc_ctrl  |= 0x00800000;
1422
1423     s->con = graphic_console_init(dev, 0, &artist_ops, s);
1424     qemu_console_resize(s->con, s->width, s->height);
1425 }
1426
1427 static int vmstate_artist_post_load(void *opaque, int version_id)
1428 {
1429     artist_invalidate(opaque);
1430     return 0;
1431 }
1432
1433 static const VMStateDescription vmstate_artist = {
1434     .name = "artist",
1435     .version_id = 2,
1436     .minimum_version_id = 2,
1437     .post_load = vmstate_artist_post_load,
1438     .fields = (VMStateField[]) {
1439         VMSTATE_UINT16(height, ARTISTState),
1440         VMSTATE_UINT16(width, ARTISTState),
1441         VMSTATE_UINT16(depth, ARTISTState),
1442         VMSTATE_UINT32(fg_color, ARTISTState),
1443         VMSTATE_UINT32(bg_color, ARTISTState),
1444         VMSTATE_UINT32(vram_char_y, ARTISTState),
1445         VMSTATE_UINT32(vram_bitmask, ARTISTState),
1446         VMSTATE_UINT32(vram_start, ARTISTState),
1447         VMSTATE_UINT32(vram_pos, ARTISTState),
1448         VMSTATE_UINT32(vram_size, ARTISTState),
1449         VMSTATE_UINT32(blockmove_source, ARTISTState),
1450         VMSTATE_UINT32(blockmove_dest, ARTISTState),
1451         VMSTATE_UINT32(blockmove_size, ARTISTState),
1452         VMSTATE_UINT32(line_size, ARTISTState),
1453         VMSTATE_UINT32(line_end, ARTISTState),
1454         VMSTATE_UINT32(line_xy, ARTISTState),
1455         VMSTATE_UINT32(cursor_pos, ARTISTState),
1456         VMSTATE_UINT32(cursor_cntrl, ARTISTState),
1457         VMSTATE_UINT32(cursor_height, ARTISTState),
1458         VMSTATE_UINT32(cursor_width, ARTISTState),
1459         VMSTATE_UINT32(plane_mask, ARTISTState),
1460         VMSTATE_UINT32(reg_100080, ARTISTState),
1461         VMSTATE_UINT32(horiz_backporch, ARTISTState),
1462         VMSTATE_UINT32(active_lines_low, ARTISTState),
1463         VMSTATE_UINT32(misc_video, ARTISTState),
1464         VMSTATE_UINT32(misc_ctrl, ARTISTState),
1465         VMSTATE_UINT32(dst_bm_access, ARTISTState),
1466         VMSTATE_UINT32(src_bm_access, ARTISTState),
1467         VMSTATE_UINT32(control_plane, ARTISTState),
1468         VMSTATE_UINT32(transfer_data, ARTISTState),
1469         VMSTATE_UINT32(image_bitmap_op, ARTISTState),
1470         VMSTATE_UINT32(font_write1, ARTISTState),
1471         VMSTATE_UINT32(font_write2, ARTISTState),
1472         VMSTATE_UINT32(font_write_pos_y, ARTISTState),
1473         VMSTATE_END_OF_LIST()
1474     }
1475 };
1476
1477 static Property artist_properties[] = {
1478     DEFINE_PROP_UINT16("width",        ARTISTState, width, 1280),
1479     DEFINE_PROP_UINT16("height",       ARTISTState, height, 1024),
1480     DEFINE_PROP_UINT16("depth",        ARTISTState, depth, 8),
1481     DEFINE_PROP_END_OF_LIST(),
1482 };
1483
1484 static void artist_reset(DeviceState *qdev)
1485 {
1486 }
1487
1488 static void artist_class_init(ObjectClass *klass, void *data)
1489 {
1490     DeviceClass *dc = DEVICE_CLASS(klass);
1491
1492     dc->realize = artist_realizefn;
1493     dc->vmsd = &vmstate_artist;
1494     dc->reset = artist_reset;
1495     device_class_set_props(dc, artist_properties);
1496 }
1497
1498 static const TypeInfo artist_info = {
1499     .name          = TYPE_ARTIST,
1500     .parent        = TYPE_SYS_BUS_DEVICE,
1501     .instance_size = sizeof(ARTISTState),
1502     .instance_init = artist_initfn,
1503     .class_init    = artist_class_init,
1504 };
1505
1506 static void artist_register_types(void)
1507 {
1508     type_register_static(&artist_info);
1509 }
1510
1511 type_init(artist_register_types)