Archipelago » qemu

    uint32_t irqctrl;

    uint32_t page;

    uint32_t page_off;

    uint8_t video_ram[128*64/8];

} musicpal_lcd_state;

        (musicpal_lcd_state *s, int x, int y, type col) \

{ \

    int dx, dy; \

\

    for (dy = 0; dy < 3; dy++, pixel += 127 * 3) \

        for (dx = 0; dx < 3; dx++, pixel++) \

static void lcd_refresh(void *opaque)

{

    musicpal_lcd_state *s = opaque;

    int x, y, col;

    case 0:

        return;

#define LCD_REFRESH(depth, func) \

        break;

    LCD_REFRESH(8, rgb_to_pixel8)

    LCD_REFRESH(16, rgb_to_pixel16)

                     rgb_to_pixel32bgr : rgb_to_pixel32))

    default:

        hw_error("unsupported colour depth %i\n",

    }

}

static void lcd_invalidate(void *opaque)

                          "musicpal-lcd", MP_LCD_SIZE);

    sysbus_init_mmio(dev, &s->iomem);

    qdev_init_gpio_in(&dev->qdev, musicpal_lcd_gpio_brigthness_in, 3);

    uint8_t effect;

    uint8_t iformat;

    uint8_t source;

    blizzard_fn_t *line_fn_tab[2];

    void *fb;

static void blizzard_window(BlizzardState *s)

{

    uint8_t *src, *dst;

    int bypp[2];

    int bypl[3];

        s->my[1] = s->data.y + s->data.dy;

    bypp[0] = s->bpp;

    bypl[0] = bypp[0] * s->data.pitch;

    bypl[1] = bypp[1] * s->x;

    bypl[2] = bypp[0] * s->data.dx;

static void blizzard_update_display(void *opaque)

{

    BlizzardState *s = (BlizzardState *) opaque;

    int y, bypp, bypl, bwidth;

    uint8_t *src, *dst;

    if (!s->enable)

        return;

        s->invalidate = 1;

    }

    if (s->invalidate) {

        s->invalidate = 0;

        if (s->blank) {

            return;

        }

    if (s->mx[1] <= s->mx[0])

        return;

    bypl = bypp * s->x;

    bwidth = bypp * (s->mx[1] - s->mx[0]);

    y = s->my[0];

    src = s->fb + bypl * y + bypp * s->mx[0];

    for (; y < s->my[1]; y ++, src += bypl, dst += bypl)

        memcpy(dst, src, bwidth);

                   s->mx[1] - s->mx[0], y - s->my[0]);

    s->mx[0] = s->x;

                                 bool cswitch, Error **errp)

{

    BlizzardState *s = (BlizzardState *) opaque;

    blizzard_update_display(opaque);

}

#define DEPTH 8

void *s1d13745_init(qemu_irq gpio_int)

{

    BlizzardState *s = (BlizzardState *) g_malloc0(sizeof(*s));

    s->fb = g_malloc(0x180000);

    case 0:

        s->line_fn_tab[0] = s->line_fn_tab[1] =

                g_malloc0(sizeof(blizzard_fn_t) * 0x10);

		      s->cirrus_blt_dstpitch, s->cirrus_blt_srcpitch,

		      s->cirrus_blt_width, s->cirrus_blt_height);

			  sx, sy, dx, dy,

			  s->cirrus_blt_width / depth,

			  s->cirrus_blt_height);

    /* we don't have to notify the display that this portion has

       changed since qemu_console_copy implies this */

static void cirrus_cursor_draw_line(VGACommonState *s1, uint8_t *d1, int scr_y)

