vcs.maemo.org Git - qemu/blob - hw/tcx.c

   1 /*
   2  * QEMU TCX Frame buffer
   3  *
   4  * Copyright (c) 2003-2005 Fabrice Bellard
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
  19  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23  */
  24 #include "vl.h"
  25
  26 #define MAXX 1024
  27 #define MAXY 768
  28 #define TCX_DAC_NREGS 16
  29
  30 typedef struct TCXState {
  31     uint32_t addr;
  32     DisplayState *ds;
  33     uint8_t *vram;
  34     ram_addr_t vram_offset;
  35     uint16_t width, height;
  36     uint8_t r[256], g[256], b[256];
  37     uint32_t palette[256];
  38     uint8_t dac_index, dac_state;
  39 } TCXState;
  40
  41 static void tcx_screen_dump(void *opaque, const char *filename);
  42
  43 /* XXX: unify with vga draw line functions */
  44 static inline unsigned int rgb_to_pixel8(unsigned int r, unsigned int g, unsigned b)
  45 {
  46     return ((r >> 5) << 5) | ((g >> 5) << 2) | (b >> 6);
  47 }
  48
  49 static inline unsigned int rgb_to_pixel15(unsigned int r, unsigned int g, unsigned b)
  50 {
  51     return ((r >> 3) << 10) | ((g >> 3) << 5) | (b >> 3);
  52 }
  53
  54 static inline unsigned int rgb_to_pixel16(unsigned int r, unsigned int g, unsigned b)
  55 {
  56     return ((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3);
  57 }
  58
  59 static inline unsigned int rgb_to_pixel32(unsigned int r, unsigned int g, unsigned b)
  60 {
  61     return (r << 16) | (g << 8) | b;
  62 }
  63
  64 static void update_palette_entries(TCXState *s, int start, int end)
  65 {
  66     int i;
  67     for(i = start; i < end; i++) {
  68         switch(s->ds->depth) {
  69         default:
  70         case 8:
  71             s->palette[i] = rgb_to_pixel8(s->r[i], s->g[i], s->b[i]);
  72             break;
  73         case 15:
  74             s->palette[i] = rgb_to_pixel15(s->r[i], s->g[i], s->b[i]);
  75             break;
  76         case 16:
  77             s->palette[i] = rgb_to_pixel16(s->r[i], s->g[i], s->b[i]);
  78             break;
  79         case 32:
  80             s->palette[i] = rgb_to_pixel32(s->r[i], s->g[i], s->b[i]);
  81             break;
  82         }
  83     }
  84 }
  85
  86 static void tcx_draw_line32(TCXState *s1, uint8_t *d,
  87                             const uint8_t *s, int width)
  88 {
  89     int x;
  90     uint8_t val;
  91
  92     for(x = 0; x < width; x++) {
  93         val = *s++;
  94         *((uint32_t *)d)++ = s1->palette[val];
  95     }
  96 }
  97
  98 static void tcx_draw_line16(TCXState *s1, uint8_t *d,
  99                             const uint8_t *s, int width)
 100 {
 101     int x;
 102     uint8_t val;
 103
 104     for(x = 0; x < width; x++) {
 105         val = *s++;
 106         *((uint16_t *)d)++ = s1->palette[val];
 107     }
 108 }
 109
 110 static void tcx_draw_line8(TCXState *s1, uint8_t *d,
 111                            const uint8_t *s, int width)
 112 {
 113     int x;
 114     uint8_t val;
 115
 116     for(x = 0; x < width; x++) {
 117         val = *s++;
 118         *d++ = s1->palette[val];
 119     }
 120 }
 121
 122 /* Fixed line length 1024 allows us to do nice tricks not possible on
 123    VGA... */
 124 static void tcx_update_display(void *opaque)
 125 {
 126     TCXState *ts = opaque;
 127     ram_addr_t page, page_min, page_max;
 128     int y, y_start, dd, ds;
 129     uint8_t *d, *s;
 130     void (*f)(TCXState *s1, uint8_t *d, const uint8_t *s, int width);
 131
 132     if (ts->ds->depth == 0)
 133         return;
 134     page = ts->vram_offset;
 135     y_start = -1;
 136     page_min = 0xffffffff;
 137     page_max = 0;
 138     d = ts->ds->data;
 139     s = ts->vram;
 140     dd = ts->ds->linesize;
 141     ds = 1024;
 142
 143     switch (ts->ds->depth) {
 144     case 32:
 145         f = tcx_draw_line32;
 146         break;
 147     case 15:
 148     case 16:
 149         f = tcx_draw_line16;
 150         break;
 151     default:
 152     case 8:
 153         f = tcx_draw_line8;
 154         break;
 155     case 0:
 156         return;
 157     }
 158
 159     for(y = 0; y < ts->height; y += 4, page += TARGET_PAGE_SIZE) {
 160         if (cpu_physical_memory_get_dirty(page, VGA_DIRTY_FLAG)) {
 161             if (y_start < 0)
 162                 y_start = y;
 163             if (page < page_min)
 164                 page_min = page;
 165             if (page > page_max)
 166                 page_max = page;
 167             f(ts, d, s, ts->width);
 168             d += dd;
 169             s += ds;
 170             f(ts, d, s, ts->width);
 171             d += dd;
 172             s += ds;
 173             f(ts, d, s, ts->width);
 174             d += dd;
 175             s += ds;
 176             f(ts, d, s, ts->width);
 177             d += dd;
 178             s += ds;
 179         } else {
 180             if (y_start >= 0) {
 181                 /* flush to display */
 182                 dpy_update(ts->ds, 0, y_start,
 183                            ts->width, y - y_start);
 184                 y_start = -1;
 185             }
 186             d += dd * 4;
 187             s += ds * 4;
 188         }
 189     }
 190     if (y_start >= 0) {
 191         /* flush to display */
 192         dpy_update(ts->ds, 0, y_start,
 193                    ts->width, y - y_start);
 194     }
 195     /* reset modified pages */
 196     if (page_min <= page_max) {
 197         cpu_physical_memory_reset_dirty(page_min, page_max + TARGET_PAGE_SIZE,
 198                                         VGA_DIRTY_FLAG);
 199     }
 200 }
 201
 202 static void tcx_invalidate_display(void *opaque)
 203 {
 204     TCXState *s = opaque;
 205     int i;
 206
 207     for (i = 0; i < MAXX*MAXY; i += TARGET_PAGE_SIZE) {
 208         cpu_physical_memory_set_dirty(s->vram_offset + i);
 209     }
 210 }
 211
 212 static void tcx_save(QEMUFile *f, void *opaque)
 213 {
 214     TCXState *s = opaque;
 215
 216     qemu_put_be32s(f, (uint32_t *)&s->addr);
 217     qemu_put_be32s(f, (uint32_t *)&s->vram);
 218     qemu_put_be16s(f, (uint16_t *)&s->height);
 219     qemu_put_be16s(f, (uint16_t *)&s->width);
 220     qemu_put_buffer(f, s->r, 256);
 221     qemu_put_buffer(f, s->g, 256);
 222     qemu_put_buffer(f, s->b, 256);
 223     qemu_put_8s(f, &s->dac_index);
 224     qemu_put_8s(f, &s->dac_state);
 225 }
 226
 227 static int tcx_load(QEMUFile *f, void *opaque, int version_id)
 228 {
 229     TCXState *s = opaque;
 230
 231     if (version_id != 1)
 232         return -EINVAL;
 233
 234     qemu_get_be32s(f, (uint32_t *)&s->addr);
 235     qemu_get_be32s(f, (uint32_t *)&s->vram);
 236     qemu_get_be16s(f, (uint16_t *)&s->height);
 237     qemu_get_be16s(f, (uint16_t *)&s->width);
 238     qemu_get_buffer(f, s->r, 256);
 239     qemu_get_buffer(f, s->g, 256);
 240     qemu_get_buffer(f, s->b, 256);
 241     qemu_get_8s(f, &s->dac_index);
 242     qemu_get_8s(f, &s->dac_state);
 243     update_palette_entries(s, 0, 256);
 244     return 0;
 245 }
 246
 247 static void tcx_reset(void *opaque)
 248 {
 249     TCXState *s = opaque;
 250
 251     /* Initialize palette */
 252     memset(s->r, 0, 256);
 253     memset(s->g, 0, 256);
 254     memset(s->b, 0, 256);
 255     s->r[255] = s->g[255] = s->b[255] = 255;
 256     update_palette_entries(s, 0, 256);
 257     memset(s->vram, 0, MAXX*MAXY);
 258     cpu_physical_memory_reset_dirty(s->vram_offset, s->vram_offset + MAXX*MAXY,
 259                                     VGA_DIRTY_FLAG);
 260     s->dac_index = 0;
 261     s->dac_state = 0;
 262 }
 263
 264 static uint32_t tcx_dac_readl(void *opaque, target_phys_addr_t addr)
 265 {
 266     return 0;
 267 }
 268
 269 static void tcx_dac_writel(void *opaque, target_phys_addr_t addr, uint32_t val)
 270 {
 271     TCXState *s = opaque;
 272     uint32_t saddr;
 273
 274     saddr = (addr & (TCX_DAC_NREGS - 1)) >> 2;
 275     switch (saddr) {
 276     case 0:
 277         s->dac_index = val >> 24;
 278         s->dac_state = 0;
 279         break;
 280     case 1:
 281         switch (s->dac_state) {
 282         case 0:
 283             s->r[s->dac_index] = val >> 24;
 284             update_palette_entries(s, s->dac_index, s->dac_index + 1);
 285             s->dac_state++;
 286             break;
 287         case 1:
 288             s->g[s->dac_index] = val >> 24;
 289             update_palette_entries(s, s->dac_index, s->dac_index + 1);
 290             s->dac_state++;
 291             break;
 292         case 2:
 293             s->b[s->dac_index] = val >> 24;
 294             update_palette_entries(s, s->dac_index, s->dac_index + 1);
 295         default:
 296             s->dac_state = 0;
 297             break;
 298         }
 299         break;
 300     default:
 301         break;
 302     }
 303     return;
 304 }
 305
 306 static CPUReadMemoryFunc *tcx_dac_read[3] = {
 307     tcx_dac_readl,
 308     tcx_dac_readl,
 309     tcx_dac_readl,
 310 };
 311
 312 static CPUWriteMemoryFunc *tcx_dac_write[3] = {
 313     tcx_dac_writel,
 314     tcx_dac_writel,
 315     tcx_dac_writel,
 316 };
 317
 318 void tcx_init(DisplayState *ds, uint32_t addr, uint8_t *vram_base,
 319               unsigned long vram_offset, int vram_size, int width, int height)
 320 {
 321     TCXState *s;
 322     int io_memory;
 323
 324     s = qemu_mallocz(sizeof(TCXState));
 325     if (!s)
 326         return;
 327     s->ds = ds;
 328     s->addr = addr;
 329     s->vram = vram_base;
 330     s->vram_offset = vram_offset;
 331     s->width = width;
 332     s->height = height;
 333
 334     cpu_register_physical_memory(addr + 0x800000, vram_size, vram_offset);
 335     io_memory = cpu_register_io_memory(0, tcx_dac_read, tcx_dac_write, s);
 336     cpu_register_physical_memory(addr + 0x200000, TCX_DAC_NREGS, io_memory);
 337
 338     graphic_console_init(s->ds, tcx_update_display, tcx_invalidate_display,
 339                          tcx_screen_dump, s);
 340     register_savevm("tcx", addr, 1, tcx_save, tcx_load, s);
 341     qemu_register_reset(tcx_reset, s);
 342     tcx_reset(s);
 343     dpy_resize(s->ds, width, height);
 344 }
 345
 346 static void tcx_screen_dump(void *opaque, const char *filename)
 347 {
 348     TCXState *s = opaque;
 349     FILE *f;
 350     uint8_t *d, *d1, v;
 351     int y, x;
 352
 353     f = fopen(filename, "wb");
 354     if (!f)
 355         return;
 356     fprintf(f, "P6\n%d %d\n%d\n", s->width, s->height, 255);
 357     d1 = s->vram;
 358     for(y = 0; y < s->height; y++) {
 359         d = d1;
 360         for(x = 0; x < s->width; x++) {
 361             v = *d;
 362             fputc(s->r[v], f);
 363             fputc(s->g[v], f);
 364             fputc(s->b[v], f);
 365             d++;
 366         }
 367         d1 += MAXX;
 368     }
 369     fclose(f);
 370     return;
 371 }
 372
 373
 374