Change since v1:

* Incorporate Phil's -vga none fix for boot-serial-test (patch 7).

r~

The following changes since commit 6918ab2570bcf942651e69f7ad975e137679738b:

Merge remote-tracking branch 'remotes/pmaydell/tags/pull-target-arm-20200123-4' into staging (2020-01-23 16:36:55 +0000)

https://github.com/rth7680/qemu.git tags/pull-pa-20200123

for you to fetch changes up to b670f6d717a6a1795358c07823b4e968c0b61a86:

target/hppa: Allow, but diagnose, LDCW aligned only mod 4 (2020-01-23 10:55:20 -1000)

Improve LASI emulation

Add Artist graphics

Fix main memory allocation

Improve LDCW emulation wrt real hw

Helge Deller (3):

hw/hppa/dino.c: Improve emulation of Dino PCI chip

hppa: Add support for LASI chip with i82596 NIC

hppa: Switch to tulip NIC by default

Philippe Mathieu-Daudé (3):

hw/hppa/machine: Correctly check the firmware is in PDC range

hw/hppa/machine: Restrict the total memory size to 3GB

hw/hppa/machine: Map the PDC memory region with higher priority

This adds emulation of Artist graphics good enough to get a text

console on both Linux and HP-UX. The X11 server from HP-UX also works.

Adjust boot-serial-test to disable graphics, so that SeaBIOS outputs

to the serial port, as expected by the test.

Message-Id: <20191220211512.3289-6-svens@stackframe.org>

