palacios/src/devices/cga.c

   1 /*
   2  * This file is part of the Palacios Virtual Machine Monitor developed
   3  * by the V3VEE Project with funding from the United States National
   4  * Science Foundation and the Department of Energy.
   5  *
   6  * The V3VEE Project is a joint project between Northwestern University
   7  * and the University of New Mexico.  You can find out more at
   8  * http://www.v3vee.org
   9  *
  10  * Copyright (c) 2009, Robert Deloatch <rtdeloatch@gmail.com>
  11  * Copyright (c) 2009, Steven Jaconette <stevenjaconette2007@u.northwestern.edu>
  12  * Copyright (c) 2009, The V3VEE Project <http://www.v3vee.org>
  13  * All rights reserved.
  14  *
  15  * Author: Robdert Deloatch <rtdeloatch@gmail.com>
  16  *         Steven Jaconette <stevenjaconette2007@u.northwestern.edu>
  17  *
  18  * Initial VGA support added by Erik van der Kouwe <vdkouwe@cs.vu.nl>
  19  *
  20  * This is free software.  You are permitted to use,
  21  * redistribute, and modify it as specified in the file "V3VEE_LICENSE".
  22  */
  23
  24 #include <palacios/vmm.h>
  25 #include <palacios/vmm_dev_mgr.h>
  26 #include <palacios/vmm_emulator.h>
  27 #include <palacios/vm_guest_mem.h>
  28 #include <palacios/vmm_io.h>
  29 #include <palacios/vmm_sprintf.h>
  30
  31 #include <devices/console.h>
  32
  33
  34 #if V3_CONFIG_DEBUG_CGA >= 2
  35 #define PrintVerbose PrintDebug
  36 #else
  37 #define PrintVerbose(fmt, args...)
  38 #endif
  39 #if V3_CONFIG_DEBUG_CGA == 0
  40 #undef PrintDebug
  41 #define PrintDebug(fmt, args...)
  42 #endif
  43
  44
  45 #define START_ADDR 0xA0000
  46 #define END_ADDR 0xC0000
  47
  48 #define FRAMEBUF_SIZE (END_ADDR - START_ADDR)
  49
  50 #define BYTES_PER_COL 2
  51
  52 struct misc_outp_reg {
  53     uint8_t ios         : 1;
  54     uint8_t eram        : 1;
  55     uint8_t cs          : 1;
  56     uint8_t reserved    : 2;
  57     uint8_t vsp         : 1;
  58     uint8_t hsp         : 1;
  59 };
  60
  61 struct seq_data_reg_clocking_mode {
  62     uint8_t d89         : 1;
  63     uint8_t reserved1   : 1;
  64     uint8_t sl          : 1;
  65     uint8_t dc          : 1;
  66     uint8_t sh4         : 1;
  67     uint8_t so          : 1;
  68     uint8_t reserved2   : 2;
  69 };
  70
  71 struct crtc_data_reg_overflow {
  72     uint8_t vt8         : 1;
  73     uint8_t vde8        : 1;
  74     uint8_t vrs8        : 1;
  75     uint8_t vbs8        : 1;
  76     uint8_t lc8         : 1;
  77     uint8_t vt9         : 1;
  78     uint8_t vde9        : 1;
  79     uint8_t vrs9        : 1;
  80 };
  81
  82 struct crtc_data_reg_max_scan_line {
  83     uint8_t msl         : 5;
  84     uint8_t vbs9        : 1;
  85     uint8_t lc9         : 1;
  86     uint8_t dsc         : 1;
  87 };
  88
  89 struct graphc_data_reg_graphics_mode {
  90     uint8_t wm          : 2;
  91     uint8_t reserved1   : 1;
  92     uint8_t rm          : 1;
  93     uint8_t or          : 1;
  94     uint8_t sr          : 1;
  95     uint8_t c256        : 1;
  96     uint8_t reserved2   : 1;
  97 };
  98
  99 struct graphc_data_reg_misc {
 100     uint8_t gm          : 1;
 101     uint8_t oe          : 1;
 102     uint8_t mm          : 2;
 103     uint8_t reserved    : 4;
 104 };
 105
 106 struct attrc_data_reg_attr_mode_control {
 107     uint8_t g           : 1;
 108     uint8_t me          : 1;
 109     uint8_t elg         : 1;
 110     uint8_t eb          : 1;
 111     uint8_t reserved    : 1;
 112     uint8_t pp          : 1;
 113     uint8_t pw          : 1;
 114     uint8_t ps          : 1;
 115 };
 116
 117 #define SEQ_REG_COUNT                           5
 118 #define SEQ_REGIDX_RESET                        0
 119 #define SEQ_REGIDX_CLOCKING_MODE                1
 120 #define SEQ_REGIDX_MAP_MASK                     2
 121 #define SEQ_REGIDX_CHARACTER_MAP_SELECT         3
 122 #define SEQ_REGIDX_MEMORY_MODE                  4
 123
 124 #define CRTC_REG_COUNT                          25
 125 #define CRTC_REGIDX_HORI_TOTAL                  0
 126 #define CRTC_REGIDX_HORI_DISPLAY_ENABLE         1
 127 #define CRTC_REGIDX_START_HORI_BLANKING         2
 128 #define CRTC_REGIDX_END_HORI_BLANKING           3
 129 #define CRTC_REGIDX_START_HORI_RETRACE          4
 130 #define CRTC_REGIDX_END_HORI_RETRACE            5
 131 #define CRTC_REGIDX_VERT_TOTAL                  6
 132 #define CRTC_REGIDX_OVERFLOW                    7
 133 #define CRTC_REGIDX_PRESET_ROW_SCAN             8
 134 #define CRTC_REGIDX_MAX_SCAN_LINE               9
 135 #define CRTC_REGIDX_CURSOR_START                10
 136 #define CRTC_REGIDX_CURSOR_END                  11
 137 #define CRTC_REGIDX_START_ADDR_HIGH             12
 138 #define CRTC_REGIDX_START_ADDR_LOW              13
 139 #define CRTC_REGIDX_CURSOR_LOC_HIGH             14
 140 #define CRTC_REGIDX_CURSOR_LOC_LOW              15
 141 #define CRTC_REGIDX_VERT_RETRACE_START          16
 142 #define CRTC_REGIDX_VERT_RETRACE_END            17
 143 #define CRTC_REGIDX_VERT_DISPLAY_ENABLE_END     18
 144 #define CRTC_REGIDX_OFFSET                      19
 145 #define CRTC_REGIDX_UNDERLINE_LOCATION          20
 146 #define CRTC_REGIDX_START_VERT_BLANKING         21
 147 #define CRTC_REGIDX_END_VERT_BLANKING           22
 148 #define CRTC_REGIDX_CRT_MODE_CONTROL            23
 149 #define CRTC_REGIDX_LINE_COMPATE                24
 150
 151 #define GRAPHC_REG_COUNT                9
 152 #define GRAPHC_REGIDX_SET_RESET         0
 153 #define GRAPHC_REGIDX_ENABLE_SET_RESET  1
 154 #define GRAPHC_REGIDX_COLOR_COMPARE     2
 155 #define GRAPHC_REGIDX_DATA_ROTATE       3
 156 #define GRAPHC_REGIDX_READ_MAP_SELECT   4
 157 #define GRAPHC_REGIDX_GRAPHICS_MODE     5
 158 #define GRAPHC_REGIDX_MISC              6
 159 #define GRAPHC_REGIDX_COLOR_DONT_CARE   7
 160 #define GRAPHC_REGIDX_BIT_MASK          8
 161
 162 #define ATTRC_REG_COUNT                         21
 163 #define ATTRC_REGIDX_PALETTE_0                  0
 164 #define ATTRC_REGIDX_ATTR_MODE_CONTROL          16
 165 #define ATTRC_REGIDX_OVERSCAN_COLOR             17
 166 #define ATTRC_REGIDX_COLOR_PLANE_ENABLE         18
 167 #define ATTRC_REGIDX_HORI_PEL_PANNING           19
 168 #define ATTRC_REGIDX_COLOR_SELECT               20
 169
 170 #define DAC_ENTRY_COUNT                 256
 171 #define DAC_COLOR_COUNT                 3
 172 #define DAC_REG_COUNT                   (DAC_ENTRY_COUNT * DAC_COLOR_COUNT)
 173
 174 struct video_internal {
 175     uint8_t * framebuf;
 176     addr_t framebuf_pa;
 177
 178     /* registers */
 179     struct misc_outp_reg misc_outp_reg;         // io port 3CC (R) / 3C2 (W)
 180     uint8_t seq_index_reg;                      // io port 3C4
 181     uint8_t seq_data_regs[SEQ_REG_COUNT];       // io port 3C5
 182     uint8_t crtc_index_reg;                     // io port 3D4
 183     uint8_t crtc_data_regs[CRTC_REG_COUNT];     // io port 3D5
 184     uint8_t graphc_index_reg;                   // io port 3CE
 185     uint8_t graphc_data_regs[GRAPHC_REG_COUNT]; // io port 3CF
 186     uint8_t attrc_index_flipflop;
 187     uint8_t attrc_index_reg;                    // io port 3C0
 188     uint8_t attrc_data_regs[ATTRC_REG_COUNT];   // io port 3C1 (R) / 3C0 (W)
 189     uint8_t dac_indexr_reg;                     // io port 3C8
 190     uint8_t dac_indexr_color;
 191     uint8_t dac_indexw_reg;                     // io port 3C7
 192     uint8_t dac_indexw_color;
 193     uint8_t dac_data_regs[DAC_REG_COUNT];       // io port 3C9
 194
 195     /* auxilary fields derived from register values */
 196     addr_t activefb_addr;
 197     uint_t activefb_len;
 198     uint16_t iorange;
 199     uint_t vres;
 200     uint_t hres;
 201     uint_t vchars;
 202     uint_t hchars;
 203     int graphmode;
 204
 205     /* status */
 206     int dirty;
 207     int reschanged;
 208
 209     /* IMPORTANT: These are column offsets _NOT_ byte offsets */
 210     uint16_t screen_offset; // relative to the framebuffer
 211     uint16_t cursor_offset; // relative to the framebuffer
 212     /* ** */
 213
 214     struct vm_device * dev;
 215
 216
 217     uint8_t passthrough;
 218
 219
 220     struct v3_console_ops * ops;
 221     void * private_data;
 222
 223
 224
 225 };
 226
 227 static void refresh_screen(struct video_internal * state) {
 228     uint_t screen_size;
 229
 230     PrintDebug("Screen config: framebuf=0x%x-0x%x, gres=%dx%d, tres=%dx%d, %s mode\n",
 231         (unsigned) state->activefb_addr,
 232         (unsigned) state->activefb_addr + state->activefb_len,
 233         state->hres,
 234         state->vres,
 235         state->hchars,
 236         state->vchars,
 237         state->graphmode ? "graphics" : "text");
 238
 239     /* tell the frontend to refresh the screen entirely */
 240     state->dirty = 0;
 241
 242     if (state->reschanged) {
 243         /* resolution change message will trigger update */
 244         state->reschanged = 0;
 245         PrintDebug("Video: set_text_resolution(%d, %d)\n",
 246             state->hchars, state->vchars);
 247         if (state->ops && state->ops->set_text_resolution) {
 248             state->ops->set_text_resolution(state->hchars, state->vchars, state->private_data);
 249         }
 250     } else {
 251         /* send update for full buffer */
 252         PrintDebug("Video: update_screen(0, 0, %d * %d * %d)\n", state->vchars, state->hchars, BYTES_PER_COL);
 253         screen_size = state->vchars * state->hchars * BYTES_PER_COL;
 254         if (state->ops) {
 255             state->ops->update_screen(0, 0, screen_size, state->private_data);
 256         }
 257     }
 258 }
 259
 260 static void registers_updated(struct video_internal * state) {
 261     struct seq_data_reg_clocking_mode *cm;
 262     struct graphc_data_reg_misc *misc;
 263     struct crtc_data_reg_max_scan_line *msl;
 264     struct crtc_data_reg_overflow *ovf;
 265     int lines_per_char;
 266     uint_t activefb_addr, activefb_len, hchars, vchars, vde, hres, vres;
 267
 268     /* framebuffer mapping address */
 269     misc = (struct graphc_data_reg_misc *)(state->graphc_data_regs + GRAPHC_REGIDX_MISC);
 270
 271     if (misc->mm >= 2) {
 272         activefb_addr = (misc->mm == 3) ? 0xb8000 : 0xb0000;
 273         activefb_len = 0x8000;
 274     } else {
 275         activefb_addr = 0xa0000;
 276         activefb_len = (misc->mm == 1) ? 0x10000 : 0x20000;
 277     }
 278
 279     if ((state->activefb_addr != activefb_addr) || (state->activefb_len != activefb_len)) {
 280         state->activefb_addr = activefb_addr;
 281         state->activefb_len = activefb_len;
 282         state->dirty = 1;
 283         PrintVerbose("Video: need refresh (activefb=0x%x-0x%x)\n",
 284             activefb_addr, activefb_addr + activefb_len);
 285     }
 286
 287     /* mode selection; may be inconclusive, keep old value in that case */
 288     if (state->graphmode != misc->gm) {
 289         state->graphmode = misc->gm;
 290         state->dirty = 1;
 291         PrintVerbose("Video: need refresh (graphmode=%d)\n", state->graphmode);
 292     }
 293
 294     /* graphics resolution */
 295     if (state->misc_outp_reg.hsp) {
 296         vres = (state->misc_outp_reg.vsp) ? 480 : 400;
 297     } else {
 298         if (!state->misc_outp_reg.vsp) {
 299             PrintError("Video: reserved value in misc_outp_reg (0x%x)\n",
 300                 *(uint8_t *) &state->misc_outp_reg);
 301         }
 302         vres = 350;
 303     }
 304     msl = (struct crtc_data_reg_max_scan_line *) (
 305         state->crtc_data_regs + CRTC_REGIDX_MAX_SCAN_LINE);
 306     if (msl->dsc) vres /= 2;
 307     if (state->vres != vres) {
 308         state->vres = vres;
 309         state->reschanged = 1;
 310         PrintVerbose("Video: need refresh (vres=%d)\n", vres);
 311     }
 312
 313     switch (state->misc_outp_reg.cs) {
 314         case 0: hres = 640; break;
 315         case 1: hres = 720; break;
 316         default:
 317                 PrintError("Video: reserved value in misc_outp_reg (0x%x)\n",
 318                         *(uint8_t *) &state->misc_outp_reg);
 319                 hres = 640;
 320                 break;
 321     }
 322     cm = (struct seq_data_reg_clocking_mode *) (
 323         state->seq_data_regs + SEQ_REGIDX_CLOCKING_MODE);
 324     if (cm->dc) hres /= 2;
 325     if (state->hres != hres) {
 326         state->hres = hres;
 327         state->reschanged = 1;
 328         PrintVerbose("Video: need refresh (hres=%d)\n", hres);
 329     }
 330
 331     /* text resolution */
 332     ovf = (struct crtc_data_reg_overflow *) (state->crtc_data_regs + CRTC_REGIDX_OVERFLOW);
 333
 334     hchars = state->crtc_data_regs[CRTC_REGIDX_HORI_DISPLAY_ENABLE] + 1;
 335     lines_per_char = msl->msl + 1;
 336     vde = state->crtc_data_regs[CRTC_REGIDX_VERT_DISPLAY_ENABLE_END] |
 337         (((unsigned) ovf->vde8) << 8) |
 338         (((unsigned) ovf->vde9) << 9);
 339     vchars = (vde + 1) / lines_per_char;
 340     if (state->hchars != hchars || state->vchars != vchars) {
 341         state->hchars = hchars;
 342         state->vchars = vchars;
 343         state->reschanged = 1;
 344         PrintVerbose("Video: need refresh (hchars=%d, vchars=%d)\n", hchars, vchars);
 345     }
 346
 347     /* resolution change implies refresh needed */
 348     if (state->reschanged) {
 349         state->dirty = 1;
 350     }
 351
 352     /* IO port range selection */
 353     state->iorange = state->misc_outp_reg.ios ? 0x3d0 : 0x3b0;
 354 }
 355
 356 static void registers_initialize(struct video_internal * state) {
 357
 358     /* initialize the registers; defaults taken from vgatables.h in the VGA
 359      * BIOS, mode 3 (which is specified by IBM as the default mode)
 360      */
 361     static const uint8_t seq_defaults[] = {
 362         0x03, 0x00, 0x03, 0x00, 0x02,
 363     };
 364     static const uint8_t crtc_defaults[] = {
 365         0x5f, 0x4f, 0x50, 0x82, /* 0 - 3 */
 366         0x55, 0x81, 0xbf, 0x1f, /* 4 - 7 */
 367         0x00, 0x4f, 0x0d, 0x0e, /* 8 - 11 */
 368         0x00, 0x00, 0x00, 0x00, /* 12 - 15 */
 369         0x9c, 0x8e, 0x8f, 0x28, /* 16 - 19 */
 370         0x1f, 0x96, 0xb9, 0xa3, /* 20 - 23 */
 371         0xff                    /* 24 */
 372     };
 373     static const uint8_t graphc_defaults[] = {
 374         0x00, 0x00, 0x00, 0x00, /* 0 - 3 */
 375         0x00, 0x10, 0x0e, 0x0f, /* 4 - 7 */
 376         0xff                    /* 8 */
 377     };
 378     static const uint8_t attrc_defaults[] = {
 379         0x00, 0x01, 0x02, 0x03, /* 0 - 3 */
 380         0x04, 0x05, 0x14, 0x07, /* 4 - 7 */
 381         0x38, 0x39, 0x3a, 0x3b, /* 8 - 11 */
 382         0x3c, 0x3d, 0x3e, 0x3f, /* 12 - 15 */
 383         0x0c, 0x00, 0x0f, 0x08, /* 16 - 19 */
 384         0x00,                   /* 20 */
 385     };
 386
 387     /* general registers */
 388     state->misc_outp_reg.ios = 1;
 389     state->misc_outp_reg.eram = 1;
 390     state->misc_outp_reg.cs = 1;
 391     state->misc_outp_reg.hsp = 1;
 392
 393     /* sequencer registers */
 394     V3_ASSERT(sizeof(seq_defaults) == sizeof(state->seq_data_regs));
 395     memcpy(state->seq_data_regs, seq_defaults, sizeof(state->seq_data_regs));
 396
 397     /* CRT controller registers */
 398     V3_ASSERT(sizeof(crtc_defaults) == sizeof(state->crtc_data_regs));
 399     memcpy(state->crtc_data_regs, crtc_defaults, sizeof(state->crtc_data_regs));
 400
 401     /* graphics controller registers */
 402     V3_ASSERT(sizeof(graphc_defaults) == sizeof(state->graphc_data_regs));
 403     memcpy(state->graphc_data_regs, graphc_defaults, sizeof(state->graphc_data_regs));
 404
 405     /* attribute controller registers */
 406     V3_ASSERT(sizeof(attrc_defaults) == sizeof(state->attrc_data_regs));
 407     memcpy(state->attrc_data_regs, attrc_defaults, sizeof(state->attrc_data_regs));
 408
 409     /* initialize auxilary fields */
 410     registers_updated(state);
 411 }
 412
 413 static void passthrough_in(uint16_t port, void * src, uint_t length) {
 414     switch (length) {
 415         case 1:
 416             *(uint8_t *)src = v3_inb(port);
 417             break;
 418         case 2:
 419             *(uint16_t *)src = v3_inw(port);
 420             break;
 421         case 4:
 422             *(uint32_t *)src = v3_indw(port);
 423             break;
 424         default:
 425             break;
 426     }
 427 }
 428
 429
 430 static void passthrough_out(uint16_t port, const void * src, uint_t length) {
 431     switch (length) {
 432         case 1:
 433             v3_outb(port, *(uint8_t *)src);
 434             break;
 435         case 2:
 436             v3_outw(port, *(uint16_t *)src);
 437             break;
 438         case 4:
 439             v3_outdw(port, *(uint32_t *)src);
 440             break;
 441         default:
 442             break;
 443     }
 444 }
 445
 446 #if V3_CONFIG_DEBUG_CGA >= 2
 447 static unsigned long get_value(const void *ptr, int len) {
 448   unsigned long value = 0;
 449
 450   if (len > sizeof(value)) len = sizeof(value);
 451   memcpy(&value, ptr, len);
 452
 453   return value;
 454 }
 455
 456 static char opsize_char(uint_t length) {
 457     switch (length) {
 458     case 1: return 'b';
 459     case 2: return 'w';
 460     case 4: return 'l';
 461     case 8: return 'q';
 462     default: return '?';
 463     }
 464 }
 465 #endif
 466
 467 static int video_write_mem(struct guest_info * core, addr_t guest_addr, void * dest, uint_t length, void * priv_data) {
 468     struct vm_device * dev = (struct vm_device *)priv_data;
 469     struct video_internal * state = (struct video_internal *)dev->private_data;
 470     uint_t length_adjusted, screen_pos, x, y;
 471     addr_t framebuf_offset, framebuf_offset_screen, screen_offset;
 472
 473     V3_ASSERT(guest_addr >= START_ADDR);
 474     V3_ASSERT(guest_addr < END_ADDR);
 475
 476     PrintVerbose("Video: write(%p, 0x%lx, %d)\n",
 477        (void *)guest_addr,
 478         get_value(state->framebuf + (guest_addr - START_ADDR), length),
 479         length);
 480
 481     /* get data written by passthrough into frame buffer if needed */
 482     if (state->passthrough) {
 483         memcpy(state->framebuf + (guest_addr - START_ADDR), V3_VAddr((void *)guest_addr), length);
 484     }
 485
 486     /* refresh the entire screen after the registers have been changed */
 487     if (state->dirty) {
 488         refresh_screen(state);
 489         return length;
 490     }
 491
 492     /* the remainder is only needed if there is a front-end */
 493     if (!state->ops) {
 494         return length;
 495     }
 496
 497     /* write may point into a framebuffer not currently active, for example
 498      * preparing a VGA buffer at 0xA0000 while the CGA text mode at 0xB8000
 499      * is still on the display; in this case we have to ignore (part of) the
 500      * write to avoid buffer overflows
 501      */
 502     length_adjusted = length;
 503     if (state->activefb_addr > guest_addr) {
 504         uint_t diff = state->activefb_addr - guest_addr;
 505         if (diff >= length_adjusted) return length;
 506         guest_addr += diff;
 507         length_adjusted -= diff;
 508     }
 509
 510     framebuf_offset = guest_addr - state->activefb_addr;
 511     if (state->activefb_len <= framebuf_offset) return length;
 512     if (length_adjusted > state->activefb_len - framebuf_offset) {
 513         length_adjusted = state->activefb_len - framebuf_offset;
 514     }
 515
 516     /* determine position on screen, considering wrapping */
 517     framebuf_offset_screen = state->screen_offset * BYTES_PER_COL;
 518     if (framebuf_offset > framebuf_offset_screen) {
 519         screen_offset = framebuf_offset - framebuf_offset_screen;
 520     } else {
 521         screen_offset = framebuf_offset + state->activefb_len - framebuf_offset_screen;
 522     }
 523
 524     /* translate to coordinates and pass to the frontend */
 525     screen_pos = screen_offset / BYTES_PER_COL;
 526     x = screen_pos % state->hchars;
 527     y = screen_pos / state->hchars;
 528     if (y >= state->vchars) return length;
 529     PrintVerbose("Video: update_screen(%d, %d, %d)\n", x, y, length_adjusted);
 530     state->ops->update_screen(x, y, length_adjusted, state->private_data);
 531
 532     return length;
 533 }
 534
 535 static void debug_port(struct video_internal * video_state, const char *function, uint16_t port, uint_t length, uint_t maxlength)
 536 {
 537     uint16_t portrange = port & 0xfff0;
 538
 539     /* report any unexpected guest behaviour, it may explain failures */
 540     if (portrange != 0x3c0 && portrange != video_state->iorange) {
 541         PrintError("Video %s: got bad port 0x%x\n", function, port);
 542     }
 543
 544     if (!video_state->passthrough && length > maxlength) {
 545         PrintError("Video %s: got bad length %d\n", function, length);
 546     }
 547     V3_ASSERT(length >= 1);
 548 }
 549
 550 static void handle_port_read(struct video_internal * video_state, const char *function, uint16_t port, void *dest, uint_t length, uint_t maxlength) {
 551     PrintVerbose("Video %s: in%c(0x%x): 0x%lx\n", function, opsize_char(length), port, get_value(dest, length));
 552     debug_port(video_state, function, port, length, maxlength);
 553
 554     if (video_state->passthrough) {
 555         passthrough_in(port, dest, length);
 556     }
 557 }
 558
 559 static void handle_port_write(struct video_internal * video_state, const char *function, uint16_t port, const void *src, uint_t length, uint_t maxlength) {
 560     PrintVerbose("Video %s: out%c(0x%x, 0x%lx)\n", function, opsize_char(length), port, get_value(src, length));
 561     debug_port(video_state, function, port, length, maxlength);
 562
 563     if (video_state->passthrough) {
 564         passthrough_out(port, src, length);
 565     }
 566 }
 567
 568 static int notimpl_port_read(struct video_internal * video_state, const char *function, uint16_t port, void *dest, uint_t length) {
 569     memset(dest, 0xff, length);
 570     handle_port_read(video_state, function, port, dest, length, 1);
 571     if (!video_state->passthrough) {
 572         PrintError("Video %s: not implemented\n", function);
 573     }
 574     return length;
 575 }
 576
 577 static int notimpl_port_write(struct video_internal * video_state, const char *function, uint16_t port, const void *src, uint_t length) {
 578     handle_port_write(video_state, function, port, src, length, 1);
 579     if (!video_state->passthrough) {
 580         PrintError("Video %s: not implemented\n", function);
 581     }
 582     return length;
 583 }
 584
 585 /* general registers */
 586 static int misc_outp_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 587     struct video_internal * video_state = priv_data;
 588
 589     *(struct misc_outp_reg *) dest = video_state->misc_outp_reg;
 590
 591     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 592     return length;
 593 }
 594
 595 static int misc_outp_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 596     struct video_internal * video_state = priv_data;
 597     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 598
 599     PrintDebug("Video: misc_outp=0x%x\n", *(uint8_t *) src);
 600     video_state->misc_outp_reg = *(struct misc_outp_reg *) src;
 601     registers_updated(video_state);
 602
 603     return length;
 604 }
 605
 606 static int inp_status0_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 607     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
 608 }
 609
 610 static int inp_status1_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 611     struct video_internal * video_state = priv_data;
 612
 613     /* next write to attrc selects the index rather than data */
 614     video_state->attrc_index_flipflop = 0;
 615     memset(dest, 0x0, length);
 616
 617     handle_port_read(priv_data, __FUNCTION__, port, dest, length, 1);
 618     return length;
 619 }
 620
 621 static int feat_ctrl_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 622     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
 623 }
 624
 625 static int feat_ctrl_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 626     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
 627 }
 628
 629 static int video_enable_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 630     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
 631 }
 632
 633 static int video_enable_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 634     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
 635 }
 636
 637 /* sequencer registers */
 638 static int seq_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 639     struct video_internal * video_state = priv_data;
 640     int index = video_state->seq_index_reg;
 641
 642     if (index < SEQ_REG_COUNT) {
 643         *(uint8_t *) dest = video_state->seq_data_regs[index];
 644     } else {
 645         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->seq_index_reg);
 646         *(uint8_t *) dest = 0;
 647     }
 648
 649     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 650     return length;
 651 }
 652
 653 static int seq_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 654     struct video_internal * video_state = priv_data;
 655     int index = video_state->seq_index_reg;
 656     uint8_t val = *(uint8_t *) src;
 657     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 658
 659     if (index < SEQ_REG_COUNT) {
 660         PrintDebug("Video: seq[%d]=0x%x\n", index, val);
 661         video_state->seq_data_regs[index] = val;
 662         registers_updated(video_state);
 663     } else {
 664         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->seq_index_reg);
 665     }
 666
 667     return length;
 668 }
 669
 670 static int seq_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 671     struct video_internal * video_state = priv_data;
 672
 673     *(uint8_t *) dest = video_state->seq_index_reg;
 674
 675     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 676     return length;
 677 }
 678
 679 static int seq_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 680     struct video_internal * video_state = priv_data;
 681     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
 682
 683     video_state->seq_index_reg = *(uint8_t *) src;
 684
 685     if (length > 1) {
 686         if (seq_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
 687             return -1;
 688         }
 689     }
 690
 691     return length;
 692 }
 693
 694 /* CRT controller registers */
 695 static int crtc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 696     struct video_internal * video_state = priv_data;
 697
 698     *(uint8_t *) dest = video_state->crtc_index_reg;
 699
 700     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 701     return length;
 702 }
 703
 704 static int crtc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 705     struct video_internal * video_state = priv_data;
 706     uint8_t val = *(uint8_t *)src;
 707     uint_t index = video_state->crtc_index_reg;
 708
 709     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 710     if (length != 1) {
 711         PrintError("Invalid write length for port 0x%x\n", port);
 712         return -1;
 713     }
 714
 715     video_state->crtc_data_regs[index] = val;
 716     registers_updated(video_state);
 717
 718     switch (index) {
 719
 720         case CRTC_REGIDX_START_ADDR_HIGH: break; // Dealt by low-order byte write
 721         case CRTC_REGIDX_START_ADDR_LOW: {  // Scroll low byte
 722             int diff, refresh;
 723             uint_t screen_offset;
 724
 725             screen_offset =
 726                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_START_ADDR_HIGH] << 8) |
 727                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_START_ADDR_LOW]);
 728             if ((screen_offset - video_state->screen_offset) % video_state->hchars) {
 729                 /* diff is not a multiple of column count, need full refresh */
 730                 diff = 0;
 731                 refresh = 1;
 732             } else {
 733                 /* normal scroll (the common case) */
 734                 diff = (screen_offset - video_state->screen_offset) / video_state->hchars;
 735                 refresh = 0;
 736             }
 737             PrintVerbose("Video: screen_offset=%d, video_state->screen_offset=%d, video_state->hchars=%d, diff=%d, refresh=%d\n",
 738                 screen_offset, video_state->screen_offset, video_state->hchars, diff, refresh);
 739
 740             // Update the true offset value
 741             video_state->screen_offset = screen_offset;
 742
 743             if (refresh || video_state->dirty) {
 744                 refresh_screen(video_state);
 745             } else if (diff && video_state->ops) {
 746                 PrintVerbose("Video: scroll(%d)\n", diff);
 747                 if (video_state->ops->scroll(diff, video_state->private_data) == -1) {
 748                     PrintError("Error sending scroll event\n");
 749                     return -1;
 750                 }
 751             }
 752             break;
 753         }
 754         case CRTC_REGIDX_CURSOR_LOC_HIGH: break; // Dealt by low-order byte write
 755         case CRTC_REGIDX_CURSOR_LOC_LOW: { // Cursor adjustment low byte
 756             uint_t x;
 757             uint_t y;
 758
 759             video_state->cursor_offset =
 760                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_CURSOR_LOC_HIGH] << 8) |
 761                 ((uint16_t) video_state->crtc_data_regs[CRTC_REGIDX_CURSOR_LOC_LOW]);
 762             x = video_state->cursor_offset % video_state->hchars;
 763             y = (video_state->cursor_offset - video_state->screen_offset) / video_state->hchars;
 764             PrintVerbose("Video: video_state->cursor_offset=%d, x=%d, y=%d\n",
 765                 video_state->cursor_offset, x, y);
 766
 767             if (video_state->dirty) {
 768                 refresh_screen(video_state);
 769             }
 770
 771             PrintVerbose("Video: set cursor(%d, %d)\n", x, y);
 772             if (video_state->ops) {
 773                 if (video_state->ops->update_cursor(x, y, video_state->private_data) == -1) {
 774                     PrintError("Error updating cursor\n");
 775                     return -1;
 776                 }
 777             }
 778
 779             break;
 780         }
 781         default:
 782             PrintDebug("Video: crtc[%d]=0x%x\n", index, val);
 783             break;
 784     }
 785
 786     if (video_state->passthrough) {
 787         passthrough_out(port, src, length);
 788     }
 789
 790     return length;
 791 }
 792
 793 static int crtc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 794     struct video_internal * video_state = priv_data;
 795
 796     *(uint8_t *) dest = video_state->crtc_index_reg;
 797
 798     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 799     return length;
 800 }
 801
 802 static int crtc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 803     struct video_internal * video_state = priv_data;
 804
 805     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
 806     if (length > 2) {
 807         PrintError("Invalid write length for crtc index register port: %d (0x%x)\n",
 808                    port, port);
 809         return -1;
 810     }
 811
 812     video_state->crtc_index_reg = *(uint8_t *)src;
 813
 814     // Only do the passthrough IO for the first byte
 815     // the second byte will be done in the data register handler
 816     if (video_state->passthrough) {
 817         passthrough_out(port, src, 1);
 818     }
 819
 820     if (length > 1) {
 821         if (crtc_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
 822             return -1;
 823         }
 824     }
 825
 826     return length;
 827 }
 828
 829 /* graphics controller registers */
 830 static int graphc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 831     struct video_internal * video_state = priv_data;
 832     int index = video_state->graphc_index_reg;
 833
 834     if (index < GRAPHC_REG_COUNT) {
 835         *(uint8_t *) dest = video_state->graphc_data_regs[index];
 836     } else {
 837         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->graphc_index_reg);
 838         *(uint8_t *) dest = 0;
 839     }
 840
 841     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 842     return length;
 843 }
 844
 845 static int graphc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 846     struct video_internal * video_state = priv_data;
 847     int index = video_state->graphc_index_reg;
 848     uint8_t val = *(uint8_t *) src;
 849     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 850
 851     if (index < GRAPHC_REG_COUNT) {
 852         PrintDebug("Video: graphc[%d]=0x%x\n", index, val);
 853         video_state->graphc_data_regs[index] = val;
 854         registers_updated(video_state);
 855     } else {
 856         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->graphc_index_reg);
 857     }
 858
 859     return length;
 860 }
 861
 862 static int graphc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 863     struct video_internal * video_state = priv_data;
 864
 865     *(uint8_t *) dest = video_state->graphc_index_reg;
 866
 867     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 868     return length;
 869 }
 870
 871 static int graphc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 872     struct video_internal * video_state = priv_data;
 873     handle_port_write(video_state, __FUNCTION__, port, src, length, 2);
 874
 875     video_state->graphc_index_reg = *(uint8_t *) src;
 876
 877     if (length > 1) {
 878         if (graphc_data_write(core, port + 1, (uint8_t *) src + 1, length - 1, priv_data) != length - 1) {
 879             return -1;
 880         }
 881     }
 882
 883     return length;
 884 }
 885
 886 /* attribute controller registers */
 887 static int attrc_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 888     struct video_internal * video_state = priv_data;
 889     int index = video_state->attrc_index_reg;
 890
 891     if (index < ATTRC_REG_COUNT) {
 892         *(uint8_t *) dest = video_state->attrc_data_regs[index];
 893     } else {
 894         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->attrc_index_reg);
 895         *(uint8_t *) dest = 0;
 896     }
 897
 898     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 899     return length;
 900 }
 901
 902 static int attrc_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 903     struct video_internal * video_state = priv_data;
 904     int index = video_state->attrc_index_reg;
 905     uint8_t val = *(uint8_t *) src;
 906     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 907
 908     if (index < ATTRC_REG_COUNT) {
 909         PrintDebug("Video: attrc[%d]=0x%x\n", index, val);
 910         video_state->attrc_data_regs[index] = val;
 911     } else {
 912         PrintError("Video %s: index %d out of range\n", __FUNCTION__, video_state->attrc_index_reg);
 913     }
 914
 915     return length;
 916 }
 917
 918 static int attrc_index_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 919     struct video_internal * video_state = priv_data;
 920
 921     *(uint8_t *) dest = video_state->attrc_index_reg;
 922
 923     if (length > 1) {
 924         if (attrc_data_read(core, port + 1, (uint8_t *) dest + 1, length - 1, priv_data) != length - 1) {
 925             return -1;
 926         }
 927     }
 928
 929     handle_port_read(video_state, __FUNCTION__, port, dest, length, 2);
 930     return length;
 931 }
 932
 933 static int attrc_index_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 934     struct video_internal * video_state = priv_data;
 935     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 936
 937     video_state->attrc_index_reg = *(uint8_t *) src;
 938
 939     return length;
 940 }
 941
 942 static int attrc_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 943     struct video_internal * video_state = priv_data;
 944
 945     /* two registers in one, written in an alternating fashion */
 946     if (video_state->attrc_index_flipflop) {
 947         video_state->attrc_index_flipflop = 0;
 948         return attrc_data_write(core, port, src, length, priv_data);
 949     } else {
 950         video_state->attrc_index_flipflop = 1;
 951         return attrc_index_write(core, port, src, length, priv_data);
 952     }
 953 }
 954
 955 /* video DAC palette registers */
 956 static int dac_indexw_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 957     struct video_internal * video_state = priv_data;
 958
 959     *(uint8_t *) dest = video_state->dac_indexw_reg;
 960
 961     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
 962     return length;
 963 }
 964
 965 static int dac_indexw_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 966     struct video_internal * video_state = priv_data;
 967     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 968
 969     video_state->dac_indexw_reg = *(uint8_t *) src;
 970     video_state->dac_indexw_color = 0;
 971
 972     return length;
 973 }
 974
 975 static int dac_indexr_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
 976     struct video_internal * video_state = priv_data;
 977     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
 978
 979     video_state->dac_indexr_reg = *(uint8_t *) src;
 980     video_state->dac_indexr_color = 0;
 981
 982     return length;
 983 }
 984
 985 static int dac_data_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
 986     struct video_internal * video_state = priv_data;
 987     unsigned index;
 988
 989     /* update palette */
 990     index = (unsigned) video_state->dac_indexr_reg * DAC_COLOR_COUNT +
 991         video_state->dac_indexr_color;
 992     V3_ASSERT(index < DAC_REG_COUNT);
 993     *(uint8_t *) dest = video_state->dac_data_regs[index];
 994
 995     /* move on to next entry/color */
 996     if (++video_state->dac_indexr_color > DAC_COLOR_COUNT) {
 997         video_state->dac_indexr_reg++;
 998         video_state->dac_indexr_color -= DAC_COLOR_COUNT;
 999     }
