/* * QEMU TCX Frame buffer * * Copyright (c) 2003-2005 Fabrice Bellard * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */#include "hw.h"#include "sun4m.h"#include "console.h"#include "pixel_ops.h"#define MAXX 1024#define MAXY 768#define TCX_DAC_NREGS 16#define TCX_THC_NREGS_8  0x081c#define TCX_THC_NREGS_24 0x1000#define TCX_TEC_NREGS    0x1000typedef struct TCXState {    target_phys_addr_t addr;    DisplayState *ds;    uint8_t *vram;    uint32_t *vram24, *cplane;    ram_addr_t vram_offset, vram24_offset, cplane_offset;    uint16_t width, height, depth;    uint8_t r[256], g[256], b[256];    uint32_t palette[256];    uint8_t dac_index, dac_state;} TCXState;static void tcx_screen_dump(void *opaque, const char *filename);static void tcx24_screen_dump(void *opaque, const char *filename);static void tcx_invalidate_display(void *opaque);static void tcx24_invalidate_display(void *opaque);static void update_palette_entries(TCXState *s, int start, int end){    int i;    for(i = start; i < end; i++) {        switch(s->ds->depth) {        default:        case 8:            s->palette[i] = rgb_to_pixel8(s->r[i], s->g[i], s->b[i]);            break;        case 15:            if (s->ds->bgr)                s->palette[i] = rgb_to_pixel15bgr(s->r[i], s->g[i], s->b[i]);            else                s->palette[i] = rgb_to_pixel15(s->r[i], s->g[i], s->b[i]);            break;        case 16:            if (s->ds->bgr)                s->palette[i] = rgb_to_pixel16bgr(s->r[i], s->g[i], s->b[i]);            else                s->palette[i] = rgb_to_pixel16(s->r[i], s->g[i], s->b[i]);            break;        case 32:            if (s->ds->bgr)                s->palette[i] = rgb_to_pixel32bgr(s->r[i], s->g[i], s->b[i]);            else                s->palette[i] = rgb_to_pixel32(s->r[i], s->g[i], s->b[i]);            break;        }    }    if (s->depth == 24)        tcx24_invalidate_display(s);    else        tcx_invalidate_display(s);}static void tcx_draw_line32(TCXState *s1, uint8_t *d,                            const uint8_t *s, int width){    int x;    uint8_t val;    uint32_t *p = (uint32_t *)d;    for(x = 0; x < width; x++) {        val = *s++;        *p++ = s1->palette[val];    }}static void tcx_draw_line16(TCXState *s1, uint8_t *d,                            const uint8_t *s, int width){    int x;    uint8_t val;    uint16_t *p = (uint16_t *)d;    for(x = 0; x < width; x++) {        val = *s++;        *p++ = s1->palette[val];    }}static void tcx_draw_line8(TCXState *s1, uint8_t *d,                           const uint8_t *s, int width){    int x;    uint8_t val;    for(x = 0; x < width; x++) {        val = *s++;        *d++ = s1->palette[val];    }}static inline void tcx24_draw_line32(TCXState *s1, uint8_t *d,                                     const uint8_t *s, int width,                                     const uint32_t *cplane,                                     const uint32_t *s24){    int x;    uint8_t val;    uint32_t *p = (uint32_t *)d;    uint32_t dval;    for(x = 0; x < width; x++, s++, s24++) {        if ((bswap32(*cplane++) & 0xff000000) == 0x03000000) { // 24-bit direct            dval = bswap32(*s24) & 0x00ffffff;        } else {            val = *s;            dval = s1->palette[val];        }        *p++ = dval;    }}static inline int check_dirty(TCXState *ts, ram_addr_t page, ram_addr_t page24,                              ram_addr_t cpage){    int ret;    unsigned int off;    ret = cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG);    for (off = 0; off < TARGET_PAGE_SIZE * 4; off += TARGET_PAGE_SIZE) {        ret |= cpu_physical_memory_get_dirty(page24 + off, VGA_DIRTY_FLAG);        ret |= cpu_physical_memory_get_dirty(cpage + off, VGA_DIRTY_FLAG);    }    return ret;}static inline void reset_dirty(TCXState *ts, ram_addr_t page_min,                               ram_addr_t page_max, ram_addr_t page24,                              ram_addr_t cpage){    cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,                                    VGA_DIRTY_FLAG);    page_min -= ts->vram_offset;    page_max -= ts->vram_offset;    cpu_physical_memory_reset_dirty(page24 + page_min * 4,                                    page24 + page_max * 4 + TARGET_PAGE_SIZE,                                    VGA_DIRTY_FLAG);    cpu_physical_memory_reset_dirty(cpage + page_min * 4,                                    cpage + page_max * 4 + TARGET_PAGE_SIZE,                                    VGA_DIRTY_FLAG);}/* Fixed line length 1024 allows us to do nice tricks not possible on   VGA... */static void tcx_update_display(void *opaque){    TCXState *ts = opaque;    ram_addr_t page, page_min, page_max;    int y, y_start, dd, ds;    uint8_t *d, *s;    void (*f)(TCXState *s1, uint8_t *dst, const uint8_t *src, int width);    if (ts->ds->depth == 0)        return;    page = ts->vram_offset;    y_start = -1;    page_min = 0xffffffff;    page_max = 0;    d = ts->ds->data;    s = ts->vram;    dd = ts->ds->linesize;    ds = 1024;    switch (ts->ds->depth) {    case 32:        f = tcx_draw_line32;        break;    case 15:    case 16:        f = tcx_draw_line16;        break;    default:    case 8:        f = tcx_draw_line8;        break;    case 0:        return;    }    for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE) {        if (cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG)) {            if (y_start < 0)                y_start = y;            if (page < page_min)                page_min = page;            if (page > page_max)                page_max = page;            f(ts, d, s, ts->width);            d += dd;            s += ds;            f(ts, d, s, ts->width);            d += dd;            s += ds;            f(ts, d, s, ts->width);            d += dd;            s += ds;            f(ts, d, s, ts->width);            d += dd;            s += ds;        } else {            if (y_start >= 0) {                /* flush to display */                dpy_update(ts->ds, 0, y_start,                           ts->width, y - y_start);                y_start = -1;            }            d += dd * 4;            s += ds * 4;        }    }    if (y_start >= 0) {        /* flush to display */        dpy_update(ts->ds, 0, y_start,                   ts->width, y - y_start);    }    /* reset modified pages */    if (page_min <= page_max) {        cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,                                        VGA_DIRTY_FLAG);    }}static void tcx24_update_display(void *opaque){    TCXState *ts = opaque;    ram_addr_t page, page_min, page_max, cpage, page24;    int y, y_start, dd, ds;    uint8_t *d, *s;    uint32_t *cptr, *s24;    if (ts->ds->depth != 32)            return;    page = ts->vram_offset;    page24 = ts->vram24_offset;    cpage = ts->cplane_offset;    y_start = -1;    page_min = 0xffffffff;    page_max = 0;    d = ts->ds->data;    s = ts->vram;    s24 = ts->vram24;    cptr = ts->cplane;    dd = ts->ds->linesize;    ds = 1024;    for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE,            page24 += TARGET_PAGE_SIZE, cpage += TARGET_PAGE_SIZE) {        if (check_dirty(ts, page, page24, cpage)) {            if (y_start < 0)                y_start = y;            if (page < page_min)                page_min = page;            if (page > page_max)                page_max = page;            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);            d += dd;            s += ds;            cptr += ds;            s24 += ds;            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);            d += dd;            s += ds;            cptr += ds;            s24 += ds;            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);            d += dd;            s += ds;            cptr += ds;            s24 += ds;            tcx24_draw_line32(ts, d, s, ts->width, cptr, s24);            d += dd;            s += ds;            cptr += ds;            s24 += ds;        } else {            if (y_start >= 0) {