[rth: Merge Helge's test for machine->enable_graphics]

hw/hppa/hppa_hardware.h | 1 +

hw/display/artist.c | 1450 ++++++++++++++++++++++++++++++++

hw/hppa/machine.c | 10 +

tests/qtest/boot-serial-test.c | 3 +-

hw/display/Kconfig | 4 +

hw/display/Makefile.objs | 1 +

hw/display/trace-events | 9 +

hw/hppa/Kconfig | 1 +

8 files changed, 1478 insertions(+), 1 deletion(-)

create mode 100644 hw/display/artist.c

diff --git a/hw/hppa/hppa_hardware.h b/hw/hppa/hppa_hardware.h

--- a/hw/hppa/hppa_hardware.h

+++ b/hw/hppa/hppa_hardware.h

@@ -XXX,XX +XXX,XX @@

#define LASI_PS2KBD_HPA 0xffd08000

#define LASI_PS2MOU_HPA 0xffd08100

#define LASI_GFX_HPA 0xf8000000

+#define ARTIST_FB_ADDR 0xf9000000

#define CPU_HPA 0xfffb0000

#define MEMORY_HPA 0xfffbf000

diff --git a/hw/display/artist.c b/hw/display/artist.c

new file mode 100644

index XXXXXXX..XXXXXXX

--- /dev/null

+++ b/hw/display/artist.c

@@ -XXX,XX +XXX,XX @@

+/*

+ * QEMU HP Artist Emulation

+ *

+ * Copyright (c) 2019 Sven Schnelle <svens@stackframe.org>

+ *

+ * This work is licensed under the terms of the GNU GPL, version 2 or later.

+ */

+

+#include "qemu/osdep.h"

+#include "qemu-common.h"

+#include "qemu/error-report.h"

+#include "qemu/typedefs.h"

+#include "qemu/log.h"

+#include "qemu/module.h"

+#include "qemu/units.h"

+#include "qapi/error.h"

+#include "hw/sysbus.h"

+#include "hw/loader.h"

+#include "hw/qdev-core.h"

+#include "hw/qdev-properties.h"

+#include "migration/vmstate.h"

+#include "ui/console.h"

+#include "trace.h"

+#include "hw/display/framebuffer.h"

+

+#define TYPE_ARTIST "artist"

+#define ARTIST(obj) OBJECT_CHECK(ARTISTState, (obj), TYPE_ARTIST)

+

+#ifdef HOST_WORDS_BIGENDIAN

+#define ROP8OFF(_i) (3 - (_i))

+#else

+#define ROP8OFF

+#endif

+

+struct vram_buffer {

+ MemoryRegion mr;

+ uint8_t *data;

+ int size;

+ int width;

+ int height;

+typedef struct ARTISTState {

+ SysBusDevice parent_obj;

+

+ QemuConsole *con;

+ MemoryRegion vram_mem;

+ MemoryRegion mem_as_root;

+ MemoryRegion reg;

+ MemoryRegionSection fbsection;

+

+ void *vram_int_mr;

+ AddressSpace as;

+

+ struct vram_buffer vram_buffer[16];

+

+ uint16_t width;

+ uint16_t height;

+ uint16_t depth;

+

+ uint32_t fg_color;

+ uint32_t bg_color;

+

+ uint32_t vram_char_y;

+ uint32_t vram_bitmask;

+

+ uint32_t vram_start;

+ uint32_t vram_pos;

+

+ uint32_t vram_size;

+

+ uint32_t blockmove_source;

+ uint32_t blockmove_dest;

+ uint32_t blockmove_size;

+

+ uint32_t line_size;

+ uint32_t line_end;

+ uint32_t line_xy;

+ uint32_t line_pattern_start;

+ uint32_t line_pattern_skip;

+

+ uint32_t cursor_pos;

+

+ uint32_t cursor_height;

+ uint32_t cursor_width;

+

+ uint32_t plane_mask;

+

+ uint32_t reg_100080;

+ uint32_t reg_300200;

+ uint32_t reg_300208;

+ uint32_t reg_300218;

+

+ uint32_t cmap_bm_access;

+ uint32_t dst_bm_access;

+ uint32_t src_bm_access;

+ uint32_t control_plane;

+ uint32_t transfer_data;

+ uint32_t image_bitmap_op;

+

+ uint32_t font_write1;

+ uint32_t font_write2;

+ uint32_t font_write_pos_y;

+

+ int draw_line_pattern;

+} ARTISTState;

+

+typedef enum {

+ ARTIST_BUFFER_AP = 1,

+ ARTIST_BUFFER_OVERLAY = 2,

+ ARTIST_BUFFER_CURSOR1 = 6,

+ ARTIST_BUFFER_CURSOR2 = 7,

+ ARTIST_BUFFER_ATTRIBUTE = 13,

+ ARTIST_BUFFER_CMAP = 15,

+} artist_buffer_t;

+

+typedef enum {

+ VRAM_IDX = 0x1004a0,

+ VRAM_BITMASK = 0x1005a0,

+ VRAM_WRITE_INCR_X = 0x100600,

+ VRAM_WRITE_INCR_X2 = 0x100604,

+ VRAM_WRITE_INCR_Y = 0x100620,

+ VRAM_START = 0x100800,

+ BLOCK_MOVE_SIZE = 0x100804,

+ BLOCK_MOVE_SOURCE = 0x100808,

+ TRANSFER_DATA = 0x100820,

+ FONT_WRITE_INCR_Y = 0x1008a0,

+ VRAM_START_TRIGGER = 0x100a00,

+ VRAM_SIZE_TRIGGER = 0x100a04,

+ FONT_WRITE_START = 0x100aa0,

+ BLOCK_MOVE_DEST_TRIGGER = 0x100b00,

+ BLOCK_MOVE_SIZE_TRIGGER = 0x100b04,

+ LINE_XY = 0x100ccc,

+ PATTERN_LINE_START = 0x100ecc,

+ LINE_SIZE = 0x100e04,

+ LINE_END = 0x100e44,

+ CMAP_BM_ACCESS = 0x118000,

+ DST_BM_ACCESS = 0x118004,

+ SRC_BM_ACCESS = 0x118008,

+ CONTROL_PLANE = 0x11800c,

+ FG_COLOR = 0x118010,

+ BG_COLOR = 0x118014,

+ PLANE_MASK = 0x118018,

+ IMAGE_BITMAP_OP = 0x11801c,

+ CURSOR_POS = 0x300100,

+ CURSOR_CTRL = 0x300104,

+} artist_reg_t;

+

+typedef enum {

+ ARTIST_ROP_CLEAR = 0,

+ ARTIST_ROP_COPY = 3,

+ ARTIST_ROP_XOR = 6,

+ ARTIST_ROP_NOT_DST = 10,

+ ARTIST_ROP_SET = 15,

+} artist_rop_t;

+

+#define REG_NAME(_x) case _x: return " "#_x;

+static const char *artist_reg_name(uint64_t addr)

+{

+ switch ((artist_reg_t)addr) {

+ REG_NAME(VRAM_IDX);

+ REG_NAME(VRAM_BITMASK);

+ REG_NAME(VRAM_WRITE_INCR_X);

+ REG_NAME(VRAM_WRITE_INCR_X2);

+ REG_NAME(VRAM_WRITE_INCR_Y);

+ REG_NAME(VRAM_START);

+ REG_NAME(BLOCK_MOVE_SIZE);

+ REG_NAME(BLOCK_MOVE_SOURCE);

+ REG_NAME(FG_COLOR);

+ REG_NAME(BG_COLOR);

+ REG_NAME(PLANE_MASK);

+ REG_NAME(VRAM_START_TRIGGER);

+ REG_NAME(VRAM_SIZE_TRIGGER);

+ REG_NAME(BLOCK_MOVE_DEST_TRIGGER);

+ REG_NAME(BLOCK_MOVE_SIZE_TRIGGER);

+ REG_NAME(TRANSFER_DATA);

+ REG_NAME(CONTROL_PLANE);

+ REG_NAME(IMAGE_BITMAP_OP);

+ REG_NAME(CMAP_BM_ACCESS);

+ REG_NAME(DST_BM_ACCESS);

+ REG_NAME(SRC_BM_ACCESS);

+ REG_NAME(CURSOR_POS);

+ REG_NAME(CURSOR_CTRL);

+ REG_NAME(LINE_XY);

+ REG_NAME(PATTERN_LINE_START);

+ REG_NAME(LINE_SIZE);

+ REG_NAME(LINE_END);

+ REG_NAME(FONT_WRITE_INCR_Y);

+ REG_NAME(FONT_WRITE_START);

+ }

+ return "";

+}

+

+static int16_t artist_get_x(uint32_t reg)

+{

+ return reg >> 16;

+}

+

+static int16_t artist_get_y(uint32_t reg)

+{

+ return reg & 0xffff;

+}

+

+static void artist_invalidate_lines(struct vram_buffer *buf,

+ int starty, int height)

+{

+ int start = starty * buf->width;

+ int size = height * buf->width;

+

+ if (start + size <= buf->size) {

+ memory_region_set_dirty(&buf->mr, start, size);

+ }

+}

+

+static int vram_write_pix_per_transfer(ARTISTState *s)

+{

+ if (s->cmap_bm_access) {

+ return 1 << ((s->cmap_bm_access >> 27) & 0x0f);

+ } else {

+ return 1 << ((s->dst_bm_access >> 27) & 0x0f);

+ }

+}

+

+static int vram_pixel_length(ARTISTState *s)

+{

+ if (s->cmap_bm_access) {

+ return (s->cmap_bm_access >> 24) & 0x07;

+ } else {

+ return (s->dst_bm_access >> 24) & 0x07;

+ }

+}

+

+static int vram_write_bufidx(ARTISTState *s)

+{

+ if (s->cmap_bm_access) {

+ return (s->cmap_bm_access >> 12) & 0x0f;

+ } else {

+ return (s->dst_bm_access >> 12) & 0x0f;

+ }

+}

+

+static int vram_read_bufidx(ARTISTState *s)

+{

+ if (s->cmap_bm_access) {

+ return (s->cmap_bm_access >> 12) & 0x0f;

+ } else {

+ return (s->src_bm_access >> 12) & 0x0f;

+ }

+}

+

+static struct vram_buffer *vram_read_buffer(ARTISTState *s)

+{

+ return &s->vram_buffer[vram_read_bufidx(s)];

+}

+

+static struct vram_buffer *vram_write_buffer(ARTISTState *s)

+{

+ return &s->vram_buffer[vram_write_bufidx(s)];

+}

+

+static uint8_t artist_get_color(ARTISTState *s)

+{

+ if (s->image_bitmap_op & 2) {

+ return s->fg_color;

+ } else {

+ return s->bg_color;

+ }

+}

+

+static artist_rop_t artist_get_op(ARTISTState *s)

+{

+ return (s->image_bitmap_op >> 8) & 0xf;

+}

+

+static void artist_rop8(ARTISTState *s, uint8_t *dst, uint8_t val)

+{

+

+ const artist_rop_t op = artist_get_op(s);

+ uint8_t plane_mask = s->plane_mask & 0xff;

+

+ switch (op) {

+ case ARTIST_ROP_CLEAR:

+ *dst &= ~plane_mask;

+ break;

+

+ case ARTIST_ROP_COPY:

+ *dst &= ~plane_mask;

+ *dst |= val & plane_mask;

+ break;

+

+ case ARTIST_ROP_XOR:

+ *dst ^= val & plane_mask;

+ break;

+

+ case ARTIST_ROP_NOT_DST:

+ *dst ^= plane_mask;

+ break;

+

+ case ARTIST_ROP_SET:

+ *dst |= plane_mask;

+ break;

+

+ default:

+ qemu_log_mask(LOG_UNIMP, "%s: unsupported rop %d\n", __func__, op);

+ break;

+ }

+}

+

+static void artist_get_cursor_pos(ARTISTState *s, int *x, int *y)

+{

+ /*

+ * Don't know whether these magic offset values are configurable via

+ * some register. They are the same for all resolutions, so don't

+ * bother about it.

+ */

+

+ *y = 0x47a - artist_get_y(s->cursor_pos);

+ *x = ((artist_get_x(s->cursor_pos) - 338) / 2);

+

+ if (*x > s->width) {

+ *x = 0;

+ }

+

+ if (*y > s->height) {

+ *y = 0;

+ }

+}

+

+static void artist_invalidate_cursor(ARTISTState *s)

+{

+ int x, y;

+ artist_get_cursor_pos(s, &x, &y);

+ artist_invalidate_lines(&s->vram_buffer[ARTIST_BUFFER_AP],

+ y, s->cursor_height);

+}

+

+static void vram_bit_write(ARTISTState *s, int posx, int posy, bool incr_x,

+ int size, uint32_t data)

+{

+ struct vram_buffer *buf;

+ uint32_t vram_bitmask = s->vram_bitmask;

+ int mask, i, pix_count, pix_length, offset, height, width;

+ uint8_t *data8, *p;

+

+ pix_count = vram_write_pix_per_transfer(s);

+ pix_length = vram_pixel_length(s);

+

+ buf = vram_write_buffer(s);

+ height = buf->height;

+ width = buf->width;

+

+ if (s->cmap_bm_access) {

+ offset = s->vram_pos;

+ } else {

+ offset = posy * width + posx;

+ }

+

+ if (!buf->size) {

+ qemu_log("write to non-existent buffer\n");

+ return;

+ }

+

+ p = buf->data;

+

+ if (pix_count > size * 8) {

+ pix_count = size * 8;

+ }

+

+ if (posy * width + posx + pix_count > buf->size) {

+ qemu_log("write outside bounds: wants %dx%d, max size %dx%d\n",

+ posx, posy, width, height);

+ return;

+ }

+

+

+ switch (pix_length) {

+ case 0:

+ if (s->image_bitmap_op & 0x20000000) {

+ data &= vram_bitmask;

+ }

+

+ for (i = 0; i < pix_count; i++) {

+ artist_rop8(s, p + offset + pix_count - 1 - i,

+ (data & 1) ? (s->plane_mask >> 24) : 0);

+ data >>= 1;

+ }

+ memory_region_set_dirty(&buf->mr, offset, pix_count);

+ break;

+

+ case 3:

+ if (s->cmap_bm_access) {

+ *(uint32_t *)(p + offset) = data;

+ break;

+ }

+ data8 = (uint8_t *)&data;

+

+ for (i = 3; i >= 0; i--) {

+ if (!(s->image_bitmap_op & 0x20000000) ||

+ s->vram_bitmask & (1 << (28 + i))) {

+ artist_rop8(s, p + offset + 3 - i, data8[ROP8OFF(i)]);

+ }

+ }

+ memory_region_set_dirty(&buf->mr, offset, 3);

+ break;

+

+ case 6:

+ switch (size) {

+ default:

+ case 4:

+ vram_bitmask = s->vram_bitmask;

+ break;

+

+ case 2:

+ vram_bitmask = s->vram_bitmask >> 16;

+ break;

+

+ case 1:

+ vram_bitmask = s->vram_bitmask >> 24;

+ break;

+ }

+

+ for (i = 0; i < pix_count; i++) {

+ mask = 1 << (pix_count - 1 - i);

+

+ if (!(s->image_bitmap_op & 0x20000000) ||

+ (vram_bitmask & mask)) {

+ if (data & mask) {

+ artist_rop8(s, p + offset + i, s->fg_color);

+ } else {

+ if (!(s->image_bitmap_op & 0x10000002)) {

+ artist_rop8(s, p + offset + i, s->bg_color);

+ }

+ }

+ }

+ }

+ memory_region_set_dirty(&buf->mr, offset, pix_count);

+ break;

+

+ default:

+ qemu_log_mask(LOG_UNIMP, "%s: unknown pixel length %d\n",

+ __func__, pix_length);

+ break;

+ }

+

+ if (incr_x) {

+ if (s->cmap_bm_access) {

+ s->vram_pos += 4;

+ } else {

+ s->vram_pos += pix_count << 2;

+ }

+ }

+

+ if (vram_write_bufidx(s) == ARTIST_BUFFER_CURSOR1 ||

+ vram_write_bufidx(s) == ARTIST_BUFFER_CURSOR2) {

+ artist_invalidate_cursor(s);

+ }

+}

+

+static void block_move(ARTISTState *s, int source_x, int source_y, int dest_x,

+ int dest_y, int width, int height)

+{

+ struct vram_buffer *buf;

+ int line, endline, lineincr, startcolumn, endcolumn, columnincr, column;

+ uint32_t dst, src;

+

+ trace_artist_block_move(source_x, source_y, dest_x, dest_y, width, height);

+

+ if (s->control_plane != 0) {

+ /* We don't support CONTROL_PLANE accesses */

+ qemu_log_mask(LOG_UNIMP, "%s: CONTROL_PLANE: %08x\n", __func__,

+ s->control_plane);

+ return;

+ }

+

+ buf = &s->vram_buffer[ARTIST_BUFFER_AP];

+

+ if (dest_y > source_y) {

+ /* move down */

+ line = height - 1;

+ endline = -1;

+ lineincr = -1;

+ } else {

+ /* move up */

+ line = 0;

+ endline = height;

+ lineincr = 1;

+ }

+

+ if (dest_x > source_x) {

+ /* move right */

+ startcolumn = width - 1;

+ endcolumn = -1;

+ columnincr = -1;

+ } else {

+ /* move left */

+ startcolumn = 0;

+ endcolumn = width;

+ columnincr = 1;

+ }

+

+ for ( ; line != endline; line += lineincr) {

+ src = source_x + ((line + source_y) * buf->width);

+ dst = dest_x + ((line + dest_y) * buf->width);

+

+ for (column = startcolumn; column != endcolumn; column += columnincr) {

+ if (dst + column > buf->size || src + column > buf->size) {

+ continue;

+ }

+ artist_rop8(s, buf->data + dst + column, buf->data[src + column]);

+ }

+ }

+

+ artist_invalidate_lines(buf, dest_y, height);

+}

+

+static void fill_window(ARTISTState *s, int startx, int starty,

+ int width, int height)

+{

+ uint32_t offset;

+ uint8_t color = artist_get_color(s);

+ struct vram_buffer *buf;

+ int x, y;

+

+ trace_artist_fill_window(startx, starty, width, height,

+ s->image_bitmap_op, s->control_plane);

+

+ if (s->control_plane != 0) {

+ /* We don't support CONTROL_PLANE accesses */

+ qemu_log_mask(LOG_UNIMP, "%s: CONTROL_PLANE: %08x\n", __func__,

+ s->control_plane);

+ return;

+ }

+

+ if (s->reg_100080 == 0x7d) {

+ /*

+ * Not sure what this register really does, but

+ * 0x7d seems to enable autoincremt of the Y axis

+ * by the current block move height.

+ */

+ height = artist_get_y(s->blockmove_size);

+ s->vram_start += height;

+ }

+

+ buf = &s->vram_buffer[ARTIST_BUFFER_AP];

+

+ for (y = starty; y < starty + height; y++) {

+ offset = y * s->width;

+

+ for (x = startx; x < startx + width; x++) {

+ artist_rop8(s, buf->data + offset + x, color);

+ }

+ }

+ artist_invalidate_lines(buf, starty, height);

+}

+

+static void draw_line(ARTISTState *s, int x1, int y1, int x2, int y2,

+ bool update_start, int skip_pix, int max_pix)

+{

+ struct vram_buffer *buf;

+ uint8_t color = artist_get_color(s);

+ int dx, dy, t, e, x, y, incy, diago, horiz;

+ bool c1;

+ uint8_t *p;

+

+

+ if (update_start) {

+ s->vram_start = (x2 << 16) | y2;

+ }

+

+ buf = &s->vram_buffer[ARTIST_BUFFER_AP];

+

+ c1 = false;

+ incy = 1;

+

+ if (x2 > x1) {

+ dx = x2 - x1;

+ } else {

+ dx = x1 - x2;

+ }

+ if (y2 > y1) {

+ dy = y2 - y1;

+ } else {

+ dy = y1 - y2;

+ }

+ if (dy > dx) {

+ t = y2;

+ y2 = x2;

+ x2 = t;

+

+ t = y1;

+ y1 = x1;

+ x1 = t;

+

+ t = dx;

+ dx = dy;

+ dy = t;

+

+ c1 = true;

+ }

+

+ if (x1 > x2) {

+ t = y2;

+ y2 = y1;

+ y1 = t;

+

+ t = x1;

+ x1 = x2;

+ x2 = t;

+ }

+

+ horiz = dy << 1;

+ diago = (dy - dx) << 1;

+ e = (dy << 1) - dx;

+

+ if (y1 <= y2) {

+ incy = 1;

+ } else {

+ incy = -1;

+ }

+ x = x1;

+ y = y1;

+

+ do {

+ if (c1) {

+ p = buf->data + x * s->width + y;

+ } else {

+ p = buf->data + y * s->width + x;

+ }

+

+ if (skip_pix > 0) {

+ skip_pix--;

+ } else {

+ artist_rop8(s, p, color);

+ }

+

+ if (e > 0) {

+ artist_invalidate_lines(buf, y, 1);

+ y += incy;

+ e += diago;

+ } else {

+ e += horiz;

+ }

+ x++;

+ } while (x <= x2 && (max_pix == -1 || --max_pix > 0));

+}

+

+static void draw_line_pattern_start(ARTISTState *s)

+{

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start);

+ int endx = artist_get_x(s->blockmove_size);

+ int endy = artist_get_y(s->blockmove_size);

+ int pstart = s->line_pattern_start >> 16;

+

+ trace_artist_draw_line(startx, starty, endx, endy);

+ draw_line(s, startx, starty, endx, endy, false, -1, pstart);

+ s->line_pattern_skip = pstart;

+}

+

+static void draw_line_pattern_next(ARTISTState *s)

+{

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start);

+ int endx = artist_get_x(s->blockmove_size);

+ int endy = artist_get_y(s->blockmove_size);

+ int line_xy = s->line_xy >> 16;

+

+ trace_artist_draw_line(startx, starty, endx, endy);

+ draw_line(s, startx, starty, endx, endy, false, s->line_pattern_skip,

+ s->line_pattern_skip + line_xy);

+ s->line_pattern_skip += line_xy;

+ s->image_bitmap_op ^= 2;

+}

