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