{

    CirrusVGAState *s = container_of(s1, CirrusVGAState, vga);

    int w, h, bpp, x1, x2, poffset;

    unsigned int color0, color1;

    const uint8_t *palette, *src;

    color1 = s->vga.rgb_to_pixel(c6_to_8(palette[0xf * 3]),

                                 c6_to_8(palette[0xf * 3 + 1]),

                                 c6_to_8(palette[0xf * 3 + 2]));

    d1 += x1 * bpp;

    default:

        break;

    case 8:

    vga_common_init(s);

    cirrus_init_common(&d->cirrus_vga, CIRRUS_ID_CLGD5430, 0,

                       isa_address_space(dev), isa_address_space_io(dev));

    rom_add_vga(VGABIOS_CIRRUS_FILENAME);

    /* XXX ISA-LFB support */

    /* FIXME not qdev yet */

     vga_common_init(&s->vga);

     cirrus_init_common(s, device_id, 1, pci_address_space(dev),

                        pci_address_space_io(dev));

     /* setup PCI */

typedef struct {

    SysBusDevice busdev;

    MemoryRegion iomem;

    qemu_irq irq[3];

    uint32_t vidcon[4];     /* Video main control registers 0-3 */

static void exynos4210_update_resolution(Exynos4210fimdState *s)

{

    /* LCD resolution is stored in VIDEO TIME CONTROL REGISTER 2 */

    uint32_t width = ((s->vidtcon[2] >> FIMD_VIDTCON2_HOR_SHIFT) &

            FIMD_VIDTCON2_SIZE_MASK) + 1;

    uint32_t height = ((s->vidtcon[2] >> FIMD_VIDTCON2_VER_SHIFT) &

            FIMD_VIDTCON2_SIZE_MASK) + 1;

        DPRINT_L1("Resolution changed from %ux%u to %ux%u\n",

        qemu_console_resize(s->console, width, height);

        s->ifb = g_realloc(s->ifb, width * height * RGBA_SIZE + 1);

        memset(s->ifb, 0, width * height * RGBA_SIZE + 1);

static void exynos4210_fimd_update(void *opaque)

{

    Exynos4210fimdState *s = (Exynos4210fimdState *)opaque;

    Exynos4210fimdWindow *w;

    int i, line;

    hwaddr fb_line_addr, inc_size;

    const int global_height = ((s->vidtcon[2] >> FIMD_VIDTCON2_VER_SHIFT) &

            FIMD_VIDTCON2_SIZE_MASK) + 1;

            !s->enabled) {

        return;

    }

        uint8_t *d;

        int bpp;

        fimd_update_putpix_qemu(bpp);

        bpp = (bpp + 1) >> 3;

        for (line = first_line; line <= last_line; line++) {

            fimd_copy_line_toqemu(global_width, s->ifb + global_width * line *

                    RGBA_SIZE, d + global_width * line * bpp);

/* Render an image from a shared memory framebuffer.  */

void framebuffer_update_display(

    MemoryRegion *address_space,

    hwaddr base,

    int cols, /* Width in pixels.  */

        return;

    }

    src = src_base;

    if (dest_col_pitch < 0)

        dest -= dest_col_pitch * (cols - 1);

    if (dest_row_pitch < 0) {

typedef void (*drawfn)(void *, uint8_t *, const uint8_t *, int, int);

void framebuffer_update_display(

    MemoryRegion *address_space,

    hwaddr base,

    int cols,

    uint32_t top_of_screen;

    uint32_t width, height; /* in pixels */

    /* display refresh support */

    int depth;

    int blanked;

} G364State;

static void g364fb_draw_graphic8(G364State *s)

{

    int i, w;

    uint8_t *vram;

    uint8_t *data_display, *dd;

    int xcursor, ycursor;

    unsigned int (*rgb_to_pixel)(unsigned int r, unsigned int g, unsigned int b);

        case 8:

            rgb_to_pixel = rgb_to_pixel8;

            w = 1;

            break;

        default:

            hw_error("g364: unknown host depth %d",

            return;

    }

    vram = s->vram + s->top_of_screen;

    /* XXX: out of range in vram? */

    while (y < s->height) {

        if (check_dirty(s, page)) {

            if (y < ymin)

                        ymax = s->height - 1;

                        goto done;

                    }

                    xmin = 0;

                    x = 0;

                }

                reset_dirty(s, page_min, page_max);

                page_min = (ram_addr_t)-1;

                page_max = 0;

                               xmax - xmin + 1, ymax - ymin + 1);

                xmin = s->width;

                xmax = 0;

            x = x % s->width;

            y += dy;

            vram += G364_PAGE_SIZE;

            dd = data_display + x * w;

        }

        page += G364_PAGE_SIZE;

done:

    if (page_min != (ram_addr_t)-1) {

        reset_dirty(s, page_min, page_max);

    }

}

static void g364fb_draw_blank(G364State *s)

{

    int i, w;

    uint8_t *d;

        return;

    }

    for (i = 0; i < s->height; i++) {

        memset(d, 0, w);

    }

    s->blanked = 1;

}

static void g364fb_update_display(void *opaque)

{

    G364State *s = opaque;

    qemu_flush_coalesced_mmio_buffer();

    if (s->width == 0 || s->height == 0)

        return;

    }

    if (s->ctla & CTLA_FORCE_BLANK) {

static void g364_invalidate_cursor_position(G364State *s)

{

    int ymin, ymax, start, end;

    /* invalidate only near the cursor */

    ymin = s->cursor_position & 0xfff;

    ymax = MIN(s->height, ymin + 64);

    memory_region_set_dirty(&s->mem_vram, start, end - start);

}

{

    s->vram = g_malloc0(s->vram_size);

    memory_region_init_io(&s->mem_ctrl, &g364fb_ctrl_ops, s, "ctrl", 0x180000);

    memory_region_init_ram_ptr(&s->mem_vram, "vram",

    SysBusDevice busdev;

    MemoryRegion iomem;

    uint8_t segments;

    screen_state_t state;

} LedState;

/***********************************************************/

/* jazz_led display */

{

    uint8_t *d;

    int x, bpp;

    switch(bpp) {

        case 1:

            for (x = posx1; x <= posx2; x++) {

    }

}

{

    uint8_t *d;

    int y, bpp;

    switch(bpp) {

        case 1:

            for (y = posy1; y <= posy2; y++) {

                *((uint8_t *)d) = color;

            }

            break;

        case 2:

            for (y = posy1; y <= posy2; y++) {

                *((uint16_t *)d) = color;

            }

            break;

        case 4:

            for (y = posy1; y <= posy2; y++) {

                *((uint32_t *)d) = color;

            }

            break;

    }

static void jazz_led_update_display(void *opaque)

{

    LedState *s = opaque;

    uint8_t *d1;

    uint32_t color_segment, color_led;

    int y, bpp;

    if (s->state & REDRAW_BACKGROUND) {

        /* clear screen */

        }

    }

    if (s->state & REDRAW_SEGMENTS) {

        /* set colors according to bpp */

            case 8:

                color_segment = rgb_to_pixel8(0xaa, 0xaa, 0xaa);

                color_led = rgb_to_pixel8(0x00, 0xff, 0x00);

        }

        /* display segments */

        /* display led */

        if (!(s->segments & 0x01))

            color_led = 0; /* black */

    }

    s->state = REDRAW_NONE;

}

static void jazz_led_invalidate_display(void *opaque)

    LedState *s = opaque;

    char buf[2];

    /* TODO: draw the segments */

    snprintf(buf, 2, "%02hhx\n", s->segments);

    console_write_ch(chardata++, 0x00200100 | buf[0]);

    console_write_ch(chardata++, 0x00200100 | buf[1]);

}

static int jazz_led_post_load(void *opaque, int version_id)

    memory_region_init_io(&s->iomem, &led_ops, s, "led", 1);

    sysbus_init_mmio(dev, &s->iomem);

    return 0;

}

    s->segments = 0;

    s->state = REDRAW_SEGMENTS | REDRAW_BACKGROUND;

}

static void jazz_led_class_init(ObjectClass *klass, void *data)

struct MilkymistVgafbState {

    SysBusDevice busdev;

    MemoryRegion regs_region;

    int invalidate;

    uint32_t fb_offset;

static void vgafb_update_display(void *opaque)

{

    MilkymistVgafbState *s = opaque;

    int first = 0;

    int last = 0;

    drawfn fn;

    int dest_width = s->regs[R_HRES];

    case 0:

        return;

    case 8:

        break;

    }

                               s->regs[R_BASEADDRESS] + s->fb_offset,

                               s->regs[R_HRES],

                               s->regs[R_VRES],

                               &first, &last);

    if (first >= 0) {

    }

    s->invalidate = 0;

}

        return;

    }

    s->invalidate = 1;

}

            "milkymist-vgafb", R_MAX * 4);

    sysbus_init_mmio(dev, &s->regs_region);

    return 0;

}

    MemoryRegion *sysmem;

    MemoryRegion iomem;

    qemu_irq irq;

    int plm;

    int tft;