+

+static void draw_line_size(ARTISTState *s, bool update_start)

+{

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start);

+ int endx = artist_get_x(s->line_size);

+ int endy = artist_get_y(s->line_size);

+

+ trace_artist_draw_line(startx, starty, endx, endy);

+ draw_line(s, startx, starty, endx, endy, update_start, -1, -1);

+}

+

+static void draw_line_xy(ARTISTState *s, bool update_start)

+{

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start);

+ int sizex = artist_get_x(s->blockmove_size);

+ int sizey = artist_get_y(s->blockmove_size);

+ int linexy = s->line_xy >> 16;

+ int endx, endy;

+

+ endx = startx;

+ endy = starty;

+

+ if (sizex > 0) {

+ endx = startx + linexy;

+ }

+

+ if (sizex < 0) {

+ endx = startx;

+ startx -= linexy;

+ }

+

+ if (sizey > 0) {

+ endy = starty + linexy;

+ }

+

+ if (sizey < 0) {

+ endy = starty;

+ starty -= linexy;

+ }

+

+ if (startx < 0) {

+ startx = 0;

+ }

+

+ if (endx < 0) {

+ endx = 0;

+ }

+

+ if (starty < 0) {

+ starty = 0;

+ }

+

+ if (endy < 0) {

+ endy = 0;

+ }

