subsystems/ntvdm/vga.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            vga.c
   5  * PURPOSE:         VGA hardware emulation
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 #include "vga.h"
  14 #include "bios.h"
  15
  16 /* PRIVATE VARIABLES **********************************************************/
  17
  18 static CONST DWORD MemoryBase[]  = { 0xA0000, 0xA0000, 0xB0000, 0xB8000 };
  19 static CONST DWORD MemoryLimit[] = { 0xAFFFF, 0xAFFFF, 0xB7FFF, 0xBFFFF };
  20
  21 static CONST COLORREF VgaDefaultPalette[VGA_MAX_COLORS] =
  22 {
  23     RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0xAA), RGB(0x00, 0xAA, 0x00), RGB(0x00, 0xAA, 0xAA),
  24     RGB(0xAA, 0x00, 0x00), RGB(0xAA, 0x00, 0xAA), RGB(0xAA, 0x55, 0x00), RGB(0xAA, 0xAA, 0xAA),
  25     RGB(0x55, 0x55, 0x55), RGB(0x55, 0x55, 0xFF), RGB(0x55, 0xFF, 0x55), RGB(0x55, 0xFF, 0xFF),
  26     RGB(0xFF, 0x55, 0x55), RGB(0xFF, 0x55, 0xFF), RGB(0xFF, 0xFF, 0x55), RGB(0xFF, 0xFF, 0xFF),
  27     RGB(0x00, 0x00, 0x00), RGB(0x10, 0x10, 0x10), RGB(0x20, 0x20, 0x20), RGB(0x35, 0x35, 0x35),
  28     RGB(0x45, 0x45, 0x45), RGB(0x55, 0x55, 0x55), RGB(0x65, 0x65, 0x65), RGB(0x75, 0x75, 0x75),
  29     RGB(0x8A, 0x8A, 0x8A), RGB(0x9A, 0x9A, 0x9A), RGB(0xAA, 0xAA, 0xAA), RGB(0xBA, 0xBA, 0xBA),
  30     RGB(0xCA, 0xCA, 0xCA), RGB(0xDF, 0xDF, 0xDF), RGB(0xEF, 0xEF, 0xEF), RGB(0xFF, 0xFF, 0xFF),
  31     RGB(0x00, 0x00, 0xFF), RGB(0x41, 0x00, 0xFF), RGB(0x82, 0x00, 0xFF), RGB(0xBE, 0x00, 0xFF),
  32     RGB(0xFF, 0x00, 0xFF), RGB(0xFF, 0x00, 0xBE), RGB(0xFF, 0x00, 0x82), RGB(0xFF, 0x00, 0x41),
  33     RGB(0xFF, 0x00, 0x00), RGB(0xFF, 0x41, 0x00), RGB(0xFF, 0x82, 0x00), RGB(0xFF, 0xBE, 0x00),
  34     RGB(0xFF, 0xFF, 0x00), RGB(0xBE, 0xFF, 0x00), RGB(0x82, 0xFF, 0x00), RGB(0x41, 0xFF, 0x00),
  35     RGB(0x00, 0xFF, 0x00), RGB(0x00, 0xFF, 0x41), RGB(0x00, 0xFF, 0x82), RGB(0x00, 0xFF, 0xBE),
  36     RGB(0x00, 0xFF, 0xFF), RGB(0x00, 0xBE, 0xFF), RGB(0x00, 0x82, 0xFF), RGB(0x00, 0x41, 0xFF),
  37     RGB(0x82, 0x82, 0xFF), RGB(0x9E, 0x82, 0xFF), RGB(0xBE, 0x82, 0xFF), RGB(0xDF, 0x82, 0xFF),
  38     RGB(0xFF, 0x82, 0xFF), RGB(0xFF, 0x82, 0xDF), RGB(0xFF, 0x82, 0xBE), RGB(0xFF, 0x82, 0x9E),
  39     RGB(0xFF, 0x82, 0x82), RGB(0xFF, 0x9E, 0x82), RGB(0xFF, 0xBE, 0x82), RGB(0xFF, 0xDF, 0x82),
  40     RGB(0xFF, 0xFF, 0x82), RGB(0xDF, 0xFF, 0x82), RGB(0xBE, 0xFF, 0x82), RGB(0x9E, 0xFF, 0x82),
  41     RGB(0x82, 0xFF, 0x82), RGB(0x82, 0xFF, 0x9E), RGB(0x82, 0xFF, 0xBE), RGB(0x82, 0xFF, 0xDF),
  42     RGB(0x82, 0xFF, 0xFF), RGB(0x82, 0xDF, 0xFF), RGB(0x82, 0xBE, 0xFF), RGB(0x82, 0x9E, 0xFF),
  43     RGB(0xBA, 0xBA, 0xFF), RGB(0xCA, 0xBA, 0xFF), RGB(0xDF, 0xBA, 0xFF), RGB(0xEF, 0xBA, 0xFF),
  44     RGB(0xFF, 0xBA, 0xFF), RGB(0xFF, 0xBA, 0xEF), RGB(0xFF, 0xBA, 0xDF), RGB(0xFF, 0xBA, 0xCA),
  45     RGB(0xFF, 0xBA, 0xBA), RGB(0xFF, 0xCA, 0xBA), RGB(0xFF, 0xDF, 0xBA), RGB(0xFF, 0xEF, 0xBA),
  46     RGB(0xFF, 0xFF, 0xBA), RGB(0xEF, 0xFF, 0xBA), RGB(0xDF, 0xFF, 0xBA), RGB(0xCA, 0xFF, 0xBA),
  47     RGB(0xBA, 0xFF, 0xBA), RGB(0xBA, 0xFF, 0xCA), RGB(0xBA, 0xFF, 0xDF), RGB(0xBA, 0xFF, 0xEF),
  48     RGB(0xBA, 0xFF, 0xFF), RGB(0xBA, 0xEF, 0xFF), RGB(0xBA, 0xDF, 0xFF), RGB(0xBA, 0xCA, 0xFF),
  49     RGB(0x00, 0x00, 0x71), RGB(0x1C, 0x00, 0x71), RGB(0x39, 0x00, 0x71), RGB(0x55, 0x00, 0x71),
  50     RGB(0x71, 0x00, 0x71), RGB(0x71, 0x00, 0x55), RGB(0x71, 0x00, 0x39), RGB(0x71, 0x00, 0x1C),
  51     RGB(0x71, 0x00, 0x00), RGB(0x71, 0x1C, 0x00), RGB(0x71, 0x39, 0x00), RGB(0x71, 0x55, 0x00),
  52     RGB(0x71, 0x71, 0x00), RGB(0x55, 0x71, 0x00), RGB(0x39, 0x71, 0x00), RGB(0x1C, 0x71, 0x00),
  53     RGB(0x00, 0x71, 0x00), RGB(0x00, 0x71, 0x1C), RGB(0x00, 0x71, 0x39), RGB(0x00, 0x71, 0x55),
  54     RGB(0x00, 0x71, 0x71), RGB(0x00, 0x55, 0x71), RGB(0x00, 0x39, 0x71), RGB(0x00, 0x1C, 0x71),
  55     RGB(0x39, 0x39, 0x71), RGB(0x45, 0x39, 0x71), RGB(0x55, 0x39, 0x71), RGB(0x61, 0x39, 0x71),
  56     RGB(0x71, 0x39, 0x71), RGB(0x71, 0x39, 0x61), RGB(0x71, 0x39, 0x55), RGB(0x71, 0x39, 0x45),
  57     RGB(0x71, 0x39, 0x39), RGB(0x71, 0x45, 0x39), RGB(0x71, 0x55, 0x39), RGB(0x71, 0x61, 0x39),
  58     RGB(0x71, 0x71, 0x39), RGB(0x61, 0x71, 0x39), RGB(0x55, 0x71, 0x39), RGB(0x45, 0x71, 0x39),
  59     RGB(0x39, 0x71, 0x39), RGB(0x39, 0x71, 0x45), RGB(0x39, 0x71, 0x55), RGB(0x39, 0x71, 0x61),
  60     RGB(0x39, 0x71, 0x71), RGB(0x39, 0x61, 0x71), RGB(0x39, 0x55, 0x71), RGB(0x39, 0x45, 0x71),
  61     RGB(0x51, 0x51, 0x71), RGB(0x59, 0x51, 0x71), RGB(0x61, 0x51, 0x71), RGB(0x69, 0x51, 0x71),
  62     RGB(0x71, 0x51, 0x71), RGB(0x71, 0x51, 0x69), RGB(0x71, 0x51, 0x61), RGB(0x71, 0x51, 0x59),
  63     RGB(0x71, 0x51, 0x51), RGB(0x71, 0x59, 0x51), RGB(0x71, 0x61, 0x51), RGB(0x71, 0x69, 0x51),
  64     RGB(0x71, 0x71, 0x51), RGB(0x69, 0x71, 0x51), RGB(0x61, 0x71, 0x51), RGB(0x59, 0x71, 0x51),
  65     RGB(0x51, 0x71, 0x51), RGB(0x51, 0x71, 0x59), RGB(0x51, 0x71, 0x61), RGB(0x51, 0x71, 0x69),
  66     RGB(0x51, 0x71, 0x71), RGB(0x51, 0x69, 0x71), RGB(0x51, 0x61, 0x71), RGB(0x51, 0x59, 0x71),
  67     RGB(0x00, 0x00, 0x41), RGB(0x10, 0x00, 0x41), RGB(0x20, 0x00, 0x41), RGB(0x31, 0x00, 0x41),
  68     RGB(0x41, 0x00, 0x41), RGB(0x41, 0x00, 0x31), RGB(0x41, 0x00, 0x20), RGB(0x41, 0x00, 0x10),
  69     RGB(0x41, 0x00, 0x00), RGB(0x41, 0x10, 0x00), RGB(0x41, 0x20, 0x00), RGB(0x41, 0x31, 0x00),
  70     RGB(0x41, 0x41, 0x00), RGB(0x31, 0x41, 0x00), RGB(0x20, 0x41, 0x00), RGB(0x10, 0x41, 0x00),
  71     RGB(0x00, 0x41, 0x00), RGB(0x00, 0x41, 0x10), RGB(0x00, 0x41, 0x20), RGB(0x00, 0x41, 0x31),
  72     RGB(0x00, 0x41, 0x41), RGB(0x00, 0x31, 0x41), RGB(0x00, 0x20, 0x41), RGB(0x00, 0x10, 0x41),
  73     RGB(0x20, 0x20, 0x41), RGB(0x28, 0x20, 0x41), RGB(0x31, 0x20, 0x41), RGB(0x39, 0x20, 0x41),
  74     RGB(0x41, 0x20, 0x41), RGB(0x41, 0x20, 0x39), RGB(0x41, 0x20, 0x31), RGB(0x41, 0x20, 0x28),
  75     RGB(0x41, 0x20, 0x20), RGB(0x41, 0x28, 0x20), RGB(0x41, 0x31, 0x20), RGB(0x41, 0x39, 0x20),
  76     RGB(0x41, 0x41, 0x20), RGB(0x39, 0x41, 0x20), RGB(0x31, 0x41, 0x20), RGB(0x28, 0x41, 0x20),
  77     RGB(0x20, 0x41, 0x20), RGB(0x20, 0x41, 0x28), RGB(0x20, 0x41, 0x31), RGB(0x20, 0x41, 0x39),
  78     RGB(0x20, 0x41, 0x41), RGB(0x20, 0x39, 0x41), RGB(0x20, 0x31, 0x41), RGB(0x20, 0x28, 0x41),
  79     RGB(0x2D, 0x2D, 0x41), RGB(0x31, 0x2D, 0x41), RGB(0x35, 0x2D, 0x41), RGB(0x3D, 0x2D, 0x41),
  80     RGB(0x41, 0x2D, 0x41), RGB(0x41, 0x2D, 0x3D), RGB(0x41, 0x2D, 0x35), RGB(0x41, 0x2D, 0x31),
  81     RGB(0x41, 0x2D, 0x2D), RGB(0x41, 0x31, 0x2D), RGB(0x41, 0x35, 0x2D), RGB(0x41, 0x3D, 0x2D),
  82     RGB(0x41, 0x41, 0x2D), RGB(0x3D, 0x41, 0x2D), RGB(0x35, 0x41, 0x2D), RGB(0x31, 0x41, 0x2D),
  83     RGB(0x2D, 0x41, 0x2D), RGB(0x2D, 0x41, 0x31), RGB(0x2D, 0x41, 0x35), RGB(0x2D, 0x41, 0x3D),
  84     RGB(0x2D, 0x41, 0x41), RGB(0x2D, 0x3D, 0x41), RGB(0x2D, 0x35, 0x41), RGB(0x2D, 0x31, 0x41),
  85     RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00),
  86     RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00), RGB(0x00, 0x00, 0x00)
  87 };
  88
  89 static BYTE VgaMemory[VGA_NUM_BANKS * VGA_BANK_SIZE];
  90 static BYTE VgaLatchRegisters[VGA_NUM_BANKS] = {0, 0, 0, 0};
  91 static BYTE VgaMiscRegister;
  92 static BYTE VgaSeqIndex = VGA_SEQ_RESET_REG;
  93 static BYTE VgaSeqRegisters[VGA_SEQ_MAX_REG];
  94 static BYTE VgaGcIndex = VGA_GC_RESET_REG;
  95 static BYTE VgaGcRegisters[VGA_GC_MAX_REG];
  96 static BYTE VgaCrtcIndex = VGA_CRTC_HORZ_TOTAL_REG;
  97 static BYTE VgaCrtcRegisters[VGA_CRTC_MAX_REG];
  98 static BYTE VgaAcIndex = VGA_AC_PAL_0_REG;
  99 static BOOLEAN VgaAcLatch = FALSE;
 100 static BYTE VgaAcRegisters[VGA_AC_MAX_REG];
 101 static WORD VgaDacIndex = 0;
 102 static BOOLEAN VgaDacReadWrite = FALSE;
 103 static BYTE VgaDacRegisters[VGA_PALETTE_SIZE];
 104 static HPALETTE PaletteHandle = NULL;
 105 static BOOLEAN InVerticalRetrace = FALSE;
 106 static BOOLEAN InHorizontalRetrace = FALSE;
 107 static HANDLE TextConsoleBuffer = NULL;
 108 static HANDLE GraphicsConsoleBuffer = NULL;
 109 static LPVOID ConsoleFramebuffer = NULL;
 110 static HANDLE ConsoleMutex = NULL;
 111 static BOOLEAN NeedsUpdate = FALSE;
 112 static BOOLEAN ModeChanged = TRUE;
 113 static BOOLEAN CursorMoved = FALSE;
 114 static BOOLEAN PaletteChanged = FALSE;
 115 static BOOLEAN TextMode = TRUE;
 116 static SMALL_RECT UpdateRectangle = { 0, 0, 0, 0 };
 117
 118 /* PRIVATE FUNCTIONS **********************************************************/
 119
 120 static inline INT VgaGetAddressSize(VOID)
 121 {
 122     if (VgaCrtcRegisters[VGA_CRTC_UNDERLINE_REG] & VGA_CRTC_UNDERLINE_DWORD)
 123     {
 124         /* Double-word addressing */
 125         return 4;
 126     }
 127
 128     if (VgaCrtcRegisters[VGA_CRTC_MODE_CONTROL_REG] & VGA_CRTC_MODE_CONTROL_BYTE)
 129     {
 130         /* Byte addressing */
 131         return 1;
 132     }
 133
 134     /* Word addressing */
 135     return 2;
 136 }
 137
 138 static inline DWORD VgaTranslateReadAddress(DWORD Address)
 139 {
 140     DWORD Offset = Address - VgaGetVideoBaseAddress();
 141     BYTE Plane;
 142
 143     /* Check for chain-4 and odd-even mode */
 144     if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
 145     {
 146         /* The lowest two bits are the plane number */
 147         Plane = Offset & 3;
 148         Offset >>= 2;
 149     }
 150     else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
 151     {
 152         /* The LSB is the plane number */
 153         Plane = Offset & 1;
 154         Offset >>= 1;
 155     }
 156     else
 157     {
 158         /* Use the read mode */
 159         Plane = VgaGcRegisters[VGA_GC_READ_MAP_SEL_REG] & 0x03;
 160     }
 161
 162     /* Multiply the offset by the address size */
 163     Offset *= VgaGetAddressSize();
 164
 165     return Offset + Plane * VGA_BANK_SIZE;
 166 }
 167
 168 static inline DWORD VgaTranslateWriteAddress(DWORD Address)
 169 {
 170     DWORD Offset = Address - VgaGetVideoBaseAddress();
 171
 172     /* Check for chain-4 and odd-even mode */
 173     if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
 174     {
 175         /* Shift the offset to the right by 2 */
 176         Offset >>= 2;
 177     }
 178     else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
 179     {
 180         /* Shift the offset to the right by 1 */
 181         Offset >>= 1;
 182     }
 183
 184     /* Multiply the offset by the address size */
 185     Offset *= VgaGetAddressSize();
 186
 187     /* Return the offset on plane 0 */
 188     return Offset;
 189 }
 190
 191 static inline BYTE VgaTranslateByteForWriting(BYTE Data, BYTE Plane)
 192 {
 193     BYTE WriteMode = VgaGcRegisters[VGA_GC_MODE_REG] & 3;
 194     BYTE LogicalOperation = (VgaGcRegisters[VGA_GC_ROTATE_REG] >> 3) & 3;
 195     BYTE RotateCount = VgaGcRegisters[VGA_GC_ROTATE_REG] & 7;
 196     BYTE BitMask = VgaGcRegisters[VGA_GC_BITMASK_REG];
 197
 198     if (WriteMode == 1)
 199     {
 200         /* In write mode 1 just return the latch register */
 201         return VgaLatchRegisters[Plane];
 202     }
 203
 204     if (WriteMode != 2)
 205     {
 206         /* Write modes 0 and 3 rotate the data to the right first */
 207         Data = LOBYTE(((DWORD)Data >> RotateCount) | ((DWORD)Data << (8 - RotateCount)));
 208     }
 209     else
 210     {
 211         /* Write mode 2 expands the appropriate bit to all 8 bits */
 212         Data = (Data & (1 << Plane)) ? 0xFF : 0x00;
 213     }
 214
 215     if (WriteMode == 0)
 216     {
 217         /*
 218          * In write mode 0, the enable set/reset register decides if the
 219          * set/reset bit should be expanded to all 8 bits.
 220          */
 221         if (VgaGcRegisters[VGA_GC_ENABLE_RESET_REG] & (1 << Plane))
 222         {
 223             /* Copy the bit from the set/reset register to all 8 bits */
 224             Data = (VgaGcRegisters[VGA_GC_RESET_REG] & (1 << Plane)) ? 0xFF : 0x00;
 225         }
 226     }
 227
 228     if (WriteMode != 3)
 229     {
 230         /* Write modes 0 and 2 then perform a logical operation on the data and latch */
 231         if (LogicalOperation == 1) Data &= VgaLatchRegisters[Plane];
 232         else if (LogicalOperation == 2) Data |= VgaLatchRegisters[Plane];
 233         else if (LogicalOperation == 3) Data ^= VgaLatchRegisters[Plane];
 234     }
 235     else
 236     {
 237         /* For write mode 3, we AND the bitmask with the data, which is used as the new bitmask */
 238         BitMask &= Data;
 239
 240         /* Then we expand the bit in the set/reset field */
 241         Data = (VgaGcRegisters[VGA_GC_RESET_REG] & (1 << Plane)) ? 0xFF : 0x00;
 242     }
 243
 244     /* Bits cleared in the bitmask are replaced with latch register bits */
 245     Data = (Data & BitMask) | (VgaLatchRegisters[Plane] & (~BitMask));
 246
 247     /* Return the byte */
 248     return Data;
 249 }
 250
 251 static inline VOID VgaMarkForUpdate(SHORT Row, SHORT Column)
 252 {
 253     DPRINT("VgaMarkForUpdate: Row %d, Column %d\n", Row, Column);
 254
 255     /* Check if this is the first time the rectangle is updated */
 256     if (!NeedsUpdate)
 257     {
 258         UpdateRectangle.Left = UpdateRectangle.Top = SHRT_MAX;
 259         UpdateRectangle.Right = UpdateRectangle.Bottom = SHRT_MIN;
 260     }
 261
 262     /* Expand the rectangle to include the point */
 263     UpdateRectangle.Left = min(UpdateRectangle.Left, Column);
 264     UpdateRectangle.Right = max(UpdateRectangle.Right, Column);
 265     UpdateRectangle.Top = min(UpdateRectangle.Top, Row);
 266     UpdateRectangle.Bottom = max(UpdateRectangle.Bottom, Row);
 267
 268     /* Set the update request flag */
 269     NeedsUpdate = TRUE;
 270 }
 271
 272 static VOID VgaWriteSequencer(BYTE Data)
 273 {
 274     ASSERT(VgaSeqIndex < VGA_SEQ_MAX_REG);
 275
 276     /* Save the value */
 277     VgaSeqRegisters[VgaSeqIndex] = Data;
 278 }
 279
 280 static VOID VgaWriteGc(BYTE Data)
 281 {
 282     ASSERT(VgaGcIndex < VGA_GC_MAX_REG);
 283
 284     /* Save the value */
 285     VgaGcRegisters[VgaGcIndex] = Data;
 286
 287     /* Check the index */
 288     switch (VgaGcIndex)
 289     {
 290         case VGA_GC_MISC_REG:
 291         {
 292             /* The GC misc register decides if it's text or graphics mode */
 293             ModeChanged = TRUE;
 294
 295             break;
 296         }
 297     }
 298 }
 299
 300 static VOID VgaWriteCrtc(BYTE Data)
 301 {
 302     ASSERT(VgaGcIndex < VGA_CRTC_MAX_REG);
 303
 304     /* Save the value */
 305     VgaCrtcRegisters[VgaCrtcIndex] = Data;
 306
 307     /* Check the index */
 308     switch (VgaCrtcIndex)
 309     {
 310         case VGA_CRTC_END_HORZ_DISP_REG:
 311         case VGA_CRTC_VERT_DISP_END_REG:
 312         case VGA_CRTC_OVERFLOW_REG:
 313         {
 314             /* The video mode has changed */
 315             ModeChanged = TRUE;
 316
 317             break;
 318         }
 319
 320         case VGA_CRTC_CURSOR_LOC_LOW_REG:
 321         case VGA_CRTC_CURSOR_LOC_HIGH_REG:
 322         case VGA_CRTC_CURSOR_START_REG:
 323         case VGA_CRTC_CURSOR_END_REG:
 324         {
 325             /* Set the cursor moved flag */
 326             CursorMoved = TRUE;
 327
 328             break;
 329         }
 330     }
 331 }
 332
 333 static VOID VgaWriteDac(BYTE Data)
 334 {
 335     INT PaletteIndex;
 336     PALETTEENTRY Entry;
 337
 338     /* Set the value */
 339     VgaDacRegisters[VgaDacIndex] = Data;
 340
 341     /* Find the palette index */
 342     PaletteIndex = VgaDacIndex / 3;
 343
 344     /* Fill the entry structure */
 345     Entry.peRed = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3]);
 346     Entry.peGreen = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3 + 1]);
 347     Entry.peBlue = VGA_DAC_TO_COLOR(VgaDacRegisters[PaletteIndex * 3 + 2]);
 348     Entry.peFlags = 0;
 349
 350     /* Update the palette entry */
 351     SetPaletteEntries(PaletteHandle, PaletteIndex, 1, &Entry);
 352
 353     /* Set the palette change flag */
 354     PaletteChanged = TRUE;
 355
 356     /* Update the index */
 357     VgaDacIndex++;
 358     VgaDacIndex %= VGA_PALETTE_SIZE;
 359 }
 360
 361 static VOID VgaWriteAc(BYTE Data)
 362 {
 363     ASSERT(VgaAcIndex < VGA_AC_MAX_REG);
 364
 365     /* Save the value */
 366     VgaAcRegisters[VgaAcIndex] = Data;
 367 }
 368
 369 static BOOL VgaEnterGraphicsMode(PCOORD Resolution)
 370 {
 371     DWORD i;
 372     CONSOLE_GRAPHICS_BUFFER_INFO GraphicsBufferInfo;
 373     BYTE BitmapInfoBuffer[VGA_BITMAP_INFO_SIZE];
 374     LPBITMAPINFO BitmapInfo = (LPBITMAPINFO)BitmapInfoBuffer;
 375     LPWORD PaletteIndex = (LPWORD)(BitmapInfo->bmiColors);
 376
 377     /* Fill the bitmap info header */
 378     ZeroMemory(&BitmapInfo->bmiHeader, sizeof(BITMAPINFOHEADER));
 379     BitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
 380     BitmapInfo->bmiHeader.biWidth = Resolution->X;
 381     BitmapInfo->bmiHeader.biHeight = Resolution->Y;
 382     BitmapInfo->bmiHeader.biBitCount = 8;
 383     BitmapInfo->bmiHeader.biPlanes = 1;
 384     BitmapInfo->bmiHeader.biCompression = BI_RGB;
 385     BitmapInfo->bmiHeader.biSizeImage = Resolution->X * Resolution->Y /* * 1 == biBitCount / 8 */;
 386
 387     /* Fill the palette data */
 388     for (i = 0; i < (VGA_PALETTE_SIZE / 3); i++) PaletteIndex[i] = (WORD)i;
 389
 390     /* Fill the console graphics buffer info */
 391     GraphicsBufferInfo.dwBitMapInfoLength = VGA_BITMAP_INFO_SIZE;
 392     GraphicsBufferInfo.lpBitMapInfo = BitmapInfo;
 393     GraphicsBufferInfo.dwUsage = DIB_PAL_COLORS;
 394
 395     /* Create the buffer */
 396     GraphicsConsoleBuffer = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
 397                                                       FILE_SHARE_READ | FILE_SHARE_WRITE,
 398                                                       NULL,
 399                                                       CONSOLE_GRAPHICS_BUFFER,
 400                                                       &GraphicsBufferInfo);
 401     if (GraphicsConsoleBuffer == INVALID_HANDLE_VALUE) return FALSE;
 402
 403     /* Save the framebuffer address and mutex */
 404     ConsoleFramebuffer = GraphicsBufferInfo.lpBitMap;
 405     ConsoleMutex = GraphicsBufferInfo.hMutex;
 406
 407     /* Clear the framebuffer */
 408     ZeroMemory(ConsoleFramebuffer, BitmapInfo->bmiHeader.biSizeImage);
 409
 410     /* Set the active buffer */
 411     SetConsoleActiveScreenBuffer(GraphicsConsoleBuffer);
 412
 413     /* Set the graphics mode palette */
 414     SetConsolePalette(GraphicsConsoleBuffer,
 415                       PaletteHandle,
 416                       SYSPAL_NOSTATIC256);
 417
 418     /* Clear the text mode flag */
 419     TextMode = FALSE;
 420
 421     return TRUE;
 422 }
 423
 424 static VOID VgaLeaveGraphicsMode(VOID)
 425 {
 426     /* Release the console framebuffer mutex if needed */
 427     ReleaseMutex(ConsoleMutex);
 428
 429     /* Switch back to the text buffer */
 430     SetConsoleActiveScreenBuffer(TextConsoleBuffer);
 431
 432     /* Cleanup the video data */
 433     CloseHandle(ConsoleMutex);
 434     ConsoleMutex = NULL;
 435     CloseHandle(GraphicsConsoleBuffer);
 436     GraphicsConsoleBuffer = NULL;
 437 }
 438
 439 static BOOL VgaEnterTextMode(PCOORD Resolution)
 440 {
 441     /* Resize the console */
 442     SetConsoleScreenBufferSize(TextConsoleBuffer, *Resolution);
 443
 444     /* Allocate a framebuffer */
 445     ConsoleFramebuffer = HeapAlloc(GetProcessHeap(),
 446                                    HEAP_ZERO_MEMORY,
 447                                    Resolution->X * Resolution->Y
 448                                    * sizeof(CHAR_INFO));
 449     if (ConsoleFramebuffer == NULL)
 450     {
 451         DisplayMessage(L"An unexpected error occurred!\n");
 452         VdmRunning = FALSE;
 453         return FALSE;
 454     }
 455
 456     /* Set the text mode flag */
 457     TextMode = TRUE;
 458
 459     return TRUE;
 460 }
 461
 462 static VOID VgaLeaveTextMode(VOID)
 463 {
 464     /* Free the old framebuffer */
 465     HeapFree(GetProcessHeap(), 0, ConsoleFramebuffer);
 466     ConsoleFramebuffer = NULL;
 467 }
 468
 469 static VOID VgaChangeMode(VOID)
 470 {
 471     COORD Resolution = VgaGetDisplayResolution();
 472
 473     /* Reset the mode change flag */
 474     // ModeChanged = FALSE;
 475
 476     if (!TextMode)
 477     {
 478         /* Leave the current graphics mode */
 479         VgaLeaveGraphicsMode();
 480     }
 481     else
 482     {
 483         /* Leave the current text mode */
 484         VgaLeaveTextMode();
 485     }
 486
 487     /* Check if the new mode is alphanumeric */
 488     if (!(VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA))
 489     {
 490         /* Enter new text mode */
 491         if (!VgaEnterTextMode(&Resolution)) return;
 492     }
 493     else
 494     {
 495         /* Enter 8-bit graphics mode */
 496         if (!VgaEnterGraphicsMode(&Resolution)) return;
 497     }
 498
 499     /* Trigger a full update of the screen */
 500     NeedsUpdate = TRUE;
 501     UpdateRectangle.Left = 0;
 502     UpdateRectangle.Top = 0;
 503     UpdateRectangle.Right = Resolution.X;
 504     UpdateRectangle.Bottom = Resolution.Y;
 505
 506     /* Reset the mode change flag */
 507     ModeChanged = FALSE;
 508 }
 509
 510 static VOID VgaUpdateFramebuffer(VOID)
 511 {
 512     INT i, j, k;
 513     COORD Resolution = VgaGetDisplayResolution();
 514     INT AddressSize = VgaGetAddressSize();
 515     DWORD Address = (VgaCrtcRegisters[VGA_CRTC_START_ADDR_HIGH_REG] << 8)
 516                     + VgaCrtcRegisters[VGA_CRTC_START_ADDR_LOW_REG];
 517     DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
 518
 519     /* Check if this is text mode or graphics mode */
 520     if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
 521     {
 522         /* Graphics mode */
 523         PBYTE GraphicsBuffer = (PBYTE)ConsoleFramebuffer;
 524
 525         /*
 526          * Synchronize access to the graphics framebuffer
 527          * with the console framebuffer mutex.
 528          */
 529         WaitForSingleObject(ConsoleMutex, INFINITE);
 530
 531         /* Loop through the scanlines */
 532         for (i = 0; i < Resolution.Y; i++)
 533         {
 534             /* Loop through the pixels */
 535             for (j = 0; j < Resolution.X; j++)
 536             {
 537                 BYTE PixelData = 0;
 538
 539                 /* Check the shifting mode */
 540                 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFT256)
 541                 {
 542                     /* 4 bits shifted from each plane */
 543
 544                     /* Check if this is 16 or 256 color mode */
 545                     if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
 546                     {
 547                         /* One byte per pixel */
 548                         PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
 549                                               + (Address + (j / VGA_NUM_BANKS))
 550                                               * AddressSize];
 551                     }
 552                     else
 553                     {
 554                         /* 4-bits per pixel */
 555
 556                         PixelData = VgaMemory[(j % VGA_NUM_BANKS) * VGA_BANK_SIZE
 557                                               + (Address + (j / (VGA_NUM_BANKS * 2)))
 558                                               * AddressSize];
 559
 560                         /* Check if we should use the highest 4 bits or lowest 4 */
 561                         if (((j / VGA_NUM_BANKS) % 2) == 0)
 562                         {
 563                             /* Highest 4 */
 564                             PixelData >>= 4;
 565                         }
 566                         else
 567                         {
 568                             /* Lowest 4 */
 569                             PixelData &= 0x0F;
 570                         }
 571                     }
 572                 }
 573                 else if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_SHIFTREG)
 574                 {
 575                     /*
 576                      * 2 bits shifted from plane 0 and 2 for the first 4 pixels,
 577                      * then 2 bits shifted from plane 1 and 3 for the next 4
 578                      */
 579
 580                     // TODO: NOT IMPLEMENTED!
 581                     DPRINT1("Interleaved shift mode is not implemented!\n");
 582                 }
 583                 else
 584                 {
 585                     /* 1 bit shifted from each plane */
 586
 587                     /* Check if this is 16 or 256 color mode */
 588                     if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT)
 589                     {
 590                         /* 8 bits per pixel, 2 on each plane */
 591
 592                         for (k = 0; k < VGA_NUM_BANKS; k++)
 593                         {
 594                             /* The data is on plane k, 4 pixels per byte */
 595                             BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
 596                                                        + (Address + (j / 4)) * AddressSize];
 597
 598                             /* The mask of the first bit in the pair */
 599                             BYTE BitMask = 1 << (((3 - (j % 4)) * 2) + 1);
 600
 601                             /* Bits 0, 1, 2 and 3 come from the first bit of the pair */
 602                             if (PlaneData & BitMask) PixelData |= 1 << k;
 603
 604                             /* Bits 4, 5, 6 and 7 come from the second bit of the pair */
 605                             if (PlaneData & (BitMask >> 1)) PixelData |= 1 << (k + 4);
 606                         }
 607                     }
 608                     else
 609                     {
 610                         /* 4 bits per pixel, 1 on each plane */
 611
 612                         for (k = 0; k < VGA_NUM_BANKS; k++)
 613                         {
 614                             BYTE PlaneData = VgaMemory[k * VGA_BANK_SIZE
 615                                                        + (Address + (j / 8)) * AddressSize];
 616
 617                             /* If the bit on that plane is set, set it */
 618                             if (PlaneData & (1 << (7 - (j % 8)))) PixelData |= 1 << k;
 619                         }
 620                     }
 621                 }
 622
 623                 /* Now check if the resulting pixel data has changed */
 624                 if (GraphicsBuffer[i * Resolution.X + j] != PixelData)
 625                 {
 626                     /* Yes, write the new value */
 627                     GraphicsBuffer[i * Resolution.X + j] = PixelData;
 628
 629                     /* Mark the specified pixel as changed */
 630                     VgaMarkForUpdate(i, j);
 631                 }
 632             }
 633
 634             /* Move to the next scanline */
 635             Address += ScanlineSize;
 636         }
 637
 638         /*
 639          * Release the console framebuffer mutex
 640          * so that we allow for repainting.
 641          */
 642         ReleaseMutex(ConsoleMutex);
 643     }
 644     else
 645     {
 646         /* Text mode */
 647         PCHAR_INFO CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
 648
 649         /* Loop through the scanlines */
 650         for (i = 0; i < Resolution.Y; i++)
 651         {
 652             /* Loop through the characters */
 653             for (j = 0; j < Resolution.X; j++)
 654             {
 655                 DWORD CurrentAddr = LOWORD((Address + j) * AddressSize);
 656                 CHAR_INFO CharInfo;
 657
 658                 /* Plane 0 holds the character itself */
 659                 CharInfo.Char.AsciiChar = VgaMemory[CurrentAddr];
 660
 661                 /* Plane 1 holds the attribute */
 662                 CharInfo.Attributes = VgaMemory[CurrentAddr + VGA_BANK_SIZE];
 663
 664                 /* Now check if the resulting character data has changed */
 665                 if ((CharBuffer[i * Resolution.X + j].Char.AsciiChar != CharInfo.Char.AsciiChar)
 666                     || (CharBuffer[i * Resolution.X + j].Attributes != CharInfo.Attributes))
 667                 {
 668                     /* Yes, write the new value */
 669                     CharBuffer[i * Resolution.X + j] = CharInfo;
 670
 671                     /* Mark the specified cell as changed */
 672                     VgaMarkForUpdate(i, j);
 673                 }
 674             }
 675
 676             /* Move to the next scanline */
 677             Address += ScanlineSize;
 678         }
 679     }
 680 }
 681
 682 static VOID VgaUpdateTextCursor(VOID)
 683 {
 684     COORD Position;
 685     CONSOLE_CURSOR_INFO CursorInfo;
 686     BYTE CursorStart = VgaCrtcRegisters[VGA_CRTC_CURSOR_START_REG] & 0x3F;
 687     BYTE CursorEnd = VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] & 0x1F;
 688     DWORD ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
 689     BYTE TextSize = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
 690     WORD Location = MAKEWORD(VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_LOW_REG],
 691                              VgaCrtcRegisters[VGA_CRTC_CURSOR_LOC_HIGH_REG]);
 692
 693     if (CursorStart < CursorEnd)
 694     {
 695         /* Visible cursor */
 696         CursorInfo.bVisible = TRUE;
 697         CursorInfo.dwSize = (100 * (CursorEnd - CursorStart)) / TextSize;
 698     }
 699     else
 700     {
 701         /* No cursor */
 702         CursorInfo.bVisible = FALSE;
 703         CursorInfo.dwSize = 0;
 704     }
 705
 706     /* Add the cursor skew to the location */
 707     Location += (VgaCrtcRegisters[VGA_CRTC_CURSOR_END_REG] >> 5) & 3;
 708
 709     /* Find the coordinates of the new position */
 710     Position.X = (WORD)(Location % ScanlineSize);
 711     Position.Y = (WORD)(Location / ScanlineSize);
 712
 713     /* Update the physical cursor */
 714     SetConsoleCursorInfo(TextConsoleBuffer, &CursorInfo);
 715     SetConsoleCursorPosition(TextConsoleBuffer, Position);
 716
 717     /* Reset the cursor move flag */
 718     CursorMoved = FALSE;
 719 }
 720
 721 /* PUBLIC FUNCTIONS ***********************************************************/
 722
 723 DWORD VgaGetVideoBaseAddress(VOID)
 724 {
 725     return MemoryBase[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
 726 }
 727
 728 DWORD VgaGetVideoLimitAddress(VOID)
 729 {
 730     return MemoryLimit[(VgaGcRegisters[VGA_GC_MISC_REG] >> 2) & 0x03];
 731 }
 732
 733 COORD VgaGetDisplayResolution(VOID)
 734 {
 735     COORD Resolution;
 736     BYTE MaximumScanLine = 1 + (VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F);
 737
 738     /* The low 8 bits are in the display registers */
 739     Resolution.X = VgaCrtcRegisters[VGA_CRTC_END_HORZ_DISP_REG];
 740     Resolution.Y = VgaCrtcRegisters[VGA_CRTC_VERT_DISP_END_REG];
 741
 742     /* Set the top bits from the overflow register */
 743     if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE8)
 744     {
 745         Resolution.Y |= 1 << 8;
 746     }
 747     if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE9)
 748     {
 749         Resolution.Y |= 1 << 9;
 750     }
 751
 752     /* Increase the values by 1 */
 753     Resolution.X++;
 754     Resolution.Y++;
 755
 756     if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
 757     {
 758         /* Multiply the horizontal resolution by the 9/8 dot mode */
 759         Resolution.X *= (VgaSeqRegisters[VGA_SEQ_CLOCK_REG] & VGA_SEQ_CLOCK_98DM)
 760                         ? 8 : 9;
 761
 762         /* The horizontal resolution is halved in 8-bit mode */
 763         if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT) Resolution.X /= 2;
 764     }
 765
 766     /* Divide the vertical resolution by the maximum scan line (== font size in text mode) */
 767     Resolution.Y /= MaximumScanLine;
 768
 769     /* Return the resolution */
 770     return Resolution;
 771 }
 772
 773 VOID VgaRefreshDisplay(VOID)
 774 {
 775     COORD Resolution = VgaGetDisplayResolution();
 776
 777     DPRINT("VgaRefreshDisplay\n");
 778
 779     /* Change the display mode */
 780     if (ModeChanged) VgaChangeMode();
 781
 782     /* Change the text cursor location */
 783     if (CursorMoved) VgaUpdateTextCursor();
 784
 785     if (PaletteChanged)
 786     {
 787         if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
 788         {
 789             /* Trigger a full update of the screen */
 790             NeedsUpdate = TRUE;
 791             UpdateRectangle.Left = 0;
 792             UpdateRectangle.Top = 0;
 793             UpdateRectangle.Right = Resolution.X;
 794             UpdateRectangle.Bottom = Resolution.Y;
 795         }
 796
 797         PaletteChanged = FALSE;
 798     }
 799
 800     /* Update the contents of the framebuffer */
 801     VgaUpdateFramebuffer();
 802
 803     /* Set the vertical retrace flag */
 804     InVerticalRetrace = TRUE;
 805
 806     /* Ignore if there's nothing to update */
 807     if (!NeedsUpdate) return;
 808
 809     DPRINT("Updating screen rectangle (%d, %d, %d, %d)\n",
 810            UpdateRectangle.Left,
 811            UpdateRectangle.Top,
 812            UpdateRectangle.Right,
 813            UpdateRectangle.Bottom);
 814
 815     /* Check if this is text mode or graphics mode */
 816     if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
 817     {
 818         /* Graphics mode */
 819
 820         /* Redraw the screen */
 821         InvalidateConsoleDIBits(GraphicsConsoleBuffer, &UpdateRectangle);
 822     }
 823     else
 824     {
 825         /* Text mode */
 826         COORD Origin = { UpdateRectangle.Left, UpdateRectangle.Top };
 827
 828         /* Write the data to the console */
 829         WriteConsoleOutputA(TextConsoleBuffer,
 830                             (PCHAR_INFO)ConsoleFramebuffer,
 831                             Resolution,
 832                             Origin,
 833                             &UpdateRectangle);
 834
 835     }
 836
 837     /* Clear the update flag */
 838     NeedsUpdate = FALSE;
 839 }
 840
 841 VOID VgaHorizontalRetrace(VOID)
 842 {
 843     /* Set the flag */
 844     InHorizontalRetrace = TRUE;
 845 }
 846
 847 VOID VgaReadMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
 848 {
 849     DWORD i;
 850     DWORD VideoAddress;
 851
 852     DPRINT("VgaReadMemory: Address 0x%08X, Size %lu\n",
 853            Address,
 854            Size);
 855
 856     /* Ignore if video RAM access is disabled */
 857     if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
 858
 859     /* Loop through each byte */
 860     for (i = 0; i < Size; i++)
 861     {
 862         VideoAddress = VgaTranslateReadAddress(Address + i);
 863
 864         /* Load the latch registers */
 865         VgaLatchRegisters[0] = VgaMemory[LOWORD(VideoAddress)];
 866         VgaLatchRegisters[1] = VgaMemory[VGA_BANK_SIZE + LOWORD(VideoAddress)];
 867         VgaLatchRegisters[2] = VgaMemory[(2 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
 868         VgaLatchRegisters[3] = VgaMemory[(3 * VGA_BANK_SIZE) + LOWORD(VideoAddress)];
 869
 870         /* Copy the value to the buffer */
 871         Buffer[i] = VgaMemory[VideoAddress];
 872     }
 873 }
 874
 875 VOID VgaWriteMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
 876 {
 877     DWORD i, j;
 878     DWORD VideoAddress;
 879
 880     DPRINT("VgaWriteMemory: Address 0x%08X, Size %lu\n",
 881            Address,
 882            Size);
 883
 884     /* Ignore if video RAM access is disabled */
 885     if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
 886
 887     /* Also ignore if write access to all planes is disabled */
 888     if ((VgaSeqRegisters[VGA_SEQ_MASK_REG] & 0x0F) == 0x00) return;
 889
 890     /* Loop through each byte */
 891     for (i = 0; i < Size; i++)
 892     {
 893         VideoAddress = VgaTranslateWriteAddress(Address + i);
 894
 895         for (j = 0; j < VGA_NUM_BANKS; j++)
 896         {
 897             /* Make sure the page is writeable */
 898             if (!(VgaSeqRegisters[VGA_SEQ_MASK_REG] & (1 << j))) continue;
 899
 900             /* Check if this is chain-4 mode */
 901             if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
 902             {
 903                 if (((Address + i) & 3) != j)
 904                 {
 905                     /* This plane will not be accessed */
 906                     continue;
 907                 }
 908             }
 909
 910             /* Check if this is odd-even mode */
 911             if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
 912             {
 913                 if (((Address + i) & 1) != (j & 1))
 914                 {
 915                     /* This plane will not be accessed */
 916                     continue;
 917                 }
 918             }
 919
 920             /* Copy the value to the VGA memory */
 921             VgaMemory[VideoAddress + j * VGA_BANK_SIZE] = VgaTranslateByteForWriting(Buffer[i], j);
 922         }
 923     }
 924 }
 925
 926 BYTE VgaReadPort(WORD Port)
 927 {
 928     DPRINT("VgaReadPort: Port 0x%04X\n", Port);
 929
 930     switch (Port)
 931     {
 932         case VGA_AC_INDEX:
 933         {
 934             return VgaAcIndex;
 935         }
 936
 937         case VGA_AC_READ:
 938         {
 939             return VgaAcRegisters[VgaAcIndex];
 940         }
 941
 942         case VGA_SEQ_INDEX:
 943         {
 944             return VgaSeqIndex;
 945         }
 946
 947         case VGA_SEQ_DATA:
 948         {
 949             return VgaSeqRegisters[VgaSeqIndex];
 950         }
 951
 952         case VGA_DAC_READ_INDEX:
 953         {
 954             /* This returns the read/write state */
 955             return VgaDacReadWrite ? 0 : 3;
 956         }
 957
 958         case VGA_DAC_WRITE_INDEX:
 959         {
 960             return VgaDacIndex / 3;
 961         }
 962
 963         case VGA_DAC_DATA:
 964         {
 965             /* Ignore reads in write mode */
 966             if (!VgaDacReadWrite)
 967             {
 968                 BYTE Data = VgaDacRegisters[VgaDacIndex++];
 969                 VgaDacIndex %= VGA_PALETTE_SIZE;
 970                 return Data;
 971             }
 972
 973             break;
 974         }
 975
 976         case VGA_MISC_READ:
 977         {
 978             return VgaMiscRegister;
 979         }
 980
 981         case VGA_CRTC_INDEX:
 982         {
 983             return VgaCrtcIndex;
 984         }
 985
 986         case VGA_CRTC_DATA:
 987         {
 988             return VgaCrtcRegisters[VgaCrtcIndex];
 989         }
 990
 991         case VGA_GC_INDEX:
 992         {
 993             return VgaGcIndex;
 994         }
 995
 996         case VGA_GC_DATA:
 997         {
 998             return VgaGcRegisters[VgaGcIndex];
 999         }
1000
1001         case VGA_STAT_MONO:
1002         case VGA_STAT_COLOR:
1003         {
1004             BYTE Result = 0;
1005
1006             /* Reset the AC latch */
1007             VgaAcLatch = FALSE;
1008
1009             /* Set a flag if there is a vertical or horizontal retrace */
1010             if (InVerticalRetrace || InHorizontalRetrace) Result |= VGA_STAT_DD;
1011
1012             /* Set an additional flag if there was a vertical retrace */
1013             if (InVerticalRetrace) Result |= VGA_STAT_VRETRACE;
1014
1015             /* Clear the flags */
1016             InHorizontalRetrace = InVerticalRetrace = FALSE;
1017
1018             return Result;
1019         }
1020     }
1021
1022     return 0;
1023 }
1024
1025 VOID VgaWritePort(WORD Port, BYTE Data)
1026 {
1027     DPRINT("VgaWritePort: Port 0x%04X, Data 0x%02X\n", Port, Data);
1028
1029     switch (Port)
1030     {
1031         case VGA_AC_INDEX:
1032         {
1033             if (!VgaAcLatch)
1034             {
1035                 /* Change the index */
1036                 if (Data < VGA_AC_MAX_REG) VgaAcIndex = Data;
1037             }
1038             else
1039             {
1040                 /* Write the data */
1041                 VgaWriteAc(Data);
1042             }
1043
1044             /* Toggle the latch */
1045             VgaAcLatch = !VgaAcLatch;
1046
1047             break;
1048         }
1049
1050         case VGA_SEQ_INDEX:
1051         {
1052             /* Set the sequencer index register */
1053             if (Data < VGA_SEQ_MAX_REG) VgaSeqIndex = Data;
1054
1055             break;
1056         }
1057
1058         case VGA_SEQ_DATA:
1059         {
1060             /* Call the sequencer function */
1061             VgaWriteSequencer(Data);
1062
1063             break;
1064         }
1065
1066         case VGA_DAC_READ_INDEX:
1067         {
1068             VgaDacReadWrite = FALSE;
1069             VgaDacIndex = Data * 3;
1070
1071             break;
1072         }
1073
1074         case VGA_DAC_WRITE_INDEX:
1075         {
1076             VgaDacReadWrite = TRUE;
1077             VgaDacIndex = Data * 3;
1078
1079             break;
1080         }
1081
1082         case VGA_DAC_DATA:
1083         {
1084             /* Ignore writes in read mode */
1085             if (VgaDacReadWrite) VgaWriteDac(Data & 0x3F);
1086
1087             break;
1088         }
1089
1090         case VGA_MISC_WRITE:
1091         {
1092             VgaMiscRegister = Data;
1093
1094             break;
1095         }
1096
1097         case VGA_CRTC_INDEX:
1098         {
1099             /* Set the CRTC index register */
1100             if (Data < VGA_CRTC_MAX_REG) VgaCrtcIndex = Data;
1101
1102             break;
1103         }
1104
1105         case VGA_CRTC_DATA:
1106         {
1107             /* Call the CRTC function */
1108             VgaWriteCrtc(Data);
1109
1110             break;
1111         }
1112
1113         case VGA_GC_INDEX:
1114         {
1115             /* Set the GC index register */
1116             if (Data < VGA_GC_MAX_REG) VgaGcIndex = Data;
1117             break;
1118         }
1119
1120         case VGA_GC_DATA:
1121         {
1122             /* Call the GC function */
1123             VgaWriteGc(Data);
1124
1125             break;
1126         }
1127     }
1128 }
1129
1130 VOID VgaClearMemory(VOID)
1131 {
1132     ZeroMemory(VgaMemory, sizeof(VgaMemory));
1133 }
1134
1135 BOOLEAN VgaInitialize(HANDLE TextHandle)
1136 {
1137     INT i, j;
1138     COORD Resolution;
1139     INT AddressSize;
1140     DWORD ScanlineSize;
1141     COORD Origin = { 0, 0 };
1142     SMALL_RECT ScreenRect;
1143     PCHAR_INFO CharBuffer;
1144     DWORD Address = 0;
1145     DWORD CurrentAddr;
1146     LPLOGPALETTE Palette;
1147
1148     /* Set the global handle */
1149     TextConsoleBuffer = TextHandle;
1150
1151     /* Clear the VGA memory */
1152     VgaClearMemory();
1153
1154     /* Set the default video mode */
1155     BiosSetVideoMode(BIOS_DEFAULT_VIDEO_MODE);
1156     VgaChangeMode();
1157
1158     /* Get the data */
1159     Resolution = VgaGetDisplayResolution();
1160     CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
1161     AddressSize = VgaGetAddressSize();
1162     ScreenRect.Left = ScreenRect.Top = 0;
1163     ScreenRect.Right = Resolution.X;
1164     ScreenRect.Bottom = Resolution.Y;
1165     ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
1166
1167     /* Read the data from the console into the framebuffer */
1168     ReadConsoleOutputA(TextConsoleBuffer,
1169                        CharBuffer,
1170                        Resolution,
1171                        Origin,
1172                        &ScreenRect);
1173
1174     /* Loop through the scanlines */
1175     for (i = 0; i < Resolution.Y; i++)
1176     {
1177         /* Loop through the characters */
1178         for (j = 0; j < Resolution.X; j++)
1179         {
1180             CurrentAddr = LOWORD((Address + j) * AddressSize);
1181
1182             /* Store the character in plane 0 */
1183             VgaMemory[CurrentAddr] = CharBuffer[i * Resolution.X + j].Char.AsciiChar;
1184
1185             /* Store the attribute in plane 1 */
1186             VgaMemory[CurrentAddr + VGA_BANK_SIZE] = (BYTE)CharBuffer[i * Resolution.X + j].Attributes;
1187         }
1188
1189         /* Move to the next scanline */
1190         Address += ScanlineSize;
1191     }
1192
1193     /* Allocate storage space for the palette */
1194     Palette = (LPLOGPALETTE)HeapAlloc(GetProcessHeap(),
1195                                       HEAP_ZERO_MEMORY,
1196                                       sizeof(LOGPALETTE)
1197                                       + VGA_MAX_COLORS * sizeof(PALETTEENTRY));
1198     if (Palette == NULL) return FALSE;
1199
1200     /* Initialize the palette */
1201     Palette->palVersion = 0x0300;
1202     Palette->palNumEntries = VGA_MAX_COLORS;
1203
1204     /* Copy the colors of the default palette to the DAC and console palette */
1205     for (i = 0; i < VGA_MAX_COLORS; i++)
1206     {
1207         /* Set the palette entries */
1208         Palette->palPalEntry[i].peRed = GetRValue(VgaDefaultPalette[i]);
1209         Palette->palPalEntry[i].peGreen = GetGValue(VgaDefaultPalette[i]);
1210         Palette->palPalEntry[i].peBlue = GetBValue(VgaDefaultPalette[i]);
1211         Palette->palPalEntry[i].peFlags = 0;
1212
1213         /* Set the DAC registers */
1214         VgaDacRegisters[i * 3] = VGA_COLOR_TO_DAC(GetRValue(VgaDefaultPalette[i]));
1215         VgaDacRegisters[i * 3 + 1] = VGA_COLOR_TO_DAC(GetGValue(VgaDefaultPalette[i]));
1216         VgaDacRegisters[i * 3 + 2] = VGA_COLOR_TO_DAC(GetBValue(VgaDefaultPalette[i]));
1217     }
1218
1219     /* Create the palette */
1220     PaletteHandle = CreatePalette(Palette);
1221
1222     /* Free the palette */
1223     HeapFree(GetProcessHeap(), 0, Palette);
1224
1225     /* Return success if the palette was successfully created */
1226     return (PaletteHandle ? TRUE : FALSE);
1227 }
1228
1229 /* EOF */