subsystems/ntvdm/bios/bios32/bios32.c

   1 /*
   2  * COPYRIGHT:       GPL - See COPYING in the top level directory
   3  * PROJECT:         ReactOS Virtual DOS Machine
   4  * FILE:            bios32.c
   5  * PURPOSE:         VDM 32-bit BIOS
   6  * PROGRAMMERS:     Aleksandar Andrejevic <theflash AT sdf DOT lonestar DOT org>
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #define NDEBUG
  12
  13 /* For BIOS Version number */
  14 #include <reactos/buildno.h>
  15
  16 #include "emulator.h"
  17 #include "cpu/cpu.h" // for EMULATOR_FLAG_CF
  18 #include "cpu/bop.h"
  19 #include "int32.h"
  20
  21 #include "../bios.h"
  22 #include "../rom.h"
  23 #include "bios32.h"
  24 #include "bios32p.h"
  25 #include "kbdbios32.h"
  26 #include "vidbios32.h"
  27 #include "moubios32.h"
  28
  29 #include "io.h"
  30 #include "hardware/cmos.h"
  31 #include "hardware/pic.h"
  32 #include "hardware/timer.h"
  33
  34 /* PRIVATE VARIABLES **********************************************************/
  35
  36 CALLBACK16 BiosContext;
  37
  38 /*
  39
  40 Bochs BIOS, see rombios.h
  41 =========================
  42
  43 // model byte 0xFC = AT
  44 #define SYS_MODEL_ID     0xFC
  45 #define SYS_SUBMODEL_ID  0x00
  46 #define BIOS_REVISION    1
  47 #define BIOS_CONFIG_TABLE 0xe6f5
  48
  49 #ifndef BIOS_BUILD_DATE
  50 #  define BIOS_BUILD_DATE "06/23/99"
  51 #endif
  52
  53 // 1K of base memory used for Extended Bios Data Area (EBDA)
  54 // EBDA is used for PS/2 mouse support, and IDE BIOS, etc.
  55 #define EBDA_SEG           0x9FC0
  56 #define EBDA_SIZE          1              // In KiB
  57 #define BASE_MEM_IN_K   (640 - EBDA_SIZE)
  58
  59
  60 See rombios.c
  61 =============
  62
  63 ROM BIOS compatibility entry points:
  64 ===================================
  65 $e05b ; POST Entry Point
  66 $e2c3 ; NMI Handler Entry Point
  67 $e3fe ; INT 13h Fixed Disk Services Entry Point
  68 $e401 ; Fixed Disk Parameter Table
  69 $e6f2 ; INT 19h Boot Load Service Entry Point
  70 $e6f5 ; Configuration Data Table
  71 $e729 ; Baud Rate Generator Table
  72 $e739 ; INT 14h Serial Communications Service Entry Point
  73 $e82e ; INT 16h Keyboard Service Entry Point
  74 $e987 ; INT 09h Keyboard Service Entry Point
  75 $ec59 ; INT 13h Diskette Service Entry Point
  76 $ef57 ; INT 0Eh Diskette Hardware ISR Entry Point
  77 $efc7 ; Diskette Controller Parameter Table
  78 $efd2 ; INT 17h Printer Service Entry Point
  79 $f045 ; INT 10 Functions 0-Fh Entry Point
  80 $f065 ; INT 10h Video Support Service Entry Point
  81 $f0a4 ; MDA/CGA Video Parameter Table (INT 1Dh)
  82 $f841 ; INT 12h Memory Size Service Entry Point
  83 $f84d ; INT 11h Equipment List Service Entry Point
  84 $f859 ; INT 15h System Services Entry Point
  85 $fa6e ; Character Font for 320x200 & 640x200 Graphics (lower 128 characters)
  86 $fe6e ; INT 1Ah Time-of-day Service Entry Point
  87 $fea5 ; INT 08h System Timer ISR Entry Point
  88 $fef3 ; Initial Interrupt Vector Offsets Loaded by POST
  89 $ff53 ; IRET Instruction for Dummy Interrupt Handler
  90 $ff54 ; INT 05h Print Screen Service Entry Point
  91 $fff0 ; Power-up Entry Point
  92 $fff5 ; ASCII Date ROM was built - 8 characters in MM/DD/YY
  93 $fffe ; System Model ID
  94
  95 */
  96
  97 /*
  98  * See Ralf Brown: http://www.ctyme.com/intr/rb-1594.htm#Table515
  99  * for more information.
 100  */
 101 #define BIOS_MODEL      0xFC // PC-AT
 102 #define BIOS_SUBMODEL   0x01 // AT models 319,339 8 MHz, Enh Keyb, 3.5"
 103 #define BIOS_REVISION   0x00
 104 // FIXME: Find a nice PS/2 486 + 487 BIOS combination!
 105
 106 /*
 107  * WARNING! For compatibility purposes the string "IBM" should be at F000:E00E .
 108  * Some programs alternatively look at "COPR. IBM" that is at F000:E008 .
 109  */
 110 static const CHAR BiosCopyright[] = "0000000 NTVDM IBM Compatible 486 32-bit BIOS Copyright (C) ReactOS Team 1996-2014";
 111 static const CHAR BiosVersion[]   = "ReactOS NTVDM 32-bit BIOS "KERNEL_VERSION_STR" (Build "KERNEL_VERSION_BUILD_STR")";
 112 static const CHAR BiosDate[]      = "06/17/13";
 113
 114 C_ASSERT(sizeof(BiosCopyright)-1 <= 0x5B); // Ensures that we won't overflow on the POST Code starting at F000:E05B
 115 C_ASSERT(sizeof(BiosDate)-1      == 0x08);
 116
 117 /* 16-bit bootstrap code at F000:FFF0 */
 118 static BYTE Bootstrap[] =
 119 {
 120     0xEA,                   // jmp far ptr
 121     0x5B, 0xE0, 0x00, 0xF0, // F000:E05B
 122 };
 123
 124 /*
 125  * Normally at F000:E05B there is the POST that finally calls the bootstrap
 126  * interrupt. It should also check the value of Bda->SoftReset. Since we do
 127  * all the POST in 32 bit from the start, we just place there the bootstrap
 128  * interrupt call.
 129  */
 130 static BYTE PostCode[] =
 131 {
 132     LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_RESET,  // Call BIOS POST
 133     0xCD, 0x19,                                             // INT 0x19, the bootstrap loader interrupt
 134 //  LOBYTE(EMULATOR_BOP), HIBYTE(EMULATOR_BOP), BOP_UNSIMULATE
 135 };
 136
 137
 138 /* PRIVATE FUNCTIONS **********************************************************/
 139
 140 static VOID WINAPI BiosException(LPWORD Stack)
 141 {
 142     /* Get the exception number and call the emulator API */
 143     BYTE ExceptionNumber = LOBYTE(Stack[STACK_INT_NUM]);
 144     EmulatorException(ExceptionNumber, Stack);
 145 }
 146
 147 static VOID WINAPI BiosMiscService(LPWORD Stack)
 148 {
 149     switch (getAH())
 150     {
 151         /* Keyboard intercept */
 152         case 0x4F:
 153         {
 154             /* CF should be set but let's just set it again just in case */
 155             /* Do not modify AL (the hardware scan code), but set CF to continue processing */
 156             // setCF(1);
 157             Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
 158             break;
 159         }
 160
 161         /* Wait */
 162         case 0x86:
 163         {
 164             /*
 165              * Interval in microseconds in CX:DX
 166              * See Ralf Brown: http://www.ctyme.com/intr/rb-1525.htm
 167              * for more information.
 168              */
 169             Sleep(MAKELONG(getDX(), getCX()));
 170
 171             /* Clear CF */
 172             Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
 173
 174             break;
 175         }
 176
 177         /* Copy Extended Memory */
 178         case 0x87:
 179         {
 180             DWORD Count = (DWORD)getCX() * 2;
 181             PFAST486_GDT_ENTRY Gdt = (PFAST486_GDT_ENTRY)SEG_OFF_TO_PTR(getES(), getSI());
 182             DWORD SourceBase = Gdt[2].Base + (Gdt[2].BaseMid << 16) + (Gdt[2].BaseHigh << 24);
 183             DWORD SourceLimit = Gdt[2].Limit + (Gdt[2].LimitHigh << 16);
 184             DWORD DestBase = Gdt[3].Base + (Gdt[3].BaseMid << 16) + (Gdt[3].BaseHigh << 24);
 185             DWORD DestLimit = Gdt[3].Limit + (Gdt[3].LimitHigh << 16);
 186
 187             /* Check for flags */
 188             if (Gdt[2].Granularity) SourceLimit = (SourceLimit << 12) | 0xFFF;
 189             if (Gdt[3].Granularity) DestLimit = (DestLimit << 12) | 0xFFF;
 190
 191             if ((Count > SourceLimit) || (Count > DestLimit))
 192             {
 193                 setAX(0x80);
 194                 Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
 195
 196                 break;
 197             }
 198
 199             /* Copy */
 200             RtlMoveMemory((PVOID)((ULONG_PTR)BaseAddress + DestBase),
 201                           (PVOID)((ULONG_PTR)BaseAddress + SourceBase),
 202                           Count);
 203
 204             setAX(ERROR_SUCCESS);
 205             Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
 206             break;
 207         }
 208
 209         /* Get Extended Memory Size */
 210         case 0x88:
 211         {
 212             UCHAR Low, High;
 213
 214             /*
 215              * Return the (usable) extended memory (after 1 MB)
 216              * size in kB from CMOS.
 217              */
 218             IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_ACTUAL_EXT_MEMORY_LOW);
 219             Low  = IOReadB(CMOS_DATA_PORT);
 220             IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_ACTUAL_EXT_MEMORY_HIGH);
 221             High = IOReadB(CMOS_DATA_PORT);
 222             setAX(MAKEWORD(Low, High));
 223
 224             /* Clear CF */
 225             Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
 226
 227             break;
 228         }
 229
 230         /* Get Configuration */
 231         case 0xC0:
 232         {
 233             /* Return the BIOS ROM Configuration Table address in ES:BX */
 234             // The BCT is found at F000:E6F5 for 100% compatible BIOSes.
 235             setES(BIOS_SEGMENT);
 236             setBX(0xE6F5);
 237
 238             /* Call successful; clear CF */
 239             setAH(0x00);
 240             Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
 241
 242             break;
 243         }
 244
 245         /* Return Extended-Bios Data-Area Segment Address (PS) */
 246         case 0xC1:
 247         {
 248             // Stack[STACK_FLAGS] &= ~EMULATOR_FLAG_CF;
 249             // setES(???);
 250
 251             /* We do not support EBDA yet */
 252             Stack[STACK_FLAGS] |= EMULATOR_FLAG_CF;
 253
 254             break;
 255         }
 256
 257         /* Pointing Device BIOS Interface (PS) */
 258         case 0xC2:
 259         {
 260             DPRINT1("INT 15h, AH = C2h must be implemented in order to support vendor mouse drivers\n");
 261             break;
 262         }
 263
 264         default:
 265         {
 266             DPRINT1("BIOS Function INT 15h, AH = 0x%02X NOT IMPLEMENTED\n",
 267                     getAH());
 268         }
 269     }
 270 }
 271
 272 static VOID WINAPI BiosRomBasic(LPWORD Stack)
 273 {
 274     /* ROM Basic is unsupported, display a message to the user */
 275     DisplayMessage(L"NTVDM doesn't support ROM Basic. The VDM is closing.");
 276
 277     /* Stop the VDM */
 278     EmulatorTerminate();
 279     return;
 280 }
 281
 282
 283 VOID DosBootsectorInitialize(VOID);
 284
 285 static VOID WINAPI BiosBootstrapLoader(LPWORD Stack)
 286 {
 287     /*
 288      * In real BIOSes one loads the bootsector read from a diskette
 289      * or from a disk, copy it to 0000:7C00 and then boot it.
 290      * Since we are 32-bit VM and we hardcode our DOS at the moment,
 291      * just call the DOS 32-bit initialization code.
 292      */
 293
 294     DPRINT1("BiosBootstrapLoader -->\n");
 295
 296     /* Load DOS */
 297     DosBootsectorInitialize();
 298
 299     /*
 300      * Position CPU to 0000:7C00 to boot the OS.
 301      *
 302      * Since we are called via the INT32 mechanism, we need to correctly set
 303      * CS:IP, not by changing the current one (otherwise the interrupt could
 304      * not be clean up and return properly), but by changing the CS:IP in the
 305      * stack, so that when the interrupt returns, the modified CS:IP is popped
 306      * off the stack and the CPU is correctly repositioned.
 307      */
 308     Stack[STACK_CS] = 0x0000;
 309     Stack[STACK_IP] = 0x7C00;
 310
 311     DPRINT1("<-- BiosBootstrapLoader\n");
 312 }
 313
 314 static VOID WINAPI BiosTimeService(LPWORD Stack)
 315 {
 316     switch (getAH())
 317     {
 318         case 0x00:
 319         {
 320             /* Set AL to 1 if midnight had passed, 0 otherwise */
 321             setAL(Bda->MidnightPassed ? 0x01 : 0x00);
 322
 323             /* Return the tick count in CX:DX */
 324             setCX(HIWORD(Bda->TickCounter));
 325             setDX(LOWORD(Bda->TickCounter));
 326
 327             /* Reset the midnight flag */
 328             Bda->MidnightPassed = FALSE;
 329
 330             break;
 331         }
 332
 333         case 0x01:
 334         {
 335             /* Set the tick count to CX:DX */
 336             Bda->TickCounter = MAKELONG(getDX(), getCX());
 337
 338             /* Reset the midnight flag */
 339             Bda->MidnightPassed = FALSE;
 340
 341             break;
 342         }
 343
 344         default:
 345         {
 346             DPRINT1("BIOS Function INT 1Ah, AH = 0x%02X NOT IMPLEMENTED\n",
 347                     getAH());
 348         }
 349     }
 350 }
 351
 352 static VOID WINAPI BiosSystemTimerInterrupt(LPWORD Stack)
 353 {
 354     /* Increase the system tick count */
 355     Bda->TickCounter++;
 356 }
 357
 358
 359 // From SeaBIOS
 360 static VOID PicSetIRQMask(USHORT off, USHORT on)
 361 {
 362     UCHAR pic1off = off, pic1on = on, pic2off = off>>8, pic2on = on>>8;
 363     IOWriteB(PIC_MASTER_DATA, (IOReadB(PIC_MASTER_DATA) & ~pic1off) | pic1on);
 364     IOWriteB(PIC_SLAVE_DATA , (IOReadB(PIC_SLAVE_DATA ) & ~pic2off) | pic2on);
 365 }
 366
 367 // From SeaBIOS
 368 VOID EnableHwIRQ(UCHAR hwirq, EMULATOR_INT32_PROC func)
 369 {
 370     UCHAR vector;
 371
 372     PicSetIRQMask(1 << hwirq, 0);
 373     if (hwirq < 8)
 374         vector = BIOS_PIC_MASTER_INT + hwirq;
 375     else
 376         vector = BIOS_PIC_SLAVE_INT  + hwirq - 8;
 377
 378     RegisterBiosInt32(vector, func);
 379 }
 380
 381
 382 VOID PicIRQComplete(LPWORD Stack)
 383 {
 384     /* Get the interrupt number */
 385     BYTE IntNum = LOBYTE(Stack[STACK_INT_NUM]);
 386
 387     /*
 388      * If this was a PIC IRQ, send an End-of-Interrupt to the PIC.
 389      */
 390
 391     if (IntNum >= BIOS_PIC_MASTER_INT && IntNum < BIOS_PIC_MASTER_INT + 8)
 392     {
 393         /* It was an IRQ from the master PIC */
 394         IOWriteB(PIC_MASTER_CMD, PIC_OCW2_EOI);
 395     }
 396     else if (IntNum >= BIOS_PIC_SLAVE_INT && IntNum < BIOS_PIC_SLAVE_INT + 8)
 397     {
 398         /* It was an IRQ from the slave PIC */
 399         IOWriteB(PIC_SLAVE_CMD , PIC_OCW2_EOI);
 400         IOWriteB(PIC_MASTER_CMD, PIC_OCW2_EOI);
 401     }
 402 }
 403
 404 static VOID WINAPI BiosHandleMasterPicIRQ(LPWORD Stack)
 405 {
 406     BYTE IrqNumber;
 407
 408     IOWriteB(PIC_MASTER_CMD, PIC_OCW3_READ_ISR /* == 0x0B */);
 409     IrqNumber = IOReadB(PIC_MASTER_CMD);
 410
 411     DPRINT("Master - IrqNumber = 0x%02X\n", IrqNumber);
 412
 413     PicIRQComplete(Stack);
 414 }
 415
 416 static VOID WINAPI BiosHandleSlavePicIRQ(LPWORD Stack)
 417 {
 418     BYTE IrqNumber;
 419
 420     IOWriteB(PIC_SLAVE_CMD, PIC_OCW3_READ_ISR /* == 0x0B */);
 421     IrqNumber = IOReadB(PIC_SLAVE_CMD);
 422
 423     DPRINT("Slave - IrqNumber = 0x%02X\n", IrqNumber);
 424
 425     PicIRQComplete(Stack);
 426 }
 427
 428 // Timer IRQ 0
 429 static VOID WINAPI BiosTimerIrq(LPWORD Stack)
 430 {
 431     /*
 432      * Perform the system timer interrupt.
 433      *
 434      * Do not call directly BiosSystemTimerInterrupt(Stack);
 435      * because some programs may hook only BIOS_SYS_TIMER_INTERRUPT
 436      * for their purpose...
 437      */
 438     /** EmulatorInterrupt(BIOS_SYS_TIMER_INTERRUPT); **/
 439     Int32Call(&BiosContext, BIOS_SYS_TIMER_INTERRUPT);
 440     PicIRQComplete(Stack);
 441 }
 442
 443
 444 static VOID BiosHwSetup(VOID)
 445 {
 446     /* Initialize the master and the slave PICs (cascade mode) */
 447     IOWriteB(PIC_MASTER_CMD, PIC_ICW1 | PIC_ICW1_ICW4);
 448     IOWriteB(PIC_SLAVE_CMD , PIC_ICW1 | PIC_ICW1_ICW4);
 449
 450     /*
 451      * Set the interrupt vector offsets for each PIC
 452      * (base IRQs: 0x08-0x0F for IRQ 0-7, 0x70-0x77 for IRQ 8-15)
 453      */
 454     IOWriteB(PIC_MASTER_DATA, BIOS_PIC_MASTER_INT);
 455     IOWriteB(PIC_SLAVE_DATA , BIOS_PIC_SLAVE_INT );
 456
 457     /* Tell the master PIC that there is a slave PIC at IRQ 2 */
 458     IOWriteB(PIC_MASTER_DATA, 1 << 2);
 459     /* Tell the slave PIC its cascade identity */
 460     IOWriteB(PIC_SLAVE_DATA , 2);
 461
 462     /* Make sure both PICs are in 8086 mode */
 463     IOWriteB(PIC_MASTER_DATA, PIC_ICW4_8086);
 464     IOWriteB(PIC_SLAVE_DATA , PIC_ICW4_8086);
 465
 466     /* Clear the masks for both PICs */
 467     // IOWriteB(PIC_MASTER_DATA, 0x00);
 468     // IOWriteB(PIC_SLAVE_DATA , 0x00);
 469     /* Disable all IRQs */
 470     IOWriteB(PIC_MASTER_DATA, 0xFF);
 471     IOWriteB(PIC_SLAVE_DATA , 0xFF);
 472
 473
 474     /* Initialize PIT Counter 0 */
 475     IOWriteB(PIT_COMMAND_PORT, 0x34);
 476     IOWriteB(PIT_DATA_PORT(0), 0x00);
 477     IOWriteB(PIT_DATA_PORT(0), 0x00);
 478
 479     /* Initialize PIT Counter 1 */
 480     IOWriteB(PIT_COMMAND_PORT, 0x74);
 481     IOWriteB(PIT_DATA_PORT(1), 0x00);
 482     IOWriteB(PIT_DATA_PORT(1), 0x00);
 483
 484     /* Initialize PIT Counter 2 */
 485     IOWriteB(PIT_COMMAND_PORT, 0xB4);
 486     IOWriteB(PIT_DATA_PORT(2), 0x00);
 487     IOWriteB(PIT_DATA_PORT(2), 0x00);
 488
 489     EnableHwIRQ(0, BiosTimerIrq);
 490 }
 491
 492 static VOID InitializeBiosInt32(VOID)
 493 {
 494     USHORT i;
 495
 496     /* Initialize the callback context */
 497     InitializeContext(&BiosContext, BIOS_SEGMENT, 0x0000);
 498
 499     /* Register the default BIOS 32-bit Interrupts */
 500     for (i = 0x00; i <= 0xFF; i++)
 501     {
 502         RegisterBiosInt32(i, NULL);
 503     }
 504
 505     /* Initialize the exception vector interrupts to a default Exception handler */
 506     for (i = 0; i < 8; i++)
 507         RegisterBiosInt32(i, BiosException);
 508
 509     /* Initialize HW vector interrupts to a default HW handler */
 510     for (i = BIOS_PIC_MASTER_INT; i < BIOS_PIC_MASTER_INT + 8; i++)
 511         RegisterBiosInt32(i, BiosHandleMasterPicIRQ);
 512     for (i = BIOS_PIC_SLAVE_INT ; i < BIOS_PIC_SLAVE_INT  + 8; i++)
 513         RegisterBiosInt32(i, BiosHandleSlavePicIRQ);
 514
 515     /* Initialize software vector handlers */
 516     RegisterBiosInt32(BIOS_EQUIPMENT_INTERRUPT, BiosEquipmentService    );
 517     RegisterBiosInt32(BIOS_MEMORY_SIZE        , BiosGetMemorySize       );
 518     RegisterBiosInt32(BIOS_MISC_INTERRUPT     , BiosMiscService         );
 519     RegisterBiosInt32(BIOS_ROM_BASIC          , BiosRomBasic            );
 520     RegisterBiosInt32(BIOS_BOOTSTRAP_LOADER   , BiosBootstrapLoader     );
 521     RegisterBiosInt32(BIOS_TIME_INTERRUPT     , BiosTimeService         );
 522     RegisterBiosInt32(BIOS_SYS_TIMER_INTERRUPT, BiosSystemTimerInterrupt);
 523
 524     /* Some interrupts are in fact addresses to tables */
 525     ((PULONG)BaseAddress)[0x1E] = (ULONG)NULL;
 526     ((PULONG)BaseAddress)[0x41] = (ULONG)NULL;
 527     ((PULONG)BaseAddress)[0x46] = (ULONG)NULL;
 528     ((PULONG)BaseAddress)[0x48] = (ULONG)NULL;
 529     ((PULONG)BaseAddress)[0x49] = (ULONG)NULL;
 530 }
 531
 532 static VOID InitializeBiosData(VOID)
 533 {
 534     UCHAR Low, High;
 535
 536     /* Initialize the BDA contents */
 537     RtlZeroMemory(Bda, sizeof(*Bda));
 538     Bda->EquipmentList = BIOS_EQUIPMENT_LIST;
 539
 540     /*
 541      * Retrieve the conventional memory size
 542      * in kB from CMOS, typically 640 kB.
 543      */
 544     IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_BASE_MEMORY_LOW);
 545     Low  = IOReadB(CMOS_DATA_PORT);
 546     IOWriteB(CMOS_ADDRESS_PORT, CMOS_REG_BASE_MEMORY_HIGH);
 547     High = IOReadB(CMOS_DATA_PORT);
 548     Bda->MemorySize = MAKEWORD(Low, High);
 549 }
 550
 551 static VOID InitializeBiosInfo(VOID)
 552 {
 553     RtlZeroMemory(Bct, sizeof(*Bct));
 554
 555     Bct->Length     = sizeof(*Bct);
 556     Bct->Model      = BIOS_MODEL;
 557     Bct->SubModel   = BIOS_SUBMODEL;
 558     Bct->Revision   = BIOS_REVISION;
 559     Bct->Feature[0] = 0x70; // At the moment we don't support "wait for external event (INT 15/AH=41h)", we also don't have any "extended BIOS area allocated (usually at top of RAM)"; see http://www.ctyme.com/intr/rb-1594.htm#Table510
 560     Bct->Feature[1] = 0x00; // We don't support anything from here; see http://www.ctyme.com/intr/rb-1594.htm#Table511
 561     Bct->Feature[2] = 0x00;
 562     Bct->Feature[3] = 0x00;
 563     Bct->Feature[4] = 0x00;
 564 }
 565
 566
 567
 568 /*
 569  * The BIOS POST (Power On-Self Test)
 570  */
 571 VOID
 572 Bios32Post(VOID)
 573 {
 574     BOOLEAN Success;
 575
 576     DPRINT1("Bios32Post\n");
 577
 578     /* Initialize the stack */
 579     // That's what says IBM... (stack at 30:00FF going downwards)
 580     // setSS(0x0000);
 581     // setSP(0x0400);
 582     setSS(0x0050);  // Stack at 50:0400, going downwards
 583     setSP(0x0400);
 584
 585     /* Set data segment */
 586     setDS(BDA_SEGMENT);
 587
 588     /* Initialize the BDA and the BIOS ROM Information */
 589     InitializeBiosData();
 590     InitializeBiosInfo();
 591
 592     /*
 593      * Initialize IVT and hardware
 594      */
 595
 596     /* Register the BIOS 32-bit Interrupts */
 597     InitializeBiosInt32();
 598
 599     /* Initialize platform hardware (PIC/PIT chips, ...) */
 600     BiosHwSetup();
 601
 602     /* Initialize the Keyboard, Video and Mouse BIOS */
 603     if (!KbdBios32Initialize() || !VidBios32Initialize() || !MouseBios32Initialize())
 604     {
 605         // return FALSE;
 606
 607         /* Stop the VDM */
 608         EmulatorTerminate();
 609         return;
 610     }
 611
 612 #if 0
 613     /* Initialize the Keyboard and Video BIOS */
 614     if (!KbdBiosInitialize() || !VidBiosInitialize())
 615     {
 616         /* Stop the VDM */
 617         EmulatorTerminate();
 618         return;
 619     }
 620 #endif
 621
 622     ///////////// MUST BE DONE AFTER IVT INITIALIZATION !! /////////////////////
 623
 624     /* Load some ROMs */
 625     Success = LoadRom("boot.bin", (PVOID)0xE0000, NULL);
 626     DPRINT1("Test ROM loading %s ; GetLastError() = %u\n", Success ? "succeeded" : "failed", GetLastError());
 627
 628     SearchAndInitRoms(&BiosContext);
 629
 630     /*
 631      * End of the 32-bit POST portion. We then fall back into 16-bit where
 632      * the rest of the POST code is executed, typically calling INT 19h
 633      * to boot up the OS.
 634      */
 635 }
 636
 637 static VOID WINAPI Bios32ResetBop(LPWORD Stack)
 638 {
 639     DPRINT1("Bios32ResetBop\n");
 640
 641     /* Disable interrupts */
 642     setIF(0);
 643
 644     // FIXME: Check the word at 0040h:0072h (Bda->SoftReset) and do one of the
 645     // following actions:
 646     // - if the word is 1234h, perform a warm reboot (aka. Ctrl-Alt-Del);
 647     // - if the word is 0000h, perform a cold reboot (aka. Reset).
 648
 649     /* Do the POST */
 650     Bios32Post();
 651
 652     /* Enable interrupts */
 653     setIF(1);
 654 }
 655
 656
 657 /* PUBLIC FUNCTIONS ***********************************************************/
 658
 659 BOOLEAN Bios32Initialize(VOID)
 660 {
 661     /*
 662      * Initialize BIOS32 static data
 663      */
 664
 665     /* Bootstrap code */
 666     RtlCopyMemory(SEG_OFF_TO_PTR(0xF000, 0xE05B), PostCode , sizeof(PostCode ));
 667     RtlCopyMemory(SEG_OFF_TO_PTR(0xF000, 0xFFF0), Bootstrap, sizeof(Bootstrap));
 668
 669     /* System BIOS Copyright */
 670     RtlCopyMemory(SEG_OFF_TO_PTR(0xF000, 0xE000), BiosCopyright, sizeof(BiosCopyright)-1);
 671
 672     /* System BIOS Version */
 673     RtlCopyMemory(SEG_OFF_TO_PTR(0xF000, 0xE080), BiosVersion, sizeof(BiosVersion)-1);
 674     // FIXME: or E061, or E100 ??
 675
 676     /* System BIOS Date */
 677     RtlCopyMemory(SEG_OFF_TO_PTR(0xF000, 0xFFF5), BiosDate, sizeof(BiosDate)-1);
 678
 679     /* System BIOS Model (same as Bct->Model) */
 680     *(PBYTE)(SEG_OFF_TO_PTR(0xF000, 0xFFFE)) = BIOS_MODEL;
 681
 682     /* Redefine our POST function */
 683     RegisterBop(BOP_RESET, Bios32ResetBop);
 684
 685     /* We are done */
 686     return TRUE;
 687 }
 688
 689 VOID Bios32Cleanup(VOID)
 690 {
 691     MouseBios32Cleanup();
 692     VidBios32Cleanup();
 693     KbdBios32Cleanup();
 694 }
 695
 696 /* EOF */