+

+

+ if (endx < 0) {

+ return;

+ }

+

+ if (endy < 0) {

+ return;

+ }

+

+ trace_artist_draw_line(startx, starty, endx, endy);

+ draw_line(s, startx, starty, endx, endy, false, -1, -1);

+}

+

+static void draw_line_end(ARTISTState *s, bool update_start)

+{

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start);

+ int endx = artist_get_x(s->line_end);

+ int endy = artist_get_y(s->line_end);

+

+ trace_artist_draw_line(startx, starty, endx, endy);

+ draw_line(s, startx, starty, endx, endy, update_start, -1, -1);

+}

+

+static void font_write16(ARTISTState *s, uint16_t val)

+{

+ struct vram_buffer *buf;

+ uint32_t color = (s->image_bitmap_op & 2) ? s->fg_color : s->bg_color;

+ uint16_t mask;

+ int i;

+

+ int startx = artist_get_x(s->vram_start);

+ int starty = artist_get_y(s->vram_start) + s->font_write_pos_y;

+ int offset = starty * s->width + startx;

+

+ buf = &s->vram_buffer[ARTIST_BUFFER_AP];

+

+ if (offset + 16 > buf->size) {

+ return;

+ }

+

+ for (i = 0; i < 16; i++) {

+ mask = 1 << (15 - i);

+ if (val & mask) {

+ artist_rop8(s, buf->data + offset + i, color);

+ } else {

+ if (!(s->image_bitmap_op & 0x20000000)) {

+ artist_rop8(s, buf->data + offset + i, s->bg_color);

+ }

+ }

+ }

+ artist_invalidate_lines(buf, starty, 1);

+}

