[NTVDM]
[reactos.git] / 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
573 /* The low 8 bits are in the display registers */
574 Resolution.X = VgaCrtcRegisters[VGA_CRTC_END_HORZ_DISP_REG];
575 Resolution.Y = VgaCrtcRegisters[VGA_CRTC_VERT_DISP_END_REG];
576
577 /* Set the top bits from the overflow register */
578 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE8)
579 {
580 Resolution.Y |= 1 << 8;
581 }
582 if (VgaCrtcRegisters[VGA_CRTC_OVERFLOW_REG] & VGA_CRTC_OVERFLOW_VDE9)
583 {
584 Resolution.Y |= 1 << 9;
585 }
586
587 /* Increase the values by 1 */
588 Resolution.X++;
589 Resolution.Y++;
590
591 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
592 {
593 /* Multiply the horizontal resolution by the 9/8 dot mode */
594 Resolution.X *= (VgaSeqRegisters[VGA_SEQ_CLOCK_REG] & VGA_SEQ_CLOCK_98DM)
595 ? 8 : 9;
596
597 /* The horizontal resolution is halved in 8-bit mode */
598 if (VgaAcRegisters[VGA_AC_CONTROL_REG] & VGA_AC_CONTROL_8BIT) Resolution.X /= 2;
599
600 /* Divide the vertical resolution by the maximum scan line */
601 Resolution.Y /= ((DWORD)VgaCrtcRegisters[VGA_CRTC_MAX_SCAN_LINE_REG] & 0x1F) + 1;
602 }
603 else
604 {
605 /* Divide the number of scanlines by the font size */
606 Resolution.Y /= 16;
607 }
608
609 /* Return the resolution */
610 return Resolution;
611 }
612
613 VOID VgaRefreshDisplay(VOID)
614 {
615 COORD Resolution = VgaGetDisplayResolution();
616
617 DPRINT("VgaRefreshDisplay\n");
618
619 if (ModeChanged)
620 {
621 /* Change the display mode */
622 VgaUpdateMode();
623
624 /* Reset the mode change flag */
625 ModeChanged = FALSE;
626 }
627
628 if (CursorMoved)
629 {
630 /* Change the text cursor location */
631 VgaUpdateTextCursor();
632
633 /* Reset the cursor move flag */
634 CursorMoved = FALSE;
635 }
636
637 /* Update the contents of the framebuffer */
638 VgaUpdateFramebuffer();
639
640 /* Set the vertical retrace flag */
641 InVerticalRetrace = TRUE;
642
643 /* Ignore if there's nothing to update */
644 if (!NeedsUpdate) return;
645
646 DPRINT("Updating screen rectangle (%d, %d, %d, %d)\n",
647 UpdateRectangle.Left,
648 UpdateRectangle.Top,
649 UpdateRectangle.Right,
650 UpdateRectangle.Bottom);
651
652 /* Check if this is text mode or graphics mode */
653 if (VgaGcRegisters[VGA_GC_MISC_REG] & VGA_GC_MISC_NOALPHA)
654 {
655 /* Graphics mode */
656
657 /* Redraw the screen */
658 InvalidateConsoleDIBits(GraphicsConsoleBuffer, &UpdateRectangle);
659 }
660 else
661 {
662 /* Text mode */
663 COORD Origin = { UpdateRectangle.Left, UpdateRectangle.Top };
664
665 /* Write the data to the console */
666 WriteConsoleOutputA(TextConsoleBuffer,
667 (PCHAR_INFO)ConsoleFramebuffer,
668 Resolution,
669 Origin,
670 &UpdateRectangle);
671
672 }
673
674 /* Clear the update flag */
675 NeedsUpdate = FALSE;
676 }
677
678 VOID VgaHorizontalRetrace(VOID)
679 {
680 /* Set the flag */
681 InHorizontalRetrace = TRUE;
682 }
683
684 VOID VgaReadMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
685 {
686 DWORD i;
687 DWORD VideoAddress;
688
689 DPRINT("VgaReadMemory: Address 0x%08X, Size %lu\n",
690 Address,
691 Size);
692
693 /* Ignore if video RAM access is disabled */
694 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
695
696 /* Loop through each byte */
697 for (i = 0; i < Size; i++)
698 {
699 VideoAddress = VgaTranslateReadAddress(Address + i);
700
701 /* Copy the value to the buffer */
702 Buffer[i] = VgaMemory[VideoAddress];
703 }
704 }
705
706 VOID VgaWriteMemory(DWORD Address, LPBYTE Buffer, DWORD Size)
707 {
708 DWORD i, j;
709 DWORD VideoAddress;
710
711 DPRINT("VgaWriteMemory: Address 0x%08X, Size %lu\n",
712 Address,
713 Size);
714
715 /* Ignore if video RAM access is disabled */
716 if (!(VgaMiscRegister & VGA_MISC_RAM_ENABLED)) return;
717
718 /* Also ignore if write access to all planes is disabled */
719 if ((VgaSeqRegisters[VGA_SEQ_MASK_REG] & 0x0F) == 0x00) return;
720
721 /* Loop through each byte */
722 for (i = 0; i < Size; i++)
723 {
724 VideoAddress = VgaTranslateWriteAddress(Address + i);
725
726 for (j = 0; j < VGA_NUM_BANKS; j++)
727 {
728 /* Make sure the page is writeable */
729 if (!(VgaSeqRegisters[VGA_SEQ_MASK_REG] & (1 << j))) continue;
730
731 /* Check if this is chain-4 mode */
732 if (VgaSeqRegisters[VGA_SEQ_MEM_REG] & VGA_SEQ_MEM_C4)
733 {
734 if (((Address + i) & 3) != j)
735 {
736 /* This plane will not be accessed */
737 continue;
738 }
739 }
740
741 /* Check if this is odd-even mode */
742 if (VgaGcRegisters[VGA_GC_MODE_REG] & VGA_GC_MODE_OE)
743 {
744 if (((Address + i) & 1) != (j & 1))
745 {
746 /* This plane will not be accessed */
747 continue;
748 }
749 }
750
751 /* Copy the value to the VGA memory */
752 VgaMemory[VideoAddress + j * VGA_BANK_SIZE] = Buffer[i];
753 }
754 }
755 }
756
757 BYTE VgaReadPort(WORD Port)
758 {
759 DPRINT("VgaReadPort: Port 0x%04X\n", Port);
760
761 switch (Port)
762 {
763 case VGA_AC_INDEX:
764 {
765 return VgaAcIndex;
766 }
767
768 case VGA_AC_READ:
769 {
770 return VgaAcRegisters[VgaAcIndex];
771 }
772
773 case VGA_SEQ_INDEX:
774 {
775 return VgaSeqIndex;
776 }
777
778 case VGA_SEQ_DATA:
779 {
780 return VgaSeqRegisters[VgaSeqIndex];
781 }
782
783 case VGA_DAC_READ_INDEX:
784 {
785 /* This returns the read/write state */
786 return VgaDacReadWrite ? 0 : 3;
787 }
788
789 case VGA_DAC_WRITE_INDEX:
790 {
791 return VgaDacIndex;
792 }
793
794 case VGA_DAC_DATA:
795 {
796 /* Ignore reads in write mode */
797 if (!VgaDacReadWrite)
798 {
799 BYTE Data = VgaDacRegisters[VgaDacIndex++];
800 VgaDacIndex %= VGA_PALETTE_SIZE;
801 return Data;
802 }
803
804 break;
805 }
806
807 case VGA_MISC_READ:
808 {
809 return VgaMiscRegister;
810 }
811
812 case VGA_CRTC_INDEX:
813 {
814 return VgaCrtcIndex;
815 }
816
817 case VGA_CRTC_DATA:
818 {
819 return VgaCrtcRegisters[VgaCrtcIndex];
820 }
821
822 case VGA_GC_INDEX:
823 {
824 return VgaGcIndex;
825 }
826
827 case VGA_GC_DATA:
828 {
829 return VgaGcRegisters[VgaGcIndex];
830 }
831
832 case VGA_STAT_MONO:
833 case VGA_STAT_COLOR:
834 {
835 BYTE Result = 0;
836
837 /* Reset the AC latch */
838 VgaAcLatch = FALSE;
839
840 /* Set a flag if there is a vertical or horizontal retrace */
841 if (InVerticalRetrace || InHorizontalRetrace) Result |= VGA_STAT_DD;
842
843 /* Set an additional flag if there was a vertical retrace */
844 if (InVerticalRetrace) Result |= VGA_STAT_VRETRACE;
845
846 /* Clear the flags */
847 InHorizontalRetrace = InVerticalRetrace = FALSE;
848
849 return Result;
850 }
851 }
852
853 return 0;
854 }
855
856 VOID VgaWritePort(WORD Port, BYTE Data)
857 {
858 DPRINT("VgaWritePort: Port 0x%04X, Data 0x%02X\n", Port, Data);
859
860 switch (Port)
861 {
862 case VGA_AC_INDEX:
863 {
864 if (!VgaAcLatch)
865 {
866 /* Change the index */
867 if (Data < VGA_AC_MAX_REG) VgaAcIndex = Data;
868 }
869 else
870 {
871 /* Write the data */
872 VgaWriteAc(Data);
873 }
874
875 /* Toggle the latch */
876 VgaAcLatch = !VgaAcLatch;
877
878 break;
879 }
880
881 case VGA_SEQ_INDEX:
882 {
883 /* Set the sequencer index register */
884 if (Data < VGA_SEQ_MAX_REG) VgaSeqIndex = Data;
885
886 break;
887 }
888
889 case VGA_SEQ_DATA:
890 {
891 /* Call the sequencer function */
892 VgaWriteSequencer(Data);
893
894 break;
895 }
896
897 case VGA_DAC_READ_INDEX:
898 {
899 VgaDacReadWrite = FALSE;
900 VgaDacIndex = Data % VGA_PALETTE_SIZE;
901
902 break;
903 }
904
905 case VGA_DAC_WRITE_INDEX:
906 {
907 VgaDacReadWrite = TRUE;
908 VgaDacIndex = Data % VGA_PALETTE_SIZE;
909
910 break;
911 }
912
913 case VGA_DAC_DATA:
914 {
915 /* Ignore writes in read mode */
916 if (VgaDacReadWrite) VgaWriteDac(Data & 0x3F);
917
918 break;
919 }
920
921 case VGA_MISC_WRITE:
922 {
923 VgaMiscRegister = Data;
924
925 break;
926 }
927
928 case VGA_CRTC_INDEX:
929 {
930 /* Set the CRTC index register */
931 if (Data < VGA_CRTC_MAX_REG) VgaCrtcIndex = Data;
932
933 break;
934 }
935
936 case VGA_CRTC_DATA:
937 {
938 /* Call the CRTC function */
939 VgaWriteCrtc(Data);
940
941 break;
942 }
943
944 case VGA_GC_INDEX:
945 {
946 /* Set the GC index register */
947 if (Data < VGA_GC_MAX_REG) VgaGcIndex = Data;
948 break;
949 }
950
951 case VGA_GC_DATA:
952 {
953 /* Call the GC function */
954 VgaWriteGc(Data);
955
956 break;
957 }
958 }
959 }
960
961 VOID VgaInitialize(HANDLE TextHandle)
962 {
963 INT i, j;
964 COORD Resolution;
965 INT AddressSize;
966 DWORD ScanlineSize;
967 COORD Origin = { 0, 0 };
968 SMALL_RECT ScreenRect;
969 PCHAR_INFO CharBuffer;
970 DWORD Address = 0;
971 DWORD CurrentAddr;
972
973 /* Set the global handle */
974 TextConsoleBuffer = TextHandle;
975
976 /* Clear the VGA memory */
977 ZeroMemory(VgaMemory, VGA_NUM_BANKS * VGA_BANK_SIZE);
978
979 /* Set the default video mode */
980 BiosSetVideoMode(BIOS_DEFAULT_VIDEO_MODE);
981 VgaUpdateMode();
982 ModeChanged = FALSE;
983
984 /* Get the data */
985 Resolution = VgaGetDisplayResolution();
986 CharBuffer = (PCHAR_INFO)ConsoleFramebuffer;
987 AddressSize = VgaGetAddressSize();
988 ScreenRect.Left = ScreenRect.Top = 0;
989 ScreenRect.Right = Resolution.X;
990 ScreenRect.Bottom = Resolution.Y;
991 ScanlineSize = (DWORD)VgaCrtcRegisters[VGA_CRTC_OFFSET_REG] * 2;
992
993 /* Read the data from the console into the framebuffer */
994 ReadConsoleOutputA(TextConsoleBuffer,
995 CharBuffer,
996 Resolution,
997 Origin,
998 &ScreenRect);
999
1000 /* Loop through the scanlines */
1001 for (i = 0; i < Resolution.Y; i++)
1002 {
1003 /* Loop through the characters */
1004 for (j = 0; j < Resolution.X; j++)
1005 {
1006 CurrentAddr = LOWORD((Address + j) * AddressSize);
1007
1008 /* Store the character in plane 0 */
1009 VgaMemory[CurrentAddr] = CharBuffer[i * Resolution.X + j].Char.AsciiChar;
1010
1011 /* Store the attribute in plane 1 */
1012 VgaMemory[CurrentAddr + VGA_BANK_SIZE] = (BYTE)CharBuffer[i * Resolution.X + j].Attributes;
1013 }
1014
1015 /* Move to the next scanline */
1016 Address += ScanlineSize;
1017 }
1018 }
1019
1020 /* EOF */