static void omap_update_display(void *opaque)

{

    struct omap_lcd_panel_s *omap_lcd = (struct omap_lcd_panel_s *) opaque;

    draw_line_func draw_line;

    int size, height, first, last;

    int width, linesize, step, bpp, frame_offset;

    hwaddr frame_base;

        return;

    frame_offset = 0;

    if (omap_lcd->plm != 2) {

    /* Colour depth */

    switch ((omap_lcd->palette[0] >> 12) & 7) {

    case 1:

        bpp = 2;

        break;

    case 2:

        bpp = 4;

        break;

    case 3:

        bpp = 8;

        break;

    case 4 ... 7:

        if (!omap_lcd->tft)

        else

        bpp = 16;

        break;

    /* Resolution */

    width = omap_lcd->width;

                            omap_lcd->width, omap_lcd->height);

        omap_lcd->invalidate = 1;

    }

    if (omap_lcd->dma->dual)

        omap_lcd->dma->current_frame ^= 1;

        return;

    first = 0;

    height = omap_lcd->height;

    }

    step = width * bpp >> 3;

                               frame_base, width, height,

                               step, linesize, 0,

                               omap_lcd->invalidate,

                               draw_line, omap_lcd->palette,

                               &first, &last);

    if (first >= 0) {

    }

    omap_lcd->invalidate = 0;

}

                             Error **errp)

