#include "bios.h"
#include "emulator.h"
+#include "vga.h"
#include "pic.h"
#include "ps2.h"
#include "timer.h"
+#include "registers.h"
+
/* PRIVATE VARIABLES **********************************************************/
-static PBIOS_DATA_AREA Bda;
+PBIOS_DATA_AREA Bda;
static BYTE BiosKeyboardMap[256];
-static HANDLE BiosConsoleInput = INVALID_HANDLE_VALUE;
+static HANDLE BiosConsoleInput = INVALID_HANDLE_VALUE;
static HANDLE BiosConsoleOutput = INVALID_HANDLE_VALUE;
-static HANDLE BiosGraphicsOutput = NULL;
-static LPVOID ConsoleFramebuffer = NULL;
-static HANDLE ConsoleMutex = NULL;
-static BYTE CurrentVideoMode, CurrentVideoPage;
-static BOOLEAN VideoNeedsUpdate = TRUE;
-static SMALL_RECT UpdateRectangle = { 0, 0, 0, 0 };
static CONSOLE_SCREEN_BUFFER_INFO BiosSavedBufferInfo;
-static VIDEO_MODE VideoModes[] =
+/*
+ * VGA Register Configurations for BIOS Video Modes
+ * The configurations come from DosBox.
+ */
+static BYTE VideoMode_40x25_text[] =
{
- /* Width | Height | Text | Bpp | Gray | Pages | Segment */
- { 40, 25, TRUE, 16, TRUE, 8, 0xB800}, /* Mode 00h */
- { 40, 25, TRUE, 16, FALSE, 8, 0xB800}, /* Mode 01h */
- { 80, 25, TRUE, 16, TRUE, 8, 0xB800}, /* Mode 02h */
- { 80, 25, TRUE, 16, FALSE, 8, 0xB800}, /* Mode 03h */
- { 320, 200, FALSE, 2, FALSE, 1, 0xB800}, /* Mode 04h */
- { 320, 200, FALSE, 2, TRUE, 1, 0xB800}, /* Mode 05h */
- { 640, 200, FALSE, 1, FALSE, 1, 0xB800}, /* Mode 06h */
- { 80, 25, TRUE, 8, FALSE, 1, 0xB000}, /* Mode 07h */
- { 0, 0, FALSE, 0, FALSE, 0, 0x0000}, /* Mode 08h - not used */
- { 0, 0, FALSE, 0, FALSE, 0, 0x0000}, /* Mode 09h - not used */
- { 0, 0, FALSE, 0, FALSE, 0, 0x0000}, /* Mode 0Ah - not used */
- { 0, 0, FALSE, 0, FALSE, 0, 0x0000}, /* Mode 0Bh - not used */
- { 0, 0, FALSE, 0, FALSE, 0, 0x0000}, /* Mode 0Ch - not used */
- { 320, 200, FALSE, 4, FALSE, 1, 0xA000}, /* Mode 0Dh */
- { 640, 200, FALSE, 4, FALSE, 1, 0xA000}, /* Mode 0Eh */
- { 640, 350, FALSE, 1, FALSE, 1, 0xA000}, /* Mode 0Fh */
- { 640, 350, FALSE, 4, FALSE, 1, 0xA000}, /* Mode 10h */
- { 640, 480, FALSE, 1, FALSE, 1, 0xA000}, /* Mode 11h */
- { 640, 480, FALSE, 4, FALSE, 1, 0xA000}, /* Mode 12h */
- { 320, 200, FALSE, 8, FALSE, 1, 0xA000} /* Mode 13h */
+ /* Miscellaneous Register */
+ 0x67,
+
+ /* Sequencer Registers */
+ 0x00, 0x08, 0x03, 0x00, 0x07,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x2D, 0x27, 0x28, 0x90, 0x2B, 0xA0, 0xBF, 0x1F, 0x00, 0x4F, 0x0D, 0x0E,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x14, 0x1F, 0x96, 0xB9, 0xA3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
+ 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x00, 0x0F, 0x08, 0x00
};
-/* PRIVATE FUNCTIONS **********************************************************/
+static BYTE VideoMode_80x25_text[] =
+{
+ /* Miscellaneous Register */
+ 0x67,
+
+ /* Sequencer Registers */
+ 0x00, 0x00, 0x03, 0x00, 0x07,
-static DWORD BiosGetVideoPageSize()
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 0x4F, 0x0D, 0x0E,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
+ 0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x00, 0x0F, 0x08, 0x00
+};
+
+static BYTE VideoMode_320x200_4color[] =
{
- INT i;
- DWORD BufferSize = VideoModes[CurrentVideoMode].Width
- * VideoModes[CurrentVideoMode].Height
- * VideoModes[CurrentVideoMode].Bpp
- / 8;
-
- for (i = 0; i < 32; i++) if ((1 << i) >= BufferSize) break;
+ /* Miscellaneous Register */
+ 0x63,
- return 1 << i;
-}
+ /* Sequencer Registers */
+ 0x00, 0x09, 0x00, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x0F, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00, 0xC1, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA2,
+ 0xFF,
-static BYTE BiosVideoAddressToPage(ULONG Address)
+ /* AC Registers */
+ 0x00, 0x13, 0x15, 0x17, 0x02, 0x04, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
+ 0x14, 0x15, 0x16, 0x17, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_640x200_2color[] =
{
- return (Address - BiosGetVideoMemoryStart())
- / BiosGetVideoPageSize();
-}
+ /* Miscellaneous Register */
+ 0x63,
+
+ /* Sequencer Registers */
+ 0x00, 0x09, 0x0F, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0F, 0x0F, 0xFF,
-static COORD BiosVideoAddressToCoord(ULONG Address)
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 0xC1, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xC2,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17, 0x17,
+ 0x17, 0x17, 0x17, 0x17, 0x01, 0x00, 0x01, 0x00, 0x00
+};
+
+static BYTE VideoMode_320x200_16color[] =
{
- COORD Result = {0, 0};
- DWORD PageStart = BiosVideoAddressToPage(Address) * BiosGetVideoPageSize();
- DWORD Offset = Address - BiosGetVideoMemoryStart() - PageStart;
+ /* Miscellaneous Register */
+ 0x63,
- if (VideoModes[CurrentVideoMode].Text)
- {
- Result.X = (Offset / sizeof(WORD)) % VideoModes[CurrentVideoMode].Width;
- Result.Y = (Offset / sizeof(WORD)) / VideoModes[CurrentVideoMode].Width;
- }
- else
- {
- Result.X = ((Offset * 8) / VideoModes[CurrentVideoMode].Bpp)
- % VideoModes[CurrentVideoMode].Width;
- Result.Y = ((Offset * 8) / VideoModes[CurrentVideoMode].Bpp)
- / VideoModes[CurrentVideoMode].Width;
- }
+ /* Sequencer Registers */
+ 0x00, 0x09, 0x0F, 0x00, 0x02,
- return Result;
-}
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00, 0xC0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xE3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
+ 0x14, 0x15, 0x16, 0x17, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_640x200_16color[] =
+{
+ /* Miscellaneous Register */
+ 0x63,
+
+ /* Sequencer Registers */
+ 0x00, 0x01, 0x0F, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 0xC0, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x28, 0x00, 0x96, 0xB9, 0xE3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
+ 0x14, 0x15, 0x16, 0x17, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_640x350_16color[] =
+{
+ /* Miscellaneous Register */
+ 0xA3,
+
+ /* Sequencer Registers */
+ 0x00, 0x01, 0x0F, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 0x40, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x83, 0x85, 0x5D, 0x28, 0x0F, 0x63, 0xBA, 0xE3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
+ 0x3C, 0x3D, 0x3E, 0x3F, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_640x480_2color[] =
+{
+ /* Miscellaneous Register */
+ 0xE3,
+
+ /* Sequencer Registers */
+ 0x00, 0x01, 0x0F, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 0x40, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xEA, 0x8C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xC3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F, 0x3F,
+ 0x3F, 0x3F, 0x3F, 0x3F, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_640x480_16color[] =
+{
+ /* Miscellaneous Register */
+ 0xE3,
+
+ /* Sequencer Registers */
+ 0x00, 0x01, 0x0F, 0x00, 0x02,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 0x40, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0xEA, 0x8C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
+ 0x3C, 0x3D, 0x3E, 0x3F, 0x01, 0x00, 0x0F, 0x00, 0x00
+};
+
+static BYTE VideoMode_320x200_256color[] =
+{
+ /* Miscellaneous Register */
+ 0x63,
+
+ /* Sequencer Registers */
+ 0x00, 0x01, 0x0F, 0x00, 0x0E,
+
+ /* GC Registers */
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
+
+ /* CRTC Registers */
+ 0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 0x41, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3,
+ 0xFF,
+
+ /* AC Registers */
+ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
+ 0x0C, 0x0D, 0x0E, 0x0F, 0x41, 0x00, 0x0F, 0x00, 0x00
+};
+
+static LPBYTE VideoModes[] =
+{
+ VideoMode_40x25_text, /* Mode 00h */
+ VideoMode_40x25_text, /* Mode 01h */
+ VideoMode_80x25_text, /* Mode 02h */
+ VideoMode_80x25_text, /* Mode 03h */
+ VideoMode_320x200_4color, /* Mode 04h */
+ VideoMode_320x200_4color, /* Mode 05h */
+ VideoMode_640x200_2color, /* Mode 06h */
+ NULL, /* Mode 07h */
+ NULL, /* Mode 08h */
+ NULL, /* Mode 09h */
+ NULL, /* Mode 0Ah */
+ NULL, /* Mode 0Bh */
+ NULL, /* Mode 0Ch */
+ VideoMode_320x200_16color, /* Mode 0Dh */
+ VideoMode_640x200_16color, /* Mode 0Eh */
+ NULL, /* Mode 0Fh */
+ VideoMode_640x350_16color, /* Mode 10h */
+ VideoMode_640x480_2color, /* Mode 11h */
+ VideoMode_640x480_16color, /* Mode 12h */
+ VideoMode_320x200_256color, /* Mode 13h */
+};
+
+/* PRIVATE FUNCTIONS **********************************************************/
static BOOLEAN BiosKbdBufferPush(WORD Data)
{
- /* Get the location of the element after the head */
- WORD NextElement = Bda->KeybdBufferHead + 2;
+ /* Get the location of the element after the tail */
+ WORD NextElement = Bda->KeybdBufferTail + 2;
/* Wrap it around if it's at or beyond the end */
if (NextElement >= Bda->KeybdBufferEnd) NextElement = Bda->KeybdBufferStart;
/* If it's full, fail */
- if (NextElement == Bda->KeybdBufferTail) return FALSE;
+ if (NextElement == Bda->KeybdBufferHead) return FALSE;
/* Put the value in the queue */
*((LPWORD)((ULONG_PTR)Bda + Bda->KeybdBufferTail)) = Data;
return TRUE;
}
-static BOOLEAN BiosKbdBufferPop()
+static BOOLEAN BiosKbdBufferPop(VOID)
{
/* If it's empty, fail */
if (Bda->KeybdBufferHead == Bda->KeybdBufferTail) return FALSE;
return TRUE;
}
-static BOOLEAN BiosCreateGraphicsBuffer(BYTE ModeNumber)
+static VOID BiosReadWindow(LPWORD Buffer, SMALL_RECT Rectangle, BYTE Page)
{
- INT i;
- CONSOLE_GRAPHICS_BUFFER_INFO GraphicsBufferInfo;
- LPBITMAPINFO BitmapInfo;
- LPWORD PaletteIndex;
-
- /* Allocate a bitmap info structure */
- BitmapInfo = (LPBITMAPINFO)HeapAlloc(GetProcessHeap(),
- HEAP_ZERO_MEMORY,
- sizeof(BITMAPINFOHEADER)
- + (1 << VideoModes[ModeNumber].Bpp)
- * sizeof(WORD));
- if (BitmapInfo == NULL) return FALSE;
-
- /* Fill the bitmap info header */
- ZeroMemory(&BitmapInfo->bmiHeader, sizeof(BITMAPINFOHEADER));
- BitmapInfo->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
- BitmapInfo->bmiHeader.biWidth = VideoModes[ModeNumber].Width;
- BitmapInfo->bmiHeader.biHeight = VideoModes[ModeNumber].Height;
- BitmapInfo->bmiHeader.biPlanes = 1;
- BitmapInfo->bmiHeader.biCompression = BI_RGB;
- BitmapInfo->bmiHeader.biBitCount = VideoModes[ModeNumber].Bpp;
-
- /* Calculate the image size */
- BitmapInfo->bmiHeader.biSizeImage = BitmapInfo->bmiHeader.biWidth
- * BitmapInfo->bmiHeader.biHeight
- * (BitmapInfo->bmiHeader.biBitCount >> 3);
-
- /* Fill the palette data */
- PaletteIndex = (LPWORD)((ULONG_PTR)BitmapInfo + sizeof(BITMAPINFOHEADER));
- for (i = 0; i < (1 << VideoModes[ModeNumber].Bpp); i++)
- {
- PaletteIndex[i] = i;
- }
-
- /* Fill the console graphics buffer info */
- GraphicsBufferInfo.dwBitMapInfoLength = sizeof(BITMAPINFOHEADER)
- + (1 << VideoModes[ModeNumber].Bpp)
- * sizeof(WORD);
- GraphicsBufferInfo.lpBitMapInfo = BitmapInfo;
- GraphicsBufferInfo.dwUsage = DIB_PAL_COLORS;
-
- /* Create the buffer */
- BiosGraphicsOutput = CreateConsoleScreenBuffer(GENERIC_READ | GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL,
- CONSOLE_GRAPHICS_BUFFER,
- &GraphicsBufferInfo);
+ INT i, j;
+ INT Counter = 0;
+ WORD Character;
+ DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Page * Bda->VideoPageSize);
- /* Save the framebuffer address and mutex */
- ConsoleFramebuffer = GraphicsBufferInfo.lpBitMap;
- ConsoleMutex = GraphicsBufferInfo.hMutex;
-
- /* Free the bitmap information */
- HeapFree(GetProcessHeap(), 0, BitmapInfo);
+ for (i = Rectangle.Top; i <= Rectangle.Bottom; i++)
+ {
+ for (j = Rectangle.Left; j <= Rectangle.Right; j++)
+ {
+ /* Read from video memory */
+ VgaReadMemory(VideoAddress + (i * Bda->ScreenColumns + j) * sizeof(WORD),
+ (LPVOID)&Character,
+ sizeof(WORD));
- return TRUE;
+ /* Write the data to the buffer in row order */
+ Buffer[Counter++] = Character;
+ }
+ }
}
-static VOID BiosDestroyGraphicsBuffer()
+static VOID BiosWriteWindow(LPWORD Buffer, SMALL_RECT Rectangle, BYTE Page)
{
- CloseHandle(ConsoleMutex);
- CloseHandle(BiosGraphicsOutput);
+ INT i, j;
+ INT Counter = 0;
+ WORD Character;
+ DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Page * Bda->VideoPageSize);
+
+ for (i = Rectangle.Top; i <= Rectangle.Bottom; i++)
+ {
+ for (j = Rectangle.Left; j <= Rectangle.Right; j++)
+ {
+ Character = Buffer[Counter++];
+
+ /* Write to video memory */
+ VgaWriteMemory(VideoAddress + (i * Bda->ScreenColumns + j) * sizeof(WORD),
+ (LPVOID)&Character,
+ sizeof(WORD));
+ }
+ }
}
/* PUBLIC FUNCTIONS ***********************************************************/
-BYTE BiosGetVideoMode()
+BYTE BiosGetVideoMode(VOID)
{
- return CurrentVideoMode;
+ return Bda->VideoMode;
}
BOOLEAN BiosSetVideoMode(BYTE ModeNumber)
{
- COORD Coord;
+ INT i;
+ COORD Resolution;
+ LPBYTE Values = VideoModes[ModeNumber];
- /* Make sure this is a valid video mode */
- if (ModeNumber > BIOS_MAX_VIDEO_MODE) return FALSE;
- if (VideoModes[ModeNumber].Pages == 0) return FALSE;
+ if (Values == NULL) return FALSE;
- /* Set the new video mode size */
- Coord.X = VideoModes[ModeNumber].Width;
- Coord.Y = VideoModes[ModeNumber].Height;
+ /* Write the misc register */
+ VgaWritePort(VGA_MISC_WRITE, *(Values++));
- if (VideoModes[ModeNumber].Text && VideoModes[CurrentVideoMode].Text)
+ /* Write the sequencer registers */
+ for (i = 0; i < VGA_SEQ_MAX_REG; i++)
{
- /* Switching from text mode to another text mode */
-
- /* Resize the text buffer */
- SetConsoleScreenBufferSize(BiosConsoleOutput, Coord);
+ VgaWritePort(VGA_SEQ_INDEX, i);
+ VgaWritePort(VGA_SEQ_DATA, *(Values++));
}
- else if (VideoModes[ModeNumber].Text && !VideoModes[CurrentVideoMode].Text)
- {
- /* Switching from graphics mode to text mode */
-
- /* Resize the text buffer */
- SetConsoleScreenBufferSize(BiosConsoleOutput, Coord);
- /* Change the active screen buffer to the text buffer */
- SetConsoleActiveScreenBuffer(BiosConsoleOutput);
-
- /* Cleanup the graphics buffer */
- BiosDestroyGraphicsBuffer();
- }
- else if (!VideoModes[ModeNumber].Text && VideoModes[CurrentVideoMode].Text)
+ /* Write the GC registers */
+ for (i = 0; i < VGA_GC_MAX_REG; i++)
{
- /* Switching from text mode to graphics mode */
- if (!BiosCreateGraphicsBuffer(ModeNumber)) return FALSE;
-
- SetConsoleActiveScreenBuffer(BiosGraphicsOutput);
+ VgaWritePort(VGA_GC_INDEX, i);
+ VgaWritePort(VGA_GC_DATA, *(Values++));
}
- else if (!VideoModes[ModeNumber].Text && !VideoModes[CurrentVideoMode].Text)
- {
- /* Switching from graphics mode to another graphics mode */
-
- /* Temporarily switch to the text mode buffer */
- SetConsoleActiveScreenBuffer(BiosConsoleOutput);
-
- /* Cleanup the current graphics mode buffer */
- BiosDestroyGraphicsBuffer();
-
- /* Create a new graphics mode buffer */
- if (!BiosCreateGraphicsBuffer(ModeNumber)) return FALSE;
- /* Switch to it */
- SetConsoleActiveScreenBuffer(BiosGraphicsOutput);
+ /* Write the CRTC registers */
+ for (i = 0; i < VGA_CRTC_MAX_REG; i++)
+ {
+ VgaWritePort(VGA_CRTC_INDEX, i);
+ VgaWritePort(VGA_CRTC_DATA, *(Values++));
}
- /* Change the mode number */
- CurrentVideoMode = ModeNumber;
- CurrentVideoPage = 0;
+ /* Write the AC registers */
+ for (i = 0; i < VGA_AC_MAX_REG; i++)
+ {
+ VgaWritePort(VGA_AC_INDEX, i);
+ VgaWritePort(VGA_AC_WRITE, *(Values++));
+ }
- /* Update the BDA */
- Bda->VideoMode = CurrentVideoMode;
- Bda->VideoPage = CurrentVideoPage;
- Bda->VideoPageSize = BiosGetVideoPageSize();
+ /* Update the values in the BDA */
+ Bda->VideoMode = ModeNumber;
+ Bda->VideoPage = 0;
+ Bda->VideoPageSize = BIOS_PAGE_SIZE;
Bda->VideoPageOffset = 0;
- Bda->ScreenColumns = VideoModes[ModeNumber].Width;
- return TRUE;
-}
+ /* Get the character height */
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_MAX_SCAN_LINE_REG);
+ Bda->CharacterHeight = 1 + (VgaReadPort(VGA_CRTC_DATA) & 0x1F);
-BOOLEAN BiosSetVideoPage(BYTE PageNumber)
-{
- ULONG PageStart;
- COORD Coordinates;
- CONSOLE_SCREEN_BUFFER_INFO BufferInfo;
-
- /* Make sure this is a valid page number */
- if (PageNumber >= VideoModes[CurrentVideoMode].Pages) return FALSE;
-
- /* Save the current console buffer in the video memory */
- PageStart = BiosGetVideoMemoryStart() + CurrentVideoPage * BiosGetVideoPageSize();
- BiosUpdateVideoMemory(PageStart, PageStart + BiosGetVideoPageSize());
-
- /* Save the cursor */
- if (!GetConsoleScreenBufferInfo(BiosConsoleOutput, &BufferInfo)) return FALSE;
- Bda->CursorPosition[CurrentVideoPage] = MAKEWORD(BufferInfo.dwCursorPosition.X,
- BufferInfo.dwCursorPosition.Y);
-
- /* Set the page */
- CurrentVideoPage = PageNumber;
-
- /* Update the BDA */
- Bda->VideoPage = CurrentVideoPage;
- Bda->VideoPageSize = BiosGetVideoPageSize();
- Bda->VideoPageOffset = CurrentVideoPage * Bda->VideoPageSize;
-
- /* Update the console */
- PageStart = BiosGetVideoMemoryStart() + Bda->VideoPage * BiosGetVideoPageSize();
- BiosUpdateConsole(PageStart, PageStart + BiosGetVideoPageSize());
-
- /* Set the cursor */
- Coordinates.X = LOBYTE(Bda->CursorPosition[Bda->VideoPage]);
- Coordinates.Y = HIBYTE(Bda->CursorPosition[Bda->VideoPage]);
- SetConsoleCursorPosition(BiosConsoleOutput, Coordinates);
+ Resolution = VgaGetDisplayResolution();
+ Bda->ScreenColumns = Resolution.X;
+ Bda->ScreenRows = Resolution.Y - 1;
return TRUE;
}
-inline DWORD BiosGetVideoMemoryStart()
+BOOLEAN BiosSetVideoPage(BYTE PageNumber)
{
- return (VideoModes[CurrentVideoMode].Segment << 4);
-}
+ /* Check if the page exists */
+ if (PageNumber >= BIOS_MAX_PAGES) return FALSE;
-inline VOID BiosVerticalRefresh()
-{
- /* Ignore if we're in text mode */
- if (VideoModes[CurrentVideoMode].Text) return;
+ /* Check if this is the same page */
+ if (PageNumber == Bda->VideoPage) return TRUE;
- /* Ignore if there's nothing to update */
- if (!VideoNeedsUpdate) return;
+ /* Set the values in the BDA */
+ Bda->VideoPage = PageNumber;
+ Bda->VideoPageSize = BIOS_PAGE_SIZE;
+ Bda->VideoPageOffset = PageNumber * BIOS_PAGE_SIZE;
- /* Redraw the screen */
- InvalidateConsoleDIBits(BiosGraphicsOutput, &UpdateRectangle);
+ /* Set the start address in the CRTC */
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_LOW_REG);
+ VgaWritePort(VGA_CRTC_DATA , LOBYTE(Bda->VideoPageOffset));
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_HIGH_REG);
+ VgaWritePort(VGA_CRTC_DATA , HIBYTE(Bda->VideoPageOffset));
- /* Clear the update flag */
- VideoNeedsUpdate = FALSE;
+ return TRUE;
}
-BOOLEAN BiosInitialize()
+BOOLEAN BiosInitialize(VOID)
{
INT i;
WORD Offset = 0;
IntVecTable[i * 2] = Offset;
IntVecTable[i * 2 + 1] = BIOS_SEGMENT;
- if (i != SPECIAL_INT_NUM)
- {
- BiosCode[Offset++] = 0xFA; // cli
+ BiosCode[Offset++] = 0xFB; // sti
- BiosCode[Offset++] = 0x6A; // push i
- BiosCode[Offset++] = (BYTE)i;
+ BiosCode[Offset++] = 0x6A; // push i
+ BiosCode[Offset++] = (BYTE)i;
- BiosCode[Offset++] = 0xCD; // int SPECIAL_INT_NUM
- BiosCode[Offset++] = SPECIAL_INT_NUM;
+ BiosCode[Offset++] = 0x6A; // push 0
+ BiosCode[Offset++] = 0x00;
- BiosCode[Offset++] = 0x83; // add sp, 2
- BiosCode[Offset++] = 0xC4;
- BiosCode[Offset++] = 0x02;
- }
+ BiosCode[Offset++] = 0xF8; // clc
+
+ BiosCode[Offset++] = LOBYTE(EMULATOR_BOP); // BOP sequence
+ BiosCode[Offset++] = HIBYTE(EMULATOR_BOP);
+ BiosCode[Offset++] = LOBYTE(EMULATOR_INT_BOP);
+ BiosCode[Offset++] = HIBYTE(EMULATOR_INT_BOP);
+
+ BiosCode[Offset++] = 0x73; // jnc +3
+ BiosCode[Offset++] = 0x03;
+
+ // HACK: The following instruction should be HLT!
+ BiosCode[Offset++] = 0x90; // nop
+
+ BiosCode[Offset++] = 0xEB; // jmp -10
+ BiosCode[Offset++] = 0xF6;
+
+ BiosCode[Offset++] = 0x83; // add sp, 4
+ BiosCode[Offset++] = 0xC4;
+ BiosCode[Offset++] = 0x04;
BiosCode[Offset++] = 0xCF; // iret
}
- /* Get the input and output handles to the real console */
- BiosConsoleInput = CreateFile(TEXT("CONIN$"),
- GENERIC_READ | GENERIC_WRITE,
- FILE_SHARE_READ | FILE_SHARE_WRITE,
- NULL,
- OPEN_EXISTING,
- 0,
- NULL);
-
- BiosConsoleOutput = CreateFile(TEXT("CONOUT$"),
+ /* Get the input handle to the real console, and check for success */
+ BiosConsoleInput = CreateFileW(L"CONIN$",
GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE,
NULL,
OPEN_EXISTING,
0,
NULL);
+ if (BiosConsoleInput == INVALID_HANDLE_VALUE)
+ {
+ return FALSE;
+ }
- /* Make sure it was successful */
- if ((BiosConsoleInput == INVALID_HANDLE_VALUE)
- || (BiosConsoleOutput == INVALID_HANDLE_VALUE))
+ /* Get the output handle to the real console, and check for success */
+ BiosConsoleOutput = CreateFileW(L"CONOUT$",
+ GENERIC_READ | GENERIC_WRITE,
+ FILE_SHARE_READ | FILE_SHARE_WRITE,
+ NULL,
+ OPEN_EXISTING,
+ 0,
+ NULL);
+ if (BiosConsoleOutput == INVALID_HANDLE_VALUE)
{
+ CloseHandle(BiosConsoleInput);
return FALSE;
}
/* Save the console screen buffer information */
if (!GetConsoleScreenBufferInfo(BiosConsoleOutput, &BiosSavedBufferInfo))
{
+ CloseHandle(BiosConsoleOutput);
+ CloseHandle(BiosConsoleInput);
return FALSE;
}
- /* Store the cursor position */
- Bda->CursorPosition[0] = MAKEWORD(BiosSavedBufferInfo.dwCursorPosition.X,
- BiosSavedBufferInfo.dwCursorPosition.Y);
-
- /* Set the default video mode */
- BiosSetVideoMode(BIOS_DEFAULT_VIDEO_MODE);
+ /* Initialize VGA */
+ if (!VgaInitialize(BiosConsoleOutput))
+ {
+ CloseHandle(BiosConsoleOutput);
+ CloseHandle(BiosConsoleInput);
+ return FALSE;
+ }
+
+ /* Update the cursor position */
+ BiosSetCursorPosition(BiosSavedBufferInfo.dwCursorPosition.Y,
+ BiosSavedBufferInfo.dwCursorPosition.X,
+ 0);
/* Set the console input mode */
SetConsoleMode(BiosConsoleInput, ENABLE_MOUSE_INPUT | ENABLE_PROCESSED_INPUT);
/* Initialize the PIC */
PicWriteCommand(PIC_MASTER_CMD, PIC_ICW1 | PIC_ICW1_ICW4);
- PicWriteCommand(PIC_SLAVE_CMD, PIC_ICW1 | PIC_ICW1_ICW4);
+ PicWriteCommand(PIC_SLAVE_CMD , PIC_ICW1 | PIC_ICW1_ICW4);
/* Set the interrupt offsets */
PicWriteData(PIC_MASTER_DATA, BIOS_PIC_MASTER_INT);
- PicWriteData(PIC_SLAVE_DATA, BIOS_PIC_SLAVE_INT);
+ PicWriteData(PIC_SLAVE_DATA , BIOS_PIC_SLAVE_INT);
/* Tell the master PIC there is a slave at IRQ 2 */
PicWriteData(PIC_MASTER_DATA, 1 << 2);
- PicWriteData(PIC_SLAVE_DATA, 2);
+ PicWriteData(PIC_SLAVE_DATA , 2);
/* Make sure the PIC is in 8086 mode */
PicWriteData(PIC_MASTER_DATA, PIC_ICW4_8086);
- PicWriteData(PIC_SLAVE_DATA, PIC_ICW4_8086);
+ PicWriteData(PIC_SLAVE_DATA , PIC_ICW4_8086);
/* Clear the masks for both PICs */
PicWriteData(PIC_MASTER_DATA, 0x00);
- PicWriteData(PIC_SLAVE_DATA, 0x00);
+ PicWriteData(PIC_SLAVE_DATA , 0x00);
PitWriteCommand(0x34);
PitWriteData(0, 0x00);
return TRUE;
}
-VOID BiosCleanup()
+VOID BiosCleanup(VOID)
{
/* Restore the old screen buffer */
SetConsoleActiveScreenBuffer(BiosConsoleOutput);
/* Restore the screen buffer size */
SetConsoleScreenBufferSize(BiosConsoleOutput, BiosSavedBufferInfo.dwSize);
- /* Free the graphics buffer */
- if (!VideoModes[CurrentVideoMode].Text) BiosDestroyGraphicsBuffer();
-
/* Close the console handles */
- if (BiosConsoleInput != INVALID_HANDLE_VALUE) CloseHandle(BiosConsoleInput);
if (BiosConsoleOutput != INVALID_HANDLE_VALUE) CloseHandle(BiosConsoleOutput);
+ if (BiosConsoleInput != INVALID_HANDLE_VALUE) CloseHandle(BiosConsoleInput);
}
-VOID BiosUpdateConsole(ULONG StartAddress, ULONG EndAddress)
+WORD BiosPeekCharacter(VOID)
{
- ULONG i;
- COORD Coordinates;
- COORD Origin = { 0, 0 };
- COORD UnitSize = { 1, 1 };
- CHAR_INFO Character;
- SMALL_RECT Rect;
+ WORD CharacterData;
+
+ /* Get the key from the queue, but don't remove it */
+ if (BiosKbdBufferTop(&CharacterData)) return CharacterData;
+ else return 0xFFFF;
+}
- /* Start from the character address */
- StartAddress &= ~1;
+WORD BiosGetCharacter(VOID)
+{
+ WORD CharacterData = 0;
- if (VideoModes[CurrentVideoMode].Text)
+ /* Check if there is a key available */
+ if (Bda->KeybdBufferHead != Bda->KeybdBufferTail)
{
- /* Loop through all the addresses */
- for (i = StartAddress; i < EndAddress; i += 2)
- {
- /* Get the coordinates */
- Coordinates = BiosVideoAddressToCoord(i);
-
- /* Make sure this is the current page */
- if (BiosVideoAddressToPage(i) != CurrentVideoPage) continue;
-
- /* Fill the rectangle structure */
- Rect.Left = Coordinates.X;
- Rect.Top = Coordinates.Y;
- Rect.Right = Rect.Left;
- Rect.Bottom = Rect.Top;
-
- /* Fill the character data */
- Character.Char.AsciiChar = *((PCHAR)((ULONG_PTR)BaseAddress + i));
- Character.Attributes = *((PBYTE)((ULONG_PTR)BaseAddress + i + 1));
-
- /* Write the character */
- WriteConsoleOutputA(BiosConsoleOutput,
- &Character,
- UnitSize,
- Origin,
- &Rect);
- }
+ /* Get the key from the queue, and remove it */
+ BiosKbdBufferTop(&CharacterData);
+ BiosKbdBufferPop();
}
else
{
- /* Wait for the mutex object */
- WaitForSingleObject(ConsoleMutex, INFINITE);
+ /* Set the handler CF to repeat the BOP */
+ EmulatorSetFlag(EMULATOR_FLAG_CF);
+ }
- /* Copy the data to the framebuffer */
- RtlCopyMemory((LPVOID)((ULONG_PTR)ConsoleFramebuffer
- + StartAddress - BiosGetVideoMemoryStart()),
- (LPVOID)((ULONG_PTR)BaseAddress + StartAddress),
- EndAddress - StartAddress);
+ return CharacterData;
+}
- /* Release the mutex */
- ReleaseMutex(ConsoleMutex);
+VOID BiosSetCursorPosition(BYTE Row, BYTE Column, BYTE Page)
+{
+ /* Make sure the selected video page is valid */
+ if (Page >= BIOS_MAX_PAGES) return;
- /* Check if this is the first time the rectangle is updated */
- if (!VideoNeedsUpdate)
- {
- UpdateRectangle.Left = UpdateRectangle.Top = (SHORT)0x7FFF;
- UpdateRectangle.Right = UpdateRectangle.Bottom = (SHORT)0x8000;
- }
+ /* Update the position in the BDA */
+ Bda->CursorPosition[Page] = (Row << 8) | Column;
- /* Expand the update rectangle */
- for (i = StartAddress; i < EndAddress; i++)
- {
- /* Get the coordinates */
- Coordinates = BiosVideoAddressToCoord(i);
-
- /* Expand the rectangle to include the point */
- UpdateRectangle.Left = min(UpdateRectangle.Left, Coordinates.X);
- UpdateRectangle.Right = max(UpdateRectangle.Right, Coordinates.X);
- UpdateRectangle.Top = min(UpdateRectangle.Top, Coordinates.Y);
- UpdateRectangle.Bottom = max(UpdateRectangle.Bottom, Coordinates.Y);
- }
+ /* Check if this is the current video page */
+ if (Page == Bda->VideoPage)
+ {
+ WORD Offset = Row * Bda->ScreenColumns + Column;
- /* Set the update flag */
- VideoNeedsUpdate = TRUE;
+ /* Modify the CRTC registers */
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_LOW_REG);
+ VgaWritePort(VGA_CRTC_DATA , LOBYTE(Offset));
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_HIGH_REG);
+ VgaWritePort(VGA_CRTC_DATA , HIBYTE(Offset));
}
}
-VOID BiosUpdateVideoMemory(ULONG StartAddress, ULONG EndAddress)
+BOOLEAN BiosScrollWindow(INT Direction,
+ DWORD Amount,
+ SMALL_RECT Rectangle,
+ BYTE Page,
+ BYTE FillAttribute)
{
- ULONG i;
- COORD Coordinates;
- WORD Attribute;
- DWORD CharsWritten;
+ DWORD i;
+ LPWORD WindowData;
+ DWORD WindowSize = (Rectangle.Bottom - Rectangle.Top + 1)
+ * (Rectangle.Right - Rectangle.Left + 1);
- if (VideoModes[CurrentVideoMode].Text)
- {
- /* Loop through all the addresses */
- for (i = StartAddress; i < EndAddress; i++)
- {
- /* Get the coordinates */
- Coordinates = BiosVideoAddressToCoord(i);
+ /* Allocate a buffer for the window */
+ WindowData = (LPWORD)HeapAlloc(GetProcessHeap(),
+ HEAP_ZERO_MEMORY,
+ WindowSize * sizeof(WORD));
+ if (WindowData == NULL) return FALSE;
- /* Make sure this is the current page */
- if (BiosVideoAddressToPage(i) != CurrentVideoPage) continue;
+ /* Read the window data */
+ BiosReadWindow(WindowData, Rectangle, Page);
- /* Check if this is a character byte or an attribute byte */
- if ((i - BiosGetVideoMemoryStart()) % 2 == 0)
- {
- /* This is a regular character */
- ReadConsoleOutputCharacterA(BiosConsoleOutput,
- (LPSTR)((ULONG_PTR)BaseAddress + i),
- sizeof(CHAR),
- Coordinates,
- &CharsWritten);
- }
- else
- {
- /* This is an attribute */
- ReadConsoleOutputAttribute(BiosConsoleOutput,
- &Attribute,
- sizeof(CHAR),
- Coordinates,
- &CharsWritten);
-
- *(PCHAR)((ULONG_PTR)BaseAddress + i) = LOBYTE(Attribute);
- }
+ if (Amount == 0)
+ {
+ /* Fill the window */
+ for (i = 0; i < WindowSize; i++)
+ {
+ WindowData[i] = ' ' | (FillAttribute << 8);
}
+
+ goto Done;
}
- else
- {
- /* Wait for the mutex object */
- WaitForSingleObject(ConsoleMutex, INFINITE);
- /* Copy the data to the emulator memory */
- RtlCopyMemory((LPVOID)((ULONG_PTR)BaseAddress + StartAddress),
- (LPVOID)((ULONG_PTR)ConsoleFramebuffer
- + StartAddress - BiosGetVideoMemoryStart()),
- EndAddress - StartAddress);
+ // TODO: Scroll the window!
- /* Release the mutex */
- ReleaseMutex(ConsoleMutex);
- }
+Done:
+ /* Write back the window data */
+ BiosWriteWindow(WindowData, Rectangle, Page);
+
+ /* Free the window buffer */
+ HeapFree(GetProcessHeap(), 0, WindowData);
+
+ return TRUE;
}
-WORD BiosPeekCharacter()
+VOID BiosPrintCharacter(CHAR Character, BYTE Attribute, BYTE Page)
{
- WORD CharacterData;
-
- /* Check if there is a key available */
- if (Bda->KeybdBufferHead == Bda->KeybdBufferTail) return 0xFFFF;
+ WORD CharData = (Attribute << 8) | Character;
+ BYTE Row, Column;
- /* Get the key from the queue, but don't remove it */
- BiosKbdBufferTop(&CharacterData);
+ /* Make sure the page exists */
+ if (Page >= BIOS_MAX_PAGES) return;
- return CharacterData;
-}
+ /* Get the cursor location */
+ Row = HIBYTE(Bda->CursorPosition[Page]);
+ Column = LOBYTE(Bda->CursorPosition[Page]);
-WORD BiosGetCharacter()
-{
- WORD CharacterData;
- INPUT_RECORD InputRecord;
- DWORD Count;
+ if (Character == '\a')
+ {
+ /* Bell control character */
+ // NOTE: We may use what the terminal emulator offers to us...
+ Beep(800, 200);
+ return;
+ }
+ else if (Character == '\b')
+ {
+ /* Backspace control character */
+ if (Column > 0)
+ {
+ Column--;
+ }
+ else if (Row > 0)
+ {
+ Column = Bda->ScreenColumns - 1;
+ Row--;
+ }
- /* Check if there is a key available */
- if (Bda->KeybdBufferHead != Bda->KeybdBufferTail)
+ /* Erase the existing character */
+ CharData = (Attribute << 8) | ' ';
+ VgaWriteMemory(TO_LINEAR(TEXT_VIDEO_SEG,
+ Page * Bda->VideoPageSize
+ + (Row * Bda->ScreenColumns + Column) * sizeof(WORD)),
+ (LPVOID)&CharData,
+ sizeof(WORD));
+ }
+ else if (Character == '\n')
{
- /* Get the key from the queue, and remove it */
- BiosKbdBufferTop(&CharacterData);
- BiosKbdBufferPop();
+ /* Line Feed control character */
+ Row++;
+ }
+ else if (Character == '\r')
+ {
+ /* Carriage Return control character */
+ Column = 0;
}
else
{
- while (TRUE)
- {
- /* Wait for a console event */
- WaitForSingleObject(BiosConsoleInput, INFINITE);
-
- /* Read the event, and make sure it's a keypress */
- if (!ReadConsoleInput(BiosConsoleInput, &InputRecord, 1, &Count)) continue;
- if (InputRecord.EventType != KEY_EVENT) continue;
- if (!InputRecord.Event.KeyEvent.bKeyDown) continue;
+ /* Default character */
- /* Save the scan code and end the loop */
- CharacterData = (InputRecord.Event.KeyEvent.wVirtualScanCode << 8)
- | InputRecord.Event.KeyEvent.uChar.AsciiChar;
+ /* Write the character */
+ VgaWriteMemory(TO_LINEAR(TEXT_VIDEO_SEG,
+ Page * Bda->VideoPageSize
+ + (Row * Bda->ScreenColumns + Column) * sizeof(WORD)),
+ (LPVOID)&CharData,
+ sizeof(WORD));
- break;
- }
+ /* Advance the cursor */
+ Column++;
}
- return CharacterData;
+ /* Check if it passed the end of the row */
+ if (Column >= Bda->ScreenColumns)
+ {
+ /* Return to the first column and go to the next line */
+ Column = 0;
+ Row++;
+ }
+
+ /* Scroll the screen up if needed */
+ if (Row > Bda->ScreenRows)
+ {
+ /* The screen must be scrolled up */
+ SMALL_RECT Rectangle = { 0, 0, Bda->ScreenColumns - 1, Bda->ScreenRows };
+
+ BiosScrollWindow(SCROLL_DIRECTION_UP,
+ 1,
+ Rectangle,
+ Page,
+ DEFAULT_ATTRIBUTE);
+ }
+
+ /* Set the cursor position */
+ BiosSetCursorPosition(Row, Column, Page);
}
-VOID BiosVideoService()
+VOID BiosVideoService(LPWORD Stack)
{
- INT i, CursorHeight;
- BOOLEAN Invisible = FALSE;
- COORD Position;
- CONSOLE_CURSOR_INFO CursorInfo;
- CHAR_INFO Character;
- SMALL_RECT Rect;
DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
DWORD Ecx = EmulatorGetRegister(EMULATOR_REG_CX);
DWORD Edx = EmulatorGetRegister(EMULATOR_REG_DX);
case 0x00:
{
BiosSetVideoMode(LOBYTE(Eax));
+ VgaClearMemory();
break;
}
/* Set Text-Mode Cursor Shape */
case 0x01:
{
- /* Retrieve and validate the input */
- Invisible = ((HIBYTE(Ecx) >> 5) & 0x03) ? TRUE : FALSE;
- CursorHeight = (HIBYTE(Ecx) & 0x1F) - (LOBYTE(Ecx) & 0x1F);
- if (CursorHeight < 1) CursorHeight = 1;
- if (CursorHeight > 100) CursorHeight = 100;
-
/* Update the BDA */
Bda->CursorStartLine = HIBYTE(Ecx);
- Bda->CursorEndLine = LOBYTE(Ecx) & 0x1F;
+ Bda->CursorEndLine = LOBYTE(Ecx);
- /* Set the cursor */
- CursorInfo.dwSize = (CursorHeight * 100) / CONSOLE_FONT_HEIGHT;
- CursorInfo.bVisible = !Invisible;
- SetConsoleCursorInfo(BiosConsoleOutput, &CursorInfo);
+ /* Modify the CRTC registers */
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_START_REG);
+ VgaWritePort(VGA_CRTC_DATA , Bda->CursorStartLine);
+ VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_END_REG);
+ VgaWritePort(VGA_CRTC_DATA , Bda->CursorEndLine);
break;
}
/* Set Cursor Position */
case 0x02:
{
- /* Make sure the selected video page exists */
- if (HIBYTE(Ebx) >= VideoModes[CurrentVideoMode].Pages) break;
-
- Bda->CursorPosition[HIBYTE(Ebx)] = LOWORD(Edx);
-
- /* Check if this is the current video page */
- if (HIBYTE(Ebx) == CurrentVideoPage)
- {
- /* Yes, change the actual cursor */
- Position.X = LOBYTE(Edx);
- Position.Y = HIBYTE(Edx);
- SetConsoleCursorPosition(BiosConsoleOutput, Position);
- }
-
+ BiosSetCursorPosition(HIBYTE(Edx), LOBYTE(Edx), HIBYTE(Ebx));
break;
}
case 0x03:
{
/* Make sure the selected video page exists */
- if (HIBYTE(Ebx) >= VideoModes[CurrentVideoMode].Pages) break;
+ if (HIBYTE(Ebx) >= BIOS_MAX_PAGES) break;
/* Return the result */
EmulatorSetRegister(EMULATOR_REG_AX, 0);
break;
}
+ /* Query Light Pen */
+ case 0x04:
+ {
+ /*
+ * On modern BIOSes, this function returns 0
+ * so that we can ignore the other registers.
+ */
+ EmulatorSetRegister(EMULATOR_REG_AX, 0);
+ break;
+ }
+
/* Select Active Display Page */
case 0x05:
{
- /* Check if the page exists */
- if (LOBYTE(Eax) >= VideoModes[CurrentVideoMode].Pages) break;
-
- /* Check if this is the same page */
- if (LOBYTE(Eax) == CurrentVideoPage) break;
-
- /* Change the video page */
BiosSetVideoPage(LOBYTE(Eax));
-
break;
}
- /* Scroll Up/Down Window */
- // TODO: Implement for different pages
+ /* Scroll Window Up/Down */
case 0x06:
case 0x07:
{
- BYTE Lines = LOBYTE(Eax);
-
- Rect.Top = HIBYTE(Ecx);
- Rect.Left = LOBYTE(Ecx);
- Rect.Bottom = HIBYTE(Edx);
- Rect.Right = LOBYTE(Edx);
- Character.Char.UnicodeChar = L' ';
- Character.Attributes = HIBYTE(Ebx);
- Position.X = Rect.Left;
-
- /* 0 means clear entire window */
- if (Lines == 0) Lines = Rect.Bottom - Rect.Top;
-
- if (HIBYTE(Eax) == 0x06) Position.Y = Rect.Top - Lines;
- else Position.Y = Rect.Top + Lines;
-
- ScrollConsoleScreenBuffer(BiosConsoleOutput,
- &Rect,
- &Rect,
- Position,
- &Character);
+ SMALL_RECT Rectangle =
+ {
+ LOBYTE(Ecx),
+ HIBYTE(Ecx),
+ LOBYTE(Edx),
+ HIBYTE(Edx)
+ };
+
+ /* Call the internal function */
+ BiosScrollWindow((HIBYTE(Eax) == 0x06) ? SCROLL_DIRECTION_UP
+ : SCROLL_DIRECTION_DOWN,
+ LOBYTE(Eax),
+ Rectangle,
+ Bda->VideoPage,
+ HIBYTE(Ebx));
break;
}
- /* Read Character And Attribute At Cursor Position */
+ /* Read/Write Character From Cursor Position */
case 0x08:
- {
- DWORD Address;
-
- /* Make sure this is text mode */
- if (!VideoModes[CurrentVideoMode].Text) break;
-
- /* Make sure the selected video page exists */
- if (HIBYTE(Ebx) >= VideoModes[CurrentVideoMode].Pages) break;
-
- /* Find the address */
- Address = BiosGetVideoMemoryStart()
- + HIBYTE(Ebx) * BiosGetVideoPageSize()
- + (HIBYTE(Bda->CursorPosition[HIBYTE(Ebx)])
- * VideoModes[CurrentVideoMode].Height
- + LOBYTE(Bda->CursorPosition[HIBYTE(Ebx)]))
- * VideoModes[CurrentVideoMode].Bpp / 8;
-
- /* Update the video memory at that address */
- BiosUpdateVideoMemory(Address,
- Address + VideoModes[CurrentVideoMode].Bpp / 8);
-
- /* Return the result in AX */
- EmulatorSetRegister(EMULATOR_REG_AX,
- *((LPWORD)((ULONG_PTR)BaseAddress + Address)));
-
- break;
- }
-
- /* Write Character And Attribute At Cursor Position */
case 0x09:
case 0x0A:
{
- BYTE PixelSize = VideoModes[CurrentVideoMode].Bpp / 8;
- WORD Data = (LOBYTE(Ebx) << 8) | LOBYTE(Eax);
- WORD Repeat = LOWORD(Ecx);
- DWORD Address = BiosGetVideoMemoryStart()
- + CurrentVideoPage * BiosGetVideoPageSize()
- + (HIBYTE(Bda->CursorPosition[CurrentVideoPage])
- * VideoModes[CurrentVideoMode].Height
- + LOBYTE(Bda->CursorPosition[CurrentVideoPage]))
- * PixelSize;
-
- /* Make sure this is text mode */
- if (!VideoModes[CurrentVideoMode].Text) break;
+ WORD CharacterData = MAKEWORD(LOBYTE(Eax), LOBYTE(Ebx));
+ BYTE Page = HIBYTE(Ebx);
+ DWORD Offset;
- /* Make sure the selected video page exists */
- if (HIBYTE(Ebx) >= VideoModes[CurrentVideoMode].Pages) break;
+ /* Check if the page exists */
+ if (Page >= BIOS_MAX_PAGES) break;
- /* Make sure we don't write over the end of video memory */
- Repeat = min(Repeat,
- (CONSOLE_VIDEO_MEM_END - Address)
- / PixelSize);
+ /* Find the offset of the character */
+ Offset = Page * Bda->VideoPageSize
+ + (HIBYTE(Bda->CursorPosition[Page]) * Bda->ScreenColumns
+ + LOBYTE(Bda->CursorPosition[Page])) * 2;
- /* Copy the values to the memory */
- for (i = 0; i < Repeat; i++)
+ if (HIBYTE(Eax) == 0x08)
{
- if (PixelSize == sizeof(BYTE) || HIBYTE(Eax) == 0x0A)
- {
- /* Just characters, no attributes */
- *((LPBYTE)((ULONG_PTR)BaseAddress + Address) + i * PixelSize) = LOBYTE(Data);
- }
- else if (PixelSize == sizeof(WORD))
- {
- /* First byte for characters, second for attributes */
- *((LPWORD)((ULONG_PTR)BaseAddress + Address) + i) = Data;
- }
- }
+ /* Read from the video memory */
+ VgaReadMemory(TO_LINEAR(TEXT_VIDEO_SEG, Offset),
+ (LPVOID)&CharacterData,
+ sizeof(WORD));
- /* Update the range */
- BiosUpdateConsole(Address,
- Address + Repeat * (VideoModes[CurrentVideoMode].Bpp / 8));
+ /* Return the character in AX */
+ EmulatorSetRegister(EMULATOR_REG_AX, CharacterData);
+ }
+ else
+ {
+ /* Write to video memory */
+ VgaWriteMemory(TO_LINEAR(TEXT_VIDEO_SEG, Offset),
+ (LPVOID)&CharacterData,
+ (HIBYTE(Ebx) == 0x09) ? sizeof(WORD) : sizeof(BYTE));
+ }
break;
}
/* Teletype Output */
case 0x0E:
{
- CHAR Character = LOBYTE(Eax);
- DWORD NumWritten;
-
- /* Make sure the page exists */
- if (HIBYTE(Ebx) >= VideoModes[CurrentVideoMode].Pages) break;
-
- /* Set the attribute */
- SetConsoleTextAttribute(BiosConsoleOutput, LOBYTE(Ebx));
-
- /* Write the character */
- WriteConsoleA(BiosConsoleOutput,
- &Character,
- sizeof(CHAR),
- &NumWritten,
- NULL);
-
+ BiosPrintCharacter(LOBYTE(Eax), LOBYTE(Ebx), HIBYTE(Ebx));
break;
}
/* Scroll Window */
case 0x12:
{
- Rect.Top = HIBYTE(Ecx);
- Rect.Left = LOBYTE(Ecx);
- Rect.Bottom = HIBYTE(Edx);
- Rect.Right = LOBYTE(Edx);
- Character.Char.UnicodeChar = L' ';
- Character.Attributes = 0x07;
- Position.X = Rect.Left;
- Position.Y = Rect.Top;
-
- if (LOBYTE(Ebx) == 0) Position.Y -= LOBYTE(Eax);
- else if (LOBYTE(Ebx) == 1) Position.Y += LOBYTE(Eax);
- else if (LOBYTE(Ebx) == 2) Position.X -= LOBYTE(Eax);
- else if (LOBYTE(Ebx) == 3) Position.X += LOBYTE(Eax);
-
- ScrollConsoleScreenBuffer(BiosConsoleOutput,
- &Rect,
- &Rect,
- Position,
- &Character);
+ SMALL_RECT Rectangle =
+ {
+ LOBYTE(Ecx),
+ HIBYTE(Ecx),
+ LOBYTE(Edx),
+ HIBYTE(Edx)
+ };
+
+ /* Call the internal function */
+ BiosScrollWindow(LOBYTE(Ebx),
+ LOBYTE(Eax),
+ Rectangle,
+ Bda->VideoPage,
+ DEFAULT_ATTRIBUTE);
break;
}
+ /* Display combination code */
+ case 0x1A:
+ {
+ switch(LOBYTE(Eax))
+ {
+ case 0x00: /* Get Display combiantion code */
+ EmulatorSetRegister(EMULATOR_REG_AX, MAKEWORD(0x1A, 0x1A));
+ EmulatorSetRegister(EMULATOR_REG_BX, MAKEWORD(0x08, 0x0)); /* VGA w/ color analog display */
+ break;
+ case 0x01: /* Set Display combination code */
+ DPRINT1("Set Display combination code - Unsupported\n");
+ break;
+ default:
+ break;
+ }
+ break;
+ }
+
default:
{
DPRINT1("BIOS Function INT 10h, AH = 0x%02X NOT IMPLEMENTED\n",
}
}
-VOID BiosKeyboardService()
+VOID BiosKeyboardService(LPWORD Stack)
{
DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
switch (HIBYTE(Eax))
{
+ /* Wait for keystroke and read */
case 0x00:
+ /* Wait for extended keystroke and read */
+ case 0x10: // FIXME: Temporarily do the same as INT 16h, 00h
{
/* Read the character (and wait if necessary) */
EmulatorSetRegister(EMULATOR_REG_AX, BiosGetCharacter());
-
break;
}
+ /* Get keystroke status */
case 0x01:
+ /* Get extended keystroke status */
+ case 0x11: // FIXME: Temporarily do the same as INT 16h, 01h
{
WORD Data = BiosPeekCharacter();
{
/* There is a character, clear ZF and return it */
EmulatorSetRegister(EMULATOR_REG_AX, Data);
- EmulatorClearFlag(EMULATOR_FLAG_ZF);
+ Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_ZF;
}
else
{
/* No character, set ZF */
- EmulatorSetFlag(EMULATOR_FLAG_ZF);
+ Stack[STACK_FLAGS] |= EMULATOR_FLAG_ZF;
}
break;
}
-
+
+ /* Get shift status */
+ case 0x02:
+ {
+ /* Return the lower byte of the keyboard shift status word */
+ setAL(LOBYTE(Bda->KeybdShiftFlags));
+ break;
+ }
+
+ /* Reserved */
+ case 0x04:
+ {
+ DPRINT1("BIOS Function INT 16h, AH = 0x04 is RESERVED\n");
+ break;
+ }
+
+ /* Push keystroke */
+ case 0x05:
+ {
+ /* Return 0 if success, 1 if failure */
+ setAL(BiosKbdBufferPush(getCX()) == FALSE);
+ break;
+ }
+
+ /* Get extended shift status */
+ case 0x12:
+ {
+ /*
+ * Be careful! The returned word is similar to Bda->KeybdShiftFlags
+ * but the high byte is organized differently:
+ * the bytes 2 and 3 of the high byte are not the same...
+ */
+ WORD KeybdShiftFlags = (Bda->KeybdShiftFlags & 0xF3FF);
+
+ /* Return the extended keyboard shift status word */
+ setAX(KeybdShiftFlags);
+ break;
+ }
+
default:
{
DPRINT1("BIOS Function INT 16h, AH = 0x%02X NOT IMPLEMENTED\n",
}
}
-VOID BiosTimeService()
+VOID BiosTimeService(LPWORD Stack)
{
DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
DWORD Ecx = EmulatorGetRegister(EMULATOR_REG_CX);
}
}
-VOID BiosSystemTimerInterrupt()
+VOID BiosSystemTimerInterrupt(LPWORD Stack)
{
/* Increase the system tick count */
Bda->TickCounter++;
}
-VOID BiosEquipmentService()
+VOID BiosEquipmentService(LPWORD Stack)
{
/* Return the equipment list */
EmulatorSetRegister(EMULATOR_REG_AX, Bda->EquipmentList);
}
-VOID BiosHandleIrq(BYTE IrqNumber)
+VOID BiosHandleIrq(BYTE IrqNumber, LPWORD Stack)
{
switch (IrqNumber)
{
{
BYTE ScanCode, VirtualKey;
WORD Character;
-
- /* Check if there is a scancode available */
- if (!(KeyboardReadStatus() & 1)) break;
-
- /* Get the scan code and virtual key code */
- ScanCode = KeyboardReadData();
- VirtualKey = MapVirtualKey(ScanCode & 0x7F, MAPVK_VSC_TO_VK);
- /* Check if this is a key press or release */
- if (!(ScanCode & (1 << 7)))
+ /* Loop while there is a scancode available */
+ do
{
- /* Key press */
- if (VirtualKey == VK_NUMLOCK
- || VirtualKey == VK_CAPITAL
- || VirtualKey == VK_SCROLL)
+ /* Get the scan code and virtual key code */
+ ScanCode = KeyboardReadData();
+ VirtualKey = MapVirtualKey(ScanCode & 0x7F, MAPVK_VSC_TO_VK);
+
+ /* Check if this is a key press or release */
+ if (!(ScanCode & (1 << 7)))
{
- /* For toggle keys, toggle the lowest bit in the keyboard map */
- BiosKeyboardMap[VirtualKey] ^= ~(1 << 0);
- }
+ /* Key press */
+ if (VirtualKey == VK_NUMLOCK
+ || VirtualKey == VK_CAPITAL
+ || VirtualKey == VK_SCROLL
+ || VirtualKey == VK_INSERT)
+ {
+ /* For toggle keys, toggle the lowest bit in the keyboard map */
+ BiosKeyboardMap[VirtualKey] ^= ~(1 << 0);
+ }
+
+ /* Set the highest bit */
+ BiosKeyboardMap[VirtualKey] |= (1 << 7);
- /* Set the highest bit */
- BiosKeyboardMap[VirtualKey] |= (1 << 7);
+ /* Find out which character this is */
+ Character = 0;
+ if (ToAscii(VirtualKey, ScanCode, BiosKeyboardMap, &Character, 0) == 0)
+ {
+ /* Not ASCII */
+ Character = 0;
+ }
- /* Find out which character this is */
- if (ToAscii(VirtualKey, ScanCode, BiosKeyboardMap, &Character, 0) > 0)
- {
/* Push it onto the BIOS keyboard queue */
- BiosKbdBufferPush((ScanCode << 8) | (Character & 0xFF));
+ BiosKbdBufferPush(MAKEWORD(Character, ScanCode));
+ }
+ else
+ {
+ /* Key release, unset the highest bit */
+ BiosKeyboardMap[VirtualKey] &= ~(1 << 7);
}
}
- else
- {
- /* Key release, unset the highest bit */
- BiosKeyboardMap[VirtualKey] &= ~(1 << 7);
- }
+ while (KeyboardReadStatus() & 1);
+
+ /* Clear the keyboard flags */
+ Bda->KeybdShiftFlags = 0;
+
+ /* Set the appropriate flags based on the state */
+ if (BiosKeyboardMap[VK_RSHIFT] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_RSHIFT;
+ if (BiosKeyboardMap[VK_LSHIFT] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LSHIFT;
+ if (BiosKeyboardMap[VK_CONTROL] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CTRL;
+ if (BiosKeyboardMap[VK_MENU] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_ALT;
+ if (BiosKeyboardMap[VK_SCROLL] & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SCROLL_ON;
+ if (BiosKeyboardMap[VK_NUMLOCK] & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_NUMLOCK_ON;
+ if (BiosKeyboardMap[VK_CAPITAL] & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CAPSLOCK_ON;
+ if (BiosKeyboardMap[VK_INSERT] & (1 << 0)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_INSERT_ON;
+ if (BiosKeyboardMap[VK_RMENU] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_RALT;
+ if (BiosKeyboardMap[VK_LMENU] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_LALT;
+ if (BiosKeyboardMap[VK_SNAPSHOT] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SYSRQ;
+ if (BiosKeyboardMap[VK_PAUSE] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_PAUSE;
+ if (BiosKeyboardMap[VK_SCROLL] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_SCROLL;
+ if (BiosKeyboardMap[VK_NUMLOCK] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_NUMLOCK;
+ if (BiosKeyboardMap[VK_CAPITAL] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_CAPSLOCK;
+ if (BiosKeyboardMap[VK_INSERT] & (1 << 7)) Bda->KeybdShiftFlags |= BDA_KBDFLAG_INSERT;
break;
}
projects / reactos.git / blobdiff