/ - Diff - qemu - Greek Research and Technology Network's projects

b/Makefile.target
672	672	OBJS+= tsc2005.o bt-hci-csr.o
673	673	OBJS+= mst_fpga.o mainstone.o
674	674	OBJS+= musicpal.o pflash_cfi02.o
	675	OBJS+= framebuffer.o
675	676	CPPFLAGS += -DHAS_AUDIO
676	677	endif
677	678	ifeq ($(TARGET_BASE_ARCH), sh4)

     /*
      * Framebuffer device helper routines
+     *
      * Copyright (c) 2009 CodeSourcery
      * Written by Paul Brook <paul@codesourcery.com>
+     *
      * This code is licensed under the GNU GPLv2.
      */
     /* TODO:
        - Do something similar for framebuffers with local ram
        - Handle rotation here instead of hacking dest_pitch
        - Use common pixel conversion routines instead of per-device drawfn
        - Remove all DisplayState knowledge from devices.
      */
     #include "hw.h"
     #include "console.h"
     #include "framebuffer.h"
     #include "kvm.h"
     /* Render an image from a shared memory framebuffer.  */
     void framebuffer_update_display(
         DisplayState *ds,
         target_phys_addr_t base,
         int cols, /* Width in pixels.  */
         int rows, /* Leight in pixels.  */
         int src_width, /* Length of source line, in bytes.  */
         int dest_row_pitch, /* Bytes between adjacent horizontal output pixels.  */
         int dest_col_pitch, /* Bytes between adjacent vertical output pixels.  */
         int invalidate, /* nonzero to redraw the whole image.  */
         drawfn fn,
         void *opaque,
         int *first_row, /* Input and output.  */
         int *last_row /* Output only */)
+    {
         target_phys_addr_t src_len;
         uint8_t *dest;
         uint8_t *src;
         uint8_t *src_base;
         int first, last = 0;
         int dirty;
         int i;
         ram_addr_t addr;
         ram_addr_t pd;
         ram_addr_t pd2;
         i = *first_row;
         *first_row = -1;
         src_len = src_width * rows;
         if (kvm_enabled()) {
             kvm_physical_sync_dirty_bitmap(base, src_len);
+        }
         pd = cpu_get_physical_page_desc(base);
         pd2 = cpu_get_physical_page_desc(base + src_len - 1);
         /* We should reall check that this is a continuous ram region.
            Instead we just check that the first and last pages are
            both ram, and the right distance apart.  */
         if ((pd & ~TARGET_PAGE_MASK) > IO_MEM_ROM
             || (pd2 & ~TARGET_PAGE_MASK) > IO_MEM_ROM) {
             return;
+        }
         pd = (pd & TARGET_PAGE_MASK) + (base & ~TARGET_PAGE_MASK);
         if (((pd + src_len - 1) & TARGET_PAGE_MASK) != (pd2 & TARGET_PAGE_MASK)) {
             return;
+        }
         src_base = cpu_physical_memory_map(base, &src_len, 0);
         /* If we can't map the framebuffer then bail.  We could try harder,
            but it's not really worth it as dirty flag tracking will probably
            already have failed above.  */
         if (!src_base)
             return;
         if (src_len != src_width * rows) {
             cpu_physical_memory_unmap(src_base, src_len, 0, 0);
             return;
+        }
         src = src_base;
         dest = ds_get_data(ds);
         if (dest_col_pitch < 0)
             dest -= dest_col_pitch * (cols - 1);
         first = -1;
         addr = pd;
         addr += i * src_width;
         src += i * src_width;
         dest += i * dest_row_pitch;
         for (; i < rows; i++) {
             target_phys_addr_t dirty_offset;
             dirty = 0;
             dirty_offset = 0;
             while (addr + dirty_offset < TARGET_PAGE_ALIGN(addr + src_width)) {
                 dirty |= cpu_physical_memory_get_dirty(addr + dirty_offset,
                                                        VGA_DIRTY_FLAG);
                 dirty_offset += TARGET_PAGE_SIZE;
+            }
             if (dirty || invalidate) {
                 fn(opaque, dest, src, cols, dest_col_pitch);
                 if (first == -1)
                     first = i;
                 last = i;
+            }
             addr += src_width;
             src += src_width;
             dest += dest_row_pitch;
+        }
         cpu_physical_memory_unmap(src_base, src_len, 0, 0);
         if (first < 0) {
             return;
+        }
         cpu_physical_memory_reset_dirty(pd, pd + src_len, VGA_DIRTY_FLAG);
         *first_row = first;
         *last_row = last;
         return;
+    }

     #ifndef QEMU_FRAMEBUFFER_H
     #define QEMU_FRAMEBUFFER_H
     /* Framebuffer device helper routines.  */
     typedef void (*drawfn)(void *, uint8_t *, const uint8_t *, int, int);
     void framebuffer_update_display(
         DisplayState *ds,
         target_phys_addr_t base,
         int cols,
         int rows,
         int src_width,
         int dest_row_pitch,
         int dest_col_pitch,
         int invalidate,
         drawfn fn,
         void *opaque,
         int *first_row,
         int *last_row);
     #endif

         int dual;
         int current_frame;
         ram_addr_t phys_framebuffer[2];
         target_phys_addr_t phys_framebuffer[2];
         qemu_irq irq;
         struct omap_mpu_state_s *mpu;
     } *omap_dma_get_lcdch(struct soc_dma_s *s);

     /*
      * 2-bit colour
      */
     static void glue(draw_line2_, DEPTH)(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal)
     static void glue(draw_line2_, DEPTH)(void *opaque,
                     uint8_t *d, const uint8_t *s, int width, int deststep)