{

    struct omap_lcd_panel_s *omap_lcd = opaque;

    omap_update_display(opaque);

                    omap_lcd->width, omap_lcd->height,

}

static void omap_invalidate_display(void *opaque) {

    memory_region_init_io(&s->iomem, &omap_lcdc_ops, s, "omap.lcdc", 0x100);

    memory_region_add_subregion(sysmem, base, &s->iomem);

    return s;

}

typedef struct {

    SysBusDevice busdev;

    MemoryRegion iomem;

    int version;

    uint32_t timing[4];

static void pl110_update_display(void *opaque)

{

    pl110_state *s = (pl110_state *)opaque;

    drawfn* fntable;

    drawfn fn;

    int dest_width;

    if (!pl110_enabled(s))

        return;

    case 0:

        return;

    case 8:

    }

    dest_width *= s->cols;

    first = 0;

                               s->upbase, s->cols, s->rows,

                               src_width, dest_width, 0,

                               s->invalidate,

                               fn, s->palette,

                               &first, &last);

    if (first >= 0) {

    }

    s->invalidate = 0;

}

    pl110_state *s = (pl110_state *)opaque;

    s->invalidate = 1;

    if (pl110_enabled(s)) {

    }

}

static void pl110_update_palette(pl110_state *s, int n)