+

+static void font_write(ARTISTState *s, uint32_t val)

+{

+ font_write16(s, val >> 16);

+ if (++s->font_write_pos_y == artist_get_y(s->blockmove_size)) {

+ s->vram_start += (s->blockmove_size & 0xffff0000);

+ return;

+ }

+

+ font_write16(s, val & 0xffff);

+ if (++s->font_write_pos_y == artist_get_y(s->blockmove_size)) {

+ s->vram_start += (s->blockmove_size & 0xffff0000);

+ return;

+ }

+}

+

+static void combine_write_reg(hwaddr addr, uint64_t val, int size, void *out)

+{

+ /*

+ * FIXME: is there a qemu helper for this?

+ */

+

+#ifndef HOST_WORDS_BIGENDIAN

+ addr ^= 3;

+#endif

+

+ switch (size) {

+ case 1:

+ *(uint8_t *)(out + (addr & 3)) = val;

+ break;

+

+ case 2:

+ *(uint16_t *)(out + (addr & 2)) = val;

+ break;

+

+ case 4:

+ *(uint32_t *)out = val;

+ break;

+

+ default:

+ qemu_log_mask(LOG_UNIMP, "unsupported write size: %d\n", size);

+ }

+}

+

+static void artist_reg_write(void *opaque, hwaddr addr, uint64_t val,

+ unsigned size)

