subsystems/ntvdm/bios.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            bios.c
   5  * PURPOSE:         VDM BIOS
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 #include "bios.h"
  14 #include "emulator.h"
  15 #include "vga.h"
  16 #include "pic.h"
  17 #include "ps2.h"
  18 #include "timer.h"
  19
  20 /* PRIVATE VARIABLES **********************************************************/
  21
  22 static PBIOS_DATA_AREA Bda;
  23 static BYTE BiosKeyboardMap[256];
  24 static HANDLE BiosConsoleInput  = INVALID_HANDLE_VALUE;
  25 static HANDLE BiosConsoleOutput = INVALID_HANDLE_VALUE;
  26 static CONSOLE_SCREEN_BUFFER_INFO BiosSavedBufferInfo;
  27
  28 static BYTE VideoMode_40x25_text[] =
  29 {
  30     /* Miscellaneous Register */
  31     0x67,
  32
  33     /* Sequencer Registers */
  34     0x03, 0x08, 0x03, 0x00, 0x02,
  35
  36     /* GC Registers */
  37     0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x0F, 0xFF,
  38
  39     /* CRTC Registers */
  40     0x2D, 0x27, 0x28, 0x90, 0x2B, 0xA0, 0xBF, 0x1F, 0x00, 0x4F, 0x0E, 0x0F,
  41     0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x14, 0x1F, 0x96, 0xB9, 0xA3,
  42     0xFF,
  43
  44     /* AC Registers */
  45     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
  46     0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x01, 0x0F, 0x13, 0x00
  47 };
  48
  49 static BYTE VideoMode_80x25_text[] =
  50 {
  51     /* Miscellaneous Register */
  52     0x67,
  53
  54     /* Sequencer Registers */
  55     0x03, 0x00, 0x03, 0x00, 0x02,
  56
  57     /* GC Registers */
  58     0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x0E, 0x0F, 0xFF,
  59
  60     /* CRTC Registers */
  61     0x5F, 0x4F, 0x50, 0x82, 0x55, 0x81, 0xBF, 0x1F, 0x00, 0x4F, 0x0E, 0x0F,
  62     0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x28, 0x1F, 0x96, 0xB9, 0xA3,
  63     0xFF,
  64
  65     /* AC Registers */
  66     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
  67     0x3C, 0x3D, 0x3E, 0x3F, 0x0C, 0x01, 0x0F, 0x13, 0x00
  68 };
  69
  70 static BYTE VideoMode_320x200_4color[] =
  71 {
  72     /* Miscellaneous Register */
  73     0x63,
  74
  75     /* Sequencer Registers */
  76     0x03, 0x09, 0x03, 0x00, 0x02,
  77
  78     /* GC Registers */
  79     0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x0F, 0x0F, 0xFF,
  80
  81     /* CRTC Registers */
  82     0x2D, 0x27, 0x28, 0x90, 0x2B, 0x80, 0xBF, 0x1F, 0x00, 0xC1, 0x00, 0x00,
  83     0x00, 0x00, 0x00, 0x00, 0x9C, 0x8E, 0x8F, 0x14, 0x00, 0x96, 0xB9, 0xA2,
  84     0xFF,
  85
  86     /* AC Registers */
  87     0x00, 0x13, 0x15, 0x17, 0x02, 0x04, 0x06, 0x07, 0x10, 0x11, 0x12, 0x13,
  88     0x14, 0x15, 0x16, 0x17, 0x01, 0x00, 0x03, 0x00, 0x00
  89 };
  90
  91 static BYTE VideoMode_640x480_16color[] =
  92 {
  93     /* Miscellaneous Register */
  94     0xE3,
  95
  96     /* Sequencer Registers */
  97     0x03, 0x01, 0x08, 0x00, 0x06,
  98
  99     /* GC Registers */
 100     0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x05, 0x0F, 0xFF,
 101
 102     /* CRTC Registers */
 103     0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0x0B, 0x3E, 0x00, 0x40, 0x00, 0x00,
 104     0x00, 0x00, 0x00, 0x00, 0xEA, 0x0C, 0xDF, 0x28, 0x00, 0xE7, 0x04, 0xE3,
 105     0xFF,
 106
 107     /* AC Registers */
 108     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x14, 0x07, 0x38, 0x39, 0x3A, 0x3B,
 109     0x3C, 0x3D, 0x3E, 0x3F, 0x01, 0x00, 0x0F, 0x00, 0x00
 110 };
 111
 112 static BYTE VideoMode_320x200_256color[] =
 113 {
 114     /* Miscellaneous Register */
 115     0x63,
 116
 117     /* Sequencer Registers */
 118     0x03, 0x01, 0x0F, 0x00, 0x0E,
 119
 120     /* GC Registers */
 121     0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x05, 0x0F, 0xFF,
 122
 123     /* CRTC Registers */
 124     0x5F, 0x4F, 0x50, 0x82, 0x54, 0x80, 0xBF, 0x1F, 0x00, 0x41, 0x00, 0x00,
 125     0x00, 0x00, 0x00, 0x00, 0x9C, 0x0E, 0x8F, 0x28, 0x40, 0x96, 0xB9, 0xA3,
 126     0xFF,
 127
 128     /* AC Registers */
 129     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A, 0x0B,
 130     0x0C, 0x0D, 0x0E, 0x0F, 0x41, 0x00, 0x0F, 0x00, 0x00
 131 };
 132
 133 static LPBYTE VideoModes[] =
 134 {
 135     VideoMode_40x25_text,       /* Mode 00h */
 136     VideoMode_40x25_text,       /* Mode 01h */
 137     VideoMode_80x25_text,       /* Mode 02h */
 138     VideoMode_80x25_text,       /* Mode 03h */
 139     VideoMode_320x200_4color,   /* Mode 04h */
 140     VideoMode_320x200_4color,   /* Mode 05h */
 141     NULL,                       /* Mode 06h */
 142     NULL,                       /* Mode 07h */
 143     NULL,                       /* Mode 08h */
 144     NULL,                       /* Mode 09h */
 145     NULL,                       /* Mode 0Ah */
 146     NULL,                       /* Mode 0Bh */
 147     NULL,                       /* Mode 0Ch */
 148     NULL,                       /* Mode 0Dh */
 149     NULL,                       /* Mode 0Eh */
 150     NULL,                       /* Mode 0Fh */
 151     NULL,                       /* Mode 10h */
 152     NULL,                       /* Mode 11h */
 153     VideoMode_640x480_16color,  /* Mode 12h */
 154     VideoMode_320x200_256color, /* Mode 13h */
 155 };
 156
 157 /* PRIVATE FUNCTIONS **********************************************************/
 158
 159 static BOOLEAN BiosKbdBufferPush(WORD Data)
 160 {
 161     /* Get the location of the element after the head */
 162     WORD NextElement = Bda->KeybdBufferHead + 2;
 163
 164     /* Wrap it around if it's at or beyond the end */
 165     if (NextElement >= Bda->KeybdBufferEnd) NextElement = Bda->KeybdBufferStart;
 166
 167     /* If it's full, fail */
 168     if (NextElement == Bda->KeybdBufferTail) return FALSE;
 169
 170     /* Put the value in the queue */
 171     *((LPWORD)((ULONG_PTR)Bda + Bda->KeybdBufferTail)) = Data;
 172     Bda->KeybdBufferTail += sizeof(WORD);
 173
 174     /* Check if we are at, or have passed, the end of the buffer */
 175     if (Bda->KeybdBufferTail >= Bda->KeybdBufferEnd)
 176     {
 177         /* Return it to the beginning */
 178         Bda->KeybdBufferTail = Bda->KeybdBufferStart;
 179     }
 180
 181     /* Return success */
 182     return TRUE;
 183 }
 184
 185 static BOOLEAN BiosKbdBufferTop(LPWORD Data)
 186 {
 187     /* If it's empty, fail */
 188     if (Bda->KeybdBufferHead == Bda->KeybdBufferTail) return FALSE;
 189
 190     /* Otherwise, get the value and return success */
 191     *Data = *((LPWORD)((ULONG_PTR)Bda + Bda->KeybdBufferHead));
 192
 193     return TRUE;
 194 }
 195
 196 static BOOLEAN BiosKbdBufferPop(VOID)
 197 {
 198     /* If it's empty, fail */
 199     if (Bda->KeybdBufferHead == Bda->KeybdBufferTail) return FALSE;
 200
 201     /* Remove the value from the queue */
 202     Bda->KeybdBufferHead += sizeof(WORD);
 203
 204     /* Check if we are at, or have passed, the end of the buffer */
 205     if (Bda->KeybdBufferHead >= Bda->KeybdBufferEnd)
 206     {
 207         /* Return it to the beginning */
 208         Bda->KeybdBufferHead = Bda->KeybdBufferStart;
 209     }
 210
 211     /* Return success */
 212     return TRUE;
 213 }
 214
 215 static VOID BiosReadWindow(LPWORD Buffer, SMALL_RECT Rectangle, BYTE Page)
 216 {
 217     INT i, j;
 218     INT Counter = 0;
 219     WORD Character;
 220     DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Page * Bda->VideoPageSize);
 221
 222     for (i = Rectangle.Top; i <= Rectangle.Bottom; i++)
 223     {
 224         for (j = Rectangle.Left; j <= Rectangle.Right; j++)
 225         {
 226             /* Read from video memory */
 227             VgaReadMemory(VideoAddress + (i * Bda->ScreenColumns + j) * sizeof(WORD),
 228                           (LPVOID)&Character,
 229                           sizeof(WORD));
 230
 231             /* Write the data to the buffer in row order */
 232             Buffer[Counter++] = Character;
 233         }
 234     }
 235 }
 236
 237 static VOID BiosWriteWindow(LPWORD Buffer, SMALL_RECT Rectangle, BYTE Page)
 238 {
 239     INT i, j;
 240     INT Counter = 0;
 241     WORD Character;
 242     DWORD VideoAddress = TO_LINEAR(TEXT_VIDEO_SEG, Page * Bda->VideoPageSize);
 243
 244     for (i = Rectangle.Top; i <= Rectangle.Bottom; i++)
 245     {
 246         for (j = Rectangle.Left; j <= Rectangle.Right; j++)
 247         {
 248             Character = Buffer[Counter++];
 249
 250             /* Read from video memory */
 251             VgaWriteMemory(VideoAddress + (i * Bda->ScreenColumns + j) * sizeof(WORD),
 252                            (LPVOID)&Character,
 253                            sizeof(WORD));
 254         }
 255     }
 256 }
 257
 258 /* PUBLIC FUNCTIONS ***********************************************************/
 259
 260 BYTE BiosGetVideoMode(VOID)
 261 {
 262     return Bda->VideoMode;
 263 }
 264
 265 BOOLEAN BiosSetVideoMode(BYTE ModeNumber)
 266 {
 267     INT i;
 268     COORD Resolution;
 269     LPBYTE Values = VideoModes[ModeNumber];
 270
 271     if (Values == NULL) return FALSE;
 272
 273     /* Write the misc register */
 274     VgaWritePort(VGA_MISC_WRITE, *(Values++));
 275
 276     /* Write the sequencer registers */
 277     for (i = 0; i < VGA_SEQ_MAX_REG; i++)
 278     {
 279         VgaWritePort(VGA_SEQ_INDEX, i);
 280         VgaWritePort(VGA_SEQ_DATA, *(Values++));
 281     }
 282
 283     /* Write the GC registers */
 284     for (i = 0; i < VGA_GC_MAX_REG; i++)
 285     {
 286         VgaWritePort(VGA_GC_INDEX, i);
 287         VgaWritePort(VGA_GC_DATA, *(Values++));
 288     }
 289
 290     /* Write the CRTC registers */
 291     for (i = 0; i < VGA_CRTC_MAX_REG; i++)
 292     {
 293         VgaWritePort(VGA_CRTC_INDEX, i);
 294         VgaWritePort(VGA_CRTC_DATA, *(Values++));
 295     }
 296
 297     /* Write the AC registers */
 298     for (i = 0; i < VGA_AC_MAX_REG; i++)
 299     {
 300         VgaWritePort(VGA_AC_INDEX, i);
 301         VgaWritePort(VGA_AC_WRITE, *(Values++));
 302     }
 303
 304     /* Update the values in the BDA */
 305     Bda->VideoMode = ModeNumber;
 306     Bda->VideoPage = 0;
 307     Bda->VideoPageSize   = BIOS_PAGE_SIZE;
 308     Bda->VideoPageOffset = 0;
 309     Bda->CharacterHeight = 16;
 310
 311     Resolution = VgaGetDisplayResolution();
 312     Bda->ScreenColumns = Resolution.X;
 313     Bda->ScreenRows = Resolution.Y - 1;
 314
 315     return TRUE;
 316 }
 317
 318 BOOLEAN BiosSetVideoPage(BYTE PageNumber)
 319 {
 320     if (PageNumber >= BIOS_MAX_PAGES) return FALSE;
 321
 322     /* Set the values in the BDA */
 323     Bda->VideoPage = PageNumber;
 324     Bda->VideoPageSize = BIOS_PAGE_SIZE;
 325     Bda->VideoPageOffset = PageNumber * BIOS_PAGE_SIZE;
 326
 327     /* Set the start address in the CRTC */
 328     VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_LOW_REG);
 329     VgaWritePort(VGA_CRTC_DATA , LOBYTE(Bda->VideoPageOffset));
 330     VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_HIGH_REG);
 331     VgaWritePort(VGA_CRTC_DATA , HIBYTE(Bda->VideoPageOffset));
 332
 333     return TRUE;
 334 }
 335
 336 BOOLEAN BiosInitialize(VOID)
 337 {
 338     INT i;
 339     WORD Offset = 0;
 340     LPWORD IntVecTable = (LPWORD)((ULONG_PTR)BaseAddress);
 341     LPBYTE BiosCode = (LPBYTE)((ULONG_PTR)BaseAddress + TO_LINEAR(BIOS_SEGMENT, 0));
 342
 343     /* Initialize the BDA */
 344     Bda = (PBIOS_DATA_AREA)((ULONG_PTR)BaseAddress + TO_LINEAR(BDA_SEGMENT, 0));
 345     Bda->EquipmentList = BIOS_EQUIPMENT_LIST;
 346     Bda->KeybdBufferStart = FIELD_OFFSET(BIOS_DATA_AREA, KeybdBuffer);
 347     Bda->KeybdBufferEnd = Bda->KeybdBufferStart + BIOS_KBD_BUFFER_SIZE * sizeof(WORD);
 348
 349     /* Generate ISR stubs and fill the IVT */
 350     for (i = 0; i < 256; i++)
 351     {
 352         IntVecTable[i * 2] = Offset;
 353         IntVecTable[i * 2 + 1] = BIOS_SEGMENT;
 354
 355         BiosCode[Offset++] = 0xFA; // cli
 356
 357         BiosCode[Offset++] = 0x6A; // push i
 358         BiosCode[Offset++] = (BYTE)i;
 359
 360         BiosCode[Offset++] = LOBYTE(EMULATOR_BOP); // BOP sequence
 361         BiosCode[Offset++] = HIBYTE(EMULATOR_BOP);
 362         BiosCode[Offset++] = LOBYTE(EMULATOR_INT_BOP);
 363         BiosCode[Offset++] = HIBYTE(EMULATOR_INT_BOP);
 364
 365         BiosCode[Offset++] = 0x83; // add sp, 2
 366         BiosCode[Offset++] = 0xC4;
 367         BiosCode[Offset++] = 0x02;
 368
 369         BiosCode[Offset++] = 0xCF; // iret
 370     }
 371
 372     /* Get the input handle to the real console, and check for success */
 373     BiosConsoleInput = CreateFileW(L"CONIN$",
 374                                    GENERIC_READ | GENERIC_WRITE,
 375                                    FILE_SHARE_READ | FILE_SHARE_WRITE,
 376                                    NULL,
 377                                    OPEN_EXISTING,
 378                                    0,
 379                                    NULL);
 380     if (BiosConsoleInput == INVALID_HANDLE_VALUE)
 381     {
 382         return FALSE;
 383     }
 384
 385     /* Get the output handle to the real console, and check for success */
 386     BiosConsoleOutput = CreateFileW(L"CONOUT$",
 387                                     GENERIC_READ | GENERIC_WRITE,
 388                                     FILE_SHARE_READ | FILE_SHARE_WRITE,
 389                                     NULL,
 390                                     OPEN_EXISTING,
 391                                     0,
 392                                     NULL);
 393     if (BiosConsoleOutput == INVALID_HANDLE_VALUE)
 394     {
 395         CloseHandle(BiosConsoleInput);
 396         return FALSE;
 397     }
 398
 399     /* Save the console screen buffer information */
 400     if (!GetConsoleScreenBufferInfo(BiosConsoleOutput, &BiosSavedBufferInfo))
 401     {
 402         CloseHandle(BiosConsoleOutput);
 403         CloseHandle(BiosConsoleInput);
 404         return FALSE;
 405     }
 406
 407     /* Store the cursor position */
 408     Bda->CursorPosition[0] = MAKEWORD(BiosSavedBufferInfo.dwCursorPosition.X,
 409                                       BiosSavedBufferInfo.dwCursorPosition.Y);
 410
 411     VgaInitialize(BiosConsoleOutput);
 412
 413     /* Set the console input mode */
 414     SetConsoleMode(BiosConsoleInput, ENABLE_MOUSE_INPUT | ENABLE_PROCESSED_INPUT);
 415
 416     /* Initialize the PIC */
 417     PicWriteCommand(PIC_MASTER_CMD, PIC_ICW1 | PIC_ICW1_ICW4);
 418     PicWriteCommand(PIC_SLAVE_CMD , PIC_ICW1 | PIC_ICW1_ICW4);
 419
 420     /* Set the interrupt offsets */
 421     PicWriteData(PIC_MASTER_DATA, BIOS_PIC_MASTER_INT);
 422     PicWriteData(PIC_SLAVE_DATA , BIOS_PIC_SLAVE_INT);
 423
 424     /* Tell the master PIC there is a slave at IRQ 2 */
 425     PicWriteData(PIC_MASTER_DATA, 1 << 2);
 426     PicWriteData(PIC_SLAVE_DATA , 2);
 427
 428     /* Make sure the PIC is in 8086 mode */
 429     PicWriteData(PIC_MASTER_DATA, PIC_ICW4_8086);
 430     PicWriteData(PIC_SLAVE_DATA , PIC_ICW4_8086);
 431
 432     /* Clear the masks for both PICs */
 433     PicWriteData(PIC_MASTER_DATA, 0x00);
 434     PicWriteData(PIC_SLAVE_DATA , 0x00);
 435
 436     PitWriteCommand(0x34);
 437     PitWriteData(0, 0x00);
 438     PitWriteData(0, 0x00);
 439
 440     return TRUE;
 441 }
 442
 443 VOID BiosCleanup(VOID)
 444 {
 445     /* Restore the old screen buffer */
 446     SetConsoleActiveScreenBuffer(BiosConsoleOutput);
 447
 448     /* Restore the screen buffer size */
 449     SetConsoleScreenBufferSize(BiosConsoleOutput, BiosSavedBufferInfo.dwSize);
 450
 451     /* Close the console handles */
 452     if (BiosConsoleOutput != INVALID_HANDLE_VALUE) CloseHandle(BiosConsoleOutput);
 453     if (BiosConsoleInput  != INVALID_HANDLE_VALUE) CloseHandle(BiosConsoleInput);
 454 }
 455
 456 WORD BiosPeekCharacter(VOID)
 457 {
 458     WORD CharacterData;
 459
 460     /* Check if there is a key available */
 461     if (Bda->KeybdBufferHead == Bda->KeybdBufferTail) return 0xFFFF;
 462
 463     /* Get the key from the queue, but don't remove it */
 464     BiosKbdBufferTop(&CharacterData);
 465
 466     return CharacterData;
 467 }
 468
 469 WORD BiosGetCharacter(VOID)
 470 {
 471     WORD CharacterData;
 472     INPUT_RECORD InputRecord;
 473     DWORD Count;
 474
 475     /* Check if there is a key available */
 476     if (Bda->KeybdBufferHead != Bda->KeybdBufferTail)
 477     {
 478         /* Get the key from the queue, and remove it */
 479         BiosKbdBufferTop(&CharacterData);
 480         BiosKbdBufferPop();
 481     }
 482     else
 483     {
 484         while (TRUE)
 485         {
 486             /* Wait for a console event */
 487             WaitForSingleObject(BiosConsoleInput, INFINITE);
 488
 489             /* Read the event, and make sure it's a keypress */
 490             if (!ReadConsoleInput(BiosConsoleInput, &InputRecord, 1, &Count)) continue;
 491             if (InputRecord.EventType != KEY_EVENT) continue;
 492             if (!InputRecord.Event.KeyEvent.bKeyDown) continue;
 493
 494             /* Save the scan code and end the loop */
 495             CharacterData = (InputRecord.Event.KeyEvent.wVirtualScanCode << 8)
 496                             | InputRecord.Event.KeyEvent.uChar.AsciiChar;
 497
 498             break;
 499         }
 500     }
 501
 502     return CharacterData;
 503 }
 504
 505 VOID BiosSetCursorPosition(BYTE Row, BYTE Column, BYTE Page)
 506 {
 507     /* Make sure the selected video page is valid */
 508     if (Page >= BIOS_MAX_PAGES) return;
 509
 510     /* Update the position in the BDA */
 511     Bda->CursorPosition[Page] = (Row << 8) | Column;
 512
 513     /* Check if this is the current video page */
 514     if (Page == Bda->VideoPage)
 515     {
 516         WORD Offset = Row * Bda->ScreenColumns + Column;
 517
 518         /* Modify the CRTC registers */
 519         VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_LOW_REG);
 520         VgaWritePort(VGA_CRTC_DATA , LOBYTE(Offset));
 521         VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_LOC_HIGH_REG);
 522         VgaWritePort(VGA_CRTC_DATA , HIBYTE(Offset));
 523     }
 524 }
 525
 526 BOOLEAN BiosScrollWindow(INT Direction,
 527                          DWORD Amount,
 528                          SMALL_RECT Rectangle,
 529                          BYTE Page,
 530                          BYTE FillAttribute)
 531 {
 532     DWORD i;
 533     LPWORD WindowData;
 534     DWORD WindowSize = (Rectangle.Bottom - Rectangle.Top + 1)
 535                        * (Rectangle.Right - Rectangle.Left + 1);
 536
 537     /* Allocate a buffer for the window */
 538     WindowData = (LPWORD)HeapAlloc(GetProcessHeap(),
 539                                    HEAP_ZERO_MEMORY,
 540                                    WindowSize * sizeof(WORD));
 541     if (WindowData == NULL) return FALSE;
 542
 543     /* Read the window data */
 544     BiosReadWindow(WindowData, Rectangle, Page);
 545
 546     if (Amount == 0)
 547     {
 548         /* Fill the window */
 549         for (i = 0; i < WindowSize; i++)
 550         {
 551             WindowData[i] = ' ' | (FillAttribute << 8);
 552         }
 553
 554         goto Done;
 555     }
 556
 557     // TODO: Scroll the window!
 558
 559 Done:
 560     /* Write back the window data */
 561     BiosWriteWindow(WindowData, Rectangle, Page);
 562
 563     /* Free the window buffer */
 564     HeapFree(GetProcessHeap(), 0, WindowData);
 565
 566     return TRUE;
 567 }
 568
 569 VOID BiosPrintCharacter(CHAR Character, BYTE Attribute, BYTE Page)
 570 {
 571     WORD CharData = (Attribute << 8) | Character;
 572     BYTE Row, Column;
 573
 574     /* Make sure the page exists */
 575     if (Page >= BIOS_MAX_PAGES) return;
 576
 577     /* Get the cursor location */
 578     Row = HIBYTE(Bda->CursorPosition[Page]);
 579     Column = LOBYTE(Bda->CursorPosition[Page]);
 580
 581     /* Write the character */
 582     VgaWriteMemory(TO_LINEAR(TEXT_VIDEO_SEG,
 583                    (Row * Bda->ScreenColumns + Column) * sizeof(WORD)),
 584                    (LPVOID)&CharData,
 585                    sizeof(WORD));
 586
 587     /* Advance the cursor */
 588     Column++;
 589
 590     /* Check if it passed the end of the row */
 591     if (Column == Bda->ScreenColumns)
 592     {
 593         /* Return to the first column */
 594         Column = 0;
 595
 596         if (Row == Bda->ScreenRows)
 597         {
 598             /* The screen must be scrolled */
 599             SMALL_RECT Rectangle = { 0, 0, Bda->ScreenColumns - 1, Bda->ScreenRows };
 600
 601             BiosScrollWindow(SCROLL_DIRECTION_UP,
 602                              1,
 603                              Rectangle,
 604                              Page,
 605                              DEFAULT_ATTRIBUTE);
 606         }
 607         else Row++;
 608     }
 609
 610     /* Set the cursor position */
 611     BiosSetCursorPosition(Row, Column, Page);
 612 }
 613
 614 VOID BiosVideoService(LPWORD Stack)
 615 {
 616     DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
 617     DWORD Ecx = EmulatorGetRegister(EMULATOR_REG_CX);
 618     DWORD Edx = EmulatorGetRegister(EMULATOR_REG_DX);
 619     DWORD Ebx = EmulatorGetRegister(EMULATOR_REG_BX);
 620
 621     switch (HIBYTE(Eax))
 622     {
 623         /* Set Video Mode */
 624         case 0x00:
 625         {
 626             BiosSetVideoMode(LOBYTE(Eax));
 627             break;
 628         }
 629
 630         /* Set Text-Mode Cursor Shape */
 631         case 0x01:
 632         {
 633             /* Update the BDA */
 634             Bda->CursorStartLine = HIBYTE(Ecx);
 635             Bda->CursorEndLine = LOBYTE(Ecx);
 636
 637             /* Modify the CRTC registers */
 638             VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_START_REG);
 639             VgaWritePort(VGA_CRTC_DATA , Bda->CursorStartLine);
 640             VgaWritePort(VGA_CRTC_INDEX, VGA_CRTC_CURSOR_END_REG);
 641             VgaWritePort(VGA_CRTC_DATA , Bda->CursorEndLine);
 642
 643             break;
 644         }
 645
 646         /* Set Cursor Position */
 647         case 0x02:
 648         {
 649             BiosSetCursorPosition(HIBYTE(Edx), LOBYTE(Edx), HIBYTE(Ebx));
 650             break;
 651         }
 652
 653         /* Get Cursor Position */
 654         case 0x03:
 655         {
 656             /* Make sure the selected video page exists */
 657             if (HIBYTE(Ebx) >= BIOS_MAX_PAGES) break;
 658
 659             /* Return the result */
 660             EmulatorSetRegister(EMULATOR_REG_AX, 0);
 661             EmulatorSetRegister(EMULATOR_REG_CX,
 662                                 (Bda->CursorStartLine << 8) | Bda->CursorEndLine);
 663             EmulatorSetRegister(EMULATOR_REG_DX, Bda->CursorPosition[HIBYTE(Ebx)]);
 664
 665             break;
 666         }
 667
 668         /* Select Active Display Page */
 669         case 0x05:
 670         {
 671             /* Check if the page exists */
 672             if (LOBYTE(Eax) >= BIOS_MAX_PAGES) break;
 673
 674             /* Check if this is the same page */
 675             if (LOBYTE(Eax) == Bda->VideoPage) break;
 676
 677             /* Change the video page */
 678             BiosSetVideoPage(LOBYTE(Eax));
 679
 680             break;
 681         }
 682
 683         /* Scroll Window Up/Down */
 684         case 0x06:
 685         case 0x07:
 686         {
 687             SMALL_RECT Rectangle =
 688             {
 689                 LOBYTE(Ecx),
 690                 HIBYTE(Ecx),
 691                 LOBYTE(Edx),
 692                 HIBYTE(Edx)
 693             };
 694
 695             /* Call the internal function */
 696             BiosScrollWindow((HIBYTE(Eax)== 0x06)
 697                              ? SCROLL_DIRECTION_UP : SCROLL_DIRECTION_DOWN,
 698                              LOBYTE(Eax),
 699                              Rectangle,
 700                              Bda->VideoPage,
 701                              HIBYTE(Ebx));
 702
 703             break;
 704         }
 705
 706         /* Read/Write Character From Cursor Position */
 707         case 0x08:
 708         case 0x09:
 709         case 0x0A:
 710         {
 711             WORD CharacterData = MAKEWORD(LOBYTE(Eax), LOBYTE(Ebx));
 712             BYTE Page = HIBYTE(Ebx);
 713             DWORD Offset;
 714
 715             /* Check if the page exists */
 716             if (Page >= BIOS_MAX_PAGES) break;
 717
 718             /* Find the offset of the character */
 719             Offset = Page * Bda->VideoPageSize
 720                      + (HIBYTE(Bda->CursorPosition[Page]) * Bda->ScreenColumns
 721                      + LOBYTE(Bda->CursorPosition[Page])) * 2;
 722
 723             if (HIBYTE(Eax) == 0x08)
 724             {
 725                 /* Read from the video memory */
 726                 VgaReadMemory(TO_LINEAR(TEXT_VIDEO_SEG, Offset),
 727                               (LPVOID)&CharacterData,
 728                               sizeof(WORD));
 729
 730                 /* Return the character in AX */
 731                 EmulatorSetRegister(EMULATOR_REG_AX, CharacterData);
 732             }
 733             else
 734             {
 735                 /* Write to video memory */
 736                 VgaWriteMemory(TO_LINEAR(TEXT_VIDEO_SEG, Offset),
 737                                (LPVOID)&CharacterData,
 738                                (HIBYTE(Ebx) == 0x09) ? sizeof(WORD) : sizeof(BYTE));
 739             }
 740
 741             break;
 742         }
 743
 744         /* Teletype Output */
 745         case 0x0E:
 746         {
 747             BiosPrintCharacter(LOBYTE(Eax), LOBYTE(Ebx), HIBYTE(Ebx));
 748             break;
 749         }
 750
 751         /* Get Current Video Mode */
 752         case 0x0F:
 753         {
 754             EmulatorSetRegister(EMULATOR_REG_AX,
 755                                 MAKEWORD(Bda->VideoMode, Bda->ScreenColumns));
 756             EmulatorSetRegister(EMULATOR_REG_BX,
 757                                 MAKEWORD(LOBYTE(Ebx), Bda->VideoPage));
 758
 759             break;
 760         }
 761
 762         /* Scroll Window */
 763         case 0x12:
 764         {
 765             SMALL_RECT Rectangle =
 766             {
 767                 LOBYTE(Ecx),
 768                 HIBYTE(Ecx),
 769                 LOBYTE(Edx),
 770                 HIBYTE(Edx)
 771             };
 772
 773             /* Call the internal function */
 774             BiosScrollWindow(LOBYTE(Ebx),
 775                              LOBYTE(Eax),
 776                              Rectangle,
 777                              Bda->VideoPage,
 778                              DEFAULT_ATTRIBUTE);
 779
 780             break;
 781         }
 782
 783         default:
 784         {
 785             DPRINT1("BIOS Function INT 10h, AH = 0x%02X NOT IMPLEMENTED\n",
 786                     HIBYTE(Eax));
 787         }
 788     }
 789 }
 790
 791 VOID BiosKeyboardService(LPWORD Stack)
 792 {
 793     DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
 794
 795     switch (HIBYTE(Eax))
 796     {
 797         case 0x00:
 798         {
 799             /* Read the character (and wait if necessary) */
 800             EmulatorSetRegister(EMULATOR_REG_AX, BiosGetCharacter());
 801
 802             break;
 803         }
 804
 805         case 0x01:
 806         {
 807             WORD Data = BiosPeekCharacter();
 808
 809             if (Data != 0xFFFF)
 810             {
 811                 /* There is a character, clear ZF and return it */
 812                 EmulatorSetRegister(EMULATOR_REG_AX, Data);
 813                 Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_ZF;
 814             }
 815             else
 816             {
 817                 /* No character, set ZF */
 818                 Stack[STACK_FLAGS] |= EMULATOR_FLAG_ZF;
 819             }
 820
 821             break;
 822         }
 823
 824         default:
 825         {
 826             DPRINT1("BIOS Function INT 16h, AH = 0x%02X NOT IMPLEMENTED\n",
 827                     HIBYTE(Eax));
 828         }
 829     }
 830 }
 831
 832 VOID BiosTimeService(LPWORD Stack)
 833 {
 834     DWORD Eax = EmulatorGetRegister(EMULATOR_REG_AX);
 835     DWORD Ecx = EmulatorGetRegister(EMULATOR_REG_CX);
 836     DWORD Edx = EmulatorGetRegister(EMULATOR_REG_DX);
 837
 838     switch (HIBYTE(Eax))
 839     {
 840         case 0x00:
 841         {
 842             /* Set AL to 1 if midnight had passed, 0 otherwise */
 843             Eax &= 0xFFFFFF00;
 844             if (Bda->MidnightPassed) Eax |= 1;
 845
 846             /* Return the tick count in CX:DX */
 847             EmulatorSetRegister(EMULATOR_REG_AX, Eax);
 848             EmulatorSetRegister(EMULATOR_REG_CX, HIWORD(Bda->TickCounter));
 849             EmulatorSetRegister(EMULATOR_REG_DX, LOWORD(Bda->TickCounter));
 850
 851             /* Reset the midnight flag */
 852             Bda->MidnightPassed = FALSE;
 853
 854             break;
 855         }
 856
 857         case 0x01:
 858         {
 859             /* Set the tick count to CX:DX */
 860             Bda->TickCounter = MAKELONG(LOWORD(Edx), LOWORD(Ecx));
 861
 862             /* Reset the midnight flag */
 863             Bda->MidnightPassed = FALSE;
 864
 865             break;
 866         }
 867
 868         default:
 869         {
 870             DPRINT1("BIOS Function INT 1Ah, AH = 0x%02X NOT IMPLEMENTED\n",
 871                     HIBYTE(Eax));
 872         }
 873     }
 874 }
 875
 876 VOID BiosSystemTimerInterrupt(LPWORD Stack)
 877 {
 878     /* Increase the system tick count */
 879     Bda->TickCounter++;
 880 }
 881
 882 VOID BiosEquipmentService(LPWORD Stack)
 883 {
 884     /* Return the equipment list */
 885     EmulatorSetRegister(EMULATOR_REG_AX, Bda->EquipmentList);
 886 }
 887
 888 VOID BiosHandleIrq(BYTE IrqNumber, LPWORD Stack)
 889 {
 890     switch (IrqNumber)
 891     {
 892         /* PIT IRQ */
 893         case 0:
 894         {
 895             /* Perform the system timer interrupt */
 896             EmulatorInterrupt(BIOS_SYS_TIMER_INTERRUPT);
 897
 898             break;
 899         }
 900
 901         /* Keyboard IRQ */
 902         case 1:
 903         {
 904             BYTE ScanCode, VirtualKey;
 905             WORD Character;
 906
 907             /* Check if there is a scancode available */
 908             if (!(KeyboardReadStatus() & 1)) break;
 909
 910             /* Get the scan code and virtual key code */
 911             ScanCode = KeyboardReadData();
 912             VirtualKey = MapVirtualKey(ScanCode & 0x7F, MAPVK_VSC_TO_VK);
 913
 914             /* Check if this is a key press or release */
 915             if (!(ScanCode & (1 << 7)))
 916             {
 917                 /* Key press */
 918                 if (VirtualKey == VK_NUMLOCK
 919                     || VirtualKey == VK_CAPITAL
 920                     || VirtualKey == VK_SCROLL)
 921                 {
 922                     /* For toggle keys, toggle the lowest bit in the keyboard map */
 923                     BiosKeyboardMap[VirtualKey] ^= ~(1 << 0);
 924                 }
 925
 926                 /* Set the highest bit */
 927                 BiosKeyboardMap[VirtualKey] |= (1 << 7);
 928
 929                 /* Find out which character this is */
 930                 if (ToAscii(VirtualKey, ScanCode, BiosKeyboardMap, &Character, 0) > 0)
 931                 {
 932                     /* Push it onto the BIOS keyboard queue */
 933                     BiosKbdBufferPush((ScanCode << 8) | (Character & 0xFF));
 934                 }
 935             }
 936             else
 937             {
 938                 /* Key release, unset the highest bit */
 939                 BiosKeyboardMap[VirtualKey] &= ~(1 << 7);
 940             }
 941
 942             break;
 943         }
 944     }
 945
 946     /* Send End-of-Interrupt to the PIC */
 947     if (IrqNumber > 8) PicWriteCommand(PIC_SLAVE_CMD, PIC_OCW2_EOI);
 948     PicWriteCommand(PIC_MASTER_CMD, PIC_OCW2_EOI);
 949 }
 950
 951 /* EOF */