Remove wrong folder copy

svn path=/branches/ros-branch-0_2_5/; revision=13827

freeldr/Makefile

@@ -31,6 +31,10 @@ all:
 	$(MAKE) -C install
 	$(MAKE) -C fdebug
 
+freeldr:
+	$(MAKE) -C freeldr
+.PHONY : freeldr
+
 clean:
 	$(MAKE) -C bootsect clean
 	$(MAKE) -C freeldr clean

freeldr/bootsect/isoboot.asm

@@ -237,8 +237,8 @@ found_drive:
 	int	13h
 	jnc	params_ok
 
-	mov	si, nosecsize_msg
-	call	writemsg
+	; mov	si, nosecsize_msg	No use in reporting this
+	; call	writemsg
 
 params_ok:
 	; Check for the sector size (should be 2048, but

freeldr/freeldr/CHANGELOG

@@ -1,3 +1,28 @@
+Changes in v1.8.26 (10/30/2004) (chorns)
+
+- Print stack frames on crashes.
+- Users should report errors to ros-dev@reactos.com.
+
+Changes in v1.8.25 (10/30/2004) (chorns)
+
+- Support FULL_MAP command line option.
+- Allow DEBUG to be set on command line.
+
+Changes in v1.8.24 (09/20/2004) (hbirr)
+
+- Implemented the driver loading by the sequence of tag entries 
+  in the GroupOrderList key.
+
+Changes in v1.8.23 (30/08/2004) (ekohl)
+
+- Fixed some compiler warnings.
+- Detect and report PCI-BIOS.
+
+Changes in v1.8.22 (21/05/2004) (navaraf)
+
+- Fixed lots of bugs in NTFS code and added correct update sequence
+  fixups handling and untested NTFS 3+ sparse file support.
+
 Changes in v1.8.21 (21/05/2004) (navaraf)
 
 - Experimental NTFS reading support with no boot code yet.

freeldr/freeldr/Makefile

@@ -21,10 +21,12 @@
 # CHANGE THESE FOR YOUR OUTPUT
 #
 TARGET		=	i386
+ifeq ($(DEBUG),)
 # Debugging information on (bigger binary)
 #DEBUG		=	yes
 # Debugging information off (smaller binary)
 DEBUG		=	no
+endif
 
 OBJDIR		=	obj
 OUTPUT_DIR	=	$(OBJDIR)/$(TARGET)
@@ -40,8 +42,9 @@ RM		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rdel
 CP		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rcopy
 MKDIR		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rmkdir
 RMDIR		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)rrmdir
-NASM_CMD	= nasm
 OBJCOPY		= objcopy
+NM   		= nm
+OBJDUMP		= objdump
 DEPTOOL		= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)deptool
 HOSTTOOL	= $(subst /,$(SEP),$(TOOLSDIR))$(SEP)hosttype
 TOOLS		= $(DEPTOOL) $(HOSTTOOL)
@@ -132,7 +135,7 @@ else
 #############################################
 # COMPILER COMMAND LINE OPTIONS
 #
-COMPILER_OPTIONS = -Wall -nostdlib -nostdinc -ffreestanding -fno-builtin -fno-inline \
+COMPILER_OPTIONS = -Wall -Werror -nostdlib -nostdinc -ffreestanding -fno-builtin -fno-inline \
                    -fno-zero-initialized-in-bss -O1 -MD
 # FreeLoader does not use any of the standard libraries, includes, or built-in functions
 
@@ -189,24 +192,41 @@ endif
 # fathelp.o must come first in the link line because it contains bootsector helper code
 # arch.o must come second in the link line because it contains the startup code
 ARCH_OBJS	=	fathelp.o	\
-				arch.o		\
-				i386idt.o	\
-				i386trap.o	\
-				i386cpu.o	\
-				i386pnp.o	\
-				boot.o		\
-				linux.o		\
-				mb.o		\
-				i386mem.o	\
-				i386rtl.o	\
-				i386vid.o	\
-				drvmap.o	\
-				int386.o	\
-				i386disk.o	\
-				portio.o	\
-				hardware.o	\
-				hwcpu.o		\
-				_alloca.o		# For Mingw32 builds
+			arch.o		\
+			i386idt.o	\
+			i386trap.o	\
+			i386cpu.o	\
+			i386pnp.o	\
+			boot.o		\
+			linux.o		\
+			mb.o		\
+			i386rtl.o	\
+			i386vid.o	\
+			drvmap.o	\
+			int386.o	\
+			i386disk.o	\
+			portio.o	\
+			hardware.o	\
+			hwacpi.o	\
+			hwapm.o		\
+			hwcpu.o		\
+			hwpci.o		\
+			archmach.o	\
+			machpc.o	\
+			machxbox.o	\
+			pccons.o	\
+			pcdisk.o	\
+			pcmem.o		\
+			pcrtc.o		\
+			pcvideo.o	\
+			xboxcons.o	\
+			xboxdisk.o	\
+			xboxfont.o	\
+			xboxhw.o	\
+			xboxmem.o	\
+			xboxrtc.o	\
+			xboxvideo.o	\
+			_alloca.o		# For Mingw32 builds
 
 
 RTL_OBJS	=	print.o		\
@@ -237,8 +257,7 @@ REACTOS_OBJS=	arcname.o	\
 COMM_OBJS	=	rs232.o
 
 DISK_OBJS	=	disk.o		\
-				geometry.o	\
-				partition.o
+			partition.o
 
 MM_OBJS		=	mm.o		\
 				meminit.o
@@ -253,11 +272,10 @@ INIFILE_OBJS=	inifile.o	\
 INFFILE_OBJS=	inffile.o
 
 VIDEO_OBJS	=	video.o		\
-				vidmode.o	\
-				fade.o		\
-				palette.o	\
-				pixel.o		\
-				bank.o
+			fade.o		\
+			palette.o	\
+			pixel.o		\
+			bank.o
 
 # libgcc2.o contains code (__udivdi3, __umoddi3) necessary to do
 # 64-bit division on the i386 (and other 32-bit) architectures
@@ -265,17 +283,19 @@ VIDEO_OBJS	=	video.o		\
 MATH_OBJS	=	libgcc2.o
 
 BASE_OBJS	=	freeldr.o \
-				debug.o \
-				multiboot.o	\
-				version.o
+			debug.o \
+			multiboot.o	\
+			version.o \
+			cmdline.o \
+			machine.o
 
 FREELDR_OBJS=	bootmgr.o \
-				drivemap.o \
-				miscboot.o \
-				options.o \
-				linuxboot.o	\
-				oslist.o \
-				custom.o
+		drivemap.o \
+		miscboot.o \
+		options.o \
+		linuxboot.o	\
+		oslist.o \
+		custom.o
 
 ROSLDR_OBJS =	reactos.o
 
@@ -347,10 +367,12 @@ all : freeldr.sys setupldr.sys
 
 freeldr.sys : $(ALL_OBJS)
 	@echo ===================================================== LINKING $@
-#	@$(LD) -N -Ttext=0x8000 --oformat=binary -s -o freeldr.sys $(F_OBJS)
-	@$(LD) $(LFLAGS) -Map freeldr.map -o freeldr.exe $(F_OBJS)
-#	@$(CC) -Wl,-Ttext=0x8000,-N,-Map,freeldr.map -o freeldr.exe $(F_OBJS)
-	@$(NM) --numeric-sort freeldr.exe > freeldr.sym
+	@$(LD) $(LFLAGS) -o freeldr.exe $(F_OBJS)
+ifeq ($(FULL_MAP),yes)
+	@$(OBJDUMP) -d -S freeldr.exe > freeldr.map
+else
+	@$(NM) --numeric-sort freeldr.exe > freeldr.map
+endif
 	@$(OBJCOPY) -O binary freeldr.exe freeldr.sys
 
 #############################################
@@ -358,7 +380,11 @@ freeldr.sys : $(ALL_OBJS)
 setupldr.sys : $(ALL_OBJS)
 	@echo ===================================================== LINKING $@
 	@$(LD) $(LFLAGS) -Map setupldr.map -o setupldr.exe $(S_OBJS)
-	@$(NM) --numeric-sort setupldr.exe > setupldr.sym
+ifeq ($(FULL_MAP),yes)
+	@$(OBJDUMP) -d -S setupldr.exe > setupldr.map
+else
+	@$(NM) --numeric-sort setupldr.exe > setupldr.map
+endif
 	@$(OBJCOPY) -O binary setupldr.exe setupldr.sys
 
 #############################################

freeldr/freeldr/arch/i386/arch.S

@@ -22,6 +22,7 @@
 
 #define ASM
 #include <arch.h>
+#include <multiboot.h>
 
 
 EXTERN(RealEntryPoint)
@@ -52,16 +53,18 @@ EXTERN(RealEntryPoint)
 	movb	%dh,(_BootPartition)
 
 	/* GO! */
+	xorl	%eax,%eax
+	pushl	%eax
 	call	_BootMain
 
 	call	switch_to_real
 	.code16
 
-	int		$0x19
+	int	$0x19
 
 	/* We should never get here */
 stop:
-	jmp		stop
+	jmp	stop
 	nop
 	nop
 
@@ -100,9 +103,9 @@ EXTERN(switch_to_prot)
 	lidt	i386idtptr
 
 	/* Enable Protected Mode */
-	mov		%cr0,%eax
-	orl		$CR0_PE_SET,%eax
-	mov		%eax,%cr0
+	mov	%cr0,%eax
+	orl	$CR0_PE_SET,%eax
+	mov	%eax,%cr0
 
 	/* Clear prefetch queue & correct CS */
 	ljmp	$PMODE_CS, $inpmode
@@ -168,9 +171,9 @@ switch_to_real16:
 	movw	%ax,%ss
 
 	/* Disable Protected Mode */
-	mov		%cr0,%eax
+	mov	%cr0,%eax
 	andl	$CR0_PE_CLR,%eax
-	mov		%eax,%cr0
+	mov	%eax,%cr0
 
 	/* Clear prefetch queue & correct CS */
 	ljmp	$0, $inrmode
@@ -211,9 +214,9 @@ inrmode:
 	.code16
 empty_8042:
 	.word	0x00eb,0x00eb            // jmp $+2, jmp $+2
-	inb     $0x64,%al
-    testb   $0x02,%al
-    jnz     empty_8042
+	inb	$0x64,%al
+	testb	$0x02,%al
+	jnz	empty_8042
 	ret
 
 	/*
@@ -228,11 +231,11 @@ EXTERN(_EnableA20)
 	.code16
 
 	call	empty_8042
-    movb	$0xD1,%al                // command write
-    outb	%al,$0x64
+	movb	$0xD1,%al                // command write
+	outb	%al,$0x64
 	call	empty_8042
-    mov		$0xDF,%al                // A20 on
-    out		%al,$0x60
+	mov	$0xDF,%al                // A20 on
+	out	%al,$0x60
 	call	empty_8042
 	call	switch_to_prot
 	.code32
@@ -253,11 +256,11 @@ EXTERN(_DisableA20)
 	.code16
 
 	call	empty_8042
-    movb	$0xD1,%al                // command write
-    outb	%al,$0x64
+	movb	$0xD1,%al                // command write
+	outb	%al,$0x64
 	call	empty_8042
-    mov		$0xDD,%al                // A20 off
-    out		%al,$0x60
+	mov	$0xDD,%al                // A20 off
+	out	%al,$0x60
 	call	empty_8042
 	call	switch_to_prot
 	.code32
@@ -266,8 +269,134 @@ EXTERN(_DisableA20)
 
 	ret
 
+/* Multiboot support
+ *
+ * Allows freeldr to be loaded as a "multiboot kernel" by
+ * other boot loaders like Grub
+ */
 
+#define MB_INFO_FLAGS_OFFSET        0
+#define MB_INFO_BOOT_DEVICE_OFFSET  12
+#define MB_INFO_COMMAND_LINE_OFFSET 16
 
+/*
+ * We want to execute at 0x8000 (to be compatible with bootsector
+ * loading), but Grub only allows loading of multiboot kernels
+ * above 1MB. So we let Grub load us there and then relocate
+ * ourself to 0x8000
+ */
+#define CMDLINE_BASE 0x7000
+#define FREELDR_BASE 0x8000
+#define INITIAL_BASE 0x200000
+
+	/* Align 32 bits boundary */
+	.align 4
+	
+	/* Multiboot header */
+MultibootHeader:
+	/* magic */
+	.long MULTIBOOT_HEADER_MAGIC
+	/* flags */
+	.long MULTIBOOT_HEADER_FLAGS
+	/* checksum */
+	.long -(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS)
+	/* header_addr */
+	.long INITIAL_BASE + MultibootHeader - FREELDR_BASE
+	/* load_addr */
+	.long INITIAL_BASE
+	/* load_end_addr */
+	.long INITIAL_BASE + __bss_start__ - FREELDR_BASE
+	/* bss_end_addr */
+	.long INITIAL_BASE + __bss_end__ - FREELDR_BASE
+	/* entry_addr */
+	.long INITIAL_BASE + MultibootEntry - FREELDR_BASE
+
+MultibootEntry:
+	cli		/* Even after setting up the our IDT below we are
+			 * not ready to handle hardware interrupts (no entries
+			 * in IDT), so there's no sti here. Interrupts will be
+			 * enabled in due time */
+
+	/* Although the multiboot spec says we should be called with the
+	 * segment registers set to 4GB flat mode, let's be sure and set up
+	 * our own */
+	lgdt	gdtptrhigh + INITIAL_BASE - FREELDR_BASE
+	/* Reload segment selectors */
+	ljmp	$PMODE_CS, $(mb1 + INITIAL_BASE - FREELDR_BASE)
+mb1:
+	movw	$PMODE_DS,%dx
+	movw	%dx,%ds
+	movw	%dx,%es
+
+	/* Copy to low mem */
+	movl	$INITIAL_BASE,%esi
+	movl	$FREELDR_BASE,%edi
+	movl	$(__bss_end__ - FREELDR_BASE),%ecx
+	addl	$3,%ecx
+	shrl	$2,%ecx
+	rep movsl
+
+	/* Load the GDT and IDT */
+	lgdt	gdtptr
+	lidt	i386idtptr
+
+	/* Clear prefetch queue & correct CS,
+	 * jump to low mem */
+	ljmp	$PMODE_CS, $mb2
+mb2:
+	/* Reload segment selectors */
+	movw	$PMODE_DS,%dx
+	movw	%dx,%ds
+	movw	%dx,%es
+	movw	%dx,%fs
+	movw	%dx,%gs
+	movw	%dx,%ss
+	movl	$STACK32ADDR,%esp
+
+	/* Check for valid multiboot signature */
+	cmpl	$MULTIBOOT_BOOTLOADER_MAGIC,%eax
+	jne	mbfail
+
+	/* See if the boot device was passed in */
+	movl	MB_INFO_FLAGS_OFFSET(%ebx),%edx
+	testl	$MB_INFO_FLAG_BOOT_DEVICE,%edx
+	jz	mb3
+	/* Retrieve boot device info */
+	movl	MB_INFO_BOOT_DEVICE_OFFSET(%ebx),%eax
+	shrl	$16,%eax
+	incb	%al
+	movb	%al,_BootPartition
+	movb	%ah,_BootDrive
+	jmp	mb4
+mb3:	/* No boot device known, assume first partition of first harddisk */
+	movb	$0x80,_BootDrive
+	movb	$1,_BootPartition
+mb4:
+
+	/* Check for a command line */
+	xorl	%eax,%eax
+	testl	$MB_INFO_FLAG_COMMAND_LINE,%edx
+	jz	mb6
+	/* Copy command line to low mem*/
+	movl	MB_INFO_COMMAND_LINE_OFFSET(%ebx),%esi
+	movl	$CMDLINE_BASE,%edi
+mb5:	lodsb
+	stosb
+	testb	%al,%al
+	jnz	mb5
+	movl	$CMDLINE_BASE,%eax
+mb6:
+
+	/* GO! */
+	pushl	%eax	
+	call	_BootMain
+
+mbfail:	call	switch_to_real
+	.code16
+	int	$0x19
+mbstop:	jmp	mbstop	/* We should never get here */
+
+	.code32
 
 	/* 16-bit stack pointer */
 stack16:
@@ -323,6 +452,11 @@ gdtptr:
 	.word	0x27		/* Limit */
 	.long	gdt			/* Base Address */
 
+/* Initial GDT table pointer for multiboot */
+gdtptrhigh:
+	.word	0x27		/* Limit */
+	.long	gdt + INITIAL_BASE - FREELDR_BASE	/* Base Address */
+
 /* Real-mode IDT pointer */
 rmode_idtptr:
 	.word	0x3ff		/* Limit */

freeldr/freeldr/arch/i386/archmach.c

@@ -0,0 +1,52 @@
+/* $Id: archmach.c,v 1.2 2004/11/09 23:36:19 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "mm.h"
+#include "machine.h"
+#include "machpc.h"
+#include "machxbox.h"
+#include "portio.h"
+#include "hardware.h"
+#include "rtl.h"
+
+VOID
+MachInit(VOID)
+{
+  U32 PciId;
+
+  memset(&MachVtbl, 0, sizeof(MACHVTBL));
+
+  /* Check for Xbox by identifying device at PCI 0:0:0, if it's
+   * 0x10de/0x02a5 then we're running on an Xbox */
+  WRITE_PORT_ULONG((U32*) 0xcf8, CONFIG_CMD(0, 0, 0));
+  PciId = READ_PORT_ULONG((U32*) 0xcfc);
+  if (0x02a510de == PciId)
+    {
+      XboxMachInit();
+    }
+  else
+    {
+      PcMachInit();
+    }
+
+  HalpCalibrateStallExecution();
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/hardware.c

@@ -1,7 +1,7 @@
 /*
  *  FreeLoader
  *
- *  Copyright (C) 2003  Eric Kohl
+ *  Copyright (C) 2003, 2004  Eric Kohl
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License as published by
@@ -24,7 +24,9 @@
 #include <debug.h>
 #include <disk.h>
 #include <mm.h>
+#include <machine.h>
 #include <portio.h>
+#include <video.h>
 
 #include "../../reactos/registry.h"
 #include "hardware.h"
@@ -167,6 +169,16 @@ typedef struct _CM_FLOPPY_DEVICE_DATA
 } __attribute__((packed)) CM_FLOPPY_DEVICE_DATA, *PCM_FLOPPY_DEVICE_DATA;
 
 
+typedef struct _CM_KEYBOARD_DEVICE_DATA
+{
+  U16 Version;
+  U16 Revision;
+  U8 Type;
+  U8 Subtype;
+  U16 KeyboardFlags;
+} __attribute__((packed)) CM_KEYBOARD_DEVICE_DATA, *PCM_KEYBOARD_DEVICE_DATA;
+
+
 static char Hex[] = "0123456789ABCDEF";
 static unsigned int delay_count = 1;
 
@@ -181,6 +193,7 @@ __KeStallExecutionProcessor(U32 Loops)
   for (i = 0; i < Loops; i++);
 }
 
+
 VOID KeStallExecutionProcessor(U32 Microseconds)
 {
   U64 LoopCount = ((U64)delay_count * (U64)Microseconds) / 1000ULL;
@@ -362,6 +375,12 @@ DetectPnpBios(HKEY SystemKey, U32 *BusNumber)
   /* Increment bus number */
   (*BusNumber)++;
 
+  /* Set 'Component Information' value similar to my NT4 box */
+  SetComponentInformation(BusKey,
+                          0x0,
+                          0x0,
+                          0xFFFFFFFF);
+
   /* Set 'Identifier' value */
   Error = RegSetValue(BusKey,
 		      "Identifier",
@@ -393,7 +412,6 @@ DetectPnpBios(HKEY SystemKey, U32 *BusNumber)
     CmResourceTypeDeviceSpecific;
   FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].ShareDisposition =
     CmResourceShareUndetermined;
-//  FullResourceDescriptor->PartialResourceList.PartialDescriptors[0].Flags =
 
   Ptr = (char *)(((PVOID)&FullResourceDescriptor->PartialResourceList.PartialDescriptors[0]) +
 		 sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR));
@@ -419,10 +437,6 @@ DetectPnpBios(HKEY SystemKey, U32 *BusNumber)
 		    DeviceNode->Node,
 		    DeviceNode->Size,
 		    DeviceNode->Size));
-//	  printf("Node: %u  Size %u (0x%x)\n",
-//		 DeviceNode->Node,
-//		 DeviceNode->Size,
-//		 DeviceNode->Size);
 
 	  memcpy (Ptr,
 		  DeviceNode,
@@ -507,7 +521,7 @@ SetHarddiskConfigurationData(HKEY DiskKey,
       DiskGeometry->SectorsPerTrack = ExtGeometry.SectorsPerTrack;
       DiskGeometry->NumberOfHeads = ExtGeometry.Heads;
     }
-  else if(DiskGetDriveParameters(DriveNumber, &Geometry))
+  else if(MachDiskGetDriveGeometry(DriveNumber, &Geometry))
     {
       DiskGeometry->BytesPerSector = Geometry.BytesPerSector;
       DiskGeometry->NumberOfCylinders = Geometry.Cylinders;
@@ -556,7 +570,7 @@ SetHarddiskIdentifier(HKEY DiskKey,
   S32 Error;
 
   /* Read the MBR */
-  if (!DiskReadLogicalSectors(DriveNumber, 0ULL, 1, (PVOID)DISKREADBUFFER))
+  if (!MachDiskReadLogicalSectors(DriveNumber, 0ULL, 1, (PVOID)DISKREADBUFFER))
     {
       DbgPrint((DPRINT_HWDETECT, "Reading MBR failed\n"));
       return;
@@ -628,13 +642,33 @@ DetectBiosDisks(HKEY SystemKey,
   U32 Size;
   U32 i;
   S32 Error;
+  BOOL Changed;
 
   /* Count the number of visible drives */
   DiskReportError(FALSE);
   DiskCount = 0;
-  while (DiskReadLogicalSectors(0x80 + DiskCount, 0ULL, 1, (PVOID)DISKREADBUFFER))
+
+  /* There are some really broken BIOSes out there. There are even BIOSes
+   * that happily report success when you ask them to read from non-existent
+   * harddisks. So, we set the buffer to known contents first, then try to
+   * read. If the BIOS reports success but the buffer contents haven't
+   * changed then we fail anyway */
+  memset((PVOID) DISKREADBUFFER, 0xcd, 512);
+  while (MachDiskReadLogicalSectors(0x80 + DiskCount, 0ULL, 1, (PVOID)DISKREADBUFFER))
     {
+      Changed = FALSE;
+      for (i = 0; ! Changed && i < 512; i++)
+        {
+          Changed = ((PUCHAR)DISKREADBUFFER)[i] != 0xcd;
+        }
+      if (! Changed)
+        {
+          DbgPrint((DPRINT_HWDETECT, "BIOS reports success for disk %d but data didn't change\n",
+                    (int)DiskCount));
+          break;
+        }
       DiskCount++;
+      memset((PVOID) DISKREADBUFFER, 0xcd, 512);
     }
   DiskReportError(TRUE);
   DbgPrint((DPRINT_HWDETECT, "BIOS reports %d harddisk%s\n",
@@ -667,7 +701,7 @@ DetectBiosDisks(HKEY SystemKey,
   Int13Drives = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
   for (i = 0; i < DiskCount; i++)
     {
-      if (DiskGetDriveParameters(0x80 + i, &Geometry))
+      if (MachDiskGetDriveGeometry(0x80 + i, &Geometry))
 	{
 	  Int13Drives[i].DriveSelect = 0x80 + i;
 	  Int13Drives[i].MaxCylinders = Geometry.Cylinders - 1;
@@ -885,7 +919,9 @@ DetectBiosFloppyController(HKEY SystemKey,
   U32 FloppyCount;
 
   FloppyCount = GetFloppyCount();
-/*  printf ("Floppy count: %u\n", FloppyCount);*/
+  DbgPrint((DPRINT_HWDETECT,
+	    "Floppy count: %u\n",
+	    FloppyCount));
 
   if (FloppyCount == 0)
     return;
@@ -1325,9 +1361,10 @@ DetectSerialPorts(HKEY BusKey)
   PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
   PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
   PCM_SERIAL_DEVICE_DATA SerialDeviceData;
-  U32 Base[4] = {0x3F8, 0x2F8, 0x3E8, 0x2E8};
   U32 Irq[4] = {4, 3, 4, 3};
+  U32 Base;
   char Buffer[80];
+  PU16 BasePtr;
   U32 ControllerNumber = 0;
   HKEY ControllerKey;
   U32 i;
@@ -1336,64 +1373,209 @@ DetectSerialPorts(HKEY BusKey)
 
   DbgPrint((DPRINT_HWDETECT, "DetectSerialPorts()\n"));
 
-  for (i = 0; i < 4; i++)
+  ControllerNumber = 0;
+  BasePtr = (PU16)0x400;
+  for (i = 0; i < 4; i++, BasePtr++)
     {
-      WRITE_PORT_UCHAR ((PUCHAR)(Base[i] + 4), 0x10);
-      if (!(READ_PORT_UCHAR((PUCHAR)Base[i] + 6) & 0xf0))
+      Base = (U32)*BasePtr;
+      if (Base == 0)
+        continue;
+
+      DbgPrint((DPRINT_HWDETECT,
+		"Found COM%u port at 0x%x\n",
+		i + 1,
+		Base));
+
+      /* Create controller key */
+      sprintf(Buffer,
+	      "SerialController\\%u",
+	      ControllerNumber);
+
+      Error = RegCreateKey(BusKey,
+			   Buffer,
+			   &ControllerKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
+	  continue;
+	}
+      DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", Buffer));
+
+      /* Set 'ComponentInformation' value */
+      SetComponentInformation(ControllerKey,
+			      0x78,
+			      ControllerNumber,
+			      0xFFFFFFFF);
+
+      /* Build full device descriptor */
+      Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
+	     2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) +
+	     sizeof(CM_SERIAL_DEVICE_DATA);
+      FullResourceDescriptor = MmAllocateMemory(Size);
+      if (FullResourceDescriptor == NULL)
 	{
 	  DbgPrint((DPRINT_HWDETECT,
-		    "Found COM%u port at 0x%x\n",
-		    i + 1,
-		    Base[i]));
+		    "Failed to allocate resource descriptor\n"));
+	  continue;
+	}
+      memset(FullResourceDescriptor, 0, Size);
 
-	  /* Create controller key */
-	  sprintf(Buffer,
-		  "SerialController\\%u",
-		  ControllerNumber);
+      /* Initialize resource descriptor */
+      FullResourceDescriptor->InterfaceType = Isa;
+      FullResourceDescriptor->BusNumber = 0;
+      FullResourceDescriptor->PartialResourceList.Count = 3;
 
-	  Error = RegCreateKey(BusKey,
-			       Buffer,
-			       &ControllerKey);
-	  if (Error != ERROR_SUCCESS)
-	    {
-	      DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
-	      continue;
-	    }
-	  DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", Buffer));
+      /* Set IO Port */
+      PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
+      PartialDescriptor->Type = CmResourceTypePort;
+      PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+      PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
+      PartialDescriptor->u.Port.Start = (U64)Base;
+      PartialDescriptor->u.Port.Length = 7;
 
-	  /* Set 'ComponentInformation' value */
-	  SetComponentInformation(ControllerKey,
-				  0x78,
-				  ControllerNumber,
-				  0xFFFFFFFF);
+      /* Set Interrupt */
+      PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
+      PartialDescriptor->Type = CmResourceTypeInterrupt;
+      PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+      PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
+      PartialDescriptor->u.Interrupt.Level = Irq[i];
+      PartialDescriptor->u.Interrupt.Vector = Irq[i];
+      PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
 
-	  /* Build full device descriptor */
-	  Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
-		 2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) +
-		 sizeof(CM_SERIAL_DEVICE_DATA);
-	  FullResourceDescriptor = MmAllocateMemory(Size);
-	  if (FullResourceDescriptor == NULL)
-	    {
-	      DbgPrint((DPRINT_HWDETECT,
-			"Failed to allocate resource descriptor\n"));
-	      continue;
-	    }
-	  memset(FullResourceDescriptor, 0, Size);
+      /* Set serial data (device specific) */
+      PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
+      PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
+      PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+      PartialDescriptor->Flags = 0;
+      PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_SERIAL_DEVICE_DATA);
 
-	  /* Initialize resource descriptor */
-	  FullResourceDescriptor->InterfaceType = Isa;
-	  FullResourceDescriptor->BusNumber = 0;
-	  FullResourceDescriptor->PartialResourceList.Count = 3;
+      SerialDeviceData =
+	(PCM_SERIAL_DEVICE_DATA)&FullResourceDescriptor->PartialResourceList.PartialDescriptors[3];
+      SerialDeviceData->BaudClock = 1843200; /* UART Clock frequency (Hertz) */
 
-	  /* Set IO Port */
-	  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
-	  PartialDescriptor->Type = CmResourceTypePort;
-	  PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
-	  PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
-	  PartialDescriptor->u.Port.Start = (U64)Base[i];
-	  PartialDescriptor->u.Port.Length = 7;
+      /* Set 'Configuration Data' value */
+      Error = RegSetValue(ControllerKey,
+			  "Configuration Data",
+			  REG_FULL_RESOURCE_DESCRIPTOR,
+			  (PU8) FullResourceDescriptor,
+			  Size);
+      MmFreeMemory(FullResourceDescriptor);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue(Configuration Data) failed (Error %u)\n",
+		    (int)Error));
+	}
 
-	  /* Set Interrupt */
+      /* Set 'Identifier' value */
+      sprintf(Buffer,
+	      "COM%u",
+	      i + 1);
+      Error = RegSetValue(ControllerKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)Buffer,
+			  strlen(Buffer) + 1);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue() failed (Error %u)\n",
+		    (int)Error));
+	  continue;
+	}
+      DbgPrint((DPRINT_HWDETECT,
+		"Created value: Identifier %s\n",
+		Buffer));
+
+      /* Detect serial mouse */
+      DetectSerialPointerPeripheral(ControllerKey, Base);
+
+      ControllerNumber++;
+    }
+}
+
+
+static VOID
+DetectParallelPorts(HKEY BusKey)
+{
+  PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
+  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
+  U32 Irq[3] = {7, 5, (U32)-1};
+  char Buffer[80];
+  HKEY ControllerKey;
+  PU16 BasePtr;
+  U32 Base;
+  U32 ControllerNumber;
+  U32 i;
+  S32 Error;
+  U32 Size;
+
+  DbgPrint((DPRINT_HWDETECT, "DetectParallelPorts() called\n"));
+
+  ControllerNumber = 0;
+  BasePtr = (PU16)0x408;
+  for (i = 0; i < 3; i++, BasePtr++)
+    {
+      Base = (U32)*BasePtr;
+      if (Base == 0)
+        continue;
+
+      DbgPrint((DPRINT_HWDETECT,
+		"Parallel port %u: %x\n",
+		ControllerNumber,
+		Base));
+
+      /* Create controller key */
+      sprintf(Buffer,
+	      "ParallelController\\%u",
+	      ControllerNumber);
+
+      Error = RegCreateKey(BusKey,
+			   Buffer,
+			   &ControllerKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
+	  continue;
+	}
+      DbgPrint((DPRINT_HWDETECT, "Created key: %s\n", Buffer));
+
+      /* Set 'ComponentInformation' value */
+      SetComponentInformation(ControllerKey,
+			      0x40,
+			      ControllerNumber,
+			      0xFFFFFFFF);
+
+      /* Build full device descriptor */
+      Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
+      if (Irq[i] != (U32)-1)
+	Size += sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
+
+      FullResourceDescriptor = MmAllocateMemory(Size);
+      if (FullResourceDescriptor == NULL)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Failed to allocate resource descriptor\n"));
+	  continue;
+	}
+      memset(FullResourceDescriptor, 0, Size);
+
+      /* Initialize resource descriptor */
+      FullResourceDescriptor->InterfaceType = Isa;
+      FullResourceDescriptor->BusNumber = 0;
+      FullResourceDescriptor->PartialResourceList.Count = (Irq[i] != (U32)-1) ? 2 : 1;
+
+      /* Set IO Port */
+      PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
+      PartialDescriptor->Type = CmResourceTypePort;
+      PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+      PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
+      PartialDescriptor->u.Port.Start = (U64)Base;
+      PartialDescriptor->u.Port.Length = 3;
+
+      /* Set Interrupt */
+      if (Irq[i] != (U32)-1)
+	{
 	  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
 	  PartialDescriptor->Type = CmResourceTypeInterrupt;
 	  PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
@@ -1401,58 +1583,284 @@ DetectSerialPorts(HKEY BusKey)
 	  PartialDescriptor->u.Interrupt.Level = Irq[i];
 	  PartialDescriptor->u.Interrupt.Vector = Irq[i];
 	  PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
-
-	  /* Set serial data (device specific) */
-	  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
-	  PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
-	  PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
-	  PartialDescriptor->Flags = 0;
-	  PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_SERIAL_DEVICE_DATA);
-
-	  SerialDeviceData =
-	   (PCM_SERIAL_DEVICE_DATA)&FullResourceDescriptor->PartialResourceList.PartialDescriptors[3];
-	  SerialDeviceData->BaudClock = 1843200; /* UART Clock frequency (Hertz) */
-
-	  /* Set 'Configuration Data' value */
-	  Error = RegSetValue(ControllerKey,
-			      "Configuration Data",
-			      REG_FULL_RESOURCE_DESCRIPTOR,
-			      (PU8) FullResourceDescriptor,
-			      Size);
-	  MmFreeMemory(FullResourceDescriptor);
-	  if (Error != ERROR_SUCCESS)
-	    {
-	      DbgPrint((DPRINT_HWDETECT,
-			"RegSetValue(Configuration Data) failed (Error %u)\n",
-			(int)Error));
-	    }
-
-	  /* Set 'Identifier' value */
-	  sprintf(Buffer,
-		  "COM%u",
-		  i + 1);
-	  Error = RegSetValue(ControllerKey,
-			      "Identifier",
-			      REG_SZ,
-			      (PU8)Buffer,
-			      5);
-	  if (Error != ERROR_SUCCESS)
-	    {
-	      DbgPrint((DPRINT_HWDETECT,
-			"RegSetValue() failed (Error %u)\n",
-			(int)Error));
-	      continue;
-	    }
-	  DbgPrint((DPRINT_HWDETECT,
-		    "Created value: Identifier %s\n",
-		    Buffer));
-
-	  /* Detect serial mouse */
-	  DetectSerialPointerPeripheral(ControllerKey, Base[i]);
-
-	  ControllerNumber++;
 	}
+
+      /* Set 'Configuration Data' value */
+      Error = RegSetValue(ControllerKey,
+			  "Configuration Data",
+			  REG_FULL_RESOURCE_DESCRIPTOR,
+			  (PU8) FullResourceDescriptor,
+			  Size);
+      MmFreeMemory(FullResourceDescriptor);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue(Configuration Data) failed (Error %u)\n",
+		    (int)Error));
+	}
+
+      /* Set 'Identifier' value */
+      sprintf(Buffer,
+	      "PARALLEL%u",
+	      i + 1);
+      Error = RegSetValue(ControllerKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)Buffer,
+			  strlen(Buffer) + 1);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue() failed (Error %u)\n",
+		    (int)Error));
+	  continue;
+	}
+      DbgPrint((DPRINT_HWDETECT,
+		"Created value: Identifier %s\n",
+		Buffer));
+
+      ControllerNumber++;
     }
+
+  DbgPrint((DPRINT_HWDETECT, "DetectParallelPorts() done\n"));
+}
+
+
+static BOOLEAN
+DetectKeyboardDevice(VOID)
+{
+  UCHAR Status;
+  UCHAR Scancode;
+
+  WRITE_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA,
+		   0xF2);
+
+  KeStallExecutionProcessor(10000);
+
+  Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
+  if ((Status & 0x01) != 0x01)
+    {
+      /* PC/XT keyboard or no keyboard */
+      return FALSE;
+    }
+
+  Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
+  if (Scancode != 0xFA)
+    {
+      /* No ACK received */
+      return FALSE;
+    }
+
+  KeStallExecutionProcessor(10000);
+  Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
+  if ((Status & 0x01) != 0x01)
+    {
+      /* Found AT keyboard */
+      return TRUE;
+    }
+
+  Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
+  if (Scancode != 0xAB)
+    {
+      /* No 0xAB received */
+      return FALSE;
+    }
+
+  KeStallExecutionProcessor(10000);
+  Status = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_STATUS);
+  if ((Status & 0x01) != 0x01)
+    {
+      /* No byte in buffer */
+      return FALSE;
+    }
+
+  Scancode = READ_PORT_UCHAR((PUCHAR)CONTROLLER_REGISTER_DATA);
+  if (Scancode != 0x41)
+    {
+      /* No 0x41 received */
+      return FALSE;
+    }
+
+  /* Found MF-II keyboard */
+  return TRUE;
+}
+
+
+static VOID
+DetectKeyboardPeripheral(HKEY ControllerKey)
+{
+  PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
+  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
+  PCM_KEYBOARD_DEVICE_DATA KeyboardData;
+  HKEY PeripheralKey;
+  char Buffer[80];
+  U32 Size;
+  S32 Error;
+
+  if (DetectKeyboardDevice())
+  {
+    /* Create controller key */
+    Error = RegCreateKey(ControllerKey,
+			 "KeyboardPeripheral\\0",
+			 &PeripheralKey);
+    if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "Failed to create peripheral key\n"));
+      return;
+    }
+    DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardPeripheral\\0\n"));
+
+    /* Set 'ComponentInformation' value */
+    SetComponentInformation(ControllerKey,
+			    0x28,
+			    0,
+			    0xFFFFFFFF);
+
+    /* Set 'Configuration Data' value */
+    Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
+	   sizeof(CM_KEYBOARD_DEVICE_DATA);
+    FullResourceDescriptor = MmAllocateMemory(Size);
+    if (FullResourceDescriptor == NULL)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"Failed to allocate resource descriptor\n"));
+      return;
+    }
+
+    /* Initialize resource descriptor */
+    memset(FullResourceDescriptor, 0, Size);
+    FullResourceDescriptor->InterfaceType = Isa;
+    FullResourceDescriptor->BusNumber = 0;
+    FullResourceDescriptor->PartialResourceList.Count = 1;
+
+    PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
+    PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
+    PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+    PartialDescriptor->u.DeviceSpecificData.DataSize = sizeof(CM_KEYBOARD_DEVICE_DATA);
+
+    KeyboardData = ((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR);
+    KeyboardData->Version = 0;
+    KeyboardData->Revision = 0;
+    KeyboardData->Type = 4;
+    KeyboardData->Subtype = 0;
+    KeyboardData->KeyboardFlags = 0x20;
+
+    /* Set 'Configuration Data' value */
+    Error = RegSetValue(PeripheralKey,
+			"Configuration Data",
+			REG_FULL_RESOURCE_DESCRIPTOR,
+			(PU8)FullResourceDescriptor,
+			Size);
+    MmFreeMemory(FullResourceDescriptor);
+    if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"RegSetValue(Configuration Data) failed (Error %u)\n",
+		(int)Error));
+    }
+
+    /* Set 'Identifier' value */
+    strcpy(Buffer,
+	   "PCAT_ENHANCED");
+    Error = RegSetValue(ControllerKey,
+			"Identifier",
+			REG_SZ,
+			(PU8)Buffer,
+			strlen(Buffer) + 1);
+    if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"RegSetValue() failed (Error %u)\n",
+		(int)Error));
+    }
+  }
+}
+
+
+static VOID
+DetectKeyboardController(HKEY BusKey)
+{
+  PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
+  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
+  HKEY ControllerKey;
+  U32 Size;
+  S32 Error;
+
+  /* Create controller key */
+  Error = RegCreateKey(BusKey,
+		       "KeyboardController\\0",
+		       &ControllerKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
+      return;
+    }
+  DbgPrint((DPRINT_HWDETECT, "Created key: KeyboardController\\0\n"));
+
+  /* Set 'ComponentInformation' value */
+  SetComponentInformation(ControllerKey,
+			  0x28,
+			  0,
+			  0xFFFFFFFF);
+
+  /* Set 'Configuration Data' value */
+  Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
+	  2 * sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
+  FullResourceDescriptor = MmAllocateMemory(Size);
+  if (FullResourceDescriptor == NULL)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"Failed to allocate resource descriptor\n"));
+      return;
+    }
+
+  /* Initialize resource descriptor */
+  memset(FullResourceDescriptor, 0, Size);
+  FullResourceDescriptor->InterfaceType = Isa;
+  FullResourceDescriptor->BusNumber = 0;
+  FullResourceDescriptor->PartialResourceList.Count = 3;
+
+  /* Set Interrupt */
+  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
+  PartialDescriptor->Type = CmResourceTypeInterrupt;
+  PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+  PartialDescriptor->Flags = CM_RESOURCE_INTERRUPT_LATCHED;
+  PartialDescriptor->u.Interrupt.Level = 1;
+  PartialDescriptor->u.Interrupt.Vector = 1;
+  PartialDescriptor->u.Interrupt.Affinity = 0xFFFFFFFF;
+
+  /* Set IO Port 0x60 */
+  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[1];
+  PartialDescriptor->Type = CmResourceTypePort;
+  PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+  PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
+  PartialDescriptor->u.Port.Start = (U64)0x60;
+  PartialDescriptor->u.Port.Length = 1;
+
+  /* Set IO Port 0x64 */
+  PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[2];
+  PartialDescriptor->Type = CmResourceTypePort;
+  PartialDescriptor->ShareDisposition = CmResourceShareDeviceExclusive;
+  PartialDescriptor->Flags = CM_RESOURCE_PORT_IO;
+  PartialDescriptor->u.Port.Start = (U64)0x64;
+  PartialDescriptor->u.Port.Length = 1;
+
+  /* Set 'Configuration Data' value */
+  Error = RegSetValue(ControllerKey,
+		      "Configuration Data",
+		      REG_FULL_RESOURCE_DESCRIPTOR,
+		      (PU8)FullResourceDescriptor,
+		      Size);
+  MmFreeMemory(FullResourceDescriptor);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"RegSetValue(Configuration Data) failed (Error %u)\n",
+		(int)Error));
+      return;
+    }
+
+  DetectKeyboardPeripheral(ControllerKey);
 }
 
 
@@ -1680,6 +2088,75 @@ DetectPS2Mouse(HKEY BusKey)
 }
 
 
+static VOID
+DetectDisplayController(HKEY BusKey)
+{
+  CHAR Buffer[80];
+  HKEY ControllerKey;
+  U16 VesaVersion;
+  S32 Error;
+
+  Error = RegCreateKey(BusKey,
+		       "DisplayController\\0",
+		       &ControllerKey);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT, "Failed to create controller key\n"));
+      return;
+    }
+  DbgPrint((DPRINT_HWDETECT, "Created key: PointerController\\0\n"));
+
+  /* Set 'ComponentInformation' value */
+  SetComponentInformation(ControllerKey,
+			  0x00,
+			  0,
+			  0xFFFFFFFF);
+
+  /* FIXME: Set 'ComponentInformation' value */
+
+  VesaVersion = BiosIsVesaSupported();
+  if (VesaVersion != 0)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"VESA version %c.%c\n",
+		(VesaVersion >> 8) + '0',
+		(VesaVersion & 0xFF) + '0'));
+    }
+  else
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"VESA not supported\n"));
+    }
+
+  if (VesaVersion >= 0x0200)
+    {
+      strcpy(Buffer,
+             "VBE Display");
+    }
+  else
+    {
+      strcpy(Buffer,
+             "VGA Display");
+    }
+
+  /* Set 'Identifier' value */
+  Error = RegSetValue(ControllerKey,
+		      "Identifier",
+		      REG_SZ,
+		      (PU8)Buffer,
+		      strlen(Buffer) + 1);
+  if (Error != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_HWDETECT,
+		"RegSetValue() failed (Error %u)\n",
+		(int)Error));
+      return;
+    }
+
+  /* FIXME: Add display peripheral (monitor) data */
+}
+
+
 static VOID
 DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
 {
@@ -1701,6 +2178,12 @@ DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
       return;
     }
 
+  /* Set 'Component Information' value similar to my NT4 box */
+  SetComponentInformation(BusKey,
+                          0x0,
+                          0x0,
+                          0xFFFFFFFF);
+
   /* Increment bus number */
   (*BusNumber)++;
 
@@ -1734,7 +2217,7 @@ DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
   FullResourceDescriptor->PartialResourceList.Count = 0;
 
   /* Set 'Configuration Data' value */
-  Error = RegSetValue(SystemKey,
+  Error = RegSetValue(BusKey,
 		      "Configuration Data",
 		      REG_FULL_RESOURCE_DESCRIPTOR,
 		      (PU8) FullResourceDescriptor,
@@ -1748,7 +2231,6 @@ DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
       return;
     }
 
-
   /* Detect ISA/BIOS devices */
   DetectBiosDisks(SystemKey, BusKey);
 
@@ -1756,22 +2238,20 @@ DetectIsaBios(HKEY SystemKey, U32 *BusNumber)
 
   DetectSerialPorts(BusKey);
 
-#if 0
-  DetectBiosParallelPorts();
-#endif
+  DetectParallelPorts(BusKey);
 
-#if 0
-  DetectBiosKeyboard(BusKey);
-#endif
+  DetectKeyboardController(BusKey);
 
   DetectPS2Mouse(BusKey);
 
+  DetectDisplayController(BusKey);
+
   /* FIXME: Detect more ISA devices */
 }
 
 
 VOID
-DetectHardware(VOID)
+PcHwDetect(VOID)
 {
   HKEY SystemKey;
   U32 BusNumber = 0;
@@ -1779,8 +2259,6 @@ DetectHardware(VOID)
 
   DbgPrint((DPRINT_HWDETECT, "DetectHardware()\n"));
 
-  HalpCalibrateStallExecution ();
-
   /* Create the 'System' key */
   Error = RegCreateKey(NULL,
 		       "\\Registry\\Machine\\HARDWARE\\DESCRIPTION\\System",
@@ -1797,16 +2275,11 @@ DetectHardware(VOID)
   DetectCPUs(SystemKey);
 
   /* Detect buses */
-#if 0
-  DetectPciBios(&BusNumber);
-  DetectApmBios(&BusNumber);
-#endif
+  DetectPciBios(SystemKey, &BusNumber);
+  DetectApmBios(SystemKey, &BusNumber);
   DetectPnpBios(SystemKey, &BusNumber);
   DetectIsaBios(SystemKey, &BusNumber);
-#if 0
-  DetectAcpiBios(&BusNumber);
-#endif
-
+  DetectAcpiBios(SystemKey, &BusNumber);
 
   DbgPrint((DPRINT_HWDETECT, "DetectHardware() Done\n"));
 

freeldr/freeldr/arch/i386/hardware.h

@@ -21,6 +21,10 @@
 #ifndef __I386_HARDWARE_H_
 #define __I386_HARDWARE_H_
 
+#ifndef __REGISTRY_H
+#include "../../reactos/registry.h"
+#endif
+
 typedef enum
 {
   InterfaceTypeUndefined = -1,
@@ -149,10 +153,13 @@ typedef struct _CM_COMPONENT_INFORMATION
 #define Input       0x00000020
 #define Output      0x00000040
 
+#define CONFIG_CMD(bus, dev_fn, where) \
+	(0x80000000 | (((U32)(bus)) << 16) | (((dev_fn) & 0x1F) << 11) | (((dev_fn) & 0xE0) << 3) | ((where) & ~3))
 
 /* PROTOTYPES ***************************************************************/
 
 /* hardware.c */
+VOID HalpCalibrateStallExecution(VOID);
 VOID KeStallExecutionProcessor(U32 Microseconds);
 
 VOID SetComponentInformation(HKEY ComponentKey,
@@ -160,9 +167,18 @@ VOID SetComponentInformation(HKEY ComponentKey,
 			     U32 Key,
 			     U32 Affinity);
 
+/* hwacpi.c */
+VOID DetectAcpiBios(HKEY SystemKey, U32 *BusNumber);
+
+/* hwapm.c */
+VOID DetectApmBios(HKEY SystemKey, U32 *BusNumber);
+
 /* hwcpu.c */
 VOID DetectCPUs(HKEY SystemKey);
 
+/* hwpci.c */
+VOID DetectPciBios(HKEY SystemKey, U32 *BusNumber);
+
 /* i386cpu.S */
 U32 CpuidSupported(VOID);
 VOID GetCpuid(U32 Level,

freeldr/freeldr/arch/i386/hwacpi.c

@@ -0,0 +1,104 @@
+/*
+ *  FreeLoader
+ *
+ *  Copyright (C) 2004  Eric Kohl
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <freeldr.h>
+#include <arch.h>
+#include <rtl.h>
+#include <debug.h>
+#include <mm.h>
+#include <portio.h>
+
+#include "../../reactos/registry.h"
+#include "hardware.h"
+
+
+static BOOL
+FindAcpiBios(VOID)
+{
+  PU8 Ptr;
+
+  /* Find the 'Root System Descriptor Table Pointer' */
+  Ptr = (PU8)0xE0000;
+  while ((U32)Ptr < 0x100000)
+    {
+      if (!memcmp(Ptr, "RSD PTR ", 8))
+	{
+	  DbgPrint((DPRINT_HWDETECT, "ACPI supported\n"));
+
+	  return TRUE;
+	}
+
+      Ptr = (PU8)((U32)Ptr + 0x10);
+    }
+
+  DbgPrint((DPRINT_HWDETECT, "ACPI not supported\n"));
+
+  return FALSE;
+}
+
+
+VOID
+DetectAcpiBios(HKEY SystemKey, U32 *BusNumber)
+{
+  char Buffer[80];
+  HKEY BiosKey;
+  S32 Error;
+
+  if (FindAcpiBios())
+    {
+      /* Create new bus key */
+      sprintf(Buffer,
+	      "MultifunctionAdapter\\%u", *BusNumber);
+      Error = RegCreateKey(SystemKey,
+			   Buffer,
+			   &BiosKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+#if 0
+      /* Set 'Component Information' */
+      SetComponentInformation(BiosKey,
+                              0x0,
+                              0x0,
+                              0xFFFFFFFF);
+#endif
+
+      /* Increment bus number */
+      (*BusNumber)++;
+
+      /* Set 'Identifier' value */
+      Error = RegSetValue(BiosKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)"ACPI BIOS",
+			  10);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/hwapm.c

@@ -0,0 +1,111 @@
+/*
+ *  FreeLoader
+ *
+ *  Copyright (C) 2004  Eric Kohl
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <freeldr.h>
+#include <arch.h>
+#include <rtl.h>
+#include <debug.h>
+#include <mm.h>
+#include <portio.h>
+
+#include "../../reactos/registry.h"
+#include "hardware.h"
+
+
+static BOOL
+FindApmBios(VOID)
+{
+  REGS  RegsIn;
+  REGS  RegsOut;
+
+  RegsIn.b.ah = 0x53;
+  RegsIn.b.al = 0x00;
+  RegsIn.w.bx = 0x0000;
+
+  Int386(0x15, &RegsIn, &RegsOut);
+
+  if (INT386_SUCCESS(RegsOut))
+    {
+      DbgPrint((DPRINT_HWDETECT, "Found APM BIOS\n"));
+      DbgPrint((DPRINT_HWDETECT, "AH: %x\n", RegsOut.b.ah));
+      DbgPrint((DPRINT_HWDETECT, "AL: %x\n", RegsOut.b.al));
+      DbgPrint((DPRINT_HWDETECT, "BH: %x\n", RegsOut.b.bh));
+      DbgPrint((DPRINT_HWDETECT, "BL: %x\n", RegsOut.b.bl));
+      DbgPrint((DPRINT_HWDETECT, "CX: %x\n", RegsOut.w.cx));
+
+      return TRUE;
+    }
+
+  printf("No APM BIOS found\n");
+
+  return FALSE;
+}
+
+
+VOID
+DetectApmBios(HKEY SystemKey, U32 *BusNumber)
+{
+  char Buffer[80];
+  HKEY BiosKey;
+  S32 Error;
+
+  if (FindApmBios())
+    {
+      /* Create new bus key */
+      sprintf(Buffer,
+	      "MultifunctionAdapter\\%u", *BusNumber);
+      Error = RegCreateKey(SystemKey,
+			   Buffer,
+			   &BiosKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+#if 0
+      /* Set 'Component Information' */
+      SetComponentInformation(BiosKey,
+                              0x0,
+                              0x0,
+                              0xFFFFFFFF);
+#endif
+
+      /* Increment bus number */
+      (*BusNumber)++;
+
+      /* Set 'Identifier' value */
+      Error = RegSetValue(BiosKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)"APM",
+			  4);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+    }
+
+  /* FIXME: Add congiguration data */
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/hwcpu.c

@@ -30,7 +30,7 @@
 
 
 #define MP_FP_SIGNATURE 0x5F504D5F	/* "_MP_" */
-#define MP_CT_SIGNATURE 0x504D4350	/* "_MP_" */
+#define MP_CT_SIGNATURE 0x504D4350	/* "PCMP" */
 
 
 typedef struct _MP_FLOATING_POINT_TABLE

freeldr/freeldr/arch/i386/hwpci.c

@@ -0,0 +1,366 @@
+/*
+ *  FreeLoader
+ *
+ *  Copyright (C) 2004  Eric Kohl
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <freeldr.h>
+#include <arch.h>
+#include <rtl.h>
+#include <debug.h>
+#include <mm.h>
+#include <portio.h>
+
+#include "../../reactos/registry.h"
+#include "hardware.h"
+
+typedef struct _ROUTING_SLOT
+{
+  U8  BusNumber;
+  U8  DeviceNumber;
+  U8  LinkA;
+  U16 BitmapA;
+  U8  LinkB;
+  U16 BitmapB;
+  U8  LinkC;
+  U16 BitmapC;
+  U8  LinkD;
+  U16 BitmapD;
+  U8  SlotNumber;
+  U8  Reserved;
+} __attribute__((packed)) ROUTING_SLOT, *PROUTING_SLOT;
+
+typedef struct _PCI_IRQ_ROUTING_TABLE
+{
+  U32 Signature;
+  U16 Version;
+  U16 Size;
+  U8  RouterBus;
+  U8  RouterSlot;
+  U16 ExclusiveIRQs;
+  U32 CompatibleRouter;
+  U32 MiniportData;
+  U8  Reserved[11];
+  U8  Checksum;
+  ROUTING_SLOT Slot[1];
+} __attribute__((packed)) PCI_IRQ_ROUTING_TABLE, *PPCI_IRQ_ROUTING_TABLE;
+
+typedef struct _CM_PCI_BUS_DATA
+{
+  U8  BusCount;
+  U16 PciVersion;
+  U8  HardwareMechanism;
+} __attribute__((packed)) CM_PCI_BUS_DATA, *PCM_PCI_BUS_DATA;
+
+
+static PPCI_IRQ_ROUTING_TABLE
+GetPciIrqRoutingTable(VOID)
+{
+  PPCI_IRQ_ROUTING_TABLE Table;
+  PU8 Ptr;
+  U32 Sum;
+  U32 i;
+
+  Table = (PPCI_IRQ_ROUTING_TABLE)0xF0000;
+  while ((U32)Table < 0x100000)
+    {
+      if (Table->Signature == 0x52495024)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Found signature\n"));
+
+	  Ptr = (PU8)Table;
+	  Sum = 0;
+	  for (i = 0; i < Table->Size; i++)
+	    {
+	      Sum += Ptr[i];
+	    }
+
+	  if ((Sum & 0xFF) != 0)
+	    {
+	      DbgPrint((DPRINT_HWDETECT,
+			"Invalid routing table\n"));
+	      return NULL;
+	    }
+
+	  DbgPrint((DPRINT_HWDETECT,
+		   "Valid checksum\n"));
+
+	  return Table;
+	}
+
+      Table = (PPCI_IRQ_ROUTING_TABLE)((U32)Table + 0x10);
+    }
+
+  return NULL;
+}
+
+
+static BOOL
+FindPciBios(PCM_PCI_BUS_DATA BusData)
+{
+  REGS  RegsIn;
+  REGS  RegsOut;
+
+  RegsIn.b.ah = 0xB1; /* Subfunction B1h */
+  RegsIn.b.al = 0x01; /* PCI BIOS present */
+
+  Int386(0x1A, &RegsIn, &RegsOut);
+
+  if (INT386_SUCCESS(RegsOut) && RegsOut.d.edx == 0x20494350 && RegsOut.b.ah == 0)
+    {
+      DbgPrint((DPRINT_HWDETECT, "Found PCI bios\n"));
+
+      DbgPrint((DPRINT_HWDETECT, "AL: %x\n", RegsOut.b.al));
+      DbgPrint((DPRINT_HWDETECT, "BH: %x\n", RegsOut.b.bh));
+      DbgPrint((DPRINT_HWDETECT, "BL: %x\n", RegsOut.b.bl));
+      DbgPrint((DPRINT_HWDETECT, "CL: %x\n", RegsOut.b.cl));
+
+      BusData->BusCount = RegsOut.b.cl + 1;
+      BusData->PciVersion = RegsOut.w.bx;
+      BusData->HardwareMechanism = RegsOut.b.cl;
+
+      return TRUE;
+    }
+
+
+  DbgPrint((DPRINT_HWDETECT, "No PCI bios found\n"));
+
+  return FALSE;
+}
+
+
+static VOID
+DetectPciIrqRoutingTable(HKEY BusKey)
+{
+  PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
+  PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialDescriptor;
+  PPCI_IRQ_ROUTING_TABLE Table;
+  HKEY TableKey;
+  U32 Size;
+  S32 Error;
+
+  Table = GetPciIrqRoutingTable();
+  if (Table != NULL)
+    {
+      DbgPrint((DPRINT_HWDETECT, "Table size: %u\n", Table->Size));
+
+      Error = RegCreateKey(BusKey,
+			   "RealModeIrqRoutingTable\\0",
+			   &TableKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+      /* Set 'Component Information' */
+      SetComponentInformation(TableKey,
+                              0x0,
+                              0x0,
+                              0xFFFFFFFF);
+
+      /* Set 'Identifier' value */
+      Error = RegSetValue(TableKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)"PCI Real-mode IRQ Routing Table",
+			  32);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+      /* Set 'Configuration Data' value */
+      Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) +
+	     Table->Size;
+      FullResourceDescriptor = MmAllocateMemory(Size);
+      if (FullResourceDescriptor == NULL)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Failed to allocate resource descriptor\n"));
+	  return;
+	}
+
+      /* Initialize resource descriptor */
+      memset(FullResourceDescriptor, 0, Size);
+      FullResourceDescriptor->InterfaceType = Isa;
+      FullResourceDescriptor->BusNumber = 0;
+      FullResourceDescriptor->PartialResourceList.Count = 1;
+
+      PartialDescriptor = &FullResourceDescriptor->PartialResourceList.PartialDescriptors[0];
+      PartialDescriptor->Type = CmResourceTypeDeviceSpecific;
+      PartialDescriptor->ShareDisposition = CmResourceShareUndetermined;
+      PartialDescriptor->u.DeviceSpecificData.DataSize = Table->Size;
+
+      memcpy(((PVOID)FullResourceDescriptor) + sizeof(CM_FULL_RESOURCE_DESCRIPTOR),
+	     Table,
+	     Table->Size);
+
+      /* Set 'Configuration Data' value */
+      Error = RegSetValue(TableKey,
+			  "Configuration Data",
+			  REG_FULL_RESOURCE_DESCRIPTOR,
+			  (PU8) FullResourceDescriptor,
+			  Size);
+      MmFreeMemory(FullResourceDescriptor);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue(Configuration Data) failed (Error %u)\n",
+		    (int)Error));
+	  return;
+	}
+    }
+}
+
+
+VOID
+DetectPciBios(HKEY SystemKey, U32 *BusNumber)
+{
+  PCM_FULL_RESOURCE_DESCRIPTOR FullResourceDescriptor;
+  CM_PCI_BUS_DATA BusData;
+  char Buffer[80];
+  HKEY BiosKey;
+  U32 Size;
+  S32 Error;
+#if 0
+  HKEY BusKey;
+  U32 i;
+#endif
+
+  /* Report the PCI BIOS */
+  if (FindPciBios(&BusData))
+    {
+      /* Create new bus key */
+      sprintf(Buffer,
+	      "MultifunctionAdapter\\%u", *BusNumber);
+      Error = RegCreateKey(SystemKey,
+			   Buffer,
+			   &BiosKey);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+      /* Set 'Component Information' */
+      SetComponentInformation(BiosKey,
+                              0x0,
+                              0x0,
+                              0xFFFFFFFF);
+
+      /* Increment bus number */
+      (*BusNumber)++;
+
+      /* Set 'Identifier' value */
+      Error = RegSetValue(BiosKey,
+			  "Identifier",
+			  REG_SZ,
+			  (PU8)"PCI BIOS",
+			  9);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	  return;
+	}
+
+      /* Set 'Configuration Data' value */
+      Size = sizeof(CM_FULL_RESOURCE_DESCRIPTOR) -
+	     sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
+      FullResourceDescriptor = MmAllocateMemory(Size);
+      if (FullResourceDescriptor == NULL)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "Failed to allocate resource descriptor\n"));
+	  return;
+	}
+
+      /* Initialize resource descriptor */
+      memset(FullResourceDescriptor, 0, Size);
+      FullResourceDescriptor->InterfaceType = Internal;
+      FullResourceDescriptor->BusNumber = 0;
+      FullResourceDescriptor->PartialResourceList.Count = 0;
+
+      /* Set 'Configuration Data' value */
+      Error = RegSetValue(BiosKey,
+			  "Configuration Data",
+			  REG_FULL_RESOURCE_DESCRIPTOR,
+			  (PU8) FullResourceDescriptor,
+			  Size);
+      MmFreeMemory(FullResourceDescriptor);
+      if (Error != ERROR_SUCCESS)
+	{
+	  DbgPrint((DPRINT_HWDETECT,
+		    "RegSetValue(Configuration Data) failed (Error %u)\n",
+		    (int)Error));
+	  return;
+	}
+
+      DetectPciIrqRoutingTable(BiosKey);
+
+#if 0
+      /*
+       * FIXME:
+       * Enabling this piece of code will corrupt the boot sequence!
+       * This is probably caused by a bug in the registry code!
+       */
+
+      /* Report PCI buses */
+      for (i = 0; i < (U32)BusData.BusCount; i++)
+	{
+	  sprintf(Buffer,
+		  "MultifunctionAdapter\\%u", *BusNumber);
+	  Error = RegCreateKey(SystemKey,
+			       Buffer,
+			       &BusKey);
+	  if (Error != ERROR_SUCCESS)
+	    {
+	      DbgPrint((DPRINT_HWDETECT, "RegCreateKey() failed (Error %u)\n", (int)Error));
+	      printf("RegCreateKey() failed (Error %u)\n", (int)Error);
+	      return;
+	    }
+
+	  /* Set 'Component Information' */
+	  SetComponentInformation(BusKey,
+				  0x0,
+				  0x0,
+				  0xFFFFFFFF);
+
+	  /* Increment bus number */
+	  (*BusNumber)++;
+
+
+	  /* Set 'Identifier' value */
+	  Error = RegSetValue(BusKey,
+			      "Identifier",
+			      REG_SZ,
+			      (PU8)"PCI",
+			      4);
+	  if (Error != ERROR_SUCCESS)
+	    {
+	      DbgPrint((DPRINT_HWDETECT, "RegSetValue() failed (Error %u)\n", (int)Error));
+	      return;
+	    }
+	}
+#endif
+
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/i386cpu.S

@@ -38,39 +38,39 @@ EXTERN(_CpuidSupported)
 
 	pushl	%ecx			/* save ECX */
 
-	pushfl					/* push original EFLAGS */
+	pushfl				/* push original EFLAGS */
 	popl	%eax			/* get original EFLAGS */
 	movl	%eax,%ecx		/* save original EFLAGS */
-	xorl	$0x40000,%eax	/* flip AC bit in EFLAGS */
+	xorl	$0x40000,%eax		/* flip AC bit in EFLAGS */
 	pushl	%eax			/* save new EFLAGS value on stack */
-	popfl					/* replace current EFLAGS value */
+	popfl				/* replace current EFLAGS value */
 
-	pushfl					/* get new EFLAGS */
+	pushfl				/* get new EFLAGS */
 	popl	%eax			/* store new EFLAGS in EAX */
 	xorl	%ecx, %eax		/* can't toggle AC bit, processor=80386 */
 
 	movl	$0x300,%eax		/* return processor id */
-    jz		NoCpuid			/* jump if 80386 processor */
+	jz	NoCpuid			/* jump if 80386 processor */
 
 	pushl	%ecx
-	popfl					/* restore AC bit in EFLAGS first */
+	popfl				/* restore AC bit in EFLAGS first */
 
 	movl	%ecx,%eax		/* get original EFLAGS */
-	xorl	$0x200000,%eax	/* flip ID bit in EFLAGS */
+	xorl	$0x200000,%eax		/* flip ID bit in EFLAGS */
 	pushl	%eax			/* save new EFLAGS value on stack */
-	popfl					/* replace current EFLAGS value */
-	pushfl					/* get new EFLAGS */
+	popfl				/* replace current EFLAGS value */
+	pushfl				/* get new EFLAGS */
 	popl	%eax			/* store new EFLAGS in EAX */
 	xorl	%ecx,%eax		/* can't toggle ID bit, */
 
 	movl	$0x400,%eax		/* return processor id */
-	je		NoCpuid			/* processor=80486 */
+	je	NoCpuid			/* processor=80486 */
 
 	movl	$1,%eax			/* CPUID supported */
 
 NoCpuid:
 	pushl	%ecx
-	popfl					/* restore EFLAGS */
+	popfl				/* restore EFLAGS */
 	popl	%ecx			/* retore ECX */
 
 	ret
@@ -97,16 +97,16 @@ EXTERN(_GetCpuid)
 	cpuid
 
 	movl	0x0C(%ebp),%esi
-	movl	%eax, (%esi)
+	movl	%eax,(%esi)
 
 	movl	0x10(%ebp),%esi
-	movl	%ebx, (%esi)
+	movl	%ebx,(%esi)
 
 	movl	0x14(%ebp),%esi
-	movl	%ecx, (%esi)
+	movl	%ecx,(%esi)
 
 	movl	0x18(%ebp),%esi
-	movl	%edx, (%esi)
+	movl	%edx,(%esi)
 
 	popl	%esi
 	popl	%edx

freeldr/freeldr/arch/i386/i386disk.c

@@ -17,259 +17,21 @@
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
-#include <freeldr.h>
-#include <disk.h>
-#include <rtl.h>
-#include <arch.h>
-#include <debug.h>
-#include <portio.h>
+#include "freeldr.h"
+#include "disk.h"
+#include "rtl.h"
+#include "arch.h"
+#include "debug.h"
+#include "portio.h"
+#include "machine.h"
 
 
-typedef struct
-{
-	U8		PacketSize;				// 00h - Size of packet (10h or 18h)
-	U8		Reserved;				// 01h - Reserved (0)
-	U16		LBABlockCount;			// 02h - Number of blocks to transfer (max 007Fh for Phoenix EDD)
-	U16		TransferBufferOffset;	// 04h - Transfer buffer offset (seg:off)
-	U16		TransferBufferSegment;	//       Transfer buffer segment (seg:off)
-	U64		LBAStartBlock;			// 08h - Starting absolute block number
-	U64		TransferBuffer64;		// 10h - (EDD-3.0, optional) 64-bit flat address of transfer buffer
-									//       used if DWORD at 04h is FFFFh:FFFFh
-} PACKED I386_DISK_ADDRESS_PACKET, *PI386_DISK_ADDRESS_PACKET;
-
 /////////////////////////////////////////////////////////////////////////////////////////////
 // FUNCTIONS
 /////////////////////////////////////////////////////////////////////////////////////////////
 
 #ifdef __i386__
 
-BOOL DiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
-{
-
-	DbgPrint((DPRINT_DISK, "DiskReadLogicalSectors() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer));
-
-	//
-	// Check to see if it is a fixed disk drive
-	// If so then check to see if Int13 extensions work
-	// If they do then use them, otherwise default back to BIOS calls
-	//
-	if ((DriveNumber >= 0x80) && DiskInt13ExtensionsSupported(DriveNumber))
-	{
-		DbgPrint((DPRINT_DISK, "Using Int 13 Extensions for read. DiskInt13ExtensionsSupported(%d) = %s\n", DriveNumber, DiskInt13ExtensionsSupported(DriveNumber) ? "TRUE" : "FALSE"));
-
-		//
-		// LBA is easy, nothing to calculate
-		// Just do the read
-		//
-		return DiskReadLogicalSectorsLBA(DriveNumber, SectorNumber, SectorCount, Buffer);
-	}
-	else
-	{
-		// LBA is not supported default to the CHS calls
-		return DiskReadLogicalSectorsCHS(DriveNumber, SectorNumber, SectorCount, Buffer);
-	}
-
-	return TRUE;
-}
-
-BOOL DiskReadLogicalSectorsLBA(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
-{
-	REGS						RegsIn;
-	REGS						RegsOut;
-	U32							RetryCount;
-	PI386_DISK_ADDRESS_PACKET	Packet = (PI386_DISK_ADDRESS_PACKET)(BIOSCALLBUFFER);
-
-	DbgPrint((DPRINT_DISK, "DiskReadLogicalSectorsLBA() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer));
-
-	// BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
-	RegsIn.b.ah = 0x42;					// Subfunction 42h
-	RegsIn.b.dl = DriveNumber;			// Drive number in DL (0 - floppy, 0x80 - harddisk)
-	RegsIn.x.ds = BIOSCALLBUFSEGMENT;	// DS:SI -> disk address packet
-	RegsIn.w.si = BIOSCALLBUFOFFSET;
-
-	// Setup disk address packet
-	RtlZeroMemory(Packet, sizeof(I386_DISK_ADDRESS_PACKET));
-	Packet->PacketSize = sizeof(I386_DISK_ADDRESS_PACKET);
-	Packet->Reserved = 0;
-	Packet->LBABlockCount = SectorCount;
-	Packet->TransferBufferOffset = ((U32)Buffer) & 0x0F;
-	Packet->TransferBufferSegment = ((U32)Buffer) >> 4;
-	Packet->LBAStartBlock = SectorNumber;
-	Packet->TransferBuffer64 = 0;
-
-	// BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
-	// Return:
-	// CF clear if successful
-	// AH = 00h
-	// CF set on error
-	// AH = error code
-	// disk address packet's block count field set to the
-	// number of blocks successfully transferred
-
-	// Retry 3 times
-	for (RetryCount=0; RetryCount<3; RetryCount++)
-	{
-		Int386(0x13, &RegsIn, &RegsOut);
-
-		// If it worked return TRUE
-		if (INT386_SUCCESS(RegsOut))
-		{
-			return TRUE;
-		}
-		// If it was a corrected ECC error then the data is still good
-		else if (RegsOut.b.ah == 0x11)
-		{
-			return TRUE;
-		}
-		// If it failed the do the next retry
-		else
-		{
-			DiskResetController(DriveNumber);
-
-			continue;
-		}
-	}
-
-	// If we get here then the read failed
-	DiskError("Disk Read Failed", RegsOut.b.ah);
-
-	return FALSE;
-}
-
-BOOL DiskReadLogicalSectorsCHS(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
-{
-	U32			PhysicalSector;
-	U32			PhysicalHead;
-	U32			PhysicalTrack;
-	GEOMETRY	DriveGeometry;
-	U32			NumberOfSectorsToRead;
-	REGS		RegsIn;
-	REGS		RegsOut;
-	U32			RetryCount;
-
-	DbgPrint((DPRINT_DISK, "DiskReadLogicalSectorsCHS()\n"));
-
-	//
-	// Get the drive geometry
-	//
-	if (!DiskGetDriveGeometry(DriveNumber, &DriveGeometry))
-	{
-		return FALSE;
-	}
-
-	while (SectorCount)
-	{
-
-		//
-		// Calculate the physical disk offsets
-		//
-		PhysicalSector = 1 + (SectorNumber % DriveGeometry.Sectors);
-		PhysicalHead = (SectorNumber / DriveGeometry.Sectors) % DriveGeometry.Heads;
-		PhysicalTrack = (SectorNumber / DriveGeometry.Sectors) / DriveGeometry.Heads;
-
-		//
-		// Calculate how many sectors we need to read this round
-		//
-		if (PhysicalSector > 1)
-		{
-			if (SectorCount >= (DriveGeometry.Sectors - (PhysicalSector - 1)))
-				NumberOfSectorsToRead = (DriveGeometry.Sectors - (PhysicalSector - 1));
-			else
-				NumberOfSectorsToRead = SectorCount;
-		}
-		else
-		{
-			if (SectorCount >= DriveGeometry.Sectors)
-				NumberOfSectorsToRead = DriveGeometry.Sectors;
-			else
-				NumberOfSectorsToRead = SectorCount;
-		}
-
-		//
-		// Make sure the read is within the geometry boundaries
-		//
-		if ((PhysicalHead >= DriveGeometry.Heads) ||
-			(PhysicalTrack >= DriveGeometry.Cylinders) ||
-			((NumberOfSectorsToRead + PhysicalSector) > (DriveGeometry.Sectors + 1)) ||
-			(PhysicalSector > DriveGeometry.Sectors))
-		{
-			DiskError("Disk read exceeds drive geometry limits.", 0);
-			return FALSE;
-		}
-
-		// BIOS Int 13h, function 2 - Read Disk Sectors
-		// AH = 02h
-		// AL = number of sectors to read (must be nonzero)
-		// CH = low eight bits of cylinder number
-		// CL = sector number 1-63 (bits 0-5)
-		//      high two bits of cylinder (bits 6-7, hard disk only)
-		// DH = head number
-		// DL = drive number (bit 7 set for hard disk)
-		// ES:BX -> data buffer
-		// Return:
-		// CF set on error
-		// if AH = 11h (corrected ECC error), AL = burst length
-		// CF clear if successful
-		// AH = status
-		// AL = number of sectors transferred
-		//  (only valid if CF set for some BIOSes)
-		RegsIn.b.ah = 0x02;
-		RegsIn.b.al = NumberOfSectorsToRead;
-		RegsIn.b.ch = (PhysicalTrack & 0xFF);
-		RegsIn.b.cl = (PhysicalSector + ((PhysicalTrack & 0x300) >> 2));
-		RegsIn.b.dh = PhysicalHead;
-		RegsIn.b.dl = DriveNumber;
-		RegsIn.w.es = ((U32)Buffer) >> 4;
-		RegsIn.w.bx = ((U32)Buffer) & 0x0F;
-
-		//
-		// Perform the read
-		// Retry 3 times
-		//
-		for (RetryCount=0; RetryCount<3; RetryCount++)
-		{
-			Int386(0x13, &RegsIn, &RegsOut);
-
-			// If it worked break out
-			if (INT386_SUCCESS(RegsOut))
-			{
-				break;
-			}
-			// If it was a corrected ECC error then the data is still good
-			else if (RegsOut.b.ah == 0x11)
-			{
-				break;
-			}
-			// If it failed the do the next retry
-			else
-			{
-				DiskResetController(DriveNumber);
-
-				continue;
-			}
-		}
-
-		// If we retried 3 times then fail
-		if (RetryCount >= 3)
-		{
-			DiskError("Disk Read Failed", RegsOut.b.ah);
-			return FALSE;
-		}
-
-		// I have learned that not all bioses return
-		// the sector read count in the AL register (at least mine doesn't)
-		// even if the sectors were read correctly. So instead
-		// of checking the sector read count we will rely solely
-		// on the carry flag being set on error
-
-		Buffer += (NumberOfSectorsToRead * DriveGeometry.BytesPerSector);
-		SectorCount -= NumberOfSectorsToRead;
-		SectorNumber += NumberOfSectorsToRead;
-	}
-
-	return TRUE;
-}
-
 BOOL DiskResetController(U32 DriveNumber)
 {
 	REGS	RegsIn;
@@ -371,55 +133,6 @@ VOID DiskStopFloppyMotor(VOID)
 	WRITE_PORT_UCHAR((PUCHAR)0x3F2, 0);
 }
 
-BOOL DiskGetDriveParameters(U32 DriveNumber, PGEOMETRY Geometry)
-{
-	REGS	RegsIn;
-	REGS	RegsOut;
-	U32		Cylinders;
-
-	DbgPrint((DPRINT_DISK, "DiskGetDriveParameters()\n"));
-
-	// BIOS Int 13h, function 08h - Get drive parameters
-	// AH = 08h
-	// DL = drive (bit 7 set for hard disk)
-	// ES:DI = 0000h:0000h to guard against BIOS bugs
-	// Return:
-	// CF set on error
-	// AH = status (07h)
-	// CF clear if successful
-	// AH = 00h
-	// AL = 00h on at least some BIOSes
-	// BL = drive type (AT/PS2 floppies only)
-	// CH = low eight bits of maximum cylinder number
-	// CL = maximum sector number (bits 5-0)
-	//      high two bits of maximum cylinder number (bits 7-6)
-	// DH = maximum head number
-	// DL = number of drives
-	// ES:DI -> drive parameter table (floppies only)
-	RegsIn.b.ah = 0x08;
-	RegsIn.b.dl = DriveNumber;
-	RegsIn.w.es = 0x0000;
-	RegsIn.w.di = 0x0000;
-
-	// Get drive parameters
-	Int386(0x13, &RegsIn, &RegsOut);
-
-	if (!INT386_SUCCESS(RegsOut))
-	{
-		return FALSE;
-	}
-
-	Cylinders = (RegsOut.b.cl & 0xC0) << 2;
-	Cylinders += RegsOut.b.ch;
-	Cylinders++;
-	Geometry->Cylinders = Cylinders;
-	Geometry->Heads = RegsOut.b.dh + 1;
-	Geometry->Sectors = RegsOut.b.cl & 0x3F;
-	Geometry->BytesPerSector = 512;				// Just assume 512 bytes per sector
-
-	return TRUE;
-}
-
 BOOL DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSize)
 {
 	REGS	RegsIn;
@@ -459,29 +172,4 @@ BOOL DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSiz
 	return TRUE;
 }
 
-
-
-U32 DiskGetCacheableBlockCount(U32 DriveNumber)
-{
-	GEOMETRY	Geometry;
-
-	// Get the disk geometry
-	// If this fails then we will just return 1 sector to be safe
-	if (!DiskGetDriveParameters(DriveNumber, &Geometry))
-	{
-		return 1;
-	}
-
-	// If LBA is supported then the block size will be 64 sectors (32k)
-	// If not then the block size is the size of one track
-	if (DiskInt13ExtensionsSupported(DriveNumber))
-	{
-		return 64;
-	}
-	else
-	{
-		return Geometry.Sectors;
-	}
-}
-
 #endif // defined __i386__

freeldr/freeldr/arch/i386/i386mem.c

@@ -1,216 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <freeldr.h>
-#include <arch.h>
-#include <mm.h>
-#include <debug.h>
-#include <rtl.h>
-#include <portio.h>
-
-
-U32 GetExtendedMemorySize(VOID)
-{
-	REGS	RegsIn;
-	REGS	RegsOut;
-	U32		MemorySize;
-
-	DbgPrint((DPRINT_MEMORY, "GetExtendedMemorySize()\n"));
-
-	// Int 15h AX=E801h
-	// Phoenix BIOS v4.0 - GET MEMORY SIZE FOR >64M CONFIGURATIONS
-	//
-	// AX = E801h
-	// Return:
-	// CF clear if successful
-	// AX = extended memory between 1M and 16M, in K (max 3C00h = 15MB)
-	// BX = extended memory above 16M, in 64K blocks
-	// CX = configured memory 1M to 16M, in K
-	// DX = configured memory above 16M, in 64K blocks
-	// CF set on error
-	RegsIn.w.ax = 0xE801;
-	Int386(0x15, &RegsIn, &RegsOut);
-
-	DbgPrint((DPRINT_MEMORY, "Int15h AX=E801h\n"));
-	DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n", RegsOut.w.ax));
-	DbgPrint((DPRINT_MEMORY, "BX = 0x%x\n", RegsOut.w.bx));
-	DbgPrint((DPRINT_MEMORY, "CX = 0x%x\n", RegsOut.w.cx));
-	DbgPrint((DPRINT_MEMORY, "DX = 0x%x\n", RegsOut.w.dx));
-	DbgPrint((DPRINT_MEMORY, "CF set = %s\n\n", (RegsOut.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
-
-	if (INT386_SUCCESS(RegsOut))
-	{
-		// If AX=BX=0000h the use CX and DX
-		if (RegsOut.w.ax == 0)
-		{
-			// Return extended memory size in K
-			MemorySize = RegsOut.w.dx * 64;
-			MemorySize += RegsOut.w.cx;
-			return MemorySize;
-		}
-		else
-		{
-			// Return extended memory size in K
-			MemorySize = RegsOut.w.bx * 64;
-			MemorySize += RegsOut.w.ax;
-			return MemorySize;
-		}
-	}
-
-	// If we get here then Int15 Func E801h didn't work
-	// So try Int15 Func 88h
-
-	// Int 15h AH=88h
-	// SYSTEM - GET EXTENDED MEMORY SIZE (286+)
-	//
-	// AH = 88h
-	// Return:
-	// CF clear if successful
-	// AX = number of contiguous KB starting at absolute address 100000h
-	// CF set on error
-	// AH = status
-	// 80h invalid command (PC,PCjr)
-	// 86h unsupported function (XT,PS30)
-	RegsIn.b.ah = 0x88;
-	Int386(0x15, &RegsIn, &RegsOut);
-
-	DbgPrint((DPRINT_MEMORY, "Int15h AH=88h\n"));
-	DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n", RegsOut.w.ax));
-	DbgPrint((DPRINT_MEMORY, "CF set = %s\n\n", (RegsOut.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
-
-	if (INT386_SUCCESS(RegsOut) && RegsOut.w.ax != 0)
-	{
-		MemorySize = RegsOut.w.ax;
-		return MemorySize;
-	}
-
-	// If we get here then Int15 Func 88h didn't work
-	// So try reading the CMOS
-	WRITE_PORT_UCHAR((PUCHAR)0x70, 0x31);
-	MemorySize = READ_PORT_UCHAR((PUCHAR)0x71);
-	MemorySize = (MemorySize & 0xFFFF);
-	MemorySize = (MemorySize << 8);
-
-	DbgPrint((DPRINT_MEMORY, "Int15h Failed\n"));
-	DbgPrint((DPRINT_MEMORY, "CMOS reports: 0x%x\n", MemorySize));
-
-	return MemorySize;
-}
-
-U32 GetConventionalMemorySize(VOID)
-{
-	REGS	Regs;
-
-	DbgPrint((DPRINT_MEMORY, "GetConventionalMemorySize()\n"));
-
-	// Int 12h
-	// BIOS - GET MEMORY SIZE
-	//
-	// Return:
-	// AX = kilobytes of contiguous memory starting at absolute address 00000h
-	//
-	// This call returns the contents of the word at 0040h:0013h;
-	// in PC and XT, this value is set from the switches on the motherboard
-	Regs.w.ax = 0;
-	Int386(0x12, &Regs, &Regs);
-
-	DbgPrint((DPRINT_MEMORY, "Int12h\n"));
-	DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n\n", Regs.w.ax));
-
-	return (U32)Regs.w.ax;
-}
-
-U32 GetBiosMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize)
-{
-	REGS	Regs;
-	U32		MapCount;
-
-	DbgPrint((DPRINT_MEMORY, "GetBiosMemoryMap()\n"));
-
-	// Int 15h AX=E820h
-	// Newer BIOSes - GET SYSTEM MEMORY MAP
-	//
-	// AX = E820h
-	// EAX = 0000E820h
-	// EDX = 534D4150h ('SMAP')
-	// EBX = continuation value or 00000000h to start at beginning of map
-	// ECX = size of buffer for result, in bytes (should be >= 20 bytes)
-	// ES:DI -> buffer for result
-	// Return:
-	// CF clear if successful
-	// EAX = 534D4150h ('SMAP')
-	// ES:DI buffer filled
-	// EBX = next offset from which to copy or 00000000h if all done
-	// ECX = actual length returned in bytes
-	// CF set on error
-	// AH = error code (86h)
-	Regs.x.eax = 0x0000E820;
-	Regs.x.edx = 0x534D4150; // ('SMAP')
-	Regs.x.ebx = 0x00000000;
-	Regs.x.ecx = sizeof(BIOS_MEMORY_MAP);
-	Regs.w.es = BIOSCALLBUFSEGMENT;
-	Regs.w.di = BIOSCALLBUFOFFSET;
-	for (MapCount=0; MapCount<MaxMemoryMapSize; MapCount++)
-	{
-		Int386(0x15, &Regs, &Regs);
-
-		DbgPrint((DPRINT_MEMORY, "Memory Map Entry %d\n", MapCount));
-		DbgPrint((DPRINT_MEMORY, "Int15h AX=E820h\n"));
-		DbgPrint((DPRINT_MEMORY, "EAX = 0x%x\n", Regs.x.eax));
-		DbgPrint((DPRINT_MEMORY, "EBX = 0x%x\n", Regs.x.ebx));
-		DbgPrint((DPRINT_MEMORY, "ECX = 0x%x\n", Regs.x.ecx));
-		DbgPrint((DPRINT_MEMORY, "CF set = %s\n", (Regs.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
-
-		// If the BIOS didn't return 'SMAP' in EAX then
-		// it doesn't support this call
-		if (Regs.x.eax != 0x534D4150)
-		{
-			break;
-		}
-
-		// Copy data to caller's buffer
-		RtlCopyMemory(&BiosMemoryMap[MapCount], (PVOID)BIOSCALLBUFFER, Regs.x.ecx);
-
-		DbgPrint((DPRINT_MEMORY, "BaseAddress: 0x%x%x\n", BiosMemoryMap[MapCount].BaseAddress));
-		DbgPrint((DPRINT_MEMORY, "Length: 0x%x%x\n", BiosMemoryMap[MapCount].Length));
-		DbgPrint((DPRINT_MEMORY, "Type: 0x%x\n", BiosMemoryMap[MapCount].Type));
-		DbgPrint((DPRINT_MEMORY, "Reserved: 0x%x\n", BiosMemoryMap[MapCount].Reserved));
-		DbgPrint((DPRINT_MEMORY, "\n"));
-
-		// If the continuation value is zero or the
-		// carry flag is set then this was
-		// the last entry so we're done
-		if (Regs.x.ebx == 0x00000000 || !INT386_SUCCESS(Regs))
-		{
-			MapCount++;
-			DbgPrint((DPRINT_MEMORY, "End Of System Memory Map!\n\n"));
-			break;
-		}
-
-		// Setup the registers for the next call
-		Regs.x.eax = 0x0000E820;
-		Regs.x.edx = 0x534D4150; // ('SMAP')
-		//Regs.x.ebx = 0x00000001; // Continuation value already set by the BIOS
-		Regs.x.ecx = sizeof(BIOS_MEMORY_MAP);
-		Regs.w.es = BIOSCALLBUFSEGMENT;
-		Regs.w.di = BIOSCALLBUFOFFSET;
-	}
-
-	return MapCount;
-}

freeldr/freeldr/arch/i386/i386rtl.c

@@ -22,312 +22,6 @@
 #include <rtl.h>
 #include <portio.h>
 
-void putchar(int ch)
-{
-	REGS	Regs;
-
-	/* If we are displaying a CR '\n' then do a LF also */
-	if (ch == '\n')
-	{
-		/* Display the LF */
-		putchar('\r');
-	}
-
-	/* If we are displaying a TAB '\t' then display 8 spaces ' ' */
-	if (ch == '\t')
-	{
-		/* Display the 8 spaces ' ' */
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		putchar(' ');
-		return;
-	}
-
-	// Int 10h AH=0Eh
-	// VIDEO - TELETYPE OUTPUT
-	//
-	// AH = 0Eh
-	// AL = character to write
-	// BH = page number
-	// BL = foreground color (graphics modes only)
-	Regs.b.ah = 0x0E;
-	Regs.b.al = ch;
-	Regs.w.bx = 1;
-	Int386(0x10, &Regs, &Regs);
-}
-
-int kbhit(void)
-{
-	REGS	Regs;
-
-	// Int 16h AH=01h
-	// KEYBOARD - CHECK FOR KEYSTROKE
-	//
-	// AH = 01h
-	// Return:
-	// ZF set if no keystroke available
-	// ZF clear if keystroke available
-	// AH = BIOS scan code
-	// AL = ASCII character
-	Regs.b.ah = 0x01;
-	Int386(0x16, &Regs, &Regs);
-
-	if (Regs.x.eflags & I386FLAG_ZF)
-	{
-		return 0;
-	}
-
-	return 1;
-}
-
-int getch(void)
-{
-	REGS	Regs;
-	static BOOL		ExtendedKey = FALSE;
-	static char		ExtendedScanCode = 0;
-
-	// If the last time we were called an
-	// extended key was pressed then return
-	// that keys scan code.
-	if (ExtendedKey)
-	{
-		ExtendedKey = FALSE;
-		return ExtendedScanCode;
-	}
-
-	// Int 16h AH=00h
-	// KEYBOARD - GET KEYSTROKE
-	//
-	// AH = 00h
-	// Return:
-	// AH = BIOS scan code
-	// AL = ASCII character
-	Regs.b.ah = 0x00;
-	Int386(0x16, &Regs, &Regs);
-
-	// Check for an extended keystroke
-	if (Regs.b.al == 0)
-	{
-		ExtendedKey = TRUE;
-		ExtendedScanCode = Regs.b.ah;
-	}
-
-	// Return keystroke
-	return Regs.b.al;
-}
-
-int getyear(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-	U16		Cent1;
-	U16		Cent2;
-	U16		Year;
-
-	// Some BIOSes, such es the 1998/07/25 system ROM
-	// in the Compaq Deskpro EP/SB, leave CF unchanged
-	// if successful, so CF should be cleared before
-	// calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=04h
-	// TIME - GET REAL-TIME CLOCK DATE (AT,XT286,PS)
-	//
-	// AH = 04h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = century (BCD)
-	// CL = year (BCD)
-	// DH = month (BCD)
-	// DL = day (BCD)
-	// CF set on error
-	Regs.b.ah = 0x04;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.cl & 0x0F;
-	Digit2 = ((Regs.b.cl >> 4) & 0x0F) * 10;
-	Cent1 = Regs.b.ch & 0x0F;
-	Cent2 = ((Regs.b.ch >> 4) & 0x0F) * 10;
-
-	Year = Cent1 + Cent2;
-	Year *= 100;
-	Year += Digit1 + Digit2;
-
-	return Year;
-}
-
-int getday(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-
-	// Some BIOSes, such es the 1998/07/25 system ROM
-	// in the Compaq Deskpro EP/SB, leave CF unchanged
-	// if successful, so CF should be cleared before
-	// calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=04h
-	// TIME - GET REAL-TIME CLOCK DATE (AT,XT286,PS)
-	//
-	// AH = 04h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = century (BCD)
-	// CL = year (BCD)
-	// DH = month (BCD)
-	// DL = day (BCD)
-	// CF set on error
-	Regs.b.ah = 0x04;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.dl & 0x0F;
-	Digit2 = ((Regs.b.dl >> 4) & 0x0F) * 10;
-
-	return (Digit1 + Digit2);
-}
-
-int getmonth(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-
-	// Some BIOSes, such es the 1998/07/25 system ROM
-	// in the Compaq Deskpro EP/SB, leave CF unchanged
-	// if successful, so CF should be cleared before
-	// calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=04h
-	// TIME - GET REAL-TIME CLOCK DATE (AT,XT286,PS)
-	//
-	// AH = 04h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = century (BCD)
-	// CL = year (BCD)
-	// DH = month (BCD)
-	// DL = day (BCD)
-	// CF set on error
-	Regs.b.ah = 0x04;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.dh & 0x0F;
-	Digit2 = ((Regs.b.dh >> 4) & 0x0F) * 10;
-
-	return (Digit1 + Digit2);
-}
-
-int gethour(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-
-	// Some BIOSes leave CF unchanged if successful,
-	// so CF should be cleared before calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=02h
-	// TIME - GET REAL-TIME CLOCK TIME (AT,XT286,PS)
-	//
-	// AH = 02h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = hour (BCD)
-	// CL = minutes (BCD)
-	// DH = seconds (BCD)
-	// DL = daylight savings flag (00h standard time, 01h daylight time)
-	// CF set on error (i.e. clock not running or in middle of update)
-	Regs.b.ah = 0x02;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.ch & 0x0F;
-	Digit2 = ((Regs.b.ch >> 4) & 0x0F) * 10;
-
-	return (Digit1 + Digit2);
-}
-
-int getminute(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-
-	// Some BIOSes leave CF unchanged if successful,
-	// so CF should be cleared before calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=02h
-	// TIME - GET REAL-TIME CLOCK TIME (AT,XT286,PS)
-	//
-	// AH = 02h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = hour (BCD)
-	// CL = minutes (BCD)
-	// DH = seconds (BCD)
-	// DL = daylight savings flag (00h standard time, 01h daylight time)
-	// CF set on error (i.e. clock not running or in middle of update)
-	Regs.b.ah = 0x02;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.cl & 0x0F;
-	Digit2 = ((Regs.b.cl >> 4) & 0x0F) * 10;
-
-	return (Digit1 + Digit2);
-}
-
-int getsecond(void)
-{
-	REGS	Regs;
-	U16		Digit1;
-	U16		Digit2;
-
-	// Some BIOSes leave CF unchanged if successful,
-	// so CF should be cleared before calling this function.
-	__asm__ ("clc");
-
-	// Int 1Ah AH=02h
-	// TIME - GET REAL-TIME CLOCK TIME (AT,XT286,PS)
-	//
-	// AH = 02h
-	// CF clear to avoid bug
-	// Return:
-	// CF clear if successful
-	// CH = hour (BCD)
-	// CL = minutes (BCD)
-	// DH = seconds (BCD)
-	// DL = daylight savings flag (00h standard time, 01h daylight time)
-	// CF set on error (i.e. clock not running or in middle of update)
-	Regs.b.ah = 0x02;
-	Int386(0x1A, &Regs, &Regs);
-
-	/* Convert from BCD to normal */
-	Digit1 = Regs.b.dh & 0x0F;
-	Digit2 = ((Regs.b.dh >> 4) & 0x0F) * 10;
-
-	return (Digit1 + Digit2);
-}
-
 void beep(void)
 {
 	sound(700);

freeldr/freeldr/arch/i386/i386trap.S

@@ -24,7 +24,7 @@
 #include <arch.h>
 #include <version.h>
 
-
+#define SCREEN_ATTR 0x1f			/* Bright white on blue background */
 
 .macro SAVE_CPU_REGS
 	movl	%eax,i386_EAX
@@ -80,11 +80,10 @@
 
 
 i386ExceptionHandlerText:
-	.ascii "FreeLoader i386 Exception Handler\n"
+	.ascii "An error occured in FreeLoader\n"
 	.ascii VERSION
 	.ascii "\n"
-//	.asciz "Report bugs to Brian Palmer <brianp@reactos.org>\n\n"
-	.asciz "Report bugs to ReactOS Kernel mailing list <ros-kernel@reactos.com>\n\n"
+	.asciz "Report this error to the ReactOS Development mailing list <ros-dev@reactos.com>\n\n"
 
 i386DivideByZeroText:
 	.asciz "Exception 00: DIVIDE BY ZERO\n\n"
@@ -188,6 +187,9 @@ i386_LDTR_Text:
 i386_TR_Text:
 	.asciz " TR: "
 
+i386FramesText:
+	.asciz "Frames:\n"
+
 /* Set by each exception handler to the address of the description text */
 i386ExceptionDescriptionText:
 	.long	0
@@ -270,7 +272,9 @@ i386CommonExceptionHandler:
 
 	SAVE_CPU_REGS
 
-	call	i386ClearScreenToBlue
+	pushl	$SCREEN_ATTR
+	call	_MachVideoClearScreen
+	add	$4,%esp
 
 	movl	$i386ExceptionHandlerText,%esi
 	call	i386PrintText
@@ -436,21 +440,53 @@ i386CommonExceptionHandler:
 	movl	$0,i386_ScreenPosX
 	incl	i386_ScreenPosY
 	incl	i386_ScreenPosY
+	call	i386PrintFrames						// Display frames
+	incl	i386_ScreenPosY
+	incl	i386_ScreenPosY
 
+	cli
 i386ExceptionHandlerHang:
-	jmp		i386ExceptionHandlerHang
+	hlt
+	jmp	i386ExceptionHandlerHang
 
 	iret
 
+i386PrintFrames:
+	movl	$0,i386_ScreenPosX
+	movl	$i386FramesText,%esi
+	call	i386PrintText
+
+	movl	i386_EBP,%edi
+printnextframe:
+	test	%edi,%edi
+	je	nomoreframes
+	movl	$STACK32ADDR,%eax
+	cmpl	%edi,%eax
+	jbe	nomoreframes
+	movl	4(%edi),%eax
+	pushl	%edi
+	call	i386PrintHexDword					// Display frame
+	popl	%edi
+	incl	i386_ScreenPosX
+	incl	i386_ScreenPosX
+	movl	0(%edi),%edi
+	jmp	printnextframe
+nomoreframes:
+	ret
+
 /************************************************************************/
-i386ClearScreenToBlue:
+/* AL = Char to display                                                 */
+/************************************************************************/
+i386PrintChar:
 	.code32
 
-	cld
-	movw	$0x1F20,%ax
-	movl	$0xB0000,%edi
-	movl	$0x8000,%ecx
-	rep stosw
+	pushl	i386_ScreenPosY
+	pushl	i386_ScreenPosX
+	pushl	$SCREEN_ATTR
+	andl	$0xff,%eax
+	pushl	%eax
+	call	_MachVideoPutChar
+	addl	$16,%esp
 
 	ret
 
@@ -464,48 +500,26 @@ i386PrintTextLoop:
 	lodsb
 
 	// Check for end of string char
-	cmp		$0,%al
-	je		i386PrintTextDone
+	cmp	$0,%al
+	je	i386PrintTextDone
 
 	// Check for newline char
-	cmp		$0x0a,%al
-	jne		i386PrintTextLoop2
+	cmp	$0x0a,%al
+	jne	i386PrintTextLoop2
 	incl	i386_ScreenPosY
 	movl	$0,i386_ScreenPosX
-	jmp		i386PrintTextLoop
+	jmp	i386PrintTextLoop
 
 i386PrintTextLoop2:
-	call	i386PrintTextCalcAddressOfNextChar
-
-	stosb
+	call	i386PrintChar
 	incl	i386_ScreenPosX
 
-	jmp		i386PrintTextLoop
+	jmp	i386PrintTextLoop
 
 i386PrintTextDone:
 	
 	ret
 
-/************************************************************************/
-/* On return EDI = Address of next char in screen memory                */
-/************************************************************************/
-i386PrintTextCalcAddressOfNextChar:
-	.code32
-
-	push	%eax
-
-	movl	$0xB8000,%edi
-	addl	i386_ScreenPosX,%edi
-	addl	i386_ScreenPosX,%edi
-	movl	i386_ScreenPosY,%eax
-	movl	$160,%ecx				// 80 columns, 2 bytes per column
-	mull	%ecx
-	addl	%eax,%edi
-
-	pop		%eax
-
-	ret
-
 /************************************************************************/
 /* Prints the value in EAX on the screen in hex                         */
 /************************************************************************/
@@ -525,8 +539,7 @@ i386PrintHex3:
 	andb	$0x0f,%al
 	movl	$i386PrintHexTable,%ebx
 	xlat	/*$i386PrintHexTable*/
-	call	i386PrintTextCalcAddressOfNextChar
-	stosb
+	call	i386PrintChar
 	incl	i386_ScreenPosX
 	pop		%eax
 
@@ -551,10 +564,9 @@ i386PrintHexWord2:
 	andb	$0x0f,%al
 	movl	$i386PrintHexTable,%ebx
 	xlat	/*$i386PrintHexTable*/
-	call	i386PrintTextCalcAddressOfNextChar
-	stosb
+	call	i386PrintChar
 	incl	i386_ScreenPosX
-	pop		%eax
+	pop	%eax
 
 	ret
 
@@ -572,8 +584,7 @@ i386PrintHexByte1:
 	andb	$0x0f,%al
 	movl	$i386PrintHexTable,%ebx
 	xlat	/*$i386PrintHexTable*/
-	call	i386PrintTextCalcAddressOfNextChar
-	stosb
+	call	i386PrintChar
 	incl	i386_ScreenPosX
 	pop		%eax
 

freeldr/freeldr/arch/i386/i386vid.c

@@ -90,59 +90,6 @@ typedef struct
 // only AX=4F00h; this case may be assumed if the list of supported video modes
 // is empty (consisting of a single word of FFFFh) 
 
-
-VOID BiosSetVideoMode(U32 VideoMode)
-{
-	REGS	Regs;
-
-	// Int 10h AH=00h
-	// VIDEO - SET VIDEO MODE
-	//
-	// AH = 00h
-	// AL = desired video mode
-	// Return:
-	// AL = video mode flag (Phoenix, AMI BIOS)
-	// 20h mode > 7
-	// 30h modes 0-5 and 7
-	// 3Fh mode 6
-	// AL = CRT controller mode byte (Phoenix 386 BIOS v1.10)
-	Regs.b.ah = 0x00;
-	Regs.b.al = VideoMode;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosSetVideoFont8x8(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AX=1112h
-	// VIDEO - TEXT-MODE CHARGEN - LOAD ROM 8x8 DBL-DOT PATTERNS (PS,EGA,VGA)
-	//
-	// AX = 1112h
-	// BL = block to load
-	// Return:
-	// Nothing
-	Regs.w.ax = 0x1112;
-	Regs.b.bl = 0x00;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosSetVideoFont8x14(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AX=1111h
-	// VIDEO - TEXT-MODE CHARGEN - LOAD ROM MONOCHROME PATTERNS (PS,EGA,VGA)
-	//
-	// AX = 1111h
-	// BL = block to load
-	// Return:
-	// Nothing
-	Regs.w.ax = 0x1111;
-	Regs.b.bl = 0;
-	Int386(0x10, &Regs, &Regs);
-}
-
 VOID BiosSetVideoFont8x16(VOID)
 {
 	REGS	Regs;
@@ -159,289 +106,8 @@ VOID BiosSetVideoFont8x16(VOID)
 	Int386(0x10, &Regs, &Regs);
 }
 
-VOID BiosSelectAlternatePrintScreen(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AH=12h BL=20h
-	// VIDEO - ALTERNATE FUNCTION SELECT (PS,EGA,VGA,MCGA) - ALTERNATE PRTSC
-	//
-	// AH = 12h
-	// BL = 20h select alternate print screen routine
-	// Return:
-	// Nothing
-	//
-	// Installs a PrtSc routine from the video card's BIOS to replace the
-	// default PrtSc handler from the ROM BIOS, which usually does not
-	// understand screen heights other than 25 lines.
-	//
-	// Some adapters disable print-screen instead of enhancing it.
-	Regs.b.ah = 0x12;
-	Regs.b.bl = 0x20;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosDisableCursorEmulation(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AH=12h BL=34h
-	// VIDEO - ALTERNATE FUNCTION SELECT (VGA) - CURSOR EMULATION
-	//
-	// AH = 12h
-	// BL = 34h
-	// AL = new state
-	// 00h enable alphanumeric cursor emulation
-	// 01h disable alphanumeric cursor emulation
-	// Return:
-	// AL = 12h if function supported
-	//
-	// Specify whether the BIOS should automatically remap cursor start/end
-	// according to the current character height in text modes.
-	Regs.b.ah = 0x12;
-	Regs.b.bl = 0x34;
-	Regs.b.al = 0x01;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosDefineCursor(U32 StartScanLine, U32 EndScanLine)
-{
-	REGS	Regs;
-
-	// Int 10h AH=01h
-	// VIDEO - SET TEXT-MODE CURSOR SHAPE
-	//
-	// AH = 01h
-	// CH = cursor start and options
-	// CL = bottom scan line containing cursor (bits 0-4)
-	// Return:
-	// Nothing
-	//
-	// Specify the starting and ending scan lines to be occupied
-	// by the hardware cursor in text modes.
-	//
-	// AMI 386 BIOS and AST Premier 386 BIOS will lock up the
-	// system if AL is not equal to the current video mode.
-	//
-	// Bitfields for cursor start and options:
-	//
-	// Bit(s)    Description
-	// 7         should be zero
-	// 6,5       cursor blink
-	// (00=normal, 01=invisible, 10=erratic, 11=slow).
-	// (00=normal, other=invisible on EGA/VGA)
-	// 4-0       topmost scan line containing cursor
-	Regs.b.ah = 0x01;
-	Regs.b.al = 0x03;
-	Regs.b.ch = StartScanLine;
-	Regs.b.cl = EndScanLine;
-	Int386(0x10, &Regs, &Regs);
-}
-
-U32 BiosDetectVideoCard(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AH=12h BL=10h
-	// VIDEO - ALTERNATE FUNCTION SELECT (PS,EGA,VGA,MCGA) - GET EGA INFO
-	//
-	// AH = 12h
-	// BL = 10h
-	// Return:
-	// BH = video state
-	// 00h color mode in effect (I/O port 3Dxh)
-	// 01h mono mode in effect (I/O port 3Bxh)
-	// BL = installed memory (00h = 64K, 01h = 128K, 02h = 192K, 03h = 256K)
-	// CH = feature connector bits
-	// CL = switch settings
-	// AH destroyed (at least by Tseng ET4000 BIOS v8.00n)
-	//
-	// Installation check;EGA
-	Regs.b.ah = 0x12;
-	Regs.b.bl = 0x10;
-	Int386(0x10, &Regs, &Regs);
-
-	// If BL is still equal to 0x10 then there is no EGA/VGA present
-	if (Regs.b.bl == 0x10)
-	{
-		return VIDEOCARD_CGA_OR_OTHER;
-	}
-
-	// Int 10h AX=1A00h
-	// VIDEO - GET DISPLAY COMBINATION CODE (PS,VGA/MCGA)
-	//
-	// AX = 1A00h
-	// Return:
-	// AL = 1Ah if function was supported
-	// BL = active display code
-	// BH = alternate display code
-	//
-	// This function is commonly used to check for the presence of a VGA.
-	//
-	// Installation check;VGA
-	//
-	// Values for display combination code:
-	// 00h    no display
-	// 01h    monochrome adapter w/ monochrome display
-	// 02h    CGA w/ color display
-	// 03h    reserved
-	// 04h    EGA w/ color display
-	// 05h    EGA w/ monochrome display
-	// 06h    PGA w/ color display
-	// 07h    VGA w/ monochrome analog display
-	// 08h    VGA w/ color analog display
-	// 09h    reserved
-	// 0Ah    MCGA w/ digital color display
-	// 0Bh    MCGA w/ monochrome analog display
-	// 0Ch    MCGA w/ color analog display
-	// FFh    unknown display type
-	Regs.b.ah = 0x12;
-	Regs.b.bl = 0x10;
-	Int386(0x10, &Regs, &Regs);
-
-	if (Regs.b.al == 0x1A)
-	{
-		return VIDEOCARD_VGA;
-	}
-	else
-	{
-		return VIDEOCARD_EGA;
-	}
-}
-
-VOID BiosSetVerticalResolution(U32 ScanLines)
-{
-	REGS	Regs;
-
-	// Int 10h AH=12h BL=30h
-	// VIDEO - ALTERNATE FUNCTION SELECT (VGA) - SELECT VERTICAL RESOLUTION
-	//
-	// AH = 12h
-	// BL = 30h
-	// AL = vertical resolution
-	// 00h 200 scan lines
-	// 01h 350 scan lines
-	// 02h 400 scan lines
-	// Return:
-	// AL = 12h if function supported
-	//
-	// Specifiy the number of scan lines used to display text modes.
-	//
-	// The specified resolution will take effect on the next mode set.
-	Regs.b.ah = 0x12;
-	Regs.b.bl = 0x30;
-	Regs.b.al = ScanLines;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosSet480ScanLines(VOID)
-{
-	int	CRTC;
-
-	// Read CRTC port
-	CRTC = READ_PORT_UCHAR((PUCHAR)0x03CC);
-
-	if (CRTC & 1)
-	{
-		CRTC = 0x3D4;
-	}
-	else
-	{
-		CRTC = 0x3B4;
-	}
-
-	// Vertical sync end (also unlocks CR0-7)
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x11);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0x0C);
-
-	// Vertical total
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x06);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0x0B);
-
-	// (vertical) overflow
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x07);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0x3E);
-
-	// Vertical sync start
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x10);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0xEA);
-
-	// Vertical display end
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x12);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0xDF);
-
-	// Vertical blank start
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x15);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0xE7);
-
-	// Vertical blank end
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x16);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0x04);
-
-	// Misc output register (read)
-	CRTC = READ_PORT_UCHAR((PUCHAR)0x03CC);
-
-	// Preserve clock select bits and color bit
-	CRTC = (CRTC & 0x0D);
-	// Set correct sync polarity
-	CRTC = (CRTC | 0xE2);
-
-	// (write)
-	WRITE_PORT_UCHAR((PUCHAR)0x03C2, CRTC);
-}
-
-VOID BiosSetVideoDisplayEnd(VOID)
-{
-	int	CRTC;
-
-	// Read CRTC port
-	CRTC = READ_PORT_UCHAR((PUCHAR)0x03CC);
-
-	if (CRTC & 1)
-	{
-		CRTC = 0x3D4;
-	}
-	else
-	{
-		CRTC = 0x3B4;
-	}
-
-	// Vertical display end
-	WRITE_PORT_UCHAR((PUCHAR)CRTC, 0x12);
-	WRITE_PORT_UCHAR((PUCHAR)CRTC+1, 0xDF);
-}
-
 VOID VideoSetTextCursorPosition(U32 X, U32 Y)
 {
-	REGS	Regs;
-
-	// Int 10h AH=02h
-	// VIDEO - SET CURSOR POSITION
-	//
-	// AH = 02h
-	// BH = page number
-	// 0-3 in modes 2&3
-	// 0-7 in modes 0&1
-	// 0 in graphics modes
-	// DH = row (00h is top)
-	// DL = column (00h is left)
-	// Return:
-	// Nothing
-	Regs.b.ah = 0x02;
-	Regs.b.bh = 0x00;
-	Regs.b.dh = Y;
-	Regs.b.dl = X;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID VideoHideTextCursor(VOID)
-{
-	BiosDefineCursor(0x20, 0x00);
-}
-
-VOID VideoShowTextCursor(VOID)
-{
-	BiosDefineCursor(0x0D, 0x0E);
 }
 
 U32 VideoGetTextCursorPositionX(VOID)
@@ -494,52 +160,6 @@ U32 VideoGetTextCursorPositionY(VOID)
 	return Regs.b.dh;
 }
 
-VOID BiosVideoDisableBlinkBit(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AX=1003h
-	// VIDEO - TOGGLE INTENSITY/BLINKING BIT (Jr, PS, TANDY 1000, EGA, VGA)
-	//
-	// AX = 1003h
-	// BL = new state
-	// 00h background intensity enabled
-	// 01h blink enabled
-	// BH = 00h to avoid problems on some adapters
-	// Return:
-	// Nothing
-	//
-	// Note: although there is no function to get
-	// the current status, bit 5 of 0040h:0065h
-	// indicates the state.
-	Regs.w.ax = 0x1003;
-	Regs.w.bx = 0x0000;
-	Int386(0x10, &Regs, &Regs);
-}
-
-VOID BiosVideoEnableBlinkBit(VOID)
-{
-	REGS	Regs;
-
-	// Int 10h AX=1003h
-	// VIDEO - TOGGLE INTENSITY/BLINKING BIT (Jr, PS, TANDY 1000, EGA, VGA)
-	//
-	// AX = 1003h
-	// BL = new state
-	// 00h background intensity enabled
-	// 01h blink enabled
-	// BH = 00h to avoid problems on some adapters
-	// Return:
-	// Nothing
-	//
-	// Note: although there is no function to get
-	// the current status, bit 5 of 0040h:0065h
-	// indicates the state.
-	Regs.w.ax = 0x1003;
-	Regs.w.bx = 0x0001;
-	Int386(0x10, &Regs, &Regs);
-}
-
 U16 BiosIsVesaSupported(VOID)
 {
 	REGS			Regs;
@@ -629,179 +249,3 @@ U16 BiosIsVesaSupported(VOID)
 
 	return SvgaInfo->VesaVersion;
 }
-
-BOOL BiosVesaSetBank(U16 Bank)
-{
-	REGS	Regs;
-
-	// Int 10h AX=4F05h
-	// VESA SuperVGA BIOS - CPU VIDEO MEMORY CONTROL
-	//
-	// AX = 4F05h
-	// BH = subfunction
-	//   00h select video memory window
-	//   01h get video memory window
-	// DX = window address in video memory (in granularity units)
-	// Return:
-	// DX = window address in video memory (in gran. units)
-	// BL = window number
-	//   00h window A
-	//   01h window B.
-	// Return:
-	// AL = 4Fh if function supported
-	// AH = status
-	//   00h successful
-	//   01h failed
-
-	Regs.w.ax = 0x4F05;
-	Regs.w.bx = 0x0000;
-	Regs.w.dx = Bank;
-	Int386(0x10, &Regs, &Regs);
-
-	if (Regs.w.ax != 0x004F)
-	{
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-BOOL BiosVesaSetVideoMode(U16 Mode)
-{
-	REGS	Regs;
-
-	// Int 10h AX=4F02h
-	// VESA SuperVGA BIOS - SET SuperVGA VIDEO MODE
-	//
-	// AX = 4F02h
-	// BX = new video mode
-	// ES:DI -> (VBE 3.0+) CRTC information block, bit mode bit 11 set
-	// Return:
-	// AL = 4Fh if function supported
-	// AH = status
-	//   00h successful
-	//   01h failed
-	//
-	// Values for VESA video mode:
-	// 00h-FFh OEM video modes (see #00010 at AH=00h)
-	// 100h   640x400x256
-	// 101h   640x480x256
-	// 102h   800x600x16
-	// 103h   800x600x256
-	// 104h   1024x768x16
-	// 105h   1024x768x256
-	// 106h   1280x1024x16
-	// 107h   1280x1024x256
-	// 108h   80x60 text
-	// 109h   132x25 text
-	// 10Ah   132x43 text
-	// 10Bh   132x50 text
-	// 10Ch   132x60 text
-	// ---VBE v1.2+ ---
-	// 10Dh   320x200x32K
-	// 10Eh   320x200x64K
-	// 10Fh   320x200x16M
-	// 110h   640x480x32K
-	// 111h   640x480x64K
-	// 112h   640x480x16M
-	// 113h   800x600x32K
-	// 114h   800x600x64K
-	// 115h   800x600x16M
-	// 116h   1024x768x32K
-	// 117h   1024x768x64K
-	// 118h   1024x768x16M
-	// 119h   1280x1024x32K (1:5:5:5)
-	// 11Ah   1280x1024x64K (5:6:5)
-	// 11Bh   1280x1024x16M
-	// ---VBE 2.0+ ---
-	// 120h   1600x1200x256
-	// 121h   1600x1200x32K
-	// 122h   1600x1200x64K
-	// 81FFh   special full-memory access mode
-
-	// Notes: The special mode 81FFh preserves the contents of the video memory and gives
-	// access to all of the memory; VESA recommends that the special mode be a packed-pixel
-	// mode. For VBE 2.0+, it is required that the VBE implement the mode, but not place it
-	// in the list of available modes (mode information for this mode can be queried
-	// directly, however).. As of VBE 2.0, VESA will no longer define video mode numbers 
-	Regs.w.ax = 0x4F02;
-	Regs.w.bx = Mode;
-	Int386(0x10, &Regs, &Regs);
-
-	if (Regs.w.ax != 0x004F)
-	{
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-BOOL BiosVesaGetSVGAModeInformation(U16 Mode, PSVGA_MODE_INFORMATION ModeInformation)
-{
-	REGS	Regs;
-
-	RtlZeroMemory((PVOID)BIOSCALLBUFFER, 256);
-
-	// VESA SuperVGA BIOS - GET SuperVGA MODE INFORMATION
-	// AX = 4F01h
-	// CX = SuperVGA video mode (see #04082 for bitfields)
-	// ES:DI -> 256-byte buffer for mode information (see #00079)
-	// Return:
-	// AL = 4Fh if function supported
-	// AH = status
-	// 00h successful
-	// ES:DI buffer filled
-	// 01h failed
-	//
-	// Desc: Determine the attributes of the specified video mode
-	//
-	// Note: While VBE 1.1 and higher will zero out all unused bytes
-	// of the buffer, v1.0 did not, so applications that want to be
-	// backward compatible should clear the buffer before calling 
-	Regs.w.ax = 0x4F01;
-	Regs.w.cx = Mode;
-	Regs.w.es = BIOSCALLBUFSEGMENT;
-	Regs.w.di = BIOSCALLBUFOFFSET;
-	Int386(0x10, &Regs, &Regs);
-
-	if (Regs.w.ax != 0x004F)
-	{
-		return FALSE;
-	}
-
-	RtlCopyMemory(ModeInformation, (PVOID)BIOSCALLBUFFER, sizeof(SVGA_MODE_INFORMATION));
-
-	DbgPrint((DPRINT_UI, "\n"));
-	DbgPrint((DPRINT_UI, "BiosVesaGetSVGAModeInformation() mode 0x%x\n", Mode));
-	DbgPrint((DPRINT_UI, "ModeAttributes = 0x%x\n", ModeInformation->ModeAttributes));
-	DbgPrint((DPRINT_UI, "WindowAttributesA = 0x%x\n", ModeInformation->WindowAttributesA));
-	DbgPrint((DPRINT_UI, "WindowAttributesB = 0x%x\n", ModeInformation->WindowsAttributesB));
-	DbgPrint((DPRINT_UI, "WindowGranularity = %dKB\n", ModeInformation->WindowGranularity));
-	DbgPrint((DPRINT_UI, "WindowSize = %dKB\n", ModeInformation->WindowSize));
-	DbgPrint((DPRINT_UI, "WindowAStartSegment = 0x%x\n", ModeInformation->WindowAStartSegment));
-	DbgPrint((DPRINT_UI, "WindowBStartSegment = 0x%x\n", ModeInformation->WindowBStartSegment));
-	DbgPrint((DPRINT_UI, "WindowPositioningFunction = 0x%x\n", ModeInformation->WindowPositioningFunction));
-	DbgPrint((DPRINT_UI, "BytesPerScanLine = %d\n", ModeInformation->BytesPerScanLine));
-	DbgPrint((DPRINT_UI, "WidthInPixels = %d\n", ModeInformation->WidthInPixels));
-	DbgPrint((DPRINT_UI, "HeightInPixels = %d\n", ModeInformation->HeightInPixels));
-	DbgPrint((DPRINT_UI, "CharacterWidthInPixels = %d\n", ModeInformation->CharacterWidthInPixels));
-	DbgPrint((DPRINT_UI, "CharacterHeightInPixels = %d\n", ModeInformation->CharacterHeightInPixels));
-	DbgPrint((DPRINT_UI, "NumberOfMemoryPlanes = %d\n", ModeInformation->NumberOfMemoryPlanes));
-	DbgPrint((DPRINT_UI, "BitsPerPixel = %d\n", ModeInformation->BitsPerPixel));
-	DbgPrint((DPRINT_UI, "NumberOfBanks = %d\n", ModeInformation->NumberOfBanks));
-	DbgPrint((DPRINT_UI, "MemoryModel = %d\n", ModeInformation->MemoryModel));
-	DbgPrint((DPRINT_UI, "BankSize = %d\n", ModeInformation->BankSize));
-	DbgPrint((DPRINT_UI, "NumberOfImagePlanes = %d\n", ModeInformation->NumberOfImagePanes));
-	DbgPrint((DPRINT_UI, "---VBE v1.2+ ---\n"));
-	DbgPrint((DPRINT_UI, "RedMaskSize = %d\n", ModeInformation->RedMaskSize));
-	DbgPrint((DPRINT_UI, "RedMaskPosition = %d\n", ModeInformation->RedMaskPosition));
-	DbgPrint((DPRINT_UI, "GreenMaskSize = %d\n", ModeInformation->GreenMaskSize));
-	DbgPrint((DPRINT_UI, "GreenMaskPosition = %d\n", ModeInformation->GreenMaskPosition));
-	DbgPrint((DPRINT_UI, "BlueMaskSize = %d\n", ModeInformation->BlueMaskSize));
-	DbgPrint((DPRINT_UI, "BlueMaskPosition = %d\n", ModeInformation->BlueMaskPosition));
-	DbgPrint((DPRINT_UI, "ReservedMaskSize = %d\n", ModeInformation->ReservedMaskSize));
-	DbgPrint((DPRINT_UI, "ReservedMaskPosition = %d\n", ModeInformation->ReservedMaskPosition));
-	DbgPrint((DPRINT_UI, "\n"));
-
-	return TRUE;
-}

freeldr/freeldr/arch/i386/machpc.c

@@ -0,0 +1,59 @@
+/* $Id: machpc.c,v 1.7 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "mm.h"
+#include "arch.h"
+#include "machine.h"
+#include "machpc.h"
+#include "rtl.h"
+
+VOID
+PcMachInit(VOID)
+{
+  EnableA20();
+
+  /* Setup vtbl */
+  MachVtbl.ConsPutChar = PcConsPutChar;
+  MachVtbl.ConsKbHit = PcConsKbHit;
+  MachVtbl.ConsGetCh = PcConsGetCh;
+  MachVtbl.VideoClearScreen = PcVideoClearScreen;
+  MachVtbl.VideoSetDisplayMode = PcVideoSetDisplayMode;
+  MachVtbl.VideoGetDisplaySize = PcVideoGetDisplaySize;
+  MachVtbl.VideoGetBufferSize = PcVideoGetBufferSize;
+  MachVtbl.VideoSetTextCursorPosition = PcVideoSetTextCursorPosition;
+  MachVtbl.VideoSetTextCursorPosition = PcVideoSetTextCursorPosition;
+  MachVtbl.VideoHideShowTextCursor = PcVideoHideShowTextCursor;
+  MachVtbl.VideoPutChar = PcVideoPutChar;
+  MachVtbl.VideoCopyOffScreenBufferToVRAM = PcVideoCopyOffScreenBufferToVRAM;
+  MachVtbl.VideoIsPaletteFixed = PcVideoIsPaletteFixed;
+  MachVtbl.VideoSetPaletteColor = PcVideoSetPaletteColor;
+  MachVtbl.VideoGetPaletteColor = PcVideoGetPaletteColor;
+  MachVtbl.VideoSync = PcVideoSync;
+  MachVtbl.VideoPrepareForReactOS = PcVideoPrepareForReactOS;
+  MachVtbl.GetMemoryMap = PcMemGetMemoryMap;
+  MachVtbl.DiskReadLogicalSectors = PcDiskReadLogicalSectors;
+  MachVtbl.DiskGetPartitionEntry = PcDiskGetPartitionEntry;
+  MachVtbl.DiskGetDriveGeometry = PcDiskGetDriveGeometry;
+  MachVtbl.DiskGetCacheableBlockCount = PcDiskGetCacheableBlockCount;
+  MachVtbl.RTCGetCurrentDateTime = PcRTCGetCurrentDateTime;
+  MachVtbl.HwDetect = PcHwDetect;
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/machpc.h

@@ -0,0 +1,62 @@
+/* $Id: machpc.h,v 1.7 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  Copyright (C) 2003  Eric Kohl
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __I386_MACHPC_H_
+#define __I386_MACHPC_H_
+
+#ifndef __MEMORY_H
+#include "mm.h"
+#endif
+
+VOID PcMachInit(VOID);
+
+VOID PcConsPutChar(int Ch);
+BOOL PcConsKbHit();
+int PcConsGetCh();
+
+VOID PcVideoClearScreen(U8 Attr);
+VIDEODISPLAYMODE PcVideoSetDisplayMode(char *DisplayMode, BOOL Init);
+VOID PcVideoGetDisplaySize(PU32 Width, PU32 Height, PU32 Depth);
+U32 PcVideoGetBufferSize(VOID);
+VOID PcVideoSetTextCursorPosition(U32 X, U32 Y);
+VOID PcVideoHideShowTextCursor(BOOL Show);
+VOID PcVideoPutChar(int Ch, U8 Attr, unsigned X, unsigned Y);
+VOID PcVideoCopyOffScreenBufferToVRAM(PVOID Buffer);
+BOOL PcVideoIsPaletteFixed(VOID);
+VOID PcVideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue);
+VOID PcVideoGetPaletteColor(U8 Color, U8* Red, U8* Green, U8* Blue);
+VOID PcVideoSync(VOID);
+VOID PcVideoPrepareForReactOS(VOID);
+
+U32 PcMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize);
+
+BOOL PcDiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
+BOOL PcDiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL PcDiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry);
+U32 PcDiskGetCacheableBlockCount(U32 DriveNumber);
+
+VOID PcRTCGetCurrentDateTime(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second);
+
+VOID PcHwDetect(VOID);
+
+#endif /* __I386_MACHPC_H_ */
+
+/* EOF */

freeldr/freeldr/arch/i386/machxbox.c

@@ -0,0 +1,55 @@
+/* $Id: machxbox.c,v 1.7 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "mm.h"
+#include "machine.h"
+#include "machxbox.h"
+
+VOID
+XboxMachInit(VOID)
+{
+  /* Initialize our stuff */
+  XboxMemInit();
+  XboxVideoInit();
+
+  /* Setup vtbl */
+  MachVtbl.ConsPutChar = XboxConsPutChar;
+  MachVtbl.ConsKbHit = XboxConsKbHit;
+  MachVtbl.ConsGetCh = XboxConsGetCh;
+  MachVtbl.VideoClearScreen = XboxVideoClearScreen;
+  MachVtbl.VideoSetDisplayMode = XboxVideoSetDisplayMode;
+  MachVtbl.VideoGetDisplaySize = XboxVideoGetDisplaySize;
+  MachVtbl.VideoGetBufferSize = XboxVideoGetBufferSize;
+  MachVtbl.VideoHideShowTextCursor = XboxVideoHideShowTextCursor;
+  MachVtbl.VideoPutChar = XboxVideoPutChar;
+  MachVtbl.VideoCopyOffScreenBufferToVRAM = XboxVideoCopyOffScreenBufferToVRAM;
+  MachVtbl.VideoIsPaletteFixed = XboxVideoIsPaletteFixed;
+  MachVtbl.VideoSetPaletteColor = XboxVideoSetPaletteColor;
+  MachVtbl.VideoGetPaletteColor = XboxVideoGetPaletteColor;
+  MachVtbl.VideoSync = XboxVideoSync;
+  MachVtbl.VideoPrepareForReactOS = XboxVideoPrepareForReactOS;
+  MachVtbl.GetMemoryMap = XboxMemGetMemoryMap;
+  MachVtbl.DiskReadLogicalSectors = XboxDiskReadLogicalSectors;
+  MachVtbl.DiskGetPartitionEntry = XboxDiskGetPartitionEntry;
+  MachVtbl.DiskGetDriveGeometry = XboxDiskGetDriveGeometry;
+  MachVtbl.DiskGetCacheableBlockCount = XboxDiskGetCacheableBlockCount;
+  MachVtbl.RTCGetCurrentDateTime = XboxRTCGetCurrentDateTime;
+  MachVtbl.HwDetect = XboxHwDetect;
+}

freeldr/freeldr/arch/i386/machxbox.h

@@ -0,0 +1,65 @@
+/* $Id: machxbox.h,v 1.7 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __I386_MACHXBOX_H_
+#define __I386_MACHXBOX_H_
+
+#ifndef __MEMORY_H
+#include "mm.h"
+#endif
+
+U8 XboxFont8x16[256 * 16];
+
+VOID XboxMachInit(VOID);
+
+VOID XboxConsPutChar(int Ch);
+BOOL XboxConsKbHit();
+int XboxConsGetCh();
+
+VOID XboxVideoInit(VOID);
+VOID XboxVideoClearScreen(U8 Attr);
+VIDEODISPLAYMODE XboxVideoSetDisplayMode(char *DisplayModem, BOOL Init);
+VOID XboxVideoGetDisplaySize(PU32 Width, PU32 Height, PU32 Depth);
+U32 XboxVideoGetBufferSize(VOID);
+VOID XboxVideoSetTextCursorPosition(U32 X, U32 Y);
+VOID XboxVideoHideShowTextCursor(BOOL Show);
+VOID XboxVideoPutChar(int Ch, U8 Attr, unsigned X, unsigned Y);
+VOID XboxVideoCopyOffScreenBufferToVRAM(PVOID Buffer);
+BOOL XboxVideoIsPaletteFixed(VOID);
+VOID XboxVideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue);
+VOID XboxVideoGetPaletteColor(U8 Color, U8* Red, U8* Green, U8* Blue);
+VOID XboxVideoSync(VOID);
+VOID XboxVideoPrepareForReactOS(VOID);
+
+VOID XboxMemInit(VOID);
+PVOID XboxMemReserveMemory(U32 MbToReserve);
+U32 XboxMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize);
+
+BOOL XboxDiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
+BOOL XboxDiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+BOOL XboxDiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry);
+U32 XboxDiskGetCacheableBlockCount(U32 DriveNumber);
+
+VOID XboxRTCGetCurrentDateTime(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second);
+
+VOID XboxHwDetect(VOID);
+
+#endif /* __I386_HWXBOX_H_ */
+
+/* EOF */

freeldr/freeldr/arch/i386/mb.S

@@ -25,117 +25,35 @@
 #include <multiboot.h>
 
 	/*
-     * Here we assume the kernel is loaded at 1mb
-     * This boots the kernel
+	 * Here we assume the kernel is loaded at 1mb
+	 * This boots the kernel
 	 */
 	.code32
 EXTERN(_boot_reactos)
-	call	switch_to_real
-	.code16
-
-    /* Save cursor position */
-	movw    $3,%ax          //! Reset video mode
-	int     $0x10
-
-
-	movb    $10,%bl
-	movb    $12,%ah
-	int     $0x10
-
-	movw    $0x1112,%ax		// Use 8x8 font
-	xorb	%bl,%bl
-	int     $0x10
-	movw    $0x1200,%ax		// Use alternate print screen
-	movb    $0x20,%bl
-	int     $0x10
-	movb    $1,%ah			// Define cursor (scan lines 6 to 7)
-	movw    $0x0607,%cx
-	int     $0x10
-
-	movb    $1,%ah
-	movw    $0x600,%cx
-	int     $0x10
-
-	movb	$6,%ah			// Scroll active page up
-	movb	$0x32,%al		// Clear 25 lines
-	movw	$0,%cx			// Upper left of scroll
-	movw	$0x314F,%dx		// Lower right of scroll
-	movb	$(1*0x00+0),%bh	// Use normal attribute on blanked line
-	int		$0x10			// Video-IO
-
-
-	movw	$0,%dx
-	movb	$0,%dh
-
-	movb	$2,%ah
-	movb	$0,%bh
-	int		$0x10
-
-	movw	$0,%dx
-	movb	$0,%dh
-
-	movb	$2,%ah
-	movb	$0,%bh
-	int		$0x10
+	call	_MachVideoPrepareForReactOS
 
 	call	_multi_boot
 
 	// Should never get here
 	cli
+bootloop:
 	hlt
+	jmp	bootloop
 
 
 	/*
 	 * After you have setup the _mb_header and _mb_info structures
 	 * then call this routine to transfer control to the kernel.
-	 * This routine must be entered in 16-bit mode.
 	 */
-	.code16
 EXTERN(_multi_boot)
 
 	cli
 
-	/*
-	 * Setup various variables
-	 */
-	movw	%ds,%bx
-	movzwl	%bx,%eax
-	shll	$4,%eax
-	addl	%eax,kernel_gdtbase
-
 	/*
 	 * Load the absolute address of the multiboot information structure
 	 */
 	movl	$_mb_info,%ebx
 
-	/*
-	 * load gdt
-	 */
-	lgdt	kernel_gdtptr
-
-	/*       
-	 * Enter pmode and clear prefetch queue
-	 */
-	movl	%cr0,%eax
-	orl		$0x10001,%eax
-	movl	%eax,%cr0
-	jmp		next
-next:
-	/*
-	 * NOTE: This must be position independant (no references to
-	 * non absolute variables)
-	 */
-
-	/*
-	 * Initalize segment registers
-	 */
-	movw	$KERNEL_DS,%ax
-	movw	%ax,%ds
-	movw	%ax,%ss
-	movw	%ax,%es
-	movw	%ax,%fs
-	movw	%ax,%gs
-
 	/*
 	 * Initalize eflags
 	 */
@@ -155,33 +73,6 @@ next:
 	pushl	_mb_entry_addr
 	lretl
 
-	//ljmpl	$KERNEL_CS,$(0x0200000+0x1000)
-	//ljmpl	$KERNEL_CS,(_mb_entry_addr)
-	//ljmpl	$KERNEL_CS,$(KERNEL_BASE+0x1000)
-
-
-	.p2align	2	/* force 4-byte alignment */
-kernel_gdt:
-	.word 0               // Zero descriptor
-	.word 0
-	.word 0
-	.word 0
-
-	.word 0xffff          // Kernel code descriptor 
-	.word 0x0000          // 
-	.word 0x9a00          // base 0h limit 4gb
-	.word 0x00cf
-                       
-	.word 0xffff          // Kernel data descriptor
-	.word 0x0000          // 
-	.word 0x9200          // base 0h limit 4gb
-	.word 0x00cf
-
-kernel_gdtptr:
-	.word	(3*8)-1			/* Limit */
-kernel_gdtbase:
-	.long	kernel_gdt				/* Base Address */
-
 
 EXTERN(_mb_header)
 _mb_magic:

freeldr/freeldr/arch/i386/pccons.c

@@ -0,0 +1,133 @@
+/* $Id: pccons.c,v 1.3 2004/11/14 22:04:38 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+#include "arch.h"
+#include "debug.h"
+#include "machpc.h"
+#include "rtl.h"
+
+#define TEXTMODE_BUFFER      0xb8000
+#define TEXTMODE_BUFFER_SIZE 0x8000
+
+#define TEXT_COLS  80
+#define TEXT_LINES 25
+
+VOID
+PcConsPutChar(int Ch)
+{
+  REGS Regs;
+
+  /* If we are displaying a CR '\n' then do a LF also */
+  if ('\n' == Ch)
+    {
+      /* Display the LF */
+      PcConsPutChar('\r');
+    }
+
+  /* If we are displaying a TAB '\t' then display 8 spaces ' ' */
+  if ('\t' == Ch)
+    {
+      /* Display the 8 spaces ' ' */
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      PcConsPutChar(' ');
+      return;
+    }
+
+  /* Int 10h AH=0Eh
+   * VIDEO - TELETYPE OUTPUT
+   *
+   * AH = 0Eh
+   * AL = character to write
+   * BH = page number
+   * BL = foreground color (graphics modes only)
+   */
+  Regs.b.ah = 0x0E;
+  Regs.b.al = Ch;
+  Regs.w.bx = 1;
+  Int386(0x10, &Regs, &Regs);
+}
+
+BOOL
+PcConsKbHit(VOID)
+{
+  REGS Regs;
+
+  /* Int 16h AH=01h
+   * KEYBOARD - CHECK FOR KEYSTROKE
+   *
+   * AH = 01h
+   * Return:
+   * ZF set if no keystroke available
+   * ZF clear if keystroke available
+   * AH = BIOS scan code
+   * AL = ASCII character
+   */
+  Regs.b.ah = 0x01;
+  Int386(0x16, &Regs, &Regs);
+
+  return 0 == (Regs.x.eflags & I386FLAG_ZF);
+}
+
+int
+PcConsGetCh(void)
+{
+  REGS Regs;
+  static BOOL ExtendedKey = FALSE;
+  static char ExtendedScanCode = 0;
+
+  /* If the last time we were called an
+   * extended key was pressed then return
+   * that keys scan code. */
+  if (ExtendedKey)
+    {
+      ExtendedKey = FALSE;
+      return ExtendedScanCode;
+    }
+
+  /* Int 16h AH=00h
+   * KEYBOARD - GET KEYSTROKE
+   *
+   * AH = 00h
+   * Return:
+   * AH = BIOS scan code
+   * AL = ASCII character
+   */
+  Regs.b.ah = 0x00;
+  Int386(0x16, &Regs, &Regs);
+
+  /* Check for an extended keystroke */
+  if (0 == Regs.b.al)
+    {
+      ExtendedKey = TRUE;
+      ExtendedScanCode = Regs.b.ah;
+    }
+
+  /* Return keystroke */
+  return Regs.b.al;
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/pcdisk.c

@@ -0,0 +1,466 @@
+/*
+ *  FreeLoader
+ *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "disk.h"
+#include "rtl.h"
+#include "arch.h"
+#include "debug.h"
+#include "portio.h"
+#include "machine.h"
+#include "machpc.h"
+
+
+typedef struct
+{
+	U8		PacketSize;				// 00h - Size of packet (10h or 18h)
+	U8		Reserved;				// 01h - Reserved (0)
+	U16		LBABlockCount;			// 02h - Number of blocks to transfer (max 007Fh for Phoenix EDD)
+	U16		TransferBufferOffset;	// 04h - Transfer buffer offset (seg:off)
+	U16		TransferBufferSegment;	//       Transfer buffer segment (seg:off)
+	U64		LBAStartBlock;			// 08h - Starting absolute block number
+	U64		TransferBuffer64;		// 10h - (EDD-3.0, optional) 64-bit flat address of transfer buffer
+									//       used if DWORD at 04h is FFFFh:FFFFh
+} PACKED I386_DISK_ADDRESS_PACKET, *PI386_DISK_ADDRESS_PACKET;
+
+/////////////////////////////////////////////////////////////////////////////////////////////
+// FUNCTIONS
+/////////////////////////////////////////////////////////////////////////////////////////////
+
+static BOOL PcDiskResetController(U32 DriveNumber)
+{
+	REGS	RegsIn;
+	REGS	RegsOut;
+
+	DbgPrint((DPRINT_DISK, "PcDiskResetController(0x%x) DISK OPERATION FAILED -- RESETTING CONTROLLER\n", DriveNumber));
+
+	// BIOS Int 13h, function 0 - Reset disk system
+	// AH = 00h
+	// DL = drive (if bit 7 is set both hard disks and floppy disks reset)
+	// Return:
+	// AH = status
+	// CF clear if successful
+	// CF set on error
+	RegsIn.b.ah = 0x00;
+	RegsIn.b.dl = DriveNumber;
+
+	// Reset the disk controller
+	Int386(0x13, &RegsIn, &RegsOut);
+
+	return INT386_SUCCESS(RegsOut);
+}
+
+static BOOL PcDiskReadLogicalSectorsLBA(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+{
+	REGS						RegsIn;
+	REGS						RegsOut;
+	U32							RetryCount;
+	PI386_DISK_ADDRESS_PACKET	Packet = (PI386_DISK_ADDRESS_PACKET)(BIOSCALLBUFFER);
+
+	DbgPrint((DPRINT_DISK, "PcDiskReadLogicalSectorsLBA() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer));
+
+	// BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
+	RegsIn.b.ah = 0x42;					// Subfunction 42h
+	RegsIn.b.dl = DriveNumber;			// Drive number in DL (0 - floppy, 0x80 - harddisk)
+	RegsIn.x.ds = BIOSCALLBUFSEGMENT;	// DS:SI -> disk address packet
+	RegsIn.w.si = BIOSCALLBUFOFFSET;
+
+	// Setup disk address packet
+	RtlZeroMemory(Packet, sizeof(I386_DISK_ADDRESS_PACKET));
+	Packet->PacketSize = sizeof(I386_DISK_ADDRESS_PACKET);
+	Packet->Reserved = 0;
+	Packet->LBABlockCount = SectorCount;
+	Packet->TransferBufferOffset = ((U32)Buffer) & 0x0F;
+	Packet->TransferBufferSegment = ((U32)Buffer) >> 4;
+	Packet->LBAStartBlock = SectorNumber;
+	Packet->TransferBuffer64 = 0;
+
+	// BIOS int 0x13, function 42h - IBM/MS INT 13 Extensions - EXTENDED READ
+	// Return:
+	// CF clear if successful
+	// AH = 00h
+	// CF set on error
+	// AH = error code
+	// disk address packet's block count field set to the
+	// number of blocks successfully transferred
+
+	// Retry 3 times
+	for (RetryCount=0; RetryCount<3; RetryCount++)
+	{
+		Int386(0x13, &RegsIn, &RegsOut);
+
+		// If it worked return TRUE
+		if (INT386_SUCCESS(RegsOut))
+		{
+			return TRUE;
+		}
+		// If it was a corrected ECC error then the data is still good
+		else if (RegsOut.b.ah == 0x11)
+		{
+			return TRUE;
+		}
+		// If it failed the do the next retry
+		else
+		{
+			PcDiskResetController(DriveNumber);
+
+			continue;
+		}
+	}
+
+	// If we get here then the read failed
+	DiskError("Disk Read Failed", RegsOut.b.ah);
+
+	return FALSE;
+}
+
+static BOOL PcDiskReadLogicalSectorsCHS(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+{
+	U32			PhysicalSector;
+	U32			PhysicalHead;
+	U32			PhysicalTrack;
+	GEOMETRY	DriveGeometry;
+	U32			NumberOfSectorsToRead;
+	REGS		RegsIn;
+	REGS		RegsOut;
+	U32			RetryCount;
+
+	DbgPrint((DPRINT_DISK, "PcDiskReadLogicalSectorsCHS()\n"));
+
+	//
+	// Get the drive geometry
+	//
+	if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry))
+	{
+		return FALSE;
+	}
+
+	while (SectorCount)
+	{
+
+		//
+		// Calculate the physical disk offsets
+		//
+		PhysicalSector = 1 + (SectorNumber % DriveGeometry.Sectors);
+		PhysicalHead = (SectorNumber / DriveGeometry.Sectors) % DriveGeometry.Heads;
+		PhysicalTrack = (SectorNumber / DriveGeometry.Sectors) / DriveGeometry.Heads;
+
+		//
+		// Calculate how many sectors we need to read this round
+		//
+		if (PhysicalSector > 1)
+		{
+			if (SectorCount >= (DriveGeometry.Sectors - (PhysicalSector - 1)))
+				NumberOfSectorsToRead = (DriveGeometry.Sectors - (PhysicalSector - 1));
+			else
+				NumberOfSectorsToRead = SectorCount;
+		}
+		else
+		{
+			if (SectorCount >= DriveGeometry.Sectors)
+				NumberOfSectorsToRead = DriveGeometry.Sectors;
+			else
+				NumberOfSectorsToRead = SectorCount;
+		}
+
+		//
+		// Make sure the read is within the geometry boundaries
+		//
+		if ((PhysicalHead >= DriveGeometry.Heads) ||
+			(PhysicalTrack >= DriveGeometry.Cylinders) ||
+			((NumberOfSectorsToRead + PhysicalSector) > (DriveGeometry.Sectors + 1)) ||
+			(PhysicalSector > DriveGeometry.Sectors))
+		{
+			DiskError("Disk read exceeds drive geometry limits.", 0);
+			return FALSE;
+		}
+
+		// BIOS Int 13h, function 2 - Read Disk Sectors
+		// AH = 02h
+		// AL = number of sectors to read (must be nonzero)
+		// CH = low eight bits of cylinder number
+		// CL = sector number 1-63 (bits 0-5)
+		//      high two bits of cylinder (bits 6-7, hard disk only)
+		// DH = head number
+		// DL = drive number (bit 7 set for hard disk)
+		// ES:BX -> data buffer
+		// Return:
+		// CF set on error
+		// if AH = 11h (corrected ECC error), AL = burst length
+		// CF clear if successful
+		// AH = status
+		// AL = number of sectors transferred
+		//  (only valid if CF set for some BIOSes)
+		RegsIn.b.ah = 0x02;
+		RegsIn.b.al = NumberOfSectorsToRead;
+		RegsIn.b.ch = (PhysicalTrack & 0xFF);
+		RegsIn.b.cl = (PhysicalSector + ((PhysicalTrack & 0x300) >> 2));
+		RegsIn.b.dh = PhysicalHead;
+		RegsIn.b.dl = DriveNumber;
+		RegsIn.w.es = ((U32)Buffer) >> 4;
+		RegsIn.w.bx = ((U32)Buffer) & 0x0F;
+
+		//
+		// Perform the read
+		// Retry 3 times
+		//
+		for (RetryCount=0; RetryCount<3; RetryCount++)
+		{
+			Int386(0x13, &RegsIn, &RegsOut);
+
+			// If it worked break out
+			if (INT386_SUCCESS(RegsOut))
+			{
+				break;
+			}
+			// If it was a corrected ECC error then the data is still good
+			else if (RegsOut.b.ah == 0x11)
+			{
+				break;
+			}
+			// If it failed the do the next retry
+			else
+			{
+				PcDiskResetController(DriveNumber);
+
+				continue;
+			}
+		}
+
+		// If we retried 3 times then fail
+		if (RetryCount >= 3)
+		{
+			DiskError("Disk Read Failed", RegsOut.b.ah);
+			return FALSE;
+		}
+
+		// I have learned that not all bioses return
+		// the sector read count in the AL register (at least mine doesn't)
+		// even if the sectors were read correctly. So instead
+		// of checking the sector read count we will rely solely
+		// on the carry flag being set on error
+
+		Buffer += (NumberOfSectorsToRead * DriveGeometry.BytesPerSector);
+		SectorCount -= NumberOfSectorsToRead;
+		SectorNumber += NumberOfSectorsToRead;
+	}
+
+	return TRUE;
+}
+
+static BOOL PcDiskInt13ExtensionsSupported(U32 DriveNumber)
+{
+	static U32	LastDriveNumber = 0xffffffff;
+	static BOOL	LastSupported;
+	REGS	RegsIn;
+	REGS	RegsOut;
+
+	DbgPrint((DPRINT_DISK, "PcDiskInt13ExtensionsSupported()\n"));
+
+	if (DriveNumber == LastDriveNumber)
+	{
+		DbgPrint((DPRINT_DISK, "Using cached value %s for drive 0x%x\n", LastSupported ? "TRUE" : "FALSE", DriveNumber));
+		return LastSupported;
+	}
+
+	LastDriveNumber = DriveNumber;
+
+	// IBM/MS INT 13 Extensions - INSTALLATION CHECK
+	// AH = 41h
+	// BX = 55AAh
+	// DL = drive (80h-FFh)
+	// Return:
+	// CF set on error (extensions not supported)
+	// AH = 01h (invalid function)
+	// CF clear if successful
+	// BX = AA55h if installed
+	// AH = major version of extensions
+	// 01h = 1.x
+	// 20h = 2.0 / EDD-1.0
+	// 21h = 2.1 / EDD-1.1
+	// 30h = EDD-3.0
+	// AL = internal use
+	// CX = API subset support bitmap
+	// DH = extension version (v2.0+ ??? -- not present in 1.x)
+	//
+	// Bitfields for IBM/MS INT 13 Extensions API support bitmap
+	// Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
+	// Bit 1, removable drive controller functions (AH=45h,46h,48h,49h,INT 15/AH=52h) supported
+	// Bit 2, enhanced disk drive (EDD) functions (AH=48h,AH=4Eh) supported
+	//        extended drive parameter table is valid
+	// Bits 3-15 reserved
+	RegsIn.b.ah = 0x41;
+	RegsIn.w.bx = 0x55AA;
+	RegsIn.b.dl = DriveNumber;
+
+	// Reset the disk controller
+	Int386(0x13, &RegsIn, &RegsOut);
+
+	if (!INT386_SUCCESS(RegsOut))
+	{
+		// CF set on error (extensions not supported)
+		LastSupported = FALSE;
+		return FALSE;
+	}
+
+	if (RegsOut.w.bx != 0xAA55)
+	{
+		// BX = AA55h if installed
+		LastSupported = FALSE;
+		return FALSE;
+	}
+
+	// Note:
+	// The original check is too strict because some BIOSes report that
+	// extended disk access functions are not suported when booting
+	// from a CD (e.g. Phoenix BIOS v6.00PG). Argh!
+#if 0
+	if (!(RegsOut.w.cx & 0x0001))
+	{
+		// CX = API subset support bitmap
+		// Bit 0, extended disk access functions (AH=42h-44h,47h,48h) supported
+		LastSupported = FALSE;
+		return FALSE;
+	}
+#endif
+
+	// Use this relaxed check instead (most BIOSes seem to use 0x9f as CD-Rom)
+	if (RegsOut.w.cx == 0x0000 && DriveNumber != 0x9f)
+	{
+		// CX = API subset support bitmap
+		printf("Suspicious API subset support bitmap 0x%x on device 0x%x\n", RegsOut.w.cx, DriveNumber);
+		LastSupported = FALSE;
+		return LastSupported;
+	}
+
+	LastSupported = TRUE;
+	return TRUE;
+}
+
+BOOL PcDiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+{
+
+	DbgPrint((DPRINT_DISK, "PcDiskReadLogicalSectors() DriveNumber: 0x%x SectorNumber: %I64d SectorCount: %d Buffer: 0x%x\n", DriveNumber, SectorNumber, SectorCount, Buffer));
+
+	//
+	// Check to see if it is a fixed disk drive
+	// If so then check to see if Int13 extensions work
+	// If they do then use them, otherwise default back to BIOS calls
+	//
+	if ((DriveNumber >= 0x80) && PcDiskInt13ExtensionsSupported(DriveNumber))
+	{
+		DbgPrint((DPRINT_DISK, "Using Int 13 Extensions for read. PcDiskInt13ExtensionsSupported(%d) = %s\n", DriveNumber, PcDiskInt13ExtensionsSupported(DriveNumber) ? "TRUE" : "FALSE"));
+
+		//
+		// LBA is easy, nothing to calculate
+		// Just do the read
+		//
+		return PcDiskReadLogicalSectorsLBA(DriveNumber, SectorNumber, SectorCount, Buffer);
+	}
+	else
+	{
+		// LBA is not supported default to the CHS calls
+		return PcDiskReadLogicalSectorsCHS(DriveNumber, SectorNumber, SectorCount, Buffer);
+	}
+
+	return TRUE;
+}
+
+BOOL
+PcDiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+  /* Just use the standard routine */
+  return DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
+}
+
+BOOL
+PcDiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY Geometry)
+{
+  REGS RegsIn;
+  REGS RegsOut;
+  U32 Cylinders;
+
+  DbgPrint((DPRINT_DISK, "DiskGetDriveGeometry()\n"));
+
+  /* BIOS Int 13h, function 08h - Get drive parameters
+   * AH = 08h
+   * DL = drive (bit 7 set for hard disk)
+   * ES:DI = 0000h:0000h to guard against BIOS bugs
+   * Return:
+   * CF set on error
+   * AH = status (07h)
+   * CF clear if successful
+   * AH = 00h
+   * AL = 00h on at least some BIOSes
+   * BL = drive type (AT/PS2 floppies only)
+   * CH = low eight bits of maximum cylinder number
+   * CL = maximum sector number (bits 5-0)
+   *      high two bits of maximum cylinder number (bits 7-6)
+   * DH = maximum head number
+   * DL = number of drives
+   * ES:DI -> drive parameter table (floppies only)
+   */
+  RegsIn.b.ah = 0x08;
+  RegsIn.b.dl = DriveNumber;
+  RegsIn.w.es = 0x0000;
+  RegsIn.w.di = 0x0000;
+
+  /* Get drive parameters */
+  Int386(0x13, &RegsIn, &RegsOut);
+
+  if (! INT386_SUCCESS(RegsOut))
+    {
+      return FALSE;
+    }
+
+  Cylinders = (RegsOut.b.cl & 0xC0) << 2;
+  Cylinders += RegsOut.b.ch;
+  Cylinders++;
+  Geometry->Cylinders = Cylinders;
+  Geometry->Heads = RegsOut.b.dh + 1;
+  Geometry->Sectors = RegsOut.b.cl & 0x3F;
+  Geometry->BytesPerSector = 512;            /* Just assume 512 bytes per sector */
+
+  return TRUE;
+}
+
+U32
+PcDiskGetCacheableBlockCount(U32 DriveNumber)
+{
+  GEOMETRY	Geometry;
+
+  /* If LBA is supported then the block size will be 64 sectors (32k)
+   * If not then the block size is the size of one track */
+  if (DiskInt13ExtensionsSupported(DriveNumber))
+    {
+      return 64;
+    }
+  /* Get the disk geometry
+   * If this fails then we will just return 1 sector to be safe */
+  else if (! PcDiskGetDriveGeometry(DriveNumber, &Geometry))
+    {
+      return 1;
+    }
+  else
+    {
+      return Geometry.Sectors;
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/pcmem.c

@@ -0,0 +1,252 @@
+/* $Id: pcmem.c,v 1.2 2004/11/10 23:45:37 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: Most of this code comes from the old file "i386mem.c", which
+ *       was Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>
+ */
+
+#include "freeldr.h"
+#include "arch.h"
+#include "debug.h"
+#include "machine.h"
+#include "machpc.h"
+#include "portio.h"
+#include "rtl.h"
+
+static U32
+PcMemGetExtendedMemorySize(VOID)
+{
+  REGS RegsIn;
+  REGS RegsOut;
+  U32 MemorySize;
+
+  DbgPrint((DPRINT_MEMORY, "GetExtendedMemorySize()\n"));
+
+  /* Int 15h AX=E801h
+   * Phoenix BIOS v4.0 - GET MEMORY SIZE FOR >64M CONFIGURATIONS
+   *
+   * AX = E801h
+   * Return:
+   * CF clear if successful
+   * AX = extended memory between 1M and 16M, in K (max 3C00h = 15MB)
+   * BX = extended memory above 16M, in 64K blocks
+   * CX = configured memory 1M to 16M, in K
+   * DX = configured memory above 16M, in 64K blocks
+   * CF set on error
+   */
+  RegsIn.w.ax = 0xE801;
+  Int386(0x15, &RegsIn, &RegsOut);
+
+  DbgPrint((DPRINT_MEMORY, "Int15h AX=E801h\n"));
+  DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n", RegsOut.w.ax));
+  DbgPrint((DPRINT_MEMORY, "BX = 0x%x\n", RegsOut.w.bx));
+  DbgPrint((DPRINT_MEMORY, "CX = 0x%x\n", RegsOut.w.cx));
+  DbgPrint((DPRINT_MEMORY, "DX = 0x%x\n", RegsOut.w.dx));
+  DbgPrint((DPRINT_MEMORY, "CF set = %s\n\n", (RegsOut.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
+
+  if (INT386_SUCCESS(RegsOut))
+    {
+      /* If AX=BX=0000h the use CX and DX */
+      if (RegsOut.w.ax == 0)
+        {
+          /* Return extended memory size in K */
+          MemorySize = RegsOut.w.dx * 64;
+          MemorySize += RegsOut.w.cx;
+          return MemorySize;
+        }
+      else
+        {
+          /* Return extended memory size in K */
+          MemorySize = RegsOut.w.bx * 64;
+          MemorySize += RegsOut.w.ax;
+          return MemorySize;
+        }
+    }
+
+  /* If we get here then Int15 Func E801h didn't work */
+  /* So try Int15 Func 88h */
+
+  /* Int 15h AH=88h
+   * SYSTEM - GET EXTENDED MEMORY SIZE (286+)
+   *
+   * AH = 88h
+   * Return:
+   * CF clear if successful
+   * AX = number of contiguous KB starting at absolute address 100000h
+   * CF set on error
+   * AH = status
+   * 80h invalid command (PC,PCjr)
+   * 86h unsupported function (XT,PS30)
+   */
+  RegsIn.b.ah = 0x88;
+  Int386(0x15, &RegsIn, &RegsOut);
+
+  DbgPrint((DPRINT_MEMORY, "Int15h AH=88h\n"));
+  DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n", RegsOut.w.ax));
+  DbgPrint((DPRINT_MEMORY, "CF set = %s\n\n", (RegsOut.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
+
+  if (INT386_SUCCESS(RegsOut) && RegsOut.w.ax != 0)
+    {
+      MemorySize = RegsOut.w.ax;
+      return MemorySize;
+    }
+
+  /* If we get here then Int15 Func 88h didn't work */
+  /* So try reading the CMOS */
+  WRITE_PORT_UCHAR((PUCHAR)0x70, 0x31);
+  MemorySize = READ_PORT_UCHAR((PUCHAR)0x71);
+  MemorySize = (MemorySize & 0xFFFF);
+  MemorySize = (MemorySize << 8);
+
+  DbgPrint((DPRINT_MEMORY, "Int15h Failed\n"));
+  DbgPrint((DPRINT_MEMORY, "CMOS reports: 0x%x\n", MemorySize));
+
+  return MemorySize;
+}
+
+static U32
+PcMemGetConventionalMemorySize(VOID)
+{
+  REGS Regs;
+
+  DbgPrint((DPRINT_MEMORY, "GetConventionalMemorySize()\n"));
+
+  /* Int 12h
+   * BIOS - GET MEMORY SIZE
+   *
+   * Return:
+   * AX = kilobytes of contiguous memory starting at absolute address 00000h
+   *
+   * This call returns the contents of the word at 0040h:0013h;
+   * in PC and XT, this value is set from the switches on the motherboard
+   */
+  Regs.w.ax = 0;
+  Int386(0x12, &Regs, &Regs);
+
+  DbgPrint((DPRINT_MEMORY, "Int12h\n"));
+  DbgPrint((DPRINT_MEMORY, "AX = 0x%x\n\n", Regs.w.ax));
+
+  return (U32)Regs.w.ax;
+}
+
+static U32
+PcMemGetBiosMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize)
+{
+  REGS Regs;
+  U32 MapCount;
+
+  DbgPrint((DPRINT_MEMORY, "GetBiosMemoryMap()\n"));
+
+  /* Int 15h AX=E820h
+   * Newer BIOSes - GET SYSTEM MEMORY MAP
+   *
+   * AX = E820h
+   * EAX = 0000E820h
+   * EDX = 534D4150h ('SMAP')
+   * EBX = continuation value or 00000000h to start at beginning of map
+   * ECX = size of buffer for result, in bytes (should be >= 20 bytes)
+   * ES:DI -> buffer for result
+   * Return:
+   * CF clear if successful
+   * EAX = 534D4150h ('SMAP')
+   * ES:DI buffer filled
+   * EBX = next offset from which to copy or 00000000h if all done
+   * ECX = actual length returned in bytes
+   * CF set on error
+   * AH = error code (86h)
+   */
+  Regs.x.eax = 0x0000E820;
+  Regs.x.edx = 0x534D4150; /* ('SMAP') */
+  Regs.x.ebx = 0x00000000;
+  Regs.x.ecx = sizeof(BIOS_MEMORY_MAP);
+  Regs.w.es = BIOSCALLBUFSEGMENT;
+  Regs.w.di = BIOSCALLBUFOFFSET;
+  for (MapCount = 0; MapCount < MaxMemoryMapSize; MapCount++)
+    {
+      Int386(0x15, &Regs, &Regs);
+
+      DbgPrint((DPRINT_MEMORY, "Memory Map Entry %d\n", MapCount));
+      DbgPrint((DPRINT_MEMORY, "Int15h AX=E820h\n"));
+      DbgPrint((DPRINT_MEMORY, "EAX = 0x%x\n", Regs.x.eax));
+      DbgPrint((DPRINT_MEMORY, "EBX = 0x%x\n", Regs.x.ebx));
+      DbgPrint((DPRINT_MEMORY, "ECX = 0x%x\n", Regs.x.ecx));
+      DbgPrint((DPRINT_MEMORY, "CF set = %s\n", (Regs.x.eflags & I386FLAG_CF) ? "TRUE" : "FALSE"));
+
+      /* If the BIOS didn't return 'SMAP' in EAX then
+       * it doesn't support this call */
+      if (Regs.x.eax != 0x534D4150)
+        {
+          break;
+        }
+
+      /* Copy data to caller's buffer */
+      RtlCopyMemory(&BiosMemoryMap[MapCount], (PVOID)BIOSCALLBUFFER, Regs.x.ecx);
+
+      DbgPrint((DPRINT_MEMORY, "BaseAddress: 0x%x%x\n", BiosMemoryMap[MapCount].BaseAddress));
+      DbgPrint((DPRINT_MEMORY, "Length: 0x%x%x\n", BiosMemoryMap[MapCount].Length));
+      DbgPrint((DPRINT_MEMORY, "Type: 0x%x\n", BiosMemoryMap[MapCount].Type));
+      DbgPrint((DPRINT_MEMORY, "Reserved: 0x%x\n", BiosMemoryMap[MapCount].Reserved));
+      DbgPrint((DPRINT_MEMORY, "\n"));
+
+      /* If the continuation value is zero or the
+       * carry flag is set then this was
+       * the last entry so we're done */
+      if (Regs.x.ebx == 0x00000000 || !INT386_SUCCESS(Regs))
+        {
+          MapCount++;
+          DbgPrint((DPRINT_MEMORY, "End Of System Memory Map!\n\n"));
+          break;
+        }
+
+      /* Setup the registers for the next call */
+      Regs.x.eax = 0x0000E820;
+      Regs.x.edx = 0x534D4150; /* ('SMAP') */
+      /* Regs.x.ebx = 0x00000001;  Continuation value already set by the BIOS */
+      Regs.x.ecx = sizeof(BIOS_MEMORY_MAP);
+      Regs.w.es = BIOSCALLBUFSEGMENT;
+      Regs.w.di = BIOSCALLBUFOFFSET;
+    }
+
+  return MapCount;
+}
+
+U32
+PcMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize)
+{
+  U32 EntryCount;
+
+  EntryCount = PcMemGetBiosMemoryMap(BiosMemoryMap, MaxMemoryMapSize);
+
+  /* If the BIOS didn't provide a memory map, synthesize one */
+  if (0 == EntryCount && 2 <= MaxMemoryMapSize)
+    {
+      /* Conventional memory */
+      BiosMemoryMap[0].BaseAddress = 0;
+      BiosMemoryMap[0].Length = PcMemGetConventionalMemorySize() * 1024;
+      BiosMemoryMap[0].Type = MEMTYPE_USABLE;
+      /* Extended memory */
+      BiosMemoryMap[1].BaseAddress = 1024 * 1024;
+      BiosMemoryMap[1].Length = PcMemGetExtendedMemorySize() * 1024;
+      BiosMemoryMap[1].Type = MEMTYPE_USABLE;
+      EntryCount = 2;
+    }
+
+  return EntryCount;
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/pcrtc.c

@@ -0,0 +1,107 @@
+/* $Id: pcrtc.c,v 1.1 2004/11/14 22:04:38 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "arch.h"
+#include "machine.h"
+#include "machpc.h"
+
+#define BCD_INT(bcd) (((bcd & 0xf0) >> 4) * 10 + (bcd &0x0f))
+
+VOID
+PcRTCGetCurrentDateTime(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second)
+{
+  REGS Regs;
+
+  if (NULL != Year || NULL != Month || NULL != Day)
+    {
+      /* Some BIOSes, such es the 1998/07/25 system ROM
+       * in the Compaq Deskpro EP/SB, leave CF unchanged
+       * if successful, so CF should be cleared before
+       * calling this function. */
+      __asm__ ("clc");
+
+      /* Int 1Ah AH=04h
+       * TIME - GET REAL-TIME CLOCK DATE (AT,XT286,PS)
+       *
+       * AH = 04h
+       * CF clear to avoid bug
+       * Return:
+       * CF clear if successful
+       * CH = century (BCD)
+       * CL = year (BCD)
+       * DH = month (BCD)
+       * DL = day (BCD)
+       * CF set on error
+       */
+      Regs.b.ah = 0x04;
+      Int386(0x1A, &Regs, &Regs);
+
+      if (NULL != Year)
+        {
+          *Year = 100 * BCD_INT(Regs.b.cl) + BCD_INT(Regs.b.ch);
+        }
+      if (NULL != Month)
+        {
+          *Month = BCD_INT(Regs.b.dh);
+        }
+      if (NULL != Day)
+        {
+          *Day = BCD_INT(Regs.b.dl);
+        }
+    }
+
+  if (NULL != Hour || NULL != Minute || NULL != Second)
+    {
+      /* Some BIOSes leave CF unchanged if successful,
+       * so CF should be cleared before calling this function. */
+      __asm__ ("clc");
+
+      /* Int 1Ah AH=02h
+       * TIME - GET REAL-TIME CLOCK TIME (AT,XT286,PS)
+       *
+       * AH = 02h
+       * CF clear to avoid bug
+       * Return:
+       * CF clear if successful
+       * CH = hour (BCD)
+       * CL = minutes (BCD)
+       * DH = seconds (BCD)
+       * DL = daylight savings flag (00h standard time, 01h daylight time)
+       * CF set on error (i.e. clock not running or in middle of update)
+       */
+      Regs.b.ah = 0x02;
+      Int386(0x1A, &Regs, &Regs);
+
+      if (NULL != Hour)
+        {
+          *Hour = BCD_INT(Regs.b.ch);
+        }
+      if (NULL != Minute)
+        {
+          *Minute = BCD_INT(Regs.b.cl);
+        }
+      if (NULL != Second)
+        {
+          *Second = BCD_INT(Regs.b.dh);
+        }
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxcons.c

@@ -0,0 +1,78 @@
+/* $Id: xboxcons.c,v 1.1 2004/11/14 22:04:38 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+#include "machxbox.h"
+
+static unsigned CurrentCursorX = 0;
+static unsigned CurrentCursorY = 0;
+static unsigned CurrentAttr = 0x0f;
+
+VOID
+XboxConsPutChar(int c)
+{
+  U32 Width;
+  U32 Height;
+  U32 Depth;
+
+  if ('\r' == c)
+    {
+      CurrentCursorX = 0;
+    }
+  else if ('\n' == c)
+    {
+      CurrentCursorX = 0;
+      CurrentCursorY++;
+    }
+  else if ('\t' == c)
+    {
+      CurrentCursorX = (CurrentCursorX + 8) & ~ 7;
+    }
+  else
+    {
+      XboxVideoPutChar(c, CurrentAttr, CurrentCursorX, CurrentCursorY);
+      CurrentCursorX++;
+    }
+  XboxVideoGetDisplaySize(&Width, &Height, &Depth);
+  if (Width <= CurrentCursorX)
+    {
+      CurrentCursorX = 0;
+      CurrentCursorY++;
+    }
+}
+
+BOOL
+XboxConsKbHit(VOID)
+{
+  /* No keyboard support yet */
+  return FALSE;
+}
+
+int
+XboxConsGetCh(void)
+{
+  /* No keyboard support yet */
+  while (1)
+    {
+      ;
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxdisk.c

@@ -0,0 +1,575 @@
+/* $Id: xboxdisk.c,v 1.3 2004/11/12 17:17:07 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: mostly ripped from atapi.c
+ *       Some of this code was based on knowledge and/or code developed
+ *       by the Xbox Linux group: http://www.xbox-linux.org
+ *
+ */
+
+#include "freeldr.h"
+#include "debug.h"
+#include "hardware.h"
+#include "machine.h"
+#include "machxbox.h"
+#include "portio.h"
+#include "rtl.h"
+
+#define XBOX_IDE_COMMAND_PORT 0x1f0
+#define XBOX_IDE_CONTROL_PORT 0x170
+
+#define XBOX_SIGNATURE_SECTOR 3
+#define XBOX_SIGNATURE        ('B' | ('R' << 8) | ('F' << 16) | ('R' << 24))
+
+static struct
+{
+  U32 SectorCountBeforePartition;
+  U32 PartitionSectorCount;
+  U8 SystemIndicator;
+} XboxPartitions[] =
+{
+  /* This is in the \Device\Harddisk0\Partition.. order used by the Xbox kernel */
+  { 0x0055F400, 0x0098f800, PARTITION_FAT32  }, /* Store, E: */
+  { 0x00465400, 0x000FA000, PARTITION_FAT_16 }, /* System, C: */
+  { 0x00000400, 0x00177000, PARTITION_FAT_16 }, /* Cache1, X: */
+  { 0x00177400, 0x00177000, PARTITION_FAT_16 }, /* Cache2, Y: */
+  { 0x002EE400, 0x00177000, PARTITION_FAT_16 }  /* Cache3, Z: */
+};
+
+#define  IDE_SECTOR_BUF_SZ         512
+#define  IDE_MAX_POLL_RETRIES      100000
+#define  IDE_MAX_BUSY_RETRIES      50000
+
+/* Control Block offsets and masks */
+#define  IDE_REG_ALT_STATUS     0x0000
+#define  IDE_REG_DEV_CNTRL      0x0000  /* device control register */
+#define    IDE_DC_SRST            0x04  /* drive reset (both drives) */
+#define    IDE_DC_nIEN            0x02  /* IRQ enable (active low) */
+#define  IDE_REG_DRV_ADDR       0x0001
+
+/* Command Block offsets and masks */
+#define  IDE_REG_DATA_PORT      0x0000
+#define  IDE_REG_ERROR          0x0001  /* error register */
+#define    IDE_ER_AMNF            0x01  /* addr mark not found */
+#define    IDE_ER_TK0NF           0x02  /* track 0 not found */
+#define    IDE_ER_ABRT            0x04  /* command aborted */
+#define    IDE_ER_MCR             0x08  /* media change requested */
+#define    IDE_ER_IDNF            0x10  /* ID not found */
+#define    IDE_ER_MC              0x20  /* Media changed */
+#define    IDE_ER_UNC             0x40  /* Uncorrectable data error */
+#define  IDE_REG_PRECOMP        0x0001
+#define  IDE_REG_SECTOR_CNT     0x0002
+#define  IDE_REG_SECTOR_NUM     0x0003
+#define  IDE_REG_CYL_LOW        0x0004
+#define  IDE_REG_CYL_HIGH       0x0005
+#define  IDE_REG_DRV_HEAD       0x0006
+#define    IDE_DH_FIXED           0xA0
+#define    IDE_DH_LBA             0x40
+#define    IDE_DH_HDMASK          0x0F
+#define    IDE_DH_DRV0            0x00
+#define    IDE_DH_DRV1            0x10
+#define  IDE_REG_STATUS           0x0007
+#define    IDE_SR_BUSY              0x80
+#define    IDE_SR_DRDY              0x40
+#define    IDE_SR_WERR              0x20
+#define    IDE_SR_DRQ               0x08
+#define    IDE_SR_ERR               0x01
+#define  IDE_REG_COMMAND          0x0007
+
+/* IDE/ATA commands */
+#define    IDE_CMD_RESET            0x08
+#define    IDE_CMD_READ             0x20
+#define    IDE_CMD_READ_RETRY       0x21
+#define    IDE_CMD_WRITE            0x30
+#define    IDE_CMD_WRITE_RETRY      0x31
+#define    IDE_CMD_PACKET           0xA0
+#define    IDE_CMD_READ_MULTIPLE    0xC4
+#define    IDE_CMD_WRITE_MULTIPLE   0xC5
+#define    IDE_CMD_READ_DMA         0xC8
+#define    IDE_CMD_WRITE_DMA        0xCA
+#define    IDE_CMD_FLUSH_CACHE      0xE7
+#define    IDE_CMD_FLUSH_CACHE_EXT  0xEA
+#define    IDE_CMD_IDENT_ATA_DRV    0xEC
+#define    IDE_CMD_IDENT_ATAPI_DRV  0xA1
+#define    IDE_CMD_GET_MEDIA_STATUS 0xDA
+
+/*
+ *  Access macros for command registers
+ *  Each macro takes an address of the command port block, and data
+ */
+#define IDEReadError(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_ERROR)))
+#define IDEWritePrecomp(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_PRECOMP), (Data)))
+#define IDEReadSectorCount(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_SECTOR_CNT)))
+#define IDEWriteSectorCount(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_SECTOR_CNT), (Data)))
+#define IDEReadSectorNum(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_SECTOR_NUM)))
+#define IDEWriteSectorNum(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_SECTOR_NUM), (Data)))
+#define IDEReadCylinderLow(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_CYL_LOW)))
+#define IDEWriteCylinderLow(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_CYL_LOW), (Data)))
+#define IDEReadCylinderHigh(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_CYL_HIGH)))
+#define IDEWriteCylinderHigh(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_CYL_HIGH), (Data)))
+#define IDEReadDriveHead(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_DRV_HEAD)))
+#define IDEWriteDriveHead(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_DRV_HEAD), (Data)))
+#define IDEReadStatus(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_STATUS)))
+#define IDEWriteCommand(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_COMMAND), (Data)))
+#define IDEReadDMACommand(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address))))
+#define IDEWriteDMACommand(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address)), (Data)))
+#define IDEReadDMAStatus(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + 2)))
+#define IDEWriteDMAStatus(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + 2), (Data)))
+#define IDEWritePRDTable(Address, Data) \
+  (WRITE_PORT_ULONG((PULONG)((Address) + 4), (Data)))  
+
+/*
+ *  Data block read and write commands
+ */
+#define IDEReadBlock(Address, Buffer, Count) \
+  (READ_PORT_BUFFER_USHORT((PU16)((Address) + IDE_REG_DATA_PORT), (PU16)(Buffer), (Count) / 2))
+#define IDEWriteBlock(Address, Buffer, Count) \
+  (WRITE_PORT_BUFFER_USHORT((PU16)((Address) + IDE_REG_DATA_PORT), (PU16)(Buffer), (Count) / 2))
+
+#define IDEReadBlock32(Address, Buffer, Count) \
+  (READ_PORT_BUFFER_ULONG((PU32)((Address) + IDE_REG_DATA_PORT), (PU32)(Buffer), (Count) / 4))
+#define IDEWriteBlock32(Address, Buffer, Count) \
+  (WRITE_PORT_BUFFER_ULONG((PU32)((Address) + IDE_REG_DATA_PORT), (PU32)(Buffer), (Count) / 4))
+
+#define IDEReadWord(Address) \
+  (READ_PORT_USHORT((PU16)((Address) + IDE_REG_DATA_PORT)))
+
+/*
+ *  Access macros for control registers
+ *  Each macro takes an address of the control port blank and data
+ */
+#define IDEReadAltStatus(Address) \
+  (READ_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_ALT_STATUS)))
+#define IDEWriteDriveControl(Address, Data) \
+  (WRITE_PORT_UCHAR((PUCHAR)((Address) + IDE_REG_DEV_CNTRL), (Data)))
+
+/* IDE_DRIVE_IDENTIFY */
+
+typedef struct _IDE_DRIVE_IDENTIFY
+{
+  U16   ConfigBits;          /*00*/
+  U16   LogicalCyls;         /*01*/
+  U16   Reserved02;          /*02*/
+  U16   LogicalHeads;        /*03*/
+  U16   BytesPerTrack;       /*04*/
+  U16   BytesPerSector;      /*05*/
+  U16   SectorsPerTrack;     /*06*/
+  U8    InterSectorGap;      /*07*/
+  U8    InterSectorGapSize;
+  U8    Reserved08H;         /*08*/
+  U8    BytesInPLO;
+  U16   VendorUniqueCnt;     /*09*/
+  char  SerialNumber[20];    /*10*/
+  U16   ControllerType;      /*20*/
+  U16   BufferSize;          /*21*/
+  U16   ECCByteCnt;          /*22*/
+  char  FirmwareRev[8];      /*23*/
+  char  ModelNumber[40];     /*27*/
+  U16   RWMultImplemented;   /*47*/
+  U16   DWordIo;	     /*48*/
+  U16   Capabilities;        /*49*/
+#define IDE_DRID_STBY_SUPPORTED   0x2000
+#define IDE_DRID_IORDY_SUPPORTED  0x0800
+#define IDE_DRID_IORDY_DISABLE    0x0400
+#define IDE_DRID_LBA_SUPPORTED    0x0200
+#define IDE_DRID_DMA_SUPPORTED    0x0100
+  U16   Reserved50;          /*50*/
+  U16   MinPIOTransTime;     /*51*/
+  U16   MinDMATransTime;     /*52*/
+  U16   TMFieldsValid;       /*53*/
+  U16   TMCylinders;         /*54*/
+  U16   TMHeads;             /*55*/
+  U16   TMSectorsPerTrk;     /*56*/
+  U16   TMCapacityLo;        /*57*/
+  U16   TMCapacityHi;        /*58*/
+  U16   RWMultCurrent;       /*59*/
+  U16   TMSectorCountLo;     /*60*/
+  U16   TMSectorCountHi;     /*61*/
+  U16   DmaModes;            /*62*/
+  U16   MultiDmaModes;       /*63*/
+  U16   Reserved64[5];       /*64*/
+  U16   Reserved69[2];       /*69*/
+  U16   Reserved71[4];       /*71*/
+  U16   MaxQueueDepth;       /*75*/
+  U16   Reserved76[4];       /*76*/
+  U16   MajorRevision;       /*80*/
+  U16   MinorRevision;       /*81*/
+  U16   SupportedFeatures82; /*82*/
+  U16   SupportedFeatures83; /*83*/
+  U16   SupportedFeatures84; /*84*/
+  U16   EnabledFeatures85;   /*85*/
+  U16   EnabledFeatures86;   /*86*/
+  U16   EnabledFeatures87;   /*87*/
+  U16   UltraDmaModes;       /*88*/
+  U16   Reserved89[11];      /*89*/
+  U16   Max48BitAddress[4];  /*100*/
+  U16   Reserved104[151];    /*104*/
+  U16   Checksum;            /*255*/
+} IDE_DRIVE_IDENTIFY, *PIDE_DRIVE_IDENTIFY;
+
+/*  XboxDiskPolledRead
+ *
+ *  DESCRIPTION:
+ *    Read a sector of data from the drive in a polled fashion.
+ *
+ *  RUN LEVEL:
+ *    PASSIVE_LEVEL
+ *
+ *  ARGUMENTS:
+ *    U32   CommandPort   Address of command port for drive
+ *    U32   ControlPort   Address of control port for drive
+ *    U8    PreComp       Value to write to precomp register
+ *    U8    SectorCnt     Value to write to sectorCnt register
+ *    U8    SectorNum     Value to write to sectorNum register
+ *    U8    CylinderLow   Value to write to CylinderLow register
+ *    U8    CylinderHigh  Value to write to CylinderHigh register
+ *    U8    DrvHead       Value to write to Drive/Head register
+ *    U8    Command       Value to write to Command register
+ *    PVOID Buffer        Buffer for output data
+ *
+ *  RETURNS:
+ *    BOOL: TRUE success, FALSE error
+ */
+
+static BOOL
+XboxDiskPolledRead(U32 CommandPort,
+                   U32 ControlPort,
+                   U8 PreComp,
+                   U8 SectorCnt,
+                   U8 SectorNum,
+                   U8 CylinderLow,
+                   U8 CylinderHigh,
+                   U8 DrvHead,
+                   U8 Command,
+                   PVOID Buffer)
+{
+  U32 SectorCount = 0;
+  U32 RetryCount;
+  BOOL Junk = FALSE;
+  U8 Status;
+
+  /* Wait for BUSY to clear */
+  for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
+    {
+      Status = IDEReadStatus(CommandPort);
+      if (!(Status & IDE_SR_BUSY))
+        {
+          break;
+        }
+      KeStallExecutionProcessor(10);
+    }
+  DbgPrint((DPRINT_DISK, "status=0x%x\n", Status));
+  DbgPrint((DPRINT_DISK, "waited %d usecs for busy to clear\n", RetryCount * 10));
+  if (RetryCount >= IDE_MAX_BUSY_RETRIES)
+    {
+      DbgPrint((DPRINT_DISK, "Drive is BUSY for too long\n"));
+      return FALSE;
+    }
+
+  /*  Write Drive/Head to select drive  */
+  IDEWriteDriveHead(CommandPort, IDE_DH_FIXED | DrvHead);
+  KeStallExecutionProcessor(500);
+
+  /* Disable interrupts */
+  IDEWriteDriveControl(ControlPort, IDE_DC_nIEN);
+  KeStallExecutionProcessor(500);
+
+  /*  Issue command to drive  */
+  if (DrvHead & IDE_DH_LBA)
+    {
+      DbgPrint((DPRINT_DISK, "READ:DRV=%d:LBA=1:BLK=%d:SC=0x%x:CM=0x%x\n",
+                DrvHead & IDE_DH_DRV1 ? 1 : 0,
+                ((DrvHead & 0x0f) << 24) + (CylinderHigh << 16) + (CylinderLow << 8) + SectorNum,
+                SectorCnt,
+                Command));
+    }
+  else
+    {
+      DbgPrint((DPRINT_DISK, "READ:DRV=%d:LBA=0:CH=0x%x:CL=0x%x:HD=0x%x:SN=0x%x:SC=0x%x:CM=0x%x\n",
+                DrvHead & IDE_DH_DRV1 ? 1 : 0,
+                CylinderHigh,
+                CylinderLow,
+                DrvHead & 0x0f,
+                SectorNum,
+                SectorCnt,
+                Command));
+    }
+
+  /*  Setup command parameters  */
+  IDEWritePrecomp(CommandPort, PreComp);
+  IDEWriteSectorCount(CommandPort, SectorCnt);
+  IDEWriteSectorNum(CommandPort, SectorNum);
+  IDEWriteCylinderHigh(CommandPort, CylinderHigh);
+  IDEWriteCylinderLow(CommandPort, CylinderLow);
+  IDEWriteDriveHead(CommandPort, IDE_DH_FIXED | DrvHead);
+
+  /*  Issue the command  */
+  IDEWriteCommand(CommandPort, Command);
+  KeStallExecutionProcessor(50);
+
+  /*  wait for DRQ or error  */
+  for (RetryCount = 0; RetryCount < IDE_MAX_POLL_RETRIES; RetryCount++)
+    {
+      Status = IDEReadStatus(CommandPort);
+      if (!(Status & IDE_SR_BUSY))
+	{
+	  if (Status & IDE_SR_ERR)
+	    {
+	      IDEWriteDriveControl(ControlPort, 0);
+	      KeStallExecutionProcessor(50);
+	      IDEReadStatus(CommandPort);
+
+	      return FALSE;
+	    }
+
+	  if (Status & IDE_SR_DRQ)
+	    {
+	      break;
+	    }
+	  else
+	    {
+	      IDEWriteDriveControl(ControlPort, 0);
+	      KeStallExecutionProcessor(50);
+	      IDEReadStatus(CommandPort);
+
+	      return FALSE;
+	    }
+	}
+      KeStallExecutionProcessor(10);
+    }
+
+  /*  timed out  */
+  if (RetryCount >= IDE_MAX_POLL_RETRIES)
+    {
+      IDEWriteDriveControl(ControlPort, 0);
+      KeStallExecutionProcessor(50);
+      IDEReadStatus(CommandPort);
+
+      return FALSE;
+    }
+
+  while (1)
+    {
+      /*  Read data into buffer  */
+      if (Junk == FALSE)
+	{
+	  IDEReadBlock(CommandPort, Buffer, IDE_SECTOR_BUF_SZ);
+	  Buffer += IDE_SECTOR_BUF_SZ;
+	}
+      else
+	{
+	  UCHAR JunkBuffer[IDE_SECTOR_BUF_SZ];
+	  IDEReadBlock(CommandPort, JunkBuffer, IDE_SECTOR_BUF_SZ);
+	}
+      SectorCount++;
+
+      /*  Check for error or more sectors to read  */
+      for (RetryCount = 0; RetryCount < IDE_MAX_BUSY_RETRIES; RetryCount++)
+	{
+	  Status = IDEReadStatus(CommandPort);
+	  if (!(Status & IDE_SR_BUSY))
+	    {
+	      if (Status & IDE_SR_ERR)
+		{
+		  IDEWriteDriveControl(ControlPort, 0);
+		  KeStallExecutionProcessor(50);
+		  IDEReadStatus(CommandPort);
+
+		  return FALSE;
+		}
+	      if (Status & IDE_SR_DRQ)
+		{
+		  if (SectorCount >= SectorCnt)
+		    {
+		      DbgPrint((DPRINT_DISK, "Buffer size exceeded!\n"));
+		      Junk = TRUE;
+		    }
+		  break;
+		}
+	      else
+		{
+		  if (SectorCount > SectorCnt)
+		    {
+		      DbgPrint((DPRINT_DISK, "Read %lu sectors of junk!\n",
+                                SectorCount - SectorCnt));
+		    }
+		  IDEWriteDriveControl(ControlPort, 0);
+		  KeStallExecutionProcessor(50);
+		  IDEReadStatus(CommandPort);
+
+		  return TRUE;
+		}
+	    }
+	}
+    }
+}
+
+BOOL
+XboxDiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+{
+  U32 StartSector;
+  U8 Count;
+
+  if (DriveNumber < 0x80 || 2 <= (DriveNumber & 0x0f))
+    {
+      /* Xbox has only 1 IDE controller and no floppy */
+      DbgPrint((DPRINT_DISK, "Invalid drive number\n"));
+      return FALSE;
+    }
+
+  if (UINT64_C(0) != ((SectorNumber + SectorCount) & UINT64_C(0xfffffffff0000000)))
+    {
+      DbgPrint((DPRINT_DISK, "48bit LBA required but not implemented\n"));
+      return FALSE;
+    }
+
+  StartSector = (U32) SectorNumber;
+  while (0 < SectorCount)
+    {
+      Count = (SectorCount <= 255 ? SectorCount : 255);
+      if (! XboxDiskPolledRead(XBOX_IDE_COMMAND_PORT,
+                               XBOX_IDE_CONTROL_PORT,
+                               0, Count,
+                               StartSector & 0xff,
+                               (StartSector >> 8) & 0xff,
+                               (StartSector >> 16) & 0xff,
+                               ((StartSector >> 24) & 0x0f) | IDE_DH_LBA |
+                               (0 == (DriveNumber & 0x0f) ? IDE_DH_DRV0 : IDE_DH_DRV1),
+                               IDE_CMD_READ,
+                                Buffer))
+        {
+          return FALSE;
+        }
+      SectorCount -= Count;
+      Buffer = (PVOID) ((PCHAR) Buffer + Count * IDE_SECTOR_BUF_SZ);
+    }
+
+  return TRUE;
+}
+
+BOOL
+XboxDiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+  U8 SectorData[IDE_SECTOR_BUF_SZ];
+
+  /* This is the Xbox, chances are that there is a Xbox-standard partitionless
+   * disk in it so let's check that first */
+
+  if (1 <= PartitionNumber && PartitionNumber <= sizeof(XboxPartitions) / sizeof(XboxPartitions[0]) &&
+      MachDiskReadLogicalSectors(DriveNumber, XBOX_SIGNATURE_SECTOR, 1, SectorData))
+    {
+      if (*((PU32) SectorData) == XBOX_SIGNATURE)
+        {
+          memset(PartitionTableEntry, 0, sizeof(PARTITION_TABLE_ENTRY));
+          PartitionTableEntry->SystemIndicator = XboxPartitions[PartitionNumber - 1].SystemIndicator;
+          PartitionTableEntry->SectorCountBeforePartition = XboxPartitions[PartitionNumber - 1].SectorCountBeforePartition;
+          PartitionTableEntry->PartitionSectorCount = XboxPartitions[PartitionNumber - 1].PartitionSectorCount;
+          return TRUE;
+        }
+    }
+
+  /* No magic Xbox partitions. Maybe there's a MBR */
+  return DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
+}
+
+BOOL
+XboxDiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY Geometry)
+{
+  IDE_DRIVE_IDENTIFY DrvParms;
+  U32 i;
+  BOOL Atapi;
+
+  Atapi = FALSE; /* FIXME */
+  /*  Get the Drive Identify block from drive or die  */
+  if (! XboxDiskPolledRead(XBOX_IDE_COMMAND_PORT,
+                           XBOX_IDE_CONTROL_PORT,
+                           0,
+                           1,
+                           0,
+                           0,
+                           0,
+                           (0 == (DriveNumber & 0x0f) ? IDE_DH_DRV0 : IDE_DH_DRV1),
+                           (Atapi ? IDE_CMD_IDENT_ATAPI_DRV : IDE_CMD_IDENT_ATA_DRV),
+                           (PUCHAR) &DrvParms))
+    {
+      DbgPrint((DPRINT_DISK, "XboxDiskPolledRead() failed\n"));
+      return FALSE;
+    }
+
+  Geometry->Cylinders = DrvParms.LogicalCyls;
+  Geometry->Heads = DrvParms.LogicalHeads;
+  Geometry->Sectors = DrvParms.SectorsPerTrack;
+
+  if (! Atapi && 0 != (DrvParms.Capabilities & IDE_DRID_LBA_SUPPORTED))
+    {
+      /* LBA ATA drives always have a sector size of 512 */
+      Geometry->BytesPerSector = 512;
+    }
+  else
+    {
+      DbgPrint((DPRINT_DISK, "BytesPerSector %d\n", DrvParms.BytesPerSector));
+      if (DrvParms.BytesPerSector == 0)
+        {
+          Geometry->BytesPerSector = 512;
+        }
+      else
+        {
+          for (i = 15; i >= 0; i--)
+            {
+              if (0 != (DrvParms.BytesPerSector & (1 << i)))
+                {
+                  Geometry->BytesPerSector = 1 << i;
+                  break;
+                }
+            }
+        }
+    }
+  DbgPrint((DPRINT_DISK, "Cylinders %d\n", Geometry->Cylinders));
+  DbgPrint((DPRINT_DISK, "Heads %d\n", Geometry->Heads));
+  DbgPrint((DPRINT_DISK, "Sectors %d\n", Geometry->Sectors));
+  DbgPrint((DPRINT_DISK, "BytesPerSector %d\n", Geometry->BytesPerSector));
+
+  return TRUE;
+}
+
+U32
+XboxDiskGetCacheableBlockCount(U32 DriveNumber)
+{
+  /* 64 seems a nice number, it is used by the machpc code for LBA devices */
+  return 64;
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxfont.c

@@ -0,0 +1,287 @@
+/* $Id: xboxfont.c,v 1.2 2004/11/10 23:45:37 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: Converted from the XFree vga.bdf font
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+#include "machxbox.h"
+
+U8 XboxFont8x16[256 * 16] =
+{
+  0x00,0x00,0x00,0x7c,0xc6,0xc6,0xde,0xde,0xde,0xdc,0xc0,0x7c,0x00,0x00,0x00,0x00, /* 0x00 */
+  0x00,0x00,0x7e,0x81,0xa5,0x81,0x81,0xa5,0x99,0x81,0x81,0x7e,0x00,0x00,0x00,0x00, /* 0x01 */
+  0x00,0x00,0x7e,0xff,0xdb,0xff,0xff,0xdb,0xe7,0xff,0xff,0x7e,0x00,0x00,0x00,0x00, /* 0x02 */
+  0x00,0x00,0x00,0x00,0x6c,0xfe,0xfe,0xfe,0xfe,0x7c,0x38,0x10,0x00,0x00,0x00,0x00, /* 0x03 */
+  0x00,0x00,0x00,0x00,0x10,0x38,0x7c,0xfe,0x7c,0x38,0x10,0x00,0x00,0x00,0x00,0x00, /* 0x04 */
+  0x00,0x00,0x00,0x18,0x3c,0x3c,0xe7,0xe7,0xe7,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0x05 */
+  0x00,0x00,0x00,0x18,0x3c,0x7e,0xff,0xff,0x7e,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0x06 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x3c,0x3c,0x18,0x00,0x00,0x00,0x00,0x00,0x00, /* 0x07 */
+  0xff,0xff,0xff,0xff,0xff,0xff,0xe7,0xc3,0xc3,0xe7,0xff,0xff,0xff,0xff,0xff,0xff, /* 0x08 */
+  0x00,0x00,0x00,0x00,0x00,0x3c,0x66,0x42,0x42,0x66,0x3c,0x00,0x00,0x00,0x00,0x00, /* 0x09 */
+  0xff,0xff,0xff,0xff,0xff,0xc3,0x99,0xbd,0xbd,0x99,0xc3,0xff,0xff,0xff,0xff,0xff, /* 0x0a */
+  0x00,0x00,0x1e,0x06,0x0e,0x1a,0x78,0xcc,0xcc,0xcc,0xcc,0x78,0x00,0x00,0x00,0x00, /* 0x0b */
+  0x00,0x00,0x3c,0x66,0x66,0x66,0x66,0x3c,0x18,0x7e,0x18,0x18,0x00,0x00,0x00,0x00, /* 0x0c */
+  0x00,0x00,0x3f,0x33,0x3f,0x30,0x30,0x30,0x30,0x70,0xf0,0xe0,0x00,0x00,0x00,0x00, /* 0x0d */
+  0x00,0x00,0x7f,0x63,0x7f,0x63,0x63,0x63,0x63,0x67,0xe7,0xe6,0xc0,0x00,0x00,0x00, /* 0x0e */
+  0x00,0x00,0x00,0x18,0x18,0xdb,0x3c,0xe7,0x3c,0xdb,0x18,0x18,0x00,0x00,0x00,0x00, /* 0x0f */
+  0x00,0x80,0xc0,0xe0,0xf0,0xf8,0xfe,0xf8,0xf0,0xe0,0xc0,0x80,0x00,0x00,0x00,0x00, /* 0x10 */
+  0x00,0x02,0x06,0x0e,0x1e,0x3e,0xfe,0x3e,0x1e,0x0e,0x06,0x02,0x00,0x00,0x00,0x00, /* 0x11 */
+  0x00,0x00,0x18,0x3c,0x7e,0x18,0x18,0x18,0x7e,0x3c,0x18,0x00,0x00,0x00,0x00,0x00, /* 0x12 */
+  0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x66,0x66,0x00,0x66,0x66,0x00,0x00,0x00,0x00, /* 0x13 */
+  0x00,0x00,0x7f,0xdb,0xdb,0xdb,0x7b,0x1b,0x1b,0x1b,0x1b,0x1b,0x00,0x00,0x00,0x00, /* 0x14 */
+  0x00,0x7c,0xc6,0x60,0x38,0x6c,0xc6,0xc6,0x6c,0x38,0x0c,0xc6,0x7c,0x00,0x00,0x00, /* 0x15 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0xfe,0xfe,0xfe,0x00,0x00,0x00,0x00, /* 0x16 */
+  0x00,0x00,0x18,0x3c,0x7e,0x18,0x18,0x18,0x7e,0x3c,0x18,0x7e,0x00,0x00,0x00,0x00, /* 0x17 */
+  0x00,0x00,0x18,0x3c,0x7e,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00, /* 0x18 */
+  0x00,0x00,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x7e,0x3c,0x18,0x00,0x00,0x00,0x00, /* 0x19 */
+  0x00,0x00,0x00,0x00,0x00,0x18,0x0c,0xfe,0x0c,0x18,0x00,0x00,0x00,0x00,0x00,0x00, /* 0x1a */
+  0x00,0x00,0x00,0x00,0x00,0x30,0x60,0xfe,0x60,0x30,0x00,0x00,0x00,0x00,0x00,0x00, /* 0x1b */
+  0x00,0x00,0x00,0x00,0x00,0x00,0xc0,0xc0,0xc0,0xfe,0x00,0x00,0x00,0x00,0x00,0x00, /* 0x1c */
+  0x00,0x00,0x00,0x00,0x00,0x28,0x6c,0xfe,0x6c,0x28,0x00,0x00,0x00,0x00,0x00,0x00, /* 0x1d */
+  0x00,0x00,0x00,0x00,0x10,0x38,0x38,0x7c,0x7c,0xfe,0xfe,0x00,0x00,0x00,0x00,0x00, /* 0x1e */
+  0x00,0x00,0x00,0x00,0xfe,0xfe,0x7c,0x7c,0x38,0x38,0x10,0x00,0x00,0x00,0x00,0x00, /* 0x1f */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /*   */
+  0x00,0x00,0x18,0x3c,0x3c,0x3c,0x18,0x18,0x18,0x00,0x18,0x18,0x00,0x00,0x00,0x00, /* ! */
+  0x00,0x66,0x66,0x66,0x24,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* " */
+  0x00,0x00,0x00,0x6c,0x6c,0xfe,0x6c,0x6c,0x6c,0xfe,0x6c,0x6c,0x00,0x00,0x00,0x00, /* # */
+  0x18,0x18,0x7c,0xc6,0xc2,0xc0,0x7c,0x06,0x06,0x86,0xc6,0x7c,0x18,0x18,0x00,0x00, /* $ */
+  0x00,0x00,0x00,0x00,0xc2,0xc6,0x0c,0x18,0x30,0x60,0xc6,0x86,0x00,0x00,0x00,0x00, /* % */
+  0x00,0x00,0x38,0x6c,0x6c,0x38,0x76,0xdc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* & */
+  0x00,0x30,0x30,0x30,0x60,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ' */
+  0x00,0x00,0x0c,0x18,0x30,0x30,0x30,0x30,0x30,0x30,0x18,0x0c,0x00,0x00,0x00,0x00, /* ( */
+  0x00,0x00,0x30,0x18,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x18,0x30,0x00,0x00,0x00,0x00, /* ) */
+  0x00,0x00,0x00,0x00,0x00,0x66,0x3c,0xff,0x3c,0x66,0x00,0x00,0x00,0x00,0x00,0x00, /* * */
+  0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x7e,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00, /* + */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x18,0x30,0x00,0x00,0x00, /* , */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* - */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00, /* . */
+  0x00,0x00,0x00,0x00,0x02,0x06,0x0c,0x18,0x30,0x60,0xc0,0x80,0x00,0x00,0x00,0x00, /* / */
+  0x00,0x00,0x38,0x6c,0xc6,0xc6,0xd6,0xd6,0xc6,0xc6,0x6c,0x38,0x00,0x00,0x00,0x00, /* 0 */
+  0x00,0x00,0x18,0x38,0x78,0x18,0x18,0x18,0x18,0x18,0x18,0x7e,0x00,0x00,0x00,0x00, /* 1 */
+  0x00,0x00,0x7c,0xc6,0x06,0x0c,0x18,0x30,0x60,0xc0,0xc6,0xfe,0x00,0x00,0x00,0x00, /* 2 */
+  0x00,0x00,0x7c,0xc6,0x06,0x06,0x3c,0x06,0x06,0x06,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 3 */
+  0x00,0x00,0x0c,0x1c,0x3c,0x6c,0xcc,0xfe,0x0c,0x0c,0x0c,0x1e,0x00,0x00,0x00,0x00, /* 4 */
+  0x00,0x00,0xfe,0xc0,0xc0,0xc0,0xfc,0x06,0x06,0x06,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 5 */
+  0x00,0x00,0x38,0x60,0xc0,0xc0,0xfc,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 6 */
+  0x00,0x00,0xfe,0xc6,0x06,0x06,0x0c,0x18,0x30,0x30,0x30,0x30,0x00,0x00,0x00,0x00, /* 7 */
+  0x00,0x00,0x7c,0xc6,0xc6,0xc6,0x7c,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 8 */
+  0x00,0x00,0x7c,0xc6,0xc6,0xc6,0x7e,0x06,0x06,0x06,0x0c,0x78,0x00,0x00,0x00,0x00, /* 9 */
+  0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00, /* : */
+  0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x18,0x18,0x30,0x00,0x00,0x00,0x00, /* ; */
+  0x00,0x00,0x00,0x06,0x0c,0x18,0x30,0x60,0x30,0x18,0x0c,0x06,0x00,0x00,0x00,0x00, /* < */
+  0x00,0x00,0x00,0x00,0x00,0x7e,0x00,0x00,0x7e,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* = */
+  0x00,0x00,0x00,0x60,0x30,0x18,0x0c,0x06,0x0c,0x18,0x30,0x60,0x00,0x00,0x00,0x00, /* > */
+  0x00,0x00,0x7c,0xc6,0xc6,0x0c,0x18,0x18,0x18,0x00,0x18,0x18,0x00,0x00,0x00,0x00, /* ? */
+  0x00,0x00,0x00,0x7c,0xc6,0xc6,0xde,0xde,0xde,0xdc,0xc0,0x7c,0x00,0x00,0x00,0x00, /* @ */
+  0x00,0x00,0x10,0x38,0x6c,0xc6,0xc6,0xfe,0xc6,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* A */
+  0x00,0x00,0xfc,0x66,0x66,0x66,0x7c,0x66,0x66,0x66,0x66,0xfc,0x00,0x00,0x00,0x00, /* B */
+  0x00,0x00,0x3c,0x66,0xc2,0xc0,0xc0,0xc0,0xc0,0xc2,0x66,0x3c,0x00,0x00,0x00,0x00, /* C */
+  0x00,0x00,0xf8,0x6c,0x66,0x66,0x66,0x66,0x66,0x66,0x6c,0xf8,0x00,0x00,0x00,0x00, /* D */
+  0x00,0x00,0xfe,0x66,0x62,0x68,0x78,0x68,0x60,0x62,0x66,0xfe,0x00,0x00,0x00,0x00, /* E */
+  0x00,0x00,0xfe,0x66,0x62,0x68,0x78,0x68,0x60,0x60,0x60,0xf0,0x00,0x00,0x00,0x00, /* F */
+  0x00,0x00,0x3c,0x66,0xc2,0xc0,0xc0,0xde,0xc6,0xc6,0x66,0x3a,0x00,0x00,0x00,0x00, /* G */
+  0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xfe,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* H */
+  0x00,0x00,0x3c,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* I */
+  0x00,0x00,0x1e,0x0c,0x0c,0x0c,0x0c,0x0c,0xcc,0xcc,0xcc,0x78,0x00,0x00,0x00,0x00, /* J */
+  0x00,0x00,0xe6,0x66,0x66,0x6c,0x78,0x78,0x6c,0x66,0x66,0xe6,0x00,0x00,0x00,0x00, /* K */
+  0x00,0x00,0xf0,0x60,0x60,0x60,0x60,0x60,0x60,0x62,0x66,0xfe,0x00,0x00,0x00,0x00, /* L */
+  0x00,0x00,0xc6,0xee,0xfe,0xfe,0xd6,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* M */
+  0x00,0x00,0xc6,0xe6,0xf6,0xfe,0xde,0xce,0xc6,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* N */
+  0x00,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* O */
+  0x00,0x00,0xfc,0x66,0x66,0x66,0x7c,0x60,0x60,0x60,0x60,0xf0,0x00,0x00,0x00,0x00, /* P */
+  0x00,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xd6,0xde,0x7c,0x0c,0x0e,0x00,0x00, /* Q */
+  0x00,0x00,0xfc,0x66,0x66,0x66,0x7c,0x6c,0x66,0x66,0x66,0xe6,0x00,0x00,0x00,0x00, /* R */
+  0x00,0x00,0x7c,0xc6,0xc6,0x60,0x38,0x0c,0x06,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* S */
+  0x00,0x00,0x7e,0x7e,0x5a,0x18,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* T */
+  0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* U */
+  0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x6c,0x38,0x10,0x00,0x00,0x00,0x00, /* V */
+  0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xd6,0xd6,0xd6,0xfe,0xee,0x6c,0x00,0x00,0x00,0x00, /* W */
+  0x00,0x00,0xc6,0xc6,0x6c,0x7c,0x38,0x38,0x7c,0x6c,0xc6,0xc6,0x00,0x00,0x00,0x00, /* X */
+  0x00,0x00,0x66,0x66,0x66,0x66,0x3c,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* Y */
+  0x00,0x00,0xfe,0xc6,0x86,0x0c,0x18,0x30,0x60,0xc2,0xc6,0xfe,0x00,0x00,0x00,0x00, /* Z */
+  0x00,0x00,0x3c,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x30,0x3c,0x00,0x00,0x00,0x00, /* [ */
+  0x00,0x00,0x00,0x80,0xc0,0xe0,0x70,0x38,0x1c,0x0e,0x06,0x02,0x00,0x00,0x00,0x00, /* \ */
+  0x00,0x00,0x3c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x0c,0x3c,0x00,0x00,0x00,0x00, /* ] */
+  0x10,0x38,0x6c,0xc6,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ^ */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x00,0x00, /* _ */
+  0x30,0x30,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ` */
+  0x00,0x00,0x00,0x00,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* a */
+  0x00,0x00,0xe0,0x60,0x60,0x78,0x6c,0x66,0x66,0x66,0x66,0x7c,0x00,0x00,0x00,0x00, /* b */
+  0x00,0x00,0x00,0x00,0x00,0x7c,0xc6,0xc0,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* c */
+  0x00,0x00,0x1c,0x0c,0x0c,0x3c,0x6c,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* d */
+  0x00,0x00,0x00,0x00,0x00,0x7c,0xc6,0xfe,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* e */
+  0x00,0x00,0x38,0x6c,0x64,0x60,0xf0,0x60,0x60,0x60,0x60,0xf0,0x00,0x00,0x00,0x00, /* f */
+  0x00,0x00,0x00,0x00,0x00,0x76,0xcc,0xcc,0xcc,0xcc,0xcc,0x7c,0x0c,0xcc,0x78,0x00, /* g */
+  0x00,0x00,0xe0,0x60,0x60,0x6c,0x76,0x66,0x66,0x66,0x66,0xe6,0x00,0x00,0x00,0x00, /* h */
+  0x00,0x00,0x18,0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* i */
+  0x00,0x00,0x06,0x06,0x00,0x0e,0x06,0x06,0x06,0x06,0x06,0x06,0x66,0x66,0x3c,0x00, /* j */
+  0x00,0x00,0xe0,0x60,0x60,0x66,0x6c,0x78,0x78,0x6c,0x66,0xe6,0x00,0x00,0x00,0x00, /* k */
+  0x00,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* l */
+  0x00,0x00,0x00,0x00,0x00,0xec,0xfe,0xd6,0xd6,0xd6,0xd6,0xc6,0x00,0x00,0x00,0x00, /* m */
+  0x00,0x00,0x00,0x00,0x00,0xdc,0x66,0x66,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00, /* n */
+  0x00,0x00,0x00,0x00,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* o */
+  0x00,0x00,0x00,0x00,0x00,0xdc,0x66,0x66,0x66,0x66,0x66,0x7c,0x60,0x60,0xf0,0x00, /* p */
+  0x00,0x00,0x00,0x00,0x00,0x76,0xcc,0xcc,0xcc,0xcc,0xcc,0x7c,0x0c,0x0c,0x1e,0x00, /* q */
+  0x00,0x00,0x00,0x00,0x00,0xdc,0x76,0x66,0x60,0x60,0x60,0xf0,0x00,0x00,0x00,0x00, /* r */
+  0x00,0x00,0x00,0x00,0x00,0x7c,0xc6,0x60,0x38,0x0c,0xc6,0x7c,0x00,0x00,0x00,0x00, /* s */
+  0x00,0x00,0x10,0x30,0x30,0xfc,0x30,0x30,0x30,0x30,0x36,0x1c,0x00,0x00,0x00,0x00, /* t */
+  0x00,0x00,0x00,0x00,0x00,0xcc,0xcc,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* u */
+  0x00,0x00,0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x3c,0x18,0x00,0x00,0x00,0x00, /* v */
+  0x00,0x00,0x00,0x00,0x00,0xc6,0xc6,0xd6,0xd6,0xd6,0xfe,0x6c,0x00,0x00,0x00,0x00, /* w */
+  0x00,0x00,0x00,0x00,0x00,0xc6,0x6c,0x38,0x38,0x38,0x6c,0xc6,0x00,0x00,0x00,0x00, /* x */
+  0x00,0x00,0x00,0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7e,0x06,0x0c,0xf8,0x00, /* y */
+  0x00,0x00,0x00,0x00,0x00,0xfe,0xcc,0x18,0x30,0x60,0xc6,0xfe,0x00,0x00,0x00,0x00, /* z */
+  0x00,0x00,0x0e,0x18,0x18,0x18,0x70,0x18,0x18,0x18,0x18,0x0e,0x00,0x00,0x00,0x00, /* { */
+  0x00,0x00,0x18,0x18,0x18,0x18,0x00,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00, /* | */
+  0x00,0x00,0x70,0x18,0x18,0x18,0x0e,0x18,0x18,0x18,0x18,0x70,0x00,0x00,0x00,0x00, /* } */
+  0x00,0x00,0x76,0xdc,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* ~ */
+  0x00,0x00,0x00,0x00,0x10,0x38,0x6c,0xc6,0xc6,0xc6,0xfe,0x00,0x00,0x00,0x00,0x00, /* 0x7f */
+  0x00,0x00,0x3c,0x66,0xc2,0xc0,0xc0,0xc0,0xc2,0x66,0x3c,0x0c,0x06,0x7c,0x00,0x00, /* 0x80 */
+  0x00,0x00,0xcc,0x00,0x00,0xcc,0xcc,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x81 */
+  0x00,0x0c,0x18,0x30,0x00,0x7c,0xc6,0xfe,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x82 */
+  0x00,0x10,0x38,0x6c,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x83 */
+  0x00,0x00,0xcc,0x00,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x84 */
+  0x00,0x60,0x30,0x18,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x85 */
+  0x00,0x38,0x6c,0x38,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x86 */
+  0x00,0x00,0x00,0x00,0x3c,0x66,0x60,0x60,0x66,0x3c,0x0c,0x06,0x3c,0x00,0x00,0x00, /* 0x87 */
+  0x00,0x10,0x38,0x6c,0x00,0x7c,0xc6,0xfe,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x88 */
+  0x00,0x00,0xc6,0x00,0x00,0x7c,0xc6,0xfe,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x89 */
+  0x00,0x60,0x30,0x18,0x00,0x7c,0xc6,0xfe,0xc0,0xc0,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x8a */
+  0x00,0x00,0x66,0x00,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0x8b */
+  0x00,0x18,0x3c,0x66,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0x8c */
+  0x00,0x60,0x30,0x18,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0x8d */
+  0x00,0xc6,0x00,0x10,0x38,0x6c,0xc6,0xc6,0xfe,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* 0x8e */
+  0x38,0x6c,0x38,0x00,0x38,0x6c,0xc6,0xc6,0xfe,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* 0x8f */
+  0x18,0x30,0x60,0x00,0xfe,0x66,0x60,0x7c,0x60,0x60,0x66,0xfe,0x00,0x00,0x00,0x00, /* 0x90 */
+  0x00,0x00,0x00,0x00,0x00,0xcc,0x76,0x36,0x7e,0xd8,0xd8,0x6e,0x00,0x00,0x00,0x00, /* 0x91 */
+  0x00,0x00,0x3e,0x6c,0xcc,0xcc,0xfe,0xcc,0xcc,0xcc,0xcc,0xce,0x00,0x00,0x00,0x00, /* 0x92 */
+  0x00,0x10,0x38,0x6c,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x93 */
+  0x00,0x00,0xc6,0x00,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x94 */
+  0x00,0x60,0x30,0x18,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x95 */
+  0x00,0x30,0x78,0xcc,0x00,0xcc,0xcc,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x96 */
+  0x00,0x60,0x30,0x18,0x00,0xcc,0xcc,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0x97 */
+  0x00,0x00,0xc6,0x00,0x00,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7e,0x06,0x0c,0x78,0x00, /* 0x98 */
+  0x00,0xc6,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x99 */
+  0x00,0xc6,0x00,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0x9a */
+  0x00,0x18,0x18,0x3c,0x66,0x60,0x60,0x60,0x66,0x3c,0x18,0x18,0x00,0x00,0x00,0x00, /* 0x9b */
+  0x00,0x38,0x6c,0x64,0x60,0xf0,0x60,0x60,0x60,0x60,0xe6,0xfc,0x00,0x00,0x00,0x00, /* 0x9c */
+  0x00,0x00,0x66,0x66,0x3c,0x18,0x7e,0x18,0x7e,0x18,0x18,0x18,0x00,0x00,0x00,0x00, /* 0x9d */
+  0x00,0xf8,0xcc,0xcc,0xf8,0xc4,0xcc,0xde,0xcc,0xcc,0xcc,0xc6,0x00,0x00,0x00,0x00, /* 0x9e */
+  0x00,0x0e,0x1b,0x18,0x18,0x18,0x7e,0x18,0x18,0x18,0x18,0x18,0xd8,0x70,0x00,0x00, /* 0x9f */
+  0x00,0x18,0x30,0x60,0x00,0x78,0x0c,0x7c,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0xa0 */
+  0x00,0x0c,0x18,0x30,0x00,0x38,0x18,0x18,0x18,0x18,0x18,0x3c,0x00,0x00,0x00,0x00, /* 0xa1 */
+  0x00,0x18,0x30,0x60,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0xa2 */
+  0x00,0x18,0x30,0x60,0x00,0xcc,0xcc,0xcc,0xcc,0xcc,0xcc,0x76,0x00,0x00,0x00,0x00, /* 0xa3 */
+  0x00,0x00,0x76,0xdc,0x00,0xdc,0x66,0x66,0x66,0x66,0x66,0x66,0x00,0x00,0x00,0x00, /* 0xa4 */
+  0x76,0xdc,0x00,0xc6,0xe6,0xf6,0xfe,0xde,0xce,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* 0xa5 */
+  0x00,0x3c,0x6c,0x6c,0x3e,0x00,0x7e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xa6 */
+  0x00,0x38,0x6c,0x6c,0x38,0x00,0x7c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xa7 */
+  0x00,0x00,0x30,0x30,0x00,0x30,0x30,0x60,0xc0,0xc6,0xc6,0x7c,0x00,0x00,0x00,0x00, /* 0xa8 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0xc0,0xc0,0xc0,0xc0,0x00,0x00,0x00,0x00,0x00, /* 0xa9 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x06,0x06,0x06,0x06,0x00,0x00,0x00,0x00,0x00, /* 0xaa */
+  0x00,0xc0,0xc0,0xc2,0xc6,0xcc,0x18,0x30,0x60,0xdc,0x86,0x0c,0x18,0x3e,0x00,0x00, /* 0xab */
+  0x00,0xc0,0xc0,0xc2,0xc6,0xcc,0x18,0x30,0x66,0xce,0x9e,0x3e,0x06,0x06,0x00,0x00, /* 0xac */
+  0x00,0x00,0x18,0x18,0x00,0x18,0x18,0x18,0x3c,0x3c,0x3c,0x18,0x00,0x00,0x00,0x00, /* 0xad */
+  0x00,0x00,0x00,0x00,0x00,0x36,0x6c,0xd8,0x6c,0x36,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xae */
+  0x00,0x00,0x00,0x00,0x00,0xd8,0x6c,0x36,0x6c,0xd8,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xaf */
+  0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44,0x11,0x44, /* 0xb0 */
+  0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa,0x55,0xaa, /* 0xb1 */
+  0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77,0xdd,0x77, /* 0xb2 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xb3 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xb4 */
+  0x18,0x18,0x18,0x18,0x18,0xf8,0x18,0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xb5 */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xf6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xb6 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xfe,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xb7 */
+  0x00,0x00,0x00,0x00,0x00,0xf8,0x18,0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xb8 */
+  0x36,0x36,0x36,0x36,0x36,0xf6,0x06,0xf6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xb9 */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xba */
+  0x00,0x00,0x00,0x00,0x00,0xfe,0x06,0xf6,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xbb */
+  0x36,0x36,0x36,0x36,0x36,0xf6,0x06,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xbc */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xfe,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xbd */
+  0x18,0x18,0x18,0x18,0x18,0xf8,0x18,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xbe */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xf8,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xbf */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xc0 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xc1 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xc2 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x1f,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xc3 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xc4 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xc5 */
+  0x18,0x18,0x18,0x18,0x18,0x1f,0x18,0x1f,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xc6 */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xc7 */
+  0x36,0x36,0x36,0x36,0x36,0x37,0x30,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xc8 */
+  0x00,0x00,0x00,0x00,0x00,0x3f,0x30,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xc9 */
+  0x36,0x36,0x36,0x36,0x36,0xf7,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xca */
+  0x00,0x00,0x00,0x00,0x00,0xff,0x00,0xf7,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xcb */
+  0x36,0x36,0x36,0x36,0x36,0x37,0x30,0x37,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xcc */
+  0x00,0x00,0x00,0x00,0x00,0xff,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xcd */
+  0x36,0x36,0x36,0x36,0x36,0xf7,0x00,0xf7,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xce */
+  0x18,0x18,0x18,0x18,0x18,0xff,0x00,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xcf */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xd0 */
+  0x00,0x00,0x00,0x00,0x00,0xff,0x00,0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xd1 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xd2 */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x3f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xd3 */
+  0x18,0x18,0x18,0x18,0x18,0x1f,0x18,0x1f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xd4 */
+  0x00,0x00,0x00,0x00,0x00,0x1f,0x18,0x1f,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xd5 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3f,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xd6 */
+  0x36,0x36,0x36,0x36,0x36,0x36,0x36,0xff,0x36,0x36,0x36,0x36,0x36,0x36,0x36,0x36, /* 0xd7 */
+  0x18,0x18,0x18,0x18,0x18,0xff,0x18,0xff,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xd8 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xd9 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xda */
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 0xdb */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff, /* 0xdc */
+  0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0,0xf0, /* 0xdd */
+  0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f,0x0f, /* 0xde */
+  0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xdf */
+  0x00,0x00,0x00,0x00,0x00,0x76,0xdc,0xd8,0xd8,0xd8,0xdc,0x76,0x00,0x00,0x00,0x00, /* 0xe0 */
+  0x00,0x00,0x78,0xcc,0xcc,0xcc,0xd8,0xcc,0xc6,0xc6,0xc6,0xcc,0x00,0x00,0x00,0x00, /* 0xe1 */
+  0x00,0x00,0xfe,0xc6,0xc6,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0xc0,0x00,0x00,0x00,0x00, /* 0xe2 */
+  0x00,0x00,0x00,0x00,0xfe,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x6c,0x00,0x00,0x00,0x00, /* 0xe3 */
+  0x00,0x00,0x00,0xfe,0xc6,0x60,0x30,0x18,0x30,0x60,0xc6,0xfe,0x00,0x00,0x00,0x00, /* 0xe4 */
+  0x00,0x00,0x00,0x00,0x00,0x7e,0xd8,0xd8,0xd8,0xd8,0xd8,0x70,0x00,0x00,0x00,0x00, /* 0xe5 */
+  0x00,0x00,0x00,0x00,0x66,0x66,0x66,0x66,0x66,0x7c,0x60,0x60,0xc0,0x00,0x00,0x00, /* 0xe6 */
+  0x00,0x00,0x00,0x00,0x76,0xdc,0x18,0x18,0x18,0x18,0x18,0x18,0x00,0x00,0x00,0x00, /* 0xe7 */
+  0x00,0x00,0x00,0x7e,0x18,0x3c,0x66,0x66,0x66,0x3c,0x18,0x7e,0x00,0x00,0x00,0x00, /* 0xe8 */
+  0x00,0x00,0x00,0x38,0x6c,0xc6,0xc6,0xfe,0xc6,0xc6,0x6c,0x38,0x00,0x00,0x00,0x00, /* 0xe9 */
+  0x00,0x00,0x38,0x6c,0xc6,0xc6,0xc6,0x6c,0x6c,0x6c,0x6c,0xee,0x00,0x00,0x00,0x00, /* 0xea */
+  0x00,0x00,0x1e,0x30,0x18,0x0c,0x3e,0x66,0x66,0x66,0x66,0x3c,0x00,0x00,0x00,0x00, /* 0xeb */
+  0x00,0x00,0x00,0x00,0x00,0x7e,0xdb,0xdb,0xdb,0x7e,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xec */
+  0x00,0x00,0x00,0x03,0x06,0x7e,0xdb,0xdb,0xf3,0x7e,0x60,0xc0,0x00,0x00,0x00,0x00, /* 0xed */
+  0x00,0x00,0x1c,0x30,0x60,0x60,0x7c,0x60,0x60,0x60,0x30,0x1c,0x00,0x00,0x00,0x00, /* 0xee */
+  0x00,0x00,0x00,0x7c,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0xc6,0x00,0x00,0x00,0x00, /* 0xef */
+  0x00,0x00,0x00,0x00,0xfe,0x00,0x00,0xfe,0x00,0x00,0xfe,0x00,0x00,0x00,0x00,0x00, /* 0xf0 */
+  0x00,0x00,0x00,0x00,0x18,0x18,0x7e,0x18,0x18,0x00,0x00,0xff,0x00,0x00,0x00,0x00, /* 0xf1 */
+  0x00,0x00,0x00,0x30,0x18,0x0c,0x06,0x0c,0x18,0x30,0x00,0x7e,0x00,0x00,0x00,0x00, /* 0xf2 */
+  0x00,0x00,0x00,0x0c,0x18,0x30,0x60,0x30,0x18,0x0c,0x00,0x7e,0x00,0x00,0x00,0x00, /* 0xf3 */
+  0x00,0x00,0x0e,0x1b,0x1b,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18, /* 0xf4 */
+  0x18,0x18,0x18,0x18,0x18,0x18,0x18,0x18,0xd8,0xd8,0xd8,0x70,0x00,0x00,0x00,0x00, /* 0xf5 */
+  0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x7e,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00, /* 0xf6 */
+  0x00,0x00,0x00,0x00,0x00,0x76,0xdc,0x00,0x76,0xdc,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xf7 */
+  0x00,0x38,0x6c,0x6c,0x38,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xf8 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xf9 */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x18,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xfa */
+  0x00,0x0f,0x0c,0x0c,0x0c,0x0c,0x0c,0xec,0x6c,0x6c,0x3c,0x1c,0x00,0x00,0x00,0x00, /* 0xfb */
+  0x00,0xd8,0x6c,0x6c,0x6c,0x6c,0x6c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xfc */
+  0x00,0x70,0xd8,0x30,0x60,0xc8,0xf8,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00, /* 0xfd */
+  0x00,0x00,0x00,0x00,0x7c,0x7c,0x7c,0x7c,0x7c,0x7c,0x7c,0x00,0x00,0x00,0x00,0x00, /* 0xfe */
+  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00  /* 0xff */
+};
+
+/* EOF */
+

freeldr/freeldr/arch/i386/xboxhw.c

@@ -0,0 +1,29 @@
+/* $Id: xboxhw.c,v 1.1 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+#include "machxbox.h"
+
+VOID
+XboxHwDetect(VOID)
+{
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxmem.c

@@ -0,0 +1,133 @@
+/* $Id: xboxmem.c,v 1.3 2004/11/10 23:45:37 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: much of this code was based on knowledge and/or code developed
+ * by the Xbox Linux group: http://www.xbox-linux.org
+ */
+
+#include "freeldr.h"
+#include "debug.h"
+#include "mm.h"
+#include "rtl.h"
+#include "hardware.h"
+#include "machine.h"
+#include "machxbox.h"
+#include "portio.h"
+
+static U32 InstalledMemoryMb = 0;
+static U32 AvailableMemoryMb = 0;
+
+#define TEST_SIZE     0x200
+#define TEST_PATTERN1 0xaa
+#define TEST_PATTERN2 0x55
+
+VOID
+XboxMemInit(VOID)
+{
+  U8 ControlRegion[TEST_SIZE];
+  PVOID MembaseTop = (PVOID)(64 * 1024 * 1024);
+  PVOID MembaseLow = (PVOID)0;
+
+  (*(PU32)(0xfd000000 + 0x100200)) = 0x03070103 ;
+  (*(PU32)(0xfd000000 + 0x100204)) = 0x11448000 ;
+
+  WRITE_PORT_ULONG((U32*) 0xcf8, CONFIG_CMD(0, 0, 0x84));
+  WRITE_PORT_ULONG((U32*) 0xcfc, 0x7ffffff);             /* Prep hardware for 128 Mb */
+
+  InstalledMemoryMb = 64;
+  memset(ControlRegion, TEST_PATTERN1, TEST_SIZE);
+  memset(MembaseTop, TEST_PATTERN1, TEST_SIZE);
+  __asm__ ("wbinvd\n");
+
+  if (0 == memcmp(MembaseTop, ControlRegion, TEST_SIZE))
+    {
+      /* Looks like there is memory .. maybe a 128MB box */
+      memset(ControlRegion, TEST_PATTERN2, TEST_SIZE);
+      memset(MembaseTop, TEST_PATTERN2, TEST_SIZE);
+      __asm__ ("wbinvd\n");
+      if (0 == memcmp(MembaseTop, ControlRegion, TEST_SIZE))
+        {
+          /* Definitely looks like there is memory */
+          if (0 == memcmp(MembaseLow, ControlRegion, TEST_SIZE))
+            {
+              /* Hell, we find the Test-string at 0x0 too ! */
+              InstalledMemoryMb = 64;
+            }
+          else
+            {
+              InstalledMemoryMb = 128;
+            }
+        }
+    }
+
+  /* Set hardware for amount of memory detected */
+  WRITE_PORT_ULONG((U32*) 0xcf8, CONFIG_CMD(0, 0, 0x84));
+  WRITE_PORT_ULONG((U32*) 0xcfc, InstalledMemoryMb * 1024 * 1024 - 1);
+
+  AvailableMemoryMb = InstalledMemoryMb;
+}
+
+U32
+XboxMemGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize)
+{
+  U32 EntryCount = 0;
+
+  /* Synthesize memory map */
+  if (1 <= MaxMemoryMapSize)
+    {
+      /* Available RAM block */
+      BiosMemoryMap[0].BaseAddress = 0;
+      BiosMemoryMap[0].Length = AvailableMemoryMb * 1024 * 1024;
+      BiosMemoryMap[0].Type = MEMTYPE_USABLE;
+      EntryCount = 1;
+    }
+
+  if (2 <= MaxMemoryMapSize)
+    {
+      /* Video memory */
+      BiosMemoryMap[1].BaseAddress = AvailableMemoryMb * 1024 * 1024;
+      BiosMemoryMap[1].Length = (InstalledMemoryMb - AvailableMemoryMb) * 1024 * 1024;
+      BiosMemoryMap[1].Type = MEMTYPE_RESERVED;
+      EntryCount = 2;
+    }
+
+  return EntryCount;
+}
+
+PVOID
+XboxMemReserveMemory(U32 MbToReserve)
+{
+  if (0 == InstalledMemoryMb)
+    {
+      /* Hmm, seems we're not initialized yet */
+      XboxMemInit();
+    }
+
+  if (AvailableMemoryMb < MbToReserve)
+    {
+      /* Can't satisfy the request */
+      return NULL;
+    }
+
+  AvailableMemoryMb -= MbToReserve;
+
+  /* Top of available memory points to the space just reserved */
+  return (PVOID) (AvailableMemoryMb * 1024 * 1024);
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxrtc.c

@@ -0,0 +1,85 @@
+/* $Id: xboxrtc.c,v 1.1 2004/11/14 22:04:38 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+#include "machxbox.h"
+#include "portio.h"
+
+#define RTC_REGISTER_A   0x0A
+#define   RTC_REG_A_UIP  0x80  /* Update In Progress bit */
+
+#define BCD_INT(bcd) (((bcd & 0xf0) >> 4) * 10 + (bcd &0x0f))
+
+static UCHAR
+HalpQueryCMOS(UCHAR Reg)
+{
+  UCHAR Val;
+  Reg |= 0x80;
+
+  WRITE_PORT_UCHAR((PUCHAR)0x70, Reg);
+  Val = READ_PORT_UCHAR((PUCHAR)0x71);
+  WRITE_PORT_UCHAR((PUCHAR)0x70, 0);
+
+  return(Val);
+}
+
+VOID
+XboxRTCGetCurrentDateTime(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second)
+{
+  while (HalpQueryCMOS (RTC_REGISTER_A) & RTC_REG_A_UIP)
+    {
+      ;
+    }
+
+  if (NULL != Second)
+    {
+      *Second = BCD_INT(HalpQueryCMOS(0));
+    }
+  if (NULL != Minute)
+    {
+      *Minute = BCD_INT(HalpQueryCMOS(2));
+    }
+  if (NULL != Hour)
+    {
+      *Hour = BCD_INT(HalpQueryCMOS(4));
+    }
+  if (NULL != Day)
+    {
+      *Day = BCD_INT(HalpQueryCMOS(7));
+    }
+  if (NULL != Month)
+    {
+      *Month = BCD_INT(HalpQueryCMOS(8));
+    }
+  if (NULL != Year)
+    {
+      *Year = BCD_INT(HalpQueryCMOS(9));
+      if (*Year > 80)
+        {
+          *Year += 1900;
+        }
+      else
+        {
+          *Year += 2000;
+        }
+    }
+}
+
+/* EOF */

freeldr/freeldr/arch/i386/xboxvideo.c

@@ -0,0 +1,332 @@
+/* $Id: xboxvideo.c,v 1.5 2004/11/28 21:54:11 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ * Note: much of this code was based on knowledge and/or code developed
+ * by the Xbox Linux group: http://www.xbox-linux.org
+ */
+
+#include "freeldr.h"
+#include "debug.h"
+#include "rtl.h"
+#include "machine.h"
+#include "machxbox.h"
+#include "portio.h"
+
+#define I2C_IO_BASE 0xc000
+
+static PVOID FrameBuffer;
+static U32 ScreenWidth;
+static U32 ScreenHeight;
+static U32 BytesPerPixel;
+static U32 Delta;
+
+#define CHAR_WIDTH  8
+#define CHAR_HEIGHT 16
+
+#define TOP_BOTTOM_LINES 0
+
+#define FB_SIZE_MB 4
+
+#define MAKE_COLOR(Red, Green, Blue) (0xff000000 | (((Red) & 0xff) << 16) | (((Green) & 0xff) << 8) | ((Blue) & 0xff))
+
+static VOID
+XboxVideoOutputChar(U8 Char, unsigned X, unsigned Y, U32 FgColor, U32 BgColor)
+{
+  PU8 FontPtr;
+  PU32 Pixel;
+  U8 Mask;
+  unsigned Line;
+  unsigned Col;
+
+  FontPtr = XboxFont8x16 + Char * 16;
+  Pixel = (PU32) ((char *) FrameBuffer + (Y * CHAR_HEIGHT + TOP_BOTTOM_LINES) * Delta
+                  + X * CHAR_WIDTH * BytesPerPixel);
+  for (Line = 0; Line < CHAR_HEIGHT; Line++)
+    {
+      Mask = 0x80;
+      for (Col = 0; Col < CHAR_WIDTH; Col++)
+        {
+          Pixel[Col] = (0 != (FontPtr[Line] & Mask) ? FgColor : BgColor);
+          Mask = Mask >> 1;
+        }
+      Pixel = (PU32) ((char *) Pixel + Delta);
+    }
+}
+
+static U32
+XboxVideoAttrToSingleColor(U8 Attr)
+{
+  U8 Intensity;
+
+  Intensity = (0 == (Attr & 0x08) ? 127 : 255);
+
+  return 0xff000000 |
+         (0 == (Attr & 0x04) ? 0 : (Intensity << 16)) |
+         (0 == (Attr & 0x02) ? 0 : (Intensity << 8)) |
+         (0 == (Attr & 0x01) ? 0 : Intensity);
+}
+
+static VOID
+XboxVideoAttrToColors(U8 Attr, U32 *FgColor, U32 *BgColor)
+{
+  *FgColor = XboxVideoAttrToSingleColor(Attr & 0xf);
+  *BgColor = XboxVideoAttrToSingleColor((Attr >> 4) & 0xf);
+}
+
+static VOID
+XboxVideoClearScreenColor(U32 Color, BOOL FullScreen)
+{
+  U32 Line, Col;
+  PU32 p;
+
+  for (Line = 0; Line < ScreenHeight - (FullScreen ? 0 : 2 * TOP_BOTTOM_LINES); Line++)
+    {
+      p = (PU32) ((char *) FrameBuffer + (Line + (FullScreen ? 0 : TOP_BOTTOM_LINES)) * Delta);
+      for (Col = 0; Col < ScreenWidth; Col++)
+        {
+          *p++ = Color;
+        }
+    }
+}
+
+VOID
+XboxVideoClearScreen(U8 Attr)
+{
+  U32 FgColor, BgColor;
+
+  XboxVideoAttrToColors(Attr, &FgColor, &BgColor);
+
+  XboxVideoClearScreenColor(BgColor, FALSE);
+}
+
+VOID
+XboxVideoPutChar(int Ch, U8 Attr, unsigned X, unsigned Y)
+{
+  U32 FgColor, BgColor;
+
+  XboxVideoAttrToColors(Attr, &FgColor, &BgColor);
+
+  XboxVideoOutputChar(Ch, X, Y, FgColor, BgColor);
+}
+
+static BOOL
+ReadfromSMBus(UCHAR Address, UCHAR bRegister, UCHAR Size, U32 *Data_to_smbus)
+{
+  int nRetriesToLive=50;
+
+  while (0 != (READ_PORT_USHORT((PU16) (I2C_IO_BASE + 0)) & 0x0800))
+    {
+      ;  /* Franz's spin while bus busy with any master traffic */
+    }
+
+  while (0 != nRetriesToLive--)
+    {
+      UCHAR b;
+      int temp;
+
+      WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 4), (Address << 1) | 1);
+      WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 8), bRegister);
+
+      temp = READ_PORT_USHORT((U16 *) (I2C_IO_BASE + 0));
+      WRITE_PORT_USHORT((PU16) (I2C_IO_BASE + 0), temp);  /* clear down all preexisting errors */
+
+      switch (Size)
+        {
+          case 4:
+            WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0d);      /* DWORD modus ? */
+            break;
+          case 2:
+            WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0b);      /* WORD modus */
+            break;
+          default:
+            WRITE_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 2), 0x0a);      // BYTE
+            break;
+        }
+
+      b = 0;
+
+      while (0 == (b & 0x36))
+        {
+          b = READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 0));
+        }
+
+      if (0 != (b & 0x24))
+        {
+          /* printf("I2CTransmitByteGetReturn error %x\n", b); */
+        }
+
+      if(0 == (b & 0x10))
+        {
+          /* printf("I2CTransmitByteGetReturn no complete, retry\n"); */
+        }
+      else
+        {
+          switch (Size)
+            {
+              case 4:
+                READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 6));
+                READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
+                READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
+                READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
+                READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 9));
+                break;
+              case 2:
+                *Data_to_smbus = READ_PORT_USHORT((U16 *) (I2C_IO_BASE + 6));
+                break;
+              default:
+                *Data_to_smbus = READ_PORT_UCHAR((PUCHAR) (I2C_IO_BASE + 6));
+                break;
+            }
+
+
+          return TRUE;
+        }
+    }
+
+  return FALSE;
+}
+
+
+static BOOL
+I2CTransmitByteGetReturn(UCHAR bPicAddressI2cFormat, UCHAR bDataToWrite, U32 *Return)
+{
+  return ReadfromSMBus(bPicAddressI2cFormat, bDataToWrite, 1, Return);
+}
+
+
+VOID
+XboxVideoInit(VOID)
+{
+  U32 AvMode;
+
+  FrameBuffer = (PVOID)((U32) XboxMemReserveMemory(FB_SIZE_MB) | 0xf0000000);
+
+  if (I2CTransmitByteGetReturn(0x10, 0x04, &AvMode))
+    {
+      if (1 == AvMode) /* HDTV */
+        {
+          ScreenWidth = 720;
+        }
+      else
+        {
+          /* FIXME Other possible values of AvMode:
+           * 0 - AV_SCART_RGB
+           * 2 - AV_VGA_SOG
+           * 4 - AV_SVIDEO
+           * 6 - AV_COMPOSITE
+           * 7 - AV_VGA
+           * other AV_COMPOSITE
+           */
+          ScreenWidth = 640;
+        }
+    }
+  else
+    {
+      ScreenWidth = 640;
+    }
+
+  ScreenHeight = 480;
+  BytesPerPixel = 4;
+  Delta = (ScreenWidth * BytesPerPixel + 3) & ~ 0x3;
+
+  XboxVideoClearScreenColor(MAKE_COLOR(0, 0, 0), TRUE);
+
+  /* Tell the nVidia controller about the framebuffer */
+  *((PU32) 0xfd600800) = (U32) FrameBuffer;
+}
+
+VIDEODISPLAYMODE
+XboxVideoSetDisplayMode(char *DisplayMode, BOOL Init)
+{
+  /* We only have one mode, semi-text */
+  return VideoTextMode;
+}
+
+VOID
+XboxVideoGetDisplaySize(PU32 Width, PU32 Height, PU32 Depth)
+{
+  *Width = ScreenWidth / CHAR_WIDTH;
+  *Height = (ScreenHeight - 2 * TOP_BOTTOM_LINES) / CHAR_HEIGHT;
+  *Depth = 0;
+}
+
+U32
+XboxVideoGetBufferSize(VOID)
+{
+  return (ScreenHeight - 2 * TOP_BOTTOM_LINES) / CHAR_HEIGHT * (ScreenWidth / CHAR_WIDTH) * 2;
+}
+
+VOID
+XboxVideoSetTextCursorPosition(U32 X, U32 Y)
+{
+  /* We don't have a cursor yet */
+}
+
+VOID
+XboxVideoHideShowTextCursor(BOOL Show)
+{
+  /* We don't have a cursor yet */
+}
+
+VOID
+XboxVideoCopyOffScreenBufferToVRAM(PVOID Buffer)
+{
+  PU8 OffScreenBuffer = (PU8) Buffer;
+  U32 Col, Line;
+
+  for (Line = 0; Line < (ScreenHeight - 2 * TOP_BOTTOM_LINES) / CHAR_HEIGHT; Line++)
+    {
+      for (Col = 0; Col < ScreenWidth / CHAR_WIDTH; Col++)
+        {
+          XboxVideoPutChar(OffScreenBuffer[0], OffScreenBuffer[1], Col, Line);
+          OffScreenBuffer += 2;
+        }
+    }
+}
+
+BOOL
+XboxVideoIsPaletteFixed(VOID)
+{
+  return FALSE;
+}
+
+VOID
+XboxVideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue)
+{
+  /* Not supported */
+}
+
+VOID
+XboxVideoGetPaletteColor(U8 Color, U8* Red, U8* Green, U8* Blue)
+{
+  /* Not supported */
+}
+
+VOID
+XboxVideoSync()
+{
+  /* Not supported */
+}
+
+VOID
+XboxVideoPrepareForReactOS(VOID)
+{
+  XboxVideoClearScreenColor(MAKE_COLOR(0, 0, 0), TRUE);
+}
+
+/* EOF */

freeldr/freeldr/bootmgr.c

@@ -34,7 +34,8 @@
 #include <bootmgr.h>
 #include <drivemap.h>
 #include <keycodes.h>
-
+#include <cmdline.h>
+#include <machine.h>
 
 VOID RunLoader(VOID)
 {
@@ -51,23 +52,25 @@ VOID RunLoader(VOID)
 	if (!IniFileInitialize())
 	{
 		printf("Press any key to reboot.\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
 
 	if (!IniOpenSection("FreeLoader", &SectionId))
 	{
 		printf("Section [FreeLoader] not found in freeldr.ini.\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
+	TimeOut = GetTimeOut();
 
-	if (!UiInitialize())
+	if (!UiInitialize(TimeOut))
 	{
 		printf("Press any key to reboot.\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
+	
 
 	if (!InitOperatingSystemList(&OperatingSystemSectionNames, &OperatingSystemDisplayNames, &OperatingSystemCount))
 	{
@@ -82,7 +85,6 @@ VOID RunLoader(VOID)
 	}
 
 	DefaultOperatingSystem = GetDefaultOperatingSystem(OperatingSystemSectionNames, OperatingSystemCount);
-	TimeOut = GetTimeOut();
 	
 	//
 	// Find all the message box settings and run them
@@ -91,6 +93,12 @@ VOID RunLoader(VOID)
 
 	for (;;)
 	{
+	
+		/* If Timeout is 0, don't even bother loading any gui */
+		if (!UserInterfaceUp) {
+			goto NoGui;
+		}
+		
 		// Redraw the backdrop
 		UiDrawBackdrop();
 
@@ -100,6 +108,8 @@ VOID RunLoader(VOID)
 			UiMessageBox("Press ENTER to reboot.\n");
 			goto reboot;
 		}
+		
+NoGui:
 		TimeOut = -1;
 		DefaultOperatingSystem = SelectedOperatingSystem;
 
@@ -121,7 +131,6 @@ VOID RunLoader(VOID)
 
 		// Install the drive mapper according to this sections drive mappings
 		DriveMapMapDrivesInSection(OperatingSystemSectionNames[SelectedOperatingSystem]);
-
 		if (stricmp(SettingValue, "ReactOS") == 0)
 		{
 			LoadAndBootReactOS(OperatingSystemSectionNames[SelectedOperatingSystem]);
@@ -153,20 +162,30 @@ reboot:
 U32	 GetDefaultOperatingSystem(PUCHAR OperatingSystemList[], U32	 OperatingSystemCount)
 {
 	UCHAR	DefaultOSText[80];
-	U32		SectionId;
-	U32		DefaultOS = 0;
-	U32		Idx;
+	char*	DefaultOSName;
+	U32	SectionId;
+	U32	DefaultOS = 0;
+	U32	Idx;
 
 	if (!IniOpenSection("FreeLoader", &SectionId))
 	{
 		return 0;
 	}
 
-	if (IniReadSettingByName(SectionId, "DefaultOS", DefaultOSText, 80))
+	DefaultOSName = CmdLineGetDefaultOS();
+	if (NULL == DefaultOSName)
+	{
+		if (IniReadSettingByName(SectionId, "DefaultOS", DefaultOSText, 80))
+		{
+			DefaultOSName = DefaultOSText;
+		}
+	}
+
+	if (NULL != DefaultOSName)
 	{
 		for (Idx=0; Idx<OperatingSystemCount; Idx++)
 		{
-			if (stricmp(DefaultOSText, OperatingSystemList[Idx]) == 0)
+			if (stricmp(DefaultOSName, OperatingSystemList[Idx]) == 0)
 			{
 				DefaultOS = Idx;
 				break;
@@ -180,9 +199,15 @@ U32	 GetDefaultOperatingSystem(PUCHAR OperatingSystemList[], U32	 OperatingSyste
 S32 GetTimeOut(VOID)
 {
 	UCHAR	TimeOutText[20];
-	U32		TimeOut;
+	S32		TimeOut;
 	U32		SectionId;
 
+	TimeOut = CmdLineGetTimeOut();
+	if (0 <= TimeOut)
+	{
+		return TimeOut;
+	}
+
 	if (!IniOpenSection("FreeLoader", &SectionId))
 	{
 		return -1;

freeldr/freeldr/cache/blocklist.c

@@ -25,6 +25,7 @@
 #include <rtl.h>
 #include <debug.h>
 #include <arch.h>
+#include <machine.h>
 
 // Returns a pointer to a CACHE_BLOCK structure
 // Adds the block to the cache manager block list
@@ -114,7 +115,7 @@ PCACHE_BLOCK CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, U32 BlockNumb
 	// allocate room for the block data
 	RtlZeroMemory(CacheBlock, sizeof(CACHE_BLOCK));
 	CacheBlock->BlockNumber = BlockNumber;
-	CacheBlock->BlockData = MmAllocateMemory(CacheDrive->BlockSize * CacheDrive->DriveGeometry.BytesPerSector);
+	CacheBlock->BlockData = MmAllocateMemory(CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 	if (CacheBlock->BlockData ==NULL)
 	{
 		MmFreeMemory(CacheBlock);
@@ -122,13 +123,13 @@ PCACHE_BLOCK CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, U32 BlockNumb
 	}
 
 	// Now try to read in the block
-	if (!DiskReadLogicalSectors(CacheDrive->DriveNumber, (BlockNumber * CacheDrive->BlockSize), CacheDrive->BlockSize, (PVOID)DISKREADBUFFER))
+	if (!MachDiskReadLogicalSectors(CacheDrive->DriveNumber, (BlockNumber * CacheDrive->BlockSize), CacheDrive->BlockSize, (PVOID)DISKREADBUFFER))
 	{
 		MmFreeMemory(CacheBlock->BlockData);
 		MmFreeMemory(CacheBlock);
 		return NULL;
 	}
-	RtlCopyMemory(CacheBlock->BlockData, (PVOID)DISKREADBUFFER, CacheDrive->BlockSize * CacheDrive->DriveGeometry.BytesPerSector);
+	RtlCopyMemory(CacheBlock->BlockData, (PVOID)DISKREADBUFFER, CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
 	// Add it to our list of blocks managed by the cache
 	if (CacheDrive->CacheBlockHead == NULL)
@@ -142,7 +143,7 @@ PCACHE_BLOCK CacheInternalAddBlockToCache(PCACHE_DRIVE CacheDrive, U32 BlockNumb
 
 	// Update the cache data
 	CacheBlockCount++;
-	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->DriveGeometry.BytesPerSector);
+	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
 	CacheInternalDumpBlockList(CacheDrive);
 
@@ -187,7 +188,7 @@ BOOL CacheInternalFreeBlock(PCACHE_DRIVE CacheDrive)
 
 	// Update the cache data
 	CacheBlockCount--;
-	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->DriveGeometry.BytesPerSector);
+	CacheSizeCurrent = CacheBlockCount * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
 	return TRUE;
 }
@@ -199,7 +200,7 @@ VOID CacheInternalCheckCacheSizeLimits(PCACHE_DRIVE CacheDrive)
 	DbgPrint((DPRINT_CACHE, "CacheInternalCheckCacheSizeLimits()\n"));
 
 	// Calculate the size of the cache if we added a block
-	NewCacheSize = (CacheBlockCount + 1) * (CacheDrive->BlockSize * CacheDrive->DriveGeometry.BytesPerSector);
+	NewCacheSize = (CacheBlockCount + 1) * (CacheDrive->BlockSize * CacheDrive->BytesPerSector);
 
 	// Check the new size against the cache size limit
 	if (NewCacheSize > CacheSizeLimit)
@@ -214,10 +215,7 @@ VOID CacheInternalDumpBlockList(PCACHE_DRIVE CacheDrive)
 	PCACHE_BLOCK	CacheBlock;
 
 	DbgPrint((DPRINT_CACHE, "Dumping block list for BIOS drive 0x%x.\n", CacheDrive->DriveNumber));
-	DbgPrint((DPRINT_CACHE, "Cylinders: %d.\n", CacheDrive->DriveGeometry.Cylinders));
-	DbgPrint((DPRINT_CACHE, "Heads: %d.\n", CacheDrive->DriveGeometry.Heads));
-	DbgPrint((DPRINT_CACHE, "Sectors: %d.\n", CacheDrive->DriveGeometry.Sectors));
-	DbgPrint((DPRINT_CACHE, "BytesPerSector: %d.\n", CacheDrive->DriveGeometry.BytesPerSector));
+	DbgPrint((DPRINT_CACHE, "BytesPerSector: %d.\n", CacheDrive->BytesPerSector));
 	DbgPrint((DPRINT_CACHE, "BlockSize: %d.\n", CacheDrive->BlockSize));
 	DbgPrint((DPRINT_CACHE, "CacheSizeLimit: %d.\n", CacheSizeLimit));
 	DbgPrint((DPRINT_CACHE, "CacheSizeCurrent: %d.\n", CacheSizeCurrent));

freeldr/freeldr/cache/cache.c

@@ -22,6 +22,7 @@
 #include "cm.h"
 #include <mm.h>
 #include <disk.h>
+#include <machine.h>
 #include <rtl.h>
 #include <debug.h>
 
@@ -33,13 +34,14 @@
 CACHE_DRIVE		CacheManagerDrive;
 BOOL			CacheManagerInitialized = FALSE;
 BOOL			CacheManagerDataInvalid = FALSE;
-U32				CacheBlockCount = 0;
-U32				CacheSizeLimit = 0;
-U32				CacheSizeCurrent = 0;
+U32			CacheBlockCount = 0;
+U32			CacheSizeLimit = 0;
+U32			CacheSizeCurrent = 0;
 
 BOOL CacheInitializeDrive(U32 DriveNumber)
 {
 	PCACHE_BLOCK	NextCacheBlock;
+	GEOMETRY	DriveGeometry;
 
 	// If we already have a cache for this drive then
 	// by all means lets keep it, unless it is a removable
@@ -82,13 +84,14 @@ BOOL CacheInitializeDrive(U32 DriveNumber)
 	// Initialize the structure
 	RtlZeroMemory(&CacheManagerDrive, sizeof(CACHE_DRIVE));
 	CacheManagerDrive.DriveNumber = DriveNumber;
-	if (!DiskGetDriveGeometry(DriveNumber, &CacheManagerDrive.DriveGeometry))
+	if (!MachDiskGetDriveGeometry(DriveNumber, &DriveGeometry))
 	{
 		return FALSE;
 	}
+	CacheManagerDrive.BytesPerSector = DriveGeometry.BytesPerSector;
 
 	// Get the number of sectors in each cache block
-	CacheManagerDrive.BlockSize = DiskGetCacheableBlockCount(DriveNumber);
+	CacheManagerDrive.BlockSize = MachDiskGetCacheableBlockCount(DriveNumber);
 
 	CacheBlockCount = 0;
 	CacheSizeLimit = GetSystemMemorySize() / 8;
@@ -101,10 +104,7 @@ BOOL CacheInitializeDrive(U32 DriveNumber)
 	CacheManagerInitialized = TRUE;
 
 	DbgPrint((DPRINT_CACHE, "Initializing BIOS drive 0x%x.\n", DriveNumber));
-	DbgPrint((DPRINT_CACHE, "Cylinders: %d.\n", CacheManagerDrive.DriveGeometry.Cylinders));
-	DbgPrint((DPRINT_CACHE, "Heads: %d.\n", CacheManagerDrive.DriveGeometry.Heads));
-	DbgPrint((DPRINT_CACHE, "Sectors: %d.\n", CacheManagerDrive.DriveGeometry.Sectors));
-	DbgPrint((DPRINT_CACHE, "BytesPerSector: %d.\n", CacheManagerDrive.DriveGeometry.BytesPerSector));
+	DbgPrint((DPRINT_CACHE, "BytesPerSector: %d.\n", CacheManagerDrive.BytesPerSector));
 	DbgPrint((DPRINT_CACHE, "BlockSize: %d.\n", CacheManagerDrive.BlockSize));
 	DbgPrint((DPRINT_CACHE, "CacheSizeLimit: %d.\n", CacheSizeLimit));
 
@@ -164,14 +164,14 @@ BOOL CacheReadDiskSectors(U32 DiskNumber, U32 StartSector, U32 SectorCount, PVOI
 		// Copy the portion requested into the buffer
 		//
 		RtlCopyMemory(Buffer,
-			(CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.DriveGeometry.BytesPerSector)),
-			(CopyLengthInStartBlock * CacheManagerDrive.DriveGeometry.BytesPerSector));
-		DbgPrint((DPRINT_CACHE, "1 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, (CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.DriveGeometry.BytesPerSector)), (CopyLengthInStartBlock * CacheManagerDrive.DriveGeometry.BytesPerSector)));
+			(CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)),
+			(CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector));
+		DbgPrint((DPRINT_CACHE, "1 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, (CacheBlock->BlockData + (SectorOffsetInStartBlock * CacheManagerDrive.BytesPerSector)), (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector)));
 
 		//
 		// Update the buffer address
 		//
-		Buffer += (CopyLengthInStartBlock * CacheManagerDrive.DriveGeometry.BytesPerSector);
+		Buffer += (CopyLengthInStartBlock * CacheManagerDrive.BytesPerSector);
 
 		//
 		// Update the block count
@@ -198,13 +198,13 @@ BOOL CacheReadDiskSectors(U32 DiskNumber, U32 StartSector, U32 SectorCount, PVOI
 		//
 		RtlCopyMemory(Buffer,
 			CacheBlock->BlockData,
-			CacheManagerDrive.BlockSize * CacheManagerDrive.DriveGeometry.BytesPerSector);
-		DbgPrint((DPRINT_CACHE, "2 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, CacheManagerDrive.BlockSize * CacheManagerDrive.DriveGeometry.BytesPerSector));
+			CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector);
+		DbgPrint((DPRINT_CACHE, "2 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector));
 
 		//
 		// Update the buffer address
 		//
-		Buffer += CacheManagerDrive.BlockSize * CacheManagerDrive.DriveGeometry.BytesPerSector;
+		Buffer += CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector;
 
 		//
 		// Update the block count
@@ -231,13 +231,13 @@ BOOL CacheReadDiskSectors(U32 DiskNumber, U32 StartSector, U32 SectorCount, PVOI
 		//
 		RtlCopyMemory(Buffer,
 			CacheBlock->BlockData,
-			SectorOffsetInEndBlock * CacheManagerDrive.DriveGeometry.BytesPerSector);
-		DbgPrint((DPRINT_CACHE, "3 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, SectorOffsetInEndBlock * CacheManagerDrive.DriveGeometry.BytesPerSector));
+			SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector);
+		DbgPrint((DPRINT_CACHE, "3 - RtlCopyMemory(0x%x, 0x%x, %d)\n", Buffer, CacheBlock->BlockData, SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector));
 
 		//
 		// Update the buffer address
 		//
-		Buffer += SectorOffsetInEndBlock * CacheManagerDrive.DriveGeometry.BytesPerSector;
+		Buffer += SectorOffsetInEndBlock * CacheManagerDrive.BytesPerSector;
 
 		//
 		// Update the block count
@@ -317,7 +317,7 @@ BOOL CacheReleaseMemory(U32 MinimumAmountToRelease)
 		}
 
 		// It succeeded so increment the amount of memory we have freed
-		AmountReleased += CacheManagerDrive.BlockSize * CacheManagerDrive.DriveGeometry.BytesPerSector;
+		AmountReleased += CacheManagerDrive.BlockSize * CacheManagerDrive.BytesPerSector;
 	}
 
 	// Return status

freeldr/freeldr/cache/cm.h

@@ -55,10 +55,10 @@ typedef struct
 ///////////////////////////////////////////////////////////////////////////////////////
 typedef struct
 {
-	U32					DriveNumber;
-	GEOMETRY			DriveGeometry;
+	U32			DriveNumber;
+	U32			BytesPerSector;
 
-	U32					BlockSize;			// Block size (in sectors)
+	U32			BlockSize;			// Block size (in sectors)
 	PCACHE_BLOCK		CacheBlockHead;
 
 } CACHE_DRIVE, *PCACHE_DRIVE;

freeldr/freeldr/cmdline.c

@@ -0,0 +1,122 @@
+/* $Id: cmdline.c,v 1.1 2004/11/01 20:49:32 gvg Exp $
+ *
+ *  FreeLoader
+ *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include <freeldr.h>	
+#include <cmdline.h>
+#include <rtl.h>
+
+static CMDLINEINFO CmdLineInfo;
+
+static char *
+SkipWhitespace(char *s)
+{
+  while ('\0' != *s && isspace(*s))
+    {
+      s++;
+    }
+
+  return s;
+}
+
+void
+CmdLineParse(char *CmdLine)
+{
+  char *s;
+  char *Name;
+  char *Value;
+  char *End;
+
+  CmdLineInfo.DefaultOperatingSystem = NULL;
+  CmdLineInfo.TimeOut = -1;
+
+  if (NULL == CmdLine)
+    {
+      return;
+    }
+
+  /* Skip over "kernel name" */
+  s = CmdLine;
+  while ('\0' != *s && ! isspace(*s))
+    {
+      s++;
+    }
+  s = SkipWhitespace(s);
+
+  while ('\0' != *s)
+    {
+      Name = s;
+      while (! isspace(*s) && '=' != *s && '\0' != *s)
+        {
+          s++;
+        }
+      End = s;
+      s = SkipWhitespace(s);
+      if ('=' == *s)
+        {
+          s++;
+          *End = '\0';
+          s = SkipWhitespace(s);
+          if ('"' == *s)
+            {
+              s++;
+              Value = s;
+              while ('"' != *s && '\0' != *s)
+                {
+                  s++;
+                }
+            }
+          else
+            {
+              Value = s;
+              while (! isspace(*s) && '\0' != *s)
+                {
+                  s++;
+                }
+            }
+          if ('\0' != *s)
+            {
+              *s++ = '\0';
+            }
+          if (0 == stricmp(Name, "defaultos"))
+            {
+              CmdLineInfo.DefaultOperatingSystem = Value;
+            }
+          else if (0 == stricmp(Name, "timeout"))
+            {
+              CmdLineInfo.TimeOut = atoi(Value);
+            }
+        }
+    }
+}
+
+char *
+CmdLineGetDefaultOS(void)
+{
+  return CmdLineInfo.DefaultOperatingSystem;
+}
+
+S32
+CmdLineGetTimeOut(void)
+{
+  return CmdLineInfo.TimeOut;
+}
+
+/* EOF */
+

freeldr/freeldr/custom.c

@@ -29,6 +29,7 @@
 #include <linux.h>
 #include <reactos.h>
 #include <drivemap.h>
+#include <machine.h>
 
 
 UCHAR	BootDrivePrompt[] = "Enter the boot drive.\n\nExamples:\nfd0 - first floppy drive\nhd0 - first hard drive\nhd1 - second hard drive\ncd0 - first CD-ROM drive.\n\nBIOS drive numbers may also be used:\n0 - first floppy drive\n0x80 - first hard drive\n0x81 - second hard drive";
@@ -78,7 +79,8 @@ VOID OptionMenuCustomBootDisk(VOID)
 {
 	UCHAR	SectionName[100];
 	UCHAR	BootDriveString[20];
-	U32		SectionId;
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
 
 	RtlZeroMemory(SectionName, sizeof(SectionName));
 	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
@@ -89,7 +91,8 @@ VOID OptionMenuCustomBootDisk(VOID)
 	}
 
 	// Generate a unique section name
-	sprintf(SectionName, "CustomBootDisk%d%d%d%d%d%d", getyear(), getday(), getmonth(), gethour(), getminute(), getsecond());
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
+	sprintf(SectionName, "CustomBootDisk%d%d%d%d%d%d", Year, Day, Month, Hour, Minute, Second);
 
 	// Add the section
 	if (!IniAddSection(SectionName, &SectionId))
@@ -119,7 +122,8 @@ VOID OptionMenuCustomBootPartition(VOID)
 	UCHAR	SectionName[100];
 	UCHAR	BootDriveString[20];
 	UCHAR	BootPartitionString[20];
-	U32		SectionId;
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
 
 	RtlZeroMemory(SectionName, sizeof(SectionName));
 	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
@@ -136,7 +140,8 @@ VOID OptionMenuCustomBootPartition(VOID)
 	}
 
 	// Generate a unique section name
-	sprintf(SectionName, "CustomBootPartition%d%d%d%d%d%d", getyear(), getday(), getmonth(), gethour(), getminute(), getsecond());
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
+	sprintf(SectionName, "CustomBootPartition%d%d%d%d%d%d", Year, Day, Month, Hour, Minute, Second);
 
 	// Add the section
 	if (!IniAddSection(SectionName, &SectionId))
@@ -173,7 +178,8 @@ VOID OptionMenuCustomBootBootSectorFile(VOID)
 	UCHAR	BootDriveString[20];
 	UCHAR	BootPartitionString[20];
 	UCHAR	BootSectorFileString[200];
-	U32		SectionId;
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
 
 	RtlZeroMemory(SectionName, sizeof(SectionName));
 	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
@@ -196,7 +202,8 @@ VOID OptionMenuCustomBootBootSectorFile(VOID)
 	}
 
 	// Generate a unique section name
-	sprintf(SectionName, "CustomBootSectorFile%d%d%d%d%d%d", getyear(), getday(), getmonth(), gethour(), getminute(), getsecond());
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
+	sprintf(SectionName, "CustomBootSectorFile%d%d%d%d%d%d", Year, Day, Month, Hour, Minute, Second);
 
 	// Add the section
 	if (!IniAddSection(SectionName, &SectionId))
@@ -241,7 +248,8 @@ VOID OptionMenuCustomBootReactOS(VOID)
 	UCHAR	ReactOSSystemPath[200];
 	UCHAR	ReactOSARCPath[200];
 	UCHAR	ReactOSOptions[200];
-	U32		SectionId;
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
 
 	RtlZeroMemory(SectionName, sizeof(SectionName));
 	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
@@ -270,7 +278,8 @@ VOID OptionMenuCustomBootReactOS(VOID)
 	}
 
 	// Generate a unique section name
-	sprintf(SectionName, "CustomReactOS%d%d%d%d%d%d", getyear(), getday(), getmonth(), gethour(), getminute(), getsecond());
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
+	sprintf(SectionName, "CustomReactOS%d%d%d%d%d%d", Year, Day, Month, Hour, Minute, Second);
 
 	// Add the section
 	if (!IniAddSection(SectionName, &SectionId))
@@ -312,7 +321,8 @@ VOID OptionMenuCustomBootLinux(VOID)
 	UCHAR	LinuxKernelString[200];
 	UCHAR	LinuxInitrdString[200];
 	UCHAR	LinuxCommandLineString[200];
-	U32		SectionId;
+	U32	SectionId;
+	U32	Year, Month, Day, Hour, Minute, Second;
 
 	RtlZeroMemory(SectionName, sizeof(SectionName));
 	RtlZeroMemory(BootDriveString, sizeof(BootDriveString));
@@ -347,7 +357,8 @@ VOID OptionMenuCustomBootLinux(VOID)
 	}
 
 	// Generate a unique section name
-	sprintf(SectionName, "CustomLinux%d%d%d%d%d%d", getyear(), getday(), getmonth(), gethour(), getminute(), getsecond());
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
+	sprintf(SectionName, "CustomLinux%d%d%d%d%d%d", Year, Day, Month, Hour, Minute, Second);
 
 	// Add the section
 	if (!IniAddSection(SectionName, &SectionId))

freeldr/freeldr/debug.c

@@ -22,6 +22,7 @@
 #include <rtl.h>
 #include <comm.h>
 #include <portio.h>
+#include <machine.h>
 
 #ifdef DEBUG
 
@@ -94,7 +95,7 @@ VOID DebugPrintChar(UCHAR Character)
 	}
 	else
 	{
-		putchar(Character);
+		MachConsPutChar(Character);
 	}
 }
 
@@ -230,26 +231,11 @@ VOID DebugPrintHeader(U32 Mask)
 	}
 }
 
-VOID DebugPrint(U32 Mask, char *format, ...)
+static VOID DebugPrintV(char *format, int *dataptr)
 {
-	int *dataptr = (int *) &format;
 	char c, *ptr, str[16];
 	int ll;
-	
-	// Mask out unwanted debug messages
-	if (!(Mask & DebugPrintMask))
-	{
-		return;
-	}
 
-	// Print the header if we have started a new line
-	if (DebugStartOfLine)
-	{
-		DebugPrintHeader(Mask);
-		DebugStartOfLine = FALSE;
-	}
-
-	dataptr++;
 	ll = 0;
 	while ((c = *(format++)))
 	{
@@ -308,7 +294,7 @@ VOID DebugPrint(U32 Mask, char *format, ...)
 				DebugPrintChar(c);
 				break;
 			default:
-				DebugPrint(Mask, "\nDebugPrint() invalid format specifier - %%%c\n", c);
+				DebugPrint(DPRINT_WARNING, "\nDebugPrint() invalid format specifier - %%%c\n", c);
 				break;
 			}
 		}
@@ -322,6 +308,33 @@ VOID DebugPrint(U32 Mask, char *format, ...)
 
 }
 
+VOID DebugPrint(U32 Mask, char *format, ...)
+{
+	int *dataptr = (int *) &format;
+	
+	// Mask out unwanted debug messages
+	if (!(Mask & DebugPrintMask))
+	{
+		return;
+	}
+
+	// Print the header if we have started a new line
+	if (DebugStartOfLine)
+	{
+		DebugPrintHeader(Mask);
+		DebugStartOfLine = FALSE;
+	}
+
+	DebugPrintV(format, ++dataptr);
+}
+
+VOID DebugPrint1(char *format, ...)
+{
+	int *dataptr = (int *) &format;
+
+	DebugPrintV(format, ++dataptr);
+}
+
 VOID DebugDumpBuffer(U32 Mask, PVOID Buffer, U32 Length)
 {
 	PUCHAR	BufPtr = (PUCHAR)Buffer;

freeldr/freeldr/disk/geometry.c

@@ -1,44 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <freeldr.h>
-#include <disk.h>
-#include <rtl.h>
-#include <mm.h>
-
-
-#ifdef __i386__
-BOOL DiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry)
-{
-	// For now just return the geometry as the BIOS reports it
-	// BytesPerSector is always set to 512 by i386DiskGetDriveParameters()
-	if (!DiskGetDriveParameters(DriveNumber, DriveGeometry))
-	{
-		DiskError("Drive geometry unknown.", 0);
-		return FALSE;
-	}
-
-	return TRUE;
-}
-#else
-BOOL DiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry)
-{
-	UNIMPLEMENTED();
-}
-#endif

freeldr/freeldr/disk/partition.c

@@ -23,6 +23,7 @@
 #include <mm.h>
 #include <debug.h>
 #include <arch.h>
+#include <machine.h>
 
 
 BOOL DiskGetActivePartitionEntry(U32 DriveNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
@@ -196,12 +197,13 @@ BOOL DiskGetFirstExtendedPartitionEntry(PMASTER_BOOT_RECORD MasterBootRecord, PP
 
 BOOL DiskReadBootRecord(U32 DriveNumber, U64 LogicalSectorNumber, PMASTER_BOOT_RECORD BootRecord)
 {
+	char		ErrMsg[64];
 #ifdef DEBUG
 	U32		Index;
 #endif
 
 	// Read master boot record
-	if (!DiskReadLogicalSectors(DriveNumber, LogicalSectorNumber, 1, (PVOID)DISKREADBUFFER))
+	if (!MachDiskReadLogicalSectors(DriveNumber, LogicalSectorNumber, 1, (PVOID)DISKREADBUFFER))
 	{
 		return FALSE;
 	}
@@ -235,7 +237,9 @@ BOOL DiskReadBootRecord(U32 DriveNumber, U64 LogicalSectorNumber, PMASTER_BOOT_R
 	// Check the partition table magic value
 	if (BootRecord->MasterBootRecordMagic != 0xaa55)
 	{
-		DiskError("Invalid partition table magic (0xaa55)", 0);
+		sprintf(ErrMsg, "Invalid partition table magic 0x%x found on drive 0x%x",
+		        BootRecord->MasterBootRecordMagic, DriveNumber);
+		DiskError(ErrMsg, 0);
 		return FALSE;
 	}
 

freeldr/freeldr/freeldr.c

@@ -20,30 +20,27 @@
 #include <freeldr.h>
 #include <rtl.h>
 #include <arch.h>
+#include <machine.h>
 #include <mm.h>
 #include <debug.h>
 #include <bootmgr.h>
 #include <fs.h>
+#include <cmdline.h>
 
-// Variables BootDrive & BootPartition moved to asmcode.S
-//U32				BootDrive = 0;							// BIOS boot drive, 0-A:, 1-B:, 0x80-C:, 0x81-D:, etc.
-//U32				BootPartition = 0;						// Boot Partition, 1-4
-
-VOID BootMain(VOID)
+VOID BootMain(char *CmdLine)
 {
+	CmdLineParse(CmdLine);
 
-	EnableA20();
+	MachInit();
 
-#ifdef DEBUG
 	DebugInit();
-#endif
 
 	DbgPrint((DPRINT_WARNING, "BootMain() called. BootDrive = 0x%x BootPartition = %d\n", BootDrive, BootPartition));
 
 	if (!MmInitializeMemoryManager())
 	{
 		printf("Press any key to reboot.\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
 

freeldr/freeldr/fs/ext2.c

@@ -27,6 +27,7 @@
 #include <mm.h>
 #include <debug.h>
 #include <cache.h>
+#include <machine.h>
 
 
 GEOMETRY			Ext2DiskGeometry;				// Ext2 file system disk geometry
@@ -53,7 +54,7 @@ BOOL Ext2OpenVolume(U8 DriveNumber, U64 VolumeStartSector)
 	Ext2DriveNumber = DriveNumber;
 	Ext2VolumeStartSector = VolumeStartSector;
 
-	if (!DiskGetDriveGeometry(DriveNumber, &Ext2DiskGeometry))
+	if (!MachDiskGetDriveGeometry(DriveNumber, &Ext2DiskGeometry))
 	{
 		return FALSE;
 	}
@@ -563,7 +564,7 @@ BOOL Ext2ReadVolumeSectors(U8 DriveNumber, U64 SectorNumber, U64 SectorCount, PV
 	//{
 	//	return FALSE;
 	//}
-	//ReturnValue = DiskReadLogicalSectors(DriveNumber, SectorNumber + Ext2VolumeStartSector, SectorCount, (PVOID)DISKREADBUFFER);
+	//ReturnValue = MachDiskReadLogicalSectors(DriveNumber, SectorNumber + Ext2VolumeStartSector, SectorCount, (PVOID)DISKREADBUFFER);
 	//RtlCopyMemory(Buffer, (PVOID)DISKREADBUFFER, SectorCount * DiskGeometry.BytesPerSector);
 	//return ReturnValue;
 
@@ -601,7 +602,7 @@ BOOL Ext2ReadSuperBlock(VOID)
 
 	// Now try to read the super block
 	// If this fails then abort
-	if (!DiskReadLogicalSectors(Ext2DriveNumber, Ext2VolumeStartSector, 8, (PVOID)DISKREADBUFFER))
+	if (!MachDiskReadLogicalSectors(Ext2DriveNumber, Ext2VolumeStartSector, 8, (PVOID)DISKREADBUFFER))
 	{
 		return FALSE;
 	}

freeldr/freeldr/fs/fat.c

@@ -27,21 +27,30 @@
 #include <mm.h>
 #include <debug.h>
 #include <cache.h>
+#include <machine.h>
 
+U32			BytesPerSector;			/* Number of bytes per sector */
+U32			SectorsPerCluster;		/* Number of sectors per cluster */
+U32			FatVolumeStartSector;		/* Absolute starting sector of the partition */
+U32			FatSectorStart;			/* Starting sector of 1st FAT table */
+U32			ActiveFatSectorStart;		/* Starting sector of active FAT table */
+U32			NumberOfFats;			/* Number of FAT tables */
+U32			SectorsPerFat;			/* Sectors per FAT table */
+U32			RootDirSectorStart;		/* Starting sector of the root directory (non-fat32) */
+U32			RootDirSectors;			/* Number of sectors of the root directory (non-fat32) */
+U32			RootDirStartCluster;		/* Starting cluster number of the root directory (fat32 only) */
+U32			DataSectorStart;		/* Starting sector of the data area */
 
-PFAT_BOOTSECTOR		FatVolumeBootSector = NULL;
-PFAT32_BOOTSECTOR	Fat32VolumeBootSector = NULL;
+U32			FatType = 0;			/* FAT12, FAT16, FAT32, FATX16 or FATX32 */
+U32			FatDriveNumber = 0;
 
-U32					RootDirSectorStart;		// Starting sector of the root directory (fat12/16)
-U32					DataSectorStart;		// Starting sector of the data area
-U32					SectorsPerFat;			// Sectors per FAT table
-U32					RootDirSectors;			// Number of sectors of the root directory (fat32)
-
-U32					FatType = 0;			// FAT12, FAT16, or FAT32
-U32					FatDriveNumber = 0;
-
-BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
+BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector, U32 PartitionSectorCount)
 {
+	char ErrMsg[80];
+	U32 FatSize;
+	PFAT_BOOTSECTOR	FatVolumeBootSector;
+	PFAT32_BOOTSECTOR Fat32VolumeBootSector;
+	PFATX_BOOTSECTOR FatXVolumeBootSector;
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatOpenVolume() DriveNumber = 0x%x VolumeStartSector = %d\n", DriveNumber, VolumeStartSector));
 
@@ -49,21 +58,11 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 	FatDriveNumber = DriveNumber;
 
 	//
-	// Free any memory previously allocated
-	//
-	if (FatVolumeBootSector != NULL)
-	{
-		MmFreeMemory(FatVolumeBootSector);
-
-		FatVolumeBootSector = NULL;
-		Fat32VolumeBootSector = NULL;
-	}
-
-	//
-	// Now allocate the memory to hold the boot sector
+	// Allocate the memory to hold the boot sector
 	//
 	FatVolumeBootSector = (PFAT_BOOTSECTOR) MmAllocateMemory(512);
 	Fat32VolumeBootSector = (PFAT32_BOOTSECTOR) FatVolumeBootSector;
+	FatXVolumeBootSector = (PFATX_BOOTSECTOR) FatVolumeBootSector;
 
 	//
 	// Make sure we got the memory
@@ -76,20 +75,34 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 
 	// Now try to read the boot sector
 	// If this fails then abort
-	if (!DiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, (PVOID)DISKREADBUFFER))
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, (PVOID)DISKREADBUFFER))
 	{
+		MmFreeMemory(FatVolumeBootSector);
 		return FALSE;
 	}
 	RtlCopyMemory(FatVolumeBootSector, (PVOID)DISKREADBUFFER, 512);
 
 	// Get the FAT type
-	FatType = FatDetermineFatType(FatVolumeBootSector);
+	FatType = FatDetermineFatType(FatVolumeBootSector, PartitionSectorCount);
 
 #ifdef DEBUG
 
 	DbgPrint((DPRINT_FILESYSTEM, "Dumping boot sector:\n"));
 
-	if (FatType == FAT32)
+	if (ISFATX(FatType))
+	{
+		DbgPrint((DPRINT_FILESYSTEM, "sizeof(FATX_BOOTSECTOR) = 0x%x.\n", sizeof(FATX_BOOTSECTOR)));
+
+		DbgPrint((DPRINT_FILESYSTEM, "FileSystemType: %c%c%c%c.\n", FatXVolumeBootSector->FileSystemType[0], FatXVolumeBootSector->FileSystemType[1], FatXVolumeBootSector->FileSystemType[2], FatXVolumeBootSector->FileSystemType[3]));
+		DbgPrint((DPRINT_FILESYSTEM, "VolumeSerialNumber: 0x%x\n", FatXVolumeBootSector->VolumeSerialNumber));
+		DbgPrint((DPRINT_FILESYSTEM, "SectorsPerCluster: %d\n", FatXVolumeBootSector->SectorsPerCluster));
+		DbgPrint((DPRINT_FILESYSTEM, "NumberOfFats: %d\n", FatXVolumeBootSector->NumberOfFats));
+		DbgPrint((DPRINT_FILESYSTEM, "Unknown: 0x%x\n", FatXVolumeBootSector->Unknown));
+
+		DbgPrint((DPRINT_FILESYSTEM, "FatType %s\n", FatType == FATX16 ? "FATX16" : "FATX32"));
+
+	}
+	else if (FatType == FAT32)
 	{
 		DbgPrint((DPRINT_FILESYSTEM, "sizeof(FAT32_BOOTSECTOR) = 0x%x.\n", sizeof(FAT32_BOOTSECTOR)));
 
@@ -154,14 +167,17 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
         //
 	// Set the correct partition offset
 	//
-	FatVolumeBootSector->HiddenSectors = VolumeStartSector;
+	FatVolumeStartSector = VolumeStartSector;
 
 	//
 	// Check the boot sector magic
 	//
-	if (FatVolumeBootSector->BootSectorMagic != 0xaa55)
+	if (! ISFATX(FatType) && FatVolumeBootSector->BootSectorMagic != 0xaa55)
 	{
-		FileSystemError("Invalid boot sector magic (0xaa55)");
+		sprintf(ErrMsg, "Invalid boot sector magic on drive 0x%x (expected 0xaa55 found 0x%x)",
+                        DriveNumber, FatVolumeBootSector->BootSectorMagic);
+		FileSystemError(ErrMsg);
+		MmFreeMemory(FatVolumeBootSector);
 		return FALSE;
 	}
 
@@ -169,15 +185,20 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 	// Check the FAT cluster size
 	// We do not support clusters bigger than 64k
 	//
-	if ((FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector) > (64 * 1024))
+	if ((ISFATX(FatType) && 64 * 1024 < FatXVolumeBootSector->SectorsPerCluster * 512) ||
+            (! ISFATX(FatType) && 64 * 1024 < FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector))
 	{
 		FileSystemError("This file system has cluster sizes bigger than 64k.\nFreeLoader does not support this.");
+		MmFreeMemory(FatVolumeBootSector);
 		return FALSE;
 	}
 
 	//
 	// Clear our variables
 	//
+	FatSectorStart = 0;
+	ActiveFatSectorStart = 0;
+	NumberOfFats = 0;
 	RootDirSectorStart = 0;
 	DataSectorStart = 0;
 	SectorsPerFat = 0;
@@ -188,21 +209,48 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 	// root directory starting sector,
 	// and data sector start
 	//
-	if (FatType != FAT32)
+	if (ISFATX(FatType))
 	{
+		BytesPerSector = 512;
+		SectorsPerCluster = FatXVolumeBootSector->SectorsPerCluster;
+		FatSectorStart = (4096 / BytesPerSector);
+		ActiveFatSectorStart = FatSectorStart;
+		NumberOfFats = 1;
+		FatSize = PartitionSectorCount / SectorsPerCluster *
+		          (FATX16 == FatType ? 2 : 4);
+		SectorsPerFat = (((FatSize + 4095) / 4096) * 4096) / BytesPerSector;
+
+		RootDirSectorStart = FatSectorStart + NumberOfFats * SectorsPerFat;
+		RootDirSectors = FatXVolumeBootSector->SectorsPerCluster;
+
+		DataSectorStart = RootDirSectorStart + RootDirSectors;
+	}
+	else if (FatType != FAT32)
+	{
+		BytesPerSector = FatVolumeBootSector->BytesPerSector;
+		SectorsPerCluster = FatVolumeBootSector->SectorsPerCluster;
+		FatSectorStart = FatVolumeBootSector->ReservedSectors;
+		ActiveFatSectorStart = FatSectorStart;
+		NumberOfFats = FatVolumeBootSector->NumberOfFats;
 		SectorsPerFat = FatVolumeBootSector->SectorsPerFat;
 
-		RootDirSectorStart = (FatVolumeBootSector->NumberOfFats * SectorsPerFat) + FatVolumeBootSector->ReservedSectors;
-		RootDirSectors = ((FatVolumeBootSector->RootDirEntries * 32) + (FatVolumeBootSector->BytesPerSector - 1)) / FatVolumeBootSector->BytesPerSector;
+		RootDirSectorStart = FatSectorStart + NumberOfFats * SectorsPerFat;
+		RootDirSectors = ((FatVolumeBootSector->RootDirEntries * 32) + (BytesPerSector - 1)) / BytesPerSector;
 
-		DataSectorStart = FatVolumeBootSector->ReservedSectors + (FatVolumeBootSector->NumberOfFats * FatVolumeBootSector->SectorsPerFat) + RootDirSectors;
+		DataSectorStart = RootDirSectorStart + RootDirSectors;
 	}
 	else
 	{
+		BytesPerSector = Fat32VolumeBootSector->BytesPerSector;
+		SectorsPerCluster = Fat32VolumeBootSector->SectorsPerCluster;
+		FatSectorStart = Fat32VolumeBootSector->ReservedSectors;
+		ActiveFatSectorStart = FatSectorStart +
+		                       ((Fat32VolumeBootSector->ExtendedFlags & 0x80) ? ((Fat32VolumeBootSector->ExtendedFlags & 0x0f) * Fat32VolumeBootSector->SectorsPerFatBig) : 0);
+		NumberOfFats = Fat32VolumeBootSector->NumberOfFats;
 		SectorsPerFat = Fat32VolumeBootSector->SectorsPerFatBig;
 
-		DataSectorStart = FatVolumeBootSector->ReservedSectors + (FatVolumeBootSector->NumberOfFats * Fat32VolumeBootSector->SectorsPerFatBig) + RootDirSectors;
-		
+		RootDirStartCluster = Fat32VolumeBootSector->RootDirStartCluster;
+		DataSectorStart = FatSectorStart + NumberOfFats * SectorsPerFat;
 
 		//
 		// Check version
@@ -214,6 +262,7 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 			return FALSE;
 		}
 	}
+	MmFreeMemory(FatVolumeBootSector);
 
 	//
 	// Initialize the disk cache for this drive
@@ -228,9 +277,9 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 	// as long as it is FAT12 or FAT16. FAT32 can
 	// have a multi-megabyte FAT so we don't want that.
 	//
-	if (FatType != FAT32)
+	if (FatType != FAT32 && FatType != FATX32)
 	{
-		if (!CacheForceDiskSectorsIntoCache(DriveNumber, FatVolumeBootSector->HiddenSectors + FatVolumeBootSector->ReservedSectors, FatVolumeBootSector->SectorsPerFat))
+		if (!CacheForceDiskSectorsIntoCache(DriveNumber, ActiveFatSectorStart, SectorsPerFat))
 		{
 			return FALSE;
 		}
@@ -239,76 +288,94 @@ BOOL FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 	return TRUE;
 }
 
-U32 FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector)
+U32 FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector, U32 PartitionSectorCount)
 {
-	U32					RootDirSectors;
-	U32					DataSectorCount;
-	U32					SectorsPerFat;
-	U32					TotalSectors;
-	U32					CountOfClusters;
+	U32			RootDirSectors;
+	U32			DataSectorCount;
+	U32			SectorsPerFat;
+	U32			TotalSectors;
+	U32			CountOfClusters;
 	PFAT32_BOOTSECTOR	Fat32BootSector = (PFAT32_BOOTSECTOR)FatBootSector;
+	PFATX_BOOTSECTOR	FatXBootSector = (PFATX_BOOTSECTOR)FatBootSector;
 
-	RootDirSectors = ((FatBootSector->RootDirEntries * 32) + (FatBootSector->BytesPerSector - 1)) / FatBootSector->BytesPerSector;
-	SectorsPerFat = FatBootSector->SectorsPerFat ? FatBootSector->SectorsPerFat : Fat32BootSector->SectorsPerFatBig;
-	TotalSectors = FatBootSector->TotalSectors ? FatBootSector->TotalSectors : FatBootSector->TotalSectorsBig;
-	DataSectorCount = TotalSectors - (FatBootSector->ReservedSectors + (FatBootSector->NumberOfFats * SectorsPerFat) + RootDirSectors);
+	if (0 == strncmp(FatXBootSector->FileSystemType, "FATX", 4))
+	{
+		CountOfClusters = PartitionSectorCount / FatXBootSector->SectorsPerCluster;
+		if (CountOfClusters < 65525)
+		{
+			/* Volume is FATX16 */
+			return FATX16;
+		}
+		else
+		{
+			/* Volume is FAT32 */
+			return FATX32;
+		}
+	}
+	else
+	{
+		RootDirSectors = ((FatBootSector->RootDirEntries * 32) + (FatBootSector->BytesPerSector - 1)) / FatBootSector->BytesPerSector;
+		SectorsPerFat = FatBootSector->SectorsPerFat ? FatBootSector->SectorsPerFat : Fat32BootSector->SectorsPerFatBig;
+		TotalSectors = FatBootSector->TotalSectors ? FatBootSector->TotalSectors : FatBootSector->TotalSectorsBig;
+		DataSectorCount = TotalSectors - (FatBootSector->ReservedSectors + (FatBootSector->NumberOfFats * SectorsPerFat) + RootDirSectors);
 	
 //mjl 
-	if (FatBootSector->SectorsPerCluster == 0)
-		CountOfClusters = 0;
-	else
-		CountOfClusters = DataSectorCount / FatBootSector->SectorsPerCluster;
+		if (FatBootSector->SectorsPerCluster == 0)
+			CountOfClusters = 0;
+		else
+			CountOfClusters = DataSectorCount / FatBootSector->SectorsPerCluster;
 
-	if (CountOfClusters < 4085)
-	{
-		/* Volume is FAT12 */
-		return FAT12;
-	}
-	else if (CountOfClusters < 65525)
-	{
-		/* Volume is FAT16 */
-		return FAT16;
-	}
-	else
-	{
-		/* Volume is FAT32 */
-		return FAT32;
+		if (CountOfClusters < 4085)
+		{
+			/* Volume is FAT12 */
+			return FAT12;
+		}
+		else if (CountOfClusters < 65525)
+		{
+			/* Volume is FAT16 */
+			return FAT16;
+		}
+		else
+		{
+			/* Volume is FAT32 */
+			return FAT32;
+		}
 	}
 }
 
-PVOID FatBufferDirectory(U32 DirectoryStartCluster, U32* EntryCountPointer, BOOL RootDirectory)
+PVOID FatBufferDirectory(U32 DirectoryStartCluster, U32 *DirectorySize, BOOL RootDirectory)
 {
-	U32	RootDirectoryStartSector;
-	U32	RootDirectorySectorCount;
 	PVOID	DirectoryBuffer;
-	U32	DirectorySize;
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatBufferDirectory() DirectoryStartCluster = %d RootDirectory = %s\n", DirectoryStartCluster, (RootDirectory ? "TRUE" : "FALSE")));
 
+	/*
+	 * For FAT32, the root directory is nothing special. We can treat it the same
+	 * as a subdirectory.
+	 */
+	if (RootDirectory && FAT32 == FatType)
+	{
+		DirectoryStartCluster = RootDirStartCluster;
+		RootDirectory = FALSE;
+	}
+
 	//
 	// Calculate the size of the directory
 	//
-	if ((RootDirectory) && (FatType != FAT32))
+	if (RootDirectory)
 	{
-		DirectorySize = ROUND_UP((FatVolumeBootSector->RootDirEntries * 32), FatVolumeBootSector->BytesPerSector);
+		*DirectorySize = RootDirSectors * BytesPerSector;
 	}
 	else
 	{
-		if (RootDirectory)
-		{
-			DirectorySize = (FatCountClustersInChain(Fat32VolumeBootSector->RootDirStartCluster) * Fat32VolumeBootSector->SectorsPerCluster) * Fat32VolumeBootSector->BytesPerSector;
-		}
-		else
-		{
-			DirectorySize = (FatCountClustersInChain(DirectoryStartCluster) * FatVolumeBootSector->SectorsPerCluster) * FatVolumeBootSector->BytesPerSector;
-		}
+		*DirectorySize = FatCountClustersInChain(DirectoryStartCluster) * SectorsPerCluster * BytesPerSector;
 	}
 
 	//
 	// Attempt to allocate memory for directory buffer
 	//
-	DbgPrint((DPRINT_FILESYSTEM, "Trying to allocate (DirectorySize) %d bytes.\n", DirectorySize));
-	DirectoryBuffer = MmAllocateMemory(DirectorySize);
+	DbgPrint((DPRINT_FILESYSTEM, "Trying to allocate (DirectorySize) %d bytes.\n", *DirectorySize));
+	DirectoryBuffer = MmAllocateMemory(*DirectorySize);
 
 	if (DirectoryBuffer == NULL)
 	{
@@ -320,27 +387,10 @@ PVOID FatBufferDirectory(U32 DirectoryStartCluster, U32* EntryCountPointer, BOOL
 	//
 	if (RootDirectory)
 	{
-		if (FatType == FAT32)
+		if (!FatReadVolumeSectors(FatDriveNumber, RootDirSectorStart, RootDirSectors, DirectoryBuffer))
 		{
-			if (!FatReadClusterChain(Fat32VolumeBootSector->RootDirStartCluster, 0xFFFFFFFF, DirectoryBuffer))
-			{
-				MmFreeMemory(DirectoryBuffer);
-				return NULL;
-			}
-		}
-		else
-		{
-			//
-			// FAT type is not FAT32 so the root directory comes right after the fat table
-			//
-			RootDirectoryStartSector = FatVolumeBootSector->ReservedSectors + (FatVolumeBootSector->NumberOfFats * FatVolumeBootSector->SectorsPerFat);
-			RootDirectorySectorCount = (DirectorySize / FatVolumeBootSector->BytesPerSector);
-
-			if (!FatReadVolumeSectors(FatDriveNumber, RootDirectoryStartSector, RootDirectorySectorCount, DirectoryBuffer))
-			{
-				MmFreeMemory(DirectoryBuffer);
-				return NULL;
-			}
+			MmFreeMemory(DirectoryBuffer);
+			return NULL;
 		}
 	}
 	else
@@ -352,28 +402,29 @@ PVOID FatBufferDirectory(U32 DirectoryStartCluster, U32* EntryCountPointer, BOOL
 		}
 	}
 
-	*EntryCountPointer = (DirectorySize / 32);
-
 	return DirectoryBuffer;
 }
 
-BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 EntryCount, PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
+BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 DirectorySize, PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
 {
-	U32				CurrentEntry;
-	PDIRENTRY		DirEntry;
+	U32		EntryCount;
+	U32		CurrentEntry;
+	PDIRENTRY	DirEntry;
 	PLFN_DIRENTRY	LfnDirEntry;
-	UCHAR			LfnNameBuffer[265];
-	UCHAR			ShortNameBuffer[20];
-	U32			StartCluster;
+	UCHAR		LfnNameBuffer[265];
+	UCHAR		ShortNameBuffer[20];
+	U32		StartCluster;
+
+	EntryCount = DirectorySize / sizeof(DIRENTRY);
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x EntryCount = %d FileName = %s\n", DirectoryBuffer, EntryCount, FileName));
 
 	memset(ShortNameBuffer, 0, 13 * sizeof(UCHAR));
 	memset(LfnNameBuffer, 0, 261 * sizeof(UCHAR));
 
-	for (CurrentEntry=0; CurrentEntry<EntryCount; CurrentEntry++)
+	DirEntry = (PDIRENTRY) DirectoryBuffer;
+	for (CurrentEntry=0; CurrentEntry<EntryCount; CurrentEntry++, DirEntry++)
 	{
-		DirEntry = (PDIRENTRY)(DirectoryBuffer + (CurrentEntry * 32) );
 		LfnDirEntry = (PLFN_DIRENTRY)DirEntry;
 
 		//DbgPrint((DPRINT_FILESYSTEM, "Dumping directory entry %d:\n", CurrentEntry));
@@ -515,8 +566,7 @@ BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 EntryCount, PUCH
 		// See if the file name matches either the short or long name
 		//
 		if (((strlen(FileName) == strlen(LfnNameBuffer)) && (stricmp(FileName, LfnNameBuffer) == 0)) ||
-			((strlen(FileName) == strlen(ShortNameBuffer)) && (stricmp(FileName, ShortNameBuffer) == 0)))
-		{
+			((strlen(FileName) == strlen(ShortNameBuffer)) && (stricmp(FileName, ShortNameBuffer) == 0)))		{
 			//
 			// We found the entry, now fill in the FAT_FILE_INFO struct
 			//
@@ -566,21 +616,85 @@ BOOL FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 EntryCount, PUCH
 	return FALSE;
 }
 
+BOOL FatXSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 DirectorySize, PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
+{
+	U32		EntryCount;
+	U32		CurrentEntry;
+	PFATX_DIRENTRY	DirEntry;
+	U32		FileNameLen;
+
+	EntryCount = DirectorySize / sizeof(FATX_DIRENTRY);
+
+	DbgPrint((DPRINT_FILESYSTEM, "FatXSearchDirectoryBufferForFile() DirectoryBuffer = 0x%x EntryCount = %d FileName = %s\n", DirectoryBuffer, EntryCount, FileName));
+
+	FileNameLen = strlen(FileName);
+	DirEntry = (PFATX_DIRENTRY) DirectoryBuffer;
+	for (CurrentEntry = 0; CurrentEntry < EntryCount; CurrentEntry++, DirEntry++)
+	{
+		if (0xff == DirEntry->FileNameSize)
+		{
+			break;
+		}
+		if (0xe5 == DirEntry->FileNameSize)
+		{
+			continue;
+		}
+		if (FileNameLen == DirEntry->FileNameSize &&
+		    0 == strnicmp(FileName, DirEntry->FileName, FileNameLen))
+		{
+			/*
+			 * We found the entry, now fill in the FAT_FILE_INFO struct
+			 */
+			FatFileInfoPointer->FileSize = DirEntry->Size;
+			FatFileInfoPointer->FilePointer = 0;
+
+			DbgPrint((DPRINT_FILESYSTEM, "FATX Directory Entry:\n"));
+			DbgPrint((DPRINT_FILESYSTEM, "FileNameSize = %d\n", DirEntry->FileNameSize));
+			DbgPrint((DPRINT_FILESYSTEM, "Attr = 0x%x\n", DirEntry->Attr));
+			DbgPrint((DPRINT_FILESYSTEM, "StartCluster = 0x%x\n", DirEntry->StartCluster));
+			DbgPrint((DPRINT_FILESYSTEM, "Size = %d\n", DirEntry->Size));
+			DbgPrint((DPRINT_FILESYSTEM, "Time = %d\n", DirEntry->Time));
+			DbgPrint((DPRINT_FILESYSTEM, "Date = %d\n", DirEntry->Date));
+			DbgPrint((DPRINT_FILESYSTEM, "CreateTime = %d\n", DirEntry->CreateTime));
+			DbgPrint((DPRINT_FILESYSTEM, "CreateDate = %d\n", DirEntry->CreateDate));
+			DbgPrint((DPRINT_FILESYSTEM, "LastAccessTime = %d\n", DirEntry->LastAccessTime));
+			DbgPrint((DPRINT_FILESYSTEM, "LastAccessDate = %d\n", DirEntry->LastAccessDate));
+
+			/*
+			 * Get the cluster chain
+			 */
+			FatFileInfoPointer->FileFatChain = FatGetClusterChainArray(DirEntry->StartCluster);
+
+			/*
+			 * See if memory allocation failed
+			 */
+			if (NULL == FatFileInfoPointer->FileFatChain)
+			{
+				return FALSE;
+			}
+
+			return TRUE;
+		}
+	}
+
+	return FALSE;
+}
+
 /*
  * FatLookupFile()
  * This function searches the file system for the
- * specified filename and fills in a FAT_STRUCT structure
+ * specified filename and fills in a FAT_FILE_INFO structure
  * with info describing the file, etc. returns true
  * if the file exists or false otherwise
  */
 BOOL FatLookupFile(PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
 {
-	int				i;
-	U32				NumberOfPathParts;
-	UCHAR			PathPart[261];
-	PVOID			DirectoryBuffer;
-	U32			DirectoryStartCluster = 0;
-	U32				DirectoryEntryCount;
+	int		i;
+	U32		NumberOfPathParts;
+	UCHAR		PathPart[261];
+	PVOID		DirectoryBuffer;
+	U32		DirectoryStartCluster = 0;
+	U32		DirectorySize;
 	FAT_FILE_INFO	FatFileInfo;
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatLookupFile() FileName = %s\n", FileName));
@@ -613,7 +727,7 @@ BOOL FatLookupFile(PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
 		//
 		// Buffer the directory contents
 		//
-		DirectoryBuffer = FatBufferDirectory(DirectoryStartCluster, &DirectoryEntryCount, (i == 0) );
+		DirectoryBuffer = FatBufferDirectory(DirectoryStartCluster, &DirectorySize, (i == 0) );
 		if (DirectoryBuffer == NULL)
 		{
 			return FALSE;
@@ -622,10 +736,21 @@ BOOL FatLookupFile(PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer)
 		//
 		// Search for file name in directory
 		//
-		if (!FatSearchDirectoryBufferForFile(DirectoryBuffer, DirectoryEntryCount, PathPart, &FatFileInfo))
+		if (ISFATX(FatType))
 		{
-			MmFreeMemory(DirectoryBuffer);
-			return FALSE;
+			if (!FatXSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo))
+			{
+				MmFreeMemory(DirectoryBuffer);
+				return FALSE;
+			}
+		}
+		else
+		{
+			if (!FatSearchDirectoryBufferForFile(DirectoryBuffer, DirectorySize, PathPart, &FatFileInfo))
+			{
+				MmFreeMemory(DirectoryBuffer);
+				return FALSE;
+			}
 		}
 
 		MmFreeMemory(DirectoryBuffer);
@@ -713,14 +838,14 @@ BOOL FatGetFatEntry(U32 Cluster, U32* ClusterPointer)
 	case FAT12:
 
 		FatOffset = Cluster + (Cluster / 2);
-		ThisFatSecNum = FatVolumeBootSector->ReservedSectors + (FatOffset / FatVolumeBootSector->BytesPerSector);
-		ThisFatEntOffset = (FatOffset % FatVolumeBootSector->BytesPerSector);
+		ThisFatSecNum = ActiveFatSectorStart + (FatOffset / BytesPerSector);
+		ThisFatEntOffset = (FatOffset % BytesPerSector);
 
 		DbgPrint((DPRINT_FILESYSTEM, "FatOffset: %d\n", FatOffset));
 		DbgPrint((DPRINT_FILESYSTEM, "ThisFatSecNum: %d\n", ThisFatSecNum));
 		DbgPrint((DPRINT_FILESYSTEM, "ThisFatEntOffset: %d\n", ThisFatEntOffset));
 
-		if (ThisFatEntOffset == (FatVolumeBootSector->BytesPerSector - 1))
+		if (ThisFatEntOffset == (BytesPerSector - 1))
 		{
 			if (!FatReadVolumeSectors(FatDriveNumber, ThisFatSecNum, 2, (PVOID)FILESYSBUFFER))
 			{
@@ -744,10 +869,11 @@ BOOL FatGetFatEntry(U32 Cluster, U32* ClusterPointer)
 		break;
 
 	case FAT16:
+	case FATX16:
 		
 		FatOffset = (Cluster * 2);
-		ThisFatSecNum = FatVolumeBootSector->ReservedSectors + (FatOffset / FatVolumeBootSector->BytesPerSector);
-		ThisFatEntOffset = (FatOffset % FatVolumeBootSector->BytesPerSector);
+		ThisFatSecNum = ActiveFatSectorStart + (FatOffset / BytesPerSector);
+		ThisFatEntOffset = (FatOffset % BytesPerSector);
 
 		if (!FatReadVolumeSectors(FatDriveNumber, ThisFatSecNum, 1, (PVOID)FILESYSBUFFER))
 		{
@@ -759,11 +885,11 @@ BOOL FatGetFatEntry(U32 Cluster, U32* ClusterPointer)
 		break;
 
 	case FAT32:
+	case FATX32:
 
 		FatOffset = (Cluster * 4);
-		ThisFatSecNum = (Fat32VolumeBootSector->ExtendedFlags & 0x80) ? ((Fat32VolumeBootSector->ExtendedFlags & 0x0f) * Fat32VolumeBootSector->SectorsPerFatBig) : 0; // Get the active fat sector offset
-		ThisFatSecNum += FatVolumeBootSector->ReservedSectors + (FatOffset / FatVolumeBootSector->BytesPerSector);
-		ThisFatEntOffset = (FatOffset % FatVolumeBootSector->BytesPerSector);
+		ThisFatSecNum = ActiveFatSectorStart + (FatOffset / BytesPerSector);
+		ThisFatEntOffset = (FatOffset % BytesPerSector);
 
 		if (!FatReadVolumeSectors(FatDriveNumber, ThisFatSecNum, 1, (PVOID)FILESYSBUFFER))
 		{
@@ -825,8 +951,8 @@ U32 FatCountClustersInChain(U32 StartCluster)
 		// If end of chain then break out of our cluster counting loop
 		//
 		if (((FatType == FAT12) && (StartCluster >= 0xff8)) ||
-			((FatType == FAT16) && (StartCluster >= 0xfff8)) ||
-			((FatType == FAT32) && (StartCluster >= 0x0ffffff8)))
+			((FatType == FAT16 || FatType == FATX16) && (StartCluster >= 0xfff8)) ||
+			((FatType == FAT32 || FatType == FATX32) && (StartCluster >= 0x0ffffff8)))
 		{
 			break;
 		}
@@ -886,8 +1012,8 @@ U32* FatGetClusterChainArray(U32 StartCluster)
 		// Don't try to get next cluster for last cluster
 		//
 		if (((FatType == FAT12) && (StartCluster >= 0xff8)) ||
-			((FatType == FAT16) && (StartCluster >= 0xfff8)) ||
-			((FatType == FAT32) && (StartCluster >= 0x0ffffff8)))
+			((FatType == FAT16 || FatType == FATX16) && (StartCluster >= 0xfff8)) ||
+			((FatType == FAT32 || FatType == FATX32) && (StartCluster >= 0x0ffffff8)))
 		{
 			Idx++;
 			break;
@@ -909,22 +1035,21 @@ U32* FatGetClusterChainArray(U32 StartCluster)
 /*
  * FatReadCluster()
  * Reads the specified cluster into memory
- * and returns the number of bytes read
  */
 BOOL FatReadCluster(U32 ClusterNumber, PVOID Buffer)
 {
 	U32		ClusterStartSector;
 
-	ClusterStartSector = ((ClusterNumber - 2) * FatVolumeBootSector->SectorsPerCluster) + DataSectorStart;
+	ClusterStartSector = ((ClusterNumber - 2) * SectorsPerCluster) + DataSectorStart;
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatReadCluster() ClusterNumber = %d Buffer = 0x%x ClusterStartSector = %d\n", ClusterNumber, Buffer, ClusterStartSector));
 
-	if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, FatVolumeBootSector->SectorsPerCluster, (PVOID)FILESYSBUFFER))
+	if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, SectorsPerCluster, (PVOID)FILESYSBUFFER))
 	{
 		return FALSE;
 	}
 
-	memcpy(Buffer, (PVOID)FILESYSBUFFER, FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector);
+	memcpy(Buffer, (PVOID)FILESYSBUFFER, SectorsPerCluster * BytesPerSector);
 
 	return TRUE;
 }
@@ -946,17 +1071,17 @@ BOOL FatReadClusterChain(U32 StartClusterNumber, U32 NumberOfClusters, PVOID Buf
 		//
 		// Calculate starting sector for cluster
 		//
-		ClusterStartSector = ((StartClusterNumber - 2) * FatVolumeBootSector->SectorsPerCluster) + DataSectorStart;
+		ClusterStartSector = ((StartClusterNumber - 2) * SectorsPerCluster) + DataSectorStart;
 
 		//
 		// Read cluster into memory
 		//
-		if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, FatVolumeBootSector->SectorsPerCluster, (PVOID)FILESYSBUFFER))
+		if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, SectorsPerCluster, (PVOID)FILESYSBUFFER))
 		{
 			return FALSE;
 		}
 
-		memcpy(Buffer, (PVOID)FILESYSBUFFER, FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector);
+		memcpy(Buffer, (PVOID)FILESYSBUFFER, SectorsPerCluster * BytesPerSector);
 
 		//
 		// Decrement count of clusters left to read
@@ -966,7 +1091,7 @@ BOOL FatReadClusterChain(U32 StartClusterNumber, U32 NumberOfClusters, PVOID Buf
 		//
 		// Increment buffer address by cluster size
 		//
-		Buffer += (FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector);
+		Buffer += SectorsPerCluster * BytesPerSector;
 
 		//
 		// Get next cluster
@@ -980,8 +1105,8 @@ BOOL FatReadClusterChain(U32 StartClusterNumber, U32 NumberOfClusters, PVOID Buf
 		// If end of chain then break out of our cluster reading loop
 		//
 		if (((FatType == FAT12) && (StartClusterNumber >= 0xff8)) ||
-			((FatType == FAT16) && (StartClusterNumber >= 0xfff8)) ||
-			((FatType == FAT32) && (StartClusterNumber >= 0x0ffffff8)))
+			((FatType == FAT16 || FatType == FATX16) && (StartClusterNumber >= 0xfff8)) ||
+			((FatType == FAT32 || FatType == FATX32) && (StartClusterNumber >= 0x0ffffff8)))
 		{
 			break;
 		}
@@ -1000,9 +1125,9 @@ BOOL FatReadPartialCluster(U32 ClusterNumber, U32 StartingOffset, U32 Length, PV
 
 	DbgPrint((DPRINT_FILESYSTEM, "FatReadPartialCluster() ClusterNumber = %d StartingOffset = %d Length = %d Buffer = 0x%x\n", ClusterNumber, StartingOffset, Length, Buffer));
 
-	ClusterStartSector = ((ClusterNumber - 2) * FatVolumeBootSector->SectorsPerCluster) + DataSectorStart;
+	ClusterStartSector = ((ClusterNumber - 2) * SectorsPerCluster) + DataSectorStart;
 
-	if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, FatVolumeBootSector->SectorsPerCluster, (PVOID)FILESYSBUFFER))
+	if (!FatReadVolumeSectors(FatDriveNumber, ClusterStartSector, SectorsPerCluster, (PVOID)FILESYSBUFFER))
 	{
 		return FALSE;
 	}
@@ -1080,7 +1205,7 @@ BOOL FatReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer
 	//     the last cluster.
 	//
 
-	BytesPerCluster = (FatVolumeBootSector->SectorsPerCluster * FatVolumeBootSector->BytesPerSector);
+	BytesPerCluster = SectorsPerCluster * BytesPerSector;
 
 	//
 	// Only do the first read if we
@@ -1200,15 +1325,5 @@ U32 FatGetFilePointer(FILE *FileHandle)
 
 BOOL FatReadVolumeSectors(U32 DriveNumber, U32 SectorNumber, U32 SectorCount, PVOID Buffer)
 {
-	//GEOMETRY	DiskGeometry;
-	//BOOL		ReturnValue;
-	//if (!DiskGetDriveGeometry(DriveNumber, &DiskGeometry))
-	//{
-	//	return FALSE;
-	//}
-	//ReturnValue = DiskReadLogicalSectors(DriveNumber, SectorNumber + FatVolumeBootSector->HiddenSectors, SectorCount, (PVOID)DISKREADBUFFER);
-	//RtlCopyMemory(Buffer, (PVOID)DISKREADBUFFER, SectorCount * DiskGeometry.BytesPerSector);
-	//return ReturnValue;
-
-	return CacheReadDiskSectors(DriveNumber, SectorNumber + FatVolumeBootSector->HiddenSectors, SectorCount, Buffer);
+	return CacheReadDiskSectors(DriveNumber, SectorNumber + FatVolumeStartSector, SectorCount, Buffer);
 }

freeldr/freeldr/fs/fat.h

@@ -85,56 +85,82 @@ typedef struct _FAT32_BOOTSECTOR
 	
 } PACKED FAT32_BOOTSECTOR, *PFAT32_BOOTSECTOR;
 
+typedef struct _FATX_BOOTSECTOR
+{
+	U8		FileSystemType[4];			/* String "FATX" */
+	U32		VolumeSerialNumber;			/* Volume serial number */
+	U32		SectorsPerCluster;			/* Number of sectors in a cluster */
+	U16		NumberOfFats;				/* Number of FAT tables */
+	U32		Unknown;				/* Always 0? */
+	U8		Unused[494];				/* Actually size should be 4078 (boot block is 4096 bytes) */
+	
+} PACKED FATX_BOOTSECTOR, *PFATX_BOOTSECTOR;
+
 /*
  * Structure of MSDOS directory entry
  */
 typedef struct //_DIRENTRY
 {
 	UCHAR	FileName[11];	/* Filename + extension */
-	U8		Attr;			/* File attributes */
-	U8		ReservedNT;		/* Reserved for use by Windows NT */
-	U8		TimeInTenths;	/* Millisecond stamp at file creation */
-	U16		CreateTime;		/* Time file was created */
-	U16		CreateDate;		/* Date file was created */
-	U16		LastAccessDate;	/* Date file was last accessed */
-	U16		ClusterHigh;	/* High word of this entry's start cluster */
-	U16		Time;			/* Time last modified */
-	U16		Date;			/* Date last modified */
-	U16		ClusterLow;		/* First cluster number low word */
-	U32		Size;			/* File size */
+	U8	Attr;		/* File attributes */
+	U8	ReservedNT;	/* Reserved for use by Windows NT */
+	U8	TimeInTenths;	/* Millisecond stamp at file creation */
+	U16	CreateTime;	/* Time file was created */
+	U16	CreateDate;	/* Date file was created */
+	U16	LastAccessDate;	/* Date file was last accessed */
+	U16	ClusterHigh;	/* High word of this entry's start cluster */
+	U16	Time;		/* Time last modified */
+	U16	Date;		/* Date last modified */
+	U16	ClusterLow;	/* First cluster number low word */
+	U32	Size;		/* File size */
 } PACKED DIRENTRY, * PDIRENTRY;
 
 typedef struct
 {
-	U8		SequenceNumber;		/* Sequence number for slot */
-	WCHAR	Name0_4[5];			/* First 5 characters in name */
-	U8		EntryAttributes;	/* Attribute byte */
-	U8		Reserved;			/* Always 0 */
-	U8		AliasChecksum;		/* Checksum for 8.3 alias */
+	U8	SequenceNumber;		/* Sequence number for slot */
+	WCHAR	Name0_4[5];		/* First 5 characters in name */
+	U8	EntryAttributes;	/* Attribute byte */
+	U8	Reserved;		/* Always 0 */
+	U8	AliasChecksum;		/* Checksum for 8.3 alias */
 	WCHAR	Name5_10[6];		/* 6 more characters in name */
-	U16		StartCluster;		/* Starting cluster number */
+	U16	StartCluster;		/* Starting cluster number */
 	WCHAR	Name11_12[2];		/* Last 2 characters in name */
 } PACKED LFN_DIRENTRY, * PLFN_DIRENTRY;
 
 typedef struct
 {
-	U32		FileSize;			// File size
-	U32		FilePointer;		// File pointer
-	U32*	FileFatChain;		// File fat chain array
-	U32		DriveNumber;
+	U8	FileNameSize;	/* Size of filename (max 42) */
+	U8	Attr;		/* File attributes */
+	UCHAR	FileName[42];	/* Filename in ASCII, padded with 0xff (not zero-terminated) */
+	U32	StartCluster;	/* Starting cluster number */
+	U32	Size;		/* File size */
+	U16	Time;		/* Time last modified */
+	U16	Date;		/* Date last modified */
+	U16	CreateTime;	/* Time file was created */
+	U16	CreateDate;	/* Date file was created */
+	U16	LastAccessTime;	/* Time file was last accessed */
+	U16	LastAccessDate;	/* Date file was last accessed */
+} PACKED FATX_DIRENTRY, * PFATX_DIRENTRY;
+
+typedef struct
+{
+	U32	FileSize;		/* File size */
+	U32	FilePointer;		/* File pointer */
+	U32*	FileFatChain;		/* File fat chain array */
+	U32	DriveNumber;
 } FAT_FILE_INFO, * PFAT_FILE_INFO;
 
 
 
-BOOL	FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector);
-U32		FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector);
+BOOL	FatOpenVolume(U32 DriveNumber, U32 VolumeStartSector, U32 PartitionSectorCount);
+U32	FatDetermineFatType(PFAT_BOOTSECTOR FatBootSector, U32 PartitionSectorCount);
 PVOID	FatBufferDirectory(U32 DirectoryStartCluster, U32* EntryCountPointer, BOOL RootDirectory);
 BOOL	FatSearchDirectoryBufferForFile(PVOID DirectoryBuffer, U32 EntryCount, PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
 BOOL	FatLookupFile(PUCHAR FileName, PFAT_FILE_INFO FatFileInfoPointer);
 void	FatParseShortFileName(PUCHAR Buffer, PDIRENTRY DirEntry);
 BOOL	FatGetFatEntry(U32 Cluster, U32* ClusterPointer);
 FILE*	FatOpenFile(PUCHAR FileName);
-U32		FatCountClustersInChain(U32 StartCluster);
+U32	FatCountClustersInChain(U32 StartCluster);
 U32*	FatGetClusterChainArray(U32 StartCluster);
 BOOL	FatReadCluster(U32 ClusterNumber, PVOID Buffer);
 BOOL	FatReadClusterChain(U32 StartClusterNumber, U32 NumberOfClusters, PVOID Buffer);
@@ -158,5 +184,9 @@ BOOL	FatReadVolumeSectors(U32 DriveNumber, U32 SectorNumber, U32 SectorCount, PV
 #define	FAT12			1
 #define	FAT16			2
 #define	FAT32			3
+#define FATX16			4
+#define FATX32			5
+
+#define ISFATX(FT) ((FT) == FATX16 || (FT) == FATX32)
 
 #endif // #defined __FAT_H

freeldr/freeldr/fs/fs.c

@@ -29,6 +29,7 @@
 #include <ui.h>
 #include <arch.h>
 #include <debug.h>
+#include <machine.h>
 
 
 /////////////////////////////////////////////////////////////////////////////////////////////
@@ -78,11 +79,11 @@ BOOL FsOpenVolume(U32 DriveNumber, U32 PartitionNumber)
 		DbgPrint((DPRINT_FILESYSTEM, "Drive is a floppy diskette drive. Assuming FAT12 file system.\n"));
 
 		FileSystemType = FS_FAT;
-		return FatOpenVolume(DriveNumber, 0);
+		return FatOpenVolume(DriveNumber, 0, 0);
 	}
 
 	// Check for ISO9660 file system type
-	if (DriveNumber > 0x80 && FsRecIsIso9660(DriveNumber))
+	if (DriveNumber >= 0x80 && FsRecIsIso9660(DriveNumber))
 	{
 		DbgPrint((DPRINT_FILESYSTEM, "Drive is a cdrom drive. Assuming ISO-9660 file system.\n"));
 
@@ -106,7 +107,7 @@ BOOL FsOpenVolume(U32 DriveNumber, U32 PartitionNumber)
 	else
 	{
 		// Get requested partition
-		if (DiskGetPartitionEntry(DriveNumber, PartitionNumber, &PartitionTableEntry) == FALSE)
+		if (MachDiskGetPartitionEntry(DriveNumber, PartitionNumber, &PartitionTableEntry) == FALSE)
 		{
 			FileSystemError("Partition not found.");
 			return FALSE;
@@ -137,7 +138,7 @@ BOOL FsOpenVolume(U32 DriveNumber, U32 PartitionNumber)
 	case PARTITION_FAT32:
 	case PARTITION_FAT32_XINT13:
 		FileSystemType = FS_FAT;
-		return FatOpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition);
+		return FatOpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition, PartitionTableEntry.PartitionSectorCount);
 	case PARTITION_EXT2:
 		FileSystemType = FS_EXT2;
 		return Ext2OpenVolume(DriveNumber, PartitionTableEntry.SectorCountBeforePartition);

freeldr/freeldr/fs/fsrec.c

@@ -28,6 +28,7 @@
 #include <rtl.h>
 #include <arch.h>
 #include <debug.h>
+#include <machine.h>
 
 
 
@@ -69,7 +70,7 @@ BOOL FsRecIsIso9660(U32 DriveNumber)
 {
 	PUCHAR Sector = (PUCHAR)DISKREADBUFFER;
 
-	if (!DiskReadLogicalSectors(DriveNumber, 16, 1, Sector))
+	if (!MachDiskReadLogicalSectors(DriveNumber, 16, 1, Sector))
 	{
 		FileSystemError("Failed to read the PVD.");
 		return FALSE;
@@ -87,7 +88,7 @@ BOOL FsRecIsExt2(U32 DriveNumber, U32 VolumeStartSector)
 {
 	PEXT2_SUPER_BLOCK	SuperBlock = (PEXT2_SUPER_BLOCK)DISKREADBUFFER;
 
-	if (!DiskReadLogicalSectors(DriveNumber, VolumeStartSector + 2, 2, SuperBlock))
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector + 2, 2, SuperBlock))
 	{
 		FileSystemError("Failed to read the super block.");
 		return FALSE;
@@ -105,7 +106,8 @@ BOOL FsRecIsFat(U32 DriveNumber, U32 VolumeStartSector)
 {
 	PFAT_BOOTSECTOR	BootSector = (PFAT_BOOTSECTOR)DISKREADBUFFER;
 	PFAT32_BOOTSECTOR BootSector32 = (PFAT32_BOOTSECTOR)DISKREADBUFFER;
-	if (!DiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
+	PFATX_BOOTSECTOR BootSectorX = (PFATX_BOOTSECTOR)DISKREADBUFFER;
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
 	{
 		FileSystemError("Failed to read the boot sector.");
 		return FALSE;
@@ -113,7 +115,8 @@ BOOL FsRecIsFat(U32 DriveNumber, U32 VolumeStartSector)
 
 	if (strncmp(BootSector->FileSystemType, "FAT12   ", 8) == 0 ||
 		strncmp(BootSector->FileSystemType, "FAT16   ", 8) == 0 ||
-		strncmp(BootSector32->FileSystemType, "FAT32   ", 8) == 0)
+		strncmp(BootSector32->FileSystemType, "FAT32   ", 8) == 0 ||
+		strncmp(BootSectorX->FileSystemType, "FATX", 4) == 0)
 	{
 		return TRUE;
 	}
@@ -124,7 +127,7 @@ BOOL FsRecIsFat(U32 DriveNumber, U32 VolumeStartSector)
 BOOL FsRecIsNtfs(U32 DriveNumber, U32 VolumeStartSector)
 {
 	PNTFS_BOOTSECTOR BootSector = (PNTFS_BOOTSECTOR)DISKREADBUFFER;
-	if (!DiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
+	if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, BootSector))
 	{
 		FileSystemError("Failed to read the boot sector.");
 		return FALSE;

freeldr/freeldr/fs/iso.c

@@ -25,6 +25,7 @@
 #include <mm.h>
 #include <debug.h>
 #include <cache.h>
+#include <machine.h>
 
 #include "iso.h"
 
@@ -49,7 +50,7 @@ BOOL IsoOpenVolume(U32 DriveNumber)
 	IsoRootSector = 0;
 	IsoRootLength = 0;
 
-	if (!DiskReadLogicalSectors(DriveNumber, 16, 1, Pvd))
+	if (!MachDiskReadLogicalSectors(DriveNumber, 16, 1, Pvd))
 	{
 		FileSystemError("Failed to read the PVD.");
 		return FALSE;
@@ -160,7 +161,7 @@ static PVOID IsoBufferDirectory(U32 DirectoryStartSector, U32 DirectoryLength)
 	//
 	for (i = 0, Ptr = DirectoryBuffer; i < SectorCount; i++, Ptr += SECTORSIZE)
 	{
-		if (!DiskReadLogicalSectors(IsoDriveNumber, DirectoryStartSector + i, 1, (PVOID)DISKREADBUFFER))
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, DirectoryStartSector + i, 1, (PVOID)DISKREADBUFFER))
 		{
 			MmFreeMemory(DirectoryBuffer);
 			return NULL;
@@ -372,7 +373,7 @@ BOOL IsoReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer
 		//
 		// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
 		//
-		if (!DiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
 		{
 			return FALSE;
 		}
@@ -403,7 +404,7 @@ BOOL IsoReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer
 			//
 			// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
 			//
-			if (!DiskReadLogicalSectorsLBA(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+			if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
 			{
 				return FALSE;
 			}
@@ -430,7 +431,7 @@ BOOL IsoReadFile(FILE *FileHandle, U32 BytesToRead, U32* BytesRead, PVOID Buffer
 		//
 		// Now do the read and update BytesRead, BytesToRead, FilePointer, & Buffer
 		//
-		if (!DiskReadLogicalSectorsLBA(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
+		if (!MachDiskReadLogicalSectors(IsoDriveNumber, SectorNumber, 1, (PVOID)DISKREADBUFFER))
 		{
 			return FALSE;
 		}

freeldr/freeldr/fs/ntfs.c

@@ -1,7 +1,4 @@
 /*
- *  FreeLoader
- *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
- *
  *  FreeLoader NTFS support
  *  Copyright (C) 2004       Filip Navara  <xnavara@volny.cz>
  *
@@ -25,10 +22,6 @@
  * - No support for compressed files.
  * - No attribute list support.
  * - May crash on currupted filesystem.
- *
- * Bugs:
- * - I encountered file names like 'KERNEL~1.EE' stored on
- *   the disk. These aren't handled correctly yet.
  */
 
 #include <freeldr.h>
@@ -39,8 +32,8 @@
 #include <mm.h>
 #include <debug.h>
 #include <cache.h>
+#include <machine.h>
 
-#define NTFS_DEFS
 #include "ntfs.h"
 
 PNTFS_BOOTSECTOR NtfsBootSector;
@@ -56,7 +49,7 @@ PUCHAR NtfsDecodeRun(PUCHAR DataRun, S64 *DataRunOffset, U64 *DataRunLength)
 {
     U8 DataRunOffsetSize;
     U8 DataRunLengthSize;
-    U8 i;
+    S8 i;
 
     DataRunOffsetSize = (*DataRun >> 4) & 0xF;
     DataRunLengthSize = *DataRun & 0xF;
@@ -68,16 +61,27 @@ PUCHAR NtfsDecodeRun(PUCHAR DataRun, S64 *DataRunOffset, U64 *DataRunLength)
         *DataRunLength += *DataRun << (i << 3);
         DataRun++;
     }
-    for (i = 0; i < DataRunOffsetSize; i++)
+
+    /* NTFS 3+ sparse files */
+    if (DataRunOffsetSize == 0)
     {
-        *DataRunOffset += *DataRun << (i << 3);
-        DataRun++;
+        *DataRunOffset = -1;
+    }
+    else
+    {
+        for (i = 0; i < DataRunOffsetSize - 1; i++)
+        {
+            *DataRunOffset += *DataRun << (i << 3);
+            DataRun++;
+        }
+        /* The last byte contains sign so we must process it different way. */
+        *DataRunOffset = ((S8)(*(DataRun++)) << (i << 3)) + *DataRunOffset;
     }
 
     DbgPrint((DPRINT_FILESYSTEM, "DataRunOffsetSize: %x\n", DataRunOffsetSize));
     DbgPrint((DPRINT_FILESYSTEM, "DataRunLengthSize: %x\n", DataRunLengthSize));
-    DbgPrint((DPRINT_FILESYSTEM, "DataRunOffset: %x\n", DataRunOffset));
-    DbgPrint((DPRINT_FILESYSTEM, "DataRunLength: %x\n", DataRunLength));
+    DbgPrint((DPRINT_FILESYSTEM, "DataRunOffset: %x\n", *DataRunOffset));
+    DbgPrint((DPRINT_FILESYSTEM, "DataRunLength: %x\n", *DataRunLength));
 
     return DataRun;
 }
@@ -97,7 +101,7 @@ BOOL NtfsFindAttribute(PNTFS_ATTR_CONTEXT Context, PNTFS_MFT_RECORD MftRecord, U
 
     while (AttrRecord < AttrRecordEnd)
     {
-        if (AttrRecord->Type == ATTR_TYPE_END)
+        if (AttrRecord->Type == NTFS_ATTR_TYPE_END)
             break;
 
         if (AttrRecord->Type == Type)
@@ -117,6 +121,7 @@ BOOL NtfsFindAttribute(PNTFS_ATTR_CONTEXT Context, PNTFS_MFT_RECORD MftRecord, U
                         Context->CacheRun = (PUCHAR)Context->Record + Context->Record->NonResident.MappingPairsOffset;
                         Context->CacheRunOffset = 0;
                         Context->CacheRun = NtfsDecodeRun(Context->CacheRun, &DataRunOffset, &DataRunLength);
+                        Context->CacheRunLength = DataRunLength;
                         if (DataRunOffset != -1)
                         {
                             /* Normal run. */
@@ -147,10 +152,13 @@ BOOL NtfsDiskRead(U64 Offset, U64 Length, PCHAR Buffer)
 {
     U16 ReadLength;
 
+    DbgPrint((DPRINT_FILESYSTEM, "NtfsDiskRead - Offset: %I64d Length: %I64d\n", Offset, Length));
+    RtlZeroMemory((PCHAR)DISKREADBUFFER, 0x1000);
+
     /* I. Read partial first sector if needed */
     if (Offset % NtfsBootSector->BytesPerSector)
     {
-        if (!DiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), 1, (PCHAR)DISKREADBUFFER))
+        if (!MachDiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), 1, (PCHAR)DISKREADBUFFER))
             return FALSE;
         ReadLength = min(Length, NtfsBootSector->BytesPerSector - (Offset % NtfsBootSector->BytesPerSector));
         RtlCopyMemory(Buffer, (PCHAR)DISKREADBUFFER + (Offset % NtfsBootSector->BytesPerSector), ReadLength);
@@ -162,7 +170,7 @@ BOOL NtfsDiskRead(U64 Offset, U64 Length, PCHAR Buffer)
     /* II. Read all complete 64-sector blocks. */
     while (Length >= 64 * NtfsBootSector->BytesPerSector)
     {
-        if (!DiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), 64, (PCHAR)DISKREADBUFFER))
+        if (!MachDiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), 64, (PCHAR)DISKREADBUFFER))
             return FALSE;
         RtlCopyMemory(Buffer, (PCHAR)DISKREADBUFFER, 64 * NtfsBootSector->BytesPerSector);
         Buffer += 64 * NtfsBootSector->BytesPerSector;
@@ -174,7 +182,7 @@ BOOL NtfsDiskRead(U64 Offset, U64 Length, PCHAR Buffer)
     if (Length)
     {
         ReadLength = ((Length + NtfsBootSector->BytesPerSector - 1) / NtfsBootSector->BytesPerSector);
-        if (!DiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), ReadLength, (PCHAR)DISKREADBUFFER))
+        if (!MachDiskReadLogicalSectors(NtfsDriveNumber, NtfsSectorOfClusterZero + (Offset / NtfsBootSector->BytesPerSector), ReadLength, (PCHAR)DISKREADBUFFER))
             return FALSE;
         RtlCopyMemory(Buffer, (PCHAR)DISKREADBUFFER, Length);
     }
@@ -216,6 +224,7 @@ U64 NtfsReadAttribute(PNTFS_ATTR_CONTEXT Context, U64 Offset, PCHAR Buffer, U64
         DataRun = Context->CacheRun;
         LastLCN = Context->CacheRunLastLCN;
         DataRunStartLCN = Context->CacheRunStartLCN;
+        DataRunLength = Context->CacheRunLength;
         CurrentOffset = Context->CacheRunCurrentOffset;
     }
     else
@@ -270,42 +279,75 @@ U64 NtfsReadAttribute(PNTFS_ATTR_CONTEXT Context, U64 Offset, PCHAR Buffer, U64
 	Buffer += ReadLength;
 	AlreadyRead += ReadLength;
 
+	/* We finished this request, but there still data in this data run. */
+	if (Length == 0 && ReadLength != DataRunLength * NtfsClusterSize)
+	    break;
+
 	/*
-	 * Go to next run in the list. Note that we don't do it only for
-         * Length > 0 because of run pointer caching.
+	 * Go to next run in the list.
          */
 	
-	{
-	    if (*DataRun == 0)
-	        break;
-            DataRun = NtfsDecodeRun(DataRun, &DataRunOffset, &DataRunLength);
-            if (DataRunOffset != -1)
-            {
-                /* Normal data run. */
-                DataRunStartLCN = LastLCN + DataRunOffset;
-                LastLCN = DataRunStartLCN;
-            }
-            else
-            {
-                /* Sparse data run. */
-                DataRunStartLCN = -1;
-            }
-            CurrentOffset += DataRunLength * NtfsClusterSize;
-	}
+	if (*DataRun == 0)
+	    break;
+        DataRun = NtfsDecodeRun(DataRun, &DataRunOffset, &DataRunLength);
+        if (DataRunOffset != -1)
+        {
+            /* Normal data run. */
+            DataRunStartLCN = LastLCN + DataRunOffset;
+            LastLCN = DataRunStartLCN;
+        }
+        else
+        {
+            /* Sparse data run. */
+            DataRunStartLCN = -1;
+        }
+        CurrentOffset += DataRunLength * NtfsClusterSize;
     }
 
     Context->CacheRun = DataRun;
     Context->CacheRunOffset = Offset + AlreadyRead;
     Context->CacheRunStartLCN = DataRunStartLCN;
+    Context->CacheRunLength = DataRunLength;
     Context->CacheRunLastLCN = LastLCN;
     Context->CacheRunCurrentOffset = CurrentOffset;
 
     return AlreadyRead;
 }
 
+BOOL NtfsFixupRecord(PNTFS_RECORD Record)
+{
+    U16 *USA;
+    U16 USANumber;
+    U16 USACount;
+    U16 *Block;
+
+    USA = (U16*)((PCHAR)Record + Record->USAOffset);
+    USANumber = *(USA++);
+    USACount = Record->USACount - 1; /* Exclude the USA Number. */
+    Block = (U16*)((PCHAR)Record + NtfsBootSector->BytesPerSector - 2);
+
+    while (USACount)
+    {
+        if (*Block != USANumber)
+            return FALSE;
+        *Block = *(USA++);
+        Block = (U16*)((PCHAR)Block + NtfsBootSector->BytesPerSector);
+        USACount--;
+    }
+
+    return TRUE;
+}
+
 BOOL NtfsReadMftRecord(U32 MFTIndex, PNTFS_MFT_RECORD Buffer)
 {
-    return NtfsReadAttribute(&NtfsMFTContext, MFTIndex * NtfsMftRecordSize, (PCHAR)Buffer, NtfsMftRecordSize) == NtfsMftRecordSize;
+    U64 BytesRead;
+    
+    BytesRead = NtfsReadAttribute(&NtfsMFTContext, MFTIndex * NtfsMftRecordSize, (PCHAR)Buffer, NtfsMftRecordSize);
+    if (BytesRead != NtfsMftRecordSize)
+        return FALSE;
+
+    /* Apply update sequence array fixups. */
+    return NtfsFixupRecord((PNTFS_RECORD)Buffer);
 }
 
 #ifdef DEBUG
@@ -344,7 +386,7 @@ BOOL NtfsCompareFileName(PCHAR FileName, PNTFS_INDEX_ENTRY IndexEntry)
         return FALSE;
 
     /* Do case-sensitive compares for Posix file names. */
-    if (IndexEntry->FileName.FileNameType == FILE_NAME_POSIX)
+    if (IndexEntry->FileName.FileNameType == NTFS_FILE_NAME_POSIX)
     {
         for (i = 0; i < EntryFileNameLength; i++)
             if (EntryFileName[i] != FileName[i])
@@ -386,7 +428,7 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
     {
         Magic = MftRecord->Magic;
 
-        if (!NtfsFindAttribute(&IndexRootCtx, MftRecord, ATTR_TYPE_INDEX_ROOT, L"$I30"))
+        if (!NtfsFindAttribute(&IndexRootCtx, MftRecord, NTFS_ATTR_TYPE_INDEX_ROOT, L"$I30"))
         {
             MmFreeMemory(MftRecord);
             return FALSE;
@@ -408,7 +450,7 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
         DbgPrint((DPRINT_FILESYSTEM, "NtfsIndexRecordSize: %x IndexBlockSize: %x\n", NtfsIndexRecordSize, IndexRoot->IndexBlockSize));
 
         while (IndexEntry < IndexEntryEnd &&
-               !(IndexEntry->Flags & INDEX_ENTRY_END))
+               !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END))
         {
             if (NtfsCompareFileName(FileName, IndexEntry))
             {
@@ -420,13 +462,13 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
 	    IndexEntry = (PNTFS_INDEX_ENTRY)((PCHAR)IndexEntry + IndexEntry->Length);
         }
 
-        if (IndexRoot->IndexHeader.Flags & LARGE_INDEX)
+        if (IndexRoot->IndexHeader.Flags & NTFS_LARGE_INDEX)
         {
             DbgPrint((DPRINT_FILESYSTEM, "Large Index!\n"));
 
             IndexBlockSize = IndexRoot->IndexBlockSize;
 
-            if (!NtfsFindAttribute(&IndexBitmapCtx, MftRecord, ATTR_TYPE_BITMAP, L"$I30"))
+            if (!NtfsFindAttribute(&IndexBitmapCtx, MftRecord, NTFS_ATTR_TYPE_BITMAP, L"$I30"))
             {
                 DbgPrint((DPRINT_FILESYSTEM, "Corrupted filesystem!\n"));
                 MmFreeMemory(MftRecord);
@@ -446,7 +488,7 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
             }
             NtfsReadAttribute(&IndexBitmapCtx, 0, BitmapData, BitmapDataSize);
 
-            if (!NtfsFindAttribute(&IndexAllocationCtx, MftRecord, ATTR_TYPE_INDEX_ALLOCATION, L"$I30"))
+            if (!NtfsFindAttribute(&IndexAllocationCtx, MftRecord, NTFS_ATTR_TYPE_INDEX_ALLOCATION, L"$I30"))
             {
                 DbgPrint((DPRINT_FILESYSTEM, "Corrupted filesystem!\n"));
                 MmFreeMemory(BitmapData);
@@ -466,7 +508,7 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
                 DbgPrint((DPRINT_FILESYSTEM, "RecordOffset: %x IndexAllocationSize: %x\n", RecordOffset, IndexAllocationSize));
                 for (; RecordOffset < IndexAllocationSize;)
                 {
-                    U8 Bit = 1 << ((RecordOffset / IndexBlockSize) & 3);
+                    U8 Bit = 1 << ((RecordOffset / IndexBlockSize) & 7);
                     U32 Byte = (RecordOffset / IndexBlockSize) >> 3;
                     if ((BitmapData[Byte] & Bit))
                         break;
@@ -474,16 +516,23 @@ BOOL NtfsFindMftRecord(U32 MFTIndex, PCHAR FileName, U32 *OutMFTIndex)
                 }
             
                 if (RecordOffset >= IndexAllocationSize)
+                {
                     break;
+                }
 
                 NtfsReadAttribute(&IndexAllocationCtx, RecordOffset, IndexRecord, IndexBlockSize);
 
+                if (!NtfsFixupRecord((PNTFS_RECORD)IndexRecord))
+                {
+                    break;
+                }
+
                 /* FIXME */
                 IndexEntry = (PNTFS_INDEX_ENTRY)(IndexRecord + 0x18 + *(U16 *)(IndexRecord + 0x18));
 	        IndexEntryEnd = (PNTFS_INDEX_ENTRY)(IndexRecord + IndexBlockSize);
 
                 while (IndexEntry < IndexEntryEnd &&
-                       !(IndexEntry->Flags & INDEX_ENTRY_END))
+                       !(IndexEntry->Flags & NTFS_INDEX_ENTRY_END))
                 {        
                     if (NtfsCompareFileName(FileName, IndexEntry))
                     {
@@ -523,7 +572,7 @@ BOOL NtfsLookupFile(PUCHAR FileName, PNTFS_MFT_RECORD MftRecord, PNTFS_ATTR_CONT
 
     DbgPrint((DPRINT_FILESYSTEM, "NtfsLookupFile() FileName = %s\n", FileName));
 
-    CurrentMFTIndex = FILE_ROOT;
+    CurrentMFTIndex = NTFS_FILE_ROOT;
     NumberOfPathParts = FsGetNumPathParts(FileName);
     for (i = 0; i < NumberOfPathParts; i++)
     {
@@ -548,7 +597,7 @@ BOOL NtfsLookupFile(PUCHAR FileName, PNTFS_MFT_RECORD MftRecord, PNTFS_ATTR_CONT
         return FALSE;
     }
 
-    if (!NtfsFindAttribute(DataContext, MftRecord, ATTR_TYPE_DATA, L""))
+    if (!NtfsFindAttribute(DataContext, MftRecord, NTFS_ATTR_TYPE_DATA, L""))
     {
         DbgPrint((DPRINT_FILESYSTEM, "NtfsLookupFile: Can't find data attribute\n"));
         return FALSE;
@@ -563,7 +612,7 @@ BOOL NtfsOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
 
     DbgPrint((DPRINT_FILESYSTEM, "NtfsOpenVolume() DriveNumber = 0x%x VolumeStartSector = 0x%x\n", DriveNumber, VolumeStartSector));
 
-    if (!DiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, (PCHAR)DISKREADBUFFER))
+    if (!MachDiskReadLogicalSectors(DriveNumber, VolumeStartSector, 1, (PCHAR)DISKREADBUFFER))
     {
         FileSystemError("Failed to read the boot sector.");
         return FALSE;
@@ -603,7 +652,7 @@ BOOL NtfsOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
     NtfsSectorOfClusterZero = VolumeStartSector;
 
     DbgPrint((DPRINT_FILESYSTEM, "Reading MFT index...\n"));
-    if (!DiskReadLogicalSectors(DriveNumber,
+    if (!MachDiskReadLogicalSectors(DriveNumber,
                                 NtfsSectorOfClusterZero +
                                 (NtfsBootSector->MftLocation * NtfsBootSector->SectorsPerCluster),
                                 NtfsMftRecordSize / NtfsBootSector->BytesPerSector, (PCHAR)DISKREADBUFFER))
@@ -622,7 +671,7 @@ BOOL NtfsOpenVolume(U32 DriveNumber, U32 VolumeStartSector)
     RtlCopyMemory(NtfsMasterFileTable, (PCHAR)DISKREADBUFFER, NtfsMftRecordSize);
 
     DbgPrint((DPRINT_FILESYSTEM, "Searching for DATA attribute...\n"));
-    if (!NtfsFindAttribute(&NtfsMFTContext, NtfsMasterFileTable, ATTR_TYPE_DATA, L""))
+    if (!NtfsFindAttribute(&NtfsMFTContext, NtfsMasterFileTable, NTFS_ATTR_TYPE_DATA, L""))
     {
         FileSystemError("Can't find data attribute for Master File Table.");
         return FALSE;

freeldr/freeldr/fs/ntfs.h

@@ -1,7 +1,4 @@
 /*
- *  FreeLoader
- *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
- *
  *  FreeLoader NTFS support
  *  Copyright (C) 2004       Filip Navara  <xnavara@volny.cz>
  *
@@ -23,76 +20,80 @@
 #ifndef __NTFS_H
 #define __NTFS_H
 
-#ifdef NTFS_DEFS
+#define NTFS_FILE_MFT				0
+#define NTFS_FILE_MFTMIRR			1
+#define NTFS_FILE_LOGFILE			2
+#define NTFS_FILE_VOLUME			3
+#define NTFS_FILE_ATTRDEF			4
+#define NTFS_FILE_ROOT				5
+#define NTFS_FILE_BITMAP			6
+#define NTFS_FILE_BOOT				7
+#define NTFS_FILE_BADCLUS			8
+#define NTFS_FILE_QUOTA				9
+#define NTFS_FILE_UPCASE			10
 
-#define FILE_MFT				0
-#define FILE_MFTMIRR				1
-#define FILE_LOGFILE				2
-#define FILE_VOLUME				3
-#define FILE_ATTRDEF				4
-#define FILE_ROOT				5
-#define FILE_BITMAP				6
-#define FILE_BOOT				7
-#define FILE_BADCLUS				8
-#define FILE_QUOTA				9
-#define FILE_UPCASE				10
+#define NTFS_ATTR_TYPE_STANDARD_INFORMATION	0x10
+#define NTFS_ATTR_TYPE_ATTRIBUTE_LIST		0x20
+#define NTFS_ATTR_TYPE_FILENAME			0x30
+#define NTFS_ATTR_TYPE_SECURITY_DESCRIPTOR	0x50
+#define NTFS_ATTR_TYPE_DATA			0x80
+#define NTFS_ATTR_TYPE_INDEX_ROOT		0x90
+#define NTFS_ATTR_TYPE_INDEX_ALLOCATION		0xa0
+#define NTFS_ATTR_TYPE_BITMAP			0xb0
+#define NTFS_ATTR_TYPE_SYMLINK			0xc0
+#define NTFS_ATTR_TYPE_END			0xffffffff
 
-#define ATTR_TYPE_STANDARD_INFORMATION		0x10
-#define ATTR_TYPE_ATTRIBUTE_LIST			0x20
-#define ATTR_TYPE_FILENAME				0x30
-#define ATTR_TYPE_SECURITY_DESCRIPTOR		0x50
-#define ATTR_TYPE_DATA				0x80
-#define ATTR_TYPE_INDEX_ROOT				0x90
-#define ATTR_TYPE_INDEX_ALLOCATION			0xa0
-#define ATTR_TYPE_BITMAP				0xb0
-#define ATTR_TYPE_SYMLINK				0xc0
-#define ATTR_TYPE_END					0xffffffff
+#define NTFS_ATTR_NORMAL			0
+#define NTFS_ATTR_COMPRESSED			1
+#define NTFS_ATTR_RESIDENT			2
+#define NTFS_ATTR_ENCRYPTED			0x4000
 
-#define ATTR_NORMAL				0
-#define ATTR_COMPRESSED				1
-#define ATTR_RESIDENT				2
-#define ATTR_ENCRYPTED				0x4000
+#define NTFS_SMALL_INDEX			0
+#define NTFS_LARGE_INDEX			1
 
-#define SMALL_INDEX				0
-#define LARGE_INDEX				1
+#define NTFS_INDEX_ENTRY_NODE			1
+#define NTFS_INDEX_ENTRY_END			2
 
-#define INDEX_ENTRY_NODE			1
-#define INDEX_ENTRY_END				2
-
-#define FILE_NAME_POSIX				0
-#define FILE_NAME_WIN32				1
-#define FILE_NAME_DOS				2
-#define FILE_NAME_WIN32_AND_DOS			3 
-#endif
+#define NTFS_FILE_NAME_POSIX			0
+#define NTFS_FILE_NAME_WIN32			1
+#define NTFS_FILE_NAME_DOS			2
+#define NTFS_FILE_NAME_WIN32_AND_DOS		3 
 
 typedef struct
 {
-	U8		JumpBoot[3];				// Jump to the boot loader routine
-	U8		SystemId[8];				// System Id ("NTFS    ")
-	U16		BytesPerSector;				// Bytes per sector
-	U8		SectorsPerCluster;			// Number of sectors in a cluster
+	U8		JumpBoot[3];			// Jump to the boot loader routine
+	U8		SystemId[8];			// System Id ("NTFS    ")
+	U16		BytesPerSector;			// Bytes per sector
+	U8		SectorsPerCluster;		// Number of sectors in a cluster
 	U8		Unused1[7];
-	U8		MediaDescriptor;			// Media descriptor byte
+	U8		MediaDescriptor;		// Media descriptor byte
 	U8		Unused2[2];
-	U16		SectorsPerTrack;			// Number of sectors in a track
-	U16		NumberOfHeads;				// Number of heads on the disk
+	U16		SectorsPerTrack;		// Number of sectors in a track
+	U16		NumberOfHeads;			// Number of heads on the disk
 	U8		Unused3[8];
-	U8		DriveNumber;				// Int 0x13 drive number (e.g. 0x80)
+	U8		DriveNumber;			// Int 0x13 drive number (e.g. 0x80)
 	U8		CurrentHead;
-	U8		BootSignature;				// Extended boot signature (0x80)
+	U8		BootSignature;			// Extended boot signature (0x80)
 	U8		Unused4;
-	U64		VolumeSectorCount;			// Number of sectors in the volume
+	U64		VolumeSectorCount;		// Number of sectors in the volume
 	U64		MftLocation;
 	U64		MftMirrorLocation;
 	S8		ClustersPerMftRecord;		// Clusters per MFT Record
 	U8		Unused5[3];
 	S8		ClustersPerIndexRecord;		// Clusters per Index Record
 	U8		Unused6[3];
-	U64		VolumeSerialNumber;			// Volume serial number
+	U64		VolumeSerialNumber;		// Volume serial number
 	U8		BootCodeAndData[430];		// The remainder of the boot sector
-	U16		BootSectorMagic;			// 0xAA55
+	U16		BootSectorMagic;		// 0xAA55
 } PACKED NTFS_BOOTSECTOR, *PNTFS_BOOTSECTOR;
 
+typedef struct
+{
+	U32		Magic;
+	U16		USAOffset;					// Offset to the Update Sequence Array from the start of the ntfs record
+	U16		USACount;
+} PACKED NTFS_RECORD, *PNTFS_RECORD;
+
 typedef struct
 {
 	U32		Magic;
@@ -206,6 +207,7 @@ typedef struct
 	PUCHAR			CacheRun;
 	U64			CacheRunOffset;
 	S64			CacheRunStartLCN;
+	U64			CacheRunLength;
 	S64			CacheRunLastLCN;
 	U64			CacheRunCurrentOffset;
 } NTFS_ATTR_CONTEXT, *PNTFS_ATTR_CONTEXT;

freeldr/freeldr/include/arch.h

@@ -29,10 +29,6 @@
 #define RMODE_DS	0x20	/* RMode data selector, base 0 limit 64k */
 
 #define	KERNEL_BASE	0xC0000000
-//#define	USER_CS		0x08
-//#define	USER_DS		0x10
-//#define	KERNEL_CS	0x20
-//#define	KERNEL_DS	0x28
 #define	KERNEL_CS	0x08
 #define	KERNEL_DS	0x10
 

freeldr/freeldr/include/cmdline.h

@@ -0,0 +1,37 @@
+/* $Id: cmdline.h,v 1.1 2004/11/01 20:49:32 gvg Exp $
+ *
+ *  FreeLdr boot loader
+ *  Copyright (C) 2002, 2003 ReactOS Team
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __CMDLINE_H__
+#define __CMDLINE_H__
+
+typedef struct tagCMDLINEINFO
+{
+  char *DefaultOperatingSystem;
+  S32 TimeOut;
+} CMDLINEINFO, *PCMDLINEINFO;
+
+extern void CmdLineParse(char *CmdLine);
+
+extern char *CmdLineGetDefaultOS(void);
+extern S32 CmdLineGetTimeOut(void);
+
+#endif /* __CMDLINE_H__ */
+
+/* EOF */

freeldr/freeldr/include/debug.h

@@ -23,24 +23,26 @@
 
 #ifdef DEBUG
 
-	#define DPRINT_NONE		    0x00000000  // No debug print
+	#define DPRINT_NONE		0x00000000  // No debug print
 	#define DPRINT_WARNING		0x00000001  // OR this with DebugPrintMask to enable debugger messages and other misc stuff
-	#define DPRINT_MEMORY		  0x00000002  // OR this with DebugPrintMask to enable memory management messages
+	#define DPRINT_MEMORY		0x00000002  // OR this with DebugPrintMask to enable memory management messages
 	#define DPRINT_FILESYSTEM	0x00000004  // OR this with DebugPrintMask to enable file system messages
 	#define DPRINT_INIFILE		0x00000008  // OR this with DebugPrintMask to enable .ini file messages
-	#define DPRINT_UI			    0x00000010  // OR this with DebugPrintMask to enable user interface messages
-	#define DPRINT_DISK			  0x00000020  // OR this with DebugPrintMask to enable disk messages
-	#define DPRINT_CACHE		  0x00000040  // OR this with DebugPrintMask to enable cache messages
+	#define DPRINT_UI		0x00000010  // OR this with DebugPrintMask to enable user interface messages
+	#define DPRINT_DISK		0x00000020  // OR this with DebugPrintMask to enable disk messages
+	#define DPRINT_CACHE		0x00000040  // OR this with DebugPrintMask to enable cache messages
 	#define DPRINT_REGISTRY		0x00000080  // OR this with DebugPrintMask to enable registry messages
 	#define DPRINT_REACTOS		0x00000100  // OR this with DebugPrintMask to enable ReactOS messages
-	#define DPRINT_LINUX		  0x00000200  // OR this with DebugPrintMask to enable Linux messages
-  #define DPRINT_HWDETECT		0x00000400  // OR this with DebugPrintMask to enable hardware detection messages
+	#define DPRINT_LINUX		0x00000200  // OR this with DebugPrintMask to enable Linux messages
+	#define DPRINT_HWDETECT		0x00000400  // OR this with DebugPrintMask to enable hardware detection messages
 
 	VOID	DebugInit(VOID);
 	VOID	DebugPrint(U32 Mask, char *format, ...);
+	VOID	DebugPrint1(char *format, ...);
 	VOID	DebugDumpBuffer(U32 Mask, PVOID Buffer, U32 Length);
 
 	#define DbgPrint(_x_)					DebugPrint _x_ ;
+	#define DPRINT1						DebugPrint1
 	#define BugCheck(_x_)					{ DebugPrint(DPRINT_WARNING, "Fatal Error: %s:%d(%s)\n", __FILE__, __LINE__, __FUNCTION__); DebugPrint _x_ ; for (;;); }
 	#define DbgDumpBuffer(_x_, _y_, _z_)	DebugDumpBuffer(_x_, _y_, _z_)
 
@@ -73,7 +75,9 @@ void	MEMORY_WRITE_BREAKPOINT4(unsigned long addr);
 
 #else
 
+	#define DebugInit()
 	#define DbgPrint(_x_)
+	#define DPRINT1(_x_)
 	#define BugCheck(_x_)
 	#define DbgDumpBuffer(_x_, _y_, _z_)
 

freeldr/freeldr/include/disk.h

@@ -106,17 +106,11 @@ typedef struct _MASTER_BOOT_RECORD
 ///////////////////////////////////////////////////////////////////////////////////////
 #ifdef __i386__
 
-//BOOL	DiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
-BOOL	DiskReadLogicalSectorsLBA(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
-BOOL	DiskReadLogicalSectorsCHS(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
 BOOL	DiskResetController(U32 DriveNumber);
 BOOL	DiskInt13ExtensionsSupported(U32 DriveNumber);
 //VOID	DiskStopFloppyMotor(VOID);
-BOOL	DiskGetDriveParameters(U32 DriveNumber, PGEOMETRY Geometry);
 BOOL	DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSize);
 
-//U32	DiskGetCacheableBlockCount(U32 DriveNumber);
-
 #endif // defined __i386__
 
 ///////////////////////////////////////////////////////////////////////////////////////
@@ -127,11 +121,9 @@ BOOL	DiskGetExtendedDriveParameters(U32 DriveNumber, PVOID Buffer, U16 BufferSiz
 VOID	DiskReportError (BOOL bError);
 VOID	DiskError(PUCHAR ErrorString, U32 ErrorCode);
 PUCHAR	DiskGetErrorCodeString(U32 ErrorCode);
-BOOL	DiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry);
 BOOL	DiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer); // Implemented in i386disk.c
 BOOL	DiskIsDriveRemovable(U32 DriveNumber);
 VOID	DiskStopFloppyMotor(VOID);	// Implemented in i386disk.c
-U32		DiskGetCacheableBlockCount(U32 DriveNumber);	// Implemented in i386disk.c
 
 ///////////////////////////////////////////////////////////////////////////////////////
 //

freeldr/freeldr/include/freeldr.h

@@ -75,7 +75,7 @@ extern U32			BootDrive;			// BIOS boot drive, 0-A:, 1-B:, 0x80-C:, 0x81-D:, etc.
 extern U32			BootPartition;		// Boot Partition, 1-4
 extern BOOL			UserInterfaceUp;	// Tells us if the user interface is displayed
 
-void	BootMain(void);
+void	BootMain(char *CmdLine);
 VOID	RunLoader(VOID);
 
 #endif  // defined __FREELDR_H

freeldr/freeldr/include/machine.h

@@ -0,0 +1,99 @@
+/* $Id: machine.h,v 1.7 2004/11/28 22:42:40 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#ifndef __MACHINE_H_
+#define __MACHINE_H_
+
+#ifndef __DISK_H
+#include "disk.h"
+#endif
+
+#ifndef __MEMORY_H
+#include "mm.h"
+#endif
+
+typedef enum tagVIDEODISPLAYMODE
+{
+  VideoTextMode,
+  VideoGraphicsMode
+} VIDEODISPLAYMODE, *PVIDEODISPLAYMODE;
+
+typedef struct tagMACHVTBL
+{
+  VOID (*ConsPutChar)(int Ch);
+  BOOL (*ConsKbHit)(VOID);
+  int (*ConsGetCh)(VOID);
+  
+  VOID (*VideoClearScreen)(U8 Attr);
+  VIDEODISPLAYMODE (*VideoSetDisplayMode)(char *DisplayMode, BOOL Init);
+  VOID (*VideoGetDisplaySize)(PU32 Width, PU32 Height, PU32 Depth);
+  U32 (*VideoGetBufferSize)(VOID);
+  VOID (*VideoSetTextCursorPosition)(U32 X, U32 Y);
+  VOID (*VideoHideShowTextCursor)(BOOL Show);
+  VOID (*VideoPutChar)(int Ch, U8 Attr, unsigned X, unsigned Y);
+  VOID (*VideoCopyOffScreenBufferToVRAM)(PVOID Buffer);
+  BOOL (*VideoIsPaletteFixed)(VOID);
+  VOID (*VideoSetPaletteColor)(U8 Color, U8 Red, U8 Green, U8 Blue);
+  VOID (*VideoGetPaletteColor)(U8 Color, U8* Red, U8* Green, U8* Blue);
+  VOID (*VideoSync)(VOID);
+  VOID (*VideoPrepareForReactOS)(VOID);
+
+  U32 (*GetMemoryMap)(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize);
+
+  BOOL (*DiskReadLogicalSectors)(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer);
+  BOOL (*DiskGetPartitionEntry)(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry);
+  BOOL (*DiskGetDriveGeometry)(U32 DriveNumber, PGEOMETRY DriveGeometry);
+  U32 (*DiskGetCacheableBlockCount)(U32 DriveNumber);
+
+  VOID (*RTCGetCurrentDateTime)(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second);
+
+  VOID (*HwDetect)(VOID);
+} MACHVTBL, *PMACHVTBL;
+
+VOID MachInit(VOID);
+
+extern MACHVTBL MachVtbl;
+
+#define MachConsPutChar(Ch)			MachVtbl.ConsPutChar(Ch)
+#define MachConsKbHit()				MachVtbl.ConsKbHit()
+#define MachConsGetCh()				MachVtbl.ConsGetCh()
+#define MachVideoClearScreen(Attr)		MachVtbl.VideoClearScreen(Attr)
+#define MachVideoSetDisplayMode(Mode, Init)	MachVtbl.VideoSetDisplayMode((Mode), (Init))
+#define MachVideoGetDisplaySize(W, H, D)	MachVtbl.VideoGetDisplaySize((W), (H), (D))
+#define MachVideoGetBufferSize()		MachVtbl.VideoGetBufferSize()
+#define MachVideoSetTextCursorPosition(X, Y)	MachVtbl.VideoSetTextCursorPosition((X), (Y))
+#define MachVideoHideShowTextCursor(Show)	MachVtbl.VideoHideShowTextCursor(Show)
+#define MachVideoPutChar(Ch, Attr, X, Y)	MachVtbl.VideoPutChar((Ch), (Attr), (X), (Y))
+#define MachVideoCopyOffScreenBufferToVRAM(Buf)	MachVtbl.VideoCopyOffScreenBufferToVRAM(Buf)
+#define MachVideoIsPaletteFixed()		MachVtbl.VideoIsPaletteFixed()
+#define MachVideoSetPaletteColor(Col, R, G, B)	MachVtbl.VideoSetPaletteColor((Col), (R), (G), (B))
+#define MachVideoGetPaletteColor(Col, R, G, B)	MachVtbl.VideoGetPaletteColor((Col), (R), (G), (B))
+#define MachVideoSync()				MachVtbl.VideoSync()
+#define MachVideoPrepareForReactOS()		MachVtbl.VideoPrepareForReactOS()
+#define MachGetMemoryMap(MMap, Size)		MachVtbl.GetMemoryMap((MMap), (Size))
+#define MachDiskReadLogicalSectors(Drive, Start, Count, Buf)	MachVtbl.DiskReadLogicalSectors((Drive), (Start), (Count), (Buf))
+#define MachDiskGetPartitionEntry(Drive, Part, Entry)	MachVtbl.DiskGetPartitionEntry((Drive), (Part), (Entry))
+#define MachDiskGetDriveGeometry(Drive, Geom)	MachVtbl.DiskGetDriveGeometry((Drive), (Geom))
+#define MachDiskGetCacheableBlockCount(Drive)	MachVtbl.DiskGetCacheableBlockCount(Drive)
+#define MachRTCGetCurrentDateTime(Y, Mo, D, H, Mi, S)	MachVtbl.RTCGetCurrentDateTime((Y), (Mo), (D), (H), (Mi), (S));
+#define MachHwDetect()				MachVtbl.HwDetect()
+
+#endif /* __MACHINE_H_ */
+
+/* EOF */

freeldr/freeldr/include/mm.h

@@ -38,13 +38,6 @@ typedef struct
 
 U32		GetSystemMemorySize(VOID);								// Returns the amount of total memory in the system
 
-// These functions are implemented in mem.S
-U32		GetExtendedMemorySize(VOID);							// Returns extended memory size in KB
-U32		GetConventionalMemorySize(VOID);						// Returns conventional memory size in KB
-U32		GetBiosMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize);	// Fills structure with BIOS memory map and returns memory map item count
-
-
-
 
 //BOOL	MmInitializeMemoryManager(U32 LowMemoryStart, U32 LowMemoryLength);
 BOOL	MmInitializeMemoryManager(VOID);

freeldr/freeldr/include/rtl.h

@@ -72,16 +72,6 @@ int		isxdigit(int c);
 char *	convert_to_ascii(char *buf, int c, ...);
 char *	convert_i64_to_ascii(char *buf, int c, ...);
 
-void	putchar(int ch);		// Implemented in asmcode.S
-int		kbhit(void);			// Implemented in asmcode.S
-int		getch(void);			// Implemented in asmcode.S
-int		getyear(void);			// Implemented in asmcode.S
-int		getday(void);			// Implemented in asmcode.S
-int		getmonth(void);			// Implemented in asmcode.S
-int		gethour(void);			// Implemented in asmcode.S
-int		getminute(void);		// Implemented in asmcode.S
-int		getsecond(void);		// Implemented in asmcode.S
-
 void	beep(void);
 void	delay(unsigned msec);
 void	sound(int freq);
@@ -94,6 +84,9 @@ void	sound(int freq);
 #define min(a, b)  (((a) < (b)) ? (a) : (b))
 #endif
 
+#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
+#define UINT64_C(val) val##ULL
+
 ///////////////////////////////////////////////////////////////////////////////////////
 //
 // Screen Output Functions

freeldr/freeldr/include/ui.h

@@ -54,7 +54,7 @@ extern	UCHAR	UiMonthNames[12][15];
 // User Interface Functions
 //
 ///////////////////////////////////////////////////////////////////////////////////////
-BOOL	UiInitialize(VOID);										// Initialize User-Interface
+BOOL	UiInitialize(BOOLEAN ShowGui);								// Initialize User-Interface
 VOID	UiUnInitialize(PUCHAR BootText);						// Un-initialize User-Interface
 VOID	UiDrawBackdrop(VOID);									// Fills the entire screen with a backdrop
 VOID	UiFillArea(U32 Left, U32 Top, U32 Right, U32 Bottom, UCHAR FillChar, UCHAR Attr /* Color Attributes */);	// Fills the area specified with FillChar and Attr

freeldr/freeldr/include/version.h

@@ -22,7 +22,7 @@
 
 
 /* just some stuff */
-#define VERSION			"FreeLoader v1.8.21"
+#define VERSION			"FreeLoader v1.9"
 #define COPYRIGHT		"Copyright (C) 1998-2003 Brian Palmer <brianp@sginet.com>"
 #define AUTHOR_EMAIL	"<brianp@sginet.com>"
 #define BY_AUTHOR		"by Brian Palmer"
@@ -35,8 +35,8 @@
 // If you add major functionality then you increment the major version and zero the minor & patch versions
 //
 #define FREELOADER_MAJOR_VERSION	1
-#define FREELOADER_MINOR_VERSION	8
-#define FREELOADER_PATCH_VERSION	21
+#define FREELOADER_MINOR_VERSION	9
+#define FREELOADER_PATCH_VERSION	0
 
 
 #ifndef ASM

freeldr/freeldr/include/video.h

@@ -20,174 +20,40 @@
 #ifndef __VIDEO_H
 #define __VIDEO_H
 
-
-
-#define	VIDEOCARD_CGA_OR_OTHER		0
-#define VIDEOCARD_EGA				1
-#define VIDEOCARD_VGA				2
-
-#define VERTRES_200_SCANLINES		0x00
-#define VERTRES_350_SCANLINES		0x01
-#define VERTRES_400_SCANLINES		0x02
-
-#define MODETYPE_TEXT				0
-#define MODETYPE_GRAPHICS			1
-
-#define VIDEOMODE_NORMAL_TEXT		0
-#define VIDEOMODE_EXTENDED_TEXT		1
-#define	VIDEOMODE_80X28				0x501C
-#define	VIDEOMODE_80X30				0x501E
-#define	VIDEOMODE_80X34				0x5022
-#define	VIDEOMODE_80X43				0x502B
-#define	VIDEOMODE_80X60				0x503C
-#define	VIDEOMODE_132X25			0x8419
-#define	VIDEOMODE_132X43			0x842B
-#define	VIDEOMODE_132X50			0x8432
-#define	VIDEOMODE_132X60			0x843C
-
-#define VIDEOPORT_PALETTE_READ		0x03C7
-#define VIDEOPORT_PALETTE_WRITE		0x03C8
-#define VIDEOPORT_PALETTE_DATA		0x03C9
-#define VIDEOPORT_VERTICAL_RETRACE	0x03DA
-
-#define VIDEOVGA_MEM_ADDRESS		0xA0000
-#define VIDEOTEXT_MEM_ADDRESS		0xB8000
-
 typedef struct
 {
-	U8	Red;
-	U8	Green;
-	U8	Blue;
+  U8 Red;
+  U8 Green;
+  U8 Blue;
 } PACKED PALETTE_ENTRY, *PPALETTE_ENTRY;
 
-typedef struct
-{
-	U16	ModeAttributes;				// mode attributes (see #00080)
-	U8	WindowAttributesA;			// window attributes, window A (see #00081)
-	U8	WindowsAttributesB;			// window attributes, window B (see #00081)
-	U16	WindowGranularity;			// window granularity in KB
-	U16	WindowSize;					// window size in KB
-	U16	WindowAStartSegment;		// start segment of window A (0000h if not supported)
-	U16	WindowBStartSegment;		// start segment of window B (0000h if not supported)
-	U32	WindowPositioningFunction;	// -> FAR window positioning function (equivalent to AX=4F05h)
-	U16	BytesPerScanLine;			// bytes per scan line
-	//---remainder is optional for VESA modes in v1.0/1.1, needed for OEM modes---
-	U16	WidthInPixels;				// width in pixels (graphics) or characters (text)
-	U16	HeightInPixels;				// height in pixels (graphics) or characters (text)
-	U8	CharacterWidthInPixels;		// width of character cell in pixels
-	U8	CharacterHeightInPixels;	// height of character cell in pixels
-	U8	NumberOfMemoryPlanes;		// number of memory planes
-	U8	BitsPerPixel;				// number of bits per pixel
-	U8	NumberOfBanks;				// number of banks
-	U8	MemoryModel;				// memory model type (see #00082)
-	U8	BankSize;					// size of bank in KB
-	U8	NumberOfImagePanes;			// number of image pages (less one) that will fit in video RAM
-	U8	Reserved1;					// reserved (00h for VBE 1.0-2.0, 01h for VBE 3.0)
-	//---VBE v1.2+ ---
-	U8	RedMaskSize;				// red mask size
-	U8	RedMaskPosition;			// red field position
-	U8	GreenMaskSize;				// green mask size
-	U8	GreenMaskPosition;			// green field size
-	U8	BlueMaskSize;				// blue mask size
-	U8	BlueMaskPosition;			// blue field size
-	U8	ReservedMaskSize;			// reserved mask size
-	U8	ReservedMaskPosition;		// reserved mask position
-	U8	DirectColorModeInfo;		// direct color mode info
-									// bit 0:Color ramp is programmable
-									// bit 1:Bytes in reserved field may be used by application
-	//---VBE v2.0+ ---
-	U32	LinearVideoBufferAddress;	// physical address of linear video buffer
-	U32	OffscreenMemoryPointer;		// pointer to start of offscreen memory
-	U16	OffscreenMemorySize;		// KB of offscreen memory
-	//---VBE v3.0 ---
-	U16	LinearBytesPerScanLine;		// bytes per scan line in linear modes
-	U8	BankedNumberOfImages;		// number of images (less one) for banked video modes
-	U8	LinearNumberOfImages;		// number of images (less one) for linear video modes
-	U8	LinearRedMaskSize;			// linear modes:Size of direct color red mask (in bits)
-	U8	LinearRedMaskPosition;		// linear modes:Bit position of red mask LSB (e.g. shift count)
-	U8	LinearGreenMaskSize;		// linear modes:Size of direct color green mask (in bits)
-	U8	LinearGreenMaskPosition;	// linear modes:Bit position of green mask LSB (e.g. shift count)
-	U8	LinearBlueMaskSize;			// linear modes:Size of direct color blue mask (in bits)
-	U8	LinearBlueMaskPosition;		// linear modes:Bit position of blue mask LSB (e.g. shift count)
-	U8	LinearReservedMaskSize;		// linear modes:Size of direct color reserved mask (in bits)
-	U8	LinearReservedMaskPosition;	// linear modes:Bit position of reserved mask LSB
-	U32	MaximumPixelClock;			// maximum pixel clock for graphics video mode, in Hz
-	U8	Reserved2[190];				// 190 BYTEs  reserved (0)
-} PACKED SVGA_MODE_INFORMATION, *PSVGA_MODE_INFORMATION;
-
-
-extern	U32						CurrentMemoryBank;
-extern	SVGA_MODE_INFORMATION	VesaVideoModeInformation;
-
-extern	PVOID					VideoOffScreenBuffer;
-
-
-
-
-VOID	BiosSetVideoMode(U32 VideoMode);				// Implemented in i386vid.S
-VOID	BiosSetVideoFont8x8(VOID);						// Implemented in i386vid.S
-VOID	BiosSetVideoFont8x14(VOID);						// Implemented in i386vid.S
-VOID	BiosSetVideoFont8x16(VOID);						// Implemented in i386vid.S
-VOID	BiosSelectAlternatePrintScreen(VOID);			// Implemented in i386vid.S
-VOID	BiosDisableCursorEmulation(VOID);				// Implemented in i386vid.S
-VOID	BiosDefineCursor(U32 StartScanLine, U32 EndScanLine);	// Implemented in i386vid.S
-U32		BiosDetectVideoCard(VOID);						// Implemented in i386vid.S
-VOID	BiosSetVerticalResolution(U32 ScanLines);		// Implemented in i386vid.S, must be called right before BiosSetVideoMode()
-VOID	BiosSet480ScanLines(VOID);						// Implemented in i386vid.S, must be called right after BiosSetVideoMode()
-VOID	BiosSetVideoDisplayEnd(VOID);					// Implemented in i386vid.S
-VOID	BiosVideoDisableBlinkBit(VOID);					// Implemented in i386vid.S
-VOID	BiosVideoEnableBlinkBit(VOID);					// Implemented in i386vid.S
+extern	PVOID	VideoOffScreenBuffer;
 
 U16		BiosIsVesaSupported(VOID);						// Implemented in i386vid.S, returns the VESA version
-BOOL	BiosVesaSetBank(U16 Bank);						// Implemented in i386vid.S
-BOOL	BiosVesaSetVideoMode(U16 Mode);					// Implemented in i386vid.S
-BOOL	BiosVesaGetSVGAModeInformation(U16 Mode, PSVGA_MODE_INFORMATION ModeInformation);	// Implemented in i386vid.S
 
-VOID	VideoSetTextCursorPosition(U32 X, U32 Y);		// Implemented in i386vid.S
-VOID	VideoHideTextCursor(VOID);						// Implemented in i386vid.S
-VOID	VideoShowTextCursor(VOID);						// Implemented in i386vid.S
-U32		VideoGetTextCursorPositionX(VOID);				// Implemented in i386vid.S
-U32		VideoGetTextCursorPositionY(VOID);				// Implemented in i386vid.S
-
-BOOL	VideoSetMode(U32 VideoMode);
-BOOL	VideoSetMode80x25(VOID);						// Sets 80x25
-BOOL	VideoSetMode80x50_80x43(VOID);					// Sets 80x50 (VGA) or 80x43 (EGA) 8-pixel mode
-BOOL	VideoSetMode80x28(VOID);						// Sets 80x28. Works on all VGA's. Standard 80x25 with 14-point font
-BOOL	VideoSetMode80x43(VOID);						// Sets 80x43. Works on all VGA's. It's a 350-scanline mode with 8-pixel font.
-BOOL	VideoSetMode80x30(VOID);						// Sets 80x30. Works on all VGA's. 480 scanlines, 16-pixel font.
-BOOL	VideoSetMode80x34(VOID);						// Sets 80x34. Works on all VGA's. 480 scanlines, 14-pixel font.
-BOOL	VideoSetMode80x60(VOID);						// Sets 80x60. Works on all VGA's. 480 scanlines, 8-pixel font.
-U32		VideoGetCurrentModeResolutionX(VOID);
-U32		VideoGetCurrentModeResolutionY(VOID);
-U32		VideoGetBytesPerScanLine(VOID);
-U32		VideoGetCurrentMode(VOID);
-U32		VideoGetCurrentModeType(VOID);					// MODETYPE_TEXT or MODETYPE_GRAPHICS
-BOOL	VideoIsCurrentModeVesa(VOID);
-U32		VideoGetCurrentModeColorDepth(VOID);			// Returns 0 for text mode, 16 for 4-bit, 256 for 8-bit, 32768 for 15-bit, 65536 for 16-bit, etc.
-
-VOID	VideoClearScreen(VOID);
-VOID	VideoWaitForVerticalRetrace(VOID);
 PVOID	VideoAllocateOffScreenBuffer(VOID);				// Returns a pointer to an off-screen buffer sufficient for the current video mode
 
-U32		VideoGetMemoryBankForPixel(U32 X, U32 Y);
-U32		VideoGetMemoryBankForPixel16(U32 X, U32 Y);
-U32		VideoGetBankOffsetForPixel(U32 X, U32 Y);
-U32		VideoGetBankOffsetForPixel16(U32 X, U32 Y);
+#if 0 /* Not used */
+U32	VideoGetMemoryBankForPixel(U32 X, U32 Y);
+U32	VideoGetMemoryBankForPixel16(U32 X, U32 Y);
+U32	VideoGetBankOffsetForPixel(U32 X, U32 Y);
+U32	VideoGetBankOffsetForPixel16(U32 X, U32 Y);
 VOID	VideoSetMemoryBank(U16 BankNumber);
-U32		VideoGetOffScreenMemoryOffsetForPixel(U32 X, U32 Y);
+U32	VideoGetOffScreenMemoryOffsetForPixel(U32 X, U32 Y);
+#endif
 VOID	VideoCopyOffScreenBufferToVRAM(VOID);
 
-VOID	VideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue);
-VOID	VideoGetPaletteColor(U8 Color, U8* Red, U8* Green, U8* Blue);
 VOID	VideoSavePaletteState(PPALETTE_ENTRY Palette, U32 ColorCount);
 VOID	VideoRestorePaletteState(PPALETTE_ENTRY Palette, U32 ColorCount);
 
+#if 0 /* Not used */
 VOID	VideoSetPixel16(U32 X, U32 Y, U8 Color);
 VOID	VideoSetPixel256(U32 X, U32 Y, U8 Color);
 VOID	VideoSetPixelRGB(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue);
 VOID	VideoSetPixel16_OffScreen(U32 X, U32 Y, U8 Color);
 VOID	VideoSetPixel256_OffScreen(U32 X, U32 Y, U8 Color);
 VOID	VideoSetPixelRGB_OffScreen(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue);
+#endif
 
 VOID	VideoSetAllColorsToBlack(U32 ColorCount);
 VOID	VideoFadeIn(PPALETTE_ENTRY Palette, U32 ColorCount);

freeldr/freeldr/inifile/parse.c

@@ -22,6 +22,7 @@
 #include <rtl.h>
 #include <mm.h>
 #include <debug.h>
+#include <machine.h>
 
 
 PINI_SECTION		IniFileSectionListHead = NULL;
@@ -125,7 +126,7 @@ BOOL IniParseFile(PUCHAR IniFileData, U32 IniFileSize)
 			{
 				printf("Error: freeldr.ini:%ld: Setting '%s' found outside of a [section].\n", CurrentLineNumber, IniFileLine);
 				printf("Press any key to continue...\n");
-				getch();
+				MachConsGetCh();
 				CurrentLineNumber++;
 				continue;
 			}

freeldr/freeldr/machine.c

@@ -0,0 +1,187 @@
+/* $Id: machine.c,v 1.7 2004/11/28 22:42:39 gvg Exp $
+ *
+ *  FreeLoader
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "freeldr.h"
+#include "machine.h"
+
+#undef MachConsPutChar
+#undef MachConsKbHit
+#undef MachConsGetCh
+#undef MachVideoClearScreen
+#undef MachVideoSetDisplayMode
+#undef MachVideoGetDisplaySize
+#undef MachVideoGetBufferSize
+#undef MachVideoSetTextCursorPosition
+#undef MachVideoHideShowTextCursor
+#undef MachVideoPutChar
+#undef MachVideoCopyOffScreenBufferToVRAM
+#undef MachVideoIsPaletteFixed
+#undef MachVideoSetPaletteColor
+#undef MachVideoGetPaletteColor
+#undef MachVideoSync
+#undef MachVideoPrepareForReactOS
+#undef MachGetMemoryMap
+#undef MachDiskReadLogicalSectors
+#undef MachDiskGetPartitionEntry
+#undef MachDiskGetDriveGeometry
+#undef MachDiskGetCacheableBlockCount
+#undef MachRTCGetCurrentDateTime
+#undef MachHwDetect
+
+MACHVTBL MachVtbl;
+
+VOID
+MachConsPutChar(int Ch)
+{
+  MachVtbl.ConsPutChar(Ch);
+}
+
+BOOL
+MachConsKbHit()
+{
+  return MachVtbl.ConsKbHit();
+}
+
+int
+MachConsGetCh()
+{
+  return MachVtbl.ConsGetCh();
+}
+
+VOID
+MachVideoClearScreen(U8 Attr)
+{
+  MachVtbl.VideoClearScreen(Attr);
+}
+
+VIDEODISPLAYMODE
+MachVideoSetDisplayMode(char *DisplayMode, BOOL Init)
+{
+  return MachVtbl.VideoSetDisplayMode(DisplayMode, Init);
+}
+
+VOID
+MachVideoGetDisplaySize(PU32 Width, PU32 Height, PU32 Depth)
+{
+  return MachVtbl.VideoGetDisplaySize(Width, Height, Depth);
+}
+
+U32
+MachVideoGetBufferSize(VOID)
+{
+  return MachVtbl.VideoGetBufferSize();
+}
+
+VOID
+MachVideoSetTextCursorPosition(U32 X, U32 Y)
+{
+  return MachVtbl.VideoSetTextCursorPosition(X, Y);
+}
+
+VOID
+MachVideoHideShowTextCursor(BOOL Show)
+{
+  MachVtbl.VideoHideShowTextCursor(Show);
+}
+
+VOID
+MachVideoPutChar(int Ch, U8 Attr, unsigned X, unsigned Y)
+{
+  MachVtbl.VideoPutChar(Ch, Attr, X, Y);
+}
+
+VOID
+MachVideoCopyOffScreenBufferToVRAM(PVOID Buffer)
+{
+  MachVtbl.VideoCopyOffScreenBufferToVRAM(Buffer);
+}
+
+BOOL
+MachVideoIsPaletteFixed(VOID)
+{
+  return MachVtbl.VideoIsPaletteFixed();
+}
+
+VOID
+MachVideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue)
+{
+  return MachVtbl.VideoSetPaletteColor(Color, Red, Green, Blue);
+}
+
+VOID
+MachVideoGetPaletteColor(U8 Color, U8 *Red, U8 *Green, U8 *Blue)
+{
+  return MachVtbl.VideoGetPaletteColor(Color, Red, Green, Blue);
+}
+
+VOID
+MachVideoSync(VOID)
+{
+  MachVtbl.VideoSync();
+}
+
+VOID
+MachVideoPrepareForReactOS(VOID)
+{
+  MachVtbl.VideoPrepareForReactOS();
+}
+
+U32
+MachGetMemoryMap(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MaxMemoryMapSize)
+{
+  return MachVtbl.GetMemoryMap(BiosMemoryMap, MaxMemoryMapSize);
+}
+
+BOOL
+MachDiskReadLogicalSectors(U32 DriveNumber, U64 SectorNumber, U32 SectorCount, PVOID Buffer)
+{
+  return MachVtbl.DiskReadLogicalSectors(DriveNumber, SectorNumber, SectorCount, Buffer);
+}
+
+BOOL
+MachDiskGetPartitionEntry(U32 DriveNumber, U32 PartitionNumber, PPARTITION_TABLE_ENTRY PartitionTableEntry)
+{
+  return MachVtbl.DiskGetPartitionEntry(DriveNumber, PartitionNumber, PartitionTableEntry);
+}
+
+BOOL
+MachDiskGetDriveGeometry(U32 DriveNumber, PGEOMETRY DriveGeometry)
+{
+  return MachVtbl.DiskGetDriveGeometry(DriveNumber, DriveGeometry);
+}
+
+U32
+MachDiskGetCacheableBlockCount(U32 DriveNumber)
+{
+  return MachVtbl.DiskGetCacheableBlockCount(DriveNumber);
+}
+
+VOID
+MachRTCGetCurrentDateTime(PU32 Year, PU32 Month, PU32 Day, PU32 Hour, PU32 Minute, PU32 Second)
+{
+  MachVtbl.RTCGetCurrentDateTime(Year, Month, Day, Hour, Minute, Second);
+}
+
+VOID
+MachHwDetect(VOID)
+{
+  MachVtbl.HwDetect();
+}
+
+/* EOF */

freeldr/freeldr/miscboot.c

@@ -27,6 +27,7 @@
 #include <inifile.h>
 #include <disk.h>
 #include <drivemap.h>
+#include <machine.h>
 
 VOID LoadAndBootBootSector(PUCHAR OperatingSystemName)
 {
@@ -152,7 +153,7 @@ VOID LoadAndBootPartition(PUCHAR OperatingSystemName)
 
 	// Now try to read the partition boot sector
 	// If this fails then abort
-	if (!DiskReadLogicalSectors(BootDrive, PartitionTableEntry.SectorCountBeforePartition, 1, (PVOID)0x7C00))
+	if (!MachDiskReadLogicalSectors(BootDrive, PartitionTableEntry.SectorCountBeforePartition, 1, (PVOID)0x7C00))
 	{
 		return;
 	}
@@ -204,7 +205,7 @@ VOID LoadAndBootDrive(PUCHAR OperatingSystemName)
 
 	// Now try to read the boot sector (or mbr)
 	// If this fails then abort
-	if (!DiskReadLogicalSectors(BootDrive, 0, 1, (PVOID)0x7C00))
+	if (!MachDiskReadLogicalSectors(BootDrive, 0, 1, (PVOID)0x7C00))
 	{
 		return;
 	}

freeldr/freeldr/mm/meminit.c

@@ -24,6 +24,7 @@
 #include <rtl.h>
 #include <debug.h>
 #include <ui.h>
+#include <machine.h>
 
 
 #ifdef DEBUG
@@ -52,20 +53,16 @@ U32		LastFreePageHint = 0;
 BOOL MmInitializeMemoryManager(VOID)
 {
 	BIOS_MEMORY_MAP	BiosMemoryMap[32];
-	U32				BiosMemoryMapEntryCount;
-	U32				ExtendedMemorySize;
-	U32				ConventionalMemorySize;
+	U32		BiosMemoryMapEntryCount;
 #ifdef DEBUG
-	U32				Index;
+	U32		Index;
 #endif
 
 	DbgPrint((DPRINT_MEMORY, "Initializing Memory Manager.\n"));
 
 	RtlZeroMemory(BiosMemoryMap, sizeof(BIOS_MEMORY_MAP) * 32);
 
-	BiosMemoryMapEntryCount = GetBiosMemoryMap(BiosMemoryMap, 32);
-	ExtendedMemorySize = GetExtendedMemorySize();
-	ConventionalMemorySize = GetConventionalMemorySize();
+	BiosMemoryMapEntryCount = MachGetMemoryMap(BiosMemoryMap, sizeof(BiosMemoryMap) / sizeof(BIOS_MEMORY_MAP));
 
 #ifdef DEBUG
 	// Dump the system memory map
@@ -77,13 +74,6 @@ BOOL MmInitializeMemoryManager(VOID)
 			DbgPrint((DPRINT_MEMORY, "%x%x\t %x%x\t %s\n", BiosMemoryMap[Index].BaseAddress, BiosMemoryMap[Index].Length, MmGetSystemMemoryMapTypeString(BiosMemoryMap[Index].Type)));
 		}
 	}
-	else
-	{
-		DbgPrint((DPRINT_MEMORY, "GetBiosMemoryMap() not supported.\n"));
-	}
-
-	DbgPrint((DPRINT_MEMORY, "Extended memory size: %d KB\n", ExtendedMemorySize));
-	DbgPrint((DPRINT_MEMORY, "Conventional memory size: %d KB\n", ConventionalMemorySize));
 #endif
 
 	// If we got the system memory map then fixup invalid entries
@@ -92,19 +82,6 @@ BOOL MmInitializeMemoryManager(VOID)
 		MmFixupSystemMemoryMap(BiosMemoryMap, &BiosMemoryMapEntryCount);
 	}
 
-	// Since I don't feel like writing two sets of routines
-	// one to handle the BiosMemoryMap structure and another
-	// to handle just a flat extended memory size I'm going
-	// to create a 'fake' memory map entry out of the
-	// extended memory size if GetBiosMemoryMap() fails.
-	//if (BiosMemoryMapEntryCount == 0)
-	{
-		BiosMemoryMap[0].BaseAddress = 0x100000;		// Start at 1MB
-		BiosMemoryMap[0].Length = ExtendedMemorySize * 1024;
-		BiosMemoryMap[0].Type = MEMTYPE_USABLE;
-		BiosMemoryMapEntryCount = 1;
-	}
-
 	TotalPagesInLookupTable = MmGetAddressablePageCountIncludingHoles(BiosMemoryMap, BiosMemoryMapEntryCount);
 	PageLookupTableAddress = MmFindLocationForPageLookupTable(BiosMemoryMap, BiosMemoryMapEntryCount);
 	LastFreePageHint = TotalPagesInLookupTable;
@@ -159,7 +136,7 @@ PVOID MmGetEndAddressOfAnyMemory(PBIOS_MEMORY_MAP BiosMemoryMap, U32 MapCount)
 	EndAddressOfMemory = 0;
 	for (Index=0; Index<MapCount; Index++)
 	{
-		if (MaxStartAddressSoFar < BiosMemoryMap[Index].BaseAddress)
+		if (MaxStartAddressSoFar <= BiosMemoryMap[Index].BaseAddress)
 		{
 			MaxStartAddressSoFar = BiosMemoryMap[Index].BaseAddress;
 			EndAddressOfMemory = (MaxStartAddressSoFar + BiosMemoryMap[Index].Length);

freeldr/freeldr/mm/mm.c

@@ -23,6 +23,7 @@
 #include <rtl.h>
 #include <debug.h>
 #include <ui.h>
+#include <machine.h>
 
 
 #ifdef DEBUG
@@ -242,6 +243,8 @@ VOID MmFreeMemory(PVOID MemoryPointer)
 		RealPageLookupTable[Idx].PageAllocationLength = 0;
 	}
 
+	FreePagesInLookupTable += PageCount;
+
 #ifdef DEBUG
 	DecrementAllocationCount();
 	DbgPrint((DPRINT_MEMORY, "Freed %d pages of memory starting at page %d. AllocationCount: %d\n", PageCount, PageNumber, AllocationCount));
@@ -375,25 +378,25 @@ VOID MemAllocTest(VOID)
 
 	MemPtr1 = MmAllocateMemory(4096);
 	printf("MemPtr1: 0x%x\n", (int)MemPtr1);
-	getch();
+	MachConsGetCh();
 	MemPtr2 = MmAllocateMemory(4096);
 	printf("MemPtr2: 0x%x\n", (int)MemPtr2);
-	getch();
+	MachConsGetCh();
 	MemPtr3 = MmAllocateMemory(4096);
 	printf("MemPtr3: 0x%x\n", (int)MemPtr3);
 	DumpMemoryAllocMap();
 	VerifyHeap();
-	getch();
+	MachConsGetCh();
 
 	MmFreeMemory(MemPtr2);
-	getch();
+	MachConsGetCh();
 
 	MemPtr4 = MmAllocateMemory(2048);
 	printf("MemPtr4: 0x%x\n", (int)MemPtr4);
-	getch();
+	MachConsGetCh();
 	MemPtr5 = MmAllocateMemory(4096);
 	printf("MemPtr5: 0x%x\n", (int)MemPtr5);
-	getch();
+	MachConsGetCh();
 }
 #endif // DEBUG
 

freeldr/freeldr/reactos/binhive.c

@@ -780,7 +780,7 @@ CmiAllocateCell (PREGISTRY_HIVE RegistryHive,
       /* Add a new block */
       if (!CmiAddBin(RegistryHive,
 		     ((sizeof(HBIN) + CellSize - 1) / REG_BLOCK_SIZE) + 1,
-		     (PVOID *)&NewBlock,
+		     (PVOID *)(PVOID)&NewBlock,
 		     pBlockOffset))
 	return FALSE;
     }
@@ -844,7 +844,7 @@ CmiAllocateHashTableCell (PREGISTRY_HIVE Hive,
 		(SubKeyCount * sizeof(HASH_RECORD));
   Status = CmiAllocateCell (Hive,
 			    NewHashSize,
-			    (PVOID*) &HashCell,
+			    (PVOID*)(PVOID)&HashCell,
 			    HBOffset);
   if ((HashCell == NULL) || (Status == FALSE))
     {
@@ -937,7 +937,7 @@ CmiAllocateValueCell(PREGISTRY_HIVE Hive,
   NameSize = (ValueName == NULL) ? 0 : strlen (ValueName);
   Status = CmiAllocateCell (Hive,
 			    sizeof(VALUE_CELL) + NameSize,
-			    (PVOID*)&NewValueCell,
+			    (PVOID*)(PVOID)&NewValueCell,
 			    ValueCellOffset);
   if ((NewValueCell == NULL) || (Status == FALSE))
     {
@@ -1081,7 +1081,7 @@ CmiExportValue (PREGISTRY_HIVE Hive,
       /* Allocate data cell */
       if (!CmiAllocateCell (Hive,
 			    sizeof(CELL_HEADER) + DstDataSize,
-			    (PVOID *)&DataCell,
+			    (PVOID *)(PVOID)&DataCell,
 			    &DataCellOffset))
 	{
 	  return FALSE;

freeldr/freeldr/reactos/reactos.c

@@ -28,6 +28,7 @@
 #include <ui.h>
 #include <multiboot.h>
 #include <mm.h>
+#include <machine.h>
 #include <inifile.h>
 
 #include "registry.h"
@@ -40,6 +41,7 @@
      (P) == PARTITION_FAT_16       || \
      (P) == PARTITION_HUGE         || \
      (P) == PARTITION_IFS          || \
+     (P) == PARTITION_EXT2         || \
      (P) == PARTITION_FAT32        || \
      (P) == PARTITION_FAT32_XINT13 || \
      (P) == PARTITION_XINT13)
@@ -226,16 +228,19 @@ static VOID
 LoadBootDrivers(PCHAR szSystemRoot, int nPos)
 {
   S32 rc = 0;
-  HKEY hGroupKey, hServiceKey, hDriverKey;
-  char ValueBuffer[512];
+  HKEY hGroupKey, hOrderKey, hServiceKey, hDriverKey;
+  char GroupNameBuffer[512];
   char ServiceName[256];
+  U32 OrderList[128];
   U32 BufferSize;
   U32 Index;
+  U32 TagIndex;
   char *GroupName;
 
   U32 ValueSize;
   U32 ValueType;
   U32 StartValue;
+  U32 TagValue;
   UCHAR DriverGroup[256];
   U32 DriverGroupSize;
 
@@ -248,7 +253,17 @@ LoadBootDrivers(PCHAR szSystemRoot, int nPos)
 		  &hGroupKey);
   if (rc != ERROR_SUCCESS)
     {
-      DbgPrint((DPRINT_REACTOS, "Failed to open the 'ServiceGroupOrder key (rc %d)\n", (int)rc));
+      DbgPrint((DPRINT_REACTOS, "Failed to open the 'ServiceGroupOrder' key (rc %d)\n", (int)rc));
+      return;
+    }
+  
+  /* get 'group order list' key */
+  rc = RegOpenKey(NULL,
+                  "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\GroupOrderList",
+		  &hOrderKey);
+  if (rc != ERROR_SUCCESS)
+    {
+      DbgPrint((DPRINT_REACTOS, "Failed to open the 'GroupOrderList' key (rc %d)\n", (int)rc));
       return;
     }
 
@@ -262,26 +277,110 @@ LoadBootDrivers(PCHAR szSystemRoot, int nPos)
       return;
     }
 
-  BufferSize = sizeof(ValueBuffer);
-  rc = RegQueryValue(hGroupKey, "List", NULL, (PUCHAR)ValueBuffer, &BufferSize);
+  BufferSize = sizeof(GroupNameBuffer);
+  rc = RegQueryValue(hGroupKey, "List", NULL, (PUCHAR)GroupNameBuffer, &BufferSize);
   DbgPrint((DPRINT_REACTOS, "RegQueryValue(): rc %d\n", (int)rc));
   if (rc != ERROR_SUCCESS)
     return;
 
   DbgPrint((DPRINT_REACTOS, "BufferSize: %d \n", (int)BufferSize));
 
-  DbgPrint((DPRINT_REACTOS, "ValueBuffer: '%s' \n", ValueBuffer));
+  DbgPrint((DPRINT_REACTOS, "GroupNameBuffer: '%s' \n", GroupNameBuffer));
 
-  GroupName = ValueBuffer;
+  GroupName = GroupNameBuffer;
   while (*GroupName)
     {
       DbgPrint((DPRINT_REACTOS, "Driver group: '%s'\n", GroupName));
 
-      /* enumerate all drivers */
+      BufferSize = sizeof(OrderList);
+      rc = RegQueryValue(hOrderKey, GroupName, NULL, (PUCHAR)OrderList, &BufferSize);
+      if (rc != ERROR_SUCCESS)
+        {
+	  OrderList[0] = 0;
+	}
+      
+      for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
+        {
+	  /* enumerate all drivers */
+	  Index = 0;
+	  while (TRUE)
+	    {
+	      ValueSize = sizeof(ServiceName);
+	      rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize);
+	      DbgPrint((DPRINT_REACTOS, "RegEnumKey(): rc %d\n", (int)rc));
+	      if (rc == ERROR_NO_MORE_ITEMS)
+	        break;
+	      if (rc != ERROR_SUCCESS)
+	        return;
+	      DbgPrint((DPRINT_REACTOS, "Service %d: '%s'\n", (int)Index, ServiceName));
+
+	      /* open driver Key */
+	      rc = RegOpenKey(hServiceKey, ServiceName, &hDriverKey);
+
+	      ValueSize = sizeof(U32);
+	      rc = RegQueryValue(hDriverKey, "Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
+	      DbgPrint((DPRINT_REACTOS, "  Start: %x  \n", (int)StartValue));
+
+	      ValueSize = sizeof(U32);
+	      rc = RegQueryValue(hDriverKey, "Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
+	      if (rc != ERROR_SUCCESS)
+	        {
+		  TagValue = (U32)-1;
+		}
+	      DbgPrint((DPRINT_REACTOS, "  Tag:   %x  \n", (int)TagValue));
+		  
+
+	      DriverGroupSize = 256;
+	      rc = RegQueryValue(hDriverKey, "Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
+	      DbgPrint((DPRINT_REACTOS, "  Group: '%s'  \n", DriverGroup));
+
+	      if ((StartValue == 0) && (TagValue == OrderList[TagIndex]) &&(stricmp(DriverGroup, GroupName) == 0))
+	        {
+	          ValueSize = 256;
+	          rc = RegQueryValue(hDriverKey,
+				     "ImagePath",
+				     NULL,
+				     (PUCHAR)TempImagePath,
+				     &ValueSize);
+	          if (rc != ERROR_SUCCESS)
+		    {
+		      DbgPrint((DPRINT_REACTOS, "  ImagePath: not found\n"));
+		      strcpy(ImagePath, szSystemRoot);
+		      strcat(ImagePath, "system32\\drivers\\");
+		      strcat(ImagePath, ServiceName);
+		      strcat(ImagePath, ".sys");
+		    }
+	          else if (TempImagePath[0] != '\\')
+		    {
+		      strcpy(ImagePath, szSystemRoot);
+		      strcat(ImagePath, TempImagePath);
+		    }
+	          else
+		    {
+		      strcpy(ImagePath, TempImagePath);
+		      DbgPrint((DPRINT_REACTOS, "  ImagePath: '%s'\n", ImagePath));
+		    }
+	          DbgPrint((DPRINT_REACTOS, "  Loading driver: '%s'\n", ImagePath));
+
+	          if (nPos < 100)
+		    nPos += 5;
+
+	          LoadDriver(ImagePath, nPos);
+	          LoadSymbolFile(szSystemRoot, ImagePath, nPos);
+	        }
+	      else
+	        {
+	          DbgPrint((DPRINT_REACTOS, "  Skipping driver '%s' with Start %d, Tag %d and Group '%s' (Current Tag %d, current group '%s')\n",
+	                   ServiceName, StartValue, TagValue, DriverGroup, OrderList[TagIndex], GroupName));
+	        }
+	      Index++;
+	    }
+	}  
+
       Index = 0;
       while (TRUE)
 	{
-	  ValueSize = sizeof(ValueBuffer);
+	  ValueSize = sizeof(ServiceName);
 	  rc = RegEnumKey(hServiceKey, Index, ServiceName, &ValueSize);
 	  DbgPrint((DPRINT_REACTOS, "RegEnumKey(): rc %d\n", (int)rc));
 	  if (rc == ERROR_NO_MORE_ITEMS)
@@ -297,11 +396,25 @@ LoadBootDrivers(PCHAR szSystemRoot, int nPos)
 	  rc = RegQueryValue(hDriverKey, "Start", &ValueType, (PUCHAR)&StartValue, &ValueSize);
 	  DbgPrint((DPRINT_REACTOS, "  Start: %x  \n", (int)StartValue));
 
+	  ValueSize = sizeof(U32);
+	  rc = RegQueryValue(hDriverKey, "Tag", &ValueType, (PUCHAR)&TagValue, &ValueSize);
+	  if (rc != ERROR_SUCCESS)
+	    {
+	      TagValue = (U32)-1;
+	    }
+	  DbgPrint((DPRINT_REACTOS, "  Tag:   %x  \n", (int)TagValue));
+
 	  DriverGroupSize = 256;
 	  rc = RegQueryValue(hDriverKey, "Group", NULL, (PUCHAR)DriverGroup, &DriverGroupSize);
 	  DbgPrint((DPRINT_REACTOS, "  Group: '%s'  \n", DriverGroup));
 
-	  if ((StartValue == 0) && (stricmp(DriverGroup, GroupName) == 0))
+          for (TagIndex = 1; TagIndex <= OrderList[0]; TagIndex++)
+	    {
+	      if (TagValue == OrderList[TagIndex])
+	        break;
+	    }
+
+	  if ((StartValue == 0) && (TagIndex > OrderList[0]) && (stricmp(DriverGroup, GroupName) == 0))
 	    {
 	      ValueSize = 256;
 	      rc = RegQueryValue(hDriverKey,
@@ -337,8 +450,8 @@ LoadBootDrivers(PCHAR szSystemRoot, int nPos)
 	    }
 	  else
 	    {
-	      DbgPrint((DPRINT_REACTOS, "  Skipping driver '%s' with Start %d and Group '%s' (Current group '%s')\n",
-	          ImagePath, StartValue, DriverGroup, GroupName));
+	      DbgPrint((DPRINT_REACTOS, "  Skipping driver '%s' with Start %d, Tag %d and Group '%s' (Current group '%s')\n",
+	               ServiceName, StartValue, TagValue, DriverGroup, GroupName));
 	    }
 	  Index++;
 	}
@@ -349,7 +462,7 @@ LoadBootDrivers(PCHAR szSystemRoot, int nPos)
 
 
 static BOOL
-LoadNlsFiles(PCHAR szSystemRoot)
+LoadNlsFiles(PCHAR szSystemRoot, PCHAR szErrorOut)
 {
   S32 rc = ERROR_SUCCESS;
   HKEY hKey;
@@ -362,77 +475,96 @@ LoadNlsFiles(PCHAR szSystemRoot)
   rc = RegOpenKey(NULL,
 		  "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\CodePage",
 		  &hKey);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "Couldn't open CodePage registry key");
+      return(FALSE);
+  }
 
 
   /* get ANSI codepage */
   BufferSize = 80;
   rc = RegQueryValue(hKey, "ACP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "Couldn't get ACP NLS setting");
+      return(FALSE);
+  }
 
   BufferSize = 80;
   rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
-
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "ACP NLS Setting exists, but isn't readable");
+      return(FALSE);
+  }
 
   /* load ANSI codepage table */
   strcpy(szFileName, szSystemRoot);
   strcat(szFileName, "system32\\");
   strcat(szFileName, szNameBuffer);
   DbgPrint((DPRINT_REACTOS, "ANSI file: %s\n", szFileName));
-  if (!LoadNlsFile(szFileName, "ansi.nls"))
-    return(FALSE);
-
+  if (!LoadNlsFile(szFileName, "ansi.nls")) {
+      strcpy(szErrorOut, "Couldn't load ansi.nls");
+      return(FALSE);
+  }
 
   /* get OEM codepage */
   BufferSize = 80;
   rc = RegQueryValue(hKey, "OEMCP", NULL, (PUCHAR)szIdBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "Couldn't get OEMCP NLS setting");
+      return(FALSE);
+  }
 
   BufferSize = 80;
   rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "OEMCP NLS setting exists, but isn't readable");
+      return(FALSE);
+  }
 
   /* load OEM codepage table */
   strcpy(szFileName, szSystemRoot);
   strcat(szFileName, "system32\\");
   strcat(szFileName, szNameBuffer);
   DbgPrint((DPRINT_REACTOS, "Oem file: %s\n", szFileName));
-  if (!LoadNlsFile(szFileName, "oem.nls"))
-    return(FALSE);
-
+  if (!LoadNlsFile(szFileName, "oem.nls")) {
+      strcpy(szErrorOut, "Couldn't load oem.nls");
+      return(FALSE);
+  }
 
   /* open the language key */
   rc = RegOpenKey(NULL,
 		  "\\Registry\\Machine\\SYSTEM\\CurrentControlSet\\Control\\NLS\\Language",
 		  &hKey);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
-
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "Couldn't open Language registry key");
+      return(FALSE);
+  }
 
   /* get the Unicode case table */
   BufferSize = 80;
   rc = RegQueryValue(hKey, "Default", NULL, (PUCHAR)szIdBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, "Couldn't get Language Default setting");
+      return(FALSE);
+  }
 
   BufferSize = 80;
   rc = RegQueryValue(hKey, szIdBuffer, NULL, (PUCHAR)szNameBuffer, &BufferSize);
-  if (rc != ERROR_SUCCESS)
-    return(FALSE);
+  if (rc != ERROR_SUCCESS) {
+      strcpy(szErrorOut, 
+	     "Language Default setting exists, but isn't readable");
+      return(FALSE);
+  }
 
   /* load Unicode case table */
   strcpy(szFileName, szSystemRoot);
   strcat(szFileName, "system32\\");
   strcat(szFileName, szNameBuffer);
   DbgPrint((DPRINT_REACTOS, "Casemap file: %s\n", szFileName));
-  if (!LoadNlsFile(szFileName, "casemap.nls"))
-    return(FALSE);
+  if (!LoadNlsFile(szFileName, "casemap.nls")) {
+      strcpy(szErrorOut, "casemap.nls");
+      return(FALSE);
+  }
 
   return(TRUE);
 }
@@ -449,16 +581,14 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 	char  szFileName[1024];
 	char  szBootPath[256];
 	int		i;
-//	int		nNumDriverFiles=0;
-//	int		nNumFilesLoaded=0;
 	char  MsgBuffer[256];
 	U32 SectionId;
 
 	char* Base;
 	U32 Size;
 
-        PARTITION_TABLE_ENTRY PartitionTableEntry;
-        U32 rosPartition;
+	PARTITION_TABLE_ENTRY PartitionTableEntry;
+	U32 rosPartition;
 
 	//
 	// Open the operating system section
@@ -475,22 +605,35 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 	 * Setup multiboot information structure
 	 */
 	mb_info.flags = MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_BOOT_DEVICE | MB_INFO_FLAG_COMMAND_LINE | MB_INFO_FLAG_MODULES;
-	mb_info.mem_lower = GetConventionalMemorySize();
-	mb_info.mem_upper = GetExtendedMemorySize();
 	mb_info.boot_device = 0xffffffff;
 	mb_info.cmdline = (unsigned long)multiboot_kernel_cmdline;
 	mb_info.mods_count = 0;
 	mb_info.mods_addr = (unsigned long)multiboot_modules;
-	mb_info.mmap_length = (unsigned long)GetBiosMemoryMap((PBIOS_MEMORY_MAP)&multiboot_memory_map, 32) * sizeof(memory_map_t);
+	mb_info.mmap_length = (unsigned long)MachGetMemoryMap((PBIOS_MEMORY_MAP)(PVOID)&multiboot_memory_map, 32) * sizeof(memory_map_t);
 	if (mb_info.mmap_length)
 	{
 		mb_info.mmap_addr = (unsigned long)&multiboot_memory_map;
-		mb_info.flags |= MB_INFO_FLAG_MEMORY_MAP;
+		mb_info.flags |= MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_MEMORY_MAP;
 		multiboot_memory_map_descriptor_size = sizeof(memory_map_t); // GetBiosMemoryMap uses a fixed value of 24
 		DbgPrint((DPRINT_REACTOS, "memory map length: %d\n", mb_info.mmap_length));
 		DbgPrint((DPRINT_REACTOS, "dumping memory map:\n"));
 		for (i=0; i<(mb_info.mmap_length/sizeof(memory_map_t)); i++)
 		{
+			if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
+			    0 == multiboot_memory_map[i].base_addr_low)
+			{
+				mb_info.mem_lower = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024;
+				if (640 < mb_info.mem_lower)
+				{
+					mb_info.mem_lower = 640;
+				}
+			}
+			if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
+			    multiboot_memory_map[i].base_addr_low <= 1024 * 1024 &&
+			    1024 * 1024 <= multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low)
+			{
+				mb_info.mem_upper = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024 - 1024;
+			}
 			DbgPrint((DPRINT_REACTOS, "start: %x\t size: %x\t type %d\n", 
 			          multiboot_memory_map[i].base_addr_low, 
 				  multiboot_memory_map[i].length_low,
@@ -537,13 +680,13 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 			UiMessageBox(MsgBuffer);
 			return;
 		}
-	        
+
 		/* recalculate the boot partition for freeldr */
 		i = 0;
 		rosPartition = 0;
 		while (1)
 		{
-		   if (!DiskGetPartitionEntry(BootDrive, ++i, &PartitionTableEntry))
+		   if (!MachDiskGetPartitionEntry(BootDrive, ++i, &PartitionTableEntry))
 		   {
 		      BootPartition = 0;
 		      break;
@@ -557,17 +700,18 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 		      }
 		   }
 		}
+
 		if (BootPartition == 0)
 		{
 			sprintf(MsgBuffer,"Invalid system path: '%s'", value);
 			UiMessageBox(MsgBuffer);
 			return;
 		}
-	        
+
 		/* copy ARC path into kernel command line */
 		strcpy(multiboot_kernel_cmdline, value);
 	}
-	        
+
 	/* Set boot drive and partition */
 	((char *)(&mb_info.boot_device))[0] = (char)BootDrive;
 	((char *)(&mb_info.boot_device))[1] = (char)BootPartition;
@@ -595,7 +739,7 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 	/*
 	 * Detect hardware
 	 */
-	DetectHardware();
+	MachHwDetect();
 
 
 	UiDrawStatusText("Loading...");
@@ -731,9 +875,9 @@ LoadAndBootReactOS(PUCHAR OperatingSystemName)
 	/*
 	 * Load NLS files
 	 */
-	if (!LoadNlsFiles(szBootPath))
+	if (!LoadNlsFiles(szBootPath, MsgBuffer))
 	{
-		UiMessageBox("Could not load the NLS files!\n");
+	        UiMessageBox(MsgBuffer);
 		return;
 	}
 	UiDrawProgressBarCenter(25, 100, "Loading ReactOS...");

freeldr/freeldr/reactos/setupldr.c

@@ -27,6 +27,7 @@
 #include <fs.h>
 #include <multiboot.h>
 #include <mm.h>
+#include <machine.h>
 #include <ui.h>
 #include <inffile.h>
 
@@ -238,45 +239,53 @@ VOID RunLoader(VOID)
   U32 Size;
   char *SourcePath;
   char *LoadOptions;
+  int i;
 
   HINF InfHandle;
   U32 ErrorLine;
   INFCONTEXT InfContext;
 
   /* Setup multiboot information structure */
-  mb_info.flags = MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_BOOT_DEVICE | MB_INFO_FLAG_COMMAND_LINE | MB_INFO_FLAG_MODULES;
-  mb_info.mem_lower = GetConventionalMemorySize();
-  mb_info.mem_upper = GetExtendedMemorySize();
+  mb_info.flags = MB_INFO_FLAG_BOOT_DEVICE | MB_INFO_FLAG_COMMAND_LINE | MB_INFO_FLAG_MODULES;
   mb_info.boot_device = 0xffffffff;
   mb_info.cmdline = (unsigned long)multiboot_kernel_cmdline;
   mb_info.mods_count = 0;
   mb_info.mods_addr = (unsigned long)multiboot_modules;
-  mb_info.mmap_length = (unsigned long)GetBiosMemoryMap((PBIOS_MEMORY_MAP)&multiboot_memory_map, 32) * sizeof(memory_map_t);
+  mb_info.mmap_length = (unsigned long)MachGetMemoryMap((PBIOS_MEMORY_MAP)(PVOID)&multiboot_memory_map, 32) * sizeof(memory_map_t);
   if (mb_info.mmap_length)
     {
       mb_info.mmap_addr = (unsigned long)&multiboot_memory_map;
-      mb_info.flags |= MB_INFO_FLAG_MEMORY_MAP;
+      mb_info.flags |= MB_INFO_FLAG_MEM_SIZE | MB_INFO_FLAG_MEMORY_MAP;
       multiboot_memory_map_descriptor_size = sizeof(memory_map_t); // GetBiosMemoryMap uses a fixed value of 24
+      for (i = 0; i < (mb_info.mmap_length / sizeof(memory_map_t)); i++)
+        {
+          if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
+              0 == multiboot_memory_map[i].base_addr_low)
+            {
+              mb_info.mem_lower = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024;
+              if (640 < mb_info.mem_lower)
+                {
+                  mb_info.mem_lower = 640;
+                }
+            }
+          if (MEMTYPE_USABLE == multiboot_memory_map[i].type &&
+              multiboot_memory_map[i].base_addr_low <= 1024 * 1024 &&
+              1024 * 1024 <= multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low)
+            {
+              mb_info.mem_upper = (multiboot_memory_map[i].base_addr_low + multiboot_memory_map[i].length_low) / 1024 - 1024;
+            }
 #if 0
-      {
-	 int i;
-         printf("memory map length: %d\n", mb_info.mmap_length);
-         printf("dumping memory map:\n");
-         for (i=0; i<(mb_info.mmap_length / sizeof(memory_map_t)); i++)
-	 {
 	    printf("start: %x\t size: %x\t type %d\n", 
 		   multiboot_memory_map[i].base_addr_low, 
 		   multiboot_memory_map[i].length_low,
 		   multiboot_memory_map[i].type);
-	 }
-         getch();
-      }
 #endif
+        }
     }
 #if 0
   printf("low_mem = %d\n", mb_info.mem_lower);
   printf("high_mem = %d\n", mb_info.mem_upper);
-  getch();
+  MachConsGetCh();
 #endif
 
 #ifdef USE_UI
@@ -293,7 +302,7 @@ VOID RunLoader(VOID)
 #else
   printf("Detecting hardware...\n\n");
 #endif
-  DetectHardware();
+  MachHwDetect();
 #ifdef USE_UI
   UiDrawStatusText("");
 #endif
@@ -392,7 +401,7 @@ for(;;);
       UiMessageBox("Please insert \"ReactOS Boot Disk 2\" and press ENTER");
 #else
       printf("\n\n Please insert \"ReactOS Boot Disk 2\" and press ENTER\n");
-      getch();
+      MachConsGetCh();
 #endif
 
       /* Open boot drive */
@@ -497,77 +506,62 @@ for(;;);
       return;
     }
 
+#if 0
+  /* Load acpi.sys */
+  if (!LoadDriver(SourcePath, "acpi.sys"))
+    return;
+#endif
 
-  /* Load drivers */
-  if (BootDrive < 0x80)
-    {
-      /*
-       * Load floppy.sys
-       */
-      if (!LoadDriver(SourcePath, "floppy.sys"))
-	return;
+#if 0
+  /* Load isapnp.sys */
+  if (!LoadDriver(SourcePath, "isapnp.sys"))
+    return;
+#endif
 
-      /*
-       * Load vfatfs.sys (could be loaded by the setup prog!)
-       */
-      if (!LoadDriver(SourcePath, "vfatfs.sys"))
-	return;
-    }
-  else
-    {
-	/*
-	 * Load scsiport.sys
-	 */
-	if (!LoadDriver(SourcePath, "scsiport.sys"))
-		return;
+#if 0
+  /* Load pci.sys */
+  if (!LoadDriver(SourcePath, "pci.sys"))
+    return;
+#endif
 
-	/*
-	 * Load atapi.sys (depends on hardware detection)
-	 */
-	if (!LoadDriver(SourcePath, "atapi.sys"))
-		return;
+  /* Load scsiport.sys */
+  if (!LoadDriver(SourcePath, "scsiport.sys"))
+    return;
 
-	/*
-	 * Load class2.sys
-	 */
-	if (!LoadDriver(SourcePath, "class2.sys"))
-		return;
+  /* Load atapi.sys (depends on hardware detection) */
+  if (!LoadDriver(SourcePath, "atapi.sys"))
+    return;
 
-	/*
-	 * Load cdrom.sys
-	 */
-	if (!LoadDriver(SourcePath, "cdrom.sys"))
-		return;
+  /* Load class2.sys */
+  if (!LoadDriver(SourcePath, "class2.sys"))
+    return;
 
-	/*
-	 * Load cdfs.sys
-	 */
-	if (!LoadDriver(SourcePath, "cdfs.sys"))
-		return;
+  /* Load cdrom.sys */
+  if (!LoadDriver(SourcePath, "cdrom.sys"))
+    return;
 
-	/*
-	 * Load disk.sys
-	 */
-	if (!LoadDriver(SourcePath, "disk.sys"))
-		return;
+  /* Load cdfs.sys */
+  if (!LoadDriver(SourcePath, "cdfs.sys"))
+    return;
 
-	/*
-	 * Load vfatfs.sys (could be loaded by the setup prog!)
-	 */
-	if (!LoadDriver(SourcePath, "vfatfs.sys"))
-		return;
-    }
+  /* Load disk.sys */
+  if (!LoadDriver(SourcePath, "disk.sys"))
+    return;
+
+  /* Load floppy.sys */
+  if (!LoadDriver(SourcePath, "floppy.sys"))
+    return;
+
+  /* Load vfatfs.sys (could be loaded by the setup prog!) */
+  if (!LoadDriver(SourcePath, "vfatfs.sys"))
+    return;
 
 
-  /*
-   * Load keyboard driver
-   */
+  /* Load keyboard driver */
   if (!LoadDriver(SourcePath, "keyboard.sys"))
     return;
 
-  /*
-   * Load screen driver
-   */
+  /* Load screen driver */
   if (!LoadDriver(SourcePath, "blue.sys"))
     return;
 
@@ -575,9 +569,7 @@ for(;;);
   UiUnInitialize("Booting ReactOS...");
 #endif
 
-  /*
-   * Now boot the kernel
-   */
+  /* Now boot the kernel */
   DiskStopFloppyMotor();
   boot_reactos();
 }

freeldr/freeldr/rtl/print.c

@@ -17,6 +17,8 @@
  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
+#include <freeldr.h>
+#include <machine.h>
 #include <rtl.h>
 
 /*
@@ -26,8 +28,8 @@ void print(char *str)
 {
 	int	i;
 
-	for(i=0; i<strlen(str); i++)
-		putchar(str[i]);
+	for (i = 0; i < strlen(str); i++)
+		MachConsPutChar(str[i]);
 }
 
 /*
@@ -36,7 +38,7 @@ void print(char *str)
  */
 void printf(char *format, ... )
 {
-	int *dataptr = (int *) &format;
+	int *dataptr = (int *)(void *)&format;
 	char c, *ptr, str[16];
 	int ll;
 
@@ -46,7 +48,7 @@ void printf(char *format, ... )
 	{
 		if (c != '%')
 		{
-			putchar(c);
+			MachConsPutChar(c);
 		}
 		else
 		{
@@ -75,22 +77,22 @@ void printf(char *format, ... )
 
 				while (*ptr)
 				{
-					putchar(*(ptr++));
+					MachConsPutChar(*(ptr++));
 				}
 				break;
 
-			case 'c': putchar((*(dataptr++))&0xff); break;
+			case 'c': MachConsPutChar((*(dataptr++))&0xff); break;
 
 			case 's':
 				ptr = (char *)(*(dataptr++));
 
 				while ((c = *(ptr++)))
 				{
-					putchar(c);
+					MachConsPutChar(c);
 				}
 				break;
 			case '%':
-				putchar(c);
+				MachConsPutChar(c);
 				break;
 			default:
 				printf("\nprintf() invalid format specifier - %%%c\n", c);
@@ -102,7 +104,7 @@ void printf(char *format, ... )
 
 void sprintf(char *buffer, char *format, ... )
 {
-	int *dataptr = (int *) &format;
+	int *dataptr = (int *)(void *)&format;
 	char c, *ptr, str[16];
 	char *p = buffer;
 	int ll;

freeldr/freeldr/ui/tui.c

@@ -27,15 +27,15 @@
 #include <inifile.h>
 #include <version.h>
 #include <video.h>
+#include <machine.h>
 
 
 PVOID	TextVideoBuffer = NULL;
 
 BOOL TuiInitialize(VOID)
 {
-	VideoClearScreen();
-	VideoHideTextCursor();
-	BiosVideoDisableBlinkBit();
+	MachVideoClearScreen(ATTR(COLOR_WHITE, COLOR_BLACK));
+	MachVideoHideShowTextCursor(FALSE);
 
 	TextVideoBuffer = VideoAllocateOffScreenBuffer();
 	if (TextVideoBuffer == NULL)
@@ -54,13 +54,11 @@ VOID TuiUnInitialize(VOID)
 	}
 	else
 	{
-		VideoSetMode(VIDEOMODE_NORMAL_TEXT);
+		MachVideoSetDisplayMode(NULL, FALSE);
 	}
 
 	//VideoClearScreen();
-	VideoSetMode(VIDEOMODE_NORMAL_TEXT);
-	VideoShowTextCursor();
-	BiosVideoEnableBlinkBit();
+	MachVideoHideShowTextCursor(TRUE);
 }
 
 VOID TuiDrawBackdrop(VOID)
@@ -397,26 +395,28 @@ VOID TuiDrawStatusText(PUCHAR StatusText)
 
 VOID TuiUpdateDateTime(VOID)
 {
+	U32	Year, Month, Day;
+	U32	Hour, Minute, Second;
 	UCHAR	DateString[40];
 	UCHAR	TimeString[40];
 	UCHAR	TempString[20];
-	U32		Hour, Minute, Second;
 	BOOL	PMHour = FALSE;
 
+	MachRTCGetCurrentDateTime(&Year, &Month, &Day, &Hour, &Minute, &Second);
 	// Get the month name
-	strcpy(DateString, UiMonthNames[getmonth()-1]);
+	strcpy(DateString, UiMonthNames[Month - 1]);
 	// Get the day
-	itoa(getday(), TempString, 10);
+	itoa(Day, TempString, 10);
 	// Get the day postfix
-	if ((getday() == 1) || (getday() == 21) || (getday() == 31))
+	if (1 == Day || 21 == Day || 31 == Day)
 	{
 		strcat(TempString, "st");
 	}
-	else if ((getday() == 2) || (getday() == 22))
+	else if (2 == Day || 22 == Day)
 	{
 		strcat(TempString, "nd");
 	}
-	else if ((getday() == 3) || (getday() == 23))
+	else if (3 == Day || 23 == Day)
 	{
 		strcat(TempString, "rd");
 	}
@@ -430,14 +430,13 @@ VOID TuiUpdateDateTime(VOID)
 	strcat(DateString, " ");
 
 	// Get the year and add it to the date
-	itoa(getyear(), TempString, 10);
+	itoa(Year, TempString, 10);
 	strcat(DateString, TempString);
 
 	// Draw the date
 	TuiDrawText(UiScreenWidth-strlen(DateString)-2, 1, DateString, ATTR(UiTitleBoxFgColor, UiTitleBoxBgColor));
 
 	// Get the hour and change from 24-hour mode to 12-hour
-	Hour = gethour();
 	if (Hour > 12)
 	{
 		Hour -= 12;
@@ -447,8 +446,6 @@ VOID TuiUpdateDateTime(VOID)
 	{
 		Hour = 12;
 	}
-	Minute = getminute();
-	Second = getsecond();
 	itoa(Hour, TempString, 10);
 	strcpy(TimeString, "    ");
 	strcat(TimeString, TempString);
@@ -584,11 +581,11 @@ VOID TuiMessageBoxCritical(PUCHAR MessageText)
 
 	for (;;)
 	{
-		if (kbhit())
+		if (MachConsKbHit())
 		{
-			key = getch();
+			key = MachConsGetCh();
 			if(key == KEY_EXTENDED)
-				key = getch();
+				key = MachConsGetCh();
 
 			if(key == KEY_ENTER)
 				break;
@@ -718,7 +715,7 @@ VOID TuiFadeInBackdrop(VOID)
 {
 	PPALETTE_ENTRY TuiFadePalette = NULL;
 
-	if (UiUseSpecialEffects)
+	if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
 	{
 		TuiFadePalette = (PPALETTE_ENTRY)MmAllocateMemory(sizeof(PALETTE_ENTRY) * 64);
 
@@ -732,7 +729,7 @@ VOID TuiFadeInBackdrop(VOID)
 	// Draw the backdrop and title box
 	TuiDrawBackdrop();
 
-	if (UiUseSpecialEffects && TuiFadePalette != NULL)
+	if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
 	{
 		VideoFadeIn(TuiFadePalette, 64);
 		MmFreeMemory(TuiFadePalette);
@@ -743,7 +740,7 @@ VOID TuiFadeOut(VOID)
 {
 	PPALETTE_ENTRY TuiFadePalette = NULL;
 
-	if (UiUseSpecialEffects)
+	if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed())
 	{
 		TuiFadePalette = (PPALETTE_ENTRY)MmAllocateMemory(sizeof(PALETTE_ENTRY) * 64);
 
@@ -753,14 +750,14 @@ VOID TuiFadeOut(VOID)
 		}
 	}
 
-	if (UiUseSpecialEffects && TuiFadePalette != NULL)
+	if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
 	{
 		VideoFadeOut(64);
 	}
 
-	VideoSetMode(VIDEOMODE_NORMAL_TEXT);
+	MachVideoSetDisplayMode(NULL, FALSE);
 
-	if (UiUseSpecialEffects && TuiFadePalette != NULL)
+	if (UiUseSpecialEffects && ! MachVideoIsPaletteFixed() && TuiFadePalette != NULL)
 	{
 		VideoRestorePaletteState(TuiFadePalette, 64);
 		MmFreeMemory(TuiFadePalette);
@@ -843,8 +840,8 @@ BOOL TuiEditBox(PUCHAR MessageText, PUCHAR EditTextBuffer, U32 Length)
 
 	// Show the cursor
 	EditBoxCursorX = EditBoxStartX;
-	VideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
-	VideoShowTextCursor();
+	MachVideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
+	MachVideoHideShowTextCursor(TRUE);
 
 	// Draw status text
 	UiDrawStatusText("Press ENTER to continue, or ESC to cancel");
@@ -853,12 +850,12 @@ BOOL TuiEditBox(PUCHAR MessageText, PUCHAR EditTextBuffer, U32 Length)
 
 	for (;;)
 	{
-		if (kbhit())
+		if (MachConsKbHit())
 		{
-			key = getch();
+			key = MachConsGetCh();
 			if(key == KEY_EXTENDED)
 			{
-				key = getch();
+				key = MachConsGetCh();
 			}
 
 			if(key == KEY_ENTER)
@@ -915,7 +912,7 @@ BOOL TuiEditBox(PUCHAR MessageText, PUCHAR EditTextBuffer, U32 Length)
 		UiDrawText(EditBoxStartX, EditBoxLine, &EditTextBuffer[EditBoxTextDisplayIndex], ATTR(UiEditBoxTextColor, UiEditBoxBgColor));
 
 		// Move the cursor
-		VideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
+		MachVideoSetTextCursorPosition(EditBoxCursorX, EditBoxLine);
 
 		TuiUpdateDateTime();
 
@@ -923,7 +920,7 @@ BOOL TuiEditBox(PUCHAR MessageText, PUCHAR EditTextBuffer, U32 Length)
 	}
 
 	// Hide the cursor again
-	VideoHideTextCursor();
+	MachVideoHideShowTextCursor(FALSE);
 
 	// Restore the screen contents
 	TuiRestoreScreen(ScreenBuffer);

freeldr/freeldr/ui/tuimenu.c

@@ -24,14 +24,16 @@
 #include "keycodes.h"
 #include <options.h>
 #include <mm.h>
+#include <machine.h>
 #include <video.h>
 
 
 BOOL TuiDisplayMenu(PUCHAR MenuItemList[], U32 MenuItemCount, U32 DefaultMenuItem, S32 MenuTimeOut, U32* SelectedMenuItem, BOOL CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter)
 {
 	TUI_MENU_INFO	MenuInformation;
-	U32				CurrentClockSecond;
-	U32				KeyPress;
+	U32		LastClockSecond;
+	U32		CurrentClockSecond;
+	U32		KeyPress;
 
 	//
 	// The first thing we need to check is the timeout
@@ -69,7 +71,7 @@ BOOL TuiDisplayMenu(PUCHAR MenuItemList[], U32 MenuItemCount, U32 DefaultMenuIte
 	//
 	// Get the current second of time
 	//
-	CurrentClockSecond = getsecond();
+	MachRTCGetCurrentDateTime(NULL, NULL, NULL, NULL, NULL, &LastClockSecond);
 
 	//
 	// Process keys
@@ -104,12 +106,13 @@ BOOL TuiDisplayMenu(PUCHAR MenuItemList[], U32 MenuItemCount, U32 DefaultMenuIte
 
 		if (MenuInformation.MenuTimeRemaining > 0)
 		{
-			if (getsecond() != CurrentClockSecond)
+			MachRTCGetCurrentDateTime(NULL, NULL, NULL, NULL, NULL, &CurrentClockSecond);
+			if (CurrentClockSecond != LastClockSecond)
 			{
 				//
 				// Update the time information
 				//
-				CurrentClockSecond = getsecond();
+				LastClockSecond = CurrentClockSecond;
 				MenuInformation.MenuTimeRemaining--;
 
 				//
@@ -339,7 +342,7 @@ U32 TuiProcessMenuKeyboardEvent(PTUI_MENU_INFO MenuInfo, UiMenuKeyPressFilterCal
 	//
 	// Check for a keypress
 	//
-	if (kbhit())
+	if (MachConsKbHit())
 	{
 		//
 		// Cancel the timeout
@@ -353,13 +356,13 @@ U32 TuiProcessMenuKeyboardEvent(PTUI_MENU_INFO MenuInfo, UiMenuKeyPressFilterCal
 		//
 		// Get the key
 		//
-		KeyEvent = getch();
+		KeyEvent = MachConsGetCh();
 
 		//
 		// Is it extended?
 		//
 		if (KeyEvent == 0)
-			KeyEvent = getch(); // Yes - so get the extended key
+			KeyEvent = MachConsGetCh(); // Yes - so get the extended key
 
 		//
 		// Call the supplied key filter callback function to see

freeldr/freeldr/ui/ui.c

@@ -22,17 +22,14 @@
 #include "tui.h"
 #include <rtl.h>
 #include <mm.h>
+#include <machine.h>
 #include <debug.h>
 #include <inifile.h>
 #include <version.h>
 #include <video.h>
 
-
-#define DISPLAYMODE_TEXT		0
-#define DISPLAYMODE_GRAPHICS	1
-
-U32		UiScreenWidth = 80;									// Screen Width
-U32		UiScreenHeight = 25;								// Screen Height
+U32	UiScreenWidth = 80;							// Screen Width
+U32	UiScreenHeight = 25;							// Screen Height
 
 UCHAR	UiStatusBarFgColor			= COLOR_BLACK;			// Status bar foreground color
 UCHAR	UiStatusBarBgColor			= COLOR_CYAN;			// Status bar background color
@@ -55,74 +52,42 @@ UCHAR	UiTitleBoxTitleText[260]	= "Boot Menu";			// Title box's title text
 
 BOOL	UserInterfaceUp				= FALSE;				// Tells us if the user interface is displayed
 
-BOOL	UiDisplayMode				= DISPLAYMODE_TEXT;		// Tells us if we are in text or graphics mode
+VIDEODISPLAYMODE	UiDisplayMode		= VideoTextMode;		// Tells us if we are in text or graphics mode
 
 BOOL	UiUseSpecialEffects			= FALSE;				// Tells us if we should use fade effects
 
 UCHAR	UiMonthNames[12][15] = { "January ", "February ", "March ", "April ", "May ", "June ", "July ", "August ", "September ", "October ", "November ", "December " };
 
 
-BOOL UiInitialize(VOID)
+BOOL UiInitialize(BOOLEAN ShowGui)
 {
-	U32		SectionId;
+	U32	SectionId;
+	UCHAR	DisplayModeText[260];
 	UCHAR	SettingText[260];
-	U32		VideoMode = VIDEOMODE_NORMAL_TEXT;
+	U32	Depth;
 
+	if (!ShowGui) {
+		if (!TuiInitialize())
+		{
+			MachVideoSetDisplayMode(NULL, FALSE);
+			return FALSE;
+		}
+		UserInterfaceUp = FALSE;
+		return TRUE;
+	}
+	
 	DbgPrint((DPRINT_UI, "Initializing User Interface.\n"));
 
 	DbgPrint((DPRINT_UI, "Reading in UI settings from [Display] section.\n"));
 
+	DisplayModeText[0] = '\0';
 	if (IniOpenSection("Display", &SectionId))
 	{
-		if (IniReadSettingByName(SectionId, "DisplayMode", SettingText, 260))
+		if (! IniReadSettingByName(SectionId, "DisplayMode", DisplayModeText, 260))
 		{
-			if (BiosDetectVideoCard() == VIDEOCARD_CGA_OR_OTHER)
-			{
-				DbgPrint((DPRINT_UI, "CGA or other display adapter detected.\n"));
-				printf("CGA or other display adapter detected.\n");
-				printf("Using 80x25 text mode.\n");
-				VideoMode = VIDEOMODE_NORMAL_TEXT;
-			}
-			else if (BiosDetectVideoCard() == VIDEOCARD_EGA)
-			{
-				DbgPrint((DPRINT_UI, "EGA display adapter detected.\n"));
-				printf("EGA display adapter detected.\n");
-				printf("Using 80x25 text mode.\n");
-				VideoMode = VIDEOMODE_NORMAL_TEXT;
-			}
-			else //if (BiosDetectVideoCard() == VIDEOCARD_VGA)
-			{
-				DbgPrint((DPRINT_UI, "VGA display adapter detected.\n"));
-
-				if (stricmp(SettingText, "NORMAL_VGA") == 0)
-				{
-					VideoMode = VIDEOMODE_NORMAL_TEXT;
-				}
-				else if (stricmp(SettingText, "EXTENDED_VGA") == 0)
-				{
-					VideoMode = VIDEOMODE_EXTENDED_TEXT;
-				}
-				else
-				{
-					VideoMode = atoi(SettingText);
-				}
-			}
-
-			if (!VideoSetMode(VideoMode))
-			{
-				printf("Error: unable to set video display mode 0x%x\n", (int) VideoMode);
-				printf("Defaulting to 80x25 text mode.\n");
-				printf("Press any key to continue.\n");
-				getch();
-
-				VideoMode = VIDEOMODE_NORMAL_TEXT;
-				VideoSetMode(VIDEOMODE_NORMAL_TEXT);
-			}
-
-			UiScreenWidth = VideoGetCurrentModeResolutionX();
-			UiScreenHeight = VideoGetCurrentModeResolutionY();
-			UiDisplayMode = VideoGetCurrentModeType();
+			DisplayModeText[0] = '\0';
 		}
+
 		if (IniReadSettingByName(SectionId, "TitleText", SettingText, 260))
 		{
 			strcpy(UiTitleBoxTitleText, SettingText);
@@ -204,11 +169,15 @@ BOOL UiInitialize(VOID)
 		}
 	}
 
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	UiDisplayMode = MachVideoSetDisplayMode(DisplayModeText, TRUE);
+	MachVideoGetDisplaySize(&UiScreenWidth, &UiScreenHeight, &Depth);
+
+
+	if (VideoTextMode == UiDisplayMode)
 	{
 		if (!TuiInitialize())
 		{
-			VideoSetMode(VIDEOMODE_NORMAL_TEXT);
+			MachVideoSetDisplayMode(NULL, FALSE);
 			return FALSE;
 		}
 	}
@@ -217,7 +186,7 @@ BOOL UiInitialize(VOID)
 		UNIMPLEMENTED();
 		//if (!GuiInitialize())
 		//{
-		//	VideoSetMode(VIDEOMODE_NORMAL_TEXT);
+		//	MachSetDisplayMode(NULL, FALSE);
 		//	return FALSE;
 		//}
 	}
@@ -238,7 +207,7 @@ VOID UiUnInitialize(PUCHAR BootText)
 	UiDrawStatusText("Booting...");
 	UiInfoBox(BootText);
 
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiUnInitialize();
 	}
@@ -251,7 +220,9 @@ VOID UiUnInitialize(PUCHAR BootText)
 
 VOID UiDrawBackdrop(VOID)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (!UserInterfaceUp) return;
+	
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawBackdrop();
 	}
@@ -264,7 +235,7 @@ VOID UiDrawBackdrop(VOID)
 
 VOID UiFillArea(U32 Left, U32 Top, U32 Right, U32 Bottom, UCHAR FillChar, UCHAR Attr /* Color Attributes */)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiFillArea(Left, Top, Right, Bottom, FillChar, Attr);
 	}
@@ -277,7 +248,7 @@ VOID UiFillArea(U32 Left, U32 Top, U32 Right, U32 Bottom, UCHAR FillChar, UCHAR
 
 VOID UiDrawShadow(U32 Left, U32 Top, U32 Right, U32 Bottom)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawShadow(Left, Top, Right, Bottom);
 	}
@@ -290,7 +261,7 @@ VOID UiDrawShadow(U32 Left, U32 Top, U32 Right, U32 Bottom)
 
 VOID UiDrawBox(U32 Left, U32 Top, U32 Right, U32 Bottom, UCHAR VertStyle, UCHAR HorzStyle, BOOL Fill, BOOL Shadow, UCHAR Attr)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawBox(Left, Top, Right, Bottom, VertStyle, HorzStyle, Fill, Shadow, Attr);
 	}
@@ -303,7 +274,7 @@ VOID UiDrawBox(U32 Left, U32 Top, U32 Right, U32 Bottom, UCHAR VertStyle, UCHAR
 
 VOID UiDrawText(U32 X, U32 Y, PUCHAR Text, UCHAR Attr)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawText(X, Y, Text, Attr);
 	}
@@ -316,7 +287,7 @@ VOID UiDrawText(U32 X, U32 Y, PUCHAR Text, UCHAR Attr)
 
 VOID UiDrawCenteredText(U32 Left, U32 Top, U32 Right, U32 Bottom, PUCHAR TextString, UCHAR Attr)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawCenteredText(Left, Top, Right, Bottom, TextString, Attr);
 	}
@@ -329,7 +300,9 @@ VOID UiDrawCenteredText(U32 Left, U32 Top, U32 Right, U32 Bottom, PUCHAR TextStr
 
 VOID UiDrawStatusText(PUCHAR StatusText)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (!UserInterfaceUp) return;
+	
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawStatusText(StatusText);
 	}
@@ -342,7 +315,7 @@ VOID UiDrawStatusText(PUCHAR StatusText)
 
 VOID UiUpdateDateTime(VOID)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiUpdateDateTime();
 	}
@@ -424,11 +397,11 @@ VOID UiMessageBox(PUCHAR MessageText)
 	{
 		printf("%s\n", MessageText);
 		printf("Press any key\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
 
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiMessageBox(MessageText);
 	}
@@ -449,11 +422,11 @@ VOID UiMessageBoxCritical(PUCHAR MessageText)
 	{
 		printf("%s\n", MessageText);
 		printf("Press any key\n");
-		getch();
+		MachConsGetCh();
 		return;
 	}
 
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiMessageBoxCritical(MessageText);
 	}
@@ -466,7 +439,7 @@ VOID UiMessageBoxCritical(PUCHAR MessageText)
 
 UCHAR UiTextToColor(PUCHAR ColorText)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		return TuiTextToColor(ColorText);
 	}
@@ -480,7 +453,7 @@ UCHAR UiTextToColor(PUCHAR ColorText)
 
 UCHAR UiTextToFillStyle(PUCHAR FillStyleText)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		return TuiTextToFillStyle(FillStyleText);
 	}
@@ -494,7 +467,9 @@ UCHAR UiTextToFillStyle(PUCHAR FillStyleText)
 
 VOID UiDrawProgressBarCenter(U32 Position, U32 Range, PUCHAR ProgressText)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (!UserInterfaceUp) return;
+	
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawProgressBarCenter(Position, Range, ProgressText);
 	}
@@ -507,7 +482,7 @@ VOID UiDrawProgressBarCenter(U32 Position, U32 Range, PUCHAR ProgressText)
 
 VOID UiDrawProgressBar(U32 Left, U32 Top, U32 Right, U32 Bottom, U32 Position, U32 Range, PUCHAR ProgressText)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiDrawProgressBar(Left, Top, Right, Bottom, Position, Range, ProgressText);
 	}
@@ -598,7 +573,7 @@ VOID UiTruncateStringEllipsis(PUCHAR StringText, U32 MaxChars)
 
 BOOL UiDisplayMenu(PUCHAR MenuItemList[], U32 MenuItemCount, U32 DefaultMenuItem, S32 MenuTimeOut, U32* SelectedMenuItem, BOOL CanEscape, UiMenuKeyPressFilterCallback KeyPressFilter)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		return TuiDisplayMenu(MenuItemList, MenuItemCount, DefaultMenuItem, MenuTimeOut, SelectedMenuItem, CanEscape, KeyPressFilter);
 	}
@@ -612,7 +587,7 @@ BOOL UiDisplayMenu(PUCHAR MenuItemList[], U32 MenuItemCount, U32 DefaultMenuItem
 
 VOID UiFadeInBackdrop(VOID)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiFadeInBackdrop();
 	}
@@ -625,7 +600,7 @@ VOID UiFadeInBackdrop(VOID)
 
 VOID UiFadeOut(VOID)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		TuiFadeOut();
 	}
@@ -638,7 +613,7 @@ VOID UiFadeOut(VOID)
 
 BOOL UiEditBox(PUCHAR MessageText, PUCHAR EditTextBuffer, U32 Length)
 {
-	if (UiDisplayMode == DISPLAYMODE_TEXT)
+	if (VideoTextMode == UiDisplayMode)
 	{
 		return TuiEditBox(MessageText, EditTextBuffer, Length);
 	}

freeldr/freeldr/video/bank.c

@@ -22,8 +22,10 @@
 #include <comm.h>
 #include <rtl.h>
 #include <debug.h>
+#include <machine.h>
 
 
+#if 0 /* This stuff isn't used and as far as I'm concerned it can go - GvG */
 U32		CurrentMemoryBank = 0;
 
 VOID VideoSetMemoryBank(U16 BankNumber)
@@ -108,45 +110,9 @@ U32 VideoGetOffScreenMemoryOffsetForPixel(U32 X, U32 Y)
 
 	return MemoryPos;
 }
+#endif
 
 VOID VideoCopyOffScreenBufferToVRAM(VOID)
 {
-	U32		BanksToCopy;
-	U32		BytesInLastBank;
-	U32		CurrentBank;
-	U32		BankSize;
-	U32		BufferSize;
-
-	//VideoWaitForVerticalRetrace();
-
-	// Text mode (BIOS or VESA)
-	if (VideoGetCurrentModeType() == MODETYPE_TEXT)
-	{
-		BufferSize = VideoGetCurrentModeResolutionX() * VideoGetBytesPerScanLine();
-		RtlCopyMemory((PVOID)VIDEOTEXT_MEM_ADDRESS, VideoOffScreenBuffer, BufferSize);
-	}
-	// VESA graphics mode
-	else if (VideoGetCurrentModeType() == MODETYPE_GRAPHICS && VideoIsCurrentModeVesa())
-	{
-		BankSize = VesaVideoModeInformation.WindowGranularity << 10;
-		BanksToCopy = (VesaVideoModeInformation.HeightInPixels * VesaVideoModeInformation.BytesPerScanLine) / BankSize;
-		BytesInLastBank = (VesaVideoModeInformation.HeightInPixels * VesaVideoModeInformation.BytesPerScanLine) % BankSize;
-
-		// Copy all the banks but the last one because
-		// it is probably a partial bank
-		for (CurrentBank=0; CurrentBank<BanksToCopy; CurrentBank++)
-		{
-			VideoSetMemoryBank(CurrentBank);
-			RtlCopyMemory((PVOID)VIDEOVGA_MEM_ADDRESS, VideoOffScreenBuffer, BankSize);
-		}
-
-		// Copy the remaining bytes into the last bank
-		VideoSetMemoryBank(CurrentBank);
-		RtlCopyMemory((PVOID)VIDEOVGA_MEM_ADDRESS, VideoOffScreenBuffer, BytesInLastBank);
-	}
-	// BIOS graphics mode
-	else
-	{
-		UNIMPLEMENTED();
-	}
+	MachVideoCopyOffScreenBufferToVRAM(VideoOffScreenBuffer);
 }

freeldr/freeldr/video/fade.c

@@ -19,7 +19,7 @@
 	
 #include <freeldr.h>
 #include <video.h>
-#include <portio.h>
+#include <machine.h>
 
 
 #define RGB_MAX						64
@@ -29,11 +29,11 @@ VOID VideoSetAllColorsToBlack(U32 ColorCount)
 {
 	U32		Color;
 
-	VideoWaitForVerticalRetrace();
+	MachVideoSync();
 
 	for (Color=0; Color<ColorCount; Color++)
 	{
-		VideoSetPaletteColor(Color, 0, 0, 0);
+		MachVideoSetPaletteColor(Color, 0, 0, 0);
 	}
 }
 
@@ -48,7 +48,7 @@ VOID VideoFadeIn(PPALETTE_ENTRY Palette, U32 ColorCount)
 
 		for (Color=0; Color<ColorCount; Color++)
 		{
-			VideoGetPaletteColor(Color, &PaletteColors[Color].Red, &PaletteColors[Color].Green, &PaletteColors[Color].Blue);
+			MachVideoGetPaletteColor(Color, &PaletteColors[Color].Red, &PaletteColors[Color].Green, &PaletteColors[Color].Blue);
 
 			// Increment each color so it approaches its real value
 			if (PaletteColors[Color].Red < Palette[Color].Red)
@@ -84,10 +84,10 @@ VOID VideoFadeIn(PPALETTE_ENTRY Palette, U32 ColorCount)
 		{
 			if ((Color % RGB_MAX_PER_ITERATION) == 0)
 			{
-				VideoWaitForVerticalRetrace();
+				MachVideoSync();
 			}
 
-			VideoSetPaletteColor(Color, PaletteColors[Color].Red, PaletteColors[Color].Green, PaletteColors[Color].Blue);
+			MachVideoSetPaletteColor(Color, PaletteColors[Color].Red, PaletteColors[Color].Green, PaletteColors[Color].Blue);
 		}
 	}
 }
@@ -106,10 +106,10 @@ VOID VideoFadeOut(U32 ColorCount)
 		{
 			if ((Color % RGB_MAX_PER_ITERATION) == 0)
 			{
-				VideoWaitForVerticalRetrace();
+				MachVideoSync();
 			}
 
-			VideoGetPaletteColor(Color, &Red, &Green, &Blue);
+			MachVideoGetPaletteColor(Color, &Red, &Green, &Blue);
 
 			if (Red > 0)
 			{
@@ -124,7 +124,7 @@ VOID VideoFadeOut(U32 ColorCount)
 				Blue--;
 			}
 
-			VideoSetPaletteColor(Color, Red, Green, Blue);
+			MachVideoSetPaletteColor(Color, Red, Green, Blue);
 		}
 	}
 }

freeldr/freeldr/video/palette.c

@@ -19,24 +19,7 @@
 	
 #include <freeldr.h>
 #include <video.h>
-#include <portio.h>
-
-
-VOID VideoSetPaletteColor(U8 Color, U8 Red, U8 Green, U8 Blue)
-{
-	WRITE_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_WRITE, Color);
-	WRITE_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA, Red);
-	WRITE_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA, Green);
-	WRITE_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA, Blue);
-}
-
-VOID VideoGetPaletteColor(U8 Color, U8* Red, U8* Green, U8* Blue)
-{
-	WRITE_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_READ, Color);
-	*Red = READ_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA);
-	*Green = READ_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA);
-	*Blue = READ_PORT_UCHAR((U8*)VIDEOPORT_PALETTE_DATA);
-}
+#include <machine.h>
 
 VOID VideoSavePaletteState(PPALETTE_ENTRY Palette, U32 ColorCount)
 {
@@ -44,7 +27,7 @@ VOID VideoSavePaletteState(PPALETTE_ENTRY Palette, U32 ColorCount)
 
 	for (Color=0; Color<ColorCount; Color++)
 	{
-		VideoGetPaletteColor(Color, &Palette[Color].Red, &Palette[Color].Green, &Palette[Color].Blue);
+		MachVideoGetPaletteColor(Color, &Palette[Color].Red, &Palette[Color].Green, &Palette[Color].Blue);
 	}
 }
 
@@ -52,10 +35,10 @@ VOID VideoRestorePaletteState(PPALETTE_ENTRY Palette, U32 ColorCount)
 {
 	U32		Color;
 
-	VideoWaitForVerticalRetrace();
+	MachVideoSync();
 
 	for (Color=0; Color<ColorCount; Color++)
 	{
-		VideoSetPaletteColor(Color, Palette[Color].Red, Palette[Color].Green, Palette[Color].Blue);
+		MachVideoSetPaletteColor(Color, Palette[Color].Red, Palette[Color].Green, Palette[Color].Blue);
 	}
 }

freeldr/freeldr/video/pixel.c

@@ -21,11 +21,11 @@
 #include <video.h>
 #include <portio.h>
 #include <debug.h>
+#include <machine.h>
 
 
 
-
-
+#if 0 /* This stuff isn't used and as far as I'm concerned it can go - GvG */
 //
 // Arrrggh!
 // I really really hate 16 color bit plane modes.
@@ -230,26 +230,24 @@ VOID VideoSetPixelRGB_24Bit(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue)
 
 VOID VideoSetPixelRGB(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue)
 {
-	if (VesaVideoModeInformation.BitsPerPixel >= 24)
+	U32 Width, Height, Depth;
+
+	MachVideoGetDisplaySize(&Width, &Height, &Depth);
+	if (Depth >= 24)
 	{
 		VideoSetPixelRGB_24Bit(X, Y, Red, Green, Blue);
 	}
-	else if (VesaVideoModeInformation.BitsPerPixel >= 16)
+	else if (Depth >= 16)
 	{
-		// 16-bit color modes give green an extra bit (5:6:5)
-		// 15-bit color modes have just 5:5:5 for R:G:B
-		if (VesaVideoModeInformation.GreenMaskSize == 6)
-		{
-			VideoSetPixelRGB_16Bit(X, Y, Red, Green, Blue);
-		}
-		else
-		{
-			VideoSetPixelRGB_15Bit(X, Y, Red, Green, Blue);
-		}
+		VideoSetPixelRGB_16Bit(X, Y, Red, Green, Blue);
+	}
+	else if (Depth == 15)
+	{
+		VideoSetPixelRGB_15Bit(X, Y, Red, Green, Blue);
 	}
 	else
 	{
-		BugCheck((DPRINT_UI, "This function does not support %d bits per pixel!", VesaVideoModeInformation.BitsPerPixel));
+		BugCheck((DPRINT_UI, "This function does not support %d bits per pixel!", Depth));
 	}
 }
 
@@ -319,25 +317,25 @@ VOID VideoSetPixelRGB_24Bit_OffScreen(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue)
 
 VOID VideoSetPixelRGB_OffScreen(U32 X, U32 Y, U8 Red, U8 Green, U8 Blue)
 {
-	if (VesaVideoModeInformation.BitsPerPixel >= 24)
+	U32 Width, Height, Depth;
+
+	MachVideoGetDisplaySize(&Width, &Height, &Depth);
+	if (Depth >= 24)
 	{
 		VideoSetPixelRGB_24Bit_OffScreen(X, Y, Red, Green, Blue);
 	}
-	else if (VesaVideoModeInformation.BitsPerPixel >= 16)
+	else if (Depth >= 16)
 	{
-		// 16-bit color modes give green an extra bit (5:6:5)
-		// 15-bit color modes have just 5:5:5 for R:G:B
-		if (VesaVideoModeInformation.GreenMaskSize == 6)
-		{
-			VideoSetPixelRGB_16Bit_OffScreen(X, Y, Red, Green, Blue);
-		}
-		else
-		{
-			VideoSetPixelRGB_15Bit_OffScreen(X, Y, Red, Green, Blue);
-		}
+		VideoSetPixelRGB_16Bit_OffScreen(X, Y, Red, Green, Blue);
+	}
+	else if (Depth == 15)
+	{
+		VideoSetPixelRGB_15Bit_OffScreen(X, Y, Red, Green, Blue);
 	}
 	else
 	{
-		BugCheck((DPRINT_UI, "This function does not support %d bits per pixel!", VesaVideoModeInformation.BitsPerPixel));
+		BugCheck((DPRINT_UI, "This function does not support %d bits per pixel!", Depth));
 	}
 }
+
+#endif

freeldr/freeldr/video/video.c

@@ -21,34 +21,11 @@
 #include <video.h>
 #include <portio.h>
 #include <mm.h>
+#include <machine.h>
 
 
 PVOID	VideoOffScreenBuffer = NULL;
 
-VOID VideoClearScreen(VOID)
-{
-	VideoSetMode(VideoGetCurrentMode());
-}
-
-VOID VideoWaitForVerticalRetrace(VOID)
-{
-
-	while ((READ_PORT_UCHAR((U8*)VIDEOPORT_VERTICAL_RETRACE) & 0x08) == 1)
-	{
-		// Keep reading the port until bit 3 is clear
-		// This waits for the current retrace to end and
-		// we can catch the next one so we know we are
-		// getting a full retrace.
-	}
-
-	while ((READ_PORT_UCHAR((U8*)VIDEOPORT_VERTICAL_RETRACE) & 0x08) == 0)
-	{
-		// Keep reading the port until bit 3 is set
-		// Now that we know we aren't doing a vertical
-		// retrace we need to wait for the next one.
-	}
-}
-
 PVOID VideoAllocateOffScreenBuffer(VOID)
 {
 	U32		BufferSize;
@@ -59,7 +36,7 @@ PVOID VideoAllocateOffScreenBuffer(VOID)
 		VideoOffScreenBuffer = NULL;
 	}
 
-	BufferSize = VideoGetCurrentModeResolutionX() * VideoGetBytesPerScanLine();
+	BufferSize = MachVideoGetBufferSize();
 
 	VideoOffScreenBuffer = MmAllocateMemory(BufferSize);
 

freeldr/freeldr/video/vidmode.c

@@ -1,313 +0,0 @@
-/*
- *  FreeLoader
- *  Copyright (C) 1998-2003  Brian Palmer  <brianp@sginet.com>
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-	
-#include <freeldr.h>
-#include <video.h>
-#include <debug.h>
-#include <portio.h>
-
-U32						CurrentVideoMode		= VIDEOMODE_NORMAL_TEXT;
-U32						VideoResolutionX		= 80;
-U32						VideoResolutionY		= 25;
-U32						VideoBytesPerScanLine	= 0;	// Number of bytes per scan line
-U32						CurrentModeType			= MODETYPE_TEXT;
-BOOL					VesaVideoMode			= FALSE;
-
-SVGA_MODE_INFORMATION	VesaVideoModeInformation;
-
-BOOL VideoSetMode(U32 VideoMode)
-{
-	CurrentMemoryBank = 0;
-
-	// Set the values for the default text modes
-	// If they are setting a graphics mode then
-	// these values will be changed.
-	CurrentVideoMode = VideoMode;
-	VideoResolutionX = 80;
-	VideoResolutionY = 25;
-	VideoBytesPerScanLine = 160;
-	CurrentModeType = MODETYPE_TEXT;
-	VesaVideoMode = FALSE;
-
-	switch (VideoMode)
-	{
-	case VIDEOMODE_NORMAL_TEXT:
-	case 0x03: /* BIOS 80x25 text mode number */
-		return VideoSetMode80x25();
-	case VIDEOMODE_EXTENDED_TEXT:
-		return VideoSetMode80x50_80x43();
-	case VIDEOMODE_80X28:
-		return VideoSetMode80x28();
-	case VIDEOMODE_80X30:
-		return VideoSetMode80x30();
-	case VIDEOMODE_80X34:
-		return VideoSetMode80x34();
-	case VIDEOMODE_80X43:
-		return VideoSetMode80x43();
-	case VIDEOMODE_80X60:
-		return VideoSetMode80x60();
-	}
-
-	if (VideoMode == 0x12)
-	{
-		// 640x480x16
-		BiosSetVideoMode(VideoMode);
-		//WRITE_PORT_USHORT((U16*)0x03CE, 0x0205); // For some reason this is necessary?
-		WRITE_PORT_USHORT((U16*)0x03CE, 0x0F01); // For some reason this is necessary?
-		VideoResolutionX = 640;
-		VideoResolutionY = 480;
-		VideoBytesPerScanLine = 80;
-		CurrentVideoMode = 0x12;
-		CurrentModeType = MODETYPE_GRAPHICS;
-
-		return TRUE;
-	}
-	else if (VideoMode == 0x13)
-	{
-		// 320x200x256
-		BiosSetVideoMode(VideoMode);
-		VideoResolutionX = 320;
-		VideoResolutionY = 200;
-		VideoBytesPerScanLine = 320;
-		CurrentVideoMode = 0x13;
-		CurrentModeType = MODETYPE_GRAPHICS;
-
-		return TRUE;
-	}
-	else if (VideoMode >= 0x0108 && VideoMode <= 0x010C)
-	{
-		// VESA Text Mode
-		if (!BiosVesaGetSVGAModeInformation(VideoMode, &VesaVideoModeInformation))
-		{
-			return FALSE;
-		}
-
-		if (!BiosVesaSetVideoMode(VideoMode))
-		{
-			return FALSE;
-		}
-
-		VideoResolutionX = VesaVideoModeInformation.WidthInPixels;
-		VideoResolutionY = VesaVideoModeInformation.HeightInPixels;
-		VideoBytesPerScanLine = VesaVideoModeInformation.BytesPerScanLine;
-		CurrentVideoMode = VideoMode;
-		CurrentModeType = MODETYPE_TEXT;
-		VesaVideoMode = TRUE;
-
-		return TRUE;
-	}
-	else
-	{
-		// VESA Graphics Mode
-		if (!BiosVesaGetSVGAModeInformation(VideoMode, &VesaVideoModeInformation))
-		{
-			return FALSE;
-		}
-
-		if (!BiosVesaSetVideoMode(VideoMode))
-		{
-			return FALSE;
-		}
-
-		VideoResolutionX = VesaVideoModeInformation.WidthInPixels;
-		VideoResolutionY = VesaVideoModeInformation.HeightInPixels;
-		VideoBytesPerScanLine = VesaVideoModeInformation.BytesPerScanLine;
-		CurrentVideoMode = VideoMode;
-		CurrentModeType = MODETYPE_GRAPHICS;
-		VesaVideoMode = TRUE;
-
-		return TRUE;
-	}
-
-	return FALSE;
-}
-
-BOOL VideoSetMode80x25(VOID)
-{
-	BiosSetVideoMode(0x03);
-	VideoResolutionX = 80;
-	VideoResolutionY = 25;
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x50_80x43(VOID)
-{
-	if (BiosDetectVideoCard() == VIDEOCARD_VGA)
-	{
-		BiosSetVideoMode(0x03);
-		BiosSetVideoFont8x8();
-		BiosSelectAlternatePrintScreen();
-		BiosDisableCursorEmulation();
-		BiosDefineCursor(6, 7);
-		VideoResolutionX = 80;
-		VideoResolutionY = 50;
-	}
-	else if (BiosDetectVideoCard() == VIDEOCARD_EGA)
-	{
-		BiosSetVideoMode(0x03);
-		BiosSetVideoFont8x8();
-		BiosSelectAlternatePrintScreen();
-		BiosDisableCursorEmulation();
-		BiosDefineCursor(6, 7);
-		VideoResolutionX = 80;
-		VideoResolutionY = 43;
-	}
-	else // VIDEOCARD_CGA_OR_OTHER
-	{
-		return FALSE;
-	}
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x28(VOID)
-{
-	// FIXME: Is this VGA-only?
-	VideoSetMode80x25();
-	BiosSetVideoFont8x14();
-	BiosDefineCursor(11, 12);
-	VideoResolutionX = 80;
-	VideoResolutionY = 28;
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x43(VOID)
-{
-	// FIXME: Is this VGA-only?
-	BiosSetVerticalResolution(VERTRES_350_SCANLINES);
-	VideoSetMode80x25();
-	BiosSetVideoFont8x8();
-	BiosSelectAlternatePrintScreen();
-	BiosDisableCursorEmulation();
-	BiosDefineCursor(6, 7);
-	VideoResolutionX = 80;
-	VideoResolutionY = 43;
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x30(VOID)
-{
-	// FIXME: Is this VGA-only?
-	VideoSetMode80x25();
-	BiosSet480ScanLines();
-	VideoResolutionX = 80;
-	VideoResolutionY = 30;
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x34(VOID)
-{
-	// FIXME: Is this VGA-only?
-	VideoSetMode80x25();
-	BiosSet480ScanLines();
-	BiosSetVideoFont8x14();
-	BiosDefineCursor(11, 12);
-	BiosSetVideoDisplayEnd();
-	VideoResolutionX = 80;
-	VideoResolutionY = 34;
-
-	return TRUE;
-}
-
-BOOL VideoSetMode80x60(VOID)
-{
-	// FIXME: Is this VGA-only?
-	VideoSetMode80x25();
-	BiosSet480ScanLines();
-	BiosSetVideoFont8x8();
-	BiosSelectAlternatePrintScreen();
-	BiosDisableCursorEmulation();
-	BiosDefineCursor(6, 7);
-	BiosSetVideoDisplayEnd();
-	VideoResolutionX = 80;
-	VideoResolutionY = 60;
-
-	return TRUE;
-}
-
-U32 VideoGetCurrentModeResolutionX(VOID)
-{
-	return VideoResolutionX;
-}
-
-U32 VideoGetCurrentModeResolutionY(VOID)
-{
-	return VideoResolutionY;
-}
-
-U32 VideoGetBytesPerScanLine(VOID)
-{
-	return VideoBytesPerScanLine;
-}
-
-U32 VideoGetCurrentMode(VOID)
-{
-	return CurrentVideoMode;
-}
-
-U32 VideoGetCurrentModeType(VOID)
-{
-	return CurrentModeType;
-}
-
-BOOL VideoIsCurrentModeVesa(VOID)
-{
-	return VesaVideoMode;
-}
-
-U32 VideoGetCurrentModeColorDepth(VOID)
-{
-	U32	ColorDepth = 2;
-	U32	i;
-
-	if (CurrentModeType == MODETYPE_TEXT)
-	{
-		return 0;
-	}
-	else // CurrentModeType == MODETYPE_GRAPHICS
-	{
-		// Calculate 2^BitsPerPixel'th power
-		for (i=0; i<(VesaVideoModeInformation.BitsPerPixel-1); i++)
-		{
-			ColorDepth *= 2;
-		}
-
-		// This algorithm works great for 24-bit & 8-bit color modes
-		// but 15-bit color modes really use 16 bits per pixel.
-		// So check to see if green has an extra bit, if so then
-		// it is 16-bit, if not it is 15-bit
-		if (ColorDepth == 65536)
-		{
-			if (VesaVideoModeInformation.GreenMaskSize == 6)
-			{
-				return ColorDepth;
-			}
-			else
-			{
-				return 32768;
-			}
-		}
-
-		return ColorDepth;
-	}
-}

freeldr/notes.txt

@@ -4,7 +4,7 @@ Memory layout:
 
 0000:0000 - 0000:0FFF: Interrupt vector table & BIOS data
 0000:1000 - 0000:6FFF: Real mode stack area
-0000:7000 - 0000:7FFF: Unused
+0000:7000 - 0000:7FFF: Cmdline (multiboot)
 0000:8000 - xxxx:xxxx: FreeLoader program & data area
 xxxx:xxxx - 7000:7FFF: Random memory allocation heap
 7000:8000 - 7000:FFFF: Protected mode stack area
@@ -34,13 +34,24 @@ ISO-9660 (CD-ROM) Boot Sector
 
 	The BIOS loads the boot sector (2048 bytes) at 0000:7C00. First, the
 boot sector relocates itself to 0000:7000 (up to 0000:7800). Then it looks
-for the I386 directory and makes it the current directory. Next it looks for
+for the LOADER directory and makes it the current directory. Next it looks for
 FREELDR.SYS and loads it at 0000:8000. Finally it restores the boot drive
 number in the DL register and jumps to FreeLoader's entry point at 0000:8000.
 
 
+Multiboot
+
+	Freeldr contains a multiboot signature and can itself be loaded by a
+multiboot-compliant loader (like Grub). The multiboot header instructs the
+primary loader to load freeldr.sys at 0x200000 (needs to be above 1MB). Control
+is then transferred to the multiboot entry point. Since freeldr.sys expects to
+be loaded at a base address 0000:8000 it will start by relocating itself there
+and then jumping to the relocated copy.
+
+
+
 FreeLoader Initialization
 
 	When FreeLoader gets control it saves the boot drive, passed to it in
 the DL register, and sets up the stack, enables protected mode, and calls
-BootMain().
+BootMain().

freeldr/tools/hosttype.c

@@ -1,7 +1,9 @@
-//
-// hosttype.c
-// Copyright (C) 2002 by Brian Palmer <brianp@sginet.com>
-//
+/**
+ *
+ * hosttype.c
+ * Copyright (C) 2002 by Brian Palmer <brianp@sginet.com>
+ *
+ */
 
 #include <stdio.h>
 

msvc6/.cvsignore

@@ -1,2 +0,0 @@
-*.ncb
-*.opt

msvc6/README.txt

@@ -1,102 +0,0 @@
-ReactOS Microsoft Visual C/C++ 6.0 IDE files
-
-This is the Microsoft Visual C/C++ 6.0 project workspace and project
-files for a few of the ReactOS binaries. They are ONLY included as a
-convenience, and is NOT to be considered supported, or even correct.
-If you build a binary that misbehaves using these files, you _might_
-be able to get in touch with someone to fix the problem
-         BUT DO NOT COUNT ON IT!
-
-The only supported build system for ReactOS is the one documented at
-www.reactos.com.
-
-------------------------------------------------------------------
-Please, before you start playing with this, read the whole of
-this document.
-
-Before you can use these project files, you _need_ to make a successful
-build using the normal ReactOS build system. There are some vital files
-that needs to be created, and currently only the normal build creates these.
-
-Once that is done, you need to generate the kernel-mode service "table"
-file by running nmake (from this point on you can use the "native"
-MSVC tools) from the directory MSVC6\iface\native.
-This will generate MSVC6\ntoskrnl\nt_zw_msvc.c, an MSVC compatible inline-
-assembler version of the file otherwise known as reactos\ntoskrnl\nt\zw.c.
-
-Next, go to def_converter and run nmake. This builds the tool to convert
-the .def files for HAL and the kernel from the MinGW format to something
-more suitable for the MSVC linker, and also generates these .def files
-to their target location [1].
-
-Now you should be set to fire up the IDE and load the project workspace.
-
-
-When building HAL or the kernel for the first time using these
-project files, just doing it the "normal" way _will not work_.
-The linker will complain about missing library, and it will fail.
-
-The reason for this is a circular dependency between these two binaries.
-
-Currently you need to follow these procedures [2]:
-
-- Select hal as your active project.
-- Select Project/Settings.
-- Select the Link tab.
-- Select "General" from the Category drop-list.
-- Temporary remove the explicit linker library
-  (e.g. "..\ntoskrnl\Debug\ntoskrnl.lib")
-- Select "Customize" from the Category drop-list.
-- Check the "Force file output" checkbox.
-- Build hal.
-- Uncheck "Force file output".
-- Put back the removed import library.
-- Now build the ntoskrnl. Do NOT try to build hal again until
-  you have sucessfully built the kernel, and the linker has
-  generated its import library!
-- Now you can "Clean" hal, and build it as usual.
-
-If everything worked as expected, you should now have both ntoskrnl.exe
-and hal.dll freshly built.
-
-
-LIMITATIONS/DEVIATIONS (from the MinGW build):
-- Since there can only be one resource file/project, the kernel had
-to choose between either its version resource, or its message table.
-The messages won.
-- Do NOT open the .rc files in the IDE's resource editor. Chances are
-it will assume ownership over them and fill them up with at least
-conditional compilation macros.
-
-
-NOTES:
-
-[1] This is needed due to differences in handling of decorated names
-in .def files. While both MinGW GCC and MSVC generates decorated names
-in the same way for at least plain cdecl and stdcall C functions, the
-MSVC linker expects names in the .def file to be either
-
-- an exact match of the decorated name, in case it exports the
-  decorated name from the linked binary, or
-- just the name without any decoration, in case it exports just the
-  name of the symbol from the linked binary (to allow for e.g.
-  GetProcAddress using the undecorated name) - but keeps the decorated
-  names in the import library to handle and "redirect" linker requests
-  for those decorated symbols, and point them to the undercorated names
-  in the binary exporting them - so that a binary A, at link time,
-  importing symbols from binary B of the form "_name@0" will resolve
-  that symbol from the import library, but the linked binary A will
-  reference it as just "name".
-
-The ROS .def files contains a mix, "half-decorated", where the leading
-undescores are missing, but the trailing "@n" (for stdcall functions)
-are present.
- 
-
-[2] Theoretically it could be possible to use a hal.lib generated by the
-following procedure, removing the need for the manual steps above.
-
-  cd MSVC6\hal\Debug
-  lib \def:..\..\..\reactos\hal\hal\hal.def
-
-but I have not tested it, and take no responsibility for its effectiveness.

msvc6/ReactOS.dsw

@@ -1,41 +0,0 @@
-Microsoft Developer Studio Workspace File, Format Version 6.00
-# WARNING: DO NOT EDIT OR DELETE THIS WORKSPACE FILE!
-
-###############################################################################
-
-Project: "hal"=.\hal\hal.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Project: "ntoskrnl"=.\ntoskrnl\ntoskrnl.dsp - Package Owner=<4>
-
-Package=<5>
-{{{
-}}}
-
-Package=<4>
-{{{
-}}}
-
-###############################################################################
-
-Global:
-
-Package=<5>
-{{{
-}}}
-
-Package=<3>
-{{{
-}}}
-
-###############################################################################
-

msvc6/def_converter/def_converter.cpp

@@ -1,64 +0,0 @@
-// Uses hard-coded filenames to require a minimum of input.
-// You think this file should be licensed? OK then,
-// Copyright (C) 2004, Mike Nordell. Use as you whish.
-#include <fstream>
-#include <string>
-#include <algorithm>
-
-const char szSrc1[] = "..\\..\\reactos\\ntoskrnl\\ntoskrnl.def";
-const char szDst1[] = "..\\ntoskrnl\\ntoskrnl.def";
-const char szSrc2[] = "..\\..\\reactos\\hal\\hal\\hal.def";
-const char szDst2[] = "..\\hal\\hal.def";
-
-enum File
-{
-	Kernel,
-	HAL
-};
-
-std::string do_kernel_replacements(std::string& s)
-{
-	std::string s2 = s.c_str();	// to fixup size after replacements
-	if (s2 == "ExAllocateFromPagedLookasideList") {
-		s2 += "=ExiAllocateFromPagedLookasideList";
-	} else
-	if (s2 == "ExFreeToPagedLookasideList") {
-		s2 += "=ExiFreeToPagedLookasideList";
-	} else
-	if (s2 == "MmLockPagableImageSection") {
-		s2 += "=MmLockPagableDataSection";
-	}
-	return s2;
-}
-
-void convert_def(const char* szSrc, const char* szDst, File file)
-{
-	using namespace std;
-	ifstream in(szSrc);
-	ofstream out(szDst);
-	string s;
-	while (getline(in, s).good()) {
-		if (!s.size()) {
-			continue;
-		}
-		if (s[0] != ';') {	// only replace non-comment lines
-			if (s[0] == '@') {
-				s.erase(0, 1);
-			}
-			replace(s.begin(), s.end(), '@', '\0');
-			if (file == Kernel) {
-				s = do_kernel_replacements(s);
-			}
-		}
-		out << s << endl;
-	}
-}
-
-
-int main()
-{
-	convert_def(szSrc1, szDst1, Kernel);
-	convert_def(szSrc2, szDst2, HAL);
-	return 0;
-}
-

msvc6/def_converter/makefile

@@ -1,19 +0,0 @@
-# $Id: makefile,v 1.1 2004/02/06 08:21:54 fireball Exp $
-#
-# ReactOS Operating System - .def converter for HAL and the kernel
-#
-
-DEF_HAL  = ..\hal\hal.def
-DEF_KRNL = ..\ntoskrnl\ntoskrnl.def
-CPPFLAGS = /GX
-
-all: def_converter.exe $(DEF_HAL) $(DEF_KRNL)
-
-$(DEF_HAL) : ..\..\reactos\hal\hal\hal.def
-	def_converter.exe
-
-$(DEF_KRNL) : ..\..\reactos\ntoskrnl\ntoskrnl.def
-	def_converter.exe
-
-def_converter.exe : def_converter.cpp
-

msvc6/hal/.cvsignore

@@ -1,3 +0,0 @@
-Debug
-Release
-hal.def

msvc6/hal/hal.dsp

@@ -1,243 +0,0 @@
-# Microsoft Developer Studio Project File - Name="hal" - Package Owner=<4>
-# Microsoft Developer Studio Generated Build File, Format Version 6.00
-# ** DO NOT EDIT **
-
-# TARGTYPE "Win32 (x86) Dynamic-Link Library" 0x0102
-
-CFG=hal - Win32 Debug
-!MESSAGE This is not a valid makefile. To build this project using NMAKE,
-!MESSAGE use the Export Makefile command and run
-!MESSAGE 
-!MESSAGE NMAKE /f "hal.mak".
-!MESSAGE 
-!MESSAGE You can specify a configuration when running NMAKE
-!MESSAGE by defining the macro CFG on the command line. For example:
-!MESSAGE 
-!MESSAGE NMAKE /f "hal.mak" CFG="hal - Win32 Debug"
-!MESSAGE 
-!MESSAGE Possible choices for configuration are:
-!MESSAGE 
-!MESSAGE "hal - Win32 Release" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE "hal - Win32 Debug" (based on "Win32 (x86) Dynamic-Link Library")
-!MESSAGE 
-
-# Begin Project
-# PROP AllowPerConfigDependencies 0
-# PROP Scc_ProjName ""
-# PROP Scc_LocalPath ""
-CPP=cl.exe
-MTL=midl.exe
-RSC=rc.exe
-
-!IF  "$(CFG)" == "hal - Win32 Release"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 0
-# PROP BASE Output_Dir "Release"
-# PROP BASE Intermediate_Dir "Release"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 0
-# PROP Output_Dir "Release"
-# PROP Intermediate_Dir "Release"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MT /W3 /GX /O2 /D "WIN32" /D "NDEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "HAL_EXPORTS" /YX /FD /c
-# ADD CPP /nologo /MT /W3 /Ot /Og /Os /Ob1 /I "..\..\reactos\include" /I "..\..\reactos\hal\halx86\include" /I "..\..\reactos\ntoskrnl\include" /D "NDEBUG" /D "WIN32" /D "_WINDOWS" /D "_MBCS" /D "i386" /D "__NTHAL__" /FD /c
-# SUBTRACT CPP /YX
-# ADD BASE MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "NDEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x41d /d "NDEBUG"
-# ADD RSC /l 0x417 /i "..\..\reactos\include" /d "NDEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 /nologo /dll /machine:I386
-# ADD LINK32 ..\ntoskrnl\Release\ntoskrnl.lib /nologo /dll /machine:I386 /fixed:no
-# SUBTRACT LINK32 /pdb:none /force
-
-!ELSEIF  "$(CFG)" == "hal - Win32 Debug"
-
-# PROP BASE Use_MFC 0
-# PROP BASE Use_Debug_Libraries 1
-# PROP BASE Output_Dir "Debug"
-# PROP BASE Intermediate_Dir "Debug"
-# PROP BASE Target_Dir ""
-# PROP Use_MFC 0
-# PROP Use_Debug_Libraries 1
-# PROP Output_Dir "Debug"
-# PROP Intermediate_Dir "Debug"
-# PROP Ignore_Export_Lib 0
-# PROP Target_Dir ""
-# ADD BASE CPP /nologo /MTd /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_WINDOWS" /D "_MBCS" /D "_USRDLL" /D "HAL_EXPORTS" /YX /FD /GZ /c
-# ADD CPP /nologo /MTd /W3 /Z7 /Od /I "..\..\reactos\include" /I "..\..\reactos\hal\halx86\include" /I "..\..\reactos\ntoskrnl\include" /D "_WINDOWS" /D "__NTHAL__" /D "_DEBUG" /D "WIN32" /D "_MBCS" /D "i386" /FD /c
-# ADD BASE MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD MTL /nologo /D "_DEBUG" /mktyplib203 /win32
-# ADD BASE RSC /l 0x41d /d "_DEBUG"
-# ADD RSC /l 0x417 /i "..\..\reactos\include" /d "_DEBUG"
-BSC32=bscmake.exe
-# ADD BASE BSC32 /nologo
-# ADD BSC32 /nologo
-LINK32=link.exe
-# ADD BASE LINK32 /nologo /dll /debug /machine:I386 /pdbtype:sept
-# ADD LINK32 ..\ntoskrnl\Debug\ntoskrnl.lib /nologo /dll /incremental:no /debug /machine:I386 /pdbtype:sept /fixed:no
-# SUBTRACT LINK32 /pdb:none
-
-!ENDIF 
-
-# Begin Target
-
-# Name "hal - Win32 Release"
-# Name "hal - Win32 Debug"
-# Begin Group "Source Files"
-
-# PROP Default_Filter "cpp;c;cxx;rc;def;r;odl;idl;hpj;bat"
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\adapter.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\beep.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\bus.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\display.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\dma.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\drive.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\enum.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\fmutex.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\fmutex_tmn.c
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\halinit.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\halx86mp.rc
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\halx86up.rc
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\irql.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\isa.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\kdbg.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\mca.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\misc.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\mp.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\mpsirql.c
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\pci.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\portio.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\pwroff.c
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\reboot.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\spinlock.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\spinlock_tmn.c
-# PROP Exclude_From_Build 1
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\sysbus.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\sysinfo.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\time.c
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\timer.c
-# End Source File
-# End Group
-# Begin Group "include"
-
-# PROP Default_Filter "h;hpp;hxx;hm;inl"
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\include\bus.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\include\hal.h
-# End Source File
-# Begin Source File
-
-SOURCE=..\..\reactos\hal\halx86\include\mps.h
-# End Source File
-# End Group
-# Begin Group "Resource Files"
-
-# PROP Default_Filter "ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe"
-# End Group
-# Begin Source File
-
-SOURCE=.\hal.def
-# End Source File
-# End Target
-# End Project

msvc6/iface/native/genntdll.c

@@ -1,392 +0,0 @@
-/* $Id: genntdll.c,v 1.1 2004/02/06 08:21:56 fireball Exp $
- *
- * COPYRIGHT:             See COPYING in the top level directory
- * PROJECT:               ReactOS version of ntdll
- * FILE:                  iface/native/genntdll.c
- * PURPOSE:               Generates the system call stubs in ntdll
- * CHANGE HISTORY:	  Added a '@xx' to deal with stdcall [ Ariadne ]
- * 	19990616 (ea)
- * 		Four arguments now required; 4th is the file
- * 		for ntoskrnl ZwXXX functions (which are merely calls
- * 		to twin NtXXX calls, via int 0x2e (x86).
- * 	19990617 (ea)
- * 		Fixed a bug in function numbers in kernel ZwXXX stubs.
- *
- */
-
-/* INCLUDE ******************************************************************/
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-
-#define PARAMETERIZED_LIBS
-
-/* #define VERBOSE */
-
-#define INPUT_BUFFER_SIZE 255
-
-/* FUNCTIONS ****************************************************************/
-
-void write_syscall_stub(FILE* out, FILE* out3, char* name, char* name2,
-			char* nr_args, unsigned int sys_call_idx)
-{
-	int i;
-	int nArgBytes = atoi(nr_args);
-#ifdef PARAMETERIZED_LIBS
-  fprintf(out,"__asm__(\"\\n\\t.global _%s@%s\\n\\t\"\n",name,nr_args);
-  fprintf(out,"\".global _%s@%s\\n\\t\"\n",name2,nr_args);
-  fprintf(out,"\"_%s@%s:\\n\\t\"\n",name,nr_args);
-  fprintf(out,"\"_%s@%s:\\n\\t\"\n",name2,nr_args);
-#else
-  fprintf(out,"__asm__(\"\\n\\t.global _%s\\n\\t\"\n",name);
-  fprintf(out,"\".global _%s\\n\\t\"\n",name2);
-  fprintf(out,"\"_%s:\\n\\t\"\n",name);
-  fprintf(out,"\"_%s:\\n\\t\"\n",name2);
-#endif
-  fprintf(out,"\t\"pushl\t%%ebp\\n\\t\"\n");
-  fprintf(out,"\t\"movl\t%%esp, %%ebp\\n\\t\"\n");
-  fprintf(out,"\t\"mov\t$%d,%%eax\\n\\t\"\n",sys_call_idx);
-  fprintf(out,"\t\"lea\t8(%%ebp),%%edx\\n\\t\"\n");
-  fprintf(out,"\t\"int\t$0x2E\\n\\t\"\n");
-  fprintf(out,"\t\"popl\t%%ebp\\n\\t\"\n");
-  fprintf(out,"\t\"ret\t$%s\\n\\t\");\n\n",nr_args);
-  
-  /*
-   * Now write the NTOSKRNL stub for the
-   * current system call. ZwXXX does NOT
-   * alias the corresponding NtXXX call.
-   */
-#if 0
-  fprintf(out3,"__asm__(\n");
-  fprintf(out3,"\".global _%s@%s\\n\\t\"\n",name2,nr_args);
-  fprintf(out3,"\"_%s@%s:\\n\\t\"\n",name2,nr_args);
-  fprintf(out3,"\t\"pushl\t%%ebp\\n\\t\"\n");
-  fprintf(out3,"\t\"movl\t%%esp, %%ebp\\n\\t\"\n");
-  fprintf(out3,"\t\"mov\t$%d,%%eax\\n\\t\"\n",sys_call_idx);
-  fprintf(out3,"\t\"lea\t8(%%ebp),%%edx\\n\\t\"\n");
-  fprintf(out3,"\t\"int\t$0x2E\\n\\t\"\n");
-  fprintf(out3,"\t\"popl\t%%ebp\\n\\t\"\n");
-  fprintf(out3,"\t\"ret\t$%s\\n\\t\");\n\n",nr_args);
-#else
-  fprintf(out3,"__declspec(naked) __stdcall\n");
-  fprintf(out3,"%s(", name2);	// make it emit callconv, reval and full signature too
-  for (i=0; i*4 < nArgBytes; ++i) {
-    fprintf(out3,"int dummy%d", i);
-	if (((i+1)*4) < nArgBytes) fprintf(out3,",");
-  }
-  fprintf(out3,")\n{\n");
-  fprintf(out3,"\t__asm {\n");
-  fprintf(out3,"\t\tpush\tebp\n");
-  fprintf(out3,"\t\tmov\tebp, esp\n");
-  fprintf(out3,"\t\tmov\teax,%d\n",sys_call_idx);
-  fprintf(out3,"\t\tlea\tedx, 8[ebp]\n");
-  fprintf(out3,"\t\tint\t0x2E\n");
-  fprintf(out3,"\t\tpop\tebp\n");
-  fprintf(out3,"\t\tret\t%s\n",nr_args);
-  fprintf(out3,"\t}\n");
-  fprintf(out3,"}\n\n");
-#endif
-}
-
-int makeSystemServiceTable(FILE *in, FILE *out)
-{
-char    line [INPUT_BUFFER_SIZE];
-char    *s;
-char    *name;
-char    *name2;
-int     sys_call_idx;
-char    *nr_args;
-char    *stmp;
-
-	/*
-	 * Main SSDT Header
-	 */
-	fprintf(out,"// Machine generated, don't edit\n");
-	fprintf(out,"\n\n");
-
-	/*
-	 * First we build the Main SSDT
-	 */
-	fprintf(out,"\n\n\n");
-	fprintf(out,"SSDT MainSSDT[] = {\n");
-
-	for (	/* First system call has index zero */
-		sys_call_idx = 0;
-		/* Go on until EOF or read zero bytes */
-		(	(!feof(in))
-			&& (fgets(line, sizeof line, in) != NULL)
-			);
-		/* Next system call index */
-		sys_call_idx++
-		)
-	{
-		if ((s = (char *) strchr(line,'\r')) != NULL)
-		{
-			*s = '\0';
-		}
-		/*
-		 * Skip comments (#) and empty lines.
-		 */
-		s = & line[0];
-		if ((*s) != '#' && (*s) != '\0')
-		{
-			/* Extract the NtXXX name */
-			name = (char *)strtok(s," \t");
-			/* Extract the ZwXXX name */
-			name2 = (char *)strtok(NULL," \t");
-			//value = strtok(NULL," \t");
-			/* Extract the stack size */
-			nr_args = (char *)strtok(NULL," \t");
-			/*
-			 * Remove, if present, the trailing LF.
-			 */
-			if ((stmp = strchr(nr_args, '\n')) != NULL)
-			{
-				*stmp = '\0';
-			}
-#ifdef VERBOSE
-			printf("%3d \"%s\"\n",sys_call_idx,name);
-#endif
-
-			if (sys_call_idx > 0)
-			{
-				fprintf(out,",\n");
-			}
-			/*
-			 * Now write the current system call's name
-			 * in the service table.
-			 */
-			fprintf(out,"\t\t{ (ULONG)%s }",name);
-		}
-	}
-	/* Close the service table (C syntax) */
-	fprintf(out,"\n};\n");
-
-	/*
-	 * Now we build the Main SSPT
-	 */
-	rewind(in);
-	fprintf(out,"\n\n\n");
-	fprintf(out,"SSPT MainSSPT[] = {\n");
-
-	for (	/* First system call has index zero */
-		sys_call_idx = 0;
-		/* Go on until EOF or read zero bytes */
-		(	(!feof(in))
-			&& (fgets(line, sizeof line, in) != NULL)
-			);
-		/* Next system call index */
-		sys_call_idx++
-		)
-	{
-		if ((s = (char *) strchr(line,'\r')) != NULL)
-		{
-			*s = '\0';
-		}
-		/*
-		 * Skip comments (#) and empty lines.
-		 */
-		s = & line[0];
-		if ((*s) != '#' && (*s) != '\0')
-		{
-			/* Extract the NtXXX name */
-			name = (char *)strtok(s," \t");
-			/* Extract the ZwXXX name */
-			name2 = (char *)strtok(NULL," \t");
-			//value = strtok(NULL," \t");
-			/* Extract the stack size */
-			nr_args = (char *)strtok(NULL," \t");
-			/*
-			 * Remove, if present, the trailing LF.
-			 */
-			if ((stmp = strchr(nr_args, '\n')) != NULL)
-			{
-				*stmp = '\0';
-			}
-#ifdef VERBOSE
-			printf("%3d \"%s\"\n",sys_call_idx,name);
-#endif
-
-			if (sys_call_idx > 0)
-			{
-				fprintf(out,",\n");
-			}
-			/*
-			 * Now write the current system call's ID
-			 * in the service table along with its Parameters Size.
-			 */
-			fprintf(out,"\t\t{ %s }",nr_args);
-		}
-	}
-	/*
-	 * Close the service table (C syntax)
-	 */
-	fprintf(out,"\n};\n");
-
-	/*
-	 * We write some useful defines
-	 */
-	fprintf(out, "\n\n#define MIN_SYSCALL_NUMBER    0\n");
-	fprintf(out, "#define MAX_SYSCALL_NUMBER    %d\n", sys_call_idx-1);
-	fprintf(out, "#define NUMBER_OF_SYSCALLS    %d\n", sys_call_idx);
-
-	return(0);
-}
-
-
-int
-process(
-	FILE	* in,
-	FILE	* out,
-	FILE	* out2,
-	FILE	* out3
-	)
-{
-	char		line [INPUT_BUFFER_SIZE];
-	char		* s;
-	char		* name;		/* NtXXX name */
-	char		* name2;	/* ZwXXX name */
-	int		sys_call_idx;	/* NtXXX index number in the service table */
-	char		* nr_args;	/* stack_size / machine_word_size */
-	char		* stmp;
-
-	/*
-	 * NTDLL stubs file header
-	 */
-	fprintf(out,"// Machine generated, don't edit\n");
-	fprintf(out,"\n\n");
-
-	/*
-	 * NTOSKRNL Zw functions stubs header
-	 */
-	fprintf(out3,"// Machine generated by genntdll, don't edit\n");
-	fprintf(out3,"\n\n");
-	/*
-	 * Scan the database. DB is a text file; each line
-	 * is a record, which contains data for one system
-	 * function. Each record has three columns:
-	 *
-	 * NT_NAME	(e.g. NtCreateProcess)
-	 * ZW_NAME	(e.g. ZwCreateProcess)
-	 * STACK_SIZE	(in machine words: for x[3456]86
-	 * 		processors a machine word is 4 bytes)
-	 */
-	for (	/* First system call has index zero */
-		sys_call_idx = 0;
-		/* Go on until EOF or read zero bytes */
-		(	(!feof(in))
-			&& (fgets(line, sizeof line, in) != NULL)
-			);
-		/* Next system call index */
-		sys_call_idx++
-		)
-	{
-		/*
-		 * Remove, if present, the trailing CR.
-		 * (os specific?)
-		 */
-		if ((s = (char *) strchr(line,'\r')) != NULL)
-		{
-			*s = '\0';
-		}
-		/*
-		 * Skip comments (#) and empty lines.
-		 */
-		s = & line[0];
-		if ((*s) != '#' && (*s) != '\0')
-		{
-			/* Extract the NtXXX name */
-			name = (char *)strtok(s," \t");
-			/* Extract the ZwXXX name */
-			name2 = (char *)strtok(NULL," \t");
-			//value = strtok(NULL," \t");
-			/* Extract the stack size */
-			nr_args = (char *)strtok(NULL," \t");
-			/*
-			 * Remove, if present, the trailing LF.
-			 */
-			if ((stmp = strchr(nr_args, '\n')) != NULL)
-			{
-				*stmp = '\0';
-			}
-#ifdef VERBOSE
-			printf("%3d \"%s\"\n",sys_call_idx,name);
-#endif
-			/*
-			 * Write the NTDLL stub for the current
-			 * system call: NtXXX and ZwXXX symbols
-			 * are aliases.
-			 */
-			write_syscall_stub(out, out3, name, name2,
-					   nr_args, sys_call_idx);
-		}
-	}
-
-	return(0);
-}
-
-void usage(char * argv0)
-{
-	printf("Usage: %s sysfuncs.lst napi.c napi.h zw.c\n"
-	       "  sysfuncs.lst  system functions database\n"
-	       "  napi.c        NTDLL stubs\n"
-	       "  napi.h        NTOSKRNL service table\n"
-	       "  zw.c          NTOSKRNL Zw stubs\n",
-		argv0
-		);
-}
-
-int main(int argc, char* argv[])
-{
-	FILE	* in;	/* System calls database */
-	FILE	* out1;	/* NTDLL stubs */
-	FILE	* out2;	/* SERVICE_TABLE */
-	FILE	* out3;	/* NTOSKRNL Zw stubs */
-	int	ret;
-
-	if (argc != 5)
-	{
-		usage(argv[0]);
-		return(1);
-	}
-
-	in = fopen(argv[1],"rb");
-	if (in == NULL)
-	{
-		perror("Failed to open input file (system calls database)");
-		return(1);
-	}
-
-	out1 = fopen(argv[2],"wb");
-	if (out1 == NULL)
-	{
-		perror("Failed to open output file (NTDLL stubs)");
-		return(1);
-	}
-
-	out2 = fopen(argv[3],"wb");
-	if (out2 == NULL)
-	{
-		perror("Failed to open output file (NTOSKRNL service table)");
-		return(1);
-	}
-
-	out3 = fopen(argv[4],"wb");
-	if (out3 == NULL)
-	{
-		perror("Failed to open output file (NTOSKRNL Zw stubs)");
-		return(1);
-	}
-
-	ret = process(in,out1,out2,out3);
-	rewind(in);
-	ret = makeSystemServiceTable(in, out2);
-
-	fclose(in);
-	fclose(out1);
-	fclose(out2);
-	fclose(out3);
-
-	return(ret);
-}

msvc6/iface/native/makefile

@@ -1,22 +0,0 @@
-# $Id: makefile,v 1.1 2004/02/06 08:21:56 fireball Exp $
-#
-# ReactOS Operating System - MSVC6 Zw functions stubs to call generator
-#
-
-SYSTEM_CALLS_DB = ..\..\..\reactos\iface\native\sysfuncs.lst
-KERNEL_ZW_CALLS =..\..\ntoskrnl\nt_zw_msvc.c
-
-all: genntdll.exe $(KERNEL_ZW_CALLS)
-
-$(KERNEL_ZW_CALLS) : $(SYSTEM_CALLS_DB)
-	genntdll.exe $(SYSTEM_CALLS_DB) foo1 foo2 $(KERNEL_ZW_CALLS)
-	-@del foo1
-	-@del foo2
-
-genntdll.exe : genntdll.c
-
-clean:
-	-@del *.exe
-	-@del *.obj
-	-@del $(KERNEL_ZW_CALLS)
-	

msvc6/ntoskrnl/.cvsignore

@@ -1,4 +0,0 @@
-Debug
-Release
-nt_zw_msvc.c
-ntoskrnl.def

msvc6/ntoskrnl/ke_i386_bthread.c

@@ -1,167 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2000 David Welch <welch@cwcom.net>
- *
- *  Moved to MSVC-compatible inline assembler by Mike Nordell, 2003-12-25
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/* $Id: ke_i386_bthread.c,v 1.1 2004/02/06 08:21:56 fireball Exp $
- *
- * COPYRIGHT:       See COPYING in the top level directory
- * PROJECT:         ReactOS kernel
- * FILE:            ntoskrnl/ke/i386/bthread.S
- * PURPOSE:         Trap handlers
- * PROGRAMMER:      David Welch (david.welch@seh.ox.ac.uk)
- */
-
-/* INCLUDES ******************************************************************/
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-
-/* Values for contextflags */
-#define CONTEXT_i386    0x10000
-#ifndef CONTEXT_CONTROL
-#define CONTEXT_CONTROL         (CONTEXT_i386 | 1)	
-#endif
-#ifndef CONTEXT_INTEGER
-#define CONTEXT_INTEGER         (CONTEXT_i386 | 2)	
-#endif
-#ifndef CONTEXT_SEGMENTS
-#define CONTEXT_SEGMENTS        (CONTEXT_i386 | 4)	
-#endif
-#ifndef CONTEXT_FLOATING_POINT
-#define CONTEXT_FLOATING_POINT  (CONTEXT_i386 | 8)	
-#endif
-#ifndef CONTEXT_DEBUG_REGISTERS
-#define CONTEXT_DEBUG_REGISTERS (CONTEXT_i386 | 0x10)
-#endif
-#ifndef CONTEXT_FULL
-#define CONTEXT_FULL (CONTEXT_CONTROL | CONTEXT_INTEGER | CONTEXT_SEGMENTS)
-#endif
-	
-/* FUNCTIONS *****************************************************************/
-
-void KeReturnFromSystemCallWithHook();
-
-VOID PiBeforeBeginThread(CONTEXT c);
-
-/*
- *
- */
-
-__declspec(naked)
-VOID PsBeginThread(PKSTART_ROUTINE StartRoutine, PVOID StartContext)
-{
-	/*
-	 * This isn't really a function, we are called as the return address
-	 * of the context switch function
-	 */
-
-	/*
-	 * Do the necessary prolog after a context switch
-	 */
-	__asm
-	{
-	call	PiBeforeBeginThread
-
-	/*
-	 * Call the actual start of the thread
-	 */
-	// We must NOT use the arguments by name. VC then uses EBP-relative
-	// addressing, and with an EBP of 0 you can imagine what happens.
-	mov	ebx, 4[esp]			// StartRoutine
-	mov	eax, 8[esp]			// StartContext
-	push	eax
-	call	ebx                        /* Call the start routine */
-	add		esp, 4
-
-	/*
-	 * Terminate the thread
-	 */
-	push	eax
-	call	PsTerminateSystemThread
-	add		esp, 4
-
-	}
-
-	/* If that fails then bug check */
-	KeBugCheck(0);
-
-	/* And if that fails then loop */
-	for (;;)
-		; // forever
-}
-
-
-__declspec(naked)
-VOID PsBeginThreadWithContextInternal(VOID)
-{
-	/*
-	 * This isn't really a function, we are called as the return
-	 * address of a context switch
-	 */
-
-	/*
-	 * Do the necessary prolog before the context switch
-	 */
-	__asm
-	{
-	call	PiBeforeBeginThread
-
-	/*
-	 * Load the context flags.
-	 */
-	pop		ebx
-	
-	/*
-	 * Load the debugging registers
-	 */
-	test	ebx, (CONTEXT_DEBUG_REGISTERS & ~CONTEXT_i386)
-	jz	L1
-	pop		eax	__asm	mov		dr0, eax
-	pop		eax	__asm	mov		dr1, eax
-	pop		eax	__asm	mov		dr2, eax
-	pop		eax	__asm	mov		dr3, eax
-	pop		eax	__asm	mov		dr6, eax
-	pop		eax	__asm	mov		dr7, eax
-	jmp	L3
-L1:
-	add		esp, 24
-L3:
-	
-	/*
-	 * Load the floating point registers
-	 */
-	mov		eax, HardwareMathSupport
-	test	eax,eax
-	jz	L2
-	test	ebx, (CONTEXT_FLOATING_POINT & ~CONTEXT_i386)
-	jz	L2
-	frstor	[esp]
-L2:
-	add		esp, 112
-
-	/* Load the rest of the thread's user mode context. */
-	mov		eax, 0
-	jmp		KeReturnFromSystemCallWithHook
-	}
-}
-

msvc6/ntoskrnl/ke_i386_irqhand.c

@@ -1,114 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2000 David Welch <welch@cwcom.net>
- *
- *  Moved to MSVC-compatible inline assembler by Mike Nordell, 2003-12-26
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/*
- * FILE:            ntoskrnl/ke/i386/vm86_sup.S
- * PURPOSE:         V86 mode support
- * PROGRAMMER:      David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- *                  Created 09/10/00
- */
-
-/* INCLUDES ******************************************************************/
-
-#pragma hdrstop
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-#include <internal/v86m.h>
-#include <ntos/tss.h>
-#include <internal/trap.h>
-#include <internal/ps.h>
-
-#include <roscfg.h>
-#include <internal/ntoskrnl.h>
-#include <internal/i386/segment.h>
-
-// no arg-list, but asm doesn't care anyway
-void KiInterruptDispatch();
-
-
-#define DEFINE_INT_HANDLER(N)			\
-__declspec(naked)						\
-void irq_handler_##N()					\
-{										\
-	__asm	pushad						\
-	__asm	push	ds					\
-	__asm	push	es					\
-	__asm	push	fs					\
-	__asm	mov		eax, 0xceafbeef		\
-	__asm	push	eax					\
-	__asm	mov		ax, KERNEL_DS		\
-	__asm	mov		ds, ax				\
-	__asm	mov		es, ax				\
-	__asm	mov		ax, PCR_SELECTOR	\
-	__asm	mov		fs, ax				\
-	__asm	push	esp					\
-	__asm	push	N					\
-	__asm	call	KiInterruptDispatch	\
-	__asm	pop		eax					\
-	__asm	pop		eax					\
-	__asm	pop		eax					\
-	__asm	pop		fs					\
-	__asm	pop		es					\
-	__asm	pop		ds					\
-	__asm	popad						\
-	__asm	iretd						
-// NOTE: The inline assembler can't deal with having the final brace,
-// ending the function, on the same line as an __asm, why there is
-// none here and it MUST be added when using the macro!
-
-DEFINE_INT_HANDLER(0)
-}
-DEFINE_INT_HANDLER(1)
-}
-DEFINE_INT_HANDLER(2)
-}
-DEFINE_INT_HANDLER(3)
-}
-DEFINE_INT_HANDLER(4)
-}
-DEFINE_INT_HANDLER(5)
-}
-DEFINE_INT_HANDLER(6)
-}
-DEFINE_INT_HANDLER(7)
-}
-DEFINE_INT_HANDLER(8)
-}
-DEFINE_INT_HANDLER(9)
-}
-DEFINE_INT_HANDLER(10)
-}
-DEFINE_INT_HANDLER(11)
-}
-DEFINE_INT_HANDLER(12)
-}
-DEFINE_INT_HANDLER(13)
-}
-DEFINE_INT_HANDLER(14)
-}
-DEFINE_INT_HANDLER(15)
-}
-

msvc6/ntoskrnl/ke_i386_multiboot.c

@@ -1,655 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2003 Mike Nordell
- *  Based on multiboot.S (no copyright note present), but so heavily
- *  modified that it bears close to no resemblance to the original work.
- *
- *  MSVC compatible combination of plain C and inline assembler to:
- *  1 Relocated all the sections in the kernel - something I feel the
- *    bootloader should have done, but multiboot being just a "raw image"
- *    loader, it unfortunately had to be done here - in-place.
- *  2 Set up page directories and stuff.
- *  3 Load IDT, GDT and turn on paging, making us execute at the intended
- *    target address (as if the image was PE-loaded and parsed into that addr.)
- *  4 Call _main, and let the rest of the startup run...
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-//
-// TODO: Fix the MP parts
-//
-
-/* INCLUDES ******************************************************************/
-
-#pragma hdrstop
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-#include <pe.h>
-
-#include <roscfg.h>
-#include <internal/ntoskrnl.h>
-#include <internal/i386/segment.h>
-#include <internal/ps.h>
-#include <internal/ldr.h>
-
-
-// some notes:
-// The MSVC linker (by defult) emits no special .bss section, but uses the data
-// section with a rawsize smaller than virtualsize. The "slack" is BSS.
-
-
-//////////////////////////////////////////////////////////////////
-// Some macros we need
-
-// some stuff straight from freeloaders multiboot.h
-#define MULTIBOOT_HEADER_MAGIC (0x1BADB002)
-#define MULTIBOOT_HEADER_FLAGS (0x00010003)
-
-#define TARGET_LOAD_ADDR  0x00200000
-#define BASE_TO_PHYS_DIST (KERNEL_BASE - TARGET_LOAD_ADDR)
-
-#define V2P(x)   (x - BASE_TO_PHYS_DIST)
-
-
-#ifdef MP
-
-#define AP_MAGIC (0x12481020)
-
-#endif /* MP */
-
-
-
-void  initialize_page_directory(void);
-
-void* relocate_pointer_log_to_phys(const void* p)
-{
-	// DON'T CALL this function until relocation of .data and/or .rdata,
-	// is completed - but still be sure that we have not yet enabled paging!
-	return (void*)((DWORD)p - BASE_TO_PHYS_DIST);
-}
-
-
-
-#ifdef _DEBUG
-
-// Macro to emit one character to Bochs debug-port (0x9e).
-// We need to do it this way, since at this point of the startup, obviously
-// we have neither HAL nor DbgPrint support.
-#define BOCHS_OUT_CHAR(c1)      __asm push eax __asm push edx __asm mov dx, 0xe9 __asm mov al, c1 __asm out dx, al __asm pop edx __asm pop eax
-
-void boch_out_hex_digit(unsigned char ch1)
-{
-	if (ch1 <= 9) { ch1 += '0'; } else { ch1 += 'a' - 10; }
-	BOCHS_OUT_CHAR(ch1)
-}
-
-void bochs_dump_hex(DWORD p)
-{
-	unsigned char ch3 = (unsigned char)((p >> 28) & 0x0f);
-	unsigned char cl3 = (unsigned char)((p >> 24) & 0x0f);
-	unsigned char ch2 = (unsigned char)((p >> 20) & 0x0f);
-	unsigned char cl2 = (unsigned char)((p >> 16) & 0x0f);
-	unsigned char ch1 = (unsigned char)((p >> 12) & 0x0f);
-	unsigned char cl1 = (unsigned char)((p >>  8) & 0x0f);
-	unsigned char ch0 = (unsigned char)((p >>  4) & 0x0f);
-	unsigned char cl0 = (unsigned char)((p >>  0) & 0x0f);
-	BOCHS_OUT_CHAR('0') BOCHS_OUT_CHAR('x')
-	boch_out_hex_digit(ch3);
-	boch_out_hex_digit(cl3);
-	boch_out_hex_digit(ch2);
-	boch_out_hex_digit(cl2);
-	boch_out_hex_digit(ch1);
-	boch_out_hex_digit(cl1);
-	boch_out_hex_digit(ch0);
-	boch_out_hex_digit(cl0);
-	BOCHS_OUT_CHAR('\n')
-}
-
-static void bochs_out_string(const char* s /* logical address! */)
-{
-	s = relocate_pointer_log_to_phys(s);
-	__asm
-	{
-		pushad
-		mov dx, 0xe9
-		mov ebx, s
-L1:
-		cmp byte ptr[ebx], 0
-		je end
-		mov al, [ebx]
-		out dx, al
-		inc ebx
-		jmp L1
-end:
-		popad
-	}
-}
-
-#else
-
-#define BOCHS_OUT_CHAR(c1)
-#define bochs_dump_hex(VAL)
-#define bochs_out_string(STR)
-
-#endif	// _DEBUG
-
-
-//////////////////////////////////////////////////////////////////
-
-typedef char kernel_page_t[4096];
-
-// Use 4096 (pagesize) more bytes that actually needed for each *_holder,
-// to be able to make sure that the other stuff is page aligned.
-// No other way to do this portably... :-(
-//
-// TODO: Consider allocating just one large block of BSS memory here, align
-// just the first pointer, and then get the other ones just as offsets from
-// this (now-aligned) pointer. That way we could get away with wasting just
-// one page of memory, instead of 4 (like 16KB would matter... but still)
-static kernel_page_t*  startup_pagedirectory_holder[1024 * 2];
-static kernel_page_t*  lowmem_pagetable_holder[1024 * 2];
-static kernel_page_t*  kernel_pagetable_holder[32*1024 + 1];
-static __int32         kpcr_pagetable_holder[4096/4 * 2];
-
-#ifdef MP
-char apic_pagetable[4096];
-#endif /* MP */
-
-__int32 unmap_me[4096/4];
-__int32 unmap_me2[4096/4];
-__int32 unmap_me3[4096/4];
-
-__int32 init_stack[3*4096/4];
-int     init_stack_top;
-
-
-__int32 trap_stack[3*4096/4];
-int     trap_stack_top;
-
-
-
-void _main();
-// lie a bit about types - since C is basically typeless anyway, it
-// doesn't really matter what type we say it is here...
-extern int KiGdtDescriptor;
-extern int KiIdtDescriptor;
-
-
-
-	/*
-	 * This is called by the realmode loader, with protected mode
-	 * enabled, paging disabled and the segment registers pointing
-	 * a 4Gb, 32-bit segment starting at zero.
-	 *
-	 *    EAX = Multiboot magic or application processor magic
-	 *
-	 *    EBX = Points to a structure in lowmem with data from the
-	 *    loader
-	 */
-#pragma intrinsic(memset)
-
-
-// We need to implement this ourself, to be able to get to it by short call's
-void our_memmove(void* pDest, const void* pSrc, DWORD size)
-{
-	      char* pD = (char*)pDest;
-	const char* pS = (char*)pSrc;
-	if (pDest < pSrc)
-	{
-		while (size--)
-		{
-			*pD++ = *pS++;
-		}
-	}
-	else if (pSrc < pDest)
-	{
-		while (size--)
-		{
-			pD[size] = pS[size];
-		}
-	}
-}
-void dummy_placeholder(void)
-{
-	// NOTE: This function MUST be placed JUST AFTER MultibootStub in memory.
-	// Yes, it's BEFORE it in this file, but linkorder.txt fixes this for us.
-}
-
-
-// This one is needed, since the boot loader hasn't relocated us
-__declspec(naked)
-void MultibootStub()
-{
-	__asm
-	{
-		jmp		_multiboot_entry
-		// This sucks, I know...
-#define EMIT_DWORD(x) __asm __emit ((x) >> 0) & 0xff __asm _emit ((x) >> 8) & 0xff __asm _emit ((x) >> 16) & 0xff __asm _emit ((x) >> 24) & 0xff
-		ALIGN 4
-		EMIT_DWORD(MULTIBOOT_HEADER_MAGIC)
-		EMIT_DWORD(MULTIBOOT_HEADER_FLAGS)
-		EMIT_DWORD(-(MULTIBOOT_HEADER_MAGIC + MULTIBOOT_HEADER_FLAGS))
-		EMIT_DWORD(TARGET_LOAD_ADDR + 0x0400 + 0x04)
-		// Now just make something up, since there is no way we can know, beforehand,
-		// where any BSS data is...
-		EMIT_DWORD((TARGET_LOAD_ADDR))
-		EMIT_DWORD((TARGET_LOAD_ADDR + 1*1024*1024)) /* assume ntoskrnel.exe is < 1MB! */
-		EMIT_DWORD((TARGET_LOAD_ADDR + 2*1024*1024)) /* just to have something, let's say BSS is 1MB too */
-		/* This is *REALLY* ugly! If MultibootStub is *EVER* at   */
-		/* any other offset, this will crash like crazy! */
-		/* 0x0400 is the file alignment of the binary (ntoskrnl.exe) */
-		EMIT_DWORD((TARGET_LOAD_ADDR + 0x0400))	// entry_addr
-
-_multiboot_entry:
-
-		cld		// just for good measure
-	}
-
-	{
-		/* Save the multiboot or application processor magic */
-		DWORD saved_eax;
-		DWORD saved_ebx;
-		__asm	mov	saved_eax, eax
-		__asm	mov	saved_ebx, ebx
-
-//		bochs_out_string("MultibootStub()\n");
-
-		// OK, time to relocate the brute-loaded image in-place...
-		// If we don't watch it, we will overwrite ourselves here - imagine
-		// the fireworks! :-) That's why the function dummy_placeholder()
-		// MUST be placed JUST JUST AFTER this function.
-
-		{
-		PIMAGE_NT_HEADERS     NtHeader = RtlImageNtHeader((PVOID)TARGET_LOAD_ADDR);
-		PIMAGE_SECTION_HEADER Section  = IMAGE_FIRST_SECTION(NtHeader);
-		const int count = NtHeader->FileHeader.NumberOfSections;
-		int i;
-		Section += count - 1;	// make it point to the last section
-		// NOTE: We MUST walk the sections "backwards".
-		for (i = count-1; i >= 0; --i, --Section)
-		{
-			DWORD dwSrc = TARGET_LOAD_ADDR + Section->PointerToRawData;
-			DWORD dwDst = TARGET_LOAD_ADDR + Section->VirtualAddress;
-			DWORD dwSiz = Section->SizeOfRawData;
-			const char* pEndThisFunc;
-
-			if (dwSrc == dwDst)
-			{
-				continue;
-			}
-
-//bochs_out_string("MultibootStub: relocating section\n");
-
-			if (Section->Characteristics & IMAGE_SCN_MEM_EXECUTE)
-			{
-				// can't get a pointer to a label from plain C :-(
-				__asm mov	pEndThisFunc, offset dummy_placeholder
-				pEndThisFunc -= BASE_TO_PHYS_DIST;
-				if (dwDst < (DWORD)pEndThisFunc)
-				{
-					// We must not move the code from under our feet!
-					// This can only happen in the code segment - the first segment
-					DWORD diff = (DWORD)pEndThisFunc - dwDst;
-					dwDst += diff;
-					dwSrc += diff;
-					dwSiz -= diff;
-				}
-			}
-
-			// obviously we must use memmove, since memory can overlap
-			our_memmove((void*)dwDst, (void*)dwSrc, dwSiz);
-
-			// While at it, we might as well zero any uninitialized data in the section...
-			if (Section->SizeOfRawData < Section->Misc.VirtualSize)
-			{
-				memset((char*)(Section->VirtualAddress + Section->SizeOfRawData + TARGET_LOAD_ADDR),
-					   0,
-					   Section->Misc.VirtualSize - Section->SizeOfRawData);
-			}
-		}
-
-		// Now all sections are relocated to their intended in-memory layout,
-		// but we are still running int the low TARGET_LOAD_ADDR memory.
-
-		{
-			// Time to jump to the real startup, the entry-point function.
-			// We must do this using assembler, since both eax and ebx are assumed
-			// to hold some magic values.
-			typedef VOID (STDCALL* pfn_t)(PPEB);
-			pfn_t pfn = (pfn_t)(NtHeader->OptionalHeader.AddressOfEntryPoint + TARGET_LOAD_ADDR);
-#if 1
-			__asm	mov eax, saved_eax
-			__asm	mov ebx, saved_ebx
-			__asm	mov ecx, pfn
-			__asm	jmp ecx
-#else
-			__asm	mov ebx, saved_ebx
-			(*pfn)((PPEB)saved_eax);
-#endif
-		}
-		}
-	}
-}
-
-
-// TMN: TODO: Convert this to the extent possible to plain C code
-// Due to the "magic" above, we enter this function with all kernel sections
-// properly relocated wrt. offsets from start-of-mem. But, we are still running
-// without paging, meaning that the address that is to be KERNEL_BASE+xyz is
-// currently still TARGET_LOAD_ADDR+xyz.
-// We get aways with a few of the functions call here since they are near calls
-// (PC-relative), but don't even _think_ about calling any other functions
-// until we have turned on paging!
-VOID STDCALL
-NtProcessStartup(
-	IN	PPEB	Peb
-	)
-{
-	DWORD saved_ebx;
-	DWORD saved_eax;
-	__asm mov saved_ebx, ebx
-	__asm mov saved_eax, eax
-
-	bochs_out_string("NtProcessStartup: Just entered\n");
-
-#ifdef MP
-	if (saved_eax != AP_MAGIC)
-	{
-#endif /* MP */
-
-		bochs_out_string("NtProcessStartup: Calling initialize_page_directory()\n");
-
-		initialize_page_directory();	// Initialize the page directory
-
-		bochs_out_string("NtProcessStartup: Page directory initialized\n");
-
-#ifdef  MP
-
-		__asm
-		{
-			/*
-			 * Initialize the page table that maps the APIC register address space
-			 */
-			 
-			/* 
-			 * FIXME: APIC register address space can be non-standard so do the 
-			 * mapping later 
-			 */
-			mov		esi, V2P(apic_pagetable)
-			mov		edi, 0
-			mov		eax, 0xFEC0001B
-			mov		[esi+edi], eax
-			mov		edi, 0x800
-			mov		eax, 0xFEE0001B
-			mov		[esi+edi], eax
-		}
-	}
-
-#endif /* MP */
-
-	{
-		bochs_out_string("NtProcessStartup: Enabling paging...\n");
-
-		/*
-		 * Enable paging and set write protect
-		 * bit 31: PG, bit 16: WP
-		 */
-		__asm	mov		eax, cr0
-		__asm	or		eax, 0x80010000
-		__asm	mov		cr0, eax
-
-		bochs_out_string("NtProcessStartup: Paging enabled!\n");
-		bochs_out_string("NtProcessStartup: But we're still at the \"low\" address\n");
-
-		/*
-		 * Do an absolute jump because we now want to execute above KERNEL_BASE
-		 */
-		__asm	mov		eax, offset l2_
-		__asm	jmp		eax
-	}
-
-l2_:
-
-bochs_out_string("We have now left \"low\" memory, and is flying at an altitude of...\n");
-bochs_out_string("OK, we're not flying, we're just executing above KERNEL_BASE\n");
-
-	/*
-	 * Load the GDTR and IDTR with new tables located above
-	 * KERNEL_BASE
-	 */
-
-#ifdef _DEBUG
-	{
-		DWORD val = (DWORD)&KiGdtDescriptor;
-		bochs_out_string("&KiGdtDescriptor: ");
-		bochs_dump_hex(val);
-
-		val = (DWORD)&KiIdtDescriptor;
-		bochs_out_string("&KiIdtDescriptor: ");
-		bochs_dump_hex(val);
-	}
-#endif
-
-bochs_out_string("Loading GDT and IDT...\n");
-
-	/* FIXME: Application processors should have their own GDT/IDT */
-	__asm	lgdt	KiGdtDescriptor
-	__asm	lidt	KiIdtDescriptor
-
-bochs_out_string("GDT and IDT loaded\n");
-
-	__asm
-	{
-		/*
-		 * Reload the data segment registers 
-		 */
-		mov		eax, KERNEL_DS
-		mov		ds, ax
-		mov		es, ax
-		mov		gs, ax
-		mov		ss, ax
-		mov		eax, 0
-		mov		fs, ax
-	}
-
-bochs_out_string("NtProcessStartup: segment registers loaded\n");
-
-#ifdef MP
-
-	if (saved_eax == AP_MAGIC)
-	{
-		__asm
-		{
-			/*
-			 * This is an application processor executing
-			 */
-
-			/*
-			 * Initialize EFLAGS
-			 */
-			push	0
-			popfd
-
-			/*
-			 * Call the application processor initialization code
-			 */
-			push	0
-			push	offset l7_
-			push	KERNEL_CS
-			push	KiSystemStartup
-			retf
-
-			/*
-			 * Catch illegal returns from KiSystemStartup
-			 */
-l7_:
-			pop		eax
-		}
-
-		KeBugCheck(0);
-
-		for (;;)
-			;	/*forever */
-	}
-
-#endif /* MP */
-
-bochs_out_string("Loading fs with PCR_SELECTOR\n");
-
-	/* Load the PCR selector */
-	__asm	mov		eax, PCR_SELECTOR
-	__asm	mov		fs, ax
-
-bochs_out_string("Loading esp with init_stack_top    : "); bochs_dump_hex((DWORD)&init_stack_top);
-bochs_out_string("Just for interest, init_stack is at: "); bochs_dump_hex((DWORD)init_stack);
-bochs_out_string("Meaing the init_stack in bytes is  : "); bochs_dump_hex((DWORD)&init_stack_top - (DWORD)init_stack);
-
-
-	/* Load the initial kernel stack */
-	__asm	mov		esp, offset init_stack_top
-
-bochs_out_string("Loaded esp with init_stack_top\n");
-
-	/*
-	 * Initialize EFLAGS
-	 */
-	__asm	push	0
-	__asm	popfd
-
-bochs_out_string("Loaded eflags\n");
-
-		/*
-		 * Call the main kernel initialization
-		 */
-bochs_out_string("TMN: Calling _main...\n");
-
-	__asm
-	{
-		xor		ebp,ebp
-		push	ebx
-		push	edx
-		push	offset l5_
-		push	KERNEL_CS
-		push	offset _main
-		retf
-	
-	/*
-	 * Catch illegal returns from main, try bug checking the system,
-	 * if that fails then loop forever.
-	 */
-l5_:
-		pop		eax
-		pop		eax
-
-	} // end of __asm block
-
-bochs_out_string("TMN: Back from _main ?! Let's crash!\n");
-
-	KeBugCheck(0);
-
-	for (;;)
-		;	/*forever */
-}
-
-
-void initialize_page_directory(void)
-{
-	/*
-	 * Initialize the page directory
-	 */
-
-	// First convert the pointers from the virtual address the compiler generated
-	// code thinks we are at, to the currently active physical address we actually
-	// got loaded into by the loader. At this point we have been relocated, so
-	// that there is a 1:1 mapping between KERNEL_BASE+n and TARGET_LOAD_ADDR+n.
-
-	kernel_page_t** startup_pagedirectory = startup_pagedirectory_holder;
-	kernel_page_t** lowmem_pagetable      = lowmem_pagetable_holder;
-	kernel_page_t** kernel_pagetable      = kernel_pagetable_holder;
-	__int32*        kpcr_pagetable        = kpcr_pagetable_holder;
-
-	bochs_out_string("startup_pagedirectory before reloc: ");
-	bochs_dump_hex((DWORD)startup_pagedirectory);
-
-	startup_pagedirectory = (kernel_page_t**)relocate_pointer_log_to_phys(startup_pagedirectory);
-	lowmem_pagetable      = (kernel_page_t**)relocate_pointer_log_to_phys(lowmem_pagetable);
-	kernel_pagetable      = (kernel_page_t**)relocate_pointer_log_to_phys(kernel_pagetable);
-	kpcr_pagetable        = (__int32*)       relocate_pointer_log_to_phys(kpcr_pagetable);
-
-	bochs_out_string("startup_pagedirectory after reloc : ");
-	bochs_dump_hex((DWORD)startup_pagedirectory);
-
-	// Now align the pointers to PAGE_SIZE...
-	startup_pagedirectory = (kernel_page_t**)(((ULONG_PTR)startup_pagedirectory + 4095) & ~4095);
-	lowmem_pagetable      = (kernel_page_t**)(((ULONG_PTR)lowmem_pagetable      + 4095) & ~4095);
-	kernel_pagetable      = (kernel_page_t**)(((ULONG_PTR)kernel_pagetable      + 4095) & ~4095);
-	kpcr_pagetable        = (__int32* )      (((ULONG_PTR)kpcr_pagetable        + 4095) & ~4095);
-
-#ifdef _DEBUG
-	bochs_out_string("startup_pagedirectory aligned     : ");
-	bochs_dump_hex((DWORD)startup_pagedirectory);
-#endif
-
-	// Ugly macros, I know...
-#define DEST(PAGE)   startup_pagedirectory[(PAGE) + 0xc00 / 4]
-#define SRC(PAGE)    (kernel_page_t*)((char*)kernel_pagetable + (PAGE)*4096 + 0x7)
-
-	startup_pagedirectory[0] = (kernel_page_t*)((char*)lowmem_pagetable + 0x7);
-
-	{
-		unsigned int i;
-		for (i=0; i<32; ++i)
-		{
-			DEST(i) = SRC(i);
-		}
-	}
-
-	DEST( 64) = (kernel_page_t*)((char*)lowmem_pagetable      + 0x7);
-	DEST(192) = (kernel_page_t*)((char*)startup_pagedirectory + 0x7);
-#ifdef MP
-	DEST(251) = (kernel_page_t*)((char*)apic_pagetable        + 0x7);
-#endif /* MP */
-	DEST(252) = (kernel_page_t*)((char*)kpcr_pagetable        + 0x7);
-
-
-	{
-		unsigned int i;
-		/* Initialize the page table that maps low memory */
-		for (i=0; i<1024; ++i) {
-			lowmem_pagetable[i] = (kernel_page_t*)(i*4096 + 7);
-		}
-
-		/* Initialize the page table that maps kernel memory */
-		for (i=0; i<6144/4 /* 1536 pages = 6MB */; ++i) {
-			kernel_pagetable[i] = (kernel_page_t*)(i*4096 + TARGET_LOAD_ADDR + 0x7);
-		}
-
-		/* Initialize the page table that maps the initial KPCR (at FF000000) */
-		kpcr_pagetable[0] = 0x1007;
-	}
-
-	/*
-	 * Set up the PDBR
-	 */	
-	__asm	mov		eax, startup_pagedirectory
-	__asm	mov		cr3, eax
-}
-

msvc6/ntoskrnl/ke_i386_stkswitch.c

@@ -1,110 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2000 David Welch <welch@cwcom.net>
- *
- *  Moved to MSVC-compatible inline assembler by Mike Nordell, 2003-12-26
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/*
- * FILE:            ntoskrnl/ke/i386/vm86_sup.S
- * PURPOSE:         V86 mode support
- * PROGRAMMER:      David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- *                  Created 09/10/00
- */
-
-/* INCLUDES ******************************************************************/
-
-#pragma hdrstop
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-#include <internal/v86m.h>
-#include <ntos/tss.h>
-//#include <ntos/service.h>
-#include <internal/trap.h>
-#include <internal/ps.h>
-
-#include <roscfg.h>
-#include <internal/ntoskrnl.h>
-#include <internal/i386/segment.h>
-
-
-void KeReturnFromSystemCall();
-
-/*
- * FUNCTION:	 KeStackSwitchAndRet
- * PURPOSE:	 Switch to a new stack and return from the first frame on
- *               the new stack which was assumed to a stdcall function with
- *               8 bytes of arguments and which saved edi, esi and ebx.
- */
-__declspec(naked)
-VOID STDCALL
-KeStackSwitchAndRet(PVOID NewStack)
-{
-	__asm
-	{
-		push	ebp
-		mov		ebp, esp
-
-		cli
-
-		mov		esp, NewStack
-
-		sti
-
-		pop		edi
-		pop		esi
-		pop		ebx
-
-		pop		ebp
-		ret		8
-	}
-}
-
-__declspec(naked)
-VOID STDCALL
-KePushAndStackSwitchAndSysRet(ULONG Push, PVOID NewStack)
-{
-	__asm
-	{
-		push	ebp
-		mov		ebp, esp
-
-		push	ebx
-		push	esi
-		push	edi
-
-		cli
-
-		push	8[ebp]
-
-		mov		ebx, fs:KPCR_CURRENT_THREAD
-		mov		KTHREAD_CALLBACK_STACK[ebx], esp
-		mov		esp, 12[ebp]
-
-		sti
-
-		push	0
-		call	KeLowerIrql
-
-		jmp		KeReturnFromSystemCall
-	}
-}

msvc6/ntoskrnl/ke_i386_syscall.c

@@ -1,325 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2000  David Welch <welch@cwcom.net>
- *
- *  Converted to MSVC-compatible inline assembler by Mike Nordell, 2003.
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/*
- * FILE:            MSVC6/ntoskrnl/ke_i386_syscall.c
- *                  based on ntoskrnl/ke/i386/syscall.s
- * PURPOSE:         syscall dispatching and support
- * PROGRAMMER:      David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- *                  Created 09/10/00
- */
-
-/* INCLUDES ******************************************************************/
-
-#pragma hdrstop
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-#include <internal/v86m.h>
-#include <ntos/tss.h>
-//#include <ntos/service.h>
-#include <internal/trap.h>
-#include <internal/ps.h>
-
-#include <roscfg.h>
-#include <internal/ntoskrnl.h>
-#include <internal/i386/segment.h>
-
-
-#define KernelMode  (0)
-#define UserMode    (1)
-
-
-// TMN: Replicated here to reduce mess-time
-#ifdef STATUS_INVALID_SYSTEM_SERVICE
-#undef STATUS_INVALID_SYSTEM_SERVICE
-#endif
-#define STATUS_INVALID_SYSTEM_SERVICE               0xc000001c
-
-
-/*
- *
- */
-
-void KiServiceCheck (ULONG Nr);
-ULONG KiAfterSystemCallHook(ULONG NtStatus, PKTRAP_FRAME TrapFrame);
-VOID KiSystemCallHook(ULONG Nr, ...);
-
-void KeReturnFromSystemCallWithHook();
-void KeReturnFromSystemCall();
-
-
-__declspec(naked)
-void interrupt_handler2e(void)
-{
-	__asm
-	{
-		/* Construct a trap frame on the stack */
-
-		/* Error code */
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		push	edi
-		push	fs
-		/* Load PCR selector into fs */
-		mov		ebx, PCR_SELECTOR
-		mov		fs, bx
-
-		/* Save the old exception list */
-		mov		ebx, fs:KPCR_EXCEPTION_LIST
-		push	ebx
-		/* Set the exception handler chain terminator */
-		mov		dword ptr fs:KPCR_EXCEPTION_LIST, 0xffffffff
-		/* Get a pointer to the current thread */
-		mov		esi, fs:KPCR_CURRENT_THREAD
-		/* Save the old previous mode */
-		xor		ebx,ebx
-		mov		bl, ss:KTHREAD_PREVIOUS_MODE[esi]
-		push	ebx
-		/* Set the new previous mode based on the saved CS selector */
-		mov		ebx, 0x24[esp]
-		and		ebx, 0x0000FFFF
-		cmp		ebx, KERNEL_CS
-#if 0
-		// TODO: Verify implementation change and use this code path
-		// to remove two conditional jumps.
-		setnz	bl
-		mov		ss:KTHREAD_PREVIOUS_MODE[esi], bl
-#else
-		jne		L1
-		mov		ss:KTHREAD_PREVIOUS_MODE[esi], KernelMode
-		jmp		L3
-L1:
-		mov		ss:KTHREAD_PREVIOUS_MODE[esi], UserMode
-L3:
-
-#endif
-		/* Save other registers */	   
-		push	eax
-		push	ecx
-		push	edx
-		push	ds
-		push	es
-		push	gs
-		push	0     /* DR7 */
-		push	0     /* DR6 */
-		push	0     /* DR3 */
-		push	0     /* DR2 */
-		push	0     /* DR1 */
-		push	0     /* DR0 */
-		push	0     /* XXX: TempESP */
-		push	0     /* XXX: TempCS */
-		push	0     /* XXX: DebugPointer */
-		push	0     /* XXX: DebugArgMark */
-		mov		ebx, 0x60[esp]
-		push	ebx   /* DebugEIP */
-		push	ebp   /* DebugEBP */
-
-		/* Load the segment registers */
-		mov		bx, KERNEL_DS
-		mov		ds, bx
-		mov		es, bx
-		mov		gs, bx
-
-		/* 
-		 * Save the old trap frame pointer over where we would save the EDX
-		 * register.
-		 */
-		mov		ebx, KTHREAD_TRAP_FRAME[esi]
-		mov		0x3C[esp], ebx
-
-		/* Save a pointer to the trap frame in the TCB */
-		mov		KTHREAD_TRAP_FRAME[esi], esp
-
-		/*  Set ES to kernel segment  */
-		mov		bx, KERNEL_DS
-		mov		es, bx
-
-		/*  Allocate new Kernel stack frame  */
-		mov		ebp, esp
-
-		/*  Users's current stack frame pointer is source  */
-		mov		esi, edx
-
-		/*  Determine system service table to use  */
-		cmp		eax, 0x0fff
-		ja		new_useShadowTable
-
-		/*  Check to see if EAX is valid/inrange  */
-		cmp		eax, es:KeServiceDescriptorTable + 8
-		jbe		new_serviceInRange
-		mov		eax, STATUS_INVALID_SYSTEM_SERVICE
-		jmp		KeReturnFromSystemCall
-
-new_serviceInRange:
-
-		/*  Allocate room for argument list from kernel stack  */
-		mov		ecx, es:KeServiceDescriptorTable + 12
-		mov		ecx, es:[ecx + eax * 4]
-		sub		esp, ecx
-
-		/*  Copy the arguments from the user stack to the kernel stack  */
-		mov		edi, esp
-		cld
-		repe	movsb
-
-		/*  DS is now also kernel segment  */
-		mov		ds, bx
-
-		/* Call system call hook */
-		push	eax
-		call	KiSystemCallHook
-		pop		eax
-
-		/*  Make the system service call  */
-		mov		ecx, es:KeServiceDescriptorTable
-		mov		eax, es:[ecx + eax * 4]
-		call	eax
-
-#if CHECKED
-		/*  Bump Service Counter  */
-#endif
-
-		/*  Deallocate the kernel stack frame  */
-		mov		esp, ebp
-
-		/* Call the post system call hook and deliver any pending APCs */
-		push	ebp
-		push	eax
-		call	KiAfterSystemCallHook
-		add		esp, 8
-
-		jmp  KeReturnFromSystemCall
-
-new_useShadowTable:
-
-		sub		eax, 0x1000
-
-		/*  Check to see if EAX is valid/inrange  */
-		cmp		eax, es:KeServiceDescriptorTableShadow + 24
-		jbe		new_shadowServiceInRange
-		mov		eax, STATUS_INVALID_SYSTEM_SERVICE
-		jmp		KeReturnFromSystemCall
-
-new_shadowServiceInRange:
-
-		/*  Allocate room for argument list from kernel stack  */
-		mov		ecx, es:KeServiceDescriptorTableShadow + 28
-		mov		ecx, es:[ecx + eax * 4]
-		sub		esp, ecx
-
-		/*  Copy the arguments from the user stack to the kernel stack  */
-		mov		edi, esp
-		cld
-		repe	movsb
-
-		/*  DS is now also kernel segment  */
-		mov		ds, bx
-
-		/* Call system call hook */
-//		pushl %eax
-//		call _KiSystemCallHook
-//		popl %eax
-
-		/* Call service check routine */
-		push	eax
-		call	KiServiceCheck
-		pop		eax
- 
-		/*  Make the system service call  */
-		mov		ecx, es:KeServiceDescriptorTableShadow + 16
-		mov		eax, es:[ecx + eax * 4]
-		call	eax
-
-#if CHECKED
-		/*  Bump Service Counter  */
-#endif
-
-		/*  Deallocate the kernel stack frame  */
-		mov		esp, ebp
-
-		// TMN: Added, to be able to separate this into different functions
-		jmp KeReturnFromSystemCallWithHook
-	}
-}
-
-__declspec(naked)
-void KeReturnFromSystemCallWithHook()
-{
-	__asm
-	{
-		/* Call the post system call hook and deliver any pending APCs */
-		push	esp
-		push	eax
-		call	KiAfterSystemCallHook
-		add		esp, 8
-
-		// TMN: Added, to be able to separate this into different functions
-		jmp KeReturnFromSystemCall
-	}
-}
-
-__declspec(naked)
-void KeReturnFromSystemCall()
-{
-	__asm
-	{
-		/* Restore the user context */
-		/* Get a pointer to the current thread */
-		mov		esi, fs:0x124
-
-		/* Restore the old trap frame pointer */
-		mov		ebx, 0x3c[esp]
-		mov		KTHREAD_TRAP_FRAME[esi], ebx
-
-		/* Skip debug information and unsaved registers */
-		add		esp, 0x30
-		pop		gs
-		pop		es
-		pop		ds
-		pop		edx
-		pop		ecx
-		add		esp, 4	/* Don't restore eax */
-
-		/* Restore the old previous mode */
-		pop		ebx
-		mov		ss:KTHREAD_PREVIOUS_MODE[esi], bl
-
-		/* Restore the old exception handler list */
-		pop		ebx
-		mov		fs:KPCR_EXCEPTION_LIST, ebx
-
-		pop		fs 
-		pop		edi
-		pop		esi
-		pop		ebx
-		pop		ebp
-		add		esp, 4	/* Ignore error code */
-		
-		iretd
-	}
-}

msvc6/ntoskrnl/ke_i386_trap.c

@@ -1,468 +0,0 @@
-/*
- *  ReactOS kernel
- *  Copyright (C) 2000 David Welch <welch@cwcom.net>
- *
- *  Moved to MSVC-compatible inline assembler by Mike Nordell, 2003-12-26
- *
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; either version 2 of the License, or
- *  (at your option) any later version.
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License
- *  along with this program; if not, write to the Free Software
- *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-/*
- * FILE:            ntoskrnl/ke/i386/vm86_sup.S
- * PURPOSE:         V86 mode support
- * PROGRAMMER:      David Welch (welch@cwcom.net)
- * UPDATE HISTORY:
- *                  Created 09/10/00
- */
-
-/* INCLUDES ******************************************************************/
-
-#pragma hdrstop
-
-#include <ddk/ntddk.h>
-#include <ddk/status.h>
-#include <internal/i386/segment.h>
-#include <internal/i386/fpu.h>
-#include <internal/ps.h>
-#include <ddk/defines.h>
-#include <internal/v86m.h>
-#include <ntos/tss.h>
-#include <internal/trap.h>
-#include <internal/ps.h>
-
-#include <roscfg.h>
-#include <internal/ntoskrnl.h>
-#include <internal/i386/segment.h>
-
-
-void KiV86Complete(void);
-void KiTrapHandler(void);
-void KiDoubleFaultHandler(void);
-
-extern int KiPcrInitDone;
-
-/*
- * Epilog for exception handlers
- */
-__declspec(naked)
-void KiTrapEpilog()
-{
-	__asm
-	{
-	cmp		eax, 1	/* Check for v86 recovery */
-	jne		_KiTrapRet
-	jmp		KiV86Complete
-_KiTrapRet:				
-	/* Skip debug information and unsaved registers */
-	add		esp, 0x30
-	pop		gs
-	pop		es
-	pop		ds
-	pop		edx
-	pop		ecx
-	pop		eax
-
-	/* Restore the old previous mode */
-	pop		ebx
-	mov		ss:KTHREAD_PREVIOUS_MODE[esi], bl
-
-	/* Restore the old exception handler list */
-	pop		ebx
-	mov		fs:KPCR_EXCEPTION_LIST, ebx
-	
-	pop		fs 
-	pop		edi
-	pop		esi
-	pop		ebx
-	pop		ebp
-	add		esp, 4	/* Ignore error code */
-
-	iretd
-	}
-}
-
-__declspec(naked)
-void KiTrapProlog()
-{
-	__asm
-	{
-		push	edi
-		push	fs
-
-		/* 
-		 * Check that the PCR exists, very early in the boot process it may 
-		 * not 
-		 */
-		cmp		ss:KiPcrInitDone, 0
-		je		L5_
-
-		/* Load the PCR selector into fs */
-		mov		ebx, PCR_SELECTOR
-		mov		fs, bx
-
-		/* Save the old exception list */
-		mov		ebx, fs:KPCR_EXCEPTION_LIST
-		push	ebx
-
-		/* Put the exception handler chain terminator */
-		mov		dword ptr fs:KPCR_EXCEPTION_LIST, 0xffffffff
-
-		/* Get a pointer to the current thread */
-		mov		edi, fs:KPCR_CURRENT_THREAD
-
-		/* The current thread may be NULL early in the boot process */
-		cmp		edi, 0
-		je		L4_
-		
-		/* Save the old previous mode */
-		xor		ebx, ebx
-		mov		bl, ss:KTHREAD_PREVIOUS_MODE[edi]
-		push	ebx
-	
-		/* Set the new previous mode based on the saved CS selector */
-		mov		ebx, 0x24[esp]
-		and		ebx, 0x0000FFFF
-		cmp		ebx, KERNEL_CS
-		jne		L1_
-		mov		ss:KTHREAD_PREVIOUS_MODE[edi], KernelMode
-		jmp		L3_
-L1_:
-		mov		ss:KTHREAD_PREVIOUS_MODE[edi], UserMode
-L3_:
-	
-		/* Save other registers */	
-		push	eax
-		push	ecx
-		push	edx
-		push	ds
-		push	es
-		push	gs
-		push	0     /* DR7 */
-		push	0     /* DR6 */
-		push	0     /* DR3 */
-		push	0     /* DR2 */
-		push	0     /* DR1 */
-		push	0     /* DR0 */
-		push	0     /* XXX: TempESP */
-		push	0     /* XXX: TempCS */
-		push	0     /* XXX: DebugPointer */
-		push	0     /* XXX: DebugArgMark */
-		mov		ebx, 0x60[esp]
-		push	ebx   /* XXX: DebugEIP */
-		push	ebp   /* XXX: DebugEBP */	
-		
-		/* Load the segment registers */
-		mov		ebx, KERNEL_DS
-		mov		ds, bx
-		mov		es, bx
-		mov		gs, bx
-	
-		/*  Set ES to kernel segment  */
-		mov		bx, KERNEL_DS
-		mov		es, bx
-
-		mov		ebx, esp
-		mov		ebp, esp
-
-	/* Save the old trap frame. */
-		cmp		edi, 0
-		je		L7_
-		mov		edx, ss:KTHREAD_TRAP_FRAME[edi]
-		push	edx
-		jmp		L8_
-L7_:
-		push	0
-L8_:
-
-		/* Save a pointer to the trap frame in the current KTHREAD */
-		cmp		edi, 0
-		je		L6_
-		mov		ss:KTHREAD_TRAP_FRAME[edi], ebx
-L6_:
-	
-		/* Call the C exception handler */
-		push	esi
-		push	ebx
-		call	KiTrapHandler
-		add		esp, 8
-
-		/* Get a pointer to the current thread */
-		mov		esi, fs:KPCR_CURRENT_THREAD
-	
-		/* Restore the old trap frame pointer */
-		pop		ebx
-		mov		KTHREAD_TRAP_FRAME[esi], ebx
-	
-		/* Return to the caller */
-		jmp		KiTrapEpilog
-
-		/* Handle the no-pcr case out of line */
-L5_:
-		push	0
-		
-		/* Handle the no-thread case out of line */
-L4_:
-		push	0
-		jmp		L3_
-
-	}	// end of __asm block
-}
-
-
-__declspec(naked)
-void KiTrap0()
-{
-	__asm
-	{
-		/* No error code */
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 0
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap1()
-{
-	__asm
-	{
-		/* No error code */
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov	esi, 1
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap2()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 2
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap3()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 3
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap4()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 4
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap5()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 5
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap6()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 6
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap7()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 7
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap8()
-{
-	__asm
-	{
-		call	KiDoubleFaultHandler
-		iretd
-	}
-}
-
-__declspec(naked)
-void KiTrap9()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 9
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap10()
-{
-	__asm
-	{
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 10
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap11()
-{
-	__asm
-	{
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 11
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap12()
-{
-	__asm
-	{
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 12
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap13()
-{
-	__asm
-	{
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 13
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap14()
-{
-	__asm
-	{
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 14
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap15()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 15
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrap16()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 16
-		jmp		KiTrapProlog
-	}
-}
-
-__declspec(naked)
-void KiTrapUnknown()
-{
-	__asm
-	{
-		push	0
-		push	ebp
-		push	ebx
-		push	esi
-		mov		esi, 255
-		jmp		KiTrapProlog
-	}
-}
-
-/* EOF */