+{

+ ARTISTState *s = opaque;

+ int posx, posy;

+ int width, height;

+

+ trace_artist_reg_write(size, addr, artist_reg_name(addr & ~3ULL), val);

+

+ switch (addr & ~3ULL) {

+ case 0x100080:

+ combine_write_reg(addr, val, size, &s->reg_100080);

+ break;

+

+ case FG_COLOR:

+ combine_write_reg(addr, val, size, &s->fg_color);

+ break;

+

+ case BG_COLOR:

+ combine_write_reg(addr, val, size, &s->bg_color);

+ break;

+

+ case VRAM_BITMASK:

+ combine_write_reg(addr, val, size, &s->vram_bitmask);

+ break;

+

+ case VRAM_WRITE_INCR_Y:

+ posx = (s->vram_pos >> 2) & 0x7ff;

+ posy = (s->vram_pos >> 13) & 0x3ff;

+ vram_bit_write(s, posx, posy + s->vram_char_y++, false, size, val);

+ break;

+

+ case VRAM_WRITE_INCR_X:

+ case VRAM_WRITE_INCR_X2:

+ posx = (s->vram_pos >> 2) & 0x7ff;

+ posy = (s->vram_pos >> 13) & 0x3ff;

+ vram_bit_write(s, posx, posy + s->vram_char_y, true, size, val);

+ break;

+

+ case VRAM_IDX:

+ combine_write_reg(addr, val, size, &s->vram_pos);

+ s->vram_char_y = 0;

+ s->draw_line_pattern = 0;

+ break;

+

+ case VRAM_START:

+ combine_write_reg(addr, val, size, &s->vram_start);

+ s->draw_line_pattern = 0;

+ break;

+

+ case VRAM_START_TRIGGER:

+ combine_write_reg(addr, val, size, &s->vram_start);

+ fill_window(s, artist_get_x(s->vram_start),

+ artist_get_y(s->vram_start),

+ artist_get_x(s->blockmove_size),

+ artist_get_y(s->blockmove_size));

+ break;

+

+ case VRAM_SIZE_TRIGGER:

+ combine_write_reg(addr, val, size, &s->vram_size);

+

+ if (size == 2 && !(addr & 2)) {

+ height = artist_get_y(s->blockmove_size);

+ } else {

+ height = artist_get_y(s->vram_size);

+ }

+

+ if (size == 2 && (addr & 2)) {

+ width = artist_get_x(s->blockmove_size);

+ } else {

+ width = artist_get_x(s->vram_size);

+ }

+

+ fill_window(s, artist_get_x(s->vram_start),

+ artist_get_y(s->vram_start),

+ width, height);

+ break;

+

+ case LINE_XY:

+ combine_write_reg(addr, val, size, &s->line_xy);

+ if (s->draw_line_pattern) {

+ draw_line_pattern_next(s);

+ } else {

+ draw_line_xy(s, true);

+ }

+ break;

+

+ case PATTERN_LINE_START:

+ combine_write_reg(addr, val, size, &s->line_pattern_start);

+ s->draw_line_pattern = 1;

+ draw_line_pattern_start(s);

+ break;

+

+ case LINE_SIZE:

+ combine_write_reg(addr, val, size, &s->line_size);

+ draw_line_size(s, true);

+ break;

+

+ case LINE_END:

+ combine_write_reg(addr, val, size, &s->line_end);

+ draw_line_end(s, true);

+ break;

+

+ case BLOCK_MOVE_SIZE:

+ combine_write_reg(addr, val, size, &s->blockmove_size);

+ break;

+

+ case BLOCK_MOVE_SOURCE:

+ combine_write_reg(addr, val, size, &s->blockmove_source);

+ break;

+

+ case BLOCK_MOVE_DEST_TRIGGER:

+ combine_write_reg(addr, val, size, &s->blockmove_dest);

+

+ block_move(s, artist_get_x(s->blockmove_source),

+ artist_get_y(s->blockmove_source),

+ artist_get_x(s->blockmove_dest),

+ artist_get_y(s->blockmove_dest),

+ artist_get_x(s->blockmove_size),

+ artist_get_y(s->blockmove_size));

+ break;

+

+ case BLOCK_MOVE_SIZE_TRIGGER:

+ combine_write_reg(addr, val, size, &s->blockmove_size);

+

+ block_move(s,

+ artist_get_x(s->blockmove_source),

+ artist_get_y(s->blockmove_source),

+ artist_get_x(s->vram_start),

+ artist_get_y(s->vram_start),

+ artist_get_x(s->blockmove_size),

+ artist_get_y(s->blockmove_size));

+ break;

+

+ case PLANE_MASK:

+ combine_write_reg(addr, val, size, &s->plane_mask);

+ break;

+

+ case CMAP_BM_ACCESS:

+ combine_write_reg(addr, val, size, &s->cmap_bm_access);

+ break;

+

+ case DST_BM_ACCESS:

+ combine_write_reg(addr, val, size, &s->dst_bm_access);

+ s->cmap_bm_access = 0;

+ break;

+

+ case SRC_BM_ACCESS:

+ combine_write_reg(addr, val, size, &s->src_bm_access);

+ s->cmap_bm_access = 0;

+ break;

+

+ case CONTROL_PLANE:

+ combine_write_reg(addr, val, size, &s->control_plane);

+ break;

+

+ case TRANSFER_DATA:

+ combine_write_reg(addr, val, size, &s->transfer_data);

+ break;

+

+ case 0x300200:

+ combine_write_reg(addr, val, size, &s->reg_300200);

+ break;

+

+ case 0x300208:

+ combine_write_reg(addr, val, size, &s->reg_300208);

+ break;

+

+ case 0x300218:

+ combine_write_reg(addr, val, size, &s->reg_300218);

+ break;

+

+ case CURSOR_POS:

+ artist_invalidate_cursor(s);

+ combine_write_reg(addr, val, size, &s->cursor_pos);

+ artist_invalidate_cursor(s);

+ break;

+

+ case CURSOR_CTRL:

+ break;

+

+ case IMAGE_BITMAP_OP:

+ combine_write_reg(addr, val, size, &s->image_bitmap_op);

+ break;

+

+ case FONT_WRITE_INCR_Y:

+ combine_write_reg(addr, val, size, &s->font_write1);

+ font_write(s, s->font_write1);

+ break;

+

+ case FONT_WRITE_START:

+ combine_write_reg(addr, val, size, &s->font_write2);

+ s->font_write_pos_y = 0;

+ font_write(s, s->font_write2);

+ break;

+

+ case 300104:

+ break;

+

+ default:

+ qemu_log_mask(LOG_UNIMP, "%s: unknown register: reg=%08lx val=%08lx"

+ " size=%d\n", __func__, addr, val, size);

+ break;

+ }

+}