+    {
         uint16_t *pal = opaque;
         uint8_t v, r, g, b;
         do {
-...
     /*
      * 4-bit colour
      */
     static void glue(draw_line4_, DEPTH)(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal)
     static void glue(draw_line4_, DEPTH)(void *opaque,
                     uint8_t *d, const uint8_t *s, int width, int deststep)
+    {
         uint16_t *pal = opaque;
         uint8_t v, r, g, b;
         do {
-...
     /*
      * 8-bit colour
      */
     static void glue(draw_line8_, DEPTH)(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal)
     static void glue(draw_line8_, DEPTH)(void *opaque,
                     uint8_t *d, const uint8_t *s, int width, int deststep)
+    {
         uint16_t *pal = opaque;
         uint8_t v, r, g, b;
         do {
-...
     /*
      * 12-bit colour
      */
     static void glue(draw_line12_, DEPTH)(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal)
     static void glue(draw_line12_, DEPTH)(void *opaque,
                     uint8_t *d, const uint8_t *s, int width, int deststep)
+    {
         uint16_t v;
         uint8_t r, g, b;
-...
     /*
      * 16-bit colour
      */
     static void glue(draw_line16_, DEPTH)(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal)
     static void glue(draw_line16_, DEPTH)(void *opaque,
                     uint8_t *d, const uint8_t *s, int width, int deststep)
+    {
     #if DEPTH == 16 && defined(WORDS_BIGENDIAN) == defined(TARGET_WORDS_BIGENDIAN)
         memcpy(d, s, width * 2);

     #include "hw.h"
     #include "console.h"
     #include "omap.h"
     #include "framebuffer.h"
     struct omap_lcd_panel_s {
         qemu_irq irq;
-...
     #include "pixel_ops.h"
     typedef void draw_line_func(
                     uint8_t *d, const uint8_t *s, int width, const uint16_t *pal);
     #define draw_line_func drawfn
     #define DEPTH 8
     #include "omap_lcd_template.h"
-...
     #define DEPTH 32
     #include "omap_lcd_template.h"
     static draw_line_func *draw_line_table2[33] = {
     static draw_line_func draw_line_table2[33] = {
         [0 ... 32]	= 0,
         [8]		= draw_line2_8,
         [15]	= draw_line2_15,
         [16]	= draw_line2_16,
         [32]	= draw_line2_32,
     }, *draw_line_table4[33] = {
     }, draw_line_table4[33] = {
         [0 ... 32]	= 0,
         [8]		= draw_line4_8,
         [15]	= draw_line4_15,
         [16]	= draw_line4_16,
         [32]	= draw_line4_32,
     }, *draw_line_table8[33] = {
     }, draw_line_table8[33] = {
         [0 ... 32]	= 0,
         [8]		= draw_line8_8,
         [15]	= draw_line8_15,
         [16]	= draw_line8_16,
         [32]	= draw_line8_32,
     }, *draw_line_table12[33] = {
     }, draw_line_table12[33] = {
         [0 ... 32]	= 0,
         [8]		= draw_line12_8,
         [15]	= draw_line12_15,
         [16]	= draw_line12_16,
         [32]	= draw_line12_32,
     }, *draw_line_table16[33] = {
     }, draw_line_table16[33] = {
         [0 ... 32]	= 0,
         [8]		= draw_line16_8,
         [15]	= draw_line16_15,
-...
     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, dirty[2], minline, maxline, height;
         int line, width, linesize, step, bpp, frame_offset;
         ram_addr_t frame_base, scanline, newline, x;
         uint8_t *s, *d;
         draw_line_func draw_line;
         int size, height, first, last;
         int width, linesize, step, bpp, frame_offset;
         target_phys_addr_t frame_base;
         if (!omap_lcd || omap_lcd->plm == 1 ||
                         !omap_lcd->enable || !ds_get_bits_per_pixel(omap_lcd->state))
-...
         frame_offset = 0;
         if (omap_lcd->plm != 2) {
             memcpy(omap_lcd->palette, phys_ram_base +
                             omap_lcd->dma->phys_framebuffer[
                             omap_lcd->dma->current_frame], 0x200);
             cpu_physical_memory_read(omap_lcd->dma->phys_framebuffer[
                                       omap_lcd->dma->current_frame],
                                      (void *)omap_lcd->palette, 0x200);
             switch (omap_lcd->palette[0] >> 12 & 7) {
             case 3 ... 7:
                 frame_offset += 0x200;
-...
         if (!ds_get_bits_per_pixel(omap_lcd->state))
             return;
         line = 0;
         first = 0;
         height = omap_lcd->height;
         if (omap_lcd->subpanel & (1 << 31)) {
             if (omap_lcd->subpanel & (1 << 29))
                 line = (omap_lcd->subpanel >> 16) & 0x3ff;
                 first = (omap_lcd->subpanel >> 16) & 0x3ff;
             else
                 height = (omap_lcd->subpanel >> 16) & 0x3ff;
             /* TODO: fill the rest of the panel with DPD */
+        }
         step = width * bpp >> 3;
         scanline = frame_base + step * line;
         s = (uint8_t *) (phys_ram_base + scanline);
         d = ds_get_data(omap_lcd->state);
         linesize = ds_get_linesize(omap_lcd->state);
         dirty[0] = dirty[1] =
                 cpu_physical_memory_get_dirty(scanline, VGA_DIRTY_FLAG);
         minline = height;
         maxline = line;
         for (; line < height; line ++) {
             newline = scanline + step;
             for (x = scanline + TARGET_PAGE_SIZE; x < newline;
                             x += TARGET_PAGE_SIZE) {
                 dirty[1] = cpu_physical_memory_get_dirty(x, VGA_DIRTY_FLAG);
                 dirty[0] |= dirty[1];
+            }
             if (dirty[0] || omap_lcd->invalidate) {
                 draw_line(d, s, width, omap_lcd->palette);
                 if (line < minline)
                     minline = line;
                 maxline = line + 1;
+            }
             scanline = newline;
             dirty[0] = dirty[1];
             s += step;
             d += linesize;
+        }
         if (maxline >= minline) {
             dpy_update(omap_lcd->state, 0, minline, width, maxline);
             cpu_physical_memory_reset_dirty(frame_base + step * minline,
                             frame_base + step * maxline, VGA_DIRTY_FLAG);
         framebuffer_update_display(omap_lcd->state,
                                    frame_base, width, height,
                                    step, linesize, 0,
                                    omap_lcd->invalidate,
                                    draw_line, omap_lcd->palette,
                                    &first, &last);
         if (first >= 0) {
             dpy_update(omap_lcd->state, 0, first, width, last - first + 1);
+        }
         omap_lcd->invalidate = 0;
+    }
     static int ppm_save(const char *filename, uint8_t *data,
-...
             return;
+        }
          if (s->dma->src == imif) {
             /* Framebuffers are in SRAM */
             s->dma->phys_framebuffer[0] = s->imif_base +
                     s->dma->src_f1_top - OMAP_IMIF_BASE;
             s->dma->phys_framebuffer[1] = s->imif_base +
                     s->dma->src_f2_top - OMAP_IMIF_BASE;
         } else {
             /* Framebuffers are in RAM */
             s->dma->phys_framebuffer[0] = s->emiff_base +
                     s->dma->src_f1_top - OMAP_EMIFF_BASE;
             s->dma->phys_framebuffer[1] = s->emiff_base +
                     s->dma->src_f2_top - OMAP_EMIFF_BASE;
+        }
         s->dma->phys_framebuffer[0] = s->dma->src_f1_top;
         s->dma->phys_framebuffer[1] = s->dma->src_f2_top;
         if (s->plm != 2 && !s->palette_done) {
             memcpy(s->palette, phys_ram_base +
                     s->dma->phys_framebuffer[s->dma->current_frame], 0x200);
             cpu_physical_memory_read(
                 s->dma->phys_framebuffer[s->dma->current_frame],
                 (void *)s->palette, 0x200);
             s->palette_done = 1;
             omap_lcd_interrupts(s);
+        }

     #include "hw.h"
     #include "primecell.h"
     #include "console.h"
     #include "framebuffer.h"
     #define PL110_CR_EN   0x001
     #define PL110_CR_BGR  0x100
-...
     #include "pixel_ops.h"
     typedef void (*drawfn)(uint32_t *, uint8_t *, const uint8_t *, int);
     #define BITS 8
     #include "pl110_template.h"
     #define BITS 15
-...
         pl110_state *s = (pl110_state *)opaque;
         drawfn* fntable;
         drawfn fn;
         uint32_t *pallette;
         uint32_t addr;
         uint32_t base;
         int dest_width;
         int src_width;
         uint8_t *dest;
         uint8_t *src;
         int first, last = 0;
         int dirty, new_dirty;
         int i;
         int bpp_offset;
         int first;
         int last;
         if (!pl110_enabled(s))
             return;
-...
             break;
+        }
         dest_width *= s->cols;
         pallette = s->pallette;
         base = s->upbase;
         /* HACK: Arm aliases physical memory at 0x80000000.  */
         if (base > 0x80000000)
             base -= 0x80000000;
         src = phys_ram_base + base;
         dest = ds_get_data(s->ds);
         first = -1;
         addr = base;
         dirty = cpu_physical_memory_get_dirty(addr, VGA_DIRTY_FLAG);
         new_dirty = dirty;
         for (i = 0; i < s->rows; i++) {
             if ((addr & ~TARGET_PAGE_MASK) + src_width >= TARGET_PAGE_SIZE) {
                 uint32_t tmp;
                 new_dirty = 0;
                 for (tmp = 0; tmp < src_width; tmp += TARGET_PAGE_SIZE) {
                     new_dirty |= cpu_physical_memory_get_dirty(addr + tmp,
                                                                VGA_DIRTY_FLAG);
+                }
+            }
             if (dirty || new_dirty || s->invalidate) {
                 fn(pallette, dest, src, s->cols);
                 if (first == -1)
                     first = i;
                 last = i;
+            }
             dirty = new_dirty;
             addr += src_width;
             dest += dest_width;
             src += src_width;
         first = 0;
         framebuffer_update_display(s->ds,
                                    s->upbase, s->cols, s->rows,
                                    src_width, dest_width, 0,
                                    s->invalidate,
                                    fn, s->pallette,
                                    &first, &last);
         if (first >= 0) {
             dpy_update(s->ds, 0, first, s->cols, last - first + 1);
+        }
         if (first < 0)
           return;
         s->invalidate = 0;
         cpu_physical_memory_reset_dirty(base + first * src_width,
                                         base + (last + 1) * src_width,
                                         VGA_DIRTY_FLAG);
         dpy_update(s->ds, 0, first, s->cols, last - first + 1);
+    }
     static void pl110_invalidate_display(void * opaque)

b/hw/pl110_template.h
115	115	#define FN_4(x, y) FN_2(x, y) FN_2(x+2, y)
116	116	#define FN_8(y) FN_4(0, y) FN_4(4, y)
117	117
118		static void glue(pl110_draw_line1_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	118	static void glue(pl110_draw_line1_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
119	119	{
	120	uint32_t *pallette = opaque;
120	121	uint32_t data;
121	122	while (width > 0) {
122	123	data = (uint32_t )src;
...	...
142	143	}
143	144	}
144	145
145		static void glue(pl110_draw_line2_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	146	static void glue(pl110_draw_line2_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
146	147	{
	148	uint32_t *pallette = opaque;
147	149	uint32_t data;
148	150	while (width > 0) {
149	151	data = (uint32_t )src;
...	...
169	171	}
170	172	}
171	173
172		static void glue(pl110_draw_line4_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	174	static void glue(pl110_draw_line4_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
173	175	{
	176	uint32_t *pallette = opaque;
174	177	uint32_t data;
175	178	while (width > 0) {
176	179	data = (uint32_t )src;
...	...
196	199	}
197	200	}
198	201
199		static void glue(pl110_draw_line8_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	202	static void glue(pl110_draw_line8_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
200	203	{
	204	uint32_t *pallette = opaque;
201	205	uint32_t data;
202	206	while (width > 0) {
203	207	data = (uint32_t )src;
...	...
219	223	}
220	224	}
221	225
222		static void glue(pl110_draw_line16_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	226	static void glue(pl110_draw_line16_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
223	227	{
224	228	uint32_t data;
225	229	unsigned int r, g, b;
...	...
265	269	}
266	270	}
267	271
268		static void glue(pl110_draw_line32_,NAME)(uint32_t pallette, uint8_t d, const uint8_t *src, int width)
	272	static void glue(pl110_draw_line32_,NAME)(void opaque, uint8_t d, const uint8_t *src, int width, int deststep)
269	273	{
270	274	uint32_t data;
271	275	unsigned int r, g, b;

     #include "pixel_ops.h"
     /* FIXME: For graphic_rotate. Should probably be done in common code.  */
     #include "sysemu.h"
     typedef void (*drawfn)(uint32_t *, uint8_t *, const uint8_t *, int, int);
     #include "framebuffer.h"
     struct pxa2xx_lcdc_s {
         qemu_irq irq;
-...
             int up;
             uint8_t palette[1024];
             uint8_t pbuffer[1024];
             void (*redraw)(struct pxa2xx_lcdc_s *s, uint8_t *fb,
             void (*redraw)(struct pxa2xx_lcdc_s *s, target_phys_addr_t addr,
                             int *miny, int *maxy);
             target_phys_addr_t descriptor;
-...
+    }
     static void pxa2xx_lcdc_dma0_redraw_horiz(struct pxa2xx_lcdc_s *s,
                     uint8_t *fb, int *miny, int *maxy)
                     target_phys_addr_t addr, int *miny, int *maxy)
+    {
         int y, src_width, dest_width, dirty[2];
         uint8_t *src, *dest;
         ram_addr_t x, addr, new_addr, start, end;
         int src_width, dest_width;
         drawfn fn = 0;
         if (s->dest_width)
             fn = s->line_fn[s->transp][s->bpp];
         if (!fn)
             return;
         src = fb;
         src_width = (s->xres + 3) & ~3;     /* Pad to a 4 pixels multiple */
         if (s->bpp == pxa_lcdc_19pbpp || s->bpp == pxa_lcdc_18pbpp)
             src_width *= 3;
-...
         else if (s->bpp > pxa_lcdc_8bpp)
             src_width *= 2;
         dest = ds_get_data(s->ds);
         dest_width = s->xres * s->dest_width;
         addr = (ram_addr_t) (fb - phys_ram_base);
         start = addr + s->yres * src_width;
         end = addr;
         dirty[0] = dirty[1] = cpu_physical_memory_get_dirty(addr, VGA_DIRTY_FLAG);
         for (y = 0; y < s->yres; y ++) {
             new_addr = addr + src_width;
             for (x = addr + TARGET_PAGE_SIZE; x < new_addr;
                             x += TARGET_PAGE_SIZE) {
                 dirty[1] = cpu_physical_memory_get_dirty(x, VGA_DIRTY_FLAG);
                 dirty[0] |= dirty[1];
+            }
             if (dirty[0] || s->invalidated) {
                 fn((uint32_t *) s->dma_ch[0].palette,
                                 dest, src, s->xres, s->dest_width);
                 if (addr < start)
                     start = addr;
                 end = new_addr;
                 if (y < *miny)
                     *miny = y;
                 if (y >= *maxy)
                     *maxy = y + 1;
+            }
             addr = new_addr;
             dirty[0] = dirty[1];
             src += src_width;
             dest += dest_width;
+        }
         if (end > start)
             cpu_physical_memory_reset_dirty(start, end, VGA_DIRTY_FLAG);
         *miny = 0;
         framebuffer_update_display(s->ds,
                                    addr, s->xres, s->yres,
                                    src_width, dest_width, s->dest_width,
                                    s->invalidated,
                                    fn, s->dma_ch[0].palette, miny, maxy);
+    }
     static void pxa2xx_lcdc_dma0_redraw_vert(struct pxa2xx_lcdc_s *s,
                     uint8_t *fb, int *miny, int *maxy)
                    target_phys_addr_t addr, int *miny, int *maxy)
+    {
         int y, src_width, dest_width, dirty[2];
         uint8_t *src, *dest;
         ram_addr_t x, addr, new_addr, start, end;
         int src_width, dest_width;
         drawfn fn = 0;
         if (s->dest_width)
             fn = s->line_fn[s->transp][s->bpp];
         if (!fn)
             return;
         src = fb;
         src_width = (s->xres + 3) & ~3;     /* Pad to a 4 pixels multiple */
         if (s->bpp == pxa_lcdc_19pbpp || s->bpp == pxa_lcdc_18pbpp)
             src_width *= 3;
-...
             src_width *= 2;
         dest_width = s->yres * s->dest_width;
         dest = ds_get_data(s->ds) + dest_width * (s->xres - 1);
         addr = (ram_addr_t) (fb - phys_ram_base);
         start = addr + s->yres * src_width;
         end = addr;
         x = addr + TARGET_PAGE_SIZE;
         dirty[0] = dirty[1] = cpu_physical_memory_get_dirty(start, VGA_DIRTY_FLAG);
         for (y = 0; y < s->yres; y ++) {
             new_addr = addr + src_width;
             for (; x < new_addr; x += TARGET_PAGE_SIZE) {
                 dirty[1] = cpu_physical_memory_get_dirty(x, VGA_DIRTY_FLAG);
                 dirty[0] |= dirty[1];
+            }
             if (dirty[0] || s->invalidated) {
                 fn((uint32_t *) s->dma_ch[0].palette,
                                 dest, src, s->xres, -dest_width);
                 if (addr < start)
                     start = addr;
                 end = new_addr;
                 if (y < *miny)
                     *miny = y;
                 if (y >= *maxy)
                     *maxy = y + 1;
+            }
             addr = new_addr;
             dirty[0] = dirty[1];
             src += src_width;
             dest += s->dest_width;
+        }
         if (end > start)
             cpu_physical_memory_reset_dirty(start, end, VGA_DIRTY_FLAG);
         *miny = 0;
         framebuffer_update_display(s->ds,
                                    addr, s->xres, s->yres,
                                    src_width, s->dest_width, -dest_width,
                                    s->invalidated,
                                    fn, s->dma_ch[0].palette,
                                    miny, maxy);
+    }
     static void pxa2xx_lcdc_resize(struct pxa2xx_lcdc_s *s)
-...
     static void pxa2xx_update_display(void *opaque)
+    {
         struct pxa2xx_lcdc_s *s = (struct pxa2xx_lcdc_s *) opaque;
         uint8_t *fb;
         target_phys_addr_t fbptr;
         int miny, maxy;
         int ch;
-...
                     pxa2xx_dma_ber_set(s, ch);
                     continue;
+                }
                 fbptr -= PXA2XX_SDRAM_BASE;
                 fb = phys_ram_base + fbptr;
                 if (s->dma_ch[ch].command & LDCMD_PAL) {
                     memcpy(s->dma_ch[ch].pbuffer, fb,
                                     MAX(LDCMD_LENGTH(s->dma_ch[ch].command),
                                     sizeof(s->dma_ch[ch].pbuffer)));
                     cpu_physical_memory_read(fbptr, s->dma_ch[ch].pbuffer,
                         MAX(LDCMD_LENGTH(s->dma_ch[ch].command),
                             sizeof(s->dma_ch[ch].pbuffer)));
                     pxa2xx_palette_parse(s, ch, s->bpp);
                 } else {
                     /* Do we need to reparse palette */
-...
                     /* ACK frame start */
                     pxa2xx_dma_sof_set(s, ch);
                     s->dma_ch[ch].redraw(s, fb, &miny, &maxy);
                     s->dma_ch[ch].redraw(s, fbptr, &miny, &maxy);
                     s->invalidated = 0;
                     /* ACK frame completed */
-...
             s->status[0] |= LCSR0_LDD;
+        }
         if (s->orientation)
             dpy_update(s->ds, miny, 0, maxy, s->xres);
         else
             dpy_update(s->ds, 0, miny, s->xres, maxy);
         if (miny >= 0) {
             if (s->orientation)
                 dpy_update(s->ds, miny, 0, maxy, s->xres);
             else
                 dpy_update(s->ds, 0, miny, s->xres, maxy);
+        }
         pxa2xx_lcdc_int_update(s);
         qemu_irq_raise(s->vsync_cb);

b/hw/pxa2xx_template.h
30	30	#define FN_2(x) FN(x + 1) FN(x)
31	31	#define FN_4(x) FN_2(x + 2) FN_2(x)
32	32
33		static void glue(pxa2xx_draw_line2_, BITS)(uint32_t *palette,
	33	static void glue(pxa2xx_draw_line2_, BITS)(void *opaque,
34	34	uint8_t dest, const uint8_t src, int width, int deststep)
35	35	{
	36	uint32_t *palette = opaque;
36	37	uint32_t data;
37	38	while (width > 0) {
38	39	data = (uint32_t ) src;
...	...
54	55	}
55	56	}
56	57
57		static void glue(pxa2xx_draw_line4_, BITS)(uint32_t *palette,
	58	static void glue(pxa2xx_draw_line4_, BITS)(void *opaque,
58	59	uint8_t dest, const uint8_t src, int width, int deststep)
59	60	{
	61	uint32_t *palette = opaque;
60	62	uint32_t data;
61	63	while (width > 0) {
62	64	data = (uint32_t ) src;
...	...
78	80	}
79	81	}
80	82
81		static void glue(pxa2xx_draw_line8_, BITS)(uint32_t *palette,
	83	static void glue(pxa2xx_draw_line8_, BITS)(void *opaque,
82	84	uint8_t dest, const uint8_t src, int width, int deststep)
83	85	{
	86	uint32_t *palette = opaque;
84	87	uint32_t data;
85	88	while (width > 0) {
86	89	data = (uint32_t ) src;
...	...
102	105	}
103	106	}
104	107
105		static void glue(pxa2xx_draw_line16_, BITS)(uint32_t *palette,
	108	static void glue(pxa2xx_draw_line16_, BITS)(void *opaque,
106	109	uint8_t dest, const uint8_t src, int width, int deststep)
107	110	{
108	111	uint32_t data;
...	...
130	133	}
131	134	}
132	135
133		static void glue(pxa2xx_draw_line16t_, BITS)(uint32_t *palette,
	136	static void glue(pxa2xx_draw_line16t_, BITS)(void *opaque,
134	137	uint8_t dest, const uint8_t src, int width, int deststep)
135	138	{
136	139	uint32_t data;
...	...
166	169	}
167	170	}
168	171
169		static void glue(pxa2xx_draw_line18_, BITS)(uint32_t *palette,
	172	static void glue(pxa2xx_draw_line18_, BITS)(void *opaque,
170	173	uint8_t dest, const uint8_t src, int width, int deststep)
171	174	{
172	175	uint32_t data;
...	...
188	191	}
189	192
190	193	/* The wicked packed format */
191		static void glue(pxa2xx_draw_line18p_, BITS)(uint32_t *palette,
	194	static void glue(pxa2xx_draw_line18p_, BITS)(void *opaque,
192	195	uint8_t dest, const uint8_t src, int width, int deststep)
193	196	{
194	197	uint32_t data[3];
...	...
236	239	}
237	240	}
238	241
239		static void glue(pxa2xx_draw_line19_, BITS)(uint32_t *palette,
	242	static void glue(pxa2xx_draw_line19_, BITS)(void *opaque,
240	243	uint8_t dest, const uint8_t src, int width, int deststep)
241	244	{
242	245	uint32_t data;
...	...
262	265	}
263	266
264	267	/* The wicked packed format */
265		static void glue(pxa2xx_draw_line19p_, BITS)(uint32_t *palette,
	268	static void glue(pxa2xx_draw_line19p_, BITS)(void *opaque,
266	269	uint8_t dest, const uint8_t src, int width, int deststep)
267	270	{
268	271	uint32_t data[3];
...	...
326	329	}
327	330	}
328	331
329		static void glue(pxa2xx_draw_line24_, BITS)(uint32_t *palette,
	332	static void glue(pxa2xx_draw_line24_, BITS)(void *opaque,
330	333	uint8_t dest, const uint8_t src, int width, int deststep)
331	334	{
332	335	uint32_t data;
...	...
347	350	}
348	351	}
349	352
350		static void glue(pxa2xx_draw_line24t_, BITS)(uint32_t *palette,
	353	static void glue(pxa2xx_draw_line24t_, BITS)(void *opaque,
351	354	uint8_t dest, const uint8_t src, int width, int deststep)
352	355	{
353	356	uint32_t data;
...	...
372	375	}
373	376	}
374	377
375		static void glue(pxa2xx_draw_line25_, BITS)(uint32_t *palette,
	378	static void glue(pxa2xx_draw_line25_, BITS)(void *opaque,
376	379	uint8_t dest, const uint8_t src, int width, int deststep)
377	380	{
378	381	uint32_t data;

Archipelago » qemu

Revision 714fa308