{

    int i;

    uint32_t raw;

    unsigned int r, g, b;

        b = (raw & 0x1f) << 3;

        /* The I bit is ignored.  */

        raw >>= 6;

        case 8:

            s->palette[n] = rgb_to_pixel8(r, g, b);

            break;

{

    if (width != s->cols || height != s->rows) {

        if (pl110_enabled(s)) {

        }

    }

    s->cols = width;

        s->cr = val;

        s->bpp = (val >> 1) & 7;

        if (pl110_enabled(s)) {

        }

        break;

    case 10: /* LCDICR */

    sysbus_init_mmio(dev, &s->iomem);

    sysbus_init_irq(dev, &s->irq);

    qdev_init_gpio_in(&s->busdev.qdev, pl110_mux_ctrl_set, 1);

    return 0;

}

    int irqlevel;

    int invalidated;

    drawfn *line_fn[2];

    int dest_width;

    int xres, yres;

/* Load new palette for a given DMA channel, convert to internal format */

static void pxa2xx_palette_parse(PXA2xxLCDState *s, int ch, int bpp)

{

    int i, n, format, r, g, b, alpha;

    uint32_t *dest;

    uint8_t *src;

            src += 4;

            break;

        }

        case 8:

            *dest = rgb_to_pixel8(r, g, b) | alpha;

            break;

static void pxa2xx_lcdc_dma0_redraw_rot0(PXA2xxLCDState *s,

                hwaddr addr, int *miny, int *maxy)

{

    int src_width, dest_width;

    drawfn fn = NULL;

    if (s->dest_width)

    dest_width = s->xres * s->dest_width;

    *miny = 0;

                               addr, s->xres, s->yres,

                               src_width, dest_width, s->dest_width,

                               s->invalidated,

static void pxa2xx_lcdc_dma0_redraw_rot90(PXA2xxLCDState *s,

               hwaddr addr, int *miny, int *maxy)

{

    int src_width, dest_width;

    drawfn fn = NULL;

    if (s->dest_width)

    dest_width = s->yres * s->dest_width;

    *miny = 0;

                               addr, s->xres, s->yres,

                               src_width, s->dest_width, -dest_width,

                               s->invalidated,

static void pxa2xx_lcdc_dma0_redraw_rot180(PXA2xxLCDState *s,

                hwaddr addr, int *miny, int *maxy)

{

    int src_width, dest_width;

    drawfn fn = NULL;

    if (s->dest_width) {

    dest_width = s->xres * s->dest_width;

    *miny = 0;

                               addr, s->xres, s->yres,

                               src_width, -dest_width, -s->dest_width,

                               s->invalidated,

static void pxa2xx_lcdc_dma0_redraw_rot270(PXA2xxLCDState *s,

               hwaddr addr, int *miny, int *maxy)

{

    int src_width, dest_width;

    drawfn fn = NULL;

    if (s->dest_width) {

    dest_width = s->yres * s->dest_width;

    *miny = 0;

                               addr, s->xres, s->yres,

                               src_width, -s->dest_width, dest_width,

                               s->invalidated,

    if (width != s->xres || height != s->yres) {

        if (s->orientation == 90 || s->orientation == 270) {

        } else {

        }

        s->invalidated = 1;

        s->xres = width;

    if (miny >= 0) {

        switch (s->orientation) {

        case 0:

            break;

        case 90:

            break;

        case 180:

            maxy = s->yres - maxy - 1;

            miny = s->yres - miny - 1;

            break;

        case 270:

            maxy = s->yres - maxy - 1;

            miny = s->yres - miny - 1;

            break;

        }

    }

                                 hwaddr base, qemu_irq irq)

{

    PXA2xxLCDState *s;

    s = (PXA2xxLCDState *) g_malloc0(sizeof(PXA2xxLCDState));

    s->invalidated = 1;

                          "pxa2xx-lcd-controller", 0x00100000);

    memory_region_add_subregion(sysmem, base, &s->iomem);

    case 0:

        s->dest_width = 0;

        break;

static void qxl_blit(PCIQXLDevice *qxl, QXLRect *rect)

{

    uint8_t *src;

    int len, i;

        return;

    }

    if (!qxl->guest_primary.data) {

                (qxl->guest_primary.surface.width,

                 qxl->guest_primary.surface.height);

        }

    }

    for (i = 0; i < qxl->num_dirty_rects; i++) {

        if (qemu_spice_rect_is_empty(qxl->dirty+i)) {

            break;

        }

        qxl_blit(qxl, qxl->dirty+i);

                       qxl->dirty[i].left, qxl->dirty[i].top,

                       qxl->dirty[i].right - qxl->dirty[i].left,

                       qxl->dirty[i].bottom - qxl->dirty[i].top);

        return 1;

    }

        return 0;

    }

    PCIQXLDevice *qxl = DO_UPCAST(PCIQXLDevice, pci, dev);

    VGACommonState *vga = &qxl->vga;

    PortioList *qxl_vga_port_list = g_new(PortioList, 1);

    int rc;

    qxl->id = 0;

    portio_list_init(qxl_vga_port_list, qxl_vga_portio_list, vga, "vga");

    portio_list_add(qxl_vga_port_list, pci_address_space_io(dev), 0x3b0);

    rc = qxl_init_common(qxl);

    if (rc != 0) {

    }

    qxl->ssd.dcl.ops = &display_listener_ops;

    return rc;

}

typedef struct SM501State {

    /* graphic console status */

    /* status & internal resources */

    hwaddr base;

    draw_hwc_line_16bgr,

};

{

    default:

    case 8:

	return 0;

    case 16:

        return 2;

    case 32:

    }

}

static void sm501_draw_crt(SM501State * s)

{

    int y;

    int width = (s->dc_crt_h_total & 0x00000FFF) + 1;

    int height = (s->dc_crt_v_total & 0x00000FFF) + 1;

    uint8_t  * src = s->local_mem;

    int src_bpp = 0;

    uint32_t * palette = (uint32_t *)&s->dc_palette[SM501_DC_CRT_PALETTE

						    - SM501_DC_PANEL_PALETTE];

    uint8_t hwc_palette[3 * 3];

    draw_line_func * draw_line = NULL;

    draw_hwc_line_func * draw_hwc_line = NULL;

    int full_update = 0;

    /* adjust console size */

    if (s->last_width != width || s->last_height != height) {

	s->last_width = width;

	s->last_height = height;

	full_update = 1;

	/* draw line and change status */

	if (update) {

            /* draw graphics layer */

            draw_line(d, src, width, palette);

	} else {

	    if (y_start >= 0) {

		/* flush to display */

		y_start = -1;

	    }

	}

    /* complete flush to display */

    if (y_start >= 0)

    /* clear dirty flags */

    if (page_min != ~0l) {

    }

    /* create qemu graphic console */

}

typedef struct {

    I2CSlave i2c;

    int row;

    int col;

    int start_line;

static void ssd0303_update_display(void *opaque)

{

    ssd0303_state *s = (ssd0303_state *)opaque;

    uint8_t *dest;

    uint8_t *src;

    int x;

    if (!s->redraw)

        return;

    case 0:

        return;

    case 15:

        colors[0] = colortab + dest_width;

        colors[1] = colortab;

    }

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

        line = (y + s->start_line) & 63;

        src = s->framebuffer + 132 * (line >> 3) + 36;

        }

    }

    s->redraw = 0;

}

static void ssd0303_invalidate_display(void * opaque)

{

    ssd0303_state *s = FROM_I2C_SLAVE(ssd0303_state, i2c);

    return 0;

}

typedef struct {

    SSISlave ssidev;

    int cmd_len;

    int cmd;

static void ssd0323_update_display(void *opaque)

{

    ssd0323_state *s = (ssd0323_state *)opaque;

    uint8_t *dest;

    uint8_t *src;

    int x;

    if (!s->redraw)

        return;

    case 0:

        return;

    case 15:

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

        int n;

        colors[i] = p;

        case 15:

            n = i * 2 + (i >> 3);

            p[0] = n | (n << 5);

        p += dest_width;

    }

    /* TODO: Implement row/column remapping.  */

    for (y = 0; y < 64; y++) {

        line = y;

        src = s->framebuffer + 64 * line;

        }

    }

    s->redraw = 0;

}

static void ssd0323_invalidate_display(void * opaque)

    s->col_end = 63;

    s->row_end = 79;