+

+static uint64_t combine_read_reg(hwaddr addr, int size, void *in)

+{

+ /*

+ * FIXME: is there a qemu helper for this?

+ */

+

+#ifndef HOST_WORDS_BIGENDIAN

+ addr ^= 3;

+#endif

+

+ switch (size) {

+ case 1:

+ return *(uint8_t *)(in + (addr & 3));

+

+ case 2:

+ return *(uint16_t *)(in + (addr & 2));

+

+ case 4:

+ return *(uint32_t *)in;

+

+ default:

+ qemu_log_mask(LOG_UNIMP, "unsupported read size: %d\n", size);

+ return 0;

+ }

+}

+

+static uint64_t artist_reg_read(void *opaque, hwaddr addr, unsigned size)

+{

+ ARTISTState *s = opaque;

+ uint32_t val = 0;

+

+ switch (addr & ~3ULL) {

+ /* Unknown status registers */

+ case 0:

+ break;

+

+ case 0x211110:

+ val = (s->width << 16) | s->height;

+ if (s->depth == 1) {

+ val |= 1 << 31;

+ }

+ break;

+

+ case 0x100000:

+ case 0x300000:

+ case 0x300004:

+ case 0x300308:

+ case 0x380000:

+ break;

+

+ case 0x300008:

+ case 0x380008:

+ /*

+ * FIFO ready flag. we're not emulating the FIFOs

+ * so we're always ready

+ */

+ val = 0x10;

+ break;

+

+ case 0x300200:

+ val = s->reg_300200;

+ break;

+

+ case 0x300208:

+ val = s->reg_300208;

+ break;

+

+ case 0x300218:

+ val = s->reg_300218;

+ break;

+

+ case 0x30023c:

+ val = 0xac4ffdac;

+ break;

+

+ case 0x380004:

+ /* 0x02000000 Buserror */

+ val = 0x6dc20006;

+ break;

+

+ default:

+ qemu_log("%s: unknown register: %08lx size %d\n", __func__, addr, size);

+ }

+ val = combine_read_reg(addr, size, &val);

+ trace_artist_reg_read(size, addr, artist_reg_name(addr & ~3ULL), val);

+ return val;

+}