1000
1001     handle_port_read(video_state, __FUNCTION__, port, dest, length, 1);
1002     return length;
1003 }
1004
1005 static int dac_data_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
1006     struct video_internal * video_state = priv_data;
1007     unsigned index;
1008     handle_port_write(video_state, __FUNCTION__, port, src, length, 1);
1009
1010     /* update palette */
1011     index = (unsigned) video_state->dac_indexw_reg * DAC_COLOR_COUNT +
1012         video_state->dac_indexw_color;
1013     V3_ASSERT(index < DAC_REG_COUNT);
1014     video_state->dac_data_regs[index] = *(uint8_t *) src;
1015
1016     /* move on to next entry/color */
1017     if (++video_state->dac_indexw_color > DAC_COLOR_COUNT) {
1018         video_state->dac_indexw_reg++;
1019         video_state->dac_indexw_color -= DAC_COLOR_COUNT;
1020     }
1021
1022     return length;
1023 }
1024
1025 static int dac_pelmask_read(struct guest_info * core, uint16_t port, void * dest, uint_t length, void * priv_data) {
1026     return notimpl_port_read(priv_data, __FUNCTION__, port, dest, length);
1027 }
1028
1029 static int dac_pelmask_write(struct guest_info * core, uint16_t port, void * src, uint_t length, void * priv_data) {
1030     return notimpl_port_write(priv_data, __FUNCTION__, port, src, length);
1031 }
1032
1033
1034 static int v3_cons_get_fb_graph(struct video_internal * state, uint8_t * dst, uint_t offset, uint_t length) {
1035     char c, text[80];
1036     uint_t textlength, textoffset, textsize;
1037
1038     /* this call is not intended for graphics mode, tell the user this */
1039
1040     /* center informative text on 10th line */
1041     snprintf(text, sizeof(text), "* * * GRAPHICS MODE %dx%d * * *",
1042         state->hres, state->vres);
1043     textlength = strlen(text);
1044     textoffset = (state->hchars * 9 + (state->hchars - textlength) / 2) * BYTES_PER_COL;
1045     textsize = textlength * BYTES_PER_COL;
1046
1047     /* fill the buffer */
1048     while (length-- > 0) {
1049         if (offset % BYTES_PER_COL) {
1050             c = 0; /* attribute byte */
1051         } else if (offset < textoffset || offset - textoffset >= textsize) {
1052             c = ' '; /* unused character byte */
1053         } else {
1054             c = text[(offset - textoffset) / BYTES_PER_COL];
1055         }
1056
1057         *(dst++) = c;
1058         offset++;
1059     }
1060
1061     return 0;
1062 }
1063
1064 static uint_t min_uint(uint_t x, uint_t y) {
1065     return (x < y) ? x : y;
1066 }
1067
1068 int v3_cons_get_fb_text(struct video_internal * state, uint8_t * dst, uint_t offset, uint_t length) {
1069     uint8_t *framebuf;
1070     uint_t framebuf_offset, len1, len2;
1071     uint_t screen_byte_offset = state->screen_offset * BYTES_PER_COL;
1072
1073     PrintVerbose("Video: getfb o=%d l=%d so=%d aa=0x%x al=0x%x hc=%d vc=%d\n",
1074         offset, length, state->screen_offset,
1075         (unsigned) state->activefb_addr, (unsigned) state->activefb_len,
1076         state->hchars, state->vchars);
1077     V3_ASSERT(state->activefb_addr >= START_ADDR);
1078     V3_ASSERT(state->activefb_addr + state->activefb_len <= END_ADDR);
1079
1080     /* Copy memory with wrapping (should be configurable, but where else to get the data?) */
1081     framebuf = state->framebuf + (state->activefb_addr - START_ADDR);
1082     framebuf_offset = (screen_byte_offset + offset) % state->activefb_len;
1083     len1 = min_uint(length, state->activefb_len - framebuf_offset);
1084     len2 = length - len1;
1085     if (len1 > 0) memcpy(dst, framebuf + framebuf_offset, len1);
1086     if (len2 > 0) memcpy(dst + len1, framebuf, len2);
1087
1088     return 0;
1089 }
1090
1091 int v3_cons_get_fb(struct vm_device * frontend_dev, uint8_t * dst, uint_t offset, uint_t length) {
1092     struct video_internal * state = (struct video_internal *)frontend_dev->private_data;
1093
1094     /* Deal with call depending on mode */
1095     if (state->graphmode) {
1096         return v3_cons_get_fb_graph(state, dst, offset, length);
1097     } else {
1098         return v3_cons_get_fb_text(state, dst, offset, length);
1099     }
1100 }
1101
1102 static int cga_free(struct video_internal * video_state) {
1103
1104     if (video_state->framebuf_pa) {
1105         PrintError("Freeing framebuffer PA %p\n", (void *)(video_state->framebuf_pa));
1106         V3_FreePages((void *)(video_state->framebuf_pa), (FRAMEBUF_SIZE / 4096));
1107     }
1108
1109     v3_unhook_mem(video_state->dev->vm, V3_MEM_CORE_ANY, START_ADDR);
1110
1111     V3_Free(video_state);
1112
1113     return 0;
1114 }
1115
1116
1117 #ifdef V3_CONFIG_CHECKPOINT
1118 static int cga_save(struct v3_chkpt_ctx * ctx, void * private_data) {
1119     struct video_internal * cga = (struct video_internal *)private_data;
1120
1121     v3_chkpt_save(ctx, "FRAMEBUFFER", FRAMEBUF_SIZE, cga->framebuf);
1122
1123     V3_CHKPT_STD_SAVE(ctx, cga->misc_outp_reg);
1124     V3_CHKPT_STD_SAVE(ctx, cga->seq_index_reg);
1125     V3_CHKPT_STD_SAVE(ctx, cga->seq_data_regs[SEQ_REG_COUNT]);
1126     V3_CHKPT_STD_SAVE(ctx, cga->crtc_index_reg);
1127     V3_CHKPT_STD_SAVE(ctx, cga->crtc_data_regs[CRTC_REG_COUNT]);
1128     V3_CHKPT_STD_SAVE(ctx, cga->graphc_index_reg);
1129     V3_CHKPT_STD_SAVE(ctx, cga->graphc_data_regs[GRAPHC_REG_COUNT]);
1130     V3_CHKPT_STD_SAVE(ctx, cga->attrc_index_flipflop);
1131     V3_CHKPT_STD_SAVE(ctx, cga->attrc_index_reg);
1132     V3_CHKPT_STD_SAVE(ctx, cga->attrc_data_regs[ATTRC_REG_COUNT]);
1133     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexr_reg);
1134     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexr_color);
1135     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexw_reg);
1136     V3_CHKPT_STD_SAVE(ctx, cga->dac_indexw_color);
1137     V3_CHKPT_STD_SAVE(ctx, cga->dac_data_regs[DAC_REG_COUNT]);
1138
1139     V3_CHKPT_STD_SAVE(ctx, cga->activefb_addr);
1140     V3_CHKPT_STD_SAVE(ctx, cga->activefb_len);
1141     V3_CHKPT_STD_SAVE(ctx, cga->iorange);
1142     V3_CHKPT_STD_SAVE(ctx, cga->vres);
1143     V3_CHKPT_STD_SAVE(ctx, cga->hres);
1144     V3_CHKPT_STD_SAVE(ctx, cga->vchars);
1145     V3_CHKPT_STD_SAVE(ctx, cga->hchars);
1146     V3_CHKPT_STD_SAVE(ctx, cga->graphmode);
1147
1148     V3_CHKPT_STD_SAVE(ctx, cga->dirty);
1149     V3_CHKPT_STD_SAVE(ctx, cga->reschanged);
1150
1151     V3_CHKPT_STD_SAVE(ctx, cga->passthrough);
1152
1153     v3_chkpt_save_16(ctx, "SCREEN_OFFSET", &(cga->screen_offset));
1154     v3_chkpt_save_16(ctx, "CURSOR_OFFSET", &(cga->cursor_offset));
1155
1156     return 0;
1157 }
1158
1159 static int cga_load(struct v3_chkpt_ctx * ctx, void * private_data) {
1160     struct video_internal * cga = (struct video_internal *)private_data;
1161
1162     v3_chkpt_load(ctx, "FRAMEBUFFER", FRAMEBUF_SIZE, cga->framebuf);
1163
1164
1165     V3_CHKPT_STD_LOAD(ctx, cga->misc_outp_reg);
1166     V3_CHKPT_STD_LOAD(ctx, cga->seq_index_reg);
1167     V3_CHKPT_STD_LOAD(ctx, cga->seq_data_regs[SEQ_REG_COUNT]);
1168     V3_CHKPT_STD_LOAD(ctx, cga->crtc_index_reg);
1169     V3_CHKPT_STD_LOAD(ctx, cga->crtc_data_regs[CRTC_REG_COUNT]);
1170     V3_CHKPT_STD_LOAD(ctx, cga->graphc_index_reg);
1171     V3_CHKPT_STD_LOAD(ctx, cga->graphc_data_regs[GRAPHC_REG_COUNT]);
1172     V3_CHKPT_STD_LOAD(ctx, cga->attrc_index_flipflop);
1173     V3_CHKPT_STD_LOAD(ctx, cga->attrc_index_reg);
1174     V3_CHKPT_STD_LOAD(ctx, cga->attrc_data_regs[ATTRC_REG_COUNT]);
1175     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexr_reg);
1176     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexr_color);
1177     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexw_reg);
1178     V3_CHKPT_STD_LOAD(ctx, cga->dac_indexw_color);
1179     V3_CHKPT_STD_LOAD(ctx, cga->dac_data_regs[DAC_REG_COUNT]);
1180
1181     V3_CHKPT_STD_LOAD(ctx, cga->activefb_addr);
1182     V3_CHKPT_STD_LOAD(ctx, cga->activefb_len);
1183     V3_CHKPT_STD_LOAD(ctx, cga->iorange);
1184     V3_CHKPT_STD_LOAD(ctx, cga->vres);
1185     V3_CHKPT_STD_LOAD(ctx, cga->hres);
1186     V3_CHKPT_STD_LOAD(ctx, cga->vchars);
1187     V3_CHKPT_STD_LOAD(ctx, cga->hchars);
1188     V3_CHKPT_STD_LOAD(ctx, cga->graphmode);
1189
1190     V3_CHKPT_STD_LOAD(ctx, cga->dirty);
1191     V3_CHKPT_STD_LOAD(ctx, cga->reschanged);
1192
1193     V3_CHKPT_STD_LOAD(ctx, cga->passthrough);
1194
1195     v3_chkpt_load_16(ctx, "SCREEN_OFFSET", &(cga->screen_offset));
1196     v3_chkpt_load_16(ctx, "CURSOR_OFFSET", &(cga->cursor_offset));
1197
1198
1199     return 0;
1200 }
1201
1202 #endif
1203
1204
1205 static struct v3_device_ops dev_ops = {
1206     .free = (int (*)(void *))cga_free,
1207 #ifdef V3_CONFIG_CHECKPOINT
1208     .save = cga_save,
1209     .load = cga_load
1210 #endif
1211
1212 };
1213
1214 static int cga_init(struct v3_vm_info * vm, v3_cfg_tree_t * cfg) {
1215     struct video_internal * video_state = NULL;
1216     char * dev_id = v3_cfg_val(cfg, "ID");
1217     char * passthrough_str = v3_cfg_val(cfg, "passthrough");
1218     int ret = 0;
1219
1220     PrintDebug("video: init_device\n");
1221
1222     video_state = (struct video_internal *)V3_Malloc(sizeof(struct video_internal));
1223     memset(video_state, 0, sizeof(struct video_internal));
1224
1225     struct vm_device * dev = v3_add_device(vm, dev_id, &dev_ops, video_state);
1226
1227     if (dev == NULL) {
1228         PrintError("Could not attach device %s\n", dev_id);
1229         V3_Free(video_state);
1230         return -1;
1231     }
1232
1233     video_state->dev = dev;
1234
1235     video_state->framebuf_pa = (addr_t)V3_AllocPages(FRAMEBUF_SIZE / 4096);
1236     video_state->framebuf = V3_VAddr((void *)(video_state->framebuf_pa));
1237     memset(video_state->framebuf, 0, FRAMEBUF_SIZE);
1238
1239     PrintDebug("PA of array: %p\n", (void *)(video_state->framebuf_pa));
1240
1241     if ((passthrough_str != NULL) &&
1242         (strcasecmp(passthrough_str, "enable") == 0)) {;
1243         video_state->passthrough = 1;
1244     }
1245
1246
1247     if (video_state->passthrough) {
1248         PrintDebug("Enabling CGA Passthrough\n");
1249         if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR,
1250                               START_ADDR, &video_write_mem, dev) == -1) {
1251             PrintError("\n\nVideo Hook failed.\n\n");
1252             return -1;
1253         }
1254     } else {
1255         if (v3_hook_write_mem(vm, V3_MEM_CORE_ANY, START_ADDR, END_ADDR,
1256                               video_state->framebuf_pa, &video_write_mem, dev) == -1) {
1257             PrintError("\n\nVideo Hook failed.\n\n");
1258             return -1;
1259         }
1260     }
1261
1262     /* registers according to http://www.mcamafia.de/pdf/ibm_vgaxga_trm2.pdf */
1263
1264     /* general registers */
1265     ret |= v3_dev_hook_io(dev, 0x3cc, &misc_outp_read, NULL);
1266     ret |= v3_dev_hook_io(dev, 0x3c2, &inp_status0_read, &misc_outp_write);
1267     ret |= v3_dev_hook_io(dev, 0x3ba, &inp_status1_read, &feat_ctrl_write);
1268     ret |= v3_dev_hook_io(dev, 0x3da, &inp_status1_read, &feat_ctrl_write);
1269     ret |= v3_dev_hook_io(dev, 0x3ca, &feat_ctrl_read, NULL);
1270     ret |= v3_dev_hook_io(dev, 0x3c3, &video_enable_read, &video_enable_write);
1271
1272     /* sequencer registers */
1273     ret |= v3_dev_hook_io(dev, 0x3c4, &seq_index_read, &seq_index_write);
1274     ret |= v3_dev_hook_io(dev, 0x3c5, &seq_data_read, &seq_data_write);
1275
1276     /* CRT controller registers, both CGA and VGA ranges */
1277     ret |= v3_dev_hook_io(dev, 0x3b4, &crtc_index_read, &crtc_index_write);
1278     ret |= v3_dev_hook_io(dev, 0x3b5, &crtc_data_read, &crtc_data_write);
1279     ret |= v3_dev_hook_io(dev, 0x3d4, &crtc_index_read, &crtc_index_write);
1280     ret |= v3_dev_hook_io(dev, 0x3d5, &crtc_data_read, &crtc_data_write);
1281
1282     /* graphics controller registers */
1283     ret |= v3_dev_hook_io(dev, 0x3ce, &graphc_index_read, &graphc_index_write);
1284     ret |= v3_dev_hook_io(dev, 0x3cf, &graphc_data_read, &graphc_data_write);
1285
1286     /* attribute controller registers */
1287     ret |= v3_dev_hook_io(dev, 0x3c0, &attrc_index_read, &attrc_write);
1288     ret |= v3_dev_hook_io(dev, 0x3c1, &attrc_data_read, NULL);
1289
1290     /* video DAC palette registers */
1291     ret |= v3_dev_hook_io(dev, 0x3c8, &dac_indexw_read, &dac_indexw_write);
1292     ret |= v3_dev_hook_io(dev, 0x3c7, NULL, &dac_indexr_write);
1293     ret |= v3_dev_hook_io(dev, 0x3c9, &dac_data_read, &dac_data_write);
1294     ret |= v3_dev_hook_io(dev, 0x3c6, &dac_pelmask_read, &dac_pelmask_write);
1295
1296     if (ret != 0) {
1297         PrintError("Error allocating VGA IO ports\n");
1298         v3_remove_device(dev);
1299         return -1;
1300     }
1301
1302     /* initialize the state as it is at boot time */
1303     registers_initialize(video_state);
1304
1305     return 0;
1306 }
1307
1308 device_register("CGA_VIDEO", cga_init);
1309
1310
1311 int v3_console_register_cga(struct vm_device * cga_dev, struct v3_console_ops * ops, void * private_data) {
1312     struct video_internal * video_state = (struct video_internal *)cga_dev->private_data;
1313
1314     video_state->ops = ops;
1315     video_state->private_data = private_data;
1316
1317     return 0;
1318 }