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