+

+static void artist_vram_write(void *opaque, hwaddr addr, uint64_t val,

+ unsigned size)

+{

+ ARTISTState *s = opaque;

+ struct vram_buffer *buf;

+ int posy = (addr >> 11) & 0x3ff;

+ int posx = addr & 0x7ff;

+ uint32_t offset;

+ trace_artist_vram_write(size, addr, val);

+

+ if (s->cmap_bm_access) {

+ buf = &s->vram_buffer[ARTIST_BUFFER_CMAP];

+ if (addr + 3 < buf->size) {

+ *(uint32_t *)(buf->data + addr) = val;

+ }

+ return;

+ }

+

+ buf = vram_write_buffer(s);

+ if (!buf->size) {

+ return;

+ }

+

+ if (posy > buf->height || posx > buf->width) {

+ return;

+ }

+

+ offset = posy * buf->width + posx;

+ switch (size) {

+ case 4:

+ *(uint32_t *)(buf->data + offset) = be32_to_cpu(val);

+ memory_region_set_dirty(&buf->mr, offset, 4);

+ break;

+ case 2:

+ *(uint16_t *)(buf->data + offset) = be16_to_cpu(val);

+ memory_region_set_dirty(&buf->mr, offset, 2);

+ break;

+ case 1:

+ *(uint8_t *)(buf->data + offset) = val;

+ memory_region_set_dirty(&buf->mr, offset, 1);

+ break;

+ default:

+ break;

+ }

+}

+

+static uint64_t artist_vram_read(void *opaque, hwaddr addr, unsigned size)

+{

+ ARTISTState *s = opaque;

+ struct vram_buffer *buf;

+ uint64_t val;

+ int